set specific version for apt cache

* RDP sync updates

* rename

* rename

.github/workflows/build.yml

@@ -11,10 +11,15 @@ env:
 
 jobs:
   build-linux:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        target: [x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu]
+        include:
+          - os: ubuntu-24.04
+            target: x86_64-unknown-linux-gnu
+          - os: ubuntu-24.04-arm
+            target: aarch64-unknown-linux-gnu
     steps:
       - uses: actions/checkout@v4
         with:
@@ -23,53 +28,18 @@ jobs:
         with:
           target: ${{ matrix.target }}
           rustflags: ""
-      - name: Install SDL2
-        if: matrix.target == 'aarch64-unknown-linux-gnu'
-        run: |
-          cat <<EOF > deb822sources
-          Types: deb
-          URIs: http://archive.ubuntu.com/ubuntu/
-          Suites: noble
-          Components: main restricted universe
-          Architectures: amd64
-
-          Types: deb
-          URIs: http://security.ubuntu.com/ubuntu/
-          Suites: noble-security
-          Components: main restricted universe
-          Architectures: amd64
-
-          Types: deb
-          URIs: http://archive.ubuntu.com/ubuntu/
-          Suites: noble-updates
-          Components: main restricted universe
-          Architectures: amd64
-
-          Types: deb
-          URIs: http://azure.ports.ubuntu.com/ubuntu-ports/
-          Suites: noble
-          Components: main restricted multiverse universe
-          Architectures: arm64
-
-          Types: deb
-          URIs: http://azure.ports.ubuntu.com/ubuntu-ports/
-          Suites: noble-updates
-          Components: main restricted multiverse universe
-          Architectures: arm64
-          EOF
-
-          sudo mv deb822sources /etc/apt/sources.list.d/ubuntu.sources
-          sudo dpkg --add-architecture arm64
-          sudo apt update
-          sudo apt -y install libsdl2-dev:arm64 g++-aarch64-linux-gnu
-      - name: Install SDL2
-        if: matrix.target == 'x86_64-unknown-linux-gnu'
-        run: |
-          sudo apt update
-          sudo apt -y install libsdl2-dev
-      - name: Set aarch64 linker
-        if: matrix.target == 'aarch64-unknown-linux-gnu'
-        run: echo "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc" >> $GITHUB_ENV
+      - name: Install SDL Dependencies
+        # https://wiki.libsdl.org/SDL3/README/linux#build-dependencies
+        uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: build-essential git make \
+            pkg-config cmake ninja-build gnome-desktop-testing libasound2-dev libpulse-dev \
+            libaudio-dev libjack-dev libsndio-dev libx11-dev libxext-dev \
+            libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-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
+          version: ${{ matrix.target }}-1.0
       - name: Build
         run: |
           cargo build --release -v --target=${{ matrix.target }}
@@ -80,8 +50,9 @@ jobs:
           path: target/${{ matrix.target }}/release/gopher64
 
   build-windows:
-    runs-on: windows-latest
+    runs-on: windows-2025
     strategy:
+      fail-fast: false
       matrix:
         target: [x86_64-pc-windows-msvc]
     steps:
@@ -102,20 +73,24 @@ jobs:
           path: target/${{ matrix.target }}/release/gopher64.exe
 
   build-macos:
-    runs-on: macos-latest
+    runs-on: macos-14
     strategy:
+      fail-fast: false
       matrix:
         target: [x86_64-apple-darwin, aarch64-apple-darwin]
     steps:
       - uses: actions/checkout@v4
         with:
           submodules: recursive
+      - name: Set up Homebrew
+        uses: Homebrew/actions/setup-homebrew@master
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           target: ${{ matrix.target }}
           rustflags: ""
       - name: Build
         run: |
+          brew install molten-vk
           cargo build --release -v --target=${{ matrix.target }}
       - name: Upload file
         uses: actions/upload-artifact@v4

.github/workflows/lint.yml

@@ -19,6 +19,18 @@ jobs:
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           components: clippy, rustfmt
+      - name: Install SDL Dependencies
+        # https://wiki.libsdl.org/SDL3/README/linux#build-dependencies
+        uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: build-essential git make \
+            pkg-config cmake ninja-build gnome-desktop-testing libasound2-dev libpulse-dev \
+            libaudio-dev libjack-dev libsndio-dev libx11-dev libxext-dev \
+            libxrandr-dev libxcursor-dev libxfixes-dev libxi-dev libxss-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
+          version: lint-1.0
       - name: Rustfmt Check
         uses: actions-rust-lang/rustfmt@v1
       - name: Lint

Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "gopher64"
-version = "0.1.17"
+version = "0.1.25"
 edition = "2021"
+rust-version = "1.82"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -14,19 +15,23 @@ chrono = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 eframe = "0.30"
-rfd = "0.15"
 sha2 = "0.10"
 rusttype = "0.9"
-futures = "0.3"
-sdl2-sys = "0.37"
+sdl3-sys = { version = "0.4", features = ["build-from-source-static"] }
+rfd = "0.15"
 spin_sleep = "1.3"
 encoding_rs = "0.8"
+mimalloc = "0.1"
+regex = "1.11"
+tungstenite = "0.26"
+socket2 = "0.5"
+postcard = { version = "1.1", features = ["use-std"] }
 clap = { version = "4.4", features = ["derive"] }
 
-[dependencies.sdl2]
-version = "0.37"
+[dependencies.reqwest]
+version = "0.12"
 default-features = false
-features = ["static-link","bundled"]
+features = ["http2","rustls-tls","charset","json","blocking"]
 
 [build-dependencies]
 winres = "0.1"

README.md

@@ -1,4 +1,5 @@
 # gopher64
+(gopher64 also has a GUI that can be launched by just running the executable)
 
 ```
 Usage: gopher64 [OPTIONS] [GAME]
@@ -11,6 +12,8 @@ Options:
           
   -c, --configure-input-profile <PROFILE_NAME>
           Create a new input profile (keyboard/gamepad mappings).
+  -u, --use-dinput
+          Use DirectInput when configuring a new input profile.
   -b, --bind-input-profile <PROFILE_NAME>
           Must also specify --port. Used to bind a previously created profile to a port
   -l, --list-controllers
@@ -19,11 +22,33 @@ Options:
           Must also specify --port. Used to assign a controller listed in --list-controllers to a port
   -p, --port <PORT>
           Valid values: 1-4. To be used alongside --bind-input-profile and --assign-controller
+  -z, --clear-input-bindings
+          Clear all input profile bindings and controller assignments
   -h, --help
           Print help
   -V, --version
           Print version
 ```
