1.2.0 - Build system that allows full modding

.gitignore

···
-/target
-/build
-/.idea
+**/target
+**/build
+**/.idea

Cargo.lock

···
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
+name = "binary-reader"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d173c51941d642588ed6a13d464617e3a9176b8fe00dc2de182434c36812a5e"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "3.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
···
 ]
 
 [[package]]
+name = "godot_pck"
+version = "0.1.0"
+dependencies = [
+ "binary-reader",
+ "md5",
+]
+
+[[package]]
 name = "h2"
 version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 dependencies = [
  "value-bag",
 ]
+
+[[package]]
+name = "md5"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
 
 [[package]]
 name = "memchr"
···
 dependencies = [
  "asky",
  "async-std",
+ "godot_pck",
  "reqwest",
  "steamlocate",
  "sudo",

Cargo.toml

···
 sysinfo = "0.33.0"
 async-std = "1.13.0"
 sudo = "0.6.0"
-asky = "0.1.1"
+asky = "0.1.1"
+godot_pck = {path = "./src/godot_pck"}

src/godot_pck/Cargo.lock

···
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "binary-reader"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d173c51941d642588ed6a13d464617e3a9176b8fe00dc2de182434c36812a5e"
+dependencies = [
+ "byteorder",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "godot_pck"
+version = "0.1.0"
+dependencies = [
+ "binary-reader",
+ "md5",
+]
+
+[[package]]
+name = "md5"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"

src/godot_pck/Cargo.toml

···
+[package]
+name = "godot_pck"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+binary-reader = "0.4.5"
+md5 = "0.7.0"

src/godot_pck/src/lib.rs

···
+pub mod structs;

src/godot_pck/src/structs.rs

···
+use binary_reader::{BinaryReader, Endian};
+
+#[derive(Debug)]
+pub struct PCK {
+    version: u8,
+    major_version: u8,
+    minor_version: u8,
+    patch_version: u8,
+    files: Vec<PckFile>,
+}
+
+#[derive(Debug, Clone)]
+pub struct PckFile {
+    path: String,
+    offset: u64,
+    content: Vec<u8>,
+    md5: [u8; 16],
+}
+
+impl PCK {
+    /// Converts pck file bytes to a PCK struct
+    pub fn from_bytes(bytes: &[u8]) -> Result<PCK, &str> {
+        let chunked_start = bytes.chunks(16).position(|chunk| chunk.starts_with("GDPC".as_ref()));
+        if let None = chunked_start {
+            return Err("Invalid PCK");
+        };
+
+        let start_offset = chunked_start.unwrap() * 16;
+        let pck: Vec<u8> = bytes.to_vec().into_iter().skip(start_offset).collect();
+        let mut pck_reader = BinaryReader::from_vec(&pck);
+        pck_reader.set_endian(Endian::Little);
+
+        let _magic = pck_reader.read_u32().unwrap();
+        let version = pck_reader.read_u32().unwrap();
+        let major_version = pck_reader.read_u32().unwrap();
+        let minor_version = pck_reader.read_u32().unwrap();
+        let patch_version = pck_reader.read_u32().unwrap();
+
+        // Skip unused
+        let _ = pck_reader.read(64);
+
+        let num_files = pck_reader.read_u32().unwrap();
+        let mut files = vec![];
+        for _ in 0..num_files {
+            files.push(PckFile::from_bytes(&mut pck_reader, bytes));
+        }
+
+        Ok(PCK {
+            version: version as u8,
+            major_version: major_version as u8,
+            minor_version: minor_version as u8,
+            patch_version: patch_version as u8,
+            files
+        })
+    }
+
+    /// Converts a PCK struct to the byte vector representing a pck file
+    pub fn to_bytes(&self) -> Vec<u8> {
+        let mut bytes = vec![];
+        bytes.append(&mut "GDPC".as_bytes().to_vec());
+        bytes.append((self.version as u32).to_le_bytes().to_vec().as_mut());
+        bytes.append((self.major_version as u32).to_le_bytes().to_vec().as_mut());
+        bytes.append((self.minor_version as u32).to_le_bytes().to_vec().as_mut());
+        bytes.append((self.patch_version as u32).to_le_bytes().to_vec().as_mut());
+        bytes.append([0u8; 16*4].to_vec().as_mut());
+        bytes.append((self.files.len() as u32).to_le_bytes().to_vec().as_mut());
+
+        let mut file_offset = bytes.len()
+            + self.files.len() * (4 + 8 + 8 + 16)
+            + self.files.iter().map(|x| x.path.len() + (4 - (x.path.len() % 4))).sum::<usize>();
+
+        if file_offset % 16 != 0 {
+            file_offset = file_offset + (16 - (file_offset % 16));
+        }
+
+        let file_base_offset = file_offset;
+
+        let mut content : Vec<u8> = vec![];
+
+        for file in &self.files {
+            content.extend(&file.content);
+
+            let mut padded_content_len = file.content.len();
+            if padded_content_len % 16 != 0 {
+                padded_content_len = padded_content_len + (16 - (padded_content_len % 16));
+            }
+
+            for _ in file.content.len()..padded_content_len {
+                content.push(0);
+            }
+
+            let padded_length = file.path.len() + (4 - (file.path.len() % 4));
+
+            bytes.append((padded_length as u32).to_le_bytes().to_vec().as_mut());
+            bytes.append(file.path.as_bytes().to_vec().as_mut());
+            for _ in file.path.len()..padded_length {
+                bytes.push(0);
+            }
+            bytes.append((file_offset as u64).to_le_bytes().to_vec().as_mut());
+            bytes.append((padded_content_len as u64).to_le_bytes().to_vec().as_mut());
+            bytes.extend(file.md5);
+
+            file_offset += padded_content_len;
+        }
+
+        for _ in bytes.len()..file_base_offset {
+            bytes.push(0);
+        }
+
+        bytes.extend(content);
+        bytes
+    }
+
+    pub fn get_file_by_path(&self, path: &str) -> Option<&PckFile> {
+        self.files.iter().find(|x| x.path == path)
+    }
+
+    pub fn get_file_by_path_mut(&mut self, path: &str) -> Option<&mut PckFile> {
+        self.files.iter_mut().find(|x| x.path == path)
+    }
+
+    pub fn add_file(&mut self, new_file: PckFile) {
+        self.files.retain(|x| x.path != new_file.path);
+        self.files.push(new_file);
+    }
+}
+
+impl PckFile {
+    pub fn from_bytes(pck_reader: &mut BinaryReader, file_bytes: &[u8]) -> PckFile {
+        let path_length = pck_reader.read_u32().unwrap();
+        let path_bytes= pck_reader.read(path_length as usize).unwrap();
+        let path: String = String::from_utf8_lossy(path_bytes).replace("\0", "").to_string();
+        let offset = pck_reader.read_u64().unwrap();
+        let size = pck_reader.read_u64().unwrap();
+        let md5 = pck_reader.read(16).unwrap();
+        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 get_content(&self) -> &[u8] {
+        &self.content
+    }
+
+    pub fn set_content(&mut self, content: Vec<u8>) {
+        self.md5 = *md5::compute(&content);
+        self.content = content;
+    }
+}

src/main.rs

···
 mod patches;
 
 use std::fs::File;
-use std::io::{Write};
+use std::io::{Read, Write};
 use std::path::Path;
 use std::process::Command;
 use std::time::Duration;
···
 use steamlocate::SteamDir;
 use sudo::RunningAs;
 use sysinfo::ProcessesToUpdate;
+use godot_pck::structs::PCK;
 
 static WEBFISHING_APPID: u32 = 3146520;
 
···
         .output().expect("Could not copy webfishing.app");
 }
 
-fn decomp_game() {
-    let webfishing_pck_path = Path::new("build").join("webfishing.app").join("Contents").join("Resources").join("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]
 async fn main() {
     if !Path::exists("build".as_ref()) {
···
         build_webfishing_macos(webfishing_path);
     }
 
-    if sudo::check() != RunningAs::Root {
-        decomp_game();
-        patches::steam_network_patch::patch().await;
-        patches::options_menu_patch::patch().await;
+    if sudo::check()!= RunningAs::Root {
+        let _ = create_dir("build/webfishing-export").await;
+        let mut bytes = vec![];
+        File::open(webfishing_path.join("webfishing.exe")).unwrap().read_to_end(&mut bytes).unwrap();
+        let mut pck = PCK::from_bytes(&*bytes).unwrap();
+
+        patches::steam_network_patch::patch(&mut pck).await;
+        patches::options_menu_patch::patch(&mut pck).await;
         println!("Root permissions needed to sign webfishing");
+
+        let bytes = &pck.to_bytes();
+        File::create("build/webfishing.app/Contents/Resources/webfishing.pck").unwrap().write(bytes).expect("Could not write to webfishing.pck");
     }
 
     sudo::escalate_if_needed().expect("Could not escalate to sign the app");

src/patches/options_menu_patch.rs

···
 use async_std::fs::File;
 use async_std::io::{ReadExt, WriteExt};
-use crate::utils::gd_utils::replace_slice;
+use godot_pck::structs::PCK;
 
+const RESOURCE_PATH: &str = "res://Scenes/Singletons/OptionsMenu/options_menu.gdc";
+const FILE_PATH: &str = "build/webfishing-export/options_menu.gdc";
 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(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");
 
-pub(crate) async fn patch() {
-    crate::utils::gd_utils::decomp_file("build/webfishing-export/Scenes/Singletons/OptionsMenu/options_menu.gdc");
+    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);
 
     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", "OS.window_borderless\n");
+    let patched_script = script_txt.replace("OS.window_borderless = PlayerData.player_options.fullscreen == 1", "");
     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);
-    let mut compiled_pck_bytes: Vec<u8> = compiled_pck_bytes.into_iter().rev().skip_while(|b| (*b) == 0).collect::<Vec<u8>>().into_iter().rev().collect();
-
-    if compiled_script_bytes.len() % 16 > 0 {
-        let to_add = 16 - (compiled_script_bytes.len() % 16);
-        for _ in 0..to_add {
-            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);
+    let mut file = File::open(COMPILED_PATH).await.expect("Cannot open compiled script");
+    let mut new_content = vec![];
+    file.read_to_end(&mut new_content).await.unwrap();
 
-    compiled_script_bytes.append(&mut tsc_bytes);
-    let mut compiled_pck_bytes: Vec<u8> = compiled_pck_bytes.into_iter().rev().skip_while(|b| (*b) == 0).collect::<Vec<u8>>().into_iter().rev().collect();
-    if compiled_script_bytes.len() % 16 > 0 {
-        let to_add = 16 - (compiled_script_bytes.len() % 16);
-        for _ in 0..to_add {
-            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");
+    pck_file.set_content(new_content);
 }

src/patches/steam_network_patch.rs

···
+use godot_pck::structs::PckFile;
 use async_std::fs::File;
 use async_std::io::{ReadExt, WriteExt};
-use crate::utils::gd_utils::replace_slice;
+use godot_pck::structs::PCK;
 
+const RESOURCE_PATH: &str = "res://Scenes/Singletons/SteamNetwork.gdc";
+const FILE_PATH: &str = "build/webfishing-export/SteamNetwork.gdc";
 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");
+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 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);
 
     let mut script = File::open(SCRIPT_PATH).await.expect("Cannot open script");
     let mut script_txt = String::new();
···
 
     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 file = File::open(COMPILED_PATH).await.expect("Cannot open compiled script");
+    let mut new_content = vec![];
+    file.read_to_end(&mut new_content).await.unwrap();
 
-    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");
+    pck_file.set_content(new_content);
 }

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: &mut [T], from: &[T], to: &[T], replace_with: &[T])
+pub(crate) fn replace_slice<T>(buf: &[T], from: &[T], to: &[T], replace_with: &mut [T]) -> Vec<T>
 where
     T: Clone + PartialEq + From<u8>,
 {
-    for mut i in 0..=buf.len() - replace_with.len() {
+    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) {
-                    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());
+                    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) {
-    Command::new(RE_TOOLS)
+    dbg!(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());
+        .output().expect(format!("Failed to decompile file: {}", path).as_str()));
 }
 
 pub(crate) fn recomp_file(path: &str) {