New patch system - Patches the option menu crash

src/main.rs

···
+mod utils;
+mod patches;
+
 use std::fs::File;
-use std::io::{Read, Write};
+use std::io::{Write};
 use std::path::Path;
 use std::process::Command;
 use std::time::Duration;
···
 static WEBFISHING_APPID: u32 = 3146520;
 
 
-// https://stackoverflow.com/a/54152901
-fn replace_slice<T>(buf: &mut [T], from: &[T], to: &[T])
-where
-    T: Clone + PartialEq,
-{
-    for i in 0..=buf.len() - from.len() {
-        if buf[i..].starts_with(from) {
-            buf[i..(i + from.len())].clone_from_slice(to);
-        }
-    }
-}
 
 async fn install_webfishing(location: &SteamDir) {
     let steam_location = location.path();
···
 
     let mut file = File::create("build/godot_steam_template.zip").expect("Could not create godotsteam template");
     file.write_all(&body).expect("Could not write godotsteam template");
+}
+
+async fn download_gd_decomp() {
+    println!("Download Godot Decompiler...");
+    let res = reqwest::get("https://github.com/GDRETools/gdsdecomp/releases/download/v0.8.0/GDRE_tools-v0.8.0-macos.zip").await.expect("Could not download decompiler");
+    let body = res.bytes().await.expect("Could not read body");
+
+    println!("Unzipping GodotSteam Decompiler...");
+    let mut file = File::create("build/decompiler.zip").expect("Could not create decompiler");
+    file.write_all(&body).expect("Could not write decompiler");
+
+    Command::new("unzip")
+        .arg("decompiler.zip")
+        .current_dir("build")
+        .output().expect("Could not unzip godotsteam template");
 }
 
 fn build_webfishing_macos(webfishing_path: &Path) {
···
         .output().expect("Could not copy webfishing.app");
 }
 
-fn patch_webfishing_pck() {
-    println!("Patching webfishing PCK");
+fn decomp_game() {
     let webfishing_pck_path = Path::new("build").join("webfishing.app").join("Contents").join("Resources").join("webfishing.pck");
-
-    let mut webfishing_pck_read = File::open(&webfishing_pck_path).expect("Could not open webfishing.pck file");
-    let mut bytes = Vec::new();
-    webfishing_pck_read.read_to_end(&mut bytes).expect("Could not read webfishing.pck");
-    drop(webfishing_pck_read);
-
-    // PATCH
-    replace_slice(&mut bytes, "steam_id_remote".as_bytes(), "remote_steam_id".as_bytes());
-
-    let mut webfishing_pck_write = File::create(webfishing_pck_path).expect("Could not open webfishing.pck file");
-    webfishing_pck_write.write_all(bytes.as_slice()).expect("Could not write webfishing.pck");
+    let decomp_command = "build/Godot RE Tools.app/Contents/MacOS/Godot RE Tools";
+    Command::new(decomp_command)
+        .arg("--headless")
+        .arg(format!("--extract={}", webfishing_pck_path.display()))
+        .arg("--include=\"*options_menu*\"")
+        .arg("--include=\"*SteamNetwork*\"")
+        .arg("--output-dir=build/webfishing-export")
+        .output().expect("Could not extract game");
 }
 
 #[tokio::main]
···
     }
 
     let (app, library) =  location.find_app(WEBFISHING_APPID).unwrap().unwrap();
+
+    if !Path::exists("build/decompiler.zip".as_ref()) {
+        download_gd_decomp().await;
+    }
 
     if !Path::exists("build/godot_steam_template.zip".as_ref()) {
         download_godot_steam_template().await;
···
     }
 
     if sudo::check() != RunningAs::Root {
-        patch_webfishing_pck();
+        decomp_game();
+        patches::steam_network_patch::patch().await;
+        patches::options_menu_patch::patch().await;
         println!("Root permissions needed to sign webfishing");
     }
 

src/patches/mod.rs

···
+pub mod steam_network_patch;
+pub mod options_menu_patch;

src/patches/options_menu_patch.rs

···
+use async_std::fs::File;
+use async_std::io::{ReadExt, WriteExt};
+use crate::utils::gd_utils::replace_slice;
+
+const SCRIPT_PATH: &str = "build/webfishing-decomp/options_menu.gd";
+const COMPILED_PATH: &str = "build/webfishing-recomp/options_menu.gdc";
+const GAME_PCK: &str = "build/webfishing.app/Contents/Resources/webfishing.pck";
+
+pub(crate) async fn patch() {
+    crate::utils::gd_utils::decomp_file("build/webfishing-export/Scenes/Singletons/OptionsMenu/options_menu.gdc");
+
+    let mut script = File::open(SCRIPT_PATH).await.expect("Cannot open script");
+    let mut script_txt = String::new();
+    script.read_to_string(&mut script_txt).await.expect("Cannot read script");
+    drop(script);
+
+    let patched_script = script_txt.replace("OS.window_borderless = PlayerData.player_options.fullscreen == 1", "\n");
+    let mut script = File::create(SCRIPT_PATH).await.expect("Cannot open script");
+    script.write_all(patched_script.as_bytes()).await.expect("Cannot write");
+    drop(script);
+
+    crate::utils::gd_utils::recomp_file(SCRIPT_PATH);
+
+    let mut compiled_script_bytes = Vec::new();
+    let mut compiled_script = File::open(COMPILED_PATH).await.expect("Cannot open script");
+    compiled_script.read_to_end(&mut compiled_script_bytes).await.expect("Cannot read");
+    drop(compiled_script);
+
+    let mut compiled_pck_bytes = Vec::new();
+    let mut compiled_pck = File::open(GAME_PCK).await.expect("Cannot open pck");
+    compiled_pck.read_to_end(&mut compiled_pck_bytes).await.expect("Cannot read");
+    drop(compiled_pck);
+
+    for _ in 0..16 - (compiled_script_bytes.len() % 16) {
+        compiled_script_bytes.push(0);
+    }
+
+    let mut tsc_bytes = Vec::new();
+    let mut tsc = File::open("build/webfishing-export/Scenes/Singletons/OptionsMenu/options_menu.tscn").await.expect("Cannot open options menu");
+    tsc.read_to_end(&mut tsc_bytes).await.expect("Cannot read");
+    drop(tsc);
+
+    compiled_script_bytes.append(&mut tsc_bytes);
+    for _ in 0..16 - (compiled_script_bytes.len() % 16) {
+        compiled_script_bytes.push(0);
+    }
+
+    replace_slice(&mut compiled_pck_bytes,
+                  &[0x47, 0x44, 0x53, 0x43, 0x0D, 0x00, 0x00, 0x00, 0x74, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00],
+                  "GDSC".as_ref(),
+                  &compiled_script_bytes
+    );
+
+
+    let mut compiled_pck = File::create(GAME_PCK).await.expect("Cannot open pck");
+    compiled_pck.write_all(compiled_pck_bytes.as_slice()).await.expect("Cannot write");
+}

