more api functions, rename low production

Author: Trolldemorted

mod-town-hall-details/src/pages/aldermans_office.rs

@@ -18,7 +18,7 @@ static TASK_RESCHEDULING_IN: &CStr = c"Rescheduling in";
 static TASK_RESCHEDULES_REMAINING: &CStr = c"Reschedule Counter";
 static TOWN: &CStr = c"Town";
 static EFFECTIVE_PRODUCTION: &CStr = c"Effective Production";
-static INEFFECTIVE_PRODUCTION: &CStr = c"Ineffective Production";
+static LOW_PRODUCTION: &CStr = c"Low Production";
 
 pub(crate) unsafe fn draw_page(window: UITownHallWindowPtr) {
     let next_mission_index = window.get_next_mission_index();
@@ -133,7 +133,7 @@ unsafe fn render_aldermans_office_modifications_found_town(window: UITownHallWin
     y += 20;
 
     font::ddraw_set_text_mode(font::TextMode::AlignLeft);
-    ui_render_text_at(x + COL_OFFSETS[0], y, INEFFECTIVE_PRODUCTION.to_bytes());
+    ui_render_text_at(x + COL_OFFSETS[0], y, LOW_PRODUCTION.to_bytes());
 
     font::ddraw_set_text_mode(font::TextMode::AlignRight);
     let mut ineffective_string = String::new();

mod-town-hall-details/src/pages/details.rs

@@ -56,7 +56,7 @@ pub(crate) unsafe fn draw_page(window: UITownHallWindowPtr) {
                 hanse_data[ware].total_wares += office_stock[ware];
                 hanse_data[ware].total_consumption += office_consumption[ware];
             }
-            office_index = office.next_office_in_town_index();
+            office_index = office.get_next_office_in_town_index();
         }
     }
     hanse_data.sort_by_key(|a| a.get_ratio());

p3-api/src/class35.rs

@@ -1,20 +1,80 @@
-use std::{ffi::c_void, mem, ptr};
+use std::{mem, ops::Deref, ptr};
 
-use log::debug;
+use log::warn;
 
-use crate::{data::p3_ptr::P3Pointer, Point};
+use crate::{
+    data::{
+        enums::{ShipType, TownId},
+        p3_ptr::P3Pointer,
+    },
+    town::static_town_data::StaticTownDataPtr,
+    Point,
+};
 
 const CLASS35_PTR_ADDRESS: *const u32 = 0x006CBDC8 as _;
+pub const CAPACITY_FACTOR_MAX: u32 = 4096;
+pub const HEALTH_FACTOR_MAX: u32 = 256;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Copy)]
 pub struct Class35Ptr {
     pub address: u32,
 }
 
+#[derive(Clone, Debug)]
+pub struct ShipRoutePtr {
+    pub address: u32,
+    pub needs_free: bool,
+}
+
+impl ShipRoutePtr {
+    pub unsafe fn calculate_distance(&self) -> i32 {
+        let mut distance = 0;
+        if self.len > 1 {
+            for i in 1..self.len as usize {
+                let p0 = (*self.points.add(i - 1)).clone();
+                let p1 = (*self.points.add(i)).clone();
+                let x_diff = (p0.x - p1.x).abs();
+                let y_diff = (p0.y - p1.y).abs();
+                if x_diff <= y_diff {
+                    distance += (16 * y_diff + 7 * x_diff) as i32;
+                } else {
+                    distance += (16 * x_diff + 7 * y_diff) as i32;
+                }
+            }
+        }
+
+        distance
+    }
+
+    pub unsafe fn calculate_travel_time(&self, ship_type: ShipType, health_factor: u32, capacity_factor: u32) -> u32 {
+        let capacity_scaled_speed = (ship_type.get_base_speed() as u32 * capacity_factor) >> 12;
+        let speed_factor = (capacity_scaled_speed * health_factor) >> 10;
+        8 * self.calculate_distance() as u32 / speed_factor
+    }
+
+    pub unsafe fn free(self) {
+        if !self.needs_free {
+            return;
+        }
+        if !self.points.is_null() {
+            crate::free(self.points as usize as _);
+        }
+        crate::free(self.address);
+    }
+}
+
+impl Deref for ShipRoutePtr {
+    type Target = ShipRoute;
+
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*(self.address as *const ShipRoute) }
+    }
+}
+
 #[derive(Clone, Debug)]
 #[repr(C)]
 pub struct ShipRoute {
-    pub points: *const c_void,
+    pub points: *mut Point<i16>,
     pub len: i32,
 }
 
@@ -37,18 +97,33 @@ impl Class35Ptr {
         Self { address: *CLASS35_PTR_ADDRESS }
     }
 
