1.3.0 - Modding implemented

Cargo.lock

···
 checksum = "512761e0bb2578dd7380c6baaa0f4ce03e84f95e960231d1dec8bf4d7d6e2627"
 
 [[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
 name = "asky"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
 
 [[package]]
+name = "bytecount"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ce89b21cab1437276d2650d57e971f9d548a2d9037cc231abdc0562b97498ce"
+
+[[package]]
 name = "byteorder"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
+name = "chrono"
+version = "0.4.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e36cc9d416881d2e24f9a963be5fb1cd90966419ac844274161d10488b3e825"
+dependencies = [
+ "android-tzdata",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
 name = "colored"
 version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "iana-time-zone"
+version = "0.1.61"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core 0.52.0",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
 name = "icu_collections"
 version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
 
 [[package]]
 name = "miniz_oxide"
···
 ]
 
 [[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
+[[package]]
+name = "nom_locate"
+version = "4.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e3c83c053b0713da60c5b8de47fe8e494fe3ece5267b2f23090a07a053ba8f3"
+dependencies = [
+ "bytecount",
+ "memchr",
+ "nom",
+]
+
+[[package]]
 name = "ntapi"
 version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e8a3895c6391c39d7fe7ebc444a87eb2991b2a0bc718fdabd071eec617fc68e4"
 dependencies = [
  "winapi",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
 ]
 
 [[package]]
···
  "redox_syscall",
  "smallvec",
  "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "patch-apply"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fe95476ec50a4e9b95ed12a4677ff5996aba4329bf2535fb21c49afaad20809"
+dependencies = [
+ "chrono",
+ "nom",
+ "nom_locate",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "serde"
-version = "1.0.216"
+version = "1.0.217"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e"
+checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.216"
+version = "1.0.217"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e"
+checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
 dependencies = [
  "proc-macro2",
  "quote",
···
  "asky",
  "async-std",
  "godot_pck",
+ "patch-apply",
  "reqwest",
+ "serde",
+ "serde_derive",
+ "serde_json",
  "steamlocate",
  "sudo",
  "sysinfo",
···
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "12342cb4d8e3b046f3d80effd474a7a02447231330ef77d71daa6fbc40681143"
 dependencies = [
- "windows-core",
+ "windows-core 0.57.0",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
  "windows-targets 0.52.6",
 ]
 

Cargo.toml

···
 async-std = "1.13.0"
 sudo = "0.6.0"
 asky = "0.1.1"
-godot_pck = {path = "./src/godot_pck"}
+patch-apply = "0.8.3"
+serde = { version = "1.0.217" }
+serde_json = { version = "1.0.134" }
+serde_derive = { version = "1.0.217" }
+
+
+godot_pck = {path = "./src/godot_pck"}

README.md

···
 - renaming `steam_id_remote` dictionnary key to `remote_steam_id` to fix network spam detection that resulted in timeouts
 - prevent the game from crashing when saving the options by not setting any values to `OS.windowed_borderless` because setting a value to it crashes the game somehow
 
+## How to make a mod?
+
+As you can see in the `example_mods` folder, a mod has typically two folders and a single `manifest.json` file having the following structure:
+```json
+{
+  "name": "Ship Mod", // Mod name
+  "author": "Estym", // Author
+  
+  "pck_info": { // (Optional)
+    "directory": "pck", // Relative folder path to where the mod resources are
+    "resource_prefix": "res://Mods/Ship/" // Resource path prefix for the mod resources
+  },
+  
+  "mod_patches": [ // Array of patches
+    {
+      "resource": "res://Scenes/Entities/Player/player.gdc", // Resource to patch
+      "patch_file": "patch/player.patch" // relative file path to the patch file
+    }
+  ],
+  
+  "deps": [] // Dependencies for the mod (Optional)
+}
+```
+
+### Notes:
+- The patch files are made by using `$ git diff [original_file] [modded_file] > file.patch`
+
 ## Credits
 
 [@vimaexd](https://github.com/vimaexd) for their blog post !

example_mods/ship/manifest.json

···
+{
+  "name": "Ship Mod",
+  "author": "Estym",
+  "pck_info": {
+    "directory": "pck",
+    "resource_prefix": "res://Mods/Ship/"
+  },
+  "mod_patches": [
+    {
+      "resource": "res://Scenes/Entities/Player/player.gdc",
+      "patch_file": "patch/player.patch"
+    }
+  ],
+  "deps": []
+}

example_mods/ship/patch/player.patch

···
+diff --git a/webfishing/Scenes/Entities/Player/player.gd b/Users/evann/Godot/Webfishing/Scenes/Entities/Player/player.gd
+index 3879ff8..cc20048 100644
+--- a/webfishing/Scenes/Entities/Player/player.gd
++++ b/Users/evann/Godot/Webfishing/Scenes/Entities/Player/player.gd
+@@ -30,6 +30,7 @@ export  var NPC_cosmetics = {"species": "species_cat", "pattern": "pattern_none"
+ export  var NPC_name = "NPC Test"
+ export  var NPC_title = "npc title here"
+ 
++var ship_mod_instance = preload("res://Mods/Ship/ship.gd").new()
+ var camera_zoom = 5.0
+ 
+ var direction = Vector3()
+@@ -341,6 +342,7 @@ func _process(delta):
+ 
+ func _controlled_process(delta):
+ 	_get_input()
++	
+ 	_process_movement(delta)
+ 	_process_timers()
+ 	_interact_check()
+@@ -480,7 +482,7 @@ func _process_timers():
+ 
+ func _get_input():
+ 	direction = Vector3.ZERO
+-	
++
+ 	if Input.is_action_just_released("primary_action"): _primary_action_release()
+ 	if Input.is_action_pressed("primary_action"): _primary_action_hold()
+ 	else: primary_hold_timer = 0
+@@ -538,8 +540,10 @@ func _get_input():
+ 	
+ 	mouse_look = false
+ 	
++	if ship_mod_instance.is_sitting_on_ship(self):
++		ship_mod_instance.process_ship(self, get_world())
++		return
+ 	if sitting: return 
+-	
+ 	if Input.is_action_pressed("move_forward"): direction -= cam_base.transform.basis.z
+ 	if Input.is_action_pressed("move_back"): direction += cam_base.transform.basis.z
+ 	if Input.is_action_pressed("move_right"): direction += cam_base.transform.basis.x
+@@ -1405,16 +1409,6 @@ func _create_prop(ref, offset = Vector3(0, 1, 0), restrict_to_one = false):
+ 			return false
+ 	
+ 	
+-	if $detection_zones / prop_detect.get_overlapping_bodies().size() > 0 or not is_on_floor() or not $detection_zones / prop_ray.is_colliding():
+-		PlayerData._send_notification("invalid prop placement", 1)
+-		return false
+-	
+-	
+-	if prop_ids.size() > 4:
+-		PlayerData._send_notification("prop limit reached", 1)
+-		return false
+-	
+-	
+ 	var item = PlayerData._find_item_code(ref)
+ 	var data = Globals.item_data[item["id"]]["file"]
+ 	var ver_offset = Vector3(0, 1.0, 0) * (1.0 - player_scale)

example_mods/ship/pck/ship.gd

···
+extends Node
+
+var ship
+# Declare member variables here. Examples:
+# var a = 2
+# var b = "text"
+var entity_node
+
+# Called when the node enters the scene tree for the first time.
+func _ready():
+	
+	pass # Replace with function body.
+
+func process_ship(player, world):
+	var entities = player.get_parent()
+	for i in entities.get_children():
+		if i.actor_type == "table":
+			if Input.is_key_pressed(KEY_SHIFT):
+				i.translation.y += 0.05
+				i.packet_cooldown = 0
+				i._network_share()
+			elif Input.is_key_pressed(KEY_CONTROL):
+				i.translation.y -= 0.05
+				i.packet_cooldown = 0
+				i._network_share()
+
+
+func get_prop_by_ref(ref):
+	for obj in PlayerData.inventory:
+		if obj.ref == ref:
+			return obj
+	return null
+
+func is_sitting_on_ship(player):
+
+	for prop in PlayerData.props_placed:
+		var obj = get_prop_by_ref(prop.ref)
+		if obj != null && obj.id == 'prop_table':
+			ship = obj
+			return player.sitting
+	return false;
+	

src/godot_pck/src/structs.rs

···
 #[derive(Debug, Clone)]
 pub struct PckFile {
     path: String,
-    offset: u64,
     content: Vec<u8>,
     md5: [u8; 16],
 }
···
         let content: Vec<u8> = file_bytes.iter().skip(offset as usize).take(size as usize).cloned().collect();
         PckFile {
             path,
-            offset,
             content,
             md5: <[u8; 16]>::try_from(md5).unwrap(),
+        }
+    }
+
+    pub fn new_file(path: String, content: Vec<u8>) -> PckFile {
+        PckFile {
+            path,
+            md5: *md5::compute(&content),
+            content
         }
     }
 

src/main.rs

···
 mod utils;
 mod patches;
+mod mods;
 
+use std::env::{current_exe, set_current_dir};
 use std::fs::File;
 use std::io::{Read, Write};
 use std::path::Path;
 use std::process::Command;
 use std::time::Duration;
-use asky::Confirm;
+use asky::Text;
 use async_std::fs::create_dir;
 use steamlocate::SteamDir;
 use sudo::RunningAs;
···
 use godot_pck::structs::PCK;
 
 static WEBFISHING_APPID: u32 = 3146520;
-
-
 
 async fn install_webfishing(location: &SteamDir) {
     let steam_location = location.path();
···
 
 #[tokio::main]
 async fn main() {
+    set_current_dir(current_exe().unwrap().parent().expect("Could not get current dir")).expect("Could not set current dir");
     if !Path::exists("build".as_ref()) {
         println!("Creating build folder");
         create_dir("build").await.expect("could not create build folder");
···
 
         patches::steam_network_patch::patch(&mut pck).await;
         patches::options_menu_patch::patch(&mut pck).await;
+        mods::mods::process_mods(&mut pck);
         println!("Root permissions needed to sign webfishing");
 
         let bytes = &pck.to_bytes();
···
         .output()
         .expect("Could not execute xattr");
 
-    if Confirm::new("Do you wanna install Webfishing in the app folder?").prompt().expect("Could not confirm to install the webfishing") {
-        Command::new("rsync")
-            .arg("-a")
-            .arg("build/webfishing.app")
-            .current_dir("/Applications/")
-            .output().expect("Could not execute rsync");
+    println!("Webfishing is in the build folder !");
 
-        Command::new("rm")
-            .arg("-r")
-            .arg("build/webfishing.app")
-            .output().expect("Could not remove webfishing.app");
-
-        println!("Successfully installed webfishing !");
-    } else {
-        println!("Webfishing is in the build folder !")
-    }
+    Text::new("Press Enter to quit").prompt().expect("Could not confirm to quit");
 }

src/mods/mod.rs

···
+mod structs;
+pub mod mods;

src/mods/mods.rs

···
+use std::fs;
+use std::fs::{read_dir, File};
+use std::io::{Read, Write};
+use std::path::{Path, PathBuf};
+use godot_pck::structs::{PckFile, PCK};
+use crate::mods::structs::{Manifest, Patch, PckInfo};
+use crate::utils;
+
+fn read_manifests() -> Vec<Manifest> {
+    let mut manifests = Vec::new();
+    let mods_dir = fs::read_dir("mods").expect("Cannot read mods directory");
+    for mod_dir in mods_dir {
+        let mod_dir = mod_dir.expect("Failed to read mod directory");
+        if !mod_dir.path().is_dir() {continue}
+
+        if !mod_dir.path().join("manifest.json").exists() {
+            println!("No manifest found in {:?}", mod_dir.path());
+            continue;
+        }
+
+        let mut manifest: Manifest = serde_json::from_reader(fs::File::open(mod_dir.path().join("manifest.json")).unwrap()).unwrap();
+        manifest.path = mod_dir.path().display().to_string();
+
+        manifests.push(manifest);
+    }
+    manifests
+}
+
+fn check_mods(manifests: Vec<Manifest>) -> Vec<Manifest> {
+    let mod_names: Vec<String> = manifests.iter().map(|m| m.get_name()).collect();
+
+    manifests.into_iter().filter(|manifest: &Manifest| {
+        let mut res = true;
+        println!("Checking {}", manifest.get_name());
+        for mod_name in manifest.get_dependencies() {
+            if !mod_names.contains(&mod_name) {
+                println!("\t- missing dependency {}", mod_name);
+                res = false;
+            }
+        }
+        res
+    }).collect::<Vec<Manifest>>()
+}
+
+fn apply_patch(manifest: &Manifest, pck: &mut PCK, patch: &&Patch) {
+    let resource_path = patch.get_resource();
+    let resource_path = resource_path.as_str();
+    let resource = pck.get_file_by_path_mut(resource_path).expect(&format!("Could not patch resource {}", resource_path));
+    let resource_name = resource_path.split("res://").last().expect("could not remove res://").split("/").last().expect("Could not get last part of resource");
+    if resource_path.ends_with(".gdc") {
+        let mut resource_exported = File::create(format!("build/webfishing-export/{}", resource_name)).expect(&format!("Could not create mod resource {}", resource_name));
+        resource_exported.write_all(resource.get_content()).expect(&format!("Could not write mod resource {}", resource_name));
+        drop(resource_exported);
+        utils::gd_utils::decomp_script(&format!("build/webfishing-export/{}", resource_name))
+    } else {
+        let mut resource_exported = File::create(format!("build/webfishing-decomp/{}", resource_name)).expect(&format!("Could not create mod resource {}", resource_name));
+        resource_exported.write_all(resource.get_content()).expect(&format!("Could not write mod resource {}", resource_name));
+        drop(resource_exported);
+    }
+
+    let mut patch_file = File::open(format!("{}/{}", manifest.path, patch.get_patch_file())).expect(&format!("Could not open patch file {}", patch.get_patch_file()));
+    let mut patch_file_content = String::new();
+    patch_file.read_to_string(&mut patch_file_content).expect(&format!("Could not read patch file {}", patch.get_patch_file()));
+    drop(patch_file);
+
+    let patch_struct = patch_apply::Patch::from_single(patch_file_content.as_str()).expect(&format!("Could not create patch {}", patch.get_patch_file()));
+
+    let mut file_to_patch = File::open(format!("build/webfishing-decomp/{}", resource_name.replace(".gdc", ".gd"))).expect(&format!("Could not open file {}", resource_name));
+    let mut file_to_patch_content = String::new();
+    file_to_patch.read_to_string(&mut file_to_patch_content).expect(&format!("Could not read patch file {}", resource_name));
+    drop(file_to_patch);
+
+    let patched_content = patch_apply::apply(file_to_patch_content, patch_struct);
+
+    if resource_path.ends_with(".gdc") {
+        let mut patched_file = File::create(format!("build/webfishing-decomp/{}", resource_name.replace(".gdc", ".gd"))).unwrap();
+        patched_file.write_all(patched_content.as_bytes()).unwrap();
+        drop(patched_file);
+
+        utils::gd_utils::recomp_file(&format!("build/webfishing-decomp/{}", resource_name.replace(".gdc", ".gd")));
+
+        let mut recompiled_patched_file = File::open(format!("build/webfishing-recomp/{}", resource_name)).expect("Could not open recompiled patched file");
+        let mut recompiled_patched_content = Vec::new();
+        recompiled_patched_file.read_to_end(&mut recompiled_patched_content).expect(&format!("Could not read patched file {}", resource_name));
+
+        resource.set_content(recompiled_patched_content);
+    } else {
+        resource.set_content(Vec::from(patched_content.as_bytes()));
+    }
+}
+
+fn add_recursive_files_to_pck(dir: String, pck: &mut PCK, pck_info: &PckInfo) {
+    let directory = read_dir(Path::new(dir.as_str())).expect("read_dir failed");
+    for entry in directory {
+        let entry = entry.expect("Failed to read entry");
+        if entry.path().is_file() {
+            let path: PathBuf = entry.path().iter()
+                .skip_while(|s| *s != pck_info.get_directory().as_str())
+                .skip(1)
+                .collect();
+
+            let resource_path = format!("{}/{}", pck_info.get_resource_prefix(), path.display()).replace("//", "/").replace("res:/", "res://");
+
+            let mut resource_file = File::open(entry.path()).expect("Cannot open resource file");
+            let mut resource_file_content = Vec::new();
+            resource_file.read_to_end(&mut resource_file_content).expect("Cannot read resource file");
+            drop(resource_file);
+
+            let pck_file = PckFile::new_file(resource_path, resource_file_content);
+            pck.add_file(pck_file);
+        } else {
+            add_recursive_files_to_pck(entry.path().display().to_string(), pck, pck_info);
+        }
+    }
+}
+
+fn apply_mod(manifest: &Manifest, pck: &mut PCK) {
+    println!("Applying {} by {}", manifest.get_name(), manifest.get_author());
+    // Apply game patches
+    for patch in manifest.get_patches() {
+        apply_patch(manifest, pck, &patch);
+    };
+
+    // Add pck data
+    match manifest.get_pck_info() {
+        Some(pck_info) => {
+            add_recursive_files_to_pck(format!("{}/{}",manifest.path,pck_info.get_directory()), pck, pck_info);
+        }
+        None => {}
+    }
+}
+
+
+pub fn process_mods(pck: &mut PCK) {
+    if !Path::exists("mods".as_ref()) {
+        fs::create_dir(Path::new("mods")).expect("Failed to create mods directory");
+    }
+
+    let manifests = read_manifests();
+    println!("Found {} mods", manifests.len());
+
+    // Dependency checking
+    println!("Checking mod dependencies");
+    let mut checked_manifests = check_mods(manifests);
+    while !checked_manifests.clone().into_iter().map(|x| x.get_name()).eq(check_mods(checked_manifests.clone()).into_iter().map(|x| x.get_name())) {
+        checked_manifests = check_mods(checked_manifests);
+    }
+
+    println!("Checked all mod dependencies, loading {} mods", checked_manifests.len());
+
+    for manifest in checked_manifests {
+        apply_mod(&manifest, pck)
+    }
+}

src/mods/structs.rs

···
+use serde_derive::{Deserialize};
+
+#[derive(Deserialize, Debug, Default, Clone)]
+pub struct Manifest {
+    name: String,
+    author: String,
+    pck_info: Option<PckInfo>,
+    patches: Vec<Patch>,
+    deps: Option<Vec<String>>,
+
+    // Reserved
+    #[serde(skip_serializing)]
+    #[serde(default)]
+    pub path: String,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct Patch {
+    resource: String,
+    patch_file: String,
+}
+
+#[derive(Deserialize, Debug, Default, Clone)]
+pub struct PckInfo {
+    directory: String,
+    resource_prefix: String
+}
+
+
+impl Manifest {
+    pub fn get_dependencies(&self) -> Vec<String> {
+        match self.deps {
+            Some(ref deps) => deps.clone(),
+            None => Vec::new()
+        }
+    }
+
+    pub fn get_author(&self) -> String {
+        self.author.clone()
+    }
+
+    pub fn get_name(&self) -> String {
+        self.name.clone()
+    }
+
+    pub fn get_patches(&self) -> &Vec<Patch> {
+        &self.patches
+    }
+
+    pub fn get_pck_info(&self) -> &Option<PckInfo> {
+        &self.pck_info
+    }
+}
+
+impl Patch {
+    pub fn get_resource(&self) -> String {
+        self.resource.clone()
+    }
+
+    pub fn get_patch_file(&self) -> String {
+        self.patch_file.clone()
+    }
+}
+
+impl PckInfo {
+    pub fn get_directory(&self) -> String {
+        self.directory.clone()
+    }
+
+    pub fn get_resource_prefix(&self) -> String {
+        self.resource_prefix.clone()
+    }
+}

src/patches/mod.rs

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

src/patches/options_menu_patch.rs

···
 const COMPILED_PATH: &str = "build/webfishing-recomp/options_menu.gdc";
 pub(crate) async fn patch(pck: &mut PCK) {
     println!("Patching {} files...", RESOURCE_PATH);
-    let mut pck_file = pck.get_file_by_path_mut(RESOURCE_PATH).expect("Couldn't find options_menu.gdc file");
+    let pck_file = pck.get_file_by_path_mut(RESOURCE_PATH).expect("Couldn't find options_menu.gdc file");
 
     let content = pck_file.get_content();
     let mut exported_file = File::create(FILE_PATH).await.expect("Couldn't create file");
     exported_file.write_all(content).await.unwrap();
     drop(exported_file);
 
-    crate::utils::gd_utils::decomp_file(FILE_PATH);
+    crate::utils::gd_utils::decomp_script(FILE_PATH);
 
     let mut script = File::open(SCRIPT_PATH).await.expect("Cannot open script");
     let mut script_txt = String::new();

src/patches/steam_network_patch.rs

···
 
 pub(crate) async fn patch(pck: &mut PCK) {
     println!("Patching {} files...", RESOURCE_PATH);
-    let mut pck_file: &mut PckFile = pck.get_file_by_path_mut(RESOURCE_PATH).expect("Couldn't find options_menu.gdc file");
+    let pck_file: &mut PckFile = pck.get_file_by_path_mut(RESOURCE_PATH).expect("Couldn't find options_menu.gdc file");
 
     let content = pck_file.get_content();
     let mut exported_file = File::create(FILE_PATH).await.expect("Couldn't create file");
     exported_file.write_all(content).await.expect("Couldn't write file");
     drop(exported_file);
 
-    crate::utils::gd_utils::decomp_file(FILE_PATH);
+    crate::utils::gd_utils::decomp_script(FILE_PATH);
 
     let mut script = File::open(SCRIPT_PATH).await.expect("Cannot open script");
     let mut script_txt = String::new();

src/utils/gd_utils.rs

···
 
 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: &[T], from: &[T], to: &[T], replace_with: &mut [T]) -> Vec<T>
-where
-    T: Clone + PartialEq + From<u8>,
-{
-    let mut last_j = 0;
-    let mut res : Vec<T> = Vec::new();
-    for i in 0..=buf.len() {
-        if buf[i..].starts_with(from) {
-            res.append(&mut buf[last_j..i].to_vec());
-            for j in (i + 1)..=buf.len()  {
-                if buf[j..].starts_with(to) {
-                    res.append(replace_with.to_vec().as_mut());
-                    last_j = j;
-                    break;
-                }
-            }
-        }
-    }
-
-    res.append(&mut buf[last_j..].to_vec());
-    res
-}
-
-pub(crate) fn decomp_file(path: &str) {
+pub(crate) fn decomp_script(path: &str) {
     Command::new(RE_TOOLS)
         .arg("--headless")
         .arg(format!("--decompile=\"{}\"", path))