+## discord
+
+https://discord.gg/9RGXq8W8JQ
+
+## controls
+
+Keys are mapped according to mupen64plus defaults: https://mupen64plus.org/wiki/index.php/KeyboardSetup#2._Default_Key_Mappings_for_SDL-Input_Plugin. Xbox-style controllers also have a default mapping applied.
+
+You can create you own mappings by running `./gopher64 --configure-input-profile my_profile`. You then bind that profile to a port: `./gopher64 --bind-input-profile my_profile --port 1`
+
+In order to use a controller (for example, an Xbox controller), run `./gopher64 --list-controllers` to get a list of attached controllers, and then assign it by doing `./gopher64 --assign-controller <controller_number> --port 1`
+
+## netplay
+
+Gopher64 supports netplay (online play with others). It has a few public netplay servers. If you are interested in running a public netplay server, please let me know (open an issue or discussion, or contact me on Discord). You can also run the server (https://github.com/simple64/simple64-netplay-server) yourself on a LAN.
+
+## portable mode
+
+If you would like to keep all the game data in the same folder as executable, you just need to create a file called "portable.txt" in the same directory as the executable.
+
 ## goals
 
 1. Performance. I want to be able to use this emulator on my laptop.
@@ -38,18 +63,6 @@ Options:
 4. `cargo build --release`
 5. `./target/release/gopher64 /path/to/rom.z64`
 
-## controls
-
-Keys are mapped according to mupen64plus defaults: https://mupen64plus.org/wiki/index.php/KeyboardSetup#2._Default_Key_Mappings_for_SDL-Input_Plugin. Xbox-style controllers also have a default mapping applied.
-
-You can create you own mappings by running `./gopher64 --configure-input-profile my_profile`. You then bind that profile to a port: `./gopher64 --bind-input-profile my_profile --port 1`
-
-In order to use a controller (for example, an Xbox controller), run `./gopher64 --list-controllers` to get a list of attached controllers, and then assign it by doing `./gopher64 --assign-controller <controller_number> --port 1`
-
-## portable mode
-
-If you would like to keep all the game data in the same folder as executable, you just need to create a file called "portable.txt" in the same directory as the executable.
-
 ## contributing
 
 I am very open to contributions! Please reach out to me via a GitHub issue, or via discord (loganmc10) before doing substantial work on a PR.

build.rs

@@ -52,7 +52,10 @@ fn main() {
         .include("parallel-rdp/parallel-rdp-standalone/vulkan")
         .include("parallel-rdp/parallel-rdp-standalone/vulkan-headers/include")
         .include("parallel-rdp/parallel-rdp-standalone/util")
-        .includes(std::env::var("DEP_SDL2_INCLUDE"));
+        .include(
+            std::path::PathBuf::from(std::env::var("DEP_SDL3_OUT_DIR").to_owned().unwrap())
+                .join("include"),
+        );
 
     let os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
     let arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap();
@@ -95,8 +98,8 @@ fn main() {
         .allowlist_function("rdp_close")
         .allowlist_function("rdp_set_vi_register")
         .allowlist_function("rdp_update_screen")
-        .allowlist_function("rdp_process_commands")
         .allowlist_function("rdp_full_sync")
+        .allowlist_function("rdp_process_commands")
         .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
         .generate()
         .expect("Unable to generate bindings");
@@ -107,7 +110,7 @@ fn main() {
 
     if arch == "aarch64" {
         let simd_bindings = bindgen::Builder::default()
-            .header("src/compat/sse2neon.h")
+            .header("src/compat/sse2neon/v1.8.0/sse2neon.h")
             .allowlist_function("_mm_setzero_si128")
             .allowlist_function("_mm_set_epi8")
             .allowlist_function("_mm_movemask_epi8")
@@ -156,4 +159,12 @@ fn main() {
         simd_build.include(".");
         simd_build.compile("simd");
     }
+
+    if os == "macos" {
+        // Add Homebrew lib path for Apple Silicon Macs
+        println!("cargo:rustc-link-search=native=/opt/homebrew/lib");
+        // Add Homebrew lib path for Intel Macs
+        println!("cargo:rustc-link-search=native=/usr/local/lib");
+        println!("cargo:rustc-link-lib=static=MoltenVK");
+    }
 }

parallel-rdp/interface.cpp

@@ -3,6 +3,7 @@
 #include "rdp_device.hpp"
 #include "interface.hpp"
 #include "spirv.hpp"
+#include <SDL3/SDL_vulkan.h>
 
 using namespace Vulkan;
 
@@ -51,6 +52,7 @@ enum vi_registers
 };
 
 static bool fullscreen;
+static bool integer_scaling;
 static SDL_Window *window;
 static RDP::CommandProcessor *processor;
 static SDL_WSIPlatform *wsi_platform;
@@ -59,11 +61,8 @@ static uint32_t cmd_data[0x00040000 >> 2];
 static int cmd_cur;
 static int cmd_ptr;
 static bool emu_running;
-static uint64_t rdp_sync_signal;
 static GFX_INFO gfx_info;
-
-static uint64_t last_frame_counter;
-static uint64_t frame_counter;
+static uint64_t sync_signal;
 
 static const unsigned cmd_len_lut[64] = {
 	1,
@@ -132,25 +131,19 @@ static const unsigned cmd_len_lut[64] = {
 	1,
 };
 
-int sdl_event_filter(void *userdata, SDL_Event *event)
+bool sdl_event_filter(void *userdata, SDL_Event *event)
 {
-	if (event->type == SDL_WINDOWEVENT)
+	if (event->type == SDL_EVENT_WINDOW_CLOSE_REQUESTED)
 	{
-		switch (event->window.event)
-		{
-		case SDL_WINDOWEVENT_CLOSE:
-			emu_running = false;
-			break;
-		case SDL_WINDOWEVENT_RESIZED:
-			wsi_platform->do_resize();
-			break;
-		default:
-			break;
-		}
+		emu_running = false;
 	}
-	else if (fullscreen && event->type == SDL_KEYDOWN)
+	else if (event->type == SDL_EVENT_WINDOW_RESIZED && emu_running)
 	{
-		switch (event->key.keysym.scancode)
+		wsi_platform->do_resize();
+	}
+	else if (event->type == SDL_EVENT_KEY_DOWN && fullscreen)
+	{
+		switch (event->key.scancode)
 		{
 		case SDL_SCANCODE_ESCAPE:
 			emu_running = false;
@@ -163,13 +156,19 @@ int sdl_event_filter(void *userdata, SDL_Event *event)
 	return 0;
 }
 
-void rdp_init(void *_window, GFX_INFO _gfx_info, bool _fullscreen, bool _upscale)
+void rdp_init(void *_window, GFX_INFO _gfx_info, bool _upscale, bool _integer_scaling, bool _fullscreen)
 {
 	window = (SDL_Window *)_window;
-	SDL_SetEventFilter(sdl_event_filter, nullptr);
+	bool result = SDL_AddEventWatch(sdl_event_filter, nullptr);
+	if (!result)
+	{
+		printf("Could not add event watch.\n");
+		return;
+	}
 
 	gfx_info = _gfx_info;
 	fullscreen = _fullscreen;
+	integer_scaling = _integer_scaling;
 	bool window_vsync = 0;
 	wsi = new WSI;
 	wsi_platform = new SDL_WSIPlatform;
@@ -178,7 +177,7 @@ void rdp_init(void *_window, GFX_INFO _gfx_info, bool _fullscreen, bool _upscale
 	wsi->set_present_mode(window_vsync ? PresentMode::SyncToVBlank : PresentMode::UnlockedMaybeTear);
 	wsi->set_backbuffer_srgb(false);
 	Context::SystemHandles handles = {};
-	if (!::Vulkan::Context::init_loader(nullptr))
+	if (!::Vulkan::Context::init_loader((PFN_vkGetInstanceProcAddr)SDL_Vulkan_GetVkGetInstanceProcAddr()))
 	{
 		rdp_close();
 	}
@@ -204,8 +203,6 @@ void rdp_init(void *_window, GFX_INFO _gfx_info, bool _fullscreen, bool _upscale
 	wsi->begin_frame();
 
 	emu_running = true;
-	last_frame_counter = 0;
-	frame_counter = 0;
 }
 
 void rdp_close()
@@ -231,34 +228,42 @@ void rdp_close()
 
 static void calculate_viewport(float *x, float *y, float *width, float *height)
 {
-	bool window_widescreen = false;
-	int32_t display_width = (window_widescreen ? 854 : 640);
-	int32_t display_height = 480;
+	const int32_t display_width = 320;
+	const int32_t display_height = 240;
 
 	int w, h;
 	SDL_GetWindowSize(window, &w, &h);
 
-	*width = w;
-	*height = h;
-	*x = 0;
-	*y = 0;
-	int32_t hw = display_height * *width;
-	int32_t wh = display_width * *height;
+	if (integer_scaling)
+	{
+		// Integer scaling path
+		int scale_x = w / display_width;
+		int scale_y = h / display_height;
+		int scale = (scale_x < scale_y) ? scale_x : scale_y;
+		if (scale < 1)
+			scale = 1;
 
-	// add letterboxes or pillarboxes if the window has a different aspect ratio
-	// than the current display mode
-	if (hw > wh)
-	{
-		int32_t w_max = wh / display_height;
-		*x += (*width - w_max) / 2;
-		*width = w_max;
+		// Calculate scaled dimensions
+		int scaled_width = display_width * scale;
+		int scaled_height = display_height * scale;
+
+		*width = scaled_width;
+		*height = scaled_height;
 	}
-	else if (hw < wh)
+	else
 	{
-		int32_t h_max = hw / display_width;
-		*y += (*height - h_max) / 2;
-		*height = h_max;
+		// Regular scaling path - maintain aspect ratio
+		float scale_x = w / (float)display_width;
+		float scale_y = h / (float)display_height;
+		float scale = (scale_x < scale_y) ? scale_x : scale_y;
+
+		*width = display_width * scale;
+		*height = display_height * scale;
 	}
+
+	// Center the viewport
+	*x = (w - *width) / 2.0f;
+	*y = (h - *height) / 2.0f;
 }
 
 static void render_frame(Vulkan::Device &device)
@@ -323,7 +328,6 @@ bool rdp_update_screen()
 	render_frame(device);
 	wsi->end_frame();
 	wsi->begin_frame();
-	frame_counter++;
 	return emu_running;
 }
 
@@ -380,16 +384,14 @@ uint64_t rdp_process_commands()
 	if ((cmd_ptr + length) & ~(0x0003FFFF >> 3))
 		return interrupt_timer;
 
-	*gfx_info.DPC_STATUS_REG |= DP_STATUS_PIPE_BUSY | DP_STATUS_START_GCLK;
-
 	uint32_t offset = DP_CURRENT;
 	if (*gfx_info.DPC_STATUS_REG & DP_STATUS_XBUS_DMA)
 	{
 		do
 		{
 			offset &= 0xFF8;
-			cmd_data[2 * cmd_ptr + 0] = SDL_SwapBE32(*reinterpret_cast<const uint32_t *>(gfx_info.DMEM + offset));
-			cmd_data[2 * cmd_ptr + 1] = SDL_SwapBE32(*reinterpret_cast<const uint32_t *>(gfx_info.DMEM + offset + 4));
+			cmd_data[2 * cmd_ptr + 0] = SDL_Swap32BE(*reinterpret_cast<const uint32_t *>(gfx_info.DMEM + offset));
+			cmd_data[2 * cmd_ptr + 1] = SDL_Swap32BE(*reinterpret_cast<const uint32_t *>(gfx_info.DMEM + offset + 4));
 			offset += sizeof(uint64_t);
 			cmd_ptr++;
 		} while (--length > 0);
@@ -430,15 +432,7 @@ uint64_t rdp_process_commands()
 
 		if (RDP::Op(command) == RDP::Op::SyncFull)
 		{
-			if (frame_counter != last_frame_counter) // Only sync once per frame
-			{
-				rdp_sync_signal = processor->signal_timeline();
-				last_frame_counter = frame_counter;
-			}
-			else
-			{
-				rdp_sync_signal = 0;
-			}
+			sync_signal = processor->signal_timeline();
 
 			uint32_t width = viCalculateHorizonalWidth(*gfx_info.VI_H_START_REG, *gfx_info.VI_X_SCALE_REG, *gfx_info.VI_WIDTH_REG);
 			if (width == 0)
@@ -451,8 +445,6 @@ uint64_t rdp_process_commands()
 				height = 240;
 			}
 			interrupt_timer = width * height * 4;
-
-			*gfx_info.DPC_STATUS_REG &= ~(DP_STATUS_PIPE_BUSY | DP_STATUS_START_GCLK);
 		}
 
 		cmd_cur += cmd_length;
@@ -461,15 +453,11 @@ uint64_t rdp_process_commands()
 	cmd_ptr = 0;
 	cmd_cur = 0;
 	*gfx_info.DPC_CURRENT_REG = *gfx_info.DPC_END_REG;
-	*gfx_info.DPC_STATUS_REG |= DP_STATUS_CBUF_READY;
 
 	return interrupt_timer;
 }
 
 void rdp_full_sync()
 {
-	if (rdp_sync_signal)
-	{
-		processor->wait_for_timeline(rdp_sync_signal);
-	}
+	processor->wait_for_timeline(sync_signal);
 }

parallel-rdp/interface.hpp

@@ -23,7 +23,7 @@ extern "C"
 		uint32_t *VI_WIDTH_REG;
 	} GFX_INFO;
 
-	void rdp_init(void *_window, GFX_INFO _gfx_info, bool fullscreen, bool _upscale);
+	void rdp_init(void *_window, GFX_INFO _gfx_info, bool _upscale, bool _integer_scaling, bool _fullscreen);
 	void rdp_close();
 	void rdp_set_vi_register(uint32_t reg, uint32_t value);
 	bool rdp_update_screen();

parallel-rdp/wsi_platform.cpp

@@ -1,11 +1,11 @@
 #include "wsi_platform.hpp"
-#include <SDL_vulkan.h>
+#include <SDL3/SDL_vulkan.h>
 
 VkSurfaceKHR SDL_WSIPlatform::create_surface(VkInstance instance, VkPhysicalDevice gpu)
 {
 	VkSurfaceKHR surface = nullptr;
-	SDL_bool result = SDL_Vulkan_CreateSurface(window, instance, &surface);
-	if (result != SDL_TRUE)
+	bool result = SDL_Vulkan_CreateSurface(window, instance, NULL, &surface);
+	if (result != true)
 	{
 		printf("Error creating surface\n");
 	}
@@ -14,18 +14,23 @@ VkSurfaceKHR SDL_WSIPlatform::create_surface(VkInstance instance, VkPhysicalDevi
 
 void SDL_WSIPlatform::destroy_surface(VkInstance instance, VkSurfaceKHR surface)
 {
+	SDL_Vulkan_DestroySurface(instance, surface, NULL);
 }
 
 std::vector<const char *> SDL_WSIPlatform::get_instance_extensions()
 {
 
 	unsigned int extensionCount = 0;
-	SDL_Vulkan_GetInstanceExtensions(window, &extensionCount, nullptr);
-	std::vector<const char *> extensionNames(extensionCount);
-	SDL_bool result = SDL_Vulkan_GetInstanceExtensions(window, &extensionCount, extensionNames.data());
-	if (result != SDL_TRUE)
+	char const *const *extensions = SDL_Vulkan_GetInstanceExtensions(&extensionCount);
+	if (extensions == NULL)
 	{
-		printf("Error creating surface\n");
+		printf("Error getting instance extensions\n");
+	}
+
+	std::vector<const char *> extensionNames;
+	for (int i = 0; i < extensionCount; ++i)
+	{
+		extensionNames.push_back(extensions[i]);
 	}
 	return extensionNames;
 }

parallel-rdp/wsi_platform.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "wsi.hpp"
-#include <SDL.h>
+#include <SDL3/SDL.h>
 
 class SDL_WSIPlatform : public Vulkan::WSIPlatform
 {

src/compat/aarch64.c

@@ -1,4 +1,4 @@
-#include "src/compat/sse2neon.h"
+#include "src/compat/sse2neon/v1.8.0/sse2neon.h"
 
 // Static wrappers
 

src/compat/aarch64.rs

@@ -1,46 +1,46 @@
 unsafe extern "C" {
     #[link_name = "_mm_srli_epi16__extern"]
-    pub fn _mm_srli_epi16(__a: __m128i, __imm8: ::std::os::raw::c_int) -> __m128i;
+    fn _mm_srli_epi16(__a: __m128i, __imm8: ::std::os::raw::c_int) -> __m128i;
 
     #[link_name = "_mm_insert_epi8__extern"]
-    pub fn _mm_insert_epi8(
+    fn _mm_insert_epi8(
         __a: __m128i,
         __i: ::std::os::raw::c_int,
         __imm8: ::std::os::raw::c_int,
     ) -> __m128i;
 
     #[link_name = "_mm_extract_epi8__extern"]
-    pub fn _mm_extract_epi8(__a: __m128i, __imm8: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+    fn _mm_extract_epi8(__a: __m128i, __imm8: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
 
     #[link_name = "_mm_insert_epi16__extern"]
-    pub fn _mm_insert_epi16(
+    fn _mm_insert_epi16(
         __a: __m128i,
         __i: ::std::os::raw::c_int,
         __imm8: ::std::os::raw::c_int,
     ) -> __m128i;
 
     #[link_name = "_mm_extract_epi16__extern"]
-    pub fn _mm_extract_epi16(__a: __m128i, __imm8: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+    fn _mm_extract_epi16(__a: __m128i, __imm8: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
 
     #[link_name = "_mm_insert_epi32__extern"]
-    pub fn _mm_insert_epi32(
+    fn _mm_insert_epi32(
         __a: __m128i,
         __i: ::std::os::raw::c_int,
         __imm8: ::std::os::raw::c_int,
     ) -> __m128i;
 
     #[link_name = "_mm_extract_epi32__extern"]
-    pub fn _mm_extract_epi32(__a: __m128i, __imm8: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
+    fn _mm_extract_epi32(__a: __m128i, __imm8: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
 
     #[link_name = "_mm_insert_epi64__extern"]
-    pub fn _mm_insert_epi64(
+    fn _mm_insert_epi64(
         __a: __m128i,
         __i: ::std::os::raw::c_longlong,
         __imm8: ::std::os::raw::c_int,
     ) -> __m128i;
 
     #[link_name = "_mm_extract_epi64__extern"]
-    pub fn _mm_extract_epi64(
+    fn _mm_extract_epi64(
         __a: __m128i,
         __imm8: ::std::os::raw::c_int,
     ) -> ::std::os::raw::c_longlong;

src/device.rs

@@ -10,6 +10,7 @@ include!(concat!(env!("OUT_DIR"), "/simd_bindings.rs"));
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 
+use crate::netplay;
 use crate::ui;
 use std::collections::HashMap;
 use std::fs;
@@ -30,7 +31,6 @@ pub mod exceptions;
 pub mod fpu_instructions;
 pub mod is_viewer;
 pub mod memory;
-pub mod mempak;
 pub mod mi;
 pub mod pi;
 pub mod pif;
@@ -46,16 +46,8 @@ pub mod sram;
 pub mod tlb;
 pub mod unmapped;
 pub mod vi;
-pub mod vru;
-
-pub fn run_game(
-    file_path: &std::path::Path,
-    data_dir: std::path::PathBuf,
-    device: &mut Device,
-    fullscreen: bool,
-) {
-    let rom_contents = get_rom_contents(file_path);
 
+pub fn run_game(rom_contents: Vec<u8>, device: &mut Device, fullscreen: bool) {
     cart_rom::init(device, rom_contents); // cart needs to come before rdram
 
     // rdram pointer is shared with parallel-rdp
@@ -68,7 +60,7 @@ pub fn run_game(
     mi::init(device);
     pif::init(device);
     if device.ui.config.input.emulate_vru {
-        vru::init(device);
+        controller::vru::init(device);
     }
     memory::init(device);
     rsp_interface::init(device);
@@ -76,14 +68,16 @@ pub fn run_game(
     vi::init(device);
     cpu::init(device);
 
-    ui::storage::init(&mut device.ui, data_dir);
-    ui::storage::load_saves(&mut device.ui);
+    ui::storage::init(&mut device.ui);
+    ui::storage::load_saves(&mut device.ui, &mut device.netplay);
     cart_rom::load_rom_save(device);
 
     cpu::run(device);
 
-    ui::video::close();
-    ui::storage::write_saves(&device.ui);
+    ui::input::close(&mut device.ui);
+    ui::video::close(&device.ui);
+    ui::audio::close(&mut device.ui);
+    ui::storage::write_saves(&device.ui, &device.netplay);
 }
 
 fn swap_rom(contents: Vec<u8>) -> Vec<u8> {
@@ -108,11 +102,12 @@ fn swap_rom(contents: Vec<u8>) -> Vec<u8> {
         }
         return data;
     } else {
-        panic!("unknown rom format")
+        let data: Vec<u8> = vec![];
+        data
     }
 }
 
-fn get_rom_contents(file_path: &std::path::Path) -> Vec<u8> {
+pub fn get_rom_contents(file_path: &std::path::Path) -> Vec<u8> {
     let mut contents = vec![];
     if file_path.extension().unwrap().eq_ignore_ascii_case("zip") {
         let zip_file = fs::File::open(file_path).unwrap();
@@ -163,9 +158,10 @@ fn get_rom_contents(file_path: &std::path::Path) -> Vec<u8> {
 }
 
 pub struct Device {
+    pub netplay: Option<netplay::Netplay>,
     pub ui: ui::Ui,
     byte_swap: usize,
-    cpu: cpu::Cpu,
+    pub cpu: cpu::Cpu,
     pif: pif::Pif,
     cart: cart_rom::Cart,
     memory: memory::Memory,
@@ -179,11 +175,11 @@ pub struct Device {
     si: si::Si,
     ri: ri::Ri,
     flashram: sram::Flashram,
-    pub vru: vru::Vru,
+    pub vru: controller::vru::Vru,
 }
 
 impl Device {
-    pub fn new(config_dir: std::path::PathBuf) -> Device {
+    pub fn new() -> Device {
         let mut byte_swap: usize = 0;
         let test: [u8; 4] = [1, 2, 3, 4];
         // if the host computer is little endian, that means the RDRAM will be stored as little endian
@@ -192,7 +188,8 @@ impl Device {
             byte_swap = 3;
         }
         Device {
-            ui: ui::Ui::new(config_dir),
+            netplay: None,
+            ui: ui::Ui::new(),
             byte_swap,
             cpu: cpu::Cpu {
                 cop0: cop0::Cop0 {
@@ -288,6 +285,7 @@ impl Device {
                     rx_buf: None,
                     process: None,
                     pak_handler: None,
+                    change_pak: controller::PakType::None,
                 }; 5],
             },
             cart: cart_rom::Cart {
@@ -322,6 +320,7 @@ impl Device {
             rdram: rdram::Rdram {
                 mem: vec![],
                 size: 0x800000,
+                regs: [[0; rdram::RDRAM_REGS_COUNT as usize]; 4],
             },
             rsp: rsp_interface::Rsp {
                 cpu: rsp_cpu::Cpu {
@@ -368,6 +367,8 @@ impl Device {
                 regs: [0; rsp_interface::SP_REGS_COUNT as usize],
                 regs2: [0; rsp_interface::SP_REGS2_COUNT as usize],
                 mem: [0; 0x2000],
+                last_status_value: 0,
+                run_after_dma: false,
                 fifo: [rsp_interface::RspDma {
                     dir: rsp_interface::DmaDir::None,
                     length: 0,
@@ -402,6 +403,7 @@ impl Device {
             },
             ri: ri::Ri {
                 regs: [0; ri::RI_REGS_COUNT as usize],
+                ram_init: false,
             },
             vi: vi::Vi {
                 regs: [0; vi::VI_REGS_COUNT as usize],
@@ -419,7 +421,7 @@ impl Device {
                 silicon_id: [sram::FLASHRAM_TYPE_ID, sram::MX29L1100_ID],
                 mode: sram::FlashramMode::ReadArray,
             },
-            vru: vru::Vru {
+            vru: controller::vru::Vru {
                 status: 0,
                 voice_state: 0,
                 load_offset: 0,

src/device/ai.rs

@@ -26,7 +26,7 @@ pub struct AiDma {
     pub duration: u64,
 }
 
-pub fn get_remaining_dma_length(device: &mut device::Device) -> u64 {
+fn get_remaining_dma_length(device: &mut device::Device) -> u64 {
     if device.ai.fifo[0].duration == 0 {
         return 0;
     }
@@ -43,7 +43,7 @@ pub fn get_remaining_dma_length(device: &mut device::Device) -> u64 {
     dma_length & !7
 }
 
-pub fn get_dma_duration(device: &device::Device) -> u64 {
+fn get_dma_duration(device: &device::Device) -> u64 {
     let samples_per_sec = device.vi.clock / (1 + device.ai.regs[AI_DACRATE_REG as usize]) as u64;
     let bytes_per_sample = 4; /* XXX: assume 16bit stereo - should depends on bitrate instead */
     let length = (device.ai.regs[AI_LEN_REG as usize] & !7) as u64;
@@ -51,7 +51,7 @@ pub fn get_dma_duration(device: &device::Device) -> u64 {
     length * (device.cpu.clock_rate / (bytes_per_sample * samples_per_sec))
 }
 
-pub fn do_dma(device: &mut device::Device) {
+fn do_dma(device: &mut device::Device) {
     device.ai.last_read = device.ai.fifo[0].length;
 
     if device.ai.delayed_carry {
@@ -71,7 +71,7 @@ pub fn do_dma(device: &mut device::Device) {
     device::mi::schedule_rcp_interrupt(device, device::mi::MI_INTR_AI);
 }
 
-pub fn fifo_push(device: &mut device::Device) {
+fn fifo_push(device: &mut device::Device) {
     let duration = get_dma_duration(device);
 
     if (device.ai.regs[AI_STATUS_REG as usize] & AI_STATUS_BUSY) != 0 {
@@ -91,7 +91,7 @@ pub fn fifo_push(device: &mut device::Device) {
     }
 }
 
-pub fn fifo_pop(device: &mut device::Device) {
+fn fifo_pop(device: &mut device::Device) {
     if device.ai.regs[AI_STATUS_REG as usize] & AI_STATUS_FULL != 0 {
         device.ai.fifo[0].address = device.ai.fifo[1].address;
         device.ai.fifo[0].length = device.ai.fifo[1].length;
@@ -144,6 +144,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
         AI_DACRATE_REG => {
             if device.ai.regs[reg as usize] != value & mask {
                 let frequency = device.vi.clock / (1 + (value & mask)) as u64;
+                ui::audio::close(&mut device.ui);
                 ui::audio::init(&mut device.ui, frequency)
             }
             device::memory::masked_write_32(&mut device.ai.regs[reg as usize], value, mask)
@@ -152,7 +153,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
     }
 }
 
-pub fn dma_event(device: &mut device::Device) {
+fn dma_event(device: &mut device::Device) {
     if device.ai.last_read != 0 {
         let diff = device.ai.fifo[0].length - device.ai.last_read;
         ui::audio::play_audio(

src/device/cache.rs

@@ -205,7 +205,7 @@ pub fn dcache_writeback(device: &mut device::Device, line_index: usize) {
     );
 }
 
-pub fn dcache_fill(device: &mut device::Device, line_index: usize, phys_address: u64) {
+fn dcache_fill(device: &mut device::Device, line_index: usize, phys_address: u64) {
     device::cop0::add_cycles(device, 7);
 
     device.memory.dcache[line_index].valid = true;

src/device/cart.rs

@@ -16,13 +16,13 @@ const JDT_AF_RTC: u16 = 0x1000; /* RTC */
 const JDT_EEPROM_4K: u16 = 0x8000; /* 4k EEPROM */
 const JDT_EEPROM_16K: u16 = 0xc000; /* 16k EEPROM */
 const EEPROM_BLOCK_SIZE: usize = 8;
-const EEPROM_MAX_SIZE: usize = 0x800;
+pub const EEPROM_MAX_SIZE: usize = 0x800;
 
 pub struct AfRtc {
     pub control: u16,
 }
 
-pub fn byte2bcd(mut n: u32) -> u8 {
+fn byte2bcd(mut n: u32) -> u8 {
     n %= 100;
     (((n / 10) << 4) | (n % 10)) as u8
 }
@@ -95,13 +95,13 @@ pub fn process(device: &mut device::Device, channel: usize) {
     }
 }
 
-pub fn format_eeprom(device: &mut device::Device) {
+fn format_eeprom(device: &mut device::Device) {
     if device.ui.saves.eeprom.0.len() < EEPROM_MAX_SIZE {
         device.ui.saves.eeprom.0.resize(EEPROM_MAX_SIZE, 0xFF)
     }
 }
 
-pub fn eeprom_read_block(device: &mut device::Device, block: usize, offset: usize) {
+fn eeprom_read_block(device: &mut device::Device, block: usize, offset: usize) {
     let address = device.pif.ram[block] as usize * EEPROM_BLOCK_SIZE;
 
     format_eeprom(device);
@@ -110,7 +110,7 @@ pub fn eeprom_read_block(device: &mut device::Device, block: usize, offset: usiz
         .copy_from_slice(&device.ui.saves.eeprom.0[address..address + EEPROM_BLOCK_SIZE]);
 }
 
-pub fn eeprom_write_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
+fn eeprom_write_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
     let address = device.pif.ram[block] as usize * EEPROM_BLOCK_SIZE;
 
     format_eeprom(device);
@@ -123,7 +123,7 @@ pub fn eeprom_write_block(device: &mut device::Device, block: usize, offset: usi
     device.ui.saves.eeprom.1 = true
 }
 
-pub fn time2data(device: &mut device::Device, offset: usize) {
+fn time2data(device: &mut device::Device, offset: usize) {
     let now: chrono::DateTime<chrono::Local> = chrono::Local::now();
 
     device.pif.ram[offset] = byte2bcd(now.second());
@@ -136,7 +136,7 @@ pub fn time2data(device: &mut device::Device, offset: usize) {
     device.pif.ram[offset + 7] = byte2bcd((now.year() as u32 - 1900) / 100);
 }
 
-pub fn af_rtc_read_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
+fn af_rtc_read_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
     match device.pif.ram[block] {
         0 => {
             device.pif.ram[offset] = device.cart.rtc.control as u8;
@@ -155,7 +155,7 @@ pub fn af_rtc_read_block(device: &mut device::Device, block: usize, offset: usiz
         }
     }
 }
-pub fn af_rtc_write_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
+fn af_rtc_write_block(device: &mut device::Device, block: usize, offset: usize, status: usize) {
     match device.pif.ram[block] {
         0 => {
             device.cart.rtc.control =

src/device/cart_rom.rs

@@ -85,9 +85,8 @@ pub fn dma_read(
                 device.rdram.mem[(dram_addr + i) as usize ^ device.byte_swap];
 
             device.ui.saves.romsave.0.insert(
-                (cart_addr + i).to_string(),
-                serde_json::to_value(device.rdram.mem[(dram_addr + i) as usize ^ device.byte_swap])
-                    .unwrap(),
+                cart_addr + i,
+                device.rdram.mem[(dram_addr + i) as usize ^ device.byte_swap],
             );
         }
     }
@@ -139,12 +138,11 @@ pub fn load_rom_save(device: &mut device::Device) {
         return;
     }
     for (key, value) in device.ui.saves.romsave.0.iter() {
-        device.cart.rom[key.parse::<usize>().unwrap()] =
-            serde_json::from_value(value.clone()).unwrap()
+        device.cart.rom[*key as usize] = *value
     }
 }
 
-pub fn set_system_region(device: &mut device::Device, country: u8) {
+fn set_system_region(device: &mut device::Device, country: u8) {
     let pal_codes: [u8; 8] = [b'D', b'F', b'I', b'P', b'S', b'U', b'X', b'Y'];
     for i in pal_codes {
         if country == i {
@@ -153,7 +151,7 @@ pub fn set_system_region(device: &mut device::Device, country: u8) {
     }
 }
 
-pub fn set_cic(device: &mut device::Device) {
+fn set_cic(device: &mut device::Device) {
     let hash = calculate_hash(&device.cart.rom[0x40..0x1000]);
     match hash.as_str() {
         "B99F06C4802C2377E31E388435955EF3E99C618A6D55D24699D828EB1075F1EB" => {
@@ -195,7 +193,7 @@ pub fn set_cic(device: &mut device::Device) {
     }
 }
 
-fn calculate_hash(data: &[u8]) -> String {
+pub fn calculate_hash(data: &[u8]) -> String {
     let mut hasher = Sha256::new();
     hasher.update(data);
     format!("{:X}", hasher.finalize())

src/device/controller.rs

@@ -1,6 +1,11 @@
 use crate::device;
+use crate::netplay;
 use crate::ui;
 
+pub mod mempak;
+pub mod rumble;
+pub mod vru;
+
 pub const JCMD_STATUS: u8 = 0x00;
 pub const JCMD_CONTROLLER_READ: u8 = 0x01;
 const JCMD_PAK_READ: u8 = 0x02;
@@ -12,14 +17,22 @@ const JDT_JOY_ABS_COUNTERS: u16 = 0x0001; /* joystick with absolute coordinates
 //const JDT_JOY_REL_COUNTERS: u16 = 0x0002; /* joystick with relative coordinates (= mouse) */
 const JDT_JOY_PORT: u16 = 0x0004; /* has port for external paks */
 const PAK_CHUNK_SIZE: usize = 0x20;
-const CONT_STATUS_PAK_NOT_PRESENT: u8 = 0;
 const CONT_STATUS_PAK_PRESENT: u8 = 1;
+const CONT_STATUS_PAK_NOT_PRESENT: u8 = 2;
 const CONT_FLAVOR: u16 = JDT_JOY_ABS_COUNTERS | JDT_JOY_PORT;
 
+#[derive(Copy, Clone, PartialEq)]
+pub enum PakType {
+    None = 0,
+    MemPak = 1,
+    RumblePak = 2,
+}
+
 #[derive(Copy, Clone)]
 pub struct PakHandler {
     pub read: fn(&mut device::Device, usize, u16, usize, usize),
     pub write: fn(&mut device::Device, usize, u16, usize, usize),
+    pub pak_type: PakType,
 }
 
 pub fn process(device: &mut device::Device, channel: usize) {
@@ -40,8 +53,34 @@ pub fn process(device: &mut device::Device, channel: usize) {
         }
         JCMD_CONTROLLER_READ => {
             let offset = device.pif.channels[channel].rx_buf.unwrap();
-            let input = ui::input::get(&mut device.ui, channel);
-            device.pif.ram[offset..offset + 4].copy_from_slice(&input.to_ne_bytes());
+            let input = if device.netplay.is_none() {
+                ui::input::get(&mut device.ui, channel)
+            } else {
+                if device.netplay.as_ref().unwrap().player_number as usize == channel {
+                    let local_input = ui::input::get(&mut device.ui, 0);
+                    netplay::send_input(device.netplay.as_ref().unwrap(), local_input);
+                }
+
+                netplay::get_input(device, channel)
+            };
+
+            device.pif.ram[offset..offset + 4].copy_from_slice(&input.0.to_ne_bytes());
+            if input.1 {
+                // pak change button pressed
+                if device::events::get_event(device, device::events::EventType::PakSwitch).is_none()
+                {
+                    device.pif.channels[channel].change_pak =
+                        device.pif.channels[channel].pak_handler.unwrap().pak_type;
+                    device.pif.channels[channel].pak_handler = None;
+                    device::events::create_event(
+                        device,
+                        device::events::EventType::PakSwitch,
+                        device.cpu.cop0.regs[device::cop0::COP0_COUNT_REG as usize]
+                            + (device.cpu.clock_rate), // 1 second
+                        pak_switch_event,
+                    )
+                }
+            }
         }
         JCMD_PAK_READ => pak_read_block(
             device,
@@ -61,7 +100,7 @@ pub fn process(device: &mut device::Device, channel: usize) {
     }
 }
 
-pub fn pak_read_block(
+fn pak_read_block(
     device: &mut device::Device,
     addr_acrc: usize,
     data: usize,
@@ -80,7 +119,7 @@ pub fn pak_read_block(
     }
 }
 
-pub fn pak_write_block(
+fn pak_write_block(
     device: &mut device::Device,
     addr_acrc: usize,
     data: usize,
@@ -99,7 +138,7 @@ pub fn pak_write_block(
     }
 }
 
-pub fn data_crc(device: &device::Device, data_offset: usize, size: usize) -> u8 {
+fn data_crc(device: &device::Device, data_offset: usize, size: usize) -> u8 {
     let mut i = 0;
     let mut crc = 0;
 
@@ -118,3 +157,34 @@ pub fn data_crc(device: &device::Device, data_offset: usize, size: usize) -> u8
     }
     crc
 }
+
+fn pak_switch_event(device: &mut device::Device) {
+    for (i, channel) in device.pif.channels.iter_mut().enumerate() {
+        if channel.change_pak != PakType::None {
+            if channel.change_pak == PakType::RumblePak {
+                if device.netplay.is_none() {
+                    device::ui::input::set_rumble(&mut device.ui, i, 0);
+                } else if device.netplay.as_ref().unwrap().player_number as usize == i {
+                    device::ui::input::set_rumble(&mut device.ui, 0, 0);
+                }
+
+                let handler = device::controller::PakHandler {
+                    read: device::controller::mempak::read,
+                    write: device::controller::mempak::write,
+                    pak_type: device::controller::PakType::MemPak,
+                };
+                channel.pak_handler = Some(handler);
+                ui::audio::play_pak_switch(&mut device.ui, PakType::MemPak);
+            } else if channel.change_pak == PakType::MemPak {
+                let handler = device::controller::PakHandler {
+                    read: device::controller::rumble::read,
+                    write: device::controller::rumble::write,
+                    pak_type: device::controller::PakType::RumblePak,
+                };
+                channel.pak_handler = Some(handler);
+                ui::audio::play_pak_switch(&mut device.ui, PakType::RumblePak);
+            }
+            channel.change_pak = PakType::None;
+        }
+    }
+}

src/device/controller/mempak.rs

@@ -1,9 +1,9 @@
 use crate::device;
 
-const MEMPAK_SIZE: usize = 0x8000;
+pub const MEMPAK_SIZE: usize = 0x8000;
 const MPK_PAGE_SIZE: usize = 256;
 
-pub fn format_mempak(device: &mut device::Device) {
+fn format_mempak(device: &mut device::Device) {
     if device.ui.saves.mempak.0.len() < MEMPAK_SIZE * 4 {
         device.ui.saves.mempak.0.resize(MEMPAK_SIZE * 4, 0);
 

src/device/controller/rumble.rs

@@ -0,0 +1,24 @@
+use crate::device;
+
+pub fn read(device: &mut device::Device, _channel: usize, address: u16, data: usize, size: usize) {
+    let value: u8 = if (0x8000..0x9000).contains(&address) {
+        0x80
+    } else {
+        0x00
+    };
+
+    for i in 0..size {
+        device.pif.ram[data + i] = value;
+    }
+}
+
+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() {
+            device::ui::input::set_rumble(&mut device.ui, channel, rumble);
+        } else if device.netplay.as_ref().unwrap().player_number as usize == channel {
+            device::ui::input::set_rumble(&mut device.ui, 0, rumble);
+        }
+    }
+}

src/device/controller/vru.rs

@@ -36,7 +36,7 @@ pub fn init(device: &mut device::Device) {
     create_word_mappings(device);
 }
 
-pub fn reset_vru(device: &mut device::Device) {
+fn reset_vru(device: &mut device::Device) {
     device.vru.status = 0x00;
     if device.cart.rom[0x3E] == /* Japan */ 0x4A || device.cart.rom[0x3E] == /* Demo */ 0x00 {
         device.vru.voice_state = VOICE_STATUS_READY;
@@ -250,11 +250,11 @@ pub fn process(device: &mut device::Device, channel: usize) {
     }
 }
 
-pub fn vru_talking_event(device: &mut device::Device) {
+fn vru_talking_event(device: &mut device::Device) {
     device.vru.talking = false
 }
 
-pub fn create_word_mappings(device: &mut device::Device) {
+fn create_word_mappings(device: &mut device::Device) {
     device.vru.word_mappings = HashMap::from([
         (
             String::from("03A50024000303CF00A80003036000EA"),
@@ -288,10 +288,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03A50024000303CF00A80003035D001200F900EA"),
             String::from("pikachu"),
         ),
-        (
-            String::from("040801740024"),
-            String::from("hey!"),
-        ),
+        (String::from("040801740024"), String::from("hey!")),
         (
             String::from("03CF00C603360405000F0234"),
             String::from("come-here"),
@@ -324,10 +321,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("02E2006903FC000303B402E2018F"),
             String::from("lets-play"),
         ),
-        (
-            String::from("040B00C002EB0213"),
-            String::from("hello"),
-        ),
+        (String::from("040B00C002EB0213"), String::from("hello")),
         (
             String::from("043B0213000303AB00A5034803FC006903FC00A503270024"),
             String::from("open-sesame"),
@@ -356,14 +350,8 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("042F01AD033603FC012602F10024"),
             String::from("im-sorry"),
         ),
-        (
-            String::from("03FC023A0024"),
-            String::from("sorry"),
-        ),
-        (
-            String::from("03FC012602F10024"),
-            String::from("sorry"),
-        ),
+        (String::from("03FC023A0024"), String::from("sorry")),
+        (String::from("03FC012602F10024"), String::from("sorry")),
         (
             String::from("042F01B00003036000ED03DB030C00EA"),
             String::from("i-choose-you"),
@@ -392,10 +380,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03A50024000303D8000303CF00C9"),
             String::from("pikka"),
         ),
-        (
-            String::from("03A50024000303CF00A8"),
-            String::from("pika"),
-        ),
+        (String::from("03A50024000303CF00A8"), String::from("pika")),
         (
             String::from("03A50024000303CF00A8000303A50024000303CF00A8"),
             String::from("pikapika"),
@@ -440,10 +425,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03F600C60348000603870234"),
             String::from("thunder"),
         ),
-        (
-            String::from("03F600C6033F0234"),
-            String::from("thunder"),
-        ),
+        (String::from("03F600C6033F0234"), String::from("thunder")),
         (
             String::from("0432009F02E20066000303D8000303C602F10045000303D802F40087000303C6"),
             String::from("electric-rat"),
@@ -489,7 +471,9 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("boing-boing"),
         ),
         (
-            String::from("043801290348000303C000ED036C00A5033C0066000303D803FC000303C603FC000303BA018F00060366"),
+            String::from(
+                "043801290348000303C000ED036C00A5033C0066000303D803FC000303C603FC000303BA018F00060366",
+            ),
             String::from("on-to-the-next-stage!"),
         ),
         (
@@ -516,10 +500,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("039F020A02EE0006038700A5033C0087000303AB009F02EE"),
             String::from("golden-apple"),
         ),
-        (
-            String::from("03A5002400030360"),
-            String::from("peach"),
-        ),
+        (String::from("03A5002400030360"), String::from("peach")),
         (
             String::from("03FC000303C602FD012C00060372029D0024"),
             String::from("strawberry"),
@@ -556,10 +537,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("032101A702EE00060390040B02340006037E"),
             String::from("wild-herb"),
         ),
-        (
-            String::from("03D502D60348"),
-            String::from("corn"),
-        ),
+        (String::from("03D502D60348"), String::from("corn")),
         (
             String::from("03B1014D000303B4000303D502D60348"),
             String::from("popcorn"),
@@ -592,18 +570,12 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03CC008102F700A8000303C6"),
             String::from("carrot"),
         ),
-        (
-            String::from("03CC02A300A8000303C6"),
-            String::from("carrot"),
-        ),
+        (String::from("03CC02A300A8000303C6"), String::from("carrot")),
         (
             String::from("043200C60339030900A50348"),
             String::from("onion"),
         ),
-        (
-            String::from("043200A5033F00A50348"),
-            String::from("onion"),
-        ),
+        (String::from("043200A5033F00A50348"), String::from("onion")),
         (
             String::from("043501080339030900A50348"),
             String::from("onion"),
@@ -621,7 +593,9 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("sweet-potato"),
         ),
         (
-            String::from("0411014D000303C603FC03150024000303C6000303AB00C9000303BA018F0006038D0213"),
+            String::from(
+                "0411014D000303C603FC03150024000303C6000303AB00C9000303BA018F0006038D0213",
+            ),
             String::from("hot-sweet-potato"),
         ),
         (
@@ -732,10 +706,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03CF00C9000303B4000303CC018F000303D8"),
             String::from("cupcake"),
         ),
-        (
-            String::from("03840174002703DB0024"),
-            String::from("daisy"),
-        ),
+        (String::from("03840174002703DB0024"), String::from("daisy")),
         (
             String::from("03A50045000303C000E70339030900A8"),
             String::from("petunia"),
@@ -768,10 +739,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03FC00C6034803F002EB01DD0234"),
             String::from("sunflower"),
         ),
-        (
-            String::from("02DF003C02DF0024"),
-            String::from("lily"),
-        ),
+        (String::from("02DF003C02DF0024"), String::from("lily")),
         (
             String::from("02FD021603DE0006037500C900060390"),
             String::from("rose-bud"),
@@ -852,10 +820,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03D5014D000303AB0234000303D501CE0348"),
             String::from("copper-coin"),
         ),
-        (
-            String::from("02FA00EA0006036F0024"),
-            String::from("ruby"),
-        ),
+        (String::from("02FA00EA0006036F0024"), String::from("ruby")),
         (
             String::from("03FC008A03F001AA0300"),
             String::from("sapphire"),
@@ -904,10 +869,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("037502340006039003F00069036C0234"),
             String::from("bird-feather"),
         ),
-        (
-            String::from("037B020A02EE000303C6"),
-            String::from("bolt"),
-        ),
+        (String::from("037B020A02EE000303C6"), String::from("bolt")),
         (
             String::from("032A0087000603A203390045000303C6"),
             String::from("magnet"),
@@ -920,10 +882,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("0333025500060375009F02EE"),
             String::from("marble"),
         ),
-        (
-            String::from("03D802F4018F000303C6"),
-            String::from("crate"),
-        ),
+        (String::from("03D802F4018F000303C6"), String::from("crate")),
         (
             String::from("03D50255000603900006037B02D9000603900006037B014D000303D803FC"),
             String::from("cardboard-box"),
@@ -936,10 +895,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("043B021603EA022804050297"),
             String::from("over-here"),
         ),
-        (
-            String::from("040B009F02EB0213"),
-            String::from("hello"),
-        ),
+        (String::from("040B009F02EB0213"), String::from("hello")),
         (
             String::from("039C010B00060390034501950024000303C6"),
             String::from("good-night"),
@@ -972,18 +928,9 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("036C0087000303C603FC03F001AD0348"),
             String::from("thats-fine"),
         ),
-        (
-            String::from("043B0213000303CC01740024"),
-            String::from("ok"),
-        ),
-        (
-            String::from("04020276"),
-            String::from("sure"),
-        ),
-        (
-            String::from("02FD01B0000303C6"),
-            String::from("right"),
-        ),
+        (String::from("043B0213000303CC01740024"), String::from("ok")),
+        (String::from("04020276"), String::from("sure")),
+        (String::from("02FD01B0000303C6"), String::from("right")),
         (
             String::from("02E2006903FC0006038A00ED036C0087000303C6"),
             String::from("lets-do-that"),
@@ -1012,18 +959,12 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03CF00C9000303BD00A8000303C301F2000303C6"),
             String::from("cut-it-out"),
         ),
-        (
-            String::from("03450213"),
-            String::from("no"),
-        ),
+        (String::from("03450213"), String::from("no")),
         (
             String::from("0318018F0006038700A80006039F0213"),
             String::from("way-to-go"),
         ),
-        (
-            String::from("03F002EB01DD0234"),
-            String::from("flower"),
-        ),
+        (String::from("03F002EB01DD0234"), String::from("flower")),
         (
             String::from("038400840348000303C603FC"),
             String::from("dance"),
@@ -1104,14 +1045,8 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03F90009030C00E102E2018F000303BD0234"),
             String::from("see-you-later"),
         ),
-        (
-            String::from("03F90009030C00EA"),
-            String::from("see-you"),
-        ),
-        (
-            String::from("037B01B0"),
-            String::from("bye"),
-        ),
+        (String::from("03F90009030C00EA"), String::from("see-you")),
+        (String::from("037B01B0"), String::from("bye")),
         (
             String::from("0411031B00A8000303BD0219030900A80006038A00CF0042035A"),
             String::from("what-are-you-doing?"),
@@ -1164,10 +1099,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("04290045000303C603FC021603EA0237036C02B8"),
             String::from("its-over-there"),
         ),
-        (
-            String::from("02DF003C02DF0024"),
-            String::from("lily"),
-        ),
+        (String::from("02DF003C02DF0024"), String::from("lily")),
         (
             String::from("03FC00C6034803F002EB01DD0234"),
             String::from("sunflower"),
@@ -1188,10 +1120,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("0438012C0006038100480402"),
             String::from("oddish"),
         ),
-        (
-            String::from("03A202E800E70336"),
-            String::from("gloom"),
-        ),
+        (String::from("03A202E800E70336"), String::from("gloom")),
         (
             String::from("03EA01A702EE000303B402E800E70336"),
             String::from("vileplume"),
@@ -1200,14 +1129,8 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("042F01AD033603FC02BE0024"),
             String::from("im-sorry"),
         ),
-        (
-            String::from("03FC02BE0024"),
-            String::from("sorry"),
-        ),
-        (
-            String::from("03CC0084033F00A50348"),
-            String::from("cannon"),
-        ),
+        (String::from("03FC02BE0024"), String::from("sorry")),
+        (String::from("03CC0084033F00A50348"), String::from("cannon")),
         (
             String::from("03810045000603930045000303C301F2000303C6"),
             String::from("dig-it-out"),
@@ -1216,18 +1139,9 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03810045000603A2036C017A0234"),
             String::from("dig-there"),
         ),
-        (
-            String::from("03810045000603A2"),
-            String::from("dig"),
-        ),
-        (
-            String::from("03AE010202EE"),
-            String::from("pull"),
-        ),
-        (
-            String::from("033F00C9000303C6"),
-            String::from("nut"),
-        ),
+        (String::from("03810045000603A2"), String::from("dig")),
+        (String::from("03AE010202EE"), String::from("pull")),
+        (String::from("033F00C9000303C6"), String::from("nut")),
         (
             String::from("03780108033C0084033F00C9"),
             String::from("banana"),
@@ -1244,10 +1158,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("0372029D002400060390000303C602F4006903E40234"),
             String::from("buried-treasure"),
         ),
-        (
-            String::from("0408005D02EB0213"),
-            String::from("hello"),
-        ),
+        (String::from("0408005D02EB0213"), String::from("hello")),
         (
             String::from("042F01A702E500CC03E7030C00EA"),
             String::from("i-love-you"),
@@ -1312,26 +1223,17 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("041101290348000303BD0234"),
             String::from("haunter"),
         ),
-        (
-            String::from("02FD0129035A"),
-            String::from("wrong"),
-        ),
+        (String::from("02FD0129035A"), String::from("wrong")),
         (
             String::from("036C0087000303C603DE02FD0129035A"),
             String::from("thats-wrong"),
         ),
-        (
-            String::from("03D503150045000303C6"),
-            String::from("quit"),
-        ),
+        (String::from("03D503150045000303C6"), String::from("quit")),
         (
             String::from("03CF00C9000303B700450006038D01F2000303C6"),
             String::from("cut-it-out"),
         ),
-        (
-            String::from("03CF00A503270297"),
-            String::from("c-mere"),
-        ),
+        (String::from("03CF00A503270297"), String::from("c-mere")),
         (
             String::from("03CF00A5033604050297"),
             String::from("come-here"),
@@ -1348,26 +1250,17 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("0321012C0003036001F2000303C6"),
             String::from("watch-out"),
         ),
-        (
-            String::from("036C02B8"),
-            String::from("there"),
-        ),
+        (String::from("036C02B8"), String::from("there")),
         (
             String::from("03FC03150042035A034501F2"),
             String::from("swing-now"),
         ),
-        (
-            String::from("03FC03150042035A"),
-            String::from("swing"),
-        ),
+        (String::from("03FC03150042035A"), String::from("swing")),
         (
             String::from("039F020D02FD01B0000303C6"),
             String::from("go-right"),
         ),
-        (
-            String::from("02FD01B0000303C6"),
-            String::from("right"),
-        ),
+        (String::from("02FD01B0000303C6"), String::from("right")),
         (
             String::from("03F00258036C022E02FD01B0000303C6"),
             String::from("farther-right"),
@@ -1376,10 +1269,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("039F020A02E2006903F0000303C6"),
             String::from("go-left"),
         ),
-        (
-            String::from("02E2006903F0000303C6"),
-            String::from("left"),
-        ),
+        (String::from("02E2006903F0000303C6"), String::from("left")),
         (
             String::from("03F00258036C022B02E2006903F0000303C6"),
             String::from("farther-left"),
@@ -1472,10 +1362,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("02DF004803F900420348000303BD00A503270024"),
             String::from("listen-to-me"),
         ),
-        (
-            String::from("03F002FA00EA000303C6"),
-            String::from("fruit"),
-        ),
+        (String::from("03F002FA00EA000303C6"), String::from("fruit")),
         (
             String::from("03450213000303C6000303A8008700060390"),
             String::from("notepad"),
@@ -1500,14 +1387,8 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("0411014D000303C603FC03150024000303B4000303BA018F0006038D0213"),
             String::from("hot-sweet-potato"),
         ),
-        (
-            String::from("03D200E102EE"),
-            String::from("cool"),
-        ),
-        (
-            String::from("03F001AD0348"),
-            String::from("fine"),
-        ),
+        (String::from("03D200E102EE"), String::from("cool")),
+        (String::from("03F001AD0348"), String::from("fine")),
         (
             String::from("0309023703FC0213000303C9030C00EA000303C6"),
             String::from("youre-so-cute"),
@@ -1572,14 +1453,8 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("032A0087000603A2033F00A8000303C6"),
             String::from("magnet"),
         ),
-        (
-            String::from("03D501CE0348"),
-            String::from("coin"),
-        ),
-        (
-            String::from("036600D5009F02EE"),
-            String::from("jewel"),
-        ),
+        (String::from("03D501CE0348"), String::from("coin")),
+        (String::from("036600D5009F02EE"), String::from("jewel")),
         (
             String::from("0333025500060375009F02EE"),
             String::from("marble"),
@@ -1596,10 +1471,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03D50315004803DE000303C301AD0336"),
             String::from("quiz-time"),
         ),
-        (
-            String::from("03B7002703E70024"),
-            String::from("tv"),
-        ),
+        (String::from("03B7002703E70024"), String::from("tv")),
         (
             String::from("042F01B0000303D503150045000303C6"),
             String::from("i-quit"),
@@ -1616,10 +1488,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03150024000303CF00A50348000303B402E2018F"),
             String::from("we-can-play"),
         ),
-        (
-            String::from("0372008700060390"),
-            String::from("bad"),
-        ),
+        (String::from("0372008700060390"), String::from("bad")),
         (
             String::from("0345014D000303C90045000303C3012F03F0"),
             String::from("knock-it-off"),
@@ -1636,10 +1505,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("042F01AD03360345014D000303C6000303B402E201740042035A"),
             String::from("im-not-playing"),
         ),
-        (
-            String::from("03D503150045000303C6"),
-            String::from("quit"),
-        ),
+        (String::from("03D503150045000303C6"), String::from("quit")),
         (
             String::from("03FC000303C3014D000303B4036C0087000303C6"),
             String::from("stop-that"),
@@ -1660,10 +1526,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03D802DF00210348036C0087000303BD00C9000303B4"),
             String::from("clean-that-up"),
         ),
-        (
-            String::from("03B70048040200EA"),
-            String::from("tissue"),
-        ),
+        (String::from("03B70048040200EA"), String::from("tissue")),
         (
             String::from("037500C002EE0006037500AB03FC02D9"),
             String::from("bulbasaur"),
@@ -1768,10 +1631,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03FC000303A502880213"),
             String::from("spearow"),
         ),
-        (
-            String::from("03ED02880213"),
-            String::from("fearow"),
-        ),
+        (String::from("03ED02880213"), String::from("fearow")),
         (
             String::from("04260024000303CF00A5034803DE"),
             String::from("ekans"),
@@ -1788,10 +1648,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03A50024000303CF00A80003036000EA"),
             String::from("pikachu"),
         ),
-        (
-            String::from("02FD01B00003036000EA"),
-            String::from("raichu"),
-        ),
+        (String::from("02FD01B00003036000EA"), String::from("raichu")),
         (
             String::from("03FC00840348040202FA00EA"),
             String::from("sandshrew"),
@@ -1884,22 +1741,13 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("0438012C0006038100480402"),
             String::from("oddish"),
         ),
-        (
-            String::from("03A202E800E70336"),
-            String::from("gloom"),
-        ),
+        (String::from("03A202E800E70336"), String::from("gloom")),
         (
             String::from("03EA01A702EE000303B402E800E70336"),
             String::from("vileplume"),
         ),
-        (
-            String::from("03B1024000AB03FC"),
-            String::from("paras"),
-        ),
-        (
-            String::from("03A802A300AB03FC"),
-            String::from("paras"),
-        ),
+        (String::from("03B1024000AB03FC"), String::from("paras")),
+        (String::from("03A802A300AB03FC"), String::from("paras")),
         (
             String::from("03B1024000AB03FC0066000303D8000303C6"),
             String::from("parasect"),
@@ -1920,10 +1768,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03810045000603A202E500A8000303C6"),
             String::from("diglett"),
         ),
-        (
-            String::from("0327001501F503F6"),
-            String::from("meowth"),
-        ),
+        (String::from("0327001501F503F6"), String::from("meowth")),
         (
             String::from("03AB023703E400A50348"),
             String::from("persian"),
@@ -2024,14 +1869,8 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03A202F4008A03EA02E50234"),
             String::from("graveler"),
         ),
-        (
-            String::from("039F020A02E500A50336"),
-            String::from("golem"),
-        ),
-        (
-            String::from("039F014402EE0336"),
-            String::from("golem"),
-        ),
+        (String::from("039F020A02E500A50336"), String::from("golem")),
+        (String::from("039F014402EE0336"), String::from("golem")),
         (
             String::from("03B1021003390024000303BD00A8"),
             String::from("ponyta"),
@@ -2060,18 +1899,12 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("032A0087000603A2033F00A8000303C3014A0348"),
             String::from("magneton"),
         ),
-        (
-            String::from("0008"),
-            String::from("farfetch"),
-        ),
+        (String::from("0008"), String::from("farfetch")),
         (
             String::from("038D02130006039002F100150213"),
             String::from("dodrio"),
         ),
-        (
-            String::from("03F9001B02EE"),
-            String::from("seel"),
-        ),
+        (String::from("03F9001B02EE"), String::from("seel")),
         (
             String::from("038A00EA0006039F014A035A"),
             String::from("dewgong"),
@@ -2080,14 +1913,8 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("038A00EA0006039F014A0348"),
             String::from("dewgong"),
         ),
-        (
-            String::from("03A202FD01AD032D0234"),
-            String::from("grimer"),
-        ),
-        (
-            String::from("032D00C9000303D8"),
-            String::from("muk"),
-        ),
+        (String::from("03A202FD01AD032D0234"), String::from("grimer")),
+        (String::from("032D00C9000303D8"), String::from("muk")),
         (
             String::from("0402005D02EE000603870234"),
             String::from("shellder"),
@@ -2100,10 +1927,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("0396008A03FC000303C602DF00"),
             String::from("gastly"),
         ),
-        (
-            String::from("0396008A03FC02DF0024"),
-            String::from("gastly"),
-        ),
+        (String::from("0396008A03FC02DF0024"), String::from("gastly")),
         (
             String::from("041101290348000303BD0234"),
             String::from("haunter"),
@@ -2232,10 +2056,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03CC018C035A0006039900AB03FC000303D5014A0348"),
             String::from("kangaskhan"),
         ),
-        (
-            String::from("041102DC03F90024"),
-            String::from("horsea"),
-        ),
+        (String::from("041102DC03F90024"), String::from("horsea")),
         (
             String::from("03F900240006039002F700A8"),
             String::from("seadra"),
@@ -2260,10 +2081,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("0327004803FC000303BD0231033301AD0336"),
             String::from("mr.mime"),
         ),
-        (
-            String::from("03FC01B3036C0234"),
-            String::from("scyther"),
-        ),
+        (String::from("03FC01B3036C0234"), String::from("scyther")),
         (
             String::from("03630042035A000303D803FC"),
             String::from("jynx"),
@@ -2280,18 +2098,9 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("032A0087000603A203330255"),
             String::from("magmar"),
         ),
-        (
-            String::from("03A50042034803FC0234"),
-            String::from("pinsir"),
-        ),
-        (
-            String::from("03C3020D02FD012F03FC"),
-            String::from("tauros"),
-        ),
-        (
-            String::from("03C30246021603FC"),
-            String::from("tauros"),
-        ),
+        (String::from("03A50042034803FC0234"), String::from("pinsir")),
+        (String::from("03C3020D02FD012F03FC"), String::from("tauros")),
+        (String::from("03C30246021603FC"), String::from("tauros")),
         (
             String::from("032A0087000603630045000303D50255000303B4"),
             String::from("magikarp"),
@@ -2312,14 +2121,8 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("02E20087000303B402F700AB03FC"),
             String::from("lapras"),
         ),
-        (
-            String::from("03810045000303C30213"),
-            String::from("ditto"),
-        ),
-        (
-            String::from("0426002703E70024"),
-            String::from("eevee"),
-        ),
+        (String::from("03810045000303C30213"), String::from("ditto")),
+        (String::from("0426002703E70024"), String::from("eevee")),
         (
             String::from("03EA018F000303B102BE0015014A0348"),
             String::from("vaporeon"),
@@ -2416,10 +2219,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("0327030C00EA000303C000EA"),
             String::from("mewtwo"),
         ),
-        (
-            String::from("0327030C00EA"),
-            String::from("mew"),
-        ),
+        (String::from("0327030C00EA"), String::from("mew")),
         (
             String::from("03C3014D000303AB00AB03EA000603630045000603A202DF0024000303AB00AB03F0"),
             String::from("top-of-jigglypuff"),
@@ -2456,10 +2256,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("038700C9000603A2000303C602F100150213"),
             String::from("dugtrio"),
         ),
-        (
-            String::from("03A50045000603630024"),
-            String::from("pidgey"),
-        ),
+        (String::from("03A50045000603630024"), String::from("pidgey")),
         (
             String::from("038D02130006038A00DB0213"),
             String::from("doduo"),
@@ -2528,30 +2325,18 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("02E2006903FC000303B402E2018F"),
             String::from("lets-play"),
         ),
-        (
-            String::from("02FD0129035A"),
-            String::from("wrong"),
-        ),
+        (String::from("02FD0129035A"), String::from("wrong")),
         (
             String::from("0372008700060390000303A50024000303CF00A80003036000EA"),
             String::from("bad-pikachu"),
         ),
-        (
-            String::from("0327004803FC"),
-            String::from("miss"),
-        ),
+        (String::from("0327004803FC"), String::from("miss")),
         (
             String::from("038D02100348000303C6000303D5012302DF0045000303C6"),
             String::from("dont-call-it"),
         ),
-        (
-            String::from("041101F503FC"),
-            String::from("house"),
-        ),
-        (
-            String::from("041102100336"),
-            String::from("home"),
-        ),
+        (String::from("041101F503FC"), String::from("house")),
+        (String::from("041102100336"), String::from("home")),
         (
             String::from("03EA00A202F1004500060381000F00C60348"),
             String::from("viridian"),
@@ -2560,10 +2345,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03EA00A202F1004500060381000F00C6034803F002C400AB03FC000303C6"),
             String::from("viridian-forest"),
         ),
-        (
-            String::from("043B0213000303CF0234"),
-            String::from("ochre"),
-        ),
+        (String::from("043B0213000303CF0234"), String::from("ochre")),
         (
             String::from("043B0213000303CF0225031E010B0006039003DE"),
             String::from("ochre-woods"),
@@ -2604,10 +2386,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03D502130006037E03ED004803FF0042035A0411020A02EE"),
             String::from("cobalt-fishing-hole"),
         ),
-        (
-            String::from("03D5021603FC000303C6"),
-            String::from("coast"),
-        ),
+        (String::from("03D5021603FC000303C6"), String::from("coast")),
         (
             String::from("03D502130006037B012302EE000303C6000303D5021603FC000303C6"),
             String::from("cobalt-coast"),
@@ -2620,16 +2399,15 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03BD0231033F00A8000303B4"),
             String::from("turnip"),
         ),
-        (
-            String::from("03BD02310348000303B4"),
-            String::from("turnip"),
-        ),
+        (String::from("03BD02310348000303B4"), String::from("turnip")),
         (
             String::from("03FC03150024000303C6000303AB00A8000303BA018F0006038D0213"),
             String::from("sweet-potato"),
         ),
         (
-            String::from("0411014D000303C603FC03150024000303C6000303AE010B000303BA018F0006038D0213"),
+            String::from(
+                "0411014D000303C603FC03150024000303C6000303AE010B000303BA018F0006038D0213",
+            ),
             String::from("hot-sweet-potato"),
         ),
         (
@@ -2640,18 +2418,12 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("04080084034B00420348036C02B8"),
             String::from("hang-in-there"),
         ),
-        (
-            String::from("03AE010202EE"),
-            String::from("pull"),
-        ),
+        (String::from("03AE010202EE"), String::from("pull")),
         (
             String::from("02F1001B02DF0045000303B700420348"),
             String::from("reel-it-in"),
         ),
-        (
-            String::from("034501F2"),
-            String::from("now"),
-        ),
+        (String::from("034501F2"), String::from("now")),
         (
             String::from("03CC00870003035D0045000303C6"),
             String::from("catch-it"),
@@ -2676,14 +2448,8 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("02F1003C02DF002703F90045000303C6"),
             String::from("release-it"),
         ),
-        (
-            String::from("02E500C6034800030360"),
-            String::from("lunch"),
-        ),
-        (
-            String::from("03FC033C0087000303D8"),
-            String::from("snack"),
-        ),
+        (String::from("02E500C6034800030360"), String::from("lunch")),
+        (String::from("03FC033C0087000303D8"), String::from("snack")),
         (
             String::from("02E2006903F90024000303C6"),
             String::from("lets-eat"),
@@ -2700,10 +2466,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("042F01B0000603930045000303B70045000303C6"),
             String::from("i-get-it"),
         ),
-        (
-            String::from("0411032101B0"),
-            String::from("why?"),
-        ),
+        (String::from("0411032101B0"), String::from("why?")),
         (
             String::from("041101F2000303CF00C60336"),
             String::from("how-come?"),
@@ -2728,10 +2491,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03FC000303C3014D000303B4036C0087000303C6"),
             String::from("stop-that"),
         ),
-        (
-            String::from("03D503150045000303C6"),
-            String::from("quit"),
-        ),
+        (String::from("03D503150045000303C6"), String::from("quit")),
         (
             String::from("03CF00C9000303B70045000303C301F2000303C6"),
             String::from("cut-it-out"),
@@ -2744,10 +2504,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("02E20066000303C603DE0006039F0213"),
             String::from("lets-go"),
         ),
-        (
-            String::from("031B0225012F03F0"),
-            String::from("we-re-off"),
-        ),
+        (String::from("031B0225012F03F0"), String::from("we-re-off")),
         (
             String::from("03BA008700060393030902190045000303C6"),
             String::from("tag-youre-it"),
@@ -2804,18 +2561,12 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("039F0213000303BD00C6033302460213"),
             String::from("go-tomorrow"),
         ),
-        (
-            String::from("02FD014D000303D8"),
-            String::from("rock"),
-        ),
+        (String::from("02FD014D000303D8"), String::from("rock")),
         (
             String::from("03F9004803DE023703FC"),
             String::from("scissors"),
         ),
-        (
-            String::from("03A8018F000303AB0234"),
-            String::from("paper"),
-        ),
+        (String::from("03A8018F000303AB0234"), String::from("paper")),
         (
             String::from("0381002A000303B10255000303C6"),
             String::from("depart"),
@@ -2872,10 +2623,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03450213000602E50042032A002A000303C6"),
             String::from("no-limit"),
         ),
-        (
-            String::from("03B7005A0348"),
-            String::from("ten"),
-        ),
+        (String::from("03B7005A0348"), String::from("ten")),
         (
             String::from("03E7002A03F6000303B700090348"),
             String::from("fifteen"),
@@ -2888,18 +2636,12 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03C30318004B0339038A002403EA019E03EA"),
             String::from("twenty-five"),
         ),
-        (
-            String::from("036C02AC03BA0027"),
-            String::from("thirty"),
-        ),
+        (String::from("036C02AC03BA0027"), String::from("thirty")),
         (
             String::from("036C02AC03BA002703EA019E03EA"),
             String::from("thirty-five"),
         ),
-        (
-            String::from("03EA02D6000603900048"),
-            String::from("forty"),
-        ),
+        (String::from("03EA02D6000603900048"), String::from("forty")),
         (
             String::from("03EA02D600060390004803EA019E03EA"),
             String::from("forty-five"),
@@ -2928,10 +2670,7 @@ pub fn create_word_mappings(device: &mut device::Device) {
             String::from("03FC004B036C00630348000303B7000903EA019E03EA"),
             String::from("seventy-five"),
         ),
-        (
-            String::from("042C018C03B70009"),
-            String::from("eighty"),
-        ),
+        (String::from("042C018C03B70009"), String::from("eighty")),
         (
             String::from("042C018C03B7000903EA019E03EA"),
             String::from("eighty-five"),

src/device/cop0.rs

@@ -99,18 +99,18 @@ pub struct Cop0 {
     pub tlb_entries: [device::tlb::TlbEntry; 32],
 }
 
-pub fn mfc0(device: &mut device::Device, opcode: u32) {
+fn mfc0(device: &mut device::Device, opcode: u32) {
     device.cpu.gpr[device::cpu_instructions::rt(opcode) as usize] = device::cpu_instructions::se32(
         (get_control_registers(device, device::cpu_instructions::rd(opcode))) as u32 as i32,
     )
 }
 
-pub fn dmfc0(device: &mut device::Device, opcode: u32) {
+fn dmfc0(device: &mut device::Device, opcode: u32) {
     device.cpu.gpr[device::cpu_instructions::rt(opcode) as usize] =
         get_control_registers(device, device::cpu_instructions::rd(opcode))
 }
 
-pub fn mtc0(device: &mut device::Device, opcode: u32) {
+fn mtc0(device: &mut device::Device, opcode: u32) {
     device::cop0::set_control_registers(
         device,
         device::cpu_instructions::rd(opcode),
@@ -120,7 +120,7 @@ pub fn mtc0(device: &mut device::Device, opcode: u32) {
     )
 }
 
-pub fn dmtc0(device: &mut device::Device, opcode: u32) {
+fn dmtc0(device: &mut device::Device, opcode: u32) {
     device::cop0::set_control_registers(
         device,
         device::cpu_instructions::rd(opcode),
@@ -128,24 +128,24 @@ pub fn dmtc0(device: &mut device::Device, opcode: u32) {
     )
 }
 
-pub fn tlbr(device: &mut device::Device, _opcode: u32) {
+fn tlbr(device: &mut device::Device, _opcode: u32) {
     device::tlb::read(device, device.cpu.cop0.regs[COP0_INDEX_REG as usize])
 }
 
-pub fn tlbwi(device: &mut device::Device, _opcode: u32) {
+fn tlbwi(device: &mut device::Device, _opcode: u32) {
     device::tlb::write(device, device.cpu.cop0.regs[COP0_INDEX_REG as usize])
 }
 
-pub fn tlbwr(device: &mut device::Device, _opcode: u32) {
+fn tlbwr(device: &mut device::Device, _opcode: u32) {
     let random = set_random_register(device);
     device::tlb::write(device, random)
 }
 
-pub fn tlbp(device: &mut device::Device, _opcode: u32) {
+fn tlbp(device: &mut device::Device, _opcode: u32) {
     device::tlb::probe(device)
 }
 
-pub fn eret(device: &mut device::Device, _opcode: u32) {
+fn eret(device: &mut device::Device, _opcode: u32) {
     if device.cpu.cop0.regs[COP0_STATUS_REG as usize] & COP0_STATUS_ERL != 0 {
         device.cpu.pc = device.cpu.cop0.regs[COP0_ERROREPC_REG as usize];
         device.cpu.cop0.regs[COP0_STATUS_REG as usize] &= !COP0_STATUS_ERL
@@ -158,7 +158,7 @@ pub fn eret(device: &mut device::Device, _opcode: u32) {
     device::exceptions::check_pending_interrupts(device)
 }
 
-pub fn execute_cp0(device: &mut device::Device, opcode: u32) {
+fn execute_cp0(device: &mut device::Device, opcode: u32) {
     device.cpu.cop0.instrs2[(opcode & 0x3F) as usize](device, opcode)
 }
 
@@ -174,7 +174,7 @@ pub fn reserved(device: &mut device::Device, _opcode: u32) {
     device::exceptions::reserved_exception(device, 0);
 }
 
-pub fn get_control_registers(device: &device::Device, index: u32) -> u64 {
+fn get_control_registers(device: &device::Device, index: u32) -> u64 {
     match index {
         COP0_COUNT_REG => device.cpu.cop0.regs[index as usize] >> 1,
         COP0_RANDOM_REG => set_random_register(device),
@@ -183,7 +183,7 @@ pub fn get_control_registers(device: &device::Device, index: u32) -> u64 {
     }
 }
 
-pub fn set_control_registers(device: &mut device::Device, index: u32, mut data: u64) {
+fn set_control_registers(device: &mut device::Device, index: u32, mut data: u64) {
     device.cpu.cop0.reg_latch = data;
     match index {
         COP0_COUNT_REG => {
@@ -230,7 +230,7 @@ pub fn set_control_registers(device: &mut device::Device, index: u32, mut data:
     device::exceptions::check_pending_interrupts(device);
 }
 
-pub fn compare_event(device: &mut device::Device) {
+fn compare_event(device: &mut device::Device) {
     device.cpu.cop0.regs[COP0_CAUSE_REG as usize] &= !COP0_CAUSE_EXCCODE_MASK;
     device.cpu.cop0.regs[COP0_CAUSE_REG as usize] |= COP0_CAUSE_IP7;
 
@@ -243,7 +243,7 @@ pub fn compare_event(device: &mut device::Device) {
     device::exceptions::check_pending_interrupts(device);
 }
 
-pub fn set_random_register(device: &device::Device) -> u64 {
+fn set_random_register(device: &device::Device) -> u64 {
     if device.cpu.cop0.regs[COP0_WIRED_REG as usize] > 31 {
         (u64::MAX - device.cpu.cop0.regs[COP0_COUNT_REG as usize]) & 0x3F
     } else {

src/device/cop1.rs

@@ -173,7 +173,7 @@ pub fn sdc1(device: &mut device::Device, opcode: u32) {
     )
 }
 
-pub fn mfc1(device: &mut device::Device, opcode: u32) {
+fn mfc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -185,7 +185,7 @@ pub fn mfc1(device: &mut device::Device, opcode: u32) {
         device::cpu_instructions::se32(u32::from_ne_bytes(value.to_ne_bytes()) as i32);
 }
 
-pub fn dmfc1(device: &mut device::Device, opcode: u32) {
+fn dmfc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -197,7 +197,7 @@ pub fn dmfc1(device: &mut device::Device, opcode: u32) {
         u64::from_ne_bytes(value.to_ne_bytes());
 }
 
-pub fn cfc1(device: &mut device::Device, opcode: u32) {
+fn cfc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -209,7 +209,7 @@ pub fn cfc1(device: &mut device::Device, opcode: u32) {
     )
 }
 
-pub fn dcfc1(device: &mut device::Device, opcode: u32) {
+fn dcfc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -221,7 +221,7 @@ pub fn dcfc1(device: &mut device::Device, opcode: u32) {
     device::exceptions::floating_point_exception(device)
 }
 
-pub fn mtc1(device: &mut device::Device, opcode: u32) {
+fn mtc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -239,7 +239,7 @@ pub fn mtc1(device: &mut device::Device, opcode: u32) {
     )
 }
 
-pub fn dmtc1(device: &mut device::Device, opcode: u32) {
+fn dmtc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -252,7 +252,7 @@ pub fn dmtc1(device: &mut device::Device, opcode: u32) {
     set_fpr_double(device, device::fpu_instructions::fs(opcode) as usize, value)
 }
 
-pub fn ctc1(device: &mut device::Device, opcode: u32) {
+fn ctc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -266,7 +266,7 @@ pub fn ctc1(device: &mut device::Device, opcode: u32) {
     )
 }
 
-pub fn dctc1(device: &mut device::Device, opcode: u32) {
+fn dctc1(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -278,7 +278,7 @@ pub fn dctc1(device: &mut device::Device, opcode: u32) {
     device::exceptions::floating_point_exception(device)
 }
 
-pub fn execute_cop1_b(device: &mut device::Device, opcode: u32) {
+fn execute_cop1_b(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -288,7 +288,7 @@ pub fn execute_cop1_b(device: &mut device::Device, opcode: u32) {
     device.cpu.cop1.b_instrs[((opcode >> 16) & 0x3) as usize](device, opcode)
 }
 
-pub fn execute_cop1_s(device: &mut device::Device, opcode: u32) {
+fn execute_cop1_s(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -298,7 +298,7 @@ pub fn execute_cop1_s(device: &mut device::Device, opcode: u32) {
     device.cpu.cop1.s_instrs[(opcode & 0x3F) as usize](device, opcode)
 }
 
-pub fn execute_cop1_d(device: &mut device::Device, opcode: u32) {
+fn execute_cop1_d(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -308,7 +308,7 @@ pub fn execute_cop1_d(device: &mut device::Device, opcode: u32) {
     device.cpu.cop1.d_instrs[(opcode & 0x3F) as usize](device, opcode)
 }
 
-pub fn execute_cop1_l(device: &mut device::Device, opcode: u32) {
+fn execute_cop1_l(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -318,7 +318,7 @@ pub fn execute_cop1_l(device: &mut device::Device, opcode: u32) {
     device.cpu.cop1.l_instrs[(opcode & 0x3F) as usize](device, opcode)
 }
 
-pub fn execute_cop1_w(device: &mut device::Device, opcode: u32) {
+fn execute_cop1_w(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU1
         == 0
     {
@@ -328,7 +328,7 @@ pub fn execute_cop1_w(device: &mut device::Device, opcode: u32) {
     device.cpu.cop1.w_instrs[(opcode & 0x3F) as usize](device, opcode)
 }
 
-pub fn unusable(device: &mut device::Device, _opcode: u32) {
+fn unusable(device: &mut device::Device, _opcode: u32) {
     device::exceptions::cop_unusable_exception(device, device::cop0::COP0_CAUSE_CE1)
 }
 
@@ -342,7 +342,7 @@ pub fn reserved(device: &mut device::Device, opcode: u32) {
     device::exceptions::reserved_exception(device, device::cop0::COP0_CAUSE_CE1);
 }
 
-pub fn get_control_registers_fpu(device: &device::Device, index: u32) -> u32 {
+fn get_control_registers_fpu(device: &device::Device, index: u32) -> u32 {
     match index {
         0 => device.cpu.cop1.fcr0,
         31 => device.cpu.cop1.fcr31,
@@ -352,7 +352,7 @@ pub fn get_control_registers_fpu(device: &device::Device, index: u32) -> u32 {
     }
 }
 
-pub fn set_control_registers_fpu(device: &mut device::Device, index: u32, data: u32) {
+fn set_control_registers_fpu(device: &mut device::Device, index: u32, data: u32) {
     match index {
         0 => { // read only
         }

src/device/cop2.rs

@@ -5,7 +5,7 @@ pub struct Cop2 {
     pub reg_latch: u64,
 }
 
-pub fn mfc2(device: &mut device::Device, opcode: u32) {
+fn mfc2(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU2
         == 0
     {
@@ -15,7 +15,7 @@ pub fn mfc2(device: &mut device::Device, opcode: u32) {
         device::cpu_instructions::se32((device.cpu.cop2.reg_latch) as u32 as i32)
 }
 
-pub fn dmfc2(device: &mut device::Device, opcode: u32) {
+fn dmfc2(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU2
         == 0
     {
@@ -24,7 +24,7 @@ pub fn dmfc2(device: &mut device::Device, opcode: u32) {
     device.cpu.gpr[device::cpu_instructions::rt(opcode) as usize] = device.cpu.cop2.reg_latch
 }
 
-pub fn cfc2(device: &mut device::Device, opcode: u32) {
+fn cfc2(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU2
         == 0
     {
@@ -34,7 +34,7 @@ pub fn cfc2(device: &mut device::Device, opcode: u32) {
         device::cpu_instructions::se32((device.cpu.cop2.reg_latch) as u32 as i32)
 }
 
-pub fn mtc2(device: &mut device::Device, opcode: u32) {
+fn mtc2(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU2
         == 0
     {
@@ -43,7 +43,7 @@ pub fn mtc2(device: &mut device::Device, opcode: u32) {
     device.cpu.cop2.reg_latch = device.cpu.gpr[device::cpu_instructions::rt(opcode) as usize]
 }
 
-pub fn dmtc2(device: &mut device::Device, opcode: u32) {
+fn dmtc2(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU2
         == 0
     {
@@ -52,7 +52,7 @@ pub fn dmtc2(device: &mut device::Device, opcode: u32) {
     device.cpu.cop2.reg_latch = device.cpu.gpr[device::cpu_instructions::rt(opcode) as usize]
 }
 
-pub fn ctc2(device: &mut device::Device, opcode: u32) {
+fn ctc2(device: &mut device::Device, opcode: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_CU2
         == 0
     {
@@ -72,7 +72,7 @@ pub fn reserved(device: &mut device::Device, opcode: u32) {
     device::exceptions::reserved_exception(device, device::cop0::COP0_CAUSE_CE2);
 }
 
-pub fn unusable(device: &mut device::Device, _opcode: u32) {
+fn unusable(device: &mut device::Device, _opcode: u32) {
     device::exceptions::cop_unusable_exception(device, device::cop0::COP0_CAUSE_CE2)
 }
 

src/device/cpu_instructions.rs

@@ -12,7 +12,7 @@ pub fn rt(opcode: u32) -> u32 {
     (opcode >> 16) & 0x1F
 }
 
-pub fn sa(opcode: u32) -> u32 {
+fn sa(opcode: u32) -> u32 {
     (opcode >> 6) & 0x1F
 }
 
@@ -28,23 +28,23 @@ pub fn se16(value: i16) -> u64 {
     value as i64 as u64
 }
 
-pub fn se8(value: i8) -> u64 {
+fn se8(value: i8) -> u64 {
     value as i64 as u64
 }
 
-pub fn bshift<T: Into<u64>>(address: T) -> u64 {
+fn bshift<T: Into<u64>>(address: T) -> u64 {
     ((address.into() & 3) ^ 3) << 3
 }
 
-pub fn hshift<T: Into<u64>>(address: T) -> u64 {
+fn hshift<T: Into<u64>>(address: T) -> u64 {
     ((address.into() & 2) ^ 2) << 3
 }
 
-pub fn bits_below_mask<T: Into<u64>>(x: T) -> u64 {
+fn bits_below_mask<T: Into<u64>>(x: T) -> u64 {
     (1 << x.into()) - 1
 }
 
-pub fn bits_above_mask<T: Into<u64>>(x: T) -> u64 {
+fn bits_above_mask<T: Into<u64>>(x: T) -> u64 {
     !bits_below_mask(x)
 }
 
@@ -60,8 +60,8 @@ pub fn check_relative_idle_loop(device: &mut device::Device, opcode: u32) {
     }
 }
 
-pub fn check_absolute_idle_loop(device: &mut device::Device, opcode: u32) {
-    if (opcode & 0x3FFFFFF) as u64 == (device.cpu.pc_phys & 0x0FFFFFFF) >> 2
+fn check_absolute_idle_loop(device: &mut device::Device, target: u64) {
+    if device.cpu.pc == target
         && device.memory.fast_read[(device.cpu.pc_phys >> 16) as usize](
             device,
             device.cpu.pc_phys + 4,
@@ -76,10 +76,10 @@ pub fn j(device: &mut device::Device, opcode: u32) {
     if device::cpu::in_delay_slot_taken(device) {
         return;
     }
-    check_absolute_idle_loop(device, opcode);
+    let target = (device.cpu.pc + 4) & 0xFFFFFFFFF0000000 | ((opcode & 0x3FFFFFF) << 2) as u64;
+    check_absolute_idle_loop(device, target);
     device.cpu.branch_state.state = device::cpu::State::Take;
-    device.cpu.branch_state.pc =
-        (device.cpu.pc + 4) & 0xFFFFFFFFF0000000 | ((opcode & 0x3FFFFFF) << 2) as u64
+    device.cpu.branch_state.pc = target
 }
 
 pub fn jal(device: &mut device::Device, opcode: u32) {
@@ -89,10 +89,10 @@ pub fn jal(device: &mut device::Device, opcode: u32) {
         device.cpu.gpr[31] = device.cpu.pc + 8
     }
     if !device::cpu::in_delay_slot_taken(device) {
-        check_absolute_idle_loop(device, opcode);
+        let target = (device.cpu.pc + 4) & 0xFFFFFFFFF0000000 | ((opcode & 0x3FFFFFF) << 2) as u64;
+        check_absolute_idle_loop(device, target);
         device.cpu.branch_state.state = device::cpu::State::Take;
-        device.cpu.branch_state.pc =
-            (device.cpu.pc + 4) & 0xFFFFFFFFF0000000 | ((opcode & 0x3FFFFFF) << 2) as u64
+        device.cpu.branch_state.pc = target
     } else if !device::cpu::in_delay_slot(device) {
         device.cpu.branch_state.state = device::cpu::State::NotTaken;
     }
@@ -966,7 +966,6 @@ pub fn srav(device: &mut device::Device, opcode: u32) {
 
 pub fn jr(device: &mut device::Device, opcode: u32) {
     if !device::cpu::in_delay_slot_taken(device) {
-        check_relative_idle_loop(device, opcode);
         device.cpu.branch_state.state = device::cpu::State::Take;
         device.cpu.branch_state.pc = device.cpu.gpr[rs(opcode) as usize];
     } else if !device::cpu::in_delay_slot(device) {
@@ -978,7 +977,6 @@ pub fn jalr(device: &mut device::Device, opcode: u32) {
     let in_delay_slot_taken = device::cpu::in_delay_slot_taken(device);
 
     if !in_delay_slot_taken {
-        check_relative_idle_loop(device, opcode);
         device.cpu.branch_state.state = device::cpu::State::Take;
         device.cpu.branch_state.pc = device.cpu.gpr[rs(opcode) as usize];
     } else if !device::cpu::in_delay_slot(device) {

src/device/events.rs

@@ -12,6 +12,7 @@ pub enum EventType {
     SPDma,
     Compare,
     Vru,
+    PakSwitch,
     Count,
 }
 
@@ -56,7 +57,7 @@ pub fn trigger_event(device: &mut device::Device) {
     set_next_event(device);
 }
 
-pub fn set_next_event(device: &mut device::Device) {
+fn set_next_event(device: &mut device::Device) {
     device.cpu.next_event_count = u64::MAX;
     for (pos, i) in device.cpu.events.iter().enumerate() {
         if i.enabled && i.count < device.cpu.next_event_count {

src/device/exceptions.rs

@@ -133,7 +133,7 @@ pub fn tlb_miss_exception(
     exception_general(device, vector_offset)
 }
 
-pub fn exception_general(device: &mut device::Device, vector_offset: u32) {
+fn exception_general(device: &mut device::Device, vector_offset: u32) {
     if device.cpu.cop0.regs[device::cop0::COP0_STATUS_REG as usize] & device::cop0::COP0_STATUS_EXL
         == 0
     {

src/device/fpu_instructions.rs

@@ -8,7 +8,7 @@ pub fn ft(opcode: u32) -> u32 {
     (opcode >> 16) & 0x1F
 }
 
-pub fn fd(opcode: u32) -> u32 {
+fn fd(opcode: u32) -> u32 {
     (opcode >> 6) & 0x1F
 }
 

src/device/memory.rs

@@ -56,13 +56,10 @@ pub fn translate_address(
     address: u64,
     access_type: AccessType,
 ) -> (u64, bool, bool) {
-    let mut cached = false;
     if (address & 0xc0000000) != 0x80000000 {
         return device::tlb::get_physical_address(device, address, access_type);
-    } else if address & 0x20000000 == 0 {
-        cached = true;
     }
-    (address & 0x1FFFFFFF, cached, false)
+    (address & 0x1FFFFFFF, address & 0x20000000 == 0, false)
 }
 
 pub fn data_read(

src/device/mi.rs

@@ -75,7 +75,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
     device::exceptions::check_pending_interrupts(device)
 }
 
-pub fn update_init_mode(device: &mut device::Device, w: u32) {
+fn update_init_mode(device: &mut device::Device, w: u32) {
     device.mi.regs[MI_INIT_MODE_REG as usize] &= !MI_INIT_LENGTH_MASK;
     device.mi.regs[MI_INIT_MODE_REG as usize] |= w & MI_INIT_LENGTH_MASK;
 
@@ -103,7 +103,7 @@ pub fn update_init_mode(device: &mut device::Device, w: u32) {
     }
 }
 
-pub fn update_intr_mask(device: &mut device::Device, w: u32) {
+fn update_intr_mask(device: &mut device::Device, w: u32) {
     if w & MI_CLR_SP != 0 {
         device.mi.regs[MI_INTR_MASK_REG as usize] &= !MI_INTR_SP
     }

src/device/pi.rs

@@ -30,7 +30,7 @@ pub struct Pi {
     pub regs: [u32; PI_REGS_COUNT as usize],
 }
 
-pub struct PiHandler {
+struct PiHandler {
     read: fn(&mut device::Device, u32, u32, u32) -> u64,
     write: fn(&mut device::Device, u32, u32, u32) -> u64,
 }
@@ -49,7 +49,7 @@ pub fn read_regs(
     }
 }
 
-pub fn dma_read(device: &mut device::Device) {
+fn dma_read(device: &mut device::Device) {
     let handler = get_handler(device.pi.regs[PI_CART_ADDR_REG as usize]);
 
     let cart_addr = device.pi.regs[PI_CART_ADDR_REG as usize] & !1;
@@ -79,7 +79,7 @@ pub fn dma_read(device: &mut device::Device) {
     device.pi.regs[PI_STATUS_REG as usize] |= PI_STATUS_DMA_BUSY
 }
 
-pub fn dma_write(device: &mut device::Device) {
+fn dma_write(device: &mut device::Device) {
     let handler = get_handler(device.pi.regs[PI_CART_ADDR_REG as usize]);
 
     let cart_addr = device.pi.regs[PI_CART_ADDR_REG as usize] & !1;
@@ -112,7 +112,7 @@ pub fn dma_write(device: &mut device::Device) {
     device.pi.regs[PI_STATUS_REG as usize] |= PI_STATUS_DMA_BUSY
 }
 
-pub fn get_handler(address: u32) -> PiHandler {
+fn get_handler(address: u32) -> PiHandler {
     let mut handler = PiHandler {
         read: device::cart_rom::dma_read,
         write: device::cart_rom::dma_write,
@@ -149,10 +149,15 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
                 device.pi.regs[PI_STATUS_REG as usize] = 0
             }
         }
-        PI_BSD_DOM1_LAT_REG | PI_BSD_DOM1_PWD_REG | PI_BSD_DOM1_PGS_REG | PI_BSD_DOM1_RLS_REG
-        | PI_BSD_DOM2_LAT_REG | PI_BSD_DOM2_PWD_REG | PI_BSD_DOM2_PGS_REG | PI_BSD_DOM2_RLS_REG => {
+        PI_BSD_DOM1_LAT_REG | PI_BSD_DOM1_PWD_REG | PI_BSD_DOM2_LAT_REG | PI_BSD_DOM2_PWD_REG => {
             device::memory::masked_write_32(&mut device.pi.regs[reg as usize], value & 0xFF, mask)
         }
+        PI_BSD_DOM1_PGS_REG | PI_BSD_DOM2_PGS_REG => {
+            device::memory::masked_write_32(&mut device.pi.regs[reg as usize], value & 0xF, mask)
+        }
+        PI_BSD_DOM1_RLS_REG | PI_BSD_DOM2_RLS_REG => {
+            device::memory::masked_write_32(&mut device.pi.regs[reg as usize], value & 0x3, mask)
+        }
         _ => device::memory::masked_write_32(&mut device.pi.regs[reg as usize], value, mask),
     }
 }

src/device/pif.rs

@@ -15,6 +15,7 @@ pub struct PifChannel {
     pub rx_buf: Option<usize>,
     pub process: Option<fn(&mut device::Device, usize)>,
     pub pak_handler: Option<device::controller::PakHandler>,
+    pub change_pak: device::controller::PakType,
 }
 
 pub const PIF_RAM_SIZE: usize = 64;
@@ -72,7 +73,7 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
         device::si::SI_STATUS_DMA_BUSY | device::si::SI_STATUS_IO_BUSY
 }
 
-pub fn process_channel(device: &mut device::Device, channel: usize) -> usize {
+fn process_channel(device: &mut device::Device, channel: usize) -> usize {
     /* don't process channel if it has been disabled */
     if device.pif.channels[channel].tx.is_none() {
         return 0;
@@ -99,17 +100,18 @@ pub fn update_pif_ram(device: &mut device::Device) -> u64 {
     for k in 0..PIF_CHANNELS_COUNT {
         active_channels += process_channel(device, k)
     }
+
     (24000 + (active_channels * 30000)) as u64
 }
 
-pub fn disable_pif_channel(channel: &mut PifChannel) {
+fn disable_pif_channel(channel: &mut PifChannel) {
     channel.tx = None;
     channel.rx = None;
     channel.tx_buf = None;
     channel.rx_buf = None;
 }
 
-pub fn setup_pif_channel(device: &mut device::Device, channel: usize, buf: usize) -> usize {
+fn setup_pif_channel(device: &mut device::Device, channel: usize, buf: usize) -> usize {
     let tx = device.pif.ram[buf] & 0x3f;
     let rx = device.pif.ram[buf + 1] & 0x3f;
 
@@ -123,7 +125,7 @@ pub fn setup_pif_channel(device: &mut device::Device, channel: usize, buf: usize
     (2 + tx + rx) as usize
 }
 
-pub fn setup_channels_format(device: &mut device::Device) {
+fn setup_channels_format(device: &mut device::Device) {
     let mut i: usize = 0;
     let mut k: usize = 0;
     while i < PIF_RAM_SIZE && k < PIF_CHANNELS_COUNT {
@@ -225,24 +227,30 @@ pub fn init(device: &mut device::Device) {
     device.pif.ram[0x27] = device.cart.cic_seed;
 
     let mempak_handler = device::controller::PakHandler {
-        read: device::mempak::read,
-        write: device::mempak::write,
+        read: device::controller::mempak::read,
+        write: device::controller::mempak::write,
+        pak_type: device::controller::PakType::MemPak,
     };
 
     for i in 0..4 {
-        if device.ui.config.input.controller_enabled[i] {
+        if device.netplay.is_none() {
+            if device.ui.config.input.controller_enabled[i] {
+                device.pif.channels[i].pak_handler = Some(mempak_handler);
+                device.pif.channels[i].process = Some(device::controller::process);
+            }
+        } else if device.netplay.as_ref().unwrap().player_data[i].reg_id != 0 {
             device.pif.channels[i].pak_handler = Some(mempak_handler);
             device.pif.channels[i].process = Some(device::controller::process);
         }
     }
     if device.ui.config.input.emulate_vru {
         device.pif.channels[3].pak_handler = None;
-        device.pif.channels[3].process = Some(device::vru::process);
+        device.pif.channels[3].process = Some(device::controller::vru::process);
     }
     device.pif.channels[4].process = Some(device::cart::process)
 }
 
-pub fn process_cic_challenge(device: &mut device::Device) {
+fn process_cic_challenge(device: &mut device::Device) {
     let mut challenge: [u8; 30] = [0; 30];
     let mut response: [u8; 30] = [0; 30];
 
@@ -263,7 +271,7 @@ pub fn process_cic_challenge(device: &mut device::Device) {
     }
 }
 
-pub fn n64_cic_nus_6105(chl: [u8; 30], rsp: &mut [u8; 30], len: usize) {
+fn n64_cic_nus_6105(chl: [u8; 30], rsp: &mut [u8; 30], len: usize) {
     let lut0: [u8; 0x10] = [
         0x4, 0x7, 0xA, 0x7, 0xE, 0x5, 0xE, 0x1, 0xC, 0xF, 0x8, 0xF, 0x6, 0x3, 0x6, 0x9,
     ];

src/device/rdp.rs

@@ -52,7 +52,16 @@ pub fn read_regs_dpc(
     address: u64,
     _access_size: device::memory::AccessSize,
 ) -> u32 {
-    device.rdp.regs_dpc[((address & 0xFFFF) >> 2) as usize]
+    let reg = (address & 0xFFFF) >> 2;
+    match reg as u32 {
+        DPC_CURRENT_REG => {
+            if device.rdp.wait_frozen {
+                device.rsp.cpu.sync_point = true;
+            }
+            device.rdp.regs_dpc[reg as usize]
+        }
+        _ => device.rdp.regs_dpc[reg as usize],
+    }
 }
 
 pub fn write_regs_dpc(device: &mut device::Device, address: u64, value: u32, mask: u32) {
@@ -91,8 +100,9 @@ pub fn write_regs_dpc(device: &mut device::Device, address: u64, value: u32, mas
     }
 }
 
-pub fn run_rdp(device: &mut device::Device) {
+fn run_rdp(device: &mut device::Device) {
     let timer = ui::video::process_rdp_list();
+    device.rdp.regs_dpc[DPC_STATUS_REG as usize] |= DPC_STATUS_START_GCLK | DPC_STATUS_PIPE_BUSY;
 
     if timer != 0 {
         device::events::create_event(
@@ -120,7 +130,7 @@ pub fn write_regs_dps(device: &mut device::Device, address: u64, value: u32, mas
     )
 }
 
-pub fn update_dpc_status(device: &mut device::Device, w: u32) {
+fn update_dpc_status(device: &mut device::Device, w: u32) {
     /* clear / set xbus_dmem_dma */
     if w & DPC_CLR_XBUS_DMEM_DMA != 0 {
         device.rdp.regs_dpc[DPC_STATUS_REG as usize] &= !DPC_STATUS_XBUS_DMEM_DMA
@@ -173,7 +183,9 @@ pub fn init(device: &mut device::Device) {
         DPC_STATUS_START_GCLK | DPC_STATUS_PIPE_BUSY | DPC_STATUS_CBUF_READY;
 }
 
-pub fn rdp_interrupt_event(device: &mut device::Device) {
+fn rdp_interrupt_event(device: &mut device::Device) {
+    device.rdp.regs_dpc[DPC_STATUS_REG as usize] &= !(DPC_STATUS_START_GCLK | DPC_STATUS_PIPE_BUSY);
+
     ui::video::full_sync();
 
     device::mi::set_rcp_interrupt(device, device::mi::MI_INTR_DP)

src/device/rdram.rs

@@ -1,11 +1,24 @@
 use crate::device;
 use std::alloc::{alloc_zeroed, Layout};
 
+//const RDRAM_CONFIG_REG: u32 = 0;
+//const RDRAM_DEVICE_ID_REG: u32 = 1;
+//const RDRAM_DELAY_REG: u32 = 2;
+const RDRAM_MODE_REG: u32 = 3;
+//const RDRAM_REF_INTERVAL_REG: u32 = 4;
+//const RDRAM_REF_ROW_REG: u32 = 5;
+//const RDRAM_RAS_INTERVAL_REG: u32 = 6;
+//const RDRAM_MIN_INTERVAL_REG: u32 = 7;
+//const RDRAM_ADDR_SELECT_REG: u32 = 8;
+//const RDRAM_DEVICE_MANUF_REG: u32 = 9;
+pub const RDRAM_REGS_COUNT: u32 = 10;
+
 pub const RDRAM_MASK: usize = 0xFFFFFF;
 
 pub struct Rdram {
     pub mem: Vec<u8>,
     pub size: u32,
+    pub regs: [[u32; RDRAM_REGS_COUNT as usize]; 4],
 }
 
 pub fn read_mem_fast(
@@ -56,16 +69,27 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
 }
 
 pub fn read_regs(
-    _device: &mut device::Device,
+    device: &mut device::Device,
     address: u64,
     _access_size: device::memory::AccessSize,
 ) -> u32 {
-    println!("Warning: read from RDRAM reg {:#x}", address);
-    0
+    let chip_id = (address >> 13) & 3;
+    let reg = (address & 0x3FF) >> 2;
+    match reg as u32 {
+        RDRAM_MODE_REG => device.pi.regs[reg as usize] ^ 0xc0c0c0c0,
+        0x80 => 0x00000000, //Row, needed for libdragon
+        _ => device.rdram.regs[chip_id as usize][reg as usize],
+    }
 }
 
-pub fn write_regs(_device: &mut device::Device, _address: u64, _value: u32, _mask: u32) {
-    panic!("rdram write reg");
+pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u32) {
+    let chip_id = (address >> 13) & 3;
+    let reg = (address & 0x3FF) >> 2;
+    device::memory::masked_write_32(
+        &mut device.rdram.regs[chip_id as usize][reg as usize],
+        value,
+        mask,
+    )
 }
 
 pub fn init(device: &mut device::Device) {
@@ -79,6 +103,11 @@ pub fn init(device: &mut device::Device) {
     // hack, skip RDRAM initialization
     device.rdram.mem[device.cart.rdram_size_offset..device.cart.rdram_size_offset + 4]
         .copy_from_slice(&device.rdram.size.to_ne_bytes());
+
+    device.ri.regs[device::ri::RI_MODE_REG as usize] = 0x0e;
+    device.ri.regs[device::ri::RI_CONFIG_REG as usize] = 0x40;
+    device.ri.regs[device::ri::RI_SELECT_REG as usize] = 0x14;
+    device.ri.regs[device::ri::RI_REFRESH_REG as usize] = 0x00063634;
 }
 
 pub fn rdram_calculate_cycles(length: u64) -> u64 {

src/device/ri.rs

@@ -1,10 +1,10 @@
 use crate::device;
 
-//const RI_MODE_REG: u32 = 0;
-//const RI_CONFIG_REG: u32 = 1;
+pub const RI_MODE_REG: u32 = 0;
+pub const RI_CONFIG_REG: u32 = 1;
 //const RI_CURRENT_LOAD_REG: u32 = 2;
-const RI_SELECT_REG: u32 = 3;
-//const RI_REFRESH_REG: u32 = 4;
+pub const RI_SELECT_REG: u32 = 3;
+pub const RI_REFRESH_REG: u32 = 4;
 //const RI_LATENCY_REG: u32 = 5;
 //const RI_ERROR_REG: u32 = 6;
 //const RI_WERROR_REG: u32 = 7;
@@ -12,6 +12,7 @@ pub const RI_REGS_COUNT: u32 = 8;
 
 pub struct Ri {
     pub regs: [u32; RI_REGS_COUNT as usize],
+    pub ram_init: bool,
 }
 
 pub fn read_regs(
@@ -19,8 +20,9 @@ pub fn read_regs(
     address: u64,
     _access_size: device::memory::AccessSize,
 ) -> u32 {
-    if ((address & 0xFFFF) >> 2) as u32 == RI_SELECT_REG {
-        return 0x14; // hack, skip RDRAM initialization
+    if ((address & 0xFFFF) >> 2) as u32 == RI_SELECT_REG && !device.ri.ram_init {
+        device::cop0::add_cycles(device, device.cpu.clock_rate / 2); // hack, simulate RDRAM initialization
+        device.ri.ram_init = true;
     }
     device.ri.regs[((address & 0xFFFF) >> 2) as usize]
 }

src/device/rsp_interface.rs

@@ -81,6 +81,8 @@ pub struct Rsp {
     pub regs2: [u32; SP_REGS2_COUNT as usize],
     pub mem: [u8; 0x2000],
     pub fifo: [RspDma; 2],
+    pub last_status_value: u32,
+    pub run_after_dma: bool,
 }
 
 pub fn read_mem_fast(
@@ -129,7 +131,7 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, _mask: u
     // SH/SB are broken: They overwrite the whole 32 bit, filling everything that isn't written with zeroes
 }
 
-pub fn do_dma(device: &mut device::Device, dma: RspDma) {
+fn do_dma(device: &mut device::Device, dma: RspDma) {
     let l = dma.length;
 
     let length = ((l & 0xfff) | 7) + 1;
@@ -205,7 +207,7 @@ pub fn do_dma(device: &mut device::Device, dma: RspDma) {
     );
 }
 
-pub fn fifo_push(device: &mut device::Device, dir: DmaDir) {
+fn fifo_push(device: &mut device::Device, dir: DmaDir) {
     if device.rsp.regs[SP_DMA_FULL_REG as usize] != 0 {
         panic!("RSP DMA already full")
     }
@@ -237,7 +239,7 @@ pub fn fifo_push(device: &mut device::Device, dir: DmaDir) {
     }
 }
 
-pub fn fifo_pop(device: &mut device::Device) {
+fn fifo_pop(device: &mut device::Device) {
     if device.rsp.regs[SP_DMA_FULL_REG as usize] != 0 {
         device.rsp.fifo[0].dir = device.rsp.fifo[1].dir;
         device.rsp.fifo[0].length = device.rsp.fifo[1].length;
@@ -249,7 +251,11 @@ pub fn fifo_pop(device: &mut device::Device) {
         do_dma(device, device.rsp.fifo[0])
     } else {
         device.rsp.regs[SP_DMA_BUSY_REG as usize] = 0;
-        device.rsp.regs[SP_STATUS_REG as usize] &= !SP_STATUS_DMA_BUSY
+        device.rsp.regs[SP_STATUS_REG as usize] &= !SP_STATUS_DMA_BUSY;
+        if device.rsp.run_after_dma {
+            device.rsp.run_after_dma = false;
+            do_task(device);
+        }
     }
 }
 
@@ -260,8 +266,30 @@ pub fn read_regs(
 ) -> u32 {
     let reg = (address & 0xFFFF) >> 2;
     match reg as u32 {
+        SP_DMA_BUSY_REG | SP_DMA_FULL_REG => {
+            if device.rsp.regs[reg as usize] != 0 {
+                device.rsp.cpu.sync_point = true;
+            }
+            device.rsp.regs[reg as usize]
+        }
+        SP_STATUS_REG => {
+            let value = device.rsp.regs[reg as usize]
+                & !(SP_STATUS_HALT | SP_STATUS_BROKE | SP_STATUS_INTR_BREAK);
+            if value == device.rsp.last_status_value && value != 0 {
+                device.rsp.cpu.sync_point = true;
+            }
+            if value & (SP_STATUS_DMA_BUSY | SP_STATUS_DMA_FULL) != 0 {
+                device.rsp.cpu.sync_point = true;
+            }
+            device.rsp.last_status_value = value;
+            device.rsp.regs[reg as usize]
+        }
         SP_SEMAPHORE_REG => {
             let value = device.rsp.regs[reg as usize];
+            if value == 1 {
+                device.rsp.cpu.sync_point = true;
+                device.rsp.cpu.cycle_counter += 4; // needed for DK64
+            }
             device.rsp.regs[reg as usize] = 1;
             value
         }
@@ -284,9 +312,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
         SP_SEMAPHORE_REG => {
             device::memory::masked_write_32(&mut device.rsp.regs[reg as usize], 0, mask)
         }
-        _ => {
-            device::memory::masked_write_32(&mut device.rsp.regs[reg as usize], value, mask);
-        }
+        _ => device::memory::masked_write_32(&mut device.rsp.regs[reg as usize], value, mask),
     }
 }
 
@@ -312,7 +338,7 @@ pub fn write_regs2(device: &mut device::Device, address: u64, value: u32, mask:
     }
 }
 
-pub fn update_sp_status(device: &mut device::Device, w: u32) {
+fn update_sp_status(device: &mut device::Device, w: u32) {
     let was_halted = device.rsp.regs[SP_STATUS_REG as usize] & SP_STATUS_HALT != 0;
 
     /* clear / set halt */
@@ -421,23 +447,28 @@ pub fn update_sp_status(device: &mut device::Device, w: u32) {
     if device.rsp.regs[SP_STATUS_REG as usize] & SP_STATUS_HALT == 0 && was_halted {
         device.rsp.cpu.broken = false;
         device.rsp.cpu.halted = false;
-        device.rsp.cpu.sync_point = false;
         do_task(device);
     }
 }
 
-pub fn do_task(device: &mut device::Device) {
-    let timer = device::rsp_cpu::run(device);
+fn do_task(device: &mut device::Device) {
+    device.rsp.cpu.sync_point = false;
+    device.rsp.last_status_value = 0;
+    if device.rsp.regs[SP_DMA_BUSY_REG as usize] == 1 {
+        device.rsp.run_after_dma = true
+    } else {
+        let timer = device::rsp_cpu::run(device);
 
-    device::events::create_event(
-        device,
-        device::events::EventType::SP,
-        device.cpu.cop0.regs[device::cop0::COP0_COUNT_REG as usize] + timer,
-        rsp_event,
-    )
+        device::events::create_event(
+            device,
+            device::events::EventType::SP,
+            device.cpu.cop0.regs[device::cop0::COP0_COUNT_REG as usize] + timer,
+            rsp_event,
+        )
+    }
 }
 
-pub fn rsp_event(device: &mut device::Device) {
+fn rsp_event(device: &mut device::Device) {
     if device.rsp.cpu.broken {
         device.rsp.regs[SP_STATUS_REG as usize] |= SP_STATUS_HALT | SP_STATUS_BROKE;
 
@@ -450,7 +481,6 @@ pub fn rsp_event(device: &mut device::Device) {
         device.rsp.regs[SP_STATUS_REG as usize] |= SP_STATUS_HALT;
         return;
     }
-    device.rsp.cpu.sync_point = false;
     do_task(device)
 }
 

src/device/rsp_su_instructions.rs

@@ -8,45 +8,45 @@ use crate::device;
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 
-pub fn rd(opcode: u32) -> u32 {
+fn rd(opcode: u32) -> u32 {
     (opcode >> 11) & 0x1F
 }
 
-pub fn rs(opcode: u32) -> u32 {
+fn rs(opcode: u32) -> u32 {
     (opcode >> 21) & 0x1F
 }
 
-pub fn rt(opcode: u32) -> u32 {
+fn rt(opcode: u32) -> u32 {
     (opcode >> 16) & 0x1F
 }
 
-pub fn sa(opcode: u32) -> u32 {
+fn sa(opcode: u32) -> u32 {
     (opcode >> 6) & 0x1F
 }
 
-pub fn imm(opcode: u32) -> u16 {
+fn imm(opcode: u32) -> u16 {
     opcode as u16
 }
 
-pub fn se16(value: i16) -> u32 {
+fn se16(value: i16) -> u32 {
     value as i32 as u32
 }
 
-pub fn voffset(opcode: u32) -> u8 {
+fn voffset(opcode: u32) -> u8 {
     (opcode & 0x7F) as u8
 }
 
-pub fn velement(opcode: u32) -> u8 {
+fn velement(opcode: u32) -> u8 {
     ((opcode >> 7) & 0xF) as u8
 }
 
-pub fn sign_extend_7bit_offset(offset: u8, shift_amount: u32) -> u32 {
+fn sign_extend_7bit_offset(offset: u8, shift_amount: u32) -> u32 {
     let soffset = (((offset << 1) & 0x80) | offset) as i8;
 
     (((soffset) as i32) as u32) << shift_amount
 }
 
-pub fn modify_vpr8(vpr: &mut __m128i, element: u8, value: u8) {
+fn modify_vpr8(vpr: &mut __m128i, element: u8, value: u8) {
     unsafe {
         *vpr = match element & 15 {
             0 => _mm_insert_epi8(*vpr, value as i32, 15),
@@ -70,7 +70,7 @@ pub fn modify_vpr8(vpr: &mut __m128i, element: u8, value: u8) {
     }
 }
 
-pub fn get_vpr8(vpr: __m128i, element: u8) -> u8 {
+fn get_vpr8(vpr: __m128i, element: u8) -> u8 {
     unsafe {
         match element & 15 {
             0 => _mm_extract_epi8(vpr, 15) as u8,
@@ -126,7 +126,7 @@ pub fn get_vpr16(vpr: __m128i, element: u8) -> u16 {
     }
 }
 
-pub fn modify_vpr32(vpr: &mut __m128i, element: u8, value: u32) {
+fn modify_vpr32(vpr: &mut __m128i, element: u8, value: u32) {
     unsafe {
         *vpr = match element & 3 {
             0 => _mm_insert_epi32(*vpr, value as i32, 3),
@@ -138,7 +138,7 @@ pub fn modify_vpr32(vpr: &mut __m128i, element: u8, value: u32) {
     }
 }
 
-pub fn get_vpr32(vpr: __m128i, element: u8) -> u32 {
+fn get_vpr32(vpr: __m128i, element: u8) -> u32 {
     unsafe {
         match element & 3 {
             0 => _mm_extract_epi32(vpr, 3) as u32,
@@ -150,7 +150,7 @@ pub fn get_vpr32(vpr: __m128i, element: u8) -> u32 {
     }
 }
 
-pub fn modify_vpr64(vpr: &mut __m128i, element: u8, value: u64) {
+fn modify_vpr64(vpr: &mut __m128i, element: u8, value: u64) {
     unsafe {
         *vpr = match element & 1 {
             0 => _mm_insert_epi64(*vpr, value as i64, 1),
@@ -160,7 +160,7 @@ pub fn modify_vpr64(vpr: &mut __m128i, element: u8, value: u64) {
     }
 }
 
-pub fn get_vpr64(vpr: __m128i, element: u8) -> u64 {
+fn get_vpr64(vpr: __m128i, element: u8) -> u64 {
     unsafe {
         match element & 1 {
             0 => _mm_extract_epi64(vpr, 1) as u64,
@@ -170,11 +170,11 @@ pub fn get_vpr64(vpr: __m128i, element: u8) -> u64 {
     }
 }
 
-pub fn modify_vpr128(vpr: &mut __m128i, value: u128) {
+fn modify_vpr128(vpr: &mut __m128i, value: u128) {
     unsafe { *vpr = std::mem::transmute::<u128, __m128i>(value) }
 }
 
-pub fn get_vpr128(vpr: __m128i) -> u128 {
+fn get_vpr128(vpr: __m128i) -> u128 {
     unsafe { std::mem::transmute::<__m128i, u128>(vpr) }
 }
 
@@ -565,8 +565,6 @@ pub fn mfc0(device: &mut device::Device, opcode: u32) {
             device::memory::AccessSize::Word,
         )
     }
-    device.rsp.cpu.cycle_counter += 4; // needed for DK64
-    device.rsp.cpu.sync_point = true;
 }
 
 pub fn mtc0(device: &mut device::Device, opcode: u32) {
@@ -592,7 +590,6 @@ pub fn mtc0(device: &mut device::Device, opcode: u32) {
             !device::rsp_interface::SP_STATUS_HALT; // set halt when event happens
         device.rsp.cpu.halted = true // the RSP can halt itself by setting SP_SET_HALT
     }
-    device.rsp.cpu.sync_point = true;
 }
 
 pub fn mfc2(device: &mut device::Device, opcode: u32) {
@@ -721,7 +718,7 @@ pub fn lsv(device: &mut device::Device, opcode: u32) {
         modify_vpr16(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
             element / 2,
-            (device.rsp.mem[(address & 0xFFF) as usize] as u16) << 8
+            ((device.rsp.mem[(address & 0xFFF) as usize] as u16) << 8)
                 | (device.rsp.mem[((address + 1) & 0xFFF) as usize] as u16),
         );
     } else {
@@ -745,13 +742,14 @@ pub fn llv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element % 4 == 0 {
+        let mut value = 0;
+        for i in 0..4 {
+            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u32) << (8 * (3 - i));
+        }
         modify_vpr32(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
             element / 4,
-            (device.rsp.mem[(address & 0xFFF) as usize] as u32) << (8 * 3)
-                | (device.rsp.mem[((address + 1) & 0xFFF) as usize] as u32) << (8 * 2)
-                | (device.rsp.mem[((address + 2) & 0xFFF) as usize] as u32) << 8
-                | (device.rsp.mem[((address + 3) & 0xFFF) as usize] as u32),
+            value,
         );
     } else {
         let end = std::cmp::min(element + 4, 16);
@@ -774,17 +772,14 @@ pub fn ldv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element % 8 == 0 {
+        let mut value = 0;
+        for i in 0..8 {
+            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u64) << (8 * (7 - i));
+        }
         modify_vpr64(
             &mut device.rsp.cpu.vpr[rt(opcode) as usize],
             element / 8,
-            (device.rsp.mem[(address & 0xFFF) as usize] as u64) << (8 * 7)
-                | (device.rsp.mem[((address + 1) & 0xFFF) as usize] as u64) << (8 * 6)
-                | (device.rsp.mem[((address + 2) & 0xFFF) as usize] as u64) << (8 * 5)
-                | (device.rsp.mem[((address + 3) & 0xFFF) as usize] as u64) << (8 * 4)
-                | (device.rsp.mem[((address + 4) & 0xFFF) as usize] as u64) << (8 * 3)
-                | (device.rsp.mem[((address + 5) & 0xFFF) as usize] as u64) << (8 * 2)
-                | (device.rsp.mem[((address + 6) & 0xFFF) as usize] as u64) << 8
-                | (device.rsp.mem[((address + 7) & 0xFFF) as usize] as u64),
+            value,
         );
     } else {
         let end = std::cmp::min(element + 8, 16);
@@ -807,25 +802,11 @@ pub fn lqv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element == 0 && address % 16 == 0 {
-        modify_vpr128(
-            &mut device.rsp.cpu.vpr[rt(opcode) as usize],
-            (device.rsp.mem[(address & 0xFFF) as usize] as u128) << (8 * 15)
-                | (device.rsp.mem[((address + 1) & 0xFFF) as usize] as u128) << (8 * 14)
-                | (device.rsp.mem[((address + 2) & 0xFFF) as usize] as u128) << (8 * 13)
-                | (device.rsp.mem[((address + 3) & 0xFFF) as usize] as u128) << (8 * 12)
-                | (device.rsp.mem[((address + 4) & 0xFFF) as usize] as u128) << (8 * 11)
-                | (device.rsp.mem[((address + 5) & 0xFFF) as usize] as u128) << (8 * 10)
-                | (device.rsp.mem[((address + 6) & 0xFFF) as usize] as u128) << (8 * 9)
-                | (device.rsp.mem[((address + 7) & 0xFFF) as usize] as u128) << (8 * 8)
-                | (device.rsp.mem[((address + 8) & 0xFFF) as usize] as u128) << (8 * 7)
-                | (device.rsp.mem[((address + 9) & 0xFFF) as usize] as u128) << (8 * 6)
-                | (device.rsp.mem[((address + 10) & 0xFFF) as usize] as u128) << (8 * 5)
-                | (device.rsp.mem[((address + 11) & 0xFFF) as usize] as u128) << (8 * 4)
-                | (device.rsp.mem[((address + 12) & 0xFFF) as usize] as u128) << (8 * 3)
-                | (device.rsp.mem[((address + 13) & 0xFFF) as usize] as u128) << (8 * 2)
-                | (device.rsp.mem[((address + 14) & 0xFFF) as usize] as u128) << 8
-                | (device.rsp.mem[((address + 15) & 0xFFF) as usize] as u128),
-        );
+        let mut value = 0;
+        for i in 0..16 {
+            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u128) << (8 * (15 - i));
+        }
+        modify_vpr128(&mut device.rsp.cpu.vpr[rt(opcode) as usize], value);
     } else {
         let end = std::cmp::min(16 + element - ((address & 15) as u8), 16);
         while element < end {
@@ -847,25 +828,11 @@ pub fn lrv(device: &mut device::Device, opcode: u32) {
     let mut element = 16u8.wrapping_sub(((address & 15) as u8).wrapping_sub(velement(opcode)));
     address &= !15;
     if element == 0 {
-        modify_vpr128(
-            &mut device.rsp.cpu.vpr[rt(opcode) as usize],
-            (device.rsp.mem[(address & 0xFFF) as usize] as u128) << (8 * 15)
-                | (device.rsp.mem[((address + 1) & 0xFFF) as usize] as u128) << (8 * 14)
-                | (device.rsp.mem[((address + 2) & 0xFFF) as usize] as u128) << (8 * 13)
-                | (device.rsp.mem[((address + 3) & 0xFFF) as usize] as u128) << (8 * 12)
-                | (device.rsp.mem[((address + 4) & 0xFFF) as usize] as u128) << (8 * 11)
-                | (device.rsp.mem[((address + 5) & 0xFFF) as usize] as u128) << (8 * 10)
-                | (device.rsp.mem[((address + 6) & 0xFFF) as usize] as u128) << (8 * 9)
-                | (device.rsp.mem[((address + 7) & 0xFFF) as usize] as u128) << (8 * 8)
-                | (device.rsp.mem[((address + 8) & 0xFFF) as usize] as u128) << (8 * 7)
-                | (device.rsp.mem[((address + 9) & 0xFFF) as usize] as u128) << (8 * 6)
-                | (device.rsp.mem[((address + 10) & 0xFFF) as usize] as u128) << (8 * 5)
-                | (device.rsp.mem[((address + 11) & 0xFFF) as usize] as u128) << (8 * 4)
-                | (device.rsp.mem[((address + 12) & 0xFFF) as usize] as u128) << (8 * 3)
-                | (device.rsp.mem[((address + 13) & 0xFFF) as usize] as u128) << (8 * 2)
-                | (device.rsp.mem[((address + 14) & 0xFFF) as usize] as u128) << 8
-                | (device.rsp.mem[((address + 15) & 0xFFF) as usize] as u128),
-        );
+        let mut value = 0;
+        for i in 0..16 {
+            value |= (device.rsp.mem[((address + i) & 0xFFF) as usize] as u128) << (8 * (15 - i));
+        }
+        modify_vpr128(&mut device.rsp.cpu.vpr[rt(opcode) as usize], value);
     } else {
         while element < 16 {
             modify_vpr8(
@@ -885,35 +852,15 @@ pub fn lpv(device: &mut device::Device, opcode: u32) {
 
     let index = ((address & 7) as u8).wrapping_sub(velement(opcode));
     address &= !7;
-    unsafe {
-        device.rsp.cpu.vpr[rt(opcode) as usize] =
-            _mm_set_epi16(
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(0)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 8,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(1)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 8,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(2)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 8,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(3)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 8,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(4)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 8,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(5)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 8,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(6)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 8,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(7)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 8,
-            );
+    let mut value = 0;
+    for i in 0..8 {
+        value |= (((device.rsp.mem
+            [((address.wrapping_add(((index.wrapping_add(i)) & 15) as u32)) & 0xFFF) as usize]
+            as u16)
+            << 8) as u128)
+            << (16 * (7 - i));
     }
+    modify_vpr128(&mut device.rsp.cpu.vpr[rt(opcode) as usize], value);
 }
 
 pub fn luv(device: &mut device::Device, opcode: u32) {
@@ -922,35 +869,15 @@ pub fn luv(device: &mut device::Device, opcode: u32) {
 
     let index = ((address & 7) as u8).wrapping_sub(velement(opcode));
     address &= !7;
-    unsafe {
-        device.rsp.cpu.vpr[rt(opcode) as usize] =
-            _mm_set_epi16(
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(0)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(1)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(2)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(3)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(4)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(5)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(6)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(7)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-            );
+    let mut value = 0;
+    for i in 0..8 {
+        value |= (((device.rsp.mem
+            [((address.wrapping_add(((index.wrapping_add(i)) & 15) as u32)) & 0xFFF) as usize]
+            as u16)
+            << 7) as u128)
+            << (16 * (7 - i));
     }
+    modify_vpr128(&mut device.rsp.cpu.vpr[rt(opcode) as usize], value);
 }
 
 pub fn lhv(device: &mut device::Device, opcode: u32) {
@@ -959,35 +886,15 @@ pub fn lhv(device: &mut device::Device, opcode: u32) {
 
     let index = ((address & 7) as u8).wrapping_sub(velement(opcode));
     address &= !7;
-    unsafe {
-        device.rsp.cpu.vpr[rt(opcode) as usize] =
-            _mm_set_epi16(
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(0)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(2)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(4)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(6)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(8)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(10)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(12)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-                (device.rsp.mem[((address.wrapping_add(((index.wrapping_add(14)) & 15) as u32))
-                    & 0xFFF) as usize] as i16)
-                    << 7,
-            );
+    let mut value = 0;
+    for i in 0..8 {
+        value |= (((device.rsp.mem
+            [((address.wrapping_add(((index.wrapping_add(i * 2)) & 15) as u32)) & 0xFFF) as usize]
+            as u16)
+            << 7) as u128)
+            << (16 * (7 - i));
     }
+    modify_vpr128(&mut device.rsp.cpu.vpr[rt(opcode) as usize], value);
 }
 
 pub fn lfv(device: &mut device::Device, opcode: u32) {
@@ -1074,10 +981,10 @@ pub fn ssv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element % 2 == 0 {
-        device.rsp.mem[(address & 0xFFF) as usize..((address + 2) & 0xFFF) as usize]
-            .copy_from_slice(
-                &get_vpr16(device.rsp.cpu.vpr[rt(opcode) as usize], element / 2).to_be_bytes(),
-            );
+        let start = (address & 0xFFF) as usize;
+        device.rsp.mem[start..start + 2].copy_from_slice(
+            &get_vpr16(device.rsp.cpu.vpr[rt(opcode) as usize], element / 2).to_be_bytes(),
+        );
     } else {
         let end = element + 2;
         while element < end {
@@ -1096,10 +1003,10 @@ pub fn slv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element % 4 == 0 {
-        device.rsp.mem[(address & 0xFFF) as usize..((address + 4) & 0xFFF) as usize]
-            .copy_from_slice(
-                &get_vpr32(device.rsp.cpu.vpr[rt(opcode) as usize], element / 4).to_be_bytes(),
-            );
+        let start = (address & 0xFFF) as usize;
+        device.rsp.mem[start..start + 4].copy_from_slice(
+            &get_vpr32(device.rsp.cpu.vpr[rt(opcode) as usize], element / 4).to_be_bytes(),
+        );
     } else {
         let end = element + 4;
         while element < end {
@@ -1118,10 +1025,10 @@ pub fn sdv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element % 8 == 0 {
-        device.rsp.mem[(address & 0xFFF) as usize..((address + 8) & 0xFFF) as usize]
-            .copy_from_slice(
-                &get_vpr64(device.rsp.cpu.vpr[rt(opcode) as usize], element / 8).to_be_bytes(),
-            );
+        let start = (address & 0xFFF) as usize;
+        device.rsp.mem[start..start + 8].copy_from_slice(
+            &get_vpr64(device.rsp.cpu.vpr[rt(opcode) as usize], element / 8).to_be_bytes(),
+        );
     } else {
         let end = element + 8;
         while element < end {
@@ -1140,7 +1047,8 @@ pub fn sqv(device: &mut device::Device, opcode: u32) {
     let mut element = velement(opcode);
 
     if element == 0 && address % 16 == 0 {
-        device.rsp.mem[(address & 0xFFF) as usize..((address + 16) & 0xFFF) as usize]
+        let start = (address & 0xFFF) as usize;
+        device.rsp.mem[start..start + 16]
             .copy_from_slice(&get_vpr128(device.rsp.cpu.vpr[rt(opcode) as usize]).to_be_bytes());
     } else {
         let end = element + (16 - (address & 15)) as u8;
@@ -1163,7 +1071,8 @@ pub fn srv(device: &mut device::Device, opcode: u32) {
     address &= !15;
 
     if element == 0 && base == 0 {
-        device.rsp.mem[(address & 0xFFF) as usize..((address + 16) & 0xFFF) as usize]
+        let start = (address & 0xFFF) as usize;
+        device.rsp.mem[start..start + 16]
             .copy_from_slice(&get_vpr128(device.rsp.cpu.vpr[rt(opcode) as usize]).to_be_bytes());
     } else {
         while element < end {

src/device/rsp_vu_instructions.rs

@@ -9,41 +9,41 @@ use crate::device::rsp_su_instructions::{get_vpr16, modify_vpr16};
 #[cfg(target_arch = "x86_64")]
 use std::arch::x86_64::*;
 
-pub fn vt(opcode: u32) -> u32 {
+fn vt(opcode: u32) -> u32 {
     (opcode >> 16) & 0x1F
 }
 
-pub fn ve(opcode: u32) -> u32 {
+fn ve(opcode: u32) -> u32 {
     (opcode >> 21) & 0xF
 }
 
-pub fn vs(opcode: u32) -> u32 {
+fn vs(opcode: u32) -> u32 {
     (opcode >> 11) & 0x1F
 }
 
-pub fn vd(opcode: u32) -> u32 {
+fn vd(opcode: u32) -> u32 {
     (opcode >> 6) & 0x1F
 }
 
-pub fn de(opcode: u32) -> u32 {
+fn de(opcode: u32) -> u32 {
     (opcode >> 11) & 0x7
 }
 
-pub fn clamp_signed_32(value: i32) -> i16 {
+fn clamp_signed_32(value: i32) -> i16 {
     value.clamp(-32768, 32767) as i16
 }
 
-pub fn clamp_signed_64(value: i64) -> i16 {
+fn clamp_signed_64(value: i64) -> i16 {
     value.clamp(-32768, 32767) as i16
 }
 
-pub fn s_clip(x: i64, bits: u32) -> i64 {
+fn s_clip(x: i64, bits: u32) -> i64 {
     let b = 1_u64 << (bits - 1);
     let m = b * 2 - 1;
     ((((x as u64) & m) ^ b).wrapping_sub(b)) as i64
 }
 
-pub fn vte(device: &device::Device, vt: u32, index: usize) -> __m128i {
+fn vte(device: &device::Device, vt: u32, index: usize) -> __m128i {
     unsafe {
         _mm_shuffle_epi8(
             device.rsp.cpu.vpr[vt as usize],

src/device/si.rs

@@ -34,7 +34,7 @@ pub fn read_regs(
     device.si.regs[((address & 0xFFFF) >> 2) as usize]
 }
 
-pub fn dma_read(device: &mut device::Device) {
+fn dma_read(device: &mut device::Device) {
     device.si.dma_dir = DmaDir::Read;
 
     let duration = device::pif::update_pif_ram(device);
@@ -49,7 +49,7 @@ pub fn dma_read(device: &mut device::Device) {
     )
 }
 
-pub fn dma_write(device: &mut device::Device) {
+fn dma_write(device: &mut device::Device) {
     device.si.dma_dir = DmaDir::Write;
 
     copy_pif_rdram(device);
@@ -78,7 +78,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
 }
 
 //rdram is in native endian format, and pif memory is in big endian format
-pub fn copy_pif_rdram(device: &mut device::Device) {
+fn copy_pif_rdram(device: &mut device::Device) {
     let dram_addr = device.si.regs[SI_DRAM_ADDR_REG as usize] as usize & device::rdram::RDRAM_MASK;
     if device.si.dma_dir == DmaDir::Write {
         let mut i = 0;

src/device/sram.rs

@@ -2,8 +2,8 @@ use crate::device;
 use crate::ui;
 
 const SRAM_MASK: usize = 0xFFFF;
-const SRAM_SIZE: usize = 0x8000;
-const FLASHRAM_SIZE: usize = 0x20000;
+pub const SRAM_SIZE: usize = 0x8000;
+pub const FLASHRAM_SIZE: usize = 0x20000;
 pub const FLASHRAM_TYPE_ID: u32 = 0x11118001;
 pub const MX29L1100_ID: u32 = 0x00c2001e;
 const MX29L0000_ID: u32 = 0x00c20000;
@@ -27,19 +27,19 @@ pub struct Flashram {
     pub silicon_id: [u32; 2],
 }
 
-pub fn format_sram(device: &mut device::Device) {
+fn format_sram(device: &mut device::Device) {
     if device.ui.saves.sram.0.len() < SRAM_SIZE {
         device.ui.saves.sram.0.resize(SRAM_SIZE, 0xFF)
     }
 }
 
-pub fn format_flash(device: &mut device::Device) {
+fn format_flash(device: &mut device::Device) {
     if device.ui.saves.flash.0.len() < FLASHRAM_SIZE {
         device.ui.saves.flash.0.resize(FLASHRAM_SIZE, 0xFF)
     }
 }
 
-pub fn read_mem_sram(device: &mut device::Device, address: u64) -> u32 {
+fn read_mem_sram(device: &mut device::Device, address: u64) -> u32 {
     let masked_address = address as usize & SRAM_MASK;
 
     format_sram(device);
@@ -51,7 +51,7 @@ pub fn read_mem_sram(device: &mut device::Device, address: u64) -> u32 {
     )
 }
 
-pub fn read_mem_flash(device: &device::Device, address: u64) -> u32 {
+fn read_mem_flash(device: &device::Device, address: u64) -> u32 {
     if (address & 0x1ffff) == 0x00000 && device.flashram.mode == FlashramMode::Status {
         /* read Status register */
         device.flashram.status
@@ -80,7 +80,7 @@ pub fn read_mem(
     }
 }
 
-pub fn write_mem_sram(device: &mut device::Device, address: u64, value: u32, mask: u32) {
+fn write_mem_sram(device: &mut device::Device, address: u64, value: u32, mask: u32) {
     let masked_address = address as usize & SRAM_MASK;
 
     format_sram(device);
@@ -96,7 +96,7 @@ pub fn write_mem_sram(device: &mut device::Device, address: u64, value: u32, mas
     device.ui.saves.sram.1 = true
 }
 
-pub fn write_mem_flash(device: &mut device::Device, address: u64, value: u32, mask: u32) {
+fn write_mem_flash(device: &mut device::Device, address: u64, value: u32, mask: u32) {
     if (address & 0x1ffff) == 0x00000 && device.flashram.mode == FlashramMode::Status {
         /* clear/set Status register */
         device.flashram.status = (value & mask) & 0xff;
@@ -128,12 +128,7 @@ pub fn write_mem(device: &mut device::Device, address: u64, value: u32, mask: u3
     );
 }
 
-pub fn dma_read_sram(
-    device: &mut device::Device,
-    mut cart_addr: u32,
-    mut dram_addr: u32,
-    length: u32,
-) {
+fn dma_read_sram(device: &mut device::Device, mut cart_addr: u32, mut dram_addr: u32, length: u32) {
     dram_addr &= device::rdram::RDRAM_MASK as u32;
     cart_addr &= SRAM_MASK as u32;
     let mut i = dram_addr;
@@ -150,7 +145,7 @@ pub fn dma_read_sram(
     device.ui.saves.sram.1 = true
 }
 
-pub fn dma_read_flash(device: &mut device::Device, cart_addr: u32, dram_addr: u32, length: u32) {
+fn dma_read_flash(device: &mut device::Device, cart_addr: u32, dram_addr: u32, length: u32) {
     format_flash(device);
 
     if (cart_addr & 0x1ffff) == 0x00000
@@ -178,7 +173,7 @@ pub fn dma_read(device: &mut device::Device, cart_addr: u32, dram_addr: u32, len
     device::pi::calculate_cycles(device, 2, length)
 }
 
-pub fn dma_write_sram(
+fn dma_write_sram(
     device: &mut device::Device,
     mut cart_addr: u32,
     mut dram_addr: u32,
@@ -198,7 +193,7 @@ pub fn dma_write_sram(
     }
 }
 
-pub fn dma_write_flash(
+fn dma_write_flash(
     device: &mut device::Device,
     mut cart_addr: u32,
     mut dram_addr: u32,
@@ -251,7 +246,7 @@ pub fn dma_write(device: &mut device::Device, cart_addr: u32, dram_addr: u32, le
     device::pi::calculate_cycles(device, 2, length)
 }
 
-pub fn flashram_command(device: &mut device::Device, command: u32) {
+fn flashram_command(device: &mut device::Device, command: u32) {
     match command & 0xff000000 {
         0x3c000000 => {
             /* set chip erase mode */

src/device/tlb.rs

@@ -145,7 +145,7 @@ pub fn probe(device: &mut device::Device) {
     }
 }
 
-pub fn tlb_unmap(device: &mut device::Device, index: u64) {
+fn tlb_unmap(device: &mut device::Device, index: u64) {
     let e = &mut device.cpu.cop0.tlb_entries[index as usize];
 
     if e.v_even != 0 {
@@ -183,7 +183,7 @@ pub fn tlb_unmap(device: &mut device::Device, index: u64) {
     }
 }
 
-pub fn tlb_map(device: &mut device::Device, index: u64) {
+fn tlb_map(device: &mut device::Device, index: u64) {
     let e = &mut device.cpu.cop0.tlb_entries[index as usize];
 
     if e.v_even != 0

src/device/vi.rs

@@ -1,4 +1,5 @@
 use crate::device;
+use crate::netplay;
 use crate::ui;
 use governor::clock::Clock;
 
@@ -32,7 +33,7 @@ pub struct Vi {
 
 const LIMIT_BUFFER: u64 = 3;
 
-pub fn set_expected_refresh_rate(device: &mut device::Device) {
+fn set_expected_refresh_rate(device: &mut device::Device) {
     let expected_refresh_rate = device.vi.clock as f64
         / (device.vi.regs[VI_V_SYNC_REG as usize] + 1) as f64
         / ((device.vi.regs[VI_H_SYNC_REG as usize] & 0xFFF) + 1) as f64
@@ -48,7 +49,7 @@ pub fn set_expected_refresh_rate(device: &mut device::Device) {
     device.vi.limiter = Some(governor::RateLimiter::direct(quota))
 }
 
-pub fn set_vertical_interrupt(device: &mut device::Device) {
+fn set_vertical_interrupt(device: &mut device::Device) {
     if device::events::get_event(device, device::events::EventType::VI).is_none() {
         device::events::create_event(
             device,
@@ -59,7 +60,7 @@ pub fn set_vertical_interrupt(device: &mut device::Device) {
     }
 }
 
-pub fn set_current_line(device: &mut device::Device) {
+fn set_current_line(device: &mut device::Device) {
     let delay = device.vi.delay;
     let next_vi = device::events::get_event(device, device::events::EventType::VI);
     if next_vi.is_some() {
@@ -115,7 +116,7 @@ pub fn write_regs(device: &mut device::Device, address: u64, value: u32, mask: u
     ui::video::set_register(reg as u32, device.vi.regs[reg as usize])
 }
 
-pub fn vertical_interrupt_event(device: &mut device::Device) {
+fn vertical_interrupt_event(device: &mut device::Device) {
     device.cpu.running = ui::video::update_screen();
 
     /*
@@ -124,8 +125,14 @@ pub fn vertical_interrupt_event(device: &mut device::Device) {
         }
     */
 
+    let mut enable_speed_limiter = true;
+    if device.netplay.is_some() {
+        netplay::send_sync_check(device);
+        enable_speed_limiter = !device.netplay.as_ref().unwrap().fast_forward;
+    }
+
     device.vi.vi_counter += 1;
-    if device.vi.vi_counter % LIMIT_BUFFER == 0 {
+    if device.vi.vi_counter % LIMIT_BUFFER == 0 && enable_speed_limiter {
         speed_limiter(device);
     }
 
@@ -162,7 +169,7 @@ pub fn init(device: &mut device::Device) {
     */
 }
 
-pub fn speed_limiter(device: &device::Device) {
+fn speed_limiter(device: &device::Device) {
     let result = device.vi.limiter.as_ref().unwrap().check();
     if result.is_err() {
         let outcome = result.unwrap_err();

src/main.rs

@@ -1,8 +1,13 @@
+#![deny(warnings)]
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")] // hide console window on Windows in release
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
 mod device;
+mod netplay;
 mod ui;
 use clap::Parser;
+use ui::gui;
 
 /// N64 emulator
 #[derive(Parser, Debug)]
@@ -18,6 +23,12 @@ struct Args {
         help = "Create a new input profile (keyboard/gamepad mappings)."
     )]
     configure_input_profile: Option<String>,
+    #[arg(
+        short,
+        long,
+        help = "Use DirectInput when configuring a new input profile."
+    )]
+    use_dinput: bool,
     #[arg(
         short,
         long,
@@ -37,7 +48,7 @@ struct Args {
         value_name = "CONTROLLER_NUMBER",
         help = "Must also specify --port. Used to assign a controller listed in --list-controllers to a port"
     )]
-    assign_controller: Option<u32>,
+    assign_controller: Option<i32>,
     #[arg(
         short,
         long,
@@ -54,35 +65,21 @@ struct Args {
 }
 
 fn main() {
-    let exe_path = std::env::current_exe().unwrap();
-    let portable_dir = exe_path.parent();
-    let portable = portable_dir.unwrap().join("portable.txt").exists();
-    let config_dir;
-    let cache_dir;
-    let data_dir;
-    if portable {
-        config_dir = portable_dir.unwrap().join("portable_data").join("config");
-        cache_dir = portable_dir.unwrap().join("portable_data").join("cache");
-        data_dir = portable_dir.unwrap().join("portable_data").join("data");
-    } else {
-        config_dir = dirs::config_dir().unwrap().join("gopher64");
-        cache_dir = dirs::cache_dir().unwrap().join("gopher64");
-        data_dir = dirs::data_dir().unwrap().join("gopher64");
-    };
+    let dirs = ui::get_dirs();
 
-    let mut result = std::fs::create_dir_all(config_dir.clone());
+    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(cache_dir.clone());
+    result = std::fs::create_dir_all(dirs.cache_dir.clone());
     if result.is_err() {
         panic!("could not create cache dir: {}", result.err().unwrap())
     }
-    result = std::fs::create_dir_all(data_dir.clone().join("saves"));
+    result = std::fs::create_dir_all(dirs.data_dir.join("saves"));
     if result.is_err() {
         panic!("could not create data dir: {}", result.err().unwrap())
     }
-    let running_file = cache_dir.join("game_running");
+    let running_file = dirs.cache_dir.join("game_running");
     if running_file.exists() {
         result = std::fs::remove_file(running_file);
         if result.is_err() {
@@ -94,7 +91,7 @@ fn main() {
     let args_as_strings: Vec<String> = std::env::args().collect();
     let args_count = args_as_strings.len();
     if args_count > 1 {
-        let mut device = device::Device::new(config_dir);
+        let mut device = device::Device::new();
 
         if args.clear_input_bindings {
             ui::input::clear_bindings(&mut device.ui);
@@ -108,7 +105,10 @@ fn main() {
             }
         }
         if args.list_controllers {
-            ui::input::list_controllers(&device.ui);
+            let controllers = gui::get_controller_names(&device.ui);
+            for (i, controller) in controllers.iter().enumerate() {
+                println!("Controller {}: {}", i, controller);
+            }
             return;
         }
         if args.assign_controller.is_some() {
@@ -139,25 +139,46 @@ fn main() {
             ui::input::configure_input_profile(
                 &mut device.ui,
                 args.configure_input_profile.unwrap(),
+                args.use_dinput,
             );
             return;
         }
 
         if args.game.is_some() {
             let file_path = std::path::Path::new(args.game.as_ref().unwrap());
-            device::run_game(file_path, data_dir, &mut device, args.fullscreen);
+            let rom_contents = device::get_rom_contents(file_path);
+            if rom_contents.is_empty() {
+                println!("Could not read rom file");
+                return;
+            }
+            device::run_game(rom_contents, &mut device, args.fullscreen);
         }
     } else {
         let options = eframe::NativeOptions {
-            viewport: eframe::egui::ViewportBuilder::default().with_inner_size([640.0, 480.0]),
+            viewport: eframe::egui::ViewportBuilder::default()
+                .with_inner_size([640.0, 480.0])
+                .with_icon(
+                    eframe::icon_data::from_png_bytes(include_bytes!("../data/gopher64.png"))
+                        .unwrap(),
+                ),
             ..Default::default()
         };
+
+        let controllers_paths;
+        let controller_names;
+        {
+            let game_ui = ui::Ui::new();
+            controllers_paths = gui::get_controller_paths(&game_ui);
+            controller_names = gui::get_controller_names(&game_ui);
+        }
         eframe::run_native(
             "gopher64",
             options,
             Box::new(|cc| {
                 Ok(Box::new(ui::gui::GopherEguiApp::new(
-                    cc, config_dir, cache_dir, data_dir,
+                    cc,
+                    controllers_paths,
+                    controller_names,
                 )))
             }),
         )

src/netplay.rs

@@ -0,0 +1,330 @@
+use crate::device;
+use crate::ui;
+use eframe::egui;
+use std::io::{Read, Write};
+//UDP packet formats
+const UDP_SEND_KEY_INFO: u8 = 0;
+const UDP_RECEIVE_KEY_INFO: u8 = 1;
+const UDP_REQUEST_KEY_INFO: u8 = 2;
+const UDP_RECEIVE_KEY_INFO_GRATUITOUS: u8 = 3;
+const UDP_SYNC_DATA: u8 = 4;
+
+//TCP packet formats
+const TCP_SEND_SAVE: u8 = 1;
+//const TCP_RECEIVE_SAVE: u8 = 2;
+//const TCP_SEND_SETTINGS: u8 = 3;
+//const TCP_RECEIVE_SETTINGS: u8 = 4;
+const TCP_REGISTER_PLAYER: u8 = 5;
+const TCP_GET_REGISTRATION: u8 = 6;
+const TCP_DISCONNECT_NOTICE: u8 = 7;
+const TCP_RECEIVE_SAVE_WITH_SIZE: u8 = 8;
+
+const CS4: u32 = 32;
+
+pub struct Netplay {
+    udp_socket: std::net::UdpSocket,
+    tcp_stream: std::net::TcpStream,
+    pub player_number: u8,
+    pub player_data: [PlayerData; 4],
+    vi_counter: u32,
+    status: u8,
+    buffer_target: u8,
+    pub fast_forward: bool,
+    pub error_notifier: std::sync::mpsc::Sender<String>,
+    pub gui_ctx: egui::Context,
+}
+
+pub struct PlayerData {
+    lag: u8,
+    count: u32,
+    pub reg_id: u32,
+    input_events: std::collections::HashMap<u32, InputEvent>,
+}
+
+struct InputEvent {
+    input: u32,
+    plugin: u8,
+}
+
+fn send_error(netplay: &mut Netplay, error: String) {
+    netplay.error_notifier.send(error).unwrap();
+
+    netplay.gui_ctx.request_repaint(); // this is so the window pops up right away
+}
+
+pub fn send_save(netplay: &mut Netplay, save_type: &str, save_data: &[u8], size: usize) {
+    let mut request: Vec<u8> = [TCP_SEND_SAVE].to_vec();
+    request.extend_from_slice(save_type.as_bytes());
+    request.push(0); // null terminate string
+    request.extend_from_slice(&(size as u32).to_be_bytes());
+
+    if size > 0 {
+        request.extend(save_data.to_owned());
+    }
+    netplay.tcp_stream.write_all(&request).unwrap();
+}
+
+pub fn receive_save(netplay: &mut Netplay, save_type: &str, save_data: &mut Vec<u8>) {
+    let mut request: Vec<u8> = [TCP_RECEIVE_SAVE_WITH_SIZE].to_vec();
+    request.extend_from_slice(save_type.as_bytes());
+    request.push(0); // null terminate string
+    netplay.tcp_stream.write_all(&request).unwrap();
+
+    let mut size: [u8; 4] = [0; 4];
+    netplay.tcp_stream.read_exact(&mut size).unwrap();
+    let mut response: Vec<u8> = vec![0; u32::from_be_bytes(size) as usize];
+    netplay.tcp_stream.read_exact(&mut response).unwrap();
+    *save_data = response;
+}
+
+pub fn send_sync_check(device: &mut device::Device) {
+    let netplay = device.netplay.as_mut().unwrap();
+    if netplay.vi_counter % 600 == 0 {
+        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());
+        }
+
+        netplay.udp_socket.send(&request).unwrap();
+    }
+    netplay.vi_counter = netplay.vi_counter.wrapping_add(1);
+}
+
+pub fn send_input(netplay: &Netplay, input: (u32, bool)) {
+    let mut request: Vec<u8> = [UDP_SEND_KEY_INFO].to_vec();
+    request.push(netplay.player_number);
+    request.extend_from_slice(
+        &(netplay.player_data[netplay.player_number as usize].count).to_be_bytes(),
+    );
+    request.extend_from_slice(&(input.0).to_be_bytes());
+    request.push(input.1 as u8);
+    netplay.udp_socket.send(&request).unwrap();
+}
+
+pub fn get_input(device: &mut device::Device, channel: usize) -> (u32, bool) {
+    let netplay = device.netplay.as_mut().unwrap();
+    let mut input = None;
+
+    let timeout = std::time::Instant::now() + std::time::Duration::from_secs(10);
+    let mut request_timer = std::time::Instant::now() - std::time::Duration::from_millis(5);
+    while input.is_none() {
+        process_incoming(netplay); // we execute process_incoming before request_input so that we send an accurate buffer count
+        if std::time::Instant::now() > request_timer {
+            // sends a request packet every 5ms
+            request_input(netplay, channel);
+            request_timer = std::time::Instant::now() + std::time::Duration::from_millis(5);
+        }
+        input = netplay.player_data[channel]
+            .input_events
+            .remove(&netplay.player_data[channel].count);
+
+        if std::time::Instant::now() > timeout {
+            send_error(
+                netplay,
+                "Timed out waiting for input. Lost connection to server".to_string(),
+            );
+            input = Some(InputEvent {
+                input: 0,
+                plugin: 0,
+            });
+            device.cpu.running = false;
+        }
+    }
+
+    netplay.fast_forward = netplay.player_data[channel].lag > 0
+        && netplay.player_data[channel].input_events.len() as u8 > netplay.buffer_target;
+
+    netplay.player_data[channel].count = netplay.player_data[channel].count.wrapping_add(1);
+    (
+        input.as_ref().unwrap().input,
+        input.as_ref().unwrap().plugin != 0,
+    )
+}
+
+fn request_input(netplay: &Netplay, channel: usize) {
+    let mut request: Vec<u8> = [UDP_REQUEST_KEY_INFO].to_vec();
+    request.push(channel as u8); //The player we need input for
+    request.extend_from_slice(
+        &(netplay.player_data[netplay.player_number as usize].reg_id).to_be_bytes(),
+    );
+    request.extend_from_slice(&(netplay.player_data[channel].count).to_be_bytes());
+    request.push(0); //spectator mode
+    request.push(netplay.player_data[channel].input_events.len() as u8);
+    netplay.udp_socket.send(&request).unwrap();
+}
+
+fn process_incoming(netplay: &mut Netplay) {
+    let mut buf: [u8; 1024] = [0; 1024];
+    while let Ok(_incoming) = netplay.udp_socket.recv(&mut buf) {
+        match buf[0] {
+            UDP_RECEIVE_KEY_INFO | UDP_RECEIVE_KEY_INFO_GRATUITOUS => {
+                let player = buf[1] as usize;
+                //current_status is a status update from the server
+                //it will let us know if another player has disconnected, or the games have desynced
+                let current_status = buf[2];
+                if buf[0] == UDP_RECEIVE_KEY_INFO {
+                    netplay.player_data[player].lag = buf[3];
+                }
+                if current_status != netplay.status {
+                    if ((current_status & 0x1) ^ (netplay.status & 0x1)) != 0 {
+                        send_error(
+                            netplay,
+                            format!("Players have desynced at VI {}", netplay.vi_counter),
+                        );
+                    }
+                    for dis in 1..5 {
+                        if ((current_status & (0x1 << dis)) ^ (netplay.status & (0x1 << dis))) != 0
+                        {
+                            send_error(netplay, format!("Player {} has disconnected", dis));
+                        }
+                    }
+                    netplay.status = current_status;
+                }
+
+                let mut buffer_offset = 5;
+                for _i in 0..buf[4] {
+                    let count = u32::from_be_bytes(
+                        buf[buffer_offset..buffer_offset + 4].try_into().unwrap(),
+                    );
+                    buffer_offset += 4;
+
+                    if (count.wrapping_sub(netplay.player_data[player].count)) > (u32::MAX / 2) {
+                        //event doesn't need to be recorded
+                        buffer_offset += 5;
+                        continue;
+                    }
+
+                    let input = u32::from_be_bytes(
+                        buf[buffer_offset..buffer_offset + 4].try_into().unwrap(),
+                    );
+                    buffer_offset += 4;
+                    let plugin = buf[buffer_offset];
+                    buffer_offset += 1;
+                    let input_event = InputEvent { input, plugin };
+                    netplay.player_data[player]
+                        .input_events
+                        .insert(count, input_event);
+                }
+            }
+            _ => {
+                panic! {"unknown UDP packet"}
+            }
+        }
+    }
+}
+
+pub fn init(
+    mut peer_addr: std::net::SocketAddr,
+    session: ui::gui::gui_netplay::NetplayRoom,
+    player_number: u8,
+    error_notifier: std::sync::mpsc::Sender<String>,
+    gui_ctx: egui::Context,
+) -> Netplay {
+    peer_addr.set_port(session.port.unwrap() as u16);
+    let udp_socket;
+    if peer_addr.is_ipv4() {
+        udp_socket = std::net::UdpSocket::bind((std::net::Ipv4Addr::UNSPECIFIED, 0))
+            .expect("couldn't bind to address");
+        socket2::SockRef::from(&udp_socket)
+            .set_tos(CS4 << 2)
+            .unwrap();
+    } else {
+        udp_socket = std::net::UdpSocket::bind((std::net::Ipv6Addr::UNSPECIFIED, 0))
+            .expect("couldn't bind to address");
+        #[cfg(not(target_os = "windows"))]
+        socket2::SockRef::from(&udp_socket)
+            .set_tclass_v6(CS4 << 2)
+            .unwrap();
+    };
+
+    udp_socket.connect(peer_addr).unwrap();
+    udp_socket.set_nonblocking(true).unwrap();
+
+    let mut stream = std::net::TcpStream::connect(peer_addr).unwrap();
+
+    let regid = (player_number + 1) as u32;
+    let mut request: [u8; 8] = [
+        TCP_REGISTER_PLAYER,
+        player_number,
+        0, //plugin/pak
+        0, //rawdata
+        0, //regid (u32)
+        0, //regid (u32)
+        0, //regid (u32)
+        0, //regid (u32)
+    ];
+
+    request[4..8].copy_from_slice(&regid.to_be_bytes());
+    stream.write_all(&request).unwrap();
+
+    let mut response: [u8; 2] = [0, 0];
+    stream.read_exact(&mut response).unwrap();
+    if response[0] != 1 {
+        panic!("Failed to register player");
+    }
+    let buffer_target = response[1];
+
+    let request: [u8; 1] = [TCP_GET_REGISTRATION];
+    stream.write_all(&request).unwrap();
+    let mut response: [u8; 24] = [0; 24];
+    stream.read_exact(&mut response).unwrap();
+
+    let mut reg_id: [u32; 4] = [0; 4];
+    for i in 0..4 {
+        // reg_id of 0 means no player connected
+        reg_id[i] = u32::from_be_bytes(response[(i * 6)..(i * 6) + 4].try_into().unwrap());
+    }
+    Netplay {
+        udp_socket,
+        tcp_stream: stream,
+        player_number,
+        vi_counter: 0,
+        status: 0,
+        buffer_target,
+        fast_forward: false,
+        error_notifier,
+        gui_ctx,
+        player_data: [
+            PlayerData {
+                lag: 0,
+                count: 0,
+                reg_id: reg_id[0],
+                input_events: std::collections::HashMap::new(),
+            },
+            PlayerData {
+                lag: 0,
+                count: 0,
+                reg_id: reg_id[1],
+                input_events: std::collections::HashMap::new(),
+            },
+            PlayerData {
+                lag: 0,
+                count: 0,
+                reg_id: reg_id[2],
+                input_events: std::collections::HashMap::new(),
+            },
+            PlayerData {
+                lag: 0,
+                count: 0,
+                reg_id: reg_id[3],
+                input_events: std::collections::HashMap::new(),
+            },
+        ],
+    }
+}
+
+pub fn close(device: &mut device::Device) {
+    let netplay = device.netplay.as_mut().unwrap();
+    let regid = (netplay.player_number + 1) as u32;
+    let mut request: [u8; 5] = [TCP_DISCONNECT_NOTICE, 0, 0, 0, 0];
+    request[1..5].copy_from_slice(&regid.to_be_bytes());
+
+    netplay.tcp_stream.write_all(&request).unwrap();
+    netplay.tcp_stream.flush().unwrap();
+    netplay
+        .tcp_stream
+        .shutdown(std::net::Shutdown::Both)
+        .unwrap();
+}

src/ui.rs

@@ -6,75 +6,113 @@ pub mod storage;
 pub mod video;
 pub mod vru;
 
+pub struct Dirs {
+    pub config_dir: std::path::PathBuf,
+    pub cache_dir: std::path::PathBuf,
+    pub data_dir: std::path::PathBuf,
+}
+
 pub struct Ui {
+    pub dirs: Dirs,
+    pub keyboard_state: *const bool,
     pub controllers: [input::Controllers; 4],
-    pub config_file_path: std::path::PathBuf,
     pub config: config::Config,
     pub save_type: Vec<storage::SaveTypes>,
     pub game_id: String,
     pub game_hash: String,
     pub paths: storage::Paths,
     pub saves: storage::Saves,
-    pub sdl_context: Option<sdl2::Sdl>,
-    pub video_subsystem: Option<sdl2::VideoSubsystem>,
-    pub audio_subsystem: Option<sdl2::AudioSubsystem>,
-    pub joystick_subsystem: Option<sdl2::JoystickSubsystem>,
-    #[allow(dead_code)]
-    pub controller_subsystem: Option<sdl2::GameControllerSubsystem>,
-    pub window: Option<sdl2::video::Window>,
-    pub audio_device: Option<sdl2::audio::AudioQueue<i16>>,
+    pub pak_audio: audio::PakAudio,
+    pub window: *mut sdl3_sys::video::SDL_Window,
+    pub audio_stream: *mut sdl3_sys::audio::SDL_AudioStream,
+    pub pak_audio_stream: *mut sdl3_sys::audio::SDL_AudioStream,
+    pub audio_freq: f64,
+    pub audio_device: u32,
+    pub num_joysticks: i32,
+    pub joysticks: *mut sdl3_sys::joystick::SDL_JoystickID,
 }
 
 impl Drop for Ui {
     fn drop(&mut self) {
-        write_config(self);
+        unsafe {
+            sdl3_sys::stdinc::SDL_free(self.joysticks as *mut std::ffi::c_void);
+            sdl3_sys::init::SDL_Quit();
+        }
     }
 }
 
-fn write_config(ui: &Ui) {
-    let f = std::fs::File::create(ui.config_file_path.clone()).unwrap();
-    serde_json::to_writer_pretty(f, &ui.config).unwrap();
+pub fn sdl_init(flag: sdl3_sys::init::SDL_InitFlags) {
+    unsafe {
+        let init = sdl3_sys::init::SDL_WasInit(0);
+        if init & flag == 0 && !sdl3_sys::init::SDL_InitSubSystem(flag) {
+            let err = std::ffi::CStr::from_ptr(sdl3_sys::error::SDL_GetError())
+                .to_str()
+                .unwrap();
+            panic!("Could not initialize SDL subsystem: {}, {}", flag, err);
+        }
+    }
+}
+
+pub fn get_dirs() -> Dirs {
+    let exe_path = std::env::current_exe().unwrap();
+    let portable_dir = exe_path.parent();
+    let portable = portable_dir.unwrap().join("portable.txt").exists();
+    let config_dir;
+    let cache_dir;
+    let data_dir;
+    if portable {
+        config_dir = portable_dir.unwrap().join("portable_data").join("config");
+        cache_dir = portable_dir.unwrap().join("portable_data").join("cache");
+        data_dir = portable_dir.unwrap().join("portable_data").join("data");
+    } else {
+        config_dir = dirs::config_dir().unwrap().join("gopher64");
+        cache_dir = dirs::cache_dir().unwrap().join("gopher64");
+        data_dir = dirs::data_dir().unwrap().join("gopher64");
+    };
+
+    Dirs {
+        config_dir,
+        cache_dir,
+        data_dir,
+    }
 }
 
 impl Ui {
-    pub fn new(config_dir: std::path::PathBuf) -> Ui {
-        let sdl_context = sdl2::init().unwrap();
-        let video_subsystem = sdl_context.video().unwrap();
-        let audio_subsystem = sdl_context.audio().unwrap();
-        let joystick_subsystem = sdl_context.joystick().unwrap();
-        let controller_subsystem = sdl_context.game_controller().unwrap();
-
-        let config_file_path = config_dir.join("config.json");
-        let config_file = std::fs::read(config_file_path.clone());
-        let mut config_map = config::Config::new();
-        if config_file.is_ok() {
-            let result = serde_json::from_slice(config_file.unwrap().as_ref());
-            if result.is_ok() {
-                config_map = result.unwrap();
-            }
+    pub fn new() -> Ui {
+        sdl_init(sdl3_sys::init::SDL_INIT_GAMEPAD);
+        let mut num_joysticks = 0;
+        let joysticks = unsafe { sdl3_sys::joystick::SDL_GetJoysticks(&mut num_joysticks) };
+        if joysticks.is_null() {
+            panic!("Could not get joystick list");
         }
 
+        let dirs = get_dirs();
+
         Ui {
             controllers: [
                 input::Controllers {
-                    game_controller: None,
-                    joystick: None,
+                    game_controller: std::ptr::null_mut(),
+                    joystick: std::ptr::null_mut(),
+                    rumble: false,
                 },
                 input::Controllers {
-                    game_controller: None,
-                    joystick: None,
+                    game_controller: std::ptr::null_mut(),
+                    joystick: std::ptr::null_mut(),
+                    rumble: false,
                 },
                 input::Controllers {
-                    game_controller: None,
-                    joystick: None,
+                    game_controller: std::ptr::null_mut(),
+                    joystick: std::ptr::null_mut(),
+                    rumble: false,
                 },
                 input::Controllers {
-                    game_controller: None,
-                    joystick: None,
+                    game_controller: std::ptr::null_mut(),
+                    joystick: std::ptr::null_mut(),
+                    rumble: false,
                 },
             ],
-            config_file_path,
-            config: config_map,
+            keyboard_state: std::ptr::null_mut(),
+            config: config::Config::new(),
             save_type: vec![],
             game_id: String::new(),
             game_hash: String::new(),
@@ -90,15 +128,20 @@ impl Ui {
                 sram: (Vec::new(), false),
                 flash: (Vec::new(), false),
                 mempak: (Vec::new(), false),
-                romsave: (serde_json::Map::new(), false),
+                romsave: (std::collections::HashMap::new(), false),
             },
-            sdl_context: Some(sdl_context),
-            video_subsystem: Some(video_subsystem),
-            audio_subsystem: Some(audio_subsystem),
-            joystick_subsystem: Some(joystick_subsystem),
-            controller_subsystem: Some(controller_subsystem),
-            window: None,
-            audio_device: None,
+            pak_audio: audio::PakAudio {
+                mempak: include_bytes!("../data/mempak.wav").to_vec(),
+                rumblepak: include_bytes!("../data/rumblepak.wav").to_vec(),
+            },
+            window: std::ptr::null_mut(),
+            audio_stream: std::ptr::null_mut(),
+            pak_audio_stream: std::ptr::null_mut(),
+            audio_freq: 0.0,
+            audio_device: 0,
+            num_joysticks,
+            joysticks,
+            dirs,
         }
     }
 }

src/ui/audio.rs

@@ -1,24 +1,102 @@
 use crate::device;
 use crate::ui;
 
+pub struct PakAudio {
+    pub mempak: Vec<u8>,
+    pub rumblepak: Vec<u8>,
+}
+
 pub fn init(ui: &mut ui::Ui, frequency: u64) {
-    let desired_spec = sdl2::audio::AudioSpecDesired {
-        freq: Some(frequency as i32),
-        channels: Some(2),
-        samples: None,
+    ui::sdl_init(sdl3_sys::init::SDL_INIT_AUDIO);
+
+    let audio_spec = sdl3_sys::audio::SDL_AudioSpec {
+        format: sdl3_sys::audio::SDL_AUDIO_S16LE,
+        freq: frequency as i32,
+        channels: 2,
     };
-    ui.audio_device = Some(
-        ui.audio_subsystem
-            .as_mut()
-            .unwrap()
-            .open_queue::<i16, _>(None, &desired_spec)
-            .unwrap(),
-    );
-    ui.audio_device.as_mut().unwrap().resume();
+    ui.audio_device = unsafe {
+        sdl3_sys::audio::SDL_OpenAudioDevice(
+            sdl3_sys::audio::SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK,
+            &audio_spec,
+        )
+    };
+    if ui.audio_device == 0 {
+        panic!("Could not open audio device");
+    }
+
+    let mut dst = Default::default();
+    if !unsafe {
+        sdl3_sys::audio::SDL_GetAudioDeviceFormat(ui.audio_device, &mut dst, std::ptr::null_mut())
+    } {
+        panic!("Could not get audio device format");
+    }
+
+    ui.audio_stream = unsafe { sdl3_sys::audio::SDL_CreateAudioStream(&audio_spec, &dst) };
+    if ui.audio_stream.is_null() {
+        return;
+    }
+    if !unsafe { sdl3_sys::audio::SDL_BindAudioStream(ui.audio_device, ui.audio_stream) } {
+        panic!("Could not bind audio stream");
+    }
+
+    let wav_audio_spec = sdl3_sys::audio::SDL_AudioSpec {
+        format: sdl3_sys::audio::SDL_AUDIO_S16LE,
+        freq: 24000,
+        channels: 1,
+    };
+
+    ui.pak_audio_stream = unsafe { sdl3_sys::audio::SDL_CreateAudioStream(&wav_audio_spec, &dst) };
+    if !unsafe { sdl3_sys::audio::SDL_BindAudioStream(ui.audio_device, ui.pak_audio_stream) } {
+        panic!("Could not bind audio stream");
+    }
+
+    ui.audio_freq = audio_spec.freq as f64;
+}
+
+pub fn close(ui: &mut ui::Ui) {
+    unsafe {
+        if !ui.audio_stream.is_null() {
+            sdl3_sys::audio::SDL_DestroyAudioStream(ui.audio_stream);
+            ui.audio_stream = std::ptr::null_mut();
+        }
+        if !ui.pak_audio_stream.is_null() {
+            sdl3_sys::audio::SDL_DestroyAudioStream(ui.pak_audio_stream);
+            ui.pak_audio_stream = std::ptr::null_mut();
+        }
+        sdl3_sys::audio::SDL_CloseAudioDevice(ui.audio_device);
+        ui.audio_device = 0;
+    }
+}
+
+pub fn play_pak_switch(ui: &mut ui::Ui, pak: device::controller::PakType) {
+    if ui.pak_audio_stream.is_null() {
+        return;
+    }
+
+    let sound;
+    if pak == device::controller::PakType::RumblePak {
+        sound = &ui.pak_audio.rumblepak;
+    } else if pak == device::controller::PakType::MemPak {
+        sound = &ui.pak_audio.mempak;
+    } else {
+        return;
+    }
+    if !unsafe {
+        sdl3_sys::audio::SDL_PutAudioStreamData(
+            ui.pak_audio_stream,
+            sound.as_ptr() as *const std::ffi::c_void,
+            sound.len() as i32,
+        )
+    } {
+        panic!("Could not play audio");
+    }
 }
 
 pub fn play_audio(device: &mut device::Device, dram_addr: usize, length: u64) {
-    let audio_device = device.ui.audio_device.as_mut().unwrap();
+    if device.ui.audio_stream.is_null() {
+        return;
+    }
+
     let mut primary_buffer: Vec<i16> = vec![0; length as usize / 2];
     let mut i = 0;
     while i < length as usize / 2 {
@@ -32,16 +110,33 @@ pub fn play_audio(device: &mut device::Device, dram_addr: usize, length: u64) {
         i += 2;
     }
 
-    let audio_queued = audio_device.size() as f64;
-    let acceptable_latency = (audio_device.spec().freq as f64 * 0.2) * 4.0;
-    let min_latency = (audio_device.spec().freq as f64 * 0.02) * 4.0;
+    let audio_queued =
+        unsafe { sdl3_sys::audio::SDL_GetAudioStreamQueued(device.ui.audio_stream) } as f64;
+    let acceptable_latency = (device.ui.audio_freq * 0.2) * 4.0;
+    let min_latency = (device.ui.audio_freq * 0.02) * 4.0;
 
     if audio_queued < min_latency {
-        let silence_buffer: Vec<i16> = vec![0; ((min_latency - audio_queued) * 2.0) as usize & !1];
-        audio_device.queue_audio(&silence_buffer).unwrap();
+        let silence_buffer: Vec<u8> = vec![0; (min_latency - audio_queued) as usize & !3];
+        if !unsafe {
+            sdl3_sys::audio::SDL_PutAudioStreamData(
+                device.ui.audio_stream,
+                silence_buffer.as_ptr() as *const std::ffi::c_void,
+                silence_buffer.len() as i32,
+            )
+        } {
+            panic!("Could not play audio");
+        }
     }
 
-    if audio_queued < acceptable_latency {
-        audio_device.queue_audio(&primary_buffer).unwrap();
+    if audio_queued < acceptable_latency
+        && !unsafe {
+            sdl3_sys::audio::SDL_PutAudioStreamData(
+                device.ui.audio_stream,
+                primary_buffer.as_ptr() as *const std::ffi::c_void,
+                primary_buffer.len() as i32 * 2,
+            )
+        }
+    {
+        panic!("Could not play audio");
     }
 }

src/ui/config.rs

@@ -2,12 +2,13 @@ use crate::ui;
 
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct InputProfile {
-    pub keys: [(bool, i32); 18],
-    pub controller_buttons: [(bool, i32); 14],
-    pub controller_axis: [(bool, i32, i16); 18],
-    pub joystick_buttons: [(bool, u32); 14],
-    pub joystick_hat: [(bool, u32, u8); 14],
-    pub joystick_axis: [(bool, u32, i16); 18],
+    pub keys: [(bool, i32); ui::input::PROFILE_SIZE],
+    pub controller_buttons: [(bool, i32); ui::input::PROFILE_SIZE],
+    pub controller_axis: [(bool, i32, i16); ui::input::PROFILE_SIZE],
+    pub joystick_buttons: [(bool, i32); ui::input::PROFILE_SIZE],
+    pub joystick_hat: [(bool, i32, u8); ui::input::PROFILE_SIZE],
+    pub joystick_axis: [(bool, i32, i16); ui::input::PROFILE_SIZE],
+    pub dinput: bool,
 }
 
 #[derive(serde::Serialize, serde::Deserialize)]
@@ -21,6 +22,8 @@ pub struct Input {
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct Video {
     pub upscale: bool,
+    pub integer_scaling: bool,
+    pub fullscreen: bool,
 }
 #[derive(serde::Serialize, serde::Deserialize)]
 pub struct Config {
@@ -28,8 +31,30 @@ pub struct Config {
     pub video: Video,
 }
 
+impl Drop for Config {
+    fn drop(&mut self) {
+        write_config(self);
+    }
+}
+
+fn write_config(config: &Config) {
+    let dirs = ui::get_dirs();
+    let file_path = dirs.config_dir.join("config.json");
+    let f = std::fs::File::create(file_path).unwrap();
+    serde_json::to_writer_pretty(f, &config).unwrap();
+}
+
 impl Config {
     pub fn new() -> Config {
+        let dirs = ui::get_dirs();
+        let file_path = dirs.config_dir.join("config.json");
+        let config_file = std::fs::read(file_path);
+        if config_file.is_ok() {
+            let result = serde_json::from_slice(config_file.unwrap().as_ref());
+            if let Ok(result) = result {
+                return result;
+            }
+        }
         let mut input_profiles = std::collections::HashMap::new();
         input_profiles.insert("default".to_string(), ui::input::get_default_profile());
         Config {
@@ -45,7 +70,11 @@ impl Config {
                 controller_enabled: [true, false, false, false],
                 emulate_vru: false,
             },
-            video: Video { upscale: false },
+            video: Video {
+                upscale: false,
+                integer_scaling: false,
+                fullscreen: false,
+            },
         }
     }
 }

src/ui/gui.rs

@@ -1,253 +1,458 @@
 use crate::device;
+use crate::netplay;
 use crate::ui;
 use eframe::egui;
 
+pub mod gui_netplay;
+
 pub struct GopherEguiApp {
-    config_dir: std::path::PathBuf,
-    cache_dir: std::path::PathBuf,
-    data_dir: std::path::PathBuf,
+    dirs: ui::Dirs,
     configure_profile: bool,
     profile_name: String,
-    controllers: Vec<String>,
+    controller_names: Vec<String>,
     selected_controller: [i32; 4],
     selected_profile: [String; 4],
     input_profiles: Vec<String>,
     controller_enabled: [bool; 4],
+    controller_paths: Vec<String>,
     upscale: bool,
+    integer_scaling: bool,
+    fullscreen: bool,
     emulate_vru: bool,
+    dinput: bool,
     show_vru_dialog: bool,
     vru_window_receiver: Option<std::sync::mpsc::Receiver<Vec<String>>>,
+    netplay_error_receiver: Option<std::sync::mpsc::Receiver<String>>,
     vru_word_notifier: Option<std::sync::mpsc::Sender<String>>,
     vru_word_list: Vec<String>,
+    pub netplay: gui_netplay::GuiNetplay,
 }
 
-fn get_input_profiles(game_ui: &ui::Ui) -> Vec<String> {
+struct SaveConfig {
+    selected_controller: [i32; 4],
+    selected_profile: [String; 4],
+    controller_enabled: [bool; 4],
+    upscale: bool,
+    integer_scaling: bool,
+    fullscreen: bool,
+    emulate_vru: bool,
+}
+
+fn get_input_profiles(config: &ui::config::Config) -> Vec<String> {
     let mut profiles = vec![];
-    for key in game_ui.config.input.input_profiles.keys() {
-        profiles.push((*key).clone())
+    for key in config.input.input_profiles.keys() {
+        profiles.push(key.clone())
     }
     profiles
 }
 
-fn get_controllers(game_ui: &ui::Ui) -> Vec<String> {
+pub fn get_controller_names(game_ui: &ui::Ui) -> Vec<String> {
     let mut controllers: Vec<String> = vec![];
 
-    let joystick_subsystem = game_ui.joystick_subsystem.as_ref().unwrap();
-    let num_joysticks = joystick_subsystem.num_joysticks().unwrap();
-    for i in 0..num_joysticks {
-        controllers.push(joystick_subsystem.name_for_index(i).unwrap());
+    for offset in 0..game_ui.num_joysticks as isize {
+        let name = unsafe {
+            std::ffi::CStr::from_ptr(sdl3_sys::joystick::SDL_GetJoystickNameForID(
+                *(game_ui.joysticks.offset(offset)),
+            ))
+        };
+        controllers.push(name.to_string_lossy().to_string());
     }
+
     controllers
 }
 
+pub fn get_controller_paths(game_ui: &ui::Ui) -> Vec<String> {
+    let mut controller_paths: Vec<String> = vec![];
+
+    for offset in 0..game_ui.num_joysticks as isize {
+        let path = unsafe {
+            std::ffi::CStr::from_ptr(sdl3_sys::joystick::SDL_GetJoystickPathForID(
+                *(game_ui.joysticks.offset(offset)),
+            ))
+            .to_string_lossy()
+            .to_string()
+        };
+        controller_paths.push(path);
+    }
+
+    controller_paths
+}
+
 impl GopherEguiApp {
     pub fn new(
         cc: &eframe::CreationContext<'_>,
-        config_dir: std::path::PathBuf,
-        cache_dir: std::path::PathBuf,
-        data_dir: std::path::PathBuf,
+        controller_paths: Vec<String>,
+        controller_names: Vec<String>,
     ) -> GopherEguiApp {
         add_japanese_font(&cc.egui_ctx);
-        let game_ui = ui::Ui::new(config_dir.clone());
-        let joystick_subsystem = game_ui.joystick_subsystem.as_ref().unwrap();
-        let num_joysticks = joystick_subsystem.num_joysticks().unwrap();
-        let mut guids: Vec<String> = vec![];
-        for i in 0..num_joysticks {
-            guids.push(joystick_subsystem.device_guid(i).unwrap().to_string());
-        }
+        let config = ui::config::Config::new();
+
         let mut selected_controller = [-1, -1, -1, -1];
-        for (pos, item) in game_ui
-            .config
-            .input
-            .controller_assignment
-            .iter()
-            .enumerate()
-        {
+        for (pos, item) in config.input.controller_assignment.iter().enumerate() {
             if item.is_some() {
-                for (guid_pos, guid) in guids.iter().enumerate() {
-                    if item.as_deref().unwrap() == *guid {
-                        selected_controller[pos] = guid_pos as i32;
+                for (path_pos, path) in controller_paths.iter().enumerate() {
+                    if item.as_deref().unwrap() == *path {
+                        selected_controller[pos] = path_pos as i32;
                         break;
                     }
                 }
             }
         }
         GopherEguiApp {
-            cache_dir: cache_dir.clone(),
-            config_dir: config_dir.clone(),
-            data_dir: data_dir.clone(),
             configure_profile: false,
             profile_name: "".to_string(),
-            selected_profile: game_ui.config.input.input_profile_binding.clone(),
+            selected_profile: config.input.input_profile_binding.clone(),
             selected_controller,
-            controllers: get_controllers(&game_ui),
-            input_profiles: get_input_profiles(&game_ui),
-            controller_enabled: game_ui.config.input.controller_enabled,
-            upscale: game_ui.config.video.upscale,
-            emulate_vru: game_ui.config.input.emulate_vru,
+            controller_names,
+            input_profiles: get_input_profiles(&config),
+            controller_enabled: config.input.controller_enabled,
+            upscale: config.video.upscale,
+            integer_scaling: config.video.integer_scaling,
+            fullscreen: config.video.fullscreen,
+            emulate_vru: config.input.emulate_vru,
             show_vru_dialog: false,
+            dinput: false,
+            controller_paths,
+            netplay_error_receiver: None,
             vru_window_receiver: None,
             vru_word_notifier: None,
             vru_word_list: Vec::new(),
+            netplay: Default::default(),
+            dirs: ui::get_dirs(),
         }
     }
 }
 
 fn save_config(
-    game_ui: &mut ui::Ui,
-    selected_controller: [i32; 4],
-    selected_profile: [String; 4],
-    controller_enabled: [bool; 4],
-    upscale: bool,
-    emulate_vru: bool,
+    config: &mut ui::config::Config,
+    controller_paths: Vec<String>,
+    save_config_items: SaveConfig,
 ) {
-    let joystick_subsystem = game_ui.joystick_subsystem.as_ref().unwrap();
-    for (pos, item) in selected_controller.iter().enumerate() {
+    for (pos, item) in save_config_items.selected_controller.iter().enumerate() {
         if *item != -1 {
-            game_ui.config.input.controller_assignment[pos] = Some(
-                joystick_subsystem
-                    .device_guid(*item as u32)
-                    .unwrap()
-                    .to_string(),
-            );
+            config.input.controller_assignment[pos] =
+                Some(controller_paths[*item as usize].clone());
         } else {
-            game_ui.config.input.controller_assignment[pos] = None
+            config.input.controller_assignment[pos] = None
         }
     }
 
-    game_ui.config.input.input_profile_binding = selected_profile;
-    game_ui.config.input.controller_enabled = controller_enabled;
+    config.input.input_profile_binding = save_config_items.selected_profile;
+    config.input.controller_enabled = save_config_items.controller_enabled;
 
-    game_ui.config.video.upscale = upscale;
-    game_ui.config.input.emulate_vru = emulate_vru;
+    config.video.upscale = save_config_items.upscale;
+    config.video.integer_scaling = save_config_items.integer_scaling;
+    config.video.fullscreen = save_config_items.fullscreen;
+    config.input.emulate_vru = save_config_items.emulate_vru;
 }
 
 impl Drop for GopherEguiApp {
     fn drop(&mut self) {
-        let mut game_ui = ui::Ui::new(self.config_dir.clone());
+        let save_config_items = SaveConfig {
+            selected_controller: self.selected_controller,
+            selected_profile: self.selected_profile.clone(),
+            controller_enabled: self.controller_enabled,
+            upscale: self.upscale,
+            integer_scaling: self.integer_scaling,
+            fullscreen: self.fullscreen,
+            emulate_vru: self.emulate_vru,
+        };
+        let mut config = ui::config::Config::new();
         save_config(
-            &mut game_ui,
-            self.selected_controller,
-            self.selected_profile.clone(),
-            self.controller_enabled,
-            self.upscale,
-            self.emulate_vru,
+            &mut config,
+            self.controller_paths.clone(),
+            save_config_items,
         );
     }
 }
 
+fn configure_profile(app: &mut GopherEguiApp, ctx: &egui::Context) {
+    egui::Window::new("Configure Input Profile")
+        // .open(&mut self.configure_profile)
+        .show(ctx, |ui| {
+            ui.horizontal(|ui| {
+                let name_label = ui.label("Profile Name:");
+                ui.text_edit_singleline(&mut app.profile_name)
+                    .labelled_by(name_label.id);
+            });
+            ui.checkbox(&mut app.dinput, "Use DirectInput");
+            ui.horizontal(|ui| {
+                if ui.button("Configure Profile").clicked() {
+                    let profile_name = app.profile_name.clone();
+                    let dinput = app.dinput;
+                    std::thread::spawn(move || {
+                        if cfg!(target_os = "macos") {
+                            let mut command =
+                                std::process::Command::new(std::env::current_exe().unwrap());
+                            if dinput {
+                                command.arg("--use-dinput");
+                            }
+                            command.arg("--configure-input-profile");
+                            command.arg(profile_name);
+
+                            let status = command.status().expect("failed to execute process");
+                            if !status.success() {
+                                panic!("process exited with: {}", status);
+                            }
+                        } else {
+                            let mut game_ui = ui::Ui::new();
+                            ui::input::configure_input_profile(&mut game_ui, profile_name, dinput);
+                        }
+                    });
+                    app.configure_profile = false;
+                    if !app.profile_name.is_empty()
+                        && !app.input_profiles.contains(&app.profile_name)
+                    {
+                        app.input_profiles.push(app.profile_name.clone())
+                    }
+                };
+                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                    if ui.button("Close").clicked() {
+                        app.configure_profile = false
+                    };
+                })
+            });
+        });
+}
+
+fn show_vru_dialog(app: &mut GopherEguiApp, ctx: &egui::Context) {
+    ctx.show_viewport_immediate(
+        egui::ViewportId::from_hash_of("vru_dialog"),
+        egui::ViewportBuilder::default()
+            .with_title("What would you like to say?")
+            .with_always_on_top(),
+        |ctx, class| {
+            assert!(
+                class == egui::ViewportClass::Immediate,
+                "This egui backend doesn't support multiple viewports"
+            );
+            egui::CentralPanel::default().show(ctx, |ui| {
+                egui::Grid::new("vru_words").show(ui, |ui| {
+                    for (i, v) in app.vru_word_list.iter().enumerate() {
+                        if i % 5 == 0 {
+                            ui.end_row();
+                        }
+                        if ui.button((*v).to_string()).clicked() {
+                            app.vru_word_notifier
+                                .as_ref()
+                                .unwrap()
+                                .send(v.clone())
+                                .unwrap();
+                            app.show_vru_dialog = false;
+                        }
+                    }
+                });
+            });
+
+            if ctx.input(|i| i.viewport().close_requested()) {
+                app.vru_word_notifier
+                    .as_ref()
+                    .unwrap()
+                    .send(String::from(""))
+                    .unwrap();
+                app.show_vru_dialog = false;
+            }
+        },
+    );
+}
+
+pub fn open_rom(app: &mut GopherEguiApp, ctx: &egui::Context) {
+    let netplay;
+
+    let selected_controller = app.selected_controller;
+    let selected_profile = app.selected_profile.clone();
+    let controller_enabled = app.controller_enabled;
+    let upscale = app.upscale;
+    let integer_scaling = app.integer_scaling;
+    let fullscreen = app.fullscreen;
+    let emulate_vru = app.emulate_vru;
+    let peer_addr;
+    let session;
+    let player_number;
+    let cache_dir = app.dirs.cache_dir.clone();
+    let controller_paths = app.controller_paths.clone();
+
+    if app.netplay.player_name.is_empty() {
+        netplay = false;
+        peer_addr = None;
+        session = None;
+        player_number = None;
+    } else {
+        netplay = true;
+        peer_addr = app.netplay.peer_addr;
+        session = app.netplay.waiting_session.clone();
+        player_number = Some(app.netplay.player_number);
+    }
+
+    let (netplay_error_notifier, netplay_error_receiver): (
+        std::sync::mpsc::Sender<String>,
+        std::sync::mpsc::Receiver<String>,
+    ) = std::sync::mpsc::channel();
+
+    let (vru_window_notifier, vru_window_receiver): (
+        std::sync::mpsc::Sender<Vec<String>>,
+        std::sync::mpsc::Receiver<Vec<String>>,
+    ) = std::sync::mpsc::channel();
+
+    let (vru_word_notifier, vru_word_receiver): (
+        std::sync::mpsc::Sender<String>,
+        std::sync::mpsc::Receiver<String>,
+    ) = std::sync::mpsc::channel();
+
+    if netplay {
+        app.netplay_error_receiver = Some(netplay_error_receiver);
+    }
+    if emulate_vru && !netplay {
+        app.vru_window_receiver = Some(vru_window_receiver);
+        app.vru_word_notifier = Some(vru_word_notifier);
+    } else {
+        app.vru_window_receiver = None;
+        app.vru_word_notifier = None;
+    }
+
+    let rom_contents = app.netplay.rom_contents.clone();
+    let gui_ctx = ctx.clone();
+    std::thread::spawn(move || {
+        let file = if !netplay {
+            rfd::FileDialog::new().pick_file()
+        } else {
+            None
+        };
+
+        let save_config_items = SaveConfig {
+            selected_controller,
+            selected_profile,
+            controller_enabled,
+            upscale,
+            integer_scaling,
+            fullscreen,
+            emulate_vru,
+        };
+
+        if cfg!(target_os = "macos") && file.is_some() {
+            // mac os requires the process to be started on the main thread
+            // this means that netplay and VRU emulation will not work on mac os
+            {
+                let mut config = ui::config::Config::new();
+                save_config(&mut config, controller_paths, save_config_items);
+            }
+            let mut command = std::process::Command::new(std::env::current_exe().unwrap());
+            if fullscreen {
+                command.arg("--fullscreen");
+            }
+            command.arg(file.unwrap().as_path());
+
+            let status = command.status().expect("failed to execute process");
+            if !status.success() {
+                panic!("process exited with: {}", status);
+            }
+        } else if file.is_some() || netplay {
+            let running_file = cache_dir.join("game_running");
+            if running_file.exists() {
+                println!("Game already running");
+                return;
+            }
+            let result = std::fs::File::create(running_file.clone());
+            if result.is_err() {
+                panic!("could not create running file: {}", result.err().unwrap())
+            }
+
+            let mut device = device::Device::new();
+            save_config(&mut device.ui.config, controller_paths, save_config_items);
+
+            if netplay {
+                device.netplay = Some(netplay::init(
+                    peer_addr.unwrap(),
+                    session.unwrap(),
+                    player_number.unwrap(),
+                    netplay_error_notifier,
+                    gui_ctx,
+                ));
+                device::run_game(rom_contents, &mut device, fullscreen);
+                netplay::close(&mut device);
+            } else {
+                if emulate_vru {
+                    device.vru.window_notifier = Some(vru_window_notifier);
+                    device.vru.word_receiver = Some(vru_word_receiver);
+                    device.vru.gui_ctx = Some(gui_ctx);
+                }
+
+                let rom_contents = device::get_rom_contents(file.unwrap().as_path());
+                if rom_contents.is_empty() {
+                    println!("Could not read rom file");
+                } else {
+                    device::run_game(rom_contents, &mut device, fullscreen);
+                }
+            }
+            let result = std::fs::remove_file(running_file);
+            if result.is_err() {
+                panic!("could not remove running file: {}", result.err().unwrap())
+            }
+        }
+    });
+}
+
 impl eframe::App for GopherEguiApp {
     fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        if self.netplay.create {
+            gui_netplay::netplay_create(self, ctx);
+        }
+
+        if self.netplay.join {
+            gui_netplay::netplay_join(self, ctx);
+        }
+
+        if self.netplay.wait {
+            gui_netplay::netplay_wait(self, ctx);
+        }
+
+        if self.netplay_error_receiver.is_some() {
+            let result = self.netplay_error_receiver.as_ref().unwrap().try_recv();
+            if result.is_ok() {
+                self.netplay.error = result.unwrap();
+            }
+        }
+
+        if !self.netplay.error.is_empty() {
+            gui_netplay::netplay_error(self, ctx, self.netplay.error.clone());
+        }
+
         if self.configure_profile {
-            egui::Window::new("Configure Input Profile")
-                // .open(&mut self.configure_profile)
-                .show(ctx, |ui| {
-                    ui.horizontal(|ui| {
-                        let name_label = ui.label("Profile Name: ");
-                        ui.text_edit_singleline(&mut self.profile_name)
-                            .labelled_by(name_label.id);
-                    });
-                    ui.horizontal(|ui| {
-                        if ui.button("Configure Profile").clicked() {
-                            let profile_name = self.profile_name.clone();
-                            let config_dir = self.config_dir.clone();
-                            execute(async {
-                                let mut game_ui = ui::Ui::new(config_dir);
-                                ui::input::configure_input_profile(&mut game_ui, profile_name);
-                            });
-                            self.configure_profile = false;
-                            if !self.profile_name.is_empty()
-                                && !self.input_profiles.contains(&self.profile_name)
-                            {
-                                self.input_profiles.push(self.profile_name.clone())
-                            }
-                        };
-                        if ui.button("Close").clicked() {
-                            self.configure_profile = false
-                        };
-                    });
-                });
+            configure_profile(self, ctx);
         }
 
         egui::CentralPanel::default().show(ctx, |ui| {
             if self.configure_profile {
                 ui.disable()
             }
+            egui::Grid::new("button_grid")
+                .min_col_width(200.0)
+                .show(ui, |ui| {
+                    if ui.button("Open ROM").clicked() {
+                        open_rom(self, ctx);
+                    }
+                    if !cfg!(target_os = "macos")
+                        && ui.button("Netplay: Create Session").clicked()
+                        && !self.dirs.cache_dir.join("game_running").exists()
+                    {
+                        self.netplay.create = true;
+                    }
 
-            if ui.button("Open ROM").clicked() {
-                // Spawn dialog on main thread
-                let task = rfd::AsyncFileDialog::new().pick_file();
-                let selected_controller = self.selected_controller;
-                let selected_profile = self.selected_profile.clone();
-                let controller_enabled = self.controller_enabled;
-                let upscale = self.upscale;
-                let emulate_vru = self.emulate_vru;
-                let config_dir = self.config_dir.clone();
-                let cache_dir = self.cache_dir.clone();
-                let data_dir = self.data_dir.clone();
+                    ui.end_row();
 
-                let (vru_window_notifier, vru_window_receiver): (
-                    std::sync::mpsc::Sender<Vec<String>>,
-                    std::sync::mpsc::Receiver<Vec<String>>,
-                ) = std::sync::mpsc::channel();
+                    if ui.button("Configure Input Profile").clicked()
+                        && !self.dirs.cache_dir.join("game_running").exists()
+                    {
+                        self.configure_profile = true;
+                    }
 
-                let (vru_word_notifier, vru_word_receiver): (
-                    std::sync::mpsc::Sender<String>,
-                    std::sync::mpsc::Receiver<String>,
-                ) = std::sync::mpsc::channel();
-
-                if emulate_vru {
-                    self.vru_window_receiver = Some(vru_window_receiver);
-                    self.vru_word_notifier = Some(vru_word_notifier);
-                }
-
-                let gui_ctx = ctx.clone();
-                execute(async move {
-                    let file = task.await;
-
-                    if let Some(file) = file {
-                        let running_file = cache_dir.join("game_running");
-                        if running_file.exists() {
-                            return;
-                        }
-                        let result = std::fs::File::create(running_file.clone());
-                        if result.is_err() {
-                            panic!("could not create running file: {}", result.err().unwrap())
-                        }
-                        let mut device = device::Device::new(config_dir);
-                        save_config(
-                            &mut device.ui,
-                            selected_controller,
-                            selected_profile,
-                            controller_enabled,
-                            upscale,
-                            emulate_vru,
-                        );
-                        if emulate_vru {
-                            device.vru.window_notifier = Some(vru_window_notifier);
-                            device.vru.word_receiver = Some(vru_word_receiver);
-                            device.vru.gui_ctx = Some(gui_ctx);
-                        }
-                        device::run_game(
-                            std::path::Path::new(file.path()),
-                            data_dir,
-                            &mut device,
-                            false,
-                        );
-                        let result = std::fs::remove_file(running_file.clone());
-                        if result.is_err() {
-                            panic!("could not remove running file: {}", result.err().unwrap())
-                        }
+                    if !cfg!(target_os = "macos")
+                        && ui.button("Netplay: Join Session").clicked()
+                        && !self.dirs.cache_dir.join("game_running").exists()
+                    {
+                        self.netplay.join = true;
                     }
                 });
-            }
-
-            if ui.button("Configure Input Profile").clicked() {
-                if self.cache_dir.join("game_running").exists() {
-                    return;
-                }
-                self.configure_profile = true;
-            }
 
             ui.add_space(32.0);
             ui.label("Controller Config:");
@@ -276,7 +481,7 @@ impl eframe::App for GopherEguiApp {
                     let controller_text = if self.selected_controller[i] == -1 {
                         "None".to_string()
                     } else {
-                        self.controllers[self.selected_controller[i] as usize].clone()
+                        self.controller_names[self.selected_controller[i] as usize].clone()
                     };
                     egui::ComboBox::from_id_salt(format!("controller-combo-{}", i))
                         .selected_text(controller_text)
@@ -286,11 +491,11 @@ impl eframe::App for GopherEguiApp {
                                 -1,
                                 "None".to_string(),
                             );
-                            for j in 0..self.controllers.len() {
+                            for j in 0..self.controller_names.len() {
                                 ui.selectable_value(
                                     &mut self.selected_controller[i],
                                     j as i32,
-                                    self.controllers[j].clone(),
+                                    self.controller_names[j].clone(),
                                 );
                             }
                         });
@@ -299,10 +504,15 @@ impl eframe::App for GopherEguiApp {
             });
             ui.add_space(32.0);
             ui.checkbox(&mut self.upscale, "High-Res Graphics");
-            ui.checkbox(
-                &mut self.emulate_vru,
-                "Emulate VRU (connects VRU to controller port 4)",
-            );
+            ui.checkbox(&mut self.integer_scaling, "Integer Scaling");
+            ui.checkbox(&mut self.fullscreen, "Fullscreen (Esc closes game)");
+            ui.add_space(32.0);
+            if !cfg!(target_os = "macos") {
+                ui.checkbox(
+                    &mut self.emulate_vru,
+                    "Emulate VRU (connects VRU to controller port 4)",
+                );
+            }
             ui.add_space(32.0);
             ui.label(format!("Version: {}", env!("CARGO_PKG_VERSION")));
         });
@@ -316,52 +526,11 @@ impl eframe::App for GopherEguiApp {
         }
 
         if self.show_vru_dialog {
-            ctx.show_viewport_immediate(
-                egui::ViewportId::from_hash_of("vru_dialog"),
-                egui::ViewportBuilder::default()
-                    .with_title("What would you like to say?")
-                    .with_always_on_top(),
-                |ctx, class| {
-                    assert!(
-                        class == egui::ViewportClass::Immediate,
-                        "This egui backend doesn't support multiple viewports"
-                    );
-                    egui::CentralPanel::default().show(ctx, |ui| {
-                        egui::Grid::new("vru_words").show(ui, |ui| {
-                            for (i, v) in self.vru_word_list.iter().enumerate() {
-                                if i % 5 == 0 {
-                                    ui.end_row();
-                                }
-                                if ui.button((*v).to_string()).clicked() {
-                                    self.vru_word_notifier
-                                        .as_ref()
-                                        .unwrap()
-                                        .send(v.clone())
-                                        .unwrap();
-                                    self.show_vru_dialog = false;
-                                }
-                            }
-                        });
-                    });
-
-                    if ctx.input(|i| i.viewport().close_requested()) {
-                        self.vru_word_notifier
-                            .as_ref()
-                            .unwrap()
-                            .send(String::from(""))
-                            .unwrap();
-                        self.show_vru_dialog = false;
-                    }
-                },
-            );
+            show_vru_dialog(self, ctx);
         }
     }
 }
 
-fn execute<F: std::future::Future<Output = ()> + Send + 'static>(f: F) {
-    std::thread::spawn(move || futures::executor::block_on(f));
-}
-
 fn add_japanese_font(ctx: &egui::Context) {
     ctx.add_font(eframe::epaint::text::FontInsert::new(
         "japanese_font",

src/ui/gui/gui_netplay.rs

@@ -0,0 +1,879 @@
+use crate::device;
+use crate::ui::gui;
+use crate::ui::gui::GopherEguiApp;
+use eframe::egui;
+use sha2::{Digest, Sha256};
+
+const NETPLAY_VERSION: i32 = 17;
+const EMU_NAME: &str = "gopher64";
+
+type GameInfo = (String, String, String, Vec<u8>);
+
+#[derive(Default)]
+pub struct GuiNetplay {
+    pub create: bool,
+    pub join: bool,
+    pub wait: bool,
+    pub session_name: String,
+    pub password: String,
+    pub player_name: String,
+    pub error: String,
+    pub create_rom_label: String,
+    pub join_rom_label: String,
+    pub send_chat: bool,
+    pub have_sessions: Option<(String, String)>,
+    pub begin_game: bool,
+    pub chat_log: String,
+    pub chat_message: String,
+    pub selected_session: Option<NetplayRoom>,
+    pub pending_begin: bool,
+    pub peer_addr: Option<std::net::SocketAddr>,
+    pub motd: String,
+    pub sessions: Vec<NetplayRoom>,
+    pub rom_contents: Vec<u8>,
+    pub player_number: u8,
+    pub player_names: [String; 4],
+    pub server: (String, String),
+    pub socket_waiting: bool,
+    pub game_info: GameInfo,
+    pub servers: std::collections::HashMap<String, String>,
+    pub waiting_session: Option<NetplayRoom>,
+    pub socket:
+        Option<tungstenite::WebSocket<tungstenite::stream::MaybeTlsStream<std::net::TcpStream>>>,
+    pub server_receiver:
+        Option<std::sync::mpsc::Receiver<std::collections::HashMap<String, String>>>,
+    pub game_info_receiver: Option<std::sync::mpsc::Receiver<GameInfo>>,
+    pub broadcast_socket: Option<std::net::UdpSocket>,
+    pub broadcast_timer: Option<std::time::Instant>,
+}
+
+#[derive(serde::Serialize, serde::Deserialize, PartialEq, Default, Clone)]
+pub struct NetplayRoom {
+    room_name: Option<String>,
+    password: Option<String>,
+    protected: Option<bool>,
+    #[serde(rename = "MD5")]
+    md5: Option<String>,
+    game_name: Option<String>,
+    pub port: Option<i32>,
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct NetplayMessage {
+    #[serde(rename = "type")]
+    message_type: String,
+    player_name: Option<String>,
+    client_sha: Option<String>,
+    netplay_version: Option<i32>,
+    emulator: Option<String>,
+    room: Option<NetplayRoom>,
+    accept: Option<i32>,
+    message: Option<String>,
+    auth: Option<String>,
+    player_names: Option<[String; 4]>,
+    #[serde(rename = "authTime")]
+    auth_time: Option<String>,
+    rooms: Option<Vec<NetplayRoom>>,
+}
+
+fn get_servers(app: &mut GopherEguiApp, ctx: &egui::Context) {
+    if app.netplay.servers.is_empty() {
+        if app.netplay.broadcast_socket.is_none() {
+            app.netplay.broadcast_socket = Some(
+                std::net::UdpSocket::bind((std::net::Ipv4Addr::UNSPECIFIED, 0))
+                    .expect("couldn't bind to address"),
+            );
+            let socket = app.netplay.broadcast_socket.as_ref().unwrap();
+            socket
+                .set_broadcast(true)
+                .expect("set_broadcast call failed");
+            socket
+                .set_nonblocking(true)
+                .expect("could not set up socket");
+            let data: [u8; 1] = [1];
+            socket
+                .send_to(&data, (std::net::Ipv4Addr::BROADCAST, 45000))
+                .expect("couldn't send data");
+            app.netplay.broadcast_timer =
+                Some(std::time::Instant::now() + std::time::Duration::from_secs(5));
+            ctx.request_repaint();
+        }
+        if app.netplay.server_receiver.is_none() {
+            let (tx, rx) = std::sync::mpsc::channel();
+            app.netplay.server_receiver = Some(rx);
+            let gui_ctx = ctx.clone();
+            std::thread::spawn(move || {
+                if let Ok(response) =
+                    reqwest::blocking::get("https://m64p.s3.amazonaws.com/servers.json")
+                        .unwrap()
+                        .json::<std::collections::HashMap<String, String>>()
+                {
+                    tx.send(response).unwrap();
+                    gui_ctx.request_repaint();
+                }
+            });
+        }
+    }
+    if app.netplay.broadcast_timer.is_some()
+        && std::time::Instant::now() > app.netplay.broadcast_timer.unwrap()
+    {
+        app.netplay.broadcast_timer = None;
+    }
+    if app.netplay.broadcast_socket.is_some() && app.netplay.broadcast_timer.is_some() {
+        let mut buffer = [0; 1024];
+        let result = app
+            .netplay
+            .broadcast_socket
+            .as_ref()
+            .unwrap()
+            .recv_from(&mut buffer);
+        if result.is_ok() {
+            let (amt, _src) = result.unwrap();
+            let data: std::collections::HashMap<String, String> =
+                serde_json::from_slice(&buffer[..amt]).unwrap();
+            for server in data.iter() {
+                let (server_name, server_ip) = server;
+                app.netplay
+                    .servers
+                    .insert(server_name.to_string(), server_ip.to_string());
+                app.netplay.server = (server.0.clone(), server.1.clone());
+            }
+            app.netplay.broadcast_socket = None;
+        }
+        ctx.request_repaint();
+    }
+    if app.netplay.server_receiver.is_some() {
+        let result = app.netplay.server_receiver.as_ref().unwrap().try_recv();
+        if result.is_ok() {
+            app.netplay.servers.extend(result.unwrap());
+            app.netplay.server_receiver = None;
+            if app.netplay.server.0.is_empty() {
+                let first_server = app.netplay.servers.iter().next().unwrap();
+                app.netplay.server = (first_server.0.clone(), first_server.1.clone());
+            }
+        }
+        ctx.request_repaint();
+    }
+}
+
+pub fn netplay_create(app: &mut GopherEguiApp, ctx: &egui::Context) {
+    egui::Window::new("Create Netplay Session").show(ctx, |ui| {
+        egui::Grid::new("netplay_create_grid").show(ui, |ui| {
+            let profile_name_label = ui.label("Session Name:");
+            let mut size = ui.spacing().interact_size;
+            size.x = 200.0;
+            ui.add_sized(size, |ui: &mut egui::Ui| {
+                ui.text_edit_singleline(&mut app.netplay.session_name)
+                    .labelled_by(profile_name_label.id)
+            });
+
+            ui.end_row();
+
+            let password_label = ui.label("Password (Optional):");
+
+            ui.text_edit_singleline(&mut app.netplay.password)
+                .labelled_by(password_label.id);
+
+            ui.end_row();
+
+            ui.label("ROM");
+            if app.netplay.create_rom_label.is_empty() {
+                app.netplay.create_rom_label = "Open ROM".to_string();
+            }
+            if ui.button(&app.netplay.create_rom_label).clicked() {
+                let (tx, rx) = std::sync::mpsc::channel();
+                app.netplay.game_info_receiver = Some(rx);
+                let gui_ctx = ctx.clone();
+                app.netplay.create_rom_label = "Inspecting ROM".to_string();
+                std::thread::spawn(move || {
+                    let file = rfd::FileDialog::new().pick_file();
+
+                    if let Some(file) = file {
+                        parse_rom_file(file, tx);
+                    } else {
+                        tx.send((
+                            "".to_string(),
+                            "".to_string(),
+                            "Open ROM".to_string(),
+                            vec![],
+                        ))
+                        .unwrap();
+                    }
+                    gui_ctx.request_repaint();
+                });
+            }
+
+            ui.end_row();
+
+            let player_name_label = ui.label("Player Name:");
+
+            ui.text_edit_singleline(&mut app.netplay.player_name)
+                .labelled_by(player_name_label.id);
+
+            ui.end_row();
+
+            ui.label("Server:");
+
+            get_servers(app, ctx);
+
+            if app.netplay.game_info_receiver.is_some() {
+                let result = app.netplay.game_info_receiver.as_ref().unwrap().try_recv();
+                if result.is_ok() {
+                    app.netplay.game_info_receiver = None;
+                    let data = result.unwrap();
+                    if !data.0.is_empty() {
+                        app.netplay.game_info = data;
+                        app.netplay.rom_contents = app.netplay.game_info.3.clone();
+                        app.netplay.create_rom_label = app.netplay.game_info.2.clone();
+                    } else {
+                        app.netplay.create_rom_label = data.2;
+                    }
+                }
+                ctx.request_repaint();
+            }
+
+            egui::ComboBox::from_id_salt("server-combobox")
+                .selected_text(app.netplay.server.0.to_string())
+                .show_ui(ui, |ui| {
+                    for server in app.netplay.servers.iter() {
+                        ui.selectable_value(
+                            &mut app.netplay.server,
+                            (server.0.clone(), server.1.clone()),
+                            server.0,
+                        );
+                    }
+                });
+
+            ui.end_row();
+
+            if app.netplay.socket_waiting {
+                let data = app.netplay.socket.as_mut().unwrap().read();
+                if data.is_ok() {
+                    let message: NetplayMessage =
+                        serde_json::from_slice(&data.unwrap().into_data()).unwrap();
+                    if message.accept.unwrap() == 0 {
+                        if message.message_type == "reply_create_room" {
+                            app.netplay.create = false;
+                            app.netplay.wait = true;
+                            app.netplay.waiting_session = Some(message.room.unwrap());
+                        }
+                    } else {
+                        app.netplay.error = message.message.unwrap();
+                    }
+                    app.netplay.socket_waiting = false;
+                }
+                ctx.request_repaint();
+            }
+        });
+        ui.horizontal(|ui| {
+            if ui.button("Create Session").clicked() {
+                if app.netplay.player_name.is_empty() {
+                    app.netplay.error = "Player Name cannot be empty".to_string();
+                } else if app.netplay.session_name.is_empty() {
+                    app.netplay.error = "Session Name cannot be empty".to_string();
+                } else if app.netplay.game_info.0.is_empty() {
+                    app.netplay.error = "ROM not loaded".to_string();
+                } else {
+                    let now_utc = chrono::Utc::now().timestamp_millis().to_string();
+                    let hasher = Sha256::new().chain_update(&now_utc).chain_update(EMU_NAME);
+                    let mut game_name = app.netplay.game_info.1.to_string();
+                    if game_name.is_empty() {
+                        // If the ROM doesn't report a name, use the filename
+                        game_name = app.netplay.create_rom_label.clone();
+                    }
+                    let netplay_message = NetplayMessage {
+                        message_type: "request_create_room".to_string(),
+                        player_name: Some(app.netplay.player_name.clone()),
+                        client_sha: Some(env!("CARGO_PKG_VERSION").to_string()),
+                        netplay_version: Some(NETPLAY_VERSION),
+                        emulator: Some(EMU_NAME.to_string()),
+                        accept: None,
+                        message: None,
+                        rooms: None,
+                        auth_time: Some(now_utc),
+                        player_names: None,
+                        auth: Some(format!("{:x}", hasher.finalize())),
+                        room: Some(NetplayRoom {
+                            room_name: Some(app.netplay.session_name.clone()),
+                            password: Some(app.netplay.password.clone()),
+                            game_name: Some(game_name),
+                            md5: Some(app.netplay.game_info.0.clone()),
+                            protected: None,
+                            port: None,
+                        }),
+                    };
+                    let (mut socket, _response) =
+                        tungstenite::connect(&app.netplay.server.1).expect("Can't connect");
+                    socket
+                        .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
+                            serde_json::to_vec(&netplay_message).unwrap(),
+                        )))
+                        .unwrap();
+                    match socket.get_mut() {
+                        tungstenite::stream::MaybeTlsStream::Plain(stream) => {
+                            app.netplay.peer_addr = Some(stream.peer_addr().unwrap());
+                            stream.set_nonblocking(true)
+                        }
+                        _ => unimplemented!(),
+                    }
+                    .expect("could not set socket to non-blocking");
+                    app.netplay.socket_waiting = true;
+                    app.netplay.socket = Some(socket);
+                }
+            }
+
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                if ui.button("Close").clicked() {
+                    if let Some(socket) = app.netplay.socket.as_mut() {
+                        socket.close(None).unwrap();
+                        loop {
+                            match socket.read() {
+                                Err(tungstenite::Error::ConnectionClosed) => break,
+                                _ => continue,
+                            };
+                        }
+                    }
+                    app.netplay = Default::default();
+                };
+            })
+        });
+    });
+}
+
+fn get_sessions(app: &mut GopherEguiApp, ctx: &egui::Context) {
+    if app.netplay.have_sessions.is_some()
+        && app.netplay.server != *app.netplay.have_sessions.as_ref().unwrap()
+    {
+        // User has changed the server
+        app.netplay.have_sessions = None;
+        app.netplay.socket = None;
+    }
+    if app.netplay.socket.is_none() {
+        let (mut sock, _response) =
+            tungstenite::connect(&app.netplay.server.1).expect("Can't connect");
+        match sock.get_mut() {
+            tungstenite::stream::MaybeTlsStream::Plain(stream) => {
+                app.netplay.peer_addr = Some(stream.peer_addr().unwrap());
+                stream.set_nonblocking(true)
+            }
+            _ => unimplemented!(),
+        }
+        .expect("could not set socket to non-blocking");
+        app.netplay.socket = Some(sock);
+    }
+    let socket = app.netplay.socket.as_mut().unwrap();
+    if app.netplay.have_sessions.is_none() {
+        let now_utc = chrono::Utc::now().timestamp_millis().to_string();
+        let hasher = Sha256::new().chain_update(&now_utc).chain_update(EMU_NAME);
+        let request_rooms = NetplayMessage {
+            message_type: "request_get_rooms".to_string(),
+            player_name: None,
+            client_sha: None,
+            netplay_version: Some(NETPLAY_VERSION),
+            player_names: None,
+            emulator: Some(EMU_NAME.to_string()),
+            accept: None,
+            rooms: None,
+            message: None,
+            auth_time: Some(now_utc),
+            auth: Some(format!("{:x}", hasher.finalize())),
+            room: None,
+        };
+
+        socket
+            .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
+                serde_json::to_vec(&request_rooms).unwrap(),
+            )))
+            .unwrap();
+        app.netplay.have_sessions = Some(app.netplay.server.clone());
+        app.netplay.socket_waiting = true;
+        ctx.request_repaint();
+    }
+}
+
+fn parse_rom_file(file: std::path::PathBuf, tx: std::sync::mpsc::Sender<GameInfo>) {
+    let rom_contents = device::get_rom_contents(file.as_path());
+    if !rom_contents.is_empty() {
+        let hash = device::cart_rom::calculate_hash(&rom_contents);
+        let game_name = std::str::from_utf8(&rom_contents[0x20..0x20 + 0x14])
+            .unwrap()
+            .trim()
+            .replace('\0', "")
+            .to_string();
+        tx.send((
+            hash,
+            game_name,
+            file.file_name().unwrap().to_string_lossy().to_string(),
+            rom_contents,
+        ))
+        .unwrap();
+    } else {
+        tx.send((
+            "".to_string(),
+            "".to_string(),
+            "Invalid ROM".to_string(),
+            vec![],
+        ))
+        .unwrap();
+    }
+}
+
+pub fn netplay_join(app: &mut GopherEguiApp, ctx: &egui::Context) {
+    if app.netplay.socket_waiting {
+        let socket = app.netplay.socket.as_mut().unwrap();
+        let data = socket.read();
+        if data.is_ok() {
+            let message: NetplayMessage =
+                serde_json::from_slice(&data.unwrap().into_data()).unwrap();
+            if message.accept.unwrap() == 0 {
+                if message.message_type == "reply_get_rooms" {
+                    if message.rooms.is_some() {
+                        app.netplay.sessions = message.rooms.unwrap();
+                    }
+                } else if message.message_type == "reply_join_room" {
+                    app.netplay.join = false;
+                    app.netplay.wait = true;
+                    app.netplay.waiting_session = Some(message.room.unwrap());
+                }
+                app.netplay.socket_waiting = false;
+            } else {
+                app.netplay.error = message.message.unwrap();
+                app.netplay.join_rom_label = "Join Session (Open ROM)".to_string();
+            }
+        }
+        ctx.request_repaint();
+    }
+    if app.netplay.game_info_receiver.is_some() {
+        let result = app.netplay.game_info_receiver.as_ref().unwrap().try_recv();
+        if result.is_ok() {
+            app.netplay.game_info_receiver = None;
+            let data = result.unwrap();
+            if !data.0.is_empty() {
+                app.netplay.game_info = data;
+                app.netplay.rom_contents = app.netplay.game_info.3.clone();
+
+                let netplay_message = NetplayMessage {
+                    message_type: "request_join_room".to_string(),
+                    player_name: Some(app.netplay.player_name.clone()),
+                    client_sha: Some(env!("CARGO_PKG_VERSION").to_string()),
+                    netplay_version: None,
+                    emulator: None,
+                    accept: None,
+                    message: None,
+                    rooms: None,
+                    auth_time: None,
+                    player_names: None,
+                    auth: None,
+                    room: Some(NetplayRoom {
+                        room_name: None,
+                        password: Some(app.netplay.password.clone()),
+                        game_name: None,
+                        md5: Some(app.netplay.game_info.0.clone()),
+                        protected: None,
+                        port: app.netplay.selected_session.as_ref().unwrap().port,
+                    }),
+                };
+                let socket = app.netplay.socket.as_mut().unwrap();
+                socket
+                    .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
+                        serde_json::to_vec(&netplay_message).unwrap(),
+                    )))
+                    .unwrap();
+
+                app.netplay.socket_waiting = true;
+            } else {
+                app.netplay.error = data.2;
+                app.netplay.join_rom_label = "Join Session (Open ROM)".to_string();
+            }
+        }
+        ctx.request_repaint();
+    }
+    egui::Window::new("Join Netplay Session").show(ctx, |ui| {
+        ui.horizontal(|ui| {
+            let mut size = ui.spacing().interact_size;
+            size.x = 100.0;
+            ui.add_sized(
+                size,
+                egui::TextEdit::singleline(&mut app.netplay.player_name).hint_text("Player name"),
+            );
+
+            get_servers(app, ctx);
+
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                if ui.button("Refresh").clicked() {
+                    app.netplay.socket = None;
+                    app.netplay.have_sessions = None;
+                    app.netplay.selected_session = None;
+                    ctx.request_repaint();
+                }
+                egui::ComboBox::from_id_salt("server-combobox")
+                    .selected_text(app.netplay.server.0.to_string())
+                    .show_ui(ui, |ui| {
+                        for server in app.netplay.servers.iter() {
+                            ui.selectable_value(
+                                &mut app.netplay.server,
+                                (server.0.clone(), server.1.clone()),
+                                server.0,
+                            );
+                        }
+                    });
+            });
+        });
+        if !app.netplay.server.0.is_empty() {
+            get_sessions(app, ctx);
+        }
+        ui.add_space(16.0);
+        if app.netplay.sessions.is_empty() {
+            ui.label("No sessions available");
+        } else {
+            egui::Grid::new("netplay_join_grid").show(ui, |ui| {
+                ui.label(egui::RichText::new("Session Name (click to select)").underline());
+                ui.label(egui::RichText::new("Game Name").underline());
+                ui.label(egui::RichText::new("Password Protected").underline());
+                ui.end_row();
+
+                for room in app.netplay.sessions.iter() {
+                    ui.selectable_value(
+                        &mut app.netplay.selected_session,
+                        Some(room.clone()),
+                        room.room_name.as_ref().unwrap(),
+                    );
+                    ui.label(room.game_name.as_ref().unwrap());
+                    ui.label(room.protected.unwrap_or(false).to_string());
+                    ui.end_row();
+                }
+            });
+        }
+        ui.add_space(16.0);
+        ui.horizontal(|ui| {
+            let mut size = ui.spacing().interact_size;
+            size.x = 130.0;
+            ui.add_sized(
+                size,
+                egui::TextEdit::singleline(&mut app.netplay.password)
+                    .hint_text("Password (if required)"),
+            );
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                if ui.button("Close").clicked() {
+                    if let Some(socket) = app.netplay.socket.as_mut() {
+                        socket.close(None).unwrap();
+                        loop {
+                            match socket.read() {
+                                Err(tungstenite::Error::ConnectionClosed) => break,
+                                _ => continue,
+                            };
+                        }
+                    }
+                    app.netplay = Default::default();
+                };
+                if app.netplay.join_rom_label.is_empty() {
+                    app.netplay.join_rom_label = "Join Session (Open ROM)".to_string();
+                }
+                if ui.button(&app.netplay.join_rom_label).clicked() {
+                    if app.netplay.player_name.is_empty() {
+                        app.netplay.error = "Player Name cannot be empty".to_string();
+                    } else if app.netplay.selected_session.is_none() {
+                        app.netplay.error = "No session selected".to_string();
+                    } else if app
+                        .netplay
+                        .selected_session
+                        .as_ref()
+                        .unwrap()
+                        .protected
+                        .unwrap()
+                        && app.netplay.password.is_empty()
+                    {
+                        app.netplay.error = "Session requires a password".to_string();
+                    } else {
+                        let (tx, rx) = std::sync::mpsc::channel();
+                        app.netplay.game_info_receiver = Some(rx);
+                        let gui_ctx = ctx.clone();
+                        app.netplay.join_rom_label = "Inspecting ROM".to_string();
+                        std::thread::spawn(move || {
+                            let file = rfd::FileDialog::new().pick_file();
+
+                            if let Some(file) = file {
+                                parse_rom_file(file, tx);
+                            } else {
+                                tx.send((
+                                    "".to_string(),
+                                    "".to_string(),
+                                    "No ROM selected".to_string(),
+                                    vec![],
+                                ))
+                                .unwrap();
+                            }
+                            gui_ctx.request_repaint();
+                        });
+                    }
+                };
+            });
+        });
+    });
+}
+
+pub fn netplay_wait(app: &mut GopherEguiApp, ctx: &egui::Context) {
+    let motd_message = NetplayMessage {
+        message_type: "request_motd".to_string(),
+        player_name: None,
+        client_sha: None,
+        netplay_version: None,
+        emulator: None,
+        accept: None,
+        rooms: None,
+        player_names: None,
+        message: None,
+        auth_time: None,
+        auth: None,
+        room: None,
+    };
+    let request_players = NetplayMessage {
+        message_type: "request_players".to_string(),
+        player_name: None,
+        client_sha: None,
+        netplay_version: None,
+        player_names: None,
+        emulator: None,
+        rooms: None,
+        accept: None,
+        message: None,
+        auth_time: None,
+        auth: None,
+        room: Some(NetplayRoom {
+            room_name: None,
+            password: None,
+            game_name: None,
+            md5: None,
+            protected: None,
+            port: app.netplay.waiting_session.as_ref().unwrap().port,
+        }),
+    };
+
+    if !app.netplay.socket_waiting {
+        let socket = app.netplay.socket.as_mut().unwrap();
+        socket
+            .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
+                serde_json::to_vec(&motd_message).unwrap(),
+            )))
+            .unwrap();
+        socket
+            .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
+                serde_json::to_vec(&request_players).unwrap(),
+            )))
+            .unwrap();
+        app.netplay.socket_waiting = true;
+    }
+
+    if app.netplay.begin_game {
+        let begin_game = NetplayMessage {
+            message_type: "request_begin_game".to_string(),
+            player_name: None,
+            client_sha: None,
+            netplay_version: None,
+            player_names: None,
+            rooms: None,
+            emulator: None,
+            accept: None,
+            message: None,
+            auth_time: None,
+            auth: None,
+            room: Some(NetplayRoom {
+                room_name: None,
+                password: None,
+                game_name: None,
+                md5: None,
+                protected: None,
+                port: app.netplay.waiting_session.as_ref().unwrap().port,
+            }),
+        };
+        let socket = app.netplay.socket.as_mut().unwrap();
+        socket
+            .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
+                serde_json::to_vec(&begin_game).unwrap(),
+            )))
+            .unwrap();
+        app.netplay.begin_game = false;
+    }
+
+    if app.netplay.send_chat {
+        let send_chat = NetplayMessage {
+            message_type: "request_chat_message".to_string(),
+            player_name: Some(app.netplay.player_name.clone()),
+            client_sha: None,
+            netplay_version: None,
+            player_names: None,
+            rooms: None,
+            emulator: None,
+            accept: None,
+            message: Some(app.netplay.chat_message.clone()),
+            auth_time: None,
+            auth: None,
+            room: Some(NetplayRoom {
+                room_name: None,
+                password: None,
+                game_name: None,
+                md5: None,
+                protected: None,
+                port: app.netplay.waiting_session.as_ref().unwrap().port,
+            }),
+        };
+        app.netplay.chat_message.clear();
+        let socket = app.netplay.socket.as_mut().unwrap();
+        socket
+            .send(tungstenite::Message::Binary(tungstenite::Bytes::from(
+                serde_json::to_vec(&send_chat).unwrap(),
+            )))
+            .unwrap();
+        app.netplay.send_chat = false;
+    }
+
+    if app.netplay.socket_waiting {
+        let socket = app.netplay.socket.as_mut().unwrap();
+        let data = socket.read();
+        if data.is_ok() {
+            let message: NetplayMessage =
+                serde_json::from_slice(&data.unwrap().into_data()).unwrap();
+            if message.accept.unwrap() == 0 {
+                if message.message_type == "reply_motd" {
+                    let re = regex::Regex::new(r"<[^>]*>").unwrap();
+                    app.netplay.motd = re
+                        .replace_all(message.message.unwrap().as_str(), "")
+                        .into_owned();
+                } else if message.message_type == "reply_players" {
+                    app.netplay.player_names = message.player_names.unwrap();
+                } else if message.message_type == "reply_chat_message" {
+                    app.netplay.chat_log.push_str(&message.message.unwrap());
+                    app.netplay.chat_log.push('\n');
+                } else if message.message_type == "reply_begin_game" {
+                    let mut player = 0;
+                    for (i, name) in app.netplay.player_names.iter().enumerate() {
+                        if *name == app.netplay.player_name {
+                            player = i;
+                            break;
+                        }
+                    }
+                    app.netplay.player_number = player as u8;
+
+                    if message.accept.unwrap() == 0 {
+                        socket.close(None).unwrap();
+                        loop {
+                            match socket.read() {
+                                Err(tungstenite::Error::ConnectionClosed) => break,
+                                _ => continue,
+                            };
+                        }
+
+                        gui::open_rom(app, ctx);
+                        app.netplay = Default::default();
+                        return;
+                    } else {
+                        app.netplay.error = message.message.unwrap();
+                    }
+                }
+            } else {
+                app.netplay.error = message.message.unwrap();
+            }
+        }
+        ctx.request_repaint();
+    }
+
+    egui::Window::new("Pending Netplay Session").show(ctx, |ui| {
+        egui::Grid::new("netplay_wait_grid_1").show(ui, |ui| {
+            ui.label("Session Name:");
+            let room_name = app
+                .netplay
+                .waiting_session
+                .as_ref()
+                .unwrap()
+                .room_name
+                .as_ref()
+                .unwrap();
+            let game_name = app
+                .netplay
+                .waiting_session
+                .as_ref()
+                .unwrap()
+                .game_name
+                .as_ref()
+                .unwrap();
+            ui.label(room_name);
+            ui.end_row();
+            ui.label("Game Name:");
+            ui.label(game_name);
+            ui.end_row();
+            for i in 0..4 {
+                ui.label(format!("Player {}:", i + 1));
+                ui.label(app.netplay.player_names[i].clone());
+                ui.end_row();
+            }
+        });
+        egui::ScrollArea::vertical()
+            .max_height(100.0)
+            .stick_to_bottom(true)
+            .show(ui, |ui| {
+                ui.add(
+                    egui::TextEdit::multiline(&mut app.netplay.chat_log)
+                        .interactive(false)
+                        .desired_width(ui.available_width()),
+                );
+            });
+
+        ui.horizontal(|ui| {
+            let mut size = ui.spacing().interact_size;
+            size.x = 200.0;
+
+            ui.add_sized(
+                size,
+                egui::TextEdit::singleline(&mut app.netplay.chat_message)
+                    .hint_text("Enter chat message here"),
+            );
+
+            if ui
+                .add_enabled(!app.netplay.send_chat, egui::Button::new("Send Message"))
+                .clicked()
+                && !app.netplay.chat_message.is_empty()
+            {
+                app.netplay.send_chat = true;
+            }
+        });
+
+        ui.add_space(16.0);
+        ui.label(app.netplay.motd.clone());
+        ui.add_space(16.0);
+
+        ui.horizontal(|ui| {
+            let button_enabled = app.netplay.player_name == app.netplay.player_names[0]
+                && !app.netplay.pending_begin;
+            if ui
+                .add_enabled(button_enabled, egui::Button::new("Start Session"))
+                .clicked()
+            {
+                app.netplay.begin_game = true;
+                app.netplay.pending_begin = true;
+            }
+            ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+                if ui.button("Close").clicked() {
+                    if let Some(socket) = app.netplay.socket.as_mut() {
+                        socket.close(None).unwrap();
+                        loop {
+                            match socket.read() {
+                                Err(tungstenite::Error::ConnectionClosed) => break,
+                                _ => continue,
+                            };
+                        }
+                    }
+                    app.netplay = Default::default();
+                };
+            });
+        });
+    });
+}
+
+pub fn netplay_error(app: &mut GopherEguiApp, ctx: &egui::Context, error: String) {
+    egui::Window::new("Netplay Error").show(ctx, |ui| {
+        ui.label(error);
+        if ui.button("Close").clicked() {
+            app.netplay.error = "".to_string();
+        };
+    });
+}

src/ui/input.rs

@@ -16,22 +16,25 @@ const D_CBUTTON: usize = 10;
 const U_CBUTTON: usize = 11;
 const R_TRIG: usize = 12;
 const L_TRIG: usize = 13;
-const X_AXIS: usize = 16;
-const Y_AXIS: usize = 24;
-
 const AXIS_LEFT: usize = 14;
 const AXIS_RIGHT: usize = 15;
 const AXIS_UP: usize = 16;
 const AXIS_DOWN: usize = 17;
+const CHANGE_PAK: usize = 18;
+pub const PROFILE_SIZE: usize = 19;
+
+const X_AXIS_SHIFT: usize = 16;
+const Y_AXIS_SHIFT: usize = 24;
 
 const MAX_AXIS_VALUE: f64 = 85.0;
 
 pub struct Controllers {
-    pub game_controller: Option<sdl2::controller::GameController>,
-    pub joystick: Option<sdl2::joystick::Joystick>,
+    pub rumble: bool,
+    pub game_controller: *mut sdl3_sys::gamepad::SDL_Gamepad,
+    pub joystick: *mut sdl3_sys::joystick::SDL_Joystick,
 }
 
-pub fn bound_axis(x: &mut f64, y: &mut f64) {
+fn bound_axis(x: &mut f64, y: &mut f64) {
     let radius = 95.0; // this is roughly the maxium diagonal distance of the controller
 
     // Calculate the distance from the origin (0, 0)
@@ -45,32 +48,40 @@ pub fn bound_axis(x: &mut f64, y: &mut f64) {
     }
 }
 
-pub fn set_axis_from_joystick(
+fn set_axis_from_joystick(
     profile: &ui::config::InputProfile,
-    joystick: &sdl2::joystick::Joystick,
+    joystick: *mut sdl3_sys::joystick::SDL_Joystick,
 ) -> (f64, f64) {
     let mut x = 0.0;
     let mut y = 0.0;
     if profile.joystick_axis[AXIS_LEFT].0 {
-        let axis_position = joystick.axis(profile.joystick_axis[AXIS_LEFT].1).unwrap();
+        let axis_position = unsafe {
+            sdl3_sys::joystick::SDL_GetJoystickAxis(joystick, profile.joystick_axis[AXIS_LEFT].1)
+        };
         if axis_position as isize * profile.joystick_axis[AXIS_LEFT].2 as isize > 0 {
             x = axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64;
         }
     }
     if profile.joystick_axis[AXIS_RIGHT].0 {
-        let axis_position = joystick.axis(profile.joystick_axis[AXIS_RIGHT].1).unwrap();
+        let axis_position = unsafe {
+            sdl3_sys::joystick::SDL_GetJoystickAxis(joystick, profile.joystick_axis[AXIS_RIGHT].1)
+        };
         if axis_position as isize * profile.joystick_axis[AXIS_RIGHT].2 as isize > 0 {
             x = axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64;
         }
     }
     if profile.joystick_axis[AXIS_DOWN].0 {
-        let axis_position = joystick.axis(profile.joystick_axis[AXIS_DOWN].1).unwrap();
+        let axis_position = unsafe {
+            sdl3_sys::joystick::SDL_GetJoystickAxis(joystick, profile.joystick_axis[AXIS_DOWN].1)
+        };
         if axis_position as isize * profile.joystick_axis[AXIS_DOWN].2 as isize > 0 {
             y = (axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64).neg();
         }
     }
     if profile.joystick_axis[AXIS_UP].0 {
-        let axis_position = joystick.axis(profile.joystick_axis[AXIS_UP].1).unwrap();
+        let axis_position = unsafe {
+            sdl3_sys::joystick::SDL_GetJoystickAxis(joystick, profile.joystick_axis[AXIS_UP].1)
+        };
         if axis_position as isize * profile.joystick_axis[AXIS_UP].2 as isize > 0 {
             y = (axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64).neg();
         }
@@ -78,68 +89,85 @@ pub fn set_axis_from_joystick(
     (x, y)
 }
 
-fn get_axis_from_i32(axis: i32) -> sdl2::controller::Axis {
+fn get_axis_from_i32(axis: i32) -> sdl3_sys::gamepad::SDL_GamepadAxis {
     match axis {
-        0 => sdl2::controller::Axis::LeftX,
-        1 => sdl2::controller::Axis::LeftY,
-        2 => sdl2::controller::Axis::RightX,
-        3 => sdl2::controller::Axis::RightY,
-        4 => sdl2::controller::Axis::TriggerLeft,
-        5 => sdl2::controller::Axis::TriggerRight,
+        0 => sdl3_sys::gamepad::SDL_GamepadAxis::LEFTX,
+        1 => sdl3_sys::gamepad::SDL_GamepadAxis::LEFTY,
+        2 => sdl3_sys::gamepad::SDL_GamepadAxis::RIGHTX,
+        3 => sdl3_sys::gamepad::SDL_GamepadAxis::RIGHTY,
+        4 => sdl3_sys::gamepad::SDL_GamepadAxis::LEFT_TRIGGER,
+        5 => sdl3_sys::gamepad::SDL_GamepadAxis::RIGHT_TRIGGER,
         _ => panic!("Invalid axis"),
     }
 }
 
-fn get_button_from_i32(button: i32) -> sdl2::controller::Button {
+fn get_button_from_i32(button: i32) -> sdl3_sys::gamepad::SDL_GamepadButton {
     match button {
-        0 => sdl2::controller::Button::A,
-        1 => sdl2::controller::Button::B,
-        2 => sdl2::controller::Button::X,
-        3 => sdl2::controller::Button::Y,
-        4 => sdl2::controller::Button::Back,
-        5 => sdl2::controller::Button::Guide,
-        6 => sdl2::controller::Button::Start,
-        7 => sdl2::controller::Button::LeftStick,
-        8 => sdl2::controller::Button::RightStick,
-        9 => sdl2::controller::Button::LeftShoulder,
-        10 => sdl2::controller::Button::RightShoulder,
-        11 => sdl2::controller::Button::DPadUp,
-        12 => sdl2::controller::Button::DPadDown,
-        13 => sdl2::controller::Button::DPadLeft,
-        14 => sdl2::controller::Button::DPadRight,
+        0 => sdl3_sys::gamepad::SDL_GamepadButton::SOUTH,
+        1 => sdl3_sys::gamepad::SDL_GamepadButton::EAST,
+        2 => sdl3_sys::gamepad::SDL_GamepadButton::WEST,
+        3 => sdl3_sys::gamepad::SDL_GamepadButton::NORTH,
+        4 => sdl3_sys::gamepad::SDL_GamepadButton::BACK,
+        5 => sdl3_sys::gamepad::SDL_GamepadButton::GUIDE,
+        6 => sdl3_sys::gamepad::SDL_GamepadButton::START,
+        7 => sdl3_sys::gamepad::SDL_GamepadButton::LEFT_STICK,
+        8 => sdl3_sys::gamepad::SDL_GamepadButton::RIGHT_STICK,
+        9 => sdl3_sys::gamepad::SDL_GamepadButton::LEFT_SHOULDER,
+        10 => sdl3_sys::gamepad::SDL_GamepadButton::RIGHT_SHOULDER,
+        11 => sdl3_sys::gamepad::SDL_GamepadButton::DPAD_UP,
+        12 => sdl3_sys::gamepad::SDL_GamepadButton::DPAD_DOWN,
+        13 => sdl3_sys::gamepad::SDL_GamepadButton::DPAD_LEFT,
+        14 => sdl3_sys::gamepad::SDL_GamepadButton::DPAD_RIGHT,
         _ => panic!("Invalid button"),
     }
 }
 
-pub fn set_axis_from_controller(
+fn set_axis_from_controller(
     profile: &ui::config::InputProfile,
-    controller: &sdl2::controller::GameController,
+    controller: *mut sdl3_sys::gamepad::SDL_Gamepad,
 ) -> (f64, f64) {
     let mut x = 0.0;
     let mut y = 0.0;
     if profile.controller_axis[AXIS_LEFT].0 {
-        let axis_position =
-            controller.axis(get_axis_from_i32(profile.controller_axis[AXIS_LEFT].1));
+        let axis_position = unsafe {
+            sdl3_sys::gamepad::SDL_GetGamepadAxis(
+                controller,
+                get_axis_from_i32(profile.controller_axis[AXIS_LEFT].1),
+            )
+        };
         if axis_position as isize * profile.controller_axis[AXIS_LEFT].2 as isize > 0 {
             x = axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64;
         }
     }
     if profile.controller_axis[AXIS_RIGHT].0 {
-        let axis_position =
-            controller.axis(get_axis_from_i32(profile.controller_axis[AXIS_RIGHT].1));
+        let axis_position = unsafe {
+            sdl3_sys::gamepad::SDL_GetGamepadAxis(
+                controller,
+                get_axis_from_i32(profile.controller_axis[AXIS_RIGHT].1),
+            )
+        };
         if axis_position as isize * profile.controller_axis[AXIS_RIGHT].2 as isize > 0 {
             x = axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64;
         }
     }
     if profile.controller_axis[AXIS_DOWN].0 {
-        let axis_position =
-            controller.axis(get_axis_from_i32(profile.controller_axis[AXIS_DOWN].1));
+        let axis_position = unsafe {
+            sdl3_sys::gamepad::SDL_GetGamepadAxis(
+                controller,
+                get_axis_from_i32(profile.controller_axis[AXIS_DOWN].1),
+            )
+        };
         if axis_position as isize * profile.controller_axis[AXIS_DOWN].2 as isize > 0 {
             y = (axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64).neg();
         }
     }
     if profile.controller_axis[AXIS_UP].0 {
-        let axis_position = controller.axis(get_axis_from_i32(profile.controller_axis[AXIS_UP].1));
+        let axis_position = unsafe {
+            sdl3_sys::gamepad::SDL_GetGamepadAxis(
+                controller,
+                get_axis_from_i32(profile.controller_axis[AXIS_UP].1),
+            )
+        };
         if axis_position as isize * profile.controller_axis[AXIS_UP].2 as isize > 0 {
             y = (axis_position as f64 * MAX_AXIS_VALUE / i16::MAX as f64).neg();
         }
@@ -147,65 +175,61 @@ pub fn set_axis_from_controller(
     (x, y)
 }
 
-pub fn set_axis_from_keys(
+fn set_axis_from_keys(
     profile: &ui::config::InputProfile,
-    keyboard_state: sdl2::keyboard::KeyboardState,
+    keyboard_state: *const bool,
 ) -> (f64, f64) {
     let mut x = 0.0;
     let mut y = 0.0;
     if profile.keys[AXIS_LEFT].0
-        && keyboard_state.is_scancode_pressed(
-            sdl2::keyboard::Scancode::from_i32(profile.keys[AXIS_LEFT].1).unwrap(),
-        )
+        && unsafe { *keyboard_state.offset(profile.keys[AXIS_LEFT].1 as isize) }
     {
         x = -MAX_AXIS_VALUE
     }
     if profile.keys[AXIS_RIGHT].0
-        && keyboard_state.is_scancode_pressed(
-            sdl2::keyboard::Scancode::from_i32(profile.keys[AXIS_RIGHT].1).unwrap(),
-        )
+        && unsafe { *keyboard_state.offset(profile.keys[AXIS_RIGHT].1 as isize) }
     {
         x = MAX_AXIS_VALUE
     }
     if profile.keys[AXIS_DOWN].0
-        && keyboard_state.is_scancode_pressed(
-            sdl2::keyboard::Scancode::from_i32(profile.keys[AXIS_DOWN].1).unwrap(),
-        )
+        && unsafe { *keyboard_state.offset(profile.keys[AXIS_DOWN].1 as isize) }
     {
         y = -MAX_AXIS_VALUE
     }
     if profile.keys[AXIS_UP].0
-        && keyboard_state.is_scancode_pressed(
-            sdl2::keyboard::Scancode::from_i32(profile.keys[AXIS_UP].1).unwrap(),
-        )
+        && unsafe { *keyboard_state.offset(profile.keys[AXIS_UP].1 as isize) }
     {
         y = MAX_AXIS_VALUE
     }
     (x, y)
 }
 
-pub fn set_buttons_from_joystick(
+fn set_buttons_from_joystick(
     profile: &ui::config::InputProfile,
     i: usize,
-    joystick: &sdl2::joystick::Joystick,
+    joystick: *mut sdl3_sys::joystick::SDL_Joystick,
     keys: &mut u32,
 ) {
     let profile_joystick_button = profile.joystick_buttons[i];
     if profile_joystick_button.0 {
-        *keys |= (joystick.button(profile_joystick_button.1).unwrap() as u32) << i;
+        *keys |= (unsafe {
+            sdl3_sys::joystick::SDL_GetJoystickButton(joystick, profile_joystick_button.1)
+        } as u32)
+            << i;
     }
 
     let profile_joystick_hat = profile.joystick_hat[i];
     if profile_joystick_hat.0
-        && joystick.hat(profile_joystick_hat.1).unwrap()
-            == sdl2::joystick::HatState::from_raw(profile_joystick_hat.2)
+        && unsafe { sdl3_sys::joystick::SDL_GetJoystickHat(joystick, profile_joystick_hat.1) }
+            == profile_joystick_hat.2
     {
         *keys |= 1 << i;
     }
 
     let profile_joystick_axis = profile.joystick_axis[i];
     if profile_joystick_axis.0 {
-        let axis_position = joystick.axis(profile_joystick_axis.1).unwrap();
+        let axis_position =
+            unsafe { sdl3_sys::joystick::SDL_GetJoystickAxis(joystick, profile_joystick_axis.1) };
         if axis_position as isize * profile_joystick_axis.2 as isize > 0
             && axis_position.saturating_abs() > i16::MAX / 2
         {
@@ -214,20 +238,31 @@ pub fn set_buttons_from_joystick(
     }
 }
 
-pub fn set_buttons_from_controller(
+fn set_buttons_from_controller(
     profile: &ui::config::InputProfile,
     i: usize,
-    controller: &sdl2::controller::GameController,
+    controller: *mut sdl3_sys::gamepad::SDL_Gamepad,
     keys: &mut u32,
 ) {
     let profile_controller_button = profile.controller_buttons[i];
     if profile_controller_button.0 {
-        *keys |= (controller.button(get_button_from_i32(profile_controller_button.1)) as u32) << i;
+        *keys |= (unsafe {
+            sdl3_sys::gamepad::SDL_GetGamepadButton(
+                controller,
+                get_button_from_i32(profile_controller_button.1),
+            )
+        } as u32)
+            << i;
     }
 
     let profile_controller_axis = profile.controller_axis[i];
     if profile_controller_axis.0 {
-        let axis_position = controller.axis(get_axis_from_i32(profile_controller_axis.1));
+        let axis_position = unsafe {
+            sdl3_sys::gamepad::SDL_GetGamepadAxis(
+                controller,
+                get_axis_from_i32(profile_controller_axis.1),
+            )
+        };
         if axis_position as isize * profile_controller_axis.2 as isize > 0
             && axis_position.saturating_abs() > i16::MAX / 2
         {
@@ -236,31 +271,81 @@ pub fn set_buttons_from_controller(
     }
 }
 
-pub fn get(ui: &mut ui::Ui, channel: usize) -> u32 {
-    let context = ui.sdl_context.as_mut().unwrap();
-    let events = context.event_pump().unwrap();
-    let keyboard_state = events.keyboard_state();
+pub fn set_rumble(ui: &mut ui::Ui, channel: usize, rumble: u8) {
+    if !ui.controllers[channel].rumble {
+        return;
+    }
+    let controller = ui.controllers[channel].game_controller;
+    let joystick = ui.controllers[channel].joystick;
+    if !controller.is_null() {
+        unsafe {
+            sdl3_sys::gamepad::SDL_RumbleGamepad(
+                controller,
+                (rumble & 1) as u16 * u16::MAX,
+                (rumble & 1) as u16 * u16::MAX,
+                (rumble & 1) as u32 * 60000,
+            )
+        };
+    } else if !joystick.is_null() {
+        unsafe {
+            sdl3_sys::joystick::SDL_RumbleJoystick(
+                joystick,
+                (rumble & 1) as u16 * u16::MAX,
+                (rumble & 1) as u16 * u16::MAX,
+                (rumble & 1) as u32 * 60000,
+            )
+        };
+    }
+}
 
+fn change_paks(
+    profile: &ui::config::InputProfile,
+    joystick: *mut sdl3_sys::joystick::SDL_Joystick,
+    controller: *mut sdl3_sys::gamepad::SDL_Gamepad,
+    keyboard_state: *const bool,
+) -> bool {
+    let controller_button = profile.controller_buttons[CHANGE_PAK];
+    let joystick_button = profile.joystick_buttons[CHANGE_PAK];
+    let joystick_hat = profile.joystick_hat[CHANGE_PAK];
+    let key = profile.keys[CHANGE_PAK];
+
+    let mut pressed = false;
+    if controller_button.0 && !controller.is_null() {
+        pressed = unsafe {
+            sdl3_sys::gamepad::SDL_GetGamepadButton(
+                controller,
+                get_button_from_i32(controller_button.1),
+            )
+        };
+    } else if joystick_button.0 && !joystick.is_null() {
+        pressed = unsafe { sdl3_sys::joystick::SDL_GetJoystickButton(joystick, joystick_button.1) };
+    } else if joystick_hat.0 && !joystick.is_null() {
+        pressed = unsafe { sdl3_sys::joystick::SDL_GetJoystickHat(joystick, joystick_hat.1) }
+            == joystick_hat.2;
+    } else if key.0 {
+        pressed = unsafe { *keyboard_state.offset(key.1 as isize) };
+    }
+    pressed
+}
+
+pub fn get(ui: &mut ui::Ui, channel: usize) -> (u32, bool) {
     let profile_name = ui.config.input.input_profile_binding[channel].clone();
     let profile = ui.config.input.input_profiles.get(&profile_name).unwrap();
     let mut keys = 0;
-    let controller = &ui.controllers[channel].game_controller;
-    let joystick = &ui.controllers[channel].joystick;
+    let controller = ui.controllers[channel].game_controller;
+    let joystick = ui.controllers[channel].joystick;
     for i in 0..14 {
         if profile_name != "default" || channel == 0 {
             let profile_key = profile.keys[i];
             if profile_key.0 {
-                keys |= (keyboard_state
-                    .is_scancode_pressed(sdl2::keyboard::Scancode::from_i32(profile_key.1).unwrap())
-                    as u32)
-                    << i;
+                keys |= (unsafe { *ui.keyboard_state.offset(profile_key.1 as isize) } as u32) << i;
             }
         }
 
-        if joystick.is_some() {
-            set_buttons_from_joystick(profile, i, joystick.as_ref().unwrap(), &mut keys);
-        } else if controller.is_some() {
-            set_buttons_from_controller(profile, i, controller.as_ref().unwrap(), &mut keys);
+        if !controller.is_null() {
+            set_buttons_from_controller(profile, i, controller, &mut keys);
+        } else if !joystick.is_null() {
+            set_buttons_from_joystick(profile, i, joystick, &mut keys);
         }
     }
 
@@ -268,42 +353,35 @@ pub fn get(ui: &mut ui::Ui, channel: usize) -> u32 {
     let mut y: f64 = 0.0;
 
     if profile_name != "default" || channel == 0 {
-        (x, y) = set_axis_from_keys(profile, keyboard_state);
+        (x, y) = set_axis_from_keys(profile, ui.keyboard_state);
     }
 
-    if joystick.is_some() {
-        (x, y) = set_axis_from_joystick(profile, joystick.as_ref().unwrap())
-    } else if controller.is_some() {
-        (x, y) = set_axis_from_controller(profile, controller.as_ref().unwrap())
+    if !controller.is_null() {
+        (x, y) = set_axis_from_controller(profile, controller)
+    } else if !joystick.is_null() {
+        (x, y) = set_axis_from_joystick(profile, joystick)
     }
     bound_axis(&mut x, &mut y);
 
-    keys |= (x.round() as i8 as u8 as u32) << X_AXIS;
-    keys |= (y.round() as i8 as u8 as u32) << Y_AXIS;
-    keys
+    keys |= (x.round() as i8 as u8 as u32) << X_AXIS_SHIFT;
+    keys |= (y.round() as i8 as u8 as u32) << Y_AXIS_SHIFT;
+
+    (
+        keys,
+        change_paks(profile, joystick, controller, ui.keyboard_state),
+    )
 }
 
-pub fn list_controllers(ui: &ui::Ui) {
-    let joystick_subsystem = ui.joystick_subsystem.as_ref().unwrap();
-    let num_joysticks = joystick_subsystem.num_joysticks().unwrap();
-    if num_joysticks == 0 {
-        println!("No controllers connected")
-    }
-    for i in 0..num_joysticks {
-        println!("{}: {}", i, joystick_subsystem.name_for_index(i).unwrap())
-    }
-}
-
-pub fn assign_controller(ui: &mut ui::Ui, controller: u32, port: usize) {
-    let joystick_subsystem = ui.joystick_subsystem.as_ref().unwrap();
-    let num_joysticks = joystick_subsystem.num_joysticks().unwrap();
-    if controller < num_joysticks {
-        ui.config.input.controller_assignment[port - 1] = Some(
-            joystick_subsystem
-                .device_guid(controller)
-                .unwrap()
-                .to_string(),
-        );
+pub fn assign_controller(ui: &mut ui::Ui, controller: i32, port: usize) {
+    if controller < ui.num_joysticks {
+        let path = unsafe {
+            std::ffi::CStr::from_ptr(sdl3_sys::joystick::SDL_GetJoystickPathForID(
+                *(ui.joysticks.offset(controller as isize)),
+            ))
+            .to_string_lossy()
+            .to_string()
+        };
+        ui.config.input.controller_assignment[port - 1] = Some(path);
     } else {
         println!("Invalid controller number")
     }
@@ -324,7 +402,21 @@ pub fn clear_bindings(ui: &mut ui::Ui) {
     }
 }
 
-pub fn configure_input_profile(ui: &mut ui::Ui, profile: String) {
+fn close_controllers(
+    open_joysticks: Vec<*mut sdl3_sys::joystick::SDL_Joystick>,
+    open_controllers: Vec<*mut sdl3_sys::gamepad::SDL_Gamepad>,
+) {
+    for joystick in open_joysticks {
+        unsafe { sdl3_sys::joystick::SDL_CloseJoystick(joystick) }
+    }
+    for controller in open_controllers {
+        unsafe { sdl3_sys::gamepad::SDL_CloseGamepad(controller) }
+    }
+}
+
+pub fn configure_input_profile(ui: &mut ui::Ui, profile: String, dinput: bool) {
+    ui::sdl_init(sdl3_sys::init::SDL_INIT_VIDEO);
+
     if profile == "default" {
         println!("Profile name cannot be default");
         return;
@@ -333,24 +425,47 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String) {
         println!("Profile name cannot be empty");
         return;
     }
-    let joystick_subsystem = ui.sdl_context.as_ref().unwrap().joystick().unwrap();
-    let mut joysticks = vec![];
-    for i in 0..joystick_subsystem.num_joysticks().unwrap() {
-        joysticks.push(ui.sdl_context.as_ref().unwrap().joystick().unwrap().open(i));
+    let mut open_joysticks: Vec<*mut sdl3_sys::joystick::SDL_Joystick> = Vec::new();
+    let mut open_controllers: Vec<*mut sdl3_sys::gamepad::SDL_Gamepad> = Vec::new();
+
+    for offset in 0..ui.num_joysticks as isize {
+        if !dinput {
+            let controller =
+                unsafe { sdl3_sys::gamepad::SDL_OpenGamepad(*ui.joysticks.offset(offset)) };
+            if !controller.is_null() {
+                open_controllers.push(controller);
+            }
+        } else {
+            let joystick =
+                unsafe { sdl3_sys::joystick::SDL_OpenJoystick(*ui.joysticks.offset(offset)) };
+            if !joystick.is_null() {
+                open_joysticks.push(joystick);
+            }
+        }
     }
 
-    let mut builder =
-        ui.video_subsystem
-            .as_ref()
-            .unwrap()
-            .window("configure input profile", 640, 480);
-    builder.position_centered();
-    let window = builder.build().unwrap();
-    let mut canvas = window.into_canvas().build().unwrap();
+    let title = std::ffi::CString::new("configure input profile").unwrap();
+    let mut window: *mut sdl3_sys::video::SDL_Window = std::ptr::null_mut();
+    let mut renderer: *mut sdl3_sys::render::SDL_Renderer = std::ptr::null_mut();
+    if !unsafe {
+        sdl3_sys::render::SDL_CreateWindowAndRenderer(
+            title.as_ptr(),
+            640,
+            480,
+            0,
+            &mut window,
+            &mut renderer,
+        )
+    } {
+        panic!("Could not create window and renderer")
+    }
+    if !unsafe { sdl3_sys::video::SDL_ShowWindow(window) } {
+        panic!("Could not show window")
+    }
     let font =
         rusttype::Font::try_from_bytes(include_bytes!("../../data/Roboto-Regular.ttf")).unwrap();
 
-    let key_labels = [
+    let key_labels: [(&str, usize); PROFILE_SIZE] = [
         ("A", A_BUTTON),
         ("B", B_BUTTON),
         ("Start", START_BUTTON),
@@ -369,128 +484,206 @@ pub fn configure_input_profile(ui: &mut ui::Ui, profile: String) {
         ("Control Stick Down", AXIS_DOWN),
         ("Control Stick Left", AXIS_LEFT),
         ("Control Stick Right", AXIS_RIGHT),
+        ("Change Pak", CHANGE_PAK),
     ];
 
-    let mut new_keys = [(false, 0); 18];
-    let mut new_joystick_buttons = [(false, 0u32); 14];
-    let mut new_joystick_hat = [(false, 0u32, 0); 14];
-    let mut new_joystick_axis = [(false, 0u32, 0); 18];
+    let mut new_keys = [(false, 0); PROFILE_SIZE];
+    let mut new_joystick_buttons = [(false, 0i32); PROFILE_SIZE];
+    let mut new_joystick_hat = [(false, 0i32, 0); PROFILE_SIZE];
+    let mut new_joystick_axis = [(false, 0i32, 0); PROFILE_SIZE];
+    let mut new_controller_buttons = [(false, 0i32); PROFILE_SIZE];
+    let mut new_controller_axis = [(false, 0i32, 0); PROFILE_SIZE];
 
-    let mut last_axis_result = (false, 0, 0);
-    let mut event_pump = ui.sdl_context.as_ref().unwrap().event_pump().unwrap();
+    let mut last_joystick_axis_result = (false, 0, 0);
     for (key, value) in key_labels.iter() {
-        for _event in event_pump.poll_iter() {} // clear events
+        let mut event: sdl3_sys::events::SDL_Event = Default::default();
+        while unsafe { sdl3_sys::events::SDL_PollEvent(&mut event) } {} // clear events
 
         ui::video::draw_text(
             format!("Select binding for: {key}").as_str(),
-            &mut canvas,
+            renderer,
             &font,
         );
 
         let mut key_set = false;
         while !key_set {
             std::thread::sleep(std::time::Duration::from_millis(100));
-            for event in event_pump.poll_iter() {
-                match event {
-                    sdl2::event::Event::Window {
-                        win_event: sdl2::event::WindowEvent::Close,
-                        ..
-                    } => return,
-                    sdl2::event::Event::KeyDown {
-                        scancode: Some(scancode),
-                        ..
-                    } => {
-                        new_keys[*value] = (true, scancode as i32);
+            while unsafe { sdl3_sys::events::SDL_PollEvent(&mut event) } {
+                let event_type = unsafe { event.r#type };
+                if event_type == u32::from(sdl3_sys::events::SDL_EVENT_WINDOW_CLOSE_REQUESTED) {
+                    close_controllers(open_joysticks, open_controllers);
+                    return;
+                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_KEY_DOWN) {
+                    new_keys[*value] = (true, i32::from(unsafe { event.key.scancode }));
+                    key_set = true
+                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_GAMEPAD_BUTTON_DOWN) {
+                    if !open_controllers.is_empty() {
+                        new_controller_buttons[*value] =
+                            (true, i32::from(unsafe { event.gbutton.button }));
                         key_set = true
                     }
-                    sdl2::event::Event::JoyButtonDown { button_idx, .. } => {
-                        new_joystick_buttons[*value] = (true, button_idx as u32);
-                        key_set = true
-                    }
-                    sdl2::event::Event::JoyHatMotion { hat_idx, state, .. } => {
-                        new_joystick_hat[*value] = (
-                            true,
-                            hat_idx as u32,
-                            sdl2::joystick::HatState::to_raw(state),
-                        );
-                        key_set = true
-                    }
-                    sdl2::event::Event::JoyAxisMotion {
-                        axis_idx,
-                        value: axis_value,
-                        ..
-                    } => {
-                        if axis_value.saturating_abs() > 24576 {
-                            let result = (
-                                true,
-                                axis_idx as u32,
-                                axis_value / axis_value.saturating_abs(),
-                            );
-                            if result != last_axis_result {
-                                new_joystick_axis[*value] = result;
-                                last_axis_result = result;
-                                key_set = true
-                            }
+                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_GAMEPAD_AXIS_MOTION) {
+                    let axis_value = unsafe { event.gaxis.value };
+                    let axis = unsafe { event.gaxis.axis };
+                    if !open_controllers.is_empty() && axis_value.saturating_abs() > i16::MAX / 2 {
+                        let result = (true, axis as i32, axis_value / axis_value.saturating_abs());
+                        if result != last_joystick_axis_result {
+                            new_controller_axis[*value] = result;
+                            last_joystick_axis_result = result;
+                            key_set = true
+                        }
+                    }
+                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_JOYSTICK_BUTTON_DOWN)
+                {
+                    if !open_joysticks.is_empty() {
+                        new_joystick_buttons[*value] =
+                            (true, i32::from(unsafe { event.jbutton.button }));
+                        key_set = true
+                    }
+                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_JOYSTICK_HAT_MOTION) {
+                    let state = unsafe { event.jhat.value };
+                    let hat = unsafe { event.jhat.hat };
+                    if !open_joysticks.is_empty() && state != sdl3_sys::joystick::SDL_HAT_CENTERED {
+                        new_joystick_hat[*value] = (true, hat as i32, state);
+                        key_set = true
+                    }
+                } else if event_type == u32::from(sdl3_sys::events::SDL_EVENT_JOYSTICK_AXIS_MOTION)
+                {
+                    let axis_value = unsafe { event.jaxis.value };
+                    let axis = unsafe { event.jaxis.axis };
+                    if !open_joysticks.is_empty() && axis_value.saturating_abs() > i16::MAX / 2 {
+                        let result = (true, axis as i32, axis_value / axis_value.saturating_abs());
+                        if result != last_joystick_axis_result {
+                            new_joystick_axis[*value] = result;
+                            last_joystick_axis_result = result;
+                            key_set = true
                         }
                     }
-                    _ => {}
                 }
             }
         }
     }
 
+    close_controllers(open_joysticks, open_controllers);
+
+    unsafe {
+        sdl3_sys::render::SDL_DestroyRenderer(renderer);
+        sdl3_sys::video::SDL_DestroyWindow(window);
+    }
+
     let new_profile = ui::config::InputProfile {
         keys: new_keys,
-        controller_buttons: Default::default(),
-        controller_axis: Default::default(),
+        controller_buttons: new_controller_buttons,
+        controller_axis: new_controller_axis,
         joystick_buttons: new_joystick_buttons,
         joystick_hat: new_joystick_hat,
         joystick_axis: new_joystick_axis,
+        dinput,
     };
     ui.config.input.input_profiles.insert(profile, new_profile);
 }
 
 pub fn get_default_profile() -> ui::config::InputProfile {
-    let mut default_controller_buttons = [(false, 0); 14];
-    let mut default_controller_axis = [(false, 0, 0); 18];
-    let mut default_keys = [(false, 0); 18];
-    default_keys[R_DPAD] = (true, sdl2::keyboard::Scancode::D as i32);
-    default_keys[L_DPAD] = (true, sdl2::keyboard::Scancode::A as i32);
-    default_keys[D_DPAD] = (true, sdl2::keyboard::Scancode::S as i32);
-    default_keys[U_DPAD] = (true, sdl2::keyboard::Scancode::W as i32);
-    default_keys[START_BUTTON] = (true, sdl2::keyboard::Scancode::Return as i32);
-    default_keys[Z_TRIG] = (true, sdl2::keyboard::Scancode::Z as i32);
-    default_keys[B_BUTTON] = (true, sdl2::keyboard::Scancode::LCtrl as i32);
-    default_keys[A_BUTTON] = (true, sdl2::keyboard::Scancode::LShift as i32);
-    default_keys[R_CBUTTON] = (true, sdl2::keyboard::Scancode::L as i32);
-    default_keys[L_CBUTTON] = (true, sdl2::keyboard::Scancode::J as i32);
-    default_keys[D_CBUTTON] = (true, sdl2::keyboard::Scancode::K as i32);
-    default_keys[U_CBUTTON] = (true, sdl2::keyboard::Scancode::I as i32);
-    default_keys[R_TRIG] = (true, sdl2::keyboard::Scancode::C as i32);
-    default_keys[L_TRIG] = (true, sdl2::keyboard::Scancode::X as i32);
-    default_keys[AXIS_LEFT] = (true, sdl2::keyboard::Scancode::Left as i32);
-    default_keys[AXIS_RIGHT] = (true, sdl2::keyboard::Scancode::Right as i32);
-    default_keys[AXIS_UP] = (true, sdl2::keyboard::Scancode::Up as i32);
-    default_keys[AXIS_DOWN] = (true, sdl2::keyboard::Scancode::Down as i32);
+    let mut default_controller_buttons = [(false, 0); PROFILE_SIZE];
+    let mut default_controller_axis = [(false, 0, 0); PROFILE_SIZE];
+    let mut default_keys = [(false, 0); PROFILE_SIZE];
+    default_keys[R_DPAD] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_D));
+    default_keys[L_DPAD] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_A));
+    default_keys[D_DPAD] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_S));
+    default_keys[U_DPAD] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_W));
+    default_keys[START_BUTTON] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_RETURN));
+    default_keys[Z_TRIG] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_Z));
+    default_keys[B_BUTTON] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_LCTRL));
+    default_keys[A_BUTTON] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_LSHIFT));
+    default_keys[R_CBUTTON] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_L));
+    default_keys[L_CBUTTON] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_J));
+    default_keys[D_CBUTTON] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_K));
+    default_keys[U_CBUTTON] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_I));
+    default_keys[R_TRIG] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_C));
+    default_keys[L_TRIG] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_X));
+    default_keys[AXIS_LEFT] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_LEFT));
+    default_keys[AXIS_RIGHT] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_RIGHT));
+    default_keys[AXIS_UP] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_UP));
+    default_keys[AXIS_DOWN] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_DOWN));
+    default_keys[CHANGE_PAK] = (true, i32::from(sdl3_sys::scancode::SDL_SCANCODE_COMMA));
 
-    default_controller_buttons[R_DPAD] = (true, sdl2::controller::Button::DPadRight as i32);
-    default_controller_buttons[L_DPAD] = (true, sdl2::controller::Button::DPadLeft as i32);
-    default_controller_buttons[D_DPAD] = (true, sdl2::controller::Button::DPadDown as i32);
-    default_controller_buttons[U_DPAD] = (true, sdl2::controller::Button::DPadUp as i32);
-    default_controller_buttons[START_BUTTON] = (true, sdl2::controller::Button::Start as i32);
-    default_controller_axis[Z_TRIG] = (true, sdl2::controller::Axis::TriggerLeft as i32, 1);
-    default_controller_buttons[B_BUTTON] = (true, sdl2::controller::Button::X as i32);
-    default_controller_buttons[A_BUTTON] = (true, sdl2::controller::Button::A as i32);
-    default_controller_axis[R_CBUTTON] = (true, sdl2::controller::Axis::RightX as i32, 1);
-    default_controller_axis[L_CBUTTON] = (true, sdl2::controller::Axis::RightX as i32, -1);
-    default_controller_axis[D_CBUTTON] = (true, sdl2::controller::Axis::RightY as i32, 1);
-    default_controller_axis[U_CBUTTON] = (true, sdl2::controller::Axis::RightY as i32, -1);
-    default_controller_buttons[R_TRIG] = (true, sdl2::controller::Button::RightShoulder as i32);
-    default_controller_buttons[L_TRIG] = (true, sdl2::controller::Button::LeftShoulder as i32);
-    default_controller_axis[AXIS_LEFT] = (true, sdl2::controller::Axis::LeftX as i32, -1);
-    default_controller_axis[AXIS_RIGHT] = (true, sdl2::controller::Axis::LeftX as i32, 1);
-    default_controller_axis[AXIS_UP] = (true, sdl2::controller::Axis::LeftY as i32, -1);
-    default_controller_axis[AXIS_DOWN] = (true, sdl2::controller::Axis::LeftY as i32, 1);
+    default_controller_buttons[R_DPAD] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_BUTTON_DPAD_RIGHT),
+    );
+    default_controller_buttons[L_DPAD] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_BUTTON_DPAD_LEFT),
+    );
+    default_controller_buttons[D_DPAD] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_BUTTON_DPAD_DOWN),
+    );
+    default_controller_buttons[U_DPAD] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_BUTTON_DPAD_UP),
+    );
+    default_controller_buttons[START_BUTTON] =
+        (true, i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_BUTTON_START));
+    default_controller_axis[Z_TRIG] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_AXIS_LEFT_TRIGGER),
+        1,
+    );
+    default_controller_buttons[B_BUTTON] =
+        (true, i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_BUTTON_WEST));
+    default_controller_buttons[A_BUTTON] =
+        (true, i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_BUTTON_SOUTH));
+    default_controller_axis[R_CBUTTON] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_AXIS_RIGHTX),
+        1,
+    );
+    default_controller_axis[L_CBUTTON] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_AXIS_RIGHTX),
+        -1,
+    );
+    default_controller_axis[D_CBUTTON] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_AXIS_RIGHTY),
+        1,
+    );
+    default_controller_axis[U_CBUTTON] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_AXIS_RIGHTY),
+        -1,
+    );
+    default_controller_buttons[R_TRIG] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_BUTTON_RIGHT_SHOULDER),
+    );
+    default_controller_buttons[L_TRIG] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_BUTTON_LEFT_SHOULDER),
+    );
+    default_controller_axis[AXIS_LEFT] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_AXIS_LEFTX),
+        -1,
+    );
+    default_controller_axis[AXIS_RIGHT] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_AXIS_LEFTX),
+        1,
+    );
+    default_controller_axis[AXIS_UP] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_AXIS_LEFTY),
+        -1,
+    );
+    default_controller_axis[AXIS_DOWN] = (
+        true,
+        i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_AXIS_LEFTY),
+        1,
+    );
+    default_controller_buttons[CHANGE_PAK] =
+        (true, i32::from(sdl3_sys::gamepad::SDL_GAMEPAD_BUTTON_BACK));
 
     ui::config::InputProfile {
         keys: default_keys,
@@ -499,54 +692,79 @@ pub fn get_default_profile() -> ui::config::InputProfile {
         joystick_buttons: Default::default(),
         joystick_hat: Default::default(),
         joystick_axis: Default::default(),
+        dinput: false,
     }
 }
 
 pub fn init(ui: &mut ui::Ui) {
-    let joystick_subsystem = ui.joystick_subsystem.as_ref().unwrap();
+    ui.keyboard_state = unsafe { sdl3_sys::keyboard::SDL_GetKeyboardState(std::ptr::null_mut()) };
+    if ui.keyboard_state.is_null() {
+        panic!("Could not get keyboard state");
+    }
+
     let mut taken = [false; 4];
     for i in 0..4 {
         let controller_assignment = &ui.config.input.controller_assignment[i];
         if controller_assignment.is_some() {
-            let mut joystick_index = u32::MAX;
-            let guid = controller_assignment.clone().unwrap();
-            for i in 0..joystick_subsystem.num_joysticks().unwrap() {
-                if joystick_subsystem.device_guid(i).unwrap().to_string() == guid
-                    && !taken[i as usize]
-                {
-                    joystick_index = i;
-                    taken[i as usize] = true;
+            let mut joystick_id = 0;
+            let assigned_path = controller_assignment.as_ref().unwrap();
+
+            for offset in 0..ui.num_joysticks as isize {
+                let path = unsafe {
+                    std::ffi::CStr::from_ptr(sdl3_sys::joystick::SDL_GetJoystickPathForID(
+                        *(ui.joysticks.offset(offset)),
+                    ))
+                    .to_string_lossy()
+                    .to_string()
+                };
+                if path == *assigned_path && !taken[offset as usize] {
+                    joystick_id = unsafe { *(ui.joysticks.offset(offset)) };
+                    taken[offset as usize] = true;
                     break;
                 }
             }
-            if joystick_index < u32::MAX {
-                if ui.config.input.input_profile_binding[i] == "default" {
-                    let controller_result = ui
-                        .sdl_context
-                        .as_ref()
-                        .unwrap()
-                        .game_controller()
-                        .unwrap()
-                        .open(joystick_index);
-                    if controller_result.is_ok() {
-                        ui.controllers[i].game_controller = Some(controller_result.unwrap());
-                    }
-                }
-                if ui.controllers[i].game_controller.is_none() {
-                    let joystick_result = ui
-                        .sdl_context
-                        .as_ref()
-                        .unwrap()
-                        .joystick()
-                        .unwrap()
-                        .open(joystick_index);
-                    if joystick_result.is_err() {
-                        println!(
-                            "could not connect joystick: {}",
-                            joystick_result.err().unwrap()
-                        )
+
+            if joystick_id != 0 {
+                let profile_name = ui.config.input.input_profile_binding[i].clone();
+                let profile = ui.config.input.input_profiles.get(&profile_name).unwrap();
+
+                if !profile.dinput {
+                    let gamepad = unsafe { sdl3_sys::gamepad::SDL_OpenGamepad(joystick_id) };
+                    if gamepad.is_null() {
+                        println!("could not connect gamepad: {}", joystick_id)
                     } else {
-                        ui.controllers[i].joystick = Some(joystick_result.unwrap());
+                        ui.controllers[i].game_controller = gamepad;
+                        let properties =
+                            unsafe { sdl3_sys::gamepad::SDL_GetGamepadProperties(gamepad) };
+                        if properties == 0 {
+                            println!("could not get gamepad properties");
+                        }
+                        ui.controllers[i].rumble = unsafe {
+                            sdl3_sys::properties::SDL_GetBooleanProperty(
+                                properties,
+                                sdl3_sys::gamepad::SDL_PROP_GAMEPAD_CAP_RUMBLE_BOOLEAN,
+                                false,
+                            )
+                        };
+                    }
+                } else {
+                    let joystick = unsafe { sdl3_sys::joystick::SDL_OpenJoystick(joystick_id) };
+                    if joystick.is_null() {
+                        println!("could not connect joystick: {}", joystick_id)
+                    } else {
+                        ui.controllers[i].joystick = joystick;
+                        let properties =
+                            unsafe { sdl3_sys::joystick::SDL_GetJoystickProperties(joystick) };
+                        if properties == 0 {
+                            println!("could not get joystick properties");
+                        }
+                        ui.controllers[i].rumble = unsafe {
+                            sdl3_sys::properties::SDL_GetBooleanProperty(
+                                properties,
+                                sdl3_sys::joystick::SDL_PROP_JOYSTICK_CAP_RUMBLE_BOOLEAN,
+                                false,
+                            )
+                        };
                     }
                 }
             } else {
@@ -555,3 +773,16 @@ pub fn init(ui: &mut ui::Ui) {
         }
     }
 }
+
+pub fn close(ui: &mut ui::Ui) {
+    for controller in ui.controllers.iter_mut() {
+        if !controller.joystick.is_null() {
+            unsafe { sdl3_sys::joystick::SDL_CloseJoystick(controller.joystick) }
+            controller.joystick = std::ptr::null_mut();
+        }
+        if !controller.game_controller.is_null() {
+            unsafe { sdl3_sys::gamepad::SDL_CloseGamepad(controller.game_controller) }
+            controller.game_controller = std::ptr::null_mut();
+        }
+    }
+}

src/ui/storage.rs

@@ -1,3 +1,4 @@
+use crate::netplay;
 use crate::ui;
 
 #[derive(PartialEq)]
@@ -25,10 +26,10 @@ pub struct Saves {
     pub sram: (Vec<u8>, bool),
     pub flash: (Vec<u8>, bool),
     pub mempak: (Vec<u8>, bool),
-    pub romsave: (serde_json::Map<String, serde_json::Value>, bool),
+    pub romsave: (std::collections::HashMap<u32, u8>, bool),
 }
 
-pub fn get_save_type(game_id: &str) -> Vec<SaveTypes> {
+fn get_save_type(game_id: &str) -> Vec<SaveTypes> {
     match game_id {
         "NB7" | // Banjo-Tooie [Banjo to Kazooie no Daiboken 2 (J)]
         "NGT" | // City Tour GrandPrix - Zen Nihon GT Senshuken
@@ -86,11 +87,11 @@ pub fn get_save_type(game_id: &str) -> Vec<SaveTypes> {
     }
 }
 
-pub fn init(ui: &mut ui::Ui, data_dir: std::path::PathBuf) {
+pub fn init(ui: &mut ui::Ui) {
     let id = ui.game_id.as_str();
     ui.save_type = get_save_type(id);
 
-    let base_path = data_dir.join("saves");
+    let base_path = ui.dirs.data_dir.join("saves");
 
     ui.paths.eep_file_path.clone_from(&base_path);
     ui.paths
@@ -118,53 +119,106 @@ pub fn init(ui: &mut ui::Ui, data_dir: std::path::PathBuf) {
         .push(ui.game_id.to_owned() + "-" + &ui.game_hash + ".romsave");
 }
 
-pub fn load_saves(ui: &mut ui::Ui) {
-    let eep = std::fs::read(&mut ui.paths.eep_file_path);
-    if eep.is_ok() {
-        ui.saves.eeprom.0 = eep.unwrap();
+pub fn load_saves(ui: &mut ui::Ui, netplay: &mut Option<netplay::Netplay>) {
+    if netplay.is_none() || netplay.as_ref().unwrap().player_number == 0 {
+        let eep = std::fs::read(&mut ui.paths.eep_file_path);
+        if eep.is_ok() {
+            ui.saves.eeprom.0 = eep.unwrap();
+        }
+        let sra = std::fs::read(&mut ui.paths.sra_file_path);
+        if sra.is_ok() {
+            ui.saves.sram.0 = sra.unwrap();
+        }
+        let fla = std::fs::read(&mut ui.paths.fla_file_path);
+        if fla.is_ok() {
+            ui.saves.flash.0 = fla.unwrap();
+        }
+        let mempak = std::fs::read(&mut ui.paths.pak_file_path);
+        if mempak.is_ok() {
+            ui.saves.mempak.0 = mempak.unwrap();
+        }
+        let romsave = std::fs::read(&mut ui.paths.romsave_file_path);
+        if romsave.is_ok() {
+            ui.saves.romsave.0 = postcard::from_bytes(romsave.unwrap().as_ref()).unwrap();
+        }
     }
-    let sra = std::fs::read(&mut ui.paths.sra_file_path);
-    if sra.is_ok() {
-        ui.saves.sram.0 = sra.unwrap();
-    }
-    let fla = std::fs::read(&mut ui.paths.fla_file_path);
-    if fla.is_ok() {
-        ui.saves.flash.0 = fla.unwrap();
-    }
-    let mempak = std::fs::read(&mut ui.paths.pak_file_path);
-    if mempak.is_ok() {
-        ui.saves.mempak.0 = mempak.unwrap();
-    }
-    let romsave = std::fs::read(&mut ui.paths.romsave_file_path);
-    if romsave.is_ok() {
-        ui.saves.romsave.0 = serde_json::from_slice(romsave.unwrap().as_ref()).unwrap();
+
+    if netplay.is_some() {
+        if netplay.as_ref().unwrap().player_number == 0 {
+            netplay::send_save(
+                netplay.as_mut().unwrap(),
+                "eep",
+                &ui.saves.eeprom.0,
+                ui.saves.eeprom.0.len(),
+            );
+            netplay::send_save(
+                netplay.as_mut().unwrap(),
+                "sra",
+                &ui.saves.sram.0,
+                ui.saves.sram.0.len(),
+            );
+            netplay::send_save(
+                netplay.as_mut().unwrap(),
+                "fla",
+                &ui.saves.flash.0,
+                ui.saves.flash.0.len(),
+            );
+            netplay::send_save(
+                netplay.as_mut().unwrap(),
+                "mpk",
+                &ui.saves.mempak.0,
+                ui.saves.mempak.0.len(),
+            );
+            let mut romsave_bytes: Vec<u8> = vec![];
+            if !ui.saves.romsave.0.is_empty() {
+                romsave_bytes = postcard::to_stdvec(&ui.saves.romsave.0).unwrap();
+            }
+            netplay::send_save(
+                netplay.as_mut().unwrap(),
+                "rom",
+                &romsave_bytes,
+                romsave_bytes.len(),
+            );
+        } else {
+            netplay::receive_save(netplay.as_mut().unwrap(), "eep", &mut ui.saves.eeprom.0);
+            netplay::receive_save(netplay.as_mut().unwrap(), "sra", &mut ui.saves.sram.0);
+            netplay::receive_save(netplay.as_mut().unwrap(), "fla", &mut ui.saves.flash.0);
+            netplay::receive_save(netplay.as_mut().unwrap(), "mpk", &mut ui.saves.mempak.0);
+            let mut romsave_bytes: Vec<u8> = vec![];
+            netplay::receive_save(netplay.as_mut().unwrap(), "rom", &mut romsave_bytes);
+            if !romsave_bytes.is_empty() {
+                ui.saves.romsave.0 = postcard::from_bytes(&romsave_bytes).unwrap();
+            }
+        }
     }
 }
 
-pub fn write_rom_save(ui: &ui::Ui) {
-    let f = std::fs::File::create(ui.paths.romsave_file_path.clone()).unwrap();
-    serde_json::to_writer(f, &ui.saves.romsave.0).unwrap();
+fn write_rom_save(ui: &ui::Ui) {
+    let data = postcard::to_stdvec(&ui.saves.romsave.0).unwrap();
+    std::fs::write(ui.paths.romsave_file_path.clone(), data).unwrap();
 }
 
-pub fn write_saves(ui: &ui::Ui) {
-    if ui.saves.eeprom.1 {
-        write_save(ui, SaveTypes::Eeprom16k)
-    }
-    if ui.saves.sram.1 {
-        write_save(ui, SaveTypes::Sram)
-    }
-    if ui.saves.flash.1 {
-        write_save(ui, SaveTypes::Flash)
-    }
-    if ui.saves.mempak.1 {
-        write_save(ui, SaveTypes::Mempak)
-    }
-    if ui.saves.romsave.1 {
-        write_save(ui, SaveTypes::Romsave)
+pub fn write_saves(ui: &ui::Ui, netplay: &Option<netplay::Netplay>) {
+    if netplay.is_none() || netplay.as_ref().unwrap().player_number == 0 {
+        if ui.saves.eeprom.1 {
+            write_save(ui, SaveTypes::Eeprom16k)
+        }
+        if ui.saves.sram.1 {
+            write_save(ui, SaveTypes::Sram)
+        }
+        if ui.saves.flash.1 {
+            write_save(ui, SaveTypes::Flash)
+        }
+        if ui.saves.mempak.1 {
+            write_save(ui, SaveTypes::Mempak)
+        }
+        if ui.saves.romsave.1 {
+            write_save(ui, SaveTypes::Romsave)
+        }
     }
 }
 
-pub fn write_save(ui: &ui::Ui, save_type: SaveTypes) {
+fn write_save(ui: &ui::Ui, save_type: SaveTypes) {
     let path: &std::path::Path;
     let data: &Vec<u8>;
     match save_type {

src/ui/video.rs

@@ -1,23 +1,29 @@
 #![allow(non_snake_case)]
 include!(concat!(env!("OUT_DIR"), "/parallel_bindings.rs"));
 use crate::device;
+use crate::ui;
 
 pub fn init(device: &mut device::Device, fullscreen: bool) {
-    let mut builder = device
-        .ui
-        .video_subsystem
-        .as_ref()
-        .unwrap()
-        .window("gopher64", 640, 480);
+    ui::sdl_init(sdl3_sys::init::SDL_INIT_VIDEO);
 
-    builder.position_centered().vulkan();
+    let title = std::ffi::CString::new("gopher64").unwrap();
+
+    let mut flags = sdl3_sys::video::SDL_WINDOW_VULKAN;
 
     if fullscreen {
-        builder.fullscreen_desktop();
+        flags |= sdl3_sys::video::SDL_WINDOW_FULLSCREEN;
     } else {
-        builder.resizable();
+        flags |= sdl3_sys::video::SDL_WINDOW_RESIZABLE;
+    }
+
+    device.ui.window =
+        unsafe { sdl3_sys::video::SDL_CreateWindow(title.as_ptr(), 640, 480, flags) };
+    if device.ui.window.is_null() {
+        panic!("Could not create window");
+    }
+    if !unsafe { sdl3_sys::video::SDL_ShowWindow(device.ui.window) } {
+        panic!("Could not show window");
     }
-    device.ui.window = Some(builder.build().unwrap());
 
     let gfx_info = GFX_INFO {
         RDRAM: device.rdram.mem.as_mut_ptr(),
@@ -36,17 +42,19 @@ pub fn init(device: &mut device::Device, fullscreen: bool) {
 
     unsafe {
         rdp_init(
-            device.ui.window.as_mut().unwrap().raw() as *mut std::ffi::c_void,
+            device.ui.window as *mut std::ffi::c_void,
             gfx_info,
-            fullscreen,
             device.ui.config.video.upscale,
+            device.ui.config.video.integer_scaling,
+            fullscreen,
         )
     }
 }
 
-pub fn close() {
+pub fn close(ui: &ui::Ui) {
     unsafe {
         rdp_close();
+        sdl3_sys::video::SDL_DestroyWindow(ui.window);
     }
 }
 
@@ -66,24 +74,26 @@ pub fn process_rdp_list() -> u64 {
 }
 
 pub fn full_sync() {
-    unsafe {
-        rdp_full_sync();
-    }
+    unsafe { rdp_full_sync() }
 }
 
-pub fn draw_text(
-    text: &str,
-    canvas: &mut sdl2::render::Canvas<sdl2::video::Window>,
-    font: &rusttype::Font,
-) {
+pub fn draw_text(text: &str, renderer: *mut sdl3_sys::render::SDL_Renderer, font: &rusttype::Font) {
     let text_size = 32;
     let scale = rusttype::Scale::uniform(text_size as f32);
     let v_metrics = font.v_metrics(scale);
     let offset = rusttype::point(10.0, 10.0 + v_metrics.ascent);
 
     // Clear the canvas
-    canvas.set_draw_color(sdl2::pixels::Color::RGB(0, 0, 0));
-    canvas.clear();
+    unsafe {
+        sdl3_sys::render::SDL_SetRenderDrawColor(
+            renderer,
+            0,
+            0,
+            0,
+            sdl3_sys::pixels::SDL_ALPHA_OPAQUE,
+        );
+        sdl3_sys::render::SDL_RenderClear(renderer);
+    };
 
     for glyph in font.layout(text, scale, offset) {
         if let Some(bb) = glyph.pixel_bounding_box() {
@@ -91,15 +101,23 @@ pub fn draw_text(
                 let x = x as i32 + bb.min.x;
                 let y = y as i32 + bb.min.y + (240 - text_size);
                 if v > 0.5 {
-                    canvas.set_draw_color(sdl2::pixels::Color::RGB(255, 255, 255));
-                    canvas
-                        .draw_point(sdl2::rect::Point::new(x, y))
-                        .expect("Error drawing pixel");
+                    unsafe {
+                        sdl3_sys::render::SDL_SetRenderDrawColor(
+                            renderer,
+                            255,
+                            255,
+                            255,
+                            sdl3_sys::pixels::SDL_ALPHA_OPAQUE,
+                        );
+                        sdl3_sys::render::SDL_RenderPoint(renderer, x as f32, y as f32);
+                    };
                 }
             });
         }
     }
 
     // Present the canvas
-    canvas.present();
+    if !unsafe { sdl3_sys::render::SDL_RenderPresent(renderer) } {
+        panic!("Could not present renderer");
+    }
 }

src/ui/vru.rs

@@ -5,7 +5,7 @@ use crate::ui;
 pub fn prompt_for_match(
     words: &[String],
     window_notifier: &std::sync::mpsc::Sender<Vec<String>>,
-    word_index_notifier: &std::sync::mpsc::Receiver<String>,
+    word_index_receiver: &std::sync::mpsc::Receiver<String>,
     gui_ctx: &egui::Context,
 ) -> u16 {
     let mut dedup_words = words.to_owned();
@@ -13,9 +13,9 @@ pub fn prompt_for_match(
     dedup_words.dedup();
     window_notifier.send(dedup_words).unwrap();
     gui_ctx.request_repaint(); // this is so the window pops up right away
-    let mut result = word_index_notifier.try_recv();
+    let mut result = word_index_receiver.try_recv();
     while result.is_err() {
-        result = word_index_notifier.try_recv();
+        result = word_index_receiver.try_recv();
         std::thread::sleep(std::time::Duration::from_secs_f64(1.0 / 60.0));
         ui::video::update_screen(); // so the OS doesn't complain about the game window being frozen
     }