-    pub unsafe fn calculate_ship_route(&self, source: Point<i16>, destination: Point<i16>) -> *const ShipRoute {
-        let args_inner = ShipRouteArgsInner { source, destination };
+    pub unsafe fn calculate_town_route(&self, source: TownId, destination: TownId) -> Option<ShipRoutePtr> {
+        let source_data = StaticTownDataPtr::new(source);
+        let destination_data = StaticTownDataPtr::new(destination);
+        self.calculate_route(&source_data.get_point_i16(), &destination_data.get_point_i16())
+    }
+
+    pub unsafe fn calculate_route(&self, source: &Point<i16>, destination: &Point<i16>) -> Option<ShipRoutePtr> {
+        let args_inner = ShipRouteArgsInner {
+            source: source.clone(),
+            destination: destination.clone(),
+        };
         let args = ShipRouteArgs {
             args_inner: &args_inner,
             route_type: 2,
         };
-        let mut ship_route: *const ShipRoute = ptr::null_mut();
-        debug!("Calling calculate_ship_route orig");
-        let orig: extern "thiscall" fn(this: u32, route_args: *const ShipRouteArgs, route: *mut *const ShipRoute) -> i32 = mem::transmute(0x00445010);
-        orig(self.address, &args, &mut ship_route);
-        debug!("Calling calculate_ship_route survived! {ship_route:?}");
-        ship_route
+        let mut ship_route: *mut ShipRoute = ptr::null_mut();
+        let orig: extern "thiscall" fn(this: u32, route_args: *const ShipRouteArgs, route: *mut *mut ShipRoute) -> bool = mem::transmute(0x00445010);
+        let needs_free = orig(self.address, &args, &mut ship_route);
+        if !ship_route.is_null() {
+            Some(ShipRoutePtr {
+                address: ship_route as _,
+                needs_free,
+            })
+        } else {
+            warn!("Failed to calculate route {:x}", ship_route as u32);
+            None
+        }
     }
 }
 

p3-api/src/data/enums.rs

@@ -112,7 +112,8 @@ pub enum ShipWeaponId {
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq, EnumIter, FromPrimitive)]
-pub enum ShipTypeId {
+#[repr(u8)]
+pub enum ShipType {
     Snaikkka = 0x00,
     Craier = 0x01,
     Cog = 0x02,
@@ -209,6 +210,18 @@ impl WareId {
             _ => true,
         }
     }
+
+    pub unsafe fn get_base_price(&self) -> f32 {
+        let base_price_ptr: *const f32 = 0x00673A18 as _;
+        *base_price_ptr.add(*self as usize)
+    }
+}
+
+impl ShipType {
+    pub unsafe fn get_base_speed(&self) -> u16 {
+        let base_speed_ptr: *const u16 = 0x0067366C as _;
+        *base_speed_ptr.add(*self as usize)
+    }
 }
 
 impl ShipWeaponId {

p3-api/src/data/office.rs

@@ -2,7 +2,7 @@ use super::{p3_ptr::P3Pointer, storage::StoragePtr};
 
 pub const OFFICE_SIZE: u32 = 0x44C;
 
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy)]
 pub struct OfficePtr {
     pub address: u32,
 }
@@ -16,13 +16,25 @@ impl OfficePtr {
         StoragePtr::new(self.address)
     }
 
