sgdkx 0.2.3

Unofficial command-line toolkit for SGDK
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use crate::path;
use clap::Parser;
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
#[cfg(not(target_os = "windows"))]
use which::which;

#[derive(Parser)]
pub struct Args {
    /// Emulator to use (gens or blastem, defaults to available emulator)
    #[arg(long)]
    emulator: Option<String>,

    /// ROM file path (defaults to out/rom.bin)
    #[arg(long, default_value = "out/rom.bin")]
    rom: String,
}

pub fn run(args: &Args) {
    let config_dir = path::config_dir();

    let rom_path = &args.rom;
    let emulator = &args.emulator;

    // Check if ROM file exists
    if !Path::new(rom_path).exists() {
        eprintln!("ROM file not found: {}", rom_path);
        std::process::exit(1);
    }

    let emulator_to_use = if let Some(emu) = emulator {
        emu.to_string()
    } else {
        // Auto-detect available emulator
        if find_emulator_executable(&config_dir, "gens").is_some() {
            "gens".to_string()
        } else if find_emulator_executable(&config_dir, "blastem").is_some() {
            "blastem".to_string()
        } else {
            eprintln!("No emulator found. Please run 'sgdkx setup-emu' first.");
            std::process::exit(1);
        }
    };

    let emulator_path = find_emulator_executable(&config_dir, &emulator_to_use);

    if let Some(exe_path) = emulator_path {
        #[cfg(target_os = "windows")]
        {
            run_direct(&exe_path, rom_path);
        }
        #[cfg(not(target_os = "windows"))]
        {
            run_with_wine(&exe_path, rom_path);
        }
    } else {
        eprintln!(
            "Emulator '{}' not found. Please run 'sgdkx setup-emu {}' first.",
            emulator_to_use, emulator_to_use
        );
        std::process::exit(1);
    }
}

pub fn find_emulator_executable(config_dir: &Path, emulator: &str) -> Option<PathBuf> {
    let emulator_dir = config_dir.join(emulator);

    match emulator {
        "gens" => {
            // Look for gens.exe in various possible locations
            let possible_paths = vec![
                emulator_dir.join("gens.exe"),
                emulator_dir.join("Gens_KMod_v0.7.3").join("gens.exe"),
            ];

            for path in possible_paths {
                if path.exists() {
                    return Some(path);
                }
            }
        }
        "blastem" => {
            // Look for blastem.exe in various possible locations
            let possible_paths = vec![emulator_dir.join("blastem.exe")];

            // Also look for blastem-win64-* directories
            if let Ok(entries) = fs::read_dir(&emulator_dir) {
                for entry in entries {
                    if let Ok(entry) = entry {
                        let path = entry.path();
                        if path.is_dir()
                            && path
                                .file_name()
                                .unwrap()
                                .to_str()
                                .unwrap()
                                .starts_with("blastem-win64")
                        {
                            let exe_path = path.join("blastem.exe");
                            if exe_path.exists() {
                                return Some(exe_path);
                            }
                        }
                    }
                }
            }

            for path in possible_paths {
                if path.exists() {
                    return Some(path);
                }
            }
        }
        _ => {}
    }

    None
}

#[cfg(not(target_os = "windows"))]
pub fn run_with_wine(exe_path: &Path, rom_path: &str) {
    // Check if wine is available
    if which("wine").is_err() {
        eprintln!(
            "Wine is not installed or not in PATH. Please install wine to run Windows emulators."
        );
        std::process::exit(1);
    }

    println!("Running {} with wine...", exe_path.display());

    let absolute_rom_path =
        fs::canonicalize(rom_path).expect("Failed to get absolute path for ROM file");

    let status = Command::new("wine")
        .arg(exe_path)
        .arg(&absolute_rom_path)
        .status()
        .expect("Failed to run emulator with wine");

    if !status.success() {
        eprintln!("Emulator exited with error code: {:?}", status.code());
    }
}

#[cfg(target_os = "windows")]
pub fn run_direct(exe_path: &Path, rom_path: &str) {
    println!("Running {} ...", exe_path.display());

    let absolute_rom_path =
        fs::canonicalize(rom_path).expect("Failed to get absolute path for ROM file");

    let status = Command::new(exe_path)
        .arg(&absolute_rom_path)
        .status()
        .expect("Failed to run emulator");

    if !status.success() {
        eprintln!("Emulator exited with error code: {:?}", status.code());
    }
}