src/patches/steam_network_patch.rs

···
+use async_std::fs::File;
+use async_std::io::{ReadExt, WriteExt};
+use crate::utils::gd_utils::replace_slice;
+
+const SCRIPT_PATH: &str = "build/webfishing-decomp/SteamNetwork.gd";
+const COMPILED_PATH: &str = "build/webfishing-recomp/SteamNetwork.gdc";
+const GAME_PCK: &str = "build/webfishing.app/Contents/Resources/webfishing.pck";
+
+pub(crate) async fn patch() {
+    crate::utils::gd_utils::decomp_file("build/webfishing-export/Scenes/Singletons/SteamNetwork.gdc");
+
+    let mut script = File::open(SCRIPT_PATH).await.expect("Cannot open script");
+    let mut script_txt = String::new();
+    script.read_to_string(&mut script_txt).await.expect("Cannot read script");
+    drop(script);
+
+    let patched_script = script_txt.replace("steam_id_remote", "remote_steam_id");
+    let mut script = File::create(SCRIPT_PATH).await.expect("Cannot open script");
+    script.write_all(patched_script.as_bytes()).await.expect("Cannot write");
+    drop(script);
+
+    crate::utils::gd_utils::recomp_file(SCRIPT_PATH);
+
+    let mut compiled_script_bytes = Vec::new();
+    let mut compiled_script = File::open(COMPILED_PATH).await.expect("Cannot open script");
+    compiled_script.read_to_end(&mut compiled_script_bytes).await.expect("Cannot read");
+    drop(compiled_script);
+
+    let mut compiled_pck_bytes = Vec::new();
+    let mut compiled_pck = File::open(GAME_PCK).await.expect("Cannot open pck");
+    compiled_pck.read_to_end(&mut compiled_pck_bytes).await.expect("Cannot read");
+    drop(compiled_pck);
+
+    replace_slice(&mut compiled_pck_bytes,
+                  &[0x47, 0x44, 0x53, 0x43, 0x0D, 0x00, 0x00, 0x00, 0x5B, 0x01, 0x00, 0x00, 0xE0, 0x00, 0x00, 0x00],
+                  "GDSC".as_ref(),
+                  &compiled_script_bytes
+    );
+
+    let mut compiled_pck = File::create(GAME_PCK).await.expect("Cannot open pck");
+    compiled_pck.write_all(compiled_pck_bytes.as_slice()).await.expect("Cannot write");
+}

src/utils/gd_utils.rs

···
+use std::process::Command;
+
+const RE_TOOLS: &str = "build/Godot RE Tools.app/Contents/MacOS/Godot RE Tools";
+
+// https://stackoverflow.com/a/54152901
+pub(crate) fn replace_slice<T>(buf: &mut [T], from: &[T], to: &[T], replace_with: &[T])
+where
+    T: Clone + PartialEq + From<u8>,
+{
+    for i in 0..=buf.len() - replace_with.len() {
+        if buf[i..].starts_with(from) {
+            for j in (i + 1)..=buf.len()  {
+                if buf[j..].starts_with(to) {
+                    let mut vec = Vec::new();
+                    vec.extend_from_slice(replace_with);
+                    if replace_with.len() < j-i {
+                        for _ in 0.. (j-i-replace_with.len()) {
+                            vec.push(T::try_from(0).expect("Failed to convert from usize"));
+                        }
+                    }
+                    buf[i..j].clone_from_slice(vec.as_slice());
+                    break;
+                }
+            }
+        }
+    }
+}
+
+pub(crate) fn decomp_file(path: &str) {
+    Command::new(RE_TOOLS)
+        .arg("--headless")
+        .arg(format!("--decompile=\"{}\"", path))
+        .arg("--bytecode=3.5.0")
+        .arg("--output-dir=build/webfishing-decomp")
+        .output().expect(format!("Failed to decompile file: {}", path).as_str());
+}
+
+pub(crate) fn recomp_file(path: &str) {
+    Command::new(RE_TOOLS)
+        .arg("--headless")
+        .arg(format!("--compile=\"{}\"", path))
+        .arg("--bytecode=3.5.0")
+        .arg("--output-dir=build/webfishing-recomp")
+        .output().expect(format!("Failed to recompile file: {}", path).as_str());
+}

src/utils/mod.rs

···
+pub mod gd_utils;