-    pub fn get_merchant_id(&self) -> u16 {
+    pub fn get_merchant_index(&self) -> u16 {
         unsafe { self.get(0x2c4) }
     }
 
-    pub fn next_office_in_town_index(&self) -> u16 {
+    pub fn get_next_office_of_merchant_index(&self) -> u16 {
+        unsafe { self.get(0x2c8) }
+    }
+
+    pub fn get_next_office_in_town_index(&self) -> u16 {
         unsafe { self.get(0x2ca) }
     }
+
+    pub unsafe fn set_administrator_trade_prices(&self, prices: [i32; 20]) {
+        self.set(0x2f4, &prices)
+    }
+
+    pub unsafe fn set_administrator_trade_actions(&self, actions: [i32; 20]) {
+        self.set(0x2f4, &actions)
+    }
 }
 
 impl P3Pointer for OfficePtr {

p3-api/src/data/p3_ptr.rs

@@ -1,6 +1,6 @@
 use std::ptr;
 
-pub trait P3Pointer {
+pub trait P3Pointer: Sized {
     fn get_address(&self) -> u32;
 
     /// # Safety
@@ -19,4 +19,8 @@ pub trait P3Pointer {
         let address = self.get_address() + offset;
         ptr::copy(data as *const _ as _, address as *mut u8, std::mem::size_of::<T>());
     }
+
+    unsafe fn free(self) {
+        crate::free(self.get_address());
+    }
 }

p3-api/src/game_world.rs

@@ -80,9 +80,8 @@ impl GameWorldPtr {
         unsafe { self.get(0x18) }
     }
 
-    pub fn get_town_id(&self, index: u8) -> Option<TownId> {
-        assert!(index < 40);
-        FromPrimitive::from_u8(unsafe { self.get(0x18 + index as u32) })
+    pub fn get_town_id(&self, index: u8) -> TownId {
+        FromPrimitive::from_u8(unsafe { self.get(0x18 + index as u32) }).unwrap()
     }
 
     pub fn get_town(&self, town_index: u8) -> TownPtr {
@@ -121,6 +120,26 @@ impl GameWorldPtr {
         MerchantPtr::new(base_address + index as u32 * MERCHANT_SIZE)
     }
 
+    pub unsafe fn get_office_index(&self, town_index: u8, merchant_id: u16) -> Option<u16> {
+        let offices_count = self.get_offices_count();
+        let town = self.get_town(town_index);
+        let mut office_index = town.get_first_office_index();
+        loop {
+            if office_index >= offices_count {
+                return None;
+            }
+
+            let office = self.get_office(office_index);
+            if office.get_merchant_index() == merchant_id {
+                trace!("returning office {:#x}", office_index);
+                return Some(office_index);
+            }
+
+            trace!("{:?} belongs to someone else {:#x}", &office, office.get_merchant_index());
+            office_index = office.get_next_office_in_town_index();
+        }
+    }
+
     pub unsafe fn get_office_in_of(&self, town_index: u8, merchant_id: u16) -> Option<OfficePtr> {
         let offices_count = self.get_offices_count();
         let town = self.get_town(town_index);
@@ -131,13 +150,13 @@ impl GameWorldPtr {
             }
 
             let office = self.get_office(office_id);
-            if office.get_merchant_id() == merchant_id {
+            if office.get_merchant_index() == merchant_id {
                 trace!("returning office {:#x}", office_id);
                 return Some(office);
             }
 
-            trace!("{:?} belongs to someone else {:#x}", &office, office.get_merchant_id());
-            office_id = office.next_office_in_town_index();
+            trace!("{:?} belongs to someone else {:#x}", &office, office.get_merchant_index());
+            office_id = office.get_next_office_in_town_index();
         }
     }
 

p3-api/src/lib.rs

@@ -1,4 +1,5 @@
 #![allow(clippy::missing_safety_doc)]
+
 extern crate num_derive;
 
 pub mod class35;
@@ -41,3 +42,8 @@ pub unsafe fn latin1_ptr_to_string(mut s: *const u8) -> String {
     }
     result
 }
+
+pub unsafe fn free(address: u32) {
+    let orig: extern "cdecl" fn(ptr: u32) = std::mem::transmute(0x0063A1B6);
+    orig(address);
+}

p3-api/src/merchant.rs

@@ -12,6 +12,10 @@ impl MerchantPtr {
         Self { address }
     }
 
+    pub fn get_first_office_index(&self) -> u16 {
+        unsafe { self.get(0x0c) }
+    }
+
     pub fn get_first_ship_index(&self) -> u16 {
         unsafe { self.get(0x0e) }
     }

p3-api/src/operation.rs

@@ -23,6 +23,13 @@ pub enum Operation {
     RepairShip {
         ship_index: u32,
     },
+    ShipMoveWares {
+        amount: i32,
+        ship_index: u16,
+        ware_id: WareId,
+        merchant_index: u16,
+        to_ship: bool,
+    },
     MoveWaresConvoy {
         raw_amount: i32,
         convoy_index: u16,
@@ -78,6 +85,22 @@ impl Operation {
                 op[0..4].copy_from_slice(&opcode.to_le_bytes());
                 op[0x04..0x08].copy_from_slice(&ship_id.to_le_bytes());
             }
+            Operation::ShipMoveWares {
+                amount,
+                ship_index,
+                ware_id,
+                merchant_index,
+                to_ship,
+            } => {
+                let opcode: u32 = 0x08;
+                let ware_id: u16 = *ware_id as _;
+                op[0x00..0x04].copy_from_slice(&opcode.to_le_bytes());
+                op[0x04..0x08].copy_from_slice(&amount.to_le_bytes());
+                op[0x08..0x0a].copy_from_slice(&ship_index.to_le_bytes());
+                op[0x0a..0x0c].copy_from_slice(&ware_id.to_le_bytes());
+                op[0x0c..0x0e].copy_from_slice(&merchant_index.to_le_bytes());
+                op[0x0e] = *to_ship as u8;
+            }
             Operation::MoveWaresConvoy {
                 raw_amount: amount,
                 convoy_index: convoy_id,