yay!

Author: Trolldemorted

.github/workflows/release.yml

@@ -18,6 +18,7 @@ jobs:
         mv target/i686-pc-windows-msvc/release/fix_damage_to_offside_ship_artillery.dll ./mods/
         mv target/i686-pc-windows-msvc/release/fix_invulnerable_ship_artillery_slots.dll ./mods/
         mv target/i686-pc-windows-msvc/release/fix_market_hall_production_town.dll ./mods/
+        mv target/i686-pc-windows-msvc/release/fix_multiplayer_locks.dll ./mods/
         mv target/i686-pc-windows-msvc/release/fix_new_settlement_ware_production.dll ./mods/
         mv target/i686-pc-windows-msvc/release/fix_siege_beggar_satisfaction_bonus.dll ./mods/
         mv target/i686-pc-windows-msvc/release/high_res.dll ./mods/

Cargo.toml

@@ -40,4 +40,4 @@ log = "0.4"
 sysinfo = "0.29"
 win_dbg_logger = "0.1"
 num-traits = "0.2"
-num-derive = "0.3"
+num-derive = "0.4"

mod-fix-multiplayer-locks/src/ffi.rs

@@ -1,7 +1,7 @@
-use std::{backtrace::Backtrace, ffi::c_void, thread};
+use std::{ffi::c_void, thread};
 
 use hooklet::windows::x86::{deploy_rel32_raw, replace_slice_rwx, X86Rel32Type};
-use log::{debug, error, trace};
+use log::{debug, trace};
 use p3_api::{mods::init_mod, operations::OperationsPtr};
 
 #[no_mangle]
@@ -56,52 +56,60 @@ pub unsafe extern "C" fn start() -> u32 {
     debug!("Fix operations_network_host_send_to_all_and_move_to_current_ops current lock");
     match deploy_rel32_raw(0x0054BCCB, &lock_current_clean as *const c_void as _, X86Rel32Type::Call) {
         Ok(_) => {}
-        Err(_) => return 11,
+        Err(_) => return 9,
     }
     let operations_network_host_send_to_all_and_move_to_current_ops_lock: [u8; 5] = [0x90, 0x90, 0x90, 0x90, 0x90];
     match replace_slice_rwx(0x0054BCCB + 5, &operations_network_host_send_to_all_and_move_to_current_ops_lock) {
         Ok(_) => {}
-        Err(_) => return 12,
+        Err(_) => return 10,
     }
 
     debug!("Fix operations_network_host_send_to_all_and_move_to_current_ops current unlock");
     match deploy_rel32_raw(0x0054BD2C, &unlock_current_clean as *const c_void as _, X86Rel32Type::Call) {
         Ok(_) => {}
-        Err(_) => return 13,
+        Err(_) => return 11,
     }
     match replace_slice_rwx(0x0054BD2C + 5, &[0x90]) {
         Ok(_) => {}
-        Err(_) => return 14,
+        Err(_) => return 12,
     }
 
     debug!("Fix operations_network_host_receive_from_all_and_own_pending pending lock");
     // There is a callee saved register restoring `pop ebx`` in the lock code (╯°□°）╯︵ ┻━┻
     match deploy_rel32_raw(0x0054B90D, &lock_pending_clean as *const c_void as _, X86Rel32Type::Call) {
         Ok(_) => {}
-        Err(_) => return 15,
+        Err(_) => return 13,
     }
     match deploy_rel32_raw(0x0054B90D + 5, 0x0054B932, X86Rel32Type::Jump) {
         Ok(_) => {}
-        Err(_) => return 16,
+        Err(_) => return 14,
     }
 
     debug!("Fix operations_network_host_receive_from_all_and_own_pending pending unlock");
     match deploy_rel32_raw(0x0054B949, &unlock_pending_clean as *const c_void as _, X86Rel32Type::Call) {
         Ok(_) => {}
-        Err(_) => return 17,
+        Err(_) => return 15,
     }
     // We sneak in the `pop ebx` here to keep the stack intact 🧠
     match replace_slice_rwx(0x0054B949 + 5, &[0x5b, 0x90, 0x90, 0x90, 0x90]) {
         Ok(_) => {}
-        Err(_) => return 18,
+        Err(_) => return 16,
     }
 
     debug!("Fix operations_client_receive_from_host current lock");
     match deploy_rel32_raw(0x0054B13F, &try_lock_current_clean as *const c_void as _, X86Rel32Type::Call) {
         Ok(_) => {}
-        Err(_) => return 19,
+        Err(_) => return 17,
     }
     match replace_slice_rwx(0x0054B13F + 5, &[0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90]) {
+        Ok(_) => {}
+        Err(_) => return 18,
+    }
+    match deploy_rel32_raw(0x0054B200, &try_lock_current_clean as *const c_void as _, X86Rel32Type::Call) {
+        Ok(_) => {}
+        Err(_) => return 19,
+    }
+    match replace_slice_rwx(0x0054B200 + 5, &[0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90]) {
         Ok(_) => {}
         Err(_) => return 20,
     }
@@ -120,28 +128,64 @@ pub unsafe extern "C" fn start() -> u32 {
         Ok(_) => {}
         Err(_) => return 23,
     }
+    match deploy_rel32_raw(0x0054B21C, &unlock_current_clean as *const c_void as _, X86Rel32Type::Call) {
+        Ok(_) => {}
+        Err(_) => return 24,
+    }
+    match replace_slice_rwx(0x0054B21C + 5, &[0x90]) {
+        Ok(_) => {}
+        Err(_) => return 25,
+    }
+    // Fix jnz above
+    match replace_slice_rwx(0x0054B20E + 1, &[0x12]) {
+        Ok(_) => {}
+        Err(_) => return 26,
+    }
 
     debug!("Fix operations_network_client_send_pending_operations pending lock");
+    match deploy_rel32_raw(0x0054AFB7, &lock_pending_clean as *const c_void as _, X86Rel32Type::Call) {
+        Ok(_) => {}
+        Err(_) => return 27,
+    }
+    match deploy_rel32_raw(0x0054AFB7 + 5, 0x0054AFD3, X86Rel32Type::Jump) {
+        Ok(_) => {}
+        Err(_) => return 28,
+    }
+
     debug!("Fix operations_network_client_send_pending_operations pending unlock");
-    let addr: u32 = &try_lock_current_clean as *const _ as _;
-    debug!("#### {addr}");
+    match deploy_rel32_raw(0x0054B049, &unlock_pending_clean as *const c_void as _, X86Rel32Type::Call) {
+        Ok(_) => {}
+        Err(_) => return 29,
+    }
+    match deploy_rel32_raw(0x0054B063, &unlock_pending_clean as *const c_void as _, X86Rel32Type::Call) {
+        Ok(_) => {}
+        Err(_) => return 30,
+    }
+    match replace_slice_rwx(0x0054B049 + 5, &[0x90]) {
+        Ok(_) => {}
+        Err(_) => return 31,
+    }
+    match replace_slice_rwx(0x0054B063 + 5, &[0x90]) {
+        Ok(_) => {}
+        Err(_) => return 32,
+    }
 
     0
 }
 
 #[no_mangle]
 unsafe extern "stdcall" fn lock_pending() {
     let thread_id = thread::current().id();
-    debug!("lock_pending {thread_id:?}");
+    trace!("lock_pending {thread_id:?}");
     crate::lock(&crate::PENDING_OPS_LOCK);
 }
 
 #[no_mangle]
 unsafe extern "stdcall" fn try_lock_pending() -> u32 {
     let thread_id = thread::current().id();
-    debug!("try_lock_pending {thread_id:?}");
+    trace!("try_lock_pending {thread_id:?}");
     let in_use = crate::try_lock(&crate::PENDING_OPS_LOCK);
-    debug!("try_lock_pending {thread_id:?} {in_use}");
+    trace!("try_lock_pending {thread_id:?} {in_use}");
     in_use
 }
 
@@ -151,7 +195,7 @@ unsafe extern "stdcall" fn unlock_pending() {
     // Unlock ops are often not guarded by the mp check, so we have to do an mp check here.
     if operations.get_status() & 0x0c != 0 {
         let thread_id = thread::current().id();
-        debug!("unlock_pending {thread_id:?}");
+        trace!("unlock_pending {thread_id:?}");
         crate::unlock(&crate::PENDING_OPS_LOCK);
     } else {
         crate::PENDING_OPS_LOCK.store(0, std::sync::atomic::Ordering::SeqCst);
@@ -161,16 +205,16 @@ unsafe extern "stdcall" fn unlock_pending() {
 #[no_mangle]
 unsafe extern "stdcall" fn lock_current() {
     let thread_id = thread::current().id();
-    debug!("lock_current {thread_id:?}");
+    trace!("lock_current {thread_id:?}");
     crate::lock(&crate::CURRENT_OPS_LOCK);
 }
 
 #[no_mangle]
 unsafe extern "stdcall" fn try_lock_current() -> u32 {
     let thread_id = thread::current().id();
-    debug!("try_lock_current {thread_id:?}");
+    trace!("try_lock_current {thread_id:?}");
     let in_use = crate::try_lock(&crate::CURRENT_OPS_LOCK);
-    debug!("try_lock_current {thread_id:?} {in_use}");
+    trace!("try_lock_current {thread_id:?} {in_use}");
     in_use
 }
 
@@ -180,7 +224,7 @@ unsafe extern "stdcall" fn unlock_current() {
     // Unlock ops are often not guarded by the mp check, so we have to do an mp check here.
     if operations.get_status() & 0x0c != 0 {
         let thread_id = thread::current().id();
-        debug!("unlock_current {thread_id:?}");
+        trace!("unlock_current {thread_id:?}");
         crate::unlock(&crate::CURRENT_OPS_LOCK);
     } else {
         crate::CURRENT_OPS_LOCK.store(0, std::sync::atomic::Ordering::SeqCst);

mod-fix-multiplayer-locks/src/lib.rs

@@ -16,13 +16,13 @@ pub(crate) fn lock(lock: &AtomicU16) {
 pub(crate) fn try_lock(lock: &AtomicU16) -> u32 {
     match lock.compare_exchange(0, 1, Ordering::SeqCst, Ordering::SeqCst) {
         Ok(_) => 0,
-        Err(_) => 1
+        Err(_) => 1,
     }
 }
 
 pub(crate) fn unlock(lock: &AtomicU16) {
     let old = lock.swap(0, Ordering::SeqCst);
     if old != 1 {
-        panic!("Lock is dirty ({old})");
+        panic!("Cannot unlock, lock is dirty ({old})");
     }
 }

p3-agent/Cargo.toml

@@ -12,8 +12,6 @@ log = "0.4"
 toml = "0.7"
 win_dbg_logger = "0.1"
 serde = { version = "1.0", features = ["derive"] }
-num-traits = "0.2"
-num-derive = "0.3"
 
 [dependencies.windows]
 version = "0.48"

p3-api/Cargo.toml

@@ -9,8 +9,8 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 log = "0.4"
-num-traits = "0.2"
-num-derive = "0.3"
+num-traits = { workspace = true }
+num-derive = { workspace = true }
 strum = { version = "0.24", features = ["derive"] }
 csbindgen = { version = "1.7.0", optional = true }
 win_dbg_logger = { workspace = true }