From 20d41eb072c8e1d5e3ffaaa9a79ae73891db7fd6 Mon Sep 17 00:00:00 2001 From: stsiakal Date: Thu, 22 Oct 2026 04:22:00 +0300 Subject: [PATCH 01/13] fix(vehicles): honor SummonPos placement and implement slave equipment Resolve SummonPos casts to the client-chosen spot, validate it against slaves.spawn_valid_area_range / skill range, water/ground and collision, and fall back to the C# in-front spawn with SlaveSpawnErrorInvalidArea when invalid. Implement CSChangeSlaveEquipmentPacket for equip/unequip/re-slot using a persistent EquipmentSlave container keyed by the slave DB id, ItemDetailType.SlaveEquipment items, SCUnitEquipmentsChanged / SCSlaveEquipmentChanged and gear/pool refreshes. Co-Authored-By: Claude Opus 5.5 --- rust/PORT-AUDIT.md | 2 +- rust/crates/aaemu-game/PORTING.md | 41 ++ rust/crates/aaemu-game/src/data/items.rs | 3 + rust/crates/aaemu-game/src/managers/item.rs | 16 +- .../crates/aaemu-game/src/models/container.rs | 14 +- rust/crates/aaemu-game/src/models/item.rs | 42 ++ .../src/systems/ai/collision/mod.rs | 19 + .../src/systems/economy/item_effects_tests.rs | 22 +- .../src/systems/economy/mate_equipment.rs | 91 ++- .../aaemu-game/src/systems/npcs/bridges.rs | 6 +- .../systems/skills/effects/special/misc.rs | 40 +- .../aaemu-game/src/systems/skills/ext.rs | 23 +- .../aaemu-game/src/systems/skills/skill.rs | 26 +- .../src/systems/skills/validation.rs | 6 +- .../src/systems/vehicles/flow_tests.rs | 350 +++++++++++ .../aaemu-game/src/systems/vehicles/mod.rs | 1 + .../src/systems/vehicles/packets.rs | 42 ++ .../src/systems/vehicles/shipyards.rs | 2 + .../aaemu-game/src/systems/vehicles/slaves.rs | 566 +++++++++++++++++- 19 files changed, 1229 insertions(+), 83 deletions(-) diff --git a/rust/PORT-AUDIT.md b/rust/PORT-AUDIT.md index baa0b39cef..cb8d1e983e 100644 --- a/rust/PORT-AUDIT.md +++ b/rust/PORT-AUDIT.md @@ -600,7 +600,7 @@ Public methods with no Rust counterpart by name, and their verdicts: | `CSChangeMateNamePacket.cs` | CSChangeMateNamePacket | ported | `CSChangeMateNamePacket` → `aaemu-game/src/systems/vehicles/packets.rs` | | `CSChangeMateTargetPacket.cs` | CSChangeMateTargetPacket | ported | `CSChangeMateTargetPacket` → `aaemu-game/src/systems/vehicles/packets.rs` | | `CSChangeMateUserStatePacket.cs` | CSChangeMateUserStatePacket | ported | `CSChangeMateUserStatePacket` → `aaemu-game/src/systems/vehicles/packets.rs` | -| `CSChangeSlaveEquipmentPacket.cs` | CSChangeSlaveEquipmentPacket | ported | `CSChangeSlaveEquipmentPacket` → `aaemu-game/src/systems/economy/mate_equipment.rs` | +| `CSChangeSlaveEquipmentPacket.cs` | CSChangeSlaveEquipmentPacket | ported | `CSChangeSlaveEquipmentPacket` → `aaemu-game/src/systems/vehicles/packets.rs` | | `CSChangeSlaveNamePacket.cs` | CSChangeSlaveNamePacket | ported | `CSChangeSlaveNamePacket` → `aaemu-game/src/systems/vehicles/packets.rs` | | `CSChangeSlaveTargetPacket.cs` | CSChangeSlaveTargetPacket | ported | `CSChangeSlaveTargetPacket` → `aaemu-game/src/packets/c2g_misc.rs` | | `CSChangeTargetPacket.cs` | CSChangeTargetPacket | ported | `CSChangeTargetPacket` → `aaemu-game/src/systems/skills/handlers.rs` | diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 1ca30539d6..eef04a9ae0 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -2502,3 +2502,44 @@ running in place). Four mirrored C# bugs and one missing safeguard: `flow_tests::follow_path_command_set_walks_every_route_point` runs the real command-set shape over three routes with an elevated point and checks every point is targeted in order, the set finishes and the NPC settles in HoldPosition without further movement. + +## Slave summon placement and equipment (2026-10-22) + +- **SummonPos placement.** The 1.2 C# `SpawnSlave` special effect ignored `targetObj` and + always called `SlaveManager.Create(owner, skillData)`; the Rust port now follows the 10.x + `Skill.GetInitialTarget` / placement path. A `SummonPos` cast resolves the client-chosen spot + (world coordinates / yaw, including the `ObjId1` basis transform), validation sees that spot + (range, angle, obstacle, `target_only_water`) and the spawn uses it instead of the owner's + in-front offset. The spot is rejected (with `ErrorMessageType.SlaveSpawnErrorInvalidArea`, + 583) and the 1.2 C# in-front placement is used when it is farther than + `slaves.spawn_valid_area_range` / the skill's `MaxRange` (the smaller nonzero limit; the boat + summon 15802 has `MaxRange` 0), when a ship spot is not on water, when a land-vehicle spot is + in water, or when a 0.5 m sphere just above the surface overlaps collision (`mask::SOLID`). + Skill 15802 also needs the 10.x `unboundedPlacement` rule: a position target with + `MaxRange <= 0` is not rejected as `TooFarRange`. +- **`CSChangeSlaveEquipmentPacket`.** The 1.2 C# read only the header and logged it ("coming + soon"), so the implementation follows the 10.x packet logic (`e113e88b6`) adapted to the 1.2 + client writer: `characterId u32`, `slaveTl u16`, `dbSlaveId u32`, `bts bool`, **one** item + pair and the four location bytes (`397d12a0`; the 10.x `num` and per-entry `expireTime` do not + exist in 1.2). Equip / unequip / re-slot move the item between the owner's bag and the slave's + persistent `EquipmentSlave` container (`SlotType 0xF2`, `ContainerKind::Equipment`, + `item_containers.mate_id` = slave DB id); the pre-move server snapshots are echoed in + `SCSlaveEquipmentChangedPacket(success)`, and the changed slots are broadcast as + `SCUnitEquipmentsChanged`, followed by `SCUnitPoints` when a part carries MaxHealth. Item + tasks go through the economy's `SplitOrMoveItemEx` (`ItemTaskType.Invalid`, as in C#), and the + slave model mirror is refreshed before `UpdateGearBonuses` / pool refresh. +- **Ship parts.** Items with `item_impl = 28` (`ItemImplEnum.SlaveEquipment`) are now + `ItemClass::SlaveEquipment` with `ItemDetailType.SlaveEquipment` (12 opaque detail bytes); + `read_wire_item` consumes detail bytes by detail type (gear 55, ship parts 12, ...) instead of + always reading an `EquipItem`. Bind-on-equip applies in `EquipmentSlave` too. A player-owned + slave gets its starter pack only once (10.x `isNewEquipment`), and the persistent container + is reused on the next summon / restart; NPC / spawner slaves keep the 1.2 in-memory pack. +- **Deviation from 1.2:** slave equipment persistence and the `0xF2` container do not exist in + the 1.2 C# at all; they are the 10.x design, recorded here because the 1.2 data already ships + `slave_initial_items`, `slave_equip_slots` and `item_slave_equipments`. The server additionally + rejects a non-slave-part item (impl 28) on equip; 10.x trusted the client for that. +- **No equipment→skill link:** the 1.2 C# never connected equipped parts to cannon / vehicle + skills; slave mount skills still come from `slave_mount_skills` and child cannons from + `slave_bindings`. The 10.x `SpawnOrReplaceEquipmentVisual` / `item_slave_equipments` visual + spawning is not ported (no 1.2 C# reference), so equipping changes stats and the equipment + container but does not spawn replacement part doodads. diff --git a/rust/crates/aaemu-game/src/data/items.rs b/rust/crates/aaemu-game/src/data/items.rs index 80eac2d9be..7c3a01d93a 100644 --- a/rust/crates/aaemu-game/src/data/items.rs +++ b/rust/crates/aaemu-game/src/data/items.rs @@ -806,6 +806,9 @@ impl ItemTemplate { /// `ItemTemplate.ClassType`. pub fn class_type(&self) -> ItemClass { + if self.impl_id == item_impl::SLAVE_EQUIPMENT { + return ItemClass::SlaveEquipment; + } match self.kind { TemplateKind::Item => ItemClass::Item, TemplateKind::Armor(_) => ItemClass::Armor, diff --git a/rust/crates/aaemu-game/src/managers/item.rs b/rust/crates/aaemu-game/src/managers/item.rs index bbab965e95..ab4395749a 100644 --- a/rust/crates/aaemu-game/src/managers/item.rs +++ b/rust/crates/aaemu-game/src/managers/item.rs @@ -106,6 +106,20 @@ impl ItemManager { }) } + /// `FindItemContainerFor(characterId, slotType, mateId)`: the existing persistent container, + /// without creating one (`EquipSlave` uses the slave DB id as `mateId`). + pub fn find_container_for_character( + &self, + character_id: u32, + slot: u8, + mate_id: u32, + ) -> Option { + self.all_containers().into_iter().find(|c| { + let g = c.lock().expect("container poisoned"); + g.owner_id == character_id && g.slot_type == slot && g.mate_id == mate_id + }) + } + /// `GetItemContainerForCharacter(characterId, slotType, parentUnit, mateId)`: the first /// persistent container matching owner/slot/mate, or a new one (new container id unless the /// slot type is `None`, persistent unless `None`). Never call it while holding a container @@ -126,7 +140,7 @@ impl ItemManager { } } let kind = match slot { - slot_type::EQUIPMENT => ContainerKind::Equipment, + slot_type::EQUIPMENT | slot_type::EQUIPMENT_SLAVE => ContainerKind::Equipment, slot_type::EQUIPMENT_MATE => ContainerKind::MateEquipment, _ => ContainerKind::Item, }; diff --git a/rust/crates/aaemu-game/src/models/container.rs b/rust/crates/aaemu-game/src/models/container.rs index 5777f51548..b3652640b5 100644 --- a/rust/crates/aaemu-game/src/models/container.rs +++ b/rust/crates/aaemu-game/src/models/container.rs @@ -24,10 +24,11 @@ pub mod slot_type { pub const TRADE: u8 = 4; pub const MAIL: u8 = 5; pub const AUCTION: u8 = 6; + pub const EQUIPMENT_SLAVE: u8 = 0xF2; pub const EQUIPMENT_MATE: u8 = 252; pub const SYSTEM: u8 = 0xFF; /// `Enum.GetValues()` order. - pub const ALL: [u8; 9] = [ + pub const ALL: [u8; 10] = [ NONE, EQUIPMENT, INVENTORY, @@ -35,6 +36,7 @@ pub mod slot_type { TRADE, MAIL, AUCTION, + EQUIPMENT_SLAVE, EQUIPMENT_MATE, SYSTEM, ]; @@ -324,6 +326,11 @@ impl ItemContainer { if item.count != 1 { return false; } + // Ship / vehicle parts are `ItemImplEnum.SlaveEquipment` templates, not character + // gear: the 10.x `EquipmentContainer.CanAccept` only checks the slot range. + if self.slot_type == slot_type::EQUIPMENT_SLAVE { + return target_slot >= 0 && target_slot < self.size; + } // `Owner == null`: not applicable to NPCs (mate gear resolves its owner by id). if !self.has_owner && !(self.kind == ContainerKind::MateEquipment && self.owner_id > 0) { @@ -710,7 +717,10 @@ impl ItemContainer { } let bt = data.template(item.template_id).map_or(0, |t| t.bind_type); if (self.slot_type == slot_type::INVENTORY && bt == bind_type::BIND_ON_PICKUP) - || (self.slot_type == slot_type::EQUIPMENT && bt == bind_type::BIND_ON_EQUIP) + || (matches!( + self.slot_type, + slot_type::EQUIPMENT | slot_type::EQUIPMENT_SLAVE + ) && bt == bind_type::BIND_ON_EQUIP) { item.flags |= ITEM_FLAG_SOUL_BOUND; item.dirty = true; diff --git a/rust/crates/aaemu-game/src/models/item.rs b/rust/crates/aaemu-game/src/models/item.rs index f5f697e369..2976322078 100644 --- a/rust/crates/aaemu-game/src/models/item.rs +++ b/rust/crates/aaemu-game/src/models/item.rs @@ -61,6 +61,8 @@ pub enum ItemClass { SummonMate, SummonSlave, TreasureMap, + /// Ship / vehicle part (`item_impl` 28, `ItemDetailType.SlaveEquipment`). + SlaveEquipment, } impl ItemClass { @@ -83,6 +85,7 @@ impl ItemClass { "SummonMate" => Self::SummonMate, "SummonSlave" => Self::SummonSlave, "TreasureMap" => Self::TreasureMap, + "SlaveEquipment" => Self::SlaveEquipment, _ => return None, }) } @@ -104,6 +107,7 @@ impl ItemClass { Self::SummonMate => "AAEmu.Game.Models.Game.Items.SummonMate", Self::SummonSlave => "AAEmu.Game.Models.Game.Items.SummonSlave", Self::TreasureMap => "AAEmu.Game.Models.Game.Items.TreasureMap", + Self::SlaveEquipment => "AAEmu.Game.Models.Game.Items.SlaveEquipment", } } @@ -125,6 +129,7 @@ impl ItemClass { Self::SummonMate => detail_type::MATE, Self::SummonSlave => detail_type::SLAVE, Self::TreasureMap => detail_type::TREASURE, + Self::SlaveEquipment => detail_type::SLAVE_EQUIPMENT, _ => detail_type::INVALID, } } @@ -139,11 +144,29 @@ impl ItemClass { Self::SummonMate => 6, Self::SummonSlave => 29, Self::TreasureMap => 24, + Self::SlaveEquipment => 12, _ => 0, } } } +/// Detail body length of a raw `ItemDetailType` byte (the bytes after the type byte), as read +/// by the 1.2 client's item detail reader `3961edf0` (the C# `ReadDetails` tables minus one). +pub fn detail_body_len(detail_type: u8) -> usize { + match detail_type { + detail_type::EQUIPMENT => 55, + detail_type::SLAVE => 29, + detail_type::MATE => 6, + detail_type::UCC => 9, + detail_type::TREASURE | detail_type::LOCATION => 24, + detail_type::BIG_FISH | detail_type::DECORATION => 16, + detail_type::MUSIC_SHEET => 8, + detail_type::GLIDER => 4, + detail_type::SLAVE_EQUIPMENT => 12, + _ => 0, + } +} + /// Class-specific detail fields (what each subclass' `ReadDetails` keeps). #[derive(Debug, Clone, Default, PartialEq)] pub struct ItemDetails { @@ -170,6 +193,9 @@ pub struct ItemDetails { /// `SummonSlave.RepairStartTime` (unix seconds, 0 = `DateTime.MinValue`). Never restored /// from the DB (the C# `ReadDetails` always falls back to `MinValue`). pub slave_repair_start_time: UnixTime, + /// `ItemDetailType.SlaveEquipment` body (opaque 12 bytes; the 1.2 C# base `Item` keeps it + /// as a raw blob). + pub slave_equipment: [u8; 12], // TreasureMap pub map_position_x: i64, pub map_position_y: i64, @@ -259,6 +285,15 @@ impl Item { ); class }); + // Ship parts keep the base `Item` type string in the C# database but always use the + // `SlaveEquipment` detail (12 opaque bytes). + let class = if template + .is_some_and(|t| t.impl_id == crate::data::items::item_impl::SLAVE_EQUIPMENT) + { + ItemClass::SlaveEquipment + } else { + class + }; let mut item = Item { class, id: row.id, @@ -534,6 +569,10 @@ impl Item { d.map_position_x = s.read_i64()?; d.map_position_y = s.read_i64()?; } + ItemClass::SlaveEquipment => { + let bytes = s.read_bytes(12)?; + d.slave_equipment.copy_from_slice(&bytes); + } _ => {} } Ok(()) @@ -601,6 +640,9 @@ impl Item { .write_i64(d.map_position_x) .write_i64(d.map_position_y); } + ItemClass::SlaveEquipment => { + s.write_raw(&d.slave_equipment); + } // Base Item.WriteDetails with DetailType Invalid writes nothing. _ => {} } diff --git a/rust/crates/aaemu-game/src/systems/ai/collision/mod.rs b/rust/crates/aaemu-game/src/systems/ai/collision/mod.rs index f3752b2532..0a104ff0b6 100644 --- a/rust/crates/aaemu-game/src/systems/ai/collision/mod.rs +++ b/rust/crates/aaemu-game/src/systems/ai/collision/mod.rs @@ -506,6 +506,25 @@ pub fn sweep_capsule( Some(st.sweep(query::capsule(a, r, hh), b - a, ent_types, 0xFFFF_FFFF, &[])) } +/// Static overlap of a sphere (`PrimitiveWorldIntersection`, zero sweep). `None` without the +/// service; `Some(false)` when nothing intersects. +pub fn overlaps_sphere( + server: &GameServer, + instance_id: u32, + center: [f32; 3], + radius: f32, + ent_types: u32, +) -> Option { + let pw = phys_world(server, instance_id)?; + let c = v(center); + let ext = radius; + let min = Vec3::new(c.x - ext, c.y - ext, c.z - ext); + let max = Vec3::new(c.x + ext, c.y + ext, c.z + ext); + ensure_box(server, &pw, min, max); + let mut st = pw.lock(); + Some(st.overlaps(query::sphere(c, radius), ent_types, 0xFFFF_FFFF, &[])) +} + /// `GetWaterLevel(pos)` (I3DEngine vt+568, 0x3013FCB0): the water-volume surface, else the /// ocean level; `None` when the point is not in water (the engine's −1e6). pub fn water_level(server: &GameServer, instance_id: u32, x: f32, y: f32, z: f32) -> Option { diff --git a/rust/crates/aaemu-game/src/systems/economy/item_effects_tests.rs b/rust/crates/aaemu-game/src/systems/economy/item_effects_tests.rs index 5c7b5c2f27..27026d1bf3 100644 --- a/rust/crates/aaemu-game/src/systems/economy/item_effects_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/item_effects_tests.rs @@ -1760,16 +1760,32 @@ async fn mate_equipment_equip_unequip_and_refusal() { #[test] fn slave_and_repair_packets_decode() { + use crate::systems::vehicles::packets::{CSChangeSlaveEquipmentPacket, WireItem}; let mut s = PacketStream::new(); - s.write_u32(5).write_u16(6).write_u32(7).write_bool(true); + s.write_u32(5) + .write_u16(6) + .write_u32(7) + .write_bool(true) + .write_u32(0) // no item in slot 1 + .write_u32(0) // no item in slot 2 + .write_u8(slot_type::INVENTORY) + .write_u8(3) + .write_u8(slot_type::EQUIPMENT_SLAVE) + .write_u8(4); let p = CSChangeSlaveEquipmentPacket::read(&mut s).unwrap(); assert_eq!( p, CSChangeSlaveEquipmentPacket { - id: 5, - tl: 6, + character_id: 5, + slave_tl: 6, db_slave_id: 7, bts: true, + item1: WireItem::default(), + item2: WireItem::default(), + slot1_type: slot_type::INVENTORY, + slot1: 3, + slot2_type: slot_type::EQUIPMENT_SLAVE, + slot2: 4, } ); let mut s = PacketStream::new(); diff --git a/rust/crates/aaemu-game/src/systems/economy/mate_equipment.rs b/rust/crates/aaemu-game/src/systems/economy/mate_equipment.rs index ad55e05531..9c335d144a 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mate_equipment.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mate_equipment.rs @@ -1,9 +1,10 @@ //! Pet / vehicle gear: `CSChangeMateEquipmentPacket` (moves between the bag and a mate's //! `MateEquipmentContainer`), the `MateEquipmentContainer.OnEnter/LeaveContainer` packets //! (`SCMateEquipmentChangedPacket`), the base `EquipmentContainer` events of a mate (the default -//! [`SummonItemHooks::on_mate_equipment_changed`]), the slave gear / slave repair packets that -//! only log in the 1.2 C# (`CSChangeSlaveEquipmentPacket`, `CSRepairSlaveItemsPacket`), and the -//! stablehand mate revive packet (`CSRepairPetItemsPacket`, handled in `vehicles::mates`). +//! [`SummonItemHooks::on_mate_equipment_changed`]), the slave repair packet that only logs in +//! the 1.2 C# (`CSRepairSlaveItemsPacket`), and the stablehand mate revive packet +//! (`CSRepairPetItemsPacket`, handled in `vehicles::mates`). The slave equipment move packet +//! lives in `vehicles::packets` with the other slave packets. use std::sync::Arc; @@ -26,22 +27,32 @@ use super::item_effect_packets::{ItemAndLocation, SCMateEquipmentChangedPacket}; use super::item_handlers::{active, sync_client_packet}; use super::item_packets::SCUnitEquipmentsChangedPacket; -/// `EquipItem.DetailBytesLength`. -const EQUIP_DETAIL_BYTES: usize = 55; +/// A raw wire item (`Item.Read` / `Item.Write`): the fields the container code needs. The detail +/// body is consumed according to its `ItemDetailType` (ship parts carry 12 bytes, gear 55). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub struct WireItem { + pub template_id: u32, + pub id: u64, + pub grade: u8, + pub flags: u8, + pub count: i32, + pub detail_type: u8, +} -/// `new EquipItem().Read(stream)`: skips one wire item, returns its template id. -pub fn read_wire_equip_item(s: &mut PacketStream) -> Result { +/// `new Item().Read(stream)`. +pub fn read_wire_item(s: &mut PacketStream) -> Result { let template_id = s.read_u32()?; if template_id == 0 { - return Ok(0); + return Ok(WireItem::default()); } - s.read_u64()?; // Id - s.read_u8()?; // Grade - s.read_u8()?; // ItemFlags - s.read_i32()?; // Count - s.read_u8()?; // detailType - if s.remaining() >= EQUIP_DETAIL_BYTES { - s.read_bytes(EQUIP_DETAIL_BYTES)?; // ReadDetails + let id = s.read_u64()?; + let grade = s.read_u8()?; + let flags = s.read_u8()?; + let count = s.read_i32()?; + let detail_type = s.read_u8()?; + let detail_len = crate::models::item::detail_body_len(detail_type); + if detail_len > 0 && s.remaining() >= detail_len { + s.read_bytes(detail_len)?; } s.read_i64()?; // CreateTime s.read_i32()?; // LifespanMins @@ -49,7 +60,19 @@ pub fn read_wire_equip_item(s: &mut PacketStream) -> Result { s.read_u8()?; // WorldId s.read_i64()?; // UnsecureTime s.read_i64()?; // UnpackTime - Ok(template_id) + Ok(WireItem { + template_id, + id, + grade, + flags, + count, + detail_type, + }) +} + +/// `new EquipItem().Read(stream)`: skips one wire item, returns its template id. +pub fn read_wire_equip_item(s: &mut PacketStream) -> Result { + Ok(read_wire_item(s)?.template_id) } /// Adds the `MateEquipmentContainer.OnEnterContainer` / `OnLeaveContainer` packets after the @@ -377,41 +400,6 @@ pub fn change_mate_equipment( } } -/// `CSChangeSlaveEquipmentPacket` (only logs in 1.2: "coming soon"). -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub struct CSChangeSlaveEquipmentPacket { - pub id: u32, - pub tl: u16, - pub db_slave_id: u32, - pub bts: bool, -} - -impl CSChangeSlaveEquipmentPacket { - fn read_body(s: &mut PacketStream) -> Result { - let id = s.read_u32()?; - let tl = s.read_u16()?; - let db_slave_id = s.read_u32()?; - let bts = s.read_bool()?; - Ok(Self { - id, - tl, - db_slave_id, - bts, - }) - } - - fn run(self, _server: &GameServer, _conn: &mut GameConnection) { - tracing::debug!( - "ChangeSlaveEquipment, Id: {}, Tl: {}, DbSlaveId: {}, Bts: {}", - self.id, - self.tl, - self.db_slave_id, - self.bts - ); - } -} -sync_client_packet!(CSChangeSlaveEquipmentPacket); - /// `CSRepairPetItemsPacket`: the stablehand revive of dead mates (not an equipment repair). #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct CSRepairPetItemsPacket { @@ -455,7 +443,6 @@ sync_client_packet!(CSRepairSlaveItemsPacket); pub fn register(reg: &mut PacketRegistry) { reg.register::(LEVEL_PLAIN, cs::CSChangeMateEquipmentPacket); - reg.register::(LEVEL_PLAIN, cs::CSChangeSlaveEquipmentPacket); reg.register::(LEVEL_PLAIN, cs::CSRepairPetItemsPacket); reg.register::(LEVEL_PLAIN, cs::CSRepairSlaveItemsPacket); } diff --git a/rust/crates/aaemu-game/src/systems/npcs/bridges.rs b/rust/crates/aaemu-game/src/systems/npcs/bridges.rs index 91aeaeb547..dfe12d5f55 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/bridges.rs @@ -447,8 +447,12 @@ impl NpcSkillHooks for NpcSkills { server: &GameServer, player: &PlayerRef, skill_item: &crate::systems::skills::types::SkillCaster, + placement: Option, + max_range: f32, ) { - crate::systems::vehicles::slaves::create_from_skill(server, player, skill_item); + crate::systems::vehicles::slaves::create_from_skill( + server, player, skill_item, placement, max_range, + ); } fn riders_escape( diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/special/misc.rs b/rust/crates/aaemu-game/src/systems/skills/effects/special/misc.rs index 74b917e34c..3dae531dd1 100644 --- a/rust/crates/aaemu-game/src/systems/skills/effects/special/misc.rs +++ b/rust/crates/aaemu-game/src/systems/skills/effects/special/misc.rs @@ -379,7 +379,8 @@ pub fn spawn_pet(server: &GameServer, args: &EffectArgs<'_>, v: [i32; 4]) { .spawn_mount(server, p, &args.caster_caster); } -/// `SpawnSlave`: `SlaveManager.Create(owner, skillItem)`. +/// `SpawnSlave`: `SlaveManager.Create(owner, skillItem)`. `SummonPos` casts carry the spot the +/// player picked; a self-targeted summon item cast has no placement and keeps the C# offset. pub fn spawn_slave(server: &GameServer, args: &EffectArgs<'_>, v: [i32; 4]) { log_values(args, "SpawnSlave", v); let Some(p) = args.caster.as_ref().and_then(WorldObject::as_player) else { @@ -394,12 +395,37 @@ pub fn spawn_slave(server: &GameServer, args: &EffectArgs<'_>, v: [i32; 4]) { ); return; } - server - .systems - .skills - .ext - .npcs() - .spawn_slave(server, p, &args.caster_caster); + let placement = match (&args.target, &args.target_caster) { + (Target::Pos(pos), SkillCastTarget::Position { rot, .. }) => { + Some(crate::systems::skills::ext::SummonPlacement { + x: pos.pos.x, + y: pos.pos.y, + z: pos.pos.z, + yaw: *rot, + }) + } + ( + Target::Pos(pos), + SkillCastTarget::Position2 { .. } | SkillCastTarget::Position3 { .. }, + ) => Some(crate::systems::skills::ext::SummonPlacement { + x: pos.pos.x, + y: pos.pos.y, + z: pos.pos.z, + yaw: 0.0, + }), + _ => None, + }; + let max_range = args + .source + .skill() + .map_or(0.0, |s| s.template.max_range as f32); + server.systems.skills.ext.npcs().spawn_slave( + server, + p, + &args.caster_caster, + placement, + max_range, + ); } /// `AttachTo`: a character binds the target slave at attach point `value1`. diff --git a/rust/crates/aaemu-game/src/systems/skills/ext.rs b/rust/crates/aaemu-game/src/systems/skills/ext.rs index 32bab28082..745d2ffbe0 100644 --- a/rust/crates/aaemu-game/src/systems/skills/ext.rs +++ b/rust/crates/aaemu-game/src/systems/skills/ext.rs @@ -40,6 +40,16 @@ pub struct MainWorldPosition { pub pos: PositionAndRotation, } +/// The client-chosen spot of a `SummonPos` cast (`SkillCastPositionTarget` and friends). +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct SummonPlacement { + pub x: f32, + pub y: f32, + pub z: f32, + /// `SkillCastPositionTarget.PosRot`. + pub yaw: f32, +} + /// Outcome of an item action that can cancel the skill and show an error (`skill.Cancelled = /// true` + `SendErrorMessage`). #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -256,8 +266,17 @@ pub trait NpcSkillHooks: Send + Sync { not_ported("SlaveManager.BindSlave"); } - /// `SlaveManager.Create(owner, skillItem)` (`SpawnSlave`). - fn spawn_slave(&self, _server: &GameServer, _player: &PlayerRef, _skill_item: &SkillCaster) { + /// `SlaveManager.Create(owner, skillItem, positionOverride)` (`SpawnSlave`). `placement` is + /// the `SummonPos` spot the client chose (`None` for a self-targeted summon item cast); + /// `max_range` is the skill template's `MaxRange` (`0` = unbounded). + fn spawn_slave( + &self, + _server: &GameServer, + _player: &PlayerRef, + _skill_item: &SkillCaster, + _placement: Option, + _max_range: f32, + ) { not_ported("SlaveManager.Create"); } diff --git a/rust/crates/aaemu-game/src/systems/skills/skill.rs b/rust/crates/aaemu-game/src/systems/skills/skill.rs index 99b3bae24c..d0a8ae261e 100644 --- a/rust/crates/aaemu-game/src/systems/skills/skill.rs +++ b/rust/crates/aaemu-game/src/systems/skills/skill.rs @@ -346,9 +346,19 @@ fn initial_target( return Some(set_initial_target(server, caster, target_caster)); } } - Some( - T::Party | T::Raid | T::Line | T::Pet | T::SummonPos | T::SourcePos | T::CursorPos, - ) => {} + Some(T::SummonPos) => { + // 10.x `Skill.GetInitialTarget`: the chosen summon spot is the target, so range, + // angle and obstacle checks see the placement instead of the caster. + if matches!( + target_caster, + SkillCastTarget::Position { .. } + | SkillCastTarget::Position2 { .. } + | SkillCastTarget::Position3 { .. } + ) { + return Some(set_initial_target(server, caster, target_caster)); + } + } + Some(T::Party | T::Raid | T::Line | T::Pet | T::SourcePos | T::CursorPos) => {} None => { tracing::error!( "SkillTargetType not supported {} (NotSupportedException)", @@ -1707,7 +1717,15 @@ pub fn apply_effects(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { let Some(template) = data.effect(kind, id) else { continue; }; - let this_target_caster = if target.obj_id() == ctx.target_caster.obj_id() { + // Position casts (ground / ballistic / summon placement) have no unit obj id: keep the + // original target so effects can read the chosen coordinates and rotation. + let this_target_caster = if matches!( + ctx.target_caster, + SkillCastTarget::Position { .. } + | SkillCastTarget::Position2 { .. } + | SkillCastTarget::Position3 { .. } + ) || target.obj_id() == ctx.target_caster.obj_id() + { ctx.target_caster } else { SkillCastTarget::Unit(target.obj_id()) diff --git a/rust/crates/aaemu-game/src/systems/skills/validation.rs b/rust/crates/aaemu-game/src/systems/skills/validation.rs index af56e0c099..5d7cebb761 100644 --- a/rust/crates/aaemu-game/src/systems/skills/validation.rs +++ b/rust/crates/aaemu-game/src/systems/skills/validation.rs @@ -200,6 +200,10 @@ pub(super) fn check( if distance < min_range { return fail("skill_too_close_range"); } + // A position-targeted skill is cast at a spot on the ground; its template may carry + // max_range 0 because the client decides where the placement is legal (10.x + // `unboundedPlacement`; summon skill 15802 rejected every boat at 3.4 m without it). + let unbounded_placement = matches!(target, Target::Pos(_)) && template.max_range <= 0; // Doodads have no model radius and a ship's origin is far from its hull, so these targets // get an allowance on top of the skill's range (C# exempted them entirely). let extent = target.as_obj().map_or(0.0, |o| { @@ -211,7 +215,7 @@ pub(super) fn check( 0.0 } }); - if distance > max_range + extent { + if distance > max_range + extent && !unbounded_placement { return fail("skill_too_far_range"); } if template.check_obstacle && !target.as_obj().is_some_and(|o| o.same(caster)) { diff --git a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs index 21ca4bf37d..558968eb2d 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs @@ -3206,3 +3206,353 @@ async fn hang_and_unhang_packets_only_mutate_the_authenticated_character() { .unwrap(); assert_eq!(pb.core().sticky_parent(), 0); } + +// --------------------------------------------------------------------------------------------- +// SummonPos summon placement (2026-10-22) +// --------------------------------------------------------------------------------------------- + +const SUMMON_POS_SKILL: u32 = 58_003; +const SLAVE_PART: u32 = 5002; + +fn summon_pos_data(spawn_range: u32) -> GameData { + use crate::systems::skills::data::effects::{EffectTemplate, SpecialEffect}; + use crate::systems::skills::data::{EffectKind, SkillTemplate}; + let mut d = slave_data(); + d.items.templates.get_mut(&SLAVE_ITEM).unwrap().use_skill_id = SUMMON_POS_SKILL; + d.systems + .vehicles + .slave_templates + .get_mut(&SLAVE_TEMPLATE) + .unwrap() + .spawn_valid_area_range = spawn_range; + d.systems.skills.add_effect( + EffectKind::SpecialEffect, + EffectTemplate::Special(SpecialEffect { + id: 1, + special_effect_type_id: 60, + value1: 0, + value2: 0, + value3: 0, + value4: 0, + }), + 1, + ); + d.systems.skills.add_skill(SkillTemplate { + id: SUMMON_POS_SKILL, + target_type: 12, // SummonPos + level_rule_no_consideration: true, + effects: vec![crate::systems::skills::tests::skill_effect( + 1, + EffectKind::SpecialEffect, + 1, + )], + ..SkillTemplate::default() + }); + d +} + +/// A client that owns `SLAVE_ITEM` in its bag and can cast the summon skill. +fn summon_pos_client( + server: &Arc, +) -> (TestClient, PlayerRef, u64, Arc) { + let mut a = TestClient::new(server, 1, 1); + let (pa, item_id) = player_with_item(server, &a, 1, PA, (100.0, 100.0), SLAVE_ITEM); + let bag = pa + .data() + .inventory + .get(slot_type::INVENTORY) + .unwrap() + .clone(); + bag.lock().unwrap().items[0].owner_id = u64::from(pa.character_id); + server.items.add_container(bag); + a.conn.active_char = Some(pa.clone()); + let world = server.world.world(0).unwrap(); + server.systems.npcs.spawns.get_or_create(&world); + a.drain(); + (a, pa, item_id, world) +} + +fn cast_summon_pos( + server: &GameServer, + client: &mut TestClient, + item_id: u64, + x: f32, + y: f32, + z: f32, + yaw: f32, +) { + use crate::systems::skills::handlers::{start_skill, CSStartSkillPacket}; + use crate::systems::skills::types::{SkillCastTarget, SkillCaster, SkillObject}; + start_skill( + server, + &mut client.conn, + CSStartSkillPacket { + skill_id: SUMMON_POS_SKILL, + caster: SkillCaster::Item { + obj_id: PA, + item_id, + item_template_id: SLAVE_ITEM, + type1: 0, + type2: 0, + }, + target: SkillCastTarget::Position { + obj_id: 0, + x, + y, + z, + rot: yaw, + obj_id1: 0, + obj_id2: 0, + }, + flag: 0, + skill_object: SkillObject::None, + }, + ); +} + +async fn wait_for_slave(world: &Arc) -> crate::world::SlaveRef { + tokio::time::timeout(Duration::from_secs(5), async { + loop { + if let Some(s) = slaves::get_active_slave_by_owner_obj_id(world, PA) { + break s; + } + tokio::time::sleep(Duration::from_millis(10)).await; + } + }) + .await + .expect("summon skill must create the vehicle") +} + +#[tokio::test] +async fn summon_pos_places_the_vehicle_at_the_chosen_spot() { + let server = server_with(summon_pos_data(50)); + crate::systems::economy::bridges::install(&server); + crate::systems::npcs::install_hooks(&server); + super::install_hooks(&server); + let (mut a, _pa, item_id, world) = summon_pos_client(&server); + cast_summon_pos(&server, &mut a, item_id, 103.0, 104.0, 200.0, 1.25); + let slave = wait_for_slave(&world).await; + let t = slave.data().unit.transform; + assert_eq!((t.x, t.y), (103.0, 104.0)); + assert!( + (t.rot_z - 1.25).abs() < 1e-6, + "yaw {}, wanted 1.25", + t.rot_z + ); + assert!( + !error_codes(&a.drain()).contains(&super::error::SLAVE_SPAWN_ERROR_INVALID_AREA), + "a valid placement must not send the invalid-area error" + ); +} + +#[tokio::test] +async fn summon_pos_outside_the_valid_area_errors_and_falls_back_in_front() { + let server = server_with(summon_pos_data(10)); + crate::systems::economy::bridges::install(&server); + crate::systems::npcs::install_hooks(&server); + super::install_hooks(&server); + let (mut a, _pa, item_id, world) = summon_pos_client(&server); + cast_summon_pos(&server, &mut a, item_id, 130.0, 100.0, 0.0, 1.25); + let slave = wait_for_slave(&world).await; + let frames = a.drain(); + assert!( + error_codes(&frames).contains(&super::error::SLAVE_SPAWN_ERROR_INVALID_AREA), + "invalid placement must send SlaveSpawnErrorInvalidArea" + ); + // C# fallback: SpawnYOffset clamped to 5 m in front, 90 degrees CCW of the owner. + let t = slave.data().unit.transform; + assert_eq!((t.x, t.y), (100.0, 105.0)); + assert!((t.rot_z - std::f32::consts::FRAC_PI_2).abs() < 1e-6); +} + +#[tokio::test] +async fn slave_equipment_equips_unequips_and_survives_a_resummon() { + use crate::models::item::ItemClass; + use crate::net::registry::ClientPacket; + use crate::systems::vehicles::packets::CSChangeSlaveEquipmentPacket; + + let mut d = slave_data(); + d.items.templates.insert( + SLAVE_PART, + ItemTemplate { + impl_id: crate::data::items::item_impl::SLAVE_EQUIPMENT, + ..ItemTemplate::plain(SLAVE_PART, 1) + }, + ); + let server = server_with(d); + crate::systems::economy::bridges::install(&server); + crate::systems::npcs::install_hooks(&server); + super::install_hooks(&server); + let mut a = TestClient::new(&server, 1, 1); + let (pa, item_id) = player_with_item(&server, &a, 1, PA, (100.0, 100.0), SLAVE_ITEM); + a.conn.active_char = Some(pa.clone()); + let world = server.world.world(0).unwrap(); + server.systems.npcs.spawns.get_or_create(&world); + let bag = pa + .data() + .inventory + .get(slot_type::INVENTORY) + .unwrap() + .clone(); + bag.lock().unwrap().items[0].owner_id = u64::from(pa.character_id); + server.items.add_container(bag.clone()); + + let item = mates::owned_item(&server, &pa, item_id).unwrap(); + let slave = slaves::create_core( + &server, + &world, + Some(&pa), + None, + SLAVE_TEMPLATE, + Some(item), + false, + None, + None, + ) + .expect("slave"); + let (tl, db_id) = { + let d = slave.data(); + (d.unit.tl_id, d.id) + }; + assert!(db_id > 0); + + let mut part = server + .items + .create( + SLAVE_PART, + 1, + 0, + 1, + &server.game_data.items, + &server.ids.item, + 0, + ) + .expect("part"); + assert_eq!(part.class, ItemClass::SlaveEquipment); + part.slot_type = slot_type::INVENTORY; + part.slot = 7; + part.owner_id = u64::from(pa.character_id); + part.dirty = true; + let part_id = part.id; + bag.lock().unwrap().items.push(part.clone()); + a.drain(); + + let character_id = pa.character_id; + let packet_body = |item1: Option<&crate::models::item::Item>, + slot1: u8, + item2: Option<&crate::models::item::Item>, + slot2: u8, + bts: bool| { + let mut s = PacketStream::new(); + s.write_u32(character_id) + .write_u16(tl) + .write_u32(db_id) + .write_bool(bts); + match item1 { + Some(i) => { + s.write(i); + } + None => { + s.write_u32(0); + } + } + match item2 { + Some(i) => { + s.write(i); + } + None => { + s.write_u32(0); + } + } + s.write_u8(slot_type::INVENTORY) + .write_u8(slot1) + .write_u8(slot_type::EQUIPMENT_SLAVE) + .write_u8(slot2); + s.into_bytes() + }; + let run = |body: Vec, a: &mut TestClient| { + let p = CSChangeSlaveEquipmentPacket::read(&mut PacketStream::from_bytes(body)).unwrap(); + futures::executor::block_on(p.handle(&server, &mut a.conn)).unwrap(); + a.drain() + }; + + // Equip bag slot 7 -> slave slot 3. + let frames = run(packet_body(Some(&part), 7, None, 3, false), &mut a); + assert!(ops(&frames).contains(&sc::SCSlaveEquipmentChangedPacket)); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 1, + "success flag" + ); + assert!(ops(&frames).contains(&sc::SCUnitEquipmentsChangedPacket)); + assert!(bag.lock().unwrap().get_item_by_slot(7).is_none()); + assert_eq!( + slave.data().equipment[3].as_ref().map(|i| i.id), + Some(part_id) + ); + let equipment = server + .items + .find_container_for_character(pa.character_id, slot_type::EQUIPMENT_SLAVE, db_id) + .expect("persistent slave equipment container"); + let stored = equipment + .lock() + .unwrap() + .get_item_by_slot(3) + .cloned() + .expect("part in the slave container"); + assert_eq!( + (stored.id, stored.slot_type), + (part_id, slot_type::EQUIPMENT_SLAVE) + ); + + // Unequip slave slot 3 -> empty bag slot 9. + let frames = run(packet_body(None, 9, Some(&stored), 3, true), &mut a); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 1 + ); + assert_eq!( + bag.lock().unwrap().get_item_by_slot(9).map(|i| i.id), + Some(part_id) + ); + assert!(slave.data().equipment[3].is_none()); + assert!(equipment.lock().unwrap().get_item_by_slot(3).is_none()); + + // Equip again, then destroy the hull and summon the saved slave: the parts must come back + // from the persistent container (item_containers.mate_id == slave DB id). + let frames = run(packet_body(Some(&stored), 9, None, 3, false), &mut a); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 1 + ); + slaves::delete(&server, Some(&pa), world.id, slave.obj_id, false); + let item = mates::owned_item(&server, &pa, item_id).unwrap(); + let again = slaves::create_core( + &server, + &world, + Some(&pa), + None, + SLAVE_TEMPLATE, + Some(item), + false, + None, + Some(slaves::SavedSlave { + id: db_id, + name: "Cart".into(), + hp: 1, + mp: 1, + }), + ) + .expect("re-summoned slave"); + assert_eq!( + again.data().equipment[3].as_ref().map(|i| i.id), + Some(part_id), + "the saved hull keeps its equipped parts" + ); +} diff --git a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs index 17c430b675..fbb49762c1 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs @@ -265,6 +265,7 @@ pub mod error { pub const SLAVE_SPAWN_ITEM_LOCKED: i16 = 101; pub const NOT_READY: i16 = 206; pub const SLAVE_SPAWN_ERROR_NEED_REPAIR_TIME: i16 = 540; + pub const SLAVE_SPAWN_ERROR_INVALID_AREA: i16 = 583; pub const SLAVE_EQUIPMENT_LOADED_ITEM: i16 = 801; } diff --git a/rust/crates/aaemu-game/src/systems/vehicles/packets.rs b/rust/crates/aaemu-game/src/systems/vehicles/packets.rs index 79e1f5594e..c0684452a2 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/packets.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/packets.rs @@ -9,6 +9,8 @@ use crate::net::packet::LEVEL_PLAIN; use crate::net::registry::PacketRegistry; use crate::opcodes::{cs, sc}; use crate::packets::packet_def; +use crate::systems::economy::mate_equipment::read_wire_item; +pub use crate::systems::economy::mate_equipment::WireItem; use super::{mates, shipyards, slaves}; @@ -341,6 +343,45 @@ cs_packet!( } ); +cs_packet!( + /// `CSChangeSlaveEquipmentPacket` (1.2 body: the header, one item pair and its two + /// locations; the 10.x count/expire fields do not exist in the 1.2 client writer + /// `397d1410` / `397d12a0`). + CSChangeSlaveEquipmentPacket { + character_id: u32, + slave_tl: u16, + db_slave_id: u32, + bts: bool, + item1: WireItem, + item2: WireItem, + slot1_type: u8, + slot1: u8, + slot2_type: u8, + slot2: u8, + } + read |s| { + Ok(Self { + character_id: s.read_u32()?, + slave_tl: s.read_u16()?, + db_slave_id: s.read_u32()?, + bts: s.read_bool()?, + item1: read_wire_item(s)?, + item2: read_wire_item(s)?, + slot1_type: s.read_u8()?, + slot1: s.read_u8()?, + slot2_type: s.read_u8()?, + slot2: s.read_u8()?, + }) + } + handle |self, server, conn| { + let Some(p) = conn.active_char.clone() else { + return Ok(()); + }; + slaves::change_slave_equipment(server, &p, &self); + Ok(()) + } +); + cs_packet!( /// `CSSpawnSlavePacket` (log only in C#). CSSpawnSlavePacket { @@ -459,6 +500,7 @@ pub fn register(reg: &mut PacketRegistry) { reg.register::(LEVEL_PLAIN, cs::CSBindSlavePacket); reg.register::(LEVEL_PLAIN, cs::CSChangeSlaveNamePacket); reg.register::(LEVEL_PLAIN, cs::CSDespawnSlavePacket); + reg.register::(LEVEL_PLAIN, cs::CSChangeSlaveEquipmentPacket); reg.register::(LEVEL_PLAIN, cs::CSDestroySlavePacket); reg.register::(LEVEL_PLAIN, cs::CSDiscardSlavePacket); reg.register::(LEVEL_PLAIN, cs::CSSpawnSlavePacket); diff --git a/rust/crates/aaemu-game/src/systems/vehicles/shipyards.rs b/rust/crates/aaemu-game/src/systems/vehicles/shipyards.rs index 5b67a2cf5e..7482e8b2e3 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/shipyards.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/shipyards.rs @@ -522,6 +522,8 @@ pub async fn shipyard_completed(server: &GameServer, shipyard: &ShipyardRef) { item_template_id, true, Some(pos), + None, + 0.0, ) .await; } diff --git a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs index 3cab8f3b1e..3545622e36 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs @@ -11,14 +11,21 @@ use rand::Rng; use sqlx::Row; use crate::data::world_templates::WorldSpawnPosition; +use crate::models::container::{slot_type, ContainerRef}; use crate::models::doodad::doodad_owner_type; use crate::models::item::{Item, ItemClass}; +use crate::models::item_task::task_type; use crate::models::slave::Slave; use crate::models::transform::Transform; use crate::models::unit::{BaseUnitType, Bonus}; use crate::packets::world::SCUnitPointsPacket; use crate::packets::world_objects::SCUnitAttachedPacket; use crate::server::GameServer; +use crate::systems::economy::inventory::{self, Inv, ItemTxn}; +use crate::systems::economy::item_effect_packets::{ + ItemAndLocation, SCSlaveEquipmentChangedPacket, +}; +use crate::systems::economy::item_packets::SCUnitEquipmentsChangedPacket; use crate::systems::npcs::doodad::spawner::SimpleSpawnerDef; use crate::systems::npcs::spawn_manager; use crate::systems::skills::effects::EffectArgs; @@ -342,6 +349,346 @@ pub fn character_slave(server: &GameServer, p: &PlayerRef) -> Option) -> bool { + if wire.template_id == 0 { + return actual.is_none(); + } + actual.is_some_and(|i| i.template_id == wire.template_id && (wire.id == 0 || i.id == wire.id)) +} + +/// Reply to one `CSChangeSlaveEquipment` entry with the pre-move server snapshots (10.x +/// `SCSlaveEquipmentChangedPacket`; the client applies the copies only when `success` is set). +fn reply_slave_equipment( + character: &PlayerRef, + p: &super::packets::CSChangeSlaveEquipmentPacket, + on_slave: Option<&Item>, + in_bag: Option<&Item>, + success: bool, +) { + character.send(SCSlaveEquipmentChangedPacket { + item_on_slave: ItemAndLocation { + item: on_slave.cloned(), + slot_type: p.slot1_type, + slot: p.slot1, + }, + item_in_bag: ItemAndLocation { + item: in_bag.cloned(), + slot_type: p.slot2_type, + slot: p.slot2, + }, + slave_tl_id: p.slave_tl, + character_id: p.character_id, + db_slave_id: p.db_slave_id, + bts: p.bts, + success, + }); +} + +/// Copies the persistent equipment container into the slave model mirror (stats and visibility +/// read the mirror). +fn mirror_slave_equipment(slave: &SlaveRef, container: &ContainerRef) { + let items = container.lock().expect("container poisoned").items.clone(); + let mut d = slave.data(); + d.equipment.fill(None); + for it in items { + let slot = it.slot.max(0) as usize; + if let Some(entry) = d.equipment.get_mut(slot) { + *entry = Some(it); + } + } +} + +/// `CSChangeSlaveEquipmentPacket` (10.x `CSChangeSlaveEquipmentPacket.Read`, adapted to the 1.2 +/// one-pair body and opcode): equip, unequip or re-slot a ship / vehicle part. The persistent +/// `EquipmentSlave` container is keyed by `(character id, slave DB id)` so the item rows survive +/// a despawn and a server restart. +pub fn change_slave_equipment( + server: &GameServer, + character: &PlayerRef, + p: &super::packets::CSChangeSlaveEquipmentPacket, +) { + tracing::debug!( + "ChangeSlaveEquipment, Char: {}, Tl: {}, DbSlaveId: {}, Bts: {}", + p.character_id, + p.slave_tl, + p.db_slave_id, + p.bts + ); + if p.character_id != character.character_id { + return; + } + let Some(world) = player_world(server, character) else { + return; + }; + let slave = (if p.slave_tl != 0 { + get_slave_by_tl_id(&world, u32::from(p.slave_tl)) + } else { + None + }) + .or_else(|| { + if p.db_slave_id != 0 { + get_slave_by_db_id(&world, p.db_slave_id) + } else { + None + } + }) + .or_else(|| get_active_slave_by_owner_obj_id(&world, character.obj_id)); + let Some(slave) = slave else { + tracing::warn!( + "ChangeSlaveEquipment: {} has no slave tl={} db={}", + character.data().unit.name, + p.slave_tl, + p.db_slave_id + ); + reply_slave_equipment(character, p, None, None, false); + return; + }; + let (slave_db_id, owned) = { + let d = slave.data(); + (d.id, d.summoner_id == character.character_id) + }; + if p.db_slave_id != 0 && slave_db_id != 0 && slave_db_id != p.db_slave_id { + tracing::warn!( + "ChangeSlaveEquipment: slave {} does not match requested db id {}", + slave.obj_id, + p.db_slave_id + ); + reply_slave_equipment(character, p, None, None, false); + return; + } + if !owned { + tracing::warn!( + "ChangeSlaveEquipment: {} does not own slave tl={} db={}", + character.data().unit.name, + p.slave_tl, + p.db_slave_id + ); + reply_slave_equipment(character, p, None, None, false); + return; + } + if slave_db_id == 0 { + reply_slave_equipment(character, p, None, None, false); + return; + } + if p.slot2_type != slot_type::EQUIPMENT_SLAVE + || !matches!( + p.slot1_type, + slot_type::INVENTORY | slot_type::EQUIPMENT_SLAVE + ) + { + tracing::warn!( + "ChangeSlaveEquipment: unsupported slots {}#{} <-> {}#{}", + p.slot1_type, + p.slot1, + p.slot2_type, + p.slot2 + ); + reply_slave_equipment(character, p, None, None, false); + return; + } + let equipment = server + .items + .find_container_for_character( + character.character_id, + slot_type::EQUIPMENT_SLAVE, + slave_db_id, + ) + .unwrap_or_else(|| { + server.items.container_for_character( + character.character_id, + slot_type::EQUIPMENT_SLAVE, + slave_db_id, + &server.ids.container, + ) + }); + let bag = Inv::of(character).bag(); + let size_ok = |c: &ContainerRef, slot: u8| { + let size = c.lock().expect("container poisoned").container_size(); + size <= 0 || i32::from(slot) < size + }; + if !size_ok(&equipment, p.slot2) + || (p.slot1_type == slot_type::EQUIPMENT_SLAVE && !size_ok(&equipment, p.slot1)) + || (p.slot1_type == slot_type::INVENTORY && !size_ok(&bag, p.slot1)) + { + tracing::warn!( + "ChangeSlaveEquipment: slot out of range {}#{} <-> {}#{}", + p.slot1_type, + p.slot1, + p.slot2_type, + p.slot2 + ); + reply_slave_equipment(character, p, None, None, false); + return; + } + let item1 = if p.slot1_type == slot_type::INVENTORY { + bag.lock() + .expect("container poisoned") + .get_item_by_slot(i32::from(p.slot1)) + .cloned() + } else { + equipment + .lock() + .expect("container poisoned") + .get_item_by_slot(i32::from(p.slot1)) + .cloned() + }; + let item2 = equipment + .lock() + .expect("container poisoned") + .get_item_by_slot(i32::from(p.slot2)) + .cloned(); + if !equipment_slot_matches(&p.item1, item1.as_ref()) + || !equipment_slot_matches(&p.item2, item2.as_ref()) + { + tracing::warn!( + "ChangeSlaveEquipment: slot contents mismatch, client {}/{} server {}/{} for {}#{} <-> {}#{}", + p.item1.template_id, + p.item2.template_id, + item1.as_ref().map_or(0, |i| i.template_id), + item2.as_ref().map_or(0, |i| i.template_id), + p.slot1_type, + p.slot1, + p.slot2_type, + p.slot2 + ); + reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), false); + return; + } + // Ship / vehicle parts only: the item template carries `ItemImplEnum.SlaveEquipment` + // (`item_slave_equipments` in the 1.2 data). + if p.slot1_type == slot_type::INVENTORY { + if let Some(i) = &item1 { + let is_part = server + .game_data + .items + .template(i.template_id) + .is_some_and(|t| t.impl_id == crate::data::items::item_impl::SLAVE_EQUIPMENT); + if !is_part { + tracing::warn!( + "ChangeSlaveEquipment: item {} (template {}) is not a slave part", + i.id, + i.template_id + ); + reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), false); + return; + } + } + } + // Source / target: the 1.2 client always puts the slave slot second. If its first slot is + // empty the second item moves to it (unequip); both filled swaps them. + let move_args = match (&item1, &item2) { + (Some(i1), _) => Some(( + if p.slot1_type == slot_type::INVENTORY { + bag.clone() + } else { + equipment.clone() + }, + equipment.clone(), + p.slot1_type, + p.slot1, + i1.id, + slot_type::EQUIPMENT_SLAVE, + p.slot2, + item2.as_ref().map_or(0, |i| i.id), + )), + (None, Some(i2)) => Some(( + equipment.clone(), + if p.slot1_type == slot_type::INVENTORY { + bag.clone() + } else { + equipment.clone() + }, + slot_type::EQUIPMENT_SLAVE, + p.slot2, + i2.id, + p.slot1_type, + p.slot1, + 0, + )), + (None, None) => None, + }; + let Some((src, dst, from_type, from_slot, from_id, to_type, to_slot, to_id)) = move_args else { + reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), false); + return; + }; + let inv = Inv::of(character); + let mut txn = ItemTxn::begin(server); + let moved = inventory::split_or_move_item_ex( + &mut txn, + &inv, + task_type::INVALID, + Some(src), + Some(dst), + from_id, + from_type, + from_slot, + to_id, + to_type, + to_slot, + 0, + ); + crate::systems::economy::fx::flush(server, txn.into_fx()); + if !moved { + reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), false); + return; + } + mirror_slave_equipment(&slave, &equipment); + let slave_obj = WorldObject::from(&slave); + crate::systems::skills::stats::update_vehicle_gear_bonuses( + server, + &slave_obj, + item1.as_ref(), + item2.as_ref(), + ); + stats::refresh_object_pools(server, &slave_obj); + let (hp, mp) = { + let mut d = slave.data(); + d.unit.hp = d.unit.hp.min(d.unit.max_hp); + d.unit.mp = d.unit.mp.min(d.unit.max_mp); + (d.unit.hp, d.unit.mp) + }; + let mut changed = Vec::new(); + for (slot, st) in [(p.slot1, p.slot1_type), (p.slot2, p.slot2_type)] { + if st != slot_type::EQUIPMENT_SLAVE || changed.iter().any(|(s, _)| *s == slot) { + continue; + } + let item = equipment + .lock() + .expect("container poisoned") + .get_item_by_slot(i32::from(slot)) + .cloned(); + changed.push((slot, item)); + } + if !changed.is_empty() { + broadcast( + server, + &slave_obj, + &SCUnitEquipmentsChangedPacket { + obj_id: slave.obj_id, + items: changed, + }, + false, + ); + } + broadcast( + server, + &slave_obj, + &SCUnitPointsPacket { + obj_id: slave.obj_id, + hp, + mp, + }, + true, + ); + reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), true); +} + // --------------------------------------------------------------------------------------------- // Bind / unbind // --------------------------------------------------------------------------------------------- @@ -795,8 +1142,15 @@ pub struct SavedChildSlave { } /// `SlaveManager.Create(owner, skillData)` (the `SpawnSlave` special effect): runs the async -/// creation on a task. -pub fn create_from_skill(server: &GameServer, owner: &PlayerRef, caster: &SkillCaster) { +/// creation on a task. `placement` is the `SummonPos` spot the client chose; it is validated +/// against the slave's `spawn_valid_area_range` / the skill range before use. +pub fn create_from_skill( + server: &GameServer, + owner: &PlayerRef, + caster: &SkillCaster, + placement: Option, + max_range: f32, +) { let SkillCaster::Item { item_id, item_template_id, @@ -810,7 +1164,17 @@ pub fn create_from_skill(server: &GameServer, owner: &PlayerRef, caster: &SkillC }; let owner = owner.clone(); let fut = async move { - create_for_owner(&server, &owner, item_id, item_template_id, false, None).await; + create_for_owner( + &server, + &owner, + item_id, + item_template_id, + false, + None, + placement, + max_range, + ) + .await; }; match tokio::runtime::Handle::try_current() { Ok(rt) => { @@ -820,7 +1184,89 @@ pub fn create_from_skill(server: &GameServer, owner: &PlayerRef, caster: &SkillC } } +/// The client-chosen `SummonPos` turned into a spawn transform, or `None` (with +/// `SlaveSpawnErrorInvalidArea`) when the spot is too far, on the wrong surface or inside +/// collision. `None` also means "no placement": the C# in-front placement is used. +fn validated_summon_placement( + server: &GameServer, + world: &WorldInstance, + owner: &PlayerRef, + template: &SlaveTemplate, + placement: Option, + max_range: f32, +) -> Option { + let p = placement?; + let invalid = |reason: &str| { + tracing::warn!( + "SlaveSpawn placement for template {} refused: {reason} at ({:.1},{:.1},{:.1})", + template.id, + p.x, + p.y, + p.z + ); + error(owner, error::SLAVE_SPAWN_ERROR_INVALID_AREA); + None + }; + let owner_pos = world.world_pos_rot(&WorldObject::from(owner)); + // `slaves.spawn_valid_area_range` is the data-side limit (50 m in the 1.2 DB); the skill's + // own MaxRange is 0 for the boat summon (15802). Use the smaller nonzero limit. + let limit = [max_range, template.spawn_valid_area_range as f32] + .into_iter() + .filter(|v| *v > 0.0) + .fold(f32::INFINITY, f32::min); + let limit = if limit.is_finite() { limit } else { 50.0 }; + let dx = p.x - owner_pos.x; + let dy = p.y - owner_pos.y; + if dx * dx + dy * dy > limit * limit { + return invalid("too far from the owner"); + } + let mut transform = Transform { + instance_id: world.id, + zone_id: owner.data().unit.transform.zone_id, + ..Default::default() + }; + transform.set_position(p.x, p.y, p.z, 0.0, 0.0, p.yaw); + if template.is_a_boat() { + if !super::ship_physics::is_water(server, world, [p.x, p.y, p.z]) { + return invalid("a ship must be summoned on water"); + } + transform.set_height(super::ship_physics::water_surface( + server, + world, + [p.x, p.y, p.z], + )); + } else { + if super::ship_physics::is_water(server, world, [p.x, p.y, p.z]) { + return invalid("a land vehicle must be summoned on ground"); + } + let ground = crate::systems::ai::collision::ground_height_or( + server, + world.id, + p.x, + p.y, + p.z, + || p.z, + ); + transform.set_height(ground); + } + // A half-metre sphere just above the surface: the hull/aabb is not needed, this only + // rejects a spot inside a rock, cliff or doodad collider. + let inside = crate::systems::ai::collision::overlaps_sphere( + server, + world.id, + [transform.x, transform.y, transform.z + 0.8], + 0.5, + crate::systems::ai::collision::query::mask::SOLID, + ) + .unwrap_or(false); + if inside { + return invalid("inside collision"); + } + Some(transform) +} + /// `Create(owner, skillData, hideSpawnEffect, positionOverride)`. +#[allow(clippy::too_many_arguments)] pub async fn create_for_owner( server: &GameServer, owner: &PlayerRef, @@ -828,6 +1274,8 @@ pub async fn create_for_owner( item_template_id: u32, hide_spawn_effect: bool, position_override: Option, + placement: Option, + max_range: f32, ) -> Option { let world = player_world(server, owner)?; if let Some(active) = get_active_slave_by_owner_obj_id(&world, owner.obj_id) { @@ -849,6 +1297,17 @@ pub async fn create_for_owner( Some(crate::data::items::TemplateKind::SummonSlave { slave_id }) => *slave_id, _ => return None, }; + let template = server + .game_data + .systems + .vehicles + .slave_template(slave_id)? + .clone(); + let position_override = if placement.is_some() { + validated_summon_placement(server, &world, owner, &template, placement, max_range) + } else { + position_override + }; create( server, &world, @@ -1389,14 +1848,105 @@ pub(crate) fn create_spawn( d.unit.mp = d.unit.max_mp; } } - // Equip it's default items. TODO (C#): Implement vehicle customization - if let Some(pack) = data.slave_initial_item_pack(template.slave_initial_item_pack_id) { + // Equip its default items. 10.x: player-owned slave parts live in a persistent + // `EquipmentSlave` container keyed by the slave DB id (`item_containers.mate_id`), seeded + // once per hull; the model mirror drives stats and visibility packets. + if owner_id > 0 && db_id > 0 { + let existing = server.items.find_container_for_character( + owner_id, + crate::models::container::slot_type::EQUIPMENT_SLAVE, + db_id, + ); + let is_new_equipment = existing.is_none() + && !is_loaded + && item.as_ref().is_none_or(|i| i.details.slave_db_id == 0); + let container = existing.unwrap_or_else(|| { + server.items.container_for_character( + owner_id, + crate::models::container::slot_type::EQUIPMENT_SLAVE, + db_id, + &server.ids.container, + ) + }); + if is_new_equipment { + if let Some(pack) = data.slave_initial_item_pack(template.slave_initial_item_pack_id) { + let now = chrono::Utc::now().timestamp(); + for initial in pack { + let Some(mut it) = server.items.create( + initial.item_id, + 1, + 0, + server.config.id, + &server.game_data.items, + &server.ids.item, + now, + ) else { + continue; + }; + it.slot_type = crate::models::container::slot_type::EQUIPMENT_SLAVE; + it.slot = i32::from(initial.equip_slot_id); + it.owner_id = u64::from(owner_id); + it.dirty = true; + if container + .lock() + .expect("container poisoned") + .add_new_item( + it.clone(), + i32::from(initial.equip_slot_id), + &server.game_data.items, + ) + .is_err() + { + continue; + } + let entered = { + let mut d = slave.data(); + match d.equipment.get_mut(usize::from(initial.equip_slot_id)) { + Some(slot) => { + *slot = Some(it.clone()); + true + } + None => false, + } + }; + // EquipmentContainer.OnEnterContainer: the SCUnitEquipmentsChanged broadcast + // reaches nobody (not spawned yet), then ParentUnit.UpdateGearBonuses(...). + if entered { + crate::systems::skills::stats::update_vehicle_gear_bonuses( + server, + &slave_obj, + Some(&it), + None, + ); + } + } + } + } else { + let items = container.lock().expect("container poisoned").items.clone(); + let mut d = slave.data(); + for it in items { + let slot = it.slot.max(0) as usize; + if let Some(entry) = d.equipment.get_mut(slot) { + *entry = Some(it); + } + } + } + } else if let Some(pack) = data.slave_initial_item_pack(template.slave_initial_item_pack_id) { + // NPC / spawner slaves have no DB row: keep the 1.2 C# in-memory starter pack. let now = chrono::Utc::now().timestamp(); for initial in pack { - let Some(t) = server.game_data.items.template(initial.item_id) else { + let Some(it) = server.items.create_detached( + initial.item_id, + 1, + 0, + server.config.id, + &server.game_data.items, + now, + ) else { continue; }; - let mut it = Item::create(0, t, 1, 0, server.config.id, &server.game_data.items, now); + let mut it = it; + it.slot_type = crate::models::container::slot_type::EQUIPMENT_SLAVE; it.slot = i32::from(initial.equip_slot_id); let entered = { let mut d = slave.data(); @@ -1408,8 +1958,6 @@ pub(crate) fn create_spawn( None => false, } }; - // EquipmentContainer.OnEnterContainer: the SCUnitEquipmentsChanged broadcast reaches - // nobody (not spawned yet), then ParentUnit.UpdateGearBonuses(item, null). if entered { crate::systems::skills::stats::update_vehicle_gear_bonuses( server, From 5fa05b6e3db88e80b3783b4b6aac41a1239da0c2 Mon Sep 17 00:00:00 2001 From: stsiakal Date: Thu, 22 Oct 2026 05:26:18 +0300 Subject: [PATCH 02/13] fix(vehicles): validate and spawn slave equipment visuals Load slave_equip_slots, item_slave_equipments and the hull/slot allow packs. Validate CSChangeSlaveEquipment against the hull and target slot before moving items, and refuse with ItemNotForPet without a move. Spawn the part's child slave or doodad at the slot attach points on equip, remove it on unequip, and respawn them from the persistent container on summon; static bindings now only cover points without an equipment slot. Seed the starter pack only into declared slots. Add client-extracted attach points for models 511, 1482 and 1546. Co-Authored-By: Claude Opus 5.5 --- rust/crates/aaemu-game/PORTING.md | 41 +- .../app/Data/slave_attach_points.json | 450 +++++++++++++++++- .../aaemu-game/src/systems/vehicles/data.rs | 160 +++++++ .../src/systems/vehicles/flow_tests.rs | 401 ++++++++++++++++ .../aaemu-game/src/systems/vehicles/mod.rs | 1 + .../aaemu-game/src/systems/vehicles/slaves.rs | 373 ++++++++++++++- 6 files changed, 1397 insertions(+), 29 deletions(-) diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index eef04a9ae0..7319e09a72 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -309,7 +309,7 @@ Cross-subsystem: mates are despawned on dungeon entry and `PlayerCanEnter` check | Area (C#) | Rust | Status | Notes | |---|---|---|---| -| `MateGameData`, `SlaveGameData` (templates, unit modifiers, initial items / buffs, passive buffs, doodad / healing point / slave bindings, drop doodads, mount skills, repairable slaves, `slave_attach_points*.json`), `TransferGameData` (templates, bindings, binding doodads, paths, client `transfer_path.xml` roads + `GetOwnerPaths`), `ShipyardManager.Load`, `TaxationsManager` table, `ModelManager` vehicle / ship models | `systems/vehicles/data.rs` | done | Gated test `real_compact_db_vehicle_tables` checks the row counts; `real_transfer_follows_its_client_route` loads the roads from the game_pak. | +| `MateGameData`, `SlaveGameData` (templates, unit modifiers, initial items / buffs, passive buffs, doodad / healing point / slave bindings, drop doodads, mount skills, repairable slaves, `slave_equip_slots`, `item_slave_equipments`, `allow_to_equip_slaves` / `allow_to_equip_slots`, `slave_attach_points*.json`), `TransferGameData` (templates, bindings, binding doodads, paths, client `transfer_path.xml` roads + `GetOwnerPaths`), `ShipyardManager.Load`, `TaxationsManager` table, `ModelManager` vehicle / ship models | `systems/vehicles/data.rs` | done | Gated test `real_compact_db_vehicle_tables` checks the row counts; `real_transfer_follows_its_client_route` loads the roads from the game_pak. | | `MateManager` (per instance), `CharacterMates` (load / save / spawn / despawn), `Mate` (`AddExp`, `MateXpUpdateTask`, `RegenTick`, `DoFallDamage`, `OnZoneChange`, stats) | `systems/vehicles/mates.rs`, `stats.rs` | done | Mount / dismount (`SCUnitAttached` / `SCUnitDetached`, rider becomes a transform child), rename, target, user state, mate equipment packet (item move through `VehicleItemHooks`), kill exp, stun / unmount skills, death despawn. | | `SlaveManager` (per instance), `SlaveSpawner`, `SummonSlave` details, `Slave` (`DoDie`, `DoHpChangeTrigger` / repair points, `RegenTick`, `Save`, `OnZoneChange`, stats) | `systems/vehicles/slaves.rs` | done | Create (saved slave / persistent doodads / saved child slaves from MySQL, position, boats on the water surface, doodad and slave bindings at the model attach points), bind / unbind, delete with portal-time despawn, Rider's Escape, repair cooldown, `RepairSlaveEffect`, `SendMySlaveTask`, logout (+10 min) / disconnect despawn task, `slaves` table (`AfterCharacters`). | | `TransferManager` (per instance, 100 ms tick), `TransferSpawner`, `Transfer` route following (`GoToPath`, `MoveTo`, `NextPoint`) | `systems/vehicles/transfers.rs` | done | Carriage motor + boarding part + bench doodads, `SCOneUnitMovementPacket` (transfer move type) for both parts. Spawned from `SpawnManager.SpawnAll`. | @@ -2518,7 +2518,8 @@ finishes and the NPC settles in HoldPosition without further movement. Skill 15802 also needs the 10.x `unboundedPlacement` rule: a position target with `MaxRange <= 0` is not rejected as `TooFarRange`. - **`CSChangeSlaveEquipmentPacket`.** The 1.2 C# read only the header and logged it ("coming - soon"), so the implementation follows the 10.x packet logic (`e113e88b6`) adapted to the 1.2 + soon"), so the implementation follows the 10.x packet logic (`e533e88b6`, C# `develop` + 2026-08-02) adapted to the 1.2 client writer: `characterId u32`, `slaveTl u16`, `dbSlaveId u32`, `bts bool`, **one** item pair and the four location bytes (`397d12a0`; the 10.x `num` and per-entry `expireTime` do not exist in 1.2). Equip / unequip / re-slot move the item between the owner's bag and the slave's @@ -2536,10 +2537,32 @@ finishes and the NPC settles in HoldPosition without further movement. is reused on the next summon / restart; NPC / spawner slaves keep the 1.2 in-memory pack. - **Deviation from 1.2:** slave equipment persistence and the `0xF2` container do not exist in the 1.2 C# at all; they are the 10.x design, recorded here because the 1.2 data already ships - `slave_initial_items`, `slave_equip_slots` and `item_slave_equipments`. The server additionally - rejects a non-slave-part item (impl 28) on equip; 10.x trusted the client for that. -- **No equipment→skill link:** the 1.2 C# never connected equipped parts to cannon / vehicle - skills; slave mount skills still come from `slave_mount_skills` and child cannons from - `slave_bindings`. The 10.x `SpawnOrReplaceEquipmentVisual` / `item_slave_equipments` visual - spawning is not ported (no 1.2 C# reference), so equipping changes stats and the equipment - container but does not spawn replacement part doodads. + `slave_initial_items`, `slave_equip_slots` and `item_slave_equipments`. +- **Equipment validation (1.2 data):** equipping checks the item's + `item_slave_equipments.slave_equip_pack_id` against `allow_to_equip_slaves` (the hull) and its + `slot_pack_id` against `allow_to_equip_slots` (the target slot); the hull must also declare the + slot in `slave_equip_slots`. A refused move sends `ErrorMessageType.ItemNotForPet` (204; the + 1.2 client's "can't use that item on a summon" message) and moves nothing. 10.x trusted the + client for this; its `SLAVE_EQUIP_ERROR_REQUIRE_SLOT_AND_ITEM` / `..._UNEQUIP_FIRST` (804/805) + are for the client's slot-dependency rules, not for a part the hull does not accept. +- **Equipment visuals (10.x `SpawnEquipmentVisualsFromInventory`):** every occupied equipment + slot spawns what `item_slave_equipments` maps it to at the slot's `slave_equip_slots` attach + points: a child slave (Steel Cannon 28852 -> slave 10, Harpoon Cannon 30306 -> slave 48) or a + doodad (sails, masts, lamps, planks, figureheads, bell, telescope, ...). A slot that drives two + points (front/rear lamp, both planks) spawns the visual at both. Unequipping removes exactly + that visual; a resummon respawns it from the persistent container. At attach points a declared + equipment slot owns, the 1.2 static `slave_bindings` / `slave_doodad_bindings` are skipped so a + part can be removed; static bindings still cover points without an equipment slot. +- **Starter pack:** `slave_initial_items` rows are seeded only into slots the hull declares in + `slave_equip_slots` (slave 110 / 139 reference pack 1 without those slots; slave 21 has slot 0 + at the cannon points and no starter cannons). +- **Attach points:** models 511 (slave 22), 1482 (slave 132) and 1546 (slaves 139/142/143/145) + were recovered from the `$` helper nodes of the 1.2 client's `galleon_body_test.cgf`, + `boardship_body_test.cgf` and `middleship_body.cgf` (CGF units / 100, the same method and + values as the existing Clipper entry). Model 115 (`caravel.ship_body`) references a caravel + mesh that is not in the 1.2 pak, and model 117 (`galleon.cannon`, the cannon's gunner seat) is + an Entity `.chr` whose only node is its root (no `$` helpers), so those two still have no table + entry. +- **No equipment skill link:** the 1.2 C# never connected equipped parts to cannon / vehicle + skills; slave mount skills still come from `slave_mount_skills`. The child slaves spawned for + equipment are visuals with the normal child-slave behaviour, as in the 10.x reference. diff --git a/rust/crates/aaemu-game/app/Data/slave_attach_points.json b/rust/crates/aaemu-game/app/Data/slave_attach_points.json index 573622bb30..00b7b53005 100644 --- a/rust/crates/aaemu-game/app/Data/slave_attach_points.json +++ b/rust/crates/aaemu-game/app/Data/slave_attach_points.json @@ -2072,5 +2072,453 @@ "Z": 0.683005 } } + }, + { + "Name": "Small Sailing Ship", + "ModelId": 511, + "AttachPoints": { + "1": { + "X": 0.0, + "Y": -14.696714, + "Z": 6.208238 + }, + "9": { + "X": -4.292767, + "Y": 2.22774, + "Z": 4.420566 + }, + "10": { + "X": -4.476786, + "Y": 0.194722, + "Z": 4.48709 + }, + "11": { + "X": -4.571741, + "Y": -3.685339, + "Z": 4.641931 + }, + "12": { + "X": -4.464495, + "Y": -5.56138, + "Z": 4.74579 + }, + "13": { + "X": 4.308322, + "Y": 2.22774, + "Z": 4.420566 + }, + "14": { + "X": 4.492342, + "Y": 0.194722, + "Z": 4.48709 + }, + "15": { + "X": 4.587296, + "Y": -3.685339, + "Z": 4.641931 + }, + "16": { + "X": 4.48005, + "Y": -5.561381, + "Z": 4.745791 + }, + "17": { + "X": -0.025801, + "Y": -17.128943, + "Z": 6.531284 + }, + "19": { + "X": 0.0, + "Y": 10.391479, + "Z": 4.538411 + }, + "20": { + "X": 0.0, + "Y": -2.67354, + "Z": 4.55663 + }, + "21": { + "X": 0.0, + "Y": 10.391479, + "Z": 4.538411 + }, + "22": { + "X": 0.0, + "Y": -2.67354, + "Z": 4.556628 + }, + "23": { + "X": 0.0, + "Y": 13.82891, + "Z": 4.65069 + }, + "24": { + "X": -5.42189, + "Y": -1.698234, + "Z": -2.22113 + }, + "25": { + "X": 5.378184, + "Y": -1.698235, + "Z": -2.22113 + }, + "26": { + "X": -5.369734, + "Y": -1.676039, + "Z": 4.52554 + }, + "27": { + "X": 5.371309, + "Y": -1.6907, + "Z": 4.52554 + }, + "28": { + "X": -3.714641, + "Y": -10.47772, + "Z": 7.13656 + }, + "29": { + "X": 3.720835, + "Y": -10.465177, + "Z": 7.165107 + }, + "35": { + "X": 0.000382, + "Y": -13.99762, + "Z": 6.924236 + }, + "36": { + "X": 1.191211, + "Y": 14.183796, + "Z": 5.122476 + }, + "37": { + "X": 5.116659, + "Y": -0.73, + "Z": 3.333826 + }, + "38": { + "X": -0.246523, + "Y": -8.880871, + "Z": 5.260171 + }, + "39": { + "X": -0.929879, + "Y": -10.47738, + "Z": 1.97259 + }, + "47": { + "X": 2.427248, + "Y": -11.812762, + "Z": 5.96707 + }, + "48": { + "X": -4.162631, + "Y": -7.366074, + "Z": 1.911389 + }, + "49": { + "X": -3.885207, + "Y": -8.409836, + "Z": 1.809706 + }, + "50": { + "X": -3.664501, + "Y": -9.193998, + "Z": 1.661757 + }, + "51": { + "X": 3.809257, + "Y": -7.199599, + "Z": 1.944338 + }, + "52": { + "X": 4.052564, + "Y": -8.259335, + "Z": 1.841062 + }, + "53": { + "X": 3.627266, + "Y": -9.254662, + "Z": 1.70237 + }, + "57": { + "X": 0.0, + "Y": 20.088551, + "Z": 2.331362 + }, + "58": { + "X": -1.04452, + "Y": -14.868832, + "Z": -2.14507 + }, + "59": { + "X": 1.044517, + "Y": -14.868833, + "Z": -2.145065 + }, + "60": { + "X": 0.728445, + "Y": 2.223569, + "Z": 4.417754 + }, + "61": { + "X": -0.599329, + "Y": 2.159536, + "Z": 4.417754 + }, + "62": { + "X": -0.599328, + "Y": 3.448201, + "Z": 4.417754 + }, + "63": { + "X": 0.772781, + "Y": 3.559707, + "Z": 4.420332 + }, + "80": { + "X": 0.0, + "Y": -0.176037, + "Z": 34.136924 + }, + "81": { + "X": -0.078262, + "Y": -3.463748, + "Z": 38.546055 + } + } + }, + { + "Name": "Boardship 01", + "ModelId": 1482, + "AttachPoints": { + "1": { + "X": 0.0, + "Y": -12.510923, + "Z": 5.880291 + }, + "9": { + "X": -3.710351, + "Y": 6.579856, + "Z": 4.430594 + }, + "10": { + "X": -3.864485, + "Y": 4.429982, + "Z": 4.363184 + }, + "11": { + "X": -4.130303, + "Y": 0.244452, + "Z": 4.36447 + }, + "12": { + "X": -4.238666, + "Y": -1.731479, + "Z": 4.368301 + }, + "13": { + "X": 3.708737, + "Y": 6.579856, + "Z": 4.375907 + }, + "14": { + "X": 3.868636, + "Y": 4.448067, + "Z": 4.361554 + }, + "15": { + "X": 4.127504, + "Y": 0.32134, + "Z": 4.36428 + }, + "16": { + "X": 4.233886, + "Y": -1.706295, + "Z": 4.354098 + }, + "19": { + "X": 0.0, + "Y": 10.642557, + "Z": 4.495363 + }, + "20": { + "X": 0.0, + "Y": -1.152741, + "Z": 3.672005 + }, + "21": { + "X": 0.0, + "Y": 10.642557, + "Z": 4.495363 + }, + "22": { + "X": 0.0, + "Y": -1.152742, + "Z": 3.672005 + }, + "23": { + "X": 0.0, + "Y": 19.774658, + "Z": 5.438883 + }, + "24": { + "X": -5.171741, + "Y": 2.380774, + "Z": -2.221128 + }, + "25": { + "X": 5.159675, + "Y": 2.380774, + "Z": -2.221128 + }, + "26": { + "X": -5.139448, + "Y": 2.403407, + "Z": 4.383686 + }, + "27": { + "X": 5.134194, + "Y": 2.39589, + "Z": 4.383686 + }, + "28": { + "X": -4.000776, + "Y": -14.896173, + "Z": 7.301553 + }, + "29": { + "X": 4.028566, + "Y": -14.892327, + "Z": 7.301553 + }, + "35": { + "X": 0.0, + "Y": -11.811825, + "Z": 6.59629 + }, + "36": { + "X": 2.76042, + "Y": 15.242299, + "Z": 5.08637 + }, + "37": { + "X": -3.167246, + "Y": 12.138176, + "Z": 4.900893 + }, + "38": { + "X": -4.064834, + "Y": -4.082207, + "Z": 5.016424 + }, + "39": { + "X": 4.24207, + "Y": -8.774927, + "Z": 5.147105 + }, + "47": { + "X": 2.624988, + "Y": -17.204258, + "Z": 4.381397 + }, + "48": { + "X": -3.93576, + "Y": -8.923267, + "Z": 1.543295 + }, + "49": { + "X": -3.638052, + "Y": -10.043942, + "Z": 1.19631 + }, + "50": { + "X": -3.540766, + "Y": -11.441772, + "Z": 0.917408 + }, + "51": { + "X": 3.995122, + "Y": -8.923267, + "Z": 1.543295 + }, + "52": { + "X": 3.916255, + "Y": -10.332164, + "Z": 1.19631 + }, + "53": { + "X": 4.02451, + "Y": -11.441772, + "Z": 0.987061 + }, + "57": { + "X": 0.0, + "Y": 23.366628, + "Z": 2.45782 + }, + "58": { + "X": -1.813038, + "Y": -15.16531, + "Z": -2.88983 + }, + "59": { + "X": 1.792523, + "Y": -15.16531, + "Z": -2.88983 + }, + "60": { + "X": -0.739297, + "Y": 16.271682, + "Z": 5.179478 + }, + "61": { + "X": 0.688232, + "Y": 16.225596, + "Z": 5.181328 + }, + "62": { + "X": -0.743975, + "Y": 6.372867, + "Z": 4.397502 + }, + "63": { + "X": 0.761367, + "Y": 6.380472, + "Z": 4.401007 + }, + "80": { + "X": 0.0, + "Y": 7.78082, + "Z": 4.53405 + }, + "81": { + "X": 0.0, + "Y": -9.061644, + "Z": 9.73219 + } + } + }, + { + "Name": "Middleship", + "ModelId": 1546, + "AttachPoints": { + "1": { + "X": 0.006367, + "Y": -24.590676, + "Z": 10.10764 + }, + "10": { + "X": 0.0, + "Y": -20.147593, + "Z": 0.0 + }, + "35": { + "X": 0.006367, + "Y": -22.123501, + "Z": 11.144756 + } + } } -] \ No newline at end of file +] diff --git a/rust/crates/aaemu-game/src/systems/vehicles/data.rs b/rust/crates/aaemu-game/src/systems/vehicles/data.rs index 94cf663e0e..4469b5d360 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/data.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/data.rs @@ -220,6 +220,29 @@ pub struct SlaveInitialItem { pub item_id: u32, } +/// `SlaveEquipSlots`: one equipment slot of a hull and the model attach point it occupies. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SlaveEquipSlot { + pub id: u32, + pub slave_id: u32, + pub attach_point_id: u8, + pub equip_slot_id: u8, + pub require_slot_id: i32, +} + +/// `ItemSlaveEquipments`: what an item spawns when it sits in a hull equipment slot (a child +/// slave and/or a doodad) and which hull / slot packs accept it. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ItemSlaveEquipment { + pub id: u32, + pub item_id: u32, + pub slave_id: u32, + pub doodad_id: u32, + pub slave_equip_pack_id: u32, + pub slot_pack_id: u32, + pub require_item_id: u32, +} + /// `SlaveTemplate`. #[derive(Debug, Clone, PartialEq, Default)] pub struct SlaveTemplate { @@ -426,6 +449,14 @@ pub struct VehiclesData { /// `_attachPoints` (model id -> attach point -> location), points in file order. pub attach_points: HashMap>, pub slave_initial_items: HashMap>, + /// `slave_equip_slots` grouped by slave template id. + pub slave_equip_slots: HashMap>, + /// `item_slave_equipments` keyed by item id. + pub item_slave_equipments: HashMap, + /// `allow_to_equip_slaves` grouped by `slave_equip_pack_id`. + pub slave_equip_packs: HashMap>, + /// `allow_to_equip_slots` grouped by `slave_equipment_equip_slot_pack_id`. + pub slave_slot_packs: HashMap>, /// `_slaveMountSkills` (id, slave id, mount skill id) in insertion order. pub slave_mount_skills: Vec<(u32, u32, u32)>, /// `_repairableSlaves` (slave id -> repair effect id). @@ -619,6 +650,60 @@ impl VehiclesData { .push(item); Ok(()) })?; + for_each_row(ctx.conn, "SELECT * FROM slave_equip_slots", [], |r| { + let slot = SlaveEquipSlot { + id: r.u32("id")?, + slave_id: r.u32("slave_id")?, + attach_point_id: r.i32("attach_point_id")? as u8, + equip_slot_id: r.i32("equip_slot_id")? as u8, + require_slot_id: r.i32("require_slot_id")?, + }; + self.slave_equip_slots + .entry(slot.slave_id) + .or_default() + .push(slot); + Ok(()) + })?; + for_each_row(ctx.conn, "SELECT * FROM item_slave_equipments", [], |r| { + let item = ItemSlaveEquipment { + id: r.u32("id")?, + item_id: r.u32("item_id")?, + slave_id: r.u32_or("slave_id", 0)?, + doodad_id: r.u32_or("doodad_id", 0)?, + slave_equip_pack_id: r.u32_or("slave_equip_pack_id", 0)?, + slot_pack_id: r.u32_or("slot_pack_id", 0)?, + require_item_id: r.u32_or("require_item_id", 0)?, + }; + if self + .item_slave_equipments + .insert(item.item_id, item) + .is_some() + { + tracing::warn!( + "Duplicate entry for item_slave_equipments item {}", + item.item_id + ); + } + Ok(()) + })?; + for_each_row(ctx.conn, "SELECT * FROM allow_to_equip_slaves", [], |r| { + let pack_id = r.u32("slave_equip_pack_id")?; + let slave_id = r.u32("slave_id")?; + let pack = self.slave_equip_packs.entry(pack_id).or_default(); + if !pack.contains(&slave_id) { + pack.push(slave_id); + } + Ok(()) + })?; + for_each_row(ctx.conn, "SELECT * FROM allow_to_equip_slots", [], |r| { + let pack_id = r.u32("slave_equipment_equip_slot_pack_id")?; + let slot_id = r.i32("equip_slot_id")? as u8; + let pack = self.slave_slot_packs.entry(pack_id).or_default(); + if !pack.contains(&slot_id) { + pack.push(slot_id); + } + Ok(()) + })?; for_each_row(ctx.conn, "SELECT * FROM slave_initial_buffs", [], |r| { let slave_id = r.u32("slave_id")?; let buff_id = r.u32("buff_id")?; @@ -1084,6 +1169,81 @@ impl VehiclesData { self.slave_initial_items.get(&pack_id).map(Vec::as_slice) } + /// The equipment slots a hull declares (`slave_equip_slots`), in table order. + pub fn slave_equip_slots(&self, slave_id: u32) -> &[SlaveEquipSlot] { + self.slave_equip_slots + .get(&slave_id) + .map(Vec::as_slice) + .unwrap_or_default() + } + + /// The attach points an equipment slot occupies on a hull. A slot may drive more than one + /// point (front and rear lamps, both planks). + pub fn slave_equip_attach_points(&self, slave_id: u32, equip_slot_id: u8) -> Vec { + let mut points = Vec::new(); + for slot in self.slave_equip_slots(slave_id) { + if slot.equip_slot_id == equip_slot_id && !points.contains(&slot.attach_point_id) { + points.push(slot.attach_point_id); + } + } + points + } + + /// Whether `slave_id` declares `equip_slot_id` in `slave_equip_slots`. + pub fn has_slave_equip_slot(&self, slave_id: u32, equip_slot_id: u8) -> bool { + self.slave_equip_slots(slave_id) + .iter() + .any(|s| s.equip_slot_id == equip_slot_id) + } + + /// Every attach point any declared equipment slot of the hull occupies. + pub fn slave_equip_attach_point_set(&self, slave_id: u32) -> std::collections::HashSet { + self.slave_equip_slots(slave_id) + .iter() + .map(|s| s.attach_point_id) + .collect() + } + + /// `item_slave_equipments` row of an item template. + pub fn item_slave_equipment(&self, item_id: u32) -> Option<&ItemSlaveEquipment> { + self.item_slave_equipments.get(&item_id) + } + + /// `allow_to_equip_slaves` check (an empty pack accepts nothing). + pub fn slave_equip_pack_allows(&self, pack_id: u32, slave_id: u32) -> bool { + self.slave_equip_packs + .get(&pack_id) + .is_some_and(|ids| ids.contains(&slave_id)) + } + + /// `allow_to_equip_slots` check (an empty pack accepts nothing). + pub fn slot_pack_allows(&self, pack_id: u32, equip_slot_id: u8) -> bool { + self.slave_slot_packs + .get(&pack_id) + .is_some_and(|slots| slots.contains(&equip_slot_id)) + } + + /// Whether `item_id` may be equipped on `slave_id` in `equip_slot_id`: the item needs an + /// `item_slave_equipments` row, the hull must declare the slot, and the item's hull / slot + /// packs (when set) must allow it. + pub fn can_equip_item_on_slave(&self, item_id: u32, slave_id: u32, equip_slot_id: u8) -> bool { + let Some(equip) = self.item_slave_equipment(item_id) else { + return false; + }; + if !self.has_slave_equip_slot(slave_id, equip_slot_id) { + return false; + } + if equip.slave_equip_pack_id != 0 + && !self.slave_equip_pack_allows(equip.slave_equip_pack_id, slave_id) + { + return false; + } + if equip.slot_pack_id != 0 && !self.slot_pack_allows(equip.slot_pack_id, equip_slot_id) { + return false; + } + true + } + /// `GetAttachPointsForSlave(modelId)`. pub fn attach_points_for_slave(&self, model_id: u32) -> Option<&[(u8, AttachPointLocation)]> { self.attach_points.get(&model_id).map(Vec::as_slice) diff --git a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs index 558968eb2d..663b8c30a8 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs @@ -2913,6 +2913,32 @@ fn real_compact_db_vehicle_tables() { for point in [21, 36, 60, 61] { assert!(coupe.iter().any(|(p, _)| *p == point), "point {point}"); } + // Equipment tables: 92 slots over the seven customizable hulls, 43 item visuals, and the + // hull / slot packs. + let slots: usize = d.slave_equip_slots.values().map(Vec::len).sum(); + assert_eq!((slots, d.item_slave_equipments.len()), (92, 43)); + assert_eq!(d.slave_equip_slots[&22].len(), 27); + assert_eq!( + d.slave_equip_attach_points(22, 13), + vec![28, 29], + "the lamp slot drives the front and rear lamps" + ); + assert!(d.can_equip_item_on_slave(28852, 22, 3)); + assert!(!d.can_equip_item_on_slave(28852, 22, 0)); + assert!(!d.can_equip_item_on_slave(28852, 21, 3)); + assert!(!d.can_equip_item_on_slave(29723, 22, 3)); + assert!(!d.has_slave_equip_slot(21, 3)); + // Attach points recovered from the 1.2 client meshes. + for (slave, point) in [(22, 9), (22, 35), (132, 9), (139, 10), (139, 35)] { + let model = d.slave_templates[&slave].model_id; + let points = d + .attach_points_for_slave(model) + .unwrap_or_else(|| panic!("model {model} attach points")); + assert!( + points.iter().any(|(p, _)| *p == point), + "slave {slave} model {model} point {point}" + ); + } } /// A server whose main_world covers the real map (31 x 31 cells), with the real vehicle data. @@ -3379,6 +3405,30 @@ async fn slave_equipment_equips_unequips_and_survives_a_resummon() { ..ItemTemplate::plain(SLAVE_PART, 1) }, ); + d.systems + .vehicles + .slave_equip_slots + .entry(SLAVE_TEMPLATE) + .or_default() + .push(super::data::SlaveEquipSlot { + id: 1, + slave_id: SLAVE_TEMPLATE, + attach_point_id: 9, + equip_slot_id: 3, + require_slot_id: -1, + }); + d.systems.vehicles.item_slave_equipments.insert( + SLAVE_PART, + super::data::ItemSlaveEquipment { + id: 1, + item_id: SLAVE_PART, + slave_id: 0, + doodad_id: 0, + slave_equip_pack_id: 0, + slot_pack_id: 0, + require_item_id: 0, + }, + ); let server = server_with(d); crate::systems::economy::bridges::install(&server); crate::systems::npcs::install_hooks(&server); @@ -3556,3 +3606,354 @@ async fn slave_equipment_equips_unequips_and_survives_a_resummon() { "the saved hull keeps its equipped parts" ); } + +const SHIP_HULL: u32 = 22; +const OTHER_HULL: u32 = 23; +const CANNON_ITEM: u32 = 28852; +const CANNON_CHILD: u32 = 10; +const SLOT20_ITEM: u32 = 5003; + +fn ship_equip_data() -> GameData { + use super::data::{ItemSlaveEquipment, SlaveEquipSlot, SlaveInitialItem}; + let mut d = slave_data(); + d.systems.vehicles.slave_templates.insert( + SHIP_HULL, + SlaveTemplate { + id: SHIP_HULL, + name: "Ship".into(), + model_id: 511, + level: 1, + slave_kind: super::data::slave_kind::MACHINE, + slave_initial_item_pack_id: 1, + // A static binding on an equipment attach point must not add a second cannon. + slave_bindings: vec![super::data::SlaveBinding { + id: 1, + owner_id: SHIP_HULL, + owner_type: "Slave".into(), + slave_id: CANNON_CHILD, + attach_point_id: 9, + }], + ..SlaveTemplate::default() + }, + ); + d.systems.vehicles.slave_templates.insert( + OTHER_HULL, + SlaveTemplate { + id: OTHER_HULL, + name: "Other".into(), + model_id: 512, + level: 1, + slave_kind: super::data::slave_kind::MACHINE, + ..SlaveTemplate::default() + }, + ); + d.systems.vehicles.slave_templates.insert( + CANNON_CHILD, + SlaveTemplate { + id: CANNON_CHILD, + name: "Steel Cannon".into(), + model_id: 117, + level: 1, + slave_kind: super::data::slave_kind::SLAVE_EQUIPMENT, + ..SlaveTemplate::default() + }, + ); + for item in [CANNON_ITEM, SLOT20_ITEM] { + d.items.templates.insert( + item, + ItemTemplate { + impl_id: crate::data::items::item_impl::SLAVE_EQUIPMENT, + ..ItemTemplate::plain(item, 1) + }, + ); + } + d.systems.vehicles.slave_initial_items.insert( + 1, + vec![ + SlaveInitialItem { + pack_id: 1, + equip_slot_id: 3, + item_id: CANNON_ITEM, + }, + // No slave_equip_slots entry: must not be seeded. + SlaveInitialItem { + pack_id: 1, + equip_slot_id: 20, + item_id: SLOT20_ITEM, + }, + ], + ); + d.systems.vehicles.slave_equip_slots.insert( + SHIP_HULL, + vec![SlaveEquipSlot { + id: 1, + slave_id: SHIP_HULL, + attach_point_id: 9, + equip_slot_id: 3, + require_slot_id: -1, + }], + ); + d.systems.vehicles.item_slave_equipments.insert( + CANNON_ITEM, + ItemSlaveEquipment { + id: 1, + item_id: CANNON_ITEM, + slave_id: CANNON_CHILD, + doodad_id: 0, + slave_equip_pack_id: 4, + slot_pack_id: 11, + require_item_id: 0, + }, + ); + d.systems + .vehicles + .slave_equip_packs + .insert(4, vec![SHIP_HULL]); + d.systems.vehicles.slave_slot_packs.insert(11, vec![3]); + d.systems.vehicles.attach_points.insert( + 511, + vec![( + 9, + WorldSpawnPosition { + x: 1.5, + y: 2.5, + z: 3.5, + ..WorldSpawnPosition::default() + }, + )], + ); + d +} + +#[tokio::test] +async fn slave_equipment_cannon_visuals_and_pack_validation() { + use crate::models::item::ItemClass; + use crate::net::registry::ClientPacket; + use crate::systems::vehicles::packets::CSChangeSlaveEquipmentPacket; + + let server = server_with(ship_equip_data()); + crate::systems::economy::bridges::install(&server); + crate::systems::npcs::install_hooks(&server); + super::install_hooks(&server); + let mut a = TestClient::new(&server, 1, 1); + let pa = spawn_player(&server, &a, test_character(1, "P1", 100.0, 100.0), PA); + a.conn.active_char = Some(pa.clone()); + let world = server.world.world(0).unwrap(); + server.systems.npcs.spawns.get_or_create(&world); + let bag = pa + .data() + .inventory + .get(slot_type::INVENTORY) + .unwrap() + .clone(); + server.items.add_container(bag.clone()); + + let hull = slaves::create_core( + &server, + &world, + Some(&pa), + None, + SHIP_HULL, + None, + false, + None, + None, + ) + .expect("hull"); + let (tl, db_id) = { + let d = hull.data(); + (d.unit.tl_id, d.id) + }; + assert!(db_id > 0); + + // The starter pack seeded the declared slot only and its cannon visual spawned. + assert_eq!( + hull.data().equipment[3].as_ref().map(|i| i.template_id), + Some(CANNON_ITEM) + ); + assert!( + hull.data().equipment[20].is_none(), + "seeding must skip equipment slots the hull does not declare" + ); + let equipment = server + .items + .find_container_for_character(pa.character_id, slot_type::EQUIPMENT_SLAVE, db_id) + .expect("persistent container"); + assert!(equipment.lock().unwrap().get_item_by_slot(20).is_none()); + let first_child = { + let ids = hull.data().attached_slaves.clone(); + assert_eq!(ids.len(), 1, "the seeded cannon must spawn its child slave"); + let child = world.slave(ids[0]).expect("child slave"); + assert_eq!(child.data().unit.template_id, CANNON_CHILD); + assert_eq!(child.data().attach_point_id, 9); + let t = child.data().unit.transform; + assert_eq!((t.x, t.y, t.z), (1.5, 2.5, 3.5)); + ids[0] + }; + + let character_id = pa.character_id; + let packet_body = |item1: Option<&crate::models::item::Item>, + slot1: u8, + item2: Option<&crate::models::item::Item>, + slot2: u8| + -> Vec { + let mut s = PacketStream::new(); + s.write_u32(character_id) + .write_u16(tl) + .write_u32(db_id) + .write_bool(false); + match item1 { + Some(i) => { + s.write(i); + } + None => { + s.write_u32(0); + } + } + match item2 { + Some(i) => { + s.write(i); + } + None => { + s.write_u32(0); + } + } + s.write_u8(slot_type::INVENTORY) + .write_u8(slot1) + .write_u8(slot_type::EQUIPMENT_SLAVE) + .write_u8(slot2); + s.into_bytes() + }; + let run = |body: Vec, a: &mut TestClient| { + let p = CSChangeSlaveEquipmentPacket::read(&mut PacketStream::from_bytes(body)).unwrap(); + futures::executor::block_on(p.handle(&server, &mut a.conn)).unwrap(); + a.drain() + }; + let stored = equipment + .lock() + .unwrap() + .get_item_by_slot(3) + .cloned() + .expect("cannon in the container"); + + // Unequip: the child slave goes away with the item. + let frames = run(packet_body(None, 9, Some(&stored), 3), &mut a); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 1 + ); + assert!(world.slave(first_child).is_none()); + assert!(hull.data().attached_slaves.is_empty()); + assert!(hull.data().equipment[3].is_none()); + + // Equip it again, then re-summon the saved hull: the persistent container respawns the visual. + let frames = run(packet_body(Some(&stored), 9, None, 3), &mut a); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 1 + ); + let respawned = hull.data().attached_slaves.clone(); + assert_eq!(respawned.len(), 1); + slaves::delete(&server, Some(&pa), world.id, hull.obj_id, false); + assert!(world.slave(respawned[0]).is_none()); + let again = slaves::create_core( + &server, + &world, + Some(&pa), + None, + SHIP_HULL, + None, + false, + None, + Some(slaves::SavedSlave { + id: db_id, + name: "Ship".into(), + hp: 1, + mp: 1, + }), + ) + .expect("re-summoned hull"); + let anew = again.data().attached_slaves.clone(); + assert_eq!( + anew.len(), + 1, + "re-summon must spawn the visual from the equipment container" + ); + assert_eq!( + again.data().equipment[3].as_ref().map(|i| i.id), + Some(stored.id) + ); + + // Bag cannon into a slot the hull does not declare: refused, no move, proper error. + let mut extra = server + .items + .create( + CANNON_ITEM, + 1, + 0, + 1, + &server.game_data.items, + &server.ids.item, + 0, + ) + .expect("extra cannon"); + assert_eq!(extra.class, ItemClass::SlaveEquipment); + extra.slot_type = slot_type::INVENTORY; + extra.slot = 7; + extra.owner_id = u64::from(pa.character_id); + extra.dirty = true; + bag.lock().unwrap().items.push(extra.clone()); + let frames = run(packet_body(Some(&extra), 7, None, 4), &mut a); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 0 + ); + assert!(error_codes(&frames).contains(&super::error::ITEM_NOT_FOR_PET)); + assert!(bag.lock().unwrap().get_item_by_slot(7).is_some()); + assert!(again.data().equipment[4].is_none()); + + // Same item on a hull whose pack does not allow it: refused as well. + let other = slaves::create_core( + &server, + &world, + Some(&pa), + None, + OTHER_HULL, + None, + false, + None, + None, + ) + .expect("other hull"); + let (other_tl, other_db) = { + let d = other.data(); + (d.unit.tl_id, d.id) + }; + let mut s = PacketStream::new(); + s.write_u32(character_id) + .write_u16(other_tl) + .write_u32(other_db) + .write_bool(false); + s.write(&extra); + s.write_u32(0); + s.write_u8(slot_type::INVENTORY) + .write_u8(7) + .write_u8(slot_type::EQUIPMENT_SLAVE) + .write_u8(3); + let frames = run(s.into_bytes(), &mut a); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 0 + ); + assert!(error_codes(&frames).contains(&super::error::ITEM_NOT_FOR_PET)); + assert!(bag.lock().unwrap().get_item_by_slot(7).is_some()); + assert!(other.data().equipment[3].is_none()); +} diff --git a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs index fbb49762c1..762c87e1a6 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs @@ -263,6 +263,7 @@ pub mod error { pub const NOT_ENOUGH_ITEM: i16 = 27; pub const SLAVE_ALREADY_HAS_MASTER: i16 = 97; pub const SLAVE_SPAWN_ITEM_LOCKED: i16 = 101; + pub const ITEM_NOT_FOR_PET: i16 = 204; pub const NOT_READY: i16 = 206; pub const SLAVE_SPAWN_ERROR_NEED_REPAIR_TIME: i16 = 540; pub const SLAVE_SPAWN_ERROR_INVALID_AREA: i16 = 583; diff --git a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs index 3545622e36..b58f21ad23 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs @@ -404,6 +404,299 @@ fn mirror_slave_equipment(slave: &SlaveRef, container: &ContainerRef) { } } +/// `SlaveGameData.IsBindingAttachPoint`: a static doodad / slave / healing-point binding owns the +/// attach point, so equipment visuals never touch it. A point a declared equipment slot owns is +/// driven by the container instead, even when the 1.2 data also lists a static binding there. +fn is_binding_attach_point( + data: &super::data::VehiclesData, + template: &SlaveTemplate, + point: u8, +) -> bool { + if data + .slave_equip_attach_point_set(template.id) + .contains(&point) + { + return false; + } + template + .doodad_bindings + .iter() + .any(|b| b.attach_point_id == point) + || template + .slave_bindings + .iter() + .any(|b| b.attach_point_id == point) + || template + .healing_point_doodads + .iter() + .any(|b| b.attach_point_id == point) +} + +/// Removes the equipment-driven visual at one attach point (a child slave / doodad created by +/// [`spawn_or_replace_equipment_visual`]). Static bindings are never removed. +fn remove_equipment_visual_at( + server: &GameServer, + world: &Arc, + slave: &SlaveRef, + point: u8, +) { + let data = &server.game_data.systems.vehicles; + if data + .slave_template(slave.data().unit.template_id) + .is_some_and(|t| is_binding_attach_point(data, t, point)) + { + return; + } + let mut doodads = Vec::new(); + let mut children = Vec::new(); + { + let d = slave.data(); + for id in &d.attached_doodads { + if world + .doodad(*id) + .is_some_and(|dd| dd.data().attach_point == point) + { + doodads.push(*id); + } + } + for id in &d.attached_slaves { + if world + .slave(*id) + .is_some_and(|s| s.data().attach_point_id as u8 == point) + { + children.push(*id); + } + } + } + slave + .data() + .attached_doodads + .retain(|id| !doodads.contains(id)); + for id in &doodads { + if let Some(doodad) = world.doodad(*id) { + spawn_manager::backend::doodad_delete(server, world, &doodad); + } + } + slave + .data() + .attached_slaves + .retain(|id| !children.contains(id)); + for id in &children { + if let Some(child) = world.slave(*id) { + world.delete(WorldObject::from(&child)); + } + } +} + +/// `SlaveManager.SpawnEquipmentDoodad`: the doodad a ship part becomes (sails, masts, lamps, ...). +fn spawn_equipment_doodad( + server: &GameServer, + world: &Arc, + slave: &SlaveRef, + point: u8, + doodad_id: u32, + item: &Item, +) { + let Some(doodad) = + crate::systems::npcs::doodad::manager::create(server, world, 0, doodad_id, None, true) + else { + tracing::warn!( + "Slave {}: doodad template {doodad_id} missing for equipment visual", + slave.data().unit.template_id + ); + return; + }; + let slave_obj = WorldObject::from(slave); + let (owner_obj_id, owner_id, slave_db_id, faction, spawn_time) = { + let d = slave.data(); + ( + d.summoner_obj_id, + d.summoner_id, + d.id, + d.unit.faction_id, + d.spawn_time_ms, + ) + }; + { + let mut d = doodad.data(); + d.owner_obj_id = owner_obj_id; + d.parent_obj_id = slave.obj_id; + d.attach_point = point; + d.owner_id = owner_id; + d.plant_time = spawn_time / 1000; + d.owner_type = doodad_owner_type::SLAVE; + d.owner_db_id = slave_db_id; + d.data = i32::from(point); + d.faction_id = faction; + d.type2 = 1; + d.scale = 1.0; + d.transform.instance_id = world.id; + d.transform.set_position(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); + if item.flags & crate::models::item::ITEM_FLAG_HAS_UCC != 0 && item.ucc_id > 0 { + d.ucc_id = item.ucc_id; + } + } + let start = crate::systems::npcs::doodad::phase::get_func_group_id( + &server.game_data.systems.npcs.doodad, + doodad_id, + ); + crate::systems::npcs::doodad::manager::set_func_group_id(server, &doodad, start); + let dobj = WorldObject::from(&doodad); + world.attach_child(&slave_obj, &dobj); + apply_attach_point_location(server, world, slave, &dobj, point); + slave.data().attached_doodads.push(doodad.obj_id); + crate::systems::npcs::doodad::manager::init_doodad(server, world, &doodad); + crate::systems::npcs::doodad::manager::spawn(server, world, &doodad); +} + +/// `SlaveManager.SpawnEquipmentChildSlave`: the child slave a part becomes (cannons, harpoons). +fn spawn_equipment_child_slave( + server: &GameServer, + world: &Arc, + slave: &SlaveRef, + point: u8, + child_template_id: u32, +) { + let data = &server.game_data.systems.vehicles; + let Some(child_template) = data.slave_template(child_template_id).cloned() else { + tracing::warn!( + "Slave {}: child template {child_template_id} missing for equipment visual", + slave.data().unit.template_id + ); + return; + }; + let Some(child_tl) = server.ids.tl.get_next_id().ok() else { + return; + }; + let Some(child_obj_id) = server.ids.object.get_next_id().ok() else { + return; + }; + let (summoner_id, summoner_obj_id, summoner_name, faction, slave_db_id) = { + let d = slave.data(); + ( + d.summoner_id, + d.summoner_obj_id, + d.summoner_name.clone(), + d.unit.faction_id, + d.id, + ) + }; + let mut c = Slave::new(0, child_template.id); + c.unit.tl_id = child_tl as u16; + c.unit.name = child_template.name.clone(); + c.unit.level = child_template.level as u8; + c.unit.model_id = child_template.model_id; + c.unit.faction_id = faction; + c.summoner_id = summoner_id; + c.summoner_obj_id = summoner_obj_id; + c.summoner_name = summoner_name; + c.spawn_time_ms = now_ms(); + c.attach_point_id = point as i8; + c.owner_obj_id = slave.obj_id; + c.owner_type = BaseUnitType::Slave; + c.unit.owner_id = slave_db_id; + let child = Entity::new(child_obj_id, c); + let child_obj = WorldObject::from(&child); + apply_slave_bonuses(server, &child_obj, &child_template); + stats::refresh_object_pools(server, &child_obj); + { + let mut d = child.data(); + d.unit.hp = d.unit.max_hp; + d.unit.mp = d.unit.max_mp; + let w = world.world_pos_rot(&WorldObject::from(slave)); + d.unit.transform.instance_id = world.id; + d.unit + .transform + .set_position(w.x, w.y, w.z, w.rot_x, w.rot_y, w.rot_z); + } + let slave_obj = WorldObject::from(slave); + world.attach_child(&slave_obj, &child_obj); + apply_attach_point_location(server, world, slave, &child_obj, point); + slave.data().attached_slaves.push(child_obj_id); + let changes = world.spawn(&child, &server.view_ctx()); + crate::world::session::handle_zone_changes(server, changes); + let hp = child.data().unit.hp; + crate::systems::skills::combat::post_update_current_hp( + server, + &child_obj, + Some(&child_obj), + 0, + hp, + KillReason::Unknown, + ); +} + +/// `SlaveManager.SpawnOrReplaceEquipmentVisual`: at every attach point the equipment slot +/// occupies, remove the previous visual and spawn the one the item maps to (`None` unequips). +pub fn spawn_or_replace_equipment_visual( + server: &GameServer, + world: &Arc, + slave: &SlaveRef, + item: Option<&Item>, + equip_slot_id: u8, +) { + let data = &server.game_data.systems.vehicles; + let Some(template) = data.slave_template(slave.data().unit.template_id).cloned() else { + return; + }; + let points = data.slave_equip_attach_points(template.id, equip_slot_id); + if points.is_empty() { + tracing::debug!( + "No slave_equip_slots entry for slave={} slot={equip_slot_id}", + template.id + ); + return; + } + for point in points { + if is_binding_attach_point(data, &template, point) { + tracing::debug!( + "Skip equip visual at {point} on slave tpl={}: attach point is a static binding", + template.id + ); + continue; + } + remove_equipment_visual_at(server, world, slave, point); + let Some(item) = item else { + continue; + }; + let Some(visual) = data.item_slave_equipment(item.template_id) else { + tracing::warn!( + "No item_slave_equipments visual for item={} on slave tpl={} slot={equip_slot_id}", + item.template_id, + template.id + ); + continue; + }; + if visual.slave_id > 0 { + spawn_equipment_child_slave(server, world, slave, point, visual.slave_id); + } else if visual.doodad_id > 0 { + spawn_equipment_doodad(server, world, slave, point, visual.doodad_id, item); + } + } +} + +/// `SlaveManager.SpawnEquipmentVisualsFromInventory`: spawn the visual of every equipped part. +pub fn spawn_equipment_visuals_from_inventory( + server: &GameServer, + world: &Arc, + slave: &SlaveRef, +) { + let items: Vec<(u8, Item)> = { + let d = slave.data(); + d.equipment + .iter() + .enumerate() + .filter_map(|(slot, item)| { + item.as_ref() + .map(|i| (u8::try_from(slot).unwrap_or(u8::MAX), i.clone())) + }) + .collect() + }; + for (slot, item) in items { + spawn_or_replace_equipment_visual(server, world, slave, Some(&item), slot); + } +} + /// `CSChangeSlaveEquipmentPacket` (10.x `CSChangeSlaveEquipmentPacket.Read`, adapted to the 1.2 /// one-pair body and opcode): equip, unequip or re-slot a ship / vehicle part. The persistent /// `EquipmentSlave` container is keyed by `(character id, slave DB id)` so the item rows survive @@ -560,24 +853,36 @@ pub fn change_slave_equipment( reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), false); return; } - // Ship / vehicle parts only: the item template carries `ItemImplEnum.SlaveEquipment` - // (`item_slave_equipments` in the 1.2 data). - if p.slot1_type == slot_type::INVENTORY { - if let Some(i) = &item1 { - let is_part = server - .game_data - .items - .template(i.template_id) - .is_some_and(|t| t.impl_id == crate::data::items::item_impl::SLAVE_EQUIPMENT); - if !is_part { - tracing::warn!( - "ChangeSlaveEquipment: item {} (template {}) is not a slave part", - i.id, - i.template_id - ); - reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), false); - return; - } + // Ship / vehicle parts only, and only where the hull / slot packs allow them. The 1.2 data + // carries the validation that the 10.x server left to the client: + // `item_slave_equipments.slave_equip_pack_id` -> `allow_to_equip_slaves` and + // `slot_pack_id` -> `allow_to_equip_slots`. + let slave_template_id = slave.data().unit.template_id; + let data = &server.game_data.systems.vehicles; + let allowed = |item: &Item, target_slot: u8| { + data.can_equip_item_on_slave(item.template_id, slave_template_id, target_slot) + }; + for (item, target_slot) in [ + (item1.as_ref(), p.slot2), + ( + (p.slot1_type == slot_type::EQUIPMENT_SLAVE) + .then_some(item2.as_ref()) + .flatten(), + p.slot1, + ), + ] { + let Some(item) = item else { continue }; + if !allowed(item, target_slot) { + tracing::warn!( + "ChangeSlaveEquipment: item {} (template {}) cannot be equipped on slave tpl={} slot {}", + item.id, + item.template_id, + slave_template_id, + target_slot + ); + error(character, super::error::ITEM_NOT_FOR_PET); + reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), false); + return; } } // Source / target: the 1.2 client always puts the slave slot second. If its first slot is @@ -639,6 +944,20 @@ pub fn change_slave_equipment( return; } mirror_slave_equipment(&slave, &equipment); + let mut touched = Vec::new(); + for (slot, st) in [(p.slot1, p.slot1_type), (p.slot2, p.slot2_type)] { + if st == slot_type::EQUIPMENT_SLAVE && !touched.contains(&slot) { + touched.push(slot); + } + } + for slot in touched { + let item = equipment + .lock() + .expect("container poisoned") + .get_item_by_slot(i32::from(slot)) + .cloned(); + spawn_or_replace_equipment_visual(server, &world, &slave, item.as_ref(), slot); + } let slave_obj = WorldObject::from(&slave); crate::systems::skills::stats::update_vehicle_gear_bonuses( server, @@ -1872,6 +2191,9 @@ pub(crate) fn create_spawn( if let Some(pack) = data.slave_initial_item_pack(template.slave_initial_item_pack_id) { let now = chrono::Utc::now().timestamp(); for initial in pack { + if !data.has_slave_equip_slot(template.id, initial.equip_slot_id) { + continue; + } let Some(mut it) = server.items.create( initial.item_id, 1, @@ -1935,6 +2257,9 @@ pub(crate) fn create_spawn( // NPC / spawner slaves have no DB row: keep the 1.2 C# in-memory starter pack. let now = chrono::Utc::now().timestamp(); for initial in pack { + if !data.has_slave_equip_slot(template.id, initial.equip_slot_id) { + continue; + } let Some(it) = server.items.create_detached( initial.item_id, 1, @@ -2051,8 +2376,14 @@ fn finish_create( d.spawn_time_ms, ) }; + // Attach points a declared equipment slot owns are driven by the equipment container instead + // of the static bindings, so unequipping a part can remove its visual. + let equipment_points = data.slave_equip_attach_point_set(template.id); // Create all remaining doodads that where not previously loaded for binding in &template.doodad_bindings { + if equipment_points.contains(&binding.attach_point_id) { + continue; + } let loaded_points: Vec = { let ids = slave.data().attached_doodads.clone(); ids.iter() @@ -2121,7 +2452,7 @@ fn finish_create( // Spawn Slave's slaves for binding in &template.slave_bindings { - if binding.owner_type != "Slave" { + if binding.owner_type != "Slave" || equipment_points.contains(&binding.attach_point_id) { continue; } let mut child_db_id = 0u32; @@ -2204,6 +2535,10 @@ fn finish_create( ); } + // Equipment-driven visuals (cannons, sails, masts, cargo, figureheads) from the parts the + // hull carries. + spawn_equipment_visuals_from_inventory(server, world, slave); + // If it's a boat, add it to boat physics if template.is_a_boat() { if owner.is_none() { From 71d9dfdadae2212762364842552a955f5c3fb4d1 Mon Sep 17 00:00:00 2001 From: stsiakal Date: Thu, 22 Oct 2026 06:35:43 +0300 Subject: [PATCH 03/13] feat(vehicles): man ship cannons A cannon (kind 8) mounted on a ship has one gunner seat (attach point 1). CSBindSlave refuses non-crew (SLAVE_CANNOT_BIND), a second gunner (SLAVE_ALREADY_HAS_MASTER) and riders of another slave (SLAVE_UNBIND_FIRST). Only the gunner casts the cannon's mount skills. The gunner is unbound when the ship is recalled, destroyed or the cannon unequipped, and on death; the seat sits at GUNNER_SEAT_OFFSET behind the barrel and follows the ship. Co-Authored-By: Claude Opus 5.5 --- rust/crates/aaemu-game/PORTING.md | 22 +- .../src/systems/skills/mount_authority.rs | 13 +- .../src/systems/vehicles/flow_tests.rs | 237 ++++++++++++++++++ .../aaemu-game/src/systems/vehicles/mod.rs | 3 + .../aaemu-game/src/systems/vehicles/slaves.rs | 127 +++++++++- 5 files changed, 396 insertions(+), 6 deletions(-) diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 7319e09a72..f5b22af869 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -2403,8 +2403,8 @@ two bots before the fix (a foreign `Mount` caster, an NPC-only skill and a far d - **Mount caster.** `SkillCaster::Mount { obj_id }` may name the player itself, a mate the player may use (`may_use_mate`), or a slave the player summoned (`summoner_obj_id` / `summoner_id`), - is attached to (`attached_characters`, or `parent_obj_id`), or that is mounted on a slave the - player summoned (cannon on a ship). Any other object (NPC, doodad, another player, a foreign + is attached to (`attached_characters`, or `parent_obj_id`), or that is a harpoon mounted on a + slave the player summoned. A ship cannon (kind 8 child) answers only its gunner. Any other object (NPC, doodad, another player, a foreign slave) is refused with a warning and `SCSkillStarted` carrying `NO_PERM`. - **Range of doodad and slave targets.** The C# skipped the `TooFarRange` check for every Doodad or Slave target (its own TODO asks for a bounding-box check). The Rust now allows @@ -2566,3 +2566,21 @@ finishes and the NPC settles in HoldPosition without further movement. - **No equipment skill link:** the 1.2 C# never connected equipped parts to cannon / vehicle skills; slave mount skills still come from `slave_mount_skills`. The child slaves spawned for equipment are visuals with the normal child-slave behaviour, as in the 10.x reference. +- **Manned ship cannons (deviation, the C# has none of this):** a kind-8 slave mounted on another + slave (`slaves::is_manned_cannon`) has one gunner seat, attach point 1 (the `mount_attached_skills` + row of mount skill 16 / Fire Cannon 10473 -> skill 14372). `CSBindSlave` on it is refused with + `SLAVE_CANNOT_BIND` unless the character summoned the cannon, owns the carrier ship or is aboard + it (standing on it or seated on any of its points; the 1.2 data has no seat permission table, so + party / expedition membership is not required), with `SLAVE_ALREADY_HAS_MASTER` when the seat is + taken and `SLAVE_UNBIND_FIRST` when the character already rides another slave. Only the gunner + may cast the cannon's mount skills (`mount_authority::may_use_slave`); the carrier's owner no + longer fires it remotely. The gunner leaves through `CSDiscardSlave`, death (`on_death_event`), + teleport / `force_dismount`, the cannon being unequipped, or the carrier being recalled, + destroyed or despawned (`unbind_child_riders`). The gunner sits at the model's driver helper if + `slave_attach_points*.json` has one, else at `GUNNER_SEAT_OFFSET` (0, -0.8, 0) in the cannon + frame: model 117 has no helper in the data or the pak, and no cannon-like model with a seat helper + exists, so this is a documented constant. The gunner is a transform child of the cannon, which is + a child of the ship, so the position follows the moving ship. Fire Cannon is a ballistic position + skill (4 m area, 4-120 m, fixed 130-170 damage); the area damage and the `SCSkillFired` broadcast + (the client draws the projectile from the skill's projectile 13) are covered by + `ship_cannon_gunner_seat_skill_and_leaving`. diff --git a/rust/crates/aaemu-game/src/systems/skills/mount_authority.rs b/rust/crates/aaemu-game/src/systems/skills/mount_authority.rs index e35a981549..f7bdabd959 100644 --- a/rust/crates/aaemu-game/src/systems/skills/mount_authority.rs +++ b/rust/crates/aaemu-game/src/systems/skills/mount_authority.rs @@ -31,8 +31,8 @@ fn summoned_by(slave: &SlaveRef, player: &PlayerRef, character_id: u32) -> bool } /// A slave (ship, cannon, cart, ...) answers the skills of its owner and of the characters -/// attached to it (driver, gunner, passengers); a cannon or a harpoon child also answers the -/// owner of the slave it is mounted on. +/// attached to it (driver, gunner, passengers); a harpoon child also answers the owner of the +/// slave it is mounted on. A ship cannon answers only the character manning it. pub(super) fn may_use_slave( server: &crate::server::GameServer, player: &PlayerRef, @@ -40,6 +40,15 @@ pub(super) fn may_use_slave( ) -> bool { let parent = player.data().unit.transform.parent_obj_id; let character_id = player.character_id; + // A cannon mounted on a ship answers its gunner only: manning it is what grants the shot. + if crate::systems::vehicles::slaves::is_manned_cannon(server, slave) { + return parent == slave.obj_id + || slave + .data() + .attached_characters + .iter() + .any(|(_, obj)| *obj == player.obj_id); + } if parent == slave.obj_id || summoned_by(slave, player, character_id) { return true; } diff --git a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs index 663b8c30a8..e2fb87a0de 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs @@ -3957,3 +3957,240 @@ async fn slave_equipment_cannon_visuals_and_pack_validation() { assert!(bag.lock().unwrap().get_item_by_slot(7).is_some()); assert!(other.data().equipment[3].is_none()); } + +const FIRE_CANNON: u32 = 10473; +const GUNNER_STATE_SKILL: u32 = 14372; +const CANNON_MOUNT_SKILL: u32 = 16; +const CANNON_TARGET_NPC: u32 = 901; + +/// `ship_equip_data` plus the 1.2 cannon fire skill: mount skill 16 -> skill 10473 (ballistic +/// position target, 4 m area, 4-120 m, fixed damage), attached skill 14372 at the gunner seat. +fn cannon_data() -> GameData { + use crate::systems::skills::data::effects::EffectTemplate; + use crate::systems::skills::data::{EffectKind, SkillTemplate}; + let mut d = ship_equip_data(); + d.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(crate::systems::skills::tests::damage_effect( + 183, 150, + ))), + 183, + ); + d.systems.skills.add_skill(SkillTemplate { + id: FIRE_CANNON, + target_type: 11, // BallisticPos + target_selection: 2, + // The real row is Hostile (4); this fixture has no factions. + target_relation: 5, + target_area_radius: 4, + min_range: 4, + max_range: 120, + source_mount: true, + level_rule_no_consideration: true, + effects: vec![crate::systems::skills::tests::skill_effect( + 183, + EffectKind::DamageEffect, + 183, + )], + ..SkillTemplate::default() + }); + d.systems.skills.add_skill(SkillTemplate { + id: GUNNER_STATE_SKILL, + target_type: 0, + level_rule_no_consideration: true, + ..SkillTemplate::default() + }); + d.systems + .vehicles + .mount_skills + .push(super::data::MountSkills { + id: CANNON_MOUNT_SKILL, + name: "Fire".into(), + skill_id: FIRE_CANNON, + }); + d.systems + .vehicles + .mount_attached_skills + .push(super::data::MountAttachedSkills { + id: 131, + mount_skill_id: CANNON_MOUNT_SKILL, + attach_point_id: attach_point::DRIVER, + skill_id: GUNNER_STATE_SKILL, + }); + d.systems.npcs.npc.templates.insert( + CANNON_TARGET_NPC, + NpcTemplate { + id: CANNON_TARGET_NPC, + name: "Target".into(), + level: 1, + ..NpcTemplate::default() + }, + ); + d +} + +#[tokio::test] +async fn ship_cannon_gunner_seat_skill_and_leaving() { + use crate::net::registry::ClientPacket; + use crate::systems::skills::handlers::{start_skill, CSStartSkillPacket}; + use crate::systems::skills::types::{SkillCastTarget, SkillCaster, SkillObject}; + + let server = server_with(cannon_data()); + crate::systems::economy::bridges::install(&server); + crate::systems::npcs::install_hooks(&server); + super::install_hooks(&server); + let mut a = TestClient::new(&server, 1, 1); + let mut b = TestClient::new(&server, 2, 2); + let mut c = TestClient::new(&server, 3, 3); + let pa = spawn_player(&server, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let pb = spawn_player(&server, &b, test_character(2, "Crew", 101.0, 100.0), PB); + let pc = spawn_player( + &server, + &c, + test_character(3, "Stranger", 102.0, 100.0), + 0x00F0_0003, + ); + a.conn.active_char = Some(pa.clone()); + b.conn.active_char = Some(pb.clone()); + c.conn.active_char = Some(pc.clone()); + let world = server.world.world(0).unwrap(); + server.systems.npcs.spawns.get_or_create(&world); + + let hull = slaves::create_core( + &server, + &world, + Some(&pa), + None, + SHIP_HULL, + None, + false, + None, + None, + ) + .expect("hull"); + let cannon = world + .slave(hull.data().attached_slaves[0]) + .expect("cannon child"); + let cannon_tl = u32::from(cannon.data().unit.tl_id); + assert!(slaves::is_manned_cannon(&server, &cannon)); + assert!(!slaves::is_manned_cannon(&server, &hull)); + + let target = spawn_npc_at(&server, 0x5000, CANNON_TARGET_NPC, 130.0, 130.0); + target.data().unit.hp = 1000; + target.data().unit.max_hp = 1000; + let fire = |client: &mut TestClient, x: f32, y: f32| { + start_skill( + &server, + &mut client.conn, + CSStartSkillPacket { + skill_id: FIRE_CANNON, + caster: SkillCaster::Mount { + obj_id: cannon.obj_id, + mount_skill_template_id: CANNON_MOUNT_SKILL, + }, + target: SkillCastTarget::Position { + obj_id: 0, + x, + y, + z: 100.0, + rot: 0.0, + obj_id1: 0, + obj_id2: 0, + }, + flag: 0, + skill_object: SkillObject::None, + }, + ); + }; + a.drain(); + b.drain(); + c.drain(); + + // Not manned yet: not even the ship owner may fire the cannon. + fire(&mut a, 130.0, 130.0); + assert_eq!(target.data().unit.hp, 1000); + a.drain(); + + // A stranger off the ship is refused with the bind error and is not seated. + slaves::bind_slave_by_tl(&server, &pc, cannon_tl); + assert!(error_codes(&c.drain()).contains(&super::error::SLAVE_CANNOT_BIND)); + assert!(cannon.data().attached_characters.is_empty()); + + // The ship owner mans it at the gunner seat, behind the barrel. + slaves::bind_slave_by_tl(&server, &pa, cannon_tl); + assert!(ops(&a.drain()).contains(&sc::SCUnitAttachedPacket)); + assert_eq!( + cannon.data().attached_characters, + vec![(attach_point::DRIVER, PA)] + ); + assert_eq!(pa.data().unit.transform.parent_obj_id, cannon.obj_id); + let t = pa.data().unit.transform; + assert_eq!((t.x, t.y, t.z), slaves::GUNNER_SEAT_OFFSET); + + // The gunner follows the cannon on the moving ship. + let before = world.world_pos_rot(&WorldObject::from(&pa)); + hull.data().unit.transform.x += 25.0; + hull.data().unit.transform.y -= 10.0; + let after = world.world_pos_rot(&WorldObject::from(&pa)); + assert!( + (after.x - before.x - 25.0).abs() < 1e-3, + "{before:?} {after:?}" + ); + assert!((after.y - before.y + 10.0).abs() < 1e-3); + + // Second gunner: a crew member standing on the ship is refused, one gunner per cannon. + world.attach_child(&WorldObject::from(&hull), &WorldObject::from(&pb)); + slaves::bind_slave_by_tl(&server, &pb, cannon_tl); + assert!(error_codes(&b.drain()).contains(&super::error::SLAVE_ALREADY_HAS_MASTER)); + assert_eq!(cannon.data().attached_characters.len(), 1); + // ... and cannot cast its skills either. + fire(&mut b, 130.0, 130.0); + assert_eq!(target.data().unit.hp, 1000); + b.drain(); + + // The gunner fires at a ground position: the unit in the area takes the shot. + fire(&mut a, 130.0, 130.0); + assert_eq!(target.data().unit.hp, 850, "fixed 150 damage"); + let fa = a.drain(); + assert!(ops(&fa).contains(&sc::SCSkillFiredPacket)); + assert!(ops(&fa).contains(&sc::SCUnitPointsPacket)); + assert!(ops(&b.drain()).contains(&sc::SCSkillFiredPacket)); + // Out of the 4 m area: no damage. + fire(&mut a, 60.0, 60.0); + assert_eq!(target.data().unit.hp, 850); + + // Leaving the cannon (CSDiscardSlave) frees the seat for the crew member. + let discard = super::packets::CSDiscardSlavePacket { + tl_id: cannon_tl as u16, + }; + futures::executor::block_on(discard.handle(&server, &mut a.conn)).unwrap(); + assert!(cannon.data().attached_characters.is_empty()); + assert_eq!(pa.data().unit.transform.parent_obj_id, 0); + assert!(ops(&a.drain()).contains(&sc::SCUnitDetachedPacket)); + b.drain(); + slaves::bind_slave_by_tl(&server, &pb, cannon_tl); + assert_eq!( + cannon.data().attached_characters, + vec![(attach_point::DRIVER, PB)] + ); + assert!(error_codes(&b.drain()).is_empty()); + + // The gunner dying leaves the cannon. + crate::systems::skills::combat::do_die( + &server, + &WorldObject::from(&pb), + Some(&WorldObject::from(&target)), + crate::systems::skills::types::KillReason::Damage, + ); + assert!(cannon.data().attached_characters.is_empty()); + assert_eq!(pb.data().unit.transform.parent_obj_id, 0); + + // Recalling the ship unbinds a gunner too. + slaves::bind_slave_by_tl(&server, &pa, cannon_tl); + assert_eq!(cannon.data().attached_characters.len(), 1); + slaves::delete(&server, Some(&pa), world.id, hull.obj_id, false); + assert_eq!(pa.data().attached_point, attach_point::NONE); + assert_eq!(pa.data().unit.transform.parent_obj_id, 0); + assert!(!pa.data().is_riding); + assert!(cannon.data().attached_characters.is_empty()); +} diff --git a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs index 762c87e1a6..30f6723fcd 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs @@ -261,8 +261,10 @@ pub mod error { pub const ITEM_FAILED_REPAIR: i16 = 23; pub const NOT_ENOUGH_MONEY: i16 = 26; pub const NOT_ENOUGH_ITEM: i16 = 27; + pub const SLAVE_CANNOT_BIND: i16 = 96; pub const SLAVE_ALREADY_HAS_MASTER: i16 = 97; pub const SLAVE_SPAWN_ITEM_LOCKED: i16 = 101; + pub const SLAVE_UNBIND_FIRST: i16 = 102; pub const ITEM_NOT_FOR_PET: i16 = 204; pub const NOT_READY: i16 = 206; pub const SLAVE_SPAWN_ERROR_NEED_REPAIR_TIME: i16 = 540; @@ -375,6 +377,7 @@ pub fn on_death_event(server: &GameServer, victim: &WorldObject) { match victim { WorldObject::Shipyard(s) => shipyards::on_death(server, s), WorldObject::Mate(m) => mates::on_death(server, m), + WorldObject::Player(p) => slaves::on_gunner_death(server, p), _ => {} } } diff --git a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs index b58f21ad23..3aa9c735b7 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs @@ -483,6 +483,7 @@ fn remove_equipment_visual_at( .retain(|id| !children.contains(id)); for id in &children { if let Some(child) = world.slave(*id) { + unbind_riders_of(server, &child, attach_reason::SLAVE_BINDING); world.delete(WorldObject::from(&child)); } } @@ -1139,12 +1140,118 @@ pub fn bind_slave( super::ship_physics::set_driver(server, &slave, true); } world.attach_child(&WorldObject::from(&slave), &me); - // TODO (C#): move to attach point's position + // TODO (C#): move to attach point's position (done for ship cannons only: their gunner + // stands behind the barrel; every other seat keeps the C# origin placement). + let (sx, sy, sz) = if is_manned_cannon(server, &slave) { + gunner_seat_offset(server, &slave, point) + } else { + (0.0, 0.0, 0.0) + }; character .data() .unit .transform - .set_position(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); + .set_position(sx, sy, sz, 0.0, 0.0, 0.0); +} + +/// Gunner seat of a cannon in the cannon's local frame when its model has no seat helper. Cannon +/// model 117 (every 1.2 cannon slave) is absent from `slave_attach_points*.json`, which only +/// covers ship / vehicle models, and no cannon-shaped model there declares a driver helper, so +/// the gunner stands 0.8 m behind the barrel pivot at its base height. +pub const GUNNER_SEAT_OFFSET: (f32, f32, f32) = (0.0, -0.8, 0.0); + +/// The gunner's seat position on a cannon: the model's own `point` helper when the attach point +/// data has one, else [`GUNNER_SEAT_OFFSET`]. +fn gunner_seat_offset(server: &GameServer, cannon: &SlaveRef, point: u8) -> (f32, f32, f32) { + let model_id = cannon.data().unit.model_id; + server + .systems + .vehicles + .attach_points_for_slave(server, model_id) + .and_then(|points| points.into_iter().find(|(p, _)| *p == point)) + .map_or(GUNNER_SEAT_OFFSET, |(_, v)| (v.x, v.y, v.z)) +} + +/// A cannon (slave kind 8) mounted on another slave: one gunner at the driver seat, the +/// `mount_attached_skills` seat of its fire skill. A cannon without a bearer keeps the plain +/// C# bind rules. +pub fn is_manned_cannon(server: &GameServer, slave: &SlaveRef) -> bool { + let (template_id, bearer) = { + let d = slave.data(); + (d.unit.template_id, d.owner_obj_id) + }; + bearer != 0 + && server + .game_data + .systems + .vehicles + .slave_template(template_id) + .is_some_and(|t| t.slave_kind == super::data::slave_kind::SLAVE_EQUIPMENT) +} + +/// Who may man a ship cannon: the cannon's summoner, the owner of the ship it is mounted on, or +/// anybody aboard that ship (standing on it or seated on any of its attach points). The C# +/// `BindSlave` has no such rule and the 1.2 data carries no seat permissions; this keeps the +/// guns to the crew. +pub fn may_man_cannon(character: &PlayerRef, cannon: &SlaveRef, world: &WorldInstance) -> bool { + let (bearer_id, summoner, summoner_id) = { + let d = cannon.data(); + (d.owner_obj_id, d.summoner_obj_id, d.summoner_id) + }; + let is_me = |obj: u32, id: u32| { + obj == character.obj_id || (character.character_id != 0 && id == character.character_id) + }; + if is_me(summoner, summoner_id) { + return true; + } + let Some(bearer) = world.slave(bearer_id) else { + return true; // Orphaned: nobody to ask. + }; + let d = bearer.data(); + is_me(d.summoner_obj_id, d.summoner_id) + || character.data().unit.transform.parent_obj_id == bearer_id + || d.attached_characters + .iter() + .any(|(_, c)| *c == character.obj_id) +} + +/// A gunner who dies leaves the cannon (a driver or passenger of a ship keeps the C# behaviour). +pub fn on_gunner_death(server: &GameServer, player: &PlayerRef) { + let Some(world) = player_world(server, player) else { + return; + }; + if let Some((cannon, _)) = get_is_mounted(&world, player.obj_id) { + if is_manned_cannon(server, &cannon) { + let tl = u32::from(cannon.data().unit.tl_id); + unbind_slave(server, player, tl, attach_reason::NONE); + } + } +} + +/// Unbinds everybody riding the cannons / harpoons mounted on `slave` (their carrier goes away). +fn unbind_child_riders(server: &GameServer, slave: &SlaveRef, reason: u8) { + let Some(world) = world_of(server, &WorldObject::from(slave)) else { + return; + }; + let children = slave.data().attached_slaves.clone(); + for id in children { + let Some(child) = world.slave(id) else { + continue; + }; + unbind_riders_of(server, &child, reason); + } +} + +fn unbind_riders_of(server: &GameServer, slave: &SlaveRef, reason: u8) { + let (tl, riders) = { + let d = slave.data(); + (u32::from(d.unit.tl_id), d.attached_characters.clone()) + }; + for (_, c) in riders { + if let Some(p) = server.world.character_by_obj_id(c) { + unbind_slave(server, &p, tl, reason); + } + } } /// `BindSlave(connection, tlId)` (`CSBindSlavePacket`). @@ -1158,6 +1265,20 @@ pub fn bind_slave_by_tl(server: &GameServer, character: &PlayerRef, tl_id: u32) if slave.data().unit.is_dead() { return; } + if is_manned_cannon(server, &slave) { + if !may_man_cannon(character, &slave, &world) { + error(character, error::SLAVE_CANNOT_BIND); + return; + } + if slave.data().has_attached_at(attach_point::DRIVER) { + error(character, error::SLAVE_ALREADY_HAS_MASTER); + return; + } + if get_is_mounted(&world, character.obj_id).is_some() { + error(character, error::SLAVE_UNBIND_FIRST); + return; + } + } bind_slave( server, character, @@ -1205,6 +1326,7 @@ pub fn delete( unbind_slave(server, &p, tl, attach_reason::SLAVE_BINDING); } } + unbind_child_riders(server, &slave, attach_reason::SLAVE_BINDING); let (doodad_ids, slave_ids, portal_time, template_id) = { let d = slave.data(); let portal = server @@ -2838,6 +2960,7 @@ pub fn do_die( unbind_slave(server, &p, u32::from(tl), attach_reason::NONE); } } + unbind_child_riders(server, slave, attach_reason::NONE); if server .game_data .systems From 201975b918c2f2d6fcdeaf4467b2793805135b54 Mon Sep 17 00:00:00 2001 From: stsiakal Date: Thu, 22 Oct 2026 07:10:19 +0300 Subject: [PATCH 04/13] fix(vehicles): use upstream collision masks for the summon placement check Co-Authored-By: Claude Opus 5.5 --- rust/crates/aaemu-game/src/systems/vehicles/slaves.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs index 3aa9c735b7..3210ef123f 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs @@ -1697,7 +1697,8 @@ fn validated_summon_placement( world.id, [transform.x, transform.y, transform.z + 0.8], 0.5, - crate::systems::ai::collision::query::mask::SOLID, + crate::systems::ai::collision::query::mask::SOLID_TERRAIN + & !crate::systems::ai::collision::query::mask::TERRAIN, ) .unwrap_or(false); if inside { From 868d4cdf2e1b7d5e362c58e99f58798f9ee533a7 Mon Sep 17 00:00:00 2001 From: stsiakal Date: Thu, 22 Oct 2026 10:14:14 +0300 Subject: [PATCH 05/13] fix(characters): save the starting items with the new character row Character creation wrote only the characters row; containers and items waited for the next world or departure save, so a stop in between kept the character without its starter gear. Co-Authored-By: Claude Opus 5.5 --- rust/crates/aaemu-game/PORTING.md | 2 + rust/crates/aaemu-game/src/db_character.rs | 130 +++++++++++++++++- .../aaemu-game/src/managers/character.rs | 4 +- rust/crates/aaemu-game/src/managers/item.rs | 40 +++++- .../aaemu-game/src/managers/item_tests.rs | 30 ++++ rust/verify/newchar-items.vtest | 11 ++ 6 files changed, 207 insertions(+), 10 deletions(-) create mode 100644 rust/verify/newchar-items.vtest diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 1ca30539d6..897e423724 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -1732,6 +1732,8 @@ servers (see `rust/LIVE-TESTING.md`). Fixed porting bugs are in the git history item task packets queued earlier (the C# sends those inline first too). `quests::events::with_quests` logs an error and returns `None` when the thread already holds the ops lock instead of hanging. +* `CharacterManager.Create` saved only the `characters` row (`SaveDirectlyToDatabase`); the starting supplies (`item_containers` / `items`) waited for the next `SaveManager` run or the departure save. A server stop or crash in that window kept the character but lost its items, and the next select built empty containers. `db_character::save_new_character` now writes the new character's dirty containers and items in the same transaction (`ItemManager::prepare_save_for_owner`); suite `rust/verify/newchar-items.vtest`. + Parity status of the scripted scenarios: `login`, `lobby` and `full` (fresh character) produce the same S->C traffic as the C# servers after id / time normalisation (0 findings); a second `full` round with the existing character only differs in the saved position precision above diff --git a/rust/crates/aaemu-game/src/db_character.rs b/rust/crates/aaemu-game/src/db_character.rs index 41e35d53ad..1aaedb26cc 100644 --- a/rust/crates/aaemu-game/src/db_character.rs +++ b/rust/crates/aaemu-game/src/db_character.rs @@ -1179,13 +1179,48 @@ async fn save_active_buffs(tx: &mut Transaction<'_, MySql>, c: &Character) { /// the state it had before the call (`save_character` advances `updated` and clears the removed /// lists while it works, so it runs on a clone that is applied only after the commit). pub async fn save_directly_to_database(pool: &MySqlPool, c: &mut Character) -> bool { + save_directly(pool, c, None).await +} + +/// Character creation: [`save_directly_to_database`] plus the new character's containers and +/// items in the same transaction (the C# left them to the next world save, so a stop or crash +/// before it kept the `characters` row but lost the starting supplies; the next select then +/// built empty containers). +pub async fn save_new_character(server: &GameServer, c: &mut Character) -> bool { + // The item write and `commit_save` share the manager's pending-batch slot with the world + // save, so they run under the same transaction lock. + let _transaction = server.save.transaction_lock().await; + let batch = server.items.prepare_save_for_owner(c.id); + save_directly(&server.db, c, Some((&server.items, batch))).await +} + +async fn save_directly( + pool: &MySqlPool, + c: &mut Character, + items: Option<( + &crate::managers::item::ItemManager, + crate::managers::item::ItemSaveBatch, + )>, +) -> bool { let mut saved = c.clone(); + let manager = items.as_ref().map(|(manager, _)| *manager); let res: Result<()> = async { let mut tx = pool.begin().await?; let now = Utc::now().timestamp(); - match save_character(&mut tx, &mut saved, now).await { + let written = async { + save_character(&mut tx, &mut saved, now).await?; + if let Some((manager, batch)) = items { + manager.write_prepared(&mut tx, batch).await?; + } + Ok::<(), GameError>(()) + } + .await; + match written { Ok(()) => { tx.commit().await?; + if let Some(manager) = manager { + manager.commit_save(); + } Ok(()) } Err(e) => { @@ -1802,6 +1837,99 @@ mod tests { pool.close().await; } + /// Character creation writes the starting supplies together with the `characters` row: a + /// stop before the next world save must not keep the character but lose its items. + #[tokio::test] + #[ignore = "requires private MySQL3317 via AAEMU_TEST_MYSQL; uses only temporary tables"] + async fn private_mysql_new_character_items_are_saved_with_the_character() { + use crate::systems::social::achievement_persistence::temporary_shadow_definition; + use crate::test_support::test_character; + + let Ok(url) = std::env::var("AAEMU_TEST_MYSQL") else { + return; + }; + let options = MySqlConnectOptions::from_str(&url).expect("valid private MySQL URL"); + assert_eq!( + options.get_port(), + 3317, + "only private MySQL3317 is allowed" + ); + assert!(matches!(options.get_host(), "127.0.0.1" | "localhost")); + let pool = MySqlPoolOptions::new() + .max_connections(1) + .connect_with(options) + .await + .expect("private MySQL"); + for table in [ + "items", + "item_containers", + "characters", + "options", + "abilities", + "actabilities", + "appellations", + "character_active_buffs", + "portal_book_coords", + "portal_visited_district", + "friends", + "blocked", + "skills", + "quests", + "completed_quests", + "accounts", + "character_records", + "character_achievements", + ] { + let (_, definition): (String, String) = + sqlx::query_as(&format!("SHOW CREATE TABLE `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + sqlx::query(&temporary_shadow_definition(&definition)) + .execute(&pool) + .await + .unwrap(); + } + sqlx::query("INSERT INTO `accounts` (`account_id`, `labor`) VALUES (1007, 1000)") + .execute(&pool) + .await + .unwrap(); + + let mut data = crate::data::GameData::empty(); + let mut template = crate::data::items::ItemTemplate::plain(1000, 20); + template.name = "Starter".into(); + data.items.templates.insert(1000, template); + let mut server = crate::test_support::test_server_with(data); + server.db = pool.clone(); + let mut c = test_character(7, "Newbie", 500.0, 500.0); + c.inventory = Inventory::new(7, 50, 50, &server.items, &server.ids.container); + let item = server + .items + .create(1000, 1, 0, 1, &server.game_data.items, &server.ids.item, 0) + .expect("item"); + let item_id = item.id; + c.inventory + .bag() + .lock() + .unwrap() + .add_new_item(item, 0, &server.game_data.items) + .expect("fits"); + + assert!(save_new_character(&server, &mut c).await); + + let rows: i64 = sqlx::query_scalar( + "SELECT COUNT(*) FROM items i JOIN item_containers ic ON ic.container_id = i.container_id WHERE ic.owner_id = 7 AND i.id = ?", + ) + .bind(item_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(rows, 1); + // The rows are marked clean, so the next world save does not rewrite them. + assert!(server.items.prepare_save_for_owner(7).item_ids().is_empty()); + pool.close().await; + } + #[tokio::test] async fn learn_skill_load_refuses_a_skill_above_the_ability_level() { // A stored attribute-less ability_level 99 row (as a pre-fix server could write) is not diff --git a/rust/crates/aaemu-game/src/managers/character.rs b/rust/crates/aaemu-game/src/managers/character.rs index fa6cb2ad44..d612c2e307 100644 --- a/rust/crates/aaemu-game/src/managers/character.rs +++ b/rust/crates/aaemu-game/src/managers/character.rs @@ -12,7 +12,7 @@ use crate::data::character_templates::EquipItemsTemplate; use crate::data::items::{bind_type, ItemTemplate}; use crate::db::get_account_details; use crate::db_character::{ - check_for_deleted_characters, is_character_pending_deletion, save_directly_to_database, + check_for_deleted_characters, is_character_pending_deletion, save_new_character, set_delete_times, }; use crate::error::{GameError, Result}; @@ -412,7 +412,7 @@ pub async fn create( c.unit.mp = c.unit.max_mp; c.restore_saved_hp_mp(); - if save_directly_to_database(&server.db, &mut c).await { + if save_new_character(server, &mut c).await { let resp = create_character_response(&c); conn.characters.push(c); conn.send(&resp); diff --git a/rust/crates/aaemu-game/src/managers/item.rs b/rust/crates/aaemu-game/src/managers/item.rs index bbab965e95..e0aae87bb4 100644 --- a/rust/crates/aaemu-game/src/managers/item.rs +++ b/rust/crates/aaemu-game/src/managers/item.rs @@ -50,6 +50,16 @@ impl ItemSaveBatch { pub(crate) fn item_ids(&self) -> Vec { self.items.iter().map(|(_, _, item)| item.id).collect() } + + /// The queued item deletions of this snapshot (test assertion helper). + pub(crate) fn removed_ids(&self) -> Vec { + self.removed.clone() + } + + /// The number of container rows of this snapshot (test assertion helper). + pub(crate) fn container_count(&self) -> usize { + self.containers.len() + } } #[derive(Debug, PartialEq, Eq)] @@ -520,12 +530,26 @@ impl ItemManager { /// Capture before database awaits, while the caller serializes economy operations. pub(crate) fn prepare_save(&self) -> ItemSaveBatch { - let mut batch = ItemSaveBatch { - removed: lock(&self.removed).clone(), - ..Default::default() - }; + let mut batch = self.prepare_save_filtered(None); + batch.removed = lock(&self.removed).clone(); + batch + } + + /// The dirty containers and items of one character only, no queued deletions: character + /// creation writes the starting supplies together with the `characters` row, so a server + /// stop before the next world save cannot lose them. The caller holds the save transaction + /// lock (the write and [`Self::commit_save`] share the single pending-batch slot). + pub(crate) fn prepare_save_for_owner(&self, owner_id: u32) -> ItemSaveBatch { + self.prepare_save_filtered(Some(owner_id)) + } + + fn prepare_save_filtered(&self, owner: Option) -> ItemSaveBatch { + let mut batch = ItemSaveBatch::default(); for container in self.all_containers() { let snapshot = container.lock().expect("container poisoned").clone(); + if owner.is_some_and(|o| snapshot.owner_id != o) { + continue; + } if snapshot.slot_type != slot_type::NONE && snapshot.container_id > 0 && snapshot.dirty { batch @@ -540,9 +564,11 @@ impl ItemManager { } } } - for item in lock(&self.loose).iter() { - if item.slot_type != slot_type::NONE && item.dirty { - batch.items.push((None, 0, item.clone())); + if owner.is_none() { + for item in lock(&self.loose).iter() { + if item.slot_type != slot_type::NONE && item.dirty { + batch.items.push((None, 0, item.clone())); + } } } batch diff --git a/rust/crates/aaemu-game/src/managers/item_tests.rs b/rust/crates/aaemu-game/src/managers/item_tests.rs index 32a2113f14..303d5933c8 100644 --- a/rust/crates/aaemu-game/src/managers/item_tests.rs +++ b/rust/crates/aaemu-game/src/managers/item_tests.rs @@ -757,3 +757,33 @@ async fn private_mysql_load_user_items_deletes_a_merged_stack_row() { .unwrap(); assert_eq!(persisted, 8); } + +// ---- Character creation save (owner-scoped batch) ---- + +/// The creation save writes only the new character's dirty containers and items, never another +/// character's pending rows or the queued deletions (those stay with the world save). +#[test] +fn prepare_save_for_owner_selects_only_that_characters_rows() { + let manager = create_item_manager(); + let container_ids = IdManager::new(crate::managers::id::CONTAINER_ID); + let data = data_with_templates(vec![ItemTemplate::plain(1000, 20)]); + for (owner, id) in [(7u32, 0x0100_0001u64), (8, 0x0100_0002)] { + let bag = manager.container_for_character(owner, slot_type::INVENTORY, 0, &container_ids); + let mut item = create_test_item(id, 1000, 1); + item.dirty = true; + bag.lock() + .unwrap() + .add_new_item(item, 0, &data) + .expect("fits"); + } + manager.mark_for_db_deletion(0x0100_0099); + + let batch = manager.prepare_save_for_owner(7); + assert_eq!(batch.item_ids(), vec![0x0100_0001]); + assert!(batch.removed_ids().is_empty()); + assert_eq!(batch.container_count(), 1); + + let all = manager.prepare_save(); + assert_eq!(all.item_ids().len(), 2); + assert_eq!(all.removed_ids(), vec![0x0100_0099]); +} diff --git a/rust/verify/newchar-items.vtest b/rust/verify/newchar-items.vtest new file mode 100644 index 0000000000..4333c5ee0d --- /dev/null +++ b/rust/verify/newchar-items.vtest @@ -0,0 +1,11 @@ +# Character creation persists the starting supplies together with the character row: right after +# create + spawn (no world save or departure save has run yet) the bag and equipment rows are +# already in MySQL, so a server stop before the first save cannot lose them. +suite newchar-items +bot nci + +[nci] +bag +expectdb "SELECT COUNT(*)>=4 FROM items i JOIN item_containers ic ON ic.container_id=i.container_id JOIN characters c ON c.id=ic.owner_id WHERE c.name='${nci}' AND ic.slot_type=2" 1 +expectdb "SELECT COUNT(*)>=1 FROM items i JOIN item_containers ic ON ic.container_id=i.container_id JOIN characters c ON c.id=ic.owner_id WHERE c.name='${nci}' AND ic.slot_type=1" 1 +pump 1 From 7d7d8bf30b23cc4ebb1eecf405a861cab112c7db Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Fri, 23 Oct 2026 09:52:25 -0400 Subject: [PATCH 06/13] fix(commons): guard packet reads and cover protocol boundaries --- rust/crates/aaemu-commons/src/net.rs | 105 +++++++ .../crates/aaemu-commons/src/packet_stream.rs | 270 +++++++++++++++++- 2 files changed, 374 insertions(+), 1 deletion(-) diff --git a/rust/crates/aaemu-commons/src/net.rs b/rust/crates/aaemu-commons/src/net.rs index 935610bd5d..a6dd4b78fd 100644 --- a/rust/crates/aaemu-commons/src/net.rs +++ b/rust/crates/aaemu-commons/src/net.rs @@ -93,4 +93,109 @@ mod tests { assert_eq!(c.decode(&mut buf).unwrap(), Some(vec![9])); assert_eq!(c.decode(&mut buf).unwrap(), None); } + + #[test] + fn frame_lengths_have_exact_wire_bytes() { + for (len, header) in [(0, [0, 0]), (258, [2, 1]), (65_535, [0xff, 0xff])] { + let payload: Vec = (0..len).map(|i| (i % 251) as u8).collect(); + let mut c = FrameCodec; + let mut buf = BytesMut::new(); + c.encode(&payload, &mut buf).unwrap(); + assert_eq!(&buf[..2], &header); + assert_eq!(&buf[2..], payload); + assert_eq!(c.decode(&mut buf).unwrap(), Some(payload)); + assert!(buf.is_empty()); + assert_eq!(c.decode(&mut buf).unwrap(), None); + } + } + + #[test] + fn decodes_at_every_fragmentation_point() { + let payload: Vec = (0..258).map(|i| (i % 251) as u8).collect(); + let mut wire = vec![2, 1]; + wire.extend_from_slice(&payload); + for split in 0..=wire.len() { + let mut c = FrameCodec; + let mut buf = BytesMut::from(&wire[..split]); + if split < wire.len() { + for _ in 0..2 { + assert_eq!(c.decode(&mut buf).unwrap(), None, "split {split}"); + assert_eq!(&buf[..], &wire[..split], "split {split}"); + } + } + buf.extend_from_slice(&wire[split..]); + assert_eq!(c.decode(&mut buf).unwrap(), Some(payload.clone())); + assert!(buf.is_empty()); + assert_eq!(c.decode(&mut buf).unwrap(), None); + } + } + + #[test] + fn coalesced_frames_preserve_incomplete_trailing_frame() { + let cases: &[(&[u8], &[u8], &[u8])] = &[ + (&[3], &[0, 9, 8, 7], &[9, 8, 7]), + (&[3, 0, 9], &[8, 7], &[9, 8, 7]), + ]; + for &(trailing, rest, payload) in cases { + let mut c = FrameCodec; + let mut buf = BytesMut::from(&[0, 0, 2, 0, 0x10, 0x20][..]); + buf.extend_from_slice(trailing); + assert_eq!(c.decode(&mut buf).unwrap(), Some(vec![])); + assert_eq!(c.decode(&mut buf).unwrap(), Some(vec![0x10, 0x20])); + assert_eq!(c.decode(&mut buf).unwrap(), None); + assert_eq!(&buf[..], trailing); + buf.extend_from_slice(rest); + assert_eq!(c.decode(&mut buf).unwrap(), Some(payload.to_vec())); + assert!(buf.is_empty()); + } + } + + #[test] + fn decode_eof_rejects_every_truncated_frame() { + let wire = [3, 0, 1, 2, 3]; + for end in 1..wire.len() { + let mut c = FrameCodec; + let mut buf = BytesMut::from(&wire[..end]); + let err = c.decode_eof(&mut buf).unwrap_err(); + assert_eq!(err.kind(), std::io::ErrorKind::Other); + assert_eq!(&buf[..], &wire[..end]); + } + } + + #[test] + fn decode_eof_drains_complete_frames_before_truncated_tail() { + let mut c = FrameCodec; + let mut buf = BytesMut::from(&[0, 0, 1, 0, 9, 2][..]); + assert_eq!(c.decode_eof(&mut buf).unwrap(), Some(vec![])); + assert_eq!(c.decode_eof(&mut buf).unwrap(), Some(vec![9])); + assert!(c.decode_eof(&mut buf).is_err()); + assert_eq!(&buf[..], &[2]); + } + + #[test] + fn decode_eof_accepts_complete_frame_and_empty_buffer() { + let mut c = FrameCodec; + let mut buf = BytesMut::new(); + assert_eq!(c.decode_eof(&mut buf).unwrap(), None); + buf.extend_from_slice(&[1, 0, 9]); + assert_eq!(c.decode_eof(&mut buf).unwrap(), Some(vec![9])); + assert!(buf.is_empty()); + assert_eq!(c.decode_eof(&mut buf).unwrap(), None); + } + + #[test] + fn oversized_encode_preserves_destination() { + let mut c = FrameCodec; + let mut buf = BytesMut::from(&[1, 0, 9][..]); + let before = buf.clone(); + let payload = vec![0; usize::from(u16::MAX) + 1]; + let err = c.encode(&payload, &mut buf).unwrap_err(); + assert_eq!(err.kind(), std::io::ErrorKind::InvalidInput); + assert_eq!(buf, before); + c.encode([8], &mut buf).unwrap(); + assert_eq!(&buf[..], &[1, 0, 9, 1, 0, 8]); + assert_eq!(c.decode(&mut buf).unwrap(), Some(vec![9])); + assert_eq!(c.decode(&mut buf).unwrap(), Some(vec![8])); + assert!(buf.is_empty()); + } } diff --git a/rust/crates/aaemu-commons/src/packet_stream.rs b/rust/crates/aaemu-commons/src/packet_stream.rs index 114bbbdead..0f548bbfdf 100644 --- a/rust/crates/aaemu-commons/src/packet_stream.rs +++ b/rust/crates/aaemu-commons/src/packet_stream.rs @@ -112,7 +112,7 @@ impl PacketStream { // ---- reads ------------------------------------------------------------------------------- fn take(&mut self, n: usize) -> Result<&[u8]> { - if self.pos + n > self.buf.len() { + if n > self.remaining() { return Err(MarshalError::EndOfStream { pos: self.pos, wanted: n, @@ -456,6 +456,8 @@ impl From> for PacketStream { mod tests { use super::*; + type Reader = fn(&mut PacketStream) -> Result<()>; + #[test] fn primitives_roundtrip() { let mut s = PacketStream::new(); @@ -477,6 +479,272 @@ mod tests { assert!(matches!(s.read_u8(), Err(MarshalError::EndOfStream { .. }))); } + #[test] + fn oversized_byte_read_preserves_cursor() { + let mut s = PacketStream::from_bytes([0x11, 0x22, 0x33]); + assert_eq!(s.read_u8().unwrap(), 0x11); + assert_eq!( + s.read_bytes(usize::MAX), + Err(MarshalError::EndOfStream { + pos: 1, + wanted: usize::MAX, + len: 3, + }) + ); + assert_eq!(s.pos(), 1); + assert_eq!(s.unread(), &[0x22, 0x33]); + assert_eq!(s.read_u16().unwrap(), 0x3322); + } + + #[test] + fn oversized_fixed_string_read_preserves_cursor() { + let mut s = PacketStream::from_bytes(b"abc".as_slice()); + assert_eq!(s.read_u8().unwrap(), b'a'); + assert_eq!( + s.read_string_fixed(usize::MAX), + Err(MarshalError::EndOfStream { + pos: 1, + wanted: usize::MAX, + len: 3, + }) + ); + assert_eq!(s.pos(), 1); + assert_eq!(s.unread(), b"bc"); + assert_eq!(s.read_string_fixed(2).unwrap(), "bc"); + } + + #[test] + fn truncated_fixed_width_reads_preserve_cursor_and_can_retry() { + let readers: &[(usize, Reader)] = &[ + (1, |s| s.read_bool().map(|_| ())), + (1, |s| s.read_u8().map(|_| ())), + (1, |s| s.read_i8().map(|_| ())), + (2, |s| s.read_i16().map(|_| ())), + (2, |s| s.read_u16().map(|_| ())), + (3, |s| s.read_bc().map(|_| ())), + (3, |s| s.read_string_fixed(3).map(|_| ())), + (4, |s| s.read_i32().map(|_| ())), + (4, |s| s.read_u32().map(|_| ())), + (4, |s| s.read_f32().map(|_| ())), + (8, |s| s.read_i64().map(|_| ())), + (8, |s| s.read_u64().map(|_| ())), + (8, |s| s.read_f64().map(|_| ())), + (9, |s| s.read_position().map(|_| ())), + ]; + for &(width, read) in readers { + for available in 0..width { + let mut s = PacketStream::from_bytes(vec![0; 1 + available]); + s.read_u8().unwrap(); + assert_eq!( + read(&mut s), + Err(MarshalError::EndOfStream { + pos: 1, + wanted: width, + len: 1 + available, + }) + ); + assert_eq!(s.pos(), 1); + assert_eq!(s.unread(), vec![0; available]); + s.write_raw(&vec![0; width - available]); + read(&mut s).unwrap(); + assert_eq!(s.pos(), 1 + width); + assert_eq!(s.remaining(), 0); + } + } + } + + #[test] + fn cursor_clamping_rollback_and_empty_reads() { + let mut s = PacketStream::from_bytes([0x11, 0x22]); + s.set_pos(usize::MAX); + assert_eq!(s.pos(), 2); + assert_eq!(s.remaining(), 0); + assert!(s.read_bytes(0).unwrap().is_empty()); + assert_eq!(s.read_string_fixed(0).unwrap(), ""); + assert!(matches!(s.read_u8(), Err(MarshalError::EndOfStream { .. }))); + assert_eq!(s.pos(), 2); + s.rollback_by(1); + assert_eq!(s.read_u8().unwrap(), 0x22); + s.rollback_by(usize::MAX); + assert_eq!(s.pos(), 0); + assert_eq!(s.read_u8().unwrap(), 0x11); + s.rollback(); + assert_eq!(s.read_u16().unwrap(), 0x2211); + s.clear(); + assert!(s.is_empty()); + assert_eq!(s.pos(), 0); + assert!(s.unread().is_empty()); + s.write_u8(0x33); + assert_eq!(s.read_u8().unwrap(), 0x33); + } + + #[test] + fn truncated_length_prefixed_reads_consume_only_complete_fields() { + let readers: [Reader; 3] = [ + |s| s.read_bytes_sized().map(|_| ()), + |s| s.read_string().map(|_| ()), + |s| s.read_packet_stream().map(|_| ()), + ]; + let wire = [3, 0, b'a', b'b', b'c']; + for read in readers { + for end in 0..wire.len() { + let mut s = PacketStream::from_bytes(&wire[..end]); + let (pos, wanted) = if end < 2 { (0, 2) } else { (2, 3) }; + assert_eq!( + read(&mut s), + Err(MarshalError::EndOfStream { + pos, + wanted, + len: end, + }) + ); + assert_eq!(s.pos(), pos); + assert_eq!(s.unread(), &wire[pos..end]); + s.write_raw(&wire[end..]); + s.rollback(); + read(&mut s).unwrap(); + assert_eq!(s.pos(), wire.len()); + } + } + } + + #[test] + fn nonpositive_i16_lengths_leave_following_bytes_unread() { + // Preserve the signed length/C# behavior, including the high-bit boundary. + for prefix in [[0, 0], [0, 0x80], [0xff, 0xff]] { + let wire = [prefix[0], prefix[1], 0x42]; + let mut s = PacketStream::from_bytes(wire); + assert!(s.read_bytes_sized().unwrap().is_empty()); + assert_eq!(s.pos(), 2); + assert_eq!(s.read_u8().unwrap(), 0x42); + + let mut s = PacketStream::from_bytes(wire); + assert_eq!(s.read_string().unwrap(), ""); + assert_eq!(s.pos(), 2); + assert_eq!(s.read_u8().unwrap(), 0x42); + + let mut s = PacketStream::from_bytes(wire); + let nested = s.read_packet_stream().unwrap(); + assert!(nested.is_empty()); + assert_eq!(nested.pos(), 0); + assert_eq!(s.pos(), 2); + assert_eq!(s.read_u8().unwrap(), 0x42); + } + } + + #[test] + fn maximum_positive_i16_length_reads_entire_payload() { + let payload = vec![0x42; i16::MAX as usize]; + let mut s = PacketStream::new(); + s.write_bytes_sized(&payload).write_u8(0x99); + assert_eq!(&s.as_bytes()[..2], &[0xff, 0x7f]); + assert_eq!(s.read_bytes_sized().unwrap(), payload); + assert_eq!(s.read_u8().unwrap(), 0x99); + } + + #[test] + fn strings_replace_invalid_utf8_and_trim_only_edge_nuls() { + let body = [0, b'a', 0xff, 0, b'b', 0]; + let mut s = PacketStream::new(); + s.write_bytes_sized(&body).write_u8(0x42); + assert_eq!(s.read_string().unwrap(), "a\u{fffd}\0b"); + assert_eq!(s.read_u8().unwrap(), 0x42); + + let mut s = PacketStream::from_bytes(body); + assert_eq!(s.read_string_fixed(body.len()).unwrap(), "a\u{fffd}\0b"); + assert_eq!(s.remaining(), 0); + } + + #[test] + fn pisc_width_boundaries_have_exact_wire_bytes() { + let cases: &[(i64, &[u8])] = &[ + (0, &[0, 0]), + (0xff, &[0, 0xff]), + (0x100, &[1, 0, 1]), + (0xffff, &[1, 0xff, 0xff]), + (0x1_0000, &[2, 0, 0, 1]), + (0xff_ffff, &[2, 0xff, 0xff, 0xff]), + (0x100_0000, &[3, 0, 0, 0, 1]), + (0xffff_ffff, &[3, 0xff, 0xff, 0xff, 0xff]), + ]; + for &(value, wire) in cases { + let mut s = PacketStream::new(); + s.write_pisc(&[value]); + assert_eq!(s.as_bytes(), wire, "value {value:#x}"); + let mut s = PacketStream::from_bytes(wire); + assert_eq!(s.read_pisc_w(1).unwrap(), [value]); + assert_eq!(s.remaining(), 0); + } + } + + #[test] + fn pisc_groups_have_exact_headers_and_partial_final_group() { + let values = [ + 0xff, + 0x100, + 0x1_0000, + 0x100_0000, + 0xffff, + 0xff_ffff, + 0xffff_ffff, + ]; + let wire = [ + 0xe4, 0xff, 0, 1, 0, 0, 1, 0, 0, 0, 1, // u8, u16, bc, u32 + 0x39, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // u16, bc, u32 + ]; + let mut s = PacketStream::new(); + s.write_pisc_w(&values); + assert_eq!(s.as_bytes(), wire); + let mut s = PacketStream::from_bytes(wire); + assert_eq!(s.read_pisc_w(values.len()).unwrap(), values); + assert_eq!(s.remaining(), 0); + } + + #[test] + fn truncated_pisc_groups_stop_before_incomplete_value() { + let wire = [ + 0xe4, 0xff, 0, 1, 0, 0, 1, 0, 0, 0, 1, // u8, u16, bc, u32 + 0x39, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // u16, bc, u32 + ]; + // Header/value offsets and widths, including the second group's header. + for (pos, wanted) in [ + (0, 1), + (1, 1), + (2, 2), + (4, 3), + (7, 4), + (11, 1), + (12, 2), + (14, 3), + (17, 4), + ] { + for end in pos..pos + wanted { + let mut s = PacketStream::from_bytes(&wire[..end]); + assert_eq!( + s.read_pisc_w(7), + Err(MarshalError::EndOfStream { + pos, + wanted, + len: end + }) + ); + assert_eq!(s.pos(), pos); + assert_eq!(s.unread(), &wire[pos..end]); + assert_eq!(s.read_bytes(end - pos).unwrap(), wire[pos..end]); + } + } + } + + #[test] + fn empty_pisc_groups_do_not_consume_or_write_bytes() { + let mut s = PacketStream::from_bytes([0x42]); + s.write_pisc_w(&[]); + assert_eq!(s.as_bytes(), &[0x42]); + assert!(s.read_pisc_w(0).unwrap().is_empty()); + assert_eq!(s.pos(), 0); + assert_eq!(s.read_u8().unwrap(), 0x42); + } + #[test] fn pisc_roundtrip() { let vals = [5, 300, 70_000, 20_000_000, 1]; From 4796cad65657b5706ea65478c64982397e192ac2 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Fri, 23 Oct 2026 09:57:29 -0400 Subject: [PATCH 07/13] fix(xtask): run ratchet unit tests in local CI --- rust/crates/xtask/src/main.rs | 228 +++++++++++++++++++++++++++++++--- 1 file changed, 212 insertions(+), 16 deletions(-) diff --git a/rust/crates/xtask/src/main.rs b/rust/crates/xtask/src/main.rs index adbd9c184e..5d05c1904e 100644 --- a/rust/crates/xtask/src/main.rs +++ b/rust/crates/xtask/src/main.rs @@ -9,13 +9,13 @@ //! once the login server accepts game-server registrations, all wired through environment //! variables. //! * `ci` — the checks CI runs: `cargo fmt --check`, `cargo clippy -D warnings`, `cargo test`, and -//! the S->C packet coverage ratchet (`tools/opcode_coverage/sc_usage.py --check`, needs python). +//! the S->C packet coverage ratchet and its tests (`tools/opcode_coverage/`, needs python). use std::collections::HashMap; use std::io::{BufRead, BufReader}; use std::net::{SocketAddr, TcpStream}; use std::path::{Path, PathBuf}; -use std::process::{Child, Command, Stdio}; +use std::process::{Child, Command, ExitStatus, Stdio}; use std::time::{Duration, Instant}; use anyhow::{bail, Context, Result}; @@ -36,7 +36,7 @@ Commands: --no-db do not start MySQL; use --db-host/--db-port or Config.Local.json --db-host MySQL host passed to the servers (default: 127.0.0.1) --db-port MySQL port (default: DB_PORT from .env, else 3306) - ci cargo fmt --check, clippy -D warnings, test, S->C coverage ratchet (the CI checks) + ci cargo fmt --check, clippy -D warnings, test, S->C coverage ratchet + tests (the CI checks) "; /// The login server's internal (game-server registration) port in the shipped `Config.json`. @@ -526,16 +526,40 @@ fn ci() -> Result<()> { /// The S->C packet coverage ratchet (`rust/tools/opcode_coverage/sc_usage.py --check`): the lists /// of opcodes without a Rust type and of packets never sent may only shrink. Needs only python and -/// the checked-in sources. A missing python interpreter is an error (the check must not pass -/// silently); set `XTASK_SKIP_RATCHET=1` to skip it explicitly with a warning (refused when `CI` -/// is set). +/// the checked-in sources. Runs `test_sc_usage` with the same interpreter after the ratchet passes. +/// A missing python interpreter is an error; set `XTASK_SKIP_RATCHET=1` to skip both explicitly +/// with a warning (refused when `CI` is set). fn sc_ratchet() -> Result<()> { - let script = workspace_dir().join("tools/opcode_coverage/sc_usage.py"); + sc_ratchet_with( + std::env::var_os("XTASK_SKIP_RATCHET").is_some_and(|v| v == "1"), + std::env::var_os("CI").is_some(), + Command::status, + ) +} + +fn sc_ratchet_with( + skip_requested: bool, + in_ci: bool, + mut execute: impl FnMut(&mut Command) -> std::io::Result, +) -> Result<()> { + let dir = workspace_dir().join("tools/opcode_coverage"); + let script = dir.join("sc_usage.py"); for python in ["python3", "python"] { let mut cmd = Command::new(python); - cmd.arg(&script).arg("--check"); - match cmd.status() { - Ok(status) if status.success() => return Ok(()), + cmd.arg(&script).arg("--check").current_dir(&dir); + match execute(&mut cmd) { + Ok(status) if status.success() => { + let mut tests = Command::new(python); + tests + .args(["-m", "unittest", "test_sc_usage"]) + .current_dir(&dir); + let status = + execute(&mut tests).with_context(|| format!("failed to start {tests:?}"))?; + if !status.success() { + bail!("{tests:?} failed ({status})"); + } + return Ok(()); + } // Windows' App Execution Alias stub for a missing python exits with 9009. Ok(status) if cfg!(windows) && status.code() == Some(9009) => continue, Ok(status) => bail!("{cmd:?} failed ({status})"), @@ -543,10 +567,7 @@ fn sc_ratchet() -> Result<()> { Err(e) => return Err(e).with_context(|| format!("failed to start {cmd:?}")), } } - skip_missing_python( - std::env::var_os("XTASK_SKIP_RATCHET").is_some_and(|v| v == "1"), - std::env::var_os("CI").is_some(), - ) + skip_missing_python(skip_requested, in_ci) } /// No python interpreter was found: fail, unless the skip was requested explicitly and this is @@ -554,12 +575,13 @@ fn sc_ratchet() -> Result<()> { fn skip_missing_python(skip_requested: bool, in_ci: bool) -> Result<()> { if skip_requested && !in_ci { eprintln!( - "warning: python not found; skipping the S->C coverage ratchet (XTASK_SKIP_RATCHET=1)" + "warning: python not found; skipping the S->C coverage ratchet and its tests \ + (XTASK_SKIP_RATCHET=1)" ); return Ok(()); } bail!(concat!( - "python (python3 or python) not found: the S->C coverage ratchet ", + "python (python3 or python) not found: the S->C coverage ratchet and its tests ", "(tools/opcode_coverage/sc_usage.py --check) cannot run. Install python, or set ", "XTASK_SKIP_RATCHET=1 to skip it explicitly (not allowed when CI is set)" )) @@ -568,6 +590,180 @@ fn skip_missing_python(skip_requested: bool, in_ci: bool) -> Result<()> { #[cfg(test)] mod tests { use super::*; + use std::io::{Error, ErrorKind}; + + fn exit_status(code: u32) -> ExitStatus { + #[cfg(windows)] + { + use std::os::windows::process::ExitStatusExt; + ExitStatus::from_raw(code) + } + #[cfg(unix)] + { + use std::os::unix::process::ExitStatusExt; + ExitStatus::from_raw((code << 8) as i32) + } + } + + fn fake_sc_ratchet( + skip_requested: bool, + in_ci: bool, + outcomes: Vec>, + programs: &[&str], + ) -> Result<()> { + assert_eq!(outcomes.len(), programs.len()); + let mut steps = programs.iter().zip(outcomes); + let result = sc_ratchet_with(skip_requested, in_ci, |cmd| { + let (program, outcome) = steps.next().expect("unexpected Python command"); + assert_eq!(cmd.get_program(), *program); + outcome + }); + assert!( + steps.next().is_none(), + "expected Python command did not run" + ); + result + } + + #[test] + fn ratchet_runs_unittests_with_same_python_and_correct_paths() { + let dir = workspace_dir().join("tools/opcode_coverage"); + let script = dir.join("sc_usage.py"); + let mut calls = 0; + // The skip only applies when no interpreter is found. + sc_ratchet_with(true, false, |cmd| { + assert_eq!(cmd.get_program(), "python3"); + assert_eq!(cmd.get_current_dir(), Some(dir.as_path())); + let args: Vec<_> = cmd.get_args().collect(); + match calls { + 0 => assert_eq!(args, [script.as_os_str(), "--check".as_ref()]), + 1 => assert_eq!(args, ["-m", "unittest", "test_sc_usage"]), + _ => panic!("unexpected Python command"), + } + calls += 1; + Ok(exit_status(0)) + }) + .unwrap(); + assert_eq!(calls, 2); + } + + #[test] + fn missing_python3_falls_back_to_python_for_ratchet_and_unittests() { + fake_sc_ratchet( + false, + false, + vec![ + Err(ErrorKind::NotFound.into()), + Ok(exit_status(0)), + Ok(exit_status(0)), + ], + &["python3", "python", "python"], + ) + .unwrap(); + } + + #[cfg(windows)] + #[test] + fn windows_python_alias_falls_back_to_python_for_ratchet_and_unittests() { + fake_sc_ratchet( + false, + false, + vec![ + Ok(exit_status(9009)), + Ok(exit_status(0)), + Ok(exit_status(0)), + ], + &["python3", "python", "python"], + ) + .unwrap(); + } + + #[test] + fn ratchet_failure_does_not_fall_back_or_honor_skip() { + let err = fake_sc_ratchet(true, false, vec![Ok(exit_status(1))], &["python3"]).unwrap_err(); + assert!(err.to_string().contains("sc_usage.py")); + assert!(err.to_string().contains("failed")); + } + + #[test] + fn python_permission_denied_does_not_fall_back_or_honor_skip() { + let err = fake_sc_ratchet( + true, + false, + vec![Err(ErrorKind::PermissionDenied.into())], + &["python3"], + ) + .unwrap_err(); + assert!(err.to_string().contains("failed to start")); + assert_eq!( + err.downcast_ref::().unwrap().kind(), + ErrorKind::PermissionDenied + ); + } + + #[test] + fn no_python_skips_both_checks_only_when_explicit_and_outside_ci() { + for skip_requested in [false, true] { + for in_ci in [false, true] { + let result = fake_sc_ratchet( + skip_requested, + in_ci, + vec![ + Err(ErrorKind::NotFound.into()), + Err(ErrorKind::NotFound.into()), + ], + &["python3", "python"], + ); + assert_eq!(result.is_ok(), skip_requested && !in_ci); + if let Err(err) = result { + assert!(err.to_string().contains("not found")); + } + } + } + } + + #[cfg(windows)] + #[test] + fn missing_windows_aliases_obey_skip_policy() { + for in_ci in [false, true] { + let result = fake_sc_ratchet( + true, + in_ci, + vec![Ok(exit_status(9009)), Ok(exit_status(9009))], + &["python3", "python"], + ); + assert_eq!(result.is_ok(), !in_ci); + } + } + + #[test] + fn python_unittest_failure_propagates_without_fallback_or_skip() { + let err = fake_sc_ratchet( + true, + false, + vec![Ok(exit_status(0)), Ok(exit_status(1))], + &["python3", "python3"], + ) + .unwrap_err(); + assert!(err.to_string().contains("test_sc_usage")); + assert!(err.to_string().contains("failed")); + } + + #[test] + fn python_unittest_start_errors_propagate_without_fallback_or_skip() { + for kind in [ErrorKind::NotFound, ErrorKind::PermissionDenied] { + let err = fake_sc_ratchet( + true, + false, + vec![Ok(exit_status(0)), Err(kind.into())], + &["python3", "python3"], + ) + .unwrap_err(); + assert!(err.to_string().contains("test_sc_usage")); + assert!(err.to_string().contains("failed to start")); + assert_eq!(err.downcast_ref::().unwrap().kind(), kind); + } + } #[test] fn missing_python_fails_unless_skipped_explicitly_outside_ci() { From c9da5b673b5f4e22496f828568bbf73371ff6711 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Fri, 23 Oct 2026 10:32:37 -0400 Subject: [PATCH 08/13] fix(vehicles): preserve legacy parts and validate cannon gunners Initialize slave equipment when its persistent container is created, migrate exact legal static defaults, and preserve bindings without item equivalents. Require matching cannon driver seats and attachments, and detach child gunners before carrier death removes their cannons. Snapshot object state before child and world lookups. Add deterministic, real compact-data, and private MySQL persistence regressions. Keep the MySQL fixture reusable across owned lanes. Co-Authored-By: Codex --- rust/crates/aaemu-game/PORTING.md | 28 +- .../src/systems/skills/mount_authority.rs | 10 +- .../src/systems/vehicles/flow_tests.rs | 3 + .../systems/vehicles/pr38_regression_tests.rs | 549 ++++++++++++++++++ .../aaemu-game/src/systems/vehicles/slaves.rs | 254 ++++---- 5 files changed, 736 insertions(+), 108 deletions(-) create mode 100644 rust/crates/aaemu-game/src/systems/vehicles/pr38_regression_tests.rs diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index f5b22af869..82e03be01a 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -2533,8 +2533,10 @@ finishes and the NPC settles in HoldPosition without further movement. `ItemClass::SlaveEquipment` with `ItemDetailType.SlaveEquipment` (12 opaque detail bytes); `read_wire_item` consumes detail bytes by detail type (gear 55, ship parts 12, ...) instead of always reading an `EquipItem`. Bind-on-equip applies in `EquipmentSlave` too. A player-owned - slave gets its starter pack only once (10.x `isNewEquipment`), and the persistent container - is reused on the next summon / restart; NPC / spawner slaves keep the 1.2 in-memory pack. + slave gets its starter pack when its equipment container is first created, including a saved + legacy hull whose summon item already names its DB id. An existing empty container represents + intentional unequipping and is reused on the next summon / restart without seeding again. + NPC / spawner slaves keep the in-memory defaults. - **Deviation from 1.2:** slave equipment persistence and the `0xF2` container do not exist in the 1.2 C# at all; they are the 10.x design, recorded here because the 1.2 data already ships `slave_initial_items`, `slave_equip_slots` and `item_slave_equipments`. @@ -2550,12 +2552,18 @@ finishes and the NPC settles in HoldPosition without further movement. points: a child slave (Steel Cannon 28852 -> slave 10, Harpoon Cannon 30306 -> slave 48) or a doodad (sails, masts, lamps, planks, figureheads, bell, telescope, ...). A slot that drives two points (front/rear lamp, both planks) spawns the visual at both. Unequipping removes exactly - that visual; a resummon respawns it from the persistent container. At attach points a declared - equipment slot owns, the 1.2 static `slave_bindings` / `slave_doodad_bindings` are skipped so a - part can be removed; static bindings still cover points without an equipment slot. + that visual; a resummon respawns it from the persistent container. Static bindings are skipped + only for slots with initial equipment, so deliberately unequipped parts remain absent. An + authored default without an exact legal equipment equivalent remains a static binding. - **Starter pack:** `slave_initial_items` rows are seeded only into slots the hull declares in `slave_equip_slots` (slave 110 / 139 reference pack 1 without those slots; slave 21 has slot 0 - at the cannon points and no starter cannons). + at the cannon points and no starter cannons). Missing defaults are inferred from static + bindings only when one legal item reproduces every binding of the slot (lowest item id breaks + ties deterministically). The item template must also exist: hull 21's slot-0 cannon visual + references missing item 28854, so all eight cannons remain static. Hull 14/75's static lamps + also have no equivalent equipment item. Real-data spawn regressions + cover hulls 14, 21, 75, 76 and 110; synthetic and MySQL restart tests cover initialization and + persistent empty slots (`vehicles/pr38_regression_tests.rs`). - **Attach points:** models 511 (slave 22), 1482 (slave 132) and 1546 (slaves 139/142/143/145) were recovered from the `$` helper nodes of the 1.2 client's `galleon_body_test.cgf`, `boardship_body_test.cgf` and `middleship_body.cgf` (CGF units / 100, the same method and @@ -2573,10 +2581,14 @@ finishes and the NPC settles in HoldPosition without further movement. it (standing on it or seated on any of its points; the 1.2 data has no seat permission table, so party / expedition membership is not required), with `SLAVE_ALREADY_HAS_MASTER` when the seat is taken and `SLAVE_UNBIND_FIRST` when the character already rides another slave. Only the gunner - may cast the cannon's mount skills (`mount_authority::may_use_slave`); the carrier's owner no + may cast the cannon's mount skills (`mount_authority::may_use_slave`): its DRIVER seat must name + the player, and the player's attach point and transform parent must match. Standing on the + cannon alone grants no shot, even when the seat is empty. The carrier's owner no longer fires it remotely. The gunner leaves through `CSDiscardSlave`, death (`on_death_event`), teleport / `force_dismount`, the cannon being unequipped, or the carrier being recalled, - destroyed or despawned (`unbind_child_riders`). The gunner sits at the model's driver helper if + destroyed or despawned (`unbind_child_riders`). Carrier death detaches child riders before + deleting their cannons, preserving world coordinates, clearing seats and sending `SCUnitDetached`. + The gunner sits at the model's driver helper if `slave_attach_points*.json` has one, else at `GUNNER_SEAT_OFFSET` (0, -0.8, 0) in the cannon frame: model 117 has no helper in the data or the pak, and no cannon-like model with a seat helper exists, so this is a documented constant. The gunner is a transform child of the cannon, which is diff --git a/rust/crates/aaemu-game/src/systems/skills/mount_authority.rs b/rust/crates/aaemu-game/src/systems/skills/mount_authority.rs index f7bdabd959..b330483c2a 100644 --- a/rust/crates/aaemu-game/src/systems/skills/mount_authority.rs +++ b/rust/crates/aaemu-game/src/systems/skills/mount_authority.rs @@ -38,16 +38,20 @@ pub(super) fn may_use_slave( player: &PlayerRef, slave: &SlaveRef, ) -> bool { - let parent = player.data().unit.transform.parent_obj_id; + let (parent, point) = { + let player = player.data(); + (player.unit.transform.parent_obj_id, player.attached_point) + }; let character_id = player.character_id; // A cannon mounted on a ship answers its gunner only: manning it is what grants the shot. if crate::systems::vehicles::slaves::is_manned_cannon(server, slave) { return parent == slave.obj_id - || slave + && point == attach_point::DRIVER + && slave .data() .attached_characters .iter() - .any(|(_, obj)| *obj == player.obj_id); + .any(|(seat, obj)| *seat == attach_point::DRIVER && *obj == player.obj_id); } if parent == slave.obj_id || summoned_by(slave, player, character_id) { return true; diff --git a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs index e2fb87a0de..1bbedf8efc 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs @@ -46,6 +46,9 @@ const PB: u32 = 0x00F0_0002; #[path = "deck_standing_tests.rs"] mod deck_standing_tests; +#[path = "pr38_regression_tests.rs"] +mod pr38_regression_tests; + fn exp_table() -> ExperienceTable { ExperienceTable::from_templates( (1..=3u8) diff --git a/rust/crates/aaemu-game/src/systems/vehicles/pr38_regression_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/pr38_regression_tests.rs new file mode 100644 index 0000000000..c2291f1071 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/vehicles/pr38_regression_tests.rs @@ -0,0 +1,549 @@ +//! Regressions for legacy hull defaults, persistent empty equipment, and gunner authority/lifetime. + +use super::*; +use crate::world::SlaveRef; + +fn hull(server: &GameServer, owner: &PlayerRef, saved: Option) -> SlaveRef { + let world = server.world.world(0).unwrap(); + slaves::create_core( + server, + &world, + Some(owner), + None, + SHIP_HULL, + None, + false, + None, + saved, + ) + .expect("hull") +} + +fn saved(id: u32) -> slaves::SavedSlave { + slaves::SavedSlave { + id, + name: "Legacy hull".into(), + hp: 100, + mp: 10, + } +} + +#[tokio::test] +async fn no_starter_pack_migrates_equivalent_defaults_and_preserves_unmapped_bindings() { + let mut d = ship_equip_data(); + d.systems.vehicles.slave_initial_items.clear(); + let template = d + .systems + .vehicles + .slave_templates + .get_mut(&SHIP_HULL) + .unwrap(); + template + .slave_bindings + .push(super::super::data::SlaveBinding { + id: 2, + owner_id: SHIP_HULL, + owner_type: "Slave".into(), + slave_id: OTHER_HULL, + attach_point_id: 10, + }); + d.systems + .vehicles + .slave_equip_slots + .get_mut(&SHIP_HULL) + .unwrap() + .push(super::super::data::SlaveEquipSlot { + id: 2, + slave_id: SHIP_HULL, + attach_point_id: 10, + equip_slot_id: 4, + require_slot_id: -1, + }); + let server = server_with(d); + let a = TestClient::new(&server, 1, 1); + let owner = spawn_player(&server, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let world = server.world.world(0).unwrap(); + let first = hull(&server, &owner, None); + let db_id = first.data().id; + assert_eq!( + first.data().attached_slaves.len(), + 2, + "both authored defaults survive" + ); + assert_eq!( + first.data().equipment[3].as_ref().unwrap().template_id, + CANNON_ITEM + ); + assert!( + first.data().equipment[4].is_none(), + "no equivalent item for the static child" + ); + let container = server + .items + .find_container_for_character(1, slot_type::EQUIPMENT_SLAVE, db_id) + .unwrap(); + // Deliberate unequipping leaves a persistent, empty container. It must not seed again. + container.lock().unwrap().items.clear(); + slaves::delete(&server, Some(&owner), world.id, first.obj_id, false); + let again = hull(&server, &owner, Some(saved(db_id))); + assert!(again.data().equipment[3].is_none()); + let children = again.data().attached_slaves.clone(); + assert_eq!( + children.len(), + 1, + "only the unmapped static default returns" + ); + assert_eq!( + world.slave(children[0]).unwrap().data().unit.template_id, + OTHER_HULL + ); +} + +#[tokio::test] +async fn saved_hull_initializes_starter_equipment_only_when_container_is_created() { + let server = server_with(ship_equip_data()); + let a = TestClient::new(&server, 1, 1); + let owner = spawn_player(&server, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let first = hull(&server, &owner, Some(saved(700))); + let item = first.data().equipment[3] + .clone() + .expect("legacy hull starter cannon"); + assert_eq!(item.template_id, CANNON_ITEM); + let container = server + .items + .find_container_for_character(1, slot_type::EQUIPMENT_SLAVE, 700) + .unwrap(); + assert_eq!( + container.lock().unwrap().get_item_by_slot(3).unwrap().id, + item.id + ); + container.lock().unwrap().items.clear(); + let world = server.world.world(0).unwrap(); + slaves::delete(&server, Some(&owner), world.id, first.obj_id, false); + let again = hull(&server, &owner, Some(saved(700))); + assert!(again.data().equipment[3].is_none()); + assert!( + again.data().attached_slaves.is_empty(), + "unequipped defaults stay absent" + ); +} + +#[tokio::test] +#[ignore = "needs AAEMU_TEST_MYSQL on private MySQL3317; uses connection-local temporary tables"] +async fn private_mysql_legacy_slave_equipment_survives_restart_and_stays_unequipped() { + use sqlx::mysql::MySqlConnectOptions; + use std::str::FromStr; + + let options = MySqlConnectOptions::from_str( + &std::env::var("AAEMU_TEST_MYSQL").expect("AAEMU_TEST_MYSQL"), + ) + .unwrap(); + assert_eq!(options.get_port(), 3317); + assert!(matches!(options.get_host(), "127.0.0.1" | "localhost")); + let pool = MySqlPoolOptions::new() + .max_connections(1) + .connect_with(options) + .await + .unwrap(); + // Exercise production serializers/loaders with connection-local tables; no persistent rows + // or another session's tables are touched, even if an assertion fails. + for table in ["items", "item_containers", "slaves"] { + let (_, ddl): (String, String) = sqlx::query_as(&format!("SHOW CREATE TABLE `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + sqlx::query(&ddl.replacen("CREATE TABLE", "CREATE TEMPORARY TABLE", 1)) + .execute(&pool) + .await + .unwrap(); + } + let make_server = || { + let mut server = test_server_with(ship_equip_data()); + server.db = pool.clone(); + let server = Arc::new(server); + server.set_self(); + server + }; + let server = make_server(); + let a = TestClient::new(&server, 1, 1); + let (owner, item_id) = player_with_item(&server, &a, 1, PA, (100.0, 100.0), SLAVE_ITEM); + let bag = owner.data().inventory.bag().clone(); + bag.lock().unwrap().container_id = 900; + server.items.add_container(bag.clone()); + let item = { + let mut bag = bag.lock().unwrap(); + let item = bag.items.iter_mut().find(|i| i.id == item_id).unwrap(); + item.owner_id = 1; + item.details.slave_db_id = 700; + item.dirty = true; + item.clone() + }; + let row = slaves::SlaveRow { + id: 700, + item_id, + template_id: SHIP_HULL, + attach_point: -1, + name: "Legacy hull".into(), + owner_type: 0, + owner_id: 1, + summoner: 1, + hp: 100, + mp: 10, + x: 100.0, + y: 100.0, + z: 100.0, + }; + slaves::write_row(&mut pool.acquire().await.unwrap(), &row) + .await + .unwrap(); + let world = server.world.world(0).unwrap(); + let first = slaves::create( + &server, + &world, + Some(&owner), + SHIP_HULL, + Some(item.clone()), + false, + None, + ) + .await + .unwrap(); + assert_eq!(first.data().id, 700); + let cannon_item = first.data().equipment[3] + .clone() + .expect("legacy starter equipment"); + assert_eq!(first.data().attached_slaves.len(), 1); + let mut tx = pool.begin().await.unwrap(); + server.items.save(&mut tx).await.unwrap(); + for row in slaves::snapshot(&server, &first) { + slaves::write_row(&mut tx, &row).await.unwrap(); + } + tx.commit().await.unwrap(); + server.items.commit_save(); + + let restart = make_server(); + restart + .items + .load_user_items( + &pool, + &restart.game_data.items, + 1, + &restart.ids.container, + &restart.ids.item, + ) + .await + .unwrap(); + let a = TestClient::new(&restart, 1, 1); + let owner = spawn_player(&restart, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let world = restart.world.world(0).unwrap(); + let again = slaves::create( + &restart, + &world, + Some(&owner), + SHIP_HULL, + Some(item.clone()), + false, + None, + ) + .await + .unwrap(); + assert_eq!( + again.data().equipment[3].as_ref().unwrap().id, + cannon_item.id, + "restart preserves item identity" + ); + assert_eq!(again.data().attached_slaves.len(), 1); + let container = restart + .items + .find_container_for_character(1, slot_type::EQUIPMENT_SLAVE, 700) + .unwrap(); + let removed = { + let mut container = container.lock().unwrap(); + container.dirty = true; + container.items.remove(0) + }; + restart.items.mark_for_db_deletion(removed.id); + let mut tx = pool.begin().await.unwrap(); + restart.items.save(&mut tx).await.unwrap(); + tx.commit().await.unwrap(); + restart.items.commit_save(); + + let restart = make_server(); + restart + .items + .load_user_items( + &pool, + &restart.game_data.items, + 1, + &restart.ids.container, + &restart.ids.item, + ) + .await + .unwrap(); + let a = TestClient::new(&restart, 1, 1); + let owner = spawn_player(&restart, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let world = restart.world.world(0).unwrap(); + let empty = slaves::create( + &restart, + &world, + Some(&owner), + SHIP_HULL, + Some(item), + false, + None, + ) + .await + .unwrap(); + assert!(empty.data().equipment[3].is_none()); + assert!( + empty.data().attached_slaves.is_empty(), + "empty persisted container is intentional" + ); + pool.close().await; +} + +async fn parent_only_cannon_attack(occupied: bool) { + use crate::models::movement::{MoveTypeActorFlags, UnitMove}; + use crate::net::registry::ClientPacket; + use crate::packets::c2g_world::CSMoveUnitPacket; + use crate::systems::skills::handlers::{start_skill, CSStartSkillPacket}; + use crate::systems::skills::types::{SkillCastTarget, SkillCaster, SkillObject}; + + let server = server_with(cannon_data()); + crate::systems::economy::bridges::install(&server); + crate::systems::npcs::install_hooks(&server); + super::super::install_hooks(&server); + let mut a = TestClient::new(&server, 1, 1); + let mut b = TestClient::new(&server, 2, 2); + let owner = spawn_player(&server, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let attacker = spawn_player(&server, &b, test_character(2, "Attacker", 101.0, 100.0), PB); + a.conn.active_char = Some(owner.clone()); + b.conn.active_char = Some(attacker.clone()); + let world = server.world.world(0).unwrap(); + let carrier = hull(&server, &owner, None); + let cannon_id = carrier.data().attached_slaves[0]; + let cannon = world.slave(cannon_id).unwrap(); + if occupied { + let tl = u32::from(cannon.data().unit.tl_id); + slaves::bind_slave_by_tl(&server, &owner, tl); + } + // The authenticated movement path accepts a supporting object, but grants no gunner seat. + CSMoveUnitPacket { + obj_id: PB, + move_type: MoveType::new(MoveKind::Unit(UnitMove { + x: 0.0, + y: 0.0, + z: 0.0, + gc_id: cannon.obj_id, + gc_flags: 1, + actor_flags: MoveTypeActorFlags::STANDING_ON_OBJECT, + ..UnitMove::default() + })), + } + .handle(&server, &mut b.conn) + .await + .unwrap(); + assert_eq!(attacker.data().unit.transform.parent_obj_id, cannon.obj_id); + assert_eq!(attacker.data().attached_point, attach_point::NONE); + let target = spawn_npc_at(&server, 0x5000, CANNON_TARGET_NPC, 130.0, 130.0); + target.data().unit.hp = 1000; + target.data().unit.max_hp = 1000; + let shot = CSStartSkillPacket { + skill_id: FIRE_CANNON, + caster: SkillCaster::Mount { + obj_id: cannon.obj_id, + mount_skill_template_id: CANNON_MOUNT_SKILL, + }, + target: SkillCastTarget::Position { + obj_id: 0, + x: 130.0, + y: 130.0, + z: 100.0, + rot: 0.0, + obj_id1: 0, + obj_id2: 0, + }, + flag: 0, + skill_object: SkillObject::None, + }; + b.drain(); + start_skill(&server, &mut b.conn, shot.clone()); + assert_eq!( + target.data().unit.hp, + 1000, + "a parent pointer cannot grant a cannon shot" + ); + assert!(!ops(&b.drain()).contains(&sc::SCSkillFiredPacket)); + if occupied { + assert_eq!( + cannon.data().attached_characters, + vec![(attach_point::DRIVER, PA)] + ); + // A stale or inconsistent attachment does not authorize the registered gunner either. + world.detach_child(&WorldObject::from(&owner)); + start_skill(&server, &mut a.conn, shot.clone()); + assert_eq!(target.data().unit.hp, 1000); + world.attach_child(&WorldObject::from(&cannon), &WorldObject::from(&owner)); + owner.data().attached_point = attach_point::NONE; + start_skill(&server, &mut a.conn, shot.clone()); + assert_eq!(target.data().unit.hp, 1000); + owner.data().attached_point = attach_point::DRIVER; + } else { + let tl = u32::from(cannon.data().unit.tl_id); + slaves::bind_slave_by_tl(&server, &owner, tl); + } + start_skill(&server, &mut a.conn, shot); + assert_eq!( + target.data().unit.hp, + 850, + "the registered, attached driver can fire" + ); +} + +#[tokio::test] +async fn parent_only_attacker_cannot_fire_an_unoccupied_cannon() { + parent_only_cannon_attack(false).await; +} + +#[tokio::test] +async fn parent_only_attacker_cannot_fire_another_gunners_cannon() { + parent_only_cannon_attack(true).await; +} + +#[tokio::test] +async fn carrier_death_detaches_gunner_before_deleting_cannon() { + let server = server_with(cannon_data()); + super::super::install_hooks(&server); + let mut a = TestClient::new(&server, 1, 1); + let owner = spawn_player(&server, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let world = server.world.world(0).unwrap(); + let carrier = hull(&server, &owner, None); + let cannon_id = carrier.data().attached_slaves[0]; + let cannon = world.slave(cannon_id).unwrap(); + let tl = u32::from(cannon.data().unit.tl_id); + slaves::bind_slave_by_tl(&server, &owner, tl); + carrier + .data() + .unit + .transform + .set_position(250.0, 175.0, 90.0, 0.0, 0.0, 1.2); + let before = world.world_pos_rot(&WorldObject::from(&owner)); + a.drain(); + slaves::do_die( + &server, + &carrier, + Some(&WorldObject::from(&owner)), + crate::systems::skills::types::KillReason::Damage, + ); + assert!(world.slave(cannon.obj_id).is_none()); + assert!( + cannon.data().attached_characters.is_empty(), + "gunner seat released before removal" + ); + let player = owner.data(); + assert_eq!(player.attached_point, attach_point::NONE); + assert!(!player.is_riding); + assert_eq!(player.unit.transform.parent_obj_id, 0); + let after = player.unit.transform.local(); + drop(player); + for (a, b) in [ + (before.x, after.x), + (before.y, after.y), + (before.z, after.z), + (before.rot_z, after.rot_z), + ] { + assert!( + (a - b).abs() < 1e-4, + "world transform changed: {before:?} -> {after:?}" + ); + } + let mut detached = bc(PA); + detached.push(slaves::attach_reason::NONE); + assert_eq!(body(&a.drain(), sc::SCUnitDetachedPacket), detached); +} + +#[tokio::test] +#[ignore = "needs AAEMU_COMPACT_DB"] +async fn real_compact_db_vehicle_defaults_spawn_on_legacy_hulls() { + let Ok(db) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + rusqlite::Connection::open_with_flags(&db, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY) + .unwrap(); + let mut d = slave_data(); + d.systems.vehicles = load_real(&db, &[]); + d.items = crate::data::items::ItemData::load(&conn).unwrap(); + d.systems.npcs.doodad = + crate::systems::npcs::doodad::data::DoodadData::load_from(&conn).unwrap(); + let server = server_with(d); + let a = TestClient::new(&server, 1, 1); + let owner = spawn_player(&server, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let world = server.world.world(0).unwrap(); + for id in [14, 21, 75, 76, 110] { + let template = server + .game_data + .systems + .vehicles + .slave_template(id) + .unwrap(); + assert!(server + .game_data + .systems + .vehicles + .slave_initial_item_pack(template.slave_initial_item_pack_id) + .is_none()); + let carrier = slaves::create_core( + &server, + &world, + Some(&owner), + None, + id, + None, + false, + None, + Some(saved(700 + id)), + ) + .unwrap(); + let children = carrier.data().attached_slaves.clone(); + assert_eq!( + children.len(), + template.slave_bindings.len(), + "hull {id}: all child defaults" + ); + for binding in &template.slave_bindings { + assert_eq!( + children + .iter() + .filter(|child| { + let child = world.slave(**child).unwrap(); + let child = child.data(); + child.attach_point_id as u8 == binding.attach_point_id + && child.unit.template_id == binding.slave_id + }) + .count(), + 1, + "hull {id} point {}", + binding.attach_point_id + ); + } + let doodads = carrier.data().attached_doodads.clone(); + for binding in &template.doodad_bindings { + assert_eq!( + doodads + .iter() + .filter(|child| { + let child = world.doodad(**child).unwrap(); + let child = child.data(); + child.attach_point == binding.attach_point_id + && child.template_id == binding.doodad_id + }) + .count(), + 1, + "hull {id} doodad point {}", + binding.attach_point_id + ); + } + slaves::delete(&server, Some(&owner), world.id, carrier.obj_id, false); + } +} diff --git a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs index 3210ef123f..af828d279e 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs @@ -404,18 +404,74 @@ fn mirror_slave_equipment(slave: &SlaveRef, container: &ContainerRef) { } } -/// `SlaveGameData.IsBindingAttachPoint`: a static doodad / slave / healing-point binding owns the -/// attach point, so equipment visuals never touch it. A point a declared equipment slot owns is -/// driven by the container instead, even when the 1.2 data also lists a static binding there. -fn is_binding_attach_point( - data: &super::data::VehiclesData, +/// Initial equipment, including legacy static defaults that have an exact legal item equivalent. +/// A multi-point slot is migrated only when one item reproduces every authored binding. Parts +/// without such an equivalent remain static, rather than disappearing merely because a slot exists. +fn initial_slave_equipment( + server: &GameServer, template: &SlaveTemplate, - point: u8, -) -> bool { - if data - .slave_equip_attach_point_set(template.id) - .contains(&point) - { +) -> Vec { + let data = &server.game_data.systems.vehicles; + let mut initial = data + .slave_initial_item_pack(template.slave_initial_item_pack_id) + .unwrap_or_default() + .iter() + .copied() + .filter(|item| server.game_data.items.template(item.item_id).is_some()) + .collect::>(); + for slot in data.slave_equip_slots(template.id) { + if initial + .iter() + .any(|i| i.equip_slot_id == slot.equip_slot_id) + { + continue; + } + let points = data.slave_equip_attach_points(template.id, slot.equip_slot_id); + let equivalent = data + .item_slave_equipments + .values() + .filter(|item| { + item.require_item_id == 0 + && server.game_data.items.template(item.item_id).is_some() + && data.can_equip_item_on_slave(item.item_id, template.id, slot.equip_slot_id) + && points.iter().all(|point| { + let child = template + .slave_bindings + .iter() + .find(|b| b.owner_type == "Slave" && b.attach_point_id == *point); + let doodad = template + .doodad_bindings + .iter() + .find(|b| b.attach_point_id == *point); + (child.is_some() || doodad.is_some()) + && child.map_or(0, |b| b.slave_id) == item.slave_id + && doodad.map_or(0, |b| b.doodad_id) == item.doodad_id + }) + }) + .min_by_key(|item| item.item_id); + if let Some(item) = equivalent { + initial.push(super::data::SlaveInitialItem { + pack_id: template.slave_initial_item_pack_id, + equip_slot_id: slot.equip_slot_id, + item_id: item.item_id, + }); + } + } + initial +} + +/// Static bindings remain authored defaults unless the slot has initial equipment (explicit or +/// migrated). That decision is independent of its current contents: an intentionally empty saved +/// slot must not grow its static default again on the next summon. +fn is_binding_attach_point(server: &GameServer, template: &SlaveTemplate, point: u8) -> bool { + let data = &server.game_data.systems.vehicles; + let initial = initial_slave_equipment(server, template); + if data.slave_equip_slots(template.id).iter().any(|slot| { + slot.attach_point_id == point + && initial + .iter() + .any(|i| i.equip_slot_id == slot.equip_slot_id) + }) { return false; } template @@ -443,31 +499,30 @@ fn remove_equipment_visual_at( let data = &server.game_data.systems.vehicles; if data .slave_template(slave.data().unit.template_id) - .is_some_and(|t| is_binding_attach_point(data, t, point)) + .is_some_and(|t| is_binding_attach_point(server, t, point)) { return; } - let mut doodads = Vec::new(); - let mut children = Vec::new(); - { + let (attached_doodads, attached_slaves) = { let d = slave.data(); - for id in &d.attached_doodads { - if world + (d.attached_doodads.clone(), d.attached_slaves.clone()) + }; + let doodads: Vec<_> = attached_doodads + .into_iter() + .filter(|id| { + world .doodad(*id) .is_some_and(|dd| dd.data().attach_point == point) - { - doodads.push(*id); - } - } - for id in &d.attached_slaves { - if world + }) + .collect(); + let children: Vec<_> = attached_slaves + .into_iter() + .filter(|id| { + world .slave(*id) .is_some_and(|s| s.data().attach_point_id as u8 == point) - { - children.push(*id); - } - } - } + }) + .collect(); slave .data() .attached_doodads @@ -600,11 +655,11 @@ fn spawn_equipment_child_slave( let child_obj = WorldObject::from(&child); apply_slave_bonuses(server, &child_obj, &child_template); stats::refresh_object_pools(server, &child_obj); + let w = world.world_pos_rot(&WorldObject::from(slave)); { let mut d = child.data(); d.unit.hp = d.unit.max_hp; d.unit.mp = d.unit.max_mp; - let w = world.world_pos_rot(&WorldObject::from(slave)); d.unit.transform.instance_id = world.id; d.unit .transform @@ -649,7 +704,7 @@ pub fn spawn_or_replace_equipment_visual( return; } for point in points { - if is_binding_attach_point(data, &template, point) { + if is_binding_attach_point(server, &template, point) { tracing::debug!( "Skip equip visual at {point} on slave tpl={}: attach point is a static binding", template.id @@ -1207,12 +1262,16 @@ pub fn may_man_cannon(character: &PlayerRef, cannon: &SlaveRef, world: &WorldIns let Some(bearer) = world.slave(bearer_id) else { return true; // Orphaned: nobody to ask. }; - let d = bearer.data(); - is_me(d.summoner_obj_id, d.summoner_id) - || character.data().unit.transform.parent_obj_id == bearer_id - || d.attached_characters - .iter() - .any(|(_, c)| *c == character.obj_id) + let (owner, attached) = { + let d = bearer.data(); + ( + is_me(d.summoner_obj_id, d.summoner_id), + d.attached_characters + .iter() + .any(|(_, c)| *c == character.obj_id), + ) + }; + owner || attached || character.data().unit.transform.parent_obj_id == bearer_id } /// A gunner who dies leaves the cannon (a driver or passenger of a ship keeps the C# behaviour). @@ -2299,9 +2358,9 @@ pub(crate) fn create_spawn( crate::models::container::slot_type::EQUIPMENT_SLAVE, db_id, ); - let is_new_equipment = existing.is_none() - && !is_loaded - && item.as_ref().is_none_or(|i| i.details.slave_db_id == 0); + // A saved 1.2 hull may predate EquipmentSlave containers. Container creation, not + // hull/item age, marks its one-time initialization; an existing empty one stays empty. + let is_new_equipment = existing.is_none(); let container = existing.unwrap_or_else(|| { server.items.container_for_character( owner_id, @@ -2311,59 +2370,58 @@ pub(crate) fn create_spawn( ) }); if is_new_equipment { - if let Some(pack) = data.slave_initial_item_pack(template.slave_initial_item_pack_id) { - let now = chrono::Utc::now().timestamp(); - for initial in pack { - if !data.has_slave_equip_slot(template.id, initial.equip_slot_id) { - continue; - } - let Some(mut it) = server.items.create( - initial.item_id, - 1, - 0, - server.config.id, + let pack = initial_slave_equipment(server, &template); + let now = chrono::Utc::now().timestamp(); + for initial in pack { + if !data.has_slave_equip_slot(template.id, initial.equip_slot_id) { + continue; + } + let Some(mut it) = server.items.create( + initial.item_id, + 1, + 0, + server.config.id, + &server.game_data.items, + &server.ids.item, + now, + ) else { + continue; + }; + it.slot_type = crate::models::container::slot_type::EQUIPMENT_SLAVE; + it.slot = i32::from(initial.equip_slot_id); + it.owner_id = u64::from(owner_id); + it.dirty = true; + if container + .lock() + .expect("container poisoned") + .add_new_item( + it.clone(), + i32::from(initial.equip_slot_id), &server.game_data.items, - &server.ids.item, - now, - ) else { - continue; - }; - it.slot_type = crate::models::container::slot_type::EQUIPMENT_SLAVE; - it.slot = i32::from(initial.equip_slot_id); - it.owner_id = u64::from(owner_id); - it.dirty = true; - if container - .lock() - .expect("container poisoned") - .add_new_item( - it.clone(), - i32::from(initial.equip_slot_id), - &server.game_data.items, - ) - .is_err() - { - continue; - } - let entered = { - let mut d = slave.data(); - match d.equipment.get_mut(usize::from(initial.equip_slot_id)) { - Some(slot) => { - *slot = Some(it.clone()); - true - } - None => false, + ) + .is_err() + { + continue; + } + let entered = { + let mut d = slave.data(); + match d.equipment.get_mut(usize::from(initial.equip_slot_id)) { + Some(slot) => { + *slot = Some(it.clone()); + true } - }; - // EquipmentContainer.OnEnterContainer: the SCUnitEquipmentsChanged broadcast - // reaches nobody (not spawned yet), then ParentUnit.UpdateGearBonuses(...). - if entered { - crate::systems::skills::stats::update_vehicle_gear_bonuses( - server, - &slave_obj, - Some(&it), - None, - ); + None => false, } + }; + // EquipmentContainer.OnEnterContainer: the SCUnitEquipmentsChanged broadcast + // reaches nobody (not spawned yet), then ParentUnit.UpdateGearBonuses(...). + if entered { + crate::systems::skills::stats::update_vehicle_gear_bonuses( + server, + &slave_obj, + Some(&it), + None, + ); } } } else { @@ -2376,7 +2434,8 @@ pub(crate) fn create_spawn( } } } - } else if let Some(pack) = data.slave_initial_item_pack(template.slave_initial_item_pack_id) { + } else { + let pack = initial_slave_equipment(server, &template); // NPC / spawner slaves have no DB row: keep the 1.2 C# in-memory starter pack. let now = chrono::Utc::now().timestamp(); for initial in pack { @@ -2499,12 +2558,9 @@ fn finish_create( d.spawn_time_ms, ) }; - // Attach points a declared equipment slot owns are driven by the equipment container instead - // of the static bindings, so unequipping a part can remove its visual. - let equipment_points = data.slave_equip_attach_point_set(template.id); // Create all remaining doodads that where not previously loaded for binding in &template.doodad_bindings { - if equipment_points.contains(&binding.attach_point_id) { + if !is_binding_attach_point(server, template, binding.attach_point_id) { continue; } let loaded_points: Vec = { @@ -2575,7 +2631,9 @@ fn finish_create( // Spawn Slave's slaves for binding in &template.slave_bindings { - if binding.owner_type != "Slave" || equipment_points.contains(&binding.attach_point_id) { + if binding.owner_type != "Slave" + || !is_binding_attach_point(server, template, binding.attach_point_id) + { continue; } let mut child_db_id = 0u32; @@ -2630,13 +2688,13 @@ fn finish_create( let child_obj = WorldObject::from(&child); apply_slave_bonuses(server, &child_obj, &child_template); stats::refresh_object_pools(server, &child_obj); + let w = world.world_pos_rot(&slave_obj); { // TODO (C#): persistent HP for child slaves when customization is enabled let mut d = child.data(); d.unit.hp = d.unit.max_hp; d.unit.mp = d.unit.max_mp; // Transform = summonedSlave.Transform.CloneDetached(child); Parent = slave - let w = world.world_pos_rot(&slave_obj); d.unit.transform.instance_id = world.id; d.unit .transform @@ -2906,6 +2964,9 @@ pub fn do_die( } None => tracing::error!("Slave.DoDie without a killer (NullReferenceException)"), } + // Keep child transforms and seat lists available until every gunner has detached in world + // coordinates. Deleting a cannon first loses its riders and their detach notifications. + unbind_child_riders(server, slave, attach_reason::NONE); destroy_attached_items(server, slave); distribute_slave_drop_doodads(server, slave); mark_summoning_item_as_destroyed(server, slave); @@ -2961,7 +3022,6 @@ pub fn do_die( unbind_slave(server, &p, u32::from(tl), attach_reason::NONE); } } - unbind_child_riders(server, slave, attach_reason::NONE); if server .game_data .systems From 27e76801fb778be68e825f1dd05a1d3e4d9ad29e Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Fri, 23 Oct 2026 10:51:58 -0400 Subject: [PATCH 09/13] fix(game): roll back starter inventory and verify fresh creation Keep inventory registration, atomic character persistence, and rejected-creation cleanup under the save transaction lock. Record canceled deletions at item allocation so rollback restores IDs released by other owners during setup. Require a fresh character in newchar-items verification and select the newly created character. Cover setup errors, save serialization, deletion interleaving, SQL rollback, and ID reuse. Co-Authored-By: Codex --- rust/crates/aaemu-game/PORTING.md | 2 +- rust/crates/aaemu-game/src/db_character.rs | 10 +- .../aaemu-game/src/managers/character.rs | 141 +++++-- .../src/managers/character_tests.rs | 376 +++++++++++++++++- rust/crates/aaemu-game/src/managers/item.rs | 75 +++- rust/crates/aaemu-testclient/src/scenario.rs | 49 ++- rust/crates/aaemu-testclient/src/verify.rs | 87 +++- rust/verify/newchar-items.vtest | 3 +- 8 files changed, 686 insertions(+), 57 deletions(-) diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 897e423724..7532be427f 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -1732,7 +1732,7 @@ servers (see `rust/LIVE-TESTING.md`). Fixed porting bugs are in the git history item task packets queued earlier (the C# sends those inline first too). `quests::events::with_quests` logs an error and returns `None` when the thread already holds the ops lock instead of hanging. -* `CharacterManager.Create` saved only the `characters` row (`SaveDirectlyToDatabase`); the starting supplies (`item_containers` / `items`) waited for the next `SaveManager` run or the departure save. A server stop or crash in that window kept the character but lost its items, and the next select built empty containers. `db_character::save_new_character` now writes the new character's dirty containers and items in the same transaction (`ItemManager::prepare_save_for_owner`); suite `rust/verify/newchar-items.vtest`. +* `CharacterManager.Create` saved only the `characters` row (`SaveDirectlyToDatabase`); the starting supplies (`item_containers` / `items`) waited for the next `SaveManager` run or the departure save. A server stop or crash in that window kept the character but lost its items, and the next select built empty containers. `db_character::save_new_character_locked` now writes the new character's dirty containers and items in the same transaction (`ItemManager::prepare_save_for_owner`). Creation holds the save transaction lock from before inventory registration through commit or cleanup; setup errors and failed saves discard the rejected containers/items before releasing the name and character ID, without consuming other owners' changes or queued deletions. Canceled item deletions are recorded at each starter allocation, including IDs another owner releases after setup begins, and restored on rollback. Suite `rust/verify/newchar-items.vtest` uses a fresh character on every run, including reruns of its provisioned account. Parity status of the scripted scenarios: `login`, `lobby` and `full` (fresh character) produce the same S->C traffic as the C# servers after id / time normalisation (0 findings); a second diff --git a/rust/crates/aaemu-game/src/db_character.rs b/rust/crates/aaemu-game/src/db_character.rs index 1aaedb26cc..85644f1611 100644 --- a/rust/crates/aaemu-game/src/db_character.rs +++ b/rust/crates/aaemu-game/src/db_character.rs @@ -1186,10 +1186,9 @@ pub async fn save_directly_to_database(pool: &MySqlPool, c: &mut Character) -> b /// items in the same transaction (the C# left them to the next world save, so a stop or crash /// before it kept the `characters` row but lost the starting supplies; the next select then /// built empty containers). -pub async fn save_new_character(server: &GameServer, c: &mut Character) -> bool { - // The item write and `commit_save` share the manager's pending-batch slot with the world - // save, so they run under the same transaction lock. - let _transaction = server.save.transaction_lock().await; +/// The caller holds `server.save.transaction_lock()` from before inventory registration +/// until commit or cleanup, excluding world snapshots of a partially created character. +pub(crate) async fn save_new_character_locked(server: &GameServer, c: &mut Character) -> bool { let batch = server.items.prepare_save_for_owner(c.id); save_directly(&server.db, c, Some((&server.items, batch))).await } @@ -1915,7 +1914,8 @@ mod tests { .add_new_item(item, 0, &server.game_data.items) .expect("fits"); - assert!(save_new_character(&server, &mut c).await); + let _transaction = server.save.transaction_lock().await; + assert!(save_new_character_locked(&server, &mut c).await); let rows: i64 = sqlx::query_scalar( "SELECT COUNT(*) FROM items i JOIN item_containers ic ON ic.container_id = i.container_id WHERE ic.owner_id = 7 AND i.id = ?", diff --git a/rust/crates/aaemu-game/src/managers/character.rs b/rust/crates/aaemu-game/src/managers/character.rs index d612c2e307..f3759a97a5 100644 --- a/rust/crates/aaemu-game/src/managers/character.rs +++ b/rust/crates/aaemu-game/src/managers/character.rs @@ -12,7 +12,7 @@ use crate::data::character_templates::EquipItemsTemplate; use crate::data::items::{bind_type, ItemTemplate}; use crate::db::get_account_details; use crate::db_character::{ - check_for_deleted_characters, is_character_pending_deletion, save_new_character, + check_for_deleted_characters, is_character_pending_deletion, save_new_character_locked, set_delete_times, }; use crate::error::{GameError, Result}; @@ -49,11 +49,50 @@ pub struct CreateCharacterRequest { /// `ItemContainer.AcquireDefaultItem(ItemTaskType.Invalid, templateId, amount, grade)`. pub fn acquire_default_item( + server: &GameServer, + container: &ContainerRef, + template_id: u32, + amount: i32, + grade: i32, +) -> Result { + acquire_default_item_recorded( + server, + container, + template_id, + amount, + grade, + &mut Vec::new(), + ) +} + +fn create_starting_item( + server: &GameServer, + template_id: u32, + amount: i32, + grade: u8, + now: i64, + created_items: &mut Vec<(u64, bool)>, +) -> Option { + let (item, canceled_deletion) = server.items.create_with_deletion( + template_id, + amount, + grade, + server.config.id, + &server.game_data.items, + &server.ids.item, + now, + )?; + created_items.push((item.id, canceled_deletion)); + Some(item) +} + +fn acquire_default_item_recorded( server: &GameServer, container: &ContainerRef, template_id: u32, mut amount: i32, grade: i32, + created_items: &mut Vec<(u64, bool)>, ) -> Result { if amount <= 0 { return Ok(true); @@ -107,15 +146,9 @@ pub fn acquire_default_item( drop(c); while amount > 0 { let add = amount.min(template.max_count); - let Some(mut item) = server.items.create( - template_id, - add, - grade as u8, - server.config.id, - data, - &server.ids.item, - now, - ) else { + let Some(mut item) = + create_starting_item(server, template_id, add, grade as u8, now, created_items) + else { tracing::error!( "Failed to add item with ID {template_id}, possible duplicate entries!" ); @@ -181,19 +214,19 @@ fn set_equip_item_template( template_id: u32, slot: i32, grade: u8, + created_items: &mut Vec<(u64, bool)>, ) -> Option { if template_id == 0 { return None; // AddOrMoveExistingItem(null) -> false } let data = &server.game_data.items; - let Some(mut item) = server.items.create( + let Some(mut item) = create_starting_item( + server, template_id, 1, grade, - server.config.id, - data, - &server.ids.item, Utc::now().timestamp(), + created_items, ) else { // Create returned null -> AddOrMoveExistingItem(null). return None; @@ -219,6 +252,7 @@ fn equip_pack( inv: &Inventory, i: &EquipItemsTemplate, on_equip: &mut dyn FnMut(&Item), + created_items: &mut Vec<(u64, bool)>, ) { use equip_slot::*; for (slot, (id, grade)) in [ @@ -239,12 +273,35 @@ fn equip_pack( (MUSICAL, i.musical), (COSPLAY, i.cosplay), ] { - if let Some(item) = set_equip_item_template(server, inv, id, slot, grade) { + if let Some(item) = set_equip_item_template(server, inv, id, slot, grade, created_items) { on_equip(&item); } } } +/// Declared after the save lock so rejected assets disappear before saves or ID reuse. +struct NewCharacter<'a> { + server: &'a GameServer, + id: u32, + created_items: Vec<(u64, bool)>, + committed: bool, +} + +impl Drop for NewCharacter<'_> { + fn drop(&mut self) { + if !self.committed { + self.server.items.discard_new_character( + self.id, + &self.created_items, + &self.server.ids.item, + &self.server.ids.container, + ); + self.server.names.remove_character_id(self.id); + self.server.ids.character.release_id(self.id); + } + } +} + /// `CharacterManager.Create`. pub async fn create( server: &GameServer, @@ -281,11 +338,20 @@ pub async fn create( .access_level_first_character .max(access_level); } + // Inventory::new registers containers immediately. Exclude world/departure snapshots + // throughout setup, SQL commit and failure cleanup, including setup errors below. + let _transaction = server.save.transaction_lock().await; let id = server .ids .character .get_next_id() .map_err(|e| GameError::Protocol(e.to_string()))?; + let mut creation = NewCharacter { + server, + id, + created_items: Vec::new(), + committed: false, + }; server.names.add_character(id, &name, conn.account_id()); let data = &server.game_data; let template = data @@ -358,14 +424,27 @@ pub async fn create( let mut gear = |item: &Item| { crate::systems::skills::stats::update_gear_bonuses(server, &player, Some(item), None); }; - equip_pack(server, &inv, &items.items, &mut gear); + equip_pack( + server, + &inv, + &items.items, + &mut gear, + &mut creation.created_items, + ); for (i, &body) in req.body_items.iter().enumerate() { let item = if body == 0 && template.items[i] > 0 { template.items[i] } else { body }; - if let Some(item) = set_equip_item_template(server, &inv, item, i as i32 + 19, 0) { + if let Some(item) = set_equip_item_template( + server, + &inv, + item, + i as i32 + 19, + 0, + &mut creation.created_items, + ) { gear(&item); } } @@ -377,7 +456,14 @@ pub async fn create( let mut slot = 10usize; let bag = c.inventory.bag().clone(); for s in &items.supplies { - acquire_default_item(server, &bag, s.id, s.amount, i32::from(s.grade))?; + acquire_default_item_recorded( + server, + &bag, + s.id, + s.amount, + i32::from(s.grade), + &mut creation.created_items, + )?; c.set_action(slot, ActionSlotType::ItemType, u64::from(s.id)); slot += 1; } @@ -388,7 +474,14 @@ pub async fn create( .cloned() .ok_or_else(|| GameError::Protocol("no ability items for ability 0".into()))?; for s in &general.supplies { - acquire_default_item(server, &bag, s.id, s.amount, i32::from(s.grade))?; + acquire_default_item_recorded( + server, + &bag, + s.id, + s.amount, + i32::from(s.grade), + &mut creation.created_items, + )?; c.set_action(slot, ActionSlotType::ItemType, u64::from(s.id)); slot += 1; } @@ -412,7 +505,8 @@ pub async fn create( c.unit.mp = c.unit.max_mp; c.restore_saved_hp_mp(); - if save_new_character(server, &mut c).await { + if save_new_character_locked(server, &mut c).await { + creation.committed = true; let resp = create_character_response(&c); conn.characters.push(c); conn.send(&resp); @@ -421,13 +515,6 @@ pub async fn create( conn.send(&SCCharacterCreationFailedPacket { reason: CharacterCreateError::Failed as u8, }); - server.ids.character.release_id(id); - server.names.remove_character_id(id); - // DeleteCharacterAssets(character, true): houses / guild / family / mails are later - // phases ("fullWipe is currently not implemented yet" in C# too). - tracing::warn!( - "DeleteCharacterAssets - fullWipe is currently not implemented yet, charId: {id}" - ); } Ok(()) } diff --git a/rust/crates/aaemu-game/src/managers/character_tests.rs b/rust/crates/aaemu-game/src/managers/character_tests.rs index e9345dd403..d65f0e360c 100644 --- a/rust/crates/aaemu-game/src/managers/character_tests.rs +++ b/rust/crates/aaemu-game/src/managers/character_tests.rs @@ -12,7 +12,7 @@ use crate::models::char_data::{read_action_slots, ActionSlot, ActionSlotType, MA use crate::models::character::Character; use crate::test_support::test_server_with; -use super::initialize_starting_skills; +use super::{create, initialize_starting_skills, CreateCharacterRequest}; const STARTERS: [(u8, u32); 10] = [ (1, 18132), @@ -71,6 +71,380 @@ fn new_character(ability: u8) -> Character { c } +fn creation_data() -> GameData { + use crate::data::character_templates::{ + AbilityItems, AbilitySupplyItem, CharacterTemplate, EquipItemsTemplate, + }; + use crate::data::items::{EquipTemplate, ItemTemplate, TemplateKind}; + let mut data = starting_skill_data(); + data.experience = crate::test_support::test_experience(10); + data.characters.templates.insert( + 17, + CharacterTemplate { + race: 1, + gender: 1, + num_inventory_slot: 50, + num_bank_slot: 50, + ..Default::default() + }, + ); + let mut armor = ItemTemplate::plain(2000, 1); + armor.kind = TemplateKind::Armor(EquipTemplate { + slot_type_id: 1, + ..Default::default() + }); + data.items.templates.insert(2000, armor); + for id in [2001, 2002] { + data.items + .templates + .insert(id, ItemTemplate::plain(id, 1000)); + } + data.characters.ability_items.insert( + 7, + AbilityItems { + items: EquipItemsTemplate { + headgear: (2000, 0), + ..Default::default() + }, + supplies: vec![AbilitySupplyItem { + id: 2001, + amount: 2, + grade: 0, + }], + ..Default::default() + }, + ); + data.characters.ability_items.insert( + 0, + AbilityItems { + supplies: vec![AbilitySupplyItem { + id: 2002, + amount: 300, + grade: 0, + }], + ..Default::default() + }, + ); + data +} + +fn creation_request(name: &str) -> CreateCharacterRequest { + CreateCharacterRequest { + name: name.into(), + race: 1, + gender: 1, + body_items: [0; 7], + model_params: Default::default(), + ability1: 7, + ability2: 11, + ability3: 11, + level: 1, + } +} + +#[tokio::test] +async fn new_character_setup_error_discards_inventory_before_id_reuse() { + let mut data = creation_data(); + data.skills = Default::default(); // fails after containers, equipment and supplies exist + let server = test_server_with(data); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + assert!( + create(&server, &mut client.conn, creation_request("Rejected")) + .await + .is_err() + ); + assert!( + server.items.all_containers().is_empty(), + "rejected inventory remains globally saveable" + ); + assert!(!server.names.name_exists("Rejected")); + assert_eq!(server.ids.character.get_next_id().unwrap(), 1); + assert_eq!( + server.ids.item.get_next_id().unwrap(), + crate::managers::id::ITEM_ID.first_id + ); + assert_eq!( + server.ids.container.get_next_id().unwrap(), + crate::managers::id::CONTAINER_ID.first_id + ); + assert!(client.conn.characters.is_empty()); +} + +#[tokio::test] +async fn new_character_registration_waits_for_world_save_lock() { + let server = test_server_with(creation_data()); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + let transaction = server.save.transaction_lock().await; + let creation = create(&server, &mut client.conn, creation_request("Waiting")); + tokio::pin!(creation); + assert!( + tokio::time::timeout(std::time::Duration::from_millis(50), &mut creation) + .await + .is_err() + ); + assert!( + server.items.all_containers().is_empty(), + "world save can see uncommitted starter items" + ); + assert!(!server.names.name_exists("Waiting")); + drop(transaction); + tokio::time::timeout(std::time::Duration::from_secs(2), creation) + .await + .unwrap() + .unwrap(); + assert!(server.items.all_containers().is_empty()); + assert!(!server.names.name_exists("Waiting")); +} + +#[tokio::test] +async fn new_character_cleanup_restores_a_deletion_queued_after_setup_started() { + use crate::models::character::Inventory; + let server = test_server_with(creation_data()); + let unrelated = Inventory::new(99, 50, 50, &server.items, &server.ids.container); + let deleted = server + .items + .create(2001, 4, 0, 1, &server.game_data.items, &server.ids.item, 0) + .unwrap(); + let deleted_id = deleted.id; + unrelated + .bag() + .lock() + .unwrap() + .add_new_item(deleted, 0, &server.game_data.items) + .unwrap(); + let survivor = server + .items + .create(2002, 5, 0, 1, &server.game_data.items, &server.ids.item, 0) + .unwrap(); + let survivor_id = survivor.id; + unrelated + .bag() + .lock() + .unwrap() + .add_new_item(survivor, 1, &server.game_data.items) + .unwrap(); + + let _transaction = server.save.transaction_lock().await; + let id = server.ids.character.get_next_id().unwrap(); + server.names.add_character(id, "Rejected", 1007); + let mut creation = super::NewCharacter { + server: &server, + id, + created_items: Vec::new(), + committed: false, + }; + let inventory = Inventory::new(id, 50, 50, &server.items, &server.ids.container); + assert!(server.items.removed_items().is_empty()); + // Another owner's ItemTxn can queue/release an ID AFTER setup begins: the save lock + // excludes database snapshots, not these synchronous item mutations. + { + let _economy = server.systems.economy.ops_lock(); + let mut bag = unrelated.bag().lock().unwrap(); + let index = bag.items.iter().position(|i| i.id == deleted_id).unwrap(); + bag.items.remove(index); + server.items.release_id(deleted_id, &server.ids.item); + } + server.items.mark_for_db_deletion(0x0100_0099); + super::acquire_default_item_recorded( + &server, + inventory.bag(), + 2001, + 2, + 0, + &mut creation.created_items, + ) + .unwrap(); + assert_eq!( + creation.created_items, + vec![(deleted_id, true)], + "canceled deletion must be captured at allocation" + ); + assert_eq!(server.items.removed_items(), vec![0x0100_0099]); + drop(creation); + + let mut removed = server.items.removed_items(); + removed.sort_unstable(); + assert_eq!(removed, vec![deleted_id, 0x0100_0099]); + assert!(inventory.bag().lock().unwrap().items.is_empty()); + assert!(server.items.item_by_id(deleted_id).is_none()); + assert_eq!(server.items.item_by_id(survivor_id).unwrap().count, 5); + assert_eq!(server.items.prepare_save().item_ids(), vec![survivor_id]); + assert!(server + .items + .all_containers() + .iter() + .all(|c| c.lock().unwrap().owner_id == 99)); + assert!(!server.names.name_exists("Rejected")); + assert_eq!(server.ids.character.get_next_id().unwrap(), id); +} + +#[tokio::test] +#[ignore = "requires private MySQL3317 via AAEMU_TEST_MYSQL; uses only temporary tables"] +async fn private_mysql_new_character_later_item_failure_cleans_up_before_id_reuse() { + use crate::models::character::Inventory; + use crate::systems::social::achievement_persistence::temporary_shadow_definition; + use sqlx::mysql::{MySqlConnectOptions, MySqlPoolOptions}; + use std::str::FromStr; + + let Ok(url) = std::env::var("AAEMU_TEST_MYSQL") else { + return; + }; + let options = MySqlConnectOptions::from_str(&url).expect("valid private MySQL URL"); + assert_eq!( + options.get_port(), + 3317, + "only private MySQL3317 is allowed" + ); + assert!(matches!(options.get_host(), "127.0.0.1" | "localhost")); + let pool = MySqlPoolOptions::new() + .max_connections(1) + .connect_with(options) + .await + .unwrap(); + for table in [ + "items", + "item_containers", + "characters", + "options", + "abilities", + "actabilities", + "appellations", + "character_active_buffs", + "portal_book_coords", + "portal_visited_district", + "friends", + "blocked", + "skills", + "quests", + "completed_quests", + "accounts", + "character_records", + "character_achievements", + ] { + let (_, definition): (String, String) = + sqlx::query_as(&format!("SHOW CREATE TABLE `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + sqlx::query(&temporary_shadow_definition(&definition)) + .execute(&pool) + .await + .unwrap(); + } + sqlx::query("INSERT INTO accounts (account_id, labor) VALUES (1007, 1000)") + .execute(&pool) + .await + .unwrap(); + sqlx::query("SET SESSION sql_mode='STRICT_ALL_TABLES'") + .execute(&pool) + .await + .unwrap(); + // Equipment (count 1) is written first; a LATER starter item (count 300) fails. + sqlx::query("ALTER TABLE items MODIFY `count` TINYINT UNSIGNED NOT NULL") + .execute(&pool) + .await + .unwrap(); + let mut server = test_server_with(creation_data()); + server.db = pool.clone(); + let unrelated = Inventory::new(99, 50, 50, &server.items, &server.ids.container); + let item = server + .items + .create(2001, 4, 0, 1, &server.game_data.items, &server.ids.item, 0) + .unwrap(); + let unrelated_id = item.id; + unrelated + .bag() + .lock() + .unwrap() + .add_new_item(item, 0, &server.game_data.items) + .unwrap(); + let reused_deletion = u64::from(server.ids.item.get_next_id().unwrap()); + server.items.release_id(reused_deletion, &server.ids.item); + server.items.mark_for_db_deletion(0x0100_0099); + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + + create(&server, &mut client.conn, creation_request("Rejected")) + .await + .unwrap(); + assert!(client.conn.characters.is_empty()); + assert!(client + .drain_ops() + .contains(&crate::opcodes::sc::SCCharacterCreationFailedPacket)); + for table in [ + "characters", + "items", + "item_containers", + "abilities", + "skills", + ] { + let count: i64 = sqlx::query_scalar(&format!("SELECT COUNT(*) FROM `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(count, 0, "partial SQL rollback in {table}"); + } + assert!(!server.names.name_exists("Rejected")); + assert!( + server + .items + .all_containers() + .iter() + .all(|c| c.lock().unwrap().owner_id == 99), + "rejected inventory remains cached" + ); + assert_eq!(server.items.prepare_save().item_ids(), vec![unrelated_id]); + let mut removed = server.items.removed_items(); + removed.sort_unstable(); + assert_eq!(removed, vec![reused_deletion, 0x0100_0099]); + assert_eq!(server.items.item_by_id(unrelated_id).unwrap().count, 4); + + sqlx::query("ALTER TABLE items MODIFY `count` INT NOT NULL") + .execute(&pool) + .await + .unwrap(); + create(&server, &mut client.conn, creation_request("Accepted")) + .await + .unwrap(); + let c = &client.conn.characters[0]; + assert_eq!(c.id, 1, "failed character ID must be reused"); + let counts = |container: &crate::models::container::ContainerRef| { + let mut items: Vec<_> = container + .lock() + .unwrap() + .items + .iter() + .map(|i| (i.template_id, i.count)) + .collect(); + items.sort_unstable(); + items + }; + assert_eq!(counts(c.inventory.bag()), vec![(2001, 2), (2002, 300)]); + assert_eq!(counts(c.inventory.equipment()), vec![(2000, 1)]); + let rows: Vec<(u32, i32)> = + sqlx::query_as("SELECT template_id, `count` FROM items ORDER BY template_id") + .fetch_all(&pool) + .await + .unwrap(); + assert_eq!(rows, vec![(2000, 1), (2001, 2), (2002, 300)]); + assert!(server.items.prepare_save_for_owner(1).item_ids().is_empty()); + assert_eq!(server.items.prepare_save().item_ids(), vec![unrelated_id]); + assert_eq!(server.items.removed_items(), vec![0x0100_0099]); + // The next item save cannot resurrect the rejected character's inventory. + let mut tx = pool.begin().await.unwrap(); + server.items.save(&mut tx).await.unwrap(); + tx.commit().await.unwrap(); + server.items.commit_save(); + let total: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM items") + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(total, 4); + assert_eq!(counts(unrelated.bag()), vec![(2001, 4)]); + pool.close().await; +} + #[test] fn constructor_does_not_call_deps() { let manager = CharacterData::default(); diff --git a/rust/crates/aaemu-game/src/managers/item.rs b/rust/crates/aaemu-game/src/managers/item.rs index e0aae87bb4..5647b7c7b3 100644 --- a/rust/crates/aaemu-game/src/managers/item.rs +++ b/rust/crates/aaemu-game/src/managers/item.rs @@ -162,6 +162,46 @@ impl ItemManager { c } + /// Discard a rejected creation while the caller holds the save transaction lock, before + /// releasing its character ID. These rows never committed: do not queue SQL deletions or + /// acknowledge another owner's pending changes. + pub(crate) fn discard_new_character( + &self, + owner_id: u32, + created_items: &[(u64, bool)], + item_ids: &IdManager, + container_ids: &IdManager, + ) { + let _create = lock(&self.create_lock); + let rejected: Vec<_> = self + .all_containers() + .into_iter() + .filter(|c| c.lock().expect("container poisoned").owner_id == owner_id) + .collect(); + lock(&self.containers).retain(|c| !rejected.iter().any(|r| Arc::ptr_eq(c, r))); + if let Some(batch) = lock(&self.pending_save).as_mut() { + batch.containers.retain(|(_, row)| row.owner_id != owner_id); + batch.items.retain(|(container, _, _)| { + !container + .as_ref() + .is_some_and(|c| rejected.iter().any(|r| Arc::ptr_eq(c, r))) + }); + } + for container in rejected { + let mut c = container.lock().expect("container poisoned"); + c.items.clear(); + container_ids.release_id(c.container_id as u32); + } + for &(id, canceled_deletion) in created_items { + // Captured at allocation: another owner can queue/release an ID during setup. + // Restore its canceled deletion before freeing the ID for another operation. + if canceled_deletion { + self.mark_for_db_deletion(id); + } + item_ids.release_id(id as u32); + } + } + /// `NewCofferContainer(characterId)`. pub fn new_coffer_container( &self, @@ -207,6 +247,10 @@ impl ItemManager { /// `GetNewId` (+ removal from the deleted-items list). pub fn new_id(&self, item_ids: &IdManager) -> Option { + self.new_id_with_deletion(item_ids).map(|(id, _)| id) + } + + fn new_id_with_deletion(&self, item_ids: &IdManager) -> Option<(u64, bool)> { let id = match item_ids.get_next_id() { Ok(id) => u64::from(id), Err(e) => { @@ -214,8 +258,10 @@ impl ItemManager { return None; } }; - lock(&self.removed).retain(|&r| r != id); - Some(id) + let mut removed = lock(&self.removed); + let before = removed.len(); + removed.retain(|&r| r != id); + Some((id, before != removed.len())) } /// `ItemManager.Create(templateId, count, grade)`. The item is not placed in a container. @@ -230,8 +276,26 @@ impl ItemManager { item_ids: &IdManager, now: i64, ) -> Option { + self.create_with_deletion(template_id, count, grade, world_id, data, item_ids, now) + .map(|(item, _)| item) + } + + /// Creation rollback needs the deletion canceled by THIS allocation, rather than a + /// snapshot taken before other owners could release more IDs. Ordinary creation ignores + /// the receipt and retains the existing new_id semantics. + #[allow(clippy::too_many_arguments)] + pub(crate) fn create_with_deletion( + &self, + template_id: u32, + count: i32, + grade: u8, + world_id: u8, + data: &ItemData, + item_ids: &IdManager, + now: i64, + ) -> Option<(Item, bool)> { let template = data.template(template_id)?; - let id = self.new_id(item_ids)?; + let (id, canceled_deletion) = self.new_id_with_deletion(item_ids)?; let treasure = if template.class_type() == ItemClass::TreasureMap { self.treasure_maps .get() @@ -239,8 +303,9 @@ impl ItemManager { } else { None }; - Some(Item::create_ex( - id, template, count, grade, world_id, data, now, treasure, + Some(( + Item::create_ex(id, template, count, grade, world_id, data, now, treasure), + canceled_deletion, )) } diff --git a/rust/crates/aaemu-testclient/src/scenario.rs b/rust/crates/aaemu-testclient/src/scenario.rs index 83ad156269..71c7ae029e 100644 --- a/rust/crates/aaemu-testclient/src/scenario.rs +++ b/rust/crates/aaemu-testclient/src/scenario.rs @@ -119,6 +119,9 @@ pub struct BotConfig { pub password: String, /// Character name used when the account has none. pub character: String, + /// Require creation of `character`, even if the account already has other characters. + #[serde(default)] + pub create_new_character: bool, #[serde(default = "default_gs")] pub game_server_id: u8, /// Skill cast on the nearest NPC (2 = melee attack). @@ -405,6 +408,48 @@ async fn finish( const QUIET: Duration = Duration::from_millis(1500); +fn character_to_select<'a>( + characters: &'a [crate::game::CharInfo], + requested: &str, + created: bool, +) -> anyhow::Result<&'a crate::game::CharInfo> { + if created { + characters + .iter() + .find(|c| c.name.eq_ignore_ascii_case(requested)) + } else { + characters.first() + } + .with_context(|| format!("no character returned for {requested} (created={created})")) +} + +#[cfg(test)] +mod creation_tests { + use super::character_to_select; + use crate::game::CharInfo; + + #[test] + fn fresh_creation_selects_the_new_character_and_never_falls_back_to_existing() { + let mut characters = vec![CharInfo { + id: 1, + name: "Existing".into(), + }]; + assert!(character_to_select(&characters, "Fresh", true).is_err()); + characters.push(CharInfo { + id: 2, + name: "Fresh".into(), + }); + assert_eq!( + character_to_select(&characters, "fresh", true).unwrap().id, + 2 + ); + assert_eq!( + character_to_select(&characters, "Fresh", false).unwrap().id, + 1 + ); + } +} + async fn run_inner( kind: Kind, cfg: &BotConfig, @@ -504,7 +549,7 @@ async fn run_inner( r.end(s, format!("{} character(s)", game.state.characters.len())); let s = r.begin("game.create"); - let created = if game.state.characters.is_empty() { + let created = if cfg.create_new_character || game.state.characters.is_empty() { game.create_character(&cfg.character).await?; let p = game .wait_for("character creation result", |p| { @@ -519,7 +564,7 @@ async fn run_inner( } else { false }; - let ch = game.state.characters[0].clone(); + let ch = character_to_select(&game.state.characters, &cfg.character, created)?.clone(); r.var("char_id", ch.id); r.end( s, diff --git a/rust/crates/aaemu-testclient/src/verify.rs b/rust/crates/aaemu-testclient/src/verify.rs index 4db6f2fbd1..e633d84b64 100644 --- a/rust/crates/aaemu-testclient/src/verify.rs +++ b/rust/crates/aaemu-testclient/src/verify.rs @@ -6,7 +6,7 @@ //! ```text //! # comments //! suite # optional, defaults to the file stem -//! bot [gm] # one per bot; `gm` is provisioned by Scripts/verify.sh +//! bot [gm] [fresh] # `gm` is provisioned by Scripts/verify.sh //! //! [] //!