fix windows build (#636)

* clippy fixes

* fix netplay browser

.github/workflows/build.yml

@@ -29,7 +29,7 @@ jobs:
             arch: linux-aarch64
             llvm: ARM64
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -48,7 +48,7 @@ jobs:
             libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev libxtst-dev \
             libxkbcommon-dev libdrm-dev libgbm-dev libgl1-mesa-dev libgles2-mesa-dev \
             libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev libudev-dev fcitx-libs-dev \
-            libpipewire-0.3-dev libwayland-dev libdecor-0-dev liburing-dev
+            libpipewire-0.3-dev libwayland-dev libdecor-0-dev liburing-dev libfreetype-dev libfontconfig-dev
           version: ${{ matrix.target }}-1.0
       - name: Install LLVM and Clang
         uses: KyleMayes/install-llvm-action@v2
@@ -60,6 +60,8 @@ jobs:
           cargo build --release -v --target=${{ matrix.target }}
           mkdir output
           cp target/${{ matrix.target }}/release/gopher64 output/gopher64-${{ matrix.arch }}
+        env:
+          NETPLAY_ID: ${{ secrets.NETPLAY_ID }}
       - name: Upload file
         uses: actions/upload-artifact@v5
         with:
@@ -81,7 +83,7 @@ jobs:
           #  arch: windows-aarch64
           #  llvm: woa64
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -102,6 +104,10 @@ jobs:
           cargo build --release -v --target=${{ matrix.target }}
           mkdir output
           cp target/${{ matrix.target }}/release/gopher64.exe output/gopher64-${{ matrix.arch }}.exe
+        env:
+          CC: clang-cl
+          CXX: clang-cl
+          NETPLAY_ID: ${{ secrets.NETPLAY_ID }}
       - name: Upload unsigned artifact
         id: upload-unsigned-artifact
         uses: actions/upload-artifact@v5
@@ -121,6 +127,7 @@ jobs:
           wait-for-completion: false
 
   build-macos:
+    if: false
     runs-on: macos-15
     strategy:
       fail-fast: false
@@ -131,7 +138,7 @@ jobs:
           - target: aarch64-apple-darwin
             arch: mac-aarch64
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -145,6 +152,7 @@ jobs:
           cp target/${{ matrix.target }}/release/gopher64 output/gopher64-${{ matrix.arch }}
         env:
           AR: ar
+          NETPLAY_ID: ${{ secrets.NETPLAY_ID }}
       - name: Upload file
         uses: actions/upload-artifact@v5
         with:

.github/workflows/lint.yml

@@ -16,7 +16,7 @@ jobs:
   lint-linux:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: actions-rust-lang/setup-rust-toolchain@v1
@@ -34,7 +34,7 @@ jobs:
             libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-dev libxtst-dev \
             libxkbcommon-dev libdrm-dev libgbm-dev libgl1-mesa-dev libgles2-mesa-dev \
             libegl1-mesa-dev libdbus-1-dev libibus-1.0-dev libudev-dev fcitx-libs-dev \
-            libpipewire-0.3-dev libwayland-dev libdecor-0-dev liburing-dev
+            libpipewire-0.3-dev libwayland-dev libdecor-0-dev liburing-dev libfreetype-dev libfontconfig-dev
           version: lint-1.0
       - name: Install LLVM and Clang
         uses: KyleMayes/install-llvm-action@v2

.github/workflows/sec.yml

@@ -10,7 +10,7 @@ jobs:
       checks: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: recursive
       - uses: rustsec/audit-check@v2

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "gopher64"
-version = "1.1.9"
+version = "1.1.11"
 edition = "2024"
-rust-version = "1.91"
+rust-version = "1.92.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -10,17 +10,17 @@ rust-version = "1.91"
 dirs = "6.0"
 zip = "6.0"
 governor = "0.10"
-sevenz-rust2 = { version = "0.19", default-features = false }
+sevenz-rust2 = { version = "0.20", default-features = false }
 chrono = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde-big-array = "0.5"
-slint = { version = "1.12", default-features = false, features = ["compat-1-2", "std", "backend-winit", "renderer-femtovg-wgpu"] }
+slint = { version = "1.12", default-features = false, features = ["compat-1-2", "std", "backend-winit", "renderer-skia-vulkan"] }
 open = "5.3"
 sha2 = "0.10"
 sdl3-sys = { version = "0.5", features = ["build-from-source-static"] }
-sdl3-ttf-sys = { version = "0.2", features = ["build-static-vendored", "no-sdlttf-harfbuzz", "no-sdlttf-plutosvg"] }
-rfd = { version = "0.15", default-features = false, features = ["xdg-portal", "tokio"] }
+sdl3-ttf-sys = { version = "0.2", features = ["build-from-source-static", "no-sdlttf-harfbuzz", "no-sdlttf-plutosvg"] }
+rfd = { version = "0.16", default-features = false, features = ["xdg-portal", "tokio", "wayland"] }
 tokio = {version = "1.46", features = ["rt-multi-thread", "macros"] }
 spin_sleep = "1.3"
 encoding_rs = "0.8"
@@ -45,7 +45,10 @@ cc = { version = "1.2", features = ["parallel"] }
 [profile.release]
 panic = "abort"
 lto = "thin"
+strip = true
 
 [profile.release-with-debug]
 inherits = "release"
 debug = true
+strip = false
+panic = "unwind"

build.rs

@@ -40,6 +40,7 @@ fn main() {
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/pipeline_event.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/query_pool.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/render_pass.cpp")
+        .file("parallel-rdp/parallel-rdp-standalone/vulkan/rtas.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/sampler.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/semaphore.cpp")
         .file("parallel-rdp/parallel-rdp-standalone/vulkan/semaphore_manager.cpp")
@@ -193,5 +194,8 @@ fn main() {
     let git_hash = String::from_utf8(git_output.stdout).unwrap();
     println!("cargo:rustc-env=GIT_HASH={git_hash}");
 
+    let netplay_id = std::env::var("NETPLAY_ID").unwrap_or("gopher64".to_string());
+    println!("cargo:rustc-env=NETPLAY_ID={netplay_id}");
+
     println!("cargo:rustc-env=N64_STACK_SIZE={}", 8 * 1024 * 1024);
 }

rust-toolchain.toml

@@ -1,2 +1,2 @@
 [toolchain]
-channel = "1.91.0"
+channel = "1.92.0"

src/device.rs

@@ -93,8 +93,7 @@ fn set_rng() -> rand_chacha::ChaCha8Rng {
 
 fn init_rng(device: &mut Device) {
     let mut rng_seed = set_rng().next_u64();
-    if device.netplay.is_some() {
-        let netplay = device.netplay.as_mut().unwrap();
+    if let Some(netplay) = &mut device.netplay {
         if netplay.player_number == 0 {
             netplay::send_rng(netplay, rng_seed);
         } else {
@@ -322,7 +321,6 @@ impl Device {
             pif: pif::Pif {
                 rom: [0; 1984],
                 ram: [0; 64],
-                input_gathered: false,
                 channels: [pif::PifChannel {
                     tx: None,
                     tx_buf: None,

src/device/cart/rom.rs

@@ -135,8 +135,7 @@ pub fn dma_write(
 pub fn init(device: &mut device::Device, rom_file: Vec<u8>) {
     let now: chrono::DateTime<chrono::Local> = chrono::Local::now();
     device.cart.rtc_timestamp = now.naive_local().and_utc().timestamp();
-    if device.netplay.is_some() {
-        let netplay = device.netplay.as_mut().unwrap();
+    if let Some(netplay) = &mut device.netplay {
         if netplay.player_number == 0 {
             netplay::send_rtc(netplay, device.cart.rtc_timestamp);
         } else {

src/device/controller.rs

@@ -56,15 +56,14 @@ pub fn process(device: &mut device::Device, channel: usize) {
         }
         JCMD_CONTROLLER_READ => {
             let offset = device.pif.channels[channel].rx_buf.unwrap();
-            let input = if device.netplay.is_none() {
-                ui::input::get(&device.ui, channel)
-            } else {
-                if device.netplay.as_ref().unwrap().player_number as usize == channel {
+            let input = if let Some(netplay) = &mut device.netplay {
+                if netplay.player_number as usize == channel {
                     let local_input = ui::input::get(&device.ui, 0);
-                    netplay::send_input(device.netplay.as_ref().unwrap(), local_input);
+                    netplay::send_input(netplay, local_input);
                 }
-
                 netplay::get_input(device, channel)
+            } else {
+                ui::input::get(&device.ui, channel)
             };
 
             device.pif.ram[offset..offset + 4].copy_from_slice(&input.data.to_ne_bytes());
@@ -162,10 +161,12 @@ pub fn pak_switch_event(device: &mut device::Device) {
     for (i, channel) in device.pif.channels.iter_mut().enumerate() {
         if channel.change_pak != PakType::None {
             //stop rumble if it is on
-            if device.netplay.is_none() {
+            if let Some(netplay) = &device.netplay {
+                if netplay.player_number as usize == i {
+                    device::ui::input::set_rumble(&device.ui, 0, 0);
+                }
+            } else {
                 device::ui::input::set_rumble(&device.ui, i, 0);
-            } else if device.netplay.as_ref().unwrap().player_number as usize == i {
-                device::ui::input::set_rumble(&device.ui, 0, 0);
             }
 
             let new_pak_type = match channel.change_pak {

src/device/controller/rumble.rs

@@ -15,10 +15,13 @@ pub fn read(device: &mut device::Device, _channel: usize, address: u16, data: us
 pub fn write(device: &mut device::Device, channel: usize, address: u16, data: usize, size: usize) {
     if address == 0xc000 {
         let rumble = device.pif.ram[data + size - 1];
-        if device.netplay.is_none() {
+
+        if let Some(netplay) = &device.netplay {
+            if netplay.player_number as usize == channel {
+                device::ui::input::set_rumble(&device.ui, 0, rumble);
+            }
+        } else {
             device::ui::input::set_rumble(&device.ui, channel, rumble);
-        } else if device.netplay.as_ref().unwrap().player_number as usize == channel {
-            device::ui::input::set_rumble(&device.ui, 0, rumble);
         }
     }
 }

src/device/controller/vru.rs

@@ -187,11 +187,12 @@ pub fn process(device: &mut device::Device, channel: usize) {
             device.pif.ram[device.pif.channels[channel].rx_buf.unwrap()] = 0;
         }
         JCMD_VRU_READ => {
-            let index = if device.vru_window.window_notifier.is_some() {
+            let index = if let Some(window_notifier) = &device.vru_window.window_notifier {
                 ui::vru::prompt_for_match(
                     &device.vru.words,
-                    device.vru_window.window_notifier.as_ref().unwrap(),
+                    window_notifier,
                     device.vru_window.word_receiver.as_mut().unwrap(),
+                    device.vi.frame_time,
                 )
             } else {
                 0x7FFF

src/device/memory.rs

@@ -62,11 +62,16 @@ pub fn masked_write_64(dst: &mut u64, value: u64, mask: u64) {
 
 pub fn translate_address(
     device: &mut device::Device,
-    address: u64,
+    mut address: u64,
     access_type: AccessType,
 ) -> (u64, bool, bool) {
     if (address & 0xc0000000) != 0x80000000 {
-        return device::tlb::get_physical_address(device, address, access_type);
+        if (address & 0xFFFFFFFF00000000) == 0x9000000000000000 {
+            // this is a hack to support 64-bit addresses used by some homebrew
+            address |= 0xA0000000;
+        } else {
+            return device::tlb::get_physical_address(device, address, access_type);
+        }
     }
     (address & 0x1FFFFFFF, address & 0x20000000 == 0, false)
 }

src/device/pif.rs

@@ -8,7 +8,6 @@ pub struct Pif {
     #[serde(with = "serde_big_array::BigArray")]
     pub ram: [u8; 64],
     pub channels: [PifChannel; 5],
-    pub input_gathered: bool,
 }
 
 #[derive(Copy, Clone, serde::Serialize, serde::Deserialize)]
@@ -96,9 +95,6 @@ fn process_channel(device: &mut device::Device, channel: usize) -> usize {
 }
 
 pub fn update_pif_ram(device: &mut device::Device) -> u64 {
-    unsafe { sdl3_sys::events::SDL_PumpEvents() };
-    device.pif.input_gathered = true;
-
     let mut active_channels = 0;
     for k in 0..PIF_CHANNELS_COUNT {
         active_channels += process_channel(device, k)
@@ -222,11 +218,11 @@ pub fn process_ram(device: &mut device::Device) {
 
 pub fn connect_pif_channels(device: &mut device::Device) {
     for i in 0..4 {
-        if device.netplay.is_none() {
-            if device.ui.config.input.controller_enabled[i] {
+        if let Some(netplay) = &device.netplay {
+            if netplay.player_data[i].reg_id != 0 {
                 device.pif.channels[i].process = Some(device::controller::process);
             }
-        } else if device.netplay.as_ref().unwrap().player_data[i].reg_id != 0 {
+        } else if device.ui.config.input.controller_enabled[i] {
             device.pif.channels[i].process = Some(device::controller::process);
         }
     }
@@ -272,16 +268,16 @@ pub fn init(device: &mut device::Device) {
     connect_pif_channels(device);
 
     for i in 0..4 {
-        if device.netplay.is_none() {
-            if device.ui.config.input.controller_enabled[i] {
-                if device.transferpaks[i].cart.rom.is_empty() {
-                    device.pif.channels[i].pak_handler = Some(default_handler);
-                } else {
-                    device.pif.channels[i].pak_handler = Some(tpak_handler);
-                }
+        if let Some(netplay) = &device.netplay {
+            if netplay.player_data[i].reg_id != 0 {
+                device.pif.channels[i].pak_handler = Some(default_handler);
+            }
+        } else if device.ui.config.input.controller_enabled[i] {
+            if device.transferpaks[i].cart.rom.is_empty() {
+                device.pif.channels[i].pak_handler = Some(default_handler);
+            } else {
+                device.pif.channels[i].pak_handler = Some(tpak_handler);
             }
-        } else if device.netplay.as_ref().unwrap().player_data[i].reg_id != 0 {
-            device.pif.channels[i].pak_handler = Some(default_handler);
         }
     }
     if device.ui.config.input.emulate_vru && device.netplay.is_none() {

src/device/vi.rs

@@ -142,11 +142,11 @@ pub fn vertical_interrupt_event(device: &mut device::Device) {
 
     let (mut speed_limiter_toggled, paused) = ui::video::check_callback(device);
 
-    if device.netplay.is_some() {
-        netplay::send_sync_check(device);
-        if device.vi.enable_speed_limiter == device.netplay.as_ref().unwrap().fast_forward {
+    if let Some(netplay) = &mut device.netplay {
+        netplay::send_sync_check(netplay, device.cpu.cop0.regs.as_ref());
+        if device.vi.enable_speed_limiter == netplay.fast_forward {
             speed_limiter_toggled = true;
-            device.vi.enable_speed_limiter = !device.netplay.as_ref().unwrap().fast_forward;
+            device.vi.enable_speed_limiter = !netplay.fast_forward;
         }
     }
 
@@ -158,13 +158,11 @@ pub fn vertical_interrupt_event(device: &mut device::Device) {
     device.vi.vi_counter += 1;
 
     if device.netplay.is_none() && paused {
-        ui::video::pause_loop();
-    } else if !device.pif.input_gathered {
-        unsafe { sdl3_sys::events::SDL_PumpEvents() }; // in case the game isn't prompting for input
-    } else {
-        device.pif.input_gathered = false;
+        ui::video::pause_loop(device.vi.frame_time);
     }
 
+    unsafe { sdl3_sys::events::SDL_PumpEvents() };
+
     /*
     let vis = if device.cart.pal { 50 } else { 60 };
     if device.vi.vi_counter % vis == 0 {

src/main.rs

@@ -9,6 +9,7 @@ mod netplay;
 mod savestates;
 mod ui;
 use clap::Parser;
+use std::io::Error;
 use ui::gui;
 
 /// N64 emulator
@@ -74,112 +75,89 @@ struct Args {
 }
 
 #[tokio::main]
-async fn main() {
+async fn main() -> std::io::Result<()> {
     let dirs = ui::get_dirs();
 
-    let mut result = std::fs::create_dir_all(dirs.config_dir);
-    if result.is_err() {
-        panic!("could not create config dir: {}", result.err().unwrap())
-    }
-    result = std::fs::create_dir_all(dirs.data_dir.join("saves"));
-    if result.is_err() {
-        panic!("could not create save dir: {}", result.err().unwrap())
-    }
-    result = std::fs::create_dir_all(dirs.data_dir.join("states"));
-    if result.is_err() {
-        panic!("could not create state dir: {}", result.err().unwrap())
-    }
-
+    std::fs::create_dir_all(dirs.config_dir)?;
+    std::fs::create_dir_all(dirs.data_dir.join("saves"))?;
+    std::fs::create_dir_all(dirs.data_dir.join("states"))?;
     let args = Args::parse();
-    let args_as_strings: Vec<String> = std::env::args().collect();
-    let args_count = args_as_strings.len();
-    if args_count > 1 && args.game.is_none() {
+    if let Some(game) = args.game {
+        let file_path = std::path::Path::new(&game);
+        let Some(rom_contents) = device::get_rom_contents(file_path) else {
+            return Err(Error::other(format!(
+                "Could not read ROM file: {}",
+                file_path.display()
+            )));
+        };
+        let handle = std::thread::Builder::new()
+            .name("n64".to_string())
+            .stack_size(env!("N64_STACK_SIZE").parse().unwrap())
+            .spawn(move || {
+                let mut device = device::Device::new();
+                let overclock = device.ui.config.emulation.overclock;
+                let disable_expansion_pak = device.ui.config.emulation.disable_expansion_pak;
+
+                let game_cheats = {
+                    let game_crc = ui::storage::get_game_crc(&rom_contents);
+                    let cheats = ui::config::Cheats::new();
+                    cheats.cheats.get(&game_crc).cloned().unwrap_or_default()
+                };
+                device::run_game(
+                    &mut device,
+                    rom_contents,
+                    ui::gui::GameSettings {
+                        fullscreen: args.fullscreen,
+                        overclock,
+                        disable_expansion_pak,
+                        cheats: game_cheats,
+                    },
+                );
+            })?;
+
+        handle.join().unwrap();
+    } else if std::env::args().count() > 1 {
         let mut ui = ui::Ui::new();
 
         if args.clear_input_bindings {
             ui::input::clear_bindings(&mut ui);
-            return;
+            return Ok(());
         }
-        if args.port.is_some() {
-            let port = args.port.unwrap();
-            if !(1..=4).contains(&port) {
-                println!("Port must be betwen 1 and 4");
-                return;
-            }
+        if let Some(port) = args.port
+            && !(1..=4).contains(&port)
+        {
+            return Err(Error::other("Port must be between 1 and 4"));
         }
         if args.list_controllers {
             let controllers = ui::input::get_controller_names(&ui);
             for (i, controller) in controllers.iter().enumerate() {
                 println!("Controller {i}: {controller}");
             }
-            return;
+            return Ok(());
         }
-        if args.configure_input_profile.is_some() {
+        if let Some(profile) = args.configure_input_profile {
             ui::input::configure_input_profile(
                 &mut ui,
-                args.configure_input_profile.unwrap(),
+                profile,
                 args.use_dinput,
                 args.deadzone.unwrap_or(ui::input::DEADZONE_DEFAULT),
             );
-            return;
+            return Ok(());
         }
-        if args.assign_controller.is_some() {
-            if args.port.is_none() {
-                println!("Must specify port number");
-                return;
-            }
-            ui::input::assign_controller(
-                &mut ui,
-                args.assign_controller.unwrap(),
-                args.port.unwrap(),
-            );
+        if let Some(assign_controller) = args.assign_controller {
+            let Some(port) = args.port else {
+                return Err(Error::other("Must specify port number"));
+            };
+            ui::input::assign_controller(&mut ui, assign_controller, port);
         }
-        if args.bind_input_profile.is_some() {
-            if args.port.is_none() {
-                println!("Must specify port number");
-                return;
-            }
-            ui::input::bind_input_profile(
-                &mut ui,
-                args.bind_input_profile.unwrap(),
-                args.port.unwrap(),
-            );
-        }
-    } else if args.game.is_some() {
-        let file_path = std::path::Path::new(args.game.as_ref().unwrap());
-        if let Some(rom_contents) = device::get_rom_contents(file_path) {
-            let handle = std::thread::Builder::new()
-                .name("n64".to_string())
-                .stack_size(env!("N64_STACK_SIZE").parse().unwrap())
-                .spawn(move || {
-                    let mut device = device::Device::new();
-                    let overclock = device.ui.config.emulation.overclock;
-                    let disable_expansion_pak = device.ui.config.emulation.disable_expansion_pak;
-
-                    let game_cheats = {
-                        let game_crc = ui::storage::get_game_crc(&rom_contents);
-                        let cheats = ui::config::Cheats::new();
-                        cheats.cheats.get(&game_crc).cloned().unwrap_or_default()
-                    };
-                    device::run_game(
-                        &mut device,
-                        rom_contents,
-                        ui::gui::GameSettings {
-                            fullscreen: args.fullscreen,
-                            overclock,
-                            disable_expansion_pak,
-                            cheats: game_cheats,
-                        },
-                    );
-                })
-                .unwrap();
-
-            handle.join().unwrap();
-        } else {
-            println!("Could not read rom file");
-            return;
+        if let Some(profile) = args.bind_input_profile {
+            let Some(port) = args.port else {
+                return Err(Error::other("Must specify port number"));
+            };
+            ui::input::bind_input_profile(&mut ui, profile, port);
         }
     } else {
         gui::app_window();
     }
+    Ok(())
 }

src/netplay.rs

@@ -103,14 +103,13 @@ pub fn receive_save(netplay: &mut Netplay, save_type: &str, save_data: &mut Vec<
     *save_data = response;
 }
 
-pub fn send_sync_check(device: &mut device::Device) {
-    let netplay = device.netplay.as_mut().unwrap();
+pub fn send_sync_check(netplay: &mut Netplay, regs: &[u64]) {
     if netplay.vi_counter.is_multiple_of(600) {
         let mut request: Vec<u8> = [UDP_SYNC_DATA].to_vec();
         request.extend_from_slice(&(netplay.vi_counter).to_be_bytes());
 
-        for i in 0..device::cop0::COP0_REGS_COUNT as usize {
-            request.extend_from_slice(&(device.cpu.cop0.regs[i] as u32).to_be_bytes());
+        for item in regs.iter() {
+            request.extend_from_slice(&(*item as u32).to_be_bytes());
         }
 
         netplay.udp_socket.send(&request).unwrap();

src/ui/gui.rs

@@ -191,6 +191,7 @@ fn controller_window(
         std::rc::Rc::new(controllers);
     app.set_controller_names(slint::ModelRc::from(controller_names_model));
 
+    let controller_changed = slint::VecModel::default();
     let selected_controllers = slint::VecModel::default();
     for selected in config.input.controller_assignment.iter() {
         let mut found = false;
@@ -204,11 +205,16 @@ fn controller_window(
         if !found {
             selected_controllers.push(0);
         }
+        controller_changed.push(false);
     }
     let selected_controllers_model: std::rc::Rc<slint::VecModel<i32>> =
         std::rc::Rc::new(selected_controllers);
     app.set_selected_controller(slint::ModelRc::from(selected_controllers_model));
 
+    let controller_changed_model: std::rc::Rc<slint::VecModel<bool>> =
+        std::rc::Rc::new(controller_changed);
+    app.set_controller_changed(slint::ModelRc::from(controller_changed_model));
+
     let weak_app = app.as_weak();
     app.on_input_profile_button_clicked(move || {
         let dialog = InputProfileDialog::new().unwrap();
@@ -269,8 +275,10 @@ pub fn save_settings(app: &AppWindow, controller_paths: &[Option<String>]) {
     }
 
     for (i, selected_controller) in app.get_selected_controller().iter().enumerate() {
-        config.input.controller_assignment[i] =
-            controller_paths[selected_controller as usize].clone();
+        if app.get_controller_changed().row_data(i).unwrap_or(false) {
+            config.input.controller_assignment[i] =
+                controller_paths[selected_controller as usize].clone();
+        }
     }
 }
 

src/ui/gui/appwindow.slint

@@ -47,6 +47,7 @@ export component AppWindow inherits Window {
     in-out property rom_dir <=> SettingsData.rom_dir;
     in-out property emulate_vru <=> ControllerData.emulate_vru;
     in-out property controller_enabled <=> ControllerData.controller_enabled;
+    in-out property controller_changed <=> ControllerData.controller_changed;
     in-out property transferpak <=> ControllerData.transferpak;
     in-out property selected_profile_binding <=> ControllerData.selected_profile_binding;
     in-out property input_profiles <=> ControllerData.input_profiles;

src/ui/gui/controller_page.slint

@@ -13,6 +13,7 @@ export global ControllerData {
     in-out property <[string]> input_profiles;
     in-out property <[string]> controller_names;
     in-out property <[int]> selected_controller;
+    in-out property <[bool]> controller_changed;
     in-out property <bool> blank_profiles;
 }
 
@@ -114,6 +115,7 @@ export component ControllerConfig inherits Page {
                         current-index: ControllerData.selected_controller[player];
                         selected => {
                             ControllerData.selected_controller[player] = self.current-index;
+                            ControllerData.controller_changed[player] = true;
                         }
                     }
                 }

src/ui/netplay.rs

@@ -111,7 +111,7 @@ impl NetplayPages for NetplayJoin {
 fn populate_server_names<T: ComponentHandle + NetplayPages + 'static>(weak: slint::Weak<T>) {
     let task = reqwest::Client::new()
         .get("https://dispatch.gopher64.com/getRegions")
-        .header("netplay-id", EMU_NAME)
+        .header("netplay-id", env!("NETPLAY_ID"))
         .send();
     tokio::spawn(async move {
         let mut local_servers: Vec<(String, String)> = vec![];
@@ -140,31 +140,34 @@ fn populate_server_names<T: ComponentHandle + NetplayPages + 'static>(weak: slin
         }
 
         let response = task.await;
-        if let Ok(response) = response
+        let public_servers = if let Ok(response) = response
             && let Ok(servers) = response.json::<Vec<String>>().await
         {
-            weak.upgrade_in_event_loop(move |handle| {
-                let server_names: slint::VecModel<slint::SharedString> = slint::VecModel::default();
-                let server_urls: slint::VecModel<slint::SharedString> = slint::VecModel::default();
-                for local_server in local_servers {
-                    server_names.push(local_server.0.into());
-                    server_urls.push(local_server.1.into());
-                }
-                for server in servers {
-                    server_names.push(server.clone().into());
-                    server_urls.push(format!("dispatcher:{server}").into());
-                }
-                server_names.push("Custom".into());
-                handle.refresh_sessions();
-                let server_names_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
-                    std::rc::Rc::new(server_names);
-                let server_urls_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
-                    std::rc::Rc::new(server_urls);
-                handle.set_server_names(slint::ModelRc::from(server_names_model));
-                handle.set_server_urls(slint::ModelRc::from(server_urls_model));
-            })
-            .unwrap();
-        }
+            servers
+        } else {
+            vec![]
+        };
+        weak.upgrade_in_event_loop(move |handle| {
+            let server_names: slint::VecModel<slint::SharedString> = slint::VecModel::default();
+            let server_urls: slint::VecModel<slint::SharedString> = slint::VecModel::default();
+            for local_server in local_servers {
+                server_names.push(local_server.0.into());
+                server_urls.push(local_server.1.into());
+            }
+            for server in public_servers {
+                server_names.push(server.clone().into());
+                server_urls.push(format!("dispatcher:{server}").into());
+            }
+            server_names.push("Custom".into());
+            handle.refresh_sessions();
+            let server_names_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
+                std::rc::Rc::new(server_names);
+            let server_urls_model: std::rc::Rc<slint::VecModel<slint::SharedString>> =
+                std::rc::Rc::new(server_urls);
+            handle.set_server_names(slint::ModelRc::from(server_names_model));
+            handle.set_server_urls(slint::ModelRc::from(server_urls_model));
+        })
+        .unwrap();
     });
 }
 
@@ -296,7 +299,7 @@ pub fn setup_create_window(
                 let task = reqwest::Client::new()
                     .get("https://dispatch.gopher64.com/createServer")
                     .query(&[("region", server_url.strip_prefix("dispatcher:").unwrap())])
-                    .header("netplay-id", EMU_NAME)
+                    .header("netplay-id", env!("NETPLAY_ID"))
                     .send();
                 let netplay_read_sender = netplay_read_sender.clone();
                 let netplay_write_receiver = netplay_write_receiver.resubscribe();
@@ -448,7 +451,7 @@ fn show_netplay_error(message: String) {
 fn update_sessions(weak: slint::Weak<NetplayJoin>) {
     let task = reqwest::Client::new()
         .get("https://dispatch.gopher64.com/getServers")
-        .header("netplay-id", EMU_NAME)
+        .header("netplay-id", env!("NETPLAY_ID"))
         .send();
     tokio::spawn(async move {
         let mut dispatcher_servers = std::collections::HashMap::new();

src/ui/video.rs

@@ -133,11 +133,11 @@ pub fn load_state(device: &mut device::Device, rdp_state: *const u8) {
     }
 }
 
-pub fn pause_loop() {
+pub fn pause_loop(frame_time: f64) {
     let mut paused = true;
     let mut frame_advance = false;
     while paused && !frame_advance {
-        std::thread::sleep(std::time::Duration::from_secs_f64(1.0 / 60.0));
+        std::thread::sleep(std::time::Duration::from_secs_f64(frame_time));
         unsafe { sdl3_sys::events::SDL_PumpEvents() };
         let callback = unsafe { rdp_check_callback() };
         paused = callback.paused;

src/ui/vru.rs

@@ -2,6 +2,7 @@ pub fn prompt_for_match(
     words: &[String],
     window_notifier: &tokio::sync::mpsc::Sender<Option<Vec<String>>>,
     word_index_receiver: &mut tokio::sync::mpsc::Receiver<String>,
+    frame_time: f64,
 ) -> u16 {
     let mut dedup_words = words.to_owned();
     dedup_words.sort();
@@ -10,7 +11,7 @@ pub fn prompt_for_match(
     let mut result = word_index_receiver.try_recv();
     while result.is_err() {
         result = word_index_receiver.try_recv();
-        std::thread::sleep(std::time::Duration::from_secs_f64(1.0 / 60.0));
+        std::thread::sleep(std::time::Duration::from_secs_f64(frame_time));
         unsafe { sdl3_sys::events::SDL_PumpEvents() }; // so the OS doesn't complain about the game window being frozen
     }
     for (i, v) in words.iter().enumerate() {