From 1118f492174d4662604b058aba390367610bcf54 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:23:53 -0400 Subject: [PATCH 01/66] docs: track complete October missing-feature repair scope --- rust/docs/audit-repair-status.json | 87 ++++++++++++++++++++++++++++++ 1 file changed, 87 insertions(+) create mode 100644 rust/docs/audit-repair-status.json diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json new file mode 100644 index 0000000000..767fb74be8 --- /dev/null +++ b/rust/docs/audit-repair-status.json @@ -0,0 +1,87 @@ +{ + "audit": "2026-10-25 missing-feature audit", + "baseline": "37e6f1aec", + "status": "in_progress", + "policy": "A finding closes only with source evidence and appropriate validation; missing native/content evidence stays explicit.", + "sources": ["protocol-and-logs", "opcode-table-gaps", "items-economy", "skills-combat-ai", "quests-social-progression", "housing-doodads", "vehicles-pvp-instances", "character-account-world"], + "items": [ + {"id":"mail-return", "status":"implementing", "owner":"audit-protocol"}, + {"id":"loot-error-width", "status":"implementing", "owner":"audit-protocol"}, + {"id":"merchant-grade", "status":"implementing", "owner":"audit-economy"}, + {"id":"craft-grade-flags", "status":"implementing", "owner":"audit-economy"}, + {"id":"web-api-authentication", "status":"implementing", "owner":"audit-web"}, + {"id":"housing-bench-plaque-permissions", "status":"queued"}, + {"id":"craft-bench-pack-and-required-doodad", "status":"queued"}, + {"id":"closed-and-unknown-zones", "status":"queued"}, + {"id":"national-tax-rate", "status":"queued"}, + {"id":"vehicle-attachment-data", "status":"queued"}, + {"id":"ordinary-warning-noise-and-cleanup-cause", "status":"queued"}, + {"id":"slave-owned-doodad-housing-lookup", "status":"queued"}, + {"id":"aoe-diminishing", "status":"queued"}, + {"id":"skill-and-buff-modifiers", "status":"queued"}, + {"id":"buff-group-rank-and-per-caster-slots", "status":"queued"}, + {"id":"reflection", "status":"queued"}, + {"id":"attack-speed", "status":"queued"}, + {"id":"buff-breakers", "status":"queued"}, + {"id":"buff-taunts", "status":"queued"}, + {"id":"casting-hit-delay-and-cancellation", "status":"queued"}, + {"id":"item-procs-and-set-procs", "status":"queued"}, + {"id":"shared-cooldown-tags", "status":"queued"}, + {"id":"xp-buff-multiplier", "status":"queued"}, + {"id":"zone-banned-item-and-skill-tags", "status":"queued"}, + {"id":"unit-and-primary-stat-limits", "status":"queued"}, + {"id":"prison-and-other-skill-restrictions", "status":"queued"}, + {"id":"damage-threat-percent-health-and-level-interpolation", "status":"queued"}, + {"id":"recipe-learning", "status":"queued"}, + {"id":"npc-groups", "status":"queued"}, + {"id":"npc-linked-aggro-and-missing-ai", "status":"queued"}, + {"id":"npc-alert-dead-events-and-friendship", "status":"queued"}, + {"id":"remaining-buff-attributes-and-controller-kinds", "status":"queued"}, + {"id":"stealth-visibility", "status":"queued"}, + {"id":"trade-pack-pricing-config-ratios-and-persistence", "status":"queued"}, + {"id":"premium-and-aa-points", "status":"queued"}, + {"id":"second-password-and-item-security", "status":"queued"}, + {"id":"item-level-gender-pickup-and-use-limits", "status":"queued"}, + {"id":"tempering-and-socket-data-rules", "status":"queued"}, + {"id":"craft-binding-and-required-grade", "status":"queued"}, + {"id":"mail-expiry-throttling-feedback-and-pagination", "status":"queued"}, + {"id":"npc-physical-enchant", "status":"queued"}, + {"id":"auction-filter-limits-and-authority", "status":"queued"}, + {"id":"missing-item-and-quest-feedback-packets", "status":"queued"}, + {"id":"quest-spawn-coverage", "status":"queued"}, + {"id":"nation-and-faction-flows", "status":"queued"}, + {"id":"bounty-board", "status":"queued"}, + {"id":"achievement-producers", "status":"queued"}, + {"id":"quest-and-skill-unit-requirements", "status":"queued"}, + {"id":"trial-jury-expedition-rename-and-quest-edge-fields", "status":"queued"}, + {"id":"doodad-phase-messages", "status":"queued"}, + {"id":"territory-statue-insert-counter", "status":"queued"}, + {"id":"navigation-doodad-expiry", "status":"queued"}, + {"id":"crest-printer-and-ucc", "status":"queued"}, + {"id":"house-repair-and-farm-notifications", "status":"queued"}, + {"id":"doodad-area-trigger-and-evidence-loot", "status":"queued"}, + {"id":"remaining-gathering-funcs", "status":"queued"}, + {"id":"puzzle-machines", "status":"queued"}, + {"id":"doodad-placement-surface-and-bundle-rules", "status":"queued"}, + {"id":"battle-pet-behavior-and-equipment", "status":"queued"}, + {"id":"movement-validation", "status":"queued"}, + {"id":"ship-handling-data", "status":"queued"}, + {"id":"shipyard-salvage", "status":"queued"}, + {"id":"instance-spawn-data", "status":"queued"}, + {"id":"instance-channel-and-client-driven-entry", "status":"queued"}, + {"id":"arena-restrictions-and-mirrored-instance-bugs", "status":"queued"}, + {"id":"siege-calendar-tickets-reinforcement-and-notifications", "status":"queued"}, + {"id":"racing", "status":"queued"}, + {"id":"remaining-geometry-and-physics-data", "status":"queued"}, + {"id":"cooldown-persistence", "status":"queued"}, + {"id":"disconnect-duplicate-login-and-dead-relogin", "status":"queued"}, + {"id":"resurrection-waits-and-server-enforcement", "status":"queued"}, + {"id":"name-chat-filtering-throttle-and-moderation", "status":"queued"}, + {"id":"character-recustomization", "status":"queued"}, + {"id":"character-slots-races-and-deletion-guards", "status":"queued"}, + {"id":"event-schedule-notifications", "status":"queued"}, + {"id":"login-capacity-and-auth-rate-limits", "status":"queued"}, + {"id":"missing-buff-and-skill-controller-static-data", "status":"queued"}, + {"id":"deprecated-empty-or-client-only-data", "status":"queued", "note":"Verify before deciding no server implementation is required."} + ] +} From 305664ae23d7a552f5a6db90677cabec52fe9b3c Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:26:51 -0400 Subject: [PATCH 02/66] fix(protocol): repair native mail return and loot failure layouts Dispatch native 1.2 mailbox returns on 0xa3 using the preserved legacy ReportSpam constant, remove the competing no-op handler, and write the loot failure error as i16. Add literal native packet fixtures and a GameServer frame flow covering recipient authorization, return, attachments and repeat refusal. Preserve the historical C# fixture with an explicit native correction in its comparison test. Validation: cargo fmt --all --check and git diff --check passed. Cargo tests and Clippy are intentionally pending parent validation; no Cargo target was populated. Co-Authored-By: Codex --- rust/crates/aaemu-game/PORTING.md | 8 ++ rust/crates/aaemu-game/src/packets/mod.rs | 13 ++- .../src/systems/economy/econ_data_tests.rs | 27 +++--- .../src/systems/economy/loot_packets.rs | 48 +++++++--- .../src/systems/economy/mail_packets.rs | 9 +- .../src/systems/economy/mail_tests.rs | 93 +++++++++++++++++++ .../src/systems/social/packets/misc.rs | 16 ---- 7 files changed, 161 insertions(+), 53 deletions(-) diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 7affb528bd..c95bddcecd 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -903,6 +903,14 @@ is no longer mirrored (see "Known deviations", dead NPC returned and healed). `CSBuySpecialtyItemPacket`, `CSReturnMailPacket` have no 1.2 opcode (0xfff): decoders exist, the 1.2 client never sends them. The specialty / trade-pack mail delay use the C# defaults (no `Specialty` config section yet). +* systems::economy (native 1.2 protocol, 2026-10-25): correction to the preceding ReturnMail + claim: the Return button (`read_mail.lua:946`) calls `ReturnMailById` (`3948B630` -> + `393CD290`), which sends opcode `0xa3` with an i64 mail id (`397BA450`). The preserved + opcode table misnames that slot `CSReportSpamPacket`; economy now registers ReturnMail + using that legacy constant, and social no longer claims it. The historical C# registry + fixture stays intact with an explicit native correction in its comparison test. Native + `SCLootItemFailedPacket` reader `397C2F00` consumes `ErrorMessage:i16`, an eight-byte + lootable and `type:u32` (14 bytes); the C# int error width is no longer mirrored. * systems::economy: the localized item names are loaded by four modules (items search, auction, mail, cash shop); a later cleanup can share one cache. * systems::services: authenticated `CSRequestCharBriefPacket` and `CSCharDetailPacket` requests diff --git a/rust/crates/aaemu-game/src/packets/mod.rs b/rust/crates/aaemu-game/src/packets/mod.rs index a7422f6953..705296f599 100644 --- a/rust/crates/aaemu-game/src/packets/mod.rs +++ b/rust/crates/aaemu-game/src/packets/mod.rs @@ -92,8 +92,8 @@ mod tests { } /// Every `RegisterPacket` call of the C# `GameNetwork()` constructor is registered in Rust - /// under the same (level, opcode) with the same packet class name, and Rust registers - /// nothing the C# does not. The C# table is a checked-in snapshot + /// under the same (level, opcode) with the same packet class name, except for documented + /// native 1.2 corrections. The C# table is a checked-in historical snapshot /// (`tests/fixtures/csharp_game_network_registry.tsv`) taken while the C# sources existed. #[test] fn registry_matches_csharp_game_network() { @@ -111,6 +111,13 @@ mod tests { let name = cols.next().unwrap().to_string(); expected.insert((level, opcode), name); } + // Native 1.2 ReturnMailById (3948B630 -> 393CD290, serializer 397BA450) + // sends 0xa3. C# called that slot ReportSpam and stranded ReturnMail on 0xfff. + // Preserve the historical fixture while checking the corrected live dispatch. + assert_eq!( + expected.insert((1, 0x0a3), "CSReturnMailPacket".into()), + Some("CSReportSpamPacket".into()) + ); assert!( expected.len() > 250, "parsed only {} registrations", @@ -131,8 +138,6 @@ mod tests { } } for ((level, opcode), reg) in r.iter() { - // `CSReturnMailPacket` is commented out in C# (opcode 0xfff, never sent by 1.2): - // registering it is harmless. // `CSTakeScheduleItemPacket` is a 1.2 client packet the C# never registered // (`systems::npcs::schedule_item_packets`, opcode read off the client). // `CSRankSnapshotPacket` (0x130), `CSRequestSetBountyMoneyPacket` (0x11f), diff --git a/rust/crates/aaemu-game/src/systems/economy/econ_data_tests.rs b/rust/crates/aaemu-game/src/systems/economy/econ_data_tests.rs index e82a2aebef..cd3df90e05 100644 --- a/rust/crates/aaemu-game/src/systems/economy/econ_data_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/econ_data_tests.rs @@ -383,16 +383,14 @@ async fn taking_loot_from_far_away_is_refused() { .write_u16(0) .write_u16(0); run::(&mut w, 0, s.as_bytes()); - let refused = SCLootItemFailedPacket { - error_message: super::error_message::TOO_FAR_AWAY, - loot_owner_type: 1, - loot_owner_obj_id: NPC_OBJ, - item_index: 1, - item_template_id: super::tests::STACK, - }; + // Native 1.2 reader 397C2F00: i16 error, u64 lootable, u32 item template. + // TOO_FAR_AWAY=154, index=1, NPC=1/0x200, STACK=1000; exactly 14 bytes. assert_eq!( w.a.drain(), - vec![(sc::SCLootItemFailedPacket, body(&refused))], + vec![( + sc::SCLootItemFailedPacket, + vec![0x9a, 0, 1, 0, 1, 0, 0, 2, 0, 0, 0xe8, 3, 0, 0] + )], "the out-of-range take must be refused with TOO_FAR_AWAY" ); assert_eq!( @@ -461,16 +459,13 @@ async fn full_bag_fails_and_restores_the_entry() { assert!(!LootManager::try_take_loot( &w.server, &w.pa, NPC_OBJ, 1, false )); - let failed = SCLootItemFailedPacket { - error_message: super::error_message::BAG_FULL, - loot_owner_type: 1, - loot_owner_obj_id: NPC_OBJ, - item_index: 1, - item_template_id: super::tests::STACK, - }; + // Native 1.2 reader 397C2F00: BAG_FULL=25, then the same lootable and template. assert_eq!( w.a.drain(), - vec![(sc::SCLootItemFailedPacket, body(&failed))] + vec![( + sc::SCLootItemFailedPacket, + vec![25, 0, 1, 0, 1, 0, 0, 2, 0, 0, 0xe8, 3, 0, 0] + )] ); assert_eq!(w.server.systems.economy.loot.item_count(NPC_OBJ), 3); } diff --git a/rust/crates/aaemu-game/src/systems/economy/loot_packets.rs b/rust/crates/aaemu-game/src/systems/economy/loot_packets.rs index 3a2f619caa..6fa6be33e9 100644 --- a/rust/crates/aaemu-game/src/systems/economy/loot_packets.rs +++ b/rust/crates/aaemu-game/src/systems/economy/loot_packets.rs @@ -120,7 +120,7 @@ impl Marshal for SCLootItemTookPacket { /// itemTemplateId)`. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct SCLootItemFailedPacket { - /// `ErrorMessageType` (written as an `int`). + /// Native 1.2 `ErrorMessage` is i16 (reader 397C2F00), unlike the C# int. pub error_message: i16, pub loot_owner_type: u16, pub loot_owner_obj_id: u32, @@ -134,7 +134,7 @@ packet_def!( ); impl Marshal for SCLootItemFailedPacket { fn write(&self, s: &mut PacketStream) { - s.write_i32(i32::from(self.error_message)) + s.write_i16(self.error_message) .write_u16(self.item_index) .write_u16(self.loot_owner_type) .write_bc(self.loot_owner_obj_id) @@ -298,7 +298,7 @@ mod tests { } #[test] - fn took_failed_state_packets_are_byte_exact() { + fn took_and_state_packets_are_byte_exact() { let took = SCLootItemTookPacket { item_template_id: 0x0102_0304, item_index: 2, @@ -310,17 +310,6 @@ mod tests { body(&took), vec![4, 3, 2, 1, 2, 0, 1, 0, 0xef, 0xcd, 0xab, 0, 5, 0, 0, 0] ); - let failed = SCLootItemFailedPacket { - error_message: 25, - loot_owner_type: 1, - loot_owner_obj_id: 0x10, - item_index: 3, - item_template_id: 9, - }; - assert_eq!( - body(&failed), - vec![25, 0, 0, 0, 3, 0, 1, 0, 0x10, 0, 0, 0, 9, 0, 0, 0] - ); let st = SCLootableStatePacket { loot_owner_type: 1, loot_owner_obj_id: 0x020304, @@ -334,6 +323,37 @@ mod tests { assert_eq!(body(&ls), vec![7, 0, 0, 2]); } + #[test] + fn loot_item_failed_matches_native_1_2_i16_error_and_14_byte_body() { + // Native 1.2 x2game12.c, reader 397C2F00 (SC 0xfa): ErrorMessage:i16, + // lootable:u64 (index:u16, owner:u16, object:bc, padding:u8), type:u32. + // Distinct nonzero fields expose any shift; the negative error pins signed width. + for (error_message, expected) in [ + ( + 25, + [ + 0x19, 0, 0x34, 0x12, 0x78, 0x56, 0xde, 0xbc, 0x9a, 0, 0x78, 0x56, 0x34, 0x12, + ], + ), + ( + -257, + [ + 0xff, 0xfe, 0x34, 0x12, 0x78, 0x56, 0xde, 0xbc, 0x9a, 0, 0x78, 0x56, 0x34, 0x12, + ], + ), + ] { + let actual = body(&SCLootItemFailedPacket { + error_message, + item_index: 0x1234, + loot_owner_type: 0x5678, + loot_owner_obj_id: 0x009a_bcde, + item_template_id: 0x1234_5678, + }); + assert_eq!(actual.len(), 14); + assert_eq!(actual, expected); + } + } + #[test] fn dice_packets_are_byte_exact() { let i = item(); diff --git a/rust/crates/aaemu-game/src/systems/economy/mail_packets.rs b/rust/crates/aaemu-game/src/systems/economy/mail_packets.rs index 48bf5e2fca..3bbe920871 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail_packets.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail_packets.rs @@ -1,7 +1,7 @@ //! The mail packets. C->S: `CSSendMailPacket`, `CSListMailPacket`, `CSListMailContinuePacket`, //! `CSReadMailPacket`, `CSTakeAttachmentItemPacket`, `CSTakeAttachmentMoneyPacket`, //! `CSTakeAttachmentSequentially`, `CSTakeAllAttachmentItemPacket`, `CSPayChargeMoneyPacket`, -//! `CSDeleteMailPacket`, `CSReturnMailPacket` (0xfff in 1.2: never sent by the client). +//! `CSDeleteMailPacket`, `CSReturnMailPacket` (native 1.2 opcode 0x0a3). //! S->C: `SCMailFailedPacket`, `SCMailSentPacket`, `SCGotMailPacket`, `SCMailListPacket`, //! `SCMailListEndPacket`, `SCMailBodyPacket`, `SCMailReceiverOpenedPacket`, //! `SCAttachmentTakenPacket`, `SCChargeMoneyPaidPacket`, `SCMailDeletedPacket`, @@ -39,7 +39,10 @@ pub fn register(reg: &mut PacketRegistry) { reg.register::(LEVEL_PLAIN, cs::CSTakeAttachmentSequentially); reg.register::(LEVEL_PLAIN, cs::CSPayChargeMoneyPacket); reg.register::(LEVEL_PLAIN, cs::CSDeleteMailPacket); - reg.register::(LEVEL_PLAIN, cs::CSReturnMailPacket); + // Native 1.2 ReturnMailById (3948B630 -> 393CD290) sends 0xa3, historically + // mislabeled CSReportSpamPacket in the preserved C# opcode table. The 1.2 + // ReportSpam binding (3948B310) sends nothing; CSReturnMailPacket is 0xfff there. + reg.register::(LEVEL_PLAIN, cs::CSReportSpamPacket); reg.register::(LEVEL_PLAIN, cs::CSTakeAllAttachmentItemPacket); } @@ -719,7 +722,7 @@ impl CSDeleteMailPacket { } sync_client_packet!(CSDeleteMailPacket); -/// `CSReturnMailPacket` (opcode 0xfff: not in the 1.2 offsets). +/// Native 1.2 `ReturnMailById`: opcode 0xa3, mail id i64 (serializer 397BA450). #[derive(Debug, Clone, PartialEq, Eq)] pub struct CSReturnMailPacket { pub mail_id: i64, diff --git a/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs b/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs index e1c32f802c..353236de7c 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs @@ -439,6 +439,20 @@ fn client_packets_decode() { let _: CSListMailContinuePacket = read(Vec::new()); } +#[test] +fn native_return_mail_request_decodes_i64() { + // Native 1.2 x2game12.c: ReturnMailById (3948B630) -> 393CD290, opcode 0xa3; + // serializer 397BA450 writes the mail id as a single i64 (archive slot +72). + let mut s = PacketStream::from_bytes(vec![8, 7, 6, 5, 4, 3, 2, 1]); + assert_eq!( + CSReturnMailPacket::read(&mut s).unwrap().mail_id, + 0x0102_0304_0506_0708 + ); + assert!(s.unread().is_empty()); + let mut truncated = PacketStream::from_bytes(vec![8, 7, 6, 5, 4, 3, 2]); + assert!(CSReturnMailPacket::read(&mut truncated).is_err()); +} + #[test] fn dotnet_dict_reuses_freed_slots_lifo() { let mut d = DotNetDict::default(); @@ -2549,3 +2563,82 @@ async fn return_preserves_zero_one_and_ten_attachments_without_charging_a_fee() } } } + +#[tokio::test] +async fn native_return_mail_frame_checks_recipient_and_returns_attachments() { + let mut w = mail_world(); + w.pa.data().money = 1000; + let item = give(&w, &w.pa, slot_type::INVENTORY, SINGLE, 1, 0); + assert_eq!( + send_p2p( + &w, + mail_type::EXPRESS, + "Bob", + 50, + &[(slot_type::INVENTORY, 0)], + ), + mail_result::SUCCESS + ); + let id = bob_mail_ids(&w.server)[0]; + let original = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert!(original.is_delivered && original.can_return_mail()); + let original_item = w.server.items.item_by_id(item).unwrap(); + let alice_money = w.pa.data().money; + let bob_money = w.pb.data().money; + assert_eq!(w.pb.data().unread_mail.received, 1); + w.a.drain(); + w.b.drain(); + + // The 1.2 UI's read_mail.lua:946 ReturnMailById -> native 393CD290 builds 0xa3, + // NOT the historical CSReturnMailPacket placeholder 0xfff. Keep the opcode literal + // and spell out the frame rather than using the server's registration/encoder. + let mut frame = vec![0xdd, 1, 0, 0, 0xa3, 0]; + frame.extend_from_slice(&id.to_le_bytes()); + + // The original sender knows the id, but only the current recipient may return it. + w.server.handle_frame(&mut w.a.conn, &frame).await.unwrap(); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + original + ); + assert_eq!(w.server.items.item_by_id(item).unwrap(), original_item); + assert!(w.a.drain().is_empty()); + assert!(w.b.drain().is_empty()); + assert_eq!(w.pb.data().unread_mail.received, 1); + + w.server.handle_frame(&mut w.b.conn, &frame).await.unwrap(); + let returned = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert_eq!(w.server.systems.economy.mail.count(), 1); + assert_eq!(returned.header.receiver_id, 1); + assert_eq!(returned.receiver_name, "Alice"); + assert_eq!(returned.header.sender_id, 2); + assert_eq!(returned.header.sender_name, "Bob"); + assert!(returned.header.returned && returned.is_delivered); + assert_eq!(returned.body.attachments, vec![item]); + assert_eq!(returned.body.copper_coins, 50); + assert_eq!(returned.body.text, original.body.text); + let returned_item = w.server.items.item_by_id(item).unwrap(); + assert_eq!(returned_item.owner_id, 1); + assert_eq!(returned_item.slot_type, slot_type::MAIL); + assert_eq!(returned_item.template_id, original_item.template_id); + assert_eq!(w.pa.data().money, alice_money); + assert_eq!(w.pb.data().money, bob_money); + assert_eq!(w.pb.data().unread_mail.received, 0); + assert_eq!(w.pa.data().unread_mail.received, 1); + let replies = w.b.drain(); + assert_eq!( + ops(&replies), + vec![sc::SCMailReturnedPacket, sc::SCCountUnreadMailPacket] + ); + assert_eq!(&replies[0].1[..8], &id.to_le_bytes()); + assert_eq!(w.a.drain_ops(), vec![sc::SCGotMailPacket]); + + // Even the new recipient cannot return a letter that was already returned. + w.server.handle_frame(&mut w.a.conn, &frame).await.unwrap(); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + returned + ); + assert!(w.a.drain().is_empty()); + assert!(w.b.drain().is_empty()); +} diff --git a/rust/crates/aaemu-game/src/systems/social/packets/misc.rs b/rust/crates/aaemu-game/src/systems/social/packets/misc.rs index 918f3ee34a..3f69cf3f5c 100644 --- a/rust/crates/aaemu-game/src/systems/social/packets/misc.rs +++ b/rust/crates/aaemu-game/src/systems/social/packets/misc.rs @@ -239,16 +239,6 @@ sc_packet!( } ); -cs_packet!( - /// `CSReportSpamPacket` (logged only, as in C#). - CSReportSpamPacket { mail_id: i64 } - read |s| { Ok(Self { mail_id: s.read_i64()? }) } - handle |self, server, conn| { - tracing::debug!("ReportSpam, mailId: {}", self.mail_id); - Ok(()) - } -); - // ---- Achievements (no achievement manager in the 1.2 C#; the Rust manager sends all of these // except `SCAchievementResetedPacket`) ---- @@ -317,7 +307,6 @@ impl SCAchievementResetedPacket { pub fn register(reg: &mut PacketRegistry) { reg.register::(LEVEL_PLAIN, cs::CSUpdateDominionTaxRatePacket); - reg.register::(LEVEL_PLAIN, cs::CSReportSpamPacket); } #[cfg(test)] @@ -714,10 +703,5 @@ mod tests { tax_rate: 10 } ); - let mut s = PacketStream::from_bytes((-5i64).to_le_bytes().to_vec()); - assert_eq!( - CSReportSpamPacket::read(&mut s).unwrap(), - CSReportSpamPacket { mail_id: -5 } - ); } } From 3de467a85f1c5aeed2efb2071030058ffeb8b29c Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:29:53 -0400 Subject: [PATCH 03/66] fix(economy): honor merchant grades and parse craft text flags Keep catalog item/grade variants, validate the native 1.2 normalized purchase grade, and acquire only matching-grade stacks. Preserve configured prices and fixed-grade rules. Read use_grade/main_grade as SQLite text flags while retaining the existing craft inheritance and free-regrade behavior. Add NPC purchase/inventory regressions for gold, honor, grades, fixed/basic templates and rollback; load real SQLite t/f flags and craft the loaded recipes. Formatting and diff checks pass. Compilation, focused tests and Clippy are explicitly pending parent validation in audit-final; no lane Cargo target was populated. Co-Authored-By: Codex --- .../src/systems/economy/craft_data.rs | 6 +- .../src/systems/economy/craft_store_tests.rs | 281 +++++++++++++++++- .../aaemu-game/src/systems/economy/hooks.rs | 10 +- .../aaemu-game/src/systems/economy/store.rs | 10 +- .../aaemu-game/src/systems/npcs/bridges.rs | 7 +- .../aaemu-game/src/systems/npcs/npc/data.rs | 90 +++++- 6 files changed, 383 insertions(+), 21 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/economy/craft_data.rs b/rust/crates/aaemu-game/src/systems/economy/craft_data.rs index a8c0a9981c..95674760ac 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft_data.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft_data.rs @@ -120,7 +120,8 @@ impl CraftData { amount: r.i32_or("amount", 1)?, // We always want to produce at least 1 item ? rate: r.i32("rate")?, show_lower_crafts: r.bool("show_lower_crafts")?, - use_grade: r.bool("use_grade")?, + // Native 1.2 LoadCraftProductDescs (0x3982E6C0) reads text 't' / '1'. + use_grade: r.bool_str("use_grade")?, item_grade_id: r.u32("item_grade_id")?, }); Ok(()) @@ -135,7 +136,8 @@ impl CraftData { craft_id, item_id: r.u32("item_id")?, amount: r.i32_or("amount", 1)?, // We always want to cost at least 1 item ? - main_grade: r.bool("main_grade")?, + // Native 1.2 LoadCraftMaterialDescs (0x3982E4D0) reads text 't' / '1'. + main_grade: r.bool_str("main_grade")?, }); Ok(()) })?; diff --git a/rust/crates/aaemu-game/src/systems/economy/craft_store_tests.rs b/rust/crates/aaemu-game/src/systems/economy/craft_store_tests.rs index 2b384955c4..03f39fc94c 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft_store_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft_store_tests.rs @@ -16,7 +16,9 @@ use crate::opcodes::sc; use crate::packets::world::SCErrorMsgPacket; use crate::server::GameServer; use crate::systems::economy::craft::{self, CSExecuteCraft, CraftHooks, SCCraftFailedPacket}; -use crate::systems::economy::craft_data::{Craft, CraftMaterial, CraftProduct, CraftSkill}; +use crate::systems::economy::craft_data::{ + Craft, CraftData, CraftMaterial, CraftProduct, CraftSkill, +}; use crate::systems::economy::hooks::{NpcEconomyHooks, NpcShopInfo}; use crate::systems::economy::inventory::Inv; use crate::systems::economy::item_packets::{ @@ -570,6 +572,123 @@ fn execute_craft(w: &mut World, craft_id: u32, count: i32) { run::(w, 0, s.as_bytes()); } +fn load_craft_sql(rows: &str) -> CraftData { + let conn = rusqlite::Connection::open_in_memory().unwrap(); + conn.execute_batch( + "CREATE TABLE crafts (id, cast_delay, tool_id, skill_id, wi_id, milestone_id, + req_doodad_id, need_bind, ac_id, actability_limit, show_upper_crafts, + recommend_level, visible_order); + INSERT INTO crafts VALUES (1, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0); + CREATE TABLE craft_products (id, craft_id, item_id, amount, rate, + show_lower_crafts, use_grade, item_grade_id); + CREATE TABLE craft_materials (id, craft_id, item_id, amount, main_grade); + CREATE TABLE craft_pack_crafts (craft_id); + CREATE TABLE skills (id, consume_lp, actability_group_id, cooldown_time); + INSERT INTO skills VALUES (10, 5, 0, 0);", + ) + .unwrap(); + conn.execute_batch(rows).unwrap(); + let files = + crate::data::client_files::ClientFileManager::from_sources(&[], std::path::Path::new(".")); + CraftData::load(&crate::systems::DataLoadCtx { + conn: &conn, + app_path: std::path::Path::new("."), + files: &files, + language: "en_us", + }) + .unwrap() +} + +#[test] +fn craft_grade_flags_load_sqlite_text() { + // Native 1.2 LoadCraftProductDescs / LoadCraftMaterialDescs (0x3982E6C0 / 0x3982E4D0) + // read the text flags, not sqlite3_column_int('t') == 0. + let d = load_craft_sql( + "INSERT INTO craft_products VALUES + (1, 1, 5000, 1, 100, 'f', 't', 3), + (2, 1, 5000, 1, 100, 'f', 'f', 0), + (3, 1, 5000, 1, 100, 'f', 1, 2), + (4, 1, 5000, 1, 100, 'f', 0, 0), + (5, 1, 5000, 1, 100, 'f', NULL, 0); + INSERT INTO craft_materials VALUES + (1, 1, 1000, 1, 'f'), (2, 1, 7000, 1, 't'), + (3, 1, 1000, 1, 0), (4, 1, 7000, 1, 1), (5, 1, 1000, 1, NULL);", + ); + let c = d.craft(CRAFT).unwrap(); + assert_eq!( + c.craft_products + .iter() + .map(|p| (p.use_grade, p.item_grade_id)) + .collect::>(), + vec![(true, 3), (false, 0), (true, 2), (false, 0), (false, 0)] + ); + assert_eq!( + c.craft_materials + .iter() + .map(|m| m.main_grade) + .collect::>(), + vec![false, true, false, true, false] + ); +} + +#[tokio::test] +async fn craft_loaded_grade_recipes_create_expected_inventory() { + for (use_grade, main_grade, material, product_grade, fixed_grade, gradable, expected) in [ + ("t", "f", STACK, 3, -1, true, 3), + ("f", "t", SWORD, 0, -1, true, 4), + // Keep the 1.2 equipment-material heuristic when the main_grade flag is unset. + ("f", "f", SWORD, 0, -1, true, 4), + ("t", "f", STACK, 3, 2, false, 2), + ("f", "f", STACK, 0, -1, true, 0), + ] { + let mut d = data(); + d.systems.economy.craft = load_craft_sql(&format!( + "INSERT INTO craft_products VALUES (1, 1, {PRODUCT}, 1, 100, 'f', '{use_grade}', {product_grade}); + INSERT INTO craft_materials VALUES (1, 1, {material}, 1, '{main_grade}');" + )); + let recipe = d.systems.economy.craft.craft(CRAFT).unwrap(); + assert_eq!(recipe.craft_products[0].use_grade, use_grade == "t"); + assert_eq!(recipe.craft_materials[0].main_grade, main_grade == "t"); + let t = d.items.templates.get_mut(&PRODUCT).unwrap(); + t.fixed_grade = fixed_grade; + t.gradable = gradable; + d.items.grades.insert( + 4, + crate::data::items::GradeTemplate { + grade: 4, + grade_order: 4, + durability: 1.0, + }, + ); + let mut w = world_with_data(d); + let rec = install_craft_hooks(&w); + let pa = w.pa.clone(); + pa.data().labor_power = 100; + let id = give(&w, &pa, slot_type::INVENTORY, material, 1, 0); + Inv::of(&pa) + .bag() + .lock() + .unwrap() + .get_item_by_id_mut(id) + .unwrap() + .grade = 4; + execute_craft(&mut w, CRAFT, 1); + assert_eq!(rec.casts.lock().unwrap().len(), 1); + craft::end_craft(&w.server, &pa); + let inv = Inv::of(&pa); + assert_eq!(inv.items_count(material, -1), 0); + let bag = inv.bag(); + let bag = bag.lock().unwrap(); + assert_eq!(bag.items.len(), 1); + let product = &bag.items[0]; + assert_eq!( + (product.template_id, product.count, product.grade), + (PRODUCT, 1, expected) + ); + assert_eq!(*rec.crafted.lock().unwrap(), vec![CRAFT]); + } +} + #[tokio::test] async fn craft_batch_consumes_materials_adds_products_and_reschedules() { let mut w = world(); @@ -878,8 +997,8 @@ impl NpcEconomyHooks for Shops { }) } - fn merchant_sells(&self, _server: &GameServer, pack_id: u32, item_id: u32) -> bool { - pack_id == 7 && item_id == STACK + fn merchant_sells(&self, _server: &GameServer, pack_id: u32, item_id: u32, grade: u8) -> bool { + pack_id == 7 && item_id == STACK && grade == 0 } } @@ -903,6 +1022,144 @@ fn buy_body(npc: u32, buy: &[(u32, i32, u8)], buy_back: &[i32]) -> Vec { s.into_bytes() } +fn catalog_world(mut d: GameData, stock: &[(u32, u8)]) -> World { + let mut goods = crate::systems::npcs::npc::data::MerchantGoods { + id: 7, + items: Vec::new(), + }; + for &(item, grade) in stock { + goods.add_item_to_stock(item, grade); + } + d.systems.npcs.npc.goods.insert(7, goods); + d.systems.npcs.npc.templates.insert( + 1234, + crate::systems::npcs::npc::data::NpcTemplate { + id: 1234, + merchant: true, + merchant_pack_id: 7, + ..Default::default() + }, + ); + let mut w = world_with_data(d); + // Use the real NPC catalog bridge, including its native fixed-grade normalization. + crate::systems::npcs::bridges::install_economy(&w.server); + spawn_npc(&mut w, MERCHANT_NPC, 1234, 101.0); + w +} + +async fn buy_grade(w: &mut World, item_id: u32, grade: u8, count: i32, currency: u8) { + use crate::net::registry::ClientPacket; + CSBuyItemsPacket { + npc_obj_id: MERCHANT_NPC, + doodad_obj_id: 0, + unk_id: 0, + buy: vec![BuyEntry { + item_id, + grade, + count, + currency, + }], + buy_back: Vec::new(), + use_aa_point: false, + } + .handle(&w.server, &mut w.a.conn) + .await + .unwrap(); +} + +#[tokio::test] +async fn shop_catalog_grades_create_distinct_paid_inventory() { + let mut d = data(); + d.items.templates.get_mut(&STACK).unwrap().gradable = true; + let sword = d.items.templates.get_mut(&SWORD).unwrap(); + sword.gradable = true; + sword.fixed_grade = -1; + sword.honor_price = 9; + let mut w = catalog_world(d, &[(STACK, 0), (STACK, 4), (STACK, 11), (SWORD, 4)]); + w.pa.data().money = 1000; + w.pa.data().honor_point = 100; + give(&w, &w.pa, slot_type::INVENTORY, STACK, 5, 0); + buy_grade(&mut w, STACK, 4, 2, shop_currency_type::MONEY).await; + buy_grade(&mut w, STACK, 11, 1, shop_currency_type::MONEY).await; + buy_grade(&mut w, SWORD, 4, 1, shop_currency_type::HONOR).await; + buy_grade(&mut w, STACK, 0, 1, shop_currency_type::MONEY).await; + let inv = Inv::of(&w.pa); + assert_eq!(inv.items_count(STACK, 0), 6); + assert_eq!(inv.items_count(STACK, 4), 2); + assert_eq!(inv.items_count(STACK, 11), 1); + assert_eq!(inv.items_count(SWORD, 4), 1); + let c = w.pa.data(); + assert_eq!((c.money, c.honor_point, c.vocation_point), (960, 91, 0)); +} + +#[tokio::test] +async fn shop_catalog_grades_reject_unlisted_grade_without_charge() { + for currency in [shop_currency_type::MONEY, shop_currency_type::HONOR] { + for grade in [0, 11] { + let mut d = data(); + d.items.templates.get_mut(&STACK).unwrap().gradable = true; + let mut w = catalog_world(d, &[(STACK, 4)]); + w.pa.data().money = 1000; + w.pa.data().honor_point = 100; + buy_grade(&mut w, STACK, grade, 1, currency).await; + assert!(Inv::of(&w.pa).bag().lock().unwrap().items.is_empty()); + let c = w.pa.data(); + assert_eq!((c.money, c.honor_point), (1000, 100)); + } + } +} + +#[tokio::test] +async fn shop_catalog_grades_respect_fixed_and_basic_templates() { + // Stock grade zero is basic for gradable gear; it is not "any grade" or "use default". + // Fixed grades are sent after normalization by native 1.2 sub_397CD260. + for (stock, fixed, gradable, requested, accepted) in [ + (0, -1, true, 0, true), + (0, -1, true, 11, false), + (0, 2, false, 2, true), + (0, 2, false, 0, false), + (4, 2, false, 2, true), + (4, 2, false, 4, false), + (0, 2, true, 2, true), + (0, 2, true, 0, false), + (4, -1, false, 0, true), + (4, -1, false, 4, false), + ] { + let mut d = data(); + let t = d.items.templates.get_mut(&STACK).unwrap(); + t.fixed_grade = fixed; + t.gradable = gradable; + let mut w = catalog_world(d, &[(STACK, stock)]); + w.pa.data().money = 100; + buy_grade(&mut w, STACK, requested, 1, shop_currency_type::MONEY).await; + assert_eq!(Inv::of(&w.pa).items_count(STACK, -1), i32::from(accepted)); + assert_eq!(w.pa.data().money, if accepted { 90 } else { 100 }); + if accepted { + assert_eq!( + item_at(&w.pa, slot_type::INVENTORY, 0).unwrap().grade, + requested + ); + } + } +} + +#[tokio::test] +async fn shop_catalog_grades_full_bag_rolls_back() { + let mut d = data(); + d.items.templates.get_mut(&STACK).unwrap().gradable = true; + let mut w = catalog_world(d, &[(STACK, 0), (STACK, 4)]); + w.pa.data().honor_point = 100; + let bag = Inv::of(&w.pa).bag(); + bag.lock().unwrap().set_container_size(1); + give(&w, &w.pa, slot_type::INVENTORY, STACK, 5, 0); + let before = bag.lock().unwrap().items.clone(); + // A partial basic stack cannot take a higher-grade purchase. + buy_grade(&mut w, STACK, 4, 1, shop_currency_type::HONOR).await; + assert_eq!(bag.lock().unwrap().items, before); + assert_eq!(w.pa.data().honor_point, 100); + assert!(w.a.drain().is_empty()); +} + #[tokio::test] async fn shop_checkout_rejects_money_only_and_mixed_currency_shortages() { for (money, honor, vocation, purchases) in [ @@ -1661,6 +1918,24 @@ fn real_compact_db_craft_and_store_tables() { assert_eq!(products, 6938 - 10); assert_eq!(materials, 23475 - 54); assert_eq!(craft.crafts.values().filter(|c| c.is_pack).count(), 2153); + assert_eq!( + craft + .crafts + .values() + .flat_map(|c| &c.craft_products) + .filter(|p| p.use_grade) + .count(), + 356 + ); + assert_eq!( + craft + .crafts + .values() + .flat_map(|c| &c.craft_materials) + .filter(|m| m.main_grade) + .count(), + 101 + ); // The 't'/'f' columns read through GetBoolean(column) are all false. assert!(craft .crafts diff --git a/rust/crates/aaemu-game/src/systems/economy/hooks.rs b/rust/crates/aaemu-game/src/systems/economy/hooks.rs index 58b629d074..322409caa9 100644 --- a/rust/crates/aaemu-game/src/systems/economy/hooks.rs +++ b/rust/crates/aaemu-game/src/systems/economy/hooks.rs @@ -99,8 +99,14 @@ pub trait NpcEconomyHooks: Send + Sync { None } - /// `NpcManager.GetGoods(packId)?.SellsItem(itemId)`. - fn merchant_sells(&self, _server: &GameServer, _pack_id: u32, _item_id: u32) -> bool { + /// Whether the catalog offers this item at the grade sent by the 1.2 client. + fn merchant_sells( + &self, + _server: &GameServer, + _pack_id: u32, + _item_id: u32, + _grade: u8, + ) -> bool { false } diff --git a/rust/crates/aaemu-game/src/systems/economy/store.rs b/rust/crates/aaemu-game/src/systems/economy/store.rs index 91bf59bc5b..eaec41c604 100644 --- a/rust/crates/aaemu-game/src/systems/economy/store.rs +++ b/rust/crates/aaemu-game/src/systems/economy/store.rs @@ -404,7 +404,7 @@ impl CSBuyItemsPacket { return; } let sells = match (pack_id, &npc_hooks) { - (Some(pack), Some(h)) => h.merchant_sells(server, pack, e.item_id), + (Some(pack), Some(h)) => h.merchant_sells(server, pack, e.item_id, e.grade), _ => false, }; if !sells { @@ -435,7 +435,7 @@ impl CSBuyItemsPacket { return; }; *total = sum; - items_buy.push((e.item_id, e.count)); + items_buy.push((e.item_id, e.count, e.grade)); } let inv = Inv::of(&p); @@ -489,12 +489,12 @@ impl CSBuyItemsPacket { let mut staged_bag = bag.clone(); let mut staged_buyback = buyback.clone(); let mut succeeded = true; - for (item_id, count) in items_buy { + for (item_id, count, grade) in items_buy { let template = txn.data().template(item_id).expect("preflight template"); let existing: Vec<_> = staged_bag .items .iter() - .filter(|i| i.template_id == item_id) + .filter(|i| i.template_id == item_id && i.grade == grade) .collect(); let units: i64 = existing.iter().map(|i| i64::from(i.count)).sum(); let capacity = (existing.len() as i64 + i64::from(staged_bag.free_slot_count())) @@ -507,7 +507,7 @@ impl CSBuyItemsPacket { task_type::STORE_BUY, item_id, count, - -1, + i32::from(grade), 0, &mut txn.env, ) diff --git a/rust/crates/aaemu-game/src/systems/npcs/bridges.rs b/rust/crates/aaemu-game/src/systems/npcs/bridges.rs index 89a2ff1c09..dc99164451 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/bridges.rs @@ -1117,7 +1117,10 @@ impl crate::systems::economy::hooks::NpcEconomyHooks for NpcsForEconomy { }) } - fn merchant_sells(&self, server: &GameServer, pack_id: u32, item_id: u32) -> bool { + fn merchant_sells(&self, server: &GameServer, pack_id: u32, item_id: u32, grade: u8) -> bool { + let Some(template) = server.game_data.items.template(item_id) else { + return false; + }; server .game_data .systems @@ -1125,7 +1128,7 @@ impl crate::systems::economy::hooks::NpcEconomyHooks for NpcsForEconomy { .npc .goods .get(&pack_id) - .is_some_and(|g| g.sells_item(item_id)) + .is_some_and(|g| g.sells_item_at_grade(template, grade)) } fn specialty_coin_id(&self, server: &GameServer, npc: &NpcRef) -> u32 { diff --git a/rust/crates/aaemu-game/src/systems/npcs/npc/data.rs b/rust/crates/aaemu-game/src/systems/npcs/npc/data.rs index e96681b935..301cf1470d 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/npc/data.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/npc/data.rs @@ -27,6 +27,7 @@ use std::collections::HashMap; use rusqlite::Connection; use crate::data::formulas::Formula; +use crate::data::items::ItemTemplate; use crate::data::sqlite::{for_each_row, SqlRow}; use crate::models::unit::{BonusTemplate, UnitAttribute, UnitModifierType}; use crate::models::unit_model::{FaceModel, UnitCustomModelParams, UnitCustomModelType}; @@ -442,9 +443,29 @@ impl MerchantGoods { .any(|i| i.item_template_id == item_template_id) } - /// `AddItemToStock` (the first grade of an item wins). + /// The client normalizes each stock grade through the item template before buying + /// (1.2 `sub_394FC6E0` -> `sub_397CD260`). A fixed grade takes precedence; an + /// ungradable template without a fixed grade uses basic. Zero is a grade, not a wildcard. + pub fn sells_item_at_grade(&self, template: &ItemTemplate, grade: u8) -> bool { + self.items.iter().any(|i| { + let offered_grade = if template.fixed_grade >= 0 { + template.fixed_grade as u8 + } else if template.gradable { + i.grade + } else { + 0 + }; + i.item_template_id == template.id && offered_grade == grade + }) + } + + /// Keep each item / grade pair offered by the catalog. pub fn add_item_to_stock(&mut self, item_template_id: u32, grade: u8) { - if self.sells_item(item_template_id) { + if self + .items + .iter() + .any(|i| i.item_template_id == item_template_id && i.grade == grade) + { return; } self.items.push(MerchantGoodsItem { @@ -922,7 +943,8 @@ impl NpcData { for_each_row(conn, "SELECT * FROM merchant_goods", [], |r| { let id = r.u32("merchant_pack_id")?; let item_id = r.u32("item_id")?; - let grade = r.u8("grade_id")?; + // The 1.2 client reads this with sqlite3_column_int: NULL is basic (0). + let grade = r.u8_or("grade_id", 0)?; d.goods .entry(id) .or_insert_with(|| MerchantGoods { @@ -1264,16 +1286,70 @@ mod tests { "; #[test] - fn merchant_goods_first_grade_wins() { + fn merchant_goods_preserve_distinct_grades() { let mut g = MerchantGoods::default(); g.add_item_to_stock(5, 1); g.add_item_to_stock(5, 3); + g.add_item_to_stock(5, 1); g.add_item_to_stock(6, 0); - assert_eq!(g.items.len(), 2); - assert_eq!(g.items[0].grade, 1); + assert_eq!(g.items.len(), 3); + assert_eq!((g.items[0].grade, g.items[1].grade), (1, 3)); assert!(g.sells_item(6) && !g.sells_item(7)); } + #[test] + fn merchant_goods_load_null_grade_as_basic() { + let c = Connection::open_in_memory().unwrap(); + c.execute_batch(TEST_SCHEMA).unwrap(); + c.execute_batch("INSERT INTO merchant_goods VALUES (4, 77, 12, NULL), (5, 77, 12, 0);") + .unwrap(); + let d = NpcData::load_conn(&c, "en_us").unwrap(); + assert_eq!( + d.goods(77).unwrap().items, + vec![ + MerchantGoodsItem { + item_template_id: 10, + grade: 0 + }, + MerchantGoodsItem { + item_template_id: 11, + grade: 0 + }, + MerchantGoodsItem { + item_template_id: 10, + grade: 2 + }, + MerchantGoodsItem { + item_template_id: 12, + grade: 0 + }, + ] + ); + } + + #[test] + fn merchant_goods_validate_native_purchase_grade() { + let mut g = MerchantGoods::default(); + g.add_item_to_stock(5, 0); + g.add_item_to_stock(5, 3); + let mut t = ItemTemplate::plain(5, 1); + t.gradable = true; + assert!(g.sells_item_at_grade(&t, 0)); + assert!(g.sells_item_at_grade(&t, 3)); + assert!(!g.sells_item_at_grade(&t, 11)); + t.fixed_grade = 2; + assert!(g.sells_item_at_grade(&t, 2)); + assert!(!g.sells_item_at_grade(&t, 0)); + assert!(!g.sells_item_at_grade(&t, 3)); + t.gradable = false; + assert!(g.sells_item_at_grade(&t, 2)); + t.fixed_grade = -1; + assert!(g.sells_item_at_grade(&t, 0)); + assert!(!g.sells_item_at_grade(&t, 3)); + t.id = 7; + assert!(!g.sells_item_at_grade(&t, 0)); + } + #[test] fn body_parts_take_last_entry_and_template_hair() { let mut ibp = HashMap::new(); @@ -1336,7 +1412,7 @@ mod tests { let t2 = d.template(101).unwrap(); assert_eq!(t2.model_params.kind, UnitCustomModelType::SKIN); assert_eq!((t2.race, t2.gender), (0, 0)); - assert_eq!(d.goods(77).unwrap().items.len(), 2); + assert_eq!(d.goods(77).unwrap().items.len(), 3); assert!(d.is_fly_or_swim(2) && !d.is_fly_or_swim(10) && !d.is_fly_or_swim(3)); assert_eq!(d.weapons[&601].level, 20); assert_eq!(d.localized_name(100, "x"), "Guard"); From 24b4699887d5350bc1a9e6f89267f98469fde8eb Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:30:22 -0400 Subject: [PATCH 04/66] fix(webapi): require bearer authentication for administrative routes Default the HTTP listener to loopback, reject unauthenticated non-loopback binds, and keep only read-only status anonymous. Add credential, mutation-side-effect, legacy configuration, disabled API, and redaction regressions with migration instructions. Validation: cargo fmt --all --check, git diff --cached --check, and shipped WebAPI JSON defaults passed. Builds, tests, Clippy, full CI, and live verification remain pending for the parent audit-final lane under the resource plan; this lane has no Cargo target. Co-Authored-By: OpenAI Codex --- ...e-Config.json-files-and-server-listings.md | 63 ++++ rust/Cargo.lock | 1 + rust/crates/aaemu-game/Cargo.toml | 1 + rust/crates/aaemu-game/PORTING.md | 6 + rust/crates/aaemu-game/README.md | 12 +- rust/crates/aaemu-game/app/Config.json | 6 +- rust/crates/aaemu-game/src/config.rs | 65 +++- .../src/systems/services/webapi/auth.rs | 34 ++ .../src/systems/services/webapi/auth_tests.rs | 341 ++++++++++++++++++ .../services/webapi/controllers/tests.rs | 11 +- .../src/systems/services/webapi/http.rs | 15 +- .../src/systems/services/webapi/mod.rs | 49 ++- .../systems/services/webapi/session_tests.rs | 25 +- 13 files changed, 606 insertions(+), 23 deletions(-) create mode 100644 rust/crates/aaemu-game/src/systems/services/webapi/auth.rs create mode 100644 rust/crates/aaemu-game/src/systems/services/webapi/auth_tests.rs diff --git a/Docs/wiki/Working-with-the-Config.json-files-and-server-listings.md b/Docs/wiki/Working-with-the-Config.json-files-and-server-listings.md index 2d106a00dc..33303f91c5 100644 --- a/Docs/wiki/Working-with-the-Config.json-files-and-server-listings.md +++ b/Docs/wiki/Working-with-the-Config.json-files-and-server-listings.md @@ -93,6 +93,69 @@ from the C# version is still read between `Config.Local.json` and the environment variables, but it can no longer be managed with a tool; move those values to `Config.Local.json` or environment variables.) +## Web API authentication and migration + +The game Web API now defaults to `127.0.0.1:1280`. Only `GET /status` is +anonymous; it returns uptime, player count and task/skill metrics. Every other +registered route requires `Authorization: Bearer `, including character, +world and auction reads, mail listing, GM commands and mail with attachments. +Missing, invalid or duplicate credentials return HTTP 401 with a Bearer challenge. +Commands still use the selected online character's command access level. + +For local status tooling, use this game's `Config.Local.json` override: + +```json +{ + "WebApiNetwork": { + "Host": "127.0.0.1", + "Port": 1280, + "Enabled": true, + "ApiKey": null + } +} +``` + +An absent, null or empty `ApiKey` disables access to every authenticated route, +including requests from localhost. To enable administrative tools, configure a +private, randomly generated key of at least 32 random bytes in the game process's +`WebApiNetwork__ApiKey` environment variable, or in the gitignored +`Config.Local.json` field `WebApiNetwork.ApiKey`. Keys accept ASCII letters, +digits and `-._~+/=`; whitespace is rejected. Keep the key separate from the +Login/Game `SecretKey`. Never put the key in URLs or commit it. + +For example, generate a key privately in PowerShell before starting the game +process from the same environment (these commands do not print the key): + +```powershell +$webApiRandom = [System.Security.Cryptography.RandomNumberGenerator]::Create() +$webApiBytes = New-Object byte[] 32 +$webApiRandom.GetBytes($webApiBytes) +$webApiRandom.Dispose() +$env:WebApiNetwork__ApiKey = [Convert]::ToBase64String($webApiBytes) +``` + +An administrative caller using that same private environment can supply the header: + +```powershell +$webApiHeaders = @{ Authorization = 'Bearer ' + $env:WebApiNetwork__ApiKey } +Invoke-RestMethod -Uri http://127.0.0.1:1280/api/world/logged-characters -Headers $webApiHeaders +``` + +Existing configurations with `Host: "*"`, `0.0.0.0`, `::`, or any other +non-loopback address now fail startup unless a nonempty valid key is configured. +For local monitoring, change the host to `127.0.0.1`; for remote administration, +configure the private key and use an HTTPS reverse proxy or SSH tunnel so the +Bearer token is encrypted in transit. The HTTP listener itself does not provide TLS. +Authentication does not make anonymous routes private: `/status` remains public +on the configured interface. Restart the game process after changing the bind, +key or `Enabled` setting; configuration reload does not restart the listener or +rotate its credential snapshot. + +To disable the API even when the shipped config contains the section, set +`"WebApiNetwork": { "Enabled": false }` in `Config.Local.json`. A missing or null +section also disables it. Existing clients must add the Bearer header to every +`/api` request; local `/status` checks continue to work without credentials. + ## Tower defense event schedules Tower defense controllers are reserved for events instead of spawning permanently. diff --git a/rust/Cargo.lock b/rust/Cargo.lock index 52e779434d..190c500796 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -52,6 +52,7 @@ dependencies = [ "serde", "serde_json", "sqlx", + "subtle", "thiserror 1.0.69", "tokio", "tokio-util", diff --git a/rust/crates/aaemu-game/Cargo.toml b/rust/crates/aaemu-game/Cargo.toml index c7cc92ade8..cfbfd5d2aa 100644 --- a/rust/crates/aaemu-game/Cargo.toml +++ b/rust/crates/aaemu-game/Cargo.toml @@ -35,6 +35,7 @@ aes.workspace = true cbc.workspace = true roxmltree.workspace = true rand.workspace = true +subtle.workspace = true axum.workspace = true twilight-gateway.workspace = true twilight-http.workspace = true diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 7affb528bd..39faccfe29 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -1218,6 +1218,12 @@ is no longer mirrored (see "Known deviations", dead NPC returned and healed). `CreatedAt` of characters created in the running session is written without the `Z` of a `DateTimeKind.Utc` value. The auction controllers serialise the lot's `Item` with its stored fields only (Id, TemplateId, Count, Grade, OwnerId, SlotType, Slot). +* systems::services (WebApi security, 2026-10-25): unlike C#, the HTTP listener defaults to + loopback and rejects non-loopback binds without a configured `WebApiNetwork.ApiKey`. + Every route except read-only `GET /status` requires a Bearer credential, compared using + `subtle::ConstantTimeEq`; an absent or empty key grants no administrative access, including + on localhost. `Enabled: false` disables the listener. Keys and bind settings are snapshotted + at listener start; changes require restart. Existing tools must add the Authorization header. * systems::services: `TaskManager.GetQueueCount` (WebApi `/status`) only counts the tasks of this queue; the other subsystems run their timers as Tokio tasks. * systems::services: `TimedRewardsManager.DoTick` skips connections without an account (C# diff --git a/rust/crates/aaemu-game/README.md b/rust/crates/aaemu-game/README.md index b3b07889de..149bb1224b 100644 --- a/rust/crates/aaemu-game/README.md +++ b/rust/crates/aaemu-game/README.md @@ -58,8 +58,10 @@ The configuration structure is as follows: "Port": 1250 }, "WebApiNetwork": { - "Host": "*", - "Port": 1280 + "Host": "127.0.0.1", + "Port": 1280, + "Enabled": true, + "ApiKey": null }, "LoginNetwork": { "Host": "%login_host%", <-- the IP address of the login server @@ -81,6 +83,12 @@ The configuration structure is as follows: ### Create Configuration File +The Web API permits anonymous `GET /status` only. All `/api` routes require an +explicit `WebApiNetwork.ApiKey` through the `Authorization: Bearer ` header; +a missing key disables those routes. Non-loopback binds require a key or startup +fails. See the [Web API migration guide](../../../Docs/wiki/Working-with-the-Config.json-files-and-server-listings.md#web-api-authentication-and-migration) +for private key generation, remote access and disabling the listener. + 1. Create a file named `Config.Local.json` next to `Config.json` in the application directory (by default `rust/crates/aaemu-game/app/`). It is gitignored and overrides the default `Config.json` with your local changes. `ExampleConfig.Local.json` is a starting point. diff --git a/rust/crates/aaemu-game/app/Config.json b/rust/crates/aaemu-game/app/Config.json index dfe19d7640..802afa1ab5 100644 --- a/rust/crates/aaemu-game/app/Config.json +++ b/rust/crates/aaemu-game/app/Config.json @@ -12,8 +12,10 @@ "Port": 1250 }, "WebApiNetwork": { - "Host": "*", - "Port": 1280 + "Host": "127.0.0.1", + "Port": 1280, + "Enabled": true, + "ApiKey": null }, "LoginNetwork": { "Host": "%login_host%", diff --git a/rust/crates/aaemu-game/src/config.rs b/rust/crates/aaemu-game/src/config.rs index f9a40dce69..5ca983ad6f 100644 --- a/rust/crates/aaemu-game/src/config.rs +++ b/rust/crates/aaemu-game/src/config.rs @@ -62,7 +62,7 @@ pub struct AppConfig { pub login_network: NetworkConfig, /// `WebApiNetwork` (`None` = section missing: "WebApi will not start"). #[serde(rename = "webapinetwork")] - pub web_api_network: Option, + pub web_api_network: Option, /// `MaxConcurencyThreadPool` (bound but unused by the C# server as well). #[serde(rename = "maxconcurencythreadpool", deserialize_with = "lenient")] pub max_concurency_thread_pool: i32, @@ -177,6 +177,42 @@ pub struct NetworkConfig { pub num_connections: i32, } +/// HTTP listener configuration. An absent key leaves only `/status` accessible. +#[derive(Clone, Deserialize)] +#[serde(default)] +pub struct WebApiConfig { + #[serde(rename = "host")] + pub host: String, + #[serde(rename = "port", deserialize_with = "lenient")] + pub port: u16, + #[serde(rename = "enabled", deserialize_with = "lenient")] + pub enabled: bool, + #[serde(rename = "apikey")] + pub api_key: Option, +} + +impl Default for WebApiConfig { + fn default() -> Self { + Self { + host: "127.0.0.1".into(), + port: 1280, + enabled: true, + api_key: None, + } + } +} + +impl std::fmt::Debug for WebApiConfig { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("WebApiConfig") + .field("host", &self.host) + .field("port", &self.port) + .field("enabled", &self.enabled) + .field("api_key", &self.api_key.as_ref().map(|_| "[redacted]")) + .finish() + } +} + #[derive(Debug, Clone, Default, Deserialize)] #[serde(default)] pub struct DbConnections { @@ -1141,7 +1177,9 @@ mod tests { assert_eq!(cfg.login_network.port, 1234); assert_eq!(cfg.connections.mysql_provider.port, 3306); let web = cfg.web_api_network.as_ref().expect("WebApiNetwork"); - assert_eq!((web.host.as_str(), web.port), ("*", 1280)); + assert_eq!((web.host.as_str(), web.port), ("127.0.0.1", 1280)); + assert!(web.enabled); + assert!(web.api_key.is_none()); assert_eq!(cfg.max_concurency_thread_pool, 8); assert!(cfg.discord_token.is_none()); // World.json @@ -1178,6 +1216,29 @@ mod tests { assert_eq!(cfg.events.halloween.end, ""); } + #[test] + fn web_api_security_settings_bind_from_environment() { + let mut value = json!({"WebApiNetwork": {"Host": "127.0.0.1"}}); + apply_env( + &mut value, + [ + ( + "WebApiNetwork__ApiKey".into(), + "synthetic-environment-key".into(), + ), + ("WebApiNetwork__Enabled".into(), "false".into()), + ], + ); + let config = AppConfig::from_value(value).unwrap(); + let web = config.web_api_network.unwrap(); + assert_eq!(web.api_key.as_deref(), Some("synthetic-environment-key")); + assert!(!web.enabled); + assert!(AppConfig::from_value(json!({"WebApiNetwork": null})) + .unwrap() + .web_api_network + .is_none()); + } + #[test] fn overrides_apply_in_builder_order() { let dir = std::env::temp_dir().join(format!("aaemu-cfg-{}", std::process::id())); diff --git a/rust/crates/aaemu-game/src/systems/services/webapi/auth.rs b/rust/crates/aaemu-game/src/systems/services/webapi/auth.rs new file mode 100644 index 0000000000..1b5783b5e7 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/services/webapi/auth.rs @@ -0,0 +1,34 @@ +//! Bearer authentication for the administrative HTTP API. + +use axum::http::{header::AUTHORIZATION, HeaderMap}; +use subtle::ConstantTimeEq; + +/// Empty keys disable authenticated routes; malformed keys must never enable a listener. +pub(super) fn validate_key(key: Option<&str>) -> anyhow::Result<()> { + if let Some(key) = key.filter(|key| !key.is_empty()) { + anyhow::ensure!( + key.bytes() + .all(|b| b.is_ascii_alphanumeric() || b"-._~+/=".contains(&b)), + "WebApiNetwork.ApiKey must contain only bearer-token characters" + ); + } + Ok(()) +} + +pub(super) fn authorized(key: Option<&str>, headers: &HeaderMap) -> bool { + let Some(key) = key.filter(|key| !key.is_empty()) else { + return false; + }; + // Reject duplicate credentials rather than relying on which value a proxy selects. + let mut values = headers.get_all(AUTHORIZATION).iter(); + let Some(value) = values.next() else { + return false; + }; + if values.next().is_some() { + return false; + } + let Some((scheme, token)) = value.to_str().ok().and_then(|s| s.split_once(' ')) else { + return false; + }; + scheme.eq_ignore_ascii_case("Bearer") && bool::from(key.as_bytes().ct_eq(token.as_bytes())) +} diff --git a/rust/crates/aaemu-game/src/systems/services/webapi/auth_tests.rs b/rust/crates/aaemu-game/src/systems/services/webapi/auth_tests.rs new file mode 100644 index 0000000000..dce5970d31 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/services/webapi/auth_tests.rs @@ -0,0 +1,341 @@ +//! Security regressions through the production route dispatcher and HTTP adapter. No live +//! stack or database is needed; privileged handlers leave observable in-memory effects. + +use std::sync::{Arc, Mutex}; + +use axum::http::{header::AUTHORIZATION, HeaderValue, Request}; +use serde_json::json; + +use super::hooks::{WebApiEconomyHooks, WebApiMail}; +use super::*; +use crate::config::{AppConfig, WebApiConfig}; +use crate::data::{items::ItemTemplate, GameData}; +use crate::systems::services::commands::{output::MessageOutput, Command, CommandContext}; +use crate::test_support::{ + spawn_player, test_character, test_server, test_server_with, TestClient, +}; + +pub(super) const TEST_KEY: &str = "synthetic-webapi-test-key"; + +pub(super) fn authenticated(mut request: HttpRequest) -> HttpRequest { + request.headers.insert( + AUTHORIZATION, + HeaderValue::from_static("Bearer synthetic-webapi-test-key"), + ); + request +} + +fn api(server: &Arc, key: Option<&str>) -> WebApiServer { + server.config.update(|c| { + c.web_api_network = Some(WebApiConfig { + api_key: key.map(str::to_owned), + ..Default::default() + }); + }); + WebApiServer::new(Arc::downgrade(server)).unwrap() +} + +fn post(url: &str, body: &str) -> HttpRequest { + HttpRequest::new("POST", url, "HTTP/1.1").with_body(body) +} + +fn invalid(mut request: HttpRequest) -> HttpRequest { + request.headers.insert( + AUTHORIZATION, + HeaderValue::from_static("Bearer synthetic-webapi-bad-key"), + ); + request +} + +fn assert_unauthorized(response: &HttpResponse) { + assert_eq!(response.status, 401); + assert_eq!(response.status_phrase, "Unauthorized"); + assert!(response.headers.iter().any(|(name, value)| { + name == "WWW-Authenticate" && value == "Bearer realm=\"AAEmu Web API\"" + })); + assert!(!response.body.contains(TEST_KEY)); +} + +struct SetHp; + +impl Command for SetHp { + fn command_names(&self) -> Vec { + vec!["auth-test".into()] + } + + fn execute( + &self, + ctx: &CommandContext<'_>, + _args: &[String], + _out: &mut dyn MessageOutput, + ) -> anyhow::Result<()> { + ctx.player()?.data().unit.hp = 42; + Ok(()) + } + + fn get_command_line_help(&self) -> String { + String::new() + } + + fn get_command_help_text(&self) -> String { + String::new() + } +} + +#[tokio::test] +async fn command_requires_credentials_before_executing_as_online_gm() { + let server = Arc::new(test_server()); + let client = TestClient::new(&server, 1, 1); + let mut character = test_character(1, "SyntheticGM", 10.0, 10.0); + character.access_level = 100; + character.unit.hp = 100; + let player = spawn_player(&server, &client, character, 0x100); + server + .systems + .services + .commands + .register("auth-test", Arc::new(SetHp)); + let api = api(&server, Some(TEST_KEY)); + let request = post( + "/api/commands/auth-test", + r#"{"character":"SyntheticGM","arguments":"fixture"}"#, + ); + for denied in [request.clone(), invalid(request.clone())] { + assert_unauthorized(&on_received_request(&api, denied).await); + assert_eq!(player.data().unit.hp, 100); + } + let response = on_received_request(&api, authenticated(request)).await; + assert_eq!(response.status, 200); + assert_eq!(player.data().unit.hp, 42); +} + +#[derive(Default)] +struct Sent(Mutex>); + +impl WebApiEconomyHooks for Sent { + fn send_mail(&self, _server: &GameServer, mail: WebApiMail) -> bool { + self.0.lock().unwrap().push(mail); + true + } +} + +#[tokio::test] +async fn mail_with_items_requires_credentials_in_http_adapter() { + let mut data = GameData::empty(); + data.items + .templates + .insert(12345, ItemTemplate::plain(12345, 20)); + let server = Arc::new(test_server_with(data)); + let sent = Arc::new(Sent::default()); + server + .systems + .services + .webapi_economy_hooks + .install(sent.clone()); + let client = TestClient::new(&server, 1, 1); + spawn_player( + &server, + &client, + test_character(1, "Bob", 10.0, 10.0), + 0x100, + ); + let api = Arc::new(api(&server, Some(TEST_KEY))); + for credential in [ + None, + Some("Bearer synthetic-webapi-bad-key"), + Some("Bearer synthetic-webapi-test-key"), + ] { + let mut builder = Request::builder().method("POST").uri("/api/mail/send"); + if let Some(credential) = credential { + // HTTP header names and the Bearer scheme are case-insensitive. + builder = builder.header("aUtHoRiZaTiOn", credential); + } + let request = builder.body(Body::from( + r#"{"Title":"fixture","Body":"fixture","RecipientType":3,"Money":5,"AttachmentItems":[{"Id":12345,"Count":2}]}"#, + )).unwrap(); + let response = dispatch(State(api.clone()), request).await; + if credential == Some("Bearer synthetic-webapi-test-key") { + assert_eq!(response.status(), 200); + let mails = sent.0.lock().unwrap(); + assert_eq!(mails.len(), 1); + assert_eq!(mails[0].receiver_name, "Bob"); + assert_eq!(mails[0].copper_coins, 5); + assert_eq!(mails[0].attachments.len(), 1); + assert_eq!(mails[0].attachments[0].template_id, 12345); + assert_eq!(mails[0].attachments[0].count, 2); + } else { + assert_eq!(response.status(), 401); + assert!(sent.0.lock().unwrap().is_empty()); + } + } +} + +#[tokio::test] +async fn all_api_routes_require_auth_even_with_legacy_regex_urls() { + let server = Arc::new(test_server()); + let api = api(&server, Some(TEST_KEY)); + for (method, url) in [ + ("POST", "/api/commands/kick"), + ("POST", "/api/mail/send"), + ("POST", "/api/mail/delete"), + ("POST", "/api/mail/list"), + ("POST", "/api/auction/add"), + ("POST", "/api/auction/generate"), + ("GET", "/api/character/list"), + ("GET", "/api/world/logged-characters"), + ("GET", "/api/expedition/list"), + ("GET", "/api/auction/list"), + ("GET", "/api/auction/search"), + ("POST", "/status?next=/api/mail/send"), + ("POST", "/prefix/API/COMMANDS/kick?status=1"), + ("POST", "/?next=/api/mail/send"), + ] { + // Invalid JSON must not be parsed before authentication. + let request = HttpRequest::new(method, url, "HTTP/1.1").with_body("invalid JSON"); + for denied in [request.clone(), invalid(request)] { + assert_unauthorized(&on_received_request(&api, denied).await); + } + } +} + +#[tokio::test] +async fn status_remains_public_and_missing_key_never_grants_api_access() { + let server = Arc::new(test_server()); + for key in [None, Some(""), Some(TEST_KEY)] { + let api = api(&server, key); + let response = + on_received_request(&api, HttpRequest::new("GET", "/status", "HTTP/1.1")).await; + assert_eq!(response.status, 200); + assert!(response.body.contains("Players online: 0")); + if key != Some(TEST_KEY) { + for url in ["/api/commands/kick", "/api/mail/send"] { + assert_unauthorized( + &on_received_request(&api, authenticated(post(url, "{}"))).await, + ); + } + } + } +} + +#[test] +fn bearer_parser_rejects_malformed_and_duplicate_credentials() { + let request = post("/api/mail/send", "{}"); + for value in [ + "", + "Bearer", + "Bearer ", + "Basic synthetic-webapi-test-key", + "Bearer synthetic-webapi-test-key", + "Bearer synthetic-webapi-test-key, synthetic-webapi-bad-key", + ] { + let mut bad = request.clone(); + bad.headers + .insert(AUTHORIZATION, HeaderValue::from_str(value).unwrap()); + assert!(!auth::authorized(Some(TEST_KEY), &bad.headers)); + } + let mut good = request; + good.headers.insert( + AUTHORIZATION, + HeaderValue::from_static("bEaReR synthetic-webapi-test-key"), + ); + assert!(auth::authorized(Some(TEST_KEY), &good.headers)); + good.headers.append( + AUTHORIZATION, + HeaderValue::from_static("Bearer synthetic-webapi-test-key"), + ); + assert!(!auth::authorized(Some(TEST_KEY), &good.headers)); +} + +#[test] +fn binding_requires_key_for_every_nonloopback_address() { + for host in [ + "*", + "0.0.0.0", + "::", + "192.0.2.1", + "2001:db8::1", + "::ffff:127.0.0.1", + ] { + for key in [None, Some("")] { + let config = WebApiConfig { + host: host.into(), + api_key: key.map(str::to_owned), + ..Default::default() + }; + assert!(bind_address(&config).is_err(), "{host}"); + } + let config = WebApiConfig { + host: host.into(), + api_key: Some(TEST_KEY.into()), + ..Default::default() + }; + assert!(bind_address(&config).is_ok(), "{host}"); + } + for host in ["127.0.0.1", "127.0.0.2", "::1"] { + assert!(bind_address(&WebApiConfig { + host: host.into(), + ..Default::default() + }) + .is_ok()); + } + for key in [" ", "key with spaces", "key\n", "key,other"] { + let config = WebApiConfig { + api_key: Some(key.into()), + ..Default::default() + }; + let error = bind_address(&config).unwrap_err().to_string(); + assert_eq!( + error, + "WebApiNetwork.ApiKey must contain only bearer-token characters" + ); + } +} + +#[tokio::test] +async fn unsafe_legacy_configuration_fails_before_listener_start() { + let server = Arc::new(test_server()); + for host in ["*", "0.0.0.0", "::", "192.0.2.1"] { + let config = + AppConfig::from_value(json!({"WebApiNetwork": {"Host": host, "Port": 0}})).unwrap(); + server + .config + .update(|c| c.web_api_network = config.web_api_network); + let service = WebApiService::default(); + let error = service.start(&server).await.unwrap_err(); + assert!(error.to_string().contains("ApiKey is required")); + assert!(!service.is_started()); + } +} + +#[tokio::test] +async fn disabled_or_absent_api_never_starts_a_listener() { + let server = Arc::new(test_server()); + for config in [ + None, + Some(WebApiConfig { + enabled: false, + host: "invalid-address".into(), + ..Default::default() + }), + ] { + server.config.update(|c| c.web_api_network = config); + let service = WebApiService::default(); + service.start(&server).await.unwrap(); + assert!(!service.is_started()); + } +} + +#[test] +fn configuration_defaults_and_diagnostics_do_not_expose_the_key() { + let config = AppConfig::from_value(json!({"WebApiNetwork": {}})).unwrap(); + let web = config.web_api_network.unwrap(); + assert_eq!((web.host.as_str(), web.port), ("127.0.0.1", 1280)); + assert!(web.enabled); + assert!(web.api_key.is_none()); + let config = + AppConfig::from_value(json!({"WebApiNetwork": {"ApiKey": TEST_KEY, "Enabled": "false"}})) + .unwrap(); + assert!(!config.web_api_network.as_ref().unwrap().enabled); + assert!(!format!("{config:?}").contains(TEST_KEY)); + assert!(!format!("{:?}", authenticated(post("/api/mail/send", "{}"))).contains(TEST_KEY)); +} diff --git a/rust/crates/aaemu-game/src/systems/services/webapi/controllers/tests.rs b/rust/crates/aaemu-game/src/systems/services/webapi/controllers/tests.rs index a4cf2bb5da..b766683010 100644 --- a/rust/crates/aaemu-game/src/systems/services/webapi/controllers/tests.rs +++ b/rust/crates/aaemu-game/src/systems/services/webapi/controllers/tests.rs @@ -3,23 +3,30 @@ use std::sync::Arc; +use super::super::auth_tests::{authenticated, TEST_KEY}; use super::super::http::HttpRequest; use super::super::{on_received_request, WebApiServer}; use super::*; use crate::test_support::{spawn_player, test_character, test_server, TestClient}; fn api(server: &Arc) -> WebApiServer { + server.config.update(|c| { + c.web_api_network = Some(crate::config::WebApiConfig { + api_key: Some(TEST_KEY.into()), + ..Default::default() + }); + }); WebApiServer::new(Arc::downgrade(server)).unwrap() } async fn get(api: &WebApiServer, url: &str) -> HttpResponse { - on_received_request(api, HttpRequest::new("GET", url, "HTTP/1.1")).await + on_received_request(api, authenticated(HttpRequest::new("GET", url, "HTTP/1.1"))).await } async fn post(api: &WebApiServer, url: &str, body: &str) -> HttpResponse { on_received_request( api, - HttpRequest::new("POST", url, "HTTP/1.1").with_body(body), + authenticated(HttpRequest::new("POST", url, "HTTP/1.1").with_body(body)), ) .await } diff --git a/rust/crates/aaemu-game/src/systems/services/webapi/http.rs b/rust/crates/aaemu-game/src/systems/services/webapi/http.rs index 274233bfbe..6515bc45cb 100644 --- a/rust/crates/aaemu-game/src/systems/services/webapi/http.rs +++ b/rust/crates/aaemu-game/src/systems/services/webapi/http.rs @@ -4,13 +4,14 @@ use super::json::JValue; /// `NetCoreServer.HttpRequest` (the members the controllers read). -#[derive(Debug, Clone, Default, PartialEq, Eq)] +#[derive(Clone, Default, PartialEq, Eq)] pub struct HttpRequest { /// `Method` as sent (`GET`, `POST`, ...). pub method: String, /// `Url`: the request target (path and query string, not decoded). pub url: String, pub protocol: String, + pub headers: axum::http::HeaderMap, /// `Body` (UTF-8). pub body: String, } @@ -22,6 +23,7 @@ impl HttpRequest { method: method.to_string(), url: url.to_string(), protocol: protocol.to_string(), + headers: axum::http::HeaderMap::new(), body: String::new(), } } @@ -32,6 +34,17 @@ impl HttpRequest { } } +impl std::fmt::Debug for HttpRequest { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + // Authorization values must never appear in request diagnostics. + f.debug_struct("HttpRequest") + .field("method", &self.method) + .field("url", &self.url) + .field("protocol", &self.protocol) + .finish_non_exhaustive() + } +} + /// `NetCoreServer.HttpResponse`. #[derive(Debug, Clone, PartialEq, Eq)] pub struct HttpResponse { diff --git a/rust/crates/aaemu-game/src/systems/services/webapi/mod.rs b/rust/crates/aaemu-game/src/systems/services/webapi/mod.rs index 679633c7d6..9fa8604461 100644 --- a/rust/crates/aaemu-game/src/systems/services/webapi/mod.rs +++ b/rust/crates/aaemu-game/src/systems/services/webapi/mod.rs @@ -5,6 +5,7 @@ //! (`OnReceivedRequest`), which keeps the C# routing (regex routes on the raw URL), status //! codes and bodies. +mod auth; pub mod controllers; pub mod hooks; pub mod http; @@ -19,15 +20,17 @@ use axum::extract::State; use axum::response::Response; use tokio_util::sync::CancellationToken; -use self::http::{HttpRequest, HttpResponse}; -use self::route_mapper::{ControllerCtx, RouteMapper}; -use crate::config::NetworkConfig; +use self::http::{error_model, json_response, HttpRequest, HttpResponse}; +use self::route_mapper::{ControllerCtx, Method, RouteMapper}; +use crate::config::WebApiConfig; use crate::server::GameServer; /// `WebApiServer`: the routes plus the server the controllers reach. pub struct WebApiServer { pub route_mapper: RouteMapper, server: Weak, + /// Snapshot at listener creation; rotating the key requires a WebAPI restart. + api_key: Option, } impl WebApiServer { @@ -35,17 +38,22 @@ impl WebApiServer { pub fn new(server: Weak) -> Result { let mut route_mapper = RouteMapper::new(); route_mapper.discover_routes()?; - Ok(Self { - route_mapper, - server, - }) + Ok(Self::with_routes(route_mapper, server)) } /// `new WebApiServer(address, port, routeMapper)`. pub fn with_routes(route_mapper: RouteMapper, server: Weak) -> Self { + let api_key = server.upgrade().and_then(|s| { + s.config + .web_api_network + .as_ref() + .filter(|c| c.enabled) + .and_then(|c| c.api_key.clone()) + }); Self { route_mapper, server, + api_key, } } } @@ -62,6 +70,14 @@ pub async fn on_received_request(server: &WebApiServer, request: HttpRequest) -> response.set_body("Not found"); return Ok(response); }; + // Check the selected route, not a URL prefix: legacy regexes also match inside + // query strings and prefixed paths. Only the read-only status handler is public. + let public_status = route.method == Method::Get && route.path == "/status"; + if !(public_status || auth::authorized(server.api_key.as_deref(), &request.headers)) { + let mut response = json_response(401, &error_model("Unauthorized")); + response.set_header("WWW-Authenticate", "Bearer realm=\"AAEmu Web API\""); + return Ok(response); + } let target = route.target.clone(); let ctx = ControllerCtx { server: server.server.upgrade(), @@ -121,6 +137,7 @@ async fn dispatch( method: parts.method.as_str().to_string(), url, protocol: format!("{:?}", parts.version), + headers: parts.headers, body: String::from_utf8_lossy(&bytes).into_owned(), }; to_axum(on_received_request(&server, request).await) @@ -141,7 +158,8 @@ impl std::fmt::Debug for WebApiService { } /// `config.Host.Equals("*") ? IPAddress.Any : IPAddress.Parse(config.Host)`. -pub fn bind_address(config: &NetworkConfig) -> anyhow::Result { +pub fn bind_address(config: &WebApiConfig) -> anyhow::Result { + auth::validate_key(config.api_key.as_deref())?; let ip: IpAddr = if config.host == "*" { IpAddr::V4(Ipv4Addr::UNSPECIFIED) } else { @@ -150,6 +168,10 @@ pub fn bind_address(config: &NetworkConfig) -> anyhow::Result { .parse() .map_err(|_| anyhow::anyhow!("An invalid IP address was specified."))? }; + anyhow::ensure!( + ip.is_loopback() || config.api_key.as_ref().is_some_and(|key| !key.is_empty()), + "WebApiNetwork.ApiKey is required for a non-loopback Host; use 127.0.0.1 for local status tooling or set Enabled to false" + ); Ok(SocketAddr::new(ip, config.port)) } @@ -160,8 +182,15 @@ impl WebApiService { tracing::warn!("WebApi server configuration not found. WebApi will not start"); return Ok(()); }; + if !config.enabled { + tracing::info!("WebApi server disabled by configuration"); + return Ok(()); + } let addr = bind_address(&config)?; - let api = Arc::new(WebApiServer::new(Arc::downgrade(server))?); + let mut api = WebApiServer::new(Arc::downgrade(server))?; + // Use the same snapshot that passed the bind check even during a config reload. + api.api_key = config.api_key.clone(); + let api = Arc::new(api); let listener = match tokio::net::TcpListener::bind(addr).await { Ok(l) => l, Err(e) => { @@ -202,5 +231,7 @@ impl WebApiService { } } +#[cfg(test)] +mod auth_tests; #[cfg(test)] mod session_tests; diff --git a/rust/crates/aaemu-game/src/systems/services/webapi/session_tests.rs b/rust/crates/aaemu-game/src/systems/services/webapi/session_tests.rs index abbcd6d17a..a0f2d2384b 100644 --- a/rust/crates/aaemu-game/src/systems/services/webapi/session_tests.rs +++ b/rust/crates/aaemu-game/src/systems/services/webapi/session_tests.rs @@ -3,6 +3,7 @@ use std::sync::Weak; +use super::auth_tests::{authenticated, TEST_KEY}; use super::http::{ok_html, HttpRequest}; use super::route_mapper::{handler, Controller, Method, RouteMapper, RouteSpec}; use super::*; @@ -65,7 +66,9 @@ fn server() -> WebApiServer { mapper .discover_routes_from_type::() .unwrap(); - WebApiServer::with_routes(mapper, Weak::new()) + let mut api = WebApiServer::with_routes(mapper, Weak::new()); + api.api_key = Some(TEST_KEY.into()); + api } #[tokio::test] @@ -89,7 +92,11 @@ async fn on_received_request_when_route_found_should_return_html() { ("GET", "/test/1", "test"), ("POST", "/test/1", "test-post"), ] { - let r = on_received_request(&server(), HttpRequest::new(method, path, "HTTP/1.1")).await; + let r = on_received_request( + &server(), + authenticated(HttpRequest::new(method, path, "HTTP/1.1")), + ) + .await; assert_eq!(r.status, 200, "{method} {path}"); assert_eq!(r.status_phrase, "OK"); assert_eq!(r.content_type(), Some("text/html")); @@ -111,7 +118,11 @@ async fn on_received_request_when_route_found_with_regex_should_return_html_with ["players", "search"], ), ] { - let r = on_received_request(&server(), HttpRequest::new(method, path, "HTTP/1.1")).await; + let r = on_received_request( + &server(), + authenticated(HttpRequest::new(method, path, "HTTP/1.1")), + ) + .await; assert_eq!(r.status, 200); assert_eq!(r.status_phrase, "OK"); assert_eq!(r.content_type(), Some("text/html")); @@ -126,7 +137,11 @@ async fn on_received_request_when_route_found_with_regex_should_return_html_with #[tokio::test] async fn controller_errors_produce_the_500_page() { - let r = on_received_request(&server(), HttpRequest::new("GET", "/fail", "HTTP/1.1")).await; + let r = on_received_request( + &server(), + authenticated(HttpRequest::new("GET", "/fail", "HTTP/1.1")), + ) + .await; assert_eq!(r.status, 500); assert_eq!(r.status_phrase, "Internal Server Error"); assert_eq!(r.content_type(), Some("text/html")); @@ -168,7 +183,7 @@ async fn served_over_http() { }); let mut s = tokio::net::TcpStream::connect(addr).await.unwrap(); s.write_all( - b"POST /multipleMatches/a/b?x=1 HTTP/1.1\r\nHost: x\r\nContent-Length: 0\r\nConnection: close\r\n\r\n", + b"POST /multipleMatches/a/b?x=1 HTTP/1.1\r\nHost: x\r\nAuthorization: Bearer synthetic-webapi-test-key\r\nContent-Length: 0\r\nConnection: close\r\n\r\n", ) .await .unwrap(); From e2e9744b59d094b2ceb74c63626336664071a59f Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:36:19 -0400 Subject: [PATCH 05/66] fix(economy): authorize bench recipes by active craft function Allow private plaque visitors to craft recipes offered with Any permission. Validate authored pack membership, current function permissions, station identity, house existence, instance and range at craft start and product commit. Preserve portable crafts and legacy authored CraftStart lists. Add native 1.2 based packet/skill flow regressions and a read-only compact assertion for all 23 tax plaque crafting phases. Validation is source-only per parent resource restriction; rustfmt and git diff checks pass, with Cargo and live checks deferred to parent. Co-Authored-By: Codex --- .../src/systems/economy/bench_tests.rs | 501 ++++++++++++++++++ .../aaemu-game/src/systems/economy/bridges.rs | 14 - .../aaemu-game/src/systems/economy/craft.rs | 246 ++++----- .../src/systems/economy/craft_data.rs | 11 +- .../src/systems/housing/access_tests.rs | 33 ++ .../aaemu-game/src/systems/npcs/bridges.rs | 37 ++ 6 files changed, 689 insertions(+), 153 deletions(-) create mode 100644 rust/crates/aaemu-game/src/systems/economy/bench_tests.rs diff --git a/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs b/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs new file mode 100644 index 0000000000..a9249f3807 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs @@ -0,0 +1,501 @@ +//! Craft station authorization through CSExecuteCraft and the real skill/CraftEffect flow. +//! Source fixtures: read-only 1.2 compact, native `sub_398A9480`, and PACKETS.md CS 0xf8 / +//! SC 0x10a (D:/aa-re/client12/decomp). No packet bytes are derived from Rust encoders. + +use std::sync::Arc; + +use aaemu_commons::PacketStream; + +use super::{doodad_func_permission as permission, CSExecuteCraft}; +use crate::data::{items::ItemTemplate, GameData}; +use crate::models::doodad::{doodad_owner_type, Doodad}; +use crate::models::house::{housing_permission, House}; +use crate::net::registry::ClientPacket; +use crate::opcodes::sc; +use crate::server::GameServer; +use crate::systems::economy::bridges::{EconomyComposite, EconomyForSkills}; +use crate::systems::economy::craft_data::{Craft, CraftProduct, CraftSkill}; +use crate::systems::economy::inventory::Inv; +use crate::systems::npcs::doodad::templates::{ + DoodadFunc, DoodadFuncCraftPack, DoodadFuncParentInfo, FuncTemplate, +}; +use crate::systems::skills::data::{EffectKind, EffectTemplate, SkillTemplate}; +use crate::systems::skills::types::SkillTargetType; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use crate::world::{DoodadRef, Entity, HouseRef, PlayerRef}; + +const TAX: u32 = 76; +const CERTIFICATE: u32 = 31892; +const SKILL: u32 = 16767; +const BENCH: u32 = 0x300; +const RESTRICTED_GROUP: u32 = 90000; +const WRONG_PACK_GROUP: u32 = 90001; +const PORTABLE: u32 = 90002; +const OTHER_RECIPE: u32 = 90003; +const HOUSE_PERMISSION_GROUP: u32 = 90004; + +// One live tax CraftPack phase per plaque template (other authored phases are checked by +// the ignored real-data test below). The recipe's req_doodad_id is always canonical 2392. +const PLAQUES: [(u32, u32, u32); 8] = [ + (2392, 6172, 298), + (973, 1240, 297), + (5767, 14787, 313), + (7340, 20054, 301), + (7341, 20058, 305), + (7342, 20062, 309), + (8249, 23031, 325), + (7308, 19956, 300), +]; + +fn add_pack(data: &mut GameData, group: u32, func_id: u32, pack: u32, perm: u8) { + let doodads = &mut data.systems.npcs.doodad; + doodads.funcs_by_groups.insert( + group, + vec![ + // ParentInfo precedes CraftPack on the real plaques. Its permission must not + // authorize a different function (especially the owner-only pack below). + DoodadFunc { + group_id: group, + func_id: 1, + func_type: "DoodadFuncParentInfo".into(), + ..Default::default() + }, + DoodadFunc { + group_id: group, + func_id, + func_type: "DoodadFuncCraftPack".into(), + perm_id: u32::from(perm), + ..Default::default() + }, + ], + ); + doodads + .func_templates + .entry("DoodadFuncParentInfo") + .or_default() + .insert(1, FuncTemplate::ParentInfo(DoodadFuncParentInfo { id: 1 })); + doodads + .func_templates + .entry("DoodadFuncCraftPack") + .or_default() + .insert( + func_id, + FuncTemplate::CraftPack(DoodadFuncCraftPack { + id: func_id, + craft_pack_id: pack, + }), + ); +} + +fn data(cast_time: i32) -> GameData { + let mut data = crate::systems::economy::tests::test_data(); + data.items + .templates + .insert(CERTIFICATE, ItemTemplate::plain(CERTIFICATE, 1000)); + for (id, skill_id, req_doodad_id, is_pack) in [ + (TAX, SKILL, 2392, true), + (PORTABLE, PORTABLE, 0, false), + (OTHER_RECIPE, SKILL, 2392, true), + ] { + data.systems.economy.craft.crafts.insert( + id, + Craft { + id, + skill_id, + req_doodad_id, + is_pack, + craft_products: vec![CraftProduct { + craft_id: id, + item_id: CERTIFICATE, + amount: 5, + rate: 100, + ..Default::default() + }], + ..Default::default() + }, + ); + } + data.systems + .economy + .craft + .craft_pack_crafts + .insert(3, [TAX].into()); + data.systems + .economy + .craft + .craft_pack_crafts + .insert(4, [OTHER_RECIPE].into()); + for (id, target_type) in [ + (SKILL, SkillTargetType::Doodad), + (PORTABLE, SkillTargetType::SelfTarget), + ] { + data.systems.economy.craft.skills.insert( + id, + CraftSkill { + id, + consume_labor_power: 200, + actability_group_id: 19, + // Give the test time to change permissions between completed batch steps. + cooldown_time: 50, + }, + ); + data.systems.skills.add_skill(SkillTemplate { + target_type: target_type as i32, + max_range: 12, + consume_labor_power: 200, + actability_group_id: 19, + casting_time: cast_time, + target_selection: 2, + target_area_count: 1, + effects: vec![crate::systems::skills::tests::skill_effect( + 1, + EffectKind::CraftEffect, + 1, + )], + ..crate::systems::skills::tests::skill_template(id) + }); + } + data.systems.skills.add_effect( + EffectKind::CraftEffect, + EffectTemplate::Craft { + id: 1, + world_interaction: 37, + }, + 1, + ); + data.systems + .npcs + .area_trigger + .world_interaction_groups + .insert( + 37, + crate::systems::npcs::area_trigger::world_interaction_group::CRAFT, + ); + for (_, group, func) in PLAQUES { + add_pack(&mut data, group, func, 3, permission::ANY); + } + add_pack( + &mut data, + RESTRICTED_GROUP, + 90000, + 3, + permission::OWNER_ONLY, + ); + add_pack(&mut data, WRONG_PACK_GROUP, 90001, 4, permission::ANY); + add_pack( + &mut data, + HOUSE_PERMISSION_GROUP, + 90004, + 3, + permission::PERMISSION1, + ); + data +} + +struct Fixture { + server: Arc, + client: TestClient, + visitor: PlayerRef, + owner_client: TestClient, + owner: PlayerRef, + house: HouseRef, + bench: DoodadRef, +} + +fn fixture(template: u32, group: u32, cast_time: i32) -> Fixture { + let server = Arc::new(test_server_with(data(cast_time))); + server.set_self(); + crate::systems::skills::install_hooks(&server); + server + .systems + .skills + .ext + .items + .install(Arc::new(EconomyForSkills)); + server + .systems + .economy + .craft + .hooks + .install(Arc::new(EconomyComposite)); + let mut client = TestClient::new(&server, 1, 1001); + let mut owner_client = TestClient::new(&server, 2, 1002); + let visitor = spawn_player( + &server, + &client, + test_character(1, "Visitor", 100.0, 100.0), + 0x100, + ); + let owner = spawn_player( + &server, + &owner_client, + test_character(2, "Owner", 101.0, 100.0), + 0x101, + ); + client.conn.active_char = Some(visitor.clone()); + owner_client.conn.active_char = Some(owner.clone()); + visitor.data().labor_power = 1000; + owner.data().labor_power = 1000; + server.names.add_character(1, "Visitor", 1001); + server.names.add_character(2, "Owner", 1002); + let mut house = House::new(1, 267); + house.current_step = -1; + house.unit.owner_id = 2; + house.account_id = 1002; + let house = Entity::new(0x200, house); + assert!(server.systems.housing.manager.insert(&house)); + let mut bench = Doodad::new(template); + bench.owner_type = doodad_owner_type::HOUSING; + bench.owner_db_id = 1; + bench.owner_id = 2; + bench.func_group_id = group; + bench.transform.set_xyz(101.0, 100.0, 100.0); + let bench = Entity::new(BENCH, bench); + server + .world + .world(0) + .unwrap() + .spawn(&bench, &server.view_ctx()); + client.drain(); + owner_client.drain(); + Fixture { + server, + client, + visitor, + owner_client, + owner, + house, + bench, + } +} + +async fn request( + server: &GameServer, + client: &mut TestClient, + craft: u32, + target: u32, + count: i32, +) { + // Native 1.2 CS 0xf8: recipe:u32, object:BC (3 bytes), count:i32. + let body = [ + craft.to_le_bytes().as_slice(), + &target.to_le_bytes()[..3], + &count.to_le_bytes(), + ] + .concat(); + let packet = CSExecuteCraft::read(&mut PacketStream::from_bytes(body)).unwrap(); + packet.handle(server, &mut client.conn).await.unwrap(); +} + +fn certificates(player: &PlayerRef) -> i32 { + Inv::of(player).items_count(CERTIFICATE, -1) +} + +fn assert_denied(f: &mut Fixture) { + assert!(!f.server.systems.economy.craft.is_crafting(1)); + assert_eq!(certificates(&f.visitor), 0); + // Native 1.2 SC 0x10a: i16 148, i16 135, u32 0, bool false (PACKETS.md). + assert!(f + .client + .drain() + .contains(&(sc::SCErrorMsgPacket, vec![148, 0, 135, 0, 0, 0, 0, 0, 0]))); +} + +#[tokio::test] +async fn private_farm_visitor_crafts_tax_at_all_eight_authored_plaques_for_200_labor() { + for (template, group, _) in PLAQUES { + let mut f = fixture(template, group, 0); + assert!(!crate::systems::housing::allowed_to_interact( + &f.server, &f.house, &f.visitor + )); + request(&f.server, &mut f.client, TAX, BENCH, 1).await; + assert_eq!(certificates(&f.visitor), 5, "plaque {template}"); + assert_eq!(f.visitor.data().labor_power, 800, "plaque {template}"); + } +} + +#[tokio::test] +async fn current_craft_pack_permission_beats_first_parent_info_and_public_house() { + let mut f = fixture(2392, RESTRICTED_GROUP, 0); + request(&f.server, &mut f.client, TAX, BENCH, 1).await; + assert_denied(&mut f); + f.house.data().permission = housing_permission::PUBLIC; + request(&f.server, &mut f.client, TAX, BENCH, 1).await; + assert_denied(&mut f); + assert_eq!(f.visitor.data().labor_power, 1000); + request(&f.server, &mut f.owner_client, TAX, BENCH, 1).await; + assert_eq!(certificates(&f.owner), 5); + assert_eq!(f.owner.data().labor_power, 800); +} + +#[tokio::test] +async fn craft_packet_rejects_wrong_recipe_pack_and_inactive_phase_even_at_canonical_id() { + for (recipe, group) in [ + (OTHER_RECIPE, 6172), + (TAX, WRONG_PACK_GROUP), + (TAX, 0), + (PORTABLE, 6172), + ] { + let mut f = fixture(2392, group, 0); + request(&f.server, &mut f.client, recipe, BENCH, 1).await; + assert_denied(&mut f); + assert_eq!(f.visitor.data().labor_power, 1000); + } +} + +#[tokio::test] +async fn craft_packet_rejects_unknown_deleted_missing_house_far_and_cross_instance_benches() { + for case in 0..9 { + let mut f = fixture(973, 1240, 0); + let target = match case { + 0 => 0x999, + 1 => 0, // tax certificates require a station + 2 => { + f.bench.data().phase.deleted = true; + BENCH + } + 3 => { + f.bench.data().owner_db_id = 999; + BENCH + } + 4 => { + f.bench.data().transform.set_xyz(200.0, 100.0, 100.0); + BENCH + } + 5 => { + f.bench.data().transform.instance_id = 1; + BENCH + } + 6 => { + f.house.data().unit.transform.instance_id = 1; + BENCH + } + 7 => { + f.bench.data().transform.x = f32::NAN; + BENCH + } + _ => f.owner.obj_id, // a unit is not a station + }; + request(&f.server, &mut f.client, TAX, target, 1).await; + assert_denied(&mut f); + assert_eq!(f.visitor.data().labor_power, 1000, "case {case}"); + } +} + +#[tokio::test] +async fn portable_craft_still_completes_without_a_doodad() { + for target in [0, 0x100] { + let mut f = fixture(973, 1240, 0); + request(&f.server, &mut f.client, PORTABLE, target, 1).await; + assert_eq!(certificates(&f.visitor), 5); + assert_eq!(f.visitor.data().labor_power, 800); + } +} + +async fn wait_for_batch_stop(f: &Fixture) { + tokio::time::timeout(std::time::Duration::from_secs(2), async { + while f + .server + .systems + .economy + .craft + .state(1) + .current_craft + .is_some() + { + tokio::time::sleep(std::time::Duration::from_millis(10)).await; + } + }) + .await + .expect("craft must finish or refuse the remaining batch"); +} + +#[tokio::test] +async fn changing_craft_function_during_a_batch_rechecks_before_product_commit() { + for group in [RESTRICTED_GROUP, WRONG_PACK_GROUP] { + // The real skill timer leaves a window to change the active phase during casting. + let mut f = fixture(973, 1240, 100); + crate::systems::skills::bind(&f.server); + request(&f.server, &mut f.client, TAX, BENCH, 2).await; + assert!(f.server.systems.economy.craft.is_crafting(1)); + assert_eq!(certificates(&f.visitor), 0); + f.bench.data().func_group_id = group; + wait_for_batch_stop(&f).await; + assert_denied(&mut f); + } +} + +#[tokio::test] +async fn changing_craft_function_between_batch_steps_refuses_the_next_cast() { + let mut f = fixture(973, 1240, 0); + request(&f.server, &mut f.client, TAX, BENCH, 2).await; + assert_eq!(certificates(&f.visitor), 5); + assert_eq!(f.visitor.data().labor_power, 800); + f.bench.data().func_group_id = RESTRICTED_GROUP; + wait_for_batch_stop(&f).await; + assert_eq!(certificates(&f.visitor), 5); + assert_eq!(f.visitor.data().labor_power, 800); + assert!(f + .client + .drain() + .contains(&(sc::SCErrorMsgPacket, vec![148, 0, 135, 0, 0, 0, 0, 0, 0]))); +} + +#[tokio::test] +async fn changing_house_permission_during_a_batch_rechecks_before_product_commit() { + let mut f = fixture(973, HOUSE_PERMISSION_GROUP, 100); + f.house.data().permission = housing_permission::PUBLIC; + crate::systems::skills::bind(&f.server); + request(&f.server, &mut f.client, TAX, BENCH, 2).await; + assert!(f.server.systems.economy.craft.is_crafting(1)); + f.house.data().permission = housing_permission::PRIVATE; + wait_for_batch_stop(&f).await; + assert_denied(&mut f); +} + +#[tokio::test] +#[ignore] +async fn real_compact_db_bench_craft_packs_include_every_tax_plaque_phase() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + rusqlite::Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY) + .unwrap(); + let files = + crate::data::client_files::ClientFileManager::from_sources(&[], std::path::Path::new(".")); + let ctx = crate::systems::DataLoadCtx { + conn: &conn, + files: &files, + app_path: std::path::Path::new("."), + language: "en_us", + }; + let mut data = GameData::empty(); + data.systems.economy.craft = + crate::systems::economy::craft_data::CraftData::load(&ctx).unwrap(); + data.systems.npcs.doodad = + crate::systems::npcs::doodad::data::DoodadData::load_from(&conn).unwrap(); + assert_eq!( + data.systems.economy.craft.craft(TAX).unwrap().req_doodad_id, + 2392 + ); + assert!(data.systems.economy.craft.craft_pack_crafts[&3].contains(&TAX)); + // Exercise all phases that actually contain CraftPack (not the Garden's loot phase). + let phases: Vec<(u32, u32)> = conn.prepare( + "SELECT g.doodad_almighty_id, g.id FROM doodad_func_groups g JOIN doodad_funcs f ON f.doodad_func_group_id = g.id WHERE f.actual_func_type = 'DoodadFuncCraftPack' AND g.doodad_almighty_id IN (2392,973,5767,7340,7341,7342,8249,7308)" + ).unwrap().query_map([], |r| Ok((r.get(0)?, r.get(1)?))).unwrap().collect::>().unwrap(); + assert_eq!(phases.len(), 23); + let server = test_server_with(data); + for (template, group) in phases { + let mut doodad = Doodad::new(template); + doodad.func_group_id = group; + assert_eq!( + crate::systems::npcs::bridges::doodad_craft_permission( + &server, + &Entity::new(BENCH, doodad), + TAX + ), + Some(permission::ANY) + ); + } +} diff --git a/rust/crates/aaemu-game/src/systems/economy/bridges.rs b/rust/crates/aaemu-game/src/systems/economy/bridges.rs index b4e4518020..4e6a18acd4 100644 --- a/rust/crates/aaemu-game/src/systems/economy/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/economy/bridges.rs @@ -3444,20 +3444,6 @@ impl super::craft::CraftHooks for EconomyComposite { crate::systems::skills::skill::interrupt_skills(server, &me); } - fn doodad_func_permission(&self, server: &GameServer, doodad: &DoodadRef) -> u8 { - let group = doodad.data().func_group_id; - server - .game_data - .systems - .npcs - .doodad - .doodad_funcs(group) - .first() - .map_or(super::craft::doodad_func_permission::ANY, |f| { - f.perm_id as u8 - }) - } - fn account_house_zone_ids(&self, server: &GameServer, account_id: u32) -> Vec { server .systems diff --git a/rust/crates/aaemu-game/src/systems/economy/craft.rs b/rust/crates/aaemu-game/src/systems/economy/craft.rs index a28fdafb41..7645f78c28 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft.rs @@ -37,6 +37,10 @@ use super::error_message; use super::inventory::{self, Inv, ItemTxn, Out}; use super::item_handlers::{active, sync_client_packet}; +#[cfg(test)] +#[path = "bench_tests.rs"] +mod bench_tests; + /// `DoodadFuncPermission`. pub mod doodad_func_permission { pub const ANY: u8 = 0; @@ -49,7 +53,8 @@ pub mod doodad_func_permission { pub const ZONE_RESIDENTS: u8 = 8; } -/// What crafting needs from other subsystems. Every method has a "not ported yet" default. +/// What crafting needs from other subsystems. Station authorization defaults to the loaded +/// NPC/craft data; the skill, housing bonus and quest hooks are installed at startup. pub trait CraftHooks: Send + Sync { /// skills: `new Skill(SkillManager.GetSkillTemplate(skillId)) { CastTimeMultiplier } /// .Use(owner, SkillCasterUnit(owner.ObjId), SkillCastDoodadTarget(doodadObjId), null, @@ -73,9 +78,15 @@ pub trait CraftHooks: Send + Sync { /// Owner.InterruptSkills();`. fn cancel_craft_skill(&self, _server: &GameServer, _player: &PlayerRef) {} - /// npcs: `Doodad.FuncPermission` (`PermId` of the first current func, `Any` without one). - fn doodad_func_permission(&self, _server: &GameServer, _doodad: &DoodadRef) -> u8 { - doodad_func_permission::ANY + /// npcs: permission of the current crafting function whose authored list contains the + /// recipe. Missing membership denies access, including at the canonical req_doodad_id. + fn doodad_craft_permission( + &self, + server: &GameServer, + doodad: &DoodadRef, + craft_id: u32, + ) -> Option { + crate::systems::npcs::bridges::doodad_craft_permission(server, doodad, craft_id) } /// housing: `HousingManager.GetByAccountId(accountId)` -> the `Transform.ZoneId` of every @@ -221,65 +232,129 @@ pub fn zone_group_id(server: &GameServer, zone_key: u32) -> u32 { .map_or(0, |z| z.group_id) } -/// A direct crafting packet must obey the same house access rules as interacting with -/// its furniture. Portable crafts and public world stations keep their normal skill checks. -fn housing_bench_access( +/// Authorize the recipe against the live station at both cast start and product commit. +fn bench_access( server: &GameServer, player: &PlayerRef, doodad_id: u32, - skill_id: u32, + craft: &Craft, + hooks: &dyn CraftHooks, ) -> bool { - match housing_bench_denial(server, player, doodad_id, skill_id) { + match bench_denial(server, player, doodad_id, craft, hooks) { None => true, Some(reason) => { tracing::warn!( - "{} may not craft at doodad {doodad_id} (skill {skill_id}): {reason}", - player.data().unit.name + craft_id = craft.id, + skill_id = craft.skill_id, + "{} may not craft at doodad {doodad_id}: {reason}", + player.data().unit.name, ); false } } } -/// Why [`housing_bench_access`] refuses (`None` = allowed). -fn housing_bench_denial( +/// Why [`bench_access`] refuses (`None` = allowed). +fn bench_denial( server: &GameServer, player: &PlayerRef, doodad_id: u32, - skill_id: u32, + craft: &Craft, + hooks: &dyn CraftHooks, ) -> Option<&'static str> { - // Not a doodad (portable craft, id 0): allowed. - let doodad = server + // Portable skills can name no target or the crafter. Neither form may bypass a + // station recipe's requirements; every other nonzero target must be a real bench. + if doodad_id == 0 || doodad_id == player.obj_id { + return (craft.req_doodad_id != 0 || craft.is_pack) + .then_some("the recipe requires a crafting station"); + } + let Some(doodad) = server .world .object(doodad_id) - .and_then(|o| o.as_doodad().cloned())?; - let (owner_type, house_id, instance_id, deleted) = { + .and_then(|o| o.as_doodad().cloned()) + else { + return Some("the crafting station does not exist"); + }; + let (owner_type, house_id, owner_id, instance_id, deleted) = { let d = doodad.data(); ( d.owner_type, d.owner_db_id, + d.owner_id, d.transform.instance_id, d.phase.deleted, ) }; - if owner_type != crate::models::doodad::doodad_owner_type::HOUSING { - return None; - } - let Some(house) = crate::systems::housing::house_by_id(server, house_id) else { - return Some("the bench's house does not exist"); - }; if deleted { return Some("the bench is deleted"); } - if player.data().unit.transform.instance_id != instance_id - || house.data().unit.transform.instance_id != instance_id - { - return Some("player, bench and house are in different instances"); + if player.data().unit.transform.instance_id != instance_id { + return Some("player and bench are in different instances"); } - if !crate::systems::housing::allowed_to_interact(server, &house, player) { - return Some("the house does not allow the player to interact"); + let Some(perm) = hooks.doodad_craft_permission(server, &doodad, craft.id) else { + return Some("the current crafting function does not offer this recipe"); + }; + use crate::models::doodad::doodad_owner_type as owner; + let house = if owner_type == owner::HOUSING { + let Some(house) = crate::systems::housing::house_by_id(server, house_id) else { + return Some("the bench's house does not exist"); + }; + if house.data().unit.transform.instance_id != instance_id { + return Some("bench and house are in different instances"); + } + // CraftPack Any explicitly opens the recipe to visitors (including the eight tax + // plaques). Other functions retain the house's access rules. + if perm != doodad_func_permission::ANY + && !crate::systems::housing::allowed_to_interact(server, &house, player) + { + let h = house.data(); + tracing::warn!( + house_id, + house_owner = h.unit.owner_id, + house_permission = h.permission, + craft_id = craft.id, + "Craft bench house access denied" + ); + return Some("the house does not allow the player to interact"); + } + Some(house) + } else { + None + }; + use doodad_func_permission as p; + match perm { + p::ANY | p::PERMISSION1 | p::PERMISSION2 | p::PERMISSION4 | p::OWNER_RAID_MEMBERS => {} + p::OWNER_ONLY => { + let owner_id = house.as_ref().map_or(owner_id, |h| h.data().unit.owner_id); + if owner_id == 0 || player.character_id != owner_id { + return Some("the crafting function requires its owner"); + } + } + p::SAME_ACCOUNT => { + let account = house.as_ref().map(|h| h.data().account_id).or_else(|| { + (owner_type == owner::CHARACTER) + .then(|| server.names.get_character_account(owner_id)) + }); + if account.is_some_and(|a| a == 0 || a != player.data().account_id) { + return Some("the crafting function requires the owner's account"); + } + } + p::ZONE_RESIDENTS => { + let zone_group = zone_group_id(server, doodad.data().transform.zone_id); + let account = player.data().account_id; + if !hooks + .account_house_zone_ids(server, account) + .into_iter() + .any(|zone| zone_group_id(server, zone) == zone_group) + { + return Some("the crafting function requires a zone resident"); + } + } + _ => return Some("the crafting function has an unknown permission"), } - let template = server.game_data.systems.skills.skill(skill_id)?; + let Some(template) = server.game_data.systems.skills.skill(craft.skill_id) else { + return Some("the craft skill does not exist"); + }; if template.max_range <= 0 { return None; } @@ -368,99 +443,11 @@ pub fn craft(server: &GameServer, player: &PlayerRef, craft_id: u32, count: i32, return; } - // Check if we have permission to actually use the doodad (mostly sanity check since the - // client already checks this before you can craft) - let mut has_permission = true; - if !housing_bench_access(server, player, doodad_id, craft.skill_id) { - error2( - &mut out, - player, - error_message::CRAFT_CANT_ACT_ANY_MORE, - error_message::CRAFT_PERMISSION_DENY, - 0, - false, - ); - cancel_craft(server, player); + if !bench_access(server, player, doodad_id, craft, hooks.as_ref()) { + abort_craft_with(server, player, error_message::CRAFT_PERMISSION_DENY); return; } let world = server.world.world_of(&WorldObject::from(player)); - let doodad = world.as_ref().and_then(|w| w.doodad(doodad_id)); - if let Some(doodad) = &doodad { - let perm = hooks.doodad_func_permission(server, doodad); - if perm != doodad_func_permission::ANY { - use doodad_func_permission as p; - match perm { - p::ANY - | p::PERMISSION1 - | p::PERMISSION2 - | p::OWNER_ONLY - | p::PERMISSION4 - | p::OWNER_RAID_MEMBERS => {} - p::SAME_ACCOUNT => { - let (owner_type, owner_id) = { - let d = doodad.data(); - (d.owner_type, d.owner_id) - }; - if owner_type == crate::models::doodad::doodad_owner_type::CHARACTER { - let my_account = player.data().account_id; - has_permission = match server.world.character_by_id(owner_id) { - Some(o) => o.data().account_id == my_account, - None => { - // C#: GetCharacterById(...).AccountId -> NullReferenceException - // (the client stayed locked). Deviation: no permission. - tracing::error!( - "Craft: doodad owner {owner_id} is not online (C# throws)" - ); - false - } - }; - } - } - p::ZONE_RESIDENTS => { - has_permission = false; - let zone_group = zone_group_id(server, doodad.data().transform.zone_id); - let account = player.data().account_id; - for house_zone in hooks.account_house_zone_ids(server, account) { - if zone_group_id(server, house_zone) == zone_group { - has_permission = true; - break; - } - } - } - _ => { - // C#: throw new ArgumentOutOfRangeException (the client stayed locked). - // Deviation: no permission. - tracing::error!("Craft: unknown DoodadFuncPermission {perm}"); - has_permission = false; - } - } - let (template_id, obj_id) = (doodad.data().template_id, doodad.obj_id); - send_debug_message( - server, - &mut out, - player, - &format!( - "Crafting using @DOODAD_NAME({template_id}) - {template_id} (objId: {obj_id}) with current permission {} = {}", - permission_name(perm), - if has_permission { "True" } else { "False" } - ), - ); - } - } - - if !has_permission { - // TODO not verified - error2( - &mut out, - player, - error_message::CRAFT_CANT_ACT_ANY_MORE, - error_message::CRAFT_PERMISSION_DENY, - 0, - false, - ); - cancel_craft(server, player); - return; - } mgr.update(char_id, |s| s.is_crafting = true); @@ -628,21 +615,6 @@ pub fn cast_failed(server: &GameServer, player: &PlayerRef, skill_id: u32, resul } } -fn permission_name(perm: u8) -> &'static str { - use doodad_func_permission as p; - match perm { - p::ANY => "Any", - p::PERMISSION1 => "Permission1", - p::PERMISSION2 => "Permission2", - p::OWNER_ONLY => "OwnerOnly", - p::PERMISSION4 => "Permission4", - p::OWNER_RAID_MEMBERS => "OwnerRaidMembers", - p::SAME_ACCOUNT => "SameAccount", - p::ZONE_RESIDENTS => "ZoneResidents", - _ => "?", - } -} - /// `CharacterCraft.EndCraft()` (called by the skills subsystem when the craft skill's /// `CraftEffect` applies). pub fn end_craft(server: &GameServer, player: &PlayerRef) { @@ -698,7 +670,7 @@ pub fn end_craft(server: &GameServer, player: &PlayerRef) { .lock() .unwrap_or_else(|e| e.into_inner()) }); - if !housing_bench_access(server, player, state.doodad_id, craft.skill_id) { + if !bench_access(server, player, state.doodad_id, craft, mgr.hooks().as_ref()) { drop(operation); error2( &mut Out::Direct, diff --git a/rust/crates/aaemu-game/src/systems/economy/craft_data.rs b/rust/crates/aaemu-game/src/systems/economy/craft_data.rs index a8c0a9981c..ef3a412322 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft_data.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft_data.rs @@ -2,7 +2,7 @@ //! `craft_materials`, `craft_pack_crafts`) and the `SkillTemplate` members `CharacterCraft` reads //! for a craft's skill (`consume_lp`, `actability_group_id`, `cooldown_time`). -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use crate::data::items::TemplateKind; use crate::data::sqlite::for_each_row; @@ -81,6 +81,8 @@ pub struct CraftData { pub crafts: HashMap, /// Skill facts of every skill a craft uses (`SkillManager.GetSkillTemplate(craft.SkillId)`). pub skills: HashMap, + /// Recipes explicitly offered by each `DoodadFuncCraftPack`. + pub craft_pack_crafts: HashMap>, } impl CraftData { @@ -140,8 +142,13 @@ impl CraftData { Ok(()) })?; for_each_row(ctx.conn, "SELECT * FROM craft_pack_crafts", [], |r| { - if let Some(craft) = d.crafts.get_mut(&r.u32("craft_id")?) { + let craft_id = r.u32("craft_id")?; + if let Some(craft) = d.crafts.get_mut(&craft_id) { craft.is_pack = true; + d.craft_pack_crafts + .entry(r.u32("craft_pack_id")?) + .or_default() + .insert(craft_id); } Ok(()) })?; diff --git a/rust/crates/aaemu-game/src/systems/housing/access_tests.rs b/rust/crates/aaemu-game/src/systems/housing/access_tests.rs index 69fb9c22df..ce247cb438 100644 --- a/rust/crates/aaemu-game/src/systems/housing/access_tests.rs +++ b/rust/crates/aaemu-game/src/systems/housing/access_tests.rs @@ -329,6 +329,38 @@ fn fixture_with_limits(always_public: bool, overall_limit: u32, group_limit: Opt 1, FuncTemplate::RecoverItem(DoodadFuncRecoverItem { id: 1 }), ); + // Crafting requires a current function that explicitly offers the recipe. Permission1 + // retains the house policy exercised below; recoverable furniture alone is no bench. + data.systems.npcs.doodad.funcs_by_groups.insert( + 71, + vec![DoodadFunc { + group_id: 71, + func_id: 1, + func_type: "DoodadFuncCraftPack".into(), + perm_id: 1, + ..Default::default() + }], + ); + data.systems + .npcs + .doodad + .func_templates + .entry("DoodadFuncCraftPack") + .or_default() + .insert( + 1, + FuncTemplate::CraftPack( + crate::systems::npcs::doodad::templates::DoodadFuncCraftPack { + id: 1, + craft_pack_id: 88, + }, + ), + ); + data.systems + .economy + .craft + .craft_pack_crafts + .insert(88, [88].into()); let server = test_server_with(data); let eco = Arc::new(Eco::default()); server.systems.housing.hooks.install(eco.clone()); @@ -493,6 +525,7 @@ impl crate::systems::economy::craft::CraftHooks for BenchRecorder { fn bench(fx: &Fx) -> (DoodadRef, Arc) { let d = recoverable(fx); + d.data().func_group_id = 71; d.data().transform.set_xyz(101.0, 100.0, 100.0); fx.server .world diff --git a/rust/crates/aaemu-game/src/systems/npcs/bridges.rs b/rust/crates/aaemu-game/src/systems/npcs/bridges.rs index 89a2ff1c09..babc3649e8 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/bridges.rs @@ -28,6 +28,43 @@ use super::doodad::manager as doodads; /// `BaseUnitType.Npc`. const BASE_UNIT_TYPE_NPC: u32 = 1; + +/// Permission of the current function that actually offers this recipe. The 1.2 client's +/// `sub_398A9480` checks both legacy CraftStart lists and CraftPack membership before sending +/// CSExecuteCraft; another function in the same phase (such as ParentInfo) grants no access. +pub fn doodad_craft_permission( + server: &GameServer, + doodad: &crate::world::DoodadRef, + craft_id: u32, +) -> Option { + use super::doodad::templates::FuncTemplate; + let group = doodad.data().func_group_id; + let data = &server.game_data.systems.npcs.doodad; + let crafts = &server.game_data.systems.economy.craft; + data.doodad_funcs(group).iter().find_map(|func| { + let offers_craft = match data.func_template(func.func_id, &func.func_type)? { + FuncTemplate::CraftPack(pack) => crafts + .craft_pack_crafts + .get(&pack.craft_pack_id) + .is_some_and(|recipes| recipes.contains(&craft_id)), + FuncTemplate::CraftStart(start) => data + .phase_func_templates + .get("DoodadFuncCraftStartCraft") + .is_some_and(|recipes| { + recipes.values().any(|recipe| { + matches!(recipe, FuncTemplate::CraftStartCraft(r) + if r.doodad_func_craft_start_id == start.id && r.craft_id == craft_id) + }) + }), + _ => false, + }; + if !offers_craft { + return None; + } + u8::try_from(func.perm_id).ok() + }) +} + /// Installs this subsystem's hook implementations into the other subsystems. pub fn install(server: &GameServer) { install_economy(server); From eb42882422b14b29c880ed2ef618c6ea9970f681 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:41:36 -0400 Subject: [PATCH 06/66] docs: record reviewed audit fixes and protocol checks --- rust/docs/audit-repair-status.json | 414 +++++++++++++++++++++++------ 1 file changed, 335 insertions(+), 79 deletions(-) diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json index 767fb74be8..94ab6d119d 100644 --- a/rust/docs/audit-repair-status.json +++ b/rust/docs/audit-repair-status.json @@ -3,85 +3,341 @@ "baseline": "37e6f1aec", "status": "in_progress", "policy": "A finding closes only with source evidence and appropriate validation; missing native/content evidence stays explicit.", - "sources": ["protocol-and-logs", "opcode-table-gaps", "items-economy", "skills-combat-ai", "quests-social-progression", "housing-doodads", "vehicles-pvp-instances", "character-account-world"], + "sources": [ + "protocol-and-logs", + "opcode-table-gaps", + "items-economy", + "skills-combat-ai", + "quests-social-progression", + "housing-doodads", + "vehicles-pvp-instances", + "character-account-world" + ], "items": [ - {"id":"mail-return", "status":"implementing", "owner":"audit-protocol"}, - {"id":"loot-error-width", "status":"implementing", "owner":"audit-protocol"}, - {"id":"merchant-grade", "status":"implementing", "owner":"audit-economy"}, - {"id":"craft-grade-flags", "status":"implementing", "owner":"audit-economy"}, - {"id":"web-api-authentication", "status":"implementing", "owner":"audit-web"}, - {"id":"housing-bench-plaque-permissions", "status":"queued"}, - {"id":"craft-bench-pack-and-required-doodad", "status":"queued"}, - {"id":"closed-and-unknown-zones", "status":"queued"}, - {"id":"national-tax-rate", "status":"queued"}, - {"id":"vehicle-attachment-data", "status":"queued"}, - {"id":"ordinary-warning-noise-and-cleanup-cause", "status":"queued"}, - {"id":"slave-owned-doodad-housing-lookup", "status":"queued"}, - {"id":"aoe-diminishing", "status":"queued"}, - {"id":"skill-and-buff-modifiers", "status":"queued"}, - {"id":"buff-group-rank-and-per-caster-slots", "status":"queued"}, - {"id":"reflection", "status":"queued"}, - {"id":"attack-speed", "status":"queued"}, - {"id":"buff-breakers", "status":"queued"}, - {"id":"buff-taunts", "status":"queued"}, - {"id":"casting-hit-delay-and-cancellation", "status":"queued"}, - {"id":"item-procs-and-set-procs", "status":"queued"}, - {"id":"shared-cooldown-tags", "status":"queued"}, - {"id":"xp-buff-multiplier", "status":"queued"}, - {"id":"zone-banned-item-and-skill-tags", "status":"queued"}, - {"id":"unit-and-primary-stat-limits", "status":"queued"}, - {"id":"prison-and-other-skill-restrictions", "status":"queued"}, - {"id":"damage-threat-percent-health-and-level-interpolation", "status":"queued"}, - {"id":"recipe-learning", "status":"queued"}, - {"id":"npc-groups", "status":"queued"}, - {"id":"npc-linked-aggro-and-missing-ai", "status":"queued"}, - {"id":"npc-alert-dead-events-and-friendship", "status":"queued"}, - {"id":"remaining-buff-attributes-and-controller-kinds", "status":"queued"}, - {"id":"stealth-visibility", "status":"queued"}, - {"id":"trade-pack-pricing-config-ratios-and-persistence", "status":"queued"}, - {"id":"premium-and-aa-points", "status":"queued"}, - {"id":"second-password-and-item-security", "status":"queued"}, - {"id":"item-level-gender-pickup-and-use-limits", "status":"queued"}, - {"id":"tempering-and-socket-data-rules", "status":"queued"}, - {"id":"craft-binding-and-required-grade", "status":"queued"}, - {"id":"mail-expiry-throttling-feedback-and-pagination", "status":"queued"}, - {"id":"npc-physical-enchant", "status":"queued"}, - {"id":"auction-filter-limits-and-authority", "status":"queued"}, - {"id":"missing-item-and-quest-feedback-packets", "status":"queued"}, - {"id":"quest-spawn-coverage", "status":"queued"}, - {"id":"nation-and-faction-flows", "status":"queued"}, - {"id":"bounty-board", "status":"queued"}, - {"id":"achievement-producers", "status":"queued"}, - {"id":"quest-and-skill-unit-requirements", "status":"queued"}, - {"id":"trial-jury-expedition-rename-and-quest-edge-fields", "status":"queued"}, - {"id":"doodad-phase-messages", "status":"queued"}, - {"id":"territory-statue-insert-counter", "status":"queued"}, - {"id":"navigation-doodad-expiry", "status":"queued"}, - {"id":"crest-printer-and-ucc", "status":"queued"}, - {"id":"house-repair-and-farm-notifications", "status":"queued"}, - {"id":"doodad-area-trigger-and-evidence-loot", "status":"queued"}, - {"id":"remaining-gathering-funcs", "status":"queued"}, - {"id":"puzzle-machines", "status":"queued"}, - {"id":"doodad-placement-surface-and-bundle-rules", "status":"queued"}, - {"id":"battle-pet-behavior-and-equipment", "status":"queued"}, - {"id":"movement-validation", "status":"queued"}, - {"id":"ship-handling-data", "status":"queued"}, - {"id":"shipyard-salvage", "status":"queued"}, - {"id":"instance-spawn-data", "status":"queued"}, - {"id":"instance-channel-and-client-driven-entry", "status":"queued"}, - {"id":"arena-restrictions-and-mirrored-instance-bugs", "status":"queued"}, - {"id":"siege-calendar-tickets-reinforcement-and-notifications", "status":"queued"}, - {"id":"racing", "status":"queued"}, - {"id":"remaining-geometry-and-physics-data", "status":"queued"}, - {"id":"cooldown-persistence", "status":"queued"}, - {"id":"disconnect-duplicate-login-and-dead-relogin", "status":"queued"}, - {"id":"resurrection-waits-and-server-enforcement", "status":"queued"}, - {"id":"name-chat-filtering-throttle-and-moderation", "status":"queued"}, - {"id":"character-recustomization", "status":"queued"}, - {"id":"character-slots-races-and-deletion-guards", "status":"queued"}, - {"id":"event-schedule-notifications", "status":"queued"}, - {"id":"login-capacity-and-auth-rate-limits", "status":"queued"}, - {"id":"missing-buff-and-skill-controller-static-data", "status":"queued"}, - {"id":"deprecated-empty-or-client-only-data", "status":"queued", "note":"Verify before deciding no server implementation is required."} + { + "id": "mail-return", + "status": "focused_passed", + "owner": "audit-protocol", + "commit": "305664ae23d7a552f5a6db90677cabec52fe9b3c" + }, + { + "id": "loot-error-width", + "status": "focused_passed", + "owner": "audit-protocol", + "commit": "305664ae23d7a552f5a6db90677cabec52fe9b3c" + }, + { + "id": "merchant-grade", + "status": "merged_pending_validation", + "owner": "audit-economy", + "commit": "3de467a85f1c5aeed2efb2071030058ffeb8b29c" + }, + { + "id": "craft-grade-flags", + "status": "merged_pending_validation", + "owner": "audit-economy", + "commit": "3de467a85f1c5aeed2efb2071030058ffeb8b29c" + }, + { + "id": "web-api-authentication", + "status": "merged_pending_validation", + "owner": "audit-web", + "commit": "24b4699887d5350bc1a9e6f89267f98469fde8eb" + }, + { + "id": "housing-bench-plaque-permissions", + "status": "merged_pending_validation", + "commit": "e2e9744b59d094b2ceb74c63626336664071a59f" + }, + { + "id": "craft-bench-pack-and-required-doodad", + "status": "merged_pending_validation", + "commit": "e2e9744b59d094b2ceb74c63626336664071a59f" + }, + { + "id": "closed-and-unknown-zones", + "status": "implementing" + }, + { + "id": "national-tax-rate", + "status": "queued" + }, + { + "id": "vehicle-attachment-data", + "status": "implementing" + }, + { + "id": "ordinary-warning-noise-and-cleanup-cause", + "status": "queued" + }, + { + "id": "slave-owned-doodad-housing-lookup", + "status": "queued" + }, + { + "id": "aoe-diminishing", + "status": "queued" + }, + { + "id": "skill-and-buff-modifiers", + "status": "implementing" + }, + { + "id": "buff-group-rank-and-per-caster-slots", + "status": "queued" + }, + { + "id": "reflection", + "status": "queued" + }, + { + "id": "attack-speed", + "status": "implementing" + }, + { + "id": "buff-breakers", + "status": "queued" + }, + { + "id": "buff-taunts", + "status": "queued" + }, + { + "id": "casting-hit-delay-and-cancellation", + "status": "queued" + }, + { + "id": "item-procs-and-set-procs", + "status": "queued" + }, + { + "id": "shared-cooldown-tags", + "status": "queued" + }, + { + "id": "xp-buff-multiplier", + "status": "implementing" + }, + { + "id": "zone-banned-item-and-skill-tags", + "status": "queued" + }, + { + "id": "unit-and-primary-stat-limits", + "status": "queued" + }, + { + "id": "prison-and-other-skill-restrictions", + "status": "queued" + }, + { + "id": "damage-threat-percent-health-and-level-interpolation", + "status": "queued" + }, + { + "id": "recipe-learning", + "status": "queued" + }, + { + "id": "npc-groups", + "status": "queued" + }, + { + "id": "npc-linked-aggro-and-missing-ai", + "status": "queued" + }, + { + "id": "npc-alert-dead-events-and-friendship", + "status": "queued" + }, + { + "id": "remaining-buff-attributes-and-controller-kinds", + "status": "queued" + }, + { + "id": "stealth-visibility", + "status": "queued" + }, + { + "id": "trade-pack-pricing-config-ratios-and-persistence", + "status": "queued" + }, + { + "id": "premium-and-aa-points", + "status": "queued" + }, + { + "id": "second-password-and-item-security", + "status": "queued" + }, + { + "id": "item-level-gender-pickup-and-use-limits", + "status": "queued" + }, + { + "id": "tempering-and-socket-data-rules", + "status": "queued" + }, + { + "id": "craft-binding-and-required-grade", + "status": "queued" + }, + { + "id": "mail-expiry-throttling-feedback-and-pagination", + "status": "queued" + }, + { + "id": "npc-physical-enchant", + "status": "queued" + }, + { + "id": "auction-filter-limits-and-authority", + "status": "queued" + }, + { + "id": "missing-item-and-quest-feedback-packets", + "status": "queued" + }, + { + "id": "quest-spawn-coverage", + "status": "queued" + }, + { + "id": "nation-and-faction-flows", + "status": "queued" + }, + { + "id": "bounty-board", + "status": "queued" + }, + { + "id": "achievement-producers", + "status": "queued" + }, + { + "id": "quest-and-skill-unit-requirements", + "status": "queued" + }, + { + "id": "trial-jury-expedition-rename-and-quest-edge-fields", + "status": "queued" + }, + { + "id": "doodad-phase-messages", + "status": "queued" + }, + { + "id": "territory-statue-insert-counter", + "status": "queued" + }, + { + "id": "navigation-doodad-expiry", + "status": "queued" + }, + { + "id": "crest-printer-and-ucc", + "status": "queued" + }, + { + "id": "house-repair-and-farm-notifications", + "status": "queued" + }, + { + "id": "doodad-area-trigger-and-evidence-loot", + "status": "queued" + }, + { + "id": "remaining-gathering-funcs", + "status": "queued" + }, + { + "id": "puzzle-machines", + "status": "queued" + }, + { + "id": "doodad-placement-surface-and-bundle-rules", + "status": "queued" + }, + { + "id": "battle-pet-behavior-and-equipment", + "status": "queued" + }, + { + "id": "movement-validation", + "status": "queued" + }, + { + "id": "ship-handling-data", + "status": "queued" + }, + { + "id": "shipyard-salvage", + "status": "queued" + }, + { + "id": "instance-spawn-data", + "status": "queued" + }, + { + "id": "instance-channel-and-client-driven-entry", + "status": "queued" + }, + { + "id": "arena-restrictions-and-mirrored-instance-bugs", + "status": "queued" + }, + { + "id": "siege-calendar-tickets-reinforcement-and-notifications", + "status": "queued" + }, + { + "id": "racing", + "status": "queued" + }, + { + "id": "remaining-geometry-and-physics-data", + "status": "queued" + }, + { + "id": "cooldown-persistence", + "status": "queued" + }, + { + "id": "disconnect-duplicate-login-and-dead-relogin", + "status": "queued" + }, + { + "id": "resurrection-waits-and-server-enforcement", + "status": "queued" + }, + { + "id": "name-chat-filtering-throttle-and-moderation", + "status": "queued" + }, + { + "id": "character-recustomization", + "status": "queued" + }, + { + "id": "character-slots-races-and-deletion-guards", + "status": "queued" + }, + { + "id": "event-schedule-notifications", + "status": "queued" + }, + { + "id": "login-capacity-and-auth-rate-limits", + "status": "queued" + }, + { + "id": "missing-buff-and-skill-controller-static-data", + "status": "queued" + }, + { + "id": "deprecated-empty-or-client-only-data", + "status": "queued", + "note": "Verify before deciding no server implementation is required." + } ] } From e9a870b8c71e8e4dbf7509d7e72bbb33bcfef20a Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:43:26 -0400 Subject: [PATCH 07/66] fix(world): enforce closed-zone access and safe returns Reject known closed portal and Return destinations before costs for access below 100. Restore the bounded historical warning and return flow with cancellation, live-session checks, verified destinations, and visibility and instance membership updates. Keep unknown mapping keys neutral and preserve the GM exemption. Add 12 focused flow regressions, including paused-clock timer, departure, disconnect, fallback, visibility and resource checks. Source-only validation: rustfmt and git diff --check passed. Cargo compilation/tests/clippy remain reserved for parent integration. Co-Authored-By: OpenAI Codex --- .../crates/aaemu-game/src/models/character.rs | 3 + .../aaemu-game/src/systems/npcs/portal/mod.rs | 32 + .../skills/effects/special/movement.rs | 45 ++ .../aaemu-game/src/systems/skills/skill.rs | 123 +++- rust/crates/aaemu-game/src/world/session.rs | 26 +- .../aaemu-game/src/world/zone_access.rs | 329 +++++++++ .../aaemu-game/src/world/zone_access_tests.rs | 650 ++++++++++++++++++ 7 files changed, 1170 insertions(+), 38 deletions(-) create mode 100644 rust/crates/aaemu-game/src/world/zone_access.rs create mode 100644 rust/crates/aaemu-game/src/world/zone_access_tests.rs diff --git a/rust/crates/aaemu-game/src/models/character.rs b/rust/crates/aaemu-game/src/models/character.rs index b74cd11124..e6aae4996f 100644 --- a/rust/crates/aaemu-game/src/models/character.rs +++ b/rust/crates/aaemu-game/src/models/character.rs @@ -220,6 +220,8 @@ pub struct Character { /// Character skill / combat state (`SkillCancelled`, `LastCast`, `IsInAggroListOf`, ...). pub skill_char: crate::systems::skills::state::CharacterSkillState, // ---- phase 3 / npcs: add this subsystem's Character fields below ---- + /// Closed-zone warning task and the last verified open-zone position (session only). + pub zone_access: crate::world::session::ZoneAccessState, /// `Bonding` (`BondDoodad`: the doodad seat / bed the character is attached to). pub bonding: Option, // ---- phase 3 / economy: add this subsystem's Character fields below ---- @@ -365,6 +367,7 @@ impl Character { // ---- phase 3 / skills ---- skill_char: Default::default(), // ---- phase 3 / npcs ---- + zone_access: Default::default(), bonding: None, // ---- phase 3 / economy ---- diff --git a/rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs b/rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs index eadd7be941..e2e18404e1 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs @@ -613,6 +613,18 @@ pub fn open_portal( tracing::error!("OpenPortal: portal {} is not in the book", effect.id); return None; }; + let instance = owner.data().unit.transform.instance_id; + if !session::zone_access_allowed( + server, + owner, + instance, + portal_info.zone_id, + portal_info.x, + portal_info.y, + ) { + owner.send(SCErrorMsgPacket::new(session::CLOSED_ZONE, 0, true)); + return None; + } if !check_can_open_portal(server, owner, portal_info.zone_id) { return None; } @@ -852,6 +864,17 @@ pub fn use_portal_with_preference( tracing::warn!("UsePortal: npc {obj_id} is not a portal"); return; }; + if !session::zone_access_allowed( + server, + player, + teleport.instance_id, + teleport.zone_id, + teleport.x, + teleport.y, + ) { + player.send(SCErrorMsgPacket::new(session::CLOSED_ZONE, 0, true)); + return; + } if only_my_portal && owner_id != player.character_id { player.send(SCErrorMsgPacket::new(error_message::NOT_MY_PORTAL, 0, true)); return; @@ -1088,6 +1111,11 @@ pub fn navi_teleport(server: &GameServer, player: &PlayerRef, obj_id: u32) { return; } let pos = world.world_pos_rot(&WorldObject::from(&doodad)); + let zone_id = doodad.data().unit.transform.zone_id; + if !session::zone_access_allowed(server, player, world.id, zone_id, pos.x, pos.y) { + player.send(SCErrorMsgPacket::new(session::CLOSED_ZONE, 0, true)); + return; + } run_navi_func(server, &doodad, player, &func); player.data().set_disabled_set_position(true); player.send(packets::SCNaviTeleportPacket { @@ -1190,6 +1218,10 @@ pub fn use_teleport( if money_amount < 0 { return; } + if !session::zone_access_allowed(server, player, instance_id, dest.zone_id, dest.x, dest.y) { + player.send(SCErrorMsgPacket::new(session::CLOSED_ZONE, 0, true)); + return; + } if money_amount > 0 { let paid = server.systems.npcs.hooks.economy.get().is_some_and(|eco| { eco.change_money(server, player, -i64::from(money_amount), ITEM_TASK_TELEPORT) diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/special/movement.rs b/rust/crates/aaemu-game/src/systems/skills/effects/special/movement.rs index 8aea4bb280..0cc66460e7 100644 --- a/rust/crates/aaemu-game/src/systems/skills/effects/special/movement.rs +++ b/rust/crates/aaemu-game/src/systems/skills/effects/special/movement.rs @@ -657,6 +657,21 @@ pub fn return_(server: &GameServer, args: &EffectArgs<'_>, v: [i32; 4]) { } if let Some(t) = &trp { if in_instance { + if !crate::world::session::zone_access_allowed( + server, + p, + instance_id, + t.zone_id, + t.x, + t.y, + ) { + p.send(SCErrorMsgPacket::new( + crate::world::session::CLOSED_ZONE, + 0, + true, + )); + return; + } move_within_instance(server, p, t); return; } @@ -664,6 +679,21 @@ pub fn return_(server: &GameServer, args: &EffectArgs<'_>, v: [i32; 4]) { trp }; if let Some(t) = &trp { + if !crate::world::session::zone_access_allowed( + server, + p, + DEFAULT_INSTANCE_ID, + t.zone_id, + t.x, + t.y, + ) { + p.send(SCErrorMsgPacket::new( + crate::world::session::CLOSED_ZONE, + 0, + true, + )); + return; + } p.data().set_disabled_set_position(true); p.send(SCLoadInstancePacket { instance_id: DEFAULT_INSTANCE_ID, @@ -682,6 +712,21 @@ pub fn return_(server: &GameServer, args: &EffectArgs<'_>, v: [i32; 4]) { PositionAndRotation::new(t.x, t.y, t.z, 0.0, 0.0, deg_to_rad(t.yaw)), ); } else if let Some(m) = npcs.main_world_position(server, p).filter(|_| !in_instance) { + if !crate::world::session::zone_access_allowed( + server, + p, + m.instance_id, + m.zone_id, + m.pos.x, + m.pos.y, + ) { + p.send(SCErrorMsgPacket::new( + crate::world::session::CLOSED_ZONE, + 0, + true, + )); + return; + } p.data().set_disabled_set_position(true); p.send(SCLoadInstancePacket { instance_id: m.instance_id, diff --git a/rust/crates/aaemu-game/src/systems/skills/skill.rs b/rust/crates/aaemu-game/src/systems/skills/skill.rs index 447c3171cd..7f879d1657 100644 --- a/rust/crates/aaemu-game/src/systems/skills/skill.rs +++ b/rust/crates/aaemu-game/src/systems/skills/skill.rs @@ -504,7 +504,7 @@ pub fn use_skill( return result; } if let Some(c) = &character { - if let Some(result) = portal_zone_check(server, &template, c) { + if let Some(result) = portal_zone_check(server, &template, c, skill_object.as_ref()) { return (result, 0); } } @@ -706,6 +706,7 @@ fn portal_zone_check( server: &GameServer, template: &SkillTemplate, c: &crate::world::PlayerRef, + skill_object: Option<&SkillObject>, ) -> Option { let (access, district, faction, instance) = { let d = c.data(); @@ -720,40 +721,88 @@ fn portal_zone_check( return None; } let data = &server.game_data.systems.skills; - let first = template.effects.first()?; - let (kind, id) = first.template?; - let mut zone_id: Option = None; - match data.effect(kind, id)? { - EffectTemplate::Special(s) if s.special_effect_type_id == 25 => { - if s.value1 > 0 { - // PortalManager.GetWorldGatesById: world gates are not loaded (portals subsystem) - } else { - let rp = server - .game_data - .portals - .district_return_point(district, faction); - zone_id = server - .game_data - .portals - .recalls - .values() - .flatten() - .find(|p| p.id == rp) - .map(|p| p.zone_id); - } - } - EffectTemplate::OpenPortal { .. } if instance != 0 => { - return Some(skill_result::INVALID_LOCATION); - } - // character.Portals.GetPortalInfo(portalInfo.Id): portals subsystem - _ => {} - } - let zone_id = zone_id?; - match server.game_data.zones.zone_by_key(zone_id) { - None => Some(skill_result::NO_PERM), - Some(z) if z.closed => Some(skill_result::NO_PERM), - _ => None, + for effect in &template.effects { + let Some((kind, id)) = effect.template else { + continue; + }; + let mut destination_instance = instance; + let destination = match data.effect(kind, id) { + Some(EffectTemplate::Special(s)) if s.special_effect_type_id == 25 => { + if s.value1 > 0 { + crate::systems::npcs::portal::world_gates_by_id(server, s.value1 as u32) + .cloned() + .or_else(|| { + if instance != 0 { + return None; + } + let t = c.data().main_world_position?; + destination_instance = t.instance_id; + Some(crate::data::world_data::Portal { + zone_id: t.zone_id, + x: t.x, + y: t.y, + z: t.z, + ..Default::default() + }) + }) + } else { + destination_instance = crate::models::character::DEFAULT_INSTANCE_ID; + let rp = server + .game_data + .portals + .district_return_point(district, faction); + server + .game_data + .portals + .recalls + .values() + .flatten() + .find(|p| p.id == rp) + .cloned() + .or_else(|| { + if rp == 0 || instance != 0 { + return None; + } + let t = c.data().main_world_position?; + destination_instance = t.instance_id; + Some(crate::data::world_data::Portal { + zone_id: t.zone_id, + x: t.x, + y: t.y, + z: t.z, + ..Default::default() + }) + }) + } + } + Some(EffectTemplate::OpenPortal { .. }) => { + if instance != 0 { + return Some(skill_result::INVALID_LOCATION); + } + match skill_object { + Some(SkillObject::PortalInfo { id, .. }) => { + crate::systems::npcs::portal::portal_info(&c.data().portals, *id as u32) + .cloned() + } + _ => None, + } + } + _ => None, + }; + if let Some(p) = destination { + if !crate::world::session::zone_access_allowed( + server, + c, + destination_instance, + p.zone_id, + p.x, + p.y, + ) { + return Some(skill_result::NO_PERM); + } + } } + None } /// `Skill.Cast(caster, casterCaster, target, targetCaster, skillObject)`. @@ -778,7 +827,11 @@ pub fn cast(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { return; } // Source, target and resources may change while the cast timer is running. - let ready = super::validation::check(server, skill, caster, &ctx.target) + let ready = caster + .as_player() + .and_then(|p| portal_zone_check(server, &skill.template, p, Some(&ctx.skill_object))) + .map_or(Ok(()), |result| Err((result, 0))) + .and_then(|()| super::validation::check(server, skill, caster, &ctx.target)) .and_then(|()| super::validation::check_resources(server, skill, caster)) .and_then(|()| { super::validation::check_build_materials(server, skill, caster, &ctx.target) diff --git a/rust/crates/aaemu-game/src/world/session.rs b/rust/crates/aaemu-game/src/world/session.rs index fe644be3d6..66131e12f3 100644 --- a/rust/crates/aaemu-game/src/world/session.rs +++ b/rust/crates/aaemu-game/src/world/session.rs @@ -32,6 +32,13 @@ use crate::server::GameServer; use crate::systems::skills::packets::SCCooldownsPacket; use crate::world::{broadcast, unit_state, Player, PlayerRef, WorldInstance, WorldObject}; +#[path = "zone_access.rs"] +mod zone_access; +pub use zone_access::{zone_access_allowed, ZoneAccessState, CLOSED_ZONE}; +#[cfg(test)] +#[path = "zone_access_tests.rs"] +mod zone_access_tests; + /// `LeaveWorldTargetType`. pub mod leave_target { pub const QUIT_GAME: u8 = 0; @@ -77,11 +84,17 @@ fn mother_id(server: &GameServer, faction_id: u32) -> u32 { /// `Character.IsOnline` setter. pub fn set_online(server: &GameServer, p: &PlayerRef, value: bool) { + if !value { + zone_access::cancel(p); + } if p.data().is_online == value { return; } crate::systems::social::friend::send_status_change(server, p, true, value); p.data().is_online = value; + if value { + zone_access::update(server, p); + } // !value -> TeamManager.SetOffline crate::systems::social::session::on_online_changed(server, p, value); } @@ -187,15 +200,13 @@ pub fn on_zone_change(server: &GameServer, p: &PlayerRef, last_zone: u32, new_zo ability: 0, language_type: 0, }); - // Later phase: the forced transport out of closed zones for access level < 100 - // (5 x SCErrorMsg(ClosedZone) every 2 s, then SCCharacterResurrected at the closest - // return portal). tracing::warn!("{} entered closed zone {}", p.data().unit.name, z.zone_key); } None => { tracing::warn!("{} entered unknown zone {new_zone}", p.data().unit.name); } } + zone_access::update(server, p); } /// `ChatManager.GetZoneChat(zoneKey)`. @@ -931,6 +942,9 @@ pub async fn move_unit(server: &GameServer, conn: &mut GameConnection, obj_id: u let t = target.transform(); (t.x, t.y, t.z) }; + if let Some(player) = target.as_player() { + zone_access::remember_open_position(server, player); + } // An actor standing on an object sends its primary position in the // supporting object's frame and the auxiliary position in world // coordinates, whatever the object kind (gcFlags 1 unit, 2 gimmick, @@ -974,6 +988,9 @@ pub async fn move_unit(server: &GameServer, conn: &mut GameConnection, obj_id: u .leave_other_instance(&crate::world::WorldObject::from(&target), world.id); let changes = world.add_visible_object(&target, &server.view_ctx()); handle_zone_changes(server, changes); + if let Some(player) = target.as_player() { + zone_access::update(server, player); + } // FinalizeTransform: every 5 s the movement speed analysis (SusManager) let new_pos = { let t = target.transform(); @@ -1380,6 +1397,7 @@ pub async fn save_and_remove_from_world(server: &GameServer, active: Option<&Pla let Some(p) = active else { return; }; + zone_access::cancel(p); // A duel / battlefield faction is temporary: restore it before the departure save so the // character is never persisted with its Red / Blue team or corps faction (RPA-09). server @@ -1415,6 +1433,7 @@ pub async fn on_disconnect(server: &GameServer, conn: &mut GameConnection) { server.enter_world.release_connection(conn.id); return; }; + zone_access::cancel(&p); crate::systems::housing::dominion::runtime::abort_character(server, p.character_id); crate::systems::housing::dominion::participants::clear_player(server, &p); crate::systems::economy::on_disconnect(server, &p); @@ -1471,6 +1490,7 @@ pub fn force_release_connection(server: &GameServer, connection_id: u32) { if p.conn.id != connection_id { continue; } + zone_access::cancel(&p); // Drop the server-wide entry first: if the grid removal below panics on a poisoned // instance lock, the character must still not be lookable up by id / obj id. server.world.try_remove_character(p.obj_id); diff --git a/rust/crates/aaemu-game/src/world/zone_access.rs b/rust/crates/aaemu-game/src/world/zone_access.rs new file mode 100644 index 0000000000..d8aacbad0e --- /dev/null +++ b/rust/crates/aaemu-game/src/world/zone_access.rs @@ -0,0 +1,329 @@ +//! Closed-zone transport from `a2ab80abd^:AAEmu.Game/Models/Game/Char/Character.cs`, +//! `OnZoneChange` (five 2 s warnings, dismount/despawn, 200 ms grace, return portal). +//! Unknown keys can be +//! world.xml placeholders (e.g. main-world 202, o_temp_b), not necessarily closed zones. + +use std::sync::Arc; +use std::time::Duration; + +use tokio_util::sync::CancellationToken; + +use crate::models::character::DEFAULT_INSTANCE_ID; +use crate::models::transform::Transform; +use crate::packets::world::SCErrorMsgPacket; +use crate::server::GameServer; +use crate::systems::npcs::portal; +use crate::systems::skills::packets_special::{SCCharacterResurrectedPacket, SCLoadInstancePacket}; +use crate::world::{broadcast, PlayerRef, WorldObject}; + +/// Native 1.2 `x2game12.c:1163240`, error-name switch case 287 = `closed_zone`. +pub const CLOSED_ZONE: i16 = 287; + +#[derive(Debug, Clone, Default)] +pub struct ZoneAccessState { + // Retain a completed attempt until departure: a missing safe route must not start a loop. + attempt: Option, + safe_position: Option, +} + +fn is_closed(server: &GameServer, zone: u32) -> bool { + server + .game_data + .zones + .zone_by_key(zone) + .is_some_and(|z| z.closed) +} + +/// Check both the saved zone and the actual destination sector before charging or moving. +/// A missing static zone row alone is not evidence that a coordinate is forbidden. +pub fn zone_access_allowed( + server: &GameServer, + player: &PlayerRef, + instance: u32, + zone: u32, + x: f32, + y: f32, +) -> bool { + if player.data().access_level >= 100 { + return true; + } + !is_closed(server, zone) + && !server + .world + .worlds() + .iter() + .any(|w| w.id == instance && is_closed(server, w.template.zone_id_at(x, y))) +} + +pub(super) fn cancel(player: &PlayerRef) { + if let Some(token) = player.data().zone_access.attempt.take() { + token.cancel(); + } +} + +fn world_transform(server: &GameServer, player: &PlayerRef) -> Option { + let mut t = player.data().unit.transform; + let world = server.world.world(t.instance_id)?; + let pos = world.world_pos_rot(&WorldObject::from(player)); + t.set_position(pos.x, pos.y, pos.z, pos.rot_x, pos.rot_y, pos.rot_z); + t.parent_obj_id = 0; + t.world_id = world.template.id; + t.zone_id = world.template.zone_id_at(t.x, t.y); + Some(t) +} + +// Eviction destinations require positive open-zone evidence, a live world and real coordinates. +// This deliberately rejects GetClosestReturnPortal's synthetic current-position fail-safe. +fn safe_destination(server: &GameServer, t: &Transform) -> bool { + [t.x, t.y, t.z, t.rot_x, t.rot_y, t.rot_z] + .iter() + .all(|v| v.is_finite()) + && server + .game_data + .zones + .zone_by_key(t.zone_id) + .is_some_and(|z| !z.closed) + && server.world.worlds().iter().any(|w| { + w.id == t.instance_id + && w.template.id == t.world_id + && w.template.zone_id_at(t.x, t.y) == t.zone_id + }) +} + +pub(super) fn remember_open_position(server: &GameServer, player: &PlayerRef) { + if let Some(t) = world_transform(server, player).filter(|t| safe_destination(server, t)) { + player.data().zone_access.safe_position = Some(t); + } +} + +fn needs_return(server: &GameServer, player: &PlayerRef) -> bool { + let (online, access, t) = { + let c = player.data(); + (c.is_online, c.access_level, c.unit.transform) + }; + online + && access < 100 + && !server.is_shutting_down() + && server + .world + .character_by_obj_id(player.obj_id) + .is_some_and(|p| Arc::ptr_eq(&p, player)) + && (is_closed(server, t.zone_id) + || world_transform(server, player).is_some_and(|t| is_closed(server, t.zone_id))) +} + +pub(super) fn update(server: &GameServer, player: &PlayerRef) { + if !needs_return(server, player) { + cancel(player); + remember_open_position(server, player); + return; + } + let Some(server) = server.self_arc() else { + return; + }; + let token = { + let mut c = player.data(); + if c.zone_access.attempt.is_some() { + return; + } + let token = CancellationToken::new(); + c.zone_access.attempt = Some(token.clone()); + token + }; + // Weak handles prevent a sleeping warning from retaining a departed session/server. + let weak_server = Arc::downgrade(&server); + let weak_player = Arc::downgrade(player); + let started = tokio::time::Instant::now(); + player.send(SCErrorMsgPacket::new(CLOSED_ZONE, 0, false)); + tokio::spawn(async move { + for tick in 1..=5 { + tokio::select! { + _ = token.cancelled() => return, + _ = tokio::time::sleep_until(started + Duration::from_secs(tick * 2)) => {} + } + let (Some(server), Some(player)) = (weak_server.upgrade(), weak_player.upgrade()) + else { + return; + }; + if token.is_cancelled() { + return; + } + if !needs_return(&server, &player) { + cancel(&player); + return; + } + if tick < 5 { + player.send(SCErrorMsgPacket::new(CLOSED_ZONE, 0, false)); + } + } + let (Some(server), Some(player)) = (weak_server.upgrade(), weak_player.upgrade()) else { + return; + }; + let Some(destination) = return_destination(&server, &player) else { + tracing::warn!( + character_id = player.character_id, + "Closed zone: no verified open return route" + ); + return; + }; + crate::systems::vehicles::force_dismount( + &server, + &player, + crate::systems::vehicles::slaves::attach_reason::PREFAB_CHANGED, + ); + let instance = player.data().unit.transform.instance_id; + crate::systems::vehicles::mates::remove_and_despawn_all_active_owned_mates( + &server, + instance, + player.character_id, + ); + // Match the historical 200 ms dismount grace; recheck cancellation and identity after it. + tokio::select! { + _ = token.cancelled() => return, + _ = tokio::time::sleep(Duration::from_millis(200)) => {} + } + if token.is_cancelled() { + return; + } + if !needs_return(&server, &player) || !safe_destination(&server, &destination) { + cancel(&player); + return; + } + transport(&server, &player, destination); + }); +} + +fn return_destination(server: &GameServer, player: &PlayerRef) -> Option { + let (instance, recorded, main) = { + let c = player.data(); + ( + c.unit.transform.instance_id, + c.zone_access.safe_position, + c.main_world_position, + ) + }; + // In an instance, prefer its recorded open route over a respawn in another world. + if let Some(t) = recorded.filter(|t| { + instance != DEFAULT_INSTANCE_ID && t.instance_id == instance && safe_destination(server, t) + }) { + return Some(t); + } + if instance != DEFAULT_INSTANCE_ID { + if let Some(t) = main.filter(|t| safe_destination(server, t)) { + return Some(t); + } + } + let p = portal::closest_return_portal(server, player); + let t = Transform { + instance_id: DEFAULT_INSTANCE_ID, + world_id: 0, + zone_id: p.zone_id, + x: p.x, + y: p.y, + z: p.z, + rot_z: p.z_rot, + ..Transform::default() + }; + safe_destination(server, &t) + .then_some(t) + .or_else(|| recorded.filter(|t| safe_destination(server, t))) +} + +fn transport(server: &GameServer, player: &PlayerRef, destination: Transform) { + let old = player.data().unit.transform; + let Some(world) = server.world.world(destination.instance_id) else { + return; + }; + if old.instance_id != destination.instance_id + && !crate::systems::vehicles::on_instance_change(server, player) + { + return; + } + if old.instance_id != destination.instance_id { + leave_instance_membership(server, player, old.instance_id); + } + if let Some(old_world) = server.world.world_of(&WorldObject::from(player)) { + old_world.detach_child(&WorldObject::from(player)); + // Old observers must receive the forced displacement before the player leaves their view. + broadcast( + &old_world, + player, + &SCCharacterResurrectedPacket { + unit_id: player.obj_id, + x: destination.x, + y: destination.y, + z: destination.z, + z_rot: destination.rot_z, + }, + true, + ); + } + if old.instance_id != destination.instance_id { + player.send(SCLoadInstancePacket { + instance_id: destination.instance_id, + zone_id: destination.zone_id, + x: destination.x, + y: destination.y, + z: destination.z, + ang_x: destination.rot_x, + ang_y: destination.rot_y, + ang_z: destination.rot_z, + }); + } + { + let mut c = player.data(); + c.set_disabled_set_position(true); + // Native OnCharacterResurrected (391D3AD0) does not acknowledge a same-world + // displacement with TeleportEnded. Only a world load waits for InstanceLoaded. + if old.instance_id == destination.instance_id { + c.set_disabled_set_position(false); + } + c.unit.transform = destination; + } + server + .world + .leave_other_instance(&WorldObject::from(player), destination.instance_id); + if old.instance_id != destination.instance_id { + if let Some(previous) = server.world.world(old.instance_id) { + previous.remove_object(player.obj_id); + } + } + world.add_object(player); + let changes = world.add_visible_object(player, &server.view_ctx()); + super::handle_zone_changes(server, changes); + if old.zone_id != destination.zone_id { + super::on_zone_change(server, player, old.zone_id, destination.zone_id); + } + update(server, player); +} + +/// The membership part of a normal instance leave, without replaying its saved return +/// transform (which may itself be closed). The verified destination is applied by transport. +fn leave_instance_membership(server: &GameServer, player: &PlayerRef, instance: u32) { + use crate::systems::instances::events::CharEvent; + let events = &server.systems.instances.events.characters; + if let Some(dungeon) = server.systems.instances.dungeon_of_world(instance) { + { + let mut state = dungeon.st(); + state + .leave_requests + .retain(|(id, _)| *id != player.character_id); + state.enter_requests.retain(|p| !Arc::ptr_eq(p, player)); + } + for event in [ + CharEvent::TeamJoin, + CharEvent::TeamKick, + CharEvent::TeamLeave, + CharEvent::DungeonLeave, + CharEvent::Disconnect, + ] { + events.unsubscribe(player, event, dungeon.uid); + } + } + if let Some(game) = server.systems.instances.instant_games.current(player) { + crate::systems::instances::instant_game::on_disconnect(server, player); + crate::systems::instances::instant_game::remove_player(server, &game, player); + crate::systems::social::faction::restore_temporary_faction(server, player); + events.unsubscribe(player, CharEvent::Kill, game.uid); + } +} diff --git a/rust/crates/aaemu-game/src/world/zone_access_tests.rs b/rust/crates/aaemu-game/src/world/zone_access_tests.rs new file mode 100644 index 0000000000..8b9dc020e8 --- /dev/null +++ b/rust/crates/aaemu-game/src/world/zone_access_tests.rs @@ -0,0 +1,650 @@ +//! Regressions for the actual movement, session and portal/skill entry paths. Timer tests +//! use Tokio's paused clock; no MySQL, client files or servers are involved. + +use std::sync::Arc; +use std::time::Duration; + +use crate::data::world_data::{DistrictReturnPoint, Portal, Zone}; +use crate::data::world_templates::{WorldTemplate, WorldTemplates}; +use crate::data::GameData; +use crate::models::movement::{MoveKind, MoveType, UnitMove}; +use crate::models::npc::{Npc, PortalInfo}; +use crate::models::transform::Transform; +use crate::net::packet::encode_raw; +use crate::opcodes::{cs, sc}; +use crate::server::GameServer; +use crate::systems::npcs::portal::{self, PortalEffectObject, PortalTables}; +use crate::systems::skills::data::{effects::SpecialEffect, EffectKind, EffectTemplate}; +use crate::systems::skills::types::{skill_result, SkillCastTarget, SkillCaster, SkillObject}; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient, TEST_ZONE}; +use crate::world::{Entity, PlayerRef, WorldObject}; + +use super::{on_zone_change, zone_access}; + +const CLOSED: u32 = 200; +const GATE_SKILL: u32 = 90001; +const OPEN_SKILL: u32 = 90002; +const GATE: u32 = 10; + +fn data(respawn: bool) -> GameData { + let mut data = GameData::empty(); + for (key, closed) in [(TEST_ZONE, false), (CLOSED, true), (201, true)] { + data.zones.zones.insert( + key, + Zone { + zone_key: key, + closed, + ..Default::default() + }, + ); + } + let point = |zone_id, x| Portal { + id: GATE, + zone_id, + x, + y: 100.0, + z: 100.0, + ..Default::default() + }; + data.systems.npcs.portal = PortalTables::from_parts( + if respawn { + vec![point(TEST_ZONE, 128.0)] + } else { + vec![] + }, + vec![point(CLOSED, 1400.0)], + vec![], + vec![], + ) + .unwrap(); + data.portals.recalls.insert(1, vec![point(CLOSED, 1400.0)]); + data.systems.npcs.portal.recalls_key.insert(GATE, 1); + data.portals + .district_return_points + .push(DistrictReturnPoint { + id: 1, + district_id: 1, + faction_id: 101, + return_point_id: GATE, + }); + data.systems.npcs.npc.templates.insert( + 900, + crate::systems::npcs::npc::data::NpcTemplate { + id: 900, + teleporter: true, + ..Default::default() + }, + ); + data.systems.skills.add_effect( + EffectKind::SpecialEffect, + EffectTemplate::Special(SpecialEffect { + id: 1, + special_effect_type_id: 25, + value1: GATE as i32, + value2: 0, + value3: 0, + value4: 0, + }), + 1, + ); + data.systems + .skills + .add_skill(crate::systems::skills::data::SkillTemplate { + target_type: 0, + mana_cost: 20, + cooldown_time: 10000, + effects: vec![crate::systems::skills::tests::skill_effect( + 1, + EffectKind::SpecialEffect, + 1, + )], + ..crate::systems::skills::tests::skill_template(GATE_SKILL) + }); + data.systems.skills.add_effect( + EffectKind::OpenPortalEffect, + EffectTemplate::OpenPortal { + id: 2, + distance: 5.0, + }, + 2, + ); + data.systems + .skills + .add_skill(crate::systems::skills::data::SkillTemplate { + target_type: 0, + mana_cost: 20, + cooldown_time: 10000, + effects: vec![crate::systems::skills::tests::skill_effect( + 2, + EffectKind::OpenPortalEffect, + 2, + )], + ..crate::systems::skills::tests::skill_template(OPEN_SKILL) + }); + data +} + +fn server(respawn: bool) -> Arc { + let mut server = test_server_with(data(respawn)); + let mut template = WorldTemplate::synthetic(0, "main_world", 2, 2, TEST_ZONE); + for x in 16..32 { + for y in 0..32 { + template.set_zone_key_at(x, y, if x < 24 { CLOSED } else { 201 }); + } + } + Arc::get_mut(&mut server.game_data).unwrap().worlds = + WorldTemplates::from_templates(vec![template], vec![]).unwrap(); + server.world = Arc::new(crate::world::WorldManager::default()); + server.world.create_world_instance( + Arc::new( + server + .game_data + .worlds + .get_world_template_by_name("main_world") + .unwrap() + .clone(), + ), + 0, + ); + let server = Arc::new(server); + server.set_self(); + crate::systems::npcs::install_hooks(&server); + server +} + +fn player(server: &GameServer, id: u32, x: f32) -> (TestClient, PlayerRef) { + let mut client = TestClient::new(server, id, 1000 + id); + let mut character = test_character(id, "ZoneTester", x, 100.0); + character.is_online = true; + character.unit.hp = 100; + character.unit.max_hp = 100; + character.unit.mp = 100; + character.unit.max_mp = 100; + let p = spawn_player(server, &client, character, 0x100 + id); + client.conn.active_char = Some(p.clone()); + client.drain(); + (client, p) +} + +async fn walk(server: &GameServer, client: &mut TestClient, p: &PlayerRef, x: f32) { + crate::world::session::move_unit( + server, + &mut client.conn, + p.obj_id, + MoveType::new(MoveKind::Unit(UnitMove { + x, + y: 100.0, + z: 100.0, + vel_x: 10, + ..Default::default() + })), + ) + .await; + tokio::task::yield_now().await; +} + +async fn advance(ms: u64) { + tokio::time::advance(Duration::from_millis(ms)).await; + tokio::task::yield_now().await; +} + +fn warning_count(client: &mut TestClient) -> usize { + client + .drain() + .into_iter() + .filter(|(op, body)| { + // Native 1.2 397C3030: ErrorMessage:i16 twice, type:u32, isNotify:bool. + *op == sc::SCErrorMsgPacket && body.as_slice() == [0x1f, 1, 0x1f, 1, 0, 0, 0, 0, 0] + }) + .count() +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_walk_warns_five_times_then_returns_and_refiles_visibility() { + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + let (mut arrival, a) = player(&server, 2, 128.0); + let (mut departure, d) = player(&server, 3, 1400.0); + walk(&server, &mut client, &p, 1400.0).await; + assert_eq!(p.data().unit.transform.zone_id, CLOSED); + assert_eq!(warning_count(&mut client), 1); + for _ in 0..4 { + // Duplicate callbacks must not allocate another timer or extend its deadline. + on_zone_change(&server, &p, CLOSED, CLOSED); + advance(2000).await; + assert_eq!(warning_count(&mut client), 1); + } + arrival.drain(); + departure.drain(); + advance(2000).await; + assert_eq!(p.data().unit.transform.x, 1400.0); + advance(200).await; + let t = p.data().unit.transform; + assert_eq!( + (t.instance_id, t.zone_id, t.x, t.y), + (0, TEST_ZONE, 128.0, 100.0) + ); + assert!(!p.data().disabled_set_position); + let frames = client.drain(); + assert_eq!( + frames + .iter() + .filter(|f| f.0 == sc::SCCharacterResurrectedPacket) + .count(), + 1 + ); + assert!(arrival.drain_ops().contains(&sc::SCUnitStatePacket)); + assert!(departure.drain_ops().contains(&sc::SCUnitsRemovedPacket)); + let world = server.world.world(0).unwrap(); + let around = world.players_around(&WorldObject::from(&p)); + assert!(around.iter().any(|x| Arc::ptr_eq(x, &a))); + assert!(!around.iter().any(|x| Arc::ptr_eq(x, &d))); + // Native resurrection has no TeleportEnded acknowledgement: movement remains usable. + walk(&server, &mut client, &p, 130.0).await; + assert_eq!(p.data().unit.transform.x, 130.0); + advance(20000).await; + assert_eq!(warning_count(&mut client), 0); +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_departure_cancels_and_reentry_gets_a_fresh_deadline() { + let server = server(false); + let (mut client, p) = player(&server, 1, 100.0); + walk(&server, &mut client, &p, 1400.0).await; + assert_eq!(warning_count(&mut client), 1); + advance(2000).await; + client.drain(); + walk(&server, &mut client, &p, 200.0).await; + advance(4000).await; + assert_eq!(warning_count(&mut client), 0); + walk(&server, &mut client, &p, 1400.0).await; + assert_eq!(warning_count(&mut client), 1); + advance(4000).await; + assert!(!client + .drain_ops() + .contains(&sc::SCCharacterResurrectedPacket)); + assert_eq!(p.data().unit.transform.x, 1400.0); + advance(6000).await; + advance(200).await; + // With no respawn data, the last recorded open position is a real fallback. + let t = p.data().unit.transform; + assert_eq!((t.zone_id, t.x), (TEST_ZONE, 200.0)); +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_no_safe_route_does_not_teleport_or_repeat() { + let server = server(false); + let (mut client, p) = player(&server, 1, 1400.0); + on_zone_change(&server, &p, 0, CLOSED); + assert_eq!(warning_count(&mut client), 1); + advance(10000).await; + advance(200).await; + assert!(!client + .drain_ops() + .contains(&sc::SCCharacterResurrectedPacket)); + assert_eq!(p.data().unit.transform.x, 1400.0); + walk(&server, &mut client, &p, 1600.0).await; + advance(20000).await; + assert_eq!(warning_count(&mut client), 0); + assert_eq!(p.data().unit.transform.x, 1600.0); +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_gm_entry_and_escalation_are_exempt() { + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + p.data().access_level = 100; + walk(&server, &mut client, &p, 1400.0).await; + advance(12000).await; + assert_eq!(warning_count(&mut client), 0); + assert_eq!(p.data().unit.transform.x, 1400.0); + p.data().access_level = 99; + walk(&server, &mut client, &p, 1401.0).await; + assert_eq!(warning_count(&mut client), 1); + p.data().access_level = 100; + advance(12000).await; + assert_eq!(warning_count(&mut client), 0); + assert_eq!(p.data().unit.transform.x, 1401.0); +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_offline_and_stale_player_cancel_pending_transport() { + for offline in [true, false] { + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + walk(&server, &mut client, &p, 1400.0).await; + assert_eq!(warning_count(&mut client), 1); + if offline { + crate::world::session::set_online(&server, &p, false); + } else { + server.world.try_remove_character(p.obj_id); + // Same obj id in a different session must not make the old timer valid. + let replacement = crate::world::Player::new(p.data().clone(), p.conn.clone()); + server.world.try_add_character(&replacement); + } + advance(20000).await; + assert!(client.drain_ops().iter().all(|op| ![ + sc::SCErrorMsgPacket, + sc::SCCharacterResurrectedPacket + ] + .contains(op))); + assert_eq!(p.data().unit.transform.x, 1400.0); + } +} + +#[tokio::test] +async fn closed_zone_portal_packet_and_open_portal_reject_before_side_effects() { + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + let destination = Transform { + zone_id: TEST_ZONE, + x: 1400.0, + y: 100.0, + z: 100.0, + ..Default::default() + }; + let mut npc = Npc::new(portal::PORTAL_ENTRANCE_TEMPLATE_ID); + npc.unit.transform.set_xyz(101.0, 100.0, 100.0); + npc.portal = Some(PortalInfo { + teleport_position: destination, + linked_portal_obj_id: 0, + }); + let npc = Entity::new(0x123456, npc); + server + .world + .world(0) + .unwrap() + .spawn(&npc, &server.view_ctx()); + client.drain(); + let before = p.data().unit.transform; + // Native x2game12.c:1756168..1756179 = bc(objId), onlyMyPortal:bool; + // deliberately misleading saved zone. + server + .handle_frame( + &mut client.conn, + &encode_raw(1, cs::CSUsePortalPacket, &[0x56, 0x34, 0x12, 0]), + ) + .await + .unwrap(); + let frames = client.drain(); + assert_eq!( + frames, + vec![(sc::SCErrorMsgPacket, vec![0x1f, 1, 0x1f, 1, 0, 0, 0, 0, 1])] + ); + assert_eq!(p.data().unit.transform, before); + p.data().portals.private_portals.push(Portal { + id: 10, + zone_id: CLOSED, + x: 1400.0, + y: 100.0, + ..Default::default() + }); + assert!(portal::open_portal( + &server, + &p, + &PortalEffectObject { + id: 10, + ..Default::default() + } + ) + .is_none()); + assert_eq!(client.drain_ops(), vec![sc::SCErrorMsgPacket]); + p.data().access_level = 100; + server + .handle_frame( + &mut client.conn, + &encode_raw(1, cs::CSUsePortalPacket, &[0x56, 0x34, 0x12, 0]), + ) + .await + .unwrap(); + assert!(client.drain_ops().contains(&sc::SCTeleportUnitPacket)); +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_logout_and_disconnect_cancel_during_dismount_grace() { + for disconnect in [false, true] { + let server = server(true); + server.db.close().await; + let (mut client, p) = player(&server, 1, 100.0); + walk(&server, &mut client, &p, 1400.0).await; + client.drain(); + advance(10000).await; + client.drain(); + if disconnect { + crate::world::session::on_disconnect(&server, &mut client.conn).await; + } else { + crate::world::session::leave_world_task( + &server, + Some(&mut client.conn), + super::leave_target::CHARACTER_SELECT, + Some(p.clone()), + ) + .await; + } + client.drain(); + advance(20000).await; + assert!(!client + .drain_ops() + .contains(&sc::SCCharacterResurrectedPacket)); + assert!(server.world.character_by_obj_id(p.obj_id).is_none()); + assert_eq!(p.data().unit.transform.x, 1400.0); + } +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_instance_return_moves_the_world_registration_and_visibility() { + let server = server(true); + let template = WorldTemplate::synthetic(2, "closed_instance", 2, 2, CLOSED); + let instance = server.world.create_world_instance(Arc::new(template), 77); + let (mut arrival, _) = player(&server, 2, 128.0); + let mut client = TestClient::new(&server, 1, 1001); + let mut character = test_character(1, "InstanceTester", 100.0, 100.0); + character.obj_id = 0x101; + character.is_online = true; + character.unit.transform.instance_id = 77; + character.unit.transform.world_id = 2; + character.unit.transform.zone_id = CLOSED; + let p = crate::world::Player::new(character, client.conn.handle()); + server.world.try_add_character(&p); + instance.spawn(&p, &server.view_ctx()); + client.conn.active_char = Some(p.clone()); + on_zone_change(&server, &p, 0, CLOSED); + client.drain(); + arrival.drain(); + advance(10000).await; + advance(200).await; + let t = p.data().unit.transform; + assert_eq!((t.instance_id, t.world_id, t.zone_id), (0, 0, TEST_ZONE)); + assert!(instance.character_by_obj_id(p.obj_id).is_none()); + assert!(server + .world + .world(0) + .unwrap() + .character_by_obj_id(p.obj_id) + .is_some_and(|live| Arc::ptr_eq(&p, &live))); + assert_eq!(p.region().map(|r| r.0), Some(0)); + assert!(client.drain_ops().contains(&sc::SCLoadInstancePacket)); + assert!(arrival.drain_ops().contains(&sc::SCUnitStatePacket)); + crate::systems::instances::worlds::instance_loaded(&server, &p); + assert!(!p.data().disabled_set_position); + advance(20000).await; + assert_eq!(warning_count(&mut client), 0); +} + +#[tokio::test] +async fn closed_zone_npc_teleport_does_not_charge_the_fare() { + struct Wallet; + impl crate::systems::npcs::hooks::EconomyBridge for Wallet { + fn change_money( + &self, + _server: &GameServer, + p: &PlayerRef, + amount: i64, + _task: u8, + ) -> bool { + p.data().money += amount; + true + } + } + let server = server(true); + server.systems.npcs.hooks.economy.install(Arc::new(Wallet)); + let (mut client, p) = player(&server, 1, 100.0); + p.data().money = 500; + let mut npc = Npc::new(900); + npc.unit.transform.set_xyz(101.0, 100.0, 100.0); + let npc = Entity::new(0x123456, npc); + server + .world + .world(0) + .unwrap() + .spawn(&npc, &server.view_ctx()); + client.drain(); + // Native 1.2 397CB0E0 (x2game12.c:1766873): return point:u32, money:i32, npc:bc. + let request = [10, 0, 0, 0, 120, 0, 0, 0, 0x56, 0x34, 0x12]; + server + .handle_frame( + &mut client.conn, + &encode_raw(1, cs::CSUseTeleportPacket, &request), + ) + .await + .unwrap(); + assert_eq!(p.data().money, 500); + assert_eq!(client.drain_ops(), vec![sc::SCErrorMsgPacket]); + assert!(!p.data().disabled_set_position); + p.data().access_level = 100; + server + .handle_frame( + &mut client.conn, + &encode_raw(1, cs::CSUseTeleportPacket, &request), + ) + .await + .unwrap(); + assert_eq!(p.data().money, 380); + assert_eq!(client.drain_ops(), vec![sc::SCTeleportUnitPacket]); +} + +#[tokio::test] +async fn closed_zone_worldgate_skill_is_rejected_before_mana_and_cooldown() { + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + let caster = WorldObject::from(&p); + let skill = crate::systems::skills::skill::new_skill_for( + &server, + server + .game_data + .systems + .skills + .skill(GATE_SKILL) + .unwrap() + .clone(), + Some(&caster), + ); + let before = p.data().unit.transform; + let result = crate::systems::skills::skill::use_skill( + &server, + &skill, + &caster, + SkillCaster::Unit(p.obj_id), + &mut SkillCastTarget::Unit(p.obj_id), + None, + false, + ); + assert_eq!(result, (skill_result::NO_PERM, 0)); + assert_eq!(p.data().unit.mp, 100); + assert!(!p + .data() + .unit + .cooldowns + .check_cooldown(GATE_SKILL, crate::world::now_ms())); + assert_eq!(p.data().unit.transform, before); + assert!(client.drain().is_empty()); +} + +#[tokio::test] +async fn closed_zone_open_portal_skill_rejects_the_saved_book_destination_before_charging() { + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + p.data().portals.private_portals.push(Portal { + id: GATE, + zone_id: CLOSED, + x: 1400.0, + y: 100.0, + ..Default::default() + }); + let caster = WorldObject::from(&p); + let skill = crate::systems::skills::skill::new_skill_for( + &server, + server + .game_data + .systems + .skills + .skill(OPEN_SKILL) + .unwrap() + .clone(), + Some(&caster), + ); + let result = crate::systems::skills::skill::use_skill( + &server, + &skill, + &caster, + SkillCaster::Unit(p.obj_id), + &mut SkillCastTarget::Unit(p.obj_id), + Some(SkillObject::PortalInfo { + kind: 0, + id: GATE as i32, + x: 101.0, + y: 100.0, + z: 100.0, + }), + false, + ); + assert_eq!(result, (skill_result::NO_PERM, 0)); + assert_eq!(p.data().unit.mp, 100); + assert!(!p + .data() + .unit + .cooldowns + .check_cooldown(OPEN_SKILL, crate::world::now_ms())); + assert!(client.drain().is_empty()); +} + +#[tokio::test] +async fn closed_zone_saved_return_and_unknown_mapping_are_checked_without_fabrication() { + use crate::systems::skills::effects::{EffectArgs, EffectSource}; + use crate::systems::skills::types::CastAction; + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + p.data().return_district_id = 1; + let before = p.data().unit.transform; + let caster = WorldObject::from(&p); + let args = EffectArgs { + caster: Some(caster.clone()), + caster_caster: SkillCaster::Unit(p.obj_id), + target: crate::systems::skills::geometry::Target::Obj(caster), + target_caster: SkillCastTarget::Unit(p.obj_id), + cast: CastAction::Skill { + skill_id: GATE_SKILL, + tl_id: 1, + }, + source: EffectSource::default(), + skill_object: &SkillObject::None, + }; + crate::systems::skills::effects::special::execute(&server, 25, &args, [0; 4]); + assert_eq!(p.data().unit.transform, before); + assert_eq!(client.drain_ops(), vec![sc::SCErrorMsgPacket]); + p.data().main_world_position = Some(Transform { + zone_id: CLOSED, + x: 1400.0, + ..before + }); + crate::systems::skills::effects::special::execute(&server, 25, &args, [9999, 0, 0, 0]); + assert_eq!(p.data().unit.transform, before); + assert_eq!(client.drain_ops(), vec![sc::SCErrorMsgPacket]); + // Unknown zone keys alone do not make an otherwise open coordinate closed. + assert!(zone_access::zone_access_allowed( + &server, &p, 0, 202, 100.0, 100.0 + )); + assert!(!zone_access::zone_access_allowed( + &server, &p, 0, 202, 1400.0, 100.0 + )); +} From 80303b48a224d83e88c17262ef92493b8b38f79c Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:43:39 -0400 Subject: [PATCH 08/66] fix(skills): apply progression and combat modifiers Apply native 1.2 XP percentage and attack haste conventions, direct skill radius/channel upgrades, heal upgrades, and buff damage modifiers. Snapshot channel duration for packet and timers and saturate newly scaled arithmetic. Add nine focused modifier regressions using applied buffs, authoritative effects, outgoing packets, and repeat delays. Source-only validation: rustfmt and diff checks; Cargo compilation, tests, Clippy, and live validation are reserved for parent allocation. Plot-only radius and channel upgrades remain unresolved pending native plot shape/delay evidence. Co-Authored-By: Codex --- .../src/systems/skills/effects/combat.rs | 36 +- .../src/systems/skills/modifier_flow_tests.rs | 689 ++++++++++++++++++ .../aaemu-game/src/systems/skills/progress.rs | 25 +- .../aaemu-game/src/systems/skills/skill.rs | 79 +- 4 files changed, 810 insertions(+), 19 deletions(-) create mode 100644 rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs b/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs index f1d5eb2162..89c0287a5a 100644 --- a/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs +++ b/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs @@ -369,6 +369,27 @@ pub fn damage( min = e.fixed_min as f32; max = e.fixed_max as f32; } + // Native 1.2 sub_3941B030 / sub_39354450: a buff source + // uses BuffAttribute::Damage (3), including fixed damage; it is not a skill modifier. + if let Some(b) = args.source.buff.as_ref().filter(|_| skill.is_none()) { + let tags = server.game_data.systems.skills.buff_tags(b.id); + caster.with_unit(|u| { + let modifiers = &u.unit().buff_modifiers; + let apply = |value: f32| { + modifiers + .apply( + b.id, + tags, + crate::models::unit::BuffAttribute::Damage, + f64::from(value), + ) + .max(0.0) + .min(f64::from(i32::MAX)) as f32 + }; + min = apply(min); + max = apply(max); + }); + } let mut final_damage = rand_float(min, max); if e.target_buff_tag_id > 0 && buffs::check_buff_tag(server, &trg, e.target_buff_tag_id) { final_damage *= e.target_buff_bonus_mul; @@ -663,6 +684,19 @@ pub fn heal( } } value = (value as f32 * cs[4] as f32) as i32; + if let Some(skill) = args.source.skill() { + // Native 1.2 sub_3941A460: Heal (12) follows HealMul, for fixed and + // computed healing alike. Reuse the cache's percent/value conventions. + value = super::super::skill::apply_skill_modifiers( + server, + skill, + &caster, + crate::models::unit::SkillAttribute::Heal, + f64::from(value), + ) + .max(0.0) + .min(f64::from(i32::MAX)) as i32; + } if let Some(p) = caster.as_player() { if e.actability_group_id > 0 { let act = p @@ -714,7 +748,7 @@ pub fn heal( let Some((old, hp, mp)) = trg.with_unit(|u| { let u = u.unit_mut(); let old = u.hp; - u.hp = (u.hp + value).min(u.max_hp); + u.hp = u.hp.saturating_add(value).min(u.max_hp); (old, u.hp, u.mp) }) else { return; diff --git a/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs b/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs new file mode 100644 index 0000000000..c05ab13092 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs @@ -0,0 +1,689 @@ +//! Modifier application regressions. Rows below retain the 1.2 compact IDs/units; +//! reduced channel times keep the scheduler tests short. Packet fields are read in native +//! 1.2 order (D:/aa-re/client12/decomp/x2game12.c): 397C6580 (XP), 397CA390 +//! (fired), 397C8760 (damage), 397C8EF0 (heal). No encoder generates expected packets. + +use std::sync::Arc; +use std::time::Duration; + +use aaemu_commons::PacketStream; + +use crate::data::GameData; +use crate::models::unit::{ + BonusTemplate, BuffAttribute, BuffModifier, SkillAttribute, SkillModifier, UnitAttribute, + UnitModifierType, +}; +use crate::opcodes::sc; +use crate::systems::skills; +use crate::test_support::{test_experience, TestClient}; +use crate::world::{NpcRef, PlayerRef, WorldObject}; + +use skills::data::effects::HealEffect; +use skills::data::{BuffTemplate, EffectKind, EffectTemplate, SkillTemplate, TickEffect}; +use skills::state::{AutoAttackSlot, CancelToken, SkillRef, SkillRun}; +use skills::types::{SkillCastTarget, SkillCaster, SkillObject}; + +fn data() -> GameData { + let mut data = GameData::empty(); + data.experience = test_experience(55); + data.formulas = crate::systems::vehicles::stats::tests::formulas( + &[(1, "100000", 14, 5), (2, "1000", 15, 5)], + &[], + ); + data +} + +fn bonus(attribute: UnitAttribute, value: i32) -> BonusTemplate { + BonusTemplate { + attribute, + modifier_type: UnitModifierType::Value, + value, + linear_level_bonus: 0, + } +} + +fn add_boost(data: &mut GameData, id: u32, bonuses: Vec) { + data.systems.skills.add_buff(BuffTemplate { + id, + kind: 1, + stack_rule: 1, + bonuses, + ..Default::default() + }); +} + +fn add_skill_modifier( + data: &mut GameData, + owner: u32, + skill_id: u32, + attr: SkillAttribute, + kind: UnitModifierType, + value: i32, +) { + add_boost(data, owner, vec![]); + data.systems + .skills + .skill_modifiers + .entry(owner) + .or_default() + .push(SkillModifier { + id: owner, + owner_id: owner, + tag_id: 0, + skill_attribute: attr, + unit_modifier_type: kind, + value, + skill_id, + synergy: false, + }); +} + +fn apply_boost(server: &crate::GameServer, player: &PlayerRef, id: u32) { + let me = WorldObject::from(player); + skills::buffs::apply_template( + server, + server.game_data.systems.skills.buff(id).unwrap(), + Some(&me), + &SkillCaster::Unit(player.obj_id), + &me, + None, + ); + assert!(player.data().unit.buffs.check_buff(id)); +} + +fn cast(server: &crate::GameServer, player: &PlayerRef, target: u32, skill: &SkillRef) { + assert_eq!( + super::use_skill( + server, + skill, + &WorldObject::from(player), + SkillCaster::Unit(player.obj_id), + &mut SkillCastTarget::Unit(target), + Some(SkillObject::None), + true, + ) + .0, + 0, + ); +} + +// Native 1.2 sub_397C7A40 (cast union), sub_397C85B0 (caster), and the readers above. +fn read_effect(s: &mut PacketStream, op: u16) -> (u32, i64) { + match s.read_u8().unwrap() { + 0 => { + s.read_u32().unwrap(); + s.read_u16().unwrap(); + } + 2 => { + s.read_u32().unwrap(); + s.read_bc().unwrap(); + s.read_u32().unwrap(); + s.read_bool().unwrap(); + s.read_bool().unwrap(); + } + other => panic!("unexpected cast union {other}"), + } + assert_eq!(s.read_u8().unwrap(), 0); // unit caster + assert_eq!(s.read_bc().unwrap(), 0x100); + if op == sc::SCUnitDamagedPacket { + assert_eq!(s.read_bc().unwrap(), 0x100); // caster ID + let target = s.read_bc().unwrap(); + s.read_u8().unwrap(); // crime + let damage = s.read_pisc_w(3).unwrap(); + s.read_pisc_w(3).unwrap(); // mana burn + s.read_u8().unwrap(); // holdable + s.read_u16().unwrap(); // dice + s.read_u8().unwrap(); + s.read_u8().unwrap(); + (target, damage[0]) + } else { + assert_eq!(op, sc::SCUnitHealedPacket); + let target = s.read_bc().unwrap(); + assert_eq!(s.read_u8().unwrap(), 0); // health + assert_eq!(s.read_u8().unwrap(), 13); // noncritical heal + let value = s.read_i32().unwrap(); + assert_eq!(s.read_i32().unwrap(), 0); // overheal field + assert!(s.read_bool().unwrap()); + (target, i64::from(value)) + } +} + +fn effects(client: &mut TestClient) -> Vec<(u32, i64)> { + let mut out = vec![]; + for (op, body) in client.drain() { + if op & 0x8000 != 0 { + let raw = skills::packets::inflate_stored(&body).unwrap(); + let mut s = PacketStream::from_bytes(raw); + for _ in 0..(op & 0x7fff) { + assert_eq!(s.read_u16().unwrap(), 0); + let op = s.read_u16().unwrap(); + out.push(read_effect(&mut s, op)); + } + assert!(s.unread().is_empty()); + } else if op == sc::SCUnitDamagedPacket || op == sc::SCUnitHealedPacket { + out.push(read_effect(&mut PacketStream::from_bytes(body), op)); + } + } + out +} + +#[tokio::test] +async fn modifier_exp_buff_boosts_positive_xp_and_active_abilities_only() { + let mut data = data(); + // compact unit_modifiers: buff 3084, ExpMul, Value +20 (percentage points). + add_boost(&mut data, 3084, vec![bonus(UnitAttribute::ExpMul, 20)]); + let (server, mut client, player, _) = skills::cast_validation_tests::fixture(data); + { + let mut c = player.data(); + c.experience = 10_000; + [c.ability1, c.ability2, c.ability3] = [1, 2, 3]; + for a in c.abilities.abilities.iter_mut().take(3) { + a.exp = 10_000; + } + } + client.drain(); + skills::progress::add_exp(&server, &player, 100, true); + // Native 1.2 sub_397C6580: BC unit ID, signed i32 XP delta, boolean ability flag. + assert!(client + .drain() + .contains(&(sc::SCExpChangedPacket, vec![0, 1, 0, 100, 0, 0, 0, 1]))); + apply_boost(&server, &player, 3084); + client.drain(); + skills::progress::add_exp(&server, &player, 100, true); + assert!(client + .drain() + .contains(&(sc::SCExpChangedPacket, vec![0, 1, 0, 120, 0, 0, 0, 1]))); + assert_eq!(player.data().experience, 10_220); + for a in &player.data().abilities.abilities { + assert_eq!(a.exp, if a.id <= 3 { 10_220 } else { 0 }); + } + skills::progress::add_exp(&server, &player, -30, true); + assert_eq!(player.data().experience, 10_190); // death/ordinary loss unchanged + skills::progress::add_exp(&server, &player, 100, false); + assert_eq!(player.data().experience, 10_310); + assert_eq!(player.data().abilities.abilities[0].exp, 10_190); + skills::buffs::remove_buff(&server, &WorldObject::from(&player), 3084); + skills::progress::add_exp(&server, &player, 100, true); + assert_eq!(player.data().experience, 10_410); +} + +#[tokio::test] +async fn modifier_exp_config_composes_and_large_gains_preserve_level_caps() { + let mut data = data(); + add_boost(&mut data, 3084, vec![bonus(UnitAttribute::ExpMul, 20)]); + let mut server = crate::test_support::test_server_with(data); + server.config.world.exp_rate = 2.0; + let mut c = crate::test_support::test_character(1, "XP", 100.0, 100.0); + c.experience = 10_000; + c.ability1 = 1; + c.unit.bonuses.add_bonus( + 1, + crate::models::unit::Bonus { + template: bonus(UnitAttribute::ExpMul, 20), + value: 20, + }, + ); + assert_eq!( + skills::progress::add_exp_locked(&server, &mut c, 100, true) + .unwrap() + .exp, + 240 + ); + skills::progress::add_exp_locked(&server, &mut c, i32::MAX, true).unwrap(); + assert_eq!(c.unit.level, 55); + assert_eq!(c.experience, 55_000); + assert_eq!(c.abilities.abilities[0].exp, 55_000); + server.config.world.exp_rate = -1.0; + assert_eq!( + skills::progress::add_exp_locked(&server, &mut c, 100, true) + .unwrap() + .exp, + 0 + ); + assert_eq!( + skills::progress::add_exp_locked(&server, &mut c, -10, false) + .unwrap() + .exp, + -10 + ); +} + +struct Weapons; +impl skills::ext::ItemSkillHooks for Weapons { + fn weapon_holdable( + &self, + _: &crate::GameServer, + _: &WorldObject, + slot: i32, + ) -> Option { + Some(skills::ext::HoldableInfo { + speed: match slot { + 15 => 1500.0, + 16 => 2000.0, + 17 => 1800.0, + _ => return None, + }, + slot_type_id: skills::stats::slot_type::ONE_HANDED, + max_range: 30.0, + ..Default::default() + }) + } +} + +#[tokio::test] +async fn modifier_attack_delay_uses_the_weapon_and_matching_haste_once() { + let mut data = data(); + // compact buff 933: MeleeSpeedMul +300; ranged should be unchanged. + add_boost( + &mut data, + 933, + vec![bonus(UnitAttribute::MeleeSpeedMul, 300)], + ); + add_boost( + &mut data, + 1447, + vec![bonus(UnitAttribute::RangedSpeedMul, -200)], + ); + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(skills::tests::damage_effect(1, 100))), + 1, + ); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + server.systems.skills.ext.items.install(Arc::new(Weapons)); + let me = WorldObject::from(&player); + for (id, slot, base, boosted) in [ + (2, 15, 1500.0, 1500.0 / 1.3), + (3, 16, 2000.0, 2000.0 / 1.3), + (4, 17, 1800.0, 1800.0), + ] { + let t = SkillTemplate { + weapon_slot_for_auto_attack_id: slot, + effects: vec![skills::tests::skill_effect(1, EffectKind::DamageEffect, 1)], + ..skills::tests::skill_template(id) + }; + assert_eq!(super::attack_delay(&server, &t, &me, true, 1000.0), base); + apply_boost(&server, &player, 933); + assert!((super::attack_delay(&server, &t, &me, true, 1000.0) - boosted).abs() < 0.001); + let skill = SkillRun::new(Arc::new(t), 1); + let cancel = CancelToken::new(); + { + let mut c = player.data(); + c.unit.current_target = npc.obj_id; + c.unit.skill_state.auto_attack = Some(AutoAttackSlot { + skill: skill.clone(), + cancel: cancel.clone(), + }); + } + client.drain(); + assert_eq!( + super::auto_attack_tick(&server, &player, &skill, &cancel), + Some(boosted as i64) + ); + assert_eq!(effects(&mut client), vec![(npc.obj_id, 100)]); + skills::buffs::remove_buff(&server, &me, 933); + } + apply_boost(&server, &player, 1447); + let t = skills::tests::skill_template(4); + assert_eq!(super::attack_delay(&server, &t, &me, true, 1000.0), 2250.0); + // Haste and GCD are distinct attributes; the GCD factor is included once. + player.data().unit.bonuses.add_bonus( + 999, + crate::models::unit::Bonus { + template: bonus(UnitAttribute::GlobalCooldownMul, 1000), + value: 1000, + }, + ); + assert_eq!(super::attack_delay(&server, &t, &me, true, 1000.0), 1125.0); +} + +fn heal_effect() -> HealEffect { + HealEffect { + id: 1, + use_fixed_heal: true, + fixed_min: 100, + fixed_max: 100, + use_level_heal: false, + level_md: 0.0, + level_va_start: 0, + level_va_end: 0, + percent: false, + use_charged_buff: false, + charged_buff_id: 0, + charged_mul: 0.0, + slave_applicable: false, + ignore_heal_aggro: false, + dps_multiplier: 0.0, + actability_group_id: 0, + actability_step: 0, + actability_mul: 0.0, + actability_add: 0.0, + } +} + +#[tokio::test] +async fn modifier_heal_buff_changes_actual_healing_and_packet_once() { + for fixed in [false, true] { + heal_with_modifier(fixed).await; + } +} + +async fn heal_with_modifier(fixed: bool) { + let mut data = data(); + // compact row 412: buff 5254, Fervent Healing 14929, Heal +7 percent. + add_skill_modifier( + &mut data, + 5254, + 14929, + SkillAttribute::Heal, + UnitModifierType::Percent, + 7, + ); + let mut effect = heal_effect(); + effect.use_fixed_heal = fixed; + effect.dps_multiplier = 1.0; + data.systems + .skills + .add_effect(EffectKind::HealEffect, EffectTemplate::Heal(effect), 1); + add_boost(&mut data, 999, vec![bonus(UnitAttribute::HealDps, 100_000)]); + let (server, mut client, player, _) = skills::cast_validation_tests::fixture(data); + apply_boost(&server, &player, 999); + let skill = SkillRun::new( + Arc::new(SkillTemplate { + target_type: 0, + effects: vec![skills::tests::skill_effect(1, EffectKind::HealEffect, 1)], + ..skills::tests::skill_template(14929) + }), + 1, + ); + for (boosted, expected) in [(false, 100), (true, 107), (false, 100)] { + if boosted { + apply_boost(&server, &player, 5254); + } else { + skills::buffs::remove_buff(&server, &WorldObject::from(&player), 5254); + } + player.data().unit.hp = 500; + client.drain(); + cast(&server, &player, player.obj_id, &skill); + assert_eq!(player.data().unit.hp, 500 + expected); + assert_eq!( + effects(&mut client), + vec![(player.obj_id, i64::from(expected))] + ); + } +} + +#[tokio::test] +async fn modifier_existing_skill_damage_is_still_applied_once() { + let mut data = data(); + add_skill_modifier( + &mut data, + 900, + 10001, + SkillAttribute::Damage, + UnitModifierType::Percent, + 10, + ); + add_boost( + &mut data, + 901, + vec![bonus(UnitAttribute::MainhandDps, 100_000)], + ); + let mut damage = skills::tests::damage_effect(1, 0); + damage.use_fixed_damage = false; + damage.use_mainhand_weapon = true; + damage.dps_multiplier = 1.0; + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(damage)), + 1, + ); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + apply_boost(&server, &player, 901); + let skill = SkillRun::new( + Arc::new(SkillTemplate { + effects: vec![skills::tests::skill_effect(1, EffectKind::DamageEffect, 1)], + ..skills::tests::skill_template(10001) + }), + 1, + ); + client.drain(); + cast(&server, &player, npc.obj_id, &skill); + assert_eq!(effects(&mut client), vec![(npc.obj_id, 100)]); + apply_boost(&server, &player, 900); + client.drain(); + cast(&server, &player, npc.obj_id, &skill); + assert_eq!(effects(&mut client), vec![(npc.obj_id, 110)]); +} + +#[tokio::test] +async fn modifier_native_channel_upgrade_adds_four_seconds() { + let mut data = data(); + // Unscaled compact row 470: Protective Wings 10714, buff 5326, +4000ms. + add_skill_modifier( + &mut data, + 5326, + 10714, + SkillAttribute::ChannelingTime, + UnitModifierType::Value, + 4000, + ); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + let skill = SkillRun::new( + Arc::new(SkillTemplate { + channeling_time: 18000, + channeling_tick: 1000, + ..skills::tests::skill_template(10714) + }), + 1, + ); + for (boosted, expected) in [(false, 1810), (true, 2210)] { + if boosted { + apply_boost(&server, &player, 5326); + } + client.drain(); + cast(&server, &player, npc.obj_id, &skill); + let fired = client + .drain() + .into_iter() + .find(|(op, _)| *op == sc::SCSkillFiredPacket) + .unwrap() + .1; + assert_eq!( + i16::from_le_bytes(fired[17..19].try_into().unwrap()), + expected + ); + super::stop(&server, &skill, &WorldObject::from(&player), 0); + } +} + +#[tokio::test] +async fn modifier_buff_damage_matches_buff_id_or_tag_and_disappears_on_removal() { + for by_tag in [false, true] { + let mut data = data(); + let owner = if by_tag { 5263 } else { 356 }; + add_boost(&mut data, owner, vec![]); + data.systems.skills.buff_game_data.buff_modifiers.insert( + owner, + vec![BuffModifier { + id: if by_tag { 95 } else { 2 }, + owner_id: owner, + buff_id: if by_tag { 0 } else { 121 }, + tag_id: if by_tag { 36 } else { 0 }, + buff_attribute: BuffAttribute::Damage, + unit_modifier_type: UnitModifierType::Percent, + value: 10, + synergy: false, + }], + ); + data.systems.skills.buff_tags.insert(121, vec![36]); + data.systems.skills.add_buff(BuffTemplate { + id: 121, + kind: 2, + duration: 1000, + tick: 1000.0, + stack_rule: 1, + tick_effects: vec![TickEffect { + effect_id: 1, + target_buff_tag_id: 0, + target_no_buff_tag_id: 0, + }], + ..Default::default() + }); + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(skills::tests::damage_effect(1, 100))), + 1, + ); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + let me = WorldObject::from(&player); + let target = WorldObject::from(&npc); + for (boosted, expected) in [(false, 100), (true, 110), (false, 100)] { + if boosted { + apply_boost(&server, &player, owner); + } else { + skills::buffs::remove_buff(&server, &me, owner); + } + skills::buffs::apply_template( + &server, + server.game_data.systems.skills.buff(121).unwrap(), + Some(&me), + &SkillCaster::Unit(player.obj_id), + &target, + None, + ); + let index = npc + .data() + .unit + .buffs + .effects + .iter() + .find(|b| b.template.id == 121) + .unwrap() + .index; + let before = npc.data().unit.hp; + client.drain(); + // Drive the real buff tick synchronously; do not duplicate its EffectSource setup. + skills::buffs::schedule_effect(&server, &target, index, false); + assert_eq!(npc.data().unit.hp, before - expected); + assert_eq!( + effects(&mut client), + vec![(npc.obj_id, i64::from(expected))] + ); + skills::buffs::remove_buff(&server, &target, 121); + } + } +} + +#[tokio::test] +async fn modifier_area_buff_expands_real_target_selection_in_meters() { + let mut data = data(); + // compact row 371: buff 5206 adds 5m to skill 11395's 5m radius. + add_skill_modifier( + &mut data, + 5206, + 11395, + SkillAttribute::AreaRadius, + UnitModifierType::Value, + 5, + ); + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(skills::tests::damage_effect(1, 100))), + 1, + ); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + player.data().unit.transform.set_xyz(100.0, 90.0, 100.0); + let world = server.world.world(0).unwrap(); + let mut other = crate::models::npc::Npc::new(1); + other.unit.hp = 1000; + other.unit.max_hp = 1000; + other.unit.transform.set_xyz(100.0, 112.0, 100.0); // 7m from original target + let other: NpcRef = crate::world::Entity::new(0x201, other); + world.spawn(&other, &server.view_ctx()); + let skill = SkillRun::new( + Arc::new(SkillTemplate { + target_area_radius: 5, + target_relation: 0, + target_selection: 1, + effects: vec![skills::tests::skill_effect(1, EffectKind::DamageEffect, 1)], + ..skills::tests::skill_template(11395) + }), + 1, + ); + for (boosted, count) in [(false, 1), (true, 2), (false, 1)] { + if boosted { + apply_boost(&server, &player, 5206); + } else { + skills::buffs::remove_buff(&server, &WorldObject::from(&player), 5206); + } + client.drain(); + let before = other.data().unit.hp; + cast(&server, &player, npc.obj_id, &skill); + let packets = effects(&mut client); + assert_eq!(packets.len(), count); + assert!(packets.contains(&(npc.obj_id, 100))); + assert_eq!(other.data().unit.hp, before - if boosted { 100 } else { 0 }); + } +} + +#[tokio::test] +async fn modifier_channel_packet_and_ticks_share_a_snapshot_of_duration() { + for boosted in [false, true] { + let mut data = data(); + // Same Value/millisecond semantics as compact 5326 (+4000ms). Small values + // let this test observe expiry and the ticks beyond the original duration. + add_skill_modifier( + &mut data, + 5326, + 10714, + SkillAttribute::ChannelingTime, + UnitModifierType::Value, + 200, + ); + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(skills::tests::damage_effect(1, 10))), + 1, + ); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + if boosted { + apply_boost(&server, &player, 5326); + } + let skill = SkillRun::new( + Arc::new(SkillTemplate { + channeling_time: 200, + channeling_tick: 50, + effects: vec![skills::tests::skill_effect(1, EffectKind::DamageEffect, 1)], + ..skills::tests::skill_template(10714) + }), + 1, + ); + client.drain(); + cast(&server, &player, npc.obj_id, &skill); + let fired = client + .drain() + .into_iter() + .find(|(op, _)| *op == sc::SCSkillFiredPacket) + .unwrap() + .1; + // Native sub_397CA390: ID, timeline, caster, target, object, two msec fields. + // Pin the current wire's duration field independently of the packet encoder. + let wire_duration = i16::from_le_bytes(fired[17..19].try_into().unwrap()); + assert_eq!(wire_duration, if boosted { 50 } else { 30 }); + skills::buffs::remove_buff(&server, &WorldObject::from(&player), 5326); + tokio::time::sleep(Duration::from_millis(270)).await; + assert_eq!(player.data().unit.skill_state.skill_task.is_some(), boosted); + let deadline = tokio::time::Instant::now() + Duration::from_secs(2); + while player.data().unit.skill_state.skill_task.is_some() + && tokio::time::Instant::now() < deadline + { + tokio::time::sleep(Duration::from_millis(10)).await; + } + assert!(player.data().unit.skill_state.skill_task.is_none()); + let packets = effects(&mut client); + assert_eq!(packets.len(), if boosted { 7 } else { 3 }); + assert!(packets.iter().all(|p| *p == (npc.obj_id, 10))); + assert_eq!(npc.data().unit.hp, if boosted { 930 } else { 970 }); + } +} diff --git a/rust/crates/aaemu-game/src/systems/skills/progress.rs b/rust/crates/aaemu-game/src/systems/skills/progress.rs index 63a30787be..f1686c14b5 100644 --- a/rust/crates/aaemu-game/src/systems/skills/progress.rs +++ b/rust/crates/aaemu-game/src/systems/skills/progress.rs @@ -10,6 +10,7 @@ use aaemu_commons::{Marshal, PacketStream}; use crate::data::formulas::FormulaKind; use crate::models::char_data::{ability, Skill}; use crate::models::character::Character; +use crate::models::unit::UnitAttribute; use crate::net::packet::LEVEL_PLAIN; use crate::opcodes::sc; use crate::packets::packet_def; @@ -122,7 +123,7 @@ fn actability_exp_multiplier(_step: u8) -> f32 { /// character's lock is released. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct ExpGain { - /// The applied delta (after `ExpRate`). + /// The applied delta (after `ExpRate` and the caster's XP bonuses). pub exp: i32, pub should_add_ability_exp: bool, /// The new level when the character leveled up. @@ -141,10 +142,22 @@ pub fn add_exp_locked( return None; } if exp_delta > 0 { - exp_delta = (f64::from(exp_delta) * server.config.world.exp_rate) as i32; + // Native 1.2 sub_398A0D60: ExpMul (95) starts at 100, unlike damage/haste's + // per-mille attributes. Apply Bonuses to that base so Percent rows work too. + let multiplier = c + .unit + .calculate_with_bonuses(100.0, UnitAttribute::ExpMul, now_ms()); + let gain = + f64::from(exp_delta) * server.config.world.exp_rate.max(0.0) * multiplier.max(0.0) + / 100.0; + exp_delta = gain.max(0.0).min(f64::from(i32::MAX)) as i32; } let exp_table = &server.game_data.experience; - let mut new_exp = c.experience.wrapping_add(exp_delta); + let mut new_exp = if exp_delta > 0 { + c.experience.saturating_add(exp_delta) + } else { + c.experience.wrapping_add(exp_delta) + }; let (new_level, overflow) = match exp_table.level_from_exp(new_exp, c.unit.level, false) { Ok(v) => v, Err(e) => { @@ -167,7 +180,11 @@ pub fn add_exp_locked( continue; } if let Some(ab) = c.abilities.get_mut(a) { - ab.exp = (ab.exp + exp_delta).min(max_exp); + ab.exp = if exp_delta > 0 { + ab.exp.saturating_add(exp_delta).min(max_exp) + } else { + (ab.exp + exp_delta).min(max_exp) + }; } } } diff --git a/rust/crates/aaemu-game/src/systems/skills/skill.rs b/rust/crates/aaemu-game/src/systems/skills/skill.rs index 447c3171cd..6d3ccd8151 100644 --- a/rust/crates/aaemu-game/src/systems/skills/skill.rs +++ b/rust/crates/aaemu-game/src/systems/skills/skill.rs @@ -9,7 +9,7 @@ use std::sync::Arc; use rand::Rng; use crate::models::transform::PositionAndRotation; -use crate::models::unit::SkillAttribute; +use crate::models::unit::{SkillAttribute, UnitAttribute}; use crate::server::GameServer; use crate::systems::social::achievement::char_record_kind; use crate::systems::social::achievement_hooks::{AchievementInput, RecordMatch}; @@ -882,6 +882,17 @@ pub fn start_channeling(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { .map(|target| (target.obj_id(), target.core() as *const _ as usize)); let caster = &ctx.caster; let t = &skill.template; + // Native 1.2 sub_398A01B0, attribute 11: milliseconds, independent of CastTime. + // The fired packet encodes duration as signed i16 (ms / 10 + 10). + let channeling_time = apply_skill_modifiers( + server, + skill, + caster, + SkillAttribute::ChannelingTime, + f64::from(t.channeling_time), + ) + .max(0.0) + .min(f64::from((i32::from(i16::MAX) - 10) * 10)) as i32; let data = &server.game_data.systems.skills; if t.channeling_buff_id != 0 { if let Some(b) = data.buff(t.channeling_buff_id).cloned() { @@ -931,7 +942,7 @@ pub fn start_channeling(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { target: ctx.target_caster, skill_object: ctx.skill_object.clone(), computed_delay: 0, - channeling_time: t.channeling_time, + channeling_time, fire_anim_id: t.fire_anim_id, }, true, @@ -953,11 +964,12 @@ pub fn start_channeling(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { ctx.clone(), cancel.clone(), t.channeling_tick, + channeling_time, ); } let skill2 = skill.clone(); let ctx2 = ctx.clone(); - let scheduled = super::tasks::schedule(server, i64::from(t.channeling_time), move |srv| { + let scheduled = super::tasks::schedule(server, i64::from(channeling_time), move |srv| { if cancel.is_cancelled() { return; } @@ -990,9 +1002,10 @@ fn schedule_channel_tick( ctx: CastCtx, cancel: CancelToken, elapsed: i32, + duration: i32, ) { let interval = skill.template.channeling_tick; - if interval <= 0 || elapsed >= skill.template.channeling_time { + if interval <= 0 || elapsed >= duration { return; } super::tasks::schedule(server, i64::from(interval), move |server| { @@ -1044,6 +1057,7 @@ fn schedule_channel_tick( ctx.clone(), cancel, elapsed.saturating_add(interval), + duration, ); }); } @@ -1367,10 +1381,11 @@ fn append_hostile_ships_hit_by_siege_hull_aoe( caster: &Target, target_self: &Target, ctx: &CastCtx, + radius: f32, possible: &mut Vec, ) { use crate::systems::ai::physics::{siege_point_hits_ship, SIEGE_PIVOT_QUERY_SLACK_METERS}; - if t.target_area_radius <= 0 { + if radius <= 0.0 { return; } if DamageType::from_raw(i64::from(t.damage_type_id)) != Some(DamageType::Siege) { @@ -1382,7 +1397,6 @@ fn append_hostile_ships_hit_by_siege_hull_aoe( ) { return; } - let radius = t.target_area_radius as f32; let p = super::geometry::world_pos(server, target_self); let relation = SkillTargetRelation::from_raw(i64::from(t.target_relation)) .unwrap_or(SkillTargetRelation::Any); @@ -1426,6 +1440,16 @@ pub fn apply_effects(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { let caster_t = Target::Obj(caster.clone()); let target_self = &ctx.target; let selection = SkillTargetSelection::from_raw(i64::from(t.target_selection)); + // Native 1.2 sub_398A01B0 attribute 3 / sub_39420B30: radius is in meters. + let area_radius = apply_skill_modifiers( + server, + skill, + caster, + SkillAttribute::AreaRadius, + f64::from(t.target_area_radius), + ) + .max(0.0) + .min(f64::from(i32::MAX)) as f32; let mut possible: Vec = Vec::new(); if t.target_siege && selection == Some(SkillTargetSelection::Source) @@ -1433,8 +1457,7 @@ pub fn apply_effects(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { { possible.push(target_self.clone()); } else if t.target_area_radius > 0 { - let mut units = - super::geometry::around_radius(server, target_self, t.target_area_radius as f32, true); + let mut units = super::geometry::around_radius(server, target_self, area_radius, true); if selection == Some(SkillTargetSelection::Source) { if let Some(o) = target_self.as_obj() { units.push(o.clone()); @@ -1456,6 +1479,7 @@ pub fn apply_effects(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { &caster_t, target_self, ctx, + area_radius, &mut possible, ); // Distinct @@ -2133,10 +2157,20 @@ pub fn attack_delay( ) -> f64 { let gcd_mul = stat(server, caster, StatKind::GlobalCooldownMul); if matches!(t.id, 2..=4) && caster.as_player().is_some() { - let (slot, fallback) = match t.id { - 2 => (equip_slot::MAINHAND, 1500.0), - 3 => (equip_slot::OFFHAND, 1500.0), - _ => (equip_slot::RANGED, 1800.0), + let slot = match t.weapon_slot_for_auto_attack_id { + equip_slot::MAINHAND | equip_slot::OFFHAND | equip_slot::RANGED => { + t.weapon_slot_for_auto_attack_id + } + _ => match t.id { + 2 => equip_slot::MAINHAND, + 3 => equip_slot::OFFHAND, + _ => equip_slot::RANGED, + }, + }; + let fallback = if slot == equip_slot::RANGED { + 1800.0 + } else { + 1500.0 }; let speed = server .systems @@ -2144,9 +2178,22 @@ pub fn attack_delay( .ext .items() .weapon_holdable(server, caster, slot) - .filter(|h| h.speed > 0.0) + .filter(|h| h.speed.is_finite() && h.speed > 0.0) .map_or(fallback, |h| f64::from(h.speed)); - return (speed * (gcd_mul / 100.0)).clamp(400.0, 5000.0); + let attr = if slot == equip_slot::RANGED { + UnitAttribute::RangedSpeedMul + } else { + UnitAttribute::MeleeSpeedMul + }; + let haste = caster + .with_unit(|u| u.unit().calculate_with_bonuses(0.0, attr, now_ms())) + .unwrap_or(0.0); + // Native 1.2 sub_398B49E0: weapon delay * 1000 / (1000 + haste), + // guarding the denominator at 1. Offhand uses melee haste, ranged its own. + // Only this server repeat timer applies haste; the GCD remains once-only. + return (speed * (gcd_mul / 100.0) * 1000.0 / (1000.0 + haste.max(-999.0))) + .max(0.0) + .min(f64::from(i32::MAX)); } let cast_mul = stat(server, caster, StatKind::CastTimeMul); let cast = f64::from(t.casting_time) * cast_mul; @@ -2364,3 +2411,7 @@ mod auto_attack_lifecycle_tests { #[cfg(test)] #[path = "owned_npc_target_tests.rs"] mod owned_npc_target_tests; + +#[cfg(test)] +#[path = "modifier_flow_tests.rs"] +mod modifier_flow_tests; From 4680231e2468feed6e6f35195f829354fe9c2431 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:46:59 -0400 Subject: [PATCH 09/66] test(game): enable paused time for standalone game regressions --- rust/crates/aaemu-game/Cargo.toml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/rust/crates/aaemu-game/Cargo.toml b/rust/crates/aaemu-game/Cargo.toml index cfbfd5d2aa..2214d62f70 100644 --- a/rust/crates/aaemu-game/Cargo.toml +++ b/rust/crates/aaemu-game/Cargo.toml @@ -41,3 +41,6 @@ twilight-gateway.workspace = true twilight-http.workspace = true twilight-model.workspace = true +[dev-dependencies] +tokio = { workspace = true, features = ["test-util"] } + From ae83bd8f6609df3dab5943dba2420733b08c5de4 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:49:10 -0400 Subject: [PATCH 10/66] fix(vehicles): recover native 1.2 slave attach transforms Recover 87 missing transforms for 15 models from native CGF helpers, CHR absolute bind poses and prefab helpers. Add bounded extraction tooling, per-node asset provenance and literal/real-data coverage tests. Keep 41 unsupported nonzero points and None bindings explicit instead of fabricating transforms. Validation: eight lightweight Python tests pass against the native 1.2 game_pak and read-only compact; rustfmt and diff checks pass. Cargo and live validation intentionally deferred to the parent build slot. Co-Authored-By: Codex --- .../app/Data/slave_attach_points.json | 786 ++++ .../aaemu-game/tests/slave_attach_coverage.rs | 164 + .../tools/slave_attach_points.provenance.json | 4137 +++++++++++++++++ rust/tools/slave_attach_points.py | 414 ++ rust/tools/test_slave_attach_points.py | 191 + 5 files changed, 5692 insertions(+) create mode 100644 rust/crates/aaemu-game/tests/slave_attach_coverage.rs create mode 100644 rust/tools/slave_attach_points.provenance.json create mode 100644 rust/tools/slave_attach_points.py create mode 100644 rust/tools/test_slave_attach_points.py 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 00b7b53005..3d5c8c5d6d 100644 --- a/rust/crates/aaemu-game/app/Data/slave_attach_points.json +++ b/rust/crates/aaemu-game/app/Data/slave_attach_points.json @@ -2520,5 +2520,791 @@ "Z": 11.144756 } } + }, + { + "Name": "Native 1.2 model 5", + "ModelId": 5, + "AttachPoints": { + "24": { + "X": -1.42433345, + "Y": -6.89326668, + "Z": 0.83646423, + "Roll": 7.89580808, + "Pitch": 0.0, + "Yaw": 179.99999135 + }, + "35": { + "X": -0.39981079, + "Y": 2.3511963, + "Z": 15.238708, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "81": { + "X": -1.98440182, + "Y": -1.09256768, + "Z": 14.48642063, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 867", + "ModelId": 867, + "AttachPoints": { + "35": { + "X": 0.0, + "Y": -2.2049498, + "Z": 2.60459892, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 892", + "ModelId": 892, + "AttachPoints": { + "9": { + "X": 0.80468994, + "Y": -2.04911017, + "Z": 2.16120005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 898", + "ModelId": 898, + "AttachPoints": { + "9": { + "X": 0.80468994, + "Y": -2.04911017, + "Z": 2.16120005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 899", + "ModelId": 899, + "AttachPoints": { + "9": { + "X": 0.80468994, + "Y": -2.04911017, + "Z": 2.16120005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 1024", + "ModelId": 1024, + "AttachPoints": { + "9": { + "X": -4.29276672, + "Y": 2.23506424, + "Z": 4.4205661, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 83.00000122 + }, + "10": { + "X": -4.4767865, + "Y": 0.2020467, + "Z": 4.48708954, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 83.99995896 + }, + "11": { + "X": -4.57174072, + "Y": -3.67801453, + "Z": 4.64193115, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 92.00001601 + }, + "12": { + "X": -4.46449463, + "Y": -5.55405579, + "Z": 4.74579041, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 93.99999888 + }, + "13": { + "X": 4.30832184, + "Y": 2.23506409, + "Z": 4.4205661, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -82.00000269 + }, + "14": { + "X": 4.49234192, + "Y": 0.20204668, + "Z": 4.48708954, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -86.00000112 + }, + "15": { + "X": 4.58729614, + "Y": -3.67801453, + "Z": 4.64193115, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -92.99999467 + }, + "16": { + "X": 4.48005005, + "Y": -5.5540564, + "Z": 4.74579102, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -93.99998923 + }, + "17": { + "X": -0.02580078, + "Y": -17.12161865, + "Z": 6.53128357, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "19": { + "X": -1.91e-06, + "Y": 10.39880371, + "Z": 4.53841064, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "20": { + "X": 6.1e-07, + "Y": -2.66621552, + "Z": 4.55662964, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "21": { + "X": -1.34e-06, + "Y": 10.39880371, + "Z": 4.53841064, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "22": { + "X": 1.13e-06, + "Y": -2.66621552, + "Z": 4.55662811, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "23": { + "X": 0.0, + "Y": 13.83623413, + "Z": 4.65069, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "24": { + "X": -3.63965759, + "Y": -8.43711731, + "Z": 1.66250549, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 90.0 + }, + "25": { + "X": 3.16607452, + "Y": -8.43917725, + "Z": 1.51600861, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -90.0 + }, + "26": { + "X": -4.9426236, + "Y": 9.73896606, + "Z": 4.52553986, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "27": { + "X": 4.81819489, + "Y": 9.7243042, + "Z": 4.52553986, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -173.00000315 + }, + "28": { + "X": -3.58012238, + "Y": -10.39539673, + "Z": 8.99327942, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 21.64487823 + }, + "29": { + "X": 3.62164337, + "Y": -10.28855225, + "Z": 8.99328064, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -9.99999827 + }, + "35": { + "X": 0.00038204, + "Y": -13.99029541, + "Z": 6.92423584, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 1.19121086, + "Y": 14.19112061, + "Z": 5.12247559, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "37": { + "X": 5.11665863, + "Y": -0.7226757, + "Z": 3.33382629, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "38": { + "X": -0.24652342, + "Y": -8.87354675, + "Z": 5.2601709, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "39": { + "X": -0.92987915, + "Y": -10.47005615, + "Z": 1.97258972, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "46": { + "X": -0.07826172, + "Y": -3.24843933, + "Z": 38.54605469, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "58": { + "X": -1.04451965, + "Y": -14.86150757, + "Z": -2.14507004, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 179.99998133 + }, + "59": { + "X": 1.04451706, + "Y": -14.86150879, + "Z": -2.145065, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 179.99996403 + } + } + }, + { + "Name": "Native 1.2 model 1287", + "ModelId": 1287, + "AttachPoints": { + "2": { + "X": -0.47789001, + "Y": 0.36952, + "Z": 0.9364399, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "35": { + "X": 0.39533997, + "Y": -0.12314003, + "Z": 1.41565994, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.0, + "Y": -1.81697433, + "Z": 1.82779999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 1323", + "ModelId": 1323, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "60": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "61": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + } + } + }, + { + "Name": "Native 1.2 model 1371", + "ModelId": 1371, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "60": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "61": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + } + } + }, + { + "Name": "Native 1.2 model 1385", + "ModelId": 1385, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 15.15861938, + "Z": 1.93809326, + "Roll": -1.6090013, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "22": { + "X": 0.0, + "Y": 1.55865067, + "Z": 1.32873474, + "Roll": -1.6090013, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "24": { + "X": -2.40109009, + "Y": 12.69552368, + "Z": -1.10956696, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 71.01340743 + }, + "25": { + "X": 2.44303604, + "Y": 12.69552246, + "Z": -1.10635902, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -63.9865921 + }, + "36": { + "X": -1.60562973, + "Y": -2.22354645, + "Z": 1.34844727, + "Roll": -31.84449881, + "Pitch": 3.04776432, + "Yaw": -147.0619414 + }, + "37": { + "X": 2.99039398, + "Y": -0.53385757, + "Z": 1.22506035, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "38": { + "X": 0.76255249, + "Y": -10.80150879, + "Z": 1.83097321, + "Roll": -17.3346917, + "Pitch": -3.82501679, + "Yaw": -150.04003415 + }, + "39": { + "X": -1.69008774, + "Y": 13.50393433, + "Z": 1.87254852, + "Roll": -66.7200763, + "Pitch": -66.38009821, + "Yaw": 66.34809364 + }, + "58": { + "X": -1.91337097, + "Y": -12.50181641, + "Z": -1.46283188, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -179.99999135 + }, + "59": { + "X": 1.91337036, + "Y": -12.50181641, + "Z": -1.46283188, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -179.99999135 + }, + "60": { + "X": -2.38570313, + "Y": 12.47859131, + "Z": 4.42517761, + "Roll": -5.84543976, + "Pitch": 0.01637078, + "Yaw": 86.80389012 + }, + "61": { + "X": 3.77372406, + "Y": 11.7718396, + "Z": 5.30033264, + "Roll": 14.61988617, + "Pitch": -3.46511977, + "Yaw": 108.08774205 + }, + "62": { + "X": -4.77853394, + "Y": 2.81668457, + "Z": 3.8049884, + "Roll": -17.63500494, + "Pitch": 5.84323429, + "Yaw": 77.92499954 + }, + "63": { + "X": 3.68675873, + "Y": 3.93022034, + "Z": 3.87374054, + "Roll": 13.35100355, + "Pitch": -3.18382401, + "Yaw": 86.95435664 + }, + "64": { + "X": -3.90936157, + "Y": -4.94448669, + "Z": 5.00377747, + "Roll": -2.59864108, + "Pitch": -1.49955419, + "Yaw": 69.03402673 + }, + "65": { + "X": 1.47495453, + "Y": -10.06739441, + "Z": 4.89309875, + "Roll": 10.83311746, + "Pitch": -1.54938953, + "Yaw": 123.05834985 + }, + "66": { + "X": -2.29154297, + "Y": 6.43949036, + "Z": -0.64560669, + "Roll": -131.47489857, + "Pitch": 12.30072769, + "Yaw": 70.05732348 + }, + "67": { + "X": 2.25987289, + "Y": 8.95768433, + "Z": -0.4294125, + "Roll": 130.59802495, + "Pitch": -14.98278824, + "Yaw": 79.18461482 + }, + "68": { + "X": -2.20217819, + "Y": -8.47400269, + "Z": -0.35781158, + "Roll": -131.09412862, + "Pitch": 10.24646171, + "Yaw": 77.10754877 + }, + "69": { + "X": 1.90979797, + "Y": -8.05894348, + "Z": -1.06294098, + "Roll": 133.31709473, + "Pitch": -12.74193914, + "Yaw": 70.72046603 + }, + "70": { + "X": -0.58215088, + "Y": 5.17909302, + "Z": 1.28867584, + "Roll": 1.18520879, + "Pitch": -0.6037615, + "Yaw": -0.27913618 + }, + "71": { + "X": 0.6358844, + "Y": 5.21191528, + "Z": 1.29706161, + "Roll": 1.15850286, + "Pitch": -0.99305488, + "Yaw": 0.09124448 + }, + "76": { + "X": -0.58215027, + "Y": -2.47363617, + "Z": 1.28406952, + "Roll": -2.97758005, + "Pitch": -0.60376143, + "Yaw": -0.27913616 + } + } + }, + { + "Name": "Native 1.2 model 1442", + "ModelId": 1442, + "AttachPoints": { + "9": { + "X": 1.31732416, + "Y": -2.06066918, + "Z": 2.79388428, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "10": { + "X": -0.12301, + "Y": -3.09071016, + "Z": 3.20470023, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 1444", + "ModelId": 1444, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "60": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "61": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + } + } + }, + { + "Name": "Native 1.2 model 1460", + "ModelId": 1460, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "60": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "61": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + } + } + }, + { + "Name": "Native 1.2 model 1461", + "ModelId": 1461, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "60": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "61": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + } + } + }, + { + "Name": "Native 1.2 model 1462", + "ModelId": 1462, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "60": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "61": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + } + } } ] diff --git a/rust/crates/aaemu-game/tests/slave_attach_coverage.rs b/rust/crates/aaemu-game/tests/slave_attach_coverage.rs new file mode 100644 index 0000000000..eff16b3de2 --- /dev/null +++ b/rust/crates/aaemu-game/tests/slave_attach_coverage.rs @@ -0,0 +1,164 @@ +//! Native 1.2 attach-data regressions. Source nodes and SHA-256s: +//! `rust/tools/slave_attach_points.provenance.json`; generator/conventions: +//! `rust/tools/slave_attach_points.py`. No client bytes are fixtures here. +//! +//! `AAEMU_COMPACT_DB= cargo test -p aaemu-game --test slave_attach_coverage -- --ignored` + +use std::collections::{BTreeMap, BTreeSet}; + +use aaemu_game::data::world_templates::WorldSpawnPosition; +use aaemu_game::systems::vehicles::data::parse_attach_points; +use rusqlite::{Connection, OpenFlags}; + +const REPAIRED: &[(u32, &[u8])] = &[ + (5, &[24, 35, 81]), + (867, &[35]), + (892, &[9]), + (898, &[9]), + (899, &[9]), + ( + 1024, + &[ + 9, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 35, 36, + 37, 38, 39, 46, 58, 59, + ], + ), + (1287, &[2, 35, 36]), + (1323, &[21, 36, 60, 61]), + (1371, &[21, 36, 60, 61]), + ( + 1385, + &[ + 21, 22, 24, 25, 36, 37, 38, 39, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 76, + ], + ), + (1442, &[9, 10]), + (1444, &[21, 36, 60, 61]), + (1460, &[21, 36, 60, 61]), + (1461, &[21, 36, 60, 61]), + (1462, &[21, 36, 60, 61]), +]; + +fn shipped() -> BTreeMap<(u32, u8), WorldSpawnPosition> { + let text = include_str!("../app/Data/slave_attach_points.json"); + let mut points = BTreeMap::new(); + for (model, entries) in parse_attach_points(text).expect("shipped attach JSON") { + for (point, location) in entries { + assert!( + points.insert((model, point), location).is_none(), + "duplicate attach point ({model}, {point})" + ); + } + } + points +} + +#[test] +fn recovered_native_attach_points_are_shipped() { + let points = shipped(); + assert_eq!(REPAIRED.iter().map(|(_, p)| p.len()).sum::(), 87); + for &(model, indexes) in REPAIRED { + for &point in indexes { + let p = points + .get(&(model, point)) + .unwrap_or_else(|| panic!("missing recovered native attach ({model}, {point})")); + assert_ne!(point, 0, "None is not an attachment helper"); + assert!([p.x, p.y, p.z, p.roll, p.pitch, p.yaw] + .into_iter() + .all(f32::is_finite)); + assert!(p.x != 0.0 || p.y != 0.0 || p.z != 0.0, "origin placeholder"); + } + } +} + +#[test] +fn native_attach_literal_transforms_preserve_units_axes_and_parent_space() { + let points = shipped(); + // Literal native 1.2 bind poses, independently inspected in the CHRs/CGFs + // (not a serializer roundtrip or a comparison to generated provenance). + // Tank cannon0 includes Bip01/Pelvis/bone_yaw/pocenter/bone_rail already. + for (model, point, expected) in [ + (892, 9, [0.804_689_94, -2.049_110_2, 2.161_2]), + (1323, 21, [0.0, 0.870_579_96, 1.181_04]), + (1323, 60, [-0.520_054_64, -2.167_765, 0.683_005_2]), + (1442, 10, [-0.123_01, -3.090_71, 3.204_7]), + // Direct prefab $helms overrides the embedded CHR's different $helms. + (5, 35, [-0.399_810_8, 2.351_196_3, 15.238_708]), + // Existing 1406 CGF-derived entry from a9dc41b8 remains intact. CHR's + // heal_point0 differs from its sibling CGF; don't copy this into cars. + (1406, 36, [0.671_114, -0.043_841, 1.030_234]), + ] { + let actual = points[&(model, point)]; + for (got, want) in [actual.x, actual.y, actual.z].into_iter().zip(expected) { + assert!( + (got - want).abs() < 0.000_01, + "({model}, {point}): {got} != {want}" + ); + } + } + let box0 = points[&(1323, 60)]; + for (got, degrees) in [box0.roll, box0.pitch, box0.yaw] + .into_iter() + .zip([-90.0_f32, -55.0, -90.0]) + { + assert!((got - degrees.to_radians()).abs() < 0.000_01); + } + let ladder = points[&(5, 24)]; + assert!((ladder.roll - 7.895_808_f32.to_radians()).abs() < 0.000_01); + assert!((ladder.yaw.abs() - std::f32::consts::PI).abs() < 0.000_01); +} + +#[test] +#[ignore = "needs AAEMU_COMPACT_DB"] +fn real_compact_attach_bindings_and_equipment_have_only_documented_content_gaps() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = Connection::open_with_flags(path, OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap(); + let mut query = conn + .prepare( + "SELECT s.model_id, b.attach_point_id FROM slave_doodad_bindings b JOIN slaves s ON s.id=b.owner_id + UNION SELECT s.model_id, b.attach_point_id FROM slave_bindings b JOIN slaves s ON s.id=b.owner_id WHERE b.owner_type='Slave' + UNION SELECT s.model_id, b.attach_point_id FROM slave_healing_point_doodads b JOIN slaves s ON s.id=b.owner_id + UNION SELECT s.model_id, b.attach_point_id FROM slave_equip_slots b JOIN slaves s ON s.id=b.slave_id", + ) + .unwrap(); + let required: BTreeSet<(u32, u8)> = query + .query_map([], |r| Ok((r.get(0)?, r.get(1)?))) + .unwrap() + .map(Result::unwrap) + // Index0 is None, not a helper, in five of the audit's 27 models. + .filter(|(_, point)| *point != 0) + .collect(); + assert!(!required.is_empty()); + let points = shipped(); + let missing: BTreeSet<_> = required + .into_iter() + .filter(|key| !points.contains_key(key)) + .collect(); + // Absent native assets/prefabs or absent helpers. Keep these explicit and + // open; notably the smallboat has NO cannon0/cannon1 for slave55's 9/10. + let gaps: &[(u32, &[u8])] = &[ + (115, &[9, 10, 11, 12, 18]), + (129, &[9, 10]), + (130, &[9]), + ( + 512, + &[ + 2, 3, 9, 10, 11, 12, 13, 14, 15, 16, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 35, 36, 37, 38, 39, + ], + ), + (857, &[2]), + (866, &[35]), + (1402, &[21]), + (1427, &[21, 36, 60, 61]), + ]; + let expected: BTreeSet<_> = gaps + .iter() + .flat_map(|(model, indexes)| indexes.iter().map(move |point| (*model, *point))) + .collect(); + assert_eq!(missing, expected, "unreviewed native attach content gaps"); + assert_eq!(missing.len(), 41); +} diff --git a/rust/tools/slave_attach_points.provenance.json b/rust/tools/slave_attach_points.provenance.json new file mode 100644 index 0000000000..e7f9033bec --- /dev/null +++ b/rust/tools/slave_attach_points.provenance.json @@ -0,0 +1,4137 @@ +{ + "baseline": "37e6f1aec", + "format": "native 1.2 r208022; see slave_attach_points.py docstring", + "models": [ + { + "model": 2, + "slaves": [ + 2, + 41, + 107 + ], + "item_summonable_slaves": [ + 2 + ], + "required": [ + 0 + ], + "already_present": [], + "points": {}, + "unresolved": { + "0": { + "reason": "None (0): no named attach transform", + "consumers": [ + { + "table": "slave_bindings", + "row": 66, + "slave": 41, + "owner_type": "Slave" + } + ] + } + }, + "issues": [], + "normal": "prefab://prefabs/siege_weapon.xml/trebuchet_a.trebuchet_a", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/04_siegeweapon/trebuchet_a.chr", + "sha256": "8b66d1799d753c27b9e7b88ec59c43bd16b5efb686ae0cc309cd4497e3c2195b" + }, + { + "path": "game/prefabs/siege_weapon.xml", + "sha256": "64f698ff21163b79ef8842abc5553fbb5d97db3e3da0bc45f8f2c375b2552ae6" + } + ] + }, + { + "model": 4, + "slaves": [ + 4, + 42 + ], + "item_summonable_slaves": [ + 4, + 42 + ], + "required": [ + 0 + ], + "already_present": [], + "points": {}, + "unresolved": { + "0": { + "reason": "None (0): no named attach transform", + "consumers": [ + { + "table": "slave_bindings", + "row": 57, + "slave": 4, + "owner_type": "Slave" + } + ] + } + }, + "issues": [], + "normal": "prefab://Prefabs/siege_weapon.xml/ground.ram", + "inspected_assets": [ + { + "path": "game/prefabs/siege_weapon.xml", + "sha256": "64f698ff21163b79ef8842abc5553fbb5d97db3e3da0bc45f8f2c375b2552ae6" + } + ] + }, + { + "model": 5, + "slaves": [ + 5 + ], + "item_summonable_slaves": [ + 5 + ], + "required": [ + 24, + 35, + 81 + ], + "already_present": [], + "points": { + "24": { + "location": { + "X": -1.42433345, + "Y": -6.89326668, + "Z": 0.83646423, + "Roll": 7.89580808, + "Pitch": 0.0, + "Yaw": 179.99999135 + }, + "asset": "game/objects/env/06_unit/04_siegeweapon/siege_tower_a.chr", + "node": "ladder_left", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 492, + "slave": 5, + "owner_type": "Slave" + } + ] + }, + "35": { + "location": { + "X": -0.39981079, + "Y": 2.3511963, + "Z": 15.238708, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/prefabs/siege_tower.xml", + "node": "$helms", + "parents": [], + "kind": "prefab-helper", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 480, + "slave": 5, + "owner_type": "Slave" + } + ] + }, + "81": { + "location": { + "X": -1.98440182, + "Y": -1.09256768, + "Z": 14.48642063, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/04_siegeweapon/siege_tower_a.chr", + "node": "bell", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 478, + "slave": 5, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/siege_tower.xml/siege_tower.siege_tower_normal", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/04_siegeweapon/siege_tower_a.chr", + "sha256": "4b06478c604794cf394e374e8acd3f1fb80822f8af9a5aef0cd17953c91b6ba5" + }, + { + "path": "game/prefabs/siege_tower.xml", + "sha256": "cfacf17dd88de16f2e0cb71208154cc1032928ab67b678cff86bcf2e63fd9c8a" + } + ] + }, + { + "model": 6, + "slaves": [ + 6, + 16, + 18, + 30, + 43 + ], + "item_summonable_slaves": [ + 6, + 43 + ], + "required": [ + 0 + ], + "already_present": [], + "points": {}, + "unresolved": { + "0": { + "reason": "None (0): no named attach transform", + "consumers": [ + { + "table": "slave_bindings", + "row": 59, + "slave": 6, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "asset absent: game/objects/env/architecture/siege/siegeweapon/ballista_a/ballista_a.chr" + ], + "normal": "prefab://Prefabs/siege_weapon.xml/ground.ballista_a", + "inspected_assets": [ + { + "path": "game/prefabs/siege_weapon.xml", + "sha256": "64f698ff21163b79ef8842abc5553fbb5d97db3e3da0bc45f8f2c375b2552ae6" + } + ] + }, + { + "model": 115, + "slaves": [ + 9 + ], + "item_summonable_slaves": [ + 9 + ], + "required": [ + 9, + 10, + 11, + 12, + 18 + ], + "already_present": [], + "points": {}, + "unresolved": { + "9": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon0", + "$cannon0" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 2, + "slave": 9, + "owner_type": "Slave" + } + ] + }, + "10": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon1", + "$cannon1" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 4, + "slave": 9, + "owner_type": "Slave" + } + ] + }, + "11": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon2", + "$cannon2" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 5, + "slave": 9, + "owner_type": "Slave" + } + ] + }, + "12": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon3", + "$cannon3" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 6, + "slave": 9, + "owner_type": "Slave" + } + ] + }, + "18": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$hook", + "$hook" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 3, + "slave": 9, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_body.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_sail1.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_sail2.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/ladder_r.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/ladder_l.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_rudder.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_helms.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_anchor.chr", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_sail1.chr", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_sail2.chr" + ], + "normal": "prefab://Prefabs/ship.xml/caravel.ship_body", + "inspected_assets": [ + { + "path": "game/prefabs/ship.xml", + "sha256": "78a8be4a6ea90707e331c41d31faea95d11026800d1451d74666c10bf003f02d" + } + ] + }, + { + "model": 127, + "slaves": [ + 13 + ], + "item_summonable_slaves": [ + 13 + ], + "required": [ + 0 + ], + "already_present": [], + "points": {}, + "unresolved": { + "0": { + "reason": "None (0): no named attach transform", + "consumers": [ + { + "table": "slave_bindings", + "row": 10, + "slave": 13, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "'game/objects/env/nuia/props/carriage/carriage_a.cgf'" + ], + "normal": "cgf://objects/Env/nuia/props/carriage/carriage_a.cgf", + "inspected_assets": [] + }, + { + "model": 129, + "slaves": [ + 15, + 55, + 91 + ], + "item_summonable_slaves": [ + 15, + 55, + 91 + ], + "required": [ + 2, + 9, + 10, + 29, + 35, + 36 + ], + "already_present": [ + 1, + 2, + 24, + 25, + 29, + 35, + 36 + ], + "points": {}, + "unresolved": { + "9": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon0", + "$cannon0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 85, + "slave": 55, + "owner_type": "Slave" + } + ] + }, + "10": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon1", + "$cannon1" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 87, + "slave": 55, + "owner_type": "Slave" + } + ] + } + }, + "issues": [], + "normal": "prefab://prefabs/smallboat.xml/smallboat.smallboat_a", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/01_ship/smallboat/smallboat_body.cgf", + "sha256": "074c9f9efe0715d9c3b4df92223e83d05d75c1877ffc4b9327871b7353b7f043" + }, + { + "path": "game/prefabs/smallboat.xml", + "sha256": "cd6ea7d7fcad18abc58cc5f4d94113a1ecfab7500ace982646eaa6d7ecb9097d" + } + ] + }, + { + "model": 130, + "slaves": [ + 17 + ], + "item_summonable_slaves": [ + 17 + ], + "required": [ + 9 + ], + "already_present": [], + "points": {}, + "unresolved": { + "9": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon0", + "$cannon0" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 8, + "slave": 17, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "asset absent: game/objects/env/nuia/props/ship/caravel/ray.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_helms.cgf" + ], + "normal": "prefab://Prefabs/ship.xml/ray.ship_body", + "inspected_assets": [ + { + "path": "game/prefabs/ship.xml", + "sha256": "78a8be4a6ea90707e331c41d31faea95d11026800d1451d74666c10bf003f02d" + } + ] + }, + { + "model": 392, + "slaves": [ + 19 + ], + "item_summonable_slaves": [], + "required": [ + 0 + ], + "already_present": [], + "points": {}, + "unresolved": { + "0": { + "reason": "None (0): no named attach transform", + "consumers": [ + { + "table": "slave_bindings", + "row": 11, + "slave": 19, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "model descriptor 392 absent from compact" + ], + "inspected_assets": [] + }, + { + "model": 512, + "slaves": [ + 23 + ], + "item_summonable_slaves": [], + "required": [ + 2, + 3, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 35, + 36, + 37, + 38, + 39 + ], + "already_present": [], + "points": {}, + "unresolved": { + "2": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "bone_spine_passenger", + "$passenger0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 65, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "3": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "bone_spine_passenger1", + "$passenger1" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 66, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "9": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon0", + "$cannon0" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 35, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "10": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon1", + "$cannon1" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 36, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "11": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon2", + "$cannon2" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 37, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "12": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon3", + "$cannon3" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 38, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "13": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon4", + "$cannon4" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 39, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "14": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon5", + "$cannon5" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 40, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "15": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon6", + "$cannon6" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 41, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "16": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon7", + "$cannon7" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 42, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "19": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$mast0", + "$mast0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 23, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "20": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$mast1", + "$mast1" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 24, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "21": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$sail0", + "$sail0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 25, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "22": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$sail1", + "$sail1" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 26, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "23": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$anchor", + "$anchor" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 33, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "24": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$ladder_left", + "$ladder_left" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 27, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "25": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$ladder_right", + "$ladder_right" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 28, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "26": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$plank_left", + "$plank_left" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 31, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "27": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$plank_right", + "$plank_right" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 32, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "28": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$lamp_front", + "$lamp_front" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 29, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "29": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$lamp_rear", + "$lamp_rear" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 30, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "35": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$helms", + "$helms" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 47, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "36": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$heal_point0", + "$heal_point0" + ], + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 10, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "37": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$heal_point1", + "$heal_point1" + ], + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 11, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "38": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$heal_point2", + "$heal_point2" + ], + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 12, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "39": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$heal_point3", + "$heal_point3" + ], + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 13, + "slave": 23, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "'game/prefabs/galleon02.xml'" + ], + "normal": "prefab://Prefabs/galleon02.xml/galleon02.galleon_step10_normal", + "inspected_assets": [] + }, + { + "model": 857, + "slaves": [ + 36 + ], + "item_summonable_slaves": [ + 36 + ], + "required": [ + 2 + ], + "already_present": [], + "points": {}, + "unresolved": { + "2": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "bone_spine_passenger", + "$passenger0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 55, + "slave": 36, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "'game/objects/env/06_unit/04_siegeweapon/siegetank.chr'" + ], + "normal": "cga://objects/Env/06_unit/04_siegeweapon/siegetank.chr", + "inspected_assets": [] + }, + { + "model": 866, + "slaves": [ + 44 + ], + "item_summonable_slaves": [ + 44 + ], + "required": [ + 35 + ], + "already_present": [], + "points": {}, + "unresolved": { + "35": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$helms", + "$helms" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 57, + "slave": 44, + "owner_type": "Slave" + } + ] + } + }, + "issues": [], + "normal": "prefab://prefabs/galleon.xml/galleon.woodpiece01", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/01_ship/galleon/galleon_item03.cgf", + "sha256": "fe7acf71f2d8e87d27caf06e5e4cdd459e511d8dc56bf635b004b67356762883" + }, + { + "path": "game/prefabs/galleon.xml", + "sha256": "7ed7617d4ef68de5c60e336cf7c2a4a21486d4e2f6ae8d77a5820773fd569cda" + } + ] + }, + { + "model": 867, + "slaves": [ + 45 + ], + "item_summonable_slaves": [ + 45 + ], + "required": [ + 35 + ], + "already_present": [], + "points": { + "35": { + "location": { + "X": 0.0, + "Y": -2.2049498, + "Z": 2.60459892, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/speedboat/speedboat_a.cgf", + "node": "$helms", + "parents": [ + "body", + "speedboat_a" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 58, + "slave": 45, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://Prefabs/speedboat.xml/speedboat_a.speedboat_hwang", + "inspected_assets": [ + { + "path": "game/objects/box.cgf", + "sha256": "921141b30889f84f0d8f1867da15aecdc15bd26672e12e666ebe7185406f8858" + }, + { + "path": "game/objects/env/06_unit/01_ship/speedboat/speedboat_a.cgf", + "sha256": "a14e2bd1d3ba67a5fe18cafbf9218a1b4b85465e5b32c3dd8f9814fa07907089" + }, + { + "path": "game/prefabs/speedboat.xml", + "sha256": "1ad4c9a7f32fc58ea29cc8ebbbc2b20e48ed3a1dac610869b4dd0bcca1f3630e" + } + ] + }, + { + "model": 892, + "slaves": [ + 46, + 53, + 84 + ], + "item_summonable_slaves": [ + 46 + ], + "required": [ + 9 + ], + "already_present": [], + "points": { + "9": { + "location": { + "X": 0.80468994, + "Y": -2.04911017, + "Z": 2.16120005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/04_siegeweapon/siegetank_a.chr", + "node": "cannon0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_yaw", + "pocenter", + "bone_rail" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 473, + "slave": 46, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/siege_weapon.xml/siegetank_a.siegetank_a", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/04_siegeweapon/siegetank_a.chr", + "sha256": "47cb57abd0304f91f6b0ebae25f59258547f8eb1f18e44c23bb7883b7e1b4bd7" + }, + { + "path": "game/prefabs/siege_weapon.xml", + "sha256": "64f698ff21163b79ef8842abc5553fbb5d97db3e3da0bc45f8f2c375b2552ae6" + } + ] + }, + { + "model": 898, + "slaves": [ + 50, + 136 + ], + "item_summonable_slaves": [ + 50 + ], + "required": [ + 9 + ], + "already_present": [], + "points": { + "9": { + "location": { + "X": 0.80468994, + "Y": -2.04911017, + "Z": 2.16120005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/04_siegeweapon/siegetank_a.chr", + "node": "cannon0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_yaw", + "pocenter", + "bone_rail" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 474, + "slave": 50, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 670, + "slave": 136, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/siege_weapon.xml/siegetank_b.siegetank_b", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/04_siegeweapon/siegetank_a.chr", + "sha256": "47cb57abd0304f91f6b0ebae25f59258547f8eb1f18e44c23bb7883b7e1b4bd7" + }, + { + "path": "game/prefabs/siege_weapon.xml", + "sha256": "64f698ff21163b79ef8842abc5553fbb5d97db3e3da0bc45f8f2c375b2552ae6" + } + ] + }, + { + "model": 899, + "slaves": [ + 51, + 137 + ], + "item_summonable_slaves": [ + 51 + ], + "required": [ + 9 + ], + "already_present": [], + "points": { + "9": { + "location": { + "X": 0.80468994, + "Y": -2.04911017, + "Z": 2.16120005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/04_siegeweapon/siegetank_a.chr", + "node": "cannon0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_yaw", + "pocenter", + "bone_rail" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 475, + "slave": 51, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 671, + "slave": 137, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/siege_weapon.xml/siegetank_c.siegetank_c", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/04_siegeweapon/siegetank_a.chr", + "sha256": "47cb57abd0304f91f6b0ebae25f59258547f8eb1f18e44c23bb7883b7e1b4bd7" + }, + { + "path": "game/prefabs/siege_weapon.xml", + "sha256": "64f698ff21163b79ef8842abc5553fbb5d97db3e3da0bc45f8f2c375b2552ae6" + } + ] + }, + { + "model": 1024, + "slaves": [ + 61 + ], + "item_summonable_slaves": [ + 61 + ], + "required": [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 35, + 36, + 37, + 38, + 39, + 46, + 58, + 59 + ], + "already_present": [], + "points": { + "9": { + "location": { + "X": -4.29276672, + "Y": 2.23506424, + "Z": 4.4205661, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 83.00000122 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon0", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 77, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "10": { + "location": { + "X": -4.4767865, + "Y": 0.2020467, + "Z": 4.48708954, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 83.99995896 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon1", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 78, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "11": { + "location": { + "X": -4.57174072, + "Y": -3.67801453, + "Z": 4.64193115, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 92.00001601 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon2", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 79, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "12": { + "location": { + "X": -4.46449463, + "Y": -5.55405579, + "Z": 4.74579041, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 93.99999888 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon3", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 72, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "13": { + "location": { + "X": 4.30832184, + "Y": 2.23506409, + "Z": 4.4205661, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -82.00000269 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon4", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 73, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "14": { + "location": { + "X": 4.49234192, + "Y": 0.20204668, + "Z": 4.48708954, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -86.00000112 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon5", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 74, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "15": { + "location": { + "X": 4.58729614, + "Y": -3.67801453, + "Z": 4.64193115, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -92.99999467 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon6", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 75, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "16": { + "location": { + "X": 4.48005005, + "Y": -5.5540564, + "Z": 4.74579102, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -93.99998923 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon7", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 76, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "17": { + "location": { + "X": -0.02580078, + "Y": -17.12161865, + "Z": 6.53128357, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon8", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 80, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "19": { + "location": { + "X": -1.91e-06, + "Y": 10.39880371, + "Z": 4.53841064, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$mast0", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 105, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "20": { + "location": { + "X": 6.1e-07, + "Y": -2.66621552, + "Z": 4.55662964, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$mast1", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 106, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "21": { + "location": { + "X": -1.34e-06, + "Y": 10.39880371, + "Z": 4.53841064, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$sail0", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 107, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "22": { + "location": { + "X": 1.13e-06, + "Y": -2.66621552, + "Z": 4.55662811, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$sail1", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 108, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "23": { + "location": { + "X": 0.0, + "Y": 13.83623413, + "Z": 4.65069, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$anchor", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 114, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "24": { + "location": { + "X": -3.63965759, + "Y": -8.43711731, + "Z": 1.66250549, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 90.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$ladder_left", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 109, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "25": { + "location": { + "X": 3.16607452, + "Y": -8.43917725, + "Z": 1.51600861, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -90.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$ladder_right", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 110, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "26": { + "location": { + "X": -4.9426236, + "Y": 9.73896606, + "Z": 4.52553986, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$plank_left", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 112, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "27": { + "location": { + "X": 4.81819489, + "Y": 9.7243042, + "Z": 4.52553986, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -173.00000315 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$plank_right", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 113, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "28": { + "location": { + "X": -3.58012238, + "Y": -10.39539673, + "Z": 8.99327942, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 21.64487823 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$lamp_front", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 119, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "29": { + "location": { + "X": 3.62164337, + "Y": -10.28855225, + "Z": 8.99328064, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -9.99999827 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$lamp_rear", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 111, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "35": { + "location": { + "X": 0.00038204, + "Y": -13.99029541, + "Z": 6.92423584, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$helms", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 116, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 1.19121086, + "Y": 14.19112061, + "Z": 5.12247559, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$heal_point0", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 22, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "37": { + "location": { + "X": 5.11665863, + "Y": -0.7226757, + "Z": 3.33382629, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$heal_point1", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 23, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "38": { + "location": { + "X": -0.24652342, + "Y": -8.87354675, + "Z": 5.2601709, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$heal_point2", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 24, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "39": { + "location": { + "X": -0.92987915, + "Y": -10.47005615, + "Z": 1.97258972, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$heal_point3", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 25, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "46": { + "location": { + "X": -0.07826172, + "Y": -3.24843933, + "Z": 38.54605469, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon9", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 115, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "58": { + "location": { + "X": -1.04451965, + "Y": -14.86150757, + "Z": -2.14507004, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 179.99998133 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$ladder_rear_left", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 117, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "59": { + "location": { + "X": 1.04451706, + "Y": -14.86150879, + "Z": -2.145065, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 179.99996403 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$ladder_rear_right", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 118, + "slave": 61, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://Prefabs/interaction_c.xml/galleon.galleon_test_body", + "inspected_assets": [ + { + "path": "game/objects/env/01_nuia/001_ndeco/ndeco_cannonball_b.cgf", + "sha256": "474f1e411494ed33b0919064f9bf651783d6b7ea71577273ce54de56a4da1eb3" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/ndeco_cookstore_chair01.cgf", + "sha256": "f9723ac8cbf6d71271ea71e9012430f7e1d227673fde7ee32410f2f08f6a1bdd" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/ndeco_sandbag01.cgf", + "sha256": "6fa036403136b22a98d62dc04c80fda61cc6cce65591f53ca9e59b86d89f98f0" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/old/barrel_oak_b.cgf", + "sha256": "4b315cd65cc43caf209f73b2555853c453f6c245adcb21d8d14235af83a858c7" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/old/fisherbarrel.cgf", + "sha256": "7f81847b162fcfa1cf4b4f07a926c109589184c5f4bff849964b83f1f486d6a0" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/old/rope_a01.cgf", + "sha256": "b05ed1d164801806d23b1522719c5be8bc90dc1339351f293b9c81ec8534942a" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/old/rope_c01.cgf", + "sha256": "2c88c1427fefebd6613006011b3ac514ebad198c41c44057c99881869dcd6f49" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/old/rope_c02.cgf", + "sha256": "ce68eb966cbe03f1f1bb3c13421572e9102330cb6e36625c81374348c513d398" + }, + { + "path": "game/objects/env/01_nuia/06_mari/mari_oscar_chainbox.cgf", + "sha256": "bb108934b81c4bcc4c09f1d08710995dfc66426d954d48e5ab48c2662d8eef52" + }, + { + "path": "game/objects/env/06_unit/01_ship/galleon/galleon_cannon.cgf", + "sha256": "561e4b7346f6236c183da8855679ff840a4b4e4d223380a20ea1c69958e11e45" + }, + { + "path": "game/objects/env/06_unit/01_ship/galleon/galleon_flag0.chr", + "sha256": "6614af9b8a1690d74e496c16b4bf16c7cded4bfc1cfb18048e4fd3ca37160931" + }, + { + "path": "game/objects/env/06_unit/01_ship/galleon/galleon_item01.cgf", + "sha256": "7a1c861a6546ba6e165dac47f082063d080587ddc69a18d60346b6b62e6bb516" + }, + { + "path": "game/objects/env/06_unit/01_ship/galleon/galleon_rudder.cgf", + "sha256": "ef89844029a161e86d051e4bbcb4504b024b4da321e2f0ea4f765a227b207a74" + }, + { + "path": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "sha256": "0cea8fce6a9104c552a150d41d955bbf02b9c417cf301021a508455e44b931e9" + }, + { + "path": "game/objects/item/shield/shield_26_2/shield_26_2.cgf", + "sha256": "c918c903ff5b11af029282880b0bb0ddffa14469689c9e7f48d252f3bfbaa769" + }, + { + "path": "game/prefabs/interaction_c.xml", + "sha256": "0ec3249c055594d0b3e43cd35a19456045b9b546ca8c39bb7397b91251d17e2d" + } + ] + }, + { + "model": 1287, + "slaves": [ + 102 + ], + "item_summonable_slaves": [ + 102 + ], + "required": [ + 2, + 35, + 36 + ], + "already_present": [], + "points": { + "2": { + "location": { + "X": -0.47789001, + "Y": 0.36952, + "Z": 0.9364399, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/coupleduckship/coupleduckship.cgf", + "node": "$passenger0", + "parents": [ + "body", + "coupleduckship" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 455, + "slave": 102, + "owner_type": "Slave" + } + ] + }, + "35": { + "location": { + "X": 0.39533997, + "Y": -0.12314003, + "Z": 1.41565994, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/coupleduckship/coupleduckship.cgf", + "node": "$helms", + "parents": [ + "body", + "coupleduckship" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 454, + "slave": 102, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.0, + "Y": -1.81697433, + "Z": 1.82779999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/coupleduckship/coupleduckship.cgf", + "node": "$heal_point0", + "parents": [ + "body", + "coupleduckship" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 61, + "slave": 102, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/coupleduckship.xml/coupleduckship.coupleduckship_body", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/01_ship/coupleduckship/coupleduckship.cgf", + "sha256": "831f8451ffff1e34979f2105323c4765a09f61b4609979ac49d17436828d7890" + }, + { + "path": "game/objects/env/06_unit/01_ship/coupleduckship/coupleduckship_foot.chr", + "sha256": "f1063d15a25ac0ca61166bc9a5513741de92adbf79c64f9f76c82ac2b53fb141" + }, + { + "path": "game/prefabs/coupleduckship.xml", + "sha256": "6e4407a62dae3a9a33a4bcae46b853b35db3331cbc2f3b6a1ff0c303452f4aab" + } + ] + }, + { + "model": 1323, + "slaves": [ + 106, + 117, + 122 + ], + "item_summonable_slaves": [ + 106, + 122 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "sail0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 477, + "slave": 106, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 589, + "slave": 117, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 634, + "slave": 122, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "heal_point0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 62, + "slave": 106, + "owner_type": "Slave" + }, + { + "table": "slave_healing_point_doodads", + "row": 77, + "slave": 117, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "box0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 584, + "slave": 106, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "box1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 593, + "slave": 106, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/speedcar.xml/speedcar.speedcar_body_r", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "sha256": "88269f91bebd8e72781a65045726ec22729d69ac091cd9afe600063e388d8f00" + }, + { + "path": "game/prefabs/speedcar.xml", + "sha256": "798116faf573a3c33349f1b1c22140bb1555689573dd8934ca87c24841b83a89" + } + ] + }, + { + "model": 1371, + "slaves": [ + 112, + 118 + ], + "item_summonable_slaves": [ + 112 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "sail0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 587, + "slave": 112, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 590, + "slave": 118, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "heal_point0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 76, + "slave": 112, + "owner_type": "Slave" + }, + { + "table": "slave_healing_point_doodads", + "row": 79, + "slave": 118, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "box0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 588, + "slave": 112, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "box1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 599, + "slave": 112, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/speedcar.xml/speedcar.speedcar_body_b", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "sha256": "88269f91bebd8e72781a65045726ec22729d69ac091cd9afe600063e388d8f00" + }, + { + "path": "game/prefabs/speedcar.xml", + "sha256": "798116faf573a3c33349f1b1c22140bb1555689573dd8934ca87c24841b83a89" + } + ] + }, + { + "model": 1385, + "slaves": [ + 101, + 120 + ], + "item_summonable_slaves": [], + "required": [ + 21, + 22, + 24, + 25, + 36, + 37, + 38, + 39, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 76 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 15.15861938, + "Z": 1.93809326, + "Roll": -1.6090013, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$sail0", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 517, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 551, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 620, + "slave": 120, + "owner_type": "Slave" + }, + { + "table": "slave_bindings", + "row": 149, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "22": { + "location": { + "X": 0.0, + "Y": 1.55865067, + "Z": 1.32873474, + "Roll": -1.6090013, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$sail1", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 518, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 604, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "24": { + "location": { + "X": -2.40109009, + "Y": 12.69552368, + "Z": -1.10956696, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 71.01340743 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$ladder_left", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 537, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 615, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "25": { + "location": { + "X": 2.44303604, + "Y": 12.69552246, + "Z": -1.10635902, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -63.9865921 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$ladder_right", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 538, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 616, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": -1.60562973, + "Y": -2.22354645, + "Z": 1.34844727, + "Roll": -31.84449881, + "Pitch": 3.04776432, + "Yaw": -147.0619414 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$heal_point0", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 572, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 623, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "37": { + "location": { + "X": 2.99039398, + "Y": -0.53385757, + "Z": 1.22506035, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$heal_point1", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 570, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 621, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "38": { + "location": { + "X": 0.76255249, + "Y": -10.80150879, + "Z": 1.83097321, + "Roll": -17.3346917, + "Pitch": -3.82501679, + "Yaw": -150.04003415 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$heal_point2", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 571, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 622, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "39": { + "location": { + "X": -1.69008774, + "Y": 13.50393433, + "Z": 1.87254852, + "Roll": -66.7200763, + "Pitch": -66.38009821, + "Yaw": 66.34809364 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$heal_point3", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 550, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 619, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "58": { + "location": { + "X": -1.91337097, + "Y": -12.50181641, + "Z": -1.46283188, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -179.99999135 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$ladder_rear_left", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 539, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 617, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "59": { + "location": { + "X": 1.91337036, + "Y": -12.50181641, + "Z": -1.46283188, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -179.99999135 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$ladder_rear_right", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 540, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 618, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -2.38570313, + "Y": 12.47859131, + "Z": 4.42517761, + "Roll": -5.84543976, + "Pitch": 0.01637078, + "Yaw": 86.80389012 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box0", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 519, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 605, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 3.77372406, + "Y": 11.7718396, + "Z": 5.30033264, + "Roll": 14.61988617, + "Pitch": -3.46511977, + "Yaw": 108.08774205 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box1", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 525, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 607, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "62": { + "location": { + "X": -4.77853394, + "Y": 2.81668457, + "Z": 3.8049884, + "Roll": -17.63500494, + "Pitch": 5.84323429, + "Yaw": 77.92499954 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box2", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 526, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 608, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "63": { + "location": { + "X": 3.68675873, + "Y": 3.93022034, + "Z": 3.87374054, + "Roll": 13.35100355, + "Pitch": -3.18382401, + "Yaw": 86.95435664 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box3", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 527, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 609, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "64": { + "location": { + "X": -3.90936157, + "Y": -4.94448669, + "Z": 5.00377747, + "Roll": -2.59864108, + "Pitch": -1.49955419, + "Yaw": 69.03402673 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box4", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 528, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 610, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "65": { + "location": { + "X": 1.47495453, + "Y": -10.06739441, + "Z": 4.89309875, + "Roll": 10.83311746, + "Pitch": -1.54938953, + "Yaw": 123.05834985 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box5", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 520, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 606, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "66": { + "location": { + "X": -2.29154297, + "Y": 6.43949036, + "Z": -0.64560669, + "Roll": -131.47489857, + "Pitch": 12.30072769, + "Yaw": 70.05732348 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box6", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 529, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 611, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "67": { + "location": { + "X": 2.25987289, + "Y": 8.95768433, + "Z": -0.4294125, + "Roll": 130.59802495, + "Pitch": -14.98278824, + "Yaw": 79.18461482 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box7", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 530, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 612, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "68": { + "location": { + "X": -2.20217819, + "Y": -8.47400269, + "Z": -0.35781158, + "Roll": -131.09412862, + "Pitch": 10.24646171, + "Yaw": 77.10754877 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box8", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 531, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 575, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 613, + "slave": 120, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 624, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "69": { + "location": { + "X": 1.90979797, + "Y": -8.05894348, + "Z": -1.06294098, + "Roll": 133.31709473, + "Pitch": -12.74193914, + "Yaw": 70.72046603 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box9", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 532, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 614, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "70": { + "location": { + "X": -0.58215088, + "Y": 5.17909302, + "Z": 1.28867584, + "Roll": 1.18520879, + "Pitch": -0.6037615, + "Yaw": -0.27913618 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box10", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 583, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 626, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "71": { + "location": { + "X": 0.6358844, + "Y": 5.21191528, + "Z": 1.29706161, + "Roll": 1.15850286, + "Pitch": -0.99305488, + "Yaw": 0.09124448 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box11", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 596, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 635, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "76": { + "location": { + "X": -0.58215027, + "Y": -2.47363617, + "Z": 1.28406952, + "Roll": -2.97758005, + "Pitch": -0.60376143, + "Yaw": -0.27913616 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box16", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 576, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 625, + "slave": 120, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/boxship_old.xml/boxship_old.boxship_old_normal", + "inspected_assets": [ + { + "path": "game/objects/box.cgf", + "sha256": "921141b30889f84f0d8f1867da15aecdc15bd26672e12e666ebe7185406f8858" + }, + { + "path": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "sha256": "837d9a5a00bc63ebc751b432f27cb4239f072a2550f1f802b38017c6574d0bb5" + }, + { + "path": "game/prefabs/boxship_old.xml", + "sha256": "d61a1baa5724f20925d47f7f05373c0f57fc02975f9804ccd81cd4c5ec94a119" + } + ] + }, + { + "model": 1402, + "slaves": [ + 109 + ], + "item_summonable_slaves": [], + "required": [ + 21 + ], + "already_present": [], + "points": {}, + "unresolved": { + "21": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$sail0", + "$sail0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 541, + "slave": 109, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "prefab missing/ambiguous: prefab://prefabs/boxship_old.xml/boxship_old.boxship_old_normal_2f" + ], + "normal": "prefab://prefabs/boxship_old.xml/boxship_old.boxship_old_normal_2f", + "inspected_assets": [ + { + "path": "game/prefabs/boxship_old.xml", + "sha256": "d61a1baa5724f20925d47f7f05373c0f57fc02975f9804ccd81cd4c5ec94a119" + } + ] + }, + { + "model": 1427, + "slaves": [ + 121 + ], + "item_summonable_slaves": [ + 121 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": {}, + "unresolved": { + "21": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$sail0", + "$sail0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 627, + "slave": 121, + "owner_type": "Slave" + } + ] + }, + "36": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$heal_point0", + "$heal_point0" + ], + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 80, + "slave": 121, + "owner_type": "Slave" + } + ] + }, + "60": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$box0", + "$box0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 628, + "slave": 121, + "owner_type": "Slave" + } + ] + }, + "61": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$box1", + "$box1" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 629, + "slave": 121, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "prefab missing/ambiguous: prefab://prefabs/speedcar.xml/speedcar.speedcar_body_redbull" + ], + "normal": "prefab://prefabs/speedcar.xml/speedcar.speedcar_body_redbull", + "inspected_assets": [ + { + "path": "game/prefabs/speedcar.xml", + "sha256": "798116faf573a3c33349f1b1c22140bb1555689573dd8934ca87c24841b83a89" + } + ] + }, + { + "model": 1442, + "slaves": [ + 108, + 123 + ], + "item_summonable_slaves": [], + "required": [ + 9, + 10 + ], + "already_present": [], + "points": { + "9": { + "location": { + "X": 1.31732416, + "Y": -2.06066918, + "Z": 2.79388428, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/transfers_battle_foodtraffic.chr", + "node": "cannon0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "Bone_back00", + "Bone_back01" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 633, + "slave": 108, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 680, + "slave": 123, + "owner_type": "Slave" + } + ] + }, + "10": { + "location": { + "X": -0.12301, + "Y": -3.09071016, + "Z": 3.20470023, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/transfers_battle_foodtraffic.chr", + "node": "cannon1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "Bone_back00", + "Bone_back01" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 601, + "slave": 108, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/vehicle_tractor.xml/transfers_battle_foodtraffic.transfers_battle_foodtraffic_body", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/transfers_battle_foodtraffic.chr", + "sha256": "c8824fa506e450954719d4850d1debbe9a5e2c63e46c7c415f85ae618744ddb1" + }, + { + "path": "game/prefabs/vehicle_tractor.xml", + "sha256": "c5c510acded32ecfae40e797b9c749f91ef77eff39ec41ffe4076593be3e3a17" + } + ] + }, + { + "model": 1444, + "slaves": [ + 124 + ], + "item_summonable_slaves": [ + 124 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "sail0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 630, + "slave": 124, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "heal_point0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 81, + "slave": 124, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 631, + "slave": 124, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 632, + "slave": 124, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/speedcar.xml/speedcar.speedcar_body_decal", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "sha256": "f0aa00a7c0f288fc5c2a169a49979091a2bd0acdc8387979f2e82a1d63f5f3ec" + }, + { + "path": "game/prefabs/speedcar.xml", + "sha256": "798116faf573a3c33349f1b1c22140bb1555689573dd8934ca87c24841b83a89" + } + ] + }, + { + "model": 1460, + "slaves": [ + 126, + 135 + ], + "item_summonable_slaves": [ + 126 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "sail0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 636, + "slave": 126, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 667, + "slave": 135, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "heal_point0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 82, + "slave": 126, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 637, + "slave": 126, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 668, + "slave": 135, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 638, + "slave": 126, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 669, + "slave": 135, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/speedcar_ucc.xml/speedcar_ucc.speedcar_body_r_ucc", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "sha256": "f0aa00a7c0f288fc5c2a169a49979091a2bd0acdc8387979f2e82a1d63f5f3ec" + }, + { + "path": "game/prefabs/speedcar_ucc.xml", + "sha256": "ee89b93694dd7b0d78a2884d7d0bd40b3ab16a9e5c03390da90511d952abecdb" + } + ] + }, + { + "model": 1461, + "slaves": [ + 127, + 134 + ], + "item_summonable_slaves": [ + 127 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "sail0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 639, + "slave": 127, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 664, + "slave": 134, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "heal_point0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 83, + "slave": 127, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 640, + "slave": 127, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 665, + "slave": 134, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 641, + "slave": 127, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 666, + "slave": 134, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/speedcar_ucc.xml/speedcar_ucc.speedcar_body_b_ucc", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "sha256": "f0aa00a7c0f288fc5c2a169a49979091a2bd0acdc8387979f2e82a1d63f5f3ec" + }, + { + "path": "game/prefabs/speedcar_ucc.xml", + "sha256": "ee89b93694dd7b0d78a2884d7d0bd40b3ab16a9e5c03390da90511d952abecdb" + } + ] + }, + { + "model": 1462, + "slaves": [ + 128 + ], + "item_summonable_slaves": [ + 128 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "sail0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 642, + "slave": 128, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "heal_point0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 84, + "slave": 128, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 643, + "slave": 128, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 644, + "slave": 128, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/speedcar_ucc.xml/speedcar_ucc.speedcar_body_y_ucc", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "sha256": "f0aa00a7c0f288fc5c2a169a49979091a2bd0acdc8387979f2e82a1d63f5f3ec" + }, + { + "path": "game/prefabs/speedcar_ucc.xml", + "sha256": "ee89b93694dd7b0d78a2884d7d0bd40b3ab16a9e5c03390da90511d952abecdb" + } + ] + } + ] +} diff --git a/rust/tools/slave_attach_points.py b/rust/tools/slave_attach_points.py new file mode 100644 index 0000000000..918468306c --- /dev/null +++ b/rust/tools/slave_attach_points.py @@ -0,0 +1,414 @@ +#!/usr/bin/env python3 +"""Audit/generate vehicle attach transforms from the original 1.2 game_pak only. + +Run from any directory (Python 3 + the existing gamepak.py's pycryptodome): + python -I rust/tools/slave_attach_points.py --compact \ + --pak D:/AA1.2/game_pak --report [--write] +Without --write this is a read-only audit. --write adds missing points in the +checked-in JSON, preserving every existing point and all hand-written comments. +It never extracts assets to disk or writes the client/compact. Reports contain +asset SHA-256s, node names, parent chains, exact unresolved indexes and consumers. + +Provenance / conventions (no published CryEngine source was used): +* 2026-10-25 audit F2; baseline 37e6f1aec; earlier 1406 fix a9dc41b8. +* Native 1.2 model_attach_point_strings maps IDs to actor/prefab names; loader + sub_39678930, D:/aa-re/client12/decomp/x2game12.c:1416646. Prefab bindings + use '$name'; CHR compiled joints also use 'name'. Only that explicit alias is + accepted, never a different numbered helper or another model's geometry. +* CGF 0x744/745, Node 0x823: local position +148, XYZW quaternion +160, + scale +176 after the copied 16-byte header. Conjugate authored quaternion, + divide positions by 100, compose parents then prefab object transforms. + Matches the native 1.2-verified collision/cga.rs::nodes/RootAnimation reader. +* CHR CompiledBones 0xACDC0000 v0x801: 48-byte header, 324-byte records, + name +216 (48 bytes), relative parent index +264, absolute bind Matrix34 + +276. These matrices ALREADY contain parents and use metres. Do not compose + the parent a second time. Layout checked in the actual 1.2 CHRs against + sibling CGFs and CDF wheel positions; no 10.x geometry is consulted. +* Prefab XML Pos is metres, Rotate is WXYZ, Scale is XYZ. Direct named prefab + helpers take precedence over embedded geometry helpers. JSON rotations are + degrees, Z-yaw/Y-pitch/X-roll, as vehicles/data.rs::parse_attach_points reads. +* Literal native Clipper/Dinghy/1406 regression samples live in the accompanying + tests. Some old hand-authored JSON rotations are inconsistent (e.g. Clipper + cannon12); they are preserved, not used to invent a rotation convention. +* Point 0 is None, not a helper. Missing assets/helpers remain explicit gaps; + no zero placeholders, neighbouring-model substitutions or compact edits. +""" + +from __future__ import annotations + +import argparse +import hashlib +import importlib.util +import json +import math +import re +import sqlite3 +import struct +from pathlib import Path +import xml.etree.ElementTree as ET + +ROOT = Path(__file__).resolve().parents[2] +DATA = ROOT / "rust/crates/aaemu-game/app/Data/slave_attach_points.json" +AUDIT_MODELS = (2, 4, 5, 6, 115, 127, 129, 130, 392, 512, 857, 866, 867, + 892, 898, 899, 1024, 1287, 1323, 1371, 1385, 1402, 1427, + 1442, 1444, 1460, 1461, 1462) +MAX_ASSET = 32 * 1024 * 1024 +MAX_CHUNKS = 8192 +MAX_NODES = 4096 +IDENTITY = (1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0.) + + +def load_json(path): + # Preserve quoted paths/URIs while stripping the data's // comments. + text = Path(path).read_text(encoding="utf-8") + return json.loads(re.sub(r'"(?:\\.|[^"\\])*"|//[^\n]*', + lambda m: "" if m[0].startswith("//") else m[0], text)) + + +def read_compact(path): + conn = sqlite3.connect(Path(path).resolve().as_uri() + "?mode=ro", uri=True) + conn.row_factory = sqlite3.Row + return conn + + +def compose(a, b): + """Column-vector affine Matrix34: parent * local (including parent scale).""" + return tuple(sum(a[r*4+k] * b[k*4+c] for k in range(3)) + + (a[r*4+3] if c == 3 else 0.) + for r in range(3) for c in range(4)) + + +def prs(position, xyzw, scale=(1., 1., 1.)): + if len(position) != 3 or len(xyzw) != 4 or len(scale) != 3 or not all( + math.isfinite(v) for v in (*position, *xyzw, *scale)): + raise ValueError("invalid/nonfinite PRS") + x, y, z, w = xyzw + norm = math.sqrt(sum(v*v for v in xyzw)) + if not 0.99 <= norm <= 1.01: + raise ValueError("invalid quaternion") + x, y, z, w = (v / norm for v in (x, y, z, w)) + r = (1-2*(y*y+z*z), 2*(x*y-z*w), 2*(x*z+y*w), + 2*(x*y+z*w), 1-2*(x*x+z*z), 2*(y*z-x*w), + 2*(x*z-y*w), 2*(y*z+x*w), 1-2*(x*x+y*y)) + return tuple(position[row] if col == 3 else r[row*3+col] * scale[col] + for row in range(3) for col in range(4)) + + +def location(matrix): + if not all(math.isfinite(v) for v in matrix): + raise ValueError("nonfinite transform") + lengths = [math.sqrt(sum(matrix[r*4+c]**2 for r in range(3))) for c in range(3)] + if min(lengths) < 1e-8: + raise ValueError("singular transform") + r = [matrix[row*4+c] / lengths[c] for row in range(3) for c in range(3)] + if any(abs(sum(r[k*3+a]*r[k*3+b] for k in range(3))) > 1e-4 + for a, b in ((0, 1), (0, 2), (1, 2))): + raise ValueError("sheared transform") + determinant = (r[0]*(r[4]*r[8]-r[5]*r[7]) - r[1]*(r[3]*r[8]-r[5]*r[6]) + + r[2]*(r[3]*r[7]-r[4]*r[6])) + if abs(determinant-1) > 1e-4: + raise ValueError("reflected transform") + pitch = math.asin(max(-1., min(1., -r[6]))) + if abs(math.cos(pitch)) > 1e-6: + roll, yaw = math.atan2(r[7], r[8]), math.atan2(r[3], r[0]) + else: + roll, yaw = 0., math.atan2(-r[1], r[4]) + values = [matrix[3], matrix[7], matrix[11], *map(math.degrees, (roll, pitch, yaw))] + return {k: (0. if abs(v) < (1e-7 if i < 3 else 1e-4) else round(v, 8)) + for i, (k, v) in enumerate(zip(("X", "Y", "Z", "Roll", "Pitch", "Yaw"), values))} + + +def chunks(data): + if len(data) < 24 or len(data) > MAX_ASSET or data[:6] != b"CryTek": + raise ValueError("invalid/bounded CryTek file") + version, table = struct.unpack_from(" len(data)-4: + raise ValueError("unsupported/truncated chunk table") + count = struct.unpack_from(" MAX_CHUNKS or table+4+count*stride > len(data): + raise ValueError("bounded/truncated chunk table") + entries = [struct.unpack_from("<4I" if stride == 16 else "<5I", data, table+4+i*stride) + for i in range(count)] + boundaries = sorted({e[2] for e in entries} | {table, len(data)}) + seen = set() + for e in entries: + kind, ver, offset, cid = e[:4] + size = e[4] if stride == 20 else next((x-offset for x in boundaries if x > offset), 0) + if cid in seen or size < 16 or offset+size > len(data): + raise ValueError("duplicate/truncated chunk") + seen.add(cid) + if kind in (0xCCCC000B, 0xACDC0000): + if struct.unpack_from("<4I", data, offset) != (kind, ver, offset, cid): + raise ValueError("chunk header mismatch") + yield kind, ver, cid, data[offset:offset+size] + + +def hierarchy(nodes, key, trail=()): + if key in trail or len(trail) >= 128 or key not in nodes: + raise ValueError("cyclic/deep/orphan hierarchy") + name, parent, local = nodes[key] + if parent is None: + return local, [name] + matrix, chain = hierarchy(nodes, parent, trail+(key,)) + return compose(matrix, local), chain+[name] + + +def geometry(data): + """Yield (name, native bind matrix, parent chain, record kind).""" + nodes, bones = {}, [] + for kind, version, cid, raw in chunks(data): + if kind == 0xCCCC000B: + if version != 0x823 or len(raw) < 220: + raise ValueError("unsupported/truncated node") + body = raw[16:] + name = body[:64].split(b"\0")[0].decode("ascii") + parent = struct.unpack_from(" MAX_NODES: + raise ValueError("too many bones") + for i in range(count): + b = 48+i*324 + name = raw[b+216:b+264].split(b"\0")[0].decode("ascii") + relative = struct.unpack_from(" MAX_NODES: + raise ValueError("too many nodes") + for cid, (name, _, _) in nodes.items(): + matrix, chain = hierarchy(nodes, cid) + yield name, matrix, chain, "cgf-local-node" + for i, (name, parent, matrix) in enumerate(bones): + # Stored absolute bind matrix, NOT parent-relative. Traverse only for + # provenance/validation; multiplying these matrices doubles the parents. + chain, visited, j = [], set(), i + while j is not None: + if j in visited or not 0 <= j < len(bones) or len(visited) >= 128: + raise ValueError("cyclic/deep/orphan bone hierarchy") + visited.add(j) + chain.insert(0, bones[j][0]) + j = bones[j][1] + yield name, matrix, chain, "chr-absolute-bind" + + +def asset_path(name): + name = name.replace("\\", "/").lower() + return name if name.startswith("game/") else "game/"+name + + +class Extractor: + def __init__(self, pak, strings): + self.pak = pak + self.names = {n.lower(): (n, offset, size) for n, offset, size in pak.entries} + self.strings = strings + self.sources, self.issues = {}, [] + + def read(self, name): + key = asset_path(name) + if key not in self.names: + raise KeyError(key) + actual, offset, size = self.names[key] + if not 0 <= size <= MAX_ASSET or offset < 0 or offset+size > self.pak.length: + raise ValueError("asset exceeds bounds: "+key) + self.pak.f.seek(offset) + data = self.pak.f.read(size) + if len(data) != size: + raise ValueError("truncated asset: "+key) + self.sources[key] = {"path": actual, "sha256": hashlib.sha256(data).hexdigest()} + return data + + def match(self, name, bone=False): + n = name.strip().casefold() + return [point for point, aliases in self.strings.items() + if n in {a.casefold() for a in aliases} + or (bone and n in {a.lstrip("$").casefold() for a in aliases})] + + def mesh(self, path, outer=IDENTITY, chain=()): + key = asset_path(path) + for name, matrix, parents, kind in geometry(self.read(key)): + for point in self.match(name, bone=kind == "chr-absolute-bind"): + yield point, {"location": location(compose(outer, matrix)), "asset": key, + "node": name, "parents": list(chain)+parents[:-1], "kind": kind} + + def model(self, uri): + if not uri.startswith("prefab://"): + result = {} + for point, evidence in self.mesh(uri.split("://", 1)[1]): + if point in result: + raise ValueError(f"ambiguous geometry helper {point} in {uri}") + result[point] = evidence + return result + file, prefab = uri[len("prefab://"):].split(".xml/", 1) + path = asset_path(file+".xml") + root = ET.fromstring(self.read(path)) + choices = [p for p in root.findall("Prefab") if p.get("Name", "").casefold() == prefab.casefold()] + if len(choices) != 1: + raise ValueError("prefab missing/ambiguous: "+uri) + objects = choices[0].findall("Objects/Object") + if len(objects) > 512: + raise ValueError("too many prefab objects") + nodes, direct, result = {}, {}, {} + for i, obj in enumerate(objects): + vec = lambda field, default: tuple(map(float, obj.get(field, default).split(","))) + w, x, y, z = vec("Rotate", "1,0,0,0") + key = obj.get("Id", str(i)) + if key in nodes: + raise ValueError("duplicate prefab object") + nodes[key] = (obj.get("Name", ""), obj.get("Parent"), + prs(vec("Pos", "0,0,0"), (x, y, z, w), vec("Scale", "1,1,1"))) + for i, obj in enumerate(objects): + outer, parents = hierarchy(nodes, obj.get("Id", str(i))) + for point in self.match(obj.get("Name", "")): + if point in direct: + raise ValueError("duplicate direct prefab helper") + direct[point] = {"location": location(outer), "asset": path, + "node": obj.get("Name"), "parents": parents[:-1], "kind": "prefab-helper"} + model = obj.get("Prefab") if obj.get("Type") == "Brush" else None + props = obj.find("Properties") + if props is not None: + model = props.get("object_Model", model) + if not model or not model.lower().endswith((".cgf", ".chr", ".cga")): + continue + try: + for point, evidence in self.mesh(model, outer, parents): + if point in result: + raise ValueError(f"ambiguous geometry helper {point} in {uri}") + result[point] = evidence + except KeyError as e: + self.issues.append("asset absent: "+str(e.args[0])) + result.update(direct) + return result + + +def requirements(conn): + """Actual child/healing/equipment consumers (same owner rules as runtime). + + Doodads/healing are loaded by owner_id. Child slaves additionally filter + owner_type == Slave in finish_create; Housing rows aliasing a slave ID must + not create spurious requirements (e.g. Housing 119 != Timber Coupe 119). + """ + result = {} + for table in ("slave_doodad_bindings", "slave_bindings", "slave_healing_point_doodads", "slave_equip_slots"): + owner = "slave_id" if table == "slave_equip_slots" else "owner_id" + for row in conn.execute(f"SELECT s.model_id, s.id slave_id, b.* FROM {table} b JOIN slaves s ON s.id=b.{owner}"): + if table == "slave_bindings" and row["owner_type"] != "Slave": + continue + point = row["attach_point_id"] + consumer = {"table": table, "row": row["id"], "slave": row["slave_id"]} + if "owner_type" in row.keys(): + consumer["owner_type"] = row["owner_type"] + result.setdefault(row["model_id"], {}).setdefault(point, []).append(consumer) + return result + + +def normal_uri(conn, mid): + row = conn.execute("SELECT sub_type, sub_id FROM models WHERE id=?", (mid,)).fetchone() + if row is None: + raise ValueError(f"model descriptor {mid} absent from compact") + table = {"VehicleModel": "vehicle_models", "ShipModel": "ship_models"}.get(row["sub_type"]) + if table is None: + raise ValueError("unsupported model type: "+row["sub_type"]) + asset = conn.execute(f"SELECT normal FROM {table} WHERE id=?", (row["sub_id"],)).fetchone() + if asset is None: + raise ValueError(f"{table} descriptor {row['sub_id']} absent") + return asset[0] + + +def audit(conn, pak, data, models=AUDIT_MODELS): + strings = {r["id"]: (r["actor"], r["prefab"]) for r in conn.execute("SELECT * FROM model_attach_point_strings")} + required = requirements(conn) + existing = {r["ModelId"]: {int(k) for k in r["AttachPoints"]} for r in data} + summonable = {r[0] for r in conn.execute("SELECT DISTINCT slave_id FROM item_summon_slaves")} + ex, report, additions = Extractor(pak, strings), [], [] + for mid in models: + slaves = [r[0] for r in conn.execute("SELECT id FROM slaves WHERE model_id=? ORDER BY id", (mid,))] + req = required.get(mid, {}) + record = {"model": mid, "slaves": slaves, "item_summonable_slaves": sorted(summonable.intersection(slaves)), + "required": sorted(req), "already_present": sorted(existing.get(mid, set())), + "points": {}, "unresolved": {}, "issues": []} + ex.issues = [] + try: + record["normal"] = normal_uri(conn, mid) + found = ex.model(record["normal"]) + except (KeyError, ValueError) as e: + found = {} + ex.issues.append(str(e)) + record["issues"] = list(ex.issues) + points = {} + for point in sorted(req): + if point in existing.get(mid, set()): + continue + if point == 0: + record["unresolved"][str(point)] = {"reason": "None (0): no named attach transform", "consumers": req[point]} + elif point in found: + evidence = found[point] + points[str(point)] = evidence["location"] + record["points"][str(point)] = {**evidence, "consumers": req[point]} + else: + record["unresolved"][str(point)] = {"reason": "native asset/helper absent; see issues and inspected sources", + "aliases": strings.get(point), "consumers": req[point]} + if points: + additions.append({"Name": "Native 1.2 model "+str(mid), "ModelId": mid, "AttachPoints": points}) + # Includes assets that contain no helpers, making negative findings auditable. + record["inspected_assets"] = [ex.sources[key] for key in sorted(ex.sources)] + report.append(record) + ex.sources = {} + return additions, {"baseline": "37e6f1aec", "format": "native 1.2 r208022; see slave_attach_points.py docstring", "models": report} + + +def write_additions(path, additions): + text = path.read_text(encoding="utf-8") + if not text.rstrip().endswith("]"): + raise ValueError("expected JSON array") + # Audit rejects existing-point replacement. Most additions are entirely new + # models; partial existing models are deliberately left for explicit review. + old = {r["ModelId"] for r in load_json(path)} + if any(r["ModelId"] in old for r in additions): + raise ValueError("partial existing model needs explicit review") + if additions: + encoded = json.dumps(additions, indent=4)[1:-1].strip("\n") + path.write_text(text.rstrip()[:-1].rstrip()+",\n"+encoded+"\n]\n", encoding="utf-8") + + +def open_pak(path): + spec = importlib.util.spec_from_file_location("gamepak", ROOT / "rust/tools/opcode_coverage/gamepak.py") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + pak = module.Pak(path) + if pak.kind != "A": + pak.f.close() + raise ValueError("requires original 1.2 TypeA pak, not 10.x") + return pak + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("--compact", type=Path, required=True) + ap.add_argument("--pak", type=Path, required=True) + ap.add_argument("--report", type=Path, required=True) + ap.add_argument("--data", type=Path, default=DATA) + ap.add_argument("--write", action="store_true") + args = ap.parse_args() + pak = open_pak(args.pak) + try: + with read_compact(args.compact) as conn: + additions, report = audit(conn, pak, load_json(args.data)) + args.report.write_text(json.dumps(report, indent=2)+"\n", encoding="utf-8") + if args.write: + write_additions(args.data, additions) + print(f"{len(additions)} models, {sum(len(r['AttachPoints']) for r in additions)} missing transforms recovered") + for r in report["models"]: + print(f"model {r['model']}: recovered {','.join(r['points']) or '-'}; unresolved {','.join(r['unresolved']) or '-'}; {'; '.join(r['issues'])}") + finally: + pak.f.close() + + +if __name__ == "__main__": + main() diff --git a/rust/tools/test_slave_attach_points.py b/rust/tools/test_slave_attach_points.py new file mode 100644 index 0000000000..050f562829 --- /dev/null +++ b/rust/tools/test_slave_attach_points.py @@ -0,0 +1,191 @@ +"""Lightweight regressions; native tests use AAEMU_CLIENT_PAK + AAEMU_COMPACT_DB. + + python -I rust/tools/test_slave_attach_points.py + # Set both environment variables to additionally audit the actual 1.2 data. +""" + +import importlib.util +import math +import os +from pathlib import Path +import struct +import unittest + +SPEC = importlib.util.spec_from_file_location("attach", Path(__file__).with_name("slave_attach_points.py")) +attach = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(attach) + +# Exact content gaps, deliberately literal rather than generated by the parser. +# Details / source hashes are in slave_attach_points.provenance.json. +CONTENT_GAPS = { + 115: [9, 10, 11, 12, 18], + 129: [9, 10], + 130: [9], + 512: [2, 3, 9, 10, 11, 12, 13, 14, 15, 16, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 35, 36, 37, 38, 39], + 857: [2], + 866: [35], + 1402: [21], + 1427: [21, 36, 60, 61], +} + + +def file_with_chunks(parts, version=0x745): + stride = 20 if version == 0x745 else 16 + data = bytearray(b"CryTek\0\0"+struct.pack(" Date: Sun, 25 Oct 2026 16:53:55 -0400 Subject: [PATCH 11/66] fix(portals): read navigation doodad transform directly --- rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs b/rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs index e2e18404e1..6803af99cf 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs @@ -1111,7 +1111,7 @@ pub fn navi_teleport(server: &GameServer, player: &PlayerRef, obj_id: u32) { return; } let pos = world.world_pos_rot(&WorldObject::from(&doodad)); - let zone_id = doodad.data().unit.transform.zone_id; + let zone_id = doodad.data().transform.zone_id; if !session::zone_access_allowed(server, player, world.id, zone_id, pos.x, pos.y) { player.send(SCErrorMsgPacket::new(session::CLOSED_ZONE, 0, true)); return; From 8540da116727672ced2d18c4b85528a60b0be7f6 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:53:56 -0400 Subject: [PATCH 12/66] docs: track combined modifier zone and attachment repairs --- rust/docs/audit-repair-status.json | 32 ++++++++++++++++++++++-------- 1 file changed, 24 insertions(+), 8 deletions(-) diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json index 94ab6d119d..a5a30f0ebc 100644 --- a/rust/docs/audit-repair-status.json +++ b/rust/docs/audit-repair-status.json @@ -56,7 +56,9 @@ }, { "id": "closed-and-unknown-zones", - "status": "implementing" + "status": "merged_pending_validation", + "commit": "e9a870b8c71e8e4dbf7509d7e72bbb33bcfef20a", + "note": "Unknown keys remain neutral; no invented safe destination. Parent corrected Doodad transform field after first compile check." }, { "id": "national-tax-rate", @@ -64,7 +66,14 @@ }, { "id": "vehicle-attachment-data", - "status": "implementing" + "status": "partial_pending_rust_validation", + "commit": "ae83bd8f6609df3dab5943dba2420733b08c5de4", + "parent_native_python_tests_passed": 8, + "transforms_added": 87, + "item_summonable_templates_fixed": 14, + "item_summonable_templates_total": 22, + "open_required_points": 41, + "note": "Missing native assets/prefabs/helpers are explicit; no invented origin points." }, { "id": "ordinary-warning-noise-and-cleanup-cause", @@ -76,11 +85,16 @@ }, { "id": "aoe-diminishing", - "status": "queued" + "status": "implementing" }, { "id": "skill-and-buff-modifiers", - "status": "implementing" + "status": "merged_pending_validation", + "commit": "80303b48a224d83e88c17262ef92493b8b38f79c", + "open_subcases": [ + "Vicious Implosion10710 plot580 radius", + "Crippling Mire10201 plot320 channel duration" + ] }, { "id": "buff-group-rank-and-per-caster-slots", @@ -92,11 +106,12 @@ }, { "id": "attack-speed", - "status": "implementing" + "status": "merged_pending_validation", + "commit": "80303b48a224d83e88c17262ef92493b8b38f79c" }, { "id": "buff-breakers", - "status": "queued" + "status": "implementing" }, { "id": "buff-taunts", @@ -116,7 +131,8 @@ }, { "id": "xp-buff-multiplier", - "status": "implementing" + "status": "merged_pending_validation", + "commit": "80303b48a224d83e88c17262ef92493b8b38f79c" }, { "id": "zone-banned-item-and-skill-tags", @@ -320,7 +336,7 @@ }, { "id": "character-slots-races-and-deletion-guards", - "status": "queued" + "status": "implementing" }, { "id": "event-schedule-notifications", From 04783cdeb438b3fefb551dbd05edb62255a11bff Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:55:08 -0400 Subject: [PATCH 13/66] fix(game): load authored AoE diminishing rates Load aoe_diminishings by authored id as floating-point percentages. Native 1.2 sub_39620E90 (x2game12.c:1321108-1321129) and reference 10.x sub_39BDC250 establish this loader. Add shuffled-id, fractional-rate, event-flag and read-only real-compact regressions. Runtime diminishing and ResetAoeDiminishing remain deferred: the available native evidence does not establish counter lifetime, miss/immunity consumption, reset scope or lookup beyond id 10. Do not infer those policies from the diagnostic multiplier reader sub_39CECDB0. Validation: cargo fmt --all and cargo fmt --all --check; git diff --check; native 1.2 compact opened mode=ro to verify all ten rates and thirteen flagged events. No compilation, tests, clippy or servers run because the parent retains the build slot. Parent selectors: systems::skills::data::plots::tests and real_compact_db_aoe_diminishings -- --ignored with AAEMU_COMPACT_DB. Co-Authored-By: Codex --- .../src/systems/skills/data/plots.rs | 83 ++++++++++++++++++- 1 file changed, 79 insertions(+), 4 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/skills/data/plots.rs b/rust/crates/aaemu-game/src/systems/skills/data/plots.rs index 2b3202a6e8..0f61a99a98 100644 --- a/rust/crates/aaemu-game/src/systems/skills/data/plots.rs +++ b/rust/crates/aaemu-game/src/systems/skills/data/plots.rs @@ -129,6 +129,9 @@ pub struct PlotData { pub events: HashMap, pub conditions: HashMap, pub trees: HashMap, + /// `aoe_diminishings.id -> rate` in authored percentage units (100 means 100%). + /// Counter lifetime and lookup outside the authored ids are separate runtime rules. + pub aoe_diminishings: HashMap, } impl PlotData { @@ -152,6 +155,12 @@ impl PlotData { pub fn load(conn: &Connection) -> rusqlite::Result { let mut d = PlotData::default(); + // Native 1.2 sub_39620E90 (x2game12.c:1321108-1321129) stores each float rate + // under its authored id. The 10.x reference sub_39BDC250 does the same. + for_each_row(conn, "SELECT id, rate FROM aoe_diminishings", [], |r| { + d.aoe_diminishings.insert(r.u32("id")?, r.f32("rate")?); + Ok(()) + })?; let dup = |what: &str, id: u32| { rusqlite::Error::InvalidParameterName(format!("duplicate {what} {id} (Dictionary.Add)")) }; @@ -365,11 +374,11 @@ mod tests { assert_eq!(v, vec![(1, 'b'), (2, 'a'), (2, 'c'), (3, 'd')]); } - #[test] - fn trees_share_nodes_per_next_event() { + fn plot_db() -> Connection { let c = Connection::open_in_memory().unwrap(); c.execute_batch( - "CREATE TABLE plots (id, name, target_type_id); + "CREATE TABLE aoe_diminishings (id, rate); + CREATE TABLE plots (id, name, target_type_id); INSERT INTO plots VALUES (1, 'p', 0); CREATE TABLE plot_events (id, plot_id, position, name, source_update_method_id, target_update_method_id, target_update_method_param1, target_update_method_param2, @@ -377,7 +386,7 @@ mod tests { target_update_method_param5, target_update_method_param6, target_update_method_param7, aoe_diminishing, target_update_method_param8, target_update_method_param9); - INSERT INTO plot_events VALUES (10,1,1,'',1,2,0,0,0,1,0,0,0,0,'f',0,0); + INSERT INTO plot_events VALUES (10,1,1,'',1,2,0,0,0,1,0,0,0,0,'t',0,0); INSERT INTO plot_events VALUES (11,1,2,'',1,2,0,0,0,1,0,0,0,0,'f',0,0); CREATE TABLE plot_conditions (id, not_condition, kind_id, param1, param2, param3); CREATE TABLE plot_event_conditions (id, event_id, condition_id, position, source_id, target_id, notify_failure); @@ -390,6 +399,12 @@ mod tests { INSERT INTO plot_next_events VALUES (101,11,1,11,'f','f',500,0,'f',0,'f','f','f','f','f','f');", ) .unwrap(); + c + } + + #[test] + fn trees_share_nodes_per_next_event() { + let c = plot_db(); let d = PlotData::load(&c).unwrap(); let t = d.tree(1).unwrap(); // root -> node(11) -> node(11 via 101) -> (101 already built) itself @@ -399,4 +414,64 @@ mod tests { assert_eq!(t.nodes[2].children, vec![2]); assert_eq!(d.parent_next_event(t, 2).unwrap().delay, 500); } + + #[test] + fn aoe_diminishing_loader_preserves_authored_ids_rates_and_event_flags() { + let c = plot_db(); + // The 1.2 compact's ten authored rows, deliberately out of id order. Native + // sub_39620E90 keys on id; neither SQL row order nor event position is the key. + c.execute_batch( + "INSERT INTO aoe_diminishings VALUES + (10,10.0),(9,10.0),(8,10.0),(7,25.0),(6,40.0), + (5,55.0),(4,70.0),(3,80.0),(2,90.0),(1,100.0);", + ) + .unwrap(); + let d = PlotData::load(&c).unwrap(); + assert_eq!(d.aoe_diminishings.len(), 10); + let rates: Vec<_> = (1..=10).map(|id| d.aoe_diminishings[&id]).collect(); + assert_eq!( + rates, + [100.0, 90.0, 80.0, 70.0, 55.0, 40.0, 25.0, 10.0, 10.0, 10.0] + ); + assert!(d.event(10).unwrap().aoe_diminishing); + assert!(!d.event(11).unwrap().aoe_diminishing); + } + + #[test] + fn aoe_diminishing_loader_retains_fractional_percentages() { + let c = plot_db(); + c.execute_batch("INSERT INTO aoe_diminishings VALUES (3,77.5);") + .unwrap(); + let d = PlotData::load(&c).unwrap(); + assert_eq!(d.aoe_diminishings.get(&3), Some(&77.5)); + assert_eq!(d.aoe_diminishings.len(), 1); + } + + #[test] + #[ignore = "requires AAEMU_COMPACT_DB pointing to the native 1.2 compact.sqlite3"] + fn real_compact_db_aoe_diminishings() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let c = + Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap(); + let d = PlotData::load(&c).unwrap(); + assert_eq!(d.aoe_diminishings.len(), 10); + let rates: Vec<_> = (1..=10).map(|id| d.aoe_diminishings[&id]).collect(); + assert_eq!( + rates, + [100.0, 90.0, 80.0, 70.0, 55.0, 40.0, 25.0, 10.0, 10.0, 10.0] + ); + let mut flagged: Vec<_> = d + .events + .values() + .filter(|e| e.aoe_diminishing) + .map(|e| e.id) + .collect(); + flagged.sort_unstable(); + assert_eq!( + flagged, + [189, 239, 1141, 2149, 2723, 2903, 3481, 4627, 4631, 4700, 5323, 5511, 8110] + ); + } } From 7441d62bcd2b85b89f907cf072428edad1ce1553 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:56:35 -0400 Subject: [PATCH 14/66] fix(game): enforce lobby creation and deletion authority Serialize persisted six-slot enforcement with character creation, honor creatable templates and blocked name rules, and guard online and expedition-owner deletion using current server state. Use native 1.2 lobby failure codes and add handler regressions. Validation: cargo fmt --all --check and git diff --check. Build and test execution deferred to the parent under the memory/disk build gate. Co-Authored-By: Codex --- .../src/data/character_templates.rs | 87 ++- .../aaemu-game/src/managers/character.rs | 157 ++++- .../src/managers/character_tests.rs | 541 ++++++++++++++++++ rust/crates/aaemu-game/src/managers/name.rs | 40 +- .../aaemu-game/src/managers/name_tests.rs | 44 +- .../crates/aaemu-game/src/world_flow_tests.rs | 5 +- 6 files changed, 838 insertions(+), 36 deletions(-) diff --git a/rust/crates/aaemu-game/src/data/character_templates.rs b/rust/crates/aaemu-game/src/data/character_templates.rs index 8234dcfbeb..e383a1d067 100644 --- a/rust/crates/aaemu-game/src/data/character_templates.rs +++ b/rust/crates/aaemu-game/src/data/character_templates.rs @@ -20,6 +20,7 @@ use super::GameDataError; pub struct CharacterTemplate { pub race: u8, pub gender: u8, + pub creatable: bool, pub model_id: u32, pub faction_id: u32, pub zone_id: u32, @@ -99,6 +100,14 @@ pub struct CharacterData { pub actability_categories: HashMap, /// `_expertLimits` by step. pub expert_limits: Vec, + /// `blocked_texts` rows with `check_name`; independent of the configured name regex. + pub blocked_names: Vec, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct BlockedName { + pub text: String, + pub partial_match: bool, } #[derive(Debug, Deserialize, Default)] @@ -135,6 +144,8 @@ impl CharacterData { pub fn template(&self, race: u8, gender: u8) -> Option<&CharacterTemplate> { self.templates .get(&(16u8.wrapping_mul(gender).wrapping_add(race))) + // The packed key alone aliases malformed race/gender bytes (e.g. gender 17). + .filter(|t| t.race == race && t.gender == gender) } pub fn actability(&self, id: u32) -> Option<&ActabilityTemplate> { @@ -164,7 +175,10 @@ impl CharacterData { zone_of: impl Fn(f32, f32) -> u32, default_world_id: u32, ) -> Result { - let mut d = CharacterData::default(); + let mut d = CharacterData { + blocked_names: load_blocked_names(conn)?, + ..CharacterData::default() + }; let mut temp: HashMap = HashMap::new(); let mut rows = Vec::new(); for_each_row(conn, "SELECT * FROM characters", [], |r| { @@ -173,6 +187,7 @@ impl CharacterData { CharacterTemplate { race: r.u8("char_race_id")?, gender: r.u8("char_gender_id")?, + creatable: r.bool_str("creatable")?, model_id: r.u32("model_id")?, faction_id: r.u32("faction_id")?, zone_id: r.u32("starting_zone_id")?, @@ -383,3 +398,73 @@ impl CharacterData { Ok(d) } } + +fn load_blocked_names(conn: &Connection) -> Result, GameDataError> { + let mut names = Vec::new(); + for_each_row(conn, "SELECT * FROM blocked_texts", [], |r| { + if r.bool_str("check_name")? { + names.push(BlockedName { + text: r.string("utf8str")?, + partial_match: r.bool_str("partial_match")?, + }); + } + Ok(()) + })?; + Ok(names) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn lobby_blocked_names_load_only_check_name_and_preserve_partial_match() { + let conn = Connection::open_in_memory().unwrap(); + conn.execute_batch( + "CREATE TABLE blocked_texts (check_name TEXT, check_chat TEXT, partial_match TEXT, utf8str TEXT); + INSERT INTO blocked_texts VALUES + ('t', 'f', 't', 'Admin'), ('1', 'f', 'f', 'GM'), + ('f', 't', 't', 'ChatOnly'), ('f', 'f', 'f', 'Ignored');", + ) + .unwrap(); + assert_eq!( + load_blocked_names(&conn).unwrap(), + vec![ + BlockedName { + text: "Admin".into(), + partial_match: true + }, + BlockedName { + text: "GM".into(), + partial_match: false + }, + ] + ); + } + + #[test] + #[ignore = "needs AAEMU_COMPACT_DB (read-only)"] + fn lobby_rules_real_compact_db() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap(); + let app = Path::new(env!("CARGO_MANIFEST_DIR")).join("app"); + let data = CharacterData::load(&conn, &app, |_, _| 0, 0).unwrap(); + for (race, gender) in [(1, 1), (1, 2), (4, 1), (4, 2), (5, 1), (5, 2)] { + assert!(data.template(race, gender).unwrap().creatable); + } + for (race, gender) in [(2, 2), (3, 1), (3, 2), (7, 1), (8, 1)] { + assert!(!data.template(race, gender).unwrap().creatable); + } + assert!(data + .blocked_names + .iter() + .any(|n| n.text == "Admin" && n.partial_match)); + assert!(data + .blocked_names + .iter() + .any(|n| n.text == "GM" && !n.partial_match)); + } +} diff --git a/rust/crates/aaemu-game/src/managers/character.rs b/rust/crates/aaemu-game/src/managers/character.rs index f3759a97a5..e75c5af34b 100644 --- a/rust/crates/aaemu-game/src/managers/character.rs +++ b/rust/crates/aaemu-game/src/managers/character.rs @@ -30,8 +30,12 @@ use crate::packets::world::{ use crate::server::GameServer; use crate::world::unit_state::create_character_response; -/// `ErrorMessageType.CannotDeleteCharWhileBotSuspected`. -pub const ERROR_CANNOT_DELETE_CHAR_WHILE_BOT_SUSPECTED: i16 = 624; +/// Matches `AcAuthResponse.slot_count` in aaemu-login (base slots, without paid slots). +pub const MAX_CHARACTERS_PER_ACCOUNT: i64 = 6; + +// Native 1.2 x2game12.c:391136-391163 (HandleErrorMessage, lobby errors). +const ERROR_CHARACTER_EXPEDITION_OWNER: i16 = 333; +const ERROR_CANNOT_DELETE_CHAR_WHILE_ON_PLAY: i16 = 575; /// The data `CSCreateCharacterPacket` carries. #[derive(Debug, Clone, PartialEq)] @@ -309,12 +313,33 @@ pub async fn create( req: CreateCharacterRequest, ) -> Result<()> { let name = normalize_name(&req.name); + let data = &server.game_data; + // Reject unavailable and malformed race/gender pairs before allocating names or assets. + let Some(template) = data + .characters + .template(req.race, req.gender) + .filter(|t| t.creatable) + .cloned() + else { + conn.send(&SCCharacterCreationFailedPacket { + reason: CharacterCreateError::Failed as u8, + }); + return Ok(()); + }; + // The same lock covers name validation, setup, slot counting and the SQL commit. In-flight + // creates on distinct connections cannot both claim the last slot or the same name. Drop + // (including cancellation) releases it after NewCharacter has rolled back its assets. + let _transaction = server.save.transaction_lock().await; let pending = if server.names.name_exists(&name) { is_character_pending_deletion(&server.db, &name).await? } else { false }; - let code = server.names.validate_character_name(&name, || pending); + let code = server.names.validate_character_name_with_blocks( + &name, + &data.characters.blocked_names, + || pending, + ); if code != CharacterCreateError::Ok { conn.send(&SCCharacterCreationFailedPacket { reason: code as u8 }); return Ok(()); @@ -340,7 +365,6 @@ pub async fn create( } // 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 @@ -353,18 +377,6 @@ pub async fn create( committed: false, }; server.names.add_character(id, &name, conn.account_id()); - let data = &server.game_data; - let template = data - .characters - .template(req.race, req.gender) - .cloned() - .ok_or_else(|| { - GameError::Protocol(format!( - "no template for race {} gender {}", - req.race, req.gender - )) - })?; - let mut c = Character::new(id, conn.account_id(), req.model_params.clone()); c.unit.name = name.clone(); c.race = req.race; @@ -505,6 +517,34 @@ pub async fn create( c.unit.mp = c.unit.max_mp; c.restore_saved_hp_mp(); + // Use persisted rows, not a connection's stale/empty lobby list. Pending deletions still + // occupy slots until deleted=1. Keep the save lock through the subsequent commit; the next + // create sees this one, and a failed create leaves neither a slot nor an inventory behind. + let slots = sqlx::query_scalar::<_, i64>( + "SELECT COUNT(*) FROM characters WHERE account_id = ? AND deleted = 0", + ) + .bind(conn.account_id()) + .fetch_one(&server.db) + .await; + match slots { + Ok(count) if count >= MAX_CHARACTERS_PER_ACCOUNT => { + conn.send(&SCCharacterCreationFailedPacket { + reason: CharacterCreateError::WorldLimit as u8, + }); + return Ok(()); + } + Err(e) => { + tracing::error!( + "Cannot count character slots for account {}: {e}", + conn.account_id() + ); + conn.send(&SCCharacterCreationFailedPacket { + reason: CharacterCreateError::Failed as u8, + }); + return Ok(()); + } + Ok(_) => {} + } if save_new_character_locked(server, &mut c).await { creation.committed = true; let resp = create_character_response(&c); @@ -519,6 +559,22 @@ pub async fn create( Ok(()) } +/// Excludes a concurrent select until the deletion request is committed. Never release an +/// existing session's reservation, including one owned by this very connection. +struct DeleteReservation<'a> { + server: &'a GameServer, + character_id: u32, + connection_id: u32, +} + +impl Drop for DeleteReservation<'_> { + fn drop(&mut self) { + self.server + .enter_world + .release_character(self.character_id, self.connection_id); + } +} + /// Learn the selected ability's starters and make its first spell the primary shortcut. fn initialize_starting_skills(server: &GameServer, c: &mut Character) -> Result<()> { let data = &server.game_data; @@ -574,7 +630,42 @@ pub async fn set_delete_character( conn: &mut GameConnection, character_id: u32, ) -> Result<()> { - if let Some(i) = conn.characters.iter().position(|c| c.id == character_id) { + if let Some(i) = conn + .characters + .iter() + .position(|c| c.id == character_id && c.account_id == conn.account_id()) + { + if server.world.character_by_id(character_id).is_some() + || server.enter_world.reserve_character(character_id, conn.id) != Ok(true) + { + conn.send(&SCErrorMsgPacket::new( + ERROR_CANNOT_DELETE_CHAR_WHILE_ON_PLAY, + 0, + false, + )); + return Ok(()); + } + let _reservation = DeleteReservation { + server, + character_id, + connection_id: conn.id, + }; + let _transaction = server.save.transaction_lock().await; + // The loaded lobby copy can predate an ownership transfer. Use the guild ledger, + // including guilds absent from that copy's expedition_id. + if server + .expeditions + .all() + .iter() + .any(|e| !e.is_disbanded && e.faction.owner_id == character_id) + { + conn.send(&SCErrorMsgPacket::new( + ERROR_CHARACTER_EXPEDITION_OWNER, + 0, + false, + )); + return Ok(()); + } let now = Utc::now().timestamp(); let level = conn.characters[i].unit.level; let mut delay = 0; @@ -583,11 +674,21 @@ pub async fn set_delete_character( delay = t.delay; } } - let c = &mut conn.characters[i]; - c.delete_request_time = now; - c.delete_time = now + i64::from(delay) * 60; - let (req, del) = (c.delete_request_time, c.delete_time); - if set_delete_times(&server.db, character_id, req, del).await? == 1 { + let (req, del) = (now, now + i64::from(delay) * 60); + let affected = sqlx::query( + "UPDATE characters SET delete_request_time = ?, delete_time = ? \ + WHERE id = ? AND account_id = ? AND deleted = 0", + ) + .bind(crate::db::from_unix(req)) + .bind(crate::db::from_unix(del)) + .bind(character_id) + .bind(conn.account_id()) + .execute(&server.db) + .await?; + if affected.rows_affected() == 1 { + let c = &mut conn.characters[i]; + c.delete_request_time = req; + c.delete_time = del; conn.send(&SCDeleteCharacterResponsePacket { character_id, status: 2, @@ -595,12 +696,12 @@ pub async fn set_delete_character( delete_time: del, }); } else { - // Not the correct message, but it seems funny enough (C#) - conn.send(&SCErrorMsgPacket::new( - ERROR_CANNOT_DELETE_CHAR_WHILE_BOT_SUSPECTED, - 0, - true, - )); + conn.send(&SCDeleteCharacterResponsePacket { + character_id, + status: 0, + delete_request_time: 0, + delete_time: 0, + }); } } else { conn.send(&SCDeleteCharacterResponsePacket { diff --git a/rust/crates/aaemu-game/src/managers/character_tests.rs b/rust/crates/aaemu-game/src/managers/character_tests.rs index 18941fd11e..57efc2417b 100644 --- a/rust/crates/aaemu-game/src/managers/character_tests.rs +++ b/rust/crates/aaemu-game/src/managers/character_tests.rs @@ -83,6 +83,7 @@ fn creation_data() -> GameData { CharacterTemplate { race: 1, gender: 1, + creatable: true, num_inventory_slot: 50, num_bank_slot: 50, ..Default::default() @@ -142,6 +143,546 @@ fn creation_request(name: &str) -> CreateCharacterRequest { } } +async fn lobby_create( + server: &crate::GameServer, + client: &mut crate::test_support::TestClient, + request: CreateCharacterRequest, +) -> crate::Result<()> { + use crate::net::registry::ClientPacket; + crate::packets::c2g_world::CSCreateCharacterPacket(request) + .handle(server, &mut client.conn) + .await +} + +/// One pinned connection: all writes are shadowed by TEMPORARY tables and disappear at close. +async fn private_lobby_pool() -> Option { + use crate::systems::social::achievement_persistence::temporary_shadow_definition; + use sqlx::mysql::{MySqlConnectOptions, MySqlPoolOptions}; + use std::str::FromStr; + let url = std::env::var("AAEMU_TEST_MYSQL").ok()?; + 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("SET SESSION sql_mode='STRICT_ALL_TABLES'") + .execute(&pool) + .await + .unwrap(); + Some(pool) +} + +async fn persisted_lobby_count(pool: &sqlx::MySqlPool, account: u32) -> i64 { + sqlx::query_scalar("SELECT COUNT(*) FROM characters WHERE account_id = ? AND deleted = 0") + .bind(account) + .fetch_one(pool) + .await + .unwrap() +} + +#[tokio::test] +#[ignore = "requires private MySQL3317 via AAEMU_TEST_MYSQL; temporary tables only"] +async fn private_mysql_lobby_slots_five_six_seven_parallel_rollback_retry_and_account_isolation() { + use crate::test_support::TestClient; + let Some(pool) = private_lobby_pool().await else { + return; + }; + let mut server = test_server_with(creation_data()); + server.db = pool.clone(); + sqlx::query("INSERT INTO accounts (account_id, labor) VALUES (1007, 1000), (1008, 1000)") + .execute(&pool) + .await + .unwrap(); + let mut seed = TestClient::new(&server, 1, 1007); + for index in 0..5 { + lobby_create( + &server, + &mut seed, + creation_request(&format!("Seed{index}")), + ) + .await + .unwrap(); + assert!(seed + .drain_ops() + .contains(&crate::opcodes::sc::SCCreateCharacterResponsePacket)); + } + assert_eq!(persisted_lobby_count(&pool, 1007).await, 5); + let pending_id = seed.conn.characters[0].id; + sqlx::query("UPDATE characters SET delete_request_time=UTC_TIMESTAMP(), delete_time=DATE_ADD(UTC_TIMESTAMP(), INTERVAL 1 DAY) WHERE id=?") + .bind(pending_id).execute(&pool).await.unwrap(); + let inventory_rows: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM items") + .fetch_one(&pool) + .await + .unwrap(); + + // Reproduce a later SQL failure at slot 5: the refused sixth character must roll back. + // A required, unprovided column rejects the skill write after the character row; unlike + // triggers or CHECK constraints this also works on MySQL TEMPORARY tables. + sqlx::query("ALTER TABLE skills ADD COLUMN lobby_required INT NOT NULL") + .execute(&pool) + .await + .unwrap(); + let mut retry = TestClient::new(&server, 2, 1007); // deliberately no loaded character list + lobby_create(&server, &mut retry, creation_request("Retry")) + .await + .unwrap(); + assert_creation_failure(&mut retry, 2); + assert_eq!(persisted_lobby_count(&pool, 1007).await, 5); + assert!(!server.names.name_exists("Retry")); + let after_failure: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM items") + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(after_failure, inventory_rows); + sqlx::query("ALTER TABLE skills DROP COLUMN lobby_required") + .execute(&pool) + .await + .unwrap(); + + let mut parallel = TestClient::new(&server, 3, 1007); + { + let transaction = server.save.transaction_lock().await; + let creates = async { + tokio::join!( + lobby_create(&server, &mut retry, creation_request("Retry")), + lobby_create(&server, &mut parallel, creation_request("Parallel")), + ) + }; + tokio::pin!(creates); + assert!( + tokio::time::timeout(std::time::Duration::from_millis(20), &mut creates) + .await + .is_err() + ); + drop(transaction); + let (a, b) = tokio::time::timeout(std::time::Duration::from_secs(10), creates) + .await + .unwrap(); + a.unwrap(); + b.unwrap(); + } + assert_eq!( + retry.conn.characters.len() + parallel.conn.characters.len(), + 1 + ); + let frames = [retry.drain(), parallel.drain()]; + assert_eq!( + frames + .iter() + .flatten() + .filter( + |(op, body)| *op == crate::opcodes::sc::SCCharacterCreationFailedPacket + && body == &[9] + ) + .count(), + 1 + ); + assert_eq!( + persisted_lobby_count(&pool, 1007).await, + 6, + "pending deletion still consumes a slot" + ); + lobby_create(&server, &mut seed, creation_request("Seventh")) + .await + .unwrap(); + assert_creation_failure(&mut seed, 9); + + // A full account never consumes a different account's slot or leaves its failed name. + let mut other = TestClient::new(&server, 4, 1008); + lobby_create(&server, &mut other, creation_request("Seventh")) + .await + .unwrap(); + assert_eq!(other.conn.characters.len(), 1); + assert_eq!(persisted_lobby_count(&pool, 1008).await, 1); + other.drain(); + let historical_id = other.conn.characters[0].id; + // Model a pre-existing over-limit account (7 rows), independently of the cached lists. + sqlx::query("UPDATE characters SET account_id=1007 WHERE id=?") + .bind(historical_id) + .execute(&pool) + .await + .unwrap(); + assert_eq!(persisted_lobby_count(&pool, 1007).await, 7); + lobby_create(&server, &mut seed, creation_request("Eighth")) + .await + .unwrap(); + assert_creation_failure(&mut seed, 9); + + // Fully deleted rows free slots; scheduled deletions above did not. + sqlx::query("UPDATE characters SET deleted=1 WHERE id IN (?, ?)") + .bind(historical_id) + .bind(seed.conn.characters[1].id) + .execute(&pool) + .await + .unwrap(); + assert_eq!(persisted_lobby_count(&pool, 1007).await, 5); + lobby_create(&server, &mut seed, creation_request("Eighth")) + .await + .unwrap(); + assert!(seed + .drain_ops() + .contains(&crate::opcodes::sc::SCCreateCharacterResponsePacket)); + assert_eq!(persisted_lobby_count(&pool, 1007).await, 6); + assert_eq!( + server + .names + .get_character_account(server.names.get_character_id("Eighth")), + 1007 + ); + pool.close().await; +} + +#[tokio::test] +#[ignore = "requires private MySQL3317 via AAEMU_TEST_MYSQL; temporary tables only"] +async fn private_mysql_lobby_delete_changes_timestamps_only_for_current_owned_undeleted_row() { + use crate::test_support::TestClient; + let Some(pool) = private_lobby_pool().await else { + return; + }; + let mut server = test_server_with(creation_data()); + server.db = pool.clone(); + sqlx::query("INSERT INTO accounts (account_id, labor) VALUES (1007, 1000)") + .execute(&pool) + .await + .unwrap(); + let mut client = TestClient::new(&server, 1, 1007); + lobby_create(&server, &mut client, creation_request("Deletable")) + .await + .unwrap(); + client.drain(); + let id = client.conn.characters[0].id; + for (account, deleted) in [(1008u32, 0), (1007, 1)] { + sqlx::query("UPDATE characters SET account_id=?, deleted=? WHERE id=?") + .bind(account) + .bind(deleted) + .bind(id) + .execute(&pool) + .await + .unwrap(); + lobby_delete(&server, &mut client, id).await.unwrap(); + let frames = client.drain(); + assert_eq!(frames.len(), 1); + assert_eq!( + frames[0].0, + crate::opcodes::sc::SCDeleteCharacterResponsePacket + ); + let mut expected = id.to_le_bytes().to_vec(); + expected.extend_from_slice(&[0; 17]); // native status=0 + two zero i64 timestamps + assert_eq!(frames[0].1, expected); + assert_eq!(client.conn.characters[0].delete_request_time, 0); + assert_eq!(client.conn.characters[0].delete_time, 0); + assert_eq!(server.enter_world.character_owner(id), None); + } + sqlx::query("UPDATE characters SET account_id=1007, deleted=0 WHERE id=?") + .bind(id) + .execute(&pool) + .await + .unwrap(); + lobby_delete(&server, &mut client, id).await.unwrap(); + let frames = client.drain(); + assert_eq!(frames.len(), 1); + assert_eq!( + frames[0].0, + crate::opcodes::sc::SCDeleteCharacterResponsePacket + ); + assert_eq!(frames[0].1.len(), 21); + assert_eq!(frames[0].1[4], 2); + let persisted: (i64, i64) = sqlx::query_as( + "SELECT CAST(UNIX_TIMESTAMP(delete_request_time) AS SIGNED), CAST(UNIX_TIMESTAMP(delete_time) AS SIGNED) FROM characters WHERE id=?", + ).bind(id).fetch_one(&pool).await.unwrap(); + let c = &client.conn.characters[0]; + assert!(c.delete_request_time > 0); + assert_eq!(persisted, (c.delete_request_time, c.delete_time)); + assert_eq!(server.enter_world.character_owner(id), None); + pool.close().await; +} + +#[tokio::test] +#[ignore = "requires private MySQL3317 via AAEMU_TEST_MYSQL; temporary tables only"] +async fn private_mysql_lobby_parallel_names_have_one_owner_and_pending_names_use_native_reason() { + use crate::test_support::TestClient; + let Some(pool) = private_lobby_pool().await else { + return; + }; + let mut server = test_server_with(creation_data()); + server.db = pool.clone(); + sqlx::query("INSERT INTO accounts (account_id, labor) VALUES (1007, 1000), (1008, 1000)") + .execute(&pool) + .await + .unwrap(); + let mut a = TestClient::new(&server, 1, 1007); + let mut b = TestClient::new(&server, 2, 1008); + let (first, second) = tokio::join!( + lobby_create(&server, &mut a, creation_request("Unique")), + lobby_create(&server, &mut b, creation_request("uNIQUE")), + ); + first.unwrap(); + second.unwrap(); + assert_eq!(a.conn.characters.len() + b.conn.characters.len(), 1); + let owner = if a.conn.characters.is_empty() { + assert_creation_failure(&mut a, 4); + b.conn.account_id() + } else { + assert_creation_failure(&mut b, 4); + a.conn.account_id() + }; + let id = server.names.get_character_id("Unique"); + assert_eq!(server.names.get_character_account(id), owner); + assert_eq!( + persisted_lobby_count(&pool, 1007).await + persisted_lobby_count(&pool, 1008).await, + 1 + ); + a.drain(); + b.drain(); + sqlx::query("UPDATE characters SET delete_request_time=UTC_TIMESTAMP() WHERE id=?") + .bind(id) + .execute(&pool) + .await + .unwrap(); + lobby_create(&server, &mut a, creation_request("UNIQUE")) + .await + .unwrap(); + assert_creation_failure(&mut a, 6); // native 'character name is to be deleted' + pool.close().await; +} + +async fn lobby_delete( + server: &crate::GameServer, + client: &mut crate::test_support::TestClient, + character_id: u32, +) -> crate::Result<()> { + use crate::net::registry::ClientPacket; + crate::packets::c2g_world::CSDeleteCharacterPacket { character_id } + .handle(server, &mut client.conn) + .await +} + +fn assert_creation_failure(client: &mut crate::test_support::TestClient, reason: u8) { + // Native 1.2 sub_397B3060 (x2game12.c:1749639): exactly one u8, no i32 enum. + assert_eq!( + client.drain(), + vec![( + crate::opcodes::sc::SCCharacterCreationFailedPacket, + vec![reason] + )] + ); +} + +#[tokio::test] +async fn lobby_create_rejects_unavailable_and_aliased_race_gender_before_allocating_assets() { + let mut data = creation_data(); + let mut unavailable = data.characters.template(1, 1).unwrap().clone(); + unavailable.race = 3; + unavailable.creatable = false; + data.characters.templates.insert(19, unavailable); + let server = test_server_with(data); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + for (race, gender) in [(3, 1), (1, 0), (1, 17), (17, 0), (255, 255)] { + let mut req = creation_request("Unavailable"); + req.race = race; + req.gender = gender; + lobby_create(&server, &mut client, req).await.unwrap(); + assert_creation_failure(&mut client, 2); // native general server failure, not continent block + assert!(client.conn.characters.is_empty()); + assert!(server.names.no_names_registered()); + assert!(server.items.all_containers().is_empty()); + } + assert_eq!(server.ids.character.get_next_id().unwrap(), 1); +} + +#[tokio::test] +async fn lobby_create_filters_invalid_blocked_and_case_variant_names() { + use crate::data::character_templates::BlockedName; + let mut data = creation_data(); + data.characters.blocked_names = vec![ + BlockedName { + text: "Admin".into(), + partial_match: true, + }, + BlockedName { + text: "GM".into(), + partial_match: false, + }, + ]; + let server = test_server_with(data); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + for name in ["bad name", "", "Admin", "AdMiN", "TheAdMiNhero", "gM"] { + lobby_create(&server, &mut client, creation_request(name)) + .await + .unwrap(); + assert_creation_failure(&mut client, 5); // sub_391D3330: forbidden name + assert!(server.names.no_names_registered()); + assert!(server.items.all_containers().is_empty()); + } + for name in ["Accepted", "Павел", "GMhero"] { + lobby_create(&server, &mut client, creation_request(name)) + .await + .unwrap(); + // Reaches the closed DB, rather than being refused by the name filter. + assert_creation_failure(&mut client, 2); + assert!(server.names.no_names_registered()); + assert!(server.items.all_containers().is_empty()); + } +} + +fn lobby_character(client: &mut crate::test_support::TestClient, id: u32) { + let mut c = Character::new(id, client.conn.account_id(), Default::default()); + c.unit.name = "Deletable".into(); + c.unit.level = 10; + client.conn.characters.push(c); +} + +fn assert_delete_error(client: &mut crate::test_support::TestClient, expected: &[u8]) { + // Native 1.2 sub_397C3030 (x2game12.c:1761305): i16, i16, u32, bool. + // isNotify=false is required for HandleErrorMessage's dedicated lobby-error events. + assert_eq!( + client.drain(), + vec![(crate::opcodes::sc::SCErrorMsgPacket, expected.to_vec())] + ); +} + +#[tokio::test] +async fn lobby_delete_refuses_online_and_inflight_select_on_any_connection() { + let server = test_server_with(creation_data()); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + lobby_character(&mut client, 50); + for owner in [1, 2] { + assert_eq!(server.enter_world.reserve_character(50, owner), Ok(true)); + lobby_delete(&server, &mut client, 50).await.unwrap(); + assert_delete_error(&mut client, &[0x3f, 0x02, 0x3f, 0x02, 0, 0, 0, 0, 0]); // 575 + assert_eq!(server.enter_world.character_owner(50), Some(owner)); + assert_eq!(client.conn.characters[0].delete_request_time, 0); + server.enter_world.release_character(50, owner); + } + // Also protect a live world object when no session reservation is present. + let mut c = client.conn.characters[0].clone(); + c.obj_id = 500; + let p = crate::world::Player::new(c, client.conn.handle()); + assert!(server.world.try_add_character(&p)); + lobby_delete(&server, &mut client, 50).await.unwrap(); + assert_delete_error(&mut client, &[0x3f, 0x02, 0x3f, 0x02, 0, 0, 0, 0, 0]); + assert_eq!(server.enter_world.character_owner(50), None); +} + +#[tokio::test] +async fn lobby_delete_uses_current_expedition_owner_and_releases_refused_reservations() { + use crate::data::world_data::SystemFaction; + use crate::systems::social::expedition::Expedition; + let server = test_server_with(creation_data()); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + lobby_character(&mut client, 50); + // The stale lobby character has expedition_id=0, but is now the authoritative owner. + server.expeditions.add(Expedition { + faction: SystemFaction { + id: 700, + owner_id: 50, + ..Default::default() + }, + members: vec![], + policies: vec![], + removed_members: vec![], + is_disbanded: false, + }); + lobby_delete(&server, &mut client, 50).await.unwrap(); + assert_delete_error(&mut client, &[0x4d, 0x01, 0x4d, 0x01, 0, 0, 0, 0, 0]); // 333 + assert_eq!(client.conn.characters[0].delete_request_time, 0); + assert_eq!(server.enter_world.character_owner(50), None); + + // After ownership changes, the stale lobby expedition field must not block deletion. + client.conn.characters[0].unit.expedition_id = 700; + server + .expeditions + .with_mut(700, |e| e.faction.owner_id = 51) + .unwrap(); + assert!(lobby_delete(&server, &mut client, 50).await.is_err()); // reaches the closed DB + assert!(client.drain().is_empty()); + assert_eq!(client.conn.characters[0].delete_request_time, 0); + assert_eq!(server.enter_world.character_owner(50), None); + assert_eq!(server.enter_world.reserve_character(50, 2), Ok(true)); + server.enter_world.release_character(50, 2); +} + +#[tokio::test] +async fn lobby_delete_cannot_mutate_another_accounts_lobby_character() { + let server = test_server_with(creation_data()); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + lobby_character(&mut client, 50); + client.conn.characters[0].account_id = 1008; + lobby_delete(&server, &mut client, 50).await.unwrap(); + // sub_397B2F50 / sub_391EA8C0: id:u32, status:u8=0, two zero i64 timestamps. + assert_eq!( + client.drain(), + vec![( + crate::opcodes::sc::SCDeleteCharacterResponsePacket, + vec![50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + )] + ); + assert_eq!(client.conn.characters[0].delete_request_time, 0); + assert_eq!(server.enter_world.character_owner(50), None); +} + +#[tokio::test] +async fn lobby_delete_blocks_select_while_waiting_and_releases_on_cancellation() { + let server = test_server_with(creation_data()); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + lobby_character(&mut client, 50); + let transaction = server.save.transaction_lock().await; + let mut deletion = Box::pin(lobby_delete(&server, &mut client, 50)); + assert!( + tokio::time::timeout(std::time::Duration::from_millis(20), &mut deletion) + .await + .is_err() + ); + assert_eq!(server.enter_world.reserve_character(50, 2), Err(1)); + drop(deletion); + assert_eq!(server.enter_world.reserve_character(50, 2), Ok(true)); + server.enter_world.release_character(50, 2); + drop(transaction); +} + #[tokio::test] async fn create_character_starting_kit_helpers_preserve_equipment_and_stacks() { use crate::data::character_templates::EquipItemsTemplate; diff --git a/rust/crates/aaemu-game/src/managers/name.rs b/rust/crates/aaemu-game/src/managers/name.rs index 3fa90f02a2..84581f01b2 100644 --- a/rust/crates/aaemu-game/src/managers/name.rs +++ b/rust/crates/aaemu-game/src/managers/name.rs @@ -7,15 +7,20 @@ use regex::Regex; use sqlx::mysql::MySqlPool; use sqlx::Row; +use crate::data::character_templates::BlockedName; + /// `CharacterCreateError`. #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(u8)] pub enum CharacterCreateError { Ok = 0, - /// Also generates "Name is pending deletion". - Failed = 3, + /// Native 1.2 `sub_3961BBC0`: general server error. + Failed = 2, NameAlreadyExists = 4, InvalidCharacters = 5, + NamePendingDeletion = 6, + /// Native 1.2 `sub_3961BBC0`: limit by world server. + WorldLimit = 9, } /// `NameManager.DefaultCharacterNameRegexPattern`. @@ -153,7 +158,7 @@ impl NameManager { ) -> CharacterCreateError { if self.name_exists(name) { if pending_deletion() { - return CharacterCreateError::Failed; + return CharacterCreateError::NamePendingDeletion; } return CharacterCreateError::NameAlreadyExists; } @@ -163,6 +168,33 @@ impl NameManager { CharacterCreateError::Ok } + pub fn validate_character_name_with_blocks( + &self, + name: &str, + blocked_names: &[BlockedName], + pending_deletion: impl FnOnce() -> bool, + ) -> CharacterCreateError { + let result = self.validate_character_name(name, pending_deletion); + if result != CharacterCreateError::Ok { + return result; + } + // Native 1.2 x2game12.c:1738997-1739029, sub_397A7540: + // check_name uses XlFindStringI for partial_match, otherwise XlCompareStringI. + // Lowercasing covers the Latin/Cyrillic alphabet supported by the default regex. + let folded = name.to_lowercase(); + if blocked_names.iter().any(|rule| { + let text = rule.text.to_lowercase(); + if rule.partial_match { + folded.contains(&text) + } else { + folded == text + } + }) { + return CharacterCreateError::InvalidCharacters; + } + CharacterCreateError::Ok + } + /// `AddCharacter`. pub fn add_character(&self, id: u32, name: &str, account_id: u32) { let normalized = normalize_name(name); @@ -254,7 +286,7 @@ mod tests { ); assert_eq!( m.validate_character_name("Taken", || true), - CharacterCreateError::Failed + CharacterCreateError::NamePendingDeletion ); assert_eq!( m.validate_character_name("Bad name", || false), diff --git a/rust/crates/aaemu-game/src/managers/name_tests.rs b/rust/crates/aaemu-game/src/managers/name_tests.rs index 1b85da8a91..aa3c4ea5b3 100644 --- a/rust/crates/aaemu-game/src/managers/name_tests.rs +++ b/rust/crates/aaemu-game/src/managers/name_tests.rs @@ -67,7 +67,7 @@ fn validation_character_name_pending_deletion_failed() { let result = sut.validate_character_name(&char_name, || true); - assert_eq!(result, CharacterCreateError::Failed); + assert_eq!(result, CharacterCreateError::NamePendingDeletion); } #[test] @@ -112,3 +112,45 @@ fn remove_character_id_works_as_expected() { assert_eq!(sut.get_character_id(&char_name), 0); assert_eq!(sut.get_character_account(char_id), 0); } + +#[test] +fn lobby_blocked_names_match_native_partial_and_exact_rules_without_changing_regex() { + let rules = [ + BlockedName { + text: "Admin".into(), + partial_match: true, + }, + BlockedName { + text: "GM".into(), + partial_match: false, + }, + BlockedName { + text: "Иван".into(), + partial_match: true, + }, + ]; + let sut = NameManager::default(); + for name in ["Admin", "ADMIN", "MyAdMiNhero", "gM", "ИВАН", "НовыйИван"] { + assert_eq!( + sut.validate_character_name_with_blocks(name, &rules, || false), + CharacterCreateError::InvalidCharacters, + "{name}" + ); + } + for name in ["Roger", "GMhero", "SomeGM", "Павел", "Игрок123"] { + assert_eq!( + sut.validate_character_name_with_blocks(name, &rules, || false), + CharacterCreateError::Ok, + "{name}" + ); + } + let custom = NameManager::new(Some("^[a-zA-Z_-]{1,18}$")); + assert_eq!( + custom.validate_character_name_with_blocks("Valid-name", &rules, || false), + CharacterCreateError::Ok + ); + assert_eq!( + custom.validate_character_name_with_blocks("AdMiN-name", &rules, || false), + CharacterCreateError::InvalidCharacters + ); +} diff --git a/rust/crates/aaemu-game/src/world_flow_tests.rs b/rust/crates/aaemu-game/src/world_flow_tests.rs index fc20f19784..49e1d4a174 100644 --- a/rust/crates/aaemu-game/src/world_flow_tests.rs +++ b/rust/crates/aaemu-game/src/world_flow_tests.rs @@ -449,6 +449,7 @@ async fn create_character_save_failure_releases_assets_and_allows_retry() { CharacterTemplate { race: 1, gender: 1, + creatable: true, faction_id: 101, num_inventory_slot: 50, num_bank_slot: 50, @@ -583,7 +584,7 @@ async fn create_character_save_failure_releases_assets_and_allows_retry() { a.frame(&s, cs::CSCreateCharacterPacket, &body(&req)).await; assert_eq!( a.drain(), - vec![(sc::SCCharacterCreationFailedPacket, vec![3])] + vec![(sc::SCCharacterCreationFailedPacket, vec![2])] ); assert_released(); assert!(a.conn.characters.is_empty()); @@ -607,7 +608,7 @@ async fn create_character_save_failure_releases_assets_and_allows_retry() { a.frame(&s, cs::CSCreateCharacterPacket, &body(&req)).await; assert_eq!( a.drain(), - vec![(sc::SCCharacterCreationFailedPacket, vec![3])] + vec![(sc::SCCharacterCreationFailedPacket, vec![2])] ); assert_released(); assert!(a.conn.characters.is_empty()); From cef491034356a3561571a4ea975223ffccc8ca8f Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:56:40 -0400 Subject: [PATCH 15/66] test(skills): update XP configuration through config cell --- .../aaemu-game/src/systems/skills/modifier_flow_tests.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs b/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs index c05ab13092..19f01ce2bb 100644 --- a/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs @@ -211,8 +211,8 @@ async fn modifier_exp_buff_boosts_positive_xp_and_active_abilities_only() { async fn modifier_exp_config_composes_and_large_gains_preserve_level_caps() { let mut data = data(); add_boost(&mut data, 3084, vec![bonus(UnitAttribute::ExpMul, 20)]); - let mut server = crate::test_support::test_server_with(data); - server.config.world.exp_rate = 2.0; + let server = crate::test_support::test_server_with(data); + server.config.update(|c| c.world.exp_rate = 2.0); let mut c = crate::test_support::test_character(1, "XP", 100.0, 100.0); c.experience = 10_000; c.ability1 = 1; @@ -233,7 +233,7 @@ async fn modifier_exp_config_composes_and_large_gains_preserve_level_caps() { assert_eq!(c.unit.level, 55); assert_eq!(c.experience, 55_000); assert_eq!(c.abilities.abilities[0].exp, 55_000); - server.config.world.exp_rate = -1.0; + server.config.update(|c| c.world.exp_rate = -1.0); assert_eq!( skills::progress::add_exp_locked(&server, &mut c, 100, true) .unwrap() From 0d935802542b3ef38a7114f5ccdde5ea7459f2b3 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 16:57:34 -0400 Subject: [PATCH 16/66] fix(skills): enforce authored buff breaker tags Load buff_breakers and reconcile accepted buff events through normal dispel cleanup, including matching channel cancellation and stale event/timer handling. Add song, glider, stance, rejection, timer, and native removal-body regressions plus an ignored compact data gate. Native relation and packet evidence is recorded in the regression module. Native apply-versus-tick timing remains unconfirmed; the accepted-event boundary is an explicit implementation choice pending parent review. Cargo validation is deferred under the parent's build-slot restriction. Co-Authored-By: OpenAI Codex --- .../src/systems/skills/buff_breaker_tests.rs | 489 ++++++++++++++++++ .../aaemu-game/src/systems/skills/buffs.rs | 73 ++- .../aaemu-game/src/systems/skills/data/mod.rs | 27 + 3 files changed, 587 insertions(+), 2 deletions(-) create mode 100644 rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs diff --git a/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs b/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs new file mode 100644 index 0000000000..e18dcce19f --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs @@ -0,0 +1,489 @@ +//! Authored 1.2 breaker relations. IDs/tags below are pinned again by the ignored compact +//! regression. No packet round trips: BuffRemoved's native reader is 397C6360, handler +//! 391D5E90 (x2game12.c:1763754-1763769 / 382144-382148): 3-byte owner, u32 buff index. +//! Relation loaders: native 1.2 395D17B0 (x2game12.c:1256462-1256496), 10.x 39B41DE0 +//! (x2game-dev_dedicate.c:2323838-2323904). Those prove ownership/direction only. Traced +//! 10.x ZoneBuffMan::Create 39450740 and its tick 3944FC90 do not establish a breaker-set +//! consumer; immediate reconciliation below is an explicit implementation choice pending +//! native timing evidence, not a claim of native timing parity. + +use std::sync::Arc; +use std::time::Duration; + +use crate::data::GameData; +use crate::models::npc::Npc; +use crate::models::unit::{BonusTemplate, UnitAttribute, UnitModifierType}; +use crate::opcodes::sc; +use crate::server::GameServer; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use crate::world::{now_ms, Entity, WorldObject}; + +use super::super::controllers::{self, ScState}; +use super::super::data::effects::BuffEffect; +use super::super::data::{ + BuffTemplate, BuffTolerance, EffectKind, EffectTemplate, SkillTemplate, TickEffect, +}; +use super::super::state::{CancelToken, SkillRun, SkillTaskKind, SkillTaskSlot, ToleranceCounter}; +use super::super::types::SkillCaster; + +const SONGS: [u32; 4] = [656, 662, 667, 778]; +const GLIDER: u32 = 1029; +const STUN: u32 = 93; +const SLEEP: u32 = 84; // Leech: Sleep tag 97, despite its stun flag in the export. +const SILENCE: u32 = 245; +const IRRELEVANT: u32 = 60_001; +const IMMUNITY: u32 = 60_002; + +fn data() -> GameData { + let mut data = GameData::empty(); + let d = &mut data.systems.skills; + for id in SONGS { + d.add_buff(BuffTemplate { + id, + kind: 3, + duration: 15_000, + tick: 500.0, + stack_rule: 1, + max_stack: 1, + bonuses: vec![BonusTemplate { + attribute: UnitAttribute::Str, + modifier_type: UnitModifierType::Value, + value: 100, + linear_level_bonus: 0, + }], + ..BuffTemplate::default() + }); + d.buff_breakers + .insert(id, vec![6, 12, 13, 97, 99, 107, 150, 346]); + } + d.add_buff(BuffTemplate { + id: GLIDER, + kind: 1, + duration: 180_000, + gliding: true, + stack_rule: 1, + max_stack: 1, + ..BuffTemplate::default() + }); + d.buff_breakers + .insert(GLIDER, vec![6, 12, 13, 27, 97, 99, 107, 150, 346]); + d.buff_tags.insert(GLIDER, vec![10, 294]); + for (id, duration) in [(431, 15_000), (2170, 10_000)] { + d.add_buff(BuffTemplate { + id, + kind: 1, + duration, + ..BuffTemplate::default() + }); + d.buff_breakers.insert(id, vec![294]); + } + for (id, tag, duration, stun, silence) in [ + (STUN, 6, 4000, true, false), + (SLEEP, 97, 5000, true, false), + (SILENCE, 99, 3500, false, true), + (IRRELEVANT, 60_000, 10_000, true, false), + ] { + d.add_buff(BuffTemplate { + id, + kind: 2, + duration, + stun, + silence, + stack_rule: 1, + max_stack: 1, + ..BuffTemplate::default() + }); + d.buff_tags.insert(id, vec![tag]); + d.tagged_buffs.insert(tag, vec![id]); + } + data +} + +fn fixture(data: GameData) -> (Arc, TestClient, WorldObject) { + let server = Arc::new(test_server_with(data)); + server.set_self(); + crate::systems::skills::bind(&server); + let client = TestClient::new(&server, 1, 1); + let owner = spawn_player( + &server, + &client, + test_character(1, "Bard", 100.0, 100.0), + 0x300, + ); + // Visibility serialization can add its synthetic state buffs. Start this fixture's + // bookkeeping at index 2 so the native removal-body expectations remain literal. + owner.data().unit.buffs = crate::models::buff::Buffs::default(); + (server, client, WorldObject::from(&owner)) +} + +fn add(server: &GameServer, owner: &WorldObject, id: u32) { + super::add_buff_by_id(server, owner, id, owner, 0); +} + +fn has(owner: &WorldObject, id: u32) -> bool { + owner.with_base_unit(|u| u.buffs().check_buff(id)) +} + +fn removed(client: &mut TestClient) -> Vec> { + client + .drain() + .into_iter() + .filter_map(|(op, body)| (op == sc::SCBuffRemovedPacket).then_some(body)) + .collect() +} + +#[tokio::test] +async fn buff_breakers_bard_songs_end_on_real_stun_sleep_and_silence_tags() { + for cc in [STUN, SLEEP, SILENCE] { + for song in SONGS { + let (server, mut client, owner) = fixture(data()); + add(&server, &owner, song); + let song_buff = owner.with_base_unit(|u| u.buffs().effects[0].clone()); + client.drain(); + add(&server, &owner, cc); + assert!(!has(&owner, song), "song {song}, CC {cc}"); + assert!(has(&owner, cc)); + assert_eq!(removed(&mut client), vec![vec![0, 3, 0, 2, 0, 0, 0]]); + assert_eq!( + owner.with_unit(|u| u + .unit() + .bonuses + .calculate(0.0, UnitAttribute::Str, now_ms())), + Some(0.0) + ); + // A queued song timer may no longer tick, resurrect, or remove twice. + super::dispel_task(&server, owner.obj_id(), song_buff.index, song_buff.task_gen); + assert!(removed(&mut client).is_empty()); + assert!(!has(&owner, song)); + } + } +} + +#[tokio::test] +async fn buff_breakers_glider_controller_stops_through_normal_dispel() { + let (server, _client, _player) = fixture(data()); + let mut npc = Npc::new(1); + npc.unit.hp = 100; + npc.unit.max_hp = 100; + npc.unit.transform.set_xyz(100.0, 100.0, 100.0); + let npc = Entity::new(0x400, npc); + let owner = WorldObject::from(&npc); + server + .world + .world(0) + .unwrap() + .spawn(&owner, &server.view_ctx()); + add(&server, &owner, GLIDER); + let controller = controllers::active(&owner).unwrap(); + assert_eq!(controller.source_buff_id(), GLIDER); + assert_eq!(controller.state(), ScState::Running); + add(&server, &owner, SILENCE); + assert!(!has(&owner, GLIDER)); + assert_eq!(controller.state(), ScState::Ended); + assert!(controllers::active(&owner).is_none()); + tokio::time::sleep(Duration::from_millis(70)).await; + assert_eq!(npc.data().unit.transform.z, 100.0); +} + +#[tokio::test] +async fn buff_breakers_ignore_irrelevant_tags_and_rejected_incoming_buffs() { + let mut d = data(); + d.systems.skills.add_buff(BuffTemplate { + id: IMMUNITY, + kind: 1, + immune_buff_tag_id: 99, + ..BuffTemplate::default() + }); + let (server, mut client, owner) = fixture(d); + add(&server, &owner, SONGS[0]); + add(&server, &owner, IRRELEVANT); + assert!(has(&owner, SONGS[0]), "CC flags alone are not breaker tags"); + add(&server, &owner, IMMUNITY); + client.drain(); + let silence = server.game_data.systems.skills.buff(SILENCE).unwrap(); + super::apply_template( + &server, + silence, + Some(&owner), + &SkillCaster::Unit(owner.obj_id()), + &owner, + None, + ); + assert!(has(&owner, SONGS[0])); + assert!(!has(&owner, SILENCE)); + assert!(removed(&mut client).is_empty()); + + let mut d = data(); + Arc::make_mut(d.systems.skills.buffs.get_mut(&SILENCE).unwrap()).require_buff_id = 60_004; + let (server, mut client, owner) = fixture(d); + add(&server, &owner, SONGS[0]); + client.drain(); + let rejected = server.game_data.systems.skills.buff(SILENCE).unwrap(); + super::apply_template( + &server, + rejected, + Some(&owner), + &SkillCaster::Unit(owner.obj_id()), + &owner, + None, + ); + assert!(has(&owner, SONGS[0])); + assert!(!has(&owner, SILENCE)); + assert!(removed(&mut client).is_empty()); +} + +#[tokio::test] +async fn buff_breakers_tolerance_rejection_does_not_end_song() { + let mut d = data(); + d.systems.skills.buff_game_data.tolerances.insert( + 6, + BuffTolerance { + id: 1, + buff_tag_id: 6, + step_duration: 60, + final_step_buff_id: IMMUNITY, + character_time_reduction: 0, + steps: vec![(1, 100, 0)], + }, + ); + let (server, mut client, owner) = fixture(d); + owner.with_unit(|u| { + u.unit_mut().skill_state.tolerance_counters.insert( + 1, + ToleranceCounter { + tolerance_id: 1, + current_step: (1, 100, 0), + last_step_ms: now_ms(), + }, + ); + }); + add(&server, &owner, SONGS[0]); + client.drain(); + add(&server, &owner, STUN); // No next tolerance step: existing rejection path. + assert!(!has(&owner, STUN)); + assert!(has(&owner, SONGS[0])); + assert!(removed(&mut client).is_empty()); +} + +#[tokio::test] +async fn buff_breakers_cancel_only_the_corresponding_channel_without_reentering_removal() { + let mut d = data(); + // Snare tag 27 is authored for gliders, without the generic stun/silence interrupt. + Arc::make_mut(d.systems.skills.buffs.get_mut(&IRRELEVANT).unwrap()).stun = false; + d.systems.skills.buff_tags.insert(IRRELEVANT, vec![27]); + let (server, mut client, owner) = fixture(d); + let skill = SkillRun::new( + Arc::new(SkillTemplate { + id: 60_010, + channeling_buff_id: GLIDER, + channeling_time: 10_000, + ..SkillTemplate::default() + }), + 1, + ); + skill.state().tl_id = server + .systems + .skills + .tl_ids + .next_id(owner.obj_id(), skill.template.id); + let cancel = CancelToken::new(); + owner.with_unit(|u| { + u.unit_mut().skill_state.skill_task = Some(SkillTaskSlot { + kind: SkillTaskKind::EndChanneling { channel_doodad: 0 }, + skill: skill.clone(), + cancel: cancel.clone(), + }); + }); + let template = server.game_data.systems.skills.buff(GLIDER).unwrap(); + let buff = super::new_buff( + &server, + template, + Some(&owner), + &SkillCaster::Unit(owner.obj_id()), + Some(&skill), + now_ms(), + ); + super::add_buff(&server, &owner, buff, 0, 0); + client.drain(); + add(&server, &owner, IRRELEVANT); + assert!(!has(&owner, GLIDER)); + assert!(cancel.is_cancelled()); + assert!(skill.cancelled()); + assert!(owner + .with_unit(|u| u.unit().skill_state.skill_task.is_none()) + .unwrap()); + assert_eq!(server.systems.skills.tl_ids.in_use(), 0); + assert_eq!(removed(&mut client), vec![vec![0, 3, 0, 2, 0, 0, 0]]); +} + +#[tokio::test] +async fn buff_breakers_timer_applied_cc_uses_the_same_acceptance_path() { + let mut d = data(); + d.systems.skills.add_buff(BuffTemplate { + id: 60_020, + kind: 3, + duration: 10_000, + tick: 10.0, + tick_effects: vec![TickEffect { + effect_id: 60_021, + target_buff_tag_id: 0, + target_no_buff_tag_id: 0, + }], + ..BuffTemplate::default() + }); + d.systems.skills.add_effect( + EffectKind::BuffEffect, + EffectTemplate::Buff(BuffEffect { + id: 60_021, + buff_id: Some(SILENCE), + chance: 100, + stack: 1, + ab_level: 0, + }), + 60_021, + ); + let (server, mut client, owner) = fixture(d); + add(&server, &owner, SONGS[0]); + add(&server, &owner, 60_020); + client.drain(); + for _ in 0..40 { + if !has(&owner, SONGS[0]) { + break; + } + tokio::time::sleep(Duration::from_millis(5)).await; + } + assert!(has(&owner, SILENCE)); + assert!(!has(&owner, SONGS[0])); + assert_eq!(removed(&mut client), vec![vec![0, 3, 0, 2, 0, 0, 0]]); +} + +#[tokio::test] +async fn buff_breakers_multiple_tags_remove_each_song_once_in_index_order() { + let mut d = data(); + d.systems.skills.buff_tags.insert(STUN, vec![99, 6, 97, 6]); + let (server, mut client, owner) = fixture(d); + for song in SONGS { + add(&server, &owner, song); + } + client.drain(); + add(&server, &owner, STUN); + for song in SONGS { + assert!(!has(&owner, song)); + } + assert_eq!( + removed(&mut client), + vec![ + vec![0, 3, 0, 2, 0, 0, 0], + vec![0, 3, 0, 3, 0, 0, 0], + vec![0, 3, 0, 4, 0, 0, 0], + vec![0, 3, 0, 5, 0, 0, 0], + ] + ); +} + +#[tokio::test] +async fn buff_breakers_mutual_batch_removal_does_not_start_a_stale_buff_event() { + let mut d = data(); + for id in [SONGS[0], GLIDER] { + d.systems.skills.buff_tags.insert(id, vec![6]); + } + let (server, mut client, owner) = fixture(d); + for id in [SONGS[0], GLIDER] { + let template = server.game_data.systems.skills.buff(id).unwrap(); + let mut buff = super::new_buff( + &server, + template, + Some(&owner), + &SkillCaster::Unit(owner.obj_id()), + None, + now_ms(), + ); + buff.duration = template.duration; + owner.with_base_unit(|u| u.buffs_mut().add_buff_with_duration(buff, 0, now_ms())); + } + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + assert!(!has(&owner, SONGS[0])); + assert!(!has(&owner, GLIDER)); + assert_eq!( + removed(&mut client), + vec![vec![0, 3, 0, 2, 0, 0, 0], vec![0, 3, 0, 3, 0, 0, 0]] + ); + assert!(controllers::active(&owner).is_none()); +} + +#[tokio::test] +async fn buff_breakers_existing_cc_prevents_restarting_a_song() { + let (server, _client, owner) = fixture(data()); + add(&server, &owner, SILENCE); + add(&server, &owner, SONGS[0]); + assert!(has(&owner, SILENCE)); + assert!(!has(&owner, SONGS[0])); + assert_eq!( + owner.with_unit(|u| u + .unit() + .bonuses + .calculate(0.0, UnitAttribute::Str, now_ms())), + Some(0.0) + ); +} + +#[tokio::test] +async fn buff_breakers_gliding_tag_ends_frigid_tracks_and_deadeye() { + let (server, mut client, owner) = fixture(data()); + add(&server, &owner, 431); + add(&server, &owner, 2170); + client.drain(); + add(&server, &owner, GLIDER); + assert!(!has(&owner, 431)); + assert!(!has(&owner, 2170)); + assert!(has(&owner, GLIDER)); + assert_eq!( + removed(&mut client), + vec![vec![0, 3, 0, 2, 0, 0, 0], vec![0, 3, 0, 3, 0, 0, 0]] + ); +} + +#[test] +fn buff_breakers_loader_preserves_direction_and_deduplicates_tags() { + let conn = rusqlite::Connection::open_in_memory().unwrap(); + conn.execute_batch("CREATE TABLE buff_breakers (buff_id, buff_tag_id); INSERT INTO buff_breakers VALUES (656,99),(656,6),(656,6),(1029,27);").unwrap(); + let breakers = super::super::data::load_buff_breakers(&conn).unwrap(); + assert_eq!(breakers[&656], vec![6, 99]); + assert_eq!(breakers[&1029], vec![27]); + assert!(!breakers.contains_key(&6)); +} + +#[test] +#[ignore = "requires AAEMU_COMPACT_DB (read-only 1.2 compact.sqlite3)"] +fn buff_breakers_real_compact_db_song_glider_and_cc_relations() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + rusqlite::Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY) + .unwrap(); + let breakers = super::super::data::load_buff_breakers(&conn).unwrap(); + assert_eq!(breakers.len(), 92); + assert_eq!(breakers.values().map(Vec::len).sum::(), 661); + for song in SONGS { + assert_eq!(breakers[&song], vec![6, 12, 13, 97, 99, 107, 150, 346]); + } + assert_eq!( + breakers[&GLIDER], + vec![6, 12, 13, 27, 97, 99, 107, 150, 346] + ); + for (id, tag) in [(STUN, 6), (SLEEP, 97), (SILENCE, 99)] { + let count: i32 = conn + .query_row( + "SELECT count(*) FROM tagged_buffs WHERE buff_id=?1 AND tag_id=?2", + [id, tag], + |r| r.get(0), + ) + .unwrap(); + assert_eq!(count, 1); + } + // Frigid Tracks and Deadeye break on Gliding, rather than arbitrary CC flags. + assert_eq!(breakers[&431], vec![294]); + assert_eq!(breakers[&2170], vec![294]); +} diff --git a/rust/crates/aaemu-game/src/systems/skills/buffs.rs b/rust/crates/aaemu-game/src/systems/skills/buffs.rs index b666888394..a8623ec570 100644 --- a/rust/crates/aaemu-game/src/systems/skills/buffs.rs +++ b/rust/crates/aaemu-game/src/systems/skills/buffs.rs @@ -502,12 +502,77 @@ pub fn buff_ab_level( /// `UnitHooks.on_buff_event`: the inline C# behaviour around `_effects` changes. pub fn on_buff_event(server: &GameServer, owner: &WorldObject, event: &BuffEvent) { match event { - BuffEvent::Started(b) => on_started(server, owner, b), - BuffEvent::Refreshed(b) => on_refreshed(server, owner, b), + BuffEvent::Started(b) | BuffEvent::Refreshed(b) => { + // An earlier event in the same batch can already have removed this effect. + if get_buff(owner, b.index).is_none() { + return; + } + if matches!(event, BuffEvent::Started(_)) { + on_started(server, owner, b); + } else { + on_refreshed(server, owner, b); + } + remove_broken_buffs(server, owner); + } BuffEvent::Removed(b) => on_removed(server, owner, b), } } +/// Reconcile authored breaker tags after an accepted start/refresh, including effects +/// applied by buff timers. Immunity/requirements/tolerance/stack rejection happens before +/// these events. The native loaders establish the relation's direction; the acceptance +/// boundary here is server policy, not a claimed native apply-vs-tick timing result. +fn remove_broken_buffs(server: &GameServer, owner: &WorldObject) { + let data = &server.game_data.systems.skills; + let mut broken: Vec = owner.with_base_unit(|u| { + let effects = &u.buffs().effects; + effects + .iter() + .filter(|b| !b.is_ended()) + .filter(|b| { + data.buff_breakers.get(&b.template.id).is_some_and(|tags| { + effects.iter().any(|other| { + other.index != b.index + && !other.is_ended() + && data + .buff_tags(other.template.id) + .iter() + .any(|t| tags.contains(t)) + }) + }) + }) + .cloned() + .collect() + }); + // Decide from one accepted snapshot. Mutual breakers and duplicate tags must not + // depend on HashMap order, or on callbacks changing the remaining candidates. + broken.sort_unstable_by_key(|b| b.index); + for b in broken { + exit(server, owner, b.index, false); + // A batch may contain an effect whose Started hook has not run yet. Finish its + // explicit exit now; the stale Started event above must not revive its controller. + if get_buff(owner, b.index).is_some_and(|e| e.state == effect_state::FINISHING) { + schedule_effect(server, owner, b.index, false); + } + // Remove first: stopping a channel can itself remove its channel/toggle buffs. + // Only cancel the channel that owns this buff, outside all object/controller locks. + let channel = owner + .with_unit(|u| u.unit().skill_state.skill_task.clone()) + .flatten() + .filter(|task| { + b.caster_obj_id == owner.obj_id() + && task.skill.template.id == b.skill_id + && (task.skill.template.channeling_buff_id == b.template.id + || task.skill.template.toggle_buff_id == b.template.id) + }); + if let Some(task) = channel { + if let super::state::SkillTaskKind::EndChanneling { channel_doodad } = task.kind { + super::skill::stop(server, &task.skill, owner, channel_doodad); + } + } + } +} + fn on_started(server: &GameServer, owner: &WorldObject, b: &Buff) { let data = &server.game_data.systems.skills; let template = full_template(server, &b.template); @@ -1769,3 +1834,7 @@ pub type Attr = UnitAttribute; #[cfg(test)] #[path = "buff_removal_tests.rs"] mod buff_removal_tests; + +#[cfg(test)] +#[path = "buff_breaker_tests.rs"] +mod buff_breaker_tests; diff --git a/rust/crates/aaemu-game/src/systems/skills/data/mod.rs b/rust/crates/aaemu-game/src/systems/skills/data/mod.rs index fbfc031c9b..938dd5a711 100644 --- a/rust/crates/aaemu-game/src/systems/skills/data/mod.rs +++ b/rust/crates/aaemu-game/src/systems/skills/data/mod.rs @@ -71,6 +71,8 @@ pub struct Data { pub buff_tags: HashMap>, /// `_taggedBuffs`: tag id -> buff ids. pub tagged_buffs: HashMap>, + /// `buff_breakers`: buff id -> tags on the owner that end that buff. + pub buff_breakers: HashMap>, /// `_skillTags`. pub skill_tags: HashMap>, /// `_taggedSkills`. @@ -296,6 +298,8 @@ impl Data { d.tagged_buffs.entry(tag).or_default().push(buff); Ok(()) })?; + d.buff_breakers = load_buff_breakers(conn)?; + d.buff_breakers.retain(|id, _| buffs.contains_key(id)); for_each_row(conn, "SELECT * FROM skill_modifiers", [], |r| { let attr = r.u32("skill_attribute_id")? as u8; let Some(skill_attribute) = SkillAttribute::from_u8(attr) else { @@ -635,6 +639,29 @@ impl Data { } } +/// The 1.2 loader (`395D17B0`) attaches each breaker tag to its `buff_id`, rather than +/// treating `buff_id` as the buff to apply. The 10.x loader (`39B41DE0`) uses a set. +pub(super) fn load_buff_breakers(conn: &Connection) -> rusqlite::Result>> { + let mut breakers: HashMap> = HashMap::new(); + for_each_row( + conn, + "SELECT buff_id, buff_tag_id FROM buff_breakers", + [], + |r| { + breakers + .entry(r.u32("buff_id")?) + .or_default() + .push(r.u32("buff_tag_id")?); + Ok(()) + }, + )?; + for tags in breakers.values_mut() { + tags.sort_unstable(); + tags.dedup(); + } + Ok(breakers) +} + #[cfg(test)] mod tests { use super::*; From 39ffe34737f13449c4d323d8941d4e0051e18a46 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:00:31 -0400 Subject: [PATCH 17/66] test(economy): allow creation in financial roundtrip fixture --- rust/crates/aaemu-game/src/systems/economy/mail_tests.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs b/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs index 353236de7c..e412942bb7 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs @@ -2177,6 +2177,7 @@ async fn private_mysql_quest_mail_auction_rollback_retry_and_reconnect() { crate::data::character_templates::CharacterTemplate { race: 1, gender: 1, + creatable: true, ..Default::default() }, ); From 779dad2da76efe272463adff8a31825f76e2516d Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:01:01 -0400 Subject: [PATCH 18/66] docs: distinguish drafted and partial audit repairs --- rust/docs/audit-repair-status.json | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json index a5a30f0ebc..f7156879e4 100644 --- a/rust/docs/audit-repair-status.json +++ b/rust/docs/audit-repair-status.json @@ -85,7 +85,9 @@ }, { "id": "aoe-diminishing", - "status": "implementing" + "status": "loader_merged_runtime_open", + "commit": "04783cdeb438b3fefb551dbd05edb62255a11bff", + "note": "Native counter/reset writer is under a separate focused trace; runtime is not repaired." }, { "id": "skill-and-buff-modifiers", @@ -111,7 +113,9 @@ }, { "id": "buff-breakers", - "status": "implementing" + "status": "draft_not_merged", + "commit": "0d935802542b3ef38a7114f5ccdde5ea7459f2b3", + "note": "Accepted-event implementation drafted; independent native timing trace pending." }, { "id": "buff-taunts", @@ -136,7 +140,7 @@ }, { "id": "zone-banned-item-and-skill-tags", - "status": "queued" + "status": "implementing" }, { "id": "unit-and-primary-stat-limits", @@ -328,7 +332,8 @@ }, { "id": "name-chat-filtering-throttle-and-moderation", - "status": "queued" + "status": "partial_merged_pending_validation", + "note": "Native ASCII block-name rules implemented in7441d62; chat/throttle/moderation remain open." }, { "id": "character-recustomization", @@ -336,7 +341,13 @@ }, { "id": "character-slots-races-and-deletion-guards", - "status": "implementing" + "status": "partial_merged_pending_validation", + "commit": "7441d62bcd2b85b89f907cf072428edad1ce1553", + "open_subcases": [ + "nation/penalty/bot/transfer deletion policy", + "ownership transfer atomicity", + "delayed expiry guard recheck" + ] }, { "id": "event-schedule-notifications", From 9dd3453085a829513db7bff1e1a80cc55a9963c3 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:07:28 -0400 Subject: [PATCH 19/66] fix(game): enforce unconditional zone banned tags before item and skill use Load all authored zone-group restrictions and item tags, retaining unresolved period rules separately. Validate the actual instance sector and server-owned item template before costs, summons or direct doodad placement; recheck pending skill and item casts. Add native 1.2 result/error body fixtures and regression coverage for tags, instance mapping, attachments, GM casts, placement and pending timers. Formatting, staged diff and read-only authored-fixture verification passed; Cargo builds, tests and clippy are deferred under the parent build-slot restriction. Period 24 semantics and Library index membership remain unresolved data limits. Co-Authored-By: OpenAI Codex --- .../aaemu-game/src/systems/economy/bridges.rs | 3 + .../src/systems/economy/inventory.rs | 23 + .../aaemu-game/src/systems/skills/data/mod.rs | 4 + .../src/systems/skills/data/zone_rules.rs | 92 ++++ .../systems/skills/data/zone_rules_tests.rs | 513 ++++++++++++++++++ .../aaemu-game/src/systems/skills/skill.rs | 4 + .../src/systems/skills/validation.rs | 39 ++ 7 files changed, 678 insertions(+) create mode 100644 rust/crates/aaemu-game/src/systems/skills/data/zone_rules.rs create mode 100644 rust/crates/aaemu-game/src/systems/skills/data/zone_rules_tests.rs diff --git a/rust/crates/aaemu-game/src/systems/economy/bridges.rs b/rust/crates/aaemu-game/src/systems/economy/bridges.rs index 4e6a18acd4..26842a89cf 100644 --- a/rust/crates/aaemu-game/src/systems/economy/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/economy/bridges.rs @@ -2361,6 +2361,9 @@ impl crate::systems::npcs::hooks::EconomyBridge for EconomyForNpcs { } else { inv.item_by_id(item_id) }?; + if !inventory::item_use_zone_allowed(server, player, item.template_id) { + return None; + } let t = server.game_data.items.template(item.template_id); Some(crate::systems::npcs::hooks::DoodadSourceItem { item_id: item.id, diff --git a/rust/crates/aaemu-game/src/systems/economy/inventory.rs b/rust/crates/aaemu-game/src/systems/economy/inventory.rs index 01d8d84612..d42e6a882f 100644 --- a/rust/crates/aaemu-game/src/systems/economy/inventory.rs +++ b/rust/crates/aaemu-game/src/systems/economy/inventory.rs @@ -1732,6 +1732,29 @@ pub fn actability_time_multiplier(step: u8) -> f32 { T[usize::from(step).min(T.len() - 1)] } +/// Validate item-cast location before costs, placement, summoning or item consumption. +pub(crate) fn item_use_zone_allowed( + server: &GameServer, + player: &PlayerRef, + template_id: u32, +) -> bool { + let banned = + crate::systems::skills::data::zone_rules::current_group(server, &WorldObject::from(player)) + .is_some_and(|group| { + server + .game_data + .systems + .skills + .zone_rules + .bans_item(group, template_id) + }); + if banned { + // Native 1.2 x2game12.c:1163648: ErrorMessage 440 = item_cannot_use_here. + send_error_message(player, error_message::ITEM_CANNOT_USE_HERE, 0, true); + } + !banned +} + /// `Character.ItemUse(item)` (`Events.OnItemUse` -> quests). pub fn item_use(server: &GameServer, player: &PlayerRef, template_id: u32) { if template_id == 0 { diff --git a/rust/crates/aaemu-game/src/systems/skills/data/mod.rs b/rust/crates/aaemu-game/src/systems/skills/data/mod.rs index fbfc031c9b..179b4cad63 100644 --- a/rust/crates/aaemu-game/src/systems/skills/data/mod.rs +++ b/rust/crates/aaemu-game/src/systems/skills/data/mod.rs @@ -6,6 +6,7 @@ pub mod effects; pub mod misc; pub mod plots; pub mod templates; +pub mod zone_rules; #[cfg(test)] mod buff_game_data_tests; @@ -75,6 +76,8 @@ pub struct Data { pub skill_tags: HashMap>, /// `_taggedSkills`. pub tagged_skills: HashMap>, + /// Authored zone-group restrictions and item tag membership. + pub zone_rules: zone_rules::ZoneRules, /// `_skillModifiers` by owner id. pub skill_modifiers: HashMap>, /// `_buffTriggers` by buff id. @@ -131,6 +134,7 @@ impl Data { let mut d = Data { plots: PlotData::load(conn)?, anims: AnimData::load(conn, files)?, + zone_rules: zone_rules::ZoneRules::load(conn)?, ..Data::default() }; // skills diff --git a/rust/crates/aaemu-game/src/systems/skills/data/zone_rules.rs b/rust/crates/aaemu-game/src/systems/skills/data/zone_rules.rs new file mode 100644 index 0000000000..94aaf45198 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/data/zone_rules.rs @@ -0,0 +1,92 @@ +//! Native 1.2 zone-group restrictions (`x2game12.c:1646640`, LoadZoneGroupBannedTagDescs). + +use std::collections::HashMap; + +use rusqlite::Connection; + +use crate::data::sqlite::for_each_row; +use crate::server::GameServer; +use crate::world::WorldObject; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct BannedTag { + pub id: u32, + pub tag_id: u32, + pub banned_periods_id: u32, +} + +#[derive(Debug, Default)] +pub struct ZoneRules { + /// Keep conditional rows intact: an unresolved schedule must not become an always-on ban. + pub banned_tags: HashMap>, + pub item_tags: HashMap>, +} + +impl ZoneRules { + pub fn load(conn: &Connection) -> rusqlite::Result { + let mut data = Self::default(); + for_each_row(conn, "SELECT * FROM zone_group_banned_tags", [], |row| { + data.banned_tags + .entry(row.u32("zone_group_id")?) + .or_default() + .push(BannedTag { + id: row.u32("id")?, + tag_id: row.u32("tag_id")?, + banned_periods_id: row.u32("banned_periods_id")?, + }); + Ok(()) + })?; + for_each_row(conn, "SELECT * FROM tagged_items", [], |row| { + data.item_tags + .entry(row.u32("item_id")?) + .or_default() + .push(row.u32("tag_id")?); + Ok(()) + })?; + let conditional = data + .banned_tags + .values() + .flatten() + .filter(|rule| rule.banned_periods_id != 0) + .count(); + if conditional != 0 { + // 1.2 exports nine guard-summon rows with period 24 but no period definition. + // Native loader evidence establishes the field, not its scheduling semantics. + tracing::warn!( + conditional, + "Scheduled zone banned tags retained but not enforced: native period semantics unresolved" + ); + } + Ok(data) + } + + pub fn bans_any(&self, group: u32, tags: &[u32]) -> bool { + self.banned_tags.get(&group).is_some_and(|rules| { + rules + .iter() + .any(|rule| rule.banned_periods_id == 0 && tags.contains(&rule.tag_id)) + }) + } + + pub fn bans_item(&self, group: u32, item: u32) -> bool { + self.item_tags + .get(&item) + .is_some_and(|tags| self.bans_any(group, tags)) + } +} + +/// Resolve the current sector in the actual instance's template, including attached players. +/// Cached Transform.ZoneId/WorldId may still describe the previous zone or a different world. +pub(crate) fn current_group(server: &GameServer, caster: &WorldObject) -> Option { + let world = server.world.world(caster.transform().instance_id)?; + let pos = world.world_pos_rot(caster); + server + .game_data + .zones + .zone_by_key(world.template.zone_id_at(pos.x, pos.y)) + .map(|zone| zone.group_id) +} + +#[cfg(test)] +#[path = "zone_rules_tests.rs"] +mod tests; diff --git a/rust/crates/aaemu-game/src/systems/skills/data/zone_rules_tests.rs b/rust/crates/aaemu-game/src/systems/skills/data/zone_rules_tests.rs new file mode 100644 index 0000000000..ab5810fbaf --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/data/zone_rules_tests.rs @@ -0,0 +1,513 @@ +//! Authored 1.2 relation subsets; coordinates/world instances are synthetic geometry. +//! Native evidence: D:/aa-re/client12/decomp/x2game12.c +//! - 1646640..1646705: banned tag descriptor fields, including banned_periods_id. +//! - 1983345..1983346: SkillResult 58 = ZONE_BANNED. +//! - 1163648..1163649: ErrorMessage 440 = item_cannot_use_here. +//! - 1766270..1766291 + 1748773..1748807: started-skill body, flags and byte result. +//! - 1761305..1761336: two i16 errors, u32 type, bool notify in SCErrorMsg. +//! - 1765129..1765192: caster discriminator, three-byte object ID and item fields. +//! These literal failure bodies are native-layout fixtures, not Rust encode/decode round trips. + +use std::sync::Arc; +use std::time::Duration; + +use aaemu_commons::PacketStream; +use rusqlite::Connection; + +use super::{current_group, ZoneRules}; +use crate::data::items::ItemTemplate; +use crate::data::world_data::Zone; +use crate::data::world_templates::WorldTemplate; +use crate::net::registry::ClientPacket; +use crate::opcodes::sc; +use crate::systems::economy::inventory::Inv; +use crate::systems::skills::data::{EffectKind, EffectTemplate, SkillItemAmount, SkillTemplate}; +use crate::systems::skills::handlers::{start_skill, CSStartSkillPacket}; +use crate::systems::skills::state::{SkillRef, SkillRun}; +use crate::systems::skills::types::{SkillCastTarget, SkillCaster, SkillObject}; +use crate::systems::skills::{self, skill}; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use crate::world::{PlayerRef, WorldObject}; +use crate::GameServer; + +const GLIDER: u32 = 12373; +const FISHING: u32 = 21571; +const GUARD: u32 = 24133; +const MOUNT_ITEM: u32 = 34580; +const SHIP_ITEM: u32 = 34314; +const GLIDER_ITEM: u32 = 14677; +const LUMBER: u32 = 8337; +const PLACEMENT_ITEM: u32 = 32095; + +fn relations() -> ZoneRules { + let conn = Connection::open_in_memory().unwrap(); + // Exact authored tuples (id, group, tag, period) from compact 1.2. Library index + // has banned-tag rows but NO tagged_items/tagged_skills rows in this export. + conn.execute_batch( + "CREATE TABLE zone_group_banned_tags (id, zone_group_id, tag_id, banned_periods_id); + INSERT INTO zone_group_banned_tags VALUES + (2,45,471,0),(3,45,472,0),(16,45,629,0),(21,45,296,0), + (13,45,628,0),(185,45,1348,0),(380,45,1581,0),(337,1,1581,0), + (271,70,472,0),(280,70,296,0),(281,70,629,0),(277,70,1348,0), + (203,63,1338,24); + CREATE TABLE tagged_items (tag_id, item_id); + INSERT INTO tagged_items VALUES (471,34580),(472,34314),(629,14677),(628,32095);", + ) + .unwrap(); + ZoneRules::load(&conn).unwrap() +} + +struct Fixture { + server: Arc, + client: TestClient, + player: PlayerRef, +} + +impl Fixture { + fn new() -> Self { + let mut data = crate::systems::economy::tests::test_data(); + for (id, key, group) in [(1, 129, 1), (168, 236, 45), (200, 288, 63), (209, 296, 70)] { + data.zones.zones.insert( + key, + Zone { + id, + zone_key: key, + group_id: group, + ..Default::default() + }, + ); + data.zones.zone_id_to_key.insert(id, key); + } + let skills = &mut data.systems.skills; + skills.zone_rules = relations(); + // Use the existing skill tag index; do not create another skill-tag loader. + skills.skill_tags.insert(GLIDER, vec![296]); + skills.skill_tags.insert(FISHING, vec![1348]); + skills.skill_tags.insert(GUARD, vec![1338]); + skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(skills::tests::damage_effect(1, 100))), + 1, + ); + for id in [GLIDER, FISHING, GUARD, 10602, 15802] { + let mut effect = skills::tests::skill_effect(1, EffectKind::DamageEffect, 1); + effect.always_hit = true; + skills.add_skill(SkillTemplate { + // Authored IDs/tags with synthetic costs and a damage sentinel to expose + // accidental side effects in a denied cast. + id, + target_type: 0, + max_range: 30, + mana_cost: 25, + consume_labor_power: 10, + gain_life_point: 5, + cooldown_time: 1000, + default_gcd: true, + damage_type_id: 1, + level_rule_no_consideration: true, + effects: vec![effect], + ..Default::default() + }); + skills.skill_reagents.push(SkillItemAmount { + id, + skill_id: id, + item_id: LUMBER, + amount: 1, + }); + data.skills.add_client_sourced_skill(id); + } + for (item, skill) in [ + (MOUNT_ITEM, 10602), + (SHIP_ITEM, 15802), + (GLIDER_ITEM, GLIDER), + ] { + let mut template = ItemTemplate::plain(item, 10); + template.use_skill_id = skill; + template.use_skill_as_reagent = true; + data.items.templates.insert(item, template); + } + data.items + .templates + .insert(LUMBER, ItemTemplate::plain(LUMBER, 10)); + data.items + .templates + .insert(PLACEMENT_ITEM, ItemTemplate::plain(PLACEMENT_ITEM, 10)); + let server = Arc::new(test_server_with(data)); + server.set_self(); + skills::bind(&server); + crate::systems::economy::bridges::install(&server); + server.world.remove_world(0); + server.world.create_world_instance( + Arc::new(WorldTemplate::synthetic(0, "main_world", 2, 2, 129)), + 0, + ); + let dungeon = Arc::new(WorldTemplate::synthetic( + 1, + "instance_burntcastle_armory", + 2, + 2, + 236, + )); + server.world.create_world_instance(dungeon.clone(), 1); + // An instanced copy has an ephemeral instance ID, NOT its world-template ID. + server.world.create_world_instance(dungeon, 9001); + server.world.create_world_instance( + Arc::new(WorldTemplate::synthetic(2, "instance_library_1", 2, 2, 296)), + 9002, + ); + let mut client = TestClient::new(&server, 1, 1); + let mut character = test_character(1, "Caster", 100.0, 100.0); + character.unit.hp = 1000; + character.unit.max_hp = 1000; + character.unit.mp = 100; + character.unit.max_mp = 100; + character.labor_power = 100; + let player = spawn_player(&server, &client, character, 0x100); + client.conn.active_char = Some(player.clone()); + server.items.add_container(Inv::of(&player).bag()); + let result = Self { + server, + client, + player, + }; + result.give(LUMBER, 0); + result + } + + fn give(&self, template: u32, slot: i32) -> u64 { + let item = self + .server + .items + .create( + template, + 2, + 0, + 1, + &self.server.game_data.items, + &self.server.ids.item, + 0, + ) + .unwrap(); + let id = item.id; + Inv::of(&self.player) + .bag() + .lock() + .unwrap() + .add_new_item(item, slot, &self.server.game_data.items) + .unwrap(); + id + } + + fn enter(&mut self, instance: u32) { + self.player.data().unit.transform.instance_id = instance; + let obj = WorldObject::from(&self.player); + self.server.world.leave_other_instance(&obj, instance); + self.server + .world + .world(instance) + .unwrap() + .spawn(&self.player, &self.server.view_ctx()); + // Deliberately stale; only the actual world's sector mapping is authoritative. + let mut c = self.player.data(); + c.unit.transform.zone_id = if instance == 0 { 236 } else { 129 }; + c.unit.transform.world_id = 0; + drop(c); + self.client.drain(); + } + + fn assert_no_costs_or_effects(&self) { + let c = self.player.data(); + assert_eq!( + (c.unit.hp, c.unit.mp, c.labor_power, c.vocation_point), + (1000, 100, 100, 0) + ); + assert!(c.unit.cooldowns.cooldowns.is_empty()); + assert_eq!(c.unit.global_cooldown_ms, 0); + assert!(c.unit.skill_state.skill_task.is_none()); + drop(c); + assert_eq!(Inv::of(&self.player).items_count(LUMBER, -1), 2); + } + + fn run(&self, id: u32, source: SkillCaster, casting_time: i32) -> (SkillRef, (u8, u32)) { + let mut template = (**self.server.game_data.systems.skills.skill(id).unwrap()).clone(); + template.casting_time = casting_time; + let run = SkillRun::new(Arc::new(template), 1); + let result = skill::use_skill( + &self.server, + &run, + &WorldObject::from(&self.player), + source, + &mut SkillCastTarget::Unit(self.player.obj_id), + Some(SkillObject::None), + false, + ); + (run, result) + } +} + +#[test] +fn zone_rules_preserve_conditional_rows_without_widening_bans() { + let rules = relations(); + assert_eq!(rules.banned_tags[&63][0].banned_periods_id, 24); + assert!(!rules.bans_any(63, &[1338])); + assert!(rules.bans_any(45, &[296])); + assert!(!rules.bans_any(45, &[1338])); + assert!(rules.bans_any(1, &[1581])); + assert!(!rules.bans_any(70, &[1581])); + assert!(!rules.item_tags.values().any(|tags| tags.contains(&1581))); +} + +#[test] +fn zone_rules_missing_period_cannot_silently_become_an_unconditional_ban() { + let conn = Connection::open_in_memory().unwrap(); + conn.execute_batch( + "CREATE TABLE zone_group_banned_tags (id, zone_group_id, tag_id, banned_periods_id); + INSERT INTO zone_group_banned_tags VALUES (203,63,1338,NULL); + CREATE TABLE tagged_items (tag_id, item_id);", + ) + .unwrap(); + assert!(ZoneRules::load(&conn).is_err()); +} + +#[tokio::test] +async fn zone_rules_attached_caster_uses_composed_position_in_actual_world() { + use crate::models::slave::Slave; + use crate::world::Entity; + let f = Fixture::new(); + let mut template = WorldTemplate::synthetic(0, "main_world", 2, 2, 129); + // Synthetic sector boundary using real zone keys: local (100,100) is open, but + // the parent's (1000,100) offset places the player at (1100,200), sector (17,3). + assert!(template.set_zone_key_at(17, 3, 236)); + let world = f + .server + .world + .create_world_instance(Arc::new(template), 9003); + f.player.data().unit.transform.instance_id = 9003; + let obj = WorldObject::from(&f.player); + f.server.world.leave_other_instance(&obj, 9003); + world.spawn(&f.player, &f.server.view_ctx()); + let mut parent = Slave::new(0x200, 1); + parent.unit.transform.set_xyz(1000.0, 100.0, 0.0); + let parent = Entity::new(0x200, parent); + world.spawn(&parent, &f.server.view_ctx()); + world.attach_child(&WorldObject::from(&parent), &obj); + assert_eq!(f.player.data().unit.transform.zone_id, 129); + assert_eq!(current_group(&f.server, &obj), Some(45)); + assert_eq!( + f.run(GLIDER, SkillCaster::Unit(f.player.obj_id), 0).1, + (58, 0) + ); + f.assert_no_costs_or_effects(); +} + +#[tokio::test] +async fn zone_rules_direct_skill_packet_is_denied_in_actual_instance_for_players_and_gms() { + for instance in [1, 9001, 9002] { + for access in [0, 100] { + let mut f = Fixture::new(); + f.enter(instance); + f.player.data().access_level = access; + assert_eq!( + current_group(&f.server, &WorldObject::from(&f.player)), + Some(if instance == 9002 { 70 } else { 45 }) + ); + // Native CSStartSkill (0x052): u32 skill, unit caster + BC id, unit target + BC id, + // flag zero. IDs are glider 12373 and this fixture's player object 0x100. + let mut body = + PacketStream::from_bytes(vec![0x55, 0x30, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]); + let packet = CSStartSkillPacket::read(&mut body).unwrap(); + start_skill(&f.server, &mut f.client.conn, packet); + let frames = f.client.drain(); + assert_eq!( + frames, + vec![( + sc::SCSkillStartedPacket, + vec![0x55, 0x30, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 58,] + )] + ); + f.assert_no_costs_or_effects(); + assert_eq!(f.player.data().unit.skill_last_used_ms, 0); + } + } +} + +#[tokio::test] +async fn zone_rules_item_request_uses_owned_template_before_costs_or_summons() { + for (item, skill) in [ + (MOUNT_ITEM, 10602), + (SHIP_ITEM, 15802), + (GLIDER_ITEM, GLIDER), + ] { + let mut f = Fixture::new(); + f.enter(9001); + let id = f.give(item, 1); + start_skill( + &f.server, + &mut f.client.conn, + CSStartSkillPacket { + skill_id: skill, + caster: SkillCaster::Item { + obj_id: f.player.obj_id, + item_id: id, + item_template_id: LUMBER, // forged untagged template hint + type1: 0, + type2: 0, + }, + target: SkillCastTarget::Unit(f.player.obj_id), + flag: 0, + skill_object: SkillObject::None, + }, + ); + let frames = f.client.drain(); + assert_eq!(frames.len(), 2); + assert_eq!( + frames[0], + (sc::SCErrorMsgPacket, vec![0xb8, 1, 0xb8, 1, 0, 0, 0, 0, 1]) + ); + assert_eq!(frames[1].0, sc::SCSkillStartedPacket); + assert_eq!(frames[1].1.last(), Some(&58)); + assert_eq!(Inv::of(&f.player).items_count(item, -1), 2); + f.assert_no_costs_or_effects(); + assert_eq!(f.player.data().unit.skill_last_used_ms, 0); + let world = f.server.world.world(9001).unwrap(); + assert!(world.all_of_kind(crate::world::ObjectKind::Mate).is_empty()); + assert!(world.all_slaves().is_empty()); + assert!(world.all_doodads().is_empty()); + } +} + +#[tokio::test] +async fn zone_rules_direct_doodad_item_request_is_denied_before_placement() { + use crate::systems::npcs::doodad::packets::CSCreateDoodadPacket; + let mut f = Fixture::new(); + let item = f.give(PLACEMENT_ITEM, 1); + // This item is otherwise visible to the placement bridge in the normal world. + assert!(f + .server + .systems + .npcs + .hooks + .economy + .get() + .unwrap() + .doodad_source_item(&f.server, &f.player, item, true) + .is_some()); + f.enter(9001); + CSCreateDoodadPacket { + id: 7876, + x: 100.0, + y: 100.0, + z: 100.0, + z_rot: 0.0, + scale: 1.0, + item_id: item, + } + .handle(&f.server, &mut f.client.conn) + .await + .unwrap(); + assert_eq!( + f.client.drain(), + vec![(sc::SCErrorMsgPacket, vec![0xb8, 1, 0xb8, 1, 0, 0, 0, 0, 1])] + ); + f.assert_no_costs_or_effects(); + assert_eq!(Inv::of(&f.player).items_count(PLACEMENT_ITEM, -1), 2); + assert!(f.server.world.world(9001).unwrap().all_doodads().is_empty()); +} + +#[tokio::test] +async fn zone_rules_fishing_denies_but_unrelated_tag_and_open_world_allow_casts() { + let mut f = Fixture::new(); + f.enter(1); + assert_eq!( + f.run(FISHING, SkillCaster::Unit(f.player.obj_id), 0).1, + (58, 0) + ); + f.assert_no_costs_or_effects(); + // Guard skill has a different tag; a conditional ban in another group cannot block it. + let (_, result) = f.run(GUARD, SkillCaster::Unit(f.player.obj_id), 0); + assert_eq!(result, (0, 0)); + assert!(f.player.data().unit.mp < 100); + assert!(f.player.data().unit.hp < 1000); + assert_eq!(Inv::of(&f.player).items_count(LUMBER, -1), 1); + let mut f = Fixture::new(); + f.enter(0); // stale zone 236 must not ban gliders in actual Gweonid sector 129. + assert_eq!( + current_group(&f.server, &WorldObject::from(&f.player)), + Some(1) + ); + assert_eq!( + f.run(GLIDER, SkillCaster::Unit(f.player.obj_id), 0).1, + (0, 0) + ); +} + +#[tokio::test] +async fn zone_rules_pending_skill_and_item_casts_recheck_zone_before_payment() { + for item_cast in [false, true] { + let mut f = Fixture::new(); + f.enter(0); + let source = if item_cast { + SkillCaster::Item { + obj_id: f.player.obj_id, + item_id: f.give(MOUNT_ITEM, 1), + item_template_id: MOUNT_ITEM, + type1: 0, + type2: 0, + } + } else { + SkillCaster::Unit(f.player.obj_id) + }; + let id = if item_cast { 10602 } else { GLIDER }; + let (run, result) = f.run(id, source, 50); + assert_eq!(result, (0, 0)); + assert_ne!(run.tl_id(), 0); + assert!(f.player.data().unit.skill_state.skill_task.is_some()); + f.enter(9001); + let deadline = tokio::time::Instant::now() + Duration::from_secs(1); + while run.tl_id() != 0 && tokio::time::Instant::now() < deadline { + tokio::time::sleep(Duration::from_millis(5)).await; + } + assert!(run.cancelled()); + assert_eq!(run.tl_id(), 0); + f.assert_no_costs_or_effects(); + let frames = f.client.drain(); + assert!(frames + .iter() + .any(|(op, body)| *op == sc::SCSkillStartedPacket && body.last() == Some(&58))); + assert!(!frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + if item_cast { + assert_eq!(Inv::of(&f.player).items_count(MOUNT_ITEM, -1), 2); + } + } +} + +#[test] +#[ignore = "requires AAEMU_COMPACT_DB pointing to the native 1.2 reference data"] +fn zone_rules_real_compact_db_preserves_all_authored_relations() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap(); + let rules = ZoneRules::load(&conn).unwrap(); + let rows: Vec<_> = rules.banned_tags.values().flatten().collect(); + assert_eq!(rows.len(), 333); + assert_eq!( + rows.iter().filter(|r| r.banned_periods_id == 0).count(), + 324 + ); + assert_eq!( + rows.iter() + .filter(|r| r.banned_periods_id == 24 && r.tag_id == 1338) + .count(), + 9 + ); + assert!(rules.bans_item(45, MOUNT_ITEM)); + assert!(rules.bans_item(45, SHIP_ITEM)); + assert!(rules.bans_item(45, GLIDER_ITEM)); + assert!(rules.bans_any(45, &[1348])); + assert!(!rules.bans_any(63, &[1338])); + assert!(rules.bans_any(1, &[1581])); + assert!(!rules.bans_any(70, &[1581])); + assert!(!rules.item_tags.values().any(|tags| tags.contains(&1581))); +} diff --git a/rust/crates/aaemu-game/src/systems/skills/skill.rs b/rust/crates/aaemu-game/src/systems/skills/skill.rs index 1229552a10..e99429195e 100644 --- a/rust/crates/aaemu-game/src/systems/skills/skill.rs +++ b/rust/crates/aaemu-game/src/systems/skills/skill.rs @@ -384,6 +384,9 @@ pub fn use_skill( if !caster.is_unit() { return (skill_result::INVALID_SOURCE, 0); } + if let Err(result) = super::validation::check_item_zone(server, caster, &caster_caster) { + return result; + } let template = skill.template.clone(); let resolved_target = initial_target(server, skill, caster, &caster_caster, target_caster); let Some(target) = &resolved_target else { @@ -831,6 +834,7 @@ pub fn cast(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { .as_player() .and_then(|p| portal_zone_check(server, &skill.template, p, Some(&ctx.skill_object))) .map_or(Ok(()), |result| Err((result, 0))) + .and_then(|()| super::validation::check_item_zone(server, caster, &ctx.caster_caster)) .and_then(|()| super::validation::check(server, skill, caster, &ctx.target)) .and_then(|()| super::validation::check_resources(server, skill, caster)) .and_then(|()| { diff --git a/rust/crates/aaemu-game/src/systems/skills/validation.rs b/rust/crates/aaemu-game/src/systems/skills/validation.rs index d81431690f..665aa0a0cc 100644 --- a/rust/crates/aaemu-game/src/systems/skills/validation.rs +++ b/rust/crates/aaemu-game/src/systems/skills/validation.rs @@ -16,6 +16,31 @@ fn fail(key: &str) -> Result<(), (u8, u32)> { Err((skill_result_for_key(key), 0)) } +/// Item-caster tags belong to the owned item's server-side template, never the wire hint. +pub(super) fn check_item_zone( + server: &GameServer, + caster: &WorldObject, + source: &super::types::SkillCaster, +) -> Result<(), (u8, u32)> { + if let (Some(player), super::types::SkillCaster::Item { item_id, .. }) = + (caster.as_player(), source) + { + if let Some((template, _)) = server + .systems + .skills + .ext + .items() + .owned_item(server, player, *item_id) + { + if !crate::systems::economy::inventory::item_use_zone_allowed(server, player, template) + { + return fail("SKILL_CANNOT_USE_HERE"); + } + } + } + Ok(()) +} + fn in_water(server: &GameServer, target: &Target) -> bool { if target .as_obj() @@ -139,6 +164,20 @@ pub(super) fn check( target: &Target, ) -> Result<(), (u8, u32)> { let template = &skill.template; + // Like the other cast restrictions, this also applies to administrators. A GM's + // cooldown override does not grant permission to use forbidden tags. + if caster.as_player().is_some() + && super::data::zone_rules::current_group(server, caster).is_some_and(|group| { + let data = &server.game_data.systems.skills; + data.zone_rules.bans_any( + group, + data.skill_tags.get(&skill.id).map_or(&[], Vec::as_slice), + ) + }) + { + // Native 1.2 x2game12.c:1983345: SkillResult 58 = ZONE_BANNED. + return fail("SKILL_CANNOT_USE_HERE"); + } if let Some(doodad) = target.as_obj().and_then(WorldObject::as_doodad) { if !crate::systems::npcs::doodad::gathering::allows_skill(server, doodad, template, caster) { From e6f6920da71f0e54eaf23cba75e4f545a2781e5b Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:11:37 -0400 Subject: [PATCH 20/66] fix(game): apply plot-scoped AoE diminishing policy Apply the reviewed compatibility policy through explicit plot effect context: first-seen distinct target ranks span sibling flagged damage events, misses and immunity occupy ranks, repeat hits reuse ranks, reset clears only its originating plot, and targets beyond the last authored id use the final rate. Bound retained identities to the maximum authored rank. Keep ordinary effects and wire formats unchanged. Apply authored floating-point rates to integer damage after existing reductions, then truncate and enforce minimum 1 for landed flagged damage. Retain the existing physical versus fixed damage and modifier ordering. Add eleven plot/combat policy regressions for target ranks 1 through 12, queued per-target projectiles, repeat waves/reset, cast and caster isolation, misses/immunity, unchanged unflagged/heal/CC effects, storage bounds, fractional rates and nonnegative damage. Document native evidence and limitations in the skills PORTING section. Native 1.2 plot-effect 5680 resets descriptor 2 in event 246; next 288 repeats at 500 ms and next 3195 fans event 3 out per target to flagged event 2723. The world-server counter producer is unavailable; this policy is not a claim of proven retail parity. Validation: cargo fmt --all; cargo fmt --all --check; git diff --check; read-only native 1.2 compact topology queries. No compilation, tests, clippy, live stack or full CI run under the parent build freeze. Parent selectors: aoe_policy_, aoe_diminishing_loader, and real_compact_db_aoe_diminishings -- --ignored with AAEMU_COMPACT_DB. Co-Authored-By: Codex --- rust/crates/aaemu-game/PORTING.md | 24 + .../src/systems/skills/effects/combat.rs | 17 + .../src/systems/skills/effects/mod.rs | 30 + .../src/systems/skills/plot_aoe_tests.rs | 616 ++++++++++++++++++ .../aaemu-game/src/systems/skills/plots.rs | 36 +- 5 files changed, 722 insertions(+), 1 deletion(-) create mode 100644 rust/crates/aaemu-game/src/systems/skills/plot_aoe_tests.rs diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 6eb2799c6b..9c1753be1d 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -168,6 +168,30 @@ Each subsystem records its status here, in its own section only (see `CONTRIBUTI | Movement hooks (`CSMoveUnit.RemoveEffects`, `Character.SetPosition` Move removal, fall damage) | `systems/skills/mod.rs` (`on_move_request`, `on_moved`) | done | Called from `world::session::move_unit`. | | `Skill.EndChanneling` target buff (`ChannelingTargetBuffId`) | `systems/skills/{skill,buffs}.rs` (`end_channeling`, `finish_effect_by_skill`) | deviation | **Deviation:** the C# `Buffs.RemoveEffect(templateId, skillId)` raised the buff's `OnTimeout` triggers on every removal; the Rust removal skips them for explicit removals (dispels, a stopped channel; see the FISH escape in `buff_removal_tests.rs`). Quest item grants hang on that trigger (GainItem on buff 3896 of skill 18449 'Extract Earth Crystal', 4 s channel under a 6 s buff, and the other channeling-target-buff quest skills of the item triage), so a channel that **runs to its end** now fires the target buff's Timeout triggers before removing it. A stopped / cancelled channel fires nothing (the C# granted the item then too). The caster-side `ChannelingBuffId` and buffs applied by skill effects (buff 1963 of 'Capture Crayfish') are unchanged: the latter expire on their own timer and fire Timeout already. | +#### AoE diminishing compatibility policy (2026-10-25) + +`systems::skills`: `aoe_diminishings` loads authored float percentages by id (native 1.2 +`sub_39620E90`, `D:/aa-re/client12/decomp/x2game12.c:1321108`). Searing Rain 11939 / plot 1 +resets through plot-effect row 5680 (descriptor 2, event 246); next-event 288 repeats every +500 ms. Next-event 3195 fans event 3 out per target at speed 20 to flagged event 2723 / Damage +3172. Thus resetting on each child invocation would give every projectile the first rate. + +The chosen **server compatibility policy is provisional, not proven retail parity**: each plot +instance keeps first-seen distinct-target ranks in existing execution order, shared across +sibling damage events. Misses and immunity occupy ranks; repeat hits reuse their wave rank. +Only flagged plot Damage effects participate. Reset clears only the calling plot's map. +Targets beyond the last authored id use its final rate; storage is limited to N identities, +where N is the last authored id (10 in 1.2). Rates apply after existing damage/modifier reductions to the +integer result, then truncate with minimum 1 for landed damage, as the native 1.2 diagnostic +`sub_39898330` describes (`x2game12.c:1984147-1984167`). Other damage, heals, buffs and CC retain +their existing paths, and wire formats are unchanged. + +The native damage diagnostic (10.x `sub_39CECDB0`, parameter `+444`) is serialized debug data +supplied by the world server; the available client/zone plot dispatcher executes visual +effects, not the authoritative counter. Its producer is unavailable in these binaries. +`plots::aoe_tests::aoe_policy_*` covers the compatibility policy through plot/combat flows; +an authoritative native lifecycle experiment and live verification remain unperformed. + #### Special effects added from data (2026-10-20) These `SpecialType` bodies were TODO stubs that only logged in the C# (`git show a2ab80abd^:AAEmu.Game/Models/Game/Skills/Effects/SpecialEffects/...`); the behaviour below is derived from the 1.2 data because value1..4 are 0. diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs b/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs index 89c0287a5a..73bff3f176 100644 --- a/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs +++ b/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs @@ -111,6 +111,16 @@ pub fn damage( e: &DamageEffect, args: &EffectArgs<'_>, packets: Option<&mut CompressedGamePackets>, +) { + damage_with_aoe(server, e, args, packets, None); +} + +pub(super) fn damage_with_aoe( + server: &GameServer, + e: &DamageEffect, + args: &EffectArgs<'_>, + packets: Option<&mut CompressedGamePackets>, + aoe_multiplier: Option, ) { let Some(trg) = args.target.as_obj().filter(|o| o.is_unit()).cloned() else { return; @@ -425,6 +435,13 @@ pub fn damage( _ => final_damage *= ts[7] as f32, } let value = (final_damage * reduction_mul) as i32; + // Native 1.2 damage diagnostic sub_39898330 (x2game12.c:1984147-1984167) + // multiplies the already integer damage, truncates, then enforces minimum 1. + // Only opted-in plot damage takes this compatibility path; counter policy is + // server-defined (PORTING.md), not evidence of a retail runtime implementation. + let value = aoe_multiplier.map_or(value, |multiplier| { + ((value as f32 * multiplier) as i32).max(1) + }); let absorbed = (final_damage * (1.0 - reduction_mul)) as i32; let health_stolen = (value as f32 * (e.health_steal_ratio as f32 / 100.0)) as i32; let mana_stolen = (value as f32 * (e.mana_steal_ratio as f32 / 100.0)) as i32; diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/mod.rs b/rust/crates/aaemu-game/src/systems/skills/effects/mod.rs index 4271576a70..75dd16753c 100644 --- a/rust/crates/aaemu-game/src/systems/skills/effects/mod.rs +++ b/rust/crates/aaemu-game/src/systems/skills/effects/mod.rs @@ -103,6 +103,35 @@ pub fn chance_succeeds(chance: i32) -> bool { chance > 0 && (chance >= 100 || rand::thread_rng().gen_range(0..100) < chance) } +/// Plot-specific context is explicit so resets and sibling damage invocations refer to +/// the originating plot instance, even when its SkillRun or caster has another active plot. +pub(super) fn apply_plot( + server: &GameServer, + kind: EffectKind, + template: &EffectTemplate, + args: &EffectArgs<'_>, + plot: &super::plots::PlotState, + aoe_diminishing: bool, +) { + match template { + EffectTemplate::Damage(t) => { + let multiplier = args + .target + .as_obj() + .filter(|target| aoe_diminishing && target.is_unit()) + .map(|target| { + plot.aoe_damage_multiplier( + &server.game_data.systems.skills.plots.aoe_diminishings, + target.obj_id(), + ) + }); + combat::damage_with_aoe(server, t, args, None, multiplier); + } + EffectTemplate::ResetAoeDiminishing { .. } => plot.reset_aoe_diminishing(), + _ => apply(server, kind, template, args, None), + } +} + /// `EffectTemplate.Apply` dispatch. pub fn apply( server: &GameServer, @@ -124,6 +153,7 @@ pub fn apply( T::Aggro(t) => combat::aggro(server, t, args), T::Special(t) => special::apply(server, t, args), T::FlyingStateChange { .. } => combat::flying_state_change(server, template, args), + // A reset has meaning only with its originating plot's context (`apply_plot`). T::ResetAoeDiminishing { .. } => {} T::SkillController(t) => combat::skill_controller(server, t, args), T::Bubble { id, kind_id } => unit_fx::bubble(server, *id, *kind_id, args), diff --git a/rust/crates/aaemu-game/src/systems/skills/plot_aoe_tests.rs b/rust/crates/aaemu-game/src/systems/skills/plot_aoe_tests.rs new file mode 100644 index 0000000000..84e0d22cb1 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/plot_aoe_tests.rs @@ -0,0 +1,616 @@ +//! Provisional server AoE policy regressions, not retail parity claims. Native clients +//! expose descriptors/diagnostics, but the authoritative world-server counter is unavailable. +//! These tests drive real plot effects and combat; expected ranks implement the reviewed +//! compatibility policy in PORTING.md. No client packet format is introduced or changed. + +use super::*; + +use crate::data::world_data::SystemFaction; +use crate::data::GameData; +use crate::models::npc::Npc; +use crate::models::unit::{Bonus, BonusTemplate, SkillModifier, UnitAttribute, UnitModifierType}; +use crate::test_support::TestClient; +use crate::world::{Entity, NpcRef, PlayerRef}; + +use super::super::data::effects::{BuffEffect, HealEffect}; +use super::super::data::misc::AreaShape; +use super::super::data::plots::{PlotEventEffect, PlotNextEvent, PlotNode}; +use super::super::data::{BuffTemplate, SkillTemplate}; +use super::super::state::SkillRun; +use super::super::types::{SkillCastTarget, SkillCaster, SkillHitType, SkillObject}; + +const PLOT: u32 = 1; +const SKILL: u32 = 11939; +const DAMAGE: u32 = 3172; +const DAMAGE_EVENT: u32 = 2723; +const RESET_EVENT: u32 = 246; +const UNFLAGGED_EVENT: u32 = 900_001; +const OTHER_FLAGGED_EVENT: u32 = 900_002; +const NON_DAMAGE_EVENT: u32 = 900_003; +const HP: i32 = 100_000; + +fn plot_effect(actual_type: &str, actual_id: u32) -> PlotEventEffect { + PlotEventEffect { + position: 1, + source_id: 1, + target_id: 4, + actual_id, + actual_type: actual_type.into(), + } +} + +fn event(id: u32, diminishing: bool, effects: Vec) -> PlotEventTemplate { + PlotEventTemplate { + id, + plot_id: PLOT, + position: 1, + source_update_method_id: 1, + target_update_method_id: 4, + aoe_diminishing: diminishing, + effects, + ..Default::default() + } +} + +fn data() -> GameData { + let mut data = GameData::empty(); + data.formulas = crate::systems::vehicles::stats::tests::formulas( + &[(1, "100000", 14, 5), (2, "1000", 15, 5)], + &[], + ); + for id in [3, 4] { + data.factions.add(SystemFaction { + id, + ..Default::default() + }); + } + let skills = &mut data.systems.skills; + skills.plots.aoe_diminishings = [ + (1, 100.0), + (2, 90.0), + (3, 80.0), + (4, 70.0), + (5, 55.0), + (6, 40.0), + (7, 25.0), + (8, 10.0), + (9, 10.0), + (10, 10.0), + ] + .into(); + skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(super::super::tests::damage_effect(DAMAGE, 1000))), + 1, + ); + skills.add_effect( + EffectKind::ResetAoeDiminishingEffect, + EffectTemplate::ResetAoeDiminishing { id: 2 }, + 2, + ); + for (id, diminishing) in [ + (DAMAGE_EVENT, true), + (UNFLAGGED_EVENT, false), + (OTHER_FLAGGED_EVENT, true), + ] { + skills.plots.events.insert( + id, + event(id, diminishing, vec![plot_effect("DamageEffect", DAMAGE)]), + ); + } + // Native plot_effects row 5680: event 246, descriptor 2, source 1, target 3. + let mut reset = plot_effect("ResetAoeDiminishingEffect", 2); + reset.target_id = 3; + skills + .plots + .events + .insert(RESET_EVENT, event(RESET_EVENT, false, vec![reset])); + data +} + +fn fixture(data: GameData, count: u32) -> (Arc, TestClient, PlayerRef, Vec) { + let (server, client, player, _) = super::super::cast_validation_tests::fixture(data); + player.data().unit.faction_id = 4; + let targets = (0..count) + .map(|i| { + let mut npc = Npc::new(1); + npc.unit.hp = HP; + npc.unit.max_hp = HP; + npc.unit.faction_id = 3; + npc.unit + .transform + .set_xyz(100.0 + i as f32 * 0.01, 100.0, 100.0); + let npc = Entity::new(0x300 + i, npc); + server + .world + .world(0) + .unwrap() + .spawn(&npc, &server.view_ctx()); + npc + }) + .collect(); + (server, client, player, targets) +} + +fn state(caster: &WorldObject, target: &NpcRef, skill: Option) -> Arc { + let skill = skill.unwrap_or_else(|| { + SkillRun::new( + Arc::new(SkillTemplate { + plot_id: Some(PLOT), + plot_only: true, + target_alive: true, + target_relation: 4, + ..super::super::tests::skill_template(SKILL) + }), + 1, + ) + }); + PlotState::new( + skill, + CastCtx { + caster: caster.clone(), + caster_caster: SkillCaster::Unit(caster.obj_id()), + target: Target::Obj(WorldObject::from(target)), + target_caster: SkillCastTarget::Unit(target.obj_id), + skill_object: SkillObject::None, + }, + ) +} + +fn node(event_id: u32) -> PlotNode { + PlotNode { + event_id, + parent: None, + parent_next_event: None, + children: vec![], + } +} + +/// Real PlotNode -> apply_plot_effect -> effect dispatch -> damage/heal/buff execution. +fn fire(server: &GameServer, state: &Arc, event_id: u32, targets: &[NpcRef]) { + let mut ti = PlotTargetInfo::new( + Some(Target::Obj(state.caster().clone())), + Some(Target::Obj(WorldObject::from(&targets[0]))), + ); + ti.effected = targets + .iter() + .map(|t| Target::Obj(WorldObject::from(t))) + .collect(); + execute_node( + server, + &PlotTree { + plot_id: PLOT, + nodes: vec![node(event_id)], + }, + 0, + state, + &ti, + ); +} + +fn damage( + server: &GameServer, + state: &Arc, + event_id: u32, + targets: &[NpcRef], +) -> Vec { + let before: Vec<_> = targets.iter().map(|t| t.data().unit.hp).collect(); + fire(server, state, event_id, targets); + before + .into_iter() + .zip(targets) + .map(|(hp, t)| hp - t.data().unit.hp) + .collect() +} + +#[tokio::test] +async fn aoe_policy_plot_damage_targets_one_through_twelve_and_reuses_floor_targets() { + let (server, _client, player, targets) = fixture(data(), 12); + let state = state(&WorldObject::from(&player), &targets[0], None); + assert_eq!( + damage(&server, &state, DAMAGE_EVENT, &targets), + [1000, 900, 800, 700, 550, 400, 250, 100, 100, 100, 100, 100] + ); + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 10); + // Stored early identities retain their rank, and unstored late identities retain the floor. + let reverse: Vec<_> = targets.into_iter().rev().collect(); + assert_eq!( + damage(&server, &state, OTHER_FLAGGED_EVENT, &reverse), + [100, 100, 100, 100, 100, 250, 400, 550, 700, 800, 900, 1000] + ); + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 10); +} + +#[tokio::test] +async fn aoe_policy_unflagged_damage_neither_diminishes_nor_consumes_a_rank() { + let (server, _client, player, targets) = fixture(data(), 3); + let state = state(&WorldObject::from(&player), &targets[0], None); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets[..1]), [1000]); + assert_eq!( + damage(&server, &state, UNFLAGGED_EVENT, &targets[1..]), + [1000, 1000] + ); + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 1); + assert_eq!( + damage(&server, &state, OTHER_FLAGGED_EVENT, &targets[2..]), + [900] + ); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets[..1]), [1000]); +} + +#[tokio::test] +async fn aoe_policy_reset_is_local_to_plot_even_with_reused_skill_and_other_casters() { + let (server, _client, player, targets) = fixture(data(), 4); + let caster = WorldObject::from(&player); + let first = state(&caster, &targets[0], None); + // Deliberately reuse the same SkillRun across two plot instances: context must remain explicit. + let second = state(&caster, &targets[0], Some(first.skill.clone())); + let other = state(&WorldObject::from(&targets[3]), &targets[0], None); + assert_eq!( + damage(&server, &first, DAMAGE_EVENT, &targets[..2]), + [1000, 900] + ); + assert_eq!( + damage(&server, &second, DAMAGE_EVENT, &targets[..2]), + [1000, 900] + ); + // This caster has no faction, so the ordinary can_attack null-faction rule permits the hit. + targets[3].data().unit.faction_id = 0; + assert_eq!(damage(&server, &other, DAMAGE_EVENT, &targets[..1]), [1000]); + fire(&server, &first, RESET_EVENT, &targets[..1]); + assert!(first.inner().aoe_diminishing_ranks.is_empty()); + assert_eq!(second.inner().aoe_diminishing_ranks.len(), 2); + assert_eq!(other.inner().aoe_diminishing_ranks.len(), 1); + assert_eq!( + damage(&server, &first, DAMAGE_EVENT, &targets[2..3]), + [1000] + ); + assert_eq!( + damage(&server, &second, DAMAGE_EVENT, &targets[2..3]), + [800] + ); + assert_eq!(damage(&server, &other, DAMAGE_EVENT, &targets[1..2]), [900]); + let weak = Arc::downgrade(&first); + drop(first); + assert!( + weak.upgrade().is_none(), + "no plot context may be retained in its SkillRun or caster" + ); + let fresh = state(&caster, &targets[0], Some(second.skill.clone())); + assert_eq!( + damage(&server, &fresh, DAMAGE_EVENT, &targets[2..3]), + [1000] + ); +} + +#[tokio::test] +async fn aoe_policy_repeat_waves_reuse_ranks_until_authored_reset_effect() { + let (server, _client, player, targets) = fixture(data(), 3); + let state = state(&WorldObject::from(&player), &targets[0], None); + for wave in 0..3 { + let mut order = targets.clone(); + order.rotate_left(wave); + assert_eq!( + damage(&server, &state, DAMAGE_EVENT, &order[..2]), + [1000, 900] + ); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &order[2..]), [800]); + assert_eq!( + damage(&server, &state, OTHER_FLAGGED_EVENT, &order[..2]), + [1000, 900] + ); + fire(&server, &state, RESET_EVENT, &targets[..1]); + assert!(state.inner().aoe_diminishing_ranks.is_empty()); + } +} + +fn next(id: u32, event_id: u32, per_target: bool, delay: i32, speed: i32) -> PlotNextEvent { + PlotNextEvent { + id, + event_id, + position: 1, + per_target, + delay, + speed, + casting: false, + channeling: false, + casting_inc: 0, + add_anim_cs_time: false, + casting_delayable: false, + casting_cancelable: false, + cancel_on_big_hit: false, + use_exe_time: false, + fail: false, + } +} + +#[tokio::test] +async fn aoe_policy_queued_per_target_projectiles_share_one_plot_wave() { + let mut data = data(); + data.systems.skills.area_shapes.insert( + 1, + AreaShape { + id: 1, + kind: 1, + value1: 10.0, + value2: 0.0, + value3: 0.0, + }, + ); + let mut area = event(3, false, vec![]); + area.target_update_method_id = 5; + area.target_update_method_params = [1, 12, 0, 0, 0, 0, 0, 4, 2]; + // Actual Searing Rain fan-out: next 3195, event 3 -> 2723, per_target, speed 20. + // Targets are within 11cm of the caster to keep real projectile delays short. + area.next_events.push(next(3195, DAMAGE_EVENT, true, 0, 20)); + data.systems.skills.plots.events.insert(3, area); + let mut root = node(3); + root.children = vec![1]; + let mut child = node(DAMAGE_EVENT); + child.parent = Some(0); + child.parent_next_event = Some((3, 0)); + data.systems.skills.plots.trees.insert( + PLOT, + PlotTree { + plot_id: PLOT, + nodes: vec![root, child], + }, + ); + let (server, _client, player, targets) = fixture(data, 12); + let state = state(&WorldObject::from(&player), &targets[0], None); + execute_tree(&server, PLOT, &state).await; + // World iteration decides which target is first. Do not impose a new sort on production. + let mut dealt: Vec<_> = targets.iter().map(|t| HP - t.data().unit.hp).collect(); + dealt.sort_unstable(); + assert_eq!( + dealt, + [100, 100, 100, 100, 100, 250, 400, 550, 700, 800, 900, 1000] + ); + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 10); + assert_eq!(state.inner().tickets[&DAMAGE_EVENT], 12); +} + +#[tokio::test] +async fn aoe_policy_misses_and_immunity_occupy_and_reuse_ranks() { + let mut data = data(); + data.systems.skills.add_buff(BuffTemplate { + id: 900, + kind: 1, + stack_rule: 1, + melee_immune: true, + ..Default::default() + }); + let (server, _client, player, targets) = fixture(data, 3); + let caster = WorldObject::from(&player); + let state = state(&caster, &targets[0], None); + state + .skill + .state() + .hit_types + .insert(targets[0].obj_id, SkillHitType::MeleeMiss); + super::super::buffs::apply_template( + &server, + server.game_data.systems.skills.buff(900).unwrap(), + Some(&caster), + &SkillCaster::Unit(player.obj_id), + &WorldObject::from(&targets[1]), + None, + ); + assert!(super::super::buffs::check_damage_immune( + &server, + &WorldObject::from(&targets[1]), + Some(super::super::types::DamageType::Melee), + )); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets), [0, 0, 800]); + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 3); + state + .skill + .state() + .hit_types + .insert(targets[0].obj_id, SkillHitType::MeleeHit); + super::super::buffs::remove_buff(&server, &WorldObject::from(&targets[1]), 900); + assert_eq!( + damage(&server, &state, OTHER_FLAGGED_EVENT, &targets[..2]), + [1000, 900] + ); +} + +#[tokio::test] +async fn aoe_policy_flagged_heals_and_buffs_do_not_consume_ranks_or_scale() { + let mut data = data(); + let skills = &mut data.systems.skills; + skills.add_buff(BuffTemplate { + id: 901, + kind: 2, + stack_rule: 1, + stun: true, + ..Default::default() + }); + skills.buff_tags.insert(901, vec![6]); // Native 1.2 Stun tag. + skills.add_effect( + EffectKind::BuffEffect, + EffectTemplate::Buff(BuffEffect { + id: 8, + buff_id: Some(901), + chance: 100, + stack: 1, + ab_level: 1, + }), + 8, + ); + skills.add_effect( + EffectKind::HealEffect, + EffectTemplate::Heal(HealEffect { + id: 9, + use_fixed_heal: true, + fixed_min: 1000, + fixed_max: 1000, + use_level_heal: false, + level_md: 0.0, + level_va_start: 0, + level_va_end: 0, + percent: false, + use_charged_buff: false, + charged_buff_id: 0, + charged_mul: 0.0, + slave_applicable: false, + ignore_heal_aggro: true, + dps_multiplier: 0.0, + actability_group_id: 0, + actability_step: 0, + actability_mul: 0.0, + actability_add: 0.0, + }), + 9, + ); + skills.plots.events.insert( + NON_DAMAGE_EVENT, + event( + NON_DAMAGE_EVENT, + true, + vec![plot_effect("HealEffect", 9), plot_effect("BuffEffect", 8)], + ), + ); + let (server, _client, player, targets) = fixture(data, 3); + let state = state(&WorldObject::from(&player), &targets[0], None); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets[..1]), [1000]); + for target in &targets { + target.data().unit.hp = 50_000; + } + fire(&server, &state, NON_DAMAGE_EVENT, &targets); + for target in &targets { + let unit = &target.data().unit; + assert_eq!(unit.hp, 51_000); + assert!(unit.buffs.check_buff(901)); + } + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 1); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets[2..]), [900]); +} + +fn add_bonus(unit: &mut crate::models::unit::UnitBase, attribute: UnitAttribute, value: i32) { + unit.bonuses.add_bonus( + 999, + Bonus { + template: BonusTemplate { + attribute, + modifier_type: UnitModifierType::Value, + value, + linear_level_bonus: 0, + }, + value, + }, + ); +} + +struct Armored; + +impl super::super::ext::NpcSkillHooks for Armored { + fn npc_attribute(&self, _: &GameServer, _: &Npc, attr: StatKind) -> Option { + // Exercise the real damage reduction without requiring NPC reference-data loaders. + (attr == StatKind::Armor).then_some(5300.0) + } +} + +#[tokio::test] +async fn aoe_policy_late_fractional_rate_preserves_physical_fixed_and_modifier_order() { + let mut data = data(); + data.systems.skills.plots.aoe_diminishings.insert(2, 77.5); + let mut physical = super::super::tests::damage_effect(10, 0); + physical.use_fixed_damage = false; + physical.use_mainhand_weapon = true; + physical.dps_multiplier = 1.0; + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(physical)), + 10, + ); + data.systems.skills.plots.events.insert( + OTHER_FLAGGED_EVENT, + event( + OTHER_FLAGGED_EVENT, + true, + vec![plot_effect("DamageEffect", 10)], + ), + ); + let (server, _client, player, targets) = fixture(data, 2); + server.systems.skills.ext.npcs.install(Arc::new(Armored)); + { + let unit = &mut player.data().unit; + // Exactly one DPS avoids random floor/ceil widening in the weapon-damage base. + add_bonus(unit, UnitAttribute::MainhandDps, 1000); + unit.skill_modifiers.add_modifiers(&[SkillModifier { + id: 1, + owner_id: 1, + tag_id: 0, + skill_attribute: SkillAttribute::Damage, + unit_modifier_type: UnitModifierType::Value, + value: 109, + skill_id: SKILL, + synergy: false, + }]); + } + let state = state(&WorldObject::from(&player), &targets[0], None); + // Physical 1 -> skill modifier +109 -> armor 55 -> authored target-2 rate 77.5% -> 42. + assert_eq!( + damage(&server, &state, OTHER_FLAGGED_EVENT, &targets), + [55, 42] + ); + // Fixed 1000 still replaces skill-modified base damage before the existing armor reduction. + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets), [500, 387]); + assert_eq!( + damage(&server, &state, UNFLAGGED_EVENT, &targets), + [500, 500] + ); +} + +#[tokio::test] +async fn aoe_policy_minimum_applies_after_integer_damage_truncation_and_never_heals() { + let mut data = data(); + let mut tiny = super::super::tests::damage_effect(DAMAGE, 7); + tiny.health_steal_ratio = 100; + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(tiny)), + 1, + ); + data.systems.skills.plots.aoe_diminishings.insert(2, 90.0); + data.systems.skills.plots.aoe_diminishings.insert(3, -100.0); + let (server, _client, player, targets) = fixture(data, 3); + server.systems.skills.ext.npcs.install(Arc::new(Armored)); + let state = state(&WorldObject::from(&player), &targets[0], None); + // Armor leaves 3.5 -> integer 3, then rank-2 90% -> 2. Multiplying before that + // first truncation would incorrectly produce 3. A negative authored rate cannot heal. + player.data().unit.hp = 100; + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets), [3, 2, 1]); + assert_eq!(player.data().unit.hp, 106); +} + +#[tokio::test] +async fn aoe_policy_negative_damage_cannot_raise_target_health() { + let mut data = data(); + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(super::super::tests::damage_effect(DAMAGE, -10))), + 1, + ); + let (server, _client, player, targets) = fixture(data, 1); + let state = state(&WorldObject::from(&player), &targets[0], None); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets), [1]); +} + +#[tokio::test] +async fn aoe_policy_rank_storage_is_bounded_and_missing_table_retains_no_state() { + let (server, _client, player, targets) = fixture(data(), 1); + let state = state(&WorldObject::from(&player), &targets[0], None); + let rates = &server.game_data.systems.skills.plots.aoe_diminishings; + for id in 1..=10_000 { + state.aoe_damage_multiplier(rates, id); + } + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 10); + assert_eq!(state.aoe_damage_multiplier(rates, 1), 1.0); + assert_eq!(state.aoe_damage_multiplier(rates, 10_000), 0.1); + fire(&server, &state, RESET_EVENT, &targets); + assert!(state.inner().aoe_diminishing_ranks.is_empty()); + assert_eq!(state.aoe_damage_multiplier(&HashMap::new(), 1), 1.0); + assert!(state.inner().aoe_diminishing_ranks.is_empty()); +} diff --git a/rust/crates/aaemu-game/src/systems/skills/plots.rs b/rust/crates/aaemu-game/src/systems/skills/plots.rs index e215439f35..68f0c786a0 100644 --- a/rust/crates/aaemu-game/src/systems/skills/plots.rs +++ b/rust/crates/aaemu-game/src/systems/skills/plots.rs @@ -28,6 +28,10 @@ use super::state::{PlotStateRef, SkillRef}; use super::stats::{stat, StatKind}; use super::types::{tags, CastAction, PlotObject, RelationState, SkillTargetRelation}; +#[cfg(test)] +#[path = "plot_aoe_tests.rs"] +mod aoe_tests; + /// The mutable part of `PlotState`. #[derive(Debug, Default)] pub struct PlotStateInner { @@ -40,6 +44,9 @@ pub struct PlotStateInner { pub channeled_buffs: Vec<(WorldObject, u32)>, /// `HitObjects` (event id -> obj ids). pub hit_objects: HashMap>, + /// Compatibility policy: first-seen distinct targets in this plot's current AoE wave. + /// Retain only the first authored maximum rank; later targets all use the final rate. + aoe_diminishing_ranks: HashMap, } /// `PlotState`. @@ -92,6 +99,33 @@ impl PlotState { pub fn caster(&self) -> &WorldObject { &self.ctx.caster } + + /// Server compatibility policy, not a recovered retail counter (see PORTING.md). + /// Called before damage hit resolution, including miss/immunity checks. Sibling + /// projectiles share this plot instance; repeat hits reuse their target's wave rank. + pub(super) fn aoe_damage_multiplier(&self, rates: &HashMap, target_id: u32) -> f32 { + let Some(last_rank) = rates.keys().copied().max().filter(|&rank| rank > 0) else { + return 1.0; + }; + let mut inner = self.inner(); + let ranks = &mut inner.aoe_diminishing_ranks; + let rank = if let Some(&rank) = ranks.get(&target_id) { + rank + } else if ranks.len() < last_rank as usize { + let rank = ranks.len() as u32 + 1; + ranks.insert(target_id, rank); + rank + } else { + // No need to retain more identities: every subsequent target, including + // repeat hits on one of those targets, receives the same final rate. + last_rank + }; + rates.get(&rank).copied().unwrap_or(100.0).max(0.0) / 100.0 + } + + pub(super) fn reset_aoe_diminishing(&self) { + self.inner().aoe_diminishing_ranks.clear(); + } } /// `PlotTargetInfo`. @@ -1154,7 +1188,7 @@ fn apply_plot_effect( source: EffectSource::from_skill(state.skill.clone()), skill_object: &state.ctx.skill_object, }; - effects::apply(server, kind, template, &args, None); + effects::apply_plot(server, kind, template, &args, state, event.aoe_diminishing); } } From 8fe6039ee99476591ec43a5c0f513fd05e25d658 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:17:46 -0400 Subject: [PATCH 21/66] fix(game): guard buff starts against synchronous removal Keep an insertion identity across refreshes and stop Started continuation after nested removal or index replacement. Scope trigger subscriptions and breaker cleanup to that lifetime while retaining synchronous trigger order and deferred CREATED exits. Add actual Started-effect, self-dispel, mutual-breaker, replacement-callback and accepted-refresh regressions. Document immediate reconciliation as server compatibility policy; native consumer timing remains unproven. Validation: standalone rustfmt check and git diff --check passed. Cargo, builds, tests, Clippy and live checks are deferred to the parent because the worker build slot is not released. Co-Authored-By: OpenAI Codex --- rust/crates/aaemu-game/src/models/buff.rs | 15 + .../src/systems/skills/buff_breaker_tests.rs | 729 +++++++++++++++++- .../aaemu-game/src/systems/skills/buffs.rs | 89 ++- 3 files changed, 812 insertions(+), 21 deletions(-) diff --git a/rust/crates/aaemu-game/src/models/buff.rs b/rust/crates/aaemu-game/src/models/buff.rs index 8421e351ec..2138a98e63 100644 --- a/rust/crates/aaemu-game/src/models/buff.rs +++ b/rust/crates/aaemu-game/src/models/buff.rs @@ -10,6 +10,8 @@ //! counters, triggers, `TriggerRemoveOn`, tag checks, modifier-cache updates, //! `SCBuffCreatedPacket` broadcasts) is `systems::skills::buffs`. +use std::sync::atomic::{AtomicU64, Ordering}; + use aaemu_commons::PacketStream; use crate::data::skills::{save_rule, stack_rule, BuffKind, BuffTemplate}; @@ -23,6 +25,8 @@ const MINIMUM_BUFF_DURATION_TO_SAVE: i32 = 60_000; /// `BuffConstants.LoggedOn`. pub const BUFF_LOGGED_ON: u32 = 2423; +static NEXT_BUFF_INSTANCE: AtomicU64 = AtomicU64::new(1); + /// `SkillCaster` as written by `SkillCaster.Write` (type + bc obj id). Only `SkillCasterUnit` /// is used by this phase. #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] @@ -35,6 +39,9 @@ pub struct SkillCaster { #[derive(Debug, Clone, PartialEq)] pub struct Buff { pub index: u32, + /// Internal lifetime identity. Explicit/wrapped indices can be reused; refreshes keep + /// this identity. Not serialized or persisted, and assigned only on insertion. + pub(crate) instance_id: u64, pub template: BuffTemplate, pub skill_caster: SkillCaster, /// `Caster?.Id` / `Caster?.Level` (`None` = no caster unit). @@ -87,6 +94,7 @@ impl Buff { ) -> Self { Self { index: 0, + instance_id: 0, template, skill_caster, caster, @@ -109,6 +117,12 @@ impl Buff { } } + /// Whether a queued event / callback still refers to this inserted effect. A clone + /// retains its identity, whereas reinserting even that clone starts a new lifetime. + pub fn same_instance(&self, other: &Buff) -> bool { + self.instance_id != 0 && self.index == other.index && self.instance_id == other.instance_id + } + /// `GetTimeLeft` (-1 for a permanent buff). pub fn time_left(&self, now_ms: i64) -> f64 { if self.duration == 0 { @@ -412,6 +426,7 @@ impl Buffs { .push(BuffEvent::Refreshed(self.effects[i].clone())); } None => { + buff.instance_id = NEXT_BUFF_INSTANCE.fetch_add(1, Ordering::Relaxed); buff.tick = buff.template.tick; buff.in_use = true; self.events.push(BuffEvent::Started(buff.clone())); diff --git a/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs b/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs index e18dcce19f..135983a42f 100644 --- a/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs @@ -4,27 +4,34 @@ //! Relation loaders: native 1.2 395D17B0 (x2game12.c:1256462-1256496), 10.x 39B41DE0 //! (x2game-dev_dedicate.c:2323838-2323904). Those prove ownership/direction only. Traced //! 10.x ZoneBuffMan::Create 39450740 and its tick 3944FC90 do not establish a breaker-set -//! consumer; immediate reconciliation below is an explicit implementation choice pending -//! native timing evidence, not a claim of native timing parity. +//! consumer. Immediate accepted-state reconciliation is the server compatibility policy; +//! exact retail apply-vs-tick timing remains a native-parity limitation. use std::sync::Arc; use std::time::Duration; use crate::data::GameData; +use crate::models::buff::Buff; use crate::models::npc::Npc; -use crate::models::unit::{BonusTemplate, UnitAttribute, UnitModifierType}; +use crate::models::unit::{ + BonusTemplate, BuffAttribute, BuffModifier, CombatBuffTemplate, SkillAttribute, SkillModifier, + UnitAttribute, UnitModifierType, +}; use crate::opcodes::sc; use crate::server::GameServer; use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; -use crate::world::{now_ms, Entity, WorldObject}; +use crate::world::{now_ms, Entity, MateRef, WorldObject}; use super::super::controllers::{self, ScState}; -use super::super::data::effects::BuffEffect; +use super::super::data::effects::{BuffEffect, DispelEffect}; use super::super::data::{ - BuffTemplate, BuffTolerance, EffectKind, EffectTemplate, SkillTemplate, TickEffect, + BuffTemplate, BuffTolerance, BuffTriggerTemplate, EffectKind, EffectTemplate, SkillTemplate, + TickEffect, +}; +use super::super::state::{ + CancelToken, SkillRef, SkillRun, SkillTaskKind, SkillTaskSlot, ToleranceCounter, }; -use super::super::state::{CancelToken, SkillRun, SkillTaskKind, SkillTaskSlot, ToleranceCounter}; -use super::super::types::SkillCaster; +use super::super::types::{BuffEventTriggerKind, SkillCaster}; const SONGS: [u32; 4] = [656, 662, 667, 778]; const GLIDER: u32 = 1029; @@ -33,6 +40,11 @@ const SLEEP: u32 = 84; // Leech: Sleep tag 97, despite its stun flag in the expo const SILENCE: u32 = 245; const IRRELEVANT: u32 = 60_001; const IMMUNITY: u32 = 60_002; +const ORIGINAL_TAG: u32 = 60_030; +const MARKER: u32 = 60_031; +const MARKER_TAG: u32 = 60_032; +const TRIGGER_EFFECT: u32 = 60_033; +const MODIFIER_TARGET: u32 = 60_034; fn data() -> GameData { let mut data = GameData::empty(); @@ -132,6 +144,309 @@ fn removed(client: &mut TestClient) -> Vec> { .collect() } +// Unit-caster Created prefix from native 397CA670 -> 397C85B0 / 397C9070: +// caster kind+bc, caster DB id, owner bc, index u32, buff id u32. Removed: owner bc,index. +// Read the emitted notices; expected IDs/order below are independent literals. +fn notices(client: &mut TestClient) -> Vec<(u16, u32, u32)> { + client + .drain() + .into_iter() + .filter_map(|(op, body)| { + if op == sc::SCBuffCreatedPacket { + assert_eq!(body[0], 0, "fixture uses unit casters"); + Some(( + op, + u32::from_le_bytes(body[15..19].try_into().unwrap()), + u32::from_le_bytes(body[11..15].try_into().unwrap()), + )) + } else if op == sc::SCBuffRemovedPacket { + assert_eq!(body.len(), 7); + Some((op, 0, u32::from_le_bytes(body[3..7].try_into().unwrap()))) + } else { + None + } + }) + .collect() +} + +fn trigger(d: &mut GameData, kind: BuffEventTriggerKind, effect: (EffectKind, u32), no_tag: u32) { + d.systems + .skills + .buff_triggers + .entry(SONGS[0]) + .or_default() + .push(BuffTriggerTemplate { + id: effect.1, + kind: kind as u16, + effect_on_source: false, + effect, + use_damage_amount: false, + use_original_source: false, + target_buff_tag_id: 0, + target_no_buff_tag_id: no_tag, + synergy: false, + }); +} + +fn trigger_buff( + d: &mut GameData, + kind: BuffEventTriggerKind, + effect_id: u32, + buff_id: u32, + no_tag: u32, +) { + d.systems.skills.add_effect( + EffectKind::BuffEffect, + EffectTemplate::Buff(BuffEffect { + id: effect_id, + buff_id: Some(buff_id), + chance: 100, + stack: 1, + ab_level: 0, + }), + 0, + ); + trigger(d, kind, (EffectKind::BuffEffect, effect_id), no_tag); +} + +fn reentrant_data() -> GameData { + let mut d = data(); + let skills = &mut d.systems.skills; + let original = Arc::make_mut(skills.buffs.get_mut(&SONGS[0]).unwrap()); + original.stun = true; // Would unmount/interrupt if the removed Started hook resumed. + original.gliding = true; // Would start a controller for non-character owners. + original.tick = 10.0; + original.tick_effects = vec![TickEffect { + effect_id: TRIGGER_EFFECT + 1, + target_buff_tag_id: 0, + target_no_buff_tag_id: 0, + }]; + skills.add_effect( + EffectKind::BuffEffect, + EffectTemplate::Buff(BuffEffect { + id: TRIGGER_EFFECT + 1, + buff_id: Some(MARKER), + chance: 100, + stack: 1, + ab_level: 0, + }), + TRIGGER_EFFECT + 1, + ); + Arc::make_mut(skills.buffs.get_mut(&IRRELEVANT).unwrap()).stun = false; + skills.buff_tags.insert(IRRELEVANT, vec![6]); + skills.tagged_buffs.insert(6, vec![STUN, IRRELEVANT]); + skills.buff_tags.insert(SONGS[0], vec![ORIGINAL_TAG]); + skills.tagged_buffs.insert(ORIGINAL_TAG, vec![SONGS[0]]); + skills.add_buff(BuffTemplate { + id: MARKER, + kind: 1, + ..Default::default() + }); + skills.buff_tags.insert(MARKER, vec![MARKER_TAG]); + skills.tagged_buffs.insert(MARKER_TAG, vec![MARKER]); + skills.skill_modifiers.insert( + SONGS[0], + vec![SkillModifier { + id: MODIFIER_TARGET, + owner_id: SONGS[0], + tag_id: 0, + skill_attribute: SkillAttribute::CastTime, + unit_modifier_type: UnitModifierType::Value, + value: 17, + skill_id: MODIFIER_TARGET, + synergy: false, + }], + ); + skills.buff_game_data.buff_modifiers.insert( + SONGS[0], + vec![BuffModifier { + id: MODIFIER_TARGET, + owner_id: SONGS[0], + tag_id: 0, + buff_attribute: BuffAttribute::Duration, + unit_modifier_type: UnitModifierType::Value, + value: 23, + buff_id: MODIFIER_TARGET, + synergy: false, + }], + ); + skills.combat_buffs.insert( + SONGS[0], + vec![CombatBuffTemplate { + id: MODIFIER_TARGET, + hit_skill_id: 0, + hit_type: 1, + req_skill_id: 0, + buff_id: MARKER, + buff_from_source: false, + buff_to_source: false, + req_buff_id: SONGS[0], + is_heal_spell: false, + }], + ); + trigger_buff( + &mut d, + BuffEventTriggerKind::Started, + TRIGGER_EFFECT, + IRRELEVANT, + MARKER_TAG, + ); + d +} + +fn channel(server: &GameServer, owner: &WorldObject, matching: bool) -> (SkillRef, CancelToken) { + let skill = SkillRun::new( + Arc::new(SkillTemplate { + id: MODIFIER_TARGET, + channeling_buff_id: if matching { + SONGS[0] + } else { + MODIFIER_TARGET + 1 + }, + channeling_time: 30_000, + ..Default::default() + }), + 1, + ); + skill.state().tl_id = server + .systems + .skills + .tl_ids + .next_id(owner.obj_id(), skill.template.id); + let cancel = CancelToken::new(); + owner.with_unit(|u| { + u.unit_mut().skill_state.skill_task = Some(SkillTaskSlot { + kind: SkillTaskKind::EndChanneling { channel_doodad: 0 }, + skill: skill.clone(), + cancel: cancel.clone(), + }); + }); + (skill, cancel) +} + +fn queue_original(server: &GameServer, owner: &WorldObject, skill: Option<&SkillRef>) -> Buff { + let template = server.game_data.systems.skills.buff(SONGS[0]).unwrap(); + let mut b = super::new_buff( + server, + template, + Some(owner), + &SkillCaster::Unit(owner.obj_id()), + skill.map(|s| s.as_ref()), + now_ms(), + ); + b.duration = template.duration; + owner.with_base_unit(|u| u.buffs_mut().add_buff_with_duration(b, 0, now_ms())); + super::get_buff(owner, 2).unwrap() +} + +fn assert_no_original_state(server: &GameServer, owner: &WorldObject, original: &Buff) { + assert!(!has(owner, SONGS[0])); + assert!(!super::check_buff_tag(server, owner, ORIGINAL_TAG)); + assert!(controllers::active(owner).is_none()); + assert!(!owner.with_base_unit(|u| u.buffs().has_events())); + let (skill_mod, buff_mod, bonus, combat) = owner + .with_unit(|u| { + let u = u.unit(); + ( + u.skill_modifiers + .apply(MODIFIER_TARGET, &[], SkillAttribute::CastTime, 0.0), + u.buff_modifiers + .apply(MODIFIER_TARGET, &[], BuffAttribute::Duration, 0.0), + u.bonuses.calculate(0.0, UnitAttribute::Str, now_ms()), + u.combat_buffs + .by_hit_type + .values() + .map(Vec::len) + .sum::(), + ) + }) + .unwrap(); + assert_eq!((skill_mod, buff_mod, bonus, combat), (0.0, 0.0, 0.0, 0)); + assert!(!server + .systems + .skills + .triggers + .lock() + .unwrap() + .iter() + .any(|s| { s.owner_obj == owner.obj_id() && s.buff_instance_id == original.instance_id })); + super::dispel_task(server, owner.obj_id(), original.index, original.task_gen); + assert!(!has(owner, SONGS[0])); +} + +fn npc_owner(server: &GameServer) -> WorldObject { + let mut npc = Npc::new(1); + npc.unit.hp = 100; + npc.unit.max_hp = 100; + npc.unit.transform.set_xyz(100.0, 100.0, 100.0); + let owner = WorldObject::from(Entity::new(0x400, npc)); + server + .world + .world(0) + .unwrap() + .spawn(&owner, &server.view_ctx()); + owner +} + +fn mount_data(d: &mut GameData) { + use crate::data::items::{ItemTemplate, TemplateKind}; + use crate::systems::npcs::npc::data::NpcTemplate; + d.experience = crate::test_support::test_experience(55); + d.formulas = crate::systems::vehicles::stats::tests::formulas( + &[(1, "1000", 14, 5), (2, "100", 15, 5)], + &[], + ); + d.systems.npcs.npc.templates.insert( + 60_090, + NpcTemplate { + id: 60_090, + name: "Horse".into(), + level: 1, + model_id: 77, + scale: 1.0, + ..Default::default() + }, + ); + d.items.templates.insert( + 60_091, + ItemTemplate { + kind: TemplateKind::SummonMate { npc_id: 60_090 }, + ..ItemTemplate::plain(60_091, 1) + }, + ); +} + +fn mount(server: &GameServer, owner: &WorldObject) -> MateRef { + use crate::models::container::slot_type; + use crate::models::item::Item; + use crate::systems::vehicles::{data::attach_point, mates}; + let player = owner.as_player().unwrap(); + let template = server.game_data.items.template(60_091).unwrap(); + let mut item = Item::create(0x7001, template, 1, 0, 1, &server.game_data.items, 0); + item.slot_type = slot_type::INVENTORY; + item.slot = 0; + let bag = player + .data() + .inventory + .get(slot_type::INVENTORY) + .cloned() + .unwrap(); + bag.lock().unwrap().items.push(item); + mates::spawn_mount(server, player, 0x7001); + let mate = server + .systems + .vehicles + .mates + .get(0) + .get_active_mates(player.character_id) + .pop() + .unwrap(); + let tl = u32::from(mate.data().unit.tl_id); + mates::mount_mate(server, player, tl, attach_point::DRIVER, 1); + assert!(player.data().is_riding); + mate +} + #[tokio::test] async fn buff_breakers_bard_songs_end_on_real_stun_sleep_and_silence_tags() { for cc in [STUN, SLEEP, SILENCE] { @@ -454,6 +769,404 @@ fn buff_breakers_loader_preserves_direction_and_deduplicates_tags() { assert!(!breakers.contains_key(&6)); } +#[tokio::test] +async fn buff_breakers_started_trigger_cc_does_not_resume_removed_buff_or_disturb_mount() { + use crate::systems::vehicles::data::attach_point; + for matching in [false, true] { + let mut d = reentrant_data(); + mount_data(&mut d); + let (server, mut client, owner) = fixture(d); + let mate = mount(&server, &owner); + // Mount visibility may serialize state buffs. Keep this buff transaction isolated. + owner.with_base_unit(|u| *u.buffs_mut() = Default::default()); + let (skill, cancel) = channel(&server, &owner, matching); + let original = queue_original(&server, &owner, Some(&skill)); + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + assert_no_original_state(&server, &owner, &original); + assert!(has(&owner, IRRELEVANT)); + assert!(!has(&owner, MARKER)); + assert_eq!(cancel.is_cancelled(), matching); + assert_eq!(skill.cancelled(), matching); + assert_eq!(server.systems.skills.tl_ids.in_use(), u32::from(!matching)); + assert_eq!( + owner.with_unit(|u| u.unit().skill_state.skill_task.is_none()), + Some(matching) + ); + let player = owner.as_player().unwrap(); + assert!( + player.data().is_riding, + "removed buff must not reach its unmount step" + ); + assert_eq!(player.data().unit.transform.parent_obj_id, mate.obj_id); + assert_eq!( + mate.data().passenger(attach_point::DRIVER).unwrap().obj_id, + owner.obj_id() + ); + assert_eq!( + notices(&mut client), + vec![ + (sc::SCBuffCreatedPacket, IRRELEVANT, 3), + (sc::SCBuffRemovedPacket, 0, 2), + ] + ); + if !matching { + super::super::skill::stop(&server, &skill, &owner, 0); + } + assert_eq!(server.systems.skills.tl_ids.in_use(), 0); + } +} + +#[tokio::test] +async fn buff_breakers_started_trigger_cc_cleans_npc_controller_and_timer_paths() { + let (server, mut client, _player) = fixture(reentrant_data()); + let owner = npc_owner(&server); + let (skill, cancel) = channel(&server, &owner, true); + let original = queue_original(&server, &owner, Some(&skill)); + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + assert_no_original_state(&server, &owner, &original); + assert!(cancel.is_cancelled()); + assert_eq!(server.systems.skills.tl_ids.in_use(), 0); + assert_eq!( + notices(&mut client), + vec![ + (sc::SCBuffCreatedPacket, IRRELEVANT, 3), + (sc::SCBuffRemovedPacket, 0, 2), + ] + ); + tokio::time::sleep(Duration::from_millis(70)).await; + assert!(!has(&owner, MARKER), "removed tick must not run"); + assert_eq!(owner.transform().z, 100.0); + assert!(controllers::active(&owner).is_none()); + assert!(notices(&mut client).is_empty()); +} + +#[tokio::test] +async fn buff_breakers_started_self_dispel_finishes_even_without_a_breaker_relation() { + let mut d = reentrant_data(); + d.systems.skills.buff_breakers.clear(); + d.systems.skills.buff_triggers.clear(); + // Also cover the permanent/non-ticking start branch, which must not turn a deferred + // explicit exit back into ACTING after its own Started trigger dispels it. + let original = Arc::make_mut(d.systems.skills.buffs.get_mut(&SONGS[0]).unwrap()); + original.kind = 2; // Model the friendly self-cure fixture as a bad buff. + original.duration = 0; + original.tick = 0.0; + original.tick_effects.clear(); + d.systems.skills.add_effect( + EffectKind::DispelEffect, + EffectTemplate::Dispel(DispelEffect { + id: TRIGGER_EFFECT, + dispel_count: 0, + cure_count: 1, + buff_tag_id: ORIGINAL_TAG, + }), + 0, + ); + trigger( + &mut d, + BuffEventTriggerKind::Started, + (EffectKind::DispelEffect, TRIGGER_EFFECT), + 0, + ); + let (server, mut client, owner) = fixture(d); + let (skill, cancel) = channel(&server, &owner, false); + let original = queue_original(&server, &owner, Some(&skill)); + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + assert_no_original_state(&server, &owner, &original); + assert!( + !cancel.is_cancelled(), + "self-dispel must not resume the stun interrupt" + ); + assert!(!has(&owner, IRRELEVANT)); + assert_eq!(notices(&mut client), vec![(sc::SCBuffRemovedPacket, 0, 2)]); + super::super::skill::stop(&server, &skill, &owner, 0); +} + +#[tokio::test] +async fn buff_breakers_started_mutual_breakers_keep_dispelled_callback_and_cleanup_order() { + let mut d = reentrant_data(); + d.systems + .skills + .buff_breakers + .insert(IRRELEVANT, vec![ORIGINAL_TAG]); + Arc::make_mut(d.systems.skills.buffs.get_mut(&IRRELEVANT).unwrap()).gliding = true; + trigger_buff( + &mut d, + BuffEventTriggerKind::Dispelled, + TRIGGER_EFFECT + 2, + MARKER, + 0, + ); + let (server, mut client, _player) = fixture(d); + let owner = npc_owner(&server); + let original = queue_original(&server, &owner, None); + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + assert_no_original_state(&server, &owner, &original); + assert!(!has(&owner, IRRELEVANT)); + assert!( + has(&owner, MARKER), + "Dispelled callback still runs during nested removal" + ); + assert!(!super::check_buff_tag(&server, &owner, 6)); + assert_eq!( + notices(&mut client), + vec![ + (sc::SCBuffCreatedPacket, IRRELEVANT, 3), + (sc::SCBuffCreatedPacket, MARKER, 4), + (sc::SCBuffRemovedPacket, 0, 2), + (sc::SCBuffRemovedPacket, 0, 3), + ] + ); + tokio::time::sleep(Duration::from_millis(70)).await; + assert_eq!(owner.transform().z, 100.0); + assert!(controllers::active(&owner).is_none()); + assert!(notices(&mut client).is_empty()); +} + +#[tokio::test] +async fn buff_breakers_started_channel_callback_reuses_index_without_resuming_old_lifetime() { + let mut d = reentrant_data(); + d.systems + .skills + .buff_breakers + .insert(IRRELEVANT, vec![ORIGINAL_TAG]); + let (server, mut client, owner) = fixture(d); + let (skill, cancel) = channel(&server, &owner, true); + let weak = Arc::downgrade(&server); + let callback_owner = owner.clone(); + *skill.callback.lock().unwrap() = Some(Box::new(move || { + let server = weak.upgrade().unwrap(); + super::remove_buff(&server, &callback_owner, IRRELEVANT); + // Replace the later mutual-breaker candidate at its index too. The outer removal + // snapshot must not remove this new lifetime. Its tag gates the new song's trigger. + let marker = super::new_buff( + &server, + server.game_data.systems.skills.buff(MARKER).unwrap(), + Some(&callback_owner), + &SkillCaster::Unit(callback_owner.obj_id()), + None, + now_ms(), + ); + super::add_buff(&server, &callback_owner, marker, 3, 0); + let t = server.game_data.systems.skills.buff(SONGS[0]).unwrap(); + let b = super::new_buff( + &server, + t, + Some(&callback_owner), + &SkillCaster::Unit(callback_owner.obj_id()), + None, + now_ms(), + ); + super::add_buff(&server, &callback_owner, b, 2, 0); + })); + let original = queue_original(&server, &owner, Some(&skill)); + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + let replacement = super::get_buff(&owner, 2).unwrap(); + assert_eq!(replacement.template.id, original.template.id); + assert!(!replacement.same_instance(&original)); + assert!( + has(&owner, MARKER), + "later candidate's replacement survives" + ); + assert_eq!(replacement.state, crate::models::buff::effect_state::ACTING); + assert_ne!(replacement.task_gen, 0); + assert!(cancel.is_cancelled()); + assert!(owner + .with_unit(|u| u.unit().skill_state.skill_task.is_none()) + .unwrap()); + assert_eq!(server.systems.skills.tl_ids.in_use(), 0); + assert_eq!( + owner.with_unit(|u| ( + u.unit() + .skill_modifiers + .apply(MODIFIER_TARGET, &[], SkillAttribute::CastTime, 0.0), + u.unit() + .buff_modifiers + .apply(MODIFIER_TARGET, &[], BuffAttribute::Duration, 0.0), + u.unit() + .combat_buffs + .by_hit_type + .values() + .map(Vec::len) + .sum::(), + )), + Some((17.0, 23.0, 1)), + "replacement gets exactly one set of modifiers" + ); + let subscriptions: Vec<_> = server + .systems + .skills + .triggers + .lock() + .unwrap() + .iter() + .filter(|s| s.owner_obj == owner.obj_id() && s.buff_index == 2) + .map(|s| s.buff_instance_id) + .collect(); + assert_eq!(subscriptions, vec![replacement.instance_id]); + super::dispel_task(&server, owner.obj_id(), original.index, original.task_gen); + assert!( + has(&owner, SONGS[0]), + "old lifetime's timer cannot remove replacement" + ); + assert_eq!( + notices(&mut client), + vec![ + (sc::SCBuffCreatedPacket, IRRELEVANT, 3), + (sc::SCBuffRemovedPacket, 0, 2), + (sc::SCBuffRemovedPacket, 0, 3), + (sc::SCBuffCreatedPacket, MARKER, 3), + (sc::SCBuffCreatedPacket, SONGS[0], 2), + ] + ); + super::exit(&server, &owner, 2, false); + assert_no_original_state(&server, &owner, &replacement); +} + +#[tokio::test] +async fn buff_breakers_accepted_refresh_reconciles_restored_active_buff_against_cc() { + let mut d = data(); + d.systems.skills.add_buff(BuffTemplate { + id: MARKER, + kind: 1, + ..Default::default() + }); + trigger_buff( + &mut d, + BuffEventTriggerKind::Started, + TRIGGER_EFFECT, + MARKER, + 0, + ); + let (server, mut client, owner) = fixture(d); + let cc = super::new_buff( + &server, + server.game_data.systems.skills.buff(SILENCE).unwrap(), + Some(&owner), + &SkillCaster::Unit(owner.obj_id()), + None, + now_ms(), + ); + super::add_buff(&server, &owner, cc, 99, 0); + // Reconstruct pre-hook/restored state through bookkeeping + lifecycle only. Drain + // Started so this regression can fail independently of Started reconciliation. + let original = queue_original(&server, &owner, None); + owner.with_base_unit(|u| u.buffs_mut().take_events()); + super::schedule_effect(&server, &owner, original.index, false); + let acting = super::get_buff(&owner, original.index).unwrap(); + assert!(acting.in_use && acting.same_instance(&original)); + assert!(!has(&owner, MARKER)); + client.drain(); + add(&server, &owner, SONGS[0]); // REFRESH keeps the index; must still reconcile. + assert!(!has(&owner, SONGS[0])); + assert!( + !has(&owner, MARKER), + "refresh must not fire Started triggers" + ); + assert!(has(&owner, SILENCE)); + assert_eq!( + notices(&mut client), + vec![ + (sc::SCBuffCreatedPacket, SONGS[0], 2), + (sc::SCBuffRemovedPacket, 0, 2), + ] + ); + super::dispel_task(&server, owner.obj_id(), acting.index, acting.task_gen); + assert!(notices(&mut client).is_empty()); +} + +#[tokio::test] +async fn buff_breakers_valid_refresh_keeps_identity_and_single_modifier_set() { + let mut d = reentrant_data(); + d.systems.skills.buff_triggers.clear(); + Arc::make_mut(d.systems.skills.buffs.get_mut(&SONGS[0]).unwrap()).stun = false; + let (server, mut client, owner) = fixture(d); + add(&server, &owner, SONGS[0]); + let original = super::get_buff(&owner, 2).unwrap(); + client.drain(); + super::add_buff_by_id(&server, &owner, SONGS[0], &owner, 30_000); + let refreshed = super::get_buff(&owner, 2).unwrap(); + assert!(refreshed.same_instance(&original)); + assert_ne!(refreshed.task_gen, original.task_gen); + assert_eq!(refreshed.duration, 30_000); + assert_eq!( + owner.with_unit(|u| ( + u.unit() + .skill_modifiers + .apply(MODIFIER_TARGET, &[], SkillAttribute::CastTime, 0.0), + u.unit() + .combat_buffs + .by_hit_type + .values() + .map(Vec::len) + .sum::(), + )), + Some((17.0, 1)) + ); + assert_eq!( + notices(&mut client), + vec![(sc::SCBuffCreatedPacket, SONGS[0], 2)] + ); + super::dispel_task(&server, owner.obj_id(), original.index, original.task_gen); + assert!(has(&owner, SONGS[0])); + super::exit(&server, &owner, 2, false); + assert_no_original_state(&server, &owner, &refreshed); +} + +#[tokio::test] +async fn buff_breakers_started_self_refresh_retains_lifetime_and_installs_modifiers_once() { + let mut d = reentrant_data(); + d.systems.skills.buff_triggers.clear(); + trigger_buff( + &mut d, + BuffEventTriggerKind::Started, + TRIGGER_EFFECT, + SONGS[0], + 0, + ); + let (server, mut client, owner) = fixture(d); + let original = queue_original(&server, &owner, None); + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + let active = super::get_buff(&owner, 2).unwrap(); + assert!(active.same_instance(&original)); + assert_eq!(active.state, crate::models::buff::effect_state::ACTING); + assert_eq!( + owner.with_unit(|u| ( + u.unit() + .skill_modifiers + .apply(MODIFIER_TARGET, &[], SkillAttribute::CastTime, 0.0), + u.unit() + .buff_modifiers + .apply(MODIFIER_TARGET, &[], BuffAttribute::Duration, 0.0), + u.unit() + .combat_buffs + .by_hit_type + .values() + .map(Vec::len) + .sum::(), + u.unit().bonuses.bonuses(UnitAttribute::Str).len(), + )), + Some((17.0, 23.0, 1, 1)) + ); + // Preserve existing order: the nested refresh publishes its update before the outer + // start completes, and both refer to the same effect. No Removed notice is valid. + assert_eq!( + notices(&mut client), + vec![ + (sc::SCBuffCreatedPacket, SONGS[0], 2), + (sc::SCBuffCreatedPacket, SONGS[0], 2), + ] + ); + super::exit(&server, &owner, 2, false); + assert_no_original_state(&server, &owner, &active); +} + #[test] #[ignore = "requires AAEMU_COMPACT_DB (read-only 1.2 compact.sqlite3)"] fn buff_breakers_real_compact_db_song_glider_and_cc_relations() { diff --git a/rust/crates/aaemu-game/src/systems/skills/buffs.rs b/rust/crates/aaemu-game/src/systems/skills/buffs.rs index a8623ec570..6f876d97c4 100644 --- a/rust/crates/aaemu-game/src/systems/skills/buffs.rs +++ b/rust/crates/aaemu-game/src/systems/skills/buffs.rs @@ -159,6 +159,10 @@ pub fn get_buff(owner: &WorldObject, index: u32) -> Option { owner.with_base_unit(|b| b.buffs().effect_by_index(index).cloned()) } +fn current_buff(owner: &WorldObject, expected: &Buff) -> Option { + get_buff(owner, expected.index).filter(|b| b.same_instance(expected)) +} + fn set_buff(owner: &WorldObject, index: u32, f: impl FnOnce(&mut Buff) -> R) -> Option { owner.with_base_unit(|b| b.buffs_mut().effect_by_index_mut(index).map(f)) } @@ -504,7 +508,7 @@ pub fn on_buff_event(server: &GameServer, owner: &WorldObject, event: &BuffEvent match event { BuffEvent::Started(b) | BuffEvent::Refreshed(b) => { // An earlier event in the same batch can already have removed this effect. - if get_buff(owner, b.index).is_none() { + if current_buff(owner, b).is_none() { return; } if matches!(event, BuffEvent::Started(_)) { @@ -520,8 +524,9 @@ pub fn on_buff_event(server: &GameServer, owner: &WorldObject, event: &BuffEvent /// Reconcile authored breaker tags after an accepted start/refresh, including effects /// applied by buff timers. Immunity/requirements/tolerance/stack rejection happens before -/// these events. The native loaders establish the relation's direction; the acceptance -/// boundary here is server policy, not a claimed native apply-vs-tick timing result. +/// these events. Immediate accepted-state reconciliation is the server compatibility +/// policy. The native loaders establish direction, but the available client/zone dumps +/// do not establish an authoritative consumer's apply-vs-tick timing. fn remove_broken_buffs(server: &GameServer, owner: &WorldObject) { let data = &server.game_data.systems.skills; let mut broken: Vec = owner.with_base_unit(|u| { @@ -548,14 +553,10 @@ fn remove_broken_buffs(server: &GameServer, owner: &WorldObject) { // depend on HashMap order, or on callbacks changing the remaining candidates. broken.sort_unstable_by_key(|b| b.index); for b in broken { - exit(server, owner, b.index, false); - // A batch may contain an effect whose Started hook has not run yet. Finish its - // explicit exit now; the stale Started event above must not revive its controller. - if get_buff(owner, b.index).is_some_and(|e| e.state == effect_state::FINISHING) { - schedule_effect(server, owner, b.index, false); + // A preceding removal callback may have replaced a later candidate at its index. + if current_buff(owner, &b).is_none() { + continue; } - // Remove first: stopping a channel can itself remove its channel/toggle buffs. - // Only cancel the channel that owns this buff, outside all object/controller locks. let channel = owner .with_unit(|u| u.unit().skill_state.skill_task.clone()) .flatten() @@ -565,9 +566,29 @@ fn remove_broken_buffs(server: &GameServer, owner: &WorldObject) { && (task.skill.template.channeling_buff_id == b.template.id || task.skill.template.toggle_buff_id == b.template.id) }); + exit(server, owner, b.index, false); + // A batch may contain an effect whose Started hook has not run yet. Finish its + // explicit exit now; the stale Started event above must not revive its controller. + if current_buff(owner, &b).is_some_and(|e| e.state == effect_state::FINISHING) { + schedule_effect(server, owner, b.index, false); + } + // Remove first: stopping a channel can itself remove its channel/toggle buffs. + // Only cancel the channel that owns this buff, outside all object/controller locks. if let Some(task) = channel { - if let super::state::SkillTaskKind::EndChanneling { channel_doodad } = task.kind { - super::skill::stop(server, &task.skill, owner, channel_doodad); + // A removal callback can start a different cast of the same skill. + let still_current = owner + .with_unit(|u| { + u.unit() + .skill_state + .skill_task + .as_ref() + .is_some_and(|live| Arc::ptr_eq(&live.skill, &task.skill)) + }) + .unwrap_or(false); + if still_current { + if let super::state::SkillTaskKind::EndChanneling { channel_doodad } = task.kind { + super::skill::stop(server, &task.skill, owner, channel_doodad); + } } } } @@ -579,6 +600,12 @@ fn on_started(server: &GameServer, owner: &WorldObject, b: &Buff) { // Triggers.SubscribeEvents + Events.OnBuffStarted subscribe_triggers(server, owner, b); fire_buff_trigger(server, owner, b.index, BuffEventTriggerKind::Started); + // Started effects run synchronously and can dispel/end this CREATED buff, apply a + // breaker, or replace it at the same explicit index. Preserve trigger order, but do + // not install modifiers, unmount, interrupt, or start a controller/timer afterwards. + let Some(b) = resume_started_buff(server, owner, b) else { + return; + }; if template.id > 0 { let skill_mods = data.skill_modifiers_by_owner(template.id).to_vec(); let buff_mods = data.buff_modifiers_for_buff(template.id).to_vec(); @@ -596,9 +623,15 @@ fn on_started(server: &GameServer, owner: &WorldObject, b: &Buff) { } } if template.stun || template.silence || template.sleep { + if resume_started_buff(server, owner, &b).is_none() { + return; + } super::skill::interrupt_skills(server, owner); } } + let Some(b) = resume_started_buff(server, owner, &b) else { + return; + }; if b.duration > 0 || !template.tick_effects.is_empty() { // SetInUse(true, false) -> ScheduleEffect(false) schedule_effect(server, owner, b.index, false); @@ -616,10 +649,26 @@ fn on_started(server: &GameServer, owner: &WorldObject, b: &Buff) { } } +/// Finish an explicit exit deferred while the buff was CREATED. The existing queued +/// CREATED removal path still runs Started triggers before reaching this boundary. +fn resume_started_buff(server: &GameServer, owner: &WorldObject, b: &Buff) -> Option { + let live = current_buff(owner, b)?; + if live.is_ended() { + if live.state == effect_state::FINISHING { + schedule_effect(server, owner, live.index, false); + } + return None; + } + Some(live) +} + fn on_refreshed(server: &GameServer, owner: &WorldObject, b: &Buff) { // SetInUse(true, true) -> UpdateEffect let template = full_template(server, &b.template); start(server, owner, b.index); + if !current_buff(owner, b).is_some_and(|live| !live.is_ended()) { + return; + } let now = now_ms(); let Some(gen) = set_buff(owner, b.index, |e| { if e.duration == 0 { @@ -799,6 +848,9 @@ fn stop_effect_task(server: &GameServer, owner: &WorldObject, index: u32, timed_ fire_buff_trigger(server, owner, index, BuffEventTriggerKind::Timeout); } unsubscribe_triggers(server, owner, &b); + if current_buff(owner, &b).is_none() { + return; + } owner.with_base_unit(|u| u.buffs_mut().remove_effect_by_index(index)); crate::systems::dispatch_buff_events(server, owner); } @@ -1600,6 +1652,8 @@ pub struct TriggerSub { pub source_obj: u32, pub owner_obj: u32, pub buff_index: u32, + /// Internal buff lifetime, since an explicit index can be reused by a callback. + pub buff_instance_id: u64, pub template: BuffTriggerTemplate, /// `DamagedBuffTrigger` (else the generic `BuffTrigger`). pub damaged: bool, @@ -1661,6 +1715,7 @@ fn subscribe_triggers(server: &GameServer, owner: &WorldObject, b: &Buff) { source_obj: if unit_event { owner.obj_id() } else { 0 }, owner_obj: owner.obj_id(), buff_index: b.index, + buff_instance_id: b.instance_id, template: t.clone(), damaged, }); @@ -1677,7 +1732,11 @@ fn unsubscribe_triggers(server: &GameServer, owner: &WorldObject, b: &Buff) { .triggers .lock() .expect("triggers poisoned") - .retain(|s| !(s.owner_obj == owner_id && s.buff_index == b.index)); + .retain(|s| { + !(s.owner_obj == owner_id + && s.buff_index == b.index + && s.buff_instance_id == b.instance_id) + }); } /// Fires a buff-level event (`Started`, `Timeout`, `Dispelled`) of the buff at `index`. @@ -1709,6 +1768,7 @@ fn fire_buff_trigger_with( .filter(|s| { s.owner_obj == owner_id && s.buff_index == b.index + && s.buff_instance_id == b.instance_id && s.source_obj == 0 && s.template.kind == kind as u16 }) @@ -1739,6 +1799,9 @@ pub fn fire_unit_event(server: &GameServer, unit: u32, kind: BuffEventTriggerKin let Some(b) = get_buff(&owner, s.buff_index) else { continue; }; + if b.instance_id != s.buff_instance_id { + continue; + } execute_trigger(server, &owner, &b, &s, amount); } } From d0f156165d33d955fb4315cdc9b829021579cfd3 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:17:56 -0400 Subject: [PATCH 22/66] fix(game): enforce per-unit shared skill cooldown tags Track shared tag expiries from authored skills.cooldown_tag_id and apply the started skill cooldown modifiers with nonnegative, saturating duration arithmetic. Check never-used members at admission and cast completion, preserve longer individual and shared expiries, and retain GM override and server-controlled NPC admission policy. Project effective cooldowns to explicit native 1.2 SCCooldowns skill records for affected members and session snapshots, including authored members missing from tagged_skills. Preserve the existing 150-entry wire cap and remaining-as-total snapshot convention. Commit costs and cooldowns after item validation; stop plot completion from reapplying raw cooldowns or duplicating UI updates. Preserve merged zone-tag and AoE work. Add twelve packet-flow and native-byte regressions for group and player isolation, never-used member refusal, longer individual timers, modifiers and expiration, cast revalidation, channel start/stop, GM/NPC policy, snapshots, signed/overflow durations, and plot completion. Native evidence: x2game12.c 397B2350, 39899D40, 39899F90, 3989A290, 3989A360/3989F900; UI baselib.lua 346-383. Read-only SQLite queries find 405 positive authored members across 54 tags, 39 missing a matching tagged_skills row. Validation: cargo fmt --all; cargo fmt --all --check; git diff --check; staged diff review. Builds, tests, clippy, live verification and full CI intentionally not run under parent build restriction. Parent test selector: cooldown_tag_flow_tests. Persistence across a full DB restart remains outside this scope. Co-Authored-By: Codex --- rust/crates/aaemu-game/src/models/unit.rs | 37 +- .../systems/skills/cooldown_tag_flow_tests.rs | 536 ++++++++++++++++++ .../aaemu-game/src/systems/skills/plots.rs | 17 +- .../aaemu-game/src/systems/skills/skill.rs | 188 ++++-- rust/crates/aaemu-game/src/world/session.rs | 7 +- 5 files changed, 730 insertions(+), 55 deletions(-) create mode 100644 rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs diff --git a/rust/crates/aaemu-game/src/models/unit.rs b/rust/crates/aaemu-game/src/models/unit.rs index 2735c7a9c2..7d2f5eacd2 100644 --- a/rust/crates/aaemu-game/src/models/unit.rs +++ b/rust/crates/aaemu-game/src/models/unit.rs @@ -361,14 +361,25 @@ impl Bonuses { #[derive(Debug, Clone, Default, PartialEq)] pub struct UnitCooldowns { pub cooldowns: HashMap, + /// Shared expiry by authored `skills.cooldown_tag_id`, local to this unit. + pub tag_cooldowns: HashMap, } impl UnitCooldowns { /// `AddCooldown(skillId, duration)` (an existing cooldown is kept). pub fn add_cooldown(&mut self, skill_id: u32, duration_ms: u32, now_ms: i64) { + if duration_ms == 0 { + return; + } + let end = now_ms.saturating_add(i64::from(duration_ms)); self.cooldowns .entry(skill_id) - .or_insert(now_ms + i64::from(duration_ms)); + .and_modify(|old| { + if *old <= now_ms { + *old = end; + } + }) + .or_insert(end); } /// `CheckCooldown(skillId)`: true while more than 250 ms are left; an (almost) expired @@ -377,13 +388,35 @@ impl UnitCooldowns { let Some(&end) = self.cooldowns.get(&skill_id) else { return false; }; - if end - now_ms > 250 { + if end.saturating_sub(now_ms) > 250 { return true; } self.cooldowns.remove(&skill_id); false } + /// Start or extend a shared cooldown without shortening an existing expiry. + pub fn add_tag_cooldown(&mut self, tag_id: u32, duration_ms: u32, now_ms: i64) { + self.tag_cooldowns.retain(|_, end| *end > now_ms); + if tag_id == 0 || duration_ms == 0 { + return; + } + let end = now_ms.saturating_add(i64::from(duration_ms)); + self.tag_cooldowns + .entry(tag_id) + .and_modify(|old| *old = (*old).max(end)) + .or_insert(end); + } + + /// A tagged member can be cooling down even if this unit has never used it. + /// Keep the existing 250 ms admission tolerance for both stores. + pub fn check_skill_cooldown(&mut self, skill_id: u32, tag_id: u32, now_ms: i64) -> bool { + let individual = self.check_cooldown(skill_id, now_ms); + self.tag_cooldowns + .retain(|_, end| end.saturating_sub(now_ms) > 250); + individual || (tag_id != 0 && self.tag_cooldowns.contains_key(&tag_id)) + } + /// `RemoveCooldown(skillId)`. pub fn remove_cooldown(&mut self, skill_id: u32) { self.cooldowns.remove(&skill_id); diff --git a/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs b/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs new file mode 100644 index 0000000000..f95ae5c40a --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs @@ -0,0 +1,536 @@ +//! Native 1.2 evidence: x2game12.c 397B2350 reads i32 skillCount and tagCount, +//! each followed by (id, total, remaining) u32 triples; 39899D40 appends them, +//! 3989A290 selects the longest skill/tag timer, and 39899F90 never shortens a tag. +//! UI baselib.lua:346-383 consumes remaining/total on item/skill_cooldown updates. +//! Authored cooldown_tag_id membership is separate from tagged_skills (39 positive +//! authored members lack the matching row in the 1.2 compact export). Expected bytes +//! below are literal native-reader fixtures, never generated by a second encoder. + +use std::sync::Arc; + +use aaemu_commons::{Marshal, PacketStream}; + +use crate::data::GameData; +use crate::models::unit::{SkillAttribute, SkillModifier, UnitCooldowns, UnitModifierType}; +use crate::net::registry::ClientPacket; +use crate::opcodes::sc; +use crate::server::GameServer; +use crate::systems::skills; +use crate::test_support::{open_client_skills, spawn_player, test_character, TestClient}; +use crate::world::{now_ms, NpcRef, PlayerRef, WorldObject}; + +use skills::data::SkillTemplate; +use skills::handlers::{start_skill, CSStartSkillPacket}; +use skills::types::{skill_result, SkillCastTarget, SkillCaster, SkillObject}; + +const POTION: u32 = 11717; +const POTION_NEXT: u32 = 11720; +const FOOD: u32 = 11816; +const FOOD_NEXT: u32 = 11817; +const GLIDER: u32 = 13411; +const GLIDER_ZERO: u32 = 12373; +const UNTAGGED: u32 = 21001; + +fn data() -> GameData { + let mut data = GameData::empty(); + for (id, tag, duration) in [ + (POTION, 144, 60_000), + // Deliberately different durations: use the started skill's duration for the group. + (POTION_NEXT, 144, 3_000), + (FOOD, 9, 3_000), + (FOOD_NEXT, 9, 3_000), + (GLIDER, 296, 10_000), + (GLIDER_ZERO, 296, 0), + (UNTAGGED, 0, 0), + ] { + data.systems.skills.add_skill(SkillTemplate { + cooldown_tag_id: tag, + cooldown_time: duration, + mana_cost: 25, + ..skills::tests::skill_template(id) + }); + } + // An unrelated generic tag must not become server cooldown-group membership. + data.systems.skills.skill_tags.insert(UNTAGGED, vec![144]); + data +} + +fn fixture(mut data: GameData) -> (Arc, TestClient, PlayerRef, NpcRef) { + open_client_skills(&mut data); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + client.conn.active_char = Some(player.clone()); + client.drain(); + (server, client, player, npc) +} + +fn edit(data: &mut GameData, id: u32, change: impl FnOnce(&mut SkillTemplate)) { + change(Arc::make_mut( + data.systems.skills.skills.get_mut(&id).unwrap(), + )); +} + +fn cast(server: &GameServer, client: &mut TestClient, id: u32, target: u32) { + let player = client.conn.active_char.clone().unwrap(); + { + let mut p = player.data(); + // Isolate skill/tag cooldown admission from the existing per-press/GCD throttle. + p.unit.skill_last_used_ms = 0; + p.unit.global_cooldown_ms = 0; + } + // CS 1.2 caster/target unions: unit kind 0, 3-byte object ids (397C85B0/397C7A40). + let mut request = Vec::from(id.to_le_bytes()); + request.push(0); + request.extend_from_slice(&player.obj_id.to_le_bytes()[..3]); + request.push(0); + request.extend_from_slice(&target.to_le_bytes()[..3]); + request.push(0); + let packet = CSStartSkillPacket::read(&mut PacketStream::from_bytes(request)).unwrap(); + start_skill(server, &mut client.conn, packet); +} + +fn cooldown_entries(frames: &[(u16, Vec)]) -> Vec<(u32, u32, u32)> { + let packets: Vec<_> = frames + .iter() + .filter(|(op, _)| *op == sc::SCCooldownsPacket) + .collect(); + assert_eq!( + packets.len(), + 1, + "one UI application per accepted tagged cast" + ); + let mut body = PacketStream::from_bytes(packets[0].1.clone()); + let count = body.read_i32().unwrap(); + let entries = (0..count) + .map(|_| { + ( + body.read_u32().unwrap(), + body.read_u32().unwrap(), + body.read_u32().unwrap(), + ) + }) + .collect(); + // Explicit skill projection avoids treating unrelated generic tags as authored members. + assert_eq!(body.read_i32().unwrap(), 0); + assert_eq!(packets[0].1.len(), 8 + count as usize * 12); + entries +} + +fn assert_denied(frames: &[(u16, Vec)], result: u8) { + assert!(!frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + assert!(!frames.iter().any(|(op, _)| *op == sc::SCCooldownsPacket)); + let errors: Vec<_> = frames + .iter() + .filter(|(op, _)| *op == sc::SCSkillStartedPacket) + .collect(); + assert_eq!(errors.len(), 1); + // Native 397CA290 -> 397B1EF0: the error byte follows the extra-flags byte at the end. + assert_eq!(&errors[0].1[errors[0].1.len() - 2..], &[1, result]); +} + +#[tokio::test] +async fn packet_flow_denies_never_used_member_and_preserves_long_individual_cooldown() { + let (server, mut client, player, npc) = fixture(data()); + let long_end = now_ms() + 120_000; + player + .data() + .unit + .cooldowns + .cooldowns + .insert(POTION_NEXT, long_end); + cast(&server, &mut client, POTION, npc.obj_id); + let frames = client.drain(); + assert!(frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + let entries = cooldown_entries(&frames); + assert_eq!( + entries.iter().map(|e| e.0).collect::>(), + [POTION, POTION_NEXT] + ); + assert!(entries[0].2 <= 60_000 && entries[0].2 > 59_000); + assert!(entries[1].2 > 119_000); + assert_eq!( + player.data().unit.cooldowns.cooldowns[&POTION_NEXT], + long_end + ); + // Remove only the fixture's old individual cooldown: this member has never been cast. + player.data().unit.cooldowns.remove_cooldown(POTION_NEXT); + cast(&server, &mut client, POTION_NEXT, npc.obj_id); + assert_denied(&client.drain(), skill_result::COOLDOWN_TIME); + assert_eq!(player.data().unit.mp, 75); + assert!(!player + .data() + .unit + .cooldowns + .cooldowns + .contains_key(&POTION_NEXT)); +} + +#[tokio::test] +async fn food_glider_zero_duration_members_and_players_have_independent_groups() { + let (server, mut client, player, npc) = fixture(data()); + for (id, members) in [ + (POTION, vec![POTION, POTION_NEXT]), + (FOOD, vec![FOOD, FOOD_NEXT]), + (GLIDER, vec![GLIDER_ZERO, GLIDER]), + ] { + player.data().unit.mp = 100; + cast(&server, &mut client, id, npc.obj_id); + let entries = cooldown_entries(&client.drain()); + assert_eq!( + entries.into_iter().map(|e| e.0).collect::>(), + members + ); + } + cast(&server, &mut client, GLIDER_ZERO, npc.obj_id); + assert_denied(&client.drain(), skill_result::COOLDOWN_TIME); + player.data().unit.mp = 100; + cast(&server, &mut client, UNTAGGED, npc.obj_id); + assert!(client.drain_ops().contains(&sc::SCSkillFiredPacket)); + assert!(!player + .data() + .unit + .cooldowns + .cooldowns + .contains_key(&UNTAGGED)); + let mut other = TestClient::new(&server, 2, 2); + let mut c = test_character(2, "Other", 100.0, 100.0); + c.unit.mp = 100; + let other_player = spawn_player(&server, &other, c, 0x101); + other.conn.active_char = Some(other_player.clone()); + other.drain(); + client.drain(); + cast(&server, &mut other, POTION_NEXT, npc.obj_id); + assert_eq!(other_player.data().unit.mp, 75); + assert_eq!(cooldown_entries(&other.drain()).len(), 2); + assert!(!client.drain_ops().contains(&sc::SCCooldownsPacket)); +} + +#[tokio::test] +async fn untagged_skill_keeps_its_individual_cooldown_and_negative_tags_are_not_groups() { + for tag in [0, -1] { + let mut data = data(); + edit(&mut data, UNTAGGED, |s| { + s.cooldown_time = 10_000; + s.cooldown_tag_id = tag; + }); + let (server, mut client, player, npc) = fixture(data); + cast(&server, &mut client, UNTAGGED, npc.obj_id); + assert!(client.drain_ops().contains(&sc::SCSkillFiredPacket)); + assert!(player.data().unit.cooldowns.tag_cooldowns.is_empty()); + cast(&server, &mut client, UNTAGGED, npc.obj_id); + assert_denied(&client.drain(), skill_result::COOLDOWN_TIME); + assert_eq!(player.data().unit.mp, 75); + } +} + +#[tokio::test] +async fn group_uses_started_skills_cooldown_modifier_and_expiry_allows_a_new_member() { + let (server, mut client, player, npc) = fixture(data()); + player + .data() + .unit + .skill_modifiers + .add_modifiers(&[SkillModifier { + id: 1, + owner_id: 1, + tag_id: 0, + skill_attribute: SkillAttribute::Cooldown, + unit_modifier_type: UnitModifierType::Percent, + value: -50, + skill_id: POTION, + synergy: false, + }]); + cast(&server, &mut client, POTION, npc.obj_id); + let entries = cooldown_entries(&client.drain()); + assert!(entries.iter().all(|e| e.2 > 29_000 && e.2 <= 30_000)); + player + .data() + .unit + .cooldowns + .tag_cooldowns + .insert(144, now_ms() - 1); + cast(&server, &mut client, POTION_NEXT, npc.obj_id); + let entries = cooldown_entries(&client.drain()); + assert!(entries.iter().find(|e| e.0 == POTION).unwrap().2 > 29_000); + assert!(entries.iter().find(|e| e.0 == POTION_NEXT).unwrap().2 <= 3_000); + assert_eq!(player.data().unit.mp, 50); +} + +#[tokio::test] +async fn cast_cost_failure_and_new_group_during_cast_do_not_start_cooldowns() { + for group_started in [false, true] { + let mut data = data(); + edit(&mut data, POTION_NEXT, |s| s.casting_time = 60_000); + let (server, mut client, player, npc) = fixture(data); + cast(&server, &mut client, POTION_NEXT, npc.obj_id); + let task = player.data().unit.skill_state.skill_task.clone().unwrap(); + assert!(player.data().unit.cooldowns.cooldowns.is_empty()); + assert!(player.data().unit.cooldowns.tag_cooldowns.is_empty()); + assert_eq!(player.data().unit.mp, 100); + client.drain(); + if group_started { + player + .data() + .unit + .cooldowns + .add_tag_cooldown(144, 60_000, now_ms()); + } else { + player.data().unit.mp = 0; + } + let before = player.data().unit.cooldowns.clone(); + super::cast( + &server, + &task.skill, + &super::CastCtx { + caster: WorldObject::from(&player), + caster_caster: SkillCaster::Unit(player.obj_id), + target: skills::geometry::Target::Obj(WorldObject::from(&npc)), + target_caster: SkillCastTarget::Unit(npc.obj_id), + skill_object: SkillObject::None, + }, + ); + task.cancel.cancel(); + let frames = client.drain(); + assert!(!frames + .iter() + .any(|(op, _)| *op == sc::SCSkillFiredPacket || *op == sc::SCCooldownsPacket)); + assert_eq!(player.data().unit.cooldowns, before); + assert_eq!(player.data().unit.mp, if group_started { 100 } else { 0 }); + } +} + +#[tokio::test] +async fn channel_commits_cost_and_shared_cooldown_once_and_stop_keeps_them() { + let mut data = data(); + edit(&mut data, FOOD, |s| s.channeling_time = 60_000); + let (server, mut client, player, npc) = fixture(data); + cast(&server, &mut client, FOOD, npc.obj_id); + assert_eq!(cooldown_entries(&client.drain()).len(), 2); + assert_eq!(player.data().unit.mp, 75); + let task = player.data().unit.skill_state.skill_task.clone().unwrap(); + let before = player.data().unit.cooldowns.clone(); + super::stop(&server, &task.skill, &WorldObject::from(&player), 0); + assert_eq!(player.data().unit.cooldowns, before); + assert!(!client.drain_ops().contains(&sc::SCCooldownsPacket)); +} + +#[tokio::test] +async fn gm_override_bypasses_shared_admission_and_resets_the_native_tag() { + let (server, mut client, player, npc) = fixture(data()); + player.data().skill_char.ignore_skill_cooldowns = true; + for _ in 0..2 { + cast(&server, &mut client, POTION, npc.obj_id); + let frames = client.drain(); + assert!(frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + assert!(!frames.iter().any(|(op, _)| *op == sc::SCCooldownsPacket)); + let reset = frames + .iter() + .find(|(op, _)| *op == sc::SCSkillCooldownResetPacket) + .unwrap(); + // Native 397B5770 / OnSkillCooldownReset 391D6420: bc chr, u32 skill/tag, bool gcd. + assert_eq!(reset.1, [0, 1, 0, 0xc5, 0x2d, 0, 0, 0x90, 0, 0, 0, 0]); + } + assert_eq!(player.data().unit.mp, 50); + assert!(player.data().unit.cooldowns.cooldowns.is_empty()); + assert!(player.data().unit.cooldowns.tag_cooldowns.is_empty()); + player + .data() + .unit + .cooldowns + .add_tag_cooldown(144, 60_000, now_ms()); + player.data().unit.mp = 100; + cast(&server, &mut client, POTION_NEXT, npc.obj_id); + assert!(client.drain_ops().contains(&sc::SCSkillFiredPacket)); +} + +#[tokio::test] +async fn npc_policy_keeps_accepting_server_skills_without_shortening_group_expiry() { + let (server, _client, player, npc) = fixture(data()); + let caster = WorldObject::from(&npc); + npc.data().unit.mp = 100; + npc.data() + .unit + .cooldowns + .add_tag_cooldown(144, 120_000, now_ms()); + let longer = npc.data().unit.cooldowns.tag_cooldowns[&144]; + for id in [POTION, POTION_NEXT] { + let skill = super::new_skill_for( + &server, + server.game_data.systems.skills.skill(id).unwrap().clone(), + Some(&caster), + ); + assert_eq!( + super::use_skill( + &server, + &skill, + &caster, + SkillCaster::Unit(npc.obj_id), + &mut SkillCastTarget::Unit(player.obj_id), + None, + true + ) + .0, + skill_result::SUCCESS + ); + assert_eq!(npc.data().unit.cooldowns.tag_cooldowns[&144], longer); + } +} + +#[tokio::test] +async fn select_snapshot_projects_members_and_preserves_long_individual_expiry() { + let server = crate::test_support::test_server_with(data()); + let mut client = TestClient::new(&server, 1, 1); + let now = now_ms(); + let mut character = test_character(1, "Restored", 100.0, 100.0); + character.unit.cooldowns.add_tag_cooldown(144, 60_000, now); + character + .unit + .cooldowns + .add_cooldown(POTION_NEXT, 120_000, now); + character + .unit + .cooldowns + .add_tag_cooldown(9, 3_000, now - 10_000); + crate::world::session::select_loaded(&server, &mut client.conn, character, Default::default()) + .unwrap(); + let entries = cooldown_entries(&client.drain()); + assert_eq!( + entries.iter().map(|e| e.0).collect::>(), + [POTION, POTION_NEXT] + ); + assert!(entries[0].2 > 59_000 && entries[1].2 > 119_000); +} + +#[tokio::test] +async fn native_snapshot_bytes_use_longest_expiry_and_omit_expired_or_unrelated_members() { + let server = crate::test_support::test_server_with(data()); + let mut cooldowns = UnitCooldowns::default(); + cooldowns.add_tag_cooldown(144, 60_000, 0); + cooldowns.add_cooldown(POTION_NEXT, 120_000, 0); + let packet = super::cooldown_snapshot(&server, &cooldowns, 1000); + let mut body = PacketStream::new(); + packet.write(&mut body); + assert_eq!( + body.into_bytes(), + [ + 2, 0, 0, 0, 0xc5, 0x2d, 0, 0, 0x78, 0xe6, 0, 0, 0x78, 0xe6, 0, 0, 0xc8, 0x2d, 0, 0, + 0xd8, 0xd0, 1, 0, 0xd8, 0xd0, 1, 0, 0, 0, 0, 0, + ] + ); + assert_eq!( + super::cooldown_snapshot(&server, &cooldowns, 120_000), + Default::default() + ); +} + +#[tokio::test] +async fn zero_negative_and_overflow_durations_never_wrap_or_create_spurious_cooldowns() { + for duration in [0, -1, i32::MIN] { + let mut data = data(); + edit(&mut data, POTION, |s| s.cooldown_time = duration); + let (server, mut client, player, npc) = fixture(data); + cast(&server, &mut client, POTION, npc.obj_id); + let frames = client.drain(); + assert!(frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + assert!(!frames.iter().any(|(op, _)| *op == sc::SCCooldownsPacket)); + assert!(player.data().unit.cooldowns.cooldowns.is_empty()); + assert!(player.data().unit.cooldowns.tag_cooldowns.is_empty()); + } + let (server, _client, player, _) = fixture(data()); + player.data().unit.skill_modifiers.add_modifiers(&[ + SkillModifier { + id: 1, + owner_id: 1, + tag_id: 0, + skill_attribute: SkillAttribute::Cooldown, + unit_modifier_type: UnitModifierType::Value, + value: i32::MAX, + skill_id: POTION, + synergy: false, + }, + SkillModifier { + id: 2, + owner_id: 2, + tag_id: 0, + skill_attribute: SkillAttribute::Cooldown, + unit_modifier_type: UnitModifierType::Percent, + value: i32::MAX, + skill_id: POTION, + synergy: false, + }, + ]); + let caster = WorldObject::from(&player); + let skill = super::new_skill_for( + &server, + server + .game_data + .systems + .skills + .skill(POTION) + .unwrap() + .clone(), + Some(&caster), + ); + super::start_skill_cooldown(&server, &skill, &caster, 0); + assert_eq!( + player.data().unit.cooldowns.tag_cooldowns[&144], + i64::from(u32::MAX) + ); + player.data().unit.cooldowns = UnitCooldowns::default(); + super::start_skill_cooldown(&server, &skill, &caster, i64::MAX - 100); + assert_eq!(player.data().unit.cooldowns.tag_cooldowns[&144], i64::MAX); + let mut cds = UnitCooldowns::default(); + cds.add_tag_cooldown(144, 60_000, 0); + cds.add_tag_cooldown(144, 1_000, 10); + assert_eq!(cds.tag_cooldowns[&144], 60_000); + assert!(cds.check_skill_cooldown(POTION_NEXT, 144, 59_749)); + assert!(!cds.check_skill_cooldown(POTION_NEXT, 144, 59_750)); + assert!(cds.tag_cooldowns.is_empty()); +} + +#[tokio::test] +async fn plot_end_keeps_modified_shared_expiry_nonnegative_and_sends_only_one_ui_update() { + for duration in [60_000, 0, -1] { + let mut data = data(); + edit(&mut data, POTION, |s| { + s.plot_only = true; + s.plot_id = Some(77); + s.cooldown_time = duration; + }); + let (server, mut client, player, npc) = fixture(data); + player + .data() + .unit + .skill_modifiers + .add_modifiers(&[SkillModifier { + id: 1, + owner_id: 1, + tag_id: 0, + skill_attribute: SkillAttribute::Cooldown, + unit_modifier_type: UnitModifierType::Percent, + value: -50, + skill_id: POTION, + synergy: false, + }]); + cast(&server, &mut client, POTION, npc.obj_id); + // Missing tree executes do_plot_end through the real scheduler without a cast path. + tokio::time::timeout(std::time::Duration::from_secs(1), async { + while player.data().unit.skill_state.active_plot.is_some() { + tokio::task::yield_now().await; + } + }) + .await + .expect("plot reaches do_plot_end"); + let frames = client.drain(); + assert!(frames.iter().any(|(op, _)| *op == sc::SCPlotEndedPacket)); + if duration > 0 { + let entries = cooldown_entries(&frames); + assert!(entries.iter().all(|e| e.2 > 29_000 && e.2 <= 30_000)); + let cds = &player.data().unit.cooldowns; + assert_eq!(cds.cooldowns[&POTION], cds.tag_cooldowns[&144]); + } else { + assert!(!frames.iter().any(|(op, _)| *op == sc::SCCooldownsPacket)); + assert!(player.data().unit.cooldowns.cooldowns.is_empty()); + assert!(player.data().unit.cooldowns.tag_cooldowns.is_empty()); + } + } +} diff --git a/rust/crates/aaemu-game/src/systems/skills/plots.rs b/rust/crates/aaemu-game/src/systems/skills/plots.rs index 68f0c786a0..c0ed2110c4 100644 --- a/rust/crates/aaemu-game/src/systems/skills/plots.rs +++ b/rust/crates/aaemu-game/src/systems/skills/plots.rs @@ -423,20 +423,9 @@ fn do_plot_end(server: &GameServer, state: &Arc) { let tl = skill.tl_id(); broadcast(server, &caster, &SCPlotEndedPacket { tl }, true); end_plot_channel(server, state); - let now = now_ms(); - let (id, cd) = (skill.template.id, skill.template.cooldown_time); - caster.with_unit(|u| u.unit_mut().cooldowns.add_cooldown(id, cd as u32, now)); - if let Some(o) = super::relation::owner_character(server, &caster) { - if o.data().skill_char.ignore_skill_cooldowns { - o.send(super::packets::SCSkillCooldownResetPacket { - obj_id: o.obj_id, - skill_id: id, - tag_id: 0, - gcd: false, - }); - caster.with_unit(|u| u.unit_mut().cooldowns.remove_cooldown(id)); - } - } + // Cooldowns are committed at accepted plot-only use or successful cast, once. + // Plot completion must not reapply raw durations, extend the tag, or send a second UI update. + super::skill::reset_cooldown_if_ignored(server, skill, &caster); // Release only what this call took: a concurrent `end_skill` (interrupt) takes the id the // same way, so whichever comes second releases 0. server.systems.skills.tl_ids.release(skill.take_tl_id()); diff --git a/rust/crates/aaemu-game/src/systems/skills/skill.rs b/rust/crates/aaemu-game/src/systems/skills/skill.rs index e99429195e..06afc3f836 100644 --- a/rust/crates/aaemu-game/src/systems/skills/skill.rs +++ b/rust/crates/aaemu-game/src/systems/skills/skill.rs @@ -9,7 +9,7 @@ use std::sync::Arc; use rand::Rng; use crate::models::transform::PositionAndRotation; -use crate::models::unit::{SkillAttribute, UnitAttribute}; +use crate::models::unit::{SkillAttribute, UnitAttribute, UnitCooldowns}; use crate::server::GameServer; use crate::systems::social::achievement::char_record_kind; use crate::systems::social::achievement_hooks::{AchievementInput, RecordMatch}; @@ -21,8 +21,8 @@ use super::data::{EffectKind, EffectTemplate, SkillEffect, SkillTemplate}; use super::effects::{self, EffectArgs, EffectSource}; use super::geometry::{distance_to, is_front, world_of, world_pos, PosUnit, Target}; use super::packets::{ - CompressedGamePackets, SCCastingStoppedPacket, SCSkillCooldownResetPacket, SCSkillEndedPacket, - SCSkillFiredPacket, SCSkillStartedPacket, SCSkillStoppedPacket, + CompressedGamePackets, SCCastingStoppedPacket, SCCooldownsPacket, SCSkillCooldownResetPacket, + SCSkillEndedPacket, SCSkillFiredPacket, SCSkillStartedPacket, SCSkillStoppedPacket, }; use super::relation::{can_attack, filter_with_relation, owner_character, relation_to}; use super::state::{AutoAttackSlot, CancelToken, SkillRef, SkillRun, SkillTaskKind, SkillTaskSlot}; @@ -180,6 +180,123 @@ fn start_global_cooldown(server: &GameServer, skill: &SkillRef, caster: &WorldOb caster.with_unit(|u| u.unit_mut().global_cooldown_ms = now + ms); } +/// Project shared expiries onto authored members, including members absent from +/// `tagged_skills`. Native 1.2 `3989A290` takes the maximum of skill/tag remaining +/// times; explicit skill entries preserve that rule without cooling unrelated generic tags. +/// `397B2350` reads the existing skill list, then the tag list (id/total/remaining u32). +/// As in the existing reconnect snapshot, total is the remaining time: only expiries are stored. +pub(crate) fn cooldown_snapshot( + server: &GameServer, + cooldowns: &UnitCooldowns, + now: i64, +) -> SCCooldownsPacket { + let mut effective = UnitCooldowns::default(); + effective.cooldowns.clone_from(&cooldowns.cooldowns); + for template in server.game_data.systems.skills.skills.values() { + let tag = template.cooldown_tag_id; + if tag <= 0 { + continue; + } + if let Some(&end) = cooldowns.tag_cooldowns.get(&(tag as u32)) { + if end > now { + effective + .cooldowns + .entry(template.id) + .and_modify(|own| *own = (*own).max(end)) + .or_insert(end); + } + } + } + SCCooldownsPacket::from_cooldowns(&effective, now) +} + +fn cooldown_ignored(server: &GameServer, caster: &WorldObject) -> bool { + caster + .as_player() + .cloned() + .or_else(|| owner_character(server, caster)) + .is_some_and(|owner| owner.data().skill_char.ignore_skill_cooldowns) +} + +fn on_skill_cooldown( + server: &GameServer, + skill: &SkillRun, + caster: &WorldObject, + now: i64, +) -> bool { + // Preserve the existing server-controlled NPC policy: only a character or its + // controlled unit is subject to skill cooldown admission, on that unit's own store. + let owner = caster + .as_player() + .cloned() + .or_else(|| owner_character(server, caster)); + let Some(owner) = owner else { + return false; + }; + if owner.data().skill_char.ignore_skill_cooldowns { + return false; + } + caster + .with_unit(|u| { + u.unit_mut().cooldowns.check_skill_cooldown( + skill.template.id, + skill.template.cooldown_tag_id.max(0) as u32, + now, + ) + }) + .unwrap_or(false) +} + +fn start_skill_cooldown(server: &GameServer, skill: &SkillRun, caster: &WorldObject, now: i64) { + if cooldown_ignored(server, caster) { + return; + } + // Native 1.2 `3989A360` -> `3989F900`, attribute 1: modify the started skill's + // own cooldown, not each member's authored duration. Never cast a signed duration to u32. + let duration = apply_skill_modifiers( + server, + skill, + caster, + SkillAttribute::Cooldown, + f64::from(skill.template.cooldown_time), + ) + .clamp(0.0, f64::from(u32::MAX)) as u32; + if duration == 0 { + return; + } + let tag = skill.template.cooldown_tag_id.max(0) as u32; + let packet = caster + .with_unit(|u| { + let cooldowns = &mut u.unit_mut().cooldowns; + cooldowns.add_cooldown(skill.template.id, duration, now); + cooldowns.add_tag_cooldown(tag, duration, now); + if tag == 0 { + return None; + } + // Send only this group's effective members. In particular, never overwrite + // a longer individual cooldown with the shorter shared expiry. + let mut affected = UnitCooldowns::default(); + for template in server.game_data.systems.skills.skills.values() { + if template.cooldown_tag_id == skill.template.cooldown_tag_id { + let end = cooldowns.tag_cooldowns[&tag] + .max(*cooldowns.cooldowns.get(&template.id).unwrap_or(&0)); + affected.cooldowns.insert(template.id, end); + } + } + Some(SCCooldownsPacket::from_cooldowns(&affected, now)) + }) + .flatten(); + if let Some(packet) = packet.filter(|p| !p.is_empty()) { + if let Some(owner) = caster + .as_player() + .cloned() + .or_else(|| owner_character(server, caster)) + { + owner.send(packet); + } + } +} + fn lookup_base_unit(server: &GameServer, caster: &WorldObject, obj_id: u32) -> Option { world_of(server, caster).and_then(|w| w.object(obj_id)) } @@ -438,9 +555,6 @@ pub fn use_skill( return (skill_result::INVALID_TARGET, 0); } let character = caster.as_player().cloned(); - let cooldown_owner = character - .clone() - .or_else(|| owner_character(server, caster)); let req = unit_reqs::can_use_skill_on_target( server, &template, @@ -512,16 +626,8 @@ pub fn use_skill( } } let now = now_ms(); - if template.cooldown_time > 0 { - if let Some(o) = &cooldown_owner { - let ignore = o.data().skill_char.ignore_skill_cooldowns; - let on_cd = caster - .with_unit(|u| u.unit_mut().cooldowns.check_cooldown(template.id, now)) - .unwrap_or(false); - if !ignore && on_cd { - return (skill_result::COOLDOWN_TIME, 0); - } - } + if on_skill_cooldown(server, skill, caster, now) { + return (skill_result::COOLDOWN_TIME, 0); } skill.state().bypass_gcd = bypass_gcd; if !bypass_gcd { @@ -633,17 +739,14 @@ pub fn use_skill( skill_object: skill_object.clone(), }; if let Some(plot_id) = template.plot_id { - super::plots::run_plot(server, plot_id, ctx.clone(), skill.clone()); if template.plot_only { - // `cast` never runs for a plot-only skill: start the GCD and the skill's own - // cooldown now, so it cannot be recast while the plot runs (`do_plot_end` adds the - // cooldown too, but `add_cooldown` keeps this earlier entry). + // Plot-only skills never enter `cast`; commit cooldowns once at acceptance, + // before a plot can finish synchronously. start_global_cooldown(server, skill, caster, now); - caster.with_unit(|u| { - u.unit_mut() - .cooldowns - .add_cooldown(template.id, template.cooldown_time as u32, now) - }); + start_skill_cooldown(server, skill, caster, now); + } + super::plots::run_plot(server, plot_id, ctx.clone(), skill.clone()); + if template.plot_only { return (skill_result::SUCCESS, 0); } } @@ -836,6 +939,13 @@ pub fn cast(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { .map_or(Ok(()), |result| Err((result, 0))) .and_then(|()| super::validation::check_item_zone(server, caster, &ctx.caster_caster)) .and_then(|()| super::validation::check(server, skill, caster, &ctx.target)) + .and_then(|()| { + if on_skill_cooldown(server, skill, caster, now_ms()) { + Err((skill_result::COOLDOWN_TIME, 0)) + } else { + Ok(()) + } + }) .and_then(|()| super::validation::check_resources(server, skill, caster)) .and_then(|()| { super::validation::check_build_materials(server, skill, caster, &ctx.target) @@ -863,8 +973,6 @@ pub fn cast(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { return; } let t = &skill.template; - let now = now_ms(); - start_global_cooldown(server, skill, caster, now); if caster.as_npc().is_some() && t.skill_controller_id != 0 { if let Some(sc) = server .game_data @@ -886,14 +994,7 @@ pub fn cast(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { } } } - caster.with_unit(|u| u.unit_mut().skill_state.skill_task = None); - consume_mana(server, skill, caster); - caster.with_unit(|u| { - u.unit_mut() - .cooldowns - .add_cooldown(t.id, t.cooldown_time as u32, now) - }); - // Validate the cast item + // Validate the cast item before committing mana or cooldowns. if let ( Some(p), SkillCaster::Item { @@ -924,6 +1025,11 @@ pub fn cast(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { } } } + let now = now_ms(); + start_global_cooldown(server, skill, caster, now); + caster.with_unit(|u| u.unit_mut().skill_state.skill_task = None); + consume_mana(server, skill, caster); + start_skill_cooldown(server, skill, caster, now); if t.channeling_time > 0 { start_channeling(server, skill, ctx); } else { @@ -2030,13 +2136,17 @@ pub fn end_skill(server: &GameServer, skill: &SkillRef, caster: &WorldObject) { } } -fn reset_cooldown_if_ignored(server: &GameServer, skill: &SkillRun, caster: &WorldObject) { +pub(super) fn reset_cooldown_if_ignored( + server: &GameServer, + skill: &SkillRun, + caster: &WorldObject, +) { if let Some(o) = owner_character(server, caster) { if o.data().skill_char.ignore_skill_cooldowns { o.send(SCSkillCooldownResetPacket { obj_id: o.obj_id, skill_id: skill.template.id, - tag_id: 0, + tag_id: skill.template.cooldown_tag_id.max(0) as u32, gcd: false, }); caster.with_unit(|u| u.unit_mut().cooldowns.remove_cooldown(skill.template.id)); @@ -2472,3 +2582,7 @@ mod owned_npc_target_tests; #[cfg(test)] #[path = "modifier_flow_tests.rs"] mod modifier_flow_tests; + +#[cfg(test)] +#[path = "cooldown_tag_flow_tests.rs"] +mod cooldown_tag_flow_tests; diff --git a/rust/crates/aaemu-game/src/world/session.rs b/rust/crates/aaemu-game/src/world/session.rs index 66131e12f3..52c427233f 100644 --- a/rust/crates/aaemu-game/src/world/session.rs +++ b/rust/crates/aaemu-game/src/world/session.rs @@ -29,7 +29,6 @@ use crate::net::connection::{ConnCommand, GameConnection, GameState}; use crate::packets::proxy::ChangeStatePacket; use crate::packets::world::*; use crate::server::GameServer; -use crate::systems::skills::packets::SCCooldownsPacket; use crate::world::{broadcast, unit_state, Player, PlayerRef, WorldInstance, WorldObject}; #[path = "zone_access.rs"] @@ -615,7 +614,11 @@ pub fn select_loaded( } // Running skill cooldowns (the client appends them to its cooldown manager; an empty list // would change nothing, so it is not sent). - let cooldowns = SCCooldownsPacket::from_cooldowns(&snapshot.unit.cooldowns, now_ms()); + let cooldowns = crate::systems::skills::skill::cooldown_snapshot( + server, + &snapshot.unit.cooldowns, + now_ms(), + ); if !cooldowns.is_empty() { conn.send(&cooldowns); } From 917759c3fb637dec43adbb2d930da37f31b4a71a Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:20:14 -0400 Subject: [PATCH 23/66] fix(game): repair damage interpolation percent terms and threat Use native 1.2 sub_398A7380 float interpolation in the shared effect range helper and truncate damage level endpoints before composing the base. Evaluate authored percent terms against a pre-hit HP/max-HP snapshot with wide integer arithmetic; current-health selects the basis only while percent damage is enabled. Compose combined fixed/percent terms while retaining the standalone fixed override and the existing crit, armor and battle-resistance order. Apply optional plot AoE scaling exactly once to integer damage, then the native sub_39898330 landed-hit minimum of one on both opted-in and ordinary paths. Immunity and misses remain zero. Use neutral unit multipliers for non-unit sources and saturating accumulated damage/life-steal arithmetic. Separate actual damage credit from authored scaled threat through a narrow opt-in combat helper. Existing add_unit_aggro callers retain their semantics. Zero new threat adds no aggro/watch but retains raw damage credit; positive accumulated damage threat saturates. Add twelve focused damage_pipeline regressions covering native low/mid/max level endpoints, HP and actual damage packets including a literal native-layout fixture, authored percent/current-HP flags, NPC and non-unit sources, credit versus threat at multipliers 0/1/3/100, unit aggro modifiers, armor/AoE order, immunity/miss, hostile authority, and negative/overflow inputs. Native evidence: D:/aa-re/client12/decomp/x2game12.c sub_398A7380, sub_3941B030, sub_39898330, sub_397C8760, sub_397C7A40, sub_397C85B0 and read-only 1.2 compact damage_effects queries. Percent /100 and endpoint truncation are explicitly a compatibility interpretation: the authoritative 1.2 server producer is unavailable. No 10.x level/height/range/zone or target-health predicates are imported. Heal ignore_heal_aggro already has a reader. Validation: targeted rustfmt --edition 2021 and --check; git diff --cached --check; source-level before-fix reproduction and read-only native/data inspection. No Cargo, compilation, tests, clippy, servers, live run or full CI under the parent build freeze. Parent selectors: damage_pipeline_, aoe_policy_, modifier_, plus focused aaemu-game clippy; parent owns combined exact-tree validation and cleanup. Co-Authored-By: Codex --- .../aaemu-game/src/systems/skills/combat.rs | 44 +- .../src/systems/skills/effects/combat.rs | 94 +-- .../skills/effects/damage_pipeline_tests.rs | 560 ++++++++++++++++++ 3 files changed, 661 insertions(+), 37 deletions(-) create mode 100644 rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs diff --git a/rust/crates/aaemu-game/src/systems/skills/combat.rs b/rust/crates/aaemu-game/src/systems/skills/combat.rs index 21efdb94f3..3581d6434e 100644 --- a/rust/crates/aaemu-game/src/systems/skills/combat.rs +++ b/rust/crates/aaemu-game/src/systems/skills/combat.rs @@ -1067,6 +1067,36 @@ pub fn add_unit_aggro( kind: AggroKind, unit: &WorldObject, amount: i32, +) -> bool { + add_aggro_amounts(server, owner, kind, unit, amount, None) +} + +/// Damage effects award actual damage credit independently of their authored threat. +/// Other callers retain `add_unit_aggro`'s historical zero/negative amount semantics. +pub fn add_damage_aggro( + server: &GameServer, + owner: &WorldObject, + unit: &WorldObject, + damage: i32, + threat: i32, +) -> bool { + add_aggro_amounts( + server, + owner, + AggroKind::Damage, + unit, + threat.max(0), + Some(damage.max(0)), + ) +} + +fn add_aggro_amounts( + server: &GameServer, + owner: &WorldObject, + kind: AggroKind, + unit: &WorldObject, + amount: i32, + damage_credit: Option, ) -> bool { if buffs::check_buff_tag(server, owner, tags::NO_FIGHT) || buffs::check_buff_tag(server, owner, tags::RETURNING) @@ -1081,19 +1111,29 @@ pub fn add_unit_aggro( return false; } if kind == AggroKind::Damage { - add_tagger(server, owner, unit, amount); + add_tagger(server, owner, unit, damage_credit.unwrap_or(amount)); } let aggro_mul = super::stats::stat(server, unit, super::stats::StatKind::AggroMul); let incoming = super::stats::stat(server, owner, super::stats::StatKind::IncomingAggroMul); let amount = (amount as f32 * (aggro_mul as f32 / 100.0)) as i32; let amount = (amount as f32 * (incoming as f32 / 100.0)) as i32; let unit_id = unit.obj_id(); + if damage_credit.is_some() && amount <= 0 { + // A zero-threat hit still earns damage credit, but creates no aggro/watch. + return owner + .with_unit(|u| u.unit().skill_state.aggro_table.contains_key(&unit_id)) + .unwrap_or(false); + } let existed = owner .with_unit(|u| { let table = &mut u.unit_mut().skill_state.aggro_table; match table.get_mut(&unit_id) { Some(a) => { - a.add(kind, amount); + if damage_credit.is_some() { + a.damage_aggro = a.damage_aggro.saturating_add(amount); + } else { + a.add(kind, amount); + } true } None => { diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs b/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs index 73bff3f176..069d533870 100644 --- a/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs +++ b/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs @@ -98,7 +98,10 @@ pub fn trigger_combat_buffs( } fn level_range(lvl_md: f32, skill_level: i32, va_start: i32, va_end: i32) -> (f32, f32) { - let level_modifier = ((skill_level - 1) / 49 * (va_end - va_start) + va_start) as f32 * 0.01; + // Native 1.2 sub_398A7380: float interpolation, not the mirrored C# integer division. + let level_modifier = ((skill_level as f32 - 1.0) / 49.0 * (va_end as f32 - va_start as f32) + + va_start as f32) + * 0.01; ( lvl_md - level_modifier * lvl_md + 0.5, (level_modifier + 1.0) * lvl_md + 0.5, @@ -125,7 +128,10 @@ pub(super) fn damage_with_aoe( let Some(trg) = args.target.as_obj().filter(|o| o.is_unit()).cloned() else { return; }; - if trg.with_unit(|u| u.unit().hp).unwrap_or(0) <= 0 { + let (target_hp, target_max_hp) = trg + .with_unit(|u| (u.unit().hp, u.unit().max_hp)) + .unwrap_or_default(); + if target_hp <= 0 { return; } let Some(caster) = args.caster.clone() else { @@ -153,7 +159,7 @@ pub(super) fn damage_with_aoe( args.caster_caster, caster.obj_id(), trg.obj_id(), - 1, + 0, 0, ); p.hit_type = SkillHitType::Immune; @@ -265,12 +271,13 @@ pub(super) fn damage_with_aoe( e.level_va_start, e.level_va_end, ); - level_min += a; - level_max += b; + // sub_398A7380 adds 0.5 then truncates each endpoint before composing the base. + level_min += a.trunc(); + level_max += b.trunc(); } let dps_inc = match damage_type { Some(DamageType::Melee) => cs[4] as i32, - Some(DamageType::Magic) => cs[5] as i32 + cs[6] as i32, + Some(DamageType::Magic) => (cs[5] as i32).saturating_add(cs[6] as i32), Some(DamageType::Ranged) => cs[7] as i32, _ => 0, }; @@ -305,9 +312,32 @@ pub(super) fn damage_with_aoe( min = level_min + (variable_damage - scaled); max = level_max + (variable_damage + scaled); } + if e.use_percent_damage { + // 1.2 descriptors retain whole percentages (e.g. 4754/5162: 99% current HP). + // The diagnostic sub_39898330 has separate integer fixed/percent/level terms. + // Server-side percent evaluation is unavailable: /100 and truncation here are + // the compatibility interpretation of those authored rows, not a 10.x rule. + let health = if e.use_current_health { + target_hp + } else { + target_max_hp + } + .max(0); + let percent = |ratio: i32| { + (i64::from(health) * i64::from(ratio) / 100).clamp(0, i64::from(i32::MAX)) as f32 + }; + min += percent(e.percent_min); + max += percent(e.percent_max); + if e.use_fixed_damage { + min += e.fixed_min as f32; + max += e.fixed_max as f32; + } + } min *= e.multiplier; max *= e.multiplier; - let damage_mul = match damage_type { + // sub_3941B030 returns before unit attributes when its unit source is null. + // Doodad/environment sources have no stats; their neutral multiplier is 1. + let damage_mul = match damage_type.filter(|_| caster.is_unit()) { Some(DamageType::Melee) => cs[11] as f32, Some(DamageType::Magic) => cs[12] as f32, Some(DamageType::Ranged) => cs[13] as f32, @@ -375,7 +405,9 @@ pub(super) fn damage_with_aoe( } } } - if e.use_fixed_damage { + // Preserve the existing standalone fixed-damage override. Combined fixed/percent + // descriptors (4821, 4944, 6198, ...) contribute both terms to the base above. + if e.use_fixed_damage && !e.use_percent_damage { min = e.fixed_min as f32; max = e.fixed_max as f32; } @@ -434,17 +466,17 @@ pub(super) fn damage_with_aoe( } _ => final_damage *= ts[7] as f32, } - let value = (final_damage * reduction_mul) as i32; + let value = ((final_damage * reduction_mul) as i32).max(0); // Native 1.2 damage diagnostic sub_39898330 (x2game12.c:1984147-1984167) // multiplies the already integer damage, truncates, then enforces minimum 1. - // Only opted-in plot damage takes this compatibility path; counter policy is - // server-defined (PORTING.md), not evidence of a retail runtime implementation. - let value = aoe_multiplier.map_or(value, |multiplier| { - ((value as f32 * multiplier) as i32).max(1) - }); - let absorbed = (final_damage * (1.0 - reduction_mul)) as i32; - let health_stolen = (value as f32 * (e.health_steal_ratio as f32 / 100.0)) as i32; - let mana_stolen = (value as f32 * (e.mana_steal_ratio as f32 / 100.0)) as i32; + // The final floor is unconditional in this landed-hit diagnostic, including + // multiplier 1. Misses and immunity returned above; only opted-in plots scale. + let value = aoe_multiplier + .map_or(value, |multiplier| (value as f32 * multiplier) as i32) + .max(1); + let absorbed = ((final_damage * (1.0 - reduction_mul)) as i32).max(0); + let health_stolen = ((value as f32 * (e.health_steal_ratio as f32 / 100.0)) as i32).max(0); + let mana_stolen = ((value as f32 * (e.mana_steal_ratio as f32 / 100.0)) as i32).max(0); let caster_t = Target::Obj(caster.clone()); let trg_t = Target::Obj(trg.clone()); let test_drive = matches!(args.cast, CastAction::Buff { buff_id: 6151, .. }); @@ -454,12 +486,15 @@ pub(super) fn damage_with_aoe( return; } unit_combat::reduce_current_hp(server, &trg, Some(&caster), value, KillReason::Damage); - caster.with_unit(|u| u.unit_mut().summarize_damage += value); + caster.with_unit(|u| { + let u = u.unit_mut(); + u.summarize_damage = u.summarize_damage.saturating_add(value); + }); if health_stolen > 0 || mana_stolen > 0 { let pts = caster.with_unit(|u| { let u = u.unit_mut(); - u.hp = u.max_hp.min(u.hp + health_stolen); - u.mp = u.max_mp.min(u.mp + mana_stolen); + u.hp = u.max_hp.min(u.hp.saturating_add(health_stolen)); + u.mp = u.max_mp.min(u.mp.saturating_add(mana_stolen)); (u.hp, u.mp) }); if let Some((hp, mp)) = pts { @@ -548,7 +583,8 @@ pub(super) fn damage_with_aoe( }, ); // Npc.OnDamageReceived: aggro + AI (npc subsystem) - unit_combat::add_unit_aggro(server, &trg, AggroKind::Damage, &caster, value); + let threat = ((value as f32 * e.aggro_multiplier) as i32).max(0); + unit_combat::add_damage_aggro(server, &trg, &caster, value, threat); server .systems .skills @@ -1107,17 +1143,5 @@ pub fn level_damage_range( } #[cfg(test)] -mod tests { - use super::*; - - #[test] - fn level_range_matches_csharp_integer_math() { - // (Level - 1) / 49 is an integer division: levels 1..49 use VaStart only. - let (lo, hi) = level_damage_range(100.0, 1.0, 10, 80, 120); - assert!((lo - (100.0 - 0.8 * 100.0 + 0.5)).abs() < 1e-4); - assert!((hi - (1.8 * 100.0 + 0.5)).abs() < 1e-4); - let (lo, hi) = level_damage_range(100.0, 1.0, 50, 80, 120); - assert!((lo - (100.0 - 1.2 * 100.0 + 0.5)).abs() < 1e-4); - assert!((hi - (2.2 * 100.0 + 0.5)).abs() < 1e-4); - } -} +#[path = "damage_pipeline_tests.rs"] +mod damage_pipeline_tests; diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs b/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs new file mode 100644 index 0000000000..33df075cea --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs @@ -0,0 +1,560 @@ +//! Damage pipeline regressions. Native 1.2 evidence: x2game12.c sub_398A7380 +//! (float level range), sub_39898330 (integer terms, final min 1 and late AoE), +//! sub_397C8760/sub_397C7A40/sub_397C85B0 (damage/cast/caster wire fields). +//! Percent evaluation is a compatibility interpretation of actual 1.2 descriptors; +//! the authoritative server formula is unavailable. No 10.x factors are imported. + +use std::sync::Arc; + +use aaemu_commons::PacketStream; + +use crate::data::world_data::SystemFaction; +use crate::data::GameData; +use crate::models::doodad::Doodad; +use crate::models::npc::Npc; +use crate::models::unit::{Bonus, BonusTemplate, UnitAttribute, UnitModifierType}; +use crate::opcodes::sc; +use crate::test_support::TestClient; +use crate::world::{Entity, WorldObject}; + +use super::super::super as skills; +use super::super::EffectSource; +use super::*; + +fn fixture_data() -> GameData { + let mut data = GameData::empty(); + data.formulas = crate::systems::vehicles::stats::tests::formulas( + &[(1, "100000", 14, 5), (2, "1000", 15, 5), (3, "100", 12, 5)], + &[], + ); + for id in [3, 4] { + data.factions.add(SystemFaction { + id, + ..Default::default() + }); + } + data.systems.skills.add_buff(skills::data::BuffTemplate { + id: 900, + kind: 1, + stack_rule: 1, + melee_immune: true, + ..Default::default() + }); + data +} + +fn args(caster: WorldObject, target: WorldObject, level: u8) -> EffectArgs<'static> { + let skill = skills::state::SkillRun::new(Arc::new(skills::tests::skill_template(1)), level); + EffectArgs { + caster_caster: if caster.is_unit() { + SkillCaster::Unit(caster.obj_id()) + } else { + SkillCaster::Doodad(caster.obj_id()) + }, + caster: Some(caster), + target_caster: skills::types::SkillCastTarget::Unit(target.obj_id()), + target: Target::Obj(target), + cast: CastAction::Skill { + skill_id: 1, + tl_id: 0, + }, + source: EffectSource::from_skill(skill), + skill_object: &skills::types::SkillObject::None, + } +} + +fn packet(client: &mut TestClient, caster: u32, target: u32) -> (i32, u16, Vec) { + let frames: Vec<_> = client + .drain() + .into_iter() + .filter(|(op, _)| *op == sc::SCUnitDamagedPacket) + .collect(); + assert_eq!(frames.len(), 1); + let body = frames.into_iter().next().unwrap().1; + // Read in native 1.2 sub_397C8760 order; expected data is not encoded locally. + let mut s = PacketStream::from_bytes(body.clone()); + assert_eq!(s.read_u8().unwrap(), 0); + assert_eq!(s.read_u32().unwrap(), 1); + assert_eq!(s.read_u16().unwrap(), 0); + assert_eq!(s.read_u8().unwrap(), if caster == 0x300 { 4 } else { 0 }); + assert_eq!(s.read_bc().unwrap(), caster); + assert_eq!(s.read_bc().unwrap(), caster); + assert_eq!(s.read_bc().unwrap(), target); + assert_eq!(s.read_u8().unwrap(), 0); + let damage = s.read_pisc_w(3).unwrap(); + assert_eq!(damage[2], 0); + assert_eq!(s.read_pisc_w(3).unwrap(), [0, 0, 0]); + assert_eq!(s.read_u8().unwrap(), 0); + let dice = s.read_u16().unwrap(); + assert_eq!(s.read_u8().unwrap(), 1); + assert_eq!(s.read_u8().unwrap(), 1); + assert_eq!(s.remaining(), 0); + (damage[0] as i32, dice, body) +} + +fn bonus(obj: &WorldObject, attribute: UnitAttribute, value: i32) { + obj.with_unit(|u| { + u.unit_mut().bonuses.add_bonus( + attribute as u32, + Bonus { + template: BonusTemplate { + attribute, + modifier_type: UnitModifierType::Value, + value, + linear_level_bonus: 0, + }, + value, + }, + ) + }); +} + +#[test] +fn damage_pipeline_native_level_endpoints_interpolate_at_every_rank() { + // Actual 1.2 damage effect 1007: level_md .5, VaStart 10, VaEnd 1. + // sub_398A7380: +0.5, then truncation into each integer output. + for (level, expected) in [(1, (45, 55)), (25, (47, 53)), (50, (50, 51))] { + let (lo, hi) = level_damage_range(100.0, 0.5, level, 10, 1); + assert_eq!((lo as i32, hi as i32), expected); + } + for (start, end) in [(10, 1), (1, 15), (10, 15)] { + let ranges: Vec<_> = (1..=50) + .map(|level| level_damage_range(100.0, 0.5, level, start, end)) + .collect(); + for pair in ranges.windows(2) { + if start > end { + assert!(pair[1].0 >= pair[0].0 && pair[1].1 <= pair[0].1); + } else { + assert!(pair[1].0 <= pair[0].0 && pair[1].1 >= pair[0].1); + } + } + } +} + +#[tokio::test] +async fn damage_pipeline_level_ranges_reach_hp_packets_and_threat() { + for (level, range) in [(1, 45..=55), (25, 47..=53), (50, 50..=51)] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + let mut effect = skills::tests::damage_effect(1007, 0); + effect.use_fixed_damage = false; + effect.use_level_damage = true; + effect.level_md = 0.5; + effect.level_va_start = 10; + effect.level_va_end = 1; + client.drain(); + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), level), + None, + ); + let (dealt, dice, _) = packet(&mut client, player.obj_id, npc.obj_id); + assert!(range.contains(&dealt)); + assert_eq!(dice & 0x1f, SkillHitType::MeleeHit as u16); + let n = npc.data(); + assert_eq!(n.unit.hp, 1000 - dealt); + assert_eq!( + n.unit.skill_state.aggro_table[&player.obj_id].damage_aggro, + dealt + ); + } +} + +#[tokio::test] +async fn damage_pipeline_authored_percent_and_current_health_bases() { + // Actual compact flags/percentages: 4754 = 99% current, 5027 = 1% maximum, + // 6047 = 50% maximum, 6198 enables fixed + level + percent together. + // Weapon and level terms are reduced to deterministic values in this fixture. + for (id, current, ratio, fixed, hp, maximum, expected) in [ + (4754, true, 99, false, 501, 1000, 495), + (4754, true, 99, false, 901, 1000, 891), + (5027, false, 1, false, 501, 1001, 10), + (6047, false, 50, false, 901, 1001, 500), + (6198, true, 10, true, 501, 1000, 150), + ] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + let mut effect = skills::tests::damage_effect(id, if fixed { 100 } else { 0 }); + effect.use_fixed_damage = fixed; + effect.use_percent_damage = true; + effect.percent_min = ratio; + effect.percent_max = ratio; + effect.use_current_health = current; + if id == 6198 { + effect.use_level_damage = true; + effect.level_md = 1.0; + } + { + let mut n = npc.data(); + n.unit.hp = hp; + n.unit.max_hp = maximum; + } + client.drain(); + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + ); + let expected = expected + if id == 6198 { 100 } else { 0 }; + assert_eq!(packet(&mut client, player.obj_id, npc.obj_id).0, expected); + let n = npc.data(); + assert_eq!(n.unit.hp, hp - expected); + assert_eq!( + n.unit.skill_state.aggro_table[&player.obj_id].damage_aggro, + expected + ); + } + // use_current_health alone does not enable percentage damage (actual row 4957). + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(fixture_data()); + let mut effect = skills::tests::damage_effect(4957, 100); + effect.use_current_health = true; + effect.percent_min = 90; + effect.percent_max = 90; + client.drain(); + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + ); + assert_eq!(packet(&mut client, player.obj_id, npc.obj_id).0, 100); +} + +#[tokio::test] +async fn damage_pipeline_scaled_threat_preserves_damage_and_kill_credit() { + for multiplier in [0.0, 1.0, 3.0, 100.0] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + let mut effect = skills::tests::damage_effect(2180, 100); + effect.aggro_multiplier = multiplier; + let target = WorldObject::from(&npc); + // Another player tagged first. Inflated threat must not steal its >50% credit. + npc.data().unit.skill_state.tagging.tagger = 0x999; + bonus(&WorldObject::from(&player), UnitAttribute::AggroMul, 50); + bonus(&target, UnitAttribute::IncomingAggroMul, 100); + client.drain(); + damage(&server, &effect, &args((&player).into(), target, 1), None); + let (dealt, _, body) = packet(&mut client, player.obj_id, npc.obj_id); + assert_eq!(dealt, 100); + // Literal native 1.2 wire fixture (cast skill 1, unit 0x100 -> 0x200, + // damage 100, absorbed/mana zero, melee hit). sub_397C8760, not a round trip. + assert_eq!( + body, + [ + 0, 1, 0, 0, 0, 0, 0, // cast + 0, 0, 1, 0, // unit caster + 0, 1, 0, 0, 2, 0, 0, // source, target, crime + 0, 100, 0, 0, // damage/absorbed/unused PISC + 0, 0, 0, 0, // mana PISC + 0, 0x21, 1, 1, 1, // holdable, dice, flags + ] + ); + let n = npc.data(); + assert_eq!(n.unit.hp, 900); + assert_eq!(n.unit.skill_state.tagging.taggers, [(player.obj_id, 100)]); + assert_eq!(n.unit.skill_state.tagging.tagger, 0x999); + if multiplier == 0.0 { + assert!(n.unit.skill_state.aggro_table.is_empty()); + assert!(!server + .systems + .skills + .aggro_watch + .lock() + .unwrap() + .contains_key(&player.obj_id)); + } else { + assert_eq!( + n.unit.skill_state.aggro_table[&player.obj_id].damage_aggro, + (100.0 * multiplier * 1.5 * 2.0) as i32 + ); + } + } +} + +struct Armored; +impl skills::ext::NpcSkillHooks for Armored { + fn npc_attribute(&self, _: &GameServer, _: &Npc, attr: StatKind) -> Option { + (attr == StatKind::Armor).then_some(5300.0) + } +} + +#[tokio::test] +async fn damage_pipeline_minimum_and_late_aoe_apply_once_after_armor() { + for (amount, aoe, expected) in [ + (7, None, 3), + (7, Some(0.9), 2), + (1, None, 1), + (1, Some(0.1), 1), + (0, None, 1), + (-100, None, 1), + ] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + server.systems.skills.ext.npcs.install(Arc::new(Armored)); + let effect = skills::tests::damage_effect(1, amount); + client.drain(); + damage_with_aoe( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + aoe, + ); + assert_eq!(packet(&mut client, player.obj_id, npc.obj_id).0, expected); + assert_eq!(npc.data().unit.hp, 1000 - expected); + } +} + +#[tokio::test] +async fn damage_pipeline_percent_descriptor_multiplier_and_aoe_each_apply_once() { + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(fixture_data()); + let mut effect = skills::tests::damage_effect(5839, 0); + effect.use_fixed_damage = false; + effect.use_percent_damage = true; + effect.percent_min = 70; + effect.percent_max = 70; + effect.multiplier = 0.5; + client.drain(); + damage_with_aoe( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + Some(0.9), + ); + // 1000 max HP * 70% * descriptor .5 -> integer 350 * AoE .9 -> 315. + assert_eq!(packet(&mut client, player.obj_id, npc.obj_id).0, 315); + assert_eq!(npc.data().unit.hp, 685); + assert_eq!( + npc.data().unit.skill_state.aggro_table[&player.obj_id].damage_aggro, + 315 + ); +} + +#[tokio::test] +async fn damage_pipeline_misses_and_immunity_stay_zero_with_or_without_aoe() { + for aoe in [None, Some(0.1)] { + for immune in [false, true] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + let a = args((&player).into(), (&npc).into(), 1); + if immune { + buffs::apply_template( + &server, + server.game_data.systems.skills.buff(900).unwrap(), + a.caster.as_ref(), + &a.caster_caster, + &WorldObject::from(&npc), + None, + ); + } else { + a.source + .skill + .as_ref() + .unwrap() + .state() + .hit_types + .insert(npc.obj_id, SkillHitType::MeleeMiss); + } + client.drain(); + damage_with_aoe( + &server, + &skills::tests::damage_effect(1, 100), + &a, + None, + aoe, + ); + let (dealt, dice, _) = packet(&mut client, player.obj_id, npc.obj_id); + assert_eq!(dealt, 0); + assert_eq!( + dice & 0x1f, + if immune { + SkillHitType::Immune + } else { + SkillHitType::MeleeMiss + } as u16 + ); + let n = npc.data(); + assert_eq!(n.unit.hp, 1000); + assert!(n.unit.skill_state.aggro_table.is_empty()); + assert!(n.unit.skill_state.tagging.taggers.is_empty()); + } + } +} + +#[tokio::test] +async fn damage_pipeline_nonunit_sources_and_hostile_target_authority() { + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(fixture_data()); + let mut d = Doodad::new(1); + d.transform.set_xyz(100.0, 100.0, 100.0); + let doodad = Entity::new(0x300, d); + server + .world + .world(0) + .unwrap() + .spawn(&doodad, &server.view_ctx()); + let effect = skills::tests::damage_effect(1, 100); + client.drain(); + damage( + &server, + &effect, + &args((&doodad).into(), (&npc).into(), 1), + None, + ); + assert_eq!(packet(&mut client, doodad.obj_id, npc.obj_id).0, 100); + assert_eq!(npc.data().unit.hp, 900); + assert!(npc.data().unit.skill_state.tagging.taggers.is_empty()); + let mut percent = skills::tests::damage_effect(861, 0); + percent.use_fixed_damage = false; + percent.use_percent_damage = true; + percent.percent_min = 35; + percent.percent_max = 35; + damage( + &server, + &percent, + &args((&doodad).into(), (&npc).into(), 1), + None, + ); + assert_eq!(packet(&mut client, doodad.obj_id, npc.obj_id).0, 350); + assert_eq!(npc.data().unit.hp, 550); + player.data().unit.faction_id = 4; + npc.data().unit.faction_id = 4; + client.drain(); + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + ); + assert!(client + .drain() + .into_iter() + .all(|(op, _)| op != sc::SCUnitDamagedPacket)); + assert_eq!(npc.data().unit.hp, 550); + npc.data().unit.faction_id = 3; + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + ); + assert_eq!(packet(&mut client, player.obj_id, npc.obj_id).0, 100); + assert_eq!(npc.data().unit.hp, 450); + damage( + &server, + &effect, + &args((&player).into(), (&doodad).into(), 1), + None, + ); + assert!(client + .drain() + .into_iter() + .all(|(op, _)| op != sc::SCUnitDamagedPacket)); +} + +#[tokio::test] +async fn damage_pipeline_npc_percent_attacks_select_pre_hit_player_hp() { + for (current, expected) in [(true, 495), (false, 990)] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + { + let mut p = player.data(); + p.unit.hp = 1001; + p.unit.max_hp = 2001; + } + let mut effect = skills::tests::damage_effect(4754, 0); + effect.use_fixed_damage = false; + effect.use_percent_damage = true; + effect.use_current_health = current; + effect.percent_min = 99; + effect.percent_max = 99; + // 5300 armor would halve melee damage; keep this sample at 0 armor, and + // use 50% incoming damage to observe both bases without killing the player. + bonus( + &WorldObject::from(&player), + UnitAttribute::IncomingMeleeDamageMul, + -500, + ); + client.drain(); + damage( + &server, + &effect, + &args((&npc).into(), (&player).into(), 1), + None, + ); + assert_eq!(packet(&mut client, npc.obj_id, player.obj_id).0, expected); + assert_eq!(player.data().unit.hp, 1001 - expected); + } +} + +#[tokio::test] +async fn damage_pipeline_new_threat_saturates_and_legacy_zero_callers_are_unchanged() { + let (server, _client, player, npc) = skills::cast_validation_tests::fixture(fixture_data()); + let target = WorldObject::from(&npc); + let caster = WorldObject::from(&player); + unit_combat::add_unit_aggro(&server, &target, AggroKind::Damage, &caster, 0); + assert!(npc + .data() + .unit + .skill_state + .aggro_table + .contains_key(&player.obj_id)); + unit_combat::add_damage_aggro(&server, &target, &caster, 10, i32::MAX); + unit_combat::add_damage_aggro(&server, &target, &caster, 10, i32::MAX); + let n = npc.data(); + assert_eq!( + n.unit.skill_state.aggro_table[&player.obj_id].damage_aggro, + i32::MAX + ); + assert_eq!(n.unit.skill_state.tagging.taggers, [(player.obj_id, 20)]); +} + +#[tokio::test] +async fn damage_pipeline_extreme_and_negative_inputs_never_heal_or_wrap() { + for amount in [i32::MIN, i32::MAX] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + player.data().unit.summarize_damage = i32::MAX; + player.data().unit.hp = 50; + let mut effect = skills::tests::damage_effect(1, amount); + effect.health_steal_ratio = i32::MAX; + client.drain(); + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + ); + let dealt = packet(&mut client, player.obj_id, npc.obj_id).0; + assert_eq!(dealt, amount.max(1)); + assert_eq!(npc.data().unit.hp, (1000_i32).saturating_sub(dealt).max(0)); + assert_eq!(player.data().unit.summarize_damage, i32::MAX); + assert!(player.data().unit.hp >= 50); + } +} + +#[tokio::test] +async fn damage_pipeline_percent_uses_wide_arithmetic_and_never_emits_negative_damage() { + for ratio in [i32::MIN, i32::MAX] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + npc.data().unit.max_hp = i32::MAX; + let mut effect = skills::tests::damage_effect(1, 0); + effect.use_fixed_damage = false; + effect.use_percent_damage = true; + effect.percent_min = ratio; + effect.percent_max = ratio; + client.drain(); + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + ); + let expected = if ratio < 0 { 1 } else { i32::MAX }; + assert_eq!(packet(&mut client, player.obj_id, npc.obj_id).0, expected); + assert_eq!(npc.data().unit.hp, 1000_i32.saturating_sub(expected).max(0)); + } +} From c173db93e1b3aa49011d492f73f78930f18cdb77 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:22:44 -0400 Subject: [PATCH 24/66] test(game): initialize complete fixtures and pause channel time --- .../src/systems/economy/bench_tests.rs | 16 ++++++++++++-- .../src/systems/skills/modifier_flow_tests.rs | 22 ++++++++++++------- .../src/systems/skills/plot_aoe_tests.rs | 3 ++- 3 files changed, 30 insertions(+), 11 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs b/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs index a9249f3807..6f51662bca 100644 --- a/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs @@ -234,8 +234,19 @@ fn fixture(template: u32, group: u32, cast_time: i32) -> Fixture { ); client.conn.active_char = Some(visitor.clone()); owner_client.conn.active_char = Some(owner.clone()); - visitor.data().labor_power = 1000; - owner.data().labor_power = 1000; + // Real characters have one entry per actability group. Construction (19) is + // required by ChangeLabor; omitting it makes the production path reject the debit. + for player in [&visitor, &owner] { + let mut c = player.data(); + c.labor_power = 1000; + c.actability + .actabilities + .push(crate::models::char_data::Actability { + id: 19, + point: 0, + step: 0, + }); + } server.names.add_character(1, "Visitor", 1001); server.names.add_character(2, "Owner", 1002); let mut house = House::new(1, 267); @@ -311,6 +322,7 @@ async fn private_farm_visitor_crafts_tax_at_all_eight_authored_plaques_for_200_l request(&f.server, &mut f.client, TAX, BENCH, 1).await; assert_eq!(certificates(&f.visitor), 5, "plaque {template}"); assert_eq!(f.visitor.data().labor_power, 800, "plaque {template}"); + assert_eq!(f.visitor.data().actability.actabilities[0].point, 200); } } diff --git a/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs b/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs index 19f01ce2bb..3d5464fef2 100644 --- a/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs @@ -27,7 +27,7 @@ fn data() -> GameData { let mut data = GameData::empty(); data.experience = test_experience(55); data.formulas = crate::systems::vehicles::stats::tests::formulas( - &[(1, "100000", 14, 5), (2, "1000", 15, 5)], + &[(1, "100000", 14, 0), (2, "1000", 15, 0)], &[], ); data @@ -627,7 +627,7 @@ async fn modifier_area_buff_expands_real_target_selection_in_meters() { } } -#[tokio::test] +#[tokio::test(start_paused = true)] async fn modifier_channel_packet_and_ticks_share_a_snapshot_of_duration() { for boosted in [false, true] { let mut data = data(); @@ -672,13 +672,19 @@ async fn modifier_channel_packet_and_ticks_share_a_snapshot_of_duration() { let wire_duration = i16::from_le_bytes(fired[17..19].try_into().unwrap()); assert_eq!(wire_duration, if boosted { 50 } else { 30 }); skills::buffs::remove_buff(&server, &WorldObject::from(&player), 5326); - tokio::time::sleep(Duration::from_millis(270)).await; + // Install the spawned timers, then visit each deadline. Wall-clock sleeps + // can skip a tick under unrelated machine load and don't test this snapshot. + tokio::task::yield_now().await; + for _ in 0..5 { + tokio::time::advance(Duration::from_millis(50)).await; + tokio::task::yield_now().await; + } + tokio::time::advance(Duration::from_millis(20)).await; + tokio::task::yield_now().await; assert_eq!(player.data().unit.skill_state.skill_task.is_some(), boosted); - let deadline = tokio::time::Instant::now() + Duration::from_secs(2); - while player.data().unit.skill_state.skill_task.is_some() - && tokio::time::Instant::now() < deadline - { - tokio::time::sleep(Duration::from_millis(10)).await; + for step in [30, 50, 50, 50] { + tokio::time::advance(Duration::from_millis(step)).await; + tokio::task::yield_now().await; } assert!(player.data().unit.skill_state.skill_task.is_none()); let packets = effects(&mut client); diff --git a/rust/crates/aaemu-game/src/systems/skills/plot_aoe_tests.rs b/rust/crates/aaemu-game/src/systems/skills/plot_aoe_tests.rs index 84e0d22cb1..0e08499fc1 100644 --- a/rust/crates/aaemu-game/src/systems/skills/plot_aoe_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/plot_aoe_tests.rs @@ -55,7 +55,7 @@ fn event(id: u32, diminishing: bool, effects: Vec) -> PlotEvent fn data() -> GameData { let mut data = GameData::empty(); data.formulas = crate::systems::vehicles::stats::tests::formulas( - &[(1, "100000", 14, 5), (2, "1000", 15, 5)], + &[(1, "100000", 14, 0), (2, "1000", 15, 0)], &[], ); for id in [3, 4] { @@ -111,6 +111,7 @@ fn data() -> GameData { fn fixture(data: GameData, count: u32) -> (Arc, TestClient, PlayerRef, Vec) { let (server, client, player, _) = super::super::cast_validation_tests::fixture(data); player.data().unit.faction_id = 4; + super::super::stats::refresh_cached_stats(&server, &WorldObject::from(&player)); let targets = (0..count) .map(|i| { let mut npc = Npc::new(1); From 28101e8640e4ecca74b15c679bdc9e8e46e848ce Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:26:38 -0400 Subject: [PATCH 25/66] docs: record executable checks and compatibility policy repairs --- rust/docs/audit-repair-status.json | 38 +++++++++++++++++------------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json index f7156879e4..38a2e71ec4 100644 --- a/rust/docs/audit-repair-status.json +++ b/rust/docs/audit-repair-status.json @@ -28,26 +28,27 @@ }, { "id": "merchant-grade", - "status": "merged_pending_validation", + "status": "focused_passed_full_gate_pending", "owner": "audit-economy", "commit": "3de467a85f1c5aeed2efb2071030058ffeb8b29c" }, { "id": "craft-grade-flags", - "status": "merged_pending_validation", + "status": "focused_passed_full_gate_pending", "owner": "audit-economy", "commit": "3de467a85f1c5aeed2efb2071030058ffeb8b29c" }, { "id": "web-api-authentication", - "status": "merged_pending_validation", + "status": "focused_passed_full_gate_pending", "owner": "audit-web", "commit": "24b4699887d5350bc1a9e6f89267f98469fde8eb" }, { "id": "housing-bench-plaque-permissions", "status": "merged_pending_validation", - "commit": "e2e9744b59d094b2ceb74c63626336664071a59f" + "commit": "e2e9744b59d094b2ceb74c63626336664071a59f", + "note": "New flow fixtures corrected to initialize Construction19; strict200LP assertions awaiting rerun." }, { "id": "craft-bench-pack-and-required-doodad", @@ -56,7 +57,7 @@ }, { "id": "closed-and-unknown-zones", - "status": "merged_pending_validation", + "status": "focused_passed_full_gate_pending", "commit": "e9a870b8c71e8e4dbf7509d7e72bbb33bcfef20a", "note": "Unknown keys remain neutral; no invented safe destination. Parent corrected Doodad transform field after first compile check." }, @@ -85,9 +86,9 @@ }, { "id": "aoe-diminishing", - "status": "loader_merged_runtime_open", - "commit": "04783cdeb438b3fefb551dbd05edb62255a11bff", - "note": "Native counter/reset writer is under a separate focused trace; runtime is not repaired." + "status": "runtime_merged_pending_retest", + "commit": "e6f6920da", + "note": "Plot-scoped first-seen distinct-target ranks/reset/clamp are explicit compatibility policy. Nativeworld-servercounter unavailable.10/11firstflows passed; health fixture corrected." }, { "id": "skill-and-buff-modifiers", @@ -113,9 +114,9 @@ }, { "id": "buff-breakers", - "status": "draft_not_merged", - "commit": "0d935802542b3ef38a7114f5ccdde5ea7459f2b3", - "note": "Accepted-event implementation drafted; independent native timing trace pending." + "status": "runtime_merged_pending_validation", + "commit": "8fe6039ee99476591ec43a5c0f513fd05e25d658", + "note": "Accepted-state compatibility policy. Lifetime identities stop reentrant Started callbacks leaking modifiers; native timing remains unverified." }, { "id": "buff-taunts", @@ -131,7 +132,8 @@ }, { "id": "shared-cooldown-tags", - "status": "queued" + "status": "revision_in_progress", + "note": "Native tag-list UI and matching GM server-state reset required before merge." }, { "id": "xp-buff-multiplier", @@ -140,11 +142,13 @@ }, { "id": "zone-banned-item-and-skill-tags", - "status": "implementing" + "status": "partial_merged_pending_validation", + "commit": "9dd3453085a829513db7bff1e1a80cc55a9963c3", + "note": "324unconditional rules enforced;9period24rules and Library1581missingmembership remain open." }, { "id": "unit-and-primary-stat-limits", - "status": "queued" + "status": "implementing" }, { "id": "prison-and-other-skill-restrictions", @@ -152,7 +156,9 @@ }, { "id": "damage-threat-percent-health-and-level-interpolation", - "status": "queued" + "status": "partial_merged_pending_validation", + "commit": "917759c3fb637dec43adbb2d930da37f31b4a71a", + "note": "Authored floatlevel range/threat/HP-percent and numeric guards; percent/HP unit interpretation documented, target_health predicates remain open." }, { "id": "recipe-learning", @@ -204,7 +210,7 @@ }, { "id": "mail-expiry-throttling-feedback-and-pagination", - "status": "queued" + "status": "implementing" }, { "id": "npc-physical-enchant", From 47217398ade1f50f9957b15a1e6ec1a72428eaa7 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:27:57 -0400 Subject: [PATCH 26/66] fix(game): keep shared cooldowns in native tag records Use SCCooldownsPacket skill and tag lists independently, sorted and capped at 150 entries each. Preserve remaining-as-total snapshots and saturate remaining-time arithmetic. Tagged starts send only the current individual timer plus the shared tag timer, keeping longer individual expiries intact and removing all-template scans under the unit lock. Reset the caster current individual and shared tag stores together when GM cooldown ignore completes a skill. Address the native reset packet to that caster while sending through its owner, and preserve unrelated groups, other members individual timers and foreign units. Retain and adapt the original cooldown regressions to native two-list bytes. Add four focused regressions for literal current-skill/tag update bytes, ignore-on/cast/reset/off admission agreement before the old expiry, controlled-unit reset identity, and independent sorting/caps/overflow safety. Preserve merged parent fixture repairs, zone-tag enforcement and AoE work. Validation: standalone rustfmt with edition 2021 and skip_children, rustfmt --check, git diff --check and staged source review. No Cargo commands, builds, tests, target directory, clippy, live verification, full CI, push or land. Parent selectors: cooldown_tag_flow_tests, skills::packets::tests::small_packets, plot_only_skill. Native evidence: 397B2350, 39899D40, 3989A290 and 391D6420/39899EC0/39899F00. Co-Authored-By: Codex --- rust/crates/aaemu-game/src/models/unit.rs | 8 + .../systems/skills/cooldown_tag_flow_tests.rs | 374 +++++++++++++++--- .../aaemu-game/src/systems/skills/packets.rs | 42 +- .../aaemu-game/src/systems/skills/skill.rs | 58 +-- rust/crates/aaemu-game/src/world/session.rs | 7 +- 5 files changed, 365 insertions(+), 124 deletions(-) diff --git a/rust/crates/aaemu-game/src/models/unit.rs b/rust/crates/aaemu-game/src/models/unit.rs index 7d2f5eacd2..9fa4366a8b 100644 --- a/rust/crates/aaemu-game/src/models/unit.rs +++ b/rust/crates/aaemu-game/src/models/unit.rs @@ -417,6 +417,14 @@ impl UnitCooldowns { individual || (tag_id != 0 && self.tag_cooldowns.contains_key(&tag_id)) } + /// Match the native skill/tag reset without touching other individual timers or groups. + pub fn remove_skill_cooldown(&mut self, skill_id: u32, tag_id: u32) { + self.remove_cooldown(skill_id); + if tag_id != 0 { + self.tag_cooldowns.remove(&tag_id); + } + } + /// `RemoveCooldown(skillId)`. pub fn remove_cooldown(&mut self, skill_id: u32) { self.cooldowns.remove(&skill_id); diff --git a/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs b/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs index f95ae5c40a..08b1f7317b 100644 --- a/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs @@ -2,9 +2,10 @@ //! each followed by (id, total, remaining) u32 triples; 39899D40 appends them, //! 3989A290 selects the longest skill/tag timer, and 39899F90 never shortens a tag. //! UI baselib.lua:346-383 consumes remaining/total on item/skill_cooldown updates. -//! Authored cooldown_tag_id membership is separate from tagged_skills (39 positive -//! authored members lack the matching row in the 1.2 compact export). Expected bytes -//! below are literal native-reader fixtures, never generated by a second encoder. +//! Server membership comes from authored cooldown_tag_id, never a generic-tag lookup. +//! Shared state stays in the native tag list so one native tag reset clears the same +//! state on both sides. Expected bytes are literal native-reader fixtures, never +//! generated by a second encoder. use std::sync::Arc; @@ -21,6 +22,7 @@ use crate::world::{now_ms, NpcRef, PlayerRef, WorldObject}; use skills::data::SkillTemplate; use skills::handlers::{start_skill, CSStartSkillPacket}; +use skills::packets::SCCooldownsPacket; use skills::types::{skill_result, SkillCastTarget, SkillCaster, SkillObject}; const POTION: u32 = 11717; @@ -88,7 +90,67 @@ fn cast(server: &GameServer, client: &mut TestClient, id: u32, target: u32) { start_skill(server, &mut client.conn, packet); } -fn cooldown_entries(frames: &[(u16, Vec)]) -> Vec<(u32, u32, u32)> { +type UiCooldownEntry = (u32, u32, u32); + +/// Minimal native 397B2350/39899D40 reader and 3989A290 remaining-time lookup. +#[derive(Debug, Default)] +struct UiCooldowns { + skills: Vec, + tags: Vec, +} + +impl UiCooldowns { + fn read(bytes: &[u8]) -> Self { + let mut body = PacketStream::from_bytes(bytes.to_vec()); + let mut read_list = || { + let count = body.read_i32().unwrap(); + assert!((0..=150).contains(&count)); + (0..count) + .map(|_| { + ( + body.read_u32().unwrap(), + body.read_u32().unwrap(), + body.read_u32().unwrap(), + ) + }) + .collect::>() + }; + let skills = read_list(); + let tags = read_list(); + assert_eq!(bytes.len(), 8 + (skills.len() + tags.len()) * 12); + Self { skills, tags } + } + + fn remaining(&self, skill_id: u32, authored_tag: u32) -> u32 { + self.skills + .iter() + .filter(|e| e.0 == skill_id) + .chain( + self.tags + .iter() + .filter(|e| authored_tag != 0 && e.0 == authored_tag), + ) + .map(|e| e.2) + .max() + .unwrap_or(0) + } + + /// Native 391D6420 -> 39899EC0/39899F00 clears the named record in each list. + fn reset(&mut self, bytes: &[u8], unit_id: u32) { + let mut body = PacketStream::from_bytes(bytes.to_vec()); + assert_eq!(body.read_bc().unwrap(), unit_id); + let skill_id = body.read_u32().unwrap(); + let tag = body.read_u32().unwrap(); + assert!(!body.read_bool().unwrap()); + for (list, id) in [(&mut self.skills, skill_id), (&mut self.tags, tag)] { + if let Some(entry) = list.iter_mut().find(|e| e.0 == id) { + entry.2 = 0; + } + } + } +} + +fn cooldown_lists(frames: &[(u16, Vec)]) -> UiCooldowns { let packets: Vec<_> = frames .iter() .filter(|(op, _)| *op == sc::SCCooldownsPacket) @@ -98,21 +160,7 @@ fn cooldown_entries(frames: &[(u16, Vec)]) -> Vec<(u32, u32, u32)> { 1, "one UI application per accepted tagged cast" ); - let mut body = PacketStream::from_bytes(packets[0].1.clone()); - let count = body.read_i32().unwrap(); - let entries = (0..count) - .map(|_| { - ( - body.read_u32().unwrap(), - body.read_u32().unwrap(), - body.read_u32().unwrap(), - ) - }) - .collect(); - // Explicit skill projection avoids treating unrelated generic tags as authored members. - assert_eq!(body.read_i32().unwrap(), 0); - assert_eq!(packets[0].1.len(), 8 + count as usize * 12); - entries + UiCooldowns::read(&packets[0].1) } fn assert_denied(frames: &[(u16, Vec)], result: u8) { @@ -140,13 +188,14 @@ async fn packet_flow_denies_never_used_member_and_preserves_long_individual_cool cast(&server, &mut client, POTION, npc.obj_id); let frames = client.drain(); assert!(frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); - let entries = cooldown_entries(&frames); - assert_eq!( - entries.iter().map(|e| e.0).collect::>(), - [POTION, POTION_NEXT] - ); - assert!(entries[0].2 <= 60_000 && entries[0].2 > 59_000); - assert!(entries[1].2 > 119_000); + let ui = cooldown_lists(&frames); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.skills[0].0, POTION); + assert_eq!(ui.tags.len(), 1); + assert_eq!(ui.tags[0].0, 144); + assert!(ui.remaining(POTION_NEXT, 144) <= 60_000); + assert!(ui.remaining(POTION_NEXT, 144) > 59_000); + assert!(!ui.skills.iter().any(|e| e.0 == POTION_NEXT)); assert_eq!( player.data().unit.cooldowns.cooldowns[&POTION_NEXT], long_end @@ -164,21 +213,63 @@ async fn packet_flow_denies_never_used_member_and_preserves_long_individual_cool .contains_key(&POTION_NEXT)); } +#[tokio::test] +async fn native_start_update_bytes_keep_current_individual_separate_from_shared_expiry() { + let (server, mut client, player, _) = fixture(data()); + { + let mut p = player.data(); + p.unit.cooldowns.add_cooldown(POTION, 120_000, 1000); + p.unit.cooldowns.add_tag_cooldown(144, 180_000, 1000); + } + let caster = WorldObject::from(&player); + let skill = super::new_skill_for( + &server, + server + .game_data + .systems + .skills + .skill(POTION) + .unwrap() + .clone(), + Some(&caster), + ); + super::start_skill_cooldown(&server, &skill, &caster, 1000); + let frames = client.drain(); + let packet = frames + .iter() + .find(|(op, _)| *op == sc::SCCooldownsPacket) + .unwrap(); + // 397B2350: one skill (11717, 120000, 120000), then one tag (144, 180000, 180000). + assert_eq!( + packet.1, + [ + 1, 0, 0, 0, 0xc5, 0x2d, 0, 0, 0xc0, 0xd4, 1, 0, 0xc0, 0xd4, 1, 0, 1, 0, 0, 0, 0x90, 0, + 0, 0, 0x20, 0xbf, 2, 0, 0x20, 0xbf, 2, 0, + ] + ); + let ui = cooldown_lists(&frames); + assert_eq!(ui.skills[0].2, 120_000); + assert_eq!(ui.remaining(POTION, 144), 180_000); + assert_eq!(player.data().unit.cooldowns.cooldowns[&POTION], 121_000); + assert_eq!(player.data().unit.cooldowns.tag_cooldowns[&144], 181_000); +} + #[tokio::test] async fn food_glider_zero_duration_members_and_players_have_independent_groups() { let (server, mut client, player, npc) = fixture(data()); - for (id, members) in [ - (POTION, vec![POTION, POTION_NEXT]), - (FOOD, vec![FOOD, FOOD_NEXT]), - (GLIDER, vec![GLIDER_ZERO, GLIDER]), + for (id, member, tag) in [ + (POTION, POTION_NEXT, 144), + (FOOD, FOOD_NEXT, 9), + (GLIDER, GLIDER_ZERO, 296), ] { player.data().unit.mp = 100; cast(&server, &mut client, id, npc.obj_id); - let entries = cooldown_entries(&client.drain()); - assert_eq!( - entries.into_iter().map(|e| e.0).collect::>(), - members - ); + let ui = cooldown_lists(&client.drain()); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.skills[0].0, id); + assert_eq!(ui.tags.len(), 1); + assert_eq!(ui.tags[0].0, tag); + assert!(ui.remaining(member, tag) > 0); } cast(&server, &mut client, GLIDER_ZERO, npc.obj_id); assert_denied(&client.drain(), skill_result::COOLDOWN_TIME); @@ -200,7 +291,9 @@ async fn food_glider_zero_duration_members_and_players_have_independent_groups() client.drain(); cast(&server, &mut other, POTION_NEXT, npc.obj_id); assert_eq!(other_player.data().unit.mp, 75); - assert_eq!(cooldown_entries(&other.drain()).len(), 2); + let ui = cooldown_lists(&other.drain()); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.tags.len(), 1); assert!(!client.drain_ops().contains(&sc::SCCooldownsPacket)); } @@ -240,8 +333,11 @@ async fn group_uses_started_skills_cooldown_modifier_and_expiry_allows_a_new_mem synergy: false, }]); cast(&server, &mut client, POTION, npc.obj_id); - let entries = cooldown_entries(&client.drain()); - assert!(entries.iter().all(|e| e.2 > 29_000 && e.2 <= 30_000)); + let ui = cooldown_lists(&client.drain()); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.tags.len(), 1); + assert!(ui.remaining(POTION_NEXT, 144) > 29_000); + assert!(ui.remaining(POTION_NEXT, 144) <= 30_000); player .data() .unit @@ -249,9 +345,13 @@ async fn group_uses_started_skills_cooldown_modifier_and_expiry_allows_a_new_mem .tag_cooldowns .insert(144, now_ms() - 1); cast(&server, &mut client, POTION_NEXT, npc.obj_id); - let entries = cooldown_entries(&client.drain()); - assert!(entries.iter().find(|e| e.0 == POTION).unwrap().2 > 29_000); - assert!(entries.iter().find(|e| e.0 == POTION_NEXT).unwrap().2 <= 3_000); + let ui = cooldown_lists(&client.drain()); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.skills[0].0, POTION_NEXT); + assert!(ui.skills[0].2 <= 3_000); + assert_eq!(ui.tags.len(), 1); + assert!(ui.tags[0].2 <= 3_000); + assert!(player.data().unit.cooldowns.cooldowns[&POTION] > now_ms() + 29_000); assert_eq!(player.data().unit.mp, 50); } @@ -298,13 +398,15 @@ async fn cast_cost_failure_and_new_group_during_cast_do_not_start_cooldowns() { } } -#[tokio::test] +#[tokio::test(start_paused = true)] async fn channel_commits_cost_and_shared_cooldown_once_and_stop_keeps_them() { let mut data = data(); edit(&mut data, FOOD, |s| s.channeling_time = 60_000); let (server, mut client, player, npc) = fixture(data); cast(&server, &mut client, FOOD, npc.obj_id); - assert_eq!(cooldown_entries(&client.drain()).len(), 2); + let ui = cooldown_lists(&client.drain()); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.tags.len(), 1); assert_eq!(player.data().unit.mp, 75); let task = player.data().unit.skill_state.skill_task.clone().unwrap(); let before = player.data().unit.cooldowns.clone(); @@ -342,6 +444,126 @@ async fn gm_override_bypasses_shared_admission_and_resets_the_native_tag() { assert!(client.drain_ops().contains(&sc::SCSkillFiredPacket)); } +#[tokio::test] +async fn gm_ignore_then_off_clears_the_same_native_records_and_preserves_longer_members() { + let (server, mut client, player, npc) = fixture(data()); + let now = now_ms(); + { + let mut p = player.data(); + let cds = &mut p.unit.cooldowns; + cds.add_cooldown(POTION, 60_000, now); + cds.add_cooldown(POTION_NEXT, 120_000, now); + cds.add_cooldown(FOOD, 60_000, now); + cds.add_tag_cooldown(144, 60_000, now); + cds.add_tag_cooldown(9, 60_000, now); + } + let before = player.data().unit.cooldowns.clone(); + // Feed the UI actual encoded server bytes, including a longer individual timer. + let initial = SCCooldownsPacket::from_cooldowns(&before, now); + client.conn.send(&initial); + let mut ui = cooldown_lists(&client.drain()); + assert_eq!(ui.remaining(POTION, 144), 60_000); + assert_eq!(ui.remaining(POTION_NEXT, 144), 120_000); + + let mut other = TestClient::new(&server, 2, 2); + let mut character = test_character(2, "Foreign", 100.0, 100.0); + character.unit.cooldowns = before.clone(); + let foreign = spawn_player(&server, &other, character, 0x101); + other.drain(); + client.drain(); + + player.data().skill_char.ignore_skill_cooldowns = true; + cast(&server, &mut client, POTION, npc.obj_id); + let frames = client.drain(); + assert!(frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + assert!(!frames.iter().any(|(op, _)| *op == sc::SCCooldownsPacket)); + let resets: Vec<_> = frames + .iter() + .filter(|(op, _)| *op == sc::SCSkillCooldownResetPacket) + .collect(); + assert_eq!(resets.len(), 1); + // Literal native 397B5770 record: bc 0x100, skill 11717, tag 144, gcd false. + assert_eq!(resets[0].1, [0, 1, 0, 0xc5, 0x2d, 0, 0, 0x90, 0, 0, 0, 0]); + ui.reset(&resets[0].1, player.obj_id); + player.data().skill_char.ignore_skill_cooldowns = false; + assert!( + now_ms() < before.tag_cooldowns[&144], + "old shared expiry is still in the future" + ); + assert_eq!(ui.remaining(POTION, 144), 0); + assert_eq!(ui.remaining(POTION_NEXT, 144), 120_000); + assert_eq!(ui.remaining(FOOD, 9), 60_000); + { + let p = player.data(); + let cds = &p.unit.cooldowns; + assert!(!cds.cooldowns.contains_key(&POTION)); + assert!(!cds.tag_cooldowns.contains_key(&144)); + assert_eq!(cds.cooldowns[&POTION_NEXT], before.cooldowns[&POTION_NEXT]); + assert_eq!(cds.cooldowns[&FOOD], before.cooldowns[&FOOD]); + assert_eq!(cds.tag_cooldowns[&9], before.tag_cooldowns[&9]); + } + assert_eq!(foreign.data().unit.cooldowns, before); + assert!(!other.drain_ops().contains(&sc::SCSkillCooldownResetPacket)); + + // Ignore is off: the long member still refuses, while the reset skill can start + // again before its original tag expiry, matching the UI's two native stores. + cast(&server, &mut client, POTION_NEXT, npc.obj_id); + assert_denied(&client.drain(), skill_result::COOLDOWN_TIME); + cast(&server, &mut client, POTION, npc.obj_id); + let frames = client.drain(); + assert!(frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + let update = cooldown_lists(&frames); + assert_eq!(update.skills.len(), 1); + assert_eq!(update.skills[0].0, POTION); + assert_eq!(update.tags.len(), 1); + assert_eq!(update.tags[0].0, 144); +} + +#[tokio::test] +async fn gm_reset_targets_the_controlled_units_native_store_instead_of_its_owners() { + let (server, mut client, player, _) = fixture(data()); + let now = now_ms(); + player.data().skill_char.ignore_skill_cooldowns = true; + player + .data() + .unit + .cooldowns + .add_cooldown(POTION, 60_000, now); + player + .data() + .unit + .cooldowns + .add_tag_cooldown(144, 60_000, now); + let owner_cooldowns = player.data().unit.cooldowns.clone(); + let mut data = crate::models::mate::Mate::new(1, 1); + data.owner_obj_id = player.obj_id; + data.unit.cooldowns = owner_cooldowns.clone(); + let mate = crate::world::Entity::new(0x300, data); + let caster = WorldObject::from(&mate); + let skill = super::new_skill_for( + &server, + server + .game_data + .systems + .skills + .skill(POTION) + .unwrap() + .clone(), + Some(&caster), + ); + super::reset_cooldown_if_ignored(&server, &skill, &caster); + let frames = client.drain(); + let reset = frames + .iter() + .find(|(op, _)| *op == sc::SCSkillCooldownResetPacket) + .unwrap(); + // The owner receives the packet, but its bc subject is the mate, 0x300. + assert_eq!(reset.1, [0, 3, 0, 0xc5, 0x2d, 0, 0, 0x90, 0, 0, 0, 0]); + assert!(mate.data().unit.cooldowns.cooldowns.is_empty()); + assert!(mate.data().unit.cooldowns.tag_cooldowns.is_empty()); + assert_eq!(player.data().unit.cooldowns, owner_cooldowns); +} + #[tokio::test] async fn npc_policy_keeps_accepting_server_skills_without_shortening_group_expiry() { let (server, _client, player, npc) = fixture(data()); @@ -376,7 +598,7 @@ async fn npc_policy_keeps_accepting_server_skills_without_shortening_group_expir } #[tokio::test] -async fn select_snapshot_projects_members_and_preserves_long_individual_expiry() { +async fn select_snapshot_keeps_native_lists_and_preserves_long_individual_expiry() { let server = crate::test_support::test_server_with(data()); let mut client = TestClient::new(&server, 1, 1); let now = now_ms(); @@ -392,36 +614,71 @@ async fn select_snapshot_projects_members_and_preserves_long_individual_expiry() .add_tag_cooldown(9, 3_000, now - 10_000); crate::world::session::select_loaded(&server, &mut client.conn, character, Default::default()) .unwrap(); - let entries = cooldown_entries(&client.drain()); - assert_eq!( - entries.iter().map(|e| e.0).collect::>(), - [POTION, POTION_NEXT] - ); - assert!(entries[0].2 > 59_000 && entries[1].2 > 119_000); + let ui = cooldown_lists(&client.drain()); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.skills[0].0, POTION_NEXT); + assert_eq!(ui.tags.len(), 1); + assert_eq!(ui.tags[0].0, 144); + assert!(ui.remaining(POTION, 144) > 59_000); + assert!(ui.remaining(POTION_NEXT, 144) > 119_000); } #[tokio::test] async fn native_snapshot_bytes_use_longest_expiry_and_omit_expired_or_unrelated_members() { - let server = crate::test_support::test_server_with(data()); let mut cooldowns = UnitCooldowns::default(); cooldowns.add_tag_cooldown(144, 60_000, 0); cooldowns.add_cooldown(POTION_NEXT, 120_000, 0); - let packet = super::cooldown_snapshot(&server, &cooldowns, 1000); + let packet = SCCooldownsPacket::from_cooldowns(&cooldowns, 1000); let mut body = PacketStream::new(); packet.write(&mut body); assert_eq!( body.into_bytes(), [ - 2, 0, 0, 0, 0xc5, 0x2d, 0, 0, 0x78, 0xe6, 0, 0, 0x78, 0xe6, 0, 0, 0xc8, 0x2d, 0, 0, - 0xd8, 0xd0, 1, 0, 0xd8, 0xd0, 1, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0xc8, 0x2d, 0, 0, 0xd8, 0xd0, 1, 0, 0xd8, 0xd0, 1, 0, 1, 0, 0, 0, 0x90, 0, + 0, 0, 0x78, 0xe6, 0, 0, 0x78, 0xe6, 0, 0, ] ); assert_eq!( - super::cooldown_snapshot(&server, &cooldowns, 120_000), + SCCooldownsPacket::from_cooldowns(&cooldowns, 120_000), Default::default() ); } +#[test] +fn native_snapshot_lists_are_sorted_capped_independently_and_expiry_safe() { + let mut cds = UnitCooldowns::default(); + for id in (1..=152).rev() { + cds.cooldowns.insert(id, 60_000); + cds.tag_cooldowns.insert(id + 1000, 120_000); + } + cds.cooldowns.insert(0, 1000); + cds.tag_cooldowns.insert(0, 1000); + let packet = SCCooldownsPacket::from_cooldowns(&cds, 1000); + assert_eq!(packet.skills.len(), 150); + assert_eq!(packet.tags.len(), 150); + assert_eq!( + packet.skills.iter().map(|e| e.id).collect::>(), + (1..=150).collect::>() + ); + assert_eq!( + packet.tags.iter().map(|e| e.id).collect::>(), + (1001..=1150).collect::>() + ); + let mut body = PacketStream::new(); + packet.write(&mut body); + let ui = UiCooldowns::read(&body.into_bytes()); + assert_eq!(ui.skills.len(), 150); + assert_eq!(ui.tags.len(), 150); + assert_eq!(ui.remaining(1, 1001), 119_000); + cds.cooldowns.clear(); + cds.tag_cooldowns.clear(); + cds.cooldowns.insert(POTION, i64::MAX); + cds.tag_cooldowns.insert(144, i64::MAX); + let packet = SCCooldownsPacket::from_cooldowns(&cds, i64::MIN); + assert_eq!(packet.skills[0].remaining_ms, u32::MAX); + assert_eq!(packet.tags[0].remaining_ms, u32::MAX); +} + #[tokio::test] async fn zero_negative_and_overflow_durations_never_wrap_or_create_spurious_cooldowns() { for duration in [0, -1, i32::MIN] { @@ -523,8 +780,11 @@ async fn plot_end_keeps_modified_shared_expiry_nonnegative_and_sends_only_one_ui let frames = client.drain(); assert!(frames.iter().any(|(op, _)| *op == sc::SCPlotEndedPacket)); if duration > 0 { - let entries = cooldown_entries(&frames); - assert!(entries.iter().all(|e| e.2 > 29_000 && e.2 <= 30_000)); + let ui = cooldown_lists(&frames); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.tags.len(), 1); + assert!(ui.remaining(POTION_NEXT, 144) > 29_000); + assert!(ui.remaining(POTION_NEXT, 144) <= 30_000); let cds = &player.data().unit.cooldowns; assert_eq!(cds.cooldowns[&POTION], cds.tag_cooldowns[&144]); } else { diff --git a/rust/crates/aaemu-game/src/systems/skills/packets.rs b/rust/crates/aaemu-game/src/systems/skills/packets.rs index c64c192185..d8b50b83ff 100644 --- a/rust/crates/aaemu-game/src/systems/skills/packets.rs +++ b/rust/crates/aaemu-game/src/systems/skills/packets.rs @@ -404,8 +404,8 @@ pub struct CooldownEntry { /// `SCCooldownsPacket`: the unit's running skill / tag cooldowns (`i32` count + entries each). /// The C# only ever sent it empty. The client's record reader (`397b64d0` -> `397b2350`) /// appends to its cooldown manager (an empty packet is not a reset) and holds 150 entries per -/// list, so the writer never emits more. The server tracks no tag cooldowns, and keeps only the -/// end time of a skill cooldown, so `total` is reported as the remaining time. +/// list, so the writer never emits more. The server keeps expiry times for both stores, +/// so `total` is reported as the remaining time. #[derive(Debug, Clone, PartialEq, Eq, Default)] pub struct SCCooldownsPacket { pub skills: Vec, @@ -415,26 +415,28 @@ impl SCCooldownsPacket { /// Entry cap per list of the client's record. pub const MAX_ENTRIES: usize = 150; - /// The still-running cooldowns of `cooldowns` at `now_ms`, ordered by skill id. + /// Still-running individual and shared cooldowns, each ordered by id and capped. pub fn from_cooldowns(cooldowns: &crate::models::unit::UnitCooldowns, now_ms: i64) -> Self { - let mut skills: Vec = cooldowns - .cooldowns - .iter() - .filter(|(_, &end)| end > now_ms) - .map(|(&id, &end)| { - let remaining = (end - now_ms).min(i64::from(u32::MAX)) as u32; - CooldownEntry { - id, - total_ms: remaining, - remaining_ms: remaining, - } - }) - .collect(); - skills.sort_by_key(|e| e.id); - skills.truncate(Self::MAX_ENTRIES); + let entries = |store: &std::collections::HashMap| { + let mut entries: Vec = store + .iter() + .filter(|(_, &end)| end > now_ms) + .map(|(&id, &end)| { + let remaining = end.saturating_sub(now_ms).min(i64::from(u32::MAX)) as u32; + CooldownEntry { + id, + total_ms: remaining, + remaining_ms: remaining, + } + }) + .collect(); + entries.sort_by_key(|e| e.id); + entries.truncate(Self::MAX_ENTRIES); + entries + }; Self { - skills, - tags: Vec::new(), + skills: entries(&cooldowns.cooldowns), + tags: entries(&cooldowns.tag_cooldowns), } } diff --git a/rust/crates/aaemu-game/src/systems/skills/skill.rs b/rust/crates/aaemu-game/src/systems/skills/skill.rs index 06afc3f836..4d83088466 100644 --- a/rust/crates/aaemu-game/src/systems/skills/skill.rs +++ b/rust/crates/aaemu-game/src/systems/skills/skill.rs @@ -180,36 +180,6 @@ fn start_global_cooldown(server: &GameServer, skill: &SkillRef, caster: &WorldOb caster.with_unit(|u| u.unit_mut().global_cooldown_ms = now + ms); } -/// Project shared expiries onto authored members, including members absent from -/// `tagged_skills`. Native 1.2 `3989A290` takes the maximum of skill/tag remaining -/// times; explicit skill entries preserve that rule without cooling unrelated generic tags. -/// `397B2350` reads the existing skill list, then the tag list (id/total/remaining u32). -/// As in the existing reconnect snapshot, total is the remaining time: only expiries are stored. -pub(crate) fn cooldown_snapshot( - server: &GameServer, - cooldowns: &UnitCooldowns, - now: i64, -) -> SCCooldownsPacket { - let mut effective = UnitCooldowns::default(); - effective.cooldowns.clone_from(&cooldowns.cooldowns); - for template in server.game_data.systems.skills.skills.values() { - let tag = template.cooldown_tag_id; - if tag <= 0 { - continue; - } - if let Some(&end) = cooldowns.tag_cooldowns.get(&(tag as u32)) { - if end > now { - effective - .cooldowns - .entry(template.id) - .and_modify(|own| *own = (*own).max(end)) - .or_insert(end); - } - } - } - SCCooldownsPacket::from_cooldowns(&effective, now) -} - fn cooldown_ignored(server: &GameServer, caster: &WorldObject) -> bool { caster .as_player() @@ -273,16 +243,15 @@ fn start_skill_cooldown(server: &GameServer, skill: &SkillRun, caster: &WorldObj if tag == 0 { return None; } - // Send only this group's effective members. In particular, never overwrite - // a longer individual cooldown with the shorter shared expiry. + // Native 1.2 397B2350 keeps these lists separate; 3989A290 takes + // max(individual, tag). Never manufacture individual entries for other members. let mut affected = UnitCooldowns::default(); - for template in server.game_data.systems.skills.skills.values() { - if template.cooldown_tag_id == skill.template.cooldown_tag_id { - let end = cooldowns.tag_cooldowns[&tag] - .max(*cooldowns.cooldowns.get(&template.id).unwrap_or(&0)); - affected.cooldowns.insert(template.id, end); - } - } + affected + .cooldowns + .insert(skill.template.id, cooldowns.cooldowns[&skill.template.id]); + affected + .tag_cooldowns + .insert(tag, cooldowns.tag_cooldowns[&tag]); Some(SCCooldownsPacket::from_cooldowns(&affected, now)) }) .flatten(); @@ -2143,13 +2112,18 @@ pub(super) fn reset_cooldown_if_ignored( ) { if let Some(o) = owner_character(server, caster) { if o.data().skill_char.ignore_skill_cooldowns { + let tag = skill.template.cooldown_tag_id.max(0) as u32; + caster.with_unit(|u| { + u.unit_mut() + .cooldowns + .remove_skill_cooldown(skill.template.id, tag); + }); o.send(SCSkillCooldownResetPacket { - obj_id: o.obj_id, + obj_id: caster.obj_id(), skill_id: skill.template.id, - tag_id: skill.template.cooldown_tag_id.max(0) as u32, + tag_id: tag, gcd: false, }); - caster.with_unit(|u| u.unit_mut().cooldowns.remove_cooldown(skill.template.id)); } } } diff --git a/rust/crates/aaemu-game/src/world/session.rs b/rust/crates/aaemu-game/src/world/session.rs index 52c427233f..66131e12f3 100644 --- a/rust/crates/aaemu-game/src/world/session.rs +++ b/rust/crates/aaemu-game/src/world/session.rs @@ -29,6 +29,7 @@ use crate::net::connection::{ConnCommand, GameConnection, GameState}; use crate::packets::proxy::ChangeStatePacket; use crate::packets::world::*; use crate::server::GameServer; +use crate::systems::skills::packets::SCCooldownsPacket; use crate::world::{broadcast, unit_state, Player, PlayerRef, WorldInstance, WorldObject}; #[path = "zone_access.rs"] @@ -614,11 +615,7 @@ pub fn select_loaded( } // Running skill cooldowns (the client appends them to its cooldown manager; an empty list // would change nothing, so it is not sent). - let cooldowns = crate::systems::skills::skill::cooldown_snapshot( - server, - &snapshot.unit.cooldowns, - now_ms(), - ); + let cooldowns = SCCooldownsPacket::from_cooldowns(&snapshot.unit.cooldowns, now_ms()); if !cooldowns.is_empty() { conn.send(&cooldowns); } From af5db95ba0687dcc4cfb7b164af77bbd038b28cc Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:31:50 -0400 Subject: [PATCH 27/66] fix(skills): isolate controlled-unit cooldown snapshots --- .../systems/skills/cooldown_tag_flow_tests.rs | 39 +++++++++++++++++++ .../systems/skills/data/zone_rules_tests.rs | 1 + .../aaemu-game/src/systems/skills/skill.rs | 11 +++--- .../aaemu-game/src/world/zone_access_tests.rs | 2 +- 4 files changed, 46 insertions(+), 7 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs b/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs index 08b1f7317b..f1cb462773 100644 --- a/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs @@ -519,6 +519,45 @@ async fn gm_ignore_then_off_clears_the_same_native_records_and_preserves_longer_ assert_eq!(update.tags[0].0, 144); } +#[tokio::test] +async fn controlled_unit_shared_cooldown_does_not_populate_owners_native_snapshot() { + let (server, mut client, player, _) = fixture(data()); + let now = now_ms(); + player + .data() + .unit + .cooldowns + .add_tag_cooldown(9, 120_000, now); + let owner_cooldowns = player.data().unit.cooldowns.clone(); + let mut data = crate::models::mate::Mate::new(1, 1); + data.owner_obj_id = player.obj_id; + let mate = crate::world::Entity::new(0x300, data); + let caster = WorldObject::from(&mate); + let skill = super::new_skill_for( + &server, + server + .game_data + .systems + .skills + .skill(POTION) + .unwrap() + .clone(), + Some(&caster), + ); + client.drain(); + super::start_skill_cooldown(&server, &skill, &caster, now); + assert_eq!(mate.data().unit.cooldowns.cooldowns[&POTION], now + 60_000); + assert_eq!(mate.data().unit.cooldowns.tag_cooldowns[&144], now + 60_000); + assert!(mate + .data() + .unit + .cooldowns + .check_skill_cooldown(POTION_NEXT, 144, now)); + assert_eq!(player.data().unit.cooldowns, owner_cooldowns); + // 391D43C0 imports this subject-less packet into the local character manager. + assert!(!client.drain_ops().contains(&sc::SCCooldownsPacket)); +} + #[tokio::test] async fn gm_reset_targets_the_controlled_units_native_store_instead_of_its_owners() { let (server, mut client, player, _) = fixture(data()); diff --git a/rust/crates/aaemu-game/src/systems/skills/data/zone_rules_tests.rs b/rust/crates/aaemu-game/src/systems/skills/data/zone_rules_tests.rs index ab5810fbaf..82011e949c 100644 --- a/rust/crates/aaemu-game/src/systems/skills/data/zone_rules_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/data/zone_rules_tests.rs @@ -6,6 +6,7 @@ //! - 1766270..1766291 + 1748773..1748807: started-skill body, flags and byte result. //! - 1761305..1761336: two i16 errors, u32 type, bool notify in SCErrorMsg. //! - 1765129..1765192: caster discriminator, three-byte object ID and item fields. +//! //! These literal failure bodies are native-layout fixtures, not Rust encode/decode round trips. use std::sync::Arc; diff --git a/rust/crates/aaemu-game/src/systems/skills/skill.rs b/rust/crates/aaemu-game/src/systems/skills/skill.rs index 4d83088466..9df68311d2 100644 --- a/rust/crates/aaemu-game/src/systems/skills/skill.rs +++ b/rust/crates/aaemu-game/src/systems/skills/skill.rs @@ -256,12 +256,11 @@ fn start_skill_cooldown(server: &GameServer, skill: &SkillRun, caster: &WorldObj }) .flatten(); if let Some(packet) = packet.filter(|p| !p.is_empty()) { - if let Some(owner) = caster - .as_player() - .cloned() - .or_else(|| owner_character(server, caster)) - { - owner.send(packet); + // OnCooldowns (native 391D43C0) addresses the local character's manager; + // unlike SkillCooldownReset, the packet has no subject object ID. A mate's + // shared timers must not populate its owner's character cooldown store. + if let Some(player) = caster.as_player() { + player.send(packet); } } } diff --git a/rust/crates/aaemu-game/src/world/zone_access_tests.rs b/rust/crates/aaemu-game/src/world/zone_access_tests.rs index 8b9dc020e8..235d29c868 100644 --- a/rust/crates/aaemu-game/src/world/zone_access_tests.rs +++ b/rust/crates/aaemu-game/src/world/zone_access_tests.rs @@ -236,7 +236,7 @@ async fn closed_zone_walk_warns_five_times_then_returns_and_refiles_visibility() assert!(arrival.drain_ops().contains(&sc::SCUnitStatePacket)); assert!(departure.drain_ops().contains(&sc::SCUnitsRemovedPacket)); let world = server.world.world(0).unwrap(); - let around = world.players_around(&WorldObject::from(&p)); + let around = world.players_around(WorldObject::from(&p)); assert!(around.iter().any(|x| Arc::ptr_eq(x, &a))); assert!(!around.iter().any(|x| Arc::ptr_eq(x, &d))); // Native resurrection has no TeleportEnded acknowledgement: movement remains usable. From e712343a3211076ddef5db75658e6075aaa47bac Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:33:53 -0400 Subject: [PATCH 28/66] fix(mail): expire ordinary player mail safely Apply the existing fourteen-day retention policy from receipt time. Return eligible unopened P2P escrow once, dispose terminal mail safely, and enforce expiry at packet edges. Preserve specialized mail owners and existing wire layouts. Add deterministic lifecycle, packet replay, concurrency, save-ack, and private temporary-table MySQL regressions. Validation in this worker is limited to rustfmt and git diff --check; Cargo and database execution await the parent build-slot release. Co-Authored-By: Codex --- .../aaemu-game/src/systems/economy/mail.rs | 250 ++++- .../src/systems/economy/mail_character.rs | 36 +- .../src/systems/economy/mail_expiry_tests.rs | 851 ++++++++++++++++++ .../src/systems/economy/mail_tests.rs | 5 +- 4 files changed, 1097 insertions(+), 45 deletions(-) create mode 100644 rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs diff --git a/rust/crates/aaemu-game/src/systems/economy/mail.rs b/rust/crates/aaemu-game/src/systems/economy/mail.rs index bbdae782a7..8d27b8e36c 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail.rs @@ -22,9 +22,9 @@ use sqlx::Row; use crate::data::Feature; use crate::db::{dt, from_unix, int, unix}; use crate::models::char_data::CountUnreadMail; -use crate::models::container::{slot_type, ContainerRef}; +use crate::models::container::{expire_item, slot_type, ContainerRef, MIN_DATE_TIME}; use crate::models::item::{Item, UnixTime}; -use crate::models::item_task::{task_type, ItemFxList}; +use crate::models::item_task::{task_type, ItemFx, ItemFxList}; use crate::server::GameServer; use crate::systems::HookSlot; use crate::world::PlayerRef; @@ -153,7 +153,8 @@ pub const COST_EXPRESS_ATTACHMENT: i32 = 80; pub const COST_FREE_ATTACHMENT_COUNT: i32 = 1; /// `MailManager.NormalMailDelay` (30 minutes), in seconds. pub const NORMAL_MAIL_DELAY_SECS: i64 = 30 * 60; -/// `MailManager.MailExpireDelay` (14 days), in seconds (unused in C#). +/// Ordinary player mail retention (the formerly unused `MailManager.MailExpireDelay`). +/// Policy: 14 days from scheduled receipt, including a fresh period after a return. pub const MAIL_EXPIRE_DELAY_SECS: i64 = 14 * 24 * 3600; /// `AppConfiguration.Specialty.TradePackMailDelayInMinutes` default. pub const DEFAULT_TRADE_PACK_MAIL_DELAY_MINUTES: f64 = 480.0; @@ -295,6 +296,19 @@ impl BaseMail { && (self.mail_type == mail_type::NORMAL || self.mail_type == mail_type::EXPRESS) } + /// Only player mail belongs to this timer. System/quest rewards can also use NORMAL + /// but have sender id zero; tax, auction and commercial mail have separate owners. + fn is_expired_at(&self, time: UnixTime) -> bool { + self.header.sender_id > 0 + && self.header.receiver_id > 0 + && matches!( + self.mail_type, + mail_type::NORMAL | mail_type::EXPRESS | mail_type::REGISTERED + ) + && self.body.recv_date <= time + && time.saturating_sub(self.body.recv_date) >= MAIL_EXPIRE_DELAY_SECS + } + /// `MailHeader` as written on the wire. pub fn header_wire(&self) -> MailHeaderWire { MailHeaderWire { @@ -951,12 +965,15 @@ fn new_mail_id(server: &GameServer, st: &mut MailState) -> u32 { /// `DeleteMail(long id)` on a locked store. pub fn delete_mail_in(server: &GameServer, st: &mut MailState, id: i64) -> bool { + if st.all.remove(id).is_none() { + return false; + } if !st.deleted.contains(&id) { st.deleted.push(id); st.deletion_versions.insert(id, Arc::new(())); } server.ids.mail.release_id(id as u32); - st.all.remove(id).is_some() + true } /// `ExtractExtraForHouse(extra, out zoneGroupId, out houseId)` -> `(zoneGroupId, houseId)`. @@ -1207,10 +1224,20 @@ pub fn notify_new_mail_by_name_if_online( fx: &mut ItemFxList, m: &mut BaseMail, receiver_name: &str, +) -> bool { + notify_new_mail_at(server, fx, m, receiver_name, now()) +} + +fn notify_new_mail_at( + server: &GameServer, + fx: &mut ItemFxList, + m: &mut BaseMail, + receiver_name: &str, + time: UnixTime, ) -> bool { tracing::trace!("NotifyNewMailByNameIfOnline() - {receiver_name}"); // If unread and ready to deliver - if m.header.status != mail_status::READ && m.body.recv_date <= now() && !m.is_delivered { + if m.header.status != mail_status::READ && m.body.recv_date <= time && !m.is_delivered { if let Some(player) = server.world.character_by_name(receiver_name) { // TODO: Mia mail stuff let add_body = m.mail_type == mail_type::CHARGED; @@ -1270,9 +1297,10 @@ pub fn notify_delete_mail_by_name_if_online( /// `SCGotMailPacket` is sent for every unread mail; every unread mail gets `IsDelivered`. pub fn get_current_mail_list(txn: &mut ItemTxn<'_>, character_id: u32) -> Vec { let server = txn.server; + let now = now(); + expire_ordinary_mail_at(txn, now); // Try to grab the actual online Character object to send live updates let character = server.world.character_by_id(character_id); - let now = now(); let mut st = server.systems.economy.mail.state(); let ids: Vec = st .all @@ -1321,28 +1349,167 @@ pub fn get_current_mail_list_for(server: &GameServer, character_id: u32) -> Vec< /// `CheckAllMailTimings()` (the `MailDeliveryTask`). pub fn check_all_mail_timings(txn: &mut ItemTxn<'_>) { + check_all_mail_timings_at(txn, now()); +} + +/// The timer and deterministic lifecycle tests share the same operation and clock value. +pub fn check_all_mail_timings_at(txn: &mut ItemTxn<'_>, time: UnixTime) { tracing::trace!("CheckAllMailTimings"); + // Expire before delivery: logging in after the deadline must not first announce stale mail. + expire_ordinary_mail_at(txn, time); let server = txn.server; - let now = now(); let mut st = server.systems.economy.mail.state(); let undelivered: Vec = st .all .iter() - .filter(|(_, m)| m.body.recv_date <= now && !m.is_delivered) + .filter(|(_, m)| m.body.recv_date <= time && !m.is_delivered && !m.is_expired_at(time)) .map(|(k, _)| k) .collect(); let mut delivered = 0; for id in &undelivered { let m = st.all.get_mut(*id).expect("listed"); let name = m.receiver_name.clone(); - if notify_new_mail_by_name_if_online(server, &mut txn.env.fx, m, &name) { + if notify_new_mail_at(server, &mut txn.env.fx, m, &name, time) { delivered += 1; } } if delivered > 0 { tracing::debug!("{delivered}/{} mail(s) delivered", undelivered.len()); } - // TODO: Return expired mails back to owner if undelivered/unread +} + +fn expire_ordinary_mail_at(txn: &mut ItemTxn<'_>, time: UnixTime) { + let ids: Vec<_> = txn + .server + .systems + .economy + .mail + .state() + .all + .iter() + .filter(|(_, m)| m.is_expired_at(time)) + .map(|(id, _)| id) + .collect(); + for id in ids { + expire_mail_at(txn, id, time); + } +} + +/// is_delivered is reconstructed from dates on restart, while a newly selected +/// character's counters start at zero. Recount after removal/return instead of +/// decrementing a counter that might never have included this letter. +fn refresh_received_count( + server: &GameServer, + player: &PlayerRef, + time: UnixTime, +) -> CountUnreadMail { + let mut received = CountUnreadMail::default(); + { + let st = server.systems.economy.mail.state(); + for (_, m) in st.all.iter() { + if m.header.receiver_id == player.character_id + && m.is_delivered + && m.body.recv_date <= time + && m.header.status != mail_status::READ + { + received.update_received(m.mail_type, 1); + } + } + } + let mut c = player.data(); + c.unread_mail.received = received.received; + c.unread_mail.mia_received = received.mia_received; + c.unread_mail.commercial_received = received.commercial_received; + c.unread_mail +} + +/// Returns true when a requested ordinary mail has expired (also when a damaged escrow +/// needs repair). Packet operations must not claim/delete/return it between timer ticks. +/// All mutations use the caller's ItemTxn, like sends, takes and financial save snapshots. +pub(super) fn expire_mail_at(txn: &mut ItemTxn<'_>, id: i64, time: UnixTime) -> bool { + let server = txn.server; + let Some(mail) = server.systems.economy.mail.get_mail_by_id(id) else { + return false; + }; + if !mail.is_expired_at(time) { + return false; + } + if mail.can_return_mail() + && server + .names + .get_character_name(mail.header.sender_id) + .is_some() + { + // A failed relocation leaves the original letter intact for retry, never deletes + // escrow that was meant to be refunded, and never credits a wallet directly. + if !return_to_sender_at(txn, id, time) { + tracing::debug!( + mail_id = id, + "Expired mail return deferred: escrow needs repair" + ); + } + return true; + } + + // Read, registered, self-addressed, already returned, or sender deleted: terminal + // expiry. Only this receiver's mail escrow may be destroyed. A stale reference to + // an item already taken into a bag must never delete that item. + for &item_id in &mail.body.attachments { + let Some(mut item) = server.items.item_by_id(item_id) else { + continue; + }; + if item.owner_id != u64::from(mail.header.receiver_id) || item.slot_type != slot_type::MAIL + { + continue; + } + if let Some(container) = server.items.holding_container(item_id) { + // Mail escrow expiry is unconditional, like item expiry; CanDestroy (for an + // active summon item) must not orphan an attachment when the letter disappears. + container + .lock() + .expect("container poisoned") + .remove_item(item_id); + } else { + server.items.take_loose(item_id); + } + if item.expiration_online_minutes_left > 0.0 + || item.expiration_time > MIN_DATE_TIME + || item.unpack_time > MIN_DATE_TIME + { + txn.env + .fx + .push(expire_item(&mut item).with_owner(mail.header.receiver_id)); + } + txn.env.fx.push(ItemFx::ReleaseId(item_id)); + } + server.systems.economy.mail.delete_mail(server, id); + if let Some(receiver) = server.world.character_by_id(mail.header.receiver_id) { + let modified = mail.is_delivered && mail.header.status != mail_status::READ; + let count = refresh_received_count(server, &receiver, time); + txn.env.fx.send( + receiver.character_id, + SCMailDeletedPacket { + is_sent: false, + mail_id: id, + is_unread_mail_count_modified: modified, + count, + }, + ); + } + if mail.header.sender_id != mail.header.receiver_id { + if let Some(sender) = server.world.character_by_id(mail.header.sender_id) { + txn.env.fx.send( + sender.character_id, + SCMailDeletedPacket { + is_sent: true, + mail_id: id, + is_unread_mail_count_modified: false, + count: sender.data().unread_mail, + }, + ); + } + } + true } /// Schedules the `MailDeliveryTask` (30 s, then every 5 s). @@ -1658,6 +1825,10 @@ pub fn delete_house_mails(txn: &mut ItemTxn<'_>, house_id: u32) { /// Return the existing mail once, preserving its item IDs and attached money. pub fn return_to_sender(txn: &mut ItemTxn<'_>, mail_id: i64) -> bool { + return_to_sender_at(txn, mail_id, now()) +} + +fn return_to_sender_at(txn: &mut ItemTxn<'_>, mail_id: i64, time: UnixTime) -> bool { let server = txn.server; let mails = &server.systems.economy.mail; let Some(mail) = mails.get_mail_by_id(mail_id) else { @@ -1669,6 +1840,31 @@ pub fn return_to_sender(txn: &mut ItemTxn<'_>, mail_id: i64) -> bool { let Some(original_sender) = server.names.get_character_name(mail.header.sender_id) else { return false; }; + if mail.body.attachments.iter().any(|id| { + server.items.item_by_id(*id).is_none_or(|item| { + item.owner_id != u64::from(mail.header.receiver_id) || item.slot_type != slot_type::MAIL + }) + }) { + return false; + } + let mut swapped = mail.clone(); + swapped.header.receiver_id = mail.header.sender_id; + swapped.receiver_name = original_sender.clone(); + swapped.is_dirty = true; + swapped.header.sender_id = mail.header.receiver_id; + swapped.header.sender_name = mail.receiver_name.clone(); + swapped.header.returned = true; + swapped.header.status = mail_status::UNREAD; + swapped.open_date = 0; + swapped.body.recv_date = time; + swapped.is_delivered = false; + swapped.header.attachments = swapped.get_total_attachment_count(); + // Move escrow before publishing the new owner or sending any success packet. The + // mail containers do not stack attachments. Failure keeps the original row retryable. + if !relocate_attachments(txn, &swapped) { + relocate_attachments(txn, &mail); + return false; + } if let Some(r) = server.world.character_by_id(mail.header.receiver_id) { txn.env.fx.send( r.character_id, @@ -1678,43 +1874,23 @@ pub fn return_to_sender(txn: &mut ItemTxn<'_>, mail_id: i64) -> bool { }, ); } - let swapped = mails.with_mail_mut(mail_id, |m| { - let original_receiver_id = m.header.receiver_id; - let original_receiver_name = m.receiver_name.clone(); - m.header.receiver_id = m.header.sender_id; - m.receiver_name = original_sender.clone(); - m.is_dirty = true; - m.header.sender_id = original_receiver_id; - m.header.sender_name = original_receiver_name; - m.header.returned = true; - m.header.status = mail_status::UNREAD; - m.open_date = 0; - m.body.recv_date = now(); - m.is_delivered = false; - // Send(): recount + renumber before MailManager.Send - m.header.attachments = m.get_total_attachment_count(); - m.clone() - }); - let Some(swapped) = swapped else { return false }; - renumber_slots(server, &swapped); - if !relocate_attachments(txn, &swapped) { - return false; - } + mails.with_mail_mut(mail_id, |m| *m = swapped); if mail.is_delivered && mail.header.status == mail_status::UNREAD { if let Some(receiver) = server.world.character_by_id(mail.header.receiver_id) { - receiver - .data() - .unread_mail - .update_received(mail.mail_type, -1); + refresh_received_count(server, &receiver, time); super::mail_character::send_unread_mail_count(&mut txn.env.fx, &receiver); } } mails.with_mail_mut(mail_id, |m| { - notify_new_mail_by_name_if_online(server, &mut txn.env.fx, m, &original_sender) + notify_new_mail_at(server, &mut txn.env.fx, m, &original_sender, time) }); true } +#[cfg(test)] +#[path = "mail_expiry_tests.rs"] +mod expiry_tests; + /// The money / item part `send_system_mail` callers commonly need: a ready-to-send system mail /// (sender id 0) to `receiver_id` with `copper` attached and already-created loose `items` /// (at most [`MAX_MAIL_ATTACHMENTS`]). Builds the same mail the C# callers build by hand diff --git a/rust/crates/aaemu-game/src/systems/economy/mail_character.rs b/rust/crates/aaemu-game/src/systems/economy/mail_character.rs index 528a6e6513..7ea99b5f4f 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail_character.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail_character.rs @@ -69,8 +69,9 @@ pub fn open_mailbox(txn: &mut ItemTxn<'_>, player: &PlayerRef) { pub fn read_mail(txn: &mut ItemTxn<'_>, player: &PlayerRef, is_sent: bool, id: i64) { let server = txn.server; let mails = &server.systems.economy.mail; - let mut st = mails.state(); - let Some(m) = st.all.get_mut(id) else { return }; + let Some(m) = mails.get_mail_by_id(id) else { + return; + }; let owner = if is_sent { m.header.sender_id } else { @@ -79,6 +80,11 @@ pub fn read_mail(txn: &mut ItemTxn<'_>, player: &PlayerRef, is_sent: bool, id: i if owner != player.character_id { return; } + if mail::expire_mail_at(txn, id, mail::now()) { + return; + } + let mut st = mails.state(); + let Some(m) = st.all.get_mut(id) else { return }; if !is_sent && (!m.is_delivered || m.body.recv_date > mail::now()) { return; } @@ -258,6 +264,9 @@ pub fn get_attached( if this_mail.header.receiver_id != cid { return Ok(false); } + if mail::expire_mail_at(txn, mail_id, mail::now()) { + return Ok(false); + } if !this_mail.is_delivered || this_mail.body.recv_date > mail::now() { return Ok(false); } @@ -453,6 +462,18 @@ pub fn get_attached( /// `DeleteMail(id, isSent)`: only the receiver may delete received mail. pub fn delete_mail(txn: &mut ItemTxn<'_>, player: &PlayerRef, id: i64, is_sent: bool) { + if !is_sent + && txn + .server + .systems + .economy + .mail + .get_mail_by_id(id) + .is_some_and(|m| m.header.receiver_id == player.character_id) + && mail::expire_mail_at(txn, id, mail::now()) + { + return; + } let server = txn.server; let mails = &server.systems.economy.mail; let mut st = mails.state(); @@ -488,10 +509,13 @@ pub fn return_mail(txn: &mut ItemTxn<'_>, player: &PlayerRef, id: i64) { let Some(this_mail) = server.systems.economy.mail.get_mail_by_id(id) else { return; }; - if this_mail.header.receiver_id != player.character_id - || !this_mail.is_delivered - || this_mail.body.recv_date > mail::now() - { + if this_mail.header.receiver_id != player.character_id { + return; + } + if mail::expire_mail_at(txn, id, mail::now()) { + return; + } + if !this_mail.is_delivered || this_mail.body.recv_date > mail::now() { return; } mail::return_to_sender(txn, id); diff --git a/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs b/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs new file mode 100644 index 0000000000..684e0b642a --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs @@ -0,0 +1,851 @@ +//! Ordinary-mail lifecycle regressions. No wall-clock sleeps, fake manager, or wire round trips. +//! Native 1.2 evidence: decomp/x2game12.c builders 393CCCD0 (money), 393CD1D0 +//! (delete), serializer 397BA450 (return), header/body at 1995740-42/1995902-09, +//! and ui/scripts/x2ui/mailbox/mail/read_mail.lua:129-139 +//! (receipt vs send date). No ordinary-mail expiry field/TTL is exposed there: the +//! 14-day receipt-time retention is an explicit server policy using the existing constant. + +use super::*; +use crate::net::registry::ClientPacket; +use crate::opcodes::sc; +use crate::systems::economy::mail_character; +use crate::systems::economy::mail_packets::CSTakeAttachmentSequentially; +use crate::systems::economy::tests::{give, world, World, SINGLE}; + +fn mail_world() -> World { + let w = world(); + w.server.names.add_character(1, "Alice", 1001); + w.server.names.add_character(2, "Bob", 1002); + for p in [&w.pa, &w.pb] { + for (_, container) in Inv::of(p).containers { + w.server.items.add_container(container); + } + } + w +} + +fn send_player_mail(w: &World, kind: u8, count: i32, copper: i32) -> (i64, Vec) { + w.pa.data().money = 10_000; + let ids: Vec<_> = (0..count) + .map(|slot| give(w, &w.pa, slot_type::INVENTORY, SINGLE, 1, slot)) + .collect(); + let slots: Vec<_> = (0..count) + .map(|slot| (slot_type::INVENTORY, slot as u8)) + .collect(); + let mut txn = ItemTxn::begin(&w.server); + assert_eq!( + mail_character::send_mail_to_player( + &mut txn, &w.pa, kind, "Bob", "expiry", "original", 0, copper, 0, 0, 0, &slots, + ), + mail_result::SUCCESS + ); + let id = w.server.systems.economy.mail.state().all.keys()[0]; + (id, ids) +} + +fn tick(server: &GameServer, time: UnixTime) { + let mut txn = ItemTxn::begin(server); + check_all_mail_timings_at(&mut txn, time); +} + +fn frame(opcode: u16, id: i64) -> Vec { + let mut frame = vec![0xdd, 1, 0, 0]; + frame.extend_from_slice(&opcode.to_le_bytes()); + frame.extend_from_slice(&id.to_le_bytes()); + frame +} + +#[tokio::test] +async fn expiry_receipt_boundary_returns_zero_one_ten_attachments_once() { + for count in [0, 1, 10] { + for kind in [mail_type::NORMAL, mail_type::EXPRESS] { + let mut w = mail_world(); + let (id, ids) = send_player_mail(&w, kind, count, 125); + let original = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + let money = (w.pa.data().money, w.pb.data().money); + let due = original.body.recv_date + MAIL_EXPIRE_DELAY_SECS; + tick(&w.server, due - 1); + assert!( + !w.server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .header + .returned + ); + if kind == mail_type::NORMAL { + assert!((NORMAL_MAIL_DELAY_SECS..=NORMAL_MAIL_DELAY_SECS + 2) + .contains(&(original.body.recv_date - original.body.send_date))); + } + w.a.drain(); + w.b.drain(); + tick(&w.server, due); + let returned = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert!(returned.header.returned && returned.is_dirty && returned.is_delivered); + assert_eq!( + (returned.header.receiver_id, returned.header.sender_id), + (1, 2) + ); + assert_eq!(returned.body.recv_date, due); + assert_eq!(returned.body.send_date, original.body.send_date); + assert_eq!(returned.body.attachments, ids); + assert_eq!(returned.body.copper_coins, 125); + assert_eq!((w.pa.data().money, w.pb.data().money), money); + assert_eq!( + ( + w.pa.data().unread_mail.received, + w.pb.data().unread_mail.received + ), + (1, 0) + ); + assert_eq!(w.a.drain_ops(), vec![sc::SCGotMailPacket]); + assert_eq!( + w.b.drain_ops(), + vec![sc::SCMailReturnedPacket, sc::SCCountUnreadMailPacket] + ); + for &item in &ids { + let item = w.server.items.item_by_id(item).unwrap(); + assert_eq!((item.owner_id, item.slot_type), (1, slot_type::MAIL)); + } + tick(&w.server, due); + tick(&w.server, due + MAIL_EXPIRE_DELAY_SECS - 1); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + returned + ); + assert!(w.a.drain().is_empty() && w.b.drain().is_empty()); + + // A returned letter has one last retention period; it never bounces back. + tick(&w.server, due + MAIL_EXPIRE_DELAY_SECS); + tick(&w.server, due + MAIL_EXPIRE_DELAY_SECS + 1); + assert_eq!(w.server.systems.economy.mail.count(), 0); + assert_eq!(w.pa.data().unread_mail.received, 0); + assert_eq!(w.pb.data().unread_mail.received, 0); + assert_eq!((w.pa.data().money, w.pb.data().money), money); + for item in ids { + assert!(w.server.items.item_by_id(item).is_none()); + assert!(w.server.items.holding_container(item).is_none()); + assert_eq!( + w.server + .items + .removed_items() + .iter() + .filter(|&&id| id == item) + .count(), + 1 + ); + } + assert_eq!(w.server.systems.economy.mail.state().deleted, vec![id]); + } + } +} + +#[tokio::test] +async fn expiry_read_registered_self_and_deleted_sender_are_terminal() { + for case in 0..4 { + let mut w = mail_world(); + let kind = if case == 1 { + mail_type::REGISTERED + } else { + mail_type::EXPRESS + }; + let (id, ids) = send_player_mail(&w, kind, 10, 50); + if case == 0 { + let mut txn = ItemTxn::begin(&w.server); + mail_character::read_mail(&mut txn, &w.pb, false, id); + } + if case == 1 { + // Reconnect resets counters before the reconstructed delivery flags. + w.pb.data().unread_mail.reset_received(); + } + w.server.systems.economy.mail.with_mail_mut(id, |m| { + if case == 2 { + m.header.sender_id = 2; + m.header.sender_name = "Bob".into(); + } + if case == 3 { + m.header.sender_id = 999; + } + }); + let money = (w.pa.data().money, w.pb.data().money); + let due = w + .server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .body + .recv_date + + MAIL_EXPIRE_DELAY_SECS; + w.a.drain(); + w.b.drain(); + tick(&w.server, due); + tick(&w.server, due + 1); + assert!(w.server.systems.economy.mail.get_mail_by_id(id).is_none()); + assert_eq!(w.pb.data().unread_mail.received, 0); + assert_eq!((w.pa.data().money, w.pb.data().money), money); + assert_eq!(w.b.drain_ops(), vec![sc::SCMailDeletedPacket]); + for id in ids { + assert!(w.server.items.item_by_id(id).is_none()); + } + } +} + +#[tokio::test] +async fn expiry_zero_receipt_and_clock_rollback_obey_the_same_boundary() { + let w = mail_world(); + let (id, _) = send_player_mail(&w, mail_type::EXPRESS, 0, 0); + w.server.systems.economy.mail.with_mail_mut(id, |m| { + m.body.send_date = 0; + m.body.recv_date = 0; + }); + for time in [-1, 0, MAIL_EXPIRE_DELAY_SECS - 1] { + tick(&w.server, time); + assert!( + !w.server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .header + .returned + ); + } + tick(&w.server, MAIL_EXPIRE_DELAY_SECS); + assert!( + w.server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .header + .returned + ); +} + +#[tokio::test] +async fn expiry_disposes_loose_escrow_but_preserves_a_stale_reference_to_taken_item() { + let w = mail_world(); + let (id, ids) = send_player_mail(&w, mail_type::EXPRESS, 2, 50); + let container = mail_container(&w.pb).unwrap(); + let loose = container.lock().unwrap().remove_item(ids[0]).unwrap(); + w.server.items.add_loose(loose); + { + let mut txn = ItemTxn::begin(&w.server); + assert!(add_or_move_existing_item( + &mut txn, + &Inv::of(&w.pb).bag(), + task_type::INVALID, + ids[1], + -1 + )); + } + w.server + .systems + .economy + .mail + .with_mail_mut(id, |m| m.header.returned = true); + let released = Arc::new(Mutex::new(Vec::new())); + let item_releases = released.clone(); + w.server + .ids + .item + .install_release_hook(move |id| item_releases.lock().unwrap().push(id)); + let mail_released = Arc::new(Mutex::new(Vec::new())); + let mail_releases = mail_released.clone(); + w.server + .ids + .mail + .install_release_hook(move |id| mail_releases.lock().unwrap().push(id)); + let due = w + .server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .body + .recv_date + + MAIL_EXPIRE_DELAY_SECS; + tick(&w.server, due); + tick(&w.server, due + 1); + assert!(w.server.items.item_by_id(ids[0]).is_none()); + assert!(w.server.items.holding_container(ids[0]).is_none()); + assert_eq!( + w.server.items.item_by_id(ids[1]).unwrap().slot_type, + slot_type::INVENTORY + ); + assert_eq!(*released.lock().unwrap(), vec![ids[0] as u32]); + assert_eq!(*mail_released.lock().unwrap(), vec![id as u32]); + assert_eq!(w.server.items.removed_items(), vec![ids[0]]); +} + +#[tokio::test] +async fn expiry_offline_return_reload_and_reconnect_do_not_repeat_refund() { + let mut w = mail_world(); + let (id, ids) = send_player_mail(&w, mail_type::EXPRESS, 1, 75); + w.server.systems.economy.mail.with_mail_mut(id, |m| { + m.body.recv_date = now() - MAIL_EXPIRE_DELAY_SECS - 10; + }); + w.server.world.world(0).unwrap().delete(&w.pa); + w.server.world.world(0).unwrap().delete(&w.pb); + assert!(w.server.world.try_remove_character(w.pa.obj_id)); + assert!(w.server.world.try_remove_character(w.pb.obj_id)); + assert!(w.server.world.character_by_id(1).is_none()); + assert!(w.server.world.character_by_id(2).is_none()); + let due = w + .server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .body + .recv_date + + MAIL_EXPIRE_DELAY_SECS; + w.a.drain(); + w.b.drain(); + tick(&w.server, due); + let returned = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert!(returned.header.returned && !returned.is_delivered); + assert_eq!(w.server.items.item_by_id(ids[0]).unwrap().owner_id, 1); + assert!(w.a.drain().is_empty() && w.b.drain().is_empty()); + // Production row loader has no persisted is_delivered flag; returned + receipt date + // must alone prevent another refund after a restart. + let rows = vec![row(&returned)]; + w.server + .systems + .economy + .mail + .load_rows(&w.server, rows, due); + tick(&w.server, due); + assert_eq!(w.server.systems.economy.mail.count(), 1); + assert_eq!( + w.server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .header + .receiver_id, + 1 + ); + w.pa.data().unread_mail.reset_received(); + assert!(w.server.world.try_add_character(&w.pa)); + w.server + .world + .world(0) + .unwrap() + .spawn(&w.pa, &w.server.view_ctx()); + { + let mut txn = ItemTxn::begin(&w.server); + assert_eq!(get_current_mail_list(&mut txn, 1), vec![id]); + } + assert_eq!(w.pa.data().unread_mail.received, 1); + let before = w.pa.data().money; + let mut txn = ItemTxn::begin(&w.server); + assert_eq!( + mail_character::get_attached(&mut txn, &w.pa, id, true, true, true, 0), + Ok(true) + ); + assert_eq!( + mail_character::get_attached(&mut txn, &w.pa, id, true, true, true, 0), + Ok(true) + ); + assert_eq!(w.pa.data().money, before + 75); + assert_eq!( + w.server.items.item_by_id(ids[0]).unwrap().slot_type, + slot_type::INVENTORY + ); +} + +#[tokio::test] +async fn expiry_packet_edges_enforce_current_owner_before_timer_and_return_auth() { + for opcode in [0x09eu16, 0x0a1, 0x0a3, 0x09c] { + let mut w = mail_world(); + let (id, ids) = send_player_mail(&w, mail_type::EXPRESS, 1, 25); + let past = now() - MAIL_EXPIRE_DELAY_SECS - 1; + w.server + .systems + .economy + .mail + .with_mail_mut(id, |m| m.body.recv_date = past); + let original = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + let mut request = frame(opcode, id); + if opcode == 0x0a1 { + request.push(0); + } + if opcode == 0x09c { + request = vec![0xdd, 1, 0, 0, 0x9c, 0, 0]; + request.extend_from_slice(&id.to_le_bytes()); + } + // Sender may read their sent copy, but cannot operate the recipient's copy. + w.server + .handle_frame(&mut w.a.conn, &request) + .await + .unwrap(); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + original + ); + let money = (w.pa.data().money, w.pb.data().money); + w.server + .handle_frame(&mut w.b.conn, &request) + .await + .unwrap(); + let returned = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert!(returned.header.returned); + assert_eq!(returned.header.receiver_id, 1); + assert_eq!(returned.body.copper_coins, 25); + assert_eq!(w.server.items.item_by_id(ids[0]).unwrap().owner_id, 1); + assert_eq!((w.pa.data().money, w.pb.data().money), money); + // Replay by the former receiver cannot take or delete the returned escrow. + w.server + .handle_frame(&mut w.b.conn, &request) + .await + .unwrap(); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + returned + ); + } +} + +#[tokio::test] +async fn expiry_serializes_with_take_delete_and_send() { + for take_first in [false, true] { + let w = mail_world(); + let (id, ids) = send_player_mail(&w, mail_type::EXPRESS, 1, 100); + let due = w + .server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .body + .recv_date + + MAIL_EXPIRE_DELAY_SECS; + let sender_money = w.pa.data().money; + let receiver_money = w.pb.data().money; + // Force either lock acquisition order, then let a second tick, take, delete and + // send contend for the real economy lock on separate OS threads. + if take_first { + let mut txn = ItemTxn::begin(&w.server); + mail_character::get_attached(&mut txn, &w.pb, id, true, true, true, 0).unwrap(); + } else { + tick(&w.server, due); + } + let new_id = w.server.systems.economy.mail.get_new_mail_id(&w.server); + let server = w.server.clone(); + let receiver = w.pb.clone(); + crate::test_support::finishes_in_time("mail expiry/take/delete/send", move || { + let runtime = tokio::runtime::Handle::current(); + std::thread::scope(|scope| { + scope.spawn(|| { + let _runtime = runtime.enter(); + tick(&server, due); + }); + scope.spawn(|| { + let _runtime = runtime.enter(); + let mut txn = ItemTxn::begin(&server); + mail_character::get_attached(&mut txn, &receiver, id, true, true, true, 0) + .unwrap(); + mail_character::delete_mail(&mut txn, &receiver, id, false); + }); + scope.spawn(|| { + let _runtime = runtime.enter(); + let mut txn = ItemTxn::begin(&server); + let mut reward = BaseMail { + id: i64::from(new_id), + mail_type: mail_type::NORMAL, + receiver_name: "Bob".into(), + title: "reward".into(), + ..BaseMail::default() + }; + reward.header.receiver_id = 2; + reward.body.recv_date = now(); + assert_eq!(send_mail(&mut txn, reward), Some(i64::from(new_id))); + }); + }); + }); + let item = w.server.items.item_by_id(ids[0]).unwrap(); + if take_first { + assert_eq!((item.owner_id, item.slot_type), (2, slot_type::INVENTORY)); + assert_eq!(w.pb.data().money, receiver_money + 100); + assert!(w.server.systems.economy.mail.get_mail_by_id(id).is_none()); + } else { + assert_eq!((item.owner_id, item.slot_type), (1, slot_type::MAIL)); + assert_eq!(w.pb.data().money, receiver_money); + assert_eq!( + w.server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .body + .copper_coins, + 100 + ); + } + assert_eq!(w.pa.data().money, sender_money); + } +} + +#[tokio::test] +async fn expiry_preserves_system_tax_auction_quest_and_legacy_billing_metadata() { + let w = mail_world(); + let (id, _) = send_player_mail(&w, mail_type::EXPRESS, 0, 25); + // New P2P sending rejects money1/2. Historical demand/point fields are opaque: + // neither an expiry nor a return may convert these into copper. + w.server + .systems + .economy + .mail + .with_mail_mut(id, |m| m.attach_money(25, 5000, 7000)); + let original = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + let due = original.body.recv_date + MAIL_EXPIRE_DELAY_SECS; + { + let mut txn = ItemTxn::begin(&w.server); + for kind in [ + mail_type::NORMAL, + mail_type::EXPRESS, + mail_type::BILLING, + mail_type::AUC_OFF_FAIL, + mail_type::AUC_OFF_SUCCESS, + mail_type::AUC_BID_WIN, + mail_type::SYS_EXPRESS, + mail_type::CHARGED, + mail_type::SYS_SELL_BACKPACK, + ] { + assert!(send_system_mail( + &mut txn, + kind, + "__QUEST__", + 2, + "owned elsewhere", + "", + 10, + vec![] + )); + } + } + let protected: Vec<_> = w + .server + .systems + .economy + .mail + .state() + .all + .iter() + .filter(|(key, _)| *key != id) + .map(|(_, m)| m.clone()) + .collect(); + let money = (w.pa.data().money, w.pb.data().money); + tick(&w.server, due); + let returned = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert_eq!( + ( + returned.body.copper_coins, + returned.body.billing_amount, + returned.body.money_amount2 + ), + (25, 5000, 7000) + ); + tick(&w.server, due + MAIL_EXPIRE_DELAY_SECS); + assert_eq!((w.pa.data().money, w.pb.data().money), money); + for m in protected { + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(m.id).unwrap(), + m + ); + } +} + +#[tokio::test] +async fn expiry_failed_return_does_not_publish_owner_or_success_then_retries() { + let mut w = mail_world(); + let (id, ids) = send_player_mail(&w, mail_type::EXPRESS, 2, 100); + let original = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + let item = w.server.items.item_by_id(ids[0]).unwrap(); + // A mismatched escrow must not steal an inventory item or announce a refund. + mutate_item(&w.server, ids[0], |i| i.slot_type = slot_type::INVENTORY); + w.a.drain(); + w.b.drain(); + let due = original.body.recv_date + MAIL_EXPIRE_DELAY_SECS; + tick(&w.server, due); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + original + ); + assert!(w.a.drain().is_empty() && w.b.drain().is_empty()); + mutate_item(&w.server, ids[0], |i| *i = item); + let target = mail_container(&w.pa).unwrap(); + target.lock().unwrap().size = 1; + // First attachment moves, second cannot fit. The original row and every item's + // ownership must survive rollback before a later retry can publish the return. + tick(&w.server, due); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + original + ); + for &item in &ids { + assert_eq!(w.server.items.item_by_id(item).unwrap().owner_id, 2); + } + assert!(w.a.drain().is_empty() && w.b.drain().is_empty()); + target.lock().unwrap().size = -1; + tick(&w.server, due); + assert_eq!( + w.server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .header + .receiver_id, + 1 + ); +} + +fn row(m: &BaseMail) -> MailRow { + let mut attachment_ids = [0; MAX_MAIL_ATTACHMENTS]; + attachment_ids[..m.body.attachments.len()].copy_from_slice(&m.body.attachments); + MailRow { + id: m.id, + mail_type: i64::from(m.mail_type), + status: i64::from(m.header.status), + title: m.title.clone(), + text: m.body.text.clone(), + sender_id: i64::from(m.header.sender_id), + sender_name: m.header.sender_name.clone(), + attachment_count: i64::from(m.header.attachments), + receiver_id: i64::from(m.header.receiver_id), + receiver_name: m.receiver_name.clone(), + open_date: m.open_date, + send_date: m.body.send_date, + received_date: m.body.recv_date, + returned: i64::from(m.header.returned), + extra: m.header.extra, + money1: i64::from(m.body.copper_coins), + money2: i64::from(m.body.billing_amount), + money3: i64::from(m.body.money_amount2), + attachment_ids, + } +} + +#[tokio::test] +async fn expiry_old_save_ack_preserves_new_return_and_terminal_deletion() { + let w = mail_world(); + let (id, _) = send_player_mail(&w, mail_type::EXPRESS, 1, 50); + let mails = &w.server.systems.economy.mail; + let before = mails.prepare_save(); + let due = mails.get_mail_by_id(id).unwrap().body.recv_date + MAIL_EXPIRE_DELAY_SECS; + tick(&w.server, due); + mails.acknowledge_committed(before); + assert!(mails.get_mail_by_id(id).unwrap().is_dirty); + let returned = mails.prepare_save(); + assert_eq!(returned.dirty.len(), 1); + tick(&w.server, due + MAIL_EXPIRE_DELAY_SECS); + mails.acknowledge_committed(returned); + assert_eq!(mails.state().deleted, vec![id]); + assert!(mails.prepare_save().dirty.is_empty()); + let deletion = mails.prepare_save(); + mails.acknowledge_committed(deletion); + assert!(mails.state().deleted.is_empty()); +} + +#[tokio::test] +async fn expiry_sequential_packet_claims_returned_money_and_items_only_once() { + let mut w = mail_world(); + let (id, ids) = send_player_mail(&w, mail_type::EXPRESS, 10, 100); + // Return with a past (but unexpired) new receipt date so normal packet clocks apply. + let mut txn = ItemTxn::begin(&w.server); + assert!(return_to_sender_at(&mut txn, id, now() - 1)); + drop(txn); + let money = w.pa.data().money; + for _ in 0..2 { + CSTakeAttachmentSequentially { mail_id: id } + .handle(&w.server, &mut w.a.conn) + .await + .unwrap(); + tick(&w.server, now()); + } + assert_eq!(w.pa.data().money, money + 100); + for id in ids { + let item = w.server.items.item_by_id(id).unwrap(); + assert_eq!((item.owner_id, item.slot_type), (1, slot_type::INVENTORY)); + } +} + +#[tokio::test] +#[ignore = "private MySQL3317 via AAEMU_TEST_MYSQL; connection-local temporary tables only"] +async fn private_mysql_expiry_return_rollback_retry_reload_and_disposal() { + use sqlx::mysql::{MySqlConnectOptions, MySqlPoolOptions}; + use std::str::FromStr; + + let url = std::env::var("AAEMU_TEST_MYSQL").expect("AAEMU_TEST_MYSQL"); + let options = MySqlConnectOptions::from_str(&url).unwrap(); + 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 ["mails", "items", "item_containers"] { + 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(); + } + fn server(pool: &sqlx::MySqlPool) -> Arc { + let mut server = + crate::test_support::test_server_with(crate::systems::economy::tests::test_data()); + server.db = pool.clone(); + let server = Arc::new(server); + server.set_self(); + server.names.add_character(1, "Alice", 1001); + server.names.add_character(2, "Bob", 1002); + server + } + async fn persist(server: &GameServer, pool: &sqlx::MySqlPool, commit: bool) { + let _save = server.save.transaction_lock().await; + let (mails, items) = { + let _economy = server.systems.economy.ops_lock(); + ( + server.systems.economy.mail.prepare_save(), + server.items.prepare_save(), + ) + }; + let mut tx = pool.begin().await.unwrap(); + server + .systems + .economy + .mail + .write_prepared(&mut tx, mails) + .await + .unwrap(); + server.items.write_prepared(&mut tx, items).await.unwrap(); + if commit { + tx.commit().await.unwrap(); + server.systems.economy.mail.commit_save(); + server.items.commit_save(); + } else { + tx.rollback().await.unwrap(); + } + } + let original = server(&pool); + let item = original + .items + .create( + SINGLE, + 1, + 0, + 1, + &original.game_data.items, + &original.ids.item, + now(), + ) + .unwrap(); + let item_id = item.id; + original.items.add_loose(item); + let due = now() - 1; + let id = { + let mut m = BaseMail { + mail_type: mail_type::EXPRESS, + receiver_name: "Bob".into(), + ..BaseMail::default() + }; + m.header.sender_id = 1; + m.header.sender_name = "Alice".into(); + m.header.receiver_id = 2; + m.body.recv_date = due - MAIL_EXPIRE_DELAY_SECS; + m.body.send_date = m.body.recv_date; + m.body.attachments.push(item_id); + m.attach_money(125, 0, 0); + let mut txn = ItemTxn::begin(&original); + send_mail(&mut txn, m).unwrap() + }; + persist(&original, &pool, true).await; + tick(&original, due); + persist(&original, &pool, false).await; + let receiver: u32 = sqlx::query_scalar("SELECT receiver_id FROM mails WHERE id=?") + .bind(id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(receiver, 2); + assert!( + original + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .is_dirty + ); + persist(&original, &pool, true).await; + + let restarted = server(&pool); + restarted + .items + .load_user_items( + &pool, + &restarted.game_data.items, + 1, + &restarted.ids.container, + &restarted.ids.item, + ) + .await + .unwrap(); + restarted + .systems + .economy + .mail + .load(&restarted) + .await + .unwrap(); + let m = restarted.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert!(m.header.returned && !m.is_dirty); + assert_eq!( + (m.header.receiver_id, m.body.copper_coins, m.body.recv_date), + (1, 125, due) + ); + let item = restarted.items.item_by_id(item_id).unwrap(); + assert_eq!((item.owner_id, item.slot_type), (1, slot_type::MAIL)); + tick(&restarted, due); + assert_eq!( + restarted.systems.economy.mail.get_mail_by_id(id).unwrap(), + m + ); + + tick(&restarted, due + MAIL_EXPIRE_DELAY_SECS); + persist(&restarted, &pool, false).await; + assert_eq!(restarted.systems.economy.mail.state().deleted, vec![id]); + assert!(restarted.items.removed_items().contains(&item_id)); + persist(&restarted, &pool, true).await; + let remaining: i64 = + sqlx::query_scalar("SELECT (SELECT COUNT(*) FROM mails) + (SELECT COUNT(*) FROM items)") + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(remaining, 0); + assert!(restarted.systems.economy.mail.state().deleted.is_empty()); + assert!(restarted.items.removed_items().is_empty()); +} diff --git a/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs b/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs index e412942bb7..e58bcf24da 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs @@ -2034,6 +2034,7 @@ async fn send_rejects_name_mismatch_and_return_preserves_the_original_mail() { #[tokio::test] async fn load_rows_restore_mails() { let w = mail_world(); + let received = mail::now() - 1; let item = give(&w, &w.pa.clone(), slot_type::MAIL, STACK, 2, 0); let mut ids = [0u64; 10]; ids[0] = item; @@ -2050,8 +2051,8 @@ async fn load_rows_restore_mails() { attachment_count: 9, receiver_id: 2, receiver_name: "Bob".into(), - send_date: 10, - received_date: 20, + send_date: received - 10, + received_date: received, money1: 5, attachment_ids: ids, ..MailRow::default() From ed2f7a9f3bc77fb342c1fa159b498ea3905d4b2c Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:35:44 -0400 Subject: [PATCH 29/66] fix(game): enforce native final unit attribute limits Load native unit limits per GameServer and clamp complete raw attributes before conversions across character, NPC, vehicle, XP and haste paths. Add buff/equipment, extreme stack, detached evaluation and server isolation regression sources with exact compact fixtures. Load permanent pStat ranges separately and document the contribution feature as open. Source-only validation: rustfmt, diff checks and read-only compact fixture comparison; Cargo and live checks reserved for parent. Co-Authored-By: Codex --- rust/crates/aaemu-game/PORTING.md | 24 + .../aaemu-game/src/data/attribute_limits.rs | 117 ++++ .../src/data/attribute_limits_tests.rs | 197 +++++++ .../src/data/character_templates.rs | 9 + rust/crates/aaemu-game/src/data/mod.rs | 1 + rust/crates/aaemu-game/src/models/unit.rs | 26 +- .../aaemu-game/src/systems/npcs/npc/stats.rs | 53 +- .../systems/skills/attribute_limits_tests.rs | 547 ++++++++++++++++++ .../aaemu-game/src/systems/skills/progress.rs | 3 + .../aaemu-game/src/systems/skills/stats.rs | 62 +- .../aaemu-game/src/systems/vehicles/stats.rs | 109 +++- rust/crates/aaemu-game/src/world/mod.rs | 5 + 12 files changed, 1102 insertions(+), 51 deletions(-) create mode 100644 rust/crates/aaemu-game/src/data/attribute_limits.rs create mode 100644 rust/crates/aaemu-game/src/data/attribute_limits_tests.rs create mode 100644 rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 9c1753be1d..09d93db24d 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -168,6 +168,30 @@ Each subsystem records its status here, in its own section only (see `CONTRIBUTI | Movement hooks (`CSMoveUnit.RemoveEffects`, `Character.SetPosition` Move removal, fall damage) | `systems/skills/mod.rs` (`on_move_request`, `on_moved`) | done | Called from `world::session::move_unit`. | | `Skill.EndChanneling` target buff (`ChannelingTargetBuffId`) | `systems/skills/{skill,buffs}.rs` (`end_channeling`, `finish_effect_by_skill`) | deviation | **Deviation:** the C# `Buffs.RemoveEffect(templateId, skillId)` raised the buff's `OnTimeout` triggers on every removal; the Rust removal skips them for explicit removals (dispels, a stopped channel; see the FISH escape in `buff_removal_tests.rs`). Quest item grants hang on that trigger (GainItem on buff 3896 of skill 18449 'Extract Earth Crystal', 4 s channel under a 6 s buff, and the other channeling-target-buff quest skills of the item triage), so a channel that **runs to its end** now fires the target buff's Timeout triggers before removing it. A stopped / cancelled channel fires nothing (the C# granted the item then too). The caster-side `ChannelingBuffId` and buffs applied by skill effects (buff 1963 of 'Capture Crayfish') are unchanged: the latter expire on their own timer and fire Timeout already. | +#### Raw attribute bounds and permanent pStats (2026-10-25) + +`systems::skills`: all 21 `unit_attribute_limits` overrides are loaded with native +defaults of -2,000,000,000..2,000,000,000 (1.2 `39577A20`, +`D:/aa-re/client12/decomp/x2game12.c:1178985`, `:1179175-1179181`). The consumer +`398A0BC0` calls `395729F0` after formula, equipment and bonus arithmetic +(`:1991333-1991338`, clamp at `:1169345-1169352`), before raw-unit conversions. +The server preserves its existing bonus ordering and units and applies this final +raw bound to character, NPC and vehicle calculations and direct UnitBase readers +(XP and haste included). MoveSpeedMul starts at 1000, so its 3000 maximum means +3x speed; ExpMul starts at 100 percentage points and has range 0..500. Limits are +per-GameServer data shared by Arc with each unit, including detached refresh paths. +As a numeric-safety policy, infinities saturate, NaN uses zero within the range, +and NPC/vehicle integer bonus intermediates are widened before the final cap. +This does not claim native parity for extreme overflow or non-finite inputs. + +The five `character_p_stat_limits` rows (0..10000) are loaded separately. Native +`39752FC0` loads max/min (`:1647826-1647832`), and `3939DD10` checks proposed +permanent pStat + delta (`:765713-765775`); they are **not final primary stat caps**. +Character still lacks permanent pStat contribution state/persistence, and +`world/unit_state.rs` emits six zero pStats. That feature remains open. Applying +the table to final character attributes or to NPC/mate/slave primaries would +invent a different rule. No storage, wire format or client/compact assets change. + #### AoE diminishing compatibility policy (2026-10-25) `systems::skills`: `aoe_diminishings` loads authored float percentages by id (native 1.2 diff --git a/rust/crates/aaemu-game/src/data/attribute_limits.rs b/rust/crates/aaemu-game/src/data/attribute_limits.rs new file mode 100644 index 0000000000..ff7f869a0c --- /dev/null +++ b/rust/crates/aaemu-game/src/data/attribute_limits.rs @@ -0,0 +1,117 @@ +//! Native 1.2 attribute bounds (read-only compact data). +//! +//! `x2game12.c` 39577A20 (:1178985, :1179175-81) initializes unit limits to +//! +/-2,000,000,000 then loads `unit_attribute_limits`. 398A0BC0 (:1991333-38) +//! calls 395729F0 AFTER formula, equipment and buff arithmetic, before the raw +//! attribute is converted to a ratio, percentage, delay, etc. These are bounds on +//! the resulting raw attribute, never on each bonus or its accumulated modifier. +//! +//! `character_p_stat_limits` is separate: 39752FC0 (:1647826-32) loads max/min; +//! 3939DD10 (:765713-59) validates permanent pStat + delta. It does NOT bound final +//! primary attributes including equipment/buffs. Permanent pStats are not yet +//! modeled/persisted by this server; loading their five ranges does not implement +//! that feature or justify applying them to NPCs or to character stat getters. + +use std::collections::HashMap; + +use rusqlite::Connection; + +use crate::models::unit::UnitAttribute; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AttributeLimit { + pub minimum: i32, + pub maximum: i32, +} + +impl Default for AttributeLimit { + fn default() -> Self { + Self { + minimum: -2_000_000_000, + maximum: 2_000_000_000, + } + } +} + +impl AttributeLimit { + /// Invalid numeric input cannot escape into casts/timers; infinities saturate + /// and NaN uses zero within the authored range (server numeric-safety policy). + pub fn clamp(self, value: f64) -> f64 { + let value = if value.is_nan() { 0.0 } else { value }; + value.clamp(f64::from(self.minimum), f64::from(self.maximum)) + } +} + +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct UnitAttributeLimits { + pub attributes: HashMap, +} + +fn invalid(message: impl Into) -> rusqlite::Error { + rusqlite::Error::InvalidParameterName(message.into()) +} + +fn limit(minimum: i32, maximum: i32) -> rusqlite::Result { + if minimum > maximum { + return Err(invalid(format!( + "inverted attribute limit {minimum}..{maximum}" + ))); + } + Ok(AttributeLimit { minimum, maximum }) +} + +impl UnitAttributeLimits { + pub fn load(conn: &Connection) -> rusqlite::Result { + let mut result = Self::default(); + let mut stmt = + conn.prepare("SELECT unit_attribute_id, minimum, maximum FROM unit_attribute_limits")?; + let mut rows = stmt.query([])?; + while let Some(row) = rows.next()? { + let id: u8 = row.get(0)?; + let attribute = UnitAttribute::from_u8(id) + .ok_or_else(|| invalid(format!("unknown unit attribute limit {id}")))?; + let range = limit(row.get(1)?, row.get(2)?)?; + if result.attributes.insert(attribute, range).is_some() { + return Err(invalid(format!("duplicate unit attribute limit {id}"))); + } + } + Ok(result) + } + + pub fn clamp(&self, attribute: UnitAttribute, value: f64) -> f64 { + self.attributes + .get(&attribute) + .copied() + .unwrap_or_default() + .clamp(value) + } +} + +/// Ranges for permanent character pStat contributions; not final stat caps. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct CharacterPStatLimits { + pub contributions: HashMap, +} + +impl CharacterPStatLimits { + pub fn load(conn: &Connection) -> rusqlite::Result { + let mut result = Self::default(); + let mut stmt = conn.prepare("SELECT p_stat_id, max, min FROM character_p_stat_limits")?; + let mut rows = stmt.query([])?; + while let Some(row) = rows.next()? { + let id: u8 = row.get(0)?; + if !(1..=5).contains(&id) { + return Err(invalid(format!("unknown character pStat limit {id}"))); + } + let range = limit(row.get(2)?, row.get(1)?)?; + if result.contributions.insert(id, range).is_some() { + return Err(invalid(format!("duplicate character pStat limit {id}"))); + } + } + Ok(result) + } +} + +#[cfg(test)] +#[path = "attribute_limits_tests.rs"] +pub(crate) mod tests; diff --git a/rust/crates/aaemu-game/src/data/attribute_limits_tests.rs b/rust/crates/aaemu-game/src/data/attribute_limits_tests.rs new file mode 100644 index 0000000000..7cd670897a --- /dev/null +++ b/rust/crates/aaemu-game/src/data/attribute_limits_tests.rs @@ -0,0 +1,197 @@ +use super::*; + +// Native 1.2 compact rows, selected read-only from the table consumed by 39577A20. +// Deliberately literal fixtures; neither the production clamp nor a round trip +// generates expected values. +pub(crate) const UNIT_ROWS: [(u8, i32, i32); 21] = [ + (6, -2_000_000_000, 10_000_000), + (8, 0, 1_000_000), + (10, -10_000, 3_000), + (16, 0, 2_000_000_000), + (21, 0, 2_000_000_000), + (22, 0, 2_000_000_000), + (25, 0, 2_000_000_000), + (30, 0, 2_000_000_000), + (33, 0, 10_000_000), + (34, 0, 10_000_000), + (35, 0, 10_000_000), + (51, -1_000, 5_000), + (52, -1_000, 5_000), + (53, -1_000, 5_000), + (54, -800, 4_000), + (55, -800, 4_000), + (71, -600, 4_000), + (74, -800, 4_000), + (95, 0, 500), + (119, -800, 4_000), + (120, -800, 5_000), +]; + +pub(crate) fn fixture() -> (UnitAttributeLimits, CharacterPStatLimits) { + let conn = Connection::open_in_memory().unwrap(); + conn.execute_batch( + "CREATE TABLE unit_attribute_limits (unit_attribute_id INTEGER, minimum INTEGER, maximum INTEGER); + CREATE TABLE character_p_stat_limits (p_stat_id INTEGER, min INTEGER, max INTEGER);", + ) + .unwrap(); + for (id, min, max) in UNIT_ROWS { + conn.execute( + "INSERT INTO unit_attribute_limits VALUES (?1,?2,?3)", + (id, min, max), + ) + .unwrap(); + } + for id in 1..=5 { + conn.execute( + "INSERT INTO character_p_stat_limits VALUES (?1,0,10000)", + [id], + ) + .unwrap(); + } + ( + UnitAttributeLimits::load(&conn).unwrap(), + CharacterPStatLimits::load(&conn).unwrap(), + ) +} + +#[test] +fn attribute_limits_native_boundaries_and_finite_numeric_policy() { + let (limits, primary) = fixture(); + assert_eq!(limits.attributes.len(), 21); + for (id, min, max) in UNIT_ROWS { + let attr = UnitAttribute::from_u8(id).unwrap(); + for (value, expected) in [ + (f64::from(min) - 1.0, f64::from(min)), + (f64::from(min), f64::from(min)), + (f64::from(min) + 0.5, f64::from(min) + 0.5), + (f64::from(max) - 0.5, f64::from(max) - 0.5), + (f64::from(max), f64::from(max)), + (f64::from(max) + 1.0, f64::from(max)), + (f64::INFINITY, f64::from(max)), + (f64::NEG_INFINITY, f64::from(min)), + (f64::NAN, 0.0), + ] { + assert_eq!(limits.clamp(attr, value), expected, "{attr:?}: {value}"); + } + } + // The five pStat ranges bound permanent contributions only, not these final + // unit attributes. Fai has no character_p_stat_limits row at all. + assert_eq!(primary.contributions.len(), 5); + for id in 1..=5 { + let range = primary.contributions[&id]; + assert_eq!( + range, + AttributeLimit { + minimum: 0, + maximum: 10_000 + } + ); + for (input, expected) in [ + (-1.0, 0.0), + (0.0, 0.0), + (10_000.0, 10_000.0), + (10_001.0, 10_000.0), + ] { + assert_eq!(range.clamp(input), expected); + } + } + assert!(!primary.contributions.contains_key(&0)); + assert!(!primary.contributions.contains_key(&6)); + assert_eq!(limits.clamp(UnitAttribute::Str, 10_001.0), 10_001.0); + assert_eq!(limits.clamp(UnitAttribute::Str, -1.0), -1.0); + assert_eq!( + limits.clamp(UnitAttribute::Fai, f64::INFINITY), + 2_000_000_000.0 + ); +} + +#[test] +fn attribute_limits_reject_malformed_ranges_ids_and_duplicates() { + for (table, columns, values, primary) in [ + ( + "unit_attribute_limits", + "unit_attribute_id, minimum, maximum", + "8,10,0", + false, + ), + ( + "unit_attribute_limits", + "unit_attribute_id, minimum, maximum", + "9,0,10", + false, + ), + ( + "unit_attribute_limits", + "unit_attribute_id, minimum, maximum", + "256,0,10", + false, + ), + ( + "unit_attribute_limits", + "unit_attribute_id, minimum, maximum", + "8,0,2147483648", + false, + ), + ( + "unit_attribute_limits", + "unit_attribute_id, minimum, maximum", + "8,NULL,10", + false, + ), + ( + "unit_attribute_limits", + "unit_attribute_id, minimum, maximum", + "8,0,10),(8,0,20", + false, + ), + ( + "character_p_stat_limits", + "p_stat_id, max, min", + "1,0,10", + true, + ), + ( + "character_p_stat_limits", + "p_stat_id, max, min", + "0,10,0", + true, + ), + ( + "character_p_stat_limits", + "p_stat_id, max, min", + "6,10,0", + true, + ), + ( + "character_p_stat_limits", + "p_stat_id, max, min", + "1,10,0),(1,20,0", + true, + ), + ] { + let conn = Connection::open_in_memory().unwrap(); + conn.execute_batch(&format!( + "CREATE TABLE {table} ({columns}); INSERT INTO {table} VALUES ({values});" + )) + .unwrap(); + let failed = if primary { + CharacterPStatLimits::load(&conn).is_err() + } else { + UnitAttributeLimits::load(&conn).is_err() + }; + assert!(failed, "accepted {table} ({values})"); + } +} + +#[test] +#[ignore = "needs AAEMU_COMPACT_DB (read-only)"] +fn attribute_limits_real_compact_db_pins_all_21_and_5_rows() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap(); + let (unit, primary) = fixture(); + assert_eq!(UnitAttributeLimits::load(&conn).unwrap(), unit); + assert_eq!(CharacterPStatLimits::load(&conn).unwrap(), primary); +} diff --git a/rust/crates/aaemu-game/src/data/character_templates.rs b/rust/crates/aaemu-game/src/data/character_templates.rs index e383a1d067..37669c1c0c 100644 --- a/rust/crates/aaemu-game/src/data/character_templates.rs +++ b/rust/crates/aaemu-game/src/data/character_templates.rs @@ -6,6 +6,7 @@ use std::collections::HashMap; use std::path::Path; +use std::sync::Arc; use rusqlite::Connection; use serde::Deserialize; @@ -89,6 +90,10 @@ pub struct ExpertLimit { #[derive(Debug, Clone, Default)] pub struct CharacterData { + /// Shared by every unit belonging to this GameServer, including non-characters. + pub unit_attribute_limits: Arc, + /// Permanent pStat contribution ranges; the contribution feature is still unimplemented. + pub p_stat_limits: super::attribute_limits::CharacterPStatLimits, /// keyed by `16 * gender + race`. pub templates: HashMap, pub ability_items: HashMap, @@ -176,6 +181,10 @@ impl CharacterData { default_world_id: u32, ) -> Result { let mut d = CharacterData { + unit_attribute_limits: Arc::new(super::attribute_limits::UnitAttributeLimits::load( + conn, + )?), + p_stat_limits: super::attribute_limits::CharacterPStatLimits::load(conn)?, blocked_names: load_blocked_names(conn)?, ..CharacterData::default() }; diff --git a/rust/crates/aaemu-game/src/data/mod.rs b/rust/crates/aaemu-game/src/data/mod.rs index 76d62981cb..7fe4b8aad6 100644 --- a/rust/crates/aaemu-game/src/data/mod.rs +++ b/rust/crates/aaemu-game/src/data/mod.rs @@ -14,6 +14,7 @@ //! //! As in the 1.2 C# (no tolerant loaders), a failing table aborts startup. +pub mod attribute_limits; pub mod character_templates; pub mod client_files; pub mod experience; diff --git a/rust/crates/aaemu-game/src/models/unit.rs b/rust/crates/aaemu-game/src/models/unit.rs index 2735c7a9c2..eac33ed301 100644 --- a/rust/crates/aaemu-game/src/models/unit.rs +++ b/rust/crates/aaemu-game/src/models/unit.rs @@ -19,7 +19,9 @@ //! holding one; collect what you need, drop the guard, then act (see `world::object`). use std::collections::HashMap; +use std::sync::Arc; +use crate::data::attribute_limits::UnitAttributeLimits; use crate::models::buff::Buffs; use crate::models::transform::Transform; use crate::models::unit_model::UnitCustomModelParams; @@ -268,9 +270,17 @@ impl DynamicBonus { pub struct Bonuses { pub statics: Vec<(u32, Vec)>, pub dynamics: Vec<(u32, Vec)>, + /// Per-server data, bound before world insertion or detached stat calculation. + pub attribute_limits: Arc, } impl Bonuses { + pub fn bind_attribute_limits(&mut self, limits: &Arc) { + if !Arc::ptr_eq(&self.attribute_limits, limits) { + self.attribute_limits = Arc::clone(limits); + } + } + /// `AddBonus(bonusIndex, bonus)`. pub fn add_bonus(&mut self, index: u32, bonus: Bonus) { match self.statics.iter_mut().find(|(i, _)| *i == index) { @@ -326,7 +336,19 @@ impl Bonuses { /// `CalculateWithBonuses(value, attr)`: static flat, dynamic flat, static percent, dynamic /// percent. (`value * bonus.Value / 100f` is float arithmetic in C#.) - pub fn calculate(&self, mut value: f64, attr: UnitAttribute, now_ms: i64) -> f64 { + pub fn calculate(&self, value: f64, attr: UnitAttribute, now_ms: i64) -> f64 { + self.calculate_with_limits(value, attr, now_ms, &self.attribute_limits) + } + + /// Explicit data also covers detached, immutable character evaluators. Apply the + /// native bound to the final raw attribute, preserving flat/percent bonus order. + pub fn calculate_with_limits( + &self, + mut value: f64, + attr: UnitAttribute, + now_ms: i64, + limits: &UnitAttributeLimits, + ) -> f64 { let statics = self.bonuses(attr); let dynamics = self.dynamic_bonuses(attr); for b in &statics { @@ -353,7 +375,7 @@ impl Bonuses { } } } - value + limits.clamp(attr, value) } } diff --git a/rust/crates/aaemu-game/src/systems/npcs/npc/stats.rs b/rust/crates/aaemu-game/src/systems/npcs/npc/stats.rs index 5994c99b97..450a8e9359 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/npc/stats.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/npc/stats.rs @@ -15,6 +15,7 @@ use std::collections::HashMap; +use crate::data::attribute_limits::UnitAttributeLimits; use crate::data::formulas::{ FormulaManager, FormulaOwnerType, UnitFormulaKind, UnitFormulaVariableType, }; @@ -92,25 +93,38 @@ pub struct NpcStatCalc<'a> { pub template: &'a NpcTemplate, pub level: u8, pub bonuses: &'a Bonuses, + pub limits: &'a UnitAttributeLimits, pub mainhand: Option, pub offhand: Option, pub ranged: Option, } /// The int-getter bonus loop. -fn apply_int(bonuses: &Bonuses, attr: UnitAttribute, mut res: i32) -> i32 { +fn apply_int( + bonuses: &Bonuses, + limits: &UnitAttributeLimits, + attr: UnitAttribute, + res: i32, +) -> i32 { + // Widen intermediates so a large stack cannot wrap before the final raw cap. + let mut res = f64::from(res); for b in bonuses.bonuses(attr) { if b.template.modifier_type == UnitModifierType::Percent { - res = res.wrapping_add((res.wrapping_mul(b.value) as f32 / 100.0) as i32); + res += f64::from(((res * f64::from(b.value)) as f32 / 100.0).trunc()); } else { - res = res.wrapping_add(b.value); + res += f64::from(b.value); } } - res + limits.clamp(attr, res) as i32 } /// The double-getter bonus loop (`DpsInc`, `RangedDpsInc`, `MDpsInc`). -fn apply_f64(bonuses: &Bonuses, attr: UnitAttribute, mut res: f64) -> f64 { +fn apply_f64( + bonuses: &Bonuses, + limits: &UnitAttributeLimits, + attr: UnitAttribute, + mut res: f64, +) -> f64 { for b in bonuses.bonuses(attr) { if b.template.modifier_type == UnitModifierType::Percent { res += res * f64::from(b.value) / 100.0; @@ -118,7 +132,7 @@ fn apply_f64(bonuses: &Bonuses, attr: UnitAttribute, mut res: f64) -> f64 { res += f64::from(b.value); } } - res + limits.clamp(attr, res) } /// Base attributes passed to the derived formulas. @@ -175,7 +189,12 @@ impl NpcStatCalc<'_> { } fn base_attr(&self, kind: UnitFormulaKind, attr: UnitAttribute) -> i32 { - apply_int(self.bonuses, attr, self.eval(kind, None, false) as i32) + apply_int( + self.bonuses, + self.limits, + attr, + self.eval(kind, None, false) as i32, + ) } fn base(&self) -> Base { @@ -190,12 +209,17 @@ impl NpcStatCalc<'_> { } fn derived_int(&self, b: Base, kind: UnitFormulaKind, attr: UnitAttribute, add: i32) -> i32 { - let res = (self.eval(kind, Some(b), false) as i32).wrapping_add(add); - apply_int(self.bonuses, attr, res) + let res = (self.eval(kind, Some(b), false) as i32).saturating_add(add); + apply_int(self.bonuses, self.limits, attr, res) } fn derived_f64(&self, b: Base, kind: UnitFormulaKind, attr: UnitAttribute) -> i32 { - apply_f64(self.bonuses, attr, self.eval(kind, Some(b), false)) as i32 + apply_f64( + self.bonuses, + self.limits, + attr, + self.eval(kind, Some(b), false), + ) as i32 } /// `Dps` / `OffhandDps` / `RangedDps`: float `weapon.Dps + stat / 10f` with the bonuses, @@ -210,7 +234,7 @@ impl NpcStatCalc<'_> { res += b.value as f32; } } - (res * 1000.0) as i32 + self.limits.clamp(attr, f64::from(res * 1000.0)) as i32 } /// Every getter. @@ -228,7 +252,7 @@ impl NpcStatCalc<'_> { res += f64::from(bo.value); } } - (res * 1000.0) as i32 + self.limits.clamp(A::SpellDps, res * 1000.0) as i32 }; let kill_exp = if self.template.no_exp { 0 @@ -290,6 +314,7 @@ pub fn npc_stats(gd: &GameData, npc: &Npc) -> Option { template, level: npc.unit.level, bonuses: &npc.unit.bonuses, + limits: &gd.characters.unit_attribute_limits, mainhand: weapon(equip_slot::MAINHAND), offhand: weapon(equip_slot::OFFHAND), ranged: weapon(equip_slot::RANGED), @@ -300,6 +325,9 @@ pub fn npc_stats(gd: &GameData, npc: &Npc) -> Option { /// Caches `MaxHp`, `MaxMp` and the regen getters in `npc.unit` (shared code reads those). pub fn refresh_cached_stats(gd: &GameData, npc: &mut Npc) { + npc.unit + .bonuses + .bind_attribute_limits(&gd.characters.unit_attribute_limits); let Some(s) = npc_stats(gd, npc) else { return; }; @@ -384,6 +412,7 @@ pub(crate) mod tests { template: t, level, bonuses: b, + limits: &b.attribute_limits, mainhand: Some(WeaponDps { dps: 30.5, mdps: 12.25, diff --git a/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs b/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs new file mode 100644 index 0000000000..b3360494fb --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs @@ -0,0 +1,547 @@ +//! Regression scenarios for the native final-raw-attribute clamp. These use the +//! real buff lifecycle, gear hook, stat evaluators and XP/haste consumers. Native +//! numeric evidence and the literal compact fixture are in data::attribute_limits. + +use std::sync::Arc; + +use crate::data::attribute_limits::{tests::fixture as limits_fixture, AttributeLimit}; +use crate::data::items::{EquipTemplate, ItemTemplate, TemplateKind}; +use crate::data::GameData; +use crate::models::container::equip_slot; +use crate::models::item::Item; +use crate::models::unit::{ + Bonus, BonusTemplate, UnitAttribute as A, UnitBase, UnitModifierType as M, +}; +use crate::systems::skills::{self, data::BuffTemplate, types::SkillCaster}; +use crate::test_support::test_experience; +use crate::world::{Entity, WorldObject}; + +use super::{stat, stats, CharInputs, CharStats, StatKind as S}; + +fn data() -> GameData { + let mut d = GameData::empty(); + let (unit, primary) = limits_fixture(); + d.characters.unit_attribute_limits = Arc::new(unit); + d.characters.p_stat_limits = primary; + d.experience = test_experience(55); + d.formulas = crate::systems::vehicles::stats::tests::formulas( + &[ + (1, "100", 22, 0), + (2, "100", 23, 0), + (3, "100", 24, 0), + (4, "100", 25, 0), + (5, "100", 26, 0), + (6, "100", 27, 0), + (7, "1000 + sta * 10", 14, 0), + (8, "100", 15, 0), + (9, "100", 18, 0), + ], + &[], + ); + d +} + +fn modifier(attr: A, kind: M, value: i32) -> BonusTemplate { + BonusTemplate { + attribute: attr, + modifier_type: kind, + value, + linear_level_bonus: 0, + } +} + +fn boost(d: &mut GameData, id: u32, modifiers: Vec) { + d.systems.skills.add_buff(BuffTemplate { + id, + kind: 1, + stack_rule: 1, + bonuses: modifiers, + ..Default::default() + }); +} + +fn apply(server: &crate::GameServer, obj: &WorldObject, id: u32) { + skills::buffs::apply_template( + server, + server.game_data.systems.skills.buff(id).unwrap(), + Some(obj), + &SkillCaster::Unit(obj.obj_id()), + obj, + None, + ); + assert!(obj.with_unit(|u| u.unit().buffs.check_buff(id)).unwrap()); +} + +#[tokio::test] +async fn attribute_limits_equipment_and_stacked_buff_flow_caps_only_final_value() { + let mut d = data(); + const ITEM: u32 = 60001; + d.items.templates.insert( + ITEM, + ItemTemplate::new(ITEM, TemplateKind::Weapon(EquipTemplate::default())), + ); + d.systems.skills.item_unit_modifiers.insert( + ITEM, + vec![ + modifier(A::MaxHealth, M::Value, 20_000_000), + modifier(A::Armor, M::Value, 2_000_000), + ], + ); + boost( + &mut d, + 60002, + vec![ + modifier(A::MaxHealth, M::Value, -15_000_000), + modifier(A::Armor, M::Value, -1_500_000), + ], + ); + boost(&mut d, 60003, vec![modifier(A::MaxHealth, M::Percent, 100)]); + let (server, _client, p, _) = skills::cast_validation_tests::fixture(d); + crate::systems::economy::bridges::install(&server); + let obj = WorldObject::from(&p); + assert_eq!( + stats(&server, &obj, &[S::MaxHp, S::Armor]), + vec![2_000.0, 100.0] + ); + + let t = server.game_data.items.template(ITEM).unwrap(); + let mut item = Item::create(42, t, 1, 0, p.character_id, &server.game_data.items, 0); + item.class = t.class_type(); + item.slot = equip_slot::MAINHAND; + p.data() + .inventory + .equipment() + .lock() + .unwrap() + .items + .push(item.clone()); + let gear = server.systems.economy.hooks.gear.get().unwrap(); + gear.update_gear_bonuses(&server, &obj, Some(&item), None); + assert_eq!( + stats(&server, &obj, &[S::MaxHp, S::Armor]), + vec![10_000_000.0, 1_000_000.0] + ); + assert_eq!(p.data().unit.max_hp, 10_000_000); + + // The original +20M item modifier remains intact. Clamping that modifier or + // the intermediate result would produce a different answer when -15M arrives. + apply(&server, &obj, 60002); + assert_eq!( + stats(&server, &obj, &[S::MaxHp, S::Armor]), + vec![5_002_000.0, 500_100.0] + ); + apply(&server, &obj, 60003); + assert_eq!(stat(&server, &obj, S::MaxHp), 10_000_000.0); + skills::buffs::remove_buff(&server, &obj, 60003); + assert_eq!(p.data().unit.max_hp, 5_002_000); + skills::buffs::remove_buff(&server, &obj, 60002); + assert_eq!(p.data().unit.max_hp, 10_000_000); + p.data().inventory.equipment().lock().unwrap().items.clear(); + gear.update_gear_bonuses(&server, &obj, None, Some(&item)); + assert_eq!( + stats(&server, &obj, &[S::MaxHp, S::Armor]), + vec![2_000.0, 100.0] + ); + assert_eq!(p.data().unit.max_hp, 2_000); +} + +#[tokio::test] +async fn attribute_limits_extreme_buff_xp_haste_and_multiplier_units() { + let mut d = data(); + let attrs = [ + A::MoveSpeedMul, + A::MeleeSpeedMul, + A::RangedSpeedMul, + A::GlobalCooldownMul, + A::CastingTimeMul, + A::MeleeDamageMul, + A::RangedDamageMul, + A::SpellDamageMul, + A::HealMul, + A::ExpMul, + ]; + for (id, value) in [(60010, i32::MAX), (60011, i32::MIN)] { + boost( + &mut d, + id, + attrs.map(|a| modifier(a, M::Value, value)).to_vec(), + ); + } + let (server, _client, p, _) = skills::cast_validation_tests::fixture(d); + let obj = WorldObject::from(&p); + let kinds = [ + S::MoveSpeedMul, + S::GlobalCooldownMul, + S::CastTimeMul, + S::MeleeDamageMul, + S::RangedDamageMul, + S::SpellDamageMul, + S::HealMul, + ]; + assert_eq!( + stats(&server, &obj, &kinds), + vec![1.0, 100.0, 1.0, 1.0, 1.0, 1.0, 1.0] + ); + p.data().experience = 10_000; + let delay = |id| { + skills::skill::attack_delay( + &server, + &skills::data::SkillTemplate { + id, + ..Default::default() + }, + &obj, + false, + 0.0, + ) + }; + assert_eq!(delay(2), 1500.0); + assert_eq!(delay(4), 1800.0); + let base = skills::progress::add_exp_locked(&server, &mut p.data(), 100, false).unwrap(); + assert_eq!(base.exp, 100); + + apply(&server, &obj, 60010); + assert_eq!( + stats(&server, &obj, &kinds), + vec![3.0, 20.0, 5.0, 6.0, 6.0, 6.0, 6.0] + ); + for attr in [A::MeleeSpeedMul, A::RangedSpeedMul] { + assert_eq!(p.data().unit.calculate_with_bonuses(0.0, attr, 0), 4000.0); + } + assert_eq!(delay(2), 60.0); // 1500 * GCD(.2) * haste(.2) + assert_eq!(delay(4), 72.0); + let gain = skills::progress::add_exp_locked(&server, &mut p.data(), 100, false).unwrap(); + assert_eq!(gain.exp, 500); + skills::buffs::remove_buff(&server, &obj, 60010); + + apply(&server, &obj, 60011); + let values = stats(&server, &obj, &kinds); + for (value, expected) in values + .into_iter() + .zip([-10.0, 500.0, 0.4, 0.0, 0.0, 0.0, 0.2]) + { + assert!((value - expected).abs() < 1e-6, "{value} != {expected}"); + } + for attr in [A::MeleeSpeedMul, A::RangedSpeedMul] { + assert_eq!(p.data().unit.calculate_with_bonuses(0.0, attr, 0), -800.0); + } + assert_eq!(delay(2), 37500.0); // 1500 * GCD(5) * haste(5) + assert_eq!(delay(4), 45000.0); + assert_eq!( + skills::progress::add_exp_locked(&server, &mut p.data(), 100, false) + .unwrap() + .exp, + 0 + ); + // XP loss still bypasses bonuses; positive gain still saturates before i32 conversion. + assert_eq!( + skills::progress::add_exp_locked(&server, &mut p.data(), -10, false) + .unwrap() + .exp, + -10 + ); + skills::buffs::remove_buff(&server, &obj, 60011); + assert_eq!( + stats(&server, &obj, &kinds), + vec![1.0, 100.0, 1.0, 1.0, 1.0, 1.0, 1.0] + ); +} + +#[tokio::test] +async fn attribute_limits_detached_xp_and_character_formulas_use_server_data() { + let server = crate::test_support::test_server_with(data()); + let mut c = crate::test_support::test_character(1, "Detached", 0.0, 0.0); + c.experience = 10_000; + c.unit.bonuses.add_bonus( + 1, + Bonus { + template: modifier(A::ExpMul, M::Value, 10000), + value: 10000, + }, + ); + assert_eq!( + skills::progress::add_exp_locked(&server, &mut c, 100, false) + .unwrap() + .exp, + 500 + ); + assert!(Arc::ptr_eq( + &c.unit.bonuses.attribute_limits, + &server.game_data.characters.unit_attribute_limits + )); + for (attr, value) in [ + (A::Str, 10_000), + (A::Dex, -101), + (A::MoveSpeedMul, 99999), + (A::MaxHealth, 99999999), + ] { + c.unit.bonuses.add_bonus( + 2, + Bonus { + template: modifier(attr, M::Value, value), + value, + }, + ); + } + let mut calc = CharStats::new(&server, &c, CharInputs::default(), 0); + assert_eq!(calc.get(S::Str), 10_100.0); // pStat limits cannot cap equipment/buffs + assert_eq!(calc.get(S::Dex), -1.0); + assert_eq!(calc.get(S::MoveSpeedMul), 3.0); + assert_eq!(calc.get(S::MaxHp), 10_000_000.0); + + // Explicit evaluator data must also work before any mutable path has bound + // this unit, and must not reuse the limits from another GameServer. + let mut other = data(); + Arc::make_mut(&mut other.characters.unit_attribute_limits) + .attributes + .insert( + A::MaxHealth, + AttributeLimit { + minimum: 0, + maximum: 5000, + }, + ); + let other = crate::test_support::test_server_with(other); + assert_eq!( + CharStats::new(&other, &c, CharInputs::default(), 0).get(S::MaxHp), + 5000.0 + ); + assert_eq!( + CharStats::new(&server, &c, CharInputs::default(), 0).get(S::MaxHp), + 10_000_000.0 + ); + assert_eq!( + skills::progress::add_exp_locked(&server, &mut c, i32::MAX, false) + .unwrap() + .exp, + i32::MAX + ); + assert!(c.experience >= 10_000); // positive gain cannot wrap into negative XP +} + +#[tokio::test] +async fn attribute_limits_detached_npc_and_vehicle_getters_widen_before_final_cap() { + use crate::models::npc::Npc; + use crate::systems::npcs::npc::{data::NpcTemplate, stats as npc_stats}; + use crate::systems::vehicles::stats::{refresh_pools, stats_of, VehicleKind}; + let mut d = data(); + // Synthetic extreme formulas make incorrect character-only 10000 caps and + // overflow in the separate NPC/vehicle integer loops observable. + let mut rows = vec![]; + let mut id = 1; + for owner in [1, 2, 4, 5, 6] { + for (formula, kind) in [("20000", 22), ("1000", 14), ("100", 18)] { + rows.push((id, formula, kind, owner)); + id += 1; + } + } + d.formulas = crate::systems::vehicles::stats::tests::formulas(&rows, &[]); + d.systems.npcs.npc.templates.insert( + 1, + NpcTemplate { + id: 1, + ..Default::default() + }, + ); + let server = crate::test_support::test_server_with(d); + let mut npc = Npc::new(1); + let baseline = npc_stats::npc_stats(&server.game_data, &npc).unwrap(); + assert_eq!( + (baseline.str_, baseline.max_hp, baseline.armor), + (20000, 1000, 100) + ); + for attr in [A::MaxHealth, A::Armor] { + for index in 1..=2 { + npc.unit.bonuses.add_bonus( + index, + Bonus { + template: modifier(attr, M::Value, i32::MAX), + value: i32::MAX, + }, + ); + } + } + let boosted = npc_stats::npc_stats(&server.game_data, &npc).unwrap(); + assert_eq!( + (boosted.str_, boosted.max_hp, boosted.armor), + (20000, 10_000_000, 1_000_000) + ); + npc_stats::refresh_cached_stats(&server.game_data, &mut npc); + assert_eq!(npc.unit.max_hp, 10_000_000); + assert!(Arc::ptr_eq( + &npc.unit.bonuses.attribute_limits, + &server.game_data.characters.unit_attribute_limits + )); + + for kind in [ + VehicleKind::Mate { mate_kind_id: 1 }, + VehicleKind::Slave, + VehicleKind::Transfer, + VehicleKind::Shipyard, + ] { + let mut u = UnitBase::default(); + assert_eq!( + stats_of(&server, kind, &u, &[S::Str, S::MaxHp]), + vec![20000.0, 1000.0] + ); + for index in 1..=2 { + u.bonuses.add_bonus( + index, + Bonus { + template: modifier(A::MaxHealth, M::Value, i32::MAX), + value: i32::MAX, + }, + ); + } + assert_eq!( + stats_of(&server, kind, &u, &[S::Str, S::MaxHp]), + vec![20000.0, 10_000_000.0] + ); + refresh_pools(&server, kind, &mut u); + assert_eq!(u.max_hp, 10_000_000); + assert!(Arc::ptr_eq( + &u.bonuses.attribute_limits, + &server.game_data.characters.unit_attribute_limits + )); + u.bonuses.statics.clear(); + for index in 1..=2 { + u.bonuses.add_bonus( + index, + Bonus { + template: modifier(A::MaxHealth, M::Value, i32::MIN), + value: i32::MIN, + }, + ); + } + refresh_pools(&server, kind, &mut u); + assert_eq!(u.max_hp, -2_000_000_000); + } +} + +#[test] +fn attribute_limits_dynamic_percent_order_and_extreme_stacks_remain_finite() { + use crate::models::unit::{DynamicBonus, DynamicBonusTemplate, LinearFuncTemplate}; + let (limits, _) = limits_fixture(); + let mut u = UnitBase::default(); + u.bonuses.bind_attribute_limits(&Arc::new(limits)); + for (index, kind, value) in [ + (1, M::Percent, 100), + (2, M::Value, 2000), + (3, M::Value, -2500), + ] { + u.bonuses.add_bonus( + index, + Bonus { + template: modifier(A::MoveSpeedMul, kind, value), + value, + }, + ); + } + u.bonuses.add_dynamic_bonus( + 4, + DynamicBonus { + template: DynamicBonusTemplate { + attribute: A::MoveSpeedMul, + modifier_type: M::Percent, + func_id: 1, + func_type: "LinearFunc".into(), + }, + source_buff_index: 4, + source_start_ms: 0, + source_duration: 1000, + linear_func: Some(LinearFuncTemplate { + id: 1, + start_value: 100, + end_value: 100, + }), + manual_values: None, + source_tick_ms: 100.0, + }, + ); + // (1000 + 2000 - 2500) * 2 * 2; no intermediate clamp despite reaching 3000. + assert_eq!( + u.calculate_with_bonuses(1000.0, A::MoveSpeedMul, 500), + 2000.0 + ); + for index in 5..150 { + u.bonuses.add_bonus( + index, + Bonus { + template: modifier(A::MoveSpeedMul, M::Percent, i32::MAX), + value: i32::MAX, + }, + ); + } + assert_eq!( + u.calculate_with_bonuses(1000.0, A::MoveSpeedMul, 500), + 3000.0 + ); + assert_eq!( + u.calculate_with_bonuses(f64::NAN, A::MoveSpeedMul, 500), + 0.0 + ); +} + +#[tokio::test] +async fn attribute_limits_are_per_server_for_every_spawned_unit_kind() { + let a = data(); + let mut b = data(); + Arc::make_mut(&mut b.characters.unit_attribute_limits) + .attributes + .insert( + A::MoveSpeedMul, + AttributeLimit { + minimum: -500, + maximum: 1250, + }, + ); + let sa = crate::test_support::test_server_with(a); + let sb = crate::test_support::test_server_with(b); + use crate::models::{ + gimmick::Gimmick, + house::House, + mate::Mate, + npc::Npc, + shipyard::{Shipyard, ShipyardData}, + slave::Slave, + transfer::Transfer, + }; + let objects = vec![ + WorldObject::from(Entity::new(100, Npc::new(1))), + WorldObject::from(Entity::new(101, Mate::new(1, 1))), + WorldObject::from(Entity::new(102, Slave::new(1, 1))), + WorldObject::from(Entity::new(103, House::new(1, 1))), + WorldObject::from(Entity::new(104, Transfer::new(1))), + WorldObject::from(Entity::new(105, Shipyard::new(ShipyardData::default()))), + WorldObject::from(Entity::new(106, Gimmick::new(1))), + ]; + for obj in objects { + obj.with_unit(|u| { + u.unit_mut().bonuses.add_bonus( + 1, + Bonus { + template: modifier(A::MoveSpeedMul, M::Value, 5000), + value: 5000, + }, + ); + }); + for (server, expected) in [(&sa, 3000.0), (&sb, 1250.0), (&sa, 3000.0)] { + server + .world + .world(0) + .unwrap() + .spawn(&obj, &server.view_ctx()); + assert_eq!( + obj.with_unit(|u| u.unit().calculate_with_bonuses(1000.0, A::MoveSpeedMul, 0)), + Some(expected) + ); + assert!(obj + .with_unit(|u| Arc::ptr_eq( + &u.unit().bonuses.attribute_limits, + &server.game_data.characters.unit_attribute_limits + )) + .unwrap()); + server.world.world(0).unwrap().delete(&obj); + } + } +} diff --git a/rust/crates/aaemu-game/src/systems/skills/progress.rs b/rust/crates/aaemu-game/src/systems/skills/progress.rs index f1686c14b5..f9a5cf014c 100644 --- a/rust/crates/aaemu-game/src/systems/skills/progress.rs +++ b/rust/crates/aaemu-game/src/systems/skills/progress.rs @@ -138,6 +138,9 @@ pub fn add_exp_locked( mut exp_delta: i32, add_ability_exp: bool, ) -> Option { + c.unit + .bonuses + .bind_attribute_limits(&server.game_data.characters.unit_attribute_limits); if exp_delta == 0 { return None; } diff --git a/rust/crates/aaemu-game/src/systems/skills/stats.rs b/rust/crates/aaemu-game/src/systems/skills/stats.rs index 1c11856519..0418c0b7a5 100644 --- a/rust/crates/aaemu-game/src/systems/skills/stats.rs +++ b/rust/crates/aaemu-game/src/systems/skills/stats.rs @@ -1,6 +1,6 @@ //! Unit attribute getters (`Unit` virtual properties, the `Character` overrides evaluated through //! `FormulaManager` + `CalculateWithBonuses` + equipment, the `Npc` overrides through the npc -//! subsystem hook). One call locks the object once and evaluates any number of attributes. +//! subsystem hook). One call evaluates any number of attributes under the object's lock. use std::collections::HashMap; @@ -221,11 +221,23 @@ pub fn composed_regen(base: f64, persistent: f64) -> f64 { /// The base `Unit` getter values (no override). pub fn base_unit_stat(u: &UnitBase, kind: StatKind, now: i64) -> f64 { + base_unit_stat_with_limits(u, kind, now, &u.bonuses.attribute_limits) +} + +/// Explicit per-server data for detached vehicle evaluators too. +pub fn base_unit_stat_with_limits( + u: &UnitBase, + kind: StatKind, + now: i64, + limits: &crate::data::attribute_limits::UnitAttributeLimits, +) -> f64 { use StatKind as S; match kind { S::MoveSpeedMul => { - (u.calculate_with_bonuses(1000.0, UnitAttribute::MoveSpeedMul, now) as f32 / 1000.0) - as f64 + (u.bonuses + .calculate_with_limits(1000.0, UnitAttribute::MoveSpeedMul, now, limits) + as f32 + / 1000.0) as f64 } S::GlobalCooldownMul => f64::from(u.global_cooldown_mul), S::MaxHp => f64::from(u.max_hp), @@ -247,9 +259,14 @@ pub fn base_unit_stat(u: &UnitBase, kind: StatKind, now: i64) -> f64 { | S::IncomingRangedDamageMul | S::IncomingSpellDamageMul | S::IncomingSiegeDamageMul => 1.0, - S::AggroMul => u.calculate_with_bonuses(100.0, UnitAttribute::AggroMul, now) as f32 as f64, + S::AggroMul => u + .bonuses + .calculate_with_limits(100.0, UnitAttribute::AggroMul, now, limits) + as f32 as f64, S::IncomingAggroMul => { - u.calculate_with_bonuses(100.0, UnitAttribute::IncomingAggroMul, now) as f32 as f64 + u.bonuses + .calculate_with_limits(100.0, UnitAttribute::IncomingAggroMul, now, limits) + as f32 as f64 } _ => 0.0, } @@ -287,7 +304,12 @@ impl<'a> CharStats<'a> { } fn cwb(&self, v: f64, a: UnitAttribute) -> f64 { - self.c.unit.calculate_with_bonuses(v, a, self.now) + self.c.unit.bonuses.calculate_with_limits( + v, + a, + self.now, + &self.server.game_data.characters.unit_attribute_limits, + ) } fn formula(&self, kind: UnitFormulaKind, params: &HashMap<&str, f64>) -> f64 { @@ -608,14 +630,15 @@ impl<'a> CharStats<'a> { S::HealCriticalMul => self.cwb(0.0, A::HealCriticalMul) as f32 as f64, S::Armor => { let pa = self.all_params(); - let res = self.formula(F::Armor, &pa) as i32 + self.inputs.gear.armor; - f64::from(self.cwb(f64::from(res), A::Armor) as i32) + let res = f64::from(self.formula(F::Armor, &pa) as i32) + + f64::from(self.inputs.gear.armor); + f64::from(self.cwb(res, A::Armor) as i32) } S::MagicResistance => { let pa = self.all_params(); - let res = - self.formula(F::MagicResist, &pa) as i32 + self.inputs.gear.magic_resistance; - f64::from(self.cwb(f64::from(res), A::MagicResist) as i32) + let res = f64::from(self.formula(F::MagicResist, &pa) as i32) + + f64::from(self.inputs.gear.magic_resistance); + f64::from(self.cwb(res, A::MagicResist) as i32) } S::DefensePenetration => f64::from(self.cwb(0.0, A::IgnoreArmor) as i32), S::MagicPenetration => f64::from(self.cwb(0.0, A::MagicPenetration) as i32), @@ -652,9 +675,9 @@ impl<'a> CharStats<'a> { res as f32 as f64 } S::LungCapacity => f64::from(self.cwb(60000.0, A::LungCapacity) as u32), - S::MoveSpeedMul | S::AggroMul | S::IncomingAggroMul => { - base_unit_stat(&self.c.unit, kind, self.now) - } + S::MoveSpeedMul => (self.cwb(1000.0, A::MoveSpeedMul) as f32 / 1000.0) as f64, + S::AggroMul => self.cwb(100.0, A::AggroMul) as f32 as f64, + S::IncomingAggroMul => self.cwb(100.0, A::IncomingAggroMul) as f32 as f64, } } } @@ -674,8 +697,13 @@ pub fn char_inputs(server: &GameServer, p: &crate::world::PlayerRef) -> CharInpu } } -/// Evaluates `kinds` for one object (locks it once). Doodads and non-units give 0. +/// Binds per-server limits, then evaluates `kinds` for one object. Doodads and non-units give 0. pub fn stats(server: &GameServer, obj: &WorldObject, kinds: &[StatKind]) -> Vec { + obj.with_unit(|u| { + u.unit_mut() + .bonuses + .bind_attribute_limits(&server.game_data.characters.unit_attribute_limits); + }); let now = now_ms(); match obj { WorldObject::Player(p) => { @@ -906,6 +934,10 @@ pub fn update_npc_gear_bonuses( update_unit_gear_bonuses(server, &WorldObject::from(npc), added, removed); } +#[cfg(test)] +#[path = "attribute_limits_tests.rs"] +mod attribute_limits_tests; + #[cfg(test)] mod vehicle_gear_tests { use std::sync::Arc; diff --git a/rust/crates/aaemu-game/src/systems/vehicles/stats.rs b/rust/crates/aaemu-game/src/systems/vehicles/stats.rs index f8a0afccd2..8301c78429 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/stats.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/stats.rs @@ -7,10 +7,11 @@ use std::collections::HashMap; +use crate::data::attribute_limits::UnitAttributeLimits; use crate::data::formulas::{FormulaOwnerType, UnitFormulaKind, UnitFormulaVariableType}; use crate::models::unit::{UnitAttribute, UnitBase, UnitModifierType}; use crate::server::GameServer; -use crate::systems::skills::stats::{base_unit_stat, StatKind}; +use crate::systems::skills::stats::{base_unit_stat_with_limits, StatKind}; use crate::world::WorldObject; /// Which getter set a unit kind uses. @@ -37,19 +38,27 @@ impl VehicleKind { } /// `foreach (var bonus in GetBonuses(attr))` on an `int` result. -fn int_bonuses(u: &UnitBase, mut res: i32, attr: UnitAttribute) -> i32 { +fn int_bonuses(u: &UnitBase, limits: &UnitAttributeLimits, res: i32, attr: UnitAttribute) -> i32 { + // Keep the int getter's per-bonus truncation, widening before a large stack + // can overflow. Only the complete raw attribute receives its data bound. + let mut res = f64::from(res); for b in u.bonuses.bonuses(attr) { if b.template.modifier_type == UnitModifierType::Percent { - res += (res as f32 * b.value as f32 / 100.0) as i32; + res += f64::from((res as f32 * b.value as f32 / 100.0).trunc()); } else { - res += b.value; + res += f64::from(b.value); } } - res + limits.clamp(attr, res) as i32 } /// `foreach (var bonus in GetBonuses(attr))` on a `double` result. -fn float_bonuses(u: &UnitBase, mut res: f64, attr: UnitAttribute) -> f64 { +fn float_bonuses( + u: &UnitBase, + limits: &UnitAttributeLimits, + mut res: f64, + attr: UnitAttribute, +) -> f64 { for b in u.bonuses.bonuses(attr) { if b.template.modifier_type == UnitModifierType::Percent { res += res * f64::from(b.value as f32 / 100.0); @@ -57,7 +66,7 @@ fn float_bonuses(u: &UnitBase, mut res: f64, attr: UnitAttribute) -> f64 { res += f64::from(b.value); } } - res + limits.clamp(attr, res) } struct Eval<'a> { @@ -86,7 +95,12 @@ impl Eval<'_> { fn base_attr(&self, kind: UnitFormulaKind, attr: UnitAttribute) -> i32 { let p = HashMap::from([("level", self.level())]); - int_bonuses(self.u, self.formula(kind, &p) as i32, attr) + int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + self.formula(kind, &p) as i32, + attr, + ) } fn str_(&self) -> i32 { @@ -171,30 +185,51 @@ impl Eval<'_> { let res = self.formula(K::MaxHealth, &self.pool_params(true, K::MaxHealth)) as i32; if mate { // `CalculateWithBonuses(res, MaxHealth)` - f64::from( - self.u - .calculate_with_bonuses(f64::from(res), A::MaxHealth, self.now) - as i32, - ) + f64::from(self.u.bonuses.calculate_with_limits( + f64::from(res), + A::MaxHealth, + self.now, + &self.server.game_data.characters.unit_attribute_limits, + ) as i32) } else { - f64::from(int_bonuses(self.u, res, A::MaxHealth)) + f64::from(int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + res, + A::MaxHealth, + )) } } S::MaxMp => { let res = self.formula(K::MaxMana, &self.pool_params(true, K::MaxMana)) as i32; - f64::from(int_bonuses(self.u, res, A::MaxMana)) + f64::from(int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + res, + A::MaxMana, + )) } S::HpRegen => { let mut res = self.formula(K::HealthRegen, &self.pool_params(false, K::HealthRegen)) as i32; res += self.spi() / 10; - f64::from(int_bonuses(self.u, res, A::HealthRegen)) + f64::from(int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + res, + A::HealthRegen, + )) } S::MpRegen => { let mut res = self.formula(K::ManaRegen, &self.pool_params(false, K::ManaRegen)) as i32; res += self.spi() / 10; - f64::from(int_bonuses(self.u, res, A::ManaRegen)) + f64::from(int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + res, + A::ManaRegen, + )) } S::PersistentHpRegen => { let mut res = self.formula( @@ -204,7 +239,12 @@ impl Eval<'_> { if persistent_div { res /= 5; } - f64::from(int_bonuses(self.u, res, A::PersistentHealthRegen)) + f64::from(int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + res, + A::PersistentHealthRegen, + )) } S::PersistentMpRegen => { let mut res = self.formula( @@ -214,7 +254,12 @@ impl Eval<'_> { if persistent_div { res /= 5; } - f64::from(int_bonuses(self.u, res, A::PersistentManaRegen)) + f64::from(int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + res, + A::PersistentManaRegen, + )) } S::LevelDps if combat => { let ab = if mate { self.level() } else { 0.0 }; @@ -228,6 +273,7 @@ impl Eval<'_> { let p = self.full_params(); f64::from(int_bonuses( self.u, + &self.server.game_data.characters.unit_attribute_limits, self.formula(K::Armor, &p) as i32, A::Armor, )) @@ -236,6 +282,7 @@ impl Eval<'_> { let p = self.full_params(); f64::from(int_bonuses( self.u, + &self.server.game_data.characters.unit_attribute_limits, self.formula(K::MagicResist, &p) as i32, A::MagicResist, )) @@ -246,13 +293,23 @@ impl Eval<'_> { S::OffhandDps if slave => self.weapon_dps(f64::from(self.str_()), A::OffhandDps), S::RangedDps if slave => self.weapon_dps(f64::from(self.dex()), A::RangedDps), S::MDps if slave => self.weapon_dps(f64::from(self.int()), A::SpellDps), - other => base_unit_stat(self.u, other, self.now), + other => base_unit_stat_with_limits( + self.u, + other, + self.now, + &self.server.game_data.characters.unit_attribute_limits, + ), } } fn inc(&self, kind: UnitFormulaKind, attr: UnitAttribute) -> f64 { let p = self.full_params(); - f64::from(float_bonuses(self.u, self.formula(kind, &p), attr) as i32) + f64::from(float_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + self.formula(kind, &p), + attr, + ) as i32) } fn weapon_dps(&self, attr_value: f64, attr: UnitAttribute) -> f64 { @@ -264,7 +321,13 @@ impl Eval<'_> { res += b.value as f32; } } - f64::from((res * 1000.0) as i32) + f64::from( + self.server + .game_data + .characters + .unit_attribute_limits + .clamp(attr, f64::from(res * 1000.0)) as i32, + ) } } @@ -315,6 +378,8 @@ pub fn stats_of( /// Recomputes the cached pool values (`max_hp`, `max_mp`, regen) of a detached unit. pub fn refresh_pools(server: &GameServer, kind: VehicleKind, u: &mut UnitBase) { + u.bonuses + .bind_attribute_limits(&server.game_data.characters.unit_attribute_limits); let v = stats_of( server, kind, diff --git a/rust/crates/aaemu-game/src/world/mod.rs b/rust/crates/aaemu-game/src/world/mod.rs index 9fef75d610..d18954ee06 100644 --- a/rust/crates/aaemu-game/src/world/mod.rs +++ b/rust/crates/aaemu-game/src/world/mod.rs @@ -834,6 +834,11 @@ impl WorldInstance { /// `GameObject.Spawn()` (`ParentWorld.AddObject(this); Show()`). pub fn spawn(&self, obj: impl Into, ctx: &ViewCtx<'_>) -> Vec { let obj = obj.into(); + obj.with_unit(|u| { + u.unit_mut() + .bonuses + .bind_attribute_limits(&ctx.data.characters.unit_attribute_limits) + }); self.add_object(&obj); self.show(obj, ctx) } From dbd7cd95251ebc692a913128b650ba25b74ba1d9 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:38:40 -0400 Subject: [PATCH 30/66] fix(crafting): require a resolved same-account bench owner --- .../src/systems/economy/bench_tests.rs | 30 +++++++++++++++++++ .../aaemu-game/src/systems/economy/craft.rs | 2 +- 2 files changed, 31 insertions(+), 1 deletion(-) diff --git a/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs b/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs index 6f51662bca..fc91bdc53f 100644 --- a/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs @@ -33,6 +33,7 @@ const WRONG_PACK_GROUP: u32 = 90001; const PORTABLE: u32 = 90002; const OTHER_RECIPE: u32 = 90003; const HOUSE_PERMISSION_GROUP: u32 = 90004; +const SAME_ACCOUNT_GROUP: u32 = 90005; // One live tax CraftPack phase per plaque template (other authored phases are checked by // the ignored real-data test below). The recipe's req_doodad_id is always canonical 2392. @@ -182,6 +183,13 @@ fn data(cast_time: i32) -> GameData { permission::OWNER_ONLY, ); add_pack(&mut data, WRONG_PACK_GROUP, 90001, 4, permission::ANY); + add_pack( + &mut data, + SAME_ACCOUNT_GROUP, + 90005, + 3, + permission::SAME_ACCOUNT, + ); add_pack( &mut data, HOUSE_PERMISSION_GROUP, @@ -340,6 +348,28 @@ async fn current_craft_pack_permission_beats_first_parent_info_and_public_house( assert_eq!(f.owner.data().labor_power, 800); } +#[tokio::test] +async fn same_account_crafting_requires_a_resolved_matching_owner_account() { + for case in 0..3 { + let mut f = fixture(2392, SAME_ACCOUNT_GROUP, 0); + f.house.data().permission = housing_permission::PUBLIC; + match case { + 0 => {} // Public housing does not waive the function's account requirement. + 1 => f.house.data().account_id = f.visitor.data().account_id, + 2 => f.bench.data().owner_type = 0, // No authoritative account to compare. + _ => unreachable!(), + } + request(&f.server, &mut f.client, TAX, BENCH, 1).await; + if case == 1 { + assert_eq!(certificates(&f.visitor), 5); + assert_eq!(f.visitor.data().labor_power, 800); + } else { + assert_denied(&mut f); + assert_eq!(f.visitor.data().labor_power, 1000); + } + } +} + #[tokio::test] async fn craft_packet_rejects_wrong_recipe_pack_and_inactive_phase_even_at_canonical_id() { for (recipe, group) in [ diff --git a/rust/crates/aaemu-game/src/systems/economy/craft.rs b/rust/crates/aaemu-game/src/systems/economy/craft.rs index 7645f78c28..9aa9761b3b 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft.rs @@ -335,7 +335,7 @@ fn bench_denial( (owner_type == owner::CHARACTER) .then(|| server.names.get_character_account(owner_id)) }); - if account.is_some_and(|a| a == 0 || a != player.data().account_id) { + if account.is_none_or(|a| a == 0 || a != player.data().account_id) { return Some("the crafting function requires the owner's account"); } } From c85ad52b822cb1857ee41946cc4adbd3304c3539 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:44:14 -0400 Subject: [PATCH 31/66] docs: track ship regressions and current validation limits --- rust/docs/audit-repair-status.json | 50 +++++++++++++++++++++++++++--- 1 file changed, 45 insertions(+), 5 deletions(-) diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json index 38a2e71ec4..d69ae0a8fb 100644 --- a/rust/docs/audit-repair-status.json +++ b/rust/docs/audit-repair-status.json @@ -132,8 +132,9 @@ }, { "id": "shared-cooldown-tags", - "status": "revision_in_progress", - "note": "Native tag-list UI and matching GM server-state reset required before merge." + "status": "merged_pending_execution", + "note": "Native separate skill/tag snapshots and GM reset; root af5db95ba additionally isolates controlled-unit UI. Game all-target Clippy passed at af5db95ba; runtime regressions pending.", + "commit": "47217398ade1f50f9957b15a1e6ec1a72428eaa7" }, { "id": "xp-buff-multiplier", @@ -148,7 +149,9 @@ }, { "id": "unit-and-primary-stat-limits", - "status": "implementing" + "status": "partial_merged_pending_validation", + "commit": "ed2f7a9f3", + "note": "Native final raw unit caps implemented per server. Permanent pStat contribution ranges are loaded; contribution storage/behavior remain open. No final-primary 10000 cap invented." }, { "id": "prison-and-other-skill-restrictions", @@ -210,7 +213,9 @@ }, { "id": "mail-expiry-throttling-feedback-and-pagination", - "status": "implementing" + "status": "partial_merged_pending_validation", + "commit": "e712343a3211076ddef5db75658e6075aaa47bac", + "note": "Ordinary player-mail 14-day retention/return-once escrow policy implemented. Specialized mail, send throttles/level gates and pagination remain open. New ordinary expiry tests unexecuted." }, { "id": "npc-physical-enchant", @@ -371,6 +376,41 @@ "id": "deprecated-empty-or-client-only-data", "status": "queued", "note": "Verify before deciding no server implementation is required." + }, + { + "id": "trade-ship-cargo-reference-atomicity", + "status": "implementing", + "owner": "audit-tradeship", + "note": "Tester-reported stuck rack; source proves error14 is stale non-System item reference, not physical stacking. Production transaction and repair tests in progress." + }, + { + "id": "trade-ship-live-root-identity-after-reconnect", + "status": "implementing", + "owner": "audit-ship-session", + "note": "Source proves failed loaded-hull deletion can be ignored by summon; root lookup includes child cannons. Async session/identity invariants under repair." + }, + { + "id": "lane-allocation-concurrency", + "status": "implementing", + "owner": "audit-lane-lock", + "note": "Concurrent creation assigned the same port prefix; isolated allocator repair in progress." } - ] + ], + "recent_validation": { + "game_check": { + "head": "0cf0f23f500628ca6a0dc0cc6d46ecebc16ac9b8", + "result": "passed_all_targets" + }, + "game_clippy": { + "head": "af5db95ba0687dcc4cfb7b164af77bbd038b28cc", + "result": "passed_all_targets_D_warnings" + }, + "latest_mail_stats_clippy": { + "head": "dbd7cd95251ebc692a913128b650ba25b74ba1d9", + "result": "held_at_memory_reserve_before_completion", + "minimum_free_gib": 5.938747406005859 + }, + "current_full_lane_ci": "pending", + "current_live": "pending" + } } From 090f515b6cd59af301045c51cb1e58c7e58056ff Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:44:54 -0400 Subject: [PATCH 32/66] fix(lanes): serialize allocation and preserve reservation ownership --- Scripts/lane.sh | 132 ++++++++++--- Scripts/test_lane.py | 443 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 551 insertions(+), 24 deletions(-) create mode 100644 Scripts/test_lane.py diff --git a/Scripts/lane.sh b/Scripts/lane.sh index e81a2b0fbf..f8975f6920 100755 --- a/Scripts/lane.sh +++ b/Scripts/lane.sh @@ -39,6 +39,38 @@ setvar() { # setvar KEY VALUE: rewrite one KEY= line of the registry file local f; f=$(reg "$1"); grep -v "^$2=" "$f" > "$f.tmp" || true; echo "$2=$3" >> "$f.tmp"; mv "$f.tmp" "$f"; } mysql_up() { "${MYSQL[@]}" -N -e "select 1" >/dev/null 2>&1; } +# mkdir is atomic in Git Bash as well as on Unix (flock is not shipped with Git for Windows). +# Hold this across allocation AND publication, and serialize destructive cleanup with it too. +# Never reclaim a lock by PID or age: PIDs are reused, and a killed shell may leave git running. +# An interrupted/stale lock fails closed. After verifying ALL creators and their children have +# stopped, inspect its files and any partial worktree/branch/target before removing it manually. +allocation_lock() { + ALLOCATION_LOCK="$LANES/.allocation.lock" + ALLOCATION_OWNER="" + local timeout=${AAEMU_LANE_LOCK_TIMEOUT:-30} start=$SECONDS + [[ "$timeout" =~ ^[0-9]{1,6}$ ]] || die "AAEMU_LANE_LOCK_TIMEOUT must be seconds (0-999999)" + timeout=$((10#$timeout)) + mkdir -p "$LANES" + trap 'allocation_unlock' EXIT + trap 'exit 129' HUP; trap 'exit 130' INT; trap 'exit 143' TERM + until mkdir "$ALLOCATION_LOCK" 2>/dev/null; do + # The owner may release it between the failed mkdir and this loop; retry even if gone. + if (( SECONDS - start >= timeout )); then + die "allocation/cleanup locked ($ALLOCATION_LOCK); retry. If interrupted, verify all creators and children stopped and inspect partial resources before manual recovery; never remove a lock by PID or age" + fi + sleep 0.1 + done + # A unique marker also prevents our EXIT trap from releasing a replacement owner's lock. + # Interruption before the marker exists deliberately leaves a stale lock, never an unsafe unlock. + ALLOCATION_OWNER=$(mktemp -d "$ALLOCATION_LOCK/owner.XXXXXXXXXX") +} +allocation_owned() { [ -n "${ALLOCATION_OWNER:-}" ] && [ -d "$ALLOCATION_OWNER" ]; } +allocation_unlock() { + allocation_owned || return 0 + rm -f "$ALLOCATION_OWNER/lane.env" + rmdir "$ALLOCATION_OWNER" && rmdir "$ALLOCATION_LOCK" +} + # The lane whose worktree contains $PWD (or the script), unless a name was given. current() { local n=${1:-} @@ -65,7 +97,7 @@ clients_on() { } port_free() { ! netstat -ano 2>/dev/null | grep LISTENING | grep -q ":$1 "; } -cmd_new() { +cmd_new() ( local name="" type=fix base=$BASE_DEFAULT while [ $# -gt 0 ]; do case "$1" in @@ -74,13 +106,18 @@ cmd_new() { esac; shift done [[ "$name" =~ ^[a-z0-9][a-z0-9-]{1,30}$ ]] || die "name: 2-31 chars of a-z 0-9 - (e.g. quest-crash)" - [ -f "$(reg "$name")" ] && die "lane '$name' exists (Scripts/lane.sh info $name)" + allocation_lock + if [ -e "$(reg "$name")" ] || [ -L "$(reg "$name")" ]; then + die "lane '$name' exists (Scripts/lane.sh info $name)" + fi # Never share a target dir between worktrees: identical artifact names make cargo's mtime # fingerprints miss edits, so tests can silently run another worktree's code. local wt="$WT_ROOT/$name" branch="$type/$name" target="$TARGET_ROOT/$name" - [ -e "$wt" ] && die "$wt already exists" - [ -e "$target" ] && die "$target already exists (Scripts/lane.sh gc)" - mkdir -p "$LANES" + if [ -e "$wt" ] || [ -L "$wt" ]; then die "$wt already exists"; fi + if [ -e "$target" ] || [ -L "$target" ]; then die "$target already exists (Scripts/lane.sh gc)"; fi + git -C "$REPO" check-ref-format "refs/heads/$branch" || die "invalid branch '$branch'" + if git -C "$REPO" show-ref --verify --quiet "refs/heads/$branch"; then die "branch '$branch' already exists"; fi + local head; head=$(git -C "$REPO" rev-parse --verify "$base^{commit}") local prefix="" for p in "${PORT_PREFIXES[@]}"; do @@ -90,7 +127,60 @@ cmd_new() { done [ -n "$prefix" ] || die "no free port block (24xxx-39xxx); finish old lanes first" + # Until lane.env is published the lock reserves all four resources. Roll back only artifacts + # we know we created, while still holding that lock. Ambiguous/partial Git failures retain it + # for inspection rather than deleting a pre-existing branch or allowing prefix reuse. + local target_started=0 target_created=0 worktree_started=0 worktree_created=0 published=0 + new_exit() { + local status=$? clean=1 + trap - EXIT + if ! allocation_owned; then + echo "lane: allocation lock ownership lost; leaving resources untouched" >&2 + exit 1 + fi + if [ "$published" = 0 ] && [ ! "$(reg "$name")" -ef "$ALLOCATION_OWNER/lane.env" ]; then + if [ "$worktree_created" = 1 ]; then + rm -f "$wt/rust/.cargo/config.toml" || clean=0 + # No --force: unexpected changes or removal errors require inspection. + git -C "$REPO" worktree remove "$wt" || clean=0 + if [ "$clean" = 1 ]; then + git -C "$REPO" update-ref -d "refs/heads/$branch" "$head" || clean=0 + fi + elif [ "$worktree_started" = 1 ]; then + if [ -e "$wt" ] || git -C "$REPO" show-ref --verify --quiet "refs/heads/$branch"; then clean=0; fi + fi + if [ "$target_created" = 1 ] && [ "$clean" = 1 ]; then rmdir "$target" || clean=0; fi + if [ "$target_started" = 1 ] && [ "$target_created" = 0 ]; then + if [ -e "$target" ] || [ -L "$target" ]; then clean=0; fi + fi + fi + if [ "$clean" = 1 ]; then allocation_unlock + else echo "lane: partial creation retained with $ALLOCATION_LOCK; inspect $wt, $branch and $target before manual recovery" >&2; fi + exit "$status" + } + trap new_exit EXIT + # Leave the reservation details inside the lock for inspection after a hard interruption. + local db=${name//-/_} + cat > "$ALLOCATION_OWNER/lane.env" < "$wt/rust/.cargo/config.toml" < "$(reg "$name")" < = deadline: + raise TimeoutError(f"barrier not reached: {paths}") + time.sleep(0.02) + + +def fake_git(args): + """Only implement commands used by new/rollback; unexpected commands fail closed.""" + root = Path(os.environ["LANE_TEST_ROOT"]).resolve() + refs = root / "refs" + if args[:1] != ["-C"]: + raise AssertionError(args) + args = args[2:] + + def ref_path(ref): + return refs / ref.removeprefix("refs/heads/") + + def owned_path(value): + path = Path(value).resolve() + if not path.is_relative_to(root): + raise AssertionError(f"path outside fixture: {path}") + return path + + if args[:1] == ["check-ref-format"]: + return 0 + if args[:3] == ["show-ref", "--verify", "--quiet"]: + return 0 if ref_path(args[3]).is_file() else 1 + if args[:2] == ["rev-parse", "--verify"]: + if args[2] == "missing^{commit}": + return 70 + print(HEAD) + return 0 + if args[:2] == ["worktree", "add"]: + _, _, quiet, wt, flag, branch, base = args + assert (quiet, flag) == ("-q", "-b") + wt = owned_path(wt) + name = wt.name + (root / f"add.{name}").touch() + if os.environ.get("LANE_TEST_HOLD") == name: + wait_for(root / f"release.{name}") + failure = os.environ.get("LANE_TEST_FAIL") + if failure == "add": + return 70 + ref = ref_path(branch) + ref.parent.mkdir(parents=True, exist_ok=True) + with ref.open("x") as file: + file.write(HEAD) + wt.mkdir() + (wt / ".git").write_text("isolated fake worktree\n") + if failure == "partial-add": + return 70 + return 0 + if args[:2] == ["worktree", "remove"]: + if os.environ.get("LANE_TEST_FAIL") == "config-remove": + return 73 + wt = owned_path(args[2]) + shutil.rmtree(wt) + return 0 + if args[:2] == ["update-ref", "-d"]: + ref = ref_path(args[2]) + if not ref.is_file() or ref.read_text() != args[3]: + return 74 + ref.unlink() + return 0 + raise AssertionError(f"unexpected Git command: {args}") + + +class AllocationTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.bash = os.environ.get("LANE_TEST_BASH") + if not cls.bash and os.name == "nt": + git = shutil.which("git") + candidate = Path(git).parent.parent / "bin/bash.exe" if git else None + cls.bash = str(candidate) if candidate and candidate.exists() else None + cls.bash = cls.bash or shutil.which("bash") + if not cls.bash: + raise unittest.SkipTest("Bash (Git Bash on Windows) is required") + + def setUp(self): + # Keep scratch space in this checkout and delete it only after our subprocesses exit. + self.temp = tempfile.TemporaryDirectory(prefix=".lane-lock-test-", dir=SCRIPT.parent.parent) + self.root = Path(self.temp.name).resolve() + self.addCleanup(self.temp.cleanup) + self.processes = [] + self.addCleanup(self.reap) + self.repo = self.root / "repo" + (self.repo / "Scripts").mkdir(parents=True) + shutil.copyfile(SCRIPT, self.repo / "Scripts/lane.sh") + self.registry = self.root / "registry" + self.registry.mkdir() + self.lock = self.registry / ".allocation.lock" + self.shims = self.root / "shims" + self.shims.mkdir() + self.env = {key: value for key, value in os.environ.items() if not key.startswith("AAEMU_")} + self.env.update({ + "AAEMU_LANES": self.registry.as_posix(), + "AAEMU_WT_ROOT": (self.root / "wt").as_posix(), + "AAEMU_TARGET_ROOT": (self.root / "target").as_posix(), + "AAEMU_LIVE_PREFIX": (self.root / "live-").as_posix(), + "AAEMU_LIVE_TEMPLATE": (self.root / "template").as_posix(), + "AAEMU_MYSQL_BIN": self.shims.as_posix(), + "AAEMU_LANE_BASE": "fixture-base", + "AAEMU_LANE_JOBS": "2", + "AAEMU_LANE_LOCK_TIMEOUT": "30", + "LANE_TEST_ROOT": self.root.as_posix(), + "LANE_TEST_HELPER": Path(__file__).resolve().as_posix(), + "LANE_TEST_PYTHON": Path(sys.executable).as_posix(), + "LANE_TEST_SHIMS": self.shims.as_posix(), + # Even a broken shim setup must not discover the enclosing real repository. + "GIT_DIR": (self.repo / ".git").as_posix(), + "BASH_ENV": "", + "PATH": str(self.shims) + os.pathsep + self.env["PATH"], + }) + self.shim("git", 'exec "$LANE_TEST_PYTHON" "$LANE_TEST_HELPER" --fake-git "$@"') + self.shim("netstat", 'printf " TCP 127.0.0.1:25237 0.0.0.0:0 LISTENING 1\\n"') + self.shim("mkdir", ''' +case "${*: -1}" in + */.allocation.lock) + if /usr/bin/mkdir "$@"; then exit 0; fi + : > "$LANE_TEST_ROOT/blocked.${LANE_TEST_ID:-test}" + if [ "${LANE_TEST_HOLD_DENIED:-}" = "${LANE_TEST_ID:-test}" ]; then + start=$SECONDS + until [ -f "$LANE_TEST_ROOT/retry.$LANE_TEST_ID" ]; do + [ $((SECONDS - start)) -lt 30 ] || exit 98 + sleep 0.02 + done + fi + exit 1 ;; +esac +if [ "${*: -1}" = "$AAEMU_TARGET_ROOT/broken" ] && [ "${LANE_TEST_FAIL:-}" = term-target ]; then + /usr/bin/mkdir "$@" + kill -TERM "$PPID"; exit 0 +fi +exec /usr/bin/mkdir "$@" +''') + self.shim("cat", ''' +[ -f "$LANE_TEST_ROOT/refs/fix/broken" ] || exec /usr/bin/cat "$@" +case "${LANE_TEST_FAIL:-}" in + config|config-remove) exit 71 ;; + term-config) kill -TERM "$PPID"; exit 0 ;; + kill-config) kill -KILL "$PPID"; exit 0 ;; +esac +exec /usr/bin/cat "$@" +''') + self.shim("ln", ''' +case "${LANE_TEST_FAIL:-}" in + publish) exit 72 ;; + publish-moved) + printf '%040d' 0 > "$LANE_TEST_ROOT/refs/fix/broken" + exit 72 ;; + publish-term) + /usr/bin/ln "$@" + kill -TERM "$PPID"; exit 0 ;; +esac +exec /usr/bin/ln "$@" +''') + for command in ("cargo", "powershell", "taskkill", "mysql.exe"): + self.shim(command, f'echo "unexpected {command}" >> "$LANE_TEST_ROOT/forbidden"; exit 99') + + def shim(self, name, body): + path = self.shims / name + path.write_text("#!/usr/bin/env bash\nset -eu\n" + body + "\n", encoding="utf-8", newline="\n") + path.chmod(0o755) + + def reap(self): + # Unblock only our fixture children, even when an assertion fails. + for path in self.root.glob("add.*"): + (self.root / path.name.replace("add.", "release.", 1)).touch() + for path in self.root.glob("blocked.*"): + (self.root / path.name.replace("blocked.", "retry.", 1)).touch() + for process in self.processes: + try: + process.communicate(timeout=40) + except subprocess.TimeoutExpired: + process.kill() + process.communicate(timeout=40) + self.assertFalse((self.root / "forbidden").exists(), "a forbidden tool was invoked") + + def start(self, *args, **env): + process = subprocess.Popen( + # Git's bin/bash.exe launcher prepends /mingw64/bin and /usr/bin to PATH. + # Install shims inside that shell, then exec Bash directly so they stay first. + [self.bash, "--noprofile", "--norc", "-c", + 'export PATH="$(cd "$LANE_TEST_SHIMS" && pwd):$PATH"; ' + 'exec /usr/bin/bash --noprofile --norc "$@"', "lane-test", + (self.repo / "Scripts/lane.sh").as_posix(), *args], + cwd=self.repo, env=self.env | env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + text=True, + ) + self.processes.append(process) + return process + + def finish(self, process, success=True): + output, _ = process.communicate(timeout=40) + if success: + self.assertEqual(process.returncode, 0, output) + else: + self.assertNotEqual(process.returncode, 0, output) + return output + + def create(self, name, **env): + return self.start("new", name, **env) + + def entry(self, name): + return dict(line.split("=", 1) for line in (self.registry / f"{name}.env").read_text().splitlines()) + + def assert_rolled_back(self, name): + for path in (self.root / "wt" / name, self.root / "target" / name, + self.root / "refs/fix" / name, self.registry / f"{name}.env", self.lock): + self.assertFalse(path.exists(), f"rollback left {path}") + + def test_concurrent_creators_get_distinct_prefixes_and_overrides(self): + # Preserve an existing lane and skip an occupied OS port (25237). + existing = self.registry / "running.env" + existing.write_text("PORT_PREFIX=24\nOTHER=unchanged\n", newline="\n") + first = self.create("first", LANE_TEST_HOLD="first", LANE_TEST_ID="first") + wait_for(self.root / "add.first") + second = self.start("new", "second", "--type", "feat", "--base", "explicit-base", + LANE_TEST_ID="second", LANE_TEST_HOLD_DENIED="second") + wait_for_any((self.root / "blocked.second", self.root / "add.second")) + self.assertFalse((self.root / "add.second").exists(), "second creator entered locked section") + (self.root / "release.first").touch() + self.finish(first) + # Return the failed mkdir only AFTER the owner removed the lock: acquisition must retry + # rather than treating this normal release race as an inability to create the lock. + (self.root / "retry.second").touch() + self.finish(second) + a, b = self.entry("first"), self.entry("second") + self.assertEqual(set(b), {"LANE", "BRANCH", "BASE", "WT", "TARGET", "PORT_PREFIX", "LIVE", + "DB_GAME", "DB_LOGIN", "CREATED", "CHECKED"}) + self.assertEqual((a["PORT_PREFIX"], b["PORT_PREFIX"]), ("26", "27")) + self.assertEqual((a["BASE"], b["BASE"], b["BRANCH"]), ("fixture-base", "explicit-base", "feat/second")) + self.assertEqual(b["WT"], (self.root / "wt/second").as_posix()) + self.assertEqual(b["TARGET"], (self.root / "target/second").as_posix()) + self.assertEqual(b["LIVE"], (self.root / "live-second").as_posix()) + self.assertEqual(b["DB_GAME"], "lane_second_game") + self.assertEqual(b["DB_LOGIN"], "lane_second_login") + self.assertEqual(b["CHECKED"], "") + config = (self.root / "wt/second/rust/.cargo/config.toml").read_text() + self.assertIn("jobs = 2", config) + self.assertIn(f'target-dir = "{b["TARGET"]}"', config) + self.assertTrue(Path(b["TARGET"]).is_dir()) + self.assertEqual(existing.read_text(), "PORT_PREFIX=24\nOTHER=unchanged\n") + self.assertFalse(self.lock.exists()) + + def test_concurrent_same_name_has_one_owner(self): + first = self.create("same", LANE_TEST_HOLD="same") + wait_for(self.root / "add.same") + second = self.create("same", LANE_TEST_ID="second") + wait_for(self.root / "blocked.second") + (self.root / "release.same").touch() + self.finish(first) + self.assertIn("lane 'same' exists", self.finish(second, success=False)) + self.assertTrue((self.root / "wt/same/.git").is_file()) + self.assertEqual(self.entry("same")["PORT_PREFIX"], "24") + self.assertFalse(self.lock.exists()) + + def test_existing_registry_path_target_and_branch_are_never_removed(self): + paths = { + "entry": self.registry / "entry.env", + "worktree": self.root / "wt/worktree/keep", + "target": self.root / "target/target/in-use", + "branch": self.root / "refs/fix/branch", + } + for name, path in paths.items(): + with self.subTest(name=name): + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text("preserve") + self.finish(self.create(name), success=False) + self.assertEqual(path.read_text(), "preserve") + self.assertFalse((self.root / f"add.{name}").exists()) + self.assertFalse(self.lock.exists()) + + def test_failures_roll_back_only_the_failed_creator_and_release_lock(self): + self.finish(self.create("keeper")) + before = (self.registry / "keeper.env").read_bytes() + for failure in ("add", "config", "publish", "term-config"): + with self.subTest(failure=failure): + self.finish(self.create("broken", LANE_TEST_FAIL=failure), success=False) + self.assert_rolled_back("broken") + self.assertEqual((self.registry / "keeper.env").read_bytes(), before) + self.assertTrue((self.root / "wt/keeper/.git").exists()) + self.finish(self.create("broken")) + self.assertEqual(self.entry("broken")["PORT_PREFIX"], "26") + + def test_missing_base_or_exhausted_prefixes_release_lock_without_creating_resources(self): + self.finish(self.start("new", "broken", "--base", "missing"), success=False) + self.assert_rolled_back("broken") + for prefix in range(24, 40): + (self.registry / f"occupied{prefix}.env").write_text(f"PORT_PREFIX={prefix}\n", newline="\n") + output = self.finish(self.create("broken"), success=False) + self.assertIn("no free port block", output) + self.assert_rolled_back("broken") + self.assertFalse((self.root / "add.broken").exists()) + + def test_partial_git_failure_retains_reservation(self): + output = self.finish(self.create("broken", LANE_TEST_FAIL="partial-add"), success=False) + self.assertIn("partial creation retained", output) + self.assertTrue((self.root / "refs/fix/broken").exists()) + self.assertTrue((self.root / "wt/broken/.git").exists()) + self.assertTrue((self.root / "target/broken").exists()) + self.assertTrue(self.lock.exists()) + self.finish(self.create("other", AAEMU_LANE_LOCK_TIMEOUT="0"), success=False) + self.assertFalse((self.root / "add.other").exists()) + + def test_registry_publication_never_clobbers_an_existing_file_or_directory(self): + for name, directory in (("fileowner", False), ("dirowner", True)): + with self.subTest(directory=directory): + process = self.create(name, LANE_TEST_HOLD=name) + wait_for(self.root / f"add.{name}") + entry = self.registry / f"{name}.env" + if directory: + entry.mkdir() + marker = entry / "keep" + else: + marker = entry + marker.write_text("another owner") + (self.root / f"release.{name}").touch() + self.finish(process, success=False) + self.assertEqual(marker.read_text(), "another owner") + if directory: + self.assertEqual(list(entry.iterdir()), [marker]) + for path in (self.root / "wt" / name, self.root / "target" / name, + self.root / "refs/fix" / name, self.lock): + self.assertFalse(path.exists(), f"rollback left {path}") + + def test_signal_immediately_after_publication_preserves_committed_lane(self): + self.finish(self.create("broken", LANE_TEST_FAIL="publish-term"), success=False) + self.assertEqual(self.entry("broken")["PORT_PREFIX"], "24") + self.assertTrue((self.root / "wt/broken/.git").exists()) + self.assertTrue((self.root / "target/broken").exists()) + self.assertTrue((self.root / "refs/fix/broken").exists()) + self.assertFalse(self.lock.exists()) + self.finish(self.create("other")) + self.assertEqual(self.entry("other")["PORT_PREFIX"], "26") + + def test_cleanup_failure_does_not_delete_moved_branch(self): + self.finish(self.create("broken", LANE_TEST_FAIL="publish-moved"), success=False) + self.assertEqual((self.root / "refs/fix/broken").read_text(), "0" * 40) + self.assertTrue(self.lock.exists()) + self.assertTrue((self.root / "target/broken").exists()) + + def test_failed_worktree_removal_retains_branch_and_lock(self): + self.finish(self.create("broken", LANE_TEST_FAIL="config-remove"), success=False) + self.assertTrue((self.root / "wt/broken/.git").exists()) + self.assertEqual((self.root / "refs/fix/broken").read_text(), HEAD) + self.assertTrue(self.lock.exists()) + + def test_hard_interruption_keeps_lock_until_manual_inspection(self): + self.finish(self.create("broken", LANE_TEST_FAIL="kill-config"), success=False) + self.assertTrue(self.lock.exists()) + self.finish(self.create("other", AAEMU_LANE_LOCK_TIMEOUT="0"), success=False) + self.assertTrue((self.root / "wt/broken/.git").exists()) + self.assertTrue((self.root / "refs/fix/broken").exists()) + self.assertFalse((self.root / "add.other").exists()) + journal, = self.lock.glob("owner.*/lane.env") + self.assertIn("LANE=broken\n", journal.read_text()) + self.assertIn("PORT_PREFIX=24\n", journal.read_text()) + + def test_signal_after_target_mkdir_retains_ambiguous_reservation(self): + output = self.finish(self.create("broken", LANE_TEST_FAIL="term-target"), success=False) + self.assertIn("partial creation retained", output) + self.assertTrue((self.root / "target/broken").is_dir()) + self.assertTrue(self.lock.is_dir()) + self.assertFalse((self.root / "add.broken").exists()) + self.finish(self.create("other", AAEMU_LANE_LOCK_TIMEOUT="0"), success=False) + self.assertFalse((self.root / "add.other").exists()) + + def test_stale_empty_or_pid_reused_lock_is_never_reclaimed(self): + self.lock.mkdir() + self.finish(self.create("other", AAEMU_LANE_LOCK_TIMEOUT="0"), success=False) + self.assertEqual(list(self.lock.iterdir()), []) + for content in ("", f"PID={os.getpid()}\nSTARTED=1900-01-01\n", "PID=999999999\n"): + with self.subTest(content=content): + owner = self.lock / "owner.stale" + owner.write_text(content) + os.utime(self.lock, (1, 1)) + output = self.finish(self.create("other", AAEMU_LANE_LOCK_TIMEOUT="0"), success=False) + self.assertIn("never remove a lock by PID or age", output) + self.assertEqual(owner.read_text(), content) + self.assertFalse((self.root / "add.other").exists()) + + def test_cleanup_never_releases_a_replacement_owners_lock(self): + process = self.create("broken", LANE_TEST_HOLD="broken", LANE_TEST_FAIL="config") + wait_for(self.root / "add.broken") + self.lock.rename(self.registry / "old-lock") + self.lock.mkdir() + replacement = self.lock / "owner.replacement" + replacement.write_text("another creator") + entry = self.registry / "other.env" + entry.write_text("PORT_PREFIX=24\n") + (self.root / "release.broken").touch() + self.assertIn("ownership lost", self.finish(process, success=False)) + self.assertEqual(replacement.read_text(), "another creator") + self.assertEqual(entry.read_text(), "PORT_PREFIX=24\n") + self.assertTrue((self.root / "wt/broken/.git").exists()) + self.assertTrue((self.root / "target/broken").exists()) + + def test_waiters_and_destructive_cleanup_cannot_release_an_active_creators_lock(self): + process = self.create("first", LANE_TEST_HOLD="first") + wait_for(self.root / "add.first") + for args in (("new", "second"), ("done", "first", "--force"), ("gc", "--apply")): + with self.subTest(args=args): + self.finish(self.start(*args, AAEMU_LANE_LOCK_TIMEOUT="0"), success=False) + self.assertTrue(self.lock.exists()) + self.assertTrue((self.root / "target/first").is_dir()) + (self.root / "release.first").touch() + self.finish(process) + + +if __name__ == "__main__": + if sys.argv[1:2] == ["--fake-git"]: + sys.exit(fake_git(sys.argv[2:])) + unittest.main(verbosity=2) From e7bd70a15c56191b7cf6183c2fce3f0004943130 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:50:13 -0400 Subject: [PATCH 33/66] ci: run isolated lane allocation tests on both platforms --- .github/workflows/rust.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index d1134012be..7729102720 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -73,6 +73,8 @@ jobs: - uses: Swatinem/rust-cache@v2 with: workspaces: rust + - name: Lane allocation regressions + run: python -I -B ../Scripts/test_lane.py - name: Build run: cargo build --workspace --all-targets --locked # Successor of the C# "Scripts Compile" step (the GM scripts are compiled into the binary). From 097f19f78e958d830621a7e238a9de01b2da0a43 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:51:40 -0400 Subject: [PATCH 34/66] fix(ai): include neutral movement speed before attribute cap Calculate the complete 1000-based MoveSpeedMul in real_movement_speed so the native raw cap agrees with the stat getter. Add an AI-helper buff flow regression source covering excessive flat bonuses, normal and negative boundaries, percentage modifiers and baseline restoration. Validation limited to rustfmt and diff checks as requested; executable validation remains with the parent. Co-Authored-By: Codex --- rust/crates/aaemu-game/src/systems/ai/npc.rs | 8 +-- .../systems/skills/attribute_limits_tests.rs | 58 +++++++++++++++++++ 2 files changed, 62 insertions(+), 4 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/ai/npc.rs b/rust/crates/aaemu-game/src/systems/ai/npc.rs index 80fafa443f..03939c213a 100644 --- a/rust/crates/aaemu-game/src/systems/ai/npc.rs +++ b/rust/crates/aaemu-game/src/systems/ai/npc.rs @@ -93,14 +93,14 @@ pub fn move_speed_mul(obj: &WorldObject) -> f32 { /// `NpcAi.GetRealMovementSpeed(baseMoveSpeed)`. pub fn real_movement_speed(obj: &WorldObject, base_move_speed: f64) -> f64 { let now = now_ms(); + // The native limit bounds the complete raw attribute, including its neutral 1000. let speed_mul = obj .with_unit(|u| { u.unit() - .calculate_with_bonuses(0.0, UnitAttribute::MoveSpeedMul, now) + .calculate_with_bonuses(1000.0, UnitAttribute::MoveSpeedMul, now) }) - .unwrap_or(0.0) - / 1000.0 - + 1.0; + .unwrap_or(1000.0) + / 1000.0; if (speed_mul - 1.0).abs() > f64::EPSILON { base_move_speed * speed_mul } else { diff --git a/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs b/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs index b3360494fb..84d2ccd48b 100644 --- a/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs @@ -482,6 +482,64 @@ fn attribute_limits_dynamic_percent_order_and_extreme_stacks_remain_finite() { ); } +#[tokio::test] +async fn attribute_limits_ai_movement_matches_stat_getter_at_raw_boundaries() { + use crate::systems::ai::npc; + + // Literal native limits: complete MoveSpeedMul starts at 1000 and is bounded + // to -10000..3000 before /1000. Adding 1 after clamping a zero-based bonus + // made +5000 move at 4x while the stat getter correctly reported 3x. + let cases = [ + (0, 0, 1.0), + (500, 0, 1.5), + (2000, 0, 3.0), + (2001, 0, 3.0), + (5000, 0, 3.0), + (-500, 0, 0.5), + (-1000, 0, 0.0), + (-10999, 0, -9.999), + (-11000, 0, -10.0), + (-11001, 0, -10.0), + (0, 50, 1.5), + (500, 100, 3.0), + (0, -50, 0.5), + ]; + let mut d = data(); + for (index, (flat, percent, _)) in cases.iter().enumerate() { + boost( + &mut d, + 60100 + index as u32, + vec![ + modifier(A::MoveSpeedMul, M::Value, *flat), + modifier(A::MoveSpeedMul, M::Percent, *percent), + ], + ); + } + let (server, _client, _player, n) = skills::cast_validation_tests::fixture(d); + let obj = WorldObject::from(&n); + for (index, (flat, percent, expected_mul)) in cases.into_iter().enumerate() { + let buff_id = 60100 + index as u32; + assert_eq!(npc::real_movement_speed(&obj, 4.5), 4.5); + apply(&server, &obj, buff_id); + for base in [0.0, 0.75, 4.5] { + // Exercise the actual AI helper before evaluating the separate getter. + let actual = npc::real_movement_speed(&obj, base); + let expected = base * expected_mul; + let stat_speed = base * stat(&server, &obj, S::MoveSpeedMul); + assert!( + (actual - expected).abs() < 1e-5, + "flat {flat}, percent {percent}, base {base}: {actual} != {expected}" + ); + assert!( + (actual - stat_speed).abs() < 1e-5, + "AI {actual} != stat-derived speed {stat_speed}" + ); + } + skills::buffs::remove_buff(&server, &obj, buff_id); + assert_eq!(npc::real_movement_speed(&obj, 4.5), 4.5); + } +} + #[tokio::test] async fn attribute_limits_are_per_server_for_every_spawned_unit_kind() { let a = data(); From 1f53a66bdd0ab289ae2a26abbbaff084cddfcaff Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:52:35 -0400 Subject: [PATCH 35/66] test(game): use public container and item fixture APIs --- .../aaemu-game/src/systems/economy/mail_expiry_tests.rs | 4 ++-- .../aaemu-game/src/systems/skills/attribute_limits_tests.rs | 4 +++- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs b/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs index 684e0b642a..6c434b84f0 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs @@ -588,7 +588,7 @@ async fn expiry_failed_return_does_not_publish_owner_or_success_then_retries() { assert!(w.a.drain().is_empty() && w.b.drain().is_empty()); mutate_item(&w.server, ids[0], |i| *i = item); let target = mail_container(&w.pa).unwrap(); - target.lock().unwrap().size = 1; + target.lock().unwrap().set_container_size(1); // First attachment moves, second cannot fit. The original row and every item's // ownership must survive rollback before a later retry can publish the return. tick(&w.server, due); @@ -600,7 +600,7 @@ async fn expiry_failed_return_does_not_publish_owner_or_success_then_retries() { assert_eq!(w.server.items.item_by_id(item).unwrap().owner_id, 2); } assert!(w.a.drain().is_empty() && w.b.drain().is_empty()); - target.lock().unwrap().size = -1; + target.lock().unwrap().set_container_size(-1); tick(&w.server, due); assert_eq!( w.server diff --git a/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs b/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs index 84d2ccd48b..f1ff6490db 100644 --- a/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs @@ -105,8 +105,10 @@ async fn attribute_limits_equipment_and_stacked_buff_flow_caps_only_final_value( ); let t = server.game_data.items.template(ITEM).unwrap(); - let mut item = Item::create(42, t, 1, 0, p.character_id, &server.game_data.items, 0); + let mut item = Item::create(42, t, 1, 0, 0, &server.game_data.items, 0); item.class = t.class_type(); + item.owner_id = u64::from(p.character_id); + item.slot_type = crate::models::container::slot_type::EQUIPMENT; item.slot = equip_slot::MAINHAND; p.data() .inventory From 8486add9cd0d57c3407f29b6ab93e0178e3e2ccc Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:52:53 -0400 Subject: [PATCH 36/66] fix(economy): make vehicle cargo escrow transfers atomic Validate equipped cargo sources and vacant racks in one inventory operation. Recover authored vehicle cargo with escrow and backpack preflight, repair only proven dangling persistent rack references, preserve shared packs during duplicate cleanup, and ignore stale child handles in removal checks. Add production-hook cargo regressions for all twenty Merchant Schooner racks, stale sources, occupied racks, failure and retry, foreign-held and missing packs, duplicate cleanup, and live child identity. Co-Authored-By: Codex --- .../aaemu-game/src/systems/economy/bridges.rs | 303 +++++++- .../src/systems/economy/cargo_flow_tests.rs | 708 ++++++++++++++++++ .../src/systems/npcs/doodad/funcs/items.rs | 168 ++++- .../src/systems/npcs/doodad/funcs/tests.rs | 16 +- .../src/systems/npcs/doodad/interactions.rs | 20 +- .../aaemu-game/src/systems/npcs/hooks.rs | 34 +- 6 files changed, 1205 insertions(+), 44 deletions(-) create mode 100644 rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs diff --git a/rust/crates/aaemu-game/src/systems/economy/bridges.rs b/rust/crates/aaemu-game/src/systems/economy/bridges.rs index 26842a89cf..311e4f9519 100644 --- a/rust/crates/aaemu-game/src/systems/economy/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/economy/bridges.rs @@ -2124,6 +2124,222 @@ impl crate::systems::npcs::hooks::EconomyBridge for EconomyForNpcs { move_to_system_container(server, player, task, item_id) } + fn try_store_doodad_item( + &self, + server: &GameServer, + player: &PlayerRef, + doodad: &DoodadRef, + expected: &Item, + required_count: i32, + ) -> bool { + let mut txn = ItemTxn::begin(server); + doodad.data().phase.to_next_phase = false; + let inv = Inv::of(player); + let equipment = inv.equipment(); + let Some(system) = inv.get(slot_type::SYSTEM) else { + return false; + }; + if required_count != 1 + || expected.count != required_count + || expected.slot_type != slot_type::EQUIPMENT + || expected.owner_id != u64::from(inv.character_id) + { + return false; + } + // The rack lock spans the container move and its reference update. No character or + // world lookup happens while it is held; item effects flush after both locks drop. + let mut d = doodad.data(); + d.phase.to_next_phase = false; + if d.phase.deleted || d.item_id != 0 || d.item_template_id != 0 { + return false; + } + let moved = { + let (mut target, source) = inventory::lock_pair(&system, &equipment); + let Some(mut source) = source else { + return false; + }; + let matches = source.owner_id == inv.character_id + && source.slot_type == slot_type::EQUIPMENT + && source.get_item_by_slot(expected.slot).is_some_and(|item| { + item.id == expected.id + && item.template_id == expected.template_id + && item.count == required_count + && item.slot_type == slot_type::EQUIPMENT + && item.owner_id == u64::from(inv.character_id) + }); + matches + && target.move_item_from( + &mut source, + task_type::DOODAD_ITEM_CHANGER, + expected.id, + -1, + txn.data(), + &mut txn.env.fx, + ) + }; + if moved { + d.item_id = expected.id; + d.item_template_id = expected.template_id; + } + moved + } + + fn recover_doodad_cargo( + &self, + server: &GameServer, + player: &PlayerRef, + doodad: &DoodadRef, + ) -> crate::systems::npcs::hooks::CargoRecovery { + use crate::systems::npcs::doodad::funcs::items::cargo_empty_phase; + use crate::systems::npcs::hooks::CargoRecovery; + + let mut txn = ItemTxn::begin(server); + doodad.data().phase.to_next_phase = false; + let inv = Inv::of(player); + let Some(empty) = cargo_empty_phase(server, doodad) else { + return CargoRecovery::Failed; + }; + let Some(can_repair) = cargo_attachment(server, doodad) else { + return CargoRecovery::Failed; + }; + let (item_id, template_id, group, attachment) = { + let d = doodad.data(); + ( + d.item_id, + d.item_template_id, + d.func_group_id, + ( + d.parent_obj_id, + d.transform.parent_obj_id, + d.owner_db_id, + d.attach_point, + ), + ) + }; + if item_id == 0 || !inventory::is_auto_equip_trade_pack(txn.data(), template_id) { + return CargoRecovery::Failed; + } + let item = server.items.item_by_id(item_id); + let holder = server.items.holding_container(item_id); + let occurrences: usize = server + .items + .all_containers() + .iter() + .map(|container| { + lock(container) + .items + .iter() + .filter(|i| i.id == item_id) + .count() + }) + .sum(); + let outside_escrow = match (&item, &holder) { + (None, None) => occurrences == 0, + (Some(item), Some(holder)) if occurrences == 1 => { + let holder = lock(holder); + holder.slot_type != slot_type::SYSTEM + && item.slot_type == holder.slot_type + && item.template_id == template_id + && item.class == ItemClass::Backpack + && item.count == 1 + } + _ => false, // Loose or multiply held items do not prove a dangling reference. + }; + let mut d = doodad.data(); + d.phase.to_next_phase = false; + if d.phase.deleted + || (d.item_id, d.item_template_id, d.func_group_id) != (item_id, template_id, group) + || ( + d.parent_obj_id, + d.transform.parent_obj_id, + d.owner_db_id, + d.attach_point, + ) != attachment + { + return CargoRecovery::Failed; + } + if outside_escrow { + if !can_repair { + return CargoRecovery::Failed; + } + d.item_id = 0; + d.item_template_id = 0; + return CargoRecovery::ClearedStale(empty); + } + let (Some(item), Some(holder)) = (item, holder) else { + return CargoRecovery::Failed; + }; + if occurrences != 1 + || item.slot_type != slot_type::SYSTEM + || item.class != ItemClass::Backpack + || item.template_id != template_id + || item.count != 1 + || lock(&holder).slot_type != slot_type::SYSTEM + { + return CargoRecovery::Failed; + } + let equipment = inv.equipment(); + if !lock(&equipment).can_accept( + &item, + txn.data().template(template_id), + equip_slot::BACKPACK, + ) { + return CargoRecovery::Failed; + } + let backpack = inv.equipped(equip_slot::BACKPACK); + let bag = inv.bag(); + if backpack.as_ref().is_some_and(|backpack| { + !matches!(txn.data().template(backpack.template_id).map(|t| &t.kind), + Some(TemplateKind::Backpack { backpack_type }) + if *backpack_type == crate::data::items::backpack_type::GLIDER) + || lock(&bag).place(backpack, -1, txn.data()).is_none() + }) { + return CargoRecovery::Failed; + } + // Preflight every destination before moving the glider. Keep a rollback snapshot for + // an unexpected failed second move; no failed operation may move the player's backpack. + let rollback = backpack.as_ref().map(|_| { + let equipment_before = lock(&equipment).clone(); + let bag_before = lock(&bag).clone(); + ( + equipment_before, + bag_before, + server.systems.economy.previous_backpack(inv.character_id), + ) + }); + if !inventory::take_off_backpack(&mut txn, &inv, task_type::RECOVER_DOODAD_ITEM, true) { + return CargoRecovery::Failed; + } + let moved = { + let (mut target, source) = inventory::lock_pair(&equipment, &holder); + source.is_some_and(|mut source| { + target.move_item_from( + &mut source, + task_type::RECOVER_DOODAD_ITEM, + item_id, + equip_slot::BACKPACK, + txn.data(), + &mut txn.env.fx, + ) + }) + }; + if !moved { + if let Some((equipment_before, bag_before, previous)) = rollback { + *lock(&equipment) = equipment_before; + *lock(&bag) = bag_before; + server + .systems + .economy + .set_previous_backpack(inv.character_id, previous); + txn.env.fx.0.clear(); + } + return CargoRecovery::Failed; + } + d.item_id = 0; + d.item_template_id = 0; + CargoRecovery::Recovered + } + fn remove_equipment_item( &self, server: &GameServer, @@ -2514,10 +2730,29 @@ impl crate::systems::npcs::hooks::EconomyBridge for EconomyForNpcs { } fn remove_expired_doodad_item(&self, server: &GameServer, item_id: u64) { + let mut txn = ItemTxn::begin(server); + // A duplicate rack can share the same escrow reference. Removing that duplicate must + // not destroy the sole pack still represented by another live doodad. + for world in server.world.worlds() { + for doodad in world.all_doodads() { + let protects_item = { + let d = doodad.data(); + !d.phase.deleted && d.item_id == item_id + }; + if protects_item { + crate::systems::npcs::doodad::funcs::items::warn_item_reference( + server, + &doodad, + item_id, + "preserved item referenced by another live doodad during cleanup", + ); + return; + } + } + } let Some(c) = server.items.holding_container(item_id) else { return; }; - let mut txn = ItemTxn::begin(server); let mut g = lock(&c); if matches!(g.slot_type, slot_type::NONE | slot_type::SYSTEM) { g.remove_item_task(task_type::INVALID, item_id, true, &mut txn.env); @@ -2551,6 +2786,68 @@ impl crate::systems::npcs::hooks::EconomyBridge for EconomyForNpcs { } } +/// A live cargo attachment, plus whether its persistent authored binding proves it safe to +/// repair. Nonpersistent or equipment-created racks can recover normally but are not repaired. +fn cargo_attachment(server: &GameServer, rack: &DoodadRef) -> Option { + let (instance, parent, transform_parent, hull_id, point, template_id, persistent) = { + let d = rack.data(); + ( + d.transform.instance_id, + d.parent_obj_id, + d.transform.parent_obj_id, + d.owner_db_id, + d.attach_point, + d.template_id, + d.is_persistent && !d.phase.deleted, + ) + }; + if parent == 0 || parent != transform_parent { + return None; + } + let Some(world) = server.world.world(instance) else { + return None; + }; + if !world + .doodad(rack.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, rack)) + { + return None; + } + let Some(hull) = world.slave(parent) else { + return None; + }; + let (id, hull_template, attached) = { + let hull = hull.data(); + ( + hull.id, + hull.unit.template_id, + hull.attached_doodads.contains(&rack.obj_id), + ) + }; + if id != hull_id || !attached { + return None; + } + let repairable = persistent + && hull_id > 0 + && server + .game_data + .systems + .vehicles + .slave_template(hull_template) + .is_some_and(|t| { + t.doodad_bindings + .iter() + .any(|b| b.persist && b.attach_point_id == point && b.doodad_id == template_id) + }); + Some( + repairable + && !rack.core().children().iter().any(|child| { + child.transform().parent_obj_id == rack.obj_id + && world.object(child.obj_id()).is_some() + }), + ) +} + /// `Inventory.SystemContainer.AddOrMoveExistingItem(task, item)`. fn move_to_system_container( server: &GameServer, @@ -3617,3 +3914,7 @@ pub fn install(server: &GameServer) { }); crate::systems::services::shutdown::BUYBACK_WIPE.install(wipe); } + +#[cfg(test)] +#[path = "cargo_flow_tests.rs"] +mod cargo_flow_tests; diff --git a/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs b/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs new file mode 100644 index 0000000000..505cc43d3a --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs @@ -0,0 +1,708 @@ +//! Merchant cargo regressions through the production economy bridge and authored phase dispatch. + +use std::sync::Arc; + +use crate::data::items::{backpack_type, ItemTemplate, TemplateKind}; +use crate::data::GameData; +use crate::models::character::Inventory; +use crate::models::container::{equip_slot, slot_type}; +use crate::models::doodad::{doodad_owner_type, Doodad}; +use crate::models::item::Item; +use crate::models::item_task::task_type; +use crate::models::slave::Slave; +use crate::opcodes::sc; +use crate::systems::economy::inventory::{Inv, ItemTxn}; +use crate::systems::economy::tests::{give, test_data, World, SINGLE}; +use crate::systems::npcs::doodad::runtime::DoodadCtx; +use crate::systems::npcs::doodad::templates::*; +use crate::systems::npcs::doodad::{funcs::items, interactions, manager, phase}; +use crate::systems::npcs::hooks::EconomyBridge; +use crate::systems::vehicles::data::{SlaveDoodadBinding, SlaveTemplate}; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use crate::world::{DoodadRef, Entity, SlaveRef, WorldObject}; + +use super::EconomyForNpcs; + +const HULL: u32 = 75; +const RACK: u32 = 3446; +const EMPTY: u32 = 8264; +const LOADED: u32 = 8265; +const STORE_SKILL: u32 = 15307; +const RECOVER_SKILL: u32 = 15309; +const PACK: u32 = 18469; +const GLIDER: u32 = 99991; + +fn authored_data() -> GameData { + let mut data = test_data(); + for (id, kind) in [(PACK, 1), (GLIDER, backpack_type::GLIDER)] { + data.items.templates.insert( + id, + ItemTemplate { + kind: TemplateKind::Backpack { + backpack_type: kind, + }, + ..ItemTemplate::plain(id, 1) + }, + ); + } + let groups = vec![ + DoodadFuncGroups { + id: EMPTY, + almighty: RACK, + group_kind_id: doodad_func_group_kind::START, + ..Default::default() + }, + DoodadFuncGroups { + id: LOADED, + almighty: RACK, + group_kind_id: doodad_func_group_kind::NORMAL, + ..Default::default() + }, + ]; + let doodads = &mut data.systems.npcs.doodad; + doodads.templates.insert( + RACK, + DoodadTemplate { + id: RACK, + func_groups: groups, + ..Default::default() + }, + ); + for (group, key, id, kind, skill, next) in [ + ( + EMPTY, + 7481, + 2, + "DoodadFuncConsumeChanger", + STORE_SKILL, + LOADED, + ), + ( + LOADED, + 9998, + 393, + "DoodadFuncRecoverItem", + RECOVER_SKILL, + EMPTY, + ), + ] { + doodads.funcs_by_groups.insert( + group, + vec![DoodadFunc { + group_id: group, + func_id: id, + func_key: key, + func_type: kind.into(), + next_phase: next as i32, + skill_id: skill, + perm_id: 5, + ..Default::default() + }], + ); + } + doodads + .func_templates + .entry("DoodadFuncConsumeChanger") + .or_default() + .insert( + 2, + FuncTemplate::ConsumeChanger(DoodadFuncConsumeChanger { + id: 2, + slot_id: 26, + count: 1, + }), + ); + doodads + .func_templates + .entry("DoodadFuncRecoverItem") + .or_default() + .insert( + 393, + FuncTemplate::RecoverItem(DoodadFuncRecoverItem { id: 393 }), + ); + doodads + .consume_changer_items + .push(DoodadFuncConsumeChangerItem { + id: 10, + doodad_func_consume_changer_id: 2, + item_id: PACK, + }); + data.systems.vehicles.slave_templates.insert( + HULL, + SlaveTemplate { + id: HULL, + name: "Merchant Schooner".into(), + model_id: 1205, + slave_kind: 2, + doodad_bindings: (60..80) + .map(|point| SlaveDoodadBinding { + id: u32::from(point), + owner_id: HULL, + owner_type: "Slave".into(), + attach_point_id: point, + doodad_id: RACK, + persist: true, + scale: 1.0, + }) + .collect(), + ..Default::default() + }, + ); + data +} + +struct CargoWorld { + w: World, + hull: SlaveRef, + racks: Vec, +} + +fn world(data: GameData) -> CargoWorld { + let bindings = data + .systems + .vehicles + .slave_template(HULL) + .unwrap() + .doodad_bindings + .iter() + .filter(|b| b.doodad_id == RACK) + .cloned() + .collect::>(); + assert_eq!(bindings.len(), 20); + let server = Arc::new(test_server_with(data)); + super::install(&server); + let mut a = TestClient::new(&server, 1, 1001); + let mut b = TestClient::new(&server, 2, 1002); + let mut alice = test_character(1, "Alice", 100.0, 100.0); + alice.inventory = Inventory::new(1, 50, 50, &server.items, &server.ids.container); + let mut bob = test_character(2, "Bob", 101.0, 100.0); + bob.inventory = Inventory::new(2, 50, 50, &server.items, &server.ids.container); + let pa = spawn_player(&server, &a, alice, 0x100); + let pb = spawn_player(&server, &b, bob, 0x101); + a.conn.active_char = Some(pa.clone()); + b.conn.active_char = Some(pb.clone()); + let instance = server.world.world(0).unwrap(); + let mut hull = Slave::new(700, HULL); + hull.unit.model_id = 1205; + hull.unit.transform.set_xyz(100.0, 100.0, 100.0); + hull.summoner_id = 1; + hull.summoner_obj_id = pa.obj_id; + let hull = Entity::new(0x300, hull); + instance.spawn(&hull, &server.view_ctx()); + let racks = bindings + .into_iter() + .map(|binding| { + let rack = manager::create(&server, &instance, 0, RACK, None, true).unwrap(); + { + let mut d = rack.data(); + d.owner_type = doodad_owner_type::SLAVE; + d.owner_id = 1; + d.owner_db_id = 700; + d.parent_obj_id = hull.obj_id; + d.attach_point = binding.attach_point_id; + d.is_persistent = true; + } + instance.attach_child(&WorldObject::from(&hull), &WorldObject::from(&rack)); + hull.data().attached_doodads.push(rack.obj_id); + instance.spawn(&rack, &server.view_ctx()); + rack + }) + .collect(); + a.drain(); + b.drain(); + CargoWorld { + w: World { + server, + a, + pa, + b, + pb, + }, + hull, + racks, + } +} + +fn use_rack(c: &CargoWorld, index: usize, skill: u32) { + assert!(interactions::execute_interaction( + &c.w.server, + interactions::world_interaction_type::USE, + &WorldObject::from(&c.w.pa), + Some(&WorldObject::from(&c.racks[index])), + skill, + 0, + None + )); +} + +fn transfer(c: &CargoWorld, item_id: u64, target_type: u8, slot: i32) { + let mut txn = ItemTxn::begin(&c.w.server); + let target = Inv::of(&c.w.pa).get(target_type).unwrap(); + assert!(crate::systems::economy::mail::add_or_move_existing_item( + &mut txn, + &target, + task_type::INVALID, + item_id, + slot + )); +} + +fn equipped(c: &CargoWorld) -> Item { + Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).unwrap() +} + +fn cargo_state(rack: &DoodadRef) -> (u32, u64, u32) { + let d = rack.data(); + (d.func_group_id, d.item_id, d.item_template_id) +} + +fn repeated_cycles(c: &mut CargoWorld) { + let ids: Vec<_> = (0..20) + .map(|_| { + let id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + transfer(c, id, slot_type::SYSTEM, -1); + id + }) + .collect(); + for cycle in 0..3 { + for step in 0..20 { + let index = (step * 7 + cycle * 3) % 20; + transfer(c, ids[index], slot_type::EQUIPMENT, equip_slot::BACKPACK); + use_rack(c, index, STORE_SKILL); + assert_eq!(cargo_state(&c.racks[index]), (LOADED, ids[index], PACK)); + assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); + } + for step in 0..20 { + let index = (step * 9 + cycle * 5) % 20; + use_rack(c, index, RECOVER_SKILL); + assert_eq!(equipped(c).id, ids[index]); + assert_eq!(cargo_state(&c.racks[index]), (EMPTY, 0, 0)); + transfer(c, ids[index], slot_type::SYSTEM, -1); + } + for id in &ids { + let copies: usize = + c.w.server + .items + .all_containers() + .iter() + .map(|container| { + container + .lock() + .unwrap() + .items + .iter() + .filter(|i| i.id == *id) + .count() + }) + .sum(); + assert_eq!(copies, 1); + } + } + assert_eq!(c.hull.data().attached_doodads.len(), 20); + assert!(!c.w.a.drain_ops().contains(&sc::SCErrorMsgPacket)); +} + +#[tokio::test] +async fn merchant_all_twenty_racks_survive_shuffled_repeated_load_unload() { + repeated_cycles(&mut world(authored_data())); +} + +#[tokio::test] +async fn cargo_checks_are_shared_with_other_hulls_and_nonpersistent_racks() { + let mut data = authored_data(); + let mut other = data.systems.vehicles.slave_template(HULL).unwrap().clone(); + other.id = 21; + for binding in &mut other.doodad_bindings { + binding.owner_id = other.id; + binding.persist = false; + } + data.systems + .vehicles + .slave_templates + .insert(other.id, other); + let c = world(data); + c.hull.data().unit.template_id = 21; + c.racks[11].data().is_persistent = false; + let id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 11, STORE_SKILL); + use_rack(&c, 11, RECOVER_SKILL); + assert_eq!(equipped(&c).id, id); + assert_eq!(cargo_state(&c.racks[11]), (EMPTY, 0, 0)); +} + +#[tokio::test] +async fn missing_deposit_source_and_zero_guid_cargo_cannot_reuse_old_success() { + let c = world(authored_data()); + c.racks[0].data().phase.to_next_phase = true; + let ctx = DoodadCtx::of(&c.w.server, &c.racks[0]).unwrap(); + items::consume_changer( + &DoodadFuncConsumeChanger { + id: 2, + slot_id: 26, + count: 1, + }, + &ctx, + Some(&WorldObject::from(&c.w.pa)), + ); + assert!(!c.racks[0].data().phase.to_next_phase); + assert_eq!(cargo_state(&c.racks[0]), (EMPTY, 0, 0)); + c.racks[0].data().item_template_id = PACK; + phase::set_func_group_id(&c.w.server, &c.racks[0], LOADED); + use_rack(&c, 0, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[0]), (LOADED, 0, PACK)); + assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); +} + +#[tokio::test] +async fn stale_captured_source_cannot_be_deposited_in_a_second_rack() { + let c = world(authored_data()); + let id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + let captured = equipped(&c); + use_rack(&c, 7, STORE_SKILL); + c.racks[18].data().phase.to_next_phase = true; + let _housing = c.w.server.systems.housing.operation_lock.lock().unwrap(); + assert!(!EconomyForNpcs.try_store_doodad_item( + &c.w.server, + &c.w.pa, + &c.racks[18], + &captured, + 1 + )); + assert_eq!(cargo_state(&c.racks[7]), (LOADED, id, PACK)); + assert_eq!(cargo_state(&c.racks[18]), (EMPTY, 0, 0)); + assert!(!c.racks[18].data().phase.to_next_phase); + assert_eq!( + c.w.server.items.item_by_id(id).unwrap().slot_type, + slot_type::SYSTEM + ); +} + +#[tokio::test] +async fn occupied_rack_and_changed_source_reject_without_overwriting_escrow() { + let mut c = world(authored_data()); + let first = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 3, STORE_SKILL); + let second = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + c.w.a.drain(); + c.racks[3].data().phase.to_next_phase = true; + let ctx = DoodadCtx::of(&c.w.server, &c.racks[3]).unwrap(); + items::consume_changer( + &DoodadFuncConsumeChanger { + id: 2, + slot_id: 26, + count: 1, + }, + &ctx, + Some(&WorldObject::from(&c.w.pa)), + ); + assert_eq!(cargo_state(&c.racks[3]), (LOADED, first, PACK)); + assert_eq!(equipped(&c).id, second); + assert!(!c.racks[3].data().phase.to_next_phase); + assert!(!c.w.a.drain_ops().contains(&sc::SCItemTaskSuccessPacket)); + for change in 0..3 { + let mut captured = equipped(&c); + match change { + 0 => captured.template_id += 1, + 1 => captured.count = 2, + _ => captured.slot -= 1, + } + let _housing = c.w.server.systems.housing.operation_lock.lock().unwrap(); + assert!(!EconomyForNpcs.try_store_doodad_item( + &c.w.server, + &c.w.pa, + &c.racks[4], + &captured, + 1 + )); + assert_eq!(cargo_state(&c.racks[4]), (EMPTY, 0, 0)); + assert_eq!(equipped(&c).id, second); + } +} + +#[tokio::test] +async fn failed_recovery_keeps_glider_and_cargo_then_retries_with_the_same_ids() { + let mut c = world(authored_data()); + let pack = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 19, STORE_SKILL); + let glider = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + GLIDER, + 1, + equip_slot::BACKPACK, + ); + Inv::of(&c.w.pa).bag().lock().unwrap().set_container_size(1); + let filler = give(&c.w, &c.w.pa, slot_type::INVENTORY, SINGLE, 1, 0); + c.w.a.drain(); + c.racks[19].data().phase.to_next_phase = true; + use_rack(&c, 19, RECOVER_SKILL); + assert_eq!(equipped(&c).id, glider); + assert_eq!(cargo_state(&c.racks[19]), (LOADED, pack, PACK)); + assert!(!c.racks[19].data().phase.to_next_phase); + assert_eq!( + c.w.server.items.item_by_id(pack).unwrap().slot_type, + slot_type::SYSTEM + ); + assert!(!c.w.a.drain_ops().contains(&sc::SCItemTaskSuccessPacket)); + { + let mut txn = ItemTxn::begin(&c.w.server); + Inv::of(&c.w.pa).bag().lock().unwrap().remove_item_task( + task_type::INVALID, + filler, + true, + &mut txn.env, + ); + } + use_rack(&c, 19, RECOVER_SKILL); + assert_eq!(equipped(&c).id, pack); + assert_eq!(cargo_state(&c.racks[19]), (EMPTY, 0, 0)); + assert_eq!( + c.w.server.items.item_by_id(glider).unwrap().slot_type, + slot_type::INVENTORY + ); + use_rack(&c, 19, STORE_SKILL); + let other_pack = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 19, RECOVER_SKILL); + assert_eq!(equipped(&c).id, other_pack); + assert_eq!(cargo_state(&c.racks[19]), (LOADED, pack, PACK)); + transfer(&c, other_pack, slot_type::SYSTEM, -1); + use_rack(&c, 19, RECOVER_SKILL); + assert_eq!(equipped(&c).id, pack); + assert_eq!(cargo_state(&c.racks[19]), (EMPTY, 0, 0)); +} + +#[tokio::test] +async fn duplicate_cleanup_preserves_the_sole_pack_for_the_surviving_rack() { + let c = world(authored_data()); + let id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 0, STORE_SKILL); + { + let mut duplicate = c.racks[1].data(); + duplicate.item_id = id; + duplicate.item_template_id = PACK; + } + phase::set_func_group_id(&c.w.server, &c.racks[1], LOADED); + let instance = c.w.server.world.world(0).unwrap(); + manager::delete(&c.w.server, &instance, &c.racks[1]); + assert_eq!( + c.w.server.items.item_by_id(id).unwrap().slot_type, + slot_type::SYSTEM + ); + use_rack(&c, 0, RECOVER_SKILL); + assert_eq!(equipped(&c).id, id); +} + +#[tokio::test] +async fn dangling_rack_repair_does_not_move_another_players_pack_or_create_one() { + let mut c = world(authored_data()); + let id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 0, STORE_SKILL); + { + let mut txn = ItemTxn::begin(&c.w.server); + assert!(crate::systems::economy::mail::add_or_move_existing_item( + &mut txn, + &Inv::of(&c.w.pb).equipment(), + task_type::INVALID, + id, + equip_slot::BACKPACK + )); + } + let before = Inv::of(&c.w.pb).equipped(equip_slot::BACKPACK).unwrap(); + c.w.a.drain(); + c.w.b.drain(); + use_rack(&c, 0, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[0]), (EMPTY, 0, 0)); + assert_eq!( + Inv::of(&c.w.pb).equipped(equip_slot::BACKPACK).unwrap(), + before + ); + assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); + assert!(!c.w.a.drain_ops().contains(&sc::SCItemTaskSuccessPacket)); + assert!(!c.w.b.drain_ops().contains(&sc::SCItemTaskSuccessPacket)); + + // A legacy pack in another actor's bag is outside escrow too: repair the rack only. + let foreign_equipment = Inv::of(&c.w.pb).equipment(); + let mut in_bag = foreign_equipment.lock().unwrap().remove_item(id).unwrap(); + in_bag.slot_type = slot_type::INVENTORY; + in_bag.slot = 0; + let foreign_bag = Inv::of(&c.w.pb).bag(); + foreign_bag.lock().unwrap().items.push(in_bag.clone()); + { + let mut d = c.racks[3].data(); + d.item_id = id; + d.item_template_id = PACK; + } + phase::set_func_group_id(&c.w.server, &c.racks[3], LOADED); + use_rack(&c, 3, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[3]), (EMPTY, 0, 0)); + assert_eq!(c.w.server.items.item_by_id(id).unwrap(), in_bag); + assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); + + // A missing item is also dangling, but only the rack reference/phase is repaired. + { + let mut d = c.racks[2].data(); + d.item_id = id + 99999; + d.item_template_id = PACK; + } + phase::set_func_group_id(&c.w.server, &c.racks[2], LOADED); + use_rack(&c, 2, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[2]), (EMPTY, 0, 0)); + assert!(c.w.server.items.item_by_id(id + 99999).is_none()); +} + +#[tokio::test] +async fn ambiguous_escrow_and_wrong_hull_graph_are_not_repaired() { + let c = world(authored_data()); + let id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 5, STORE_SKILL); + let source = c.w.server.items.item_by_id(id).unwrap(); + let mut second_copy = source.clone(); + second_copy.slot_type = slot_type::INVENTORY; + second_copy.owner_id = u64::from(c.w.pb.character_id); + second_copy.slot = 0; + let foreign_bag = Inv::of(&c.w.pb).bag(); + foreign_bag.lock().unwrap().items.push(second_copy); + use_rack(&c, 5, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[5]), (LOADED, id, PACK)); + assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); + foreign_bag.lock().unwrap().remove_item(id); + c.w.server.items.add_loose(source.clone()); + // Loose items are not inferred as missing if the persistent holder disappears. + let system = Inv::of(&c.w.pa).get(slot_type::SYSTEM).unwrap(); + system.lock().unwrap().remove_item(id); + use_rack(&c, 5, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[5]), (LOADED, id, PACK)); + c.w.server.items.take_loose(id); + c.racks[5].data().owner_db_id += 1; + use_rack(&c, 5, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[5]), (LOADED, id, PACK)); +} + +#[tokio::test] +async fn removal_ignores_stale_children_but_blocks_a_live_persistent_child() { + let c = world(authored_data()); + let instance = c.w.server.world.world(0).unwrap(); + let mut data = Doodad::new(RACK); + data.is_persistent = true; + let child = Entity::new(0x900, data); + instance.spawn(&child, &c.w.server.view_ctx()); + instance.attach_child(&WorldObject::from(&c.racks[0]), &WorldObject::from(&child)); + assert!(!interactions::doodad_allow_removal( + &c.w.server, + &c.racks[0] + )); + // Existing attach_child leaves the old parent's entry behind when reparenting. + instance.attach_child(&WorldObject::from(&c.racks[1]), &WorldObject::from(&child)); + assert!(interactions::doodad_allow_removal(&c.w.server, &c.racks[0])); + assert!(!interactions::doodad_allow_removal( + &c.w.server, + &c.racks[1] + )); + instance.remove_object(child.obj_id); + assert!(interactions::doodad_allow_removal(&c.w.server, &c.racks[1])); + let replacement = Entity::new(child.obj_id, child.data().clone()); + instance.spawn(&replacement, &c.w.server.view_ctx()); + assert!(interactions::doodad_allow_removal(&c.w.server, &c.racks[1])); +} + +#[tokio::test] +#[ignore = "needs AAEMU_COMPACT_DB"] +async fn real_compact_merchant_all_twenty_racks_survive_shuffled_cycles() { + use crate::data::client_files::ClientFileManager; + use crate::systems::DataLoadCtx; + + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + rusqlite::Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY) + .unwrap(); + let app = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("app"); + let files = ClientFileManager::from_sources(&[], &app); + let ctx = DataLoadCtx { + conn: &conn, + app_path: &app, + files: &files, + language: "en_us", + }; + let mut data = GameData::empty(); + data.items = crate::data::ItemData::load(&conn).unwrap(); + data.systems.npcs.doodad = crate::systems::npcs::doodad::data::DoodadData::load(&ctx).unwrap(); + data.systems.vehicles = crate::systems::vehicles::Data::load(&ctx).unwrap(); + assert!(matches!( + data.items.template(23398).unwrap().kind, + TemplateKind::SummonSlave { slave_id: HULL } + )); + repeated_cycles(&mut world(data)); +} diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs index f33b350db2..4f57518925 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs @@ -9,12 +9,75 @@ use crate::models::container::{equip_slot, slot_type}; use crate::models::doodad::doodad_owner_type; use crate::systems::npcs::doodad::runtime::DoodadCtx; use crate::systems::npcs::doodad::templates::{ - DoodadFuncBuyFish, DoodadFuncConsumeChanger, DoodadFuncLootItem, DoodadFuncLootPack, - DoodadFuncPurchase, DoodadFuncRecoverItem, DoodadFuncRemoveItem, + doodad_func_group_kind, DoodadFuncBuyFish, DoodadFuncConsumeChanger, DoodadFuncLootItem, + DoodadFuncLootPack, DoodadFuncPurchase, DoodadFuncRecoverItem, DoodadFuncRemoveItem, }; +use crate::systems::npcs::hooks::CargoRecovery; use crate::systems::social::achievement::char_record_kind; use crate::systems::social::achievement_hooks::{AchievementInput, RecordMatch}; -use crate::world::{PlayerRef, WorldObject}; +use crate::world::{DoodadRef, PlayerRef, WorldObject}; + +/// The authored loaded -> empty transition of a vehicle storage, not ordinary furniture. +pub(crate) fn cargo_empty_phase( + server: &crate::server::GameServer, + rack: &DoodadRef, +) -> Option { + let (owner_type, template_id, group) = { + let d = rack.data(); + (d.owner_type, d.template_id, d.func_group_id) + }; + if owner_type != doodad_owner_type::SLAVE { + return None; + } + let data = &server.game_data.systems.npcs.doodad; + let recover = data + .funcs_for_group(group) + .iter() + .find(|f| f.func_type == "DoodadFuncRecoverItem" && f.next_phase > 0)?; + let empty = recover.next_phase as u32; + (data + .doodad_func_groups(template_id) + .iter() + .any(|g| g.id == empty && g.group_kind_id == doodad_func_group_kind::START) + && data + .funcs_for_group(empty) + .iter() + .any(|f| f.func_type == "DoodadFuncConsumeChanger" && f.next_phase == group as i32)) + .then_some(empty) +} + +pub(crate) fn warn_item_reference( + server: &crate::server::GameServer, + rack: &DoodadRef, + item_id: u64, + reason: &str, +) { + let (rack_db_id, hull_db_id, hull_obj_id, attach_point) = { + let d = rack.data(); + (d.db_id, d.owner_db_id, d.parent_obj_id, d.attach_point) + }; + let (container_id, container_slot_type, container_owner_id) = server + .items + .holding_container(item_id) + .map(|c| { + let c = c.lock().expect("container poisoned"); + (c.container_id, c.slot_type, c.owner_id) + }) + .unwrap_or_default(); + tracing::warn!( + rack_obj_id = rack.obj_id, + rack_db_id, + item_id, + container_id, + container_slot_type, + container_owner_id, + hull_db_id, + hull_obj_id, + attach_point, + reason, + "Doodad item reference refused or repaired" + ); +} /// `SCUnitEquipmentsChangedPacket`: one definition per opcode (`crate::systems::economy::item_packets::SCUnitEquipmentsChangedPacket`). pub use crate::systems::economy::item_packets::SCUnitEquipmentsChangedPacket; @@ -145,6 +208,7 @@ pub fn recover_item( skill_id: u32, next_phase: i32, ) { + set_to_next_phase(ctx, false); // `caster.Name` / `(Character)caster` throw for a null / non-character caster. let Some(player) = DoodadCtx::as_player(caster) else { return; @@ -169,9 +233,6 @@ pub fn recover_item( d.template_id, ) }; - // Recovery can also be reached through an InteractionEffect, outside the phase - // machine's normal result reset. A failed recovery must never reuse an old success. - set_to_next_phase(ctx, false); if owner_type == doodad_owner_type::HOUSING && owner_db_id > 0 { let allowed = crate::systems::housing::house_by_id(ctx.server, owner_db_id).is_some_and(|house| { @@ -198,6 +259,49 @@ pub fn recover_item( ); let server = ctx.server; let eco = economy(server); + if cargo_empty_phase(server, &ctx.doodad).is_some() { + match eco.recover_doodad_cargo(server, player, &ctx.doodad) { + CargoRecovery::Recovered => { + if let Some(moved) = server.items.item_by_id(item_id) { + crate::world::broadcast( + &ctx.world, + player, + &SCUnitEquipmentsChangedPacket { + obj_id: player.obj_id, + items: vec![(moved.slot as u8, Some(moved))], + }, + false, + ); + } + set_to_next_phase(ctx, true); + } + CargoRecovery::ClearedStale(empty) => { + warn_item_reference( + server, + &ctx.doodad, + item_id, + "cleared dangling cargo reference without moving an item", + ); + super::super::manager::do_change_phase( + server, + &ctx.world, + &ctx.doodad, + Some(&WorldObject::from(player)), + empty as i32, + ); + } + CargoRecovery::Failed => { + warn_item_reference( + server, + &ctx.doodad, + item_id, + "cargo recovery failed escrow, rack or backpack preflight", + ); + send_error(player, err::FAILED_TO_USE_ITEM); + } + } + return; + } let mut added_item = false; let item = server.items.item_by_id(item_id); if item_id > 0 { @@ -406,16 +510,26 @@ pub fn consume_changer( caster: Option<&WorldObject>, ) { tracing::trace!("DoodadFuncConsumeChanger"); + set_to_next_phase(ctx, false); let Some(player) = DoodadCtx::as_player(caster) else { return; }; + let _operation = ctx + .server + .systems + .housing + .operation_lock + .lock() + .unwrap_or_else(|e| e.into_inner()); + if ctx.doodad.data().phase.deleted { + return; + } let source = { let equipment = player.data().inventory.equipment().clone(); let c = equipment.lock().expect("container poisoned"); - c.get_item_by_slot(f.slot_id as i32) - .map(|i| (i.id, i.template_id)) + c.get_item_by_slot(f.slot_id as i32).cloned() }; - let Some((source_id, source_template)) = source else { + let Some(source) = source else { send_error(player, err::UNKNOWN_ITEM); return; }; @@ -423,41 +537,21 @@ pub fn consume_changer( if !ctx .data() .consume_changer_items(f.id) - .contains(&source_template) + .contains(&source.template_id) { send_error(player, err::STORE_INVALID_ITEM); return; } - let (template_id, owner_id) = { - let d = ctx.doodad.data(); - (d.template_id, d.owner_id) - }; - // TODO (C#): if this item count would be different from 1, this would cause issues - if f.count > 1 { - tracing::warn!( - "DoodadFuncConsumeChanger, expected source count is higher than one ({}) for slot {} on doodad type {} ({}) from player {}", - f.count, - f.slot_id, - template_id, - owner_id, - player.data().unit.name + if !economy(ctx.server).try_store_doodad_item(ctx.server, player, &ctx.doodad, &source, f.count) + { + warn_item_reference( + ctx.server, + &ctx.doodad, + source.id, + "cargo deposit source changed or rack occupied", ); - } - // Move the actual item to the owner's SystemContainer - if !economy(ctx.server).move_item_to_system_container( - ctx.server, - player, - item_task::DOODAD_ITEM_CHANGER, - source_id, - ) { - set_to_next_phase(ctx, false); send_error(player, err::STORE_INVALID_ITEM); return; } - { - let mut d = ctx.doodad.data(); - d.item_id = source_id; - d.item_template_id = source_template; - } set_to_next_phase(ctx, true); } diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/tests.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/tests.rs index 6ee632ba9b..5bff440162 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/tests.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/tests.rs @@ -82,14 +82,22 @@ impl EconomyBridge for Rec { self.push(format!("consume {task} {t} {c}")); self.consumed } - fn move_item_to_system_container( + fn try_store_doodad_item( &self, _s: &GameServer, _p: &PlayerRef, - task: u8, - id: u64, + doodad: &DoodadRef, + source: &Item, + _count: i32, ) -> bool { - self.push(format!("system {task} {id}")); + self.push(format!( + "system {} {}", + item_task::DOODAD_ITEM_CHANGER, + source.id + )); + let mut d = doodad.data(); + d.item_id = source.id; + d.item_template_id = source.template_id; true } } diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/interactions.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/interactions.rs index 6380954a62..1c13f11427 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/interactions.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/interactions.rs @@ -365,12 +365,30 @@ pub fn doodad_allow_removal(server: &GameServer, doodad: &DoodadRef) -> bool { if !coffer::coffer_is_empty(server, doodad) { return false; } + let instance = doodad.data().transform.instance_id; !doodad .core() .children() .iter() .filter_map(WorldObject::as_doodad) - .any(|c| c.data().is_persistent) + .any(|child| { + let (persistent, parent, child_instance) = { + let d = child.data(); + ( + d.is_persistent && !d.phase.deleted, + d.transform.parent_obj_id, + d.transform.instance_id, + ) + }; + persistent + && parent == doodad.obj_id + && child_instance == instance + && server + .world + .world(instance) + .and_then(|world| world.doodad(child.obj_id)) + .is_some_and(|live| std::sync::Arc::ptr_eq(&live, child)) + }) } /// `RecoverItem.Execute`. diff --git a/rust/crates/aaemu-game/src/systems/npcs/hooks.rs b/rust/crates/aaemu-game/src/systems/npcs/hooks.rs index ad551b92a4..ee621caec8 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/hooks.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/hooks.rs @@ -12,7 +12,15 @@ use crate::server::GameServer; use crate::systems::HookSlot; -use crate::world::{NpcRef, PlayerRef, WorldObject}; +use crate::world::{DoodadRef, NpcRef, PlayerRef, WorldObject}; + +/// Result of recovering an authored vehicle cargo rack; stale repair never grants an item. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum CargoRecovery { + Failed, + Recovered, + ClearedStale(u32), +} /// Implemented by the **skills** subsystem (`SkillManager`, `Skill.Use`, buffs, combat). pub trait SkillsBridge: Send + Sync { @@ -418,6 +426,30 @@ pub trait EconomyBridge: Send + Sync { false } + /// Check the exact equipped source and vacant rack, then move and record it atomically. + /// The caller holds the housing operation lock before entering the economy operation. + fn try_store_doodad_item( + &self, + _server: &GameServer, + _player: &PlayerRef, + _doodad: &DoodadRef, + _source: &crate::models::item::Item, + _required_count: i32, + ) -> bool { + false + } + + /// Recover vehicle cargo from System escrow, including backpack-space preflight, in one + /// item operation. Ordinary furniture recovery retains its separate behavior. + fn recover_doodad_cargo( + &self, + _server: &GameServer, + _player: &PlayerRef, + _doodad: &DoodadRef, + ) -> CargoRecovery { + CargoRecovery::Failed + } + /// `Equipment.RemoveItem(task, item, true)` (`DoodadFuncBuyFish` / `ConvertFish`). fn remove_equipment_item( &self, From 73babdda7a13f92e6eb0c5ac7fb64fa4a88925ea Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:55:07 -0400 Subject: [PATCH 37/66] fix(vehicles): serialize ship summons across sessions Keep one live root per summon item and preserve owner switching across worlds. Validate requests and loaded-hull removal before destructive effects, fence queued saves before lookup, and close publication on departure. Add deterministic lifecycle regressions and a gated temporary-table persistence fixture. Runtime validation is reserved for the parent session. Co-Authored-By: Codex --- .../src/systems/vehicles/flow_tests.rs | 33 +- .../aaemu-game/src/systems/vehicles/mod.rs | 101 ++- .../systems/vehicles/ship_identity_tests.rs | 802 ++++++++++++++++++ .../aaemu-game/src/systems/vehicles/slaves.rs | 690 ++++++++++++--- 4 files changed, 1452 insertions(+), 174 deletions(-) create mode 100644 rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs 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 1bbedf8efc..c15ed699ae 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs @@ -49,6 +49,9 @@ mod deck_standing_tests; #[path = "pr38_regression_tests.rs"] mod pr38_regression_tests; +#[path = "ship_identity_tests.rs"] +mod ship_identity_tests; + fn exp_table() -> ExperienceTable { ExperienceTable::from_templates( (1..=3u8) @@ -134,6 +137,12 @@ fn data() -> GameData { fn server_with(d: GameData) -> Arc { let s = Arc::new(test_server_with(d)); s.set_self(); + // This synthetic server has no MySQL. Explicitly supply an empty saved-hull store; + // persistence/error regressions use their own loader or private temporary tables. + *s.systems.vehicles.slave_summons.test_loader.lock().unwrap() = + Some(slaves::TestSlaveLoader(Arc::new(|_, _| { + Box::pin(async { Ok(slaves::LoadedHull::default()) }) + }))); s } @@ -3375,23 +3384,30 @@ async fn summon_pos_places_the_vehicle_at_the_chosen_spot() { } #[tokio::test] -async fn summon_pos_outside_the_valid_area_errors_and_falls_back_in_front() { +async fn summon_pos_outside_the_valid_area_errors_without_spawning() { 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(); + let frames = tokio::time::timeout(Duration::from_secs(5), async { + let mut frames = Vec::new(); + loop { + frames.extend(a.drain()); + if error_codes(&frames).contains(&super::error::SLAVE_SPAWN_ERROR_INVALID_AREA) { + break frames; + } + tokio::task::yield_now().await; + } + }) + .await + .expect("invalid summon placement must be handled"); 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); + assert!(slaves::get_active_slave_by_owner_obj_id(&world, PA).is_none()); } #[tokio::test] @@ -3619,6 +3635,9 @@ const SLOT20_ITEM: u32 = 5003; fn ship_equip_data() -> GameData { use super::data::{ItemSlaveEquipment, SlaveEquipSlot, SlaveInitialItem}; let mut d = slave_data(); + d.items.templates.get_mut(&SLAVE_ITEM).unwrap().kind = TemplateKind::SummonSlave { + slave_id: SHIP_HULL, + }; d.systems.vehicles.slave_templates.insert( SHIP_HULL, SlaveTemplate { diff --git a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs index 30f6723fcd..df60337e9e 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs @@ -56,6 +56,8 @@ pub struct System { pub mates: mates::MateManagers, /// The loaded `SlaveSpawner`s. pub slave_spawners: slaves::SlaveSpawners, + /// Summon identity reservations, departure/publication ordering and pending hull saves. + pub(crate) slave_summons: slaves::SlaveSummons, /// `world.TransferManager` of every instance + the transfer spawners. pub transfers: transfers::TransferManagers, /// `ShipyardManager`. @@ -432,16 +434,11 @@ pub fn active_region_tick(server: &GameServer) { pub fn on_character_selected(server: &GameServer, player: &PlayerRef) { let char_id = player.data().id; mates::on_character_selected(server, char_id); - let instance = player.data().unit.transform.instance_id; - if let Some(world) = server.world.world(instance) { - if let Some(slave) = slaves::get_active_slave_by_owner_obj_id(&world, player.obj_id) { - tracing::warn!( - "{}: Abort the task of disabling vehicles", - player.data().unit.name - ); - slave.data().leave_task = 0; - } - } + server + .systems + .vehicles + .slave_summons + .reconnect(server, player); } /// `CharacterMates.Load` (called from `Character.Load` at character select). @@ -467,18 +464,24 @@ pub async fn save_character(server: &GameServer, character_id: u32) { /// The logout extension of `EnterWorldManager.Leave` (+10 minutes with an active vehicle). pub fn leave_extra_logout_ms(server: &GameServer, player: &PlayerRef) -> i32 { - let instance = player.data().unit.transform.instance_id; - match server.world.world(instance) { - Some(w) if slaves::get_active_slave_by_owner_obj_id(&w, player.obj_id).is_some() => { - 1000 * 60 * 10 - } - _ => 0, + if slaves::owned_roots(server, player.character_id).is_empty() { + 0 + } else { + 1000 * 60 * 10 } } /// `EnterWorldManager.LeaveWorldTask` part: despawn the owned mates and slaves (the caller then /// closes coffers and calls [`force_dismount`], as the C# order). pub fn on_leave_world(server: &GameServer, player: &PlayerRef) { + let Some(_departure) = server + .systems + .vehicles + .slave_summons + .departure(server, player) + else { + return; + }; let (instance, id) = { let c = player.data(); (c.unit.transform.instance_id, c.id) @@ -493,6 +496,14 @@ pub fn on_leave_world(server: &GameServer, player: &PlayerRef) { /// `GameConnection.OnDisconnect` part: `RemoveAndDespawnActiveOwnedMatesSlaves()` (owned mates /// now, the active vehicle 10 minutes later unless the character logs in again). pub fn on_disconnect(server: &GameServer, player: &PlayerRef) { + let Some(_departure) = server + .systems + .vehicles + .slave_summons + .departure(server, player) + else { + return; + }; let (instance, id) = { let c = player.data(); (c.unit.transform.instance_id, c.id) @@ -513,26 +524,36 @@ pub fn force_dismount_and_despawn( time_to_despawn_ms: u64, ) -> bool { let res = force_dismount(server, player, slaves::attach_reason::PREFAB_CHANGED); - let instance = player.data().unit.transform.instance_id; - let Some(world) = server.world.world(instance) else { - return res; - }; - let Some(slave) = slaves::get_active_slave_by_owner_obj_id(&world, player.obj_id) else { - return res; - }; - let gen = LEAVE_TASK_GEN.fetch_add(1, std::sync::atomic::Ordering::Relaxed); - slave.data().leave_task = gen; - let (Some(server), Ok(rt)) = (server.self_arc(), tokio::runtime::Handle::try_current()) else { - return res; - }; - let (player, slave) = (player.clone(), slave.clone()); - rt.spawn(async move { - tokio::time::sleep(Duration::from_millis(time_to_despawn_ms)).await; - if slave.data().leave_task != gen { - return; - } - slaves::remove_and_despawn_all_active_owned_slaves(&server, &player, false); - }); + for (world, slave) in slaves::owned_roots(server, player.character_id) { + let gen = LEAVE_TASK_GEN.fetch_add(1, std::sync::atomic::Ordering::Relaxed); + slave.data().leave_task = gen; + let (Some(server), Ok(rt)) = (server.self_arc(), tokio::runtime::Handle::try_current()) + else { + continue; + }; + let player = player.clone(); + rt.spawn(async move { + tokio::time::sleep(Duration::from_millis(time_to_despawn_ms)).await; + let _publication = server + .systems + .vehicles + .slave_summons + .departing + .lock() + .expect("slave departures poisoned"); + if slave.data().leave_task != gen { + return; + } + if !world + .slave(slave.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, &slave)) + { + return; + } + // A timer belongs to this hull, not whichever ship the owner summons later. + slaves::delete(&server, Some(&player), world.id, slave.obj_id, false); + }); + } res } @@ -560,6 +581,14 @@ pub fn force_dismount_and_despawn_test_slave( return; } let instance = slave.data().unit.transform.instance_id; + if !server + .world + .world(instance) + .and_then(|w| w.slave(slave.obj_id)) + .is_some_and(|live| Arc::ptr_eq(&live, &slave)) + { + return; + } slaves::delete(&server, Some(&player), instance, slave.obj_id, false); }); res diff --git a/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs new file mode 100644 index 0000000000..0b5df802a7 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs @@ -0,0 +1,802 @@ +//! Ship identity and session regressions. Synthetic fixtures exercise lifecycle ordering; +//! the gated temporary-table fixture exercises the production MySQL lookup/save fence. + +use super::*; +use crate::models::doodad::{doodad_owner_type, Doodad}; +use crate::models::unit::BaseUnitType; +use crate::world::{Entity, SlaveRef}; +use futures::poll; +use std::sync::atomic::{AtomicUsize, Ordering}; +use tokio::sync::Semaphore; + +const MERCHANT: u32 = 75; +const MERCHANT_ITEM: u32 = 23398; +const SECOND_SHIP_ITEM: u32 = 23400; + +fn identity_data() -> GameData { + let mut data = ship_equip_data(); + data.systems + .vehicles + .slave_templates + .get_mut(&SHIP_HULL) + .unwrap() + .slave_kind = super::super::data::slave_kind::SMALL_SAILING_SHIP; + let mut merchant = data.systems.vehicles.slave_templates[&SHIP_HULL].clone(); + merchant.id = MERCHANT; + merchant.name = "Merchant Ship".into(); + merchant.model_id = 1205; + merchant.slave_kind = super::super::data::slave_kind::MERCHANT_SHIP; + merchant.portal_time = 2.0; + for binding in &mut merchant.slave_bindings { + binding.owner_id = MERCHANT; + } + let mut slots = data.systems.vehicles.slave_equip_slots[&SHIP_HULL].clone(); + for slot in &mut slots { + slot.slave_id = MERCHANT; + } + data.systems + .vehicles + .slave_templates + .insert(MERCHANT, merchant); + data.systems + .vehicles + .slave_equip_slots + .insert(MERCHANT, slots); + let points = data.systems.vehicles.attach_points[&511].clone(); + data.systems.vehicles.attach_points.insert(1205, points); + data.systems + .vehicles + .slave_equip_packs + .get_mut(&4) + .unwrap() + .push(MERCHANT); + for (item_id, hull_id) in [(MERCHANT_ITEM, MERCHANT), (SECOND_SHIP_ITEM, SHIP_HULL)] { + data.items.templates.insert( + item_id, + ItemTemplate { + kind: TemplateKind::SummonSlave { slave_id: hull_id }, + ..ItemTemplate::plain(item_id, 1) + }, + ); + } + data +} + +fn owner_with_ship( + server: &GameServer, + client: &TestClient, + character_id: u32, + obj_id: u32, + template: u32, +) -> (PlayerRef, u64) { + let (owner, item_id) = player_with_item( + server, + client, + character_id, + obj_id, + (100.0, 100.0), + template, + ); + let bag = owner.data().inventory.bag().clone(); + bag.lock().unwrap().items[0].owner_id = u64::from(character_id); + server.items.add_container(bag); + (owner, item_id) +} + +fn second_item(server: &GameServer, owner: &PlayerRef, item_id: u64, template: u32) { + let mut item = Item::create( + item_id, + server.game_data.items.template(template).unwrap(), + 1, + 0, + 1, + &server.game_data.items, + 0, + ); + item.owner_id = u64::from(owner.character_id); + item.slot_type = slot_type::INVENTORY; + item.slot = 1; + let bag = owner.data().inventory.bag().clone(); + bag.lock().unwrap().items.push(item); +} + +fn root(server: &GameServer, owner: &PlayerRef, item_id: u64, hull_id: u32) -> SlaveRef { + let world = server.world.world(0).unwrap(); + server.systems.npcs.spawns.get_or_create(&world); + let item = mates::owned_item(server, owner, item_id).unwrap(); + slaves::create_core( + server, + &world, + Some(owner), + None, + hull_id, + Some(item), + false, + Some(crate::models::transform::Transform { + x: 100.0, + y: 100.0, + z: 200.0, + ..Default::default() + }), + None, + ) + .unwrap() +} + +fn roots(server: &GameServer, owner: u32) -> Vec { + server + .world + .worlds() + .into_iter() + .flat_map(|world| slaves::all_slaves(&world)) + .filter(|slave| { + let d = slave.data(); + d.owner_type == BaseUnitType::Character && d.summoner_id == owner && !d.unit.is_dead() + }) + .collect() +} + +fn persistent_id(slave: &SlaveRef) -> u32 { + slave.data().id +} + +fn loaded_rack(server: &GameServer, hull: &SlaveRef) -> crate::world::DoodadRef { + let world = server.world.world(0).unwrap(); + let mut rack = Doodad::new(3446); + rack.item_id = 0xdead; + rack.item_template_id = 29203; + rack.attach_point = 60; + rack.func_group_id = 8265; + rack.owner_type = doodad_owner_type::SLAVE; + rack.owner_id = hull.data().summoner_id; + rack.owner_db_id = hull.data().id; + let rack = Entity::new(server.ids.object.get_next_id().unwrap(), rack); + world.attach_child(&WorldObject::from(hull), &WorldObject::from(&rack)); + hull.data().attached_doodads.push(rack.obj_id); + world.spawn(&rack, &server.view_ctx()); + rack +} + +/// Model a saved hull's identity without a database. The production persistence tests below +/// bypass this loader; a nonzero detail id is explicitly a saved identity, never a live flag. +fn install_memory_loader(server: &Arc) { + let weak = Arc::downgrade(server); + *server + .systems + .vehicles + .slave_summons + .test_loader + .lock() + .unwrap() = Some(slaves::TestSlaveLoader(Arc::new(move |_, item_id| { + let server = weak.upgrade().unwrap(); + let id = server + .items + .item_by_id(item_id) + .unwrap() + .details + .slave_db_id; + Box::pin(async move { + Ok(slaves::LoadedHull { + saved: (id != 0).then_some(slaves::SavedSlave { + id, + name: "Saved hull".into(), + hp: 100, + mp: 10, + }), + children: Vec::new(), + }) + }) + }))); +} + +fn install_barrier_loader(server: &GameServer) -> (Arc, Arc) { + let entered = Arc::new(AtomicUsize::new(0)); + let release = Arc::new(Semaphore::new(0)); + let (calls, permits) = (entered.clone(), release.clone()); + *server + .systems + .vehicles + .slave_summons + .test_loader + .lock() + .unwrap() = Some(slaves::TestSlaveLoader(Arc::new(move |_, _| { + calls.fetch_add(1, Ordering::SeqCst); + let permits = permits.clone(); + Box::pin(async move { + permits.acquire_owned().await.unwrap().forget(); + Ok(slaves::LoadedHull::default()) + }) + }))); + (entered, release) +} + +async fn summon( + server: &GameServer, + owner: &PlayerRef, + item_id: u64, + template: u32, +) -> Option { + slaves::create_for_owner(server, owner, item_id, template, false, None, None, 0.0).await +} + +#[tokio::test] +async fn merchant_loaded_refusal_preserves_hull_rider_gunner_and_item_identity() { + let server = server_with(identity_data()); + let mut owner_client = TestClient::new(&server, 1, 1); + let mut gunner_client = TestClient::new(&server, 2, 2); + let (owner, item_id) = owner_with_ship(&server, &owner_client, 1, PA, MERCHANT_ITEM); + let gunner = spawn_player( + &server, + &gunner_client, + test_character(2, "Gunner", 100.0, 100.0), + PB, + ); + let hull = root(&server, &owner, item_id, MERCHANT); + let world = server.world.world(0).unwrap(); + let cannon_id = hull.data().attached_slaves[0]; + let cannon = world.slave(cannon_id).unwrap(); + let tl = u32::from(hull.data().unit.tl_id); + slaves::bind_slave_by_tl(&server, &owner, tl); + let pos = world.world_pos_rot(&WorldObject::from(&cannon)); + gunner.data().unit.transform.set_xyz(pos.x, pos.y, pos.z); + world.attach_child(&WorldObject::from(&hull), &WorldObject::from(&gunner)); + let cannon_tl = u32::from(cannon.data().unit.tl_id); + slaves::bind_slave_by_tl(&server, &gunner, cannon_tl); + assert!(!hull.data().attached_characters.is_empty()); + assert!(!cannon.data().attached_characters.is_empty()); + let rack = loaded_rack(&server, &hull); + let hull_before = hull.data().clone(); + let cannon_before = cannon.data().clone(); + let rack_before = rack.data().clone(); + let item_before = mates::owned_item(&server, &owner, item_id).unwrap(); + owner_client.drain(); + gunner_client.drain(); + + slaves::delete(&server, Some(&owner), world.id, hull.obj_id, false); + assert!(summon(&server, &owner, item_id, MERCHANT_ITEM) + .await + .is_none()); + let item = mates::owned_item(&server, &owner, item_id).unwrap(); + assert!(slaves::create( + &server, + &world, + Some(&owner), + MERCHANT, + Some(item), + false, + None + ) + .await + .is_none()); + assert_eq!( + roots(&server, 1) + .iter() + .map(|s| s.obj_id) + .collect::>(), + vec![hull.obj_id] + ); + assert_eq!(*hull.data(), hull_before); + assert_eq!(*cannon.data(), cannon_before); + assert_eq!(*rack.data(), rack_before); + assert_eq!( + mates::owned_item(&server, &owner, item_id).unwrap(), + item_before + ); + assert_eq!(owner.data().unit.transform.parent_obj_id, hull.obj_id); + assert_eq!(gunner.data().unit.transform.parent_obj_id, cannon.obj_id); + let frames = owner_client.drain(); + let gunner_frames = gunner_client.drain(); + assert!(error_codes(&frames).contains(&super::super::error::SLAVE_EQUIPMENT_LOADED_ITEM)); + for op in [ + sc::SCSlaveCreatedPacket, + sc::SCSlaveDespawnPacket, + sc::SCSlaveRemovedPacket, + sc::SCUnitDetachedPacket, + sc::SCItemTaskSuccessPacket, + ] { + assert!(!ops(&frames).contains(&op)); + assert!(!ops(&gunner_frames).contains(&op)); + } + assert!(server + .systems + .npcs + .spawns + .get(0) + .unwrap() + .pending_despawns() + .is_empty()); +} + +#[tokio::test] +async fn cannon_children_never_qualify_as_an_active_root() { + let server = server_with(identity_data()); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let hull = root(&server, &owner, item_id, SHIP_HULL); + let world = server.world.world(0).unwrap(); + assert!(!hull.data().attached_slaves.is_empty()); + assert_eq!( + slaves::get_active_slave_by_owner_obj_id(&world, PA) + .unwrap() + .obj_id, + hull.obj_id + ); + client.drain(); + slaves::send_my_slave_packet_to_all_owners(&server); + let notifications = client.drain(); + assert_eq!(ops(¬ifications), vec![sc::SCMySlavePacket]); + assert!(body(¬ifications, sc::SCMySlavePacket).starts_with(&bc(hull.obj_id))); + // Deterministic: even when it is the only slave in the table, the cannon is not a root. + world.remove_object(hull.obj_id); + assert!(slaves::get_active_slave_by_owner_obj_id(&world, PA).is_none()); + assert_eq!(super::super::leave_extra_logout_ms(&server, &owner), 0); + slaves::send_my_slave_packet_to_all_owners(&server); + assert!(client.drain().is_empty()); +} + +#[tokio::test] +async fn invalid_item_placement_and_repair_leave_the_prior_hull_intact() { + let server = server_with(identity_data()); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let hull = root(&server, &owner, item_id, SHIP_HULL); + let original = hull.data().clone(); + client.drain(); + assert!(summon(&server, &owner, item_id, MERCHANT_ITEM) + .await + .is_none()); + assert!(slaves::create_for_owner( + &server, + &owner, + item_id, + SECOND_SHIP_ITEM, + false, + None, + Some(crate::systems::skills::ext::SummonPlacement { + x: 500.0, + y: 500.0, + z: 200.0, + yaw: 0.0, + }), + 10.0 + ) + .await + .is_none()); + mates::update_owned_item(&server, Some(&owner), item_id, |item| { + item.details.slave_is_destroyed = 1; + item.details.slave_repair_start_time = chrono::Utc::now().timestamp(); + }); + assert!(summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .is_none()); + assert_eq!(*hull.data(), original); + assert_eq!(roots(&server, 1).len(), 1); + assert!(!ops(&client.drain()).contains(&sc::SCSlaveDespawnPacket)); +} + +#[tokio::test] +async fn owner_reservation_serializes_requests_across_the_load_await() { + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let (calls, release) = install_barrier_loader(&server); + let mut first = Box::pin(summon(&server, &owner, item_id, SECOND_SHIP_ITEM)); + let mut second = Box::pin(summon(&server, &owner, item_id, SECOND_SHIP_ITEM)); + assert!(poll!(first.as_mut()).is_pending()); + assert_eq!(calls.load(Ordering::SeqCst), 1); + assert!(poll!(second.as_mut()).is_pending()); + assert_eq!( + calls.load(Ordering::SeqCst), + 1, + "second request must wait before querying" + ); + release.add_permits(1); + let first_hull = first.await.unwrap(); + assert!(poll!(second.as_mut()).is_pending()); + assert_eq!(calls.load(Ordering::SeqCst), 2); + release.add_permits(1); + let second_hull = second.await.unwrap(); + assert_ne!(first_hull.obj_id, second_hull.obj_id); + assert_eq!( + roots(&server, 1) + .iter() + .map(|s| s.obj_id) + .collect::>(), + vec![second_hull.obj_id] + ); +} + +#[tokio::test] +async fn cancelled_load_releases_reservation_and_departed_session_cannot_publish() { + let server = server_with(identity_data()); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let (calls, release) = install_barrier_loader(&server); + let mut cancelled = Box::pin(summon(&server, &owner, item_id, SECOND_SHIP_ITEM)); + assert!(poll!(cancelled.as_mut()).is_pending()); + drop(cancelled); + let mut pending = Box::pin(summon(&server, &owner, item_id, SECOND_SHIP_ITEM)); + assert!(poll!(pending.as_mut()).is_pending()); + assert_eq!( + calls.load(Ordering::SeqCst), + 2, + "cancel released owner and item guards" + ); + super::super::on_disconnect(&server, &owner); + // Even before world removal, the departure marker closes the publication window. + release.add_permits(1); + assert!(pending.await.is_none()); + assert!(roots(&server, 1).is_empty()); + assert!(!ops(&client.drain()).contains(&sc::SCSlaveCreatedPacket)); + + server.world.world(0).unwrap().delete(&owner); + server.world.try_remove_character(owner.obj_id); + let reconnect = TestClient::new(&server, 2, 1); + let (new_owner, new_item) = owner_with_ship(&server, &reconnect, 1, PA, SECOND_SHIP_ITEM); + super::super::on_character_selected(&server, &new_owner); + install_memory_loader(&server); + assert!(summon(&server, &new_owner, new_item, SECOND_SHIP_ITEM) + .await + .is_some()); + assert!(summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .is_none()); + assert_eq!(roots(&server, 1).len(), 1); +} + +#[tokio::test] +async fn reconnect_during_an_old_sessions_load_cannot_publish_its_retained_player() { + let server = server_with(identity_data()); + let mut old_client = TestClient::new(&server, 1, 1); + let (old_owner, item_id) = owner_with_ship(&server, &old_client, 1, PA, SECOND_SHIP_ITEM); + let (calls, release) = install_barrier_loader(&server); + let mut old_request = Box::pin(summon(&server, &old_owner, item_id, SECOND_SHIP_ITEM)); + assert!(poll!(old_request.as_mut()).is_pending()); + super::super::on_disconnect(&server, &old_owner); + server.world.world(0).unwrap().delete(&old_owner); + server.world.try_remove_character(old_owner.obj_id); + let reconnect = TestClient::new(&server, 2, 1); + let character = old_owner.data().clone(); + let new_owner = spawn_player(&server, &reconnect, character, PA); + super::super::on_character_selected(&server, &new_owner); + let mut new_request = Box::pin(summon(&server, &new_owner, item_id, SECOND_SHIP_ITEM)); + assert!(poll!(new_request.as_mut()).is_pending()); + assert_eq!(calls.load(Ordering::SeqCst), 1); + release.add_permits(1); + assert!(old_request.await.is_none()); + assert!(!ops(&old_client.drain()).contains(&sc::SCSlaveCreatedPacket)); + assert!(poll!(new_request.as_mut()).is_pending()); + assert_eq!(calls.load(Ordering::SeqCst), 2); + release.add_permits(1); + new_request.await.unwrap(); + assert_eq!(roots(&server, 1).len(), 1); +} + +#[tokio::test] +async fn another_owner_can_load_while_the_first_owner_is_waiting() { + let server = server_with(identity_data()); + let a = TestClient::new(&server, 1, 1); + let b = TestClient::new(&server, 2, 2); + let (owner, item_id) = owner_with_ship(&server, &a, 1, PA, SECOND_SHIP_ITEM); + let (other, other_item) = owner_with_ship(&server, &b, 2, PB, SECOND_SHIP_ITEM); + let (calls, _) = install_barrier_loader(&server); + let mut first = Box::pin(summon(&server, &owner, item_id, SECOND_SHIP_ITEM)); + let mut second = Box::pin(summon(&server, &other, other_item, SECOND_SHIP_ITEM)); + assert!(poll!(first.as_mut()).is_pending()); + assert!(poll!(second.as_mut()).is_pending()); + assert_eq!(calls.load(Ordering::SeqCst), 2); +} + +#[tokio::test] +async fn item_reservation_also_serializes_conflicting_owners() { + let server = server_with(identity_data()); + let a = TestClient::new(&server, 1, 1); + let b = TestClient::new(&server, 2, 2); + let (owner, item_id) = owner_with_ship(&server, &a, 1, PA, SECOND_SHIP_ITEM); + let (other, _) = owner_with_ship(&server, &b, 2, PB, SECOND_SHIP_ITEM); + // Deliberately conflicting inventory snapshots must not publish the same persistent item + // twice, even when each request initially sees its own character as the item owner. + let bag = other.data().inventory.bag().clone(); + bag.lock().unwrap().items[0].id = item_id; + let (calls, release) = install_barrier_loader(&server); + let mut first = Box::pin(summon(&server, &owner, item_id, SECOND_SHIP_ITEM)); + let mut conflicting = Box::pin(summon(&server, &other, item_id, SECOND_SHIP_ITEM)); + assert!(poll!(first.as_mut()).is_pending()); + assert!(poll!(conflicting.as_mut()).is_pending()); + assert_eq!(calls.load(Ordering::SeqCst), 1); + release.add_permits(1); + first.await.unwrap(); + assert!(conflicting.await.is_none()); + assert_eq!(calls.load(Ordering::SeqCst), 1); + assert_eq!(roots(&server, 1).len(), 1); + assert!(roots(&server, 2).is_empty()); +} + +#[tokio::test] +async fn switching_distinct_items_preserves_each_identity_and_other_owners() { + let server = server_with(identity_data()); + install_memory_loader(&server); + let a = TestClient::new(&server, 1, 1); + let b = TestClient::new(&server, 2, 2); + let (owner, first_item) = owner_with_ship(&server, &a, 1, PA, MERCHANT_ITEM); + let (other, other_item) = owner_with_ship(&server, &b, 2, PB, SECOND_SHIP_ITEM); + second_item(&server, &owner, 0x8000, SECOND_SHIP_ITEM); + let first = summon(&server, &owner, first_item, MERCHANT_ITEM) + .await + .unwrap(); + let unaffected = summon(&server, &other, other_item, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert!(summon(&server, &owner, other_item, SECOND_SHIP_ITEM) + .await + .is_none()); + let second = summon(&server, &owner, 0x8000, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert_ne!(persistent_id(&first), persistent_id(&second)); + assert_eq!(roots(&server, 1).len(), 1); + assert_eq!(roots(&server, 2)[0].obj_id, unaffected.obj_id); + let again = summon(&server, &owner, first_item, MERCHANT_ITEM) + .await + .unwrap(); + assert_eq!(persistent_id(&again), persistent_id(&first)); + assert_ne!(again.obj_id, first.obj_id); + assert_eq!(roots(&server, 1).len(), 1); +} + +#[tokio::test(start_paused = true)] +async fn retained_reconnect_cancels_the_hull_timer_and_cannot_duplicate_loaded_merchant() { + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let hull = root(&server, &owner, item_id, MERCHANT); + loaded_rack(&server, &hull); + super::super::on_disconnect(&server, &owner); + assert_ne!(hull.data().leave_task, 0); + tokio::task::yield_now().await; + tokio::time::advance(Duration::from_secs(599)).await; + assert_eq!(roots(&server, 1)[0].obj_id, hull.obj_id); + server.world.world(0).unwrap().delete(&owner); + server.world.try_remove_character(owner.obj_id); + let reconnect = TestClient::new(&server, 2, 1); + let mut character = owner.data().clone(); + character.unit.transform.parent_obj_id = 0; + let new_owner = spawn_player(&server, &reconnect, character, PA); + super::super::on_character_selected(&server, &new_owner); + assert_eq!(hull.data().leave_task, 0); + assert!(summon(&server, &new_owner, item_id, MERCHANT_ITEM) + .await + .is_none()); + tokio::time::advance(Duration::from_secs(2)).await; + tokio::task::yield_now().await; + assert_eq!(roots(&server, 1)[0].obj_id, hull.obj_id); + // A late disconnect callback from the old connection cannot schedule the new session's hull. + super::super::on_disconnect(&server, &owner); + assert_eq!(hull.data().leave_task, 0); +} + +#[tokio::test] +async fn a_root_in_another_world_still_blocks_a_loaded_replacement() { + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let hull = root(&server, &owner, item_id, MERCHANT); + let rack = loaded_rack(&server, &hull); + let old_world = server.world.world(0).unwrap(); + let template = Arc::new(WorldTemplate::synthetic(1, "other_world", 2, 2, TEST_ZONE)); + let other_world = server.world.create_world_instance(template, 1); + old_world.delete(&owner); + owner.data().unit.transform.instance_id = 1; + other_world.spawn(&owner, &server.view_ctx()); + assert!(summon(&server, &owner, item_id, MERCHANT_ITEM) + .await + .is_none()); + assert!(other_world + .all_of_kind(crate::world::ObjectKind::Slave) + .is_empty()); + assert!(old_world.slave(hull.obj_id).is_some()); + { + let mut rack = rack.data(); + rack.item_id = 0; + rack.item_template_id = 0; + } + install_memory_loader(&server); + let replacement = summon(&server, &owner, item_id, MERCHANT_ITEM) + .await + .unwrap(); + assert_eq!(persistent_id(&replacement), persistent_id(&hull)); + assert!(old_world.slave(hull.obj_id).is_none()); + assert!(other_world.slave(replacement.obj_id).is_some()); + assert_eq!(roots(&server, 1).len(), 1); +} + +#[tokio::test(start_paused = true)] +async fn offline_hull_remains_for_600_seconds_then_uses_delayed_portal_removal() { + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let hull = root(&server, &owner, item_id, MERCHANT); + super::super::on_disconnect(&server, &owner); + tokio::task::yield_now().await; + tokio::time::advance(Duration::from_secs(599)).await; + assert_eq!(roots(&server, 1)[0].obj_id, hull.obj_id); + tokio::time::advance(Duration::from_secs(1)).await; + tokio::task::yield_now().await; + assert!(roots(&server, 1).is_empty()); + assert!( + hull.core().is_visible(), + "portal rendering survives authoritative removal" + ); + let spawns = server.systems.npcs.spawns.get(0).unwrap(); + crate::systems::npcs::spawn_manager::advance_test_clock(Duration::from_secs(3)); + spawns.check_respawns_tick(&server); + assert!(!hull.core().is_visible()); +} + +#[tokio::test(start_paused = true)] +async fn old_disconnect_timer_cannot_delete_another_hull_reusing_the_object_id() { + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let old_hull = root(&server, &owner, item_id, MERCHANT); + super::super::on_disconnect(&server, &owner); + tokio::task::yield_now().await; + let world = server.world.world(0).unwrap(); + world.delete(&old_hull); + // Model a later allocation after the old object's portal/death timer released its id. + let mut data = crate::models::slave::Slave::new(900, MERCHANT); + data.summoner_id = 1; + data.summoner_obj_id = PA; + data.owner_obj_id = PA; + data.summoning_item_id = 0xbeef; + data.unit.hp = 1; + data.unit.transform.set_xyz(100.0, 100.0, 100.0); + let replacement = Entity::new(old_hull.obj_id, data); + world.spawn(&replacement, &server.view_ctx()); + tokio::time::advance(Duration::from_secs(600)).await; + tokio::task::yield_now().await; + assert!(Arc::ptr_eq( + &world.slave(replacement.obj_id).unwrap(), + &replacement + )); +} + +#[tokio::test] +async fn failed_lookup_releases_reservations_without_changing_the_prior_hull() { + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let hull = root(&server, &owner, item_id, SHIP_HULL); + *server + .systems + .vehicles + .slave_summons + .test_loader + .lock() + .unwrap() = Some(slaves::TestSlaveLoader(Arc::new(|_, _| { + Box::pin(async { Err(sqlx::Error::Protocol("deliberate failed SELECT".into())) }) + }))); + assert!(summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .is_none()); + assert_eq!(roots(&server, 1)[0].obj_id, hull.obj_id); + install_memory_loader(&server); + let retry = summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert_eq!(persistent_id(&retry), persistent_id(&hull)); + assert_eq!(roots(&server, 1).len(), 1); +} + +#[tokio::test] +#[ignore = "requires private MySQL3317 via AAEMU_TEST_MYSQL; connection-local temporary tables only"] +async fn private_mysql_ship_save_fence_query_failure_retry_and_restart() { + use sqlx::mysql::MySqlConnectOptions; + use std::str::FromStr; + + let options = + MySqlConnectOptions::from_str(&std::env::var("AAEMU_TEST_MYSQL").unwrap()).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(); + let mut slave_ddl = String::new(); + for table in ["slaves", "doodads"] { + let (_, ddl): (String, String) = sqlx::query_as(&format!("SHOW CREATE TABLE `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + let ddl = ddl.replacen("CREATE TABLE", "CREATE TEMPORARY TABLE", 1); + if table == "slaves" { + slave_ddl = ddl; + sqlx::query("CREATE TEMPORARY TABLE slaves (id INT UNSIGNED PRIMARY KEY)") + .execute(&pool) + .await + .unwrap(); + } else { + sqlx::query(&ddl).execute(&pool).await.unwrap(); + } + } + let make_server = || { + let mut server = test_server_with(identity_data()); + server.db = pool.clone(); + let server = Arc::new(server); + server.set_self(); + server + }; + let server = make_server(); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let before = mates::owned_item(&server, &owner, item_id).unwrap(); + // A genuine SQL error must not become "no row" and allocate/publish a new identity. + assert!(summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .is_none()); + assert_eq!(mates::owned_item(&server, &owner, item_id).unwrap(), before); + assert!(roots(&server, 1).is_empty()); + // No writes/tasks exist yet, so restoring this temporary fixture cannot expose a real table + // to an in-flight writer during the DROP/CREATE interval. + sqlx::query("DROP TEMPORARY TABLE slaves") + .execute(&pool) + .await + .unwrap(); + sqlx::query(&slave_ddl).execute(&pool).await.unwrap(); + let first = summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap(); + let db_id = first.data().id; + let second = summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert_eq!( + second.data().id, + db_id, + "SELECT must observe queued save before replacement" + ); + assert_ne!(second.obj_id, first.obj_id); + assert_eq!(roots(&server, 1).len(), 1); + slaves::delete(&server, Some(&owner), 0, second.obj_id, false); + let third = summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert_eq!( + third.data().id, + db_id, + "manual despawn's queued save is fenced too" + ); + let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM slaves WHERE item_id = ?") + .bind(item_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(count, 1); + { + let _transaction = server.save.transaction_lock().await; + let mut tx = pool.begin().await.unwrap(); + slaves::save_all(&server, &mut tx).await.unwrap(); + tx.commit().await.unwrap(); + } + // Keep unknown legacy duplicates intact. The actual item's saved id wins the lookup, + // while the fresh server still admits only one live root for that item. + let mut legacy_duplicate = slaves::snapshot(&server, &third)[0].clone(); + legacy_duplicate.id = db_id + 10_000; + slaves::write_row(&mut pool.acquire().await.unwrap(), &legacy_duplicate) + .await + .unwrap(); + let restart = make_server(); + let restarted_client = TestClient::new(&restart, 2, 1); + let mut character = owner.data().clone(); + character.unit.transform.parent_obj_id = 0; + let restarted_owner = spawn_player(&restart, &restarted_client, character, PA); + let bag = restarted_owner.data().inventory.bag().clone(); + restart.items.add_container(bag); + let restored = summon(&restart, &restarted_owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert_eq!(restored.data().id, db_id); + assert_eq!(roots(&restart, 1).len(), 1); + pool.close().await; +} diff --git a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs index af828d279e..7ca0047fdb 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs @@ -4,7 +4,8 @@ //! //! Locking: one object data lock at a time; world calls never hold a data lock. -use std::sync::{Arc, Mutex}; +use std::collections::HashMap; +use std::sync::{Arc, Mutex, MutexGuard, Weak}; use dashmap::DashMap; use rand::Rng; @@ -65,6 +66,127 @@ pub mod buff { const BASE_WATER_DENSITY: f32 = 1.025; const SHIP_WATER_DENSITY_MUL: f32 = 3.0; +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +enum SummonKey { + Owner(u32), + Item(u64), +} + +/// Owner/item guards survive database awaits; the separate synchronous gate orders hull +/// publication with departure. No object lock or synchronous guard crosses an await. +#[derive(Debug, Default)] +pub(crate) struct SlaveSummons { + reservations: Mutex>>>, + pub(super) departing: Mutex>, + pending_saves: Mutex>>>, + #[cfg(test)] + pub(crate) test_loader: Mutex>, +} + +#[cfg(test)] +type TestSlaveLoad = + dyn Fn(u32, u64) -> futures::future::BoxFuture<'static, sqlx::Result> + Send + Sync; + +#[cfg(test)] +#[derive(Clone)] +pub(crate) struct TestSlaveLoader(pub Arc); + +#[cfg(test)] +impl std::fmt::Debug for TestSlaveLoader { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("TestSlaveLoader") + } +} + +impl SlaveSummons { + fn reservation(&self, key: SummonKey) -> Arc> { + let mut locks = self + .reservations + .lock() + .expect("slave reservations poisoned"); + locks.retain(|_, lock| lock.strong_count() != 0); + if let Some(lock) = locks.get(&key).and_then(Weak::upgrade) { + return lock; + } + let lock = Arc::new(tokio::sync::Mutex::new(())); + locks.insert(key, Arc::downgrade(&lock)); + lock + } + + fn publication<'a>( + &'a self, + server: &GameServer, + player: &PlayerRef, + ) -> Option>> { + let state = self.departing.lock().expect("slave departures poisoned"); + if state.get(&player.character_id) == Some(&player.conn.id) + || !current_session(server, player) + { + return None; + } + Some(state) + } + + pub(super) fn departure<'a>( + &'a self, + server: &GameServer, + player: &PlayerRef, + ) -> Option>> { + let mut state = self.departing.lock().expect("slave departures poisoned"); + if !current_session(server, player) + || state.get(&player.character_id) == Some(&player.conn.id) + { + return None; + } + state.insert(player.character_id, player.conn.id); + Some(state) + } + + pub(super) fn reconnect(&self, server: &GameServer, player: &PlayerRef) { + let mut state = self.departing.lock().expect("slave departures poisoned"); + if !current_session(server, player) { + return; + } + state.remove(&player.character_id); + for (world, root) in owned_roots(server, player.character_id) { + let (children, doodads) = { + let mut d = root.data(); + d.leave_task = 0; + d.summoner_obj_id = player.obj_id; + d.owner_obj_id = player.obj_id; + (d.attached_slaves.clone(), d.attached_doodads.clone()) + }; + for child in children { + if let Some(child) = world.slave(child) { + child.data().summoner_obj_id = player.obj_id; + } + } + for doodad in doodads { + if let Some(doodad) = world.doodad(doodad) { + doodad.data().owner_obj_id = player.obj_id; + } + } + } + } + + fn queue_save(&self, server: &GameServer, slave: &SlaveRef) -> Arc> { + // Capture and enqueue in one order, so an older snapshot cannot overwrite a newer one. + let mut pending = self.pending_saves.lock().expect("slave saves poisoned"); + let rows = Arc::new(snapshot(server, slave)); + if let Some(row) = rows.first().filter(|row| row.item_id != 0) { + pending.insert(row.item_id, rows.clone()); + } + rows + } +} + +fn current_session(server: &GameServer, player: &PlayerRef) -> bool { + server + .world + .character_by_obj_id(player.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, player)) +} + // --------------------------------------------------------------------------------------------- // SlaveSpawner // --------------------------------------------------------------------------------------------- @@ -246,7 +368,46 @@ pub fn all_slaves(world: &WorldInstance) -> Vec { pub fn get_active_slave_by_owner_obj_id(world: &WorldInstance, obj_id: u32) -> Option { all_slaves(world).into_iter().find(|s| { let d = s.data(); - d.summoner_obj_id != 0 && d.summoner_obj_id == obj_id && !d.unit.is_dead() + d.owner_type == BaseUnitType::Character + && d.summoner_obj_id != 0 + && d.summoner_obj_id == obj_id + && !d.unit.is_dead() + }) +} + +/// Persistent owner identity, across instances. Cannon children share the summoner but are +/// owned by a slave, so they must never stand in for a summoned root. +pub(super) fn owned_roots( + server: &GameServer, + owner_id: u32, +) -> Vec<(Arc, SlaveRef)> { + server + .world + .worlds() + .into_iter() + .flat_map(|world| { + all_slaves(&world) + .into_iter() + .filter(|slave| { + let d = slave.data(); + d.owner_type == BaseUnitType::Character + && d.summoner_id == owner_id + && !d.unit.is_dead() + }) + .map(move |slave| (world.clone(), slave)) + }) + .collect() +} + +fn item_has_other_live_root(server: &GameServer, item_id: u64, owner_id: u32) -> bool { + server.world.worlds().into_iter().any(|world| { + all_slaves(&world).into_iter().any(|slave| { + let d = slave.data(); + d.owner_type == BaseUnitType::Character + && !d.unit.is_dead() + && d.summoning_item_id == item_id + && d.summoner_id != owner_id + }) }) } @@ -1366,14 +1527,60 @@ pub fn delete( obj_id: u32, ignore_attached_item_warning: bool, ) { + try_delete( + server, + owner, + instance_id, + obj_id, + ignore_attached_item_warning, + ); +} + +fn can_delete( + world: &WorldInstance, + slave: &SlaveRef, + owner: Option<&PlayerRef>, + ignore_attached_item_warning: bool, +) -> bool { + if owner.is_some_and(|player| slave.data().summoner_id != player.character_id) { + return false; + } + if !ignore_attached_item_warning { + let doodads = slave.data().attached_doodads.clone(); + for id in doodads { + if let Some(doodad) = world.doodad(id) { + let loaded = { + let d = doodad.data(); + d.item_id != 0 || d.item_template_id != 0 + }; + if loaded { + if let Some(owner) = owner { + error(owner, error::SLAVE_EQUIPMENT_LOADED_ITEM); + } + return false; + } + } + } + } + true +} + +/// Refusal is checked before saves, rider/gunner detachment, physics or success packets. +fn try_delete( + server: &GameServer, + owner: Option<&PlayerRef>, + instance_id: u32, + obj_id: u32, + ignore_attached_item_warning: bool, +) -> bool { let Some(world) = server.world.world(instance_id) else { - return; + return false; }; let Some(slave) = world.slave(obj_id) else { - return; + return false; }; - if owner.is_some_and(|player| slave.data().summoner_obj_id != player.obj_id) { - return; + if !can_delete(&world, &slave, owner, ignore_attached_item_warning) { + return false; } save(server, &slave); let (attached_chars, tl) = { @@ -1401,22 +1608,6 @@ pub fn delete( d.unit.template_id, ) }; - if !ignore_attached_item_warning { - for id in &doodad_ids { - if let Some(d) = world.doodad(*id) { - let (item, tpl) = { - let d = d.data(); - (d.item_id, d.item_template_id) - }; - if item != 0 || tpl != 0 { - if let Some(o) = owner { - error(o, error::SLAVE_EQUIPMENT_LOADED_ITEM); - } - return; - } - } - } - } let now = spawn_manager::now(); let despawn_delayed = spawn_manager::add_secs(now, f64::from(portal_time - 0.5)); // slaveInfo.Transform.DetachAll() @@ -1465,6 +1656,7 @@ pub fn delete( ); } let _ = template_id; + true } /// `DestroyAndSpawnSlave` (special effect 72; row 8224 is the only row, on skill 19165 "destroy @@ -1543,13 +1735,13 @@ pub fn remove_and_despawn_all_active_owned_slaves( owner: &PlayerRef, force: bool, ) { - if let Some(world) = player_world(server, owner) { - if let Some(active) = get_active_slave_by_owner_obj_id(&world, owner.obj_id) { - save(server, &active); - delete(server, Some(owner), world.id, active.obj_id, force); - } + let mut removed = true; + for (world, active) in owned_roots(server, owner.character_id) { + removed &= try_delete(server, Some(owner), world.id, active.obj_id, force); + } + if removed { + clear_slave_attachment_state(server, owner); } - clear_slave_attachment_state(server, owner); } /// `RidersEscape(player, positionTarget)`. @@ -1641,6 +1833,26 @@ pub struct SavedChildSlave { pub mp: i32, } +#[derive(Debug, Default)] +pub(crate) struct LoadedHull { + pub(crate) saved: Option, + pub(crate) children: Vec, +} + +fn owned_summon_item( + server: &GameServer, + owner: &PlayerRef, + item_id: u64, + item_template_id: u32, +) -> Option { + let item = super::mates::owned_item(server, owner, item_id)?; + (item.owner_id == u64::from(owner.character_id) + && item.slot_type == slot_type::INVENTORY + && item.class == ItemClass::SummonSlave + && item.template_id == item_template_id) + .then_some(item) +} + /// `SlaveManager.Create(owner, skillData)` (the `SpawnSlave` special effect): runs the async /// 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. @@ -1708,6 +1920,9 @@ fn validated_summon_placement( None }; let owner_pos = world.world_pos_rot(&WorldObject::from(owner)); + if [p.x, p.y, p.z, p.yaw].iter().any(|v| !v.is_finite()) { + return invalid("non-finite coordinates"); + } // `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] @@ -1779,16 +1994,11 @@ pub async fn create_for_owner( 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) { - save(server, &active); - // TODO (C#): If too far away, don't delete - delete(server, Some(owner), world.id, active.obj_id, false); - } if item_id == 0 || item_template_id == 0 { return None; } // skillData.SkillSourceItem = ItemManager.GetItemByItemId(ItemId) - let item = super::mates::owned_item(server, owner, item_id)?; + let item = owned_summon_item(server, owner, item_id, item_template_id)?; let slave_id = match server .game_data .items @@ -1805,11 +2015,13 @@ pub async fn create_for_owner( .slave_template(slave_id)? .clone(); let position_override = if placement.is_some() { - validated_summon_placement(server, &world, owner, &template, placement, max_range) + Some(validated_summon_placement( + server, &world, owner, &template, placement, max_range, + )?) } else { position_override }; - create( + create_with_placement( server, &world, Some(owner), @@ -1817,6 +2029,8 @@ pub async fn create_for_owner( Some(item), hide_spawn_effect, position_override, + placement, + max_range, ) .await } @@ -1831,32 +2045,179 @@ pub async fn create( item: Option, hide_spawn_effect: bool, position_override: Option, +) -> Option { + create_with_placement( + server, + world, + owner, + template_id, + item, + hide_spawn_effect, + position_override, + None, + 0.0, + ) + .await +} + +#[allow(clippy::too_many_arguments)] +async fn create_with_placement( + server: &GameServer, + world: &Arc, + owner: Option<&PlayerRef>, + template_id: u32, + item: Option, + hide_spawn_effect: bool, + mut position_override: Option, + placement: Option, + max_range: f32, ) -> Option { server .game_data .systems .vehicles .slave_template(template_id)?; - let owner_id = owner.map_or(0, |o| o.data().id); - let mut saved = None; - if owner_id > 0 { - if let Some(item) = &item { - if item.id > 0 { - saved = load_saved_slave(server, owner_id, item.id).await; + if position_override.is_some_and(|t| { + [t.x, t.y, t.z, t.rot_x, t.rot_y, t.rot_z] + .iter() + .any(|v| !v.is_finite()) + }) { + return None; + } + let summons = &server.systems.vehicles.slave_summons; + let owner_id = owner.map_or(0, |o| o.character_id); + // Acquire in one order. Owned async guards release on all errors and future cancellation. + let _owner_reservation = match owner { + Some(_) => Some( + summons + .reservation(SummonKey::Owner(owner_id)) + .lock_owned() + .await, + ), + None => None, + }; + let _item_reservation = match (&item, owner) { + (Some(item), Some(_)) if item.id != 0 => Some( + summons + .reservation(SummonKey::Item(item.id)) + .lock_owned() + .await, + ), + _ => None, + }; + let mut item = match (item, owner) { + (Some(item), Some(owner)) => { + let item = owned_summon_item(server, owner, item.id, item.template_id)?; + if !matches!(server.game_data.items.template(item.template_id).map(|t| &t.kind), + Some(crate::data::items::TemplateKind::SummonSlave { slave_id }) if *slave_id == template_id) + { + return None; } + if let Some(left) = repair_seconds_left(&item, chrono::Utc::now().timestamp()) { + owner.send(crate::packets::world::SCErrorMsgPacket::new( + error::SLAVE_SPAWN_ERROR_NEED_REPAIR_TIME, + left as u32, + true, + )); + return None; + } + Some(item) } - } - let spawned = create_spawn( - server, - world, - owner, - None, - template_id, - item.clone(), - hide_spawn_effect, - position_override, - saved, - )?; + (item, _) => item, + }; + let prior = if let Some(owner) = owner { + let _publication = summons.publication(server, owner)?; + if player_world(server, owner)?.id != world.id + || item + .as_ref() + .is_some_and(|i| item_has_other_live_root(server, i.id, owner_id)) + { + return None; + } + let prior = owned_roots(server, owner_id); + if prior + .iter() + .any(|(world, slave)| !can_delete(world, slave, Some(owner), false)) + { + return None; + } + for (_, slave) in &prior { + save(server, slave); + } + prior + } else { + Vec::new() + }; + let loaded = if let Some(item) = item.as_ref().filter(|_| owner_id != 0) { + let mut flush_items: Vec<_> = prior + .iter() + .map(|(_, s)| s.data().summoning_item_id) + .collect(); + flush_items.push(item.id); + match load_hull(server, owner_id, item, &flush_items).await { + Ok(loaded) => loaded, + Err(e) => { + tracing::error!("SlaveManager.Create({owner_id}, {}): {e}", item.id); + return None; + } + } + } else { + LoadedHull::default() + }; + let spawned = { + let _publication = match owner { + Some(owner) => Some(summons.publication(server, owner)?), + None => None, + }; + if let (Some(owner), Some(current)) = (owner, &item) { + // Inventory and session may have changed during the DB await. + let fresh = owned_summon_item(server, owner, current.id, current.template_id)?; + if player_world(server, owner)?.id != world.id + || item_has_other_live_root(server, fresh.id, owner_id) + { + return None; + } + if repair_seconds_left(&fresh, chrono::Utc::now().timestamp()).is_some() { + return None; + } + item = Some(fresh); + } + if let Some(owner) = owner { + if placement.is_some() { + let template = server + .game_data + .systems + .vehicles + .slave_template(template_id)?; + position_override = Some(validated_summon_placement( + server, world, owner, template, placement, max_range, + )?); + } + let prior = owned_roots(server, owner_id); + if prior + .iter() + .any(|(w, s)| !can_delete(w, s, Some(owner), false)) + { + return None; + } + for (w, s) in prior { + if !try_delete(server, Some(owner), w.id, s.obj_id, false) { + return None; + } + } + } + create_spawn( + server, + world, + owner, + None, + template_id, + item.clone(), + hide_spawn_effect, + position_override, + loaded.saved, + )? + }; let db_id = spawned.slave.data().id; if spawned.is_loaded { // If this was a previously saved slave, load doodads from DB and spawn them @@ -1879,11 +2240,15 @@ pub async fn create( } } } - let children = if db_id > 0 { - load_saved_children(server, db_id, owner_id).await - } else { - Vec::new() - }; + // The hull was published before any departure can scan it. A delayed DB load must not + // finish an already removed hull (including adding it back to boat physics). + let _publication = summons.departing.lock().expect("slave departures poisoned"); + if !world + .slave(spawned.slave.obj_id) + .is_some_and(|s| Arc::ptr_eq(&s, &spawned.slave)) + { + return None; + } finish_create( server, world, @@ -1892,43 +2257,76 @@ pub async fn create( &spawned.template, item.as_ref(), spawned.is_loaded, - children, + loaded.children, ) } -async fn load_saved_slave(server: &GameServer, owner_id: u32, item_id: u64) -> Option { +async fn load_hull( + server: &GameServer, + owner_id: u32, + item: &Item, + flush_items: &[u64], +) -> sqlx::Result { + #[cfg(test)] + { + let loader = server + .systems + .vehicles + .slave_summons + .test_loader + .lock() + .expect("test slave loader poisoned") + .clone(); + if let Some(loader) = loader { + return (loader.0)(owner_id, item.id).await; + } + } + let _transaction = server.save.transaction_lock().await; + for item_id in flush_items.iter().copied().filter(|id| *id != 0) { + flush_pending_save(server, item_id).await?; + } + server.systems.npcs.doodads.persistence.flush().await?; + let saved = load_saved_slave(server, owner_id, item.id, item.details.slave_db_id).await?; + let children = match &saved { + Some(saved) => load_saved_children(server, saved.id, owner_id).await?, + None => Vec::new(), + }; + Ok(LoadedHull { saved, children }) +} + +async fn load_saved_slave( + server: &GameServer, + owner_id: u32, + item_id: u64, + preferred_id: u32, +) -> sqlx::Result> { let r = sqlx::query( "SELECT CAST(id AS UNSIGNED) AS id, name, CAST(hp AS SIGNED) AS hp, CAST(mp AS SIGNED) AS mp \ - FROM slaves WHERE (owner_type = 0) AND (owner_id = ?) AND (summoner = ?) AND (item_id = ?) LIMIT 1", + FROM slaves WHERE (owner_type = 0) AND (owner_id = ?) AND (summoner = ?) AND (item_id = ?) \ + ORDER BY (id = ?) DESC, id LIMIT 1", ) .bind(owner_id) .bind(owner_id) .bind(item_id) + .bind(preferred_id) .fetch_optional(&server.db) - .await; - match r { - Ok(Some(r)) => Some(SavedSlave { - id: r.try_get::("id").ok()? as u32, - name: r - .try_get::, _>("name") - .ok()? - .unwrap_or_default(), - hp: r.try_get::, _>("hp").ok()?.unwrap_or(0) as i32, - mp: r.try_get::, _>("mp").ok()?.unwrap_or(0) as i32, - }), - Ok(None) => None, - Err(e) => { - tracing::error!("load saved slave: {e}"); - None - } - } + .await?; + r.map(|r| { + Ok(SavedSlave { + id: r.try_get::("id")? as u32, + name: r.try_get::, _>("name")?.unwrap_or_default(), + hp: r.try_get::, _>("hp")?.unwrap_or(0) as i32, + mp: r.try_get::, _>("mp")?.unwrap_or(0) as i32, + }) + }) + .transpose() } async fn load_saved_children( server: &GameServer, parent_db_id: u32, summoner_id: u32, -) -> Vec { +) -> sqlx::Result> { let rows = sqlx::query( "SELECT CAST(id AS UNSIGNED) AS id, CAST(template_id AS UNSIGNED) AS template_id, \ CAST(attach_point AS SIGNED) AS attach_point, name, CAST(hp AS SIGNED) AS hp, \ @@ -1937,35 +2335,19 @@ async fn load_saved_children( .bind(parent_db_id) .bind(summoner_id) .fetch_all(&server.db) - .await; - match rows { - Ok(rows) => rows - .into_iter() - .filter_map(|r| { - Some(SavedChildSlave { - id: r.try_get::("id").ok()? as u32, - template_id: r - .try_get::, _>("template_id") - .ok()? - .unwrap_or(0) as u32, - attach_point: r - .try_get::, _>("attach_point") - .ok()? - .unwrap_or(0) as u8, - name: r - .try_get::, _>("name") - .ok()? - .unwrap_or_default(), - hp: r.try_get::, _>("hp").ok()?.unwrap_or(0) as i32, - mp: r.try_get::, _>("mp").ok()?.unwrap_or(0) as i32, - }) + .await?; + rows.into_iter() + .map(|r| { + Ok(SavedChildSlave { + id: r.try_get::("id")? as u32, + template_id: r.try_get::, _>("template_id")?.unwrap_or(0) as u32, + attach_point: r.try_get::, _>("attach_point")?.unwrap_or(0) as u8, + name: r.try_get::, _>("name")?.unwrap_or_default(), + hp: r.try_get::, _>("hp")?.unwrap_or(0) as i32, + mp: r.try_get::, _>("mp")?.unwrap_or(0) as i32, }) - .collect(), - Err(e) => { - tracing::error!("load saved child slaves: {e}"); - Vec::new() - } - } + }) + .collect() } /// `ApplySlaveBonuses(summonedSlave)`. @@ -2261,11 +2643,11 @@ pub(crate) fn create_spawn( if it.class == ItemClass::SummonSlave { let now = chrono::Utc::now().timestamp(); let res = super::mates::update_owned_item(server, Some(o), it.id, |i| { - i.details.slave_type = 0x02; - i.details.slave_db_id = db_id; if let Some(left) = repair_seconds_left(i, now) { return Err(left as f64); } + i.details.slave_type = 0x02; + i.details.slave_db_id = db_id; // SummonLocation (not part of the 1.2 detail bytes); RepairStartTime = MinValue i.details.slave_repair_start_time = 0; i.dirty = true; @@ -3239,6 +3621,9 @@ pub fn send_my_slave_packet_to_all_owners(server: &GameServer) { let obj = WorldObject::from(&slave); let (summoner, p) = { let d = slave.data(); + if d.owner_type != BaseUnitType::Character { + continue; + } ( d.summoner_obj_id, ( @@ -3368,23 +3753,22 @@ pub fn save(server: &GameServer, slave: &SlaveRef) { if slave.data().summoning_item_id == 0 { return; } - let rows = snapshot(server, slave); + let rows = server + .systems + .vehicles + .slave_summons + .queue_save(server, slave); if rows.is_empty() { return; } - let db = server.db.clone(); + let item_id = rows[0].item_id; + let Some(server) = server.self_arc() else { + return; + }; let fut = async move { - let mut conn = match db.acquire().await { - Ok(c) => c, - Err(e) => { - tracing::error!("Slave.Save: {e}"); - return; - } - }; - for r in &rows { - if let Err(e) = write_row(&mut conn, r).await { - tracing::error!("Slave.Save: {e}"); - } + let _transaction = server.save.transaction_lock().await; + if let Err(e) = flush_pending_save(&server, item_id).await { + tracing::error!("Slave.Save: {e}"); } }; if let Ok(rt) = tokio::runtime::Handle::try_current() { @@ -3392,6 +3776,38 @@ pub fn save(server: &GameServer, slave: &SlaveRef) { } } +/// Caller owns SaveManager's transaction lock. A failed write stays queued for retry; a +/// later summon must flush it before SELECT, never interpret an unfinished save as absence. +async fn flush_pending_save(server: &GameServer, item_id: u64) -> sqlx::Result<()> { + let pending = &server.systems.vehicles.slave_summons.pending_saves; + loop { + let rows = pending + .lock() + .expect("slave saves poisoned") + .get(&item_id) + .cloned(); + let Some(rows) = rows else { return Ok(()) }; + let mut tx = server.db.begin().await?; + for row in rows.iter() { + write_row(&mut tx, row).await?; + } + tx.commit().await?; + let flushed = { + let mut pending = pending.lock().expect("slave saves poisoned"); + let current = pending + .get(&item_id) + .is_some_and(|current| Arc::ptr_eq(current, &rows)); + if current { + pending.remove(&item_id); + } + current + }; + if flushed { + return Ok(()); + } + } +} + /// The `SaveManager.DoSave` slave part: `slave.Save(connection, transaction)` for every slave /// of every world (children are written again by their parent, as in C#). Returns the number /// of slaves saved. @@ -3402,7 +3818,11 @@ pub async fn save_all( let mut n = 0; for world in server.world.worlds() { for slave in all_slaves(&world) { - let rows = snapshot(server, &slave); + let rows = server + .systems + .vehicles + .slave_summons + .queue_save(server, &slave); if rows.is_empty() { continue; } @@ -3433,15 +3853,23 @@ pub async fn on_delete_slave_item( if slave_db_id == 0 { return false; } - if let Some(world) = player_world(server, owner) { - if let Some(s) = get_slave_by_db_id(&world, slave_db_id) { - let summoner = s.data().summoner_obj_id; - if let Some(p) = server.world.character_by_obj_id(summoner) { - let tl = s.data().unit.tl_id; - remove_active_slave(server, &p, tl, true); - } + let summons = &server.systems.vehicles.slave_summons; + let _owner = summons + .reservation(SummonKey::Owner(owner.character_id)) + .lock_owned() + .await; + for (world, slave) in owned_roots(server, owner.character_id) { + if slave.data().id == slave_db_id { + delete(server, Some(owner), world.id, slave.obj_id, true); } } + // Queued fire-and-forget saves must not resurrect the row after item destruction. + let _transaction = server.save.transaction_lock().await; + summons + .pending_saves + .lock() + .expect("slave saves poisoned") + .retain(|_, rows| rows.first().is_none_or(|row| row.id != slave_db_id)); let mut conn = match server.db.acquire().await { Ok(c) => c, Err(e) => { From 395386180a9b99d0e8518cb590892d343bd13aaf Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 17:59:50 -0400 Subject: [PATCH 38/66] test(game): initialize live combat fixtures and pin immune bytes --- .../src/systems/economy/fishing/tests.rs | 25 ++++++------------- .../src/systems/skills/buff_breaker_tests.rs | 6 +++++ .../systems/skills/cooldown_tag_flow_tests.rs | 2 ++ .../skills/effects/damage_pipeline_tests.rs | 3 ++- 4 files changed, 17 insertions(+), 19 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/economy/fishing/tests.rs b/rust/crates/aaemu-game/src/systems/economy/fishing/tests.rs index d10a111a4d..ddc6de1880 100644 --- a/rust/crates/aaemu-game/src/systems/economy/fishing/tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/fishing/tests.rs @@ -180,10 +180,7 @@ impl FishDamageFixture { #[tokio::test] async fn fish_creator_blocks_foreign_ordinary_siege_damage() { - use crate::systems::skills::packets::SCUnitDamagedPacket; - use crate::systems::skills::types::{CastAction, SkillCaster, SkillHitType}; use crate::systems::skills::{buffs, types::DamageType}; - use aaemu_commons::PacketStream; let mut f = FishDamageFixture::new(); let original = f.fish.data().unit.buffs.effects[0].clone(); assert_eq!(original.caster_obj_id, f.fish.obj_id); @@ -212,20 +209,12 @@ async fn fish_creator_blocks_foreign_ordinary_siege_damage() { assert_eq!(f.fish.data().unit.skill_state.aggro_table, aggro); assert_eq!(f.foreign.data().unit.summarize_damage, 0); assert_eq!(f.fish.data().unit.buffs.effects[0], original); - let mut immune = SCUnitDamagedPacket::new( - CastAction::Skill { - skill_id: 91000, - tl_id: 0, - }, - SkillCaster::Unit(f.foreign.obj_id), - f.foreign.obj_id, - f.fish.obj_id, - 1, - 0, - ); - immune.hit_type = SkillHitType::Immune; - let mut expected = PacketStream::new(); - expected.write(&immune); + // Native 1.2 damage reader 397C8760: skill 91000, unit caster 0x720, + // target 0x730, zero damage/healing, Immune flags. Immunity never reports 1 HP. + let expected = vec![ + 0, 120, 99, 1, 0, 0, 0, 0, 32, 7, 0, 32, 7, 0, 48, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, + 1, 1, 1, + ]; let frames = f.foreign_client.drain(); assert_eq!( frames @@ -240,7 +229,7 @@ async fn fish_creator_blocks_foreign_ordinary_siege_damage() { .find(|p| p.0 == sc::SCUnitDamagedPacket) .unwrap() .1, - expected.into_bytes(), + expected, ); // A valid fishing skill tag still cannot override a different creator. f.damage_with_skill(&foreign, 3, Some(21196)); diff --git a/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs b/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs index 135983a42f..ec1efef273 100644 --- a/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs @@ -845,6 +845,12 @@ async fn buff_breakers_started_trigger_cc_cleans_npc_controller_and_timer_paths( #[tokio::test] async fn buff_breakers_started_self_dispel_finishes_even_without_a_breaker_relation() { let mut d = reentrant_data(); + // An unknown faction is attackable even against itself, so a friendly self-cure + // needs the same known faction as a live character. + d.factions.add(crate::data::world_data::SystemFaction { + id: 101, + ..Default::default() + }); d.systems.skills.buff_breakers.clear(); d.systems.skills.buff_triggers.clear(); // Also cover the permanent/non-ticking start branch, which must not turn a deferred diff --git a/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs b/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs index f1cb462773..08efeae598 100644 --- a/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs @@ -284,7 +284,9 @@ async fn food_glider_zero_duration_members_and_players_have_independent_groups() .contains_key(&UNTAGGED)); let mut other = TestClient::new(&server, 2, 2); let mut c = test_character(2, "Other", 100.0, 100.0); + c.unit.hp = 1000; c.unit.mp = 100; + c.unit.max_mp = 1000; let other_player = spawn_player(&server, &other, c, 0x101); other.conn.active_char = Some(other_player.clone()); other.drain(); diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs b/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs index 33df075cea..9588ae5f01 100644 --- a/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs @@ -24,7 +24,8 @@ use super::*; fn fixture_data() -> GameData { let mut data = GameData::empty(); data.formulas = crate::systems::vehicles::stats::tests::formulas( - &[(1, "100000", 14, 5), (2, "1000", 15, 5), (3, "100", 12, 5)], + // Character formulas use owner 0; owner 5 belongs to mates. + &[(1, "100000", 14, 0), (2, "1000", 15, 0), (3, "100", 12, 0)], &[], ); for id in [3, 4] { From 5dfd7282b71ec84655b44b861b24991502dd5ff2 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:00:15 -0400 Subject: [PATCH 39/66] test(combat): populate cached health before theft checks --- .../src/systems/skills/effects/damage_pipeline_tests.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs b/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs index 9588ae5f01..c57895d552 100644 --- a/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs @@ -517,6 +517,8 @@ async fn damage_pipeline_extreme_and_negative_inputs_never_heal_or_wrap() { for amount in [i32::MIN, i32::MAX] { let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(fixture_data()); + // Health theft clamps to the cached pool, populated during normal stat refresh. + skills::stats::refresh_cached_stats(&server, &WorldObject::from(&player)); player.data().unit.summarize_damage = i32::MAX; player.data().unit.hp = 50; let mut effect = skills::tests::damage_effect(1, amount); From a0a62dbf37d50c08d76e2cef06c4d02f359cbaee Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:02:45 -0400 Subject: [PATCH 40/66] fix(economy): retain cargo during ambiguous doodad cleanup Preserve cargo items through both spawned and saved-row cleanup hooks because synchronous cleanup cannot rule out unloaded rack references. Avoid world scans for ordinary items and document deferred orphan reconciliation. Require cached child allocation identity, current parent and instance before blocking cargo repair. Add production-hook preservation and replay regressions, ordinary-item cleanup coverage, reused child ID coverage, and a private MySQL regression that reloads an unspawned surviving rack after either deletion route. Co-Authored-By: Codex --- .../aaemu-game/src/systems/economy/bridges.rs | 69 +++-- .../src/systems/economy/cargo_flow_tests.rs | 246 +++++++++++++++++- .../aaemu-game/src/systems/npcs/hooks.rs | 7 +- 3 files changed, 299 insertions(+), 23 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/economy/bridges.rs b/rust/crates/aaemu-game/src/systems/economy/bridges.rs index 311e4f9519..5d74d21350 100644 --- a/rust/crates/aaemu-game/src/systems/economy/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/economy/bridges.rs @@ -2731,24 +2731,8 @@ impl crate::systems::npcs::hooks::EconomyBridge for EconomyForNpcs { fn remove_expired_doodad_item(&self, server: &GameServer, item_id: u64) { let mut txn = ItemTxn::begin(server); - // A duplicate rack can share the same escrow reference. Removing that duplicate must - // not destroy the sole pack still represented by another live doodad. - for world in server.world.worlds() { - for doodad in world.all_doodads() { - let protects_item = { - let d = doodad.data(); - !d.phase.deleted && d.item_id == item_id - }; - if protects_item { - crate::systems::npcs::doodad::funcs::items::warn_item_reference( - server, - &doodad, - item_id, - "preserved item referenced by another live doodad during cleanup", - ); - return; - } - } + if preserve_cargo_on_doodad_delete(server, item_id) { + return; } let Some(c) = server.items.holding_container(item_id) else { return; @@ -2760,6 +2744,12 @@ impl crate::systems::npcs::hooks::EconomyBridge for EconomyForNpcs { } fn release_deleted_doodad_items(&self, server: &GameServer, item_id: u64, container_id: u64) { + let _operation = ItemTxn::begin(server); + if preserve_cargo_on_doodad_delete(server, item_id) { + // Do not forget a referenced item's holding container either. Cargo racks normally + // have no attached container; ambiguous legacy rows are preserved conservatively. + return; + } // item._holdingContainer = null; itemManager.ReleaseId(item.Id) if item_id != 0 && server.items.item_by_id(item_id).is_some() { if let Some(c) = server.items.holding_container(item_id) { @@ -2786,6 +2776,40 @@ impl crate::systems::npcs::hooks::EconomyBridge for EconomyForNpcs { } } +/// These synchronous deletion hooks cannot rule out references in unloaded `doodads` rows. +/// Retain cargo instead of releasing its sole item or queuing its row for deletion. This also +/// protects packs already picked up from a stale rack. No world scan or DB await is needed. +/// Known gliders/toy flags and ordinary doodad items keep their existing cleanup policy. +/// A separate reconciliation/GC operation must establish that retained cargo is unreferenced; +/// this fallback intentionally does not collect cargo orphaned by removal of its last rack. +fn preserve_cargo_on_doodad_delete(server: &GameServer, item_id: u64) -> bool { + if item_id == 0 { + return false; + } + let Some(item) = server.items.item_by_id(item_id) else { + return false; + }; + let cargo = match server + .game_data + .items + .template(item.template_id) + .map(|t| &t.kind) + { + Some(TemplateKind::Backpack { backpack_type }) => !matches!( + *backpack_type, + crate::data::items::backpack_type::GLIDER | crate::data::items::backpack_type::TOY_FLAG + ), + None => item.class == ItemClass::Backpack, + _ => false, + }; + if cargo { + tracing::warn!(item_id, item_template_id = item.template_id, + item_slot_type = item.slot_type, + "Retained doodad cargo item: unloaded persistent references have not been ruled out; orphan cleanup deferred"); + } + cargo +} + /// A live cargo attachment, plus whether its persistent authored binding proves it safe to /// repair. Nonpersistent or equipment-created racks can recover normally but are not repaired. fn cargo_attachment(server: &GameServer, rack: &DoodadRef) -> Option { @@ -2842,8 +2866,13 @@ fn cargo_attachment(server: &GameServer, rack: &DoodadRef) -> Option { Some( repairable && !rack.core().children().iter().any(|child| { - child.transform().parent_obj_id == rack.obj_id - && world.object(child.obj_id()).is_some() + world.object(child.obj_id()).is_some_and(|live| { + // ObjectCore belongs to the immutable Arc allocation, not its recycled id. + std::ptr::eq(child.core(), live.core()) && { + let transform = live.transform(); + transform.parent_obj_id == rack.obj_id && transform.instance_id == instance + } + }) }), ) } diff --git a/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs b/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs index 505cc43d3a..2ff25c241b 100644 --- a/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs @@ -158,6 +158,10 @@ struct CargoWorld { } fn world(data: GameData) -> CargoWorld { + world_with_pool(data, None) +} + +fn world_with_pool(data: GameData, pool: Option) -> CargoWorld { let bindings = data .systems .vehicles @@ -169,7 +173,11 @@ fn world(data: GameData) -> CargoWorld { .cloned() .collect::>(); assert_eq!(bindings.len(), 20); - let server = Arc::new(test_server_with(data)); + let mut server = test_server_with(data); + if let Some(pool) = pool { + server.db = pool; + } + let server = Arc::new(server); super::install(&server); let mut a = TestClient::new(&server, 1, 1001); let mut b = TestClient::new(&server, 2, 1002); @@ -549,6 +557,68 @@ async fn duplicate_cleanup_preserves_the_sole_pack_for_the_surviving_rack() { assert_eq!(equipped(&c).id, id); } +#[tokio::test] +async fn both_cleanup_hooks_retain_cargo_without_any_spawned_reference() { + for persisted_row_route in [false, true] { + let c = world(authored_data()); + let id = give(&c.w, &c.w.pa, slot_type::SYSTEM, PACK, 1, -1); + assert!(c + .w + .server + .world + .world(0) + .unwrap() + .all_doodads() + .iter() + .all(|d| d.data().item_id != id)); + if persisted_row_route { + EconomyForNpcs.release_deleted_doodad_items(&c.w.server, id, 0); + } else { + EconomyForNpcs.remove_expired_doodad_item(&c.w.server, id); + } + assert!(!c.w.server.items.removed_items().contains(&id)); + assert_eq!( + c.w.server.items.item_by_id(id).unwrap().slot_type, + slot_type::SYSTEM + ); + // Model the surviving saved rack becoming available after cleanup. + { + let mut survivor = c.racks[0].data(); + survivor.item_id = id; + survivor.item_template_id = PACK; + } + phase::set_func_group_id(&c.w.server, &c.racks[0], LOADED); + use_rack(&c, 0, RECOVER_SKILL); + assert_eq!(equipped(&c).id, id); + assert!(!c.w.server.items.removed_items().contains(&id)); + // Replayed cleanup of the stale alias cannot delete the pack after its recovery either. + if persisted_row_route { + EconomyForNpcs.release_deleted_doodad_items(&c.w.server, id, 0); + } else { + EconomyForNpcs.remove_expired_doodad_item(&c.w.server, id); + } + assert_eq!(equipped(&c).id, id); + assert!(!c.w.server.items.removed_items().contains(&id)); + } +} + +#[tokio::test] +async fn cargo_preservation_does_not_disable_ordinary_item_or_glider_cleanup() { + for persisted_row_route in [false, true] { + for template in [SINGLE, GLIDER] { + let c = world(authored_data()); + let id = give(&c.w, &c.w.pa, slot_type::SYSTEM, template, 1, -1); + if persisted_row_route { + EconomyForNpcs.release_deleted_doodad_items(&c.w.server, id, 0); + } else { + EconomyForNpcs.remove_expired_doodad_item(&c.w.server, id); + } + assert!(c.w.server.items.item_by_id(id).is_none()); + assert!(c.w.server.items.removed_items().contains(&id)); + } + } +} + #[tokio::test] async fn dangling_rack_repair_does_not_move_another_players_pack_or_create_one() { let mut c = world(authored_data()); @@ -676,6 +746,180 @@ async fn removal_ignores_stale_children_but_blocks_a_live_persistent_child() { assert!(interactions::doodad_allow_removal(&c.w.server, &c.racks[1])); } +#[tokio::test] +async fn dangling_cargo_repair_requires_live_child_identity_not_a_reused_id() { + let c = world(authored_data()); + let missing_item = 9_000_000; + { + let mut rack = c.racks[0].data(); + rack.item_id = missing_item; + rack.item_template_id = PACK; + } + phase::set_func_group_id(&c.w.server, &c.racks[0], LOADED); + let instance = c.w.server.world.world(0).unwrap(); + let mut data = Doodad::new(RACK); + data.is_persistent = true; + let child = Entity::new(0x900, data); + instance.spawn(&child, &c.w.server.view_ctx()); + instance.attach_child(&WorldObject::from(&c.racks[0]), &WorldObject::from(&child)); + use_rack(&c, 0, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[0]), (LOADED, missing_item, PACK)); + // The cached child retains its old parent, but this live allocation with its id is unrelated. + instance.remove_object(child.obj_id); + let unrelated = Entity::new(child.obj_id, Doodad::new(RACK)); + instance.spawn(&unrelated, &c.w.server.view_ctx()); + use_rack(&c, 0, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[0]), (EMPTY, 0, 0)); + assert!(Arc::ptr_eq( + &instance.doodad(unrelated.obj_id).unwrap(), + &unrelated + )); + assert!(c.w.server.items.item_by_id(missing_item).is_none()); + assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); +} + +#[tokio::test] +#[ignore = "private MySQL3317 via AAEMU_TEST_MYSQL; connection-local temporary doodads table"] +async fn private_mysql_saved_offline_rack_alias_survives_both_cleanup_routes() { + use crate::systems::npcs::doodad::db; + use sqlx::mysql::{MySqlConnectOptions, MySqlPoolOptions}; + 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) + .idle_timeout(None) + .max_lifetime(None) + .connect_with(options) + .await + .unwrap(); + let (_, ddl): (String, String) = sqlx::query_as("SHOW CREATE TABLE doodads") + .fetch_one(&pool) + .await + .unwrap(); + sqlx::query(&ddl.replacen("CREATE TABLE", "CREATE TEMPORARY TABLE", 1)) + .execute(&pool) + .await + .unwrap(); + + for persisted_row_route in [false, true] { + // `doodads` is the connection-local temporary table created above. + sqlx::query("DELETE FROM doodads") + .execute(&pool) + .await + .unwrap(); + let c = world_with_pool(authored_data(), Some(pool.clone())); + let item_id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 0, STORE_SKILL); + { + let mut survivor = c.racks[1].data(); + survivor.item_id = item_id; + survivor.item_template_id = PACK; + } + phase::set_func_group_id(&c.w.server, &c.racks[1], LOADED); + c.w.server + .systems + .npcs + .doodads + .persistence + .flush() + .await + .unwrap(); + let deleted_id = c.racks[0].data().db_id; + let survivor_id = c.racks[1].data().db_id; + let aliases: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM doodads WHERE item_id = ?") + .bind(item_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(aliases, 2); + let instance = c.w.server.world.world(0).unwrap(); + // Unload the surviving object without deleting its saved row or its escrow item. + instance.delete(&c.racks[1]); + if persisted_row_route { + instance.delete(&c.racks[0]); + let mut connection = pool.acquire().await.unwrap(); + assert!( + db::delete_doodad_by_id(&c.w.server, &mut connection, deleted_id) + .await + .unwrap() + ); + } else { + manager::delete(&c.w.server, &instance, &c.racks[0]); + } + c.w.server + .systems + .npcs + .doodads + .persistence + .flush() + .await + .unwrap(); + assert!(instance + .all_doodads() + .iter() + .all(|d| d.data().item_id != item_id)); + assert_eq!( + c.w.server.items.item_by_id(item_id).unwrap().slot_type, + slot_type::SYSTEM + ); + assert!(!c.w.server.items.removed_items().contains(&item_id)); + let survivors: Vec = + sqlx::query_scalar("SELECT CAST(id AS UNSIGNED) FROM doodads WHERE item_id = ?") + .bind(item_id) + .fetch_all(&pool) + .await + .unwrap(); + assert_eq!(survivors, vec![u64::from(survivor_id)]); + let spawns = c.w.server.systems.npcs.spawns.get_or_create(&instance); + assert_eq!( + spawns + .spawn_persistent_doodads( + &c.w.server, + doodad_owner_type::SLAVE, + 700, + Some(&WorldObject::from(&c.hull)), + true + ) + .await + .unwrap(), + 1 + ); + let restored = instance.doodad_by_db_id(survivor_id).unwrap(); + assert!(interactions::execute_interaction( + &c.w.server, + interactions::world_interaction_type::USE, + &WorldObject::from(&c.w.pa), + Some(&WorldObject::from(&restored)), + RECOVER_SKILL, + 0, + None + )); + assert_eq!(equipped(&c).id, item_id); + assert!(!c.w.server.items.removed_items().contains(&item_id)); + c.w.server + .systems + .npcs + .doodads + .persistence + .flush() + .await + .unwrap(); + } +} + #[tokio::test] #[ignore = "needs AAEMU_COMPACT_DB"] async fn real_compact_merchant_all_twenty_racks_survive_shuffled_cycles() { diff --git a/rust/crates/aaemu-game/src/systems/npcs/hooks.rs b/rust/crates/aaemu-game/src/systems/npcs/hooks.rs index ee621caec8..7584b27f05 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/hooks.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/hooks.rs @@ -651,11 +651,14 @@ pub trait EconomyBridge: Send + Sync { } /// `Doodad.Delete()` item cleanup: `GetItemByItemId(itemId)` held by a `None` / `System` - /// container -> `RemoveItem(Invalid, item, true)`. Default: nothing. + /// container -> `RemoveItem(Invalid, item, true)`. Cargo must be retained when unloaded + /// persistent references cannot be ruled out; collection of such orphans is deferred. + /// Default: nothing. fn remove_expired_doodad_item(&self, _server: &GameServer, _item_id: u64) {} /// `DeleteDoodadById` item part: the attached item loses its container and its id is - /// released; the attached container is deleted. Default: nothing. + /// released; the attached container is deleted. Cargo with unproven unloaded references + /// is conservatively retained, including an ambiguous attached container. Default: nothing. fn release_deleted_doodad_items( &self, _server: &GameServer, From 8c2e977b5ba6b7660e4739964465e0b1e97b9d7b Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:14:01 -0400 Subject: [PATCH 41/66] fix(economy): validate doodad escrow before releasing item IDs Carry original doodad owner and template context through live and saved-row cleanup. Retain rack-origin references after GUID reuse, require matching ordinary owned System escrow for item disposal, guard deletion against changed row references, and defer all container cleanup without allocation provenance. Add allocator-reuse regressions for foreign ordinary items, gliders and container IDs through saved-row deletion, with release-observer and pending-deletion assertions plus a legitimate furniture escrow control. Co-Authored-By: Codex --- .../aaemu-game/src/systems/economy/bridges.rs | 164 ++++++---- .../src/systems/economy/cargo_flow_tests.rs | 292 ++++++++++++++++-- .../aaemu-game/src/systems/npcs/doodad/db.rs | 45 ++- .../src/systems/npcs/doodad/manager.rs | 20 +- .../aaemu-game/src/systems/npcs/hooks.rs | 36 ++- 5 files changed, 440 insertions(+), 117 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/economy/bridges.rs b/rust/crates/aaemu-game/src/systems/economy/bridges.rs index 5d74d21350..98d89aa7aa 100644 --- a/rust/crates/aaemu-game/src/systems/economy/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/economy/bridges.rs @@ -2729,85 +2729,119 @@ impl crate::systems::npcs::hooks::EconomyBridge for EconomyForNpcs { true } - fn remove_expired_doodad_item(&self, server: &GameServer, item_id: u64) { + fn remove_expired_doodad_item( + &self, + server: &GameServer, + source: crate::systems::npcs::hooks::DoodadItemCleanup, + ) { let mut txn = ItemTxn::begin(server); - if preserve_cargo_on_doodad_delete(server, item_id) { - return; - } - let Some(c) = server.items.holding_container(item_id) else { - return; - }; - let mut g = lock(&c); - if matches!(g.slot_type, slot_type::NONE | slot_type::SYSTEM) { - g.remove_item_task(task_type::INVALID, item_id, true, &mut txn.env); - } + cleanup_doodad_escrow_item(&mut txn, source); } - fn release_deleted_doodad_items(&self, server: &GameServer, item_id: u64, container_id: u64) { - let _operation = ItemTxn::begin(server); - if preserve_cargo_on_doodad_delete(server, item_id) { - // Do not forget a referenced item's holding container either. Cargo racks normally - // have no attached container; ambiguous legacy rows are preserved conservatively. - return; - } - // item._holdingContainer = null; itemManager.ReleaseId(item.Id) - if item_id != 0 && server.items.item_by_id(item_id).is_some() { - if let Some(c) = server.items.holding_container(item_id) { - lock(&c).remove_item(item_id); - } - server.items.release_id(item_id, &server.ids.item); - } - // itemManager.DeleteItemContainer(container) - if container_id != 0 && server.items.forget_container(container_id) { - if let Ok(rt) = tokio::runtime::Handle::try_current() { - let pool = server.db.clone(); - rt.spawn(async move { - if let Err(e) = crate::managers::item::ItemManager::delete_container_row( - &pool, - container_id, - ) - .await - { - tracing::error!("DeleteItemContainer {container_id}: {e}"); - } - }); - } + fn release_deleted_doodad_items( + &self, + server: &GameServer, + source: crate::systems::npcs::hooks::DoodadItemCleanup, + ) { + let mut txn = ItemTxn::begin(server); + cleanup_doodad_escrow_item(&mut txn, source); + if source.container_id != 0 { + // A coffer's container has no immutable doodad/generation association. Even an + // empty container with a matching owner may be a reused allocation; retain it. + tracing::warn!(?source, "Retained doodad container: allocation provenance unavailable; reconciliation deferred"); } } } -/// These synchronous deletion hooks cannot rule out references in unloaded `doodads` rows. -/// Retain cargo instead of releasing its sole item or queuing its row for deletion. This also -/// protects packs already picked up from a stale rack. No world scan or DB await is needed. -/// Known gliders/toy flags and ordinary doodad items keep their existing cleanup policy. -/// A separate reconciliation/GC operation must establish that retained cargo is unreferenced; -/// this fallback intentionally does not collect cargo orphaned by removal of its last rack. -fn preserve_cargo_on_doodad_delete(server: &GameServer, item_id: u64) -> bool { - if item_id == 0 { - return false; - } - let Some(item) = server.items.item_by_id(item_id) else { - return false; - }; - let cargo = match server - .game_data - .items - .template(item.template_id) - .map(|t| &t.kind) - { +/// Original rack references cannot authorize destruction after GUID reuse, regardless of the +/// current item's class. Other doodads may remove only a unique, matching singleton in their +/// original character owner's System escrow. Bag/equipment/bank, loose, foreign and mismatched +/// items are retained. These checks establish escrow authority, not an allocation generation. +/// Cargo/ambiguous item references and all saved container references still need reconciliation; +/// these synchronous hooks do not prove absence of unloaded aliases or collect those orphans. +fn cleanup_doodad_escrow_item( + txn: &mut ItemTxn<'_>, + source: crate::systems::npcs::hooks::DoodadItemCleanup, +) { + use crate::models::doodad::doodad_owner_type; + + let server = txn.server; + if source.item_id == 0 { + return; + } + let doodads = &server.game_data.systems.npcs.doodad; + let rack = doodads + .doodad_func_groups(source.doodad_template_id) + .iter() + .any(|group| { + doodads + .funcs_for_group(group.id) + .iter() + .any(|f| f.func_type == "DoodadFuncConsumeChanger") + }); + let template = server.game_data.items.template(source.item_template_id); + let cargo = match template.map(|t| &t.kind) { Some(TemplateKind::Backpack { backpack_type }) => !matches!( *backpack_type, crate::data::items::backpack_type::GLIDER | crate::data::items::backpack_type::TOY_FLAG ), - None => item.class == ItemClass::Backpack, _ => false, }; - if cargo { - tracing::warn!(item_id, item_template_id = item.template_id, - item_slot_type = item.slot_type, - "Retained doodad cargo item: unloaded persistent references have not been ruled out; orphan cleanup deferred"); + if rack + || cargo + || source.owner_type == doodad_owner_type::SLAVE + || !matches!( + source.owner_type, + doodad_owner_type::CHARACTER | doodad_owner_type::HOUSING + ) + || source.owner_id == 0 + || source.item_template_id == 0 + || !doodads.templates.contains_key(&source.doodad_template_id) + || !template.is_some_and(|t| t.max_count == 1) + { + tracing::warn!(?source, "Retained doodad item: original escrow authority is ambiguous or cargo-origin; reconciliation deferred"); + return; + } + let copies: usize = server + .items + .all_containers() + .iter() + .map(|c| { + lock(c) + .items + .iter() + .filter(|i| i.id == source.item_id) + .count() + }) + .sum(); + if copies != 1 { + return; + } + let Some(container) = server.items.holding_container(source.item_id) else { + return; + }; + let mut container = lock(&container); + let matches = container.slot_type == slot_type::SYSTEM + && container.owner_id == source.owner_id + && container + .get_item_by_id(source.item_id) + .is_some_and(|item| { + item.slot_type == slot_type::SYSTEM + && item.owner_id == u64::from(source.owner_id) + && item.template_id == source.item_template_id + && item.count == 1 + }); + if matches { + container.remove_item_task(task_type::INVALID, source.item_id, true, &mut txn.env); + } else { + tracing::warn!( + ?source, + actual_container_id = container.container_id, + actual_container_owner = container.owner_id, + actual_slot_type = container.slot_type, + "Retained doodad item: current holder does not match original owned System escrow" + ); } - cargo } /// A live cargo attachment, plus whether its persistent authored binding proves it safe to diff --git a/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs b/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs index 2ff25c241b..ef0a8016db 100644 --- a/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs @@ -16,7 +16,7 @@ use crate::systems::economy::tests::{give, test_data, World, SINGLE}; use crate::systems::npcs::doodad::runtime::DoodadCtx; use crate::systems::npcs::doodad::templates::*; use crate::systems::npcs::doodad::{funcs::items, interactions, manager, phase}; -use crate::systems::npcs::hooks::EconomyBridge; +use crate::systems::npcs::hooks::{DoodadItemCleanup, EconomyBridge}; use crate::systems::vehicles::data::{SlaveDoodadBinding, SlaveTemplate}; use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; use crate::world::{DoodadRef, Entity, SlaveRef, WorldObject}; @@ -31,6 +31,7 @@ const STORE_SKILL: u32 = 15307; const RECOVER_SKILL: u32 = 15309; const PACK: u32 = 18469; const GLIDER: u32 = 99991; +const FURNITURE: u32 = 60000; fn authored_data() -> GameData { let mut data = test_data(); @@ -60,6 +61,13 @@ fn authored_data() -> GameData { }, ]; let doodads = &mut data.systems.npcs.doodad; + doodads.templates.insert( + FURNITURE, + DoodadTemplate { + id: FURNITURE, + ..Default::default() + }, + ); doodads.templates.insert( RACK, DoodadTemplate { @@ -264,6 +272,21 @@ fn cargo_state(rack: &DoodadRef) -> (u32, u64, u32) { (d.func_group_id, d.item_id, d.item_template_id) } +fn cleanup_source(item_id: u64, template: u32) -> DoodadItemCleanup { + DoodadItemCleanup { + doodad_template_id: if template == PACK { RACK } else { FURNITURE }, + owner_id: 1, + owner_type: if template == PACK { + doodad_owner_type::SLAVE + } else { + doodad_owner_type::CHARACTER + }, + item_id, + item_template_id: template, + ..Default::default() + } +} + fn repeated_cycles(c: &mut CargoWorld) { let ids: Vec<_> = (0..20) .map(|_| { @@ -572,9 +595,9 @@ async fn both_cleanup_hooks_retain_cargo_without_any_spawned_reference() { .iter() .all(|d| d.data().item_id != id)); if persisted_row_route { - EconomyForNpcs.release_deleted_doodad_items(&c.w.server, id, 0); + EconomyForNpcs.release_deleted_doodad_items(&c.w.server, cleanup_source(id, PACK)); } else { - EconomyForNpcs.remove_expired_doodad_item(&c.w.server, id); + EconomyForNpcs.remove_expired_doodad_item(&c.w.server, cleanup_source(id, PACK)); } assert!(!c.w.server.items.removed_items().contains(&id)); assert_eq!( @@ -593,9 +616,9 @@ async fn both_cleanup_hooks_retain_cargo_without_any_spawned_reference() { assert!(!c.w.server.items.removed_items().contains(&id)); // Replayed cleanup of the stale alias cannot delete the pack after its recovery either. if persisted_row_route { - EconomyForNpcs.release_deleted_doodad_items(&c.w.server, id, 0); + EconomyForNpcs.release_deleted_doodad_items(&c.w.server, cleanup_source(id, PACK)); } else { - EconomyForNpcs.remove_expired_doodad_item(&c.w.server, id); + EconomyForNpcs.remove_expired_doodad_item(&c.w.server, cleanup_source(id, PACK)); } assert_eq!(equipped(&c).id, id); assert!(!c.w.server.items.removed_items().contains(&id)); @@ -609,9 +632,11 @@ async fn cargo_preservation_does_not_disable_ordinary_item_or_glider_cleanup() { let c = world(authored_data()); let id = give(&c.w, &c.w.pa, slot_type::SYSTEM, template, 1, -1); if persisted_row_route { - EconomyForNpcs.release_deleted_doodad_items(&c.w.server, id, 0); + EconomyForNpcs + .release_deleted_doodad_items(&c.w.server, cleanup_source(id, template)); } else { - EconomyForNpcs.remove_expired_doodad_item(&c.w.server, id); + EconomyForNpcs + .remove_expired_doodad_item(&c.w.server, cleanup_source(id, template)); } assert!(c.w.server.items.item_by_id(id).is_none()); assert!(c.w.server.items.removed_items().contains(&id)); @@ -619,6 +644,75 @@ async fn cargo_preservation_does_not_disable_ordinary_item_or_glider_cleanup() { } } +fn recycle_pack_guid(c: &CargoWorld, id: u64, template: u32, slot_type: u8, slot: i32) { + { + let mut txn = ItemTxn::begin(&c.w.server); + let system = Inv::of(&c.w.pa) + .get(crate::models::container::slot_type::SYSTEM) + .unwrap(); + assert!(system + .lock() + .unwrap() + .remove_item_task(task_type::INVALID, id, true, &mut txn.env) + .is_some()); + } + assert_eq!( + give(&c.w, &c.w.pb, slot_type, template, 1, slot), + id, + "exercise actual allocator reuse, not just a stale item snapshot" + ); + assert!(!c.w.server.items.removed_items().contains(&id)); +} + +fn record_item_releases(c: &CargoWorld) -> Arc>> { + let releases = Arc::new(std::sync::Mutex::new(Vec::new())); + let observed = releases.clone(); + c.w.server + .ids + .item + .install_release_hook(move |id| observed.lock().unwrap().push(id)); + releases +} + +#[tokio::test] +async fn both_cleanup_hooks_reject_recycled_foreign_items_and_unrelated_containers() { + for (template, target, slot) in [ + (SINGLE, slot_type::INVENTORY, 0), + (SINGLE, slot_type::BANK, 0), + (SINGLE, slot_type::SYSTEM, -1), + (GLIDER, slot_type::EQUIPMENT, equip_slot::BACKPACK), + ] { + let c = world(authored_data()); + let releases = record_item_releases(&c); + let id = give(&c.w, &c.w.pa, slot_type::SYSTEM, PACK, 1, -1); + recycle_pack_guid(&c, id, template, target, slot); + releases.lock().unwrap().clear(); + let before = c.w.server.items.item_by_id(id).unwrap(); + let foreign = Inv::of(&c.w.pb).get(target).unwrap(); + let mut sources = vec![cleanup_source(id, PACK), cleanup_source(id, template)]; + if target != slot_type::SYSTEM { + let mut same_owner = cleanup_source(id, template); + same_owner.owner_id = 2; + sources.push(same_owner); + } + for mut source in sources { + source.container_id = foreign.lock().unwrap().container_id; + EconomyForNpcs.remove_expired_doodad_item(&c.w.server, source); + EconomyForNpcs.release_deleted_doodad_items(&c.w.server, source); + assert_eq!(c.w.server.items.item_by_id(id).unwrap(), before); + assert!(releases.lock().unwrap().is_empty()); + assert!(!c.w.server.items.removed_items().contains(&id)); + assert!(Arc::ptr_eq( + &c.w.server + .items + .container_by_id(source.container_id) + .unwrap(), + &foreign + )); + } + } +} + #[tokio::test] async fn dangling_rack_repair_does_not_move_another_players_pack_or_create_one() { let mut c = world(authored_data()); @@ -778,10 +872,7 @@ async fn dangling_cargo_repair_requires_live_child_identity_not_a_reused_id() { assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); } -#[tokio::test] -#[ignore = "private MySQL3317 via AAEMU_TEST_MYSQL; connection-local temporary doodads table"] -async fn private_mysql_saved_offline_rack_alias_survives_both_cleanup_routes() { - use crate::systems::npcs::doodad::db; +async fn private_doodad_pool() -> sqlx::MySqlPool { use sqlx::mysql::{MySqlConnectOptions, MySqlPoolOptions}; use std::str::FromStr; @@ -798,14 +889,24 @@ async fn private_mysql_saved_offline_rack_alias_survives_both_cleanup_routes() { .connect_with(options) .await .unwrap(); - let (_, ddl): (String, String) = sqlx::query_as("SHOW CREATE TABLE doodads") - .fetch_one(&pool) - .await - .unwrap(); - sqlx::query(&ddl.replacen("CREATE TABLE", "CREATE TEMPORARY TABLE", 1)) - .execute(&pool) - .await - .unwrap(); + for table in ["doodads", "items", "item_containers"] { + 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(); + } + pool +} + +#[tokio::test] +#[ignore = "private MySQL3317 via AAEMU_TEST_MYSQL; connection-local temporary tables"] +async fn private_mysql_saved_offline_rack_alias_survives_both_cleanup_routes() { + use crate::systems::npcs::doodad::db; + let pool = private_doodad_pool().await; for persisted_row_route in [false, true] { // `doodads` is the connection-local temporary table created above. @@ -920,6 +1021,159 @@ async fn private_mysql_saved_offline_rack_alias_survives_both_cleanup_routes() { } } +async fn persist_inventory(c: &CargoWorld, pool: &sqlx::MySqlPool) { + let batch = { + let _economy = c.w.server.systems.economy.ops_lock(); + c.w.server.items.prepare_save() + }; + let mut tx = pool.begin().await.unwrap(); + c.w.server + .items + .write_prepared(&mut tx, batch) + .await + .unwrap(); + tx.commit().await.unwrap(); + c.w.server.items.commit_save(); +} + +#[tokio::test] +#[ignore = "private MySQL3317 via AAEMU_TEST_MYSQL; connection-local temporary tables"] +async fn private_mysql_stale_rack_guid_reuse_preserves_foreign_items_and_container() { + use crate::models::doodad::DoodadCofferState; + use crate::systems::npcs::doodad::db; + + let pool = private_doodad_pool().await; + for (template, target, slot) in [ + (SINGLE, slot_type::INVENTORY, 0), + (SINGLE, slot_type::BANK, 0), + (GLIDER, slot_type::EQUIPMENT, equip_slot::BACKPACK), + ] { + for table in ["doodads", "items", "item_containers"] { + // All three names refer to this connection's temporary tables. + sqlx::query(&format!("DELETE FROM `{table}`")) + .execute(&pool) + .await + .unwrap(); + } + let c = world_with_pool(authored_data(), Some(pool.clone())); + let releases = record_item_releases(&c); + let original_coffer = + c.w.server + .items + .new_coffer_container(1, &c.w.server.ids.container); + let container_id = original_coffer.lock().unwrap().container_id; + // Legacy rows may carry stale item-container references as well as cargo item GUIDs. + c.racks[0].data().coffer = Some(DoodadCofferState { + capacity: 1, + container_id, + opened_by: None, + }); + let item_id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 0, STORE_SKILL); + c.w.server + .systems + .npcs + .doodads + .persistence + .flush() + .await + .unwrap(); + let deleted_id = c.racks[0].data().db_id; + recycle_pack_guid(&c, item_id, template, target, slot); + assert!(c.w.server.items.forget_container(container_id)); + c.w.server.ids.container.release_id(container_id as u32); + let foreign_coffer = + c.w.server + .items + .new_coffer_container(2, &c.w.server.ids.container); + assert_eq!( + foreign_coffer.lock().unwrap().container_id, + container_id, + "exercise actual container allocator reuse" + ); + persist_inventory(&c, &pool).await; + let before = c.w.server.items.item_by_id(item_id).unwrap(); + releases.lock().unwrap().clear(); + c.w.server.world.world(0).unwrap().delete(&c.racks[0]); + { + let mut conn = pool.acquire().await.unwrap(); + assert!(db::delete_doodad_by_id(&c.w.server, &mut conn, deleted_id) + .await + .unwrap()); + } + assert_eq!(c.w.server.items.item_by_id(item_id).unwrap(), before); + assert!(!c.w.server.items.removed_items().contains(&item_id)); + assert!(releases.lock().unwrap().is_empty()); + assert!(Arc::ptr_eq( + &c.w.server.items.container_by_id(container_id).unwrap(), + &foreign_coffer + )); + persist_inventory(&c, &pool).await; + let foreign_owner: u64 = + sqlx::query_scalar("SELECT CAST(owner AS UNSIGNED) FROM items WHERE id = ?") + .bind(item_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(foreign_owner, 2); + let container_owner: u64 = sqlx::query_scalar( + "SELECT CAST(owner_id AS UNSIGNED) FROM item_containers WHERE container_id = ?", + ) + .bind(container_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(container_owner, 2); + } + + for table in ["doodads", "items", "item_containers"] { + sqlx::query(&format!("DELETE FROM `{table}`")) + .execute(&pool) + .await + .unwrap(); + } + // Control: a saved ordinary furniture reference still owns a matching System-escrow item. + let c = world_with_pool(authored_data(), Some(pool.clone())); + let releases = record_item_releases(&c); + let item_id = give(&c.w, &c.w.pa, slot_type::SYSTEM, SINGLE, 1, -1); + let instance = c.w.server.world.world(0).unwrap(); + let furniture = manager::create(&c.w.server, &instance, 0, FURNITURE, None, true).unwrap(); + { + let mut d = furniture.data(); + d.is_persistent = true; + d.owner_type = doodad_owner_type::CHARACTER; + d.owner_id = 1; + d.item_id = item_id; + d.item_template_id = SINGLE; + } + db::save_now(&c.w.server, &furniture).await.unwrap(); + persist_inventory(&c, &pool).await; + let db_id = furniture.data().db_id; + { + let mut conn = pool.acquire().await.unwrap(); + assert!(db::delete_doodad_by_id(&c.w.server, &mut conn, db_id) + .await + .unwrap()); + } + assert!(c.w.server.items.item_by_id(item_id).is_none()); + assert!(c.w.server.items.removed_items().contains(&item_id)); + assert_eq!(*releases.lock().unwrap(), vec![item_id as u32]); + persist_inventory(&c, &pool).await; + let remaining: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM items WHERE id = ?") + .bind(item_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(remaining, 0); +} + #[tokio::test] #[ignore = "needs AAEMU_COMPACT_DB"] async fn real_compact_merchant_all_twenty_racks_survive_shuffled_cycles() { diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/db.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/db.rs index b20e979c93..f936321e18 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/db.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/db.rs @@ -306,32 +306,49 @@ pub async fn delete_doodad_by_id( server.systems.npcs.doodads.persistence.flush().await?; // First grab the item related data let row = sqlx::query( - "SELECT CAST(item_id AS UNSIGNED) AS item_id, \ + "SELECT CAST(owner_id AS UNSIGNED) AS owner_id, CAST(owner_type AS UNSIGNED) AS owner_type, \ + CAST(template_id AS UNSIGNED) AS template_id, \ + CAST(item_template_id AS UNSIGNED) AS item_template_id, CAST(item_id AS UNSIGNED) AS item_id, \ CAST(item_container_id AS UNSIGNED) AS item_container_id FROM doodads WHERE id = ? LIMIT 1", ) .bind(db_id) .fetch_optional(&mut *conn) .await?; - let (item_id, container_id) = match row { - Some(r) => ( - r.try_get::("item_id")?, - r.try_get::("item_container_id")?, - ), - None => (0, 0), + let source = match row { + Some(r) => crate::systems::npcs::hooks::DoodadItemCleanup { + doodad_db_id: db_id, + doodad_template_id: r.try_get::("template_id")? as u32, + owner_id: r.try_get::("owner_id")? as u32, + owner_type: r.try_get::("owner_type")? as u8, + item_id: r.try_get::("item_id")?, + item_template_id: r.try_get::("item_template_id")? as u32, + container_id: r.try_get::("item_container_id")?, + }, + None => return Ok(false), }; - let n = sqlx::query("DELETE FROM doodads WHERE id = ?") - .bind(db_id) - .execute(&mut *conn) - .await? - .rows_affected(); + // Do not clean up the selected reference if another writer replaced its owner or items. + let n = sqlx::query( + "DELETE FROM doodads WHERE id = ? AND owner_id = ? AND owner_type = ? \ + AND template_id = ? AND item_id = ? AND item_template_id = ? AND item_container_id = ?", + ) + .bind(db_id) + .bind(source.owner_id) + .bind(source.owner_type) + .bind(source.doodad_template_id) + .bind(source.item_id) + .bind(source.item_template_id) + .bind(source.container_id) + .execute(&mut *conn) + .await? + .rows_affected(); if n == 0 { tracing::error!("Failed to delete doodad from DB Id: {db_id}"); return Ok(false); } server.ids.doodad.release_id(db_id); // Free up the Id - if item_id > 0 || container_id > 0 { + if source.item_id > 0 || source.container_id > 0 { if let Some(h) = server.systems.npcs.hooks.economy.get() { - h.release_deleted_doodad_items(server, item_id, container_id); + h.release_deleted_doodad_items(server, source); } } Ok(true) diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/manager.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/manager.rs index 1c866d82e7..dd52ac9abe 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/manager.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/manager.rs @@ -245,14 +245,26 @@ pub fn delete(server: &GameServer, world: &Arc, doodad: &DoodadRe world.delete(doodad); area_trigger::remove_doodad_area_triggers(server, doodad.obj_id); - let (item_id, persistent, db_id) = { + let (source, persistent, db_id) = { let d = doodad.data(); - (d.item_id, d.is_persistent, d.db_id) + ( + crate::systems::npcs::hooks::DoodadItemCleanup { + doodad_db_id: d.db_id, + doodad_template_id: d.template_id, + owner_id: d.owner_id, + owner_type: d.owner_type, + item_id: d.item_id, + item_template_id: d.item_template_id, + container_id: d.coffer.as_ref().map_or(0, |c| c.container_id), + }, + d.is_persistent, + d.db_id, + ) }; // Delete associated item if expired - if item_id > 0 { + if source.item_id > 0 { if let Some(h) = server.systems.npcs.hooks.economy.get() { - h.remove_expired_doodad_item(server, item_id); + h.remove_expired_doodad_item(server, source); } } if let Some(spawns) = server.systems.npcs.spawns.get(world.id) { diff --git a/rust/crates/aaemu-game/src/systems/npcs/hooks.rs b/rust/crates/aaemu-game/src/systems/npcs/hooks.rs index 7584b27f05..ba4bea8565 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/hooks.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/hooks.rs @@ -650,22 +650,15 @@ pub trait EconomyBridge: Send + Sync { ) { } - /// `Doodad.Delete()` item cleanup: `GetItemByItemId(itemId)` held by a `None` / `System` - /// container -> `RemoveItem(Invalid, item, true)`. Cargo must be retained when unloaded - /// persistent references cannot be ruled out; collection of such orphans is deferred. - /// Default: nothing. - fn remove_expired_doodad_item(&self, _server: &GameServer, _item_id: u64) {} + /// `Doodad.Delete()` item cleanup. The original doodad context, not a possibly recycled + /// item's current class, determines whether ordinary owned System escrow may be removed. + /// Cargo and ambiguous references are retained for reconciliation. Default: nothing. + fn remove_expired_doodad_item(&self, _server: &GameServer, _source: DoodadItemCleanup) {} - /// `DeleteDoodadById` item part: the attached item loses its container and its id is - /// released; the attached container is deleted. Cargo with unproven unloaded references - /// is conservatively retained, including an ambiguous attached container. Default: nothing. - fn release_deleted_doodad_items( - &self, - _server: &GameServer, - _item_id: u64, - _container_id: u64, - ) { - } + /// `DeleteDoodadById` item part. Only matching ordinary owned System escrow may be removed. + /// Container GUIDs have no immutable link to the deleted row, so their deletion is deferred. + /// Default: nothing. + fn release_deleted_doodad_items(&self, _server: &GameServer, _source: DoodadItemCleanup) {} /// `HousingManager.GetHouseAtLocation(x, y)` (database id of the house whose land covers /// the point). Default: the housing subsystem. @@ -674,6 +667,19 @@ pub trait EconomyBridge: Send + Sync { } } +/// Original live/saved doodad metadata for item cleanup. Item and container GUIDs can be reused; +/// this describes the source reference and does not assert an allocation-generation identity. +#[derive(Debug, Clone, Copy, Default)] +pub struct DoodadItemCleanup { + pub doodad_db_id: u32, + pub doodad_template_id: u32, + pub owner_id: u32, + pub owner_type: u8, + pub item_id: u64, + pub item_template_id: u32, + pub container_id: u64, +} + /// The item fields `CSCreateDoodadPacket` / `CreatePlayerDoodad` read. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct DoodadSourceItem { From 8db0e003df5c329d9ee6522b09a26d0c7158dfc0 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:23:31 -0400 Subject: [PATCH 42/66] docs(audit): record cargo safeguards and validation limits --- rust/crates/aaemu-game/PORTING.md | 33 ++++++++++++++++++++++++++++ rust/docs/audit-repair-status.json | 35 +++++++++++++++++++++++++----- 2 files changed, 63 insertions(+), 5 deletions(-) diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 09d93db24d..353934e8fe 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -279,6 +279,39 @@ connected by `systems::economy::wiring`). | Item skill-effect bodies (grade enchant, socketing, conversion, cap scale, UCC imprint, ...), mate / slave equipment packets | `systems/economy/item_effects*.rs` | done | Called by the skills subsystem's effects. UCC imprint / cleanup require owned source and target items; client UCC casts require the actual source item's configured use skill, preserving the unrelated legacy bound-item portal exception. Dyeing checks the loaded `dyeable_items` allowlist. Invalid UCC / dye effects cancel deferred reagent consumption. | | Item skill-effect stubs given data-derived bodies (`GainItemWithPosImprint` 32, `RechargeItemBuff` 95, `ExpToItem` 96) | `systems/economy/item_effects.rs` | done (data-derived) | The C# `Execute` bodies were `// TODO` stubs, so the behaviour comes from `special_effects` 405 / 546 / 547 / 548 (32: create `value1` x1 with `SkillEffectGainItemWithPos`), 12446 / 17017 (95) and 12462 (96: `value1` XP -> `value2` x1 with `SkillEffectExpToItem`) plus the tool skills that cast them. `GainItemWithPosImprint` stores no position imprint: the 1.2 item details have no such field. `ExpToItem` subtracts the experience directly instead of through `AddExp` (which recomputes the level and could level the character down), sends `SCExpChangedPacket(-value1)`, checks bag room before spending the XP, and cancels so the reagent is kept. `RechargeItemBuff` takes the cast's item target, resets `charge_start_time` (and `charge_count` when the template has one) and re-applies the equipped item's gear buff through `apply_gear_buffs` with the item both removed and added, so the recharge buff is not stacked; the 1 s item timers read the new charge window on their next tick, so nothing is re-scheduled. | +#### Cargo escrow and stale rack references (2026-10-25) + +Merchant-ship rack deposits now revalidate the exact equipped pack and a vacant +rack in one economy transaction. Recovery validates System escrow and backpack +space, moves the same item ID, and clears the rack reference together. A rejected +pickup preserves the pack, the current backpack and recorded item effects. +The shared path covers other hulls and ordinary racks; the real-data regression +uses Merchant hull 75, item 23398 and its twenty attachment points 60..79. + +Error 14 (`INTERACTION_RECOVER_PARENT`) on this path means the referenced item is +outside System escrow; it does not establish that another pack is physically on +top. The separate persistent-child removal check uses error 207. Provably dangling +persistent cargo references can return to the authored empty phase without moving +or creating an item. Ambiguous references remain blocked with rack/item/container +and hull diagnostics; current child allocation identity and parent/instance must +match before a child can block repair or removal. + +Both live and saved-row cleanup receive the original doodad metadata. Original +rack/cargo/Slave references never authorize deleting the current item at a recycled +GUID. Ordinary furniture cleanup requires a unique singleton matching the original +template and owner in that owner's System escrow. Items in inventory, equipment, +bank or another owner's containers are retained. Saved container GUIDs alone never +authorize container deletion. Saved-row removal checks its selected reference +fields before invoking cleanup. + +This conservative policy protects unloaded rack aliases and recovered/recycled +items. Metadata matching does not establish allocation generation. Cargo and +ambiguous item references, plus saved containers, may be retained after the last +rack disappears; reconciliation and orphan collection remain open. Regression +sources cover shuffled twenty-rack cycles, stale sources, failed recovery, +allocator reuse and private-MySQL saved aliases. Source review is complete; +exact-head execution and live reconnect acceptance are still pending. + ### systems::social | Area (C#) | Rust | Status | Notes | diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json index d69ae0a8fb..c6c45a6eae 100644 --- a/rust/docs/audit-repair-status.json +++ b/rust/docs/audit-repair-status.json @@ -379,9 +379,10 @@ }, { "id": "trade-ship-cargo-reference-atomicity", - "status": "implementing", + "status": "source_reviewed_merged_pending_validation", "owner": "audit-tradeship", - "note": "Tester-reported stuck rack; source proves error14 is stale non-System item reference, not physical stacking. Production transaction and repair tests in progress." + "note": "Exact equipped-source deposit and checked recovery are integrated. Original-reference cleanup protects foreign/recycled items; ambiguous cargo and saved containers are conservatively retained. Allocation-generation proof and reconciliation/GC remain open. Cargo tests, ignored MySQL/compact checks and live acceptance are pending.", + "commit": "8c2e977b5ba6b7660e4739964465e0b1e97b9d7b" }, { "id": "trade-ship-live-root-identity-after-reconnect", @@ -391,9 +392,10 @@ }, { "id": "lane-allocation-concurrency", - "status": "implementing", + "status": "focused_passed_full_gate_pending", "owner": "audit-lane-lock", - "note": "Concurrent creation assigned the same port prefix; isolated allocator repair in progress." + "note": "15 isolated root Python tests passed; original allocator fails concurrent allocation. Two real concurrent probe lanes received distinct prefixes and were removed. Windows/Linux workflow now runs the suite.", + "commit": "090f515b6" } ], "recent_validation": { @@ -411,6 +413,29 @@ "minimum_free_gib": 5.938747406005859 }, "current_full_lane_ci": "pending", - "current_live": "pending" + "current_live": "pending", + "game_unit_tests": { + "head": "1f53a66bdd0ab289ae2a26abbbaff084cddfcaff", + "passed": 2813, + "failed": 6, + "ignored": 145, + "result": "completed_with_fixture_failures", + "fixture_corrections": [ + "395386180", + "5dfd7282b" + ], + "corrected_execution": "pending; subsequent builds held at memory reserve before tests ran" + }, + "latest_corrected_builds": { + "head": "5dfd7282b71ec84655b44b861b24991502dd5ff2", + "clippy": "held_at_memory_reserve", + "game_tests": "held_at_memory_reserve_before_execution" + }, + "cargo_source_review": { + "head": "8c2e977b5ba6b7660e4739964465e0b1e97b9d7b", + "round": 3, + "result": "no_new_actionable_P1_P2_within_documented_conservative_policy", + "execution": "pending" + } } } From da8e370bac84f993a582ef990a4159cd43555fb5 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:26:02 -0400 Subject: [PATCH 43/66] test(mail): decode expiry receiver with schema signedness --- rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs b/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs index 6c434b84f0..96bfdc16de 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs @@ -785,7 +785,7 @@ async fn private_mysql_expiry_return_rollback_retry_reload_and_disposal() { persist(&original, &pool, true).await; tick(&original, due); persist(&original, &pool, false).await; - let receiver: u32 = sqlx::query_scalar("SELECT receiver_id FROM mails WHERE id=?") + let receiver: i32 = sqlx::query_scalar("SELECT receiver_id FROM mails WHERE id=?") .bind(id) .fetch_one(&pool) .await From ae07101987b54bad15c047fd644633f20e80bc5a Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:26:55 -0400 Subject: [PATCH 44/66] fix(vehicles): coordinate item mutations and restored ship publication Preload and validate saved hull, child and persistent doodad data before replacement. Commit actual summon metadata before retiring the old hull, serialize ordinary item operations through a per-server thread-bound outer scope, and protect synchronous restore publication against direct despawn. Add deterministic source regressions plus gated persistent-query failure coverage. Runtime checks remain reserved for the parent. Co-Authored-By: Codex --- .../src/systems/economy/inventory.rs | 4 + .../aaemu-game/src/systems/economy/mod.rs | 29 +- .../src/systems/economy/operation_scope.rs | 86 ++++ .../systems/economy/operation_scope_tests.rs | 104 ++++ .../src/systems/npcs/spawn_manager.rs | 249 +++++++-- .../src/systems/vehicles/flow_tests.rs | 3 + .../aaemu-game/src/systems/vehicles/mod.rs | 10 +- .../systems/vehicles/ship_identity_tests.rs | 475 +++++++++++++++++- .../aaemu-game/src/systems/vehicles/slaves.rs | 360 +++++++++---- 9 files changed, 1189 insertions(+), 131 deletions(-) create mode 100644 rust/crates/aaemu-game/src/systems/economy/operation_scope.rs create mode 100644 rust/crates/aaemu-game/src/systems/economy/operation_scope_tests.rs diff --git a/rust/crates/aaemu-game/src/systems/economy/inventory.rs b/rust/crates/aaemu-game/src/systems/economy/inventory.rs index d42e6a882f..08204c9508 100644 --- a/rust/crates/aaemu-game/src/systems/economy/inventory.rs +++ b/rust/crates/aaemu-game/src/systems/economy/inventory.rs @@ -77,6 +77,10 @@ impl<'a> ItemTxn<'a> { /// lock (the quest "locked hooks"): starting a normal transaction there could deadlock with /// an operation that holds the lock and waits for that character. Hand the effects to /// [`ItemTxn::into_fx`] and flush them once the character lock is released. + /// This path deliberately bypasses both the ops mutex and the outer publication scope. + /// It is not protected against concurrent world publication; callers must keep its quest + /// mutations confined to their already-locked character and must never acquire the outer + /// scope while holding that character lock. pub fn unlocked(server: &'a GameServer) -> Self { Self { server, diff --git a/rust/crates/aaemu-game/src/systems/economy/mod.rs b/rust/crates/aaemu-game/src/systems/economy/mod.rs index d7615b6db2..cdb36af874 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mod.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mod.rs @@ -57,6 +57,9 @@ pub mod mail_packets; #[cfg(test)] mod mail_tests; pub mod mate_equipment; +mod operation_scope; +#[cfg(test)] +mod operation_scope_tests; #[cfg(test)] mod ported_unit_tests; pub mod repair; @@ -86,6 +89,8 @@ pub struct System { pub hooks: hooks::EconomyHooks, /// Serialises item operations (see [`inventory::ItemTxn`]). ops: Mutex<()>, + /// Callback-bearing synchronous publications exclude ordinary item operations here. + operation_scope: operation_scope::OperationScope, /// `Inventory.PreviousBackPackItemId` by character id (glider re-equip after a trade pack). previous_backpack: Mutex>, /// Account-wide attributes (`account_attributes`, auction posting authority, ...). @@ -118,22 +123,40 @@ thread_local! { } /// The held item-operation lock ([`System::ops_lock`]); tracks the holding thread. -pub struct OpsGuard<'a>(Option>); +pub struct OpsGuard<'a> { + guard: Option>, + _scope: operation_scope::OperationScopeGuard<'a>, +} impl Drop for OpsGuard<'_> { fn drop(&mut self) { - self.0.take(); + self.guard.take(); OPS_HELD.with(|held| held.set(held.get().saturating_sub(1))); } } impl System { + /// Acquire before world/publication locks and after all awaits. Callback ItemTxn scopes + /// may reenter this outer boundary; callbacks must still run outside the ops mutex. + pub(crate) fn operation_scope(&self) -> operation_scope::OperationScopeGuard<'_> { + self.operation_scope.enter() + } + /// The item-operation lock (outermost lock of every economy operation; never taken while a /// character or container lock is held). pub fn ops_lock(&self) -> OpsGuard<'_> { + let scope = self.operation_scope(); let guard = self.ops.lock().unwrap_or_else(|e| e.into_inner()); OPS_HELD.with(|held| held.set(held.get() + 1)); - OpsGuard(Some(guard)) + OpsGuard { + guard: Some(guard), + _scope: scope, + } + } + + #[cfg(test)] + pub(crate) fn wait_until_operation_blocked(&self) { + self.operation_scope.wait_until_blocked(); } /// Whether the current thread holds the item-operation lock. The lock is not re-entrant, so diff --git a/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs b/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs new file mode 100644 index 0000000000..2403b65753 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs @@ -0,0 +1,86 @@ +//! Synchronous operation boundary around callback-bearing world/item changes. The inner +//! economy ops mutex stays non-reentrant; only this outer scope permits same-thread entry. + +use std::marker::PhantomData; +use std::rc::Rc; +use std::sync::{Condvar, Mutex}; +use std::thread::{self, ThreadId}; + +#[derive(Debug, Default)] +struct Owner { + thread: Option, + depth: usize, + #[cfg(test)] + waiters: usize, +} + +#[derive(Debug, Default)] +pub(super) struct OperationScope { + owner: Mutex, + available: Condvar, + #[cfg(test)] + waiting: Condvar, +} + +/// The Rc marker binds acquisition/release to one thread, without unsafe Send/Sync impls. +pub(crate) struct OperationScopeGuard<'a> { + scope: &'a OperationScope, + _thread_bound: PhantomData>, +} + +impl OperationScope { + pub(super) fn enter(&self) -> OperationScopeGuard<'_> { + let current = thread::current().id(); + let mut owner = self.owner.lock().unwrap_or_else(|e| e.into_inner()); + loop { + if owner.thread.is_none() || owner.thread == Some(current) { + owner.thread = Some(current); + owner.depth += 1; + return OperationScopeGuard { + scope: self, + _thread_bound: PhantomData, + }; + } + #[cfg(test)] + { + owner.waiters += 1; + self.waiting.notify_all(); + } + owner = self + .available + .wait(owner) + .unwrap_or_else(|e| e.into_inner()); + #[cfg(test)] + { + owner.waiters -= 1; + } + } + } + + #[cfg(test)] + pub(super) fn wait_until_blocked(&self) { + let owner = self.owner.lock().unwrap_or_else(|e| e.into_inner()); + let (owner, timeout) = self + .waiting + .wait_timeout_while(owner, std::time::Duration::from_secs(5), |owner| { + owner.waiters == 0 + }) + .unwrap_or_else(|e| e.into_inner()); + assert!( + !timeout.timed_out() && owner.waiters != 0, + "ordinary operation must reach the outer scope" + ); + } +} + +impl Drop for OperationScopeGuard<'_> { + fn drop(&mut self) { + let mut owner = self.scope.owner.lock().unwrap_or_else(|e| e.into_inner()); + debug_assert_eq!(owner.thread, Some(thread::current().id())); + owner.depth -= 1; + if owner.depth == 0 { + owner.thread = None; + self.scope.available.notify_one(); + } + } +} diff --git a/rust/crates/aaemu-game/src/systems/economy/operation_scope_tests.rs b/rust/crates/aaemu-game/src/systems/economy/operation_scope_tests.rs new file mode 100644 index 0000000000..7766738467 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/economy/operation_scope_tests.rs @@ -0,0 +1,104 @@ +use super::*; +use crate::models::item_task::ItemFx; +use crate::test_support::{spawn_player, test_character, test_server, TestClient}; +use crate::world::PlayerRef; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::mpsc; +use std::time::Duration; + +#[test] +fn direct_ops_lock_waits_for_the_outer_scope() { + let economy = Arc::new(System::default()); + let scope = economy.operation_scope(); + let worker_economy = economy.clone(); + let (done, received) = mpsc::channel(); + let worker = std::thread::spawn(move || { + let _ops = worker_economy.ops_lock(); + done.send(()).unwrap(); + }); + economy.wait_until_operation_blocked(); + assert!(received.try_recv().is_err()); + drop(scope); + received.recv_timeout(Duration::from_secs(5)).unwrap(); + worker.join().unwrap(); +} + +#[test] +fn failure_and_panic_release_every_scope_depth() { + let economy = Arc::new(System::default()); + let fail = || -> Option<()> { + let _outer = economy.operation_scope(); + let _inner = economy.operation_scope(); + None + }; + assert!(fail().is_none()); + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let _outer = economy.operation_scope(); + let _ops = economy.ops_lock(); + panic!("deliberate publication failure"); + })); + assert!(result.is_err()); + assert!(!System::ops_held_on_this_thread()); + let worker_economy = economy.clone(); + let (done, received) = mpsc::channel(); + let worker = std::thread::spawn(move || { + let _ops = worker_economy.ops_lock(); + done.send(()).unwrap(); + }); + received.recv_timeout(Duration::from_secs(5)).unwrap(); + worker.join().unwrap(); +} + +#[tokio::test] +async fn scopes_of_different_game_servers_are_independent() { + let first = Arc::new(test_server()); + let second = Arc::new(test_server()); + let _first_scope = first.systems.economy.operation_scope(); + let (done, received) = mpsc::channel(); + let worker = std::thread::spawn(move || { + let _ops = second.systems.economy.ops_lock(); + done.send(()).unwrap(); + }); + received.recv_timeout(Duration::from_secs(5)).unwrap(); + worker.join().unwrap(); +} + +struct Reenter(AtomicUsize); + +impl hooks::QuestItemHooks for Reenter { + fn on_items_acquired(&self, server: &GameServer, _player: &PlayerRef, _id: u32, _count: i32) { + assert!(!System::ops_held_on_this_thread()); + let _callback = inventory::ItemTxn::begin(server); + self.0.fetch_add(1, Ordering::SeqCst); + } +} + +#[tokio::test] +async fn item_callbacks_reenter_the_outer_scope_after_releasing_ops() { + let server = Arc::new(test_server()); + server.set_self(); + let client = TestClient::new(&server, 1, 1); + spawn_player( + &server, + &client, + test_character(1, "Owner", 100.0, 100.0), + 0x100, + ); + let callback = Arc::new(Reenter(AtomicUsize::new(0))); + server + .systems + .economy + .hooks + .quests + .install(callback.clone()); + let _publication = server.systems.economy.operation_scope(); + let mut txn = inventory::ItemTxn::begin(&server); + txn.env.fx.push(ItemFx::Acquired { + owner: 1, + template_id: 1, + count: 1, + }); + drop(txn); + assert_eq!(callback.0.load(Ordering::SeqCst), 1); + assert!(!System::ops_held_on_this_thread()); +} diff --git a/rust/crates/aaemu-game/src/systems/npcs/spawn_manager.rs b/rust/crates/aaemu-game/src/systems/npcs/spawn_manager.rs index 6d02ad71cd..a15c63ba30 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/spawn_manager.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/spawn_manager.rs @@ -61,6 +61,73 @@ pub const FIRST_FAKE_SPAWNER_ID: u32 = 9_000_001; /// spawners) quadratically, so a pathological configuration is clamped to a modest ring. pub const MAX_PREWARM_REGION_MARGIN: u32 = 4; +/// Fully decoded persistent rows. Fetching/validating this batch allocates no world objects, +/// changes no parent links and queues no persistence writes. +#[derive(Debug, Default)] +pub(crate) struct PersistentDoodads { + rows: Vec, +} + +#[derive(Debug)] +struct PreparedDoodad { + row: crate::systems::npcs::doodad::db::DoodadRow, + interaction_counts: HashMap, +} + +impl PersistentDoodads { + pub(crate) fn prepare( + server: &GameServer, + rows: Vec, + ) -> anyhow::Result { + let mut prepared = Vec::with_capacity(rows.len()); + for row in rows { + anyhow::ensure!(row.id != 0, "persistent doodad has no database id"); + let template = server + .game_data + .systems + .npcs + .doodad + .template(row.template_id) + .ok_or_else(|| { + anyhow::anyhow!( + "persistent doodad {}: template {} does not exist", + row.id, + row.template_id + ) + })?; + anyhow::ensure!( + [row.x, row.y, row.z, row.roll, row.pitch, row.yaw, row.scale] + .iter() + .all(|value| value.is_finite()), + "persistent doodad {}: non-finite transform", + row.id + ); + anyhow::ensure!( + row.current_phase_id == 0 + || template + .func_groups + .iter() + .any(|group| group.id == row.current_phase_id), + "persistent doodad {}: phase {} does not belong to template {}", + row.id, + row.current_phase_id, + row.template_id + ); + let interaction_counts = serde_json::from_str(&row.interaction_counts)?; + prepared.push(PreparedDoodad { + row, + interaction_counts, + }); + } + Ok(Self { rows: prepared }) + } +} + +#[cfg(test)] +pub(crate) type PersistentDoodadLoad = dyn Fn(u8, i64) -> futures::future::BoxFuture<'static, anyhow::Result> + + Send + + Sync; + /// The configured prewarm margin, clamped to [`MAX_PREWARM_REGION_MARGIN`]. pub fn prewarm_region_margin(config: &WorldConfig) -> u32 { config @@ -296,6 +363,8 @@ pub struct SpawnManagers { activation_rotation: AtomicU32, #[cfg(test)] pub(crate) test_backend: Mutex>>, + #[cfg(test)] + pub(crate) test_persistent_loader: Mutex>>, } impl std::fmt::Debug for SpawnManagers { @@ -324,6 +393,8 @@ impl Default for SpawnManagers { activation_rotation: AtomicU32::new(0), #[cfg(test)] test_backend: Mutex::new(None), + #[cfg(test)] + test_persistent_loader: Mutex::new(None), } } } @@ -1277,8 +1348,8 @@ impl SpawnManager { // ----- persistent doodads ----- - /// `SpawnPersistentDoodads(ownerType, ownerId, useParentObject, doSpawn)`: the `doodads` - /// rows of an owner type (optionally of one `house_id`) into `PlayerDoodads`. + /// Compatibility entry point for startup/housing callers. Ships preload the same batch + /// before touching their old hull and call the synchronous publication method later. pub async fn spawn_persistent_doodads( &self, server: &GameServer, @@ -1287,9 +1358,41 @@ impl SpawnManager { use_parent_object: Option<&WorldObject>, do_spawn: bool, ) -> anyhow::Result { - use crate::db::{dt, int, unix}; + let prepared = self + .fetch_persistent_doodads(server, owner_type_to_spawn, owner_to_spawn_id) + .await?; + let _items = use_parent_object + .and_then(WorldObject::as_slave) + .map(|_| server.systems.economy.operation_scope()); + let _parent_scope = use_parent_object + .and_then(WorldObject::as_slave) + .map(|_| server.systems.vehicles.slave_summons.publication_scope()); + self.publish_persistent_doodads(server, prepared, use_parent_object, do_spawn) + } + + pub(crate) async fn fetch_persistent_doodads( + &self, + server: &GameServer, + owner_type_to_spawn: u8, + owner_to_spawn_id: i64, + ) -> anyhow::Result { + use crate::db::{int, min_value}; + use crate::systems::npcs::doodad::db::DoodadRow; use sqlx::Row; - + #[cfg(test)] + { + let loader = server + .systems + .npcs + .spawns + .test_persistent_loader + .lock() + .expect("test persistent loader poisoned") + .clone(); + if let Some(loader) = loader { + return loader(owner_type_to_spawn, owner_to_spawn_id).await; + } + } let mut sql = String::from( "SELECT CAST(id AS SIGNED) AS id, CAST(template_id AS SIGNED) AS template_id, \ CAST(current_phase_id AS SIGNED) AS current_phase_id, x, y, z, roll, pitch, yaw, scale, \ @@ -1310,27 +1413,110 @@ impl SpawnManager { q = q.bind(owner_to_spawn_id); } let rows = q.fetch_all(&server.db).await?; + let rows = rows + .into_iter() + .map(|r| -> anyhow::Result { + let float = |column: &str| -> sqlx::Result { r.try_get(column) }; + let time = |column: &str| -> sqlx::Result { + Ok(r.try_get::, _>(column)? + .unwrap_or_else(min_value)) + }; + Ok(DoodadRow { + id: int(&r, "id")? as u32, + owner_id: int(&r, "owner_id")? as u32, + owner_type: int(&r, "owner_type")? as u8, + attach_point: int(&r, "attach_point")? as u8, + template_id: int(&r, "template_id")? as u32, + current_phase_id: int(&r, "current_phase_id")? as u32, + plant_time: time("plant_time")?, + growth_time: time("growth_time")?, + phase_time: time("phase_time")?, + x: float("x")?, + y: float("y")?, + z: float("z")?, + roll: float("roll")?, + pitch: float("pitch")?, + yaw: float("yaw")?, + scale: float("scale")?, + item_id: r.try_get("item_id")?, + house_id: int(&r, "house_id")? as u32, + parent_doodad: int(&r, "parent_doodad")? as u32, + item_template_id: int(&r, "item_template_id")? as u32, + item_container_id: r.try_get("item_container_id")?, + data: int(&r, "data")? as i32, + farm_type: int(&r, "farm_type")? as u8, + interaction_counts: r + .try_get::, _>("interaction_counts")? + .unwrap_or_else(|| "{}".into()), + }) + }) + .collect::>>()?; + PersistentDoodads::prepare(server, rows) + } + + /// Caller coordinates parent removal for the whole synchronous publication. The pointer + /// check rejects batches fetched for an earlier generation of a reused parent object id. + pub(crate) fn publish_persistent_doodads( + &self, + server: &GameServer, + prepared: PersistentDoodads, + use_parent_object: Option<&WorldObject>, + do_spawn: bool, + ) -> anyhow::Result { + use crate::db::unix; + use crate::systems::npcs::doodad::db::DoodadRow; + if let Some(parent) = use_parent_object { + anyhow::ensure!( + self.world + .object(parent.obj_id()) + .is_some_and(|live| std::ptr::eq(live.core(), parent.core())), + "persistent doodad parent is no longer live" + ); + if let Some(slave) = parent.as_slave() { + let db_id = slave.data().id; + anyhow::ensure!( + prepared + .rows + .iter() + .all(|d| d.row.owner_type == doodad_owner_type::SLAVE + && d.row.house_id == db_id), + "persistent doodad batch does not belong to this hull" + ); + } + } let mut count = 0; let mut new_coffers = Vec::new(); - for r in rows { - let template_id = int(&r, "template_id")? as u32; - let db_id = int(&r, "id")? as u32; - let f = |c: &str| -> anyhow::Result { Ok(r.try_get::(c)?) }; - let (x, y, z) = (f("x")?, f("y")?, f("z")?); - let (roll, pitch, yaw) = (f("roll")?, f("pitch")?, f("yaw")?); - let scale = f("scale")?; - let owner_id = int(&r, "owner_id")? as u32; - let owner_type = int(&r, "owner_type")? as u8; - let attach_point = int(&r, "attach_point")? as u8; - let item_id: u64 = r.try_get("item_id")?; - let house_id = int(&r, "house_id")? as u32; - let parent_doodad = int(&r, "parent_doodad")? as u32; - let item_template_id = int(&r, "item_template_id")? as u32; - let item_container_id: u64 = r.try_get("item_container_id")?; - let data = int(&r, "data")? as i32; - let farm_type = int(&r, "farm_type")? as u8; - let phase_id = int(&r, "current_phase_id")? as u32; - + for PreparedDoodad { + row, + interaction_counts, + } in prepared.rows + { + let DoodadRow { + id: db_id, + owner_id, + owner_type, + attach_point, + template_id, + current_phase_id: phase_id, + plant_time, + growth_time, + phase_time, + x, + y, + z, + roll, + pitch, + yaw, + scale, + item_id, + house_id, + parent_doodad, + item_template_id, + item_container_id, + data, + farm_type, + interaction_counts: _, + } = row; let Some(doodad) = backend::doodad_create(server, &self.world, 0, template_id, None, true) else { @@ -1346,17 +1532,14 @@ impl SpawnManager { .get() .and_then(|h| h.item_template_and_ucc(server, item_id)) .unwrap_or((item_template_id, 0)); - let plant_time = dt(&r, "plant_time"); - let growth_time = dt(&r, "growth_time"); - let phase_time = dt(&r, "phase_time"); { let mut d = doodad.data(); d.db_id = db_id; d.owner_id = owner_id; d.owner_type = owner_type; d.attach_point = attach_point; - d.plant_time = unix(plant_time); - d.growth_time_ms = growth_time.map_or(0, |t| t.and_utc().timestamp_millis().max(0)); + d.plant_time = unix(Some(plant_time)); + d.growth_time_ms = growth_time.and_utc().timestamp_millis().max(0); d.item_id = item_id; d.owner_db_id = house_id; d.scale = if scale != 0.0 { scale } else { 1.0 }; @@ -1368,16 +1551,12 @@ impl SpawnManager { // `FuncGroupId = phaseId` (setter: PhaseTime = now, Save, phase caches), then // `OverridePhaseTime = PhaseTime = phase_time`. crate::systems::npcs::doodad::manager::set_func_group_id(server, &doodad, phase_id); - let interaction_counts = r - .try_get::, _>("interaction_counts")? - .map(|json| serde_json::from_str(&json)) - .transpose()?; { - let pt = phase_time.map_or(0, |t| t.and_utc().timestamp_millis().max(0)); + let pt = phase_time.and_utc().timestamp_millis().max(0); let mut d = doodad.data(); d.phase.override_phase_time_ms = pt; d.phase_time_ms = pt; - d.phase.interaction_counts = interaction_counts.unwrap_or_default(); + d.phase.interaction_counts = interaction_counts; } let doodad_obj = WorldObject::from(&doodad); let mut has_parent = false; @@ -1454,7 +1633,7 @@ impl SpawnManager { } } // Slave AttachedDoodads - if owner_type_to_spawn == doodad_owner_type::SLAVE { + if owner_type == doodad_owner_type::SLAVE { if let Some(slave) = use_parent_object.and_then(WorldObject::as_slave) { let mut s = slave.data(); if !s.attached_doodads.contains(&doodad.obj_id) { 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 c15ed699ae..c672978fb1 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs @@ -143,6 +143,8 @@ fn server_with(d: GameData) -> Arc { Some(slaves::TestSlaveLoader(Arc::new(|_, _| { Box::pin(async { Ok(slaves::LoadedHull::default()) }) }))); + *s.systems.npcs.spawns.test_persistent_loader.lock().unwrap() = + Some(Arc::new(|_, _| Box::pin(async { Ok(Default::default()) }))); s } @@ -169,6 +171,7 @@ fn player_with_item( .unwrap() .clone(); let mut item = Item::create(item_id, &t, 1, 0, 1, &server.game_data.items, 0); + item.owner_id = u64::from(id); item.slot_type = slot_type::INVENTORY; item.slot = 0; let bag = p diff --git a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs index df60337e9e..b5b6b9e198 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs @@ -474,6 +474,7 @@ pub fn leave_extra_logout_ms(server: &GameServer, player: &PlayerRef) -> i32 { /// `EnterWorldManager.LeaveWorldTask` part: despawn the owned mates and slaves (the caller then /// closes coffers and calls [`force_dismount`], as the C# order). pub fn on_leave_world(server: &GameServer, player: &PlayerRef) { + let _items = server.systems.economy.operation_scope(); let Some(_departure) = server .systems .vehicles @@ -496,6 +497,7 @@ pub fn on_leave_world(server: &GameServer, player: &PlayerRef) { /// `GameConnection.OnDisconnect` part: `RemoveAndDespawnActiveOwnedMatesSlaves()` (owned mates /// now, the active vehicle 10 minutes later unless the character logs in again). pub fn on_disconnect(server: &GameServer, player: &PlayerRef) { + let _items = server.systems.economy.operation_scope(); let Some(_departure) = server .systems .vehicles @@ -534,13 +536,13 @@ pub fn force_dismount_and_despawn( let player = player.clone(); rt.spawn(async move { tokio::time::sleep(Duration::from_millis(time_to_despawn_ms)).await; + let _items = server.systems.economy.operation_scope(); let _publication = server .systems .vehicles .slave_summons - .departing - .lock() - .expect("slave departures poisoned"); + .publication_gate + .lock(); if slave.data().leave_task != gen { return; } @@ -577,6 +579,8 @@ pub fn force_dismount_and_despawn_test_slave( let (player, slave) = (player.clone(), slave.clone()); rt.spawn(async move { tokio::time::sleep(Duration::from_millis(time_to_despawn_ms)).await; + let _items = server.systems.economy.operation_scope(); + let _publication = server.systems.vehicles.slave_summons.publication_scope(); if slave.data().leave_task != gen { return; } diff --git a/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs index 0b5df802a7..1b5f8a1d14 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs @@ -15,6 +15,40 @@ const SECOND_SHIP_ITEM: u32 = 23400; fn identity_data() -> GameData { let mut data = ship_equip_data(); + for id in [511, 1205] { + data.systems + .vehicles + .model_types + .insert(id, (id, "ShipModel".into())); + data.systems.vehicles.ship_models.insert( + id, + super::super::data::ShipModel { + id, + mass: 100.0, + mass_box_size_x: 2.0, + mass_box_size_y: 6.0, + mass_box_size_z: 2.0, + ..Default::default() + }, + ); + } + use crate::systems::npcs::doodad::templates::{DoodadFuncGroups, DoodadTemplate}; + data.systems.npcs.doodad.templates.insert( + 3446, + DoodadTemplate { + id: 3446, + func_groups: [8264, 8265] + .into_iter() + .map(|id| DoodadFuncGroups { + id, + almighty: 3446, + group_kind_id: if id == 8264 { 1 } else { 2 }, + ..Default::default() + }) + .collect(), + ..Default::default() + }, + ); data.systems .vehicles .slave_templates @@ -184,6 +218,7 @@ fn install_memory_loader(server: &Arc) { mp: 10, }), children: Vec::new(), + ..Default::default() }) }) }))); @@ -219,6 +254,370 @@ async fn summon( slaves::create_for_owner(server, owner, item_id, template, false, None, None, 0.0).await } +fn saved_rack_row(parent: u32) -> crate::systems::npcs::doodad::db::DoodadRow { + crate::systems::npcs::doodad::db::DoodadRow { + id: 500, + owner_id: 1, + owner_type: doodad_owner_type::SLAVE, + attach_point: 60, + template_id: 3446, + current_phase_id: 8265, + plant_time: crate::db::min_value(), + growth_time: crate::db::min_value(), + phase_time: crate::db::min_value(), + x: 0.0, + y: 0.0, + z: 0.0, + roll: 0.0, + pitch: 0.0, + yaw: 0.0, + scale: 1.0, + item_id: 0, + house_id: parent, + parent_doodad: 0, + item_template_id: 0, + item_container_id: 0, + data: 0, + farm_type: 0, + interaction_counts: "{}".into(), + } +} + +async fn ordinary_mutation_waits_after_final_clone(destroy: bool) { + use crate::net::registry::ClientPacket; + use crate::systems::economy::inventory::{self, Inv, ItemTxn}; + use std::sync::mpsc; + let server = server_with(identity_data()); + install_memory_loader(&server); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let prior = root(&server, &owner, item_id, SHIP_HULL); + let (release, continuation) = mpsc::channel(); + let continuation = Mutex::new(continuation); + let (entered, ready) = tokio::sync::oneshot::channel(); + let entered = Mutex::new(Some(entered)); + *server + .systems + .vehicles + .slave_summons + .test_after_item_validation + .lock() + .unwrap() = Some(slaves::TestPublicationHook(Arc::new(move |server| { + assert!(!crate::systems::economy::System::ops_held_on_this_thread()); + // A callback may open its own normal transaction under the outer scope. + drop(ItemTxn::begin(server)); + entered.lock().unwrap().take().unwrap().send(()).unwrap(); + continuation + .lock() + .unwrap() + .recv_timeout(Duration::from_secs(5)) + .unwrap(); + }))); + let creation_server = server.clone(); + let creation_owner = owner.clone(); + let creation = tokio::spawn(async move { + summon(&creation_server, &creation_owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap() + .obj_id + }); + ready.await.unwrap(); + let mutation_server = server.clone(); + let mutation_owner = owner.clone(); + let runtime = tokio::runtime::Handle::current(); + let mutation = std::thread::spawn(move || { + let _runtime = runtime.enter(); + if destroy { + let mut client = TestClient::new(&mutation_server, 2, 1); + client.conn.active_char = Some(mutation_owner); + futures::executor::block_on( + crate::systems::economy::item_handlers::CSDestroyItemPacket { + item_id, + slot_type: slot_type::INVENTORY, + slot: 0, + count: 1, + } + .handle(&mutation_server, &mut client.conn), + ) + .unwrap(); + } else { + let mut txn = ItemTxn::begin(&mutation_server); + let inv = Inv::of(&mutation_owner); + assert!(inventory::split_or_move_item( + &mut txn, + &inv, + crate::models::item_task::task_type::SWAP_ITEMS, + item_id, + slot_type::INVENTORY, + 0, + 0, + slot_type::BANK, + 0, + 0 + )); + } + }); + server.systems.economy.wait_until_operation_blocked(); + assert_eq!(roots(&server, 1)[0].obj_id, prior.obj_id); + assert_eq!( + mates::owned_item(&server, &owner, item_id) + .unwrap() + .slot_type, + slot_type::INVENTORY + ); + release.send(()).unwrap(); + let published = creation.await.unwrap(); + mutation.join().unwrap(); + assert_ne!(published, prior.obj_id); + assert_eq!(roots(&server, 1)[0].obj_id, published); + let item = mates::owned_item(&server, &owner, item_id); + if destroy { + assert!(item.is_none()); + } else { + assert_eq!(item.unwrap().slot_type, slot_type::BANK); + } +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn ordinary_destroy_waits_until_ship_publication_finishes() { + ordinary_mutation_waits_after_final_clone(true).await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn ordinary_bank_move_waits_until_ship_publication_finishes() { + ordinary_mutation_waits_after_final_clone(false).await; +} + +#[tokio::test] +async fn missing_actual_metadata_update_fails_before_prior_hull_replacement() { + let server = server_with(identity_data()); + install_memory_loader(&server); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let prior = root(&server, &owner, item_id, SHIP_HULL); + let prior_state = prior.data().clone(); + let bag = owner.data().inventory.bag().clone(); + *server + .systems + .vehicles + .slave_summons + .test_after_item_validation + .lock() + .unwrap() = Some(slaves::TestPublicationHook(Arc::new(move |server| { + // Explicit limitation: unlocked quest-style writes do not enter the outer scope. + let mut txn = crate::systems::economy::inventory::ItemTxn::unlocked(server); + bag.lock() + .unwrap() + .remove_item_task( + crate::models::item_task::task_type::DESTROY, + item_id, + true, + &mut txn.env, + ) + .unwrap(); + }))); + client.drain(); + assert!(summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .is_none()); + assert_eq!(roots(&server, 1)[0].obj_id, prior.obj_id); + assert_eq!(*prior.data(), prior_state); + let packets = client.drain(); + for opcode in [ + sc::SCSlaveCreatedPacket, + sc::SCSlaveDespawnPacket, + sc::SCSlaveRemovedPacket, + ] { + assert!(!ops(&packets).contains(&opcode)); + } +} + +#[tokio::test] +async fn panic_after_final_validation_releases_publication_and_item_reservations() { + let server = server_with(identity_data()); + install_memory_loader(&server); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let prior = root(&server, &owner, item_id, SHIP_HULL); + *server + .systems + .vehicles + .slave_summons + .test_after_item_validation + .lock() + .unwrap() = Some(slaves::TestPublicationHook(Arc::new(|_| { + panic!("deliberate pre-publication panic") + }))); + let task_server = server.clone(); + let task_owner = owner.clone(); + let task = + tokio::spawn( + async move { summon(&task_server, &task_owner, item_id, SECOND_SHIP_ITEM).await }, + ); + assert!(task.await.unwrap_err().is_panic()); + assert_eq!(roots(&server, 1)[0].obj_id, prior.obj_id); + server + .systems + .vehicles + .slave_summons + .test_after_item_validation + .lock() + .unwrap() + .take(); + let retry = summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert_eq!(persistent_id(&retry), persistent_id(&prior)); + assert_eq!(roots(&server, 1).len(), 1); +} + +#[tokio::test] +async fn persistent_query_then_direct_despawn_cannot_publish_orphan_racks_or_physics() { + use crate::net::registry::ClientPacket; + use crate::systems::ai::physics; + let mut data = identity_data(); + data.systems.ai.ai.ship_models.insert( + 1205, + crate::systems::ai::data::ShipModel { + id: 1205, + mass: 100.0, + mass_box_size_x: 2.0, + mass_box_size_y: 6.0, + mass_box_size_z: 2.0, + water_density: 1000.0, + ..Default::default() + }, + ); + let server = server_with(data); + server.systems.ai.physics.set_manual_ticks(true); + install_memory_loader(&server); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + client.conn.active_char = Some(owner.clone()); + let prior = root(&server, &owner, item_id, MERCHANT); + let physics_world = server.systems.ai.physics.world(0).unwrap(); + physics::run_world_tick(&server, &physics_world, 40); + assert!(physics::ship_state(&server, prior.obj_id).is_some()); + let release = Arc::new(Semaphore::new(0)); + let entered = Arc::new(AtomicUsize::new(0)); + let (permits, calls, weak) = (release.clone(), entered.clone(), Arc::downgrade(&server)); + *server + .systems + .npcs + .spawns + .test_persistent_loader + .lock() + .unwrap() = Some(Arc::new(move |_, parent| { + let prepared = crate::systems::npcs::spawn_manager::PersistentDoodads::prepare( + &weak.upgrade().unwrap(), + vec![saved_rack_row(parent as u32)], + ) + .unwrap(); + calls.fetch_add(1, Ordering::SeqCst); + let permits = permits.clone(); + Box::pin(async move { + permits.acquire_owned().await.unwrap().forget(); + Ok(prepared) + }) + })); + client.drain(); + let mut creation = Box::pin(summon(&server, &owner, item_id, MERCHANT_ITEM)); + assert!(poll!(creation.as_mut()).is_pending()); + assert_eq!(entered.load(Ordering::SeqCst), 1); + super::super::packets::CSDespawnSlavePacket { + slave_obj_id: prior.obj_id, + } + .handle(&server, &mut client.conn) + .await + .unwrap(); + physics::run_world_tick(&server, &physics_world, 40); + assert!(physics::ship_state(&server, prior.obj_id).is_none()); + release.add_permits(1); + assert!(creation.await.is_none()); + physics::run_world_tick(&server, &physics_world, 40); + assert!(physics::ship_state(&server, prior.obj_id).is_none()); + assert!(roots(&server, 1).is_empty()); + assert!(server.world.world(0).unwrap().all_doodads().is_empty()); + assert!(server + .systems + .npcs + .spawns + .get(0) + .unwrap() + .get_all_player_doodads() + .is_empty()); + assert!(!ops(&client.drain()).contains(&sc::SCSlaveCreatedPacket)); +} + +#[tokio::test] +async fn persistent_query_failure_preserves_prior_hull_cargo_and_emits_no_creation() { + let server = server_with(identity_data()); + install_memory_loader(&server); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let prior = root(&server, &owner, item_id, MERCHANT); + let rack = loaded_rack(&server, &prior); + { + let mut rack = rack.data(); + rack.item_id = 0; + rack.item_template_id = 0; + } + let hull_before = prior.data().clone(); + let rack_before = rack.data().clone(); + let item_before = mates::owned_item(&server, &owner, item_id).unwrap(); + let calls = Arc::new(AtomicUsize::new(0)); + let queries = calls.clone(); + *server + .systems + .npcs + .spawns + .test_persistent_loader + .lock() + .unwrap() = Some(Arc::new(move |_, _| { + queries.fetch_add(1, Ordering::SeqCst); + Box::pin(async { anyhow::bail!("deliberate persistent doodad query failure") }) + })); + client.drain(); + assert!(summon(&server, &owner, item_id, MERCHANT_ITEM) + .await + .is_none()); + assert_eq!(calls.load(Ordering::SeqCst), 1); + assert_eq!(*prior.data(), hull_before); + assert_eq!(*rack.data(), rack_before); + assert_eq!( + mates::owned_item(&server, &owner, item_id).unwrap(), + item_before + ); + assert_eq!(roots(&server, 1)[0].obj_id, prior.obj_id); + assert_eq!(server.world.world(0).unwrap().all_doodads().len(), 1); + assert!(!ops(&client.drain()).contains(&sc::SCSlaveCreatedPacket)); +} + +#[tokio::test] +async fn persistent_batch_validation_and_stale_parent_have_no_world_side_effects() { + use crate::systems::npcs::spawn_manager::PersistentDoodads; + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let parent = root(&server, &owner, item_id, MERCHANT); + let row = saved_rack_row(persistent_id(&parent)); + let mut malformed = row.clone(); + malformed.id += 1; + malformed.interaction_counts = "invalid JSON".into(); + assert!(PersistentDoodads::prepare(&server, vec![row.clone(), malformed]).is_err()); + let prepared = PersistentDoodads::prepare(&server, vec![row]).unwrap(); + let world = server.world.world(0).unwrap(); + world.remove_object(parent.obj_id); + let replacement = Entity::new(parent.obj_id, parent.data().clone()); + world.spawn(&replacement, &server.view_ctx()); + let manager = server.systems.npcs.spawns.get(0).unwrap(); + assert!(manager + .publish_persistent_doodads(&server, prepared, Some(&WorldObject::from(&parent)), true) + .is_err()); + assert!(world.all_doodads().is_empty()); + assert!(manager.get_all_player_doodads().is_empty()); +} + #[tokio::test] async fn merchant_loaded_refusal_preserves_hull_rider_gunner_and_item_identity() { let server = server_with(identity_data()); @@ -721,14 +1120,36 @@ async fn private_mysql_ship_save_fence_query_failure_retry_and_restart() { } } let make_server = || { - let mut server = test_server_with(identity_data()); + let mut data = identity_data(); + data.systems + .vehicles + .attach_points + .get_mut(&511) + .unwrap() + .push((60, WorldSpawnPosition::default())); + data.systems + .vehicles + .slave_templates + .get_mut(&SHIP_HULL) + .unwrap() + .doodad_bindings + .push(super::super::data::SlaveDoodadBinding { + id: 1, + owner_id: SHIP_HULL, + owner_type: "Slave".into(), + attach_point_id: 60, + doodad_id: 3446, + persist: true, + scale: 1.0, + }); + let mut server = test_server_with(data); server.db = pool.clone(); let server = Arc::new(server); server.set_self(); server }; let server = make_server(); - let client = TestClient::new(&server, 1, 1); + let mut client = TestClient::new(&server, 1, 1); let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); let before = mates::owned_item(&server, &owner, item_id).unwrap(); // A genuine SQL error must not become "no row" and allocate/publish a new identity. @@ -773,6 +1194,56 @@ async fn private_mysql_ship_save_fence_query_failure_retry_and_restart() { .await .unwrap(); assert_eq!(count, 1); + let item_before_failed_racks = mates::owned_item(&server, &owner, item_id).unwrap(); + let hull_before_failed_racks = third.data().clone(); + server + .systems + .npcs + .doodads + .persistence + .flush() + .await + .unwrap(); + let rows_before_failed_racks: Vec<(u32, u32, u64)> = + sqlx::query_as("SELECT id, current_phase_id, item_id FROM doodads ORDER BY id") + .fetch_all(&pool) + .await + .unwrap(); + assert_eq!(rows_before_failed_racks.len(), 1); + client.drain(); + // The writer was drained. Fail the persistent SELECT itself: the saved rack must survive + // without a replacement/default persistent row being seeded. + sqlx::query("ALTER TABLE doodads RENAME COLUMN interaction_counts TO unavailable_counts") + .execute(&pool) + .await + .unwrap(); + assert!(summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .is_none()); + assert_eq!(*third.data(), hull_before_failed_racks); + assert_eq!( + mates::owned_item(&server, &owner, item_id).unwrap(), + item_before_failed_racks + ); + assert!(!ops(&client.drain()).contains(&sc::SCSlaveCreatedPacket)); + let rack_count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM doodads") + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!( + rack_count, 1, + "a failed rack query must not seed default persistent rows" + ); + let rows_after_failed_racks: Vec<(u32, u32, u64)> = + sqlx::query_as("SELECT id, current_phase_id, item_id FROM doodads ORDER BY id") + .fetch_all(&pool) + .await + .unwrap(); + assert_eq!(rows_after_failed_racks, rows_before_failed_racks); + sqlx::query("ALTER TABLE doodads RENAME COLUMN unavailable_counts TO interaction_counts") + .execute(&pool) + .await + .unwrap(); { let _transaction = server.save.transaction_lock().await; let mut tx = pool.begin().await.unwrap(); diff --git a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs index 7ca0047fdb..13c0cb6b0f 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs @@ -5,7 +5,7 @@ //! Locking: one object data lock at a time; world calls never hold a data lock. use std::collections::HashMap; -use std::sync::{Arc, Mutex, MutexGuard, Weak}; +use std::sync::{Arc, Mutex, Weak}; use dashmap::DashMap; use rand::Rng; @@ -15,7 +15,7 @@ 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::item_task::{task_type, ItemTask}; use crate::models::slave::Slave; use crate::models::transform::Transform; use crate::models::unit::{BaseUnitType, Bonus}; @@ -78,9 +78,13 @@ enum SummonKey { pub(crate) struct SlaveSummons { reservations: Mutex>>>, pub(super) departing: Mutex>, + /// Serializes complete synchronous hull publication/removal, including nested callbacks. + pub(super) publication_gate: spawn_manager::ReentrantLock, pending_saves: Mutex>>>, #[cfg(test)] pub(crate) test_loader: Mutex>, + #[cfg(test)] + pub(crate) test_after_item_validation: Mutex>, } #[cfg(test)] @@ -98,7 +102,22 @@ impl std::fmt::Debug for TestSlaveLoader { } } +#[cfg(test)] +#[derive(Clone)] +pub(crate) struct TestPublicationHook(pub Arc); + +#[cfg(test)] +impl std::fmt::Debug for TestPublicationHook { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("TestPublicationHook") + } +} + impl SlaveSummons { + pub(crate) fn publication_scope(&self) -> spawn_manager::ReentrantGuard<'_> { + self.publication_gate.lock() + } + fn reservation(&self, key: SummonKey) -> Arc> { let mut locks = self .reservations @@ -117,21 +136,23 @@ impl SlaveSummons { &'a self, server: &GameServer, player: &PlayerRef, - ) -> Option>> { + ) -> Option> { + let publication = self.publication_gate.lock(); let state = self.departing.lock().expect("slave departures poisoned"); if state.get(&player.character_id) == Some(&player.conn.id) || !current_session(server, player) { return None; } - Some(state) + Some(publication) } pub(super) fn departure<'a>( &'a self, server: &GameServer, player: &PlayerRef, - ) -> Option>> { + ) -> Option> { + let publication = self.publication_gate.lock(); let mut state = self.departing.lock().expect("slave departures poisoned"); if !current_session(server, player) || state.get(&player.character_id) == Some(&player.conn.id) @@ -139,15 +160,18 @@ impl SlaveSummons { return None; } state.insert(player.character_id, player.conn.id); - Some(state) + Some(publication) } pub(super) fn reconnect(&self, server: &GameServer, player: &PlayerRef) { + let _items = server.systems.economy.operation_scope(); + let _publication = self.publication_gate.lock(); let mut state = self.departing.lock().expect("slave departures poisoned"); if !current_session(server, player) { return; } state.remove(&player.character_id); + drop(state); for (world, root) in owned_roots(server, player.character_id) { let (children, doodads) = { let mut d = root.data(); @@ -1573,6 +1597,13 @@ fn try_delete( obj_id: u32, ignore_attached_item_warning: bool, ) -> bool { + let _items = server.systems.economy.operation_scope(); + let _publication = server + .systems + .vehicles + .slave_summons + .publication_gate + .lock(); let Some(world) = server.world.world(instance_id) else { return false; }; @@ -1837,6 +1868,7 @@ pub struct SavedChildSlave { pub(crate) struct LoadedHull { pub(crate) saved: Option, pub(crate) children: Vec, + pub(crate) doodads: spawn_manager::PersistentDoodads, } fn owned_summon_item( @@ -2154,7 +2186,7 @@ async fn create_with_placement( .map(|(_, s)| s.data().summoning_item_id) .collect(); flush_items.push(item.id); - match load_hull(server, owner_id, item, &flush_items).await { + match load_hull(server, world, owner_id, item, template_id, &flush_items).await { Ok(loaded) => loaded, Err(e) => { tracing::error!("SlaveManager.Create({owner_id}, {}): {e}", item.id); @@ -2164,7 +2196,29 @@ async fn create_with_placement( } else { LoadedHull::default() }; - let spawned = { + if loaded.saved.as_ref().is_some_and(|saved| saved.id == 0) { + tracing::error!("Saved hull has no persistent identity"); + return None; + } + for child in &loaded.children { + if child.id == 0 + || server + .game_data + .systems + .vehicles + .slave_template(child.template_id) + .is_none() + { + tracing::error!( + "Saved slave child {} has invalid template {}", + child.id, + child.template_id + ); + return None; + } + } + { + let _items = server.systems.economy.operation_scope(); let _publication = match owner { Some(owner) => Some(summons.publication(server, owner)?), None => None, @@ -2182,7 +2236,29 @@ async fn create_with_placement( } item = Some(fresh); } + #[cfg(test)] + { + let hook = summons + .test_after_item_validation + .lock() + .expect("test publication hook poisoned") + .clone(); + if let Some(hook) = hook { + (hook.0)(server); + } + } if let Some(owner) = owner { + let current = owned_roots(server, owner_id); + if current.len() != prior.len() + || prior.iter().any(|(world, slave)| { + !world + .slave(slave.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, slave)) + || !current.iter().any(|(_, live)| Arc::ptr_eq(live, slave)) + }) + { + return None; + } if placement.is_some() { let template = server .game_data @@ -2200,13 +2276,35 @@ async fn create_with_placement( { return None; } - for (w, s) in prior { + } + // Commit the actual item update before altering the prior hull. A missing or moved + // source (including an unlocked quest mutation) must fail at this boundary. + let committed = if let (Some(owner), Some(item)) = (owner, &item) { + let new_id = loaded.saved.is_none(); + let db_id = match &loaded.saved { + Some(saved) => saved.id, + None => server.ids.character.get_next_id().ok()?, + }; + match commit_summon_item(server, owner, item, db_id) { + Some(committed) => Some(committed), + None => { + if new_id { + server.ids.character.release_id(db_id); + } + return None; + } + } + } else { + None + }; + if let Some(owner) = owner { + for (w, s) in owned_roots(server, owner_id) { if !try_delete(server, Some(owner), w.id, s.obj_id, false) { return None; } } } - create_spawn( + let spawned = create_spawn_committed( server, world, owner, @@ -2216,57 +2314,47 @@ async fn create_with_placement( hide_spawn_effect, position_override, loaded.saved, - )? - }; - let db_id = spawned.slave.data().id; - if spawned.is_loaded { - // If this was a previously saved slave, load doodads from DB and spawn them - if let Some(sm) = spawn_manager_of(server, world.id) { - match sm - .spawn_persistent_doodads( - server, - doodad_owner_type::SLAVE, - i64::from(db_id), - Some(&WorldObject::from(&spawned.slave)), - true, - ) - .await - { - Ok(n) => tracing::debug!( - "Loaded {n} doodads from DB for Slave {} (Db: {db_id}", - spawned.slave.obj_id - ), - Err(e) => tracing::error!("SpawnPersistentDoodads (slave {db_id}): {e}"), + committed, + )?; + if spawned.is_loaded { + let manager = server.systems.npcs.spawns.get_or_create(world); + if let Err(error) = manager.publish_persistent_doodads( + server, + loaded.doodads, + Some(&WorldObject::from(&spawned.slave)), + true, + ) { + tracing::error!("Publish persistent slave doodads: {error}"); + return None; } } + if !world + .slave(spawned.slave.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, &spawned.slave)) + { + return None; + } + finish_create( + server, + world, + owner, + &spawned.slave, + &spawned.template, + item.as_ref(), + spawned.is_loaded, + loaded.children, + ) } - // The hull was published before any departure can scan it. A delayed DB load must not - // finish an already removed hull (including adding it back to boat physics). - let _publication = summons.departing.lock().expect("slave departures poisoned"); - if !world - .slave(spawned.slave.obj_id) - .is_some_and(|s| Arc::ptr_eq(&s, &spawned.slave)) - { - return None; - } - finish_create( - server, - world, - owner, - &spawned.slave, - &spawned.template, - item.as_ref(), - spawned.is_loaded, - loaded.children, - ) } async fn load_hull( server: &GameServer, + world: &Arc, owner_id: u32, item: &Item, + template_id: u32, flush_items: &[u64], -) -> sqlx::Result { +) -> anyhow::Result { #[cfg(test)] { let loader = server @@ -2278,7 +2366,8 @@ async fn load_hull( .expect("test slave loader poisoned") .clone(); if let Some(loader) = loader { - return (loader.0)(owner_id, item.id).await; + let loaded = (loader.0)(owner_id, item.id).await?; + return load_hull_doodads(server, world, loaded).await; } } let _transaction = server.save.transaction_lock().await; @@ -2286,12 +2375,45 @@ async fn load_hull( flush_pending_save(server, item_id).await?; } server.systems.npcs.doodads.persistence.flush().await?; - let saved = load_saved_slave(server, owner_id, item.id, item.details.slave_db_id).await?; + let saved = load_saved_slave( + server, + owner_id, + item.id, + item.details.slave_db_id, + template_id, + ) + .await?; let children = match &saved { Some(saved) => load_saved_children(server, saved.id, owner_id).await?, None => Vec::new(), }; - Ok(LoadedHull { saved, children }) + load_hull_doodads( + server, + world, + LoadedHull { + saved, + children, + ..Default::default() + }, + ) + .await +} + +async fn load_hull_doodads( + server: &GameServer, + world: &Arc, + mut loaded: LoadedHull, +) -> anyhow::Result { + if let Some(saved) = &loaded.saved { + loaded.doodads = server + .systems + .npcs + .spawns + .get_or_create(world) + .fetch_persistent_doodads(server, doodad_owner_type::SLAVE, i64::from(saved.id)) + .await?; + } + Ok(loaded) } async fn load_saved_slave( @@ -2299,9 +2421,10 @@ async fn load_saved_slave( owner_id: u32, item_id: u64, preferred_id: u32, + template_id: u32, ) -> sqlx::Result> { let r = sqlx::query( - "SELECT CAST(id AS UNSIGNED) AS id, name, CAST(hp AS SIGNED) AS hp, CAST(mp AS SIGNED) AS mp \ + "SELECT CAST(id AS UNSIGNED) AS id, CAST(template_id AS UNSIGNED) AS template_id, name, CAST(hp AS SIGNED) AS hp, CAST(mp AS SIGNED) AS mp \ FROM slaves WHERE (owner_type = 0) AND (owner_id = ?) AND (summoner = ?) AND (item_id = ?) \ ORDER BY (id = ?) DESC, id LIMIT 1", ) @@ -2312,6 +2435,11 @@ async fn load_saved_slave( .fetch_optional(&server.db) .await?; r.map(|r| { + if r.try_get::, _>("template_id")? != Some(u64::from(template_id)) { + return Err(sqlx::Error::Protocol( + "saved hull does not match its summon item template".into(), + )); + } Ok(SavedSlave { id: r.try_get::("id")? as u32, name: r.try_get::, _>("name")?.unwrap_or_default(), @@ -2473,6 +2601,52 @@ fn repair_seconds_left(item: &Item, now: i64) -> Option { (left > 0).then_some(left) } +struct CommittedSummonItem { + db_id: u32, + task: ItemTask, +} + +fn commit_summon_item( + server: &GameServer, + owner: &PlayerRef, + source: &Item, + db_id: u32, +) -> Option { + let result = { + let _ops = server.systems.economy.ops_lock(); + super::mates::update_owned_item(server, Some(owner), source.id, |item| { + if item.id != source.id + || item.template_id != source.template_id + || item.owner_id != u64::from(owner.character_id) + || item.class != ItemClass::SummonSlave + || item.slot_type != slot_type::INVENTORY + { + return Err(None); + } + if let Some(left) = repair_seconds_left(item, chrono::Utc::now().timestamp()) { + return Err(Some(left)); + } + item.details.slave_type = 0x02; + item.details.slave_db_id = db_id; + item.details.slave_repair_start_time = 0; + item.dirty = true; + Ok(super::packets::item_update(item)) + }) + }; + match result { + Some(Ok(task)) => Some(CommittedSummonItem { db_id, task }), + Some(Err(Some(left))) => { + owner.send(crate::packets::world::SCErrorMsgPacket::new( + error::SLAVE_SPAWN_ERROR_NEED_REPAIR_TIME, + left as u32, + true, + )); + None + } + Some(Err(None)) | None => None, + } +} + /// The first half of `Create`: template, position, summon item checks, `SCSlaveCreatedPacket`, /// the slave itself (bonuses, HP / MP, initial items) and `Spawn()`. `saved` is the /// `load_saved_slave` row (owner + item only). @@ -2487,6 +2661,33 @@ pub(crate) fn create_spawn( hide_spawn_effect: bool, position_override: Option, saved: Option, +) -> Option { + create_spawn_committed( + server, + world, + owner, + spawner, + template_id, + item, + hide_spawn_effect, + position_override, + saved, + None, + ) +} + +#[allow(clippy::too_many_arguments)] +fn create_spawn_committed( + server: &GameServer, + world: &Arc, + owner: Option<&PlayerRef>, + spawner: Option<&Arc>, + template_id: u32, + item: Option, + hide_spawn_effect: bool, + position_override: Option, + saved: Option, + committed: Option, ) -> Option { let data = &server.game_data.systems.vehicles; let template = data @@ -2633,44 +2834,25 @@ pub(crate) fn create_spawn( spawn_pos.rot_z = yaw; } + if let Some(committed) = &committed { + db_id = committed.db_id; + } // Get new Id to save if it has a player as owner if owner_id > 0 && db_id == 0 { db_id = server.ids.character.get_next_id().ok()?; } - // Update the summoning item - if let (Some(it), Some(o)) = (&item, owner) { - if it.class == ItemClass::SummonSlave { - let now = chrono::Utc::now().timestamp(); - let res = super::mates::update_owned_item(server, Some(o), it.id, |i| { - if let Some(left) = repair_seconds_left(i, now) { - return Err(left as f64); - } - i.details.slave_type = 0x02; - i.details.slave_db_id = db_id; - // SummonLocation (not part of the 1.2 detail bytes); RepairStartTime = MinValue - i.details.slave_repair_start_time = 0; - i.dirty = true; - Ok(super::packets::item_update(i)) - }); - match res { - Some(Err(left)) => { - // Slave was destroyed and is on cooldown - o.send(crate::packets::world::SCErrorMsgPacket::new( - error::SLAVE_SPAWN_ERROR_NEED_REPAIR_TIME, - left.round_ties_even() as u32, - true, - )); - return None; - } - Some(Ok(task)) => o.send(SCItemTaskSuccessPacket { - action: item_task_type::UPDATE_SUMMON_MATE_ITEM, - tasks: vec![task], - force_remove: Vec::new(), - }), - None => {} - } - } + let committed = match (committed, &item, owner) { + (Some(committed), _, _) => Some(committed), + (None, Some(item), Some(owner)) => Some(commit_summon_item(server, owner, item, db_id)?), + _ => None, + }; + if let (Some(committed), Some(owner)) = (committed, owner) { + owner.send(SCItemTaskSuccessPacket { + action: item_task_type::UPDATE_SUMMON_MATE_ITEM, + tasks: vec![committed.task], + force_remove: Vec::new(), + }); } // Create the Slave (packet) @@ -3316,6 +3498,8 @@ pub fn do_die( killer: Option<&WorldObject>, kill_reason: KillReason, ) { + let _items = server.systems.economy.operation_scope(); + let _publication = server.systems.vehicles.slave_summons.publication_scope(); let obj = WorldObject::from(slave); crate::systems::skills::skill::interrupt_skills(server, &obj); crate::systems::skills::buffs::fire_unit_event( From 293749f80084c0dac4b02426036117682927f663 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:27:00 -0400 Subject: [PATCH 45/66] docs(audit): record selected data and lobby database checks --- rust/docs/audit-repair-status.json | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json index c6c45a6eae..37be750e48 100644 --- a/rust/docs/audit-repair-status.json +++ b/rust/docs/audit-repair-status.json @@ -436,6 +436,27 @@ "round": 3, "result": "no_new_actionable_P1_P2_within_documented_conservative_policy", "execution": "pending" + }, + "cargo_integrated_game_build": { + "head": "8db0e003df5c329d9ee6522b09a26d0c7158dfc0", + "result": "held_at_memory_reserve_before_tests", + "minimum_free_gib": 7.936, + "native_diagnostics": "none before guard stopped the owned compiler subtree" + }, + "selected_ignored_snapshot_checks": { + "binary_head": "1f53a66bdd0ab289ae2a26abbbaff084cddfcaff", + "binary_sha256": "836cf147a09b999582e302e8dae807cbd6d867e65a99da120abaa3ccc1009230", + "scope": "previously compiled snapshot; not final-head acceptance", + "compact_passed": 9, + "private_mysql_lobby_passed": 3, + "mail_expiry": "fixture signed/unsigned decode mismatch found; fixed da8e370ba, rebuilt execution pending", + "database_scope": "private 3317 lane_audit_final_game; connection-local temporary tables" + }, + "remote_checks": { + "head": "5dfd7282b71ec84655b44b861b24991502dd5ff2", + "passed": 12, + "failed": 0, + "scope": "draft PR46 before cargo integration" } } } From 06d68e55ab0af11fd17813a0a851e2f1ce6a7943 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:32:14 -0400 Subject: [PATCH 46/66] feat(testclient): add bounded JSONL stdio control sessions --- rust/crates/aaemu-testclient/src/control.rs | 927 +++++++++++++++++++ rust/crates/aaemu-testclient/src/game.rs | 139 ++- rust/crates/aaemu-testclient/src/main.rs | 20 +- rust/crates/aaemu-testclient/src/record.rs | 230 ++++- rust/crates/aaemu-testclient/src/scenario.rs | 195 +++- 5 files changed, 1468 insertions(+), 43 deletions(-) create mode 100644 rust/crates/aaemu-testclient/src/control.rs diff --git a/rust/crates/aaemu-testclient/src/control.rs b/rust/crates/aaemu-testclient/src/control.rs new file mode 100644 index 0000000000..9f38e48b37 --- /dev/null +++ b/rust/crates/aaemu-testclient/src/control.rs @@ -0,0 +1,927 @@ +//! Bounded stdio controller, using the same session and packet paths as scenarios. +//! +//! First send `{"protocol":"aaemu-control/1","id":1,"method":"hello","params":{}}`. +//! Its response is the ready boundary. Every subsequent request has the same envelope and +//! a unique string (1..64 bytes) or unsigned integer id. All params objects are strict. +//! Stdout contains only versioned responses, independent game events and lifecycle records; +//! tracing goes to stderr. Events preceding a response have `seq <= response.event_seq`. +//! This boundary orders observations; it does not imply that a server action has settled. + +use std::collections::HashSet; +use std::future::Future; +use std::io::{BufRead, Write}; +use std::path::Path; +use std::time::Duration; + +use aaemu_game::opcodes::cs; +use aaemu_testclient::record::Recorder; +use aaemu_testclient::scenario::{self, BotConfig, ControlSession}; +use anyhow::{bail, ensure, Context}; +use serde::{Deserialize, Serialize}; +use serde_json::{json, Value}; +use tokio::sync::{mpsc, oneshot}; +use tokio::time::Instant; + +const PROTOCOL: &str = "aaemu-control/1"; +const MAX_LINE: usize = 16 * 1024; +const MAX_BODY: usize = 4096; +const MAX_GM: usize = 1024; +const MAX_COMMANDS: usize = 4096; +const MAX_PUMP_MS: u64 = 5000; +const MAX_DEADLINE_MS: u64 = 600_000; +const COMMAND_TIMEOUT: Duration = Duration::from_secs(5); +const CONNECT_TIMEOUT: Duration = Duration::from_secs(60); + +pub(crate) fn describe() -> Value { + json!({ + "protocol": PROTOCOL, + "methods": ["hello", "pump", "gm", "tp", "rawcs", "state", + "disconnect_hard", "reconnect", "close"], + "request": {"protocol": PROTOCOL, "id": 1, "method": "hello", "params": {}}, + "params": { + "hello": {}, "pump": {"ms": "u64 <= 5000"}, + "gm": {"command": "GM command without leading slash"}, + "tp": {"x": "finite f32", "y": "finite f32", "z": "finite f32"}, + "rawcs": {"opcode": "literal u16", "body_hex": "contiguous hex"}, + "state": {}, "disconnect_hard": {}, + "reconnect": {"character_id": "previous ready character_id (u32)"}, "close": {} + }, + "limits": { + "line_bytes": MAX_LINE, "body_bytes": MAX_BODY, "gm_bytes": MAX_GM, + "id_bytes": 64, "commands": MAX_COMMANDS, "pump_ms": MAX_PUMP_MS, + "command_ms": COMMAND_TIMEOUT.as_millis(), + "connect_ms": CONNECT_TIMEOUT.as_millis(), "deadline_ms": MAX_DEADLINE_MS, + "event_queue_bytes": 8 * 1024 * 1024, "event_queue_count": 2048 + }, + "incremental_game_capture": true, + "capture_create_new": true, + "auth_frames_omitted": true, + "capture_start": "post-lobby character select/spawn (each session)", + "handshake_before_network": true, + "initial_character": "existing configured name, never first/create", + "state_source": "client_observation", + "automatic_retry": false, + "hard_close": "local game write/read halves and stream; no CSLeaveWorld; FIN/RST, not logout", + "completion": "one response per input line; event_seq is an observation boundary", + "cleanup": "close, EOF, input/output failure or deadline closes only this session" + }) +} + +#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)] +#[serde(untagged)] +enum RequestId { + Number(u64), + Text(String), +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Request { + protocol: String, + id: RequestId, + method: String, + #[serde(deserialize_with = "unique_params")] + params: Value, +} + +fn unique_params<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result { + struct Params; + impl<'de> serde::de::Visitor<'de> for Params { + type Value = Value; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("a params object with unique keys") + } + + fn visit_map>(self, mut map: M) -> Result { + let mut values = serde_json::Map::new(); + while let Some(key) = map.next_key::()? { + if values.contains_key(&key) { + return Err(serde::de::Error::custom("duplicate param")); + } + values.insert(key, map.next_value()?); + } + Ok(Value::Object(values)) + } + } + deserializer.deserialize_map(Params) +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Empty {} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Pump { + ms: u64, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Gm { + command: String, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Tp { + x: f32, + y: f32, + z: f32, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct RawCs { + opcode: u16, + body_hex: String, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Reconnect { + character_id: u32, +} + +enum Command { + Hello, + Pump(Pump), + Gm(Gm), + Tp(Tp), + RawCs(u16, Vec), + State, + DisconnectHard, + Reconnect(u32), + Close, +} + +struct Rejected { + id: Option, + code: &'static str, + fatal: bool, +} + +fn command(request: &Request) -> anyhow::Result { + let params = request.params.clone(); + Ok(match request.method.as_str() { + "hello" | "state" | "disconnect_hard" | "close" => { + serde_json::from_value::(params)?; + match request.method.as_str() { + "hello" => Command::Hello, + "state" => Command::State, + "disconnect_hard" => Command::DisconnectHard, + _ => Command::Close, + } + } + "pump" => { + let p: Pump = serde_json::from_value(params)?; + ensure!(p.ms <= MAX_PUMP_MS, "pump limit"); + Command::Pump(p) + } + "gm" => { + let p: Gm = serde_json::from_value(params)?; + ensure!( + !p.command.trim().is_empty() + && p.command.len() <= MAX_GM + && !p.command.starts_with('/') + && !p.command.chars().any(char::is_control), + "GM command limit/format" + ); + Command::Gm(p) + } + "tp" => { + let p: Tp = serde_json::from_value(params)?; + ensure!( + p.x.is_finite() && p.y.is_finite() && p.z.is_finite(), + "position" + ); + Command::Tp(p) + } + "rawcs" => { + let p: RawCs = serde_json::from_value(params)?; + ensure!(p.body_hex.len() <= MAX_BODY * 2, "raw body limit"); + // Authentication belongs exclusively to the shared session implementation. + ensure!(p.opcode != cs::X2EnterWorldPacket, "authentication packet"); + Command::RawCs(p.opcode, hex::decode(p.body_hex)?) + } + "reconnect" => { + let p: Reconnect = serde_json::from_value(params)?; + ensure!(p.character_id != 0, "character id 0"); + Command::Reconnect(p.character_id) + } + _ => bail!("unknown method"), + }) +} + +/// Errors deliberately contain no request body, config value, credential or packet bytes. +fn parse(line: &[u8]) -> Result<(RequestId, Command), Rejected> { + if line.len() > MAX_LINE { + return Err(Rejected { + id: None, + code: "line_limit", + fatal: true, + }); + } + let r: Request = serde_json::from_slice(line).map_err(|_| Rejected { + id: None, + code: "invalid_request", + fatal: false, + })?; + let reject = |code, fatal| Rejected { + id: Some(r.id.clone()), + code, + fatal, + }; + if r.protocol != PROTOCOL { + return Err(reject("protocol_mismatch", true)); + } + if matches!(&r.id, RequestId::Text(s) if s.is_empty() || s.len() > 64) { + return Err(Rejected { + id: None, + code: "invalid_id", + fatal: false, + }); + } + let cmd = command(&r).map_err(|_| reject("invalid_method_or_params", false))?; + Ok((r.id, cmd)) +} + +/// Bounded even if the sender never terminates an oversized line. A partial final line is +/// rejected, so EOF cannot turn a truncated gameplay request into a command. +fn read_line(reader: &mut impl BufRead) -> Result>, &'static str> { + let mut line = Vec::new(); + loop { + let bytes = reader.fill_buf().map_err(|_| "input_io")?; + if bytes.is_empty() { + return if line.is_empty() { + Ok(None) + } else { + Err("truncated_line") + }; + } + let newline = bytes.iter().position(|&b| b == b'\n'); + let len = newline.unwrap_or(bytes.len()); + if len > MAX_LINE.saturating_sub(line.len()) { + return Err("line_limit"); + } + line.extend_from_slice(&bytes[..len]); + reader.consume(len + usize::from(newline.is_some())); + if newline.is_some() { + if line.last() == Some(&b'\r') { + line.pop(); + } + return Ok(Some(line)); + } + } +} + +enum Input { + Line(Vec), + End, + Fault(&'static str), +} + +struct Output { + bytes: Vec, + ack: oneshot::Sender>, +} + +/// Detached, bounded stdio workers avoid Tokio's uncancellable blocking stdin read keeping +/// the runtime alive after deadline. They own no sockets and are never joined on shutdown. +fn stdio() -> anyhow::Result<(mpsc::Receiver, mpsc::Sender)> { + let (input_tx, input_rx) = mpsc::channel(1); + std::thread::Builder::new() + .name("control-input".into()) + .spawn(move || { + let mut stdin = std::io::stdin().lock(); + loop { + let message = match read_line(&mut stdin) { + Ok(Some(line)) => Input::Line(line), + Ok(None) => Input::End, + Err(code) => Input::Fault(code), + }; + let terminal = !matches!(&message, Input::Line(_)); + if input_tx.blocking_send(message).is_err() || terminal { + break; + } + } + })?; + let (output_tx, mut output_rx) = mpsc::channel::(1); + // Use an owned OS handle rather than holding Rust's global stdout lock. A blocked + // writer must not prevent runtime/process cleanup after its acknowledgement times out. + #[cfg(windows)] + let mut stdout = { + use std::os::windows::io::AsHandle; + std::fs::File::from(std::io::stdout().as_handle().try_clone_to_owned()?) + }; + #[cfg(unix)] + let mut stdout = { + use std::os::fd::AsFd; + std::fs::File::from(std::io::stdout().as_fd().try_clone_to_owned()?) + }; + #[cfg(not(any(windows, unix)))] + let mut stdout = std::io::stdout(); + std::thread::Builder::new() + .name("control-output".into()) + .spawn(move || { + while let Some(out) = output_rx.blocking_recv() { + let result = stdout.write_all(&out.bytes).and_then(|()| stdout.flush()); + let failed = result.is_err(); + let _ = out.ack.send(result); + if failed { + break; + } + } + })?; + Ok((input_rx, output_tx)) +} + +struct Reporter { + output: mpsc::Sender, + deadline: Instant, + seq: u64, +} + +impl Reporter { + async fn write(&mut self, mut value: Value) -> anyhow::Result<()> { + value["protocol"] = PROTOCOL.into(); + let mut bytes = serde_json::to_vec(&value)?; + bytes.push(b'\n'); + let (ack, completed) = oneshot::channel(); + // A blocked/broken output must not hold game sockets indefinitely. Allow a small + // terminal reporting window after the network deadline; no gameplay runs then. + let until = (Instant::now() + Duration::from_secs(1)) + .min(self.deadline + Duration::from_millis(200)); + tokio::time::timeout_at(until, async { + self.output + .send(Output { bytes, ack }) + .await + .context("stdout worker closed")?; + completed.await.context("stdout worker stopped")??; + Ok::<_, anyhow::Error>(()) + }) + .await + .context("stdout deadline")??; + Ok(()) + } + + async fn events(&mut self, rec: &Recorder) -> anyhow::Result<()> { + for event in rec.take_live_events()? { + self.seq += 1; + self.write(json!({"type": "event", "seq": self.seq, "event": event})) + .await?; + } + Ok(()) + } + + async fn response( + &mut self, + id: Option, + result: Result, + ) -> anyhow::Result<()> { + let value = match result { + Ok(value) => json!({"type": "response", "id": id, "ok": true, + "result": value, "event_seq": self.seq}), + Err(code) => json!({"type": "response", "id": id, "ok": false, + "error": {"code": code}, "event_seq": self.seq}), + }; + self.write(value).await + } +} + +struct Controller { + cfg: BotConfig, + rec: Recorder, + session: Option, + handshaken: bool, + character_id: Option, + generation: u32, + started: Instant, + clock: u32, +} + +fn reconnect_allowed(connected: bool, previous: Option, requested: u32) -> bool { + !connected && requested != 0 && previous == Some(requested) +} + +impl Controller { + fn state(&self) -> Value { + let observed = self.session.as_ref().map(|session| { + let game = &session.game; + json!({ + "account_id": game.account_id, "character_id": game.state.selected_char, + "self_obj": game.state.self_obj, "position": game.state.observed_self_pos, + "position_source": "SCUnitState/SCOneUnitMovement/SCTeleportUnit", + "observation_seq": game.state.observation_seq, + "observation_errors": game.state.observation_errors, + "units_seen": game.state.units.len(), "doodads_seen": game.state.doodads.len() + }) + }); + json!({"source": "client_observation", "authoritative": false, + "connected": self.session.is_some(), "character_id": self.character_id, + "session_generation": self.generation, + "sampled_t_ms": self.started.elapsed().as_millis(), "observed": observed}) + } + + async fn disconnect(&mut self, reason: &str) -> Value { + let old = self.session.take(); + let old_self_obj = old.as_ref().map(|s| s.game.state.self_obj); + let had_session = old.is_some(); + if let Some(ControlSession { game, stream, .. }) = old { + // StreamClient owns one unsplit socket and no background task. + drop(stream); + game.disconnect_hard().await; + } + json!({"reason": reason, "t_ms": self.started.elapsed().as_millis(), + "session_generation": self.generation, "old_self_obj": old_self_obj, + "had_session": had_session, "game_read_closed": had_session, + "game_write_closed": had_session, "stream_closed": had_session, + "closure_scope": "local socket handles", "sent_leave_world": false}) + } + + async fn execute(&mut self, cmd: Command) -> anyhow::Result { + match cmd { + Command::Hello => { + ensure!(!self.handshaken, "already handshaken"); + self.handshaken = true; + let session = scenario::connect_control(&self.cfg, &self.rec, None).await?; + self.character_id = Some(session.game.state.selected_char); + self.generation += 1; + self.session = Some(session); + Ok(json!({"ready": true, "state": self.state()})) + } + Command::Reconnect(id) => { + ensure!( + reconnect_allowed(self.session.is_some(), self.character_id, id), + "reconnect identity/session" + ); + let session = scenario::connect_control(&self.cfg, &self.rec, Some(id)).await?; + self.generation += 1; + self.session = Some(session); + Ok(json!({"ready": true, "state": self.state()})) + } + Command::State => Ok(self.state()), + Command::DisconnectHard => { + self.rec.flush_live()?; + Ok(self.disconnect("disconnect_hard").await) + } + Command::Close => { + let closed = self.disconnect("close").await; + self.rec.flush_live()?; + Ok(closed) + } + command => { + let game = &mut self.session.as_mut().context("no connected session")?.game; + match command { + Command::Pump(p) => { + let until = Instant::now() + Duration::from_millis(p.ms); + while Instant::now() < until { + game.recv_within(until.saturating_duration_since(Instant::now())) + .await?; + } + } + Command::Gm(p) => scenario::control_gm(game, &p.command).await?, + Command::Tp(p) => { + self.clock = self.clock.wrapping_add(1500); + scenario::control_tp(game, p.x, p.y, p.z, self.clock).await?; + } + Command::RawCs(opcode, body) => game.send_cs(opcode, &body).await?, + _ => unreachable!("handled lifecycle method"), + } + // Control consumers use raw events, not scenario-specific accumulated histories. + game.state.events.clear(); + game.state.social.clear(); + Ok(self.state()) + } + } + } + + async fn idle(&mut self) -> anyhow::Result<()> { + if let Some(session) = self.session.as_mut() { + for _ in 0..128 { + if session + .game + .recv_within(Duration::from_millis(1)) + .await? + .is_none() + { + break; + } + } + session.game.state.events.clear(); + session.game.state.social.clear(); + } + Ok(()) + } +} + +enum Completion { + Done(anyhow::Result), + Stopped(&'static str), +} + +/// Keep capture/event delivery and EOF detection alive while the shared session code runs. +/// One look-ahead command is allowed; subsequent input remains backpressured. +async fn drive( + future: impl Future>, + until: Instant, + rec: &Recorder, + report: &mut Reporter, + input: &mut mpsc::Receiver, + pending: &mut Option, +) -> anyhow::Result { + tokio::pin!(future); + let mut tick = tokio::time::interval(Duration::from_millis(20)); + loop { + tokio::select! { + biased; + _ = tokio::time::sleep_until(until) => return Ok(Completion::Stopped("command_deadline")), + result = &mut future => return Ok(Completion::Done(result)), + message = input.recv(), if pending.is_none() => match message { + Some(line @ Input::Line(_)) => *pending = Some(line), + Some(Input::Fault(code)) => return Ok(Completion::Stopped(code)), + Some(Input::End) | None => return Ok(Completion::Stopped("eof")), + }, + _ = tick.tick() => report.events(rec).await?, + } + } +} + +async fn serve( + controller: &mut Controller, + report: &mut Reporter, + input: &mut mpsc::Receiver, +) -> anyhow::Result<&'static str> { + let mut pending = None; + let mut ids = HashSet::new(); + let mut count = 0; + let mut next_poll = Instant::now(); + report + .write(json!({"type": "capabilities", "capabilities": describe()})) + .await?; + loop { + if Instant::now() >= report.deadline { + return Ok("deadline"); + } + // Poll independently of stdin readiness: a stream of state/rawcs requests must + // not starve receive/keep-alive work, even with one look-ahead request queued. + if Instant::now() >= next_poll { + let idle = tokio::time::timeout_at(report.deadline, controller.idle()).await; + if !matches!(idle, Ok(Ok(()))) { + let closed = controller.disconnect("session_error").await; + report + .write(json!({"type": "lifecycle", "closed": closed})) + .await?; + } + report.events(&controller.rec).await?; + next_poll = Instant::now() + Duration::from_millis(50); + } + let message = if let Some(message) = pending.take() { + Some(message) + } else { + tokio::select! { + biased; + _ = tokio::time::sleep_until(report.deadline) => return Ok("deadline"), + _ = tokio::time::sleep_until(next_poll) => continue, + message = input.recv() => message, + } + }; + let line = match message { + Some(Input::Line(line)) => line, + Some(Input::Fault(code)) => { + report.response(None, Err(code)).await?; + return Ok(code); + } + Some(Input::End) | None => return Ok("eof"), + }; + if Instant::now() >= report.deadline { + return Ok("deadline"); + } + count += 1; + if count > MAX_COMMANDS { + report.response(None, Err("command_limit")).await?; + return Ok("command_limit"); + } + let (id, cmd) = match parse(&line) { + Ok(parsed) => parsed, + Err(e) => { + if let Some(id) = &e.id { + if !ids.insert(id.clone()) { + report.response(None, Err("duplicate_id")).await?; + return Ok("duplicate_id"); + } + } + report.response(e.id, Err(e.code)).await?; + if e.fatal { + return Ok(e.code); + } + continue; + } + }; + if !ids.insert(id.clone()) { + report.response(None, Err("duplicate_id")).await?; + return Ok("duplicate_id"); + } + if !controller.handshaken && !matches!(&cmd, Command::Hello) { + report.response(Some(id), Err("handshake_required")).await?; + return Ok("handshake_required"); + } + if (controller.handshaken && matches!(&cmd, Command::Hello)) + || matches!(&cmd, Command::Reconnect(id) + if !reconnect_allowed(controller.session.is_some(), controller.character_id, *id)) + { + report + .response(Some(id), Err("invalid_session_state")) + .await?; + continue; + } + let closing = matches!(&cmd, Command::Close); + let connecting = matches!(&cmd, Command::Hello | Command::Reconnect(_)); + let allowance = if connecting { + CONNECT_TIMEOUT + } else { + COMMAND_TIMEOUT + }; + // Pump's requested maximum may equal the ordinary action ceiling. + let allowance = if matches!(&cmd, Command::Pump(_)) { + allowance + Duration::from_millis(100) + } else { + allowance + }; + let until = (Instant::now() + allowance).min(report.deadline); + controller.rec.step(&format!("control.{count}")); + let rec = controller.rec.clone(); + let done = drive( + controller.execute(cmd), + until, + &rec, + report, + input, + &mut pending, + ) + .await?; + let mut stop = None; + let result = match done { + Completion::Done(Ok(value)) => Ok(value), + Completion::Done(Err(error)) => { + tracing::debug!("control action failed: {error:#}"); + let closed = controller.disconnect("session_error").await; + report + .write(json!({"type": "lifecycle", "closed": closed})) + .await?; + Err("session_error") + } + Completion::Stopped(code) => { + let closed = controller.disconnect(code).await; + report + .write(json!({"type": "lifecycle", "closed": closed})) + .await?; + if code != "command_deadline" || Instant::now() >= report.deadline { + stop = Some(code); + } + Err(code) + } + }; + report.events(&rec).await?; + report.response(Some(id), result).await?; + if closing { + return Ok("close"); + } + if let Some(reason) = stop { + return Ok(reason); + } + } +} + +pub(crate) async fn run(cfg: BotConfig, capture: &Path, deadline_ms: u64) -> anyhow::Result<()> { + ensure!( + (1..=MAX_DEADLINE_MS).contains(&deadline_ms), + "deadline-ms must be 1..=600000" + ); + ensure!( + !cfg.create_new_character, + "control cannot create characters" + ); + let started = Instant::now(); + let rec = Recorder::incremental_game(capture)?; + let (mut input, output) = stdio()?; + let mut report = Reporter { + output, + deadline: started + Duration::from_millis(deadline_ms), + seq: 0, + }; + let mut controller = Controller { + cfg, + rec: rec.clone(), + session: None, + handshaken: false, + character_id: None, + generation: 0, + started, + clock: 40_000, + }; + let outcome = match tokio::time::timeout_at( + report.deadline, + serve(&mut controller, &mut report, &mut input), + ) + .await + { + Ok(result) => result, + Err(_) => Ok("deadline"), + }; + let reason = outcome.as_ref().copied().unwrap_or("control_error"); + // Always clean up before attempting terminal output, including a broken stdout/capture. + let closed = controller.disconnect(reason).await; + let flushed = rec.flush_live(); + if outcome.is_ok() { + report.events(&rec).await?; + report + .write(json!({"type": "closed", "closed": closed})) + .await?; + } + flushed?; + let reason = outcome?; + ensure!( + matches!(reason, "close" | "eof"), + "control stopped: {reason}" + ); + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::io::{BufReader, Cursor}; + use std::sync::{ + atomic::{AtomicBool, Ordering}, + Arc, + }; + + struct Released(Arc); + + impl Drop for Released { + fn drop(&mut self) { + self.0.store(true, Ordering::SeqCst); + } + } + + fn request(method: &str, params: Value) -> Vec { + serde_json::to_vec( + &json!({"protocol": PROTOCOL, "id": "probe-1", "method": method, "params": params}), + ) + .unwrap() + } + + #[test] + fn strict_envelope_rejects_incompatible_or_ambiguous_commands() { + for input in [ + br#"{"id":1,"method":"hello","params":{}}"#.as_slice(), + br#"{"protocol":"aaemu-control/2","id":1,"method":"hello","params":{}}"#, + br#"{"protocol":"aaemu-control/1","id":null,"method":"hello","params":{}}"#, + br#"{"protocol":"aaemu-control/1","id":1,"method":"hello","params":{},"extra":1}"#, + br#"{"protocol":"aaemu-control/1","id":1,"id":2,"method":"hello","params":{}}"#, + br#"{"protocol":"aaemu-control/1","id":1,"method":"pump","params":{"ms":0,"ms":1}}"#, + br#"{"protocol":"aaemu-control/1","id":1,"method":"hello","params":null}"#, + b"\xff", + b"", + ] { + assert!(parse(input).is_err(), "accepted incompatible request"); + } + assert!(matches!( + parse(&request("hello", json!({}))), + Ok((_, Command::Hello)) + )); + let wrong = parse(br#"{"protocol":"wrong","id":7,"method":"hello","params":{}}"#) + .err() + .unwrap(); + assert!(wrong.fatal); + assert_eq!(wrong.id, Some(RequestId::Number(7))); + } + + #[test] + fn literal_packet_and_action_limits_do_not_coerce_or_truncate() { + for (method, params) in [ + ("pump", json!({"ms": MAX_PUMP_MS + 1})), + ("pump", json!({"ms": -1})), + ("state", json!({"authoritative": true})), + ("gm", json!({"command": "x".repeat(MAX_GM + 1)})), + ("gm", json!({"command": "move 1 2 3\nitem add self 1"})), + ("rawcs", json!({"opcode": "0x03a", "body_hex": "00"})), + ("rawcs", json!({"opcode": 65536, "body_hex": "00"})), + ("rawcs", json!({"opcode": 58, "body_hex": "0"})), + ("rawcs", json!({"opcode": 58, "body_hex": "00 01"})), + ( + "rawcs", + json!({"opcode": 58, "body_hex": "00".repeat(MAX_BODY + 1)}), + ), + ( + "rawcs", + json!({"opcode": cs::X2EnterWorldPacket, "body_hex": "00"}), + ), + ("reconnect", json!({"character_id": 0})), + ] { + assert!( + parse(&request(method, params)).is_err(), + "accepted invalid {method}" + ); + } + let (_, cmd) = parse(&request("rawcs", json!({"opcode": 58, "body_hex": "abcd"}))) + .ok() + .unwrap(); + assert!(matches!(cmd, Command::RawCs(58, body) if body == [0xab, 0xcd])); + assert!(parse(&request("pump", json!({"ms": MAX_PUMP_MS}))).is_ok()); + assert!(parse(&request( + "rawcs", + json!({"opcode": 58, "body_hex": "00".repeat(MAX_BODY)}) + )) + .is_ok()); + } + + #[test] + fn framing_handles_split_crlf_and_rejects_truncation_or_unterminated_overflow() { + let mut reader = BufReader::with_capacity(3, Cursor::new(b"{}\r\nsecond\n")); + assert_eq!(read_line(&mut reader).unwrap(), Some(b"{}".to_vec())); + assert_eq!(read_line(&mut reader).unwrap(), Some(b"second".to_vec())); + assert_eq!(read_line(&mut reader).unwrap(), None); + assert_eq!(read_line(&mut Cursor::new(b"{}")), Err("truncated_line")); + assert_eq!( + read_line(&mut Cursor::new(vec![b'a'; MAX_LINE + 1])), + Err("line_limit") + ); + let mut exact = vec![b'a'; MAX_LINE]; + exact.push(b'\n'); + assert_eq!( + read_line(&mut Cursor::new(exact)).unwrap().unwrap().len(), + MAX_LINE + ); + } + + #[test] + fn reconnect_requires_disconnected_session_and_the_exact_prior_character() { + assert!(!reconnect_allowed(false, None, 42)); + assert!(!reconnect_allowed(true, Some(42), 42)); + assert!(!reconnect_allowed(false, Some(42), 43)); + assert!(!reconnect_allowed(false, Some(0), 0)); + assert!(reconnect_allowed(false, Some(42), 42)); + } + + #[tokio::test] + async fn eof_cancels_an_active_action_without_waiting_for_its_timeout() { + let rec = Recorder::new(false); + let (output, _reader) = mpsc::channel(1); + let mut report = Reporter { + output, + deadline: Instant::now() + CONNECT_TIMEOUT, + seq: 0, + }; + let (sender, mut input) = mpsc::channel(1); + sender.send(Input::End).await.unwrap(); + let released = Arc::new(AtomicBool::new(false)); + let resource = Released(released.clone()); + let result = drive( + async move { + let _resource = resource; + std::future::pending().await + }, + report.deadline, + &rec, + &mut report, + &mut input, + &mut None, + ) + .await + .unwrap(); + assert!(matches!(result, Completion::Stopped("eof"))); + assert!(released.load(Ordering::SeqCst)); + } + + #[tokio::test] + async fn expired_deadline_cancels_even_when_input_is_idle() { + let rec = Recorder::new(false); + let (output, _reader) = mpsc::channel(1); + let mut report = Reporter { + output, + deadline: Instant::now(), + seq: 0, + }; + let (_sender, mut input) = mpsc::channel(1); + let released = Arc::new(AtomicBool::new(false)); + let resource = Released(released.clone()); + let result = drive( + async move { + let _resource = resource; + std::future::pending().await + }, + report.deadline, + &rec, + &mut report, + &mut input, + &mut None, + ) + .await + .unwrap(); + assert!(matches!(result, Completion::Stopped("command_deadline"))); + assert!(released.load(Ordering::SeqCst)); + } +} diff --git a/rust/crates/aaemu-testclient/src/game.rs b/rust/crates/aaemu-testclient/src/game.rs index ab18fcaf4a..ba6739ed2b 100644 --- a/rust/crates/aaemu-testclient/src/game.rs +++ b/rust/crates/aaemu-testclient/src/game.rs @@ -268,6 +268,10 @@ pub struct GameState { pub selected_char: u32, pub self_obj: u32, pub self_pos: (f32, f32, f32), + /// Last position actually received from the server, independent of local movement sends. + pub observed_self_pos: Option<(f32, f32, f32)>, + pub observation_seq: u64, + pub observation_errors: u64, pub units: HashMap, /// Doodads announced by `SCDoodad(s)CreatedPacket` and not removed since. pub doodads: HashMap, @@ -297,6 +301,7 @@ pub struct GameState { impl GameState { /// Updates the state from a packet. pub fn observe(&mut self, p: &Packet) -> anyhow::Result<()> { + self.observation_seq += 1; if let Some(ev) = crate::social::decode(p) { self.social.push(ev); } @@ -357,6 +362,7 @@ impl GameState { if unit_type == 0 && id == st.selected_char && id != 0 { st.self_obj = obj_id; st.self_pos = pos; + st.observed_self_pos = Some(pos); } st.units.insert( obj_id, @@ -380,6 +386,9 @@ impl GameState { s.read_u8()?; } let pos = s.read_position()?; + if obj_id == st.self_obj { + st.observed_self_pos = Some(pos); + } if let Some(u) = st.units.get_mut(&obj_id) { u.pos = pos; } @@ -391,6 +400,7 @@ impl GameState { let pos = s.read_position()?; st.last_teleport = Some(pos); st.self_pos = pos; + st.observed_self_pos = Some(pos); } else if p.is_sc(sc::SCDoodadCreatedPacket) { let d = read_doodad(&mut s)?; st.doodads.insert(d.obj_id, d); @@ -462,8 +472,9 @@ impl GameState { } pub struct GameClient { - writer: FramedWrite, - rx: mpsc::UnboundedReceiver>, + writer: Option>, + reader: SocketReader, + rx: mpsc::Receiver>, rec: Recorder, count: u8, pub account_id: u32, @@ -475,6 +486,26 @@ pub struct GameClient { started: Instant, } +/// Aborting a client (including a cancelled connection attempt) must release the read half. +struct SocketReader(Option>); + +impl SocketReader { + async fn close(&mut self) { + if let Some(task) = self.0.take() { + task.abort(); + let _ = task.await; + } + } +} + +impl Drop for SocketReader { + fn drop(&mut self) { + if let Some(task) = self.0.take() { + task.abort(); + } + } +} + impl GameClient { pub async fn connect(addr: &str, rec: Recorder) -> anyhow::Result { let sock = TcpStream::connect(addr) @@ -482,13 +513,13 @@ impl GameClient { .with_context(|| format!("connecting to game server {addr}"))?; sock.set_nodelay(true)?; let (rd, wr) = sock.into_split(); - let (tx, rx) = mpsc::unbounded_channel(); - tokio::spawn(async move { + let (tx, rx) = mpsc::channel(256); + let reader = tokio::spawn(async move { let mut reader = FramedRead::new(rd, FrameCodec); loop { match reader.next().await { Some(Ok(frame)) => { - if tx.send(frame).is_err() { + if tx.send(frame).await.is_err() { break; } } @@ -504,7 +535,8 @@ impl GameClient { } }); Ok(Self { - writer: FramedWrite::new(wr, FrameCodec), + writer: Some(FramedWrite::new(wr, FrameCodec)), + reader: SocketReader(Some(reader)), rx, rec, count: 0, @@ -521,6 +553,19 @@ impl GameClient { &self.rec } + /// Close both game socket halves, without sending `CSLeaveWorldPacket`. + /// Awaiting the aborted reader confirms that its socket half was dropped. + pub async fn disconnect_hard(mut self) { + drop(self.writer.take()); + self.reader.close().await; + // Preserve frames the reader had already delivered before it was stopped. + while let Ok(frame) = self.rx.try_recv() { + let _ = self.decode(frame); + } + self.rx.close(); + self.state.disconnected = true; + } + /// Sends a level-1 (`CS*`) packet. pub async fn send_cs(&mut self, opcode: u16, body: &[u8]) -> anyhow::Result<()> { self.rec.push( @@ -536,7 +581,11 @@ impl GameClient { self.count = self.count.wrapping_add(1); p.extend_from_slice(&opcode.to_le_bytes()); p.extend_from_slice(body); - self.writer.send(p).await?; + self.writer + .as_mut() + .context("game writer closed")? + .send(p) + .await?; Ok(()) } @@ -554,7 +603,11 @@ impl GameClient { p.extend_from_slice(&[0xDD, LEVEL_PROXY]); p.extend_from_slice(&opcode.to_le_bytes()); p.extend_from_slice(body); - self.writer.send(p).await?; + self.writer + .as_mut() + .context("game writer closed")? + .send(p) + .await?; Ok(()) } @@ -608,6 +661,7 @@ impl GameClient { self.rec .push(Channel::Game, Dir::S2C, level, opcode, p.name(), &p.body); if let Err(e) = self.observe(&p) { + self.state.observation_errors += 1; tracing::debug!("could not parse {}: {e}", p.name()); } Ok(p) @@ -1120,6 +1174,75 @@ impl GameClient { } } +#[cfg(test)] +mod socket_reader_tests { + use super::SocketReader; + use tokio::sync::oneshot; + + struct OnDrop(Option>); + + impl Drop for OnDrop { + fn drop(&mut self) { + let _ = self.0.take().unwrap().send(()); + } + } + + async fn reader() -> (SocketReader, oneshot::Receiver<()>) { + let (started, ready) = oneshot::channel(); + let (stopped, done) = oneshot::channel(); + let task = tokio::spawn(async move { + let _resource = OnDrop(Some(stopped)); + let _ = started.send(()); + std::future::pending::<()>().await; + }); + ready.await.unwrap(); + (SocketReader(Some(task)), done) + } + + #[tokio::test] + async fn explicit_close_and_cancelled_owner_release_reader_resources() { + let (mut task, stopped) = reader().await; + task.close().await; + assert!(stopped.await.is_ok()); + task.close().await; + + let (task, stopped) = reader().await; + drop(task); + assert!(stopped.await.is_ok()); + } +} + +#[cfg(test)] +mod observed_position_tests { + use super::*; + + #[test] + fn server_observation_does_not_report_a_locally_predicted_position() { + let mut state = GameState { + self_obj: 42, + self_pos: (900.0, 900.0, 900.0), + ..GameState::default() + }; + assert_eq!(state.observed_self_pos, None); + let mut body = PacketStream::new(); + body.write_bc(42) + .write_u8(1) + .write_u32(123) + .write_u8(0) + .write_position(10.0, 20.0, 30.0); + state + .observe(&Packet { + level: LEVEL_GAME, + opcode: sc::SCOneUnitMovementPacket, + body: body.as_bytes().to_vec(), + }) + .unwrap(); + assert_eq!(state.observed_self_pos, Some((10.0, 20.0, 30.0))); + assert_eq!(state.self_pos, (900.0, 900.0, 900.0)); + assert_eq!(state.observation_seq, 1); + } +} + fn dist2(a: (f32, f32, f32), b: (f32, f32, f32)) -> f32 { let (dx, dy, dz) = (a.0 - b.0, a.1 - b.1, a.2 - b.2); dx * dx + dy * dy + dz * dz diff --git a/rust/crates/aaemu-testclient/src/main.rs b/rust/crates/aaemu-testclient/src/main.rs index 307014e9ba..9b6993580b 100644 --- a/rust/crates/aaemu-testclient/src/main.rs +++ b/rust/crates/aaemu-testclient/src/main.rs @@ -14,6 +14,9 @@ //! [--scenario load] //! aaemu-testclient verify --suite file.vtest [--login H:P] [--password P] [--list-bots] //! Run one live verification suite (see Docs/wiki/Verification.md). +//! aaemu-testclient control --describe +//! aaemu-testclient control --config private.json --login H:P --capture game.jsonl +//! [--deadline-ms 570000] //! ``` //! //! Settings come from `--config` (JSON, see `testclient.example.json`), then the flags. Keep @@ -31,6 +34,8 @@ use aaemu_testclient::verify; use anyhow::{bail, Context}; use tracing_subscriber::EnvFilter; +mod control; + struct Args { cmd: String, flags: HashMap, @@ -38,7 +43,7 @@ struct Args { impl Args { fn parse() -> anyhow::Result { - const SWITCHES: &[&str] = &["list-bots"]; + const SWITCHES: &[&str] = &["list-bots", "describe"]; let mut it = std::env::args().skip(1); let cmd = it.next().unwrap_or_else(|| "help".into()); let argv: Vec = it.collect(); @@ -188,11 +193,24 @@ fn diff_files(a: &Path, b: &Path, cfg: &DiffConfig, la: &str, lb: &str) -> anyho #[tokio::main] async fn main() -> anyhow::Result<()> { tracing_subscriber::fmt() + .with_writer(std::io::stderr) .with_env_filter( EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("warn")), ) .init(); let args = Args::parse()?; + if args.cmd == "control" { + if args.has("describe") { + println!("{}", control::describe()); + return Ok(()); + } + args.get("config") + .context("control requires --config ")?; + let cfg = bot_config(&args).context("invalid control config")?; + let capture = Path::new(args.get("capture").context("control requires --capture")?); + let deadline_ms = args.get("deadline-ms").unwrap_or("570000").parse()?; + return control::run(cfg, capture, deadline_ms).await; + } let kind: Kind = args.get("scenario").unwrap_or("full").parse()?; match args.cmd.as_str() { "run" => { diff --git a/rust/crates/aaemu-testclient/src/record.rs b/rust/crates/aaemu-testclient/src/record.rs index 4cd16ed5d3..cb539d3afe 100644 --- a/rust/crates/aaemu-testclient/src/record.rs +++ b/rust/crates/aaemu-testclient/src/record.rs @@ -50,6 +50,38 @@ struct Inner { step: String, events: Vec, enabled: bool, + live: Option, +} + +/// Control mode drains this bounded queue to stdout; ordinary recorders still keep a Vec. +const MAX_PENDING_EVENTS: usize = 2048; +const MAX_PENDING_BYTES: usize = 8 * 1024 * 1024; + +struct LiveCapture { + sink: Box, + pending: Vec, + pending_bytes: usize, + failed: bool, + game_ready: bool, +} + +impl std::fmt::Debug for LiveCapture { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("LiveCapture") + .field("pending", &self.pending.len()) + .field("failed", &self.failed) + .finish_non_exhaustive() + } +} + +fn public_game_event(channel: Channel, dir: Dir, level: u8, opcode: u16) -> bool { + use aaemu_game::opcodes::{cs, sc}; + channel == Channel::Game + && !(level == 1 + && match dir { + Dir::C2S => opcode == cs::X2EnterWorldPacket, + Dir::S2C => opcode == sc::X2EnterWorldResponsePacket, + }) } /// Shared, cheaply cloneable capture buffer. @@ -69,9 +101,66 @@ impl Recorder { step: "connect".into(), events: Vec::new(), enabled, + live: None, }))) } + /// Incremental, game-only capture for control mode. Refuses to overwrite evidence. + /// Login/stream authentication and game cookie/token packets are never retained here. + /// Unlike `new`, this recorder does not retain the entire run in memory. + pub fn incremental_game(path: &Path) -> anyhow::Result { + let file = std::fs::OpenOptions::new() + .write(true) + .create_new(true) + .open(path)?; + Ok(Self::with_live_sink(Box::new(std::io::BufWriter::new( + file, + )))) + } + + fn with_live_sink(sink: Box) -> Self { + let rec = Self::new(true); + rec.inner().live = Some(LiveCapture { + sink, + pending: Vec::new(), + pending_bytes: 0, + failed: false, + game_ready: false, + }); + rec + } + + /// Omit the authentication/lobby burst, including any compressed token-bearing frames. + /// Select/spawn and all subsequent gameplay remain available to the controller. + pub fn control_game_ready(&self, ready: bool) { + if let Some(live) = self.inner().live.as_mut() { + live.game_ready = ready; + } + } + + /// Drain independent game events, after checking for capture/queue failures. + pub fn take_live_events(&self) -> anyhow::Result> { + let mut i = self.inner(); + let live = i + .live + .as_mut() + .ok_or_else(|| anyhow::anyhow!("not a live recorder"))?; + anyhow::ensure!(!live.failed, "incremental capture failed or queue exceeded"); + live.pending_bytes = 0; + Ok(std::mem::take(&mut live.pending)) + } + + pub fn flush_live(&self) -> anyhow::Result<()> { + if let Some(live) = self.inner().live.as_mut() { + anyhow::ensure!(!live.failed, "incremental capture failed or queue exceeded"); + if live.sink.flush().is_err() { + live.failed = true; + anyhow::bail!("incremental capture flush failed"); + } + } + Ok(()) + } + fn inner(&self) -> std::sync::MutexGuard<'_, Inner> { self.0.lock().unwrap_or_else(|e| e.into_inner()) } @@ -98,6 +187,12 @@ impl Recorder { if !i.enabled { return; } + if i.live + .as_ref() + .is_some_and(|live| !live.game_ready || !public_game_event(channel, dir, level, opcode)) + { + return; + } let ev = Event { t_ms: i.start.elapsed().as_millis() as u64, channel, @@ -108,7 +203,29 @@ impl Recorder { step: i.step.clone(), body: hex::encode(body), }; - i.events.push(ev); + if let Some(live) = i.live.as_mut() { + if live.failed { + return; + } + let result = (|| -> anyhow::Result<()> { + let mut line = serde_json::to_vec(&ev)?; + line.push(b'\n'); + anyhow::ensure!( + live.pending.len() < MAX_PENDING_EVENTS + && line.len() <= MAX_PENDING_BYTES.saturating_sub(live.pending_bytes), + "live event queue exceeded" + ); + live.sink.write_all(&line)?; + // A hard socket close or process kill must preserve earlier accepted frames. + live.sink.flush()?; + live.pending_bytes += line.len(); + live.pending.push(ev); + Ok(()) + })(); + live.failed = result.is_err(); + } else { + i.events.push(ev); + } } pub fn events(&self) -> Vec { @@ -134,3 +251,114 @@ pub fn load(path: &Path) -> anyhow::Result> { .map(|l| Ok(serde_json::from_str(l)?)) .collect() } + +#[cfg(test)] +mod tests { + use super::*; + use aaemu_game::opcodes::{cs, sc}; + + #[derive(Default)] + struct Written { + bytes: Vec, + flushes: usize, + fail_flush: bool, + } + + #[derive(Clone, Default)] + struct Sink(Arc>); + + impl Write for Sink { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.lock().unwrap().bytes.extend_from_slice(bytes); + Ok(bytes.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + let mut written = self.0.lock().unwrap(); + written.flushes += 1; + if written.fail_flush { + return Err(std::io::Error::other("injected flush failure")); + } + Ok(()) + } + } + + fn push(rec: &Recorder) { + rec.push( + Channel::Game, + Dir::S2C, + 1, + sc::SCErrorMsgPacket, + "SCErrorMsgPacket", + &[7, 0], + ); + } + + #[test] + fn live_capture_flushes_before_drain_and_omits_all_authentication_channels() { + let sink = Sink::default(); + let rec = Recorder::with_live_sink(Box::new(sink.clone())); + rec.push( + Channel::Game, + Dir::S2C, + 4, + 1, + "CompressedGamePackets", + b"lobby-token", + ); + assert!(sink.0.lock().unwrap().bytes.is_empty()); + rec.control_game_ready(true); + for (channel, dir, opcode) in [ + (Channel::Login, Dir::C2S, 4), + (Channel::Stream, Dir::C2S, 1), + (Channel::Game, Dir::C2S, cs::X2EnterWorldPacket), + (Channel::Game, Dir::S2C, sc::X2EnterWorldResponsePacket), + ] { + rec.push(channel, dir, 1, opcode, "auth", b"private"); + } + push(&rec); + let persisted = sink.0.lock().unwrap(); + assert_eq!(persisted.flushes, 1); + let event: Event = serde_json::from_slice(&persisted.bytes).unwrap(); + assert_eq!(event.body_bytes(), [7, 0]); + drop(persisted); + assert_eq!(rec.take_live_events().unwrap(), vec![event]); + assert!(rec.take_live_events().unwrap().is_empty()); + assert!( + rec.events().is_empty(), + "control must not retain the whole run" + ); + rec.control_game_ready(false); + push(&rec); + assert_eq!(sink.0.lock().unwrap().flushes, 1); + } + + #[test] + fn queue_or_sink_failure_is_observable_and_never_silently_resumes() { + let sink = Sink::default(); + let rec = Recorder::with_live_sink(Box::new(sink.clone())); + rec.control_game_ready(true); + sink.0.lock().unwrap().fail_flush = true; + push(&rec); + assert!(rec.take_live_events().is_err()); + sink.0.lock().unwrap().fail_flush = false; + assert!(rec.flush_live().is_err()); + + let rec = Recorder::with_live_sink(Box::new(Sink::default())); + rec.control_game_ready(true); + for _ in 0..=MAX_PENDING_EVENTS { + push(&rec); + } + assert!(rec.take_live_events().is_err()); + } + + #[test] + fn ordinary_recorders_still_buffer_every_channel() { + let rec = Recorder::new(true); + rec.push(Channel::Login, Dir::C2S, 0, 4, "auth", b"ticket"); + rec.push(Channel::Stream, Dir::C2S, 0, 1, "join", b"token"); + push(&rec); + assert_eq!(rec.events().len(), 3); + assert_eq!(rec.events()[0].body_bytes(), b"ticket"); + } +} diff --git a/rust/crates/aaemu-testclient/src/scenario.rs b/rust/crates/aaemu-testclient/src/scenario.rs index f30c62ec3f..8665892078 100644 --- a/rust/crates/aaemu-testclient/src/scenario.rs +++ b/rust/crates/aaemu-testclient/src/scenario.rs @@ -463,12 +463,12 @@ mod creation_tests { } } -async fn run_inner( +/// Existing login/lobby path shared by scenarios and the stdio controller. +async fn open_lobby( kind: Kind, cfg: &BotConfig, r: &mut Runner<'_>, - script_input: Option<&ScriptInput<'_>>, -) -> anyhow::Result<()> { +) -> anyhow::Result> { // ---- login server ---- let s = r.begin("login.auth"); let mut login = LoginClient::connect(&cfg.login, r.rec.clone()).await?; @@ -503,7 +503,7 @@ async fn run_inner( format!("{}:{} cookie {}", cookie.ip, cookie.port, cookie.cookie), ); if kind == Kind::Login { - return Ok(()); + return Ok(None); } // ---- game server: lobby ---- @@ -561,6 +561,163 @@ async fn run_inner( .await?; r.end(s, format!("{} character(s)", game.state.characters.len())); + Ok(Some((game, stream, login))) +} + +async fn select_and_spawn( + game: &mut GameClient, + character_id: u32, + r: &mut Runner<'_>, +) -> anyhow::Result<()> { + // ---- world ---- + let s = r.begin("game.select"); + game.select_character(character_id).await?; + game.wait_sc(sc::SCCharacterStatePacket).await?; + game.drain(QUIET, Duration::from_secs(10)).await?; + r.end(s, format!("{} bag items seen", game.state.bag_items.len())); + + let s = r.begin("game.spawn"); + game.spawn_character().await?; + game.wait_for("own SCUnitStatePacket", |p| p.is_sc(sc::SCUnitStatePacket)) + .await?; + game.notify_in_game().await?; + game.notify_in_game_completed().await?; + game.drain(QUIET, Duration::from_secs(15)).await?; + ensure!(game.state.self_obj != 0, "own unit state not received"); + r.var("self_obj", game.state.self_obj); + let npcs = game + .state + .units + .values() + .filter(|u| u.unit_type == 1) + .count(); + r.end( + s, + format!( + "obj {} at {:?}, {npcs} npcs visible", + game.state.self_obj, game.state.self_pos + ), + ); + + Ok(()) +} + +/// A control session owns its connections and reuses the scenario login handoff. +pub struct ControlSession { + pub game: GameClient, + pub stream: StreamClient, + // Preserve the ordinary scenario's login-connection lifetime through the handoff. + _login: LoginClient, +} + +fn control_character( + characters: &[crate::game::CharInfo], + requested: &str, + character_id: Option, +) -> anyhow::Result { + let mut matches = characters.iter().filter(|c| match character_id { + Some(id) => id != 0 && c.id == id, + None => c.name.eq_ignore_ascii_case(requested), + }); + let ch = matches + .next() + .context("requested existing character not listed")?; + ensure!(matches.next().is_none(), "ambiguous existing character"); + Ok(ch.id) +} + +#[cfg(test)] +mod control_character_tests { + use super::control_character; + use crate::game::CharInfo; + + #[test] + fn control_never_falls_back_to_first_or_creates_a_missing_character() { + let characters = [ + CharInfo { + id: 10, + name: "Unrelated".into(), + }, + CharInfo { + id: 42, + name: "Owner".into(), + }, + ]; + assert_eq!(control_character(&characters, "owner", None).unwrap(), 42); + assert!(control_character(&characters, "missing", None).is_err()); + assert!(control_character(&[], "Owner", None).is_err()); + assert_eq!( + control_character(&characters, "renamed", Some(42)).unwrap(), + 42 + ); + assert!(control_character(&characters, "Owner", Some(43)).is_err()); + assert!(control_character(&characters, "Owner", Some(0)).is_err()); + } +} + +/// Connect once, selecting an existing character only. No creation or retries. +pub async fn connect_control( + cfg: &BotConfig, + rec: &Recorder, + character_id: Option, +) -> anyhow::Result { + ensure!( + !cfg.create_new_character, + "control cannot create characters" + ); + rec.control_game_ready(false); + let mut r = Runner { + rec, + out: Outcome::default(), + }; + let (mut game, stream, login) = open_lobby(Kind::Full, cfg, &mut r) + .await? + .context("game lobby was not opened")?; + let id = control_character(&game.state.characters, &cfg.character, character_id)?; + rec.control_game_ready(true); + select_and_spawn(&mut game, id, &mut r).await?; + Ok(ControlSession { + game, + stream, + _login: login, + }) +} + +/// Use the scenario's GM chat path without printing command text or replies. +pub async fn control_gm(game: &mut GameClient, command: &str) -> anyhow::Result<()> { + questitem::gm_command(game, command).await?; + Ok(()) +} + +/// The script `tp` sequence, using the position returned by the server. +pub async fn control_tp( + game: &mut GameClient, + x: f32, + y: f32, + z: f32, + clock: u32, +) -> anyhow::Result<()> { + game.state.last_teleport = None; + game.chat(0, &format!("/move {x} {y} {z}")).await?; + game.wait_sc(sc::SCTeleportUnitPacket).await?; + let at = game.state.self_pos; + game.teleport_ended(at).await?; + game.move_to(at, clock).await?; + game.drain(Duration::from_millis(1500), Duration::from_secs(8)) + .await?; + Ok(()) +} + +async fn run_inner( + kind: Kind, + cfg: &BotConfig, + r: &mut Runner<'_>, + script_input: Option<&ScriptInput<'_>>, +) -> anyhow::Result<()> { + let Some((mut game, stream, _login)) = open_lobby(kind, cfg, r).await? else { + return Ok(()); + }; + let s = r.begin("game.create"); let created = if cfg.create_new_character || game.state.characters.is_empty() { game.create_character(&cfg.character).await?; @@ -597,35 +754,7 @@ async fn run_inner( return Ok(()); } - // ---- world ---- - let s = r.begin("game.select"); - game.select_character(ch.id).await?; - game.wait_sc(sc::SCCharacterStatePacket).await?; - game.drain(QUIET, Duration::from_secs(10)).await?; - r.end(s, format!("{} bag items seen", game.state.bag_items.len())); - - let s = r.begin("game.spawn"); - game.spawn_character().await?; - game.wait_for("own SCUnitStatePacket", |p| p.is_sc(sc::SCUnitStatePacket)) - .await?; - game.notify_in_game().await?; - game.notify_in_game_completed().await?; - game.drain(QUIET, Duration::from_secs(15)).await?; - ensure!(game.state.self_obj != 0, "own unit state not received"); - r.var("self_obj", game.state.self_obj); - let npcs = game - .state - .units - .values() - .filter(|u| u.unit_type == 1) - .count(); - r.end( - s, - format!( - "obj {} at {:?}, {npcs} npcs visible", - game.state.self_obj, game.state.self_pos - ), - ); + select_and_spawn(&mut game, ch.id, r).await?; if kind == Kind::NpcReturn { npc_return(&mut game, cfg, r).await?; From 7ac9af6eb3b7d0b511310d7865dc10a1f6bf2712 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:33:15 -0400 Subject: [PATCH 47/66] test(cargo): allocate distinct world object identities --- rust/crates/aaemu-game/src/systems/economy/bridges.rs | 8 ++------ .../aaemu-game/src/systems/economy/cargo_flow_tests.rs | 6 +++--- 2 files changed, 5 insertions(+), 9 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/economy/bridges.rs b/rust/crates/aaemu-game/src/systems/economy/bridges.rs index 98d89aa7aa..643284e7e0 100644 --- a/rust/crates/aaemu-game/src/systems/economy/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/economy/bridges.rs @@ -2862,18 +2862,14 @@ fn cargo_attachment(server: &GameServer, rack: &DoodadRef) -> Option { if parent == 0 || parent != transform_parent { return None; } - let Some(world) = server.world.world(instance) else { - return None; - }; + let world = server.world.world(instance)?; if !world .doodad(rack.obj_id) .is_some_and(|live| Arc::ptr_eq(&live, rack)) { return None; } - let Some(hull) = world.slave(parent) else { - return None; - }; + let hull = world.slave(parent)?; let (id, hull_template, attached) = { let hull = hull.data(); ( diff --git a/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs b/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs index ef0a8016db..846f43065f 100644 --- a/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs @@ -193,8 +193,8 @@ fn world_with_pool(data: GameData, pool: Option) -> CargoWorld alice.inventory = Inventory::new(1, 50, 50, &server.items, &server.ids.container); let mut bob = test_character(2, "Bob", 101.0, 100.0); bob.inventory = Inventory::new(2, 50, 50, &server.items, &server.ids.container); - let pa = spawn_player(&server, &a, alice, 0x100); - let pb = spawn_player(&server, &b, bob, 0x101); + let pa = spawn_player(&server, &a, alice, server.ids.object.get_next_id().unwrap()); + let pb = spawn_player(&server, &b, bob, server.ids.object.get_next_id().unwrap()); a.conn.active_char = Some(pa.clone()); b.conn.active_char = Some(pb.clone()); let instance = server.world.world(0).unwrap(); @@ -203,7 +203,7 @@ fn world_with_pool(data: GameData, pool: Option) -> CargoWorld hull.unit.transform.set_xyz(100.0, 100.0, 100.0); hull.summoner_id = 1; hull.summoner_obj_id = pa.obj_id; - let hull = Entity::new(0x300, hull); + let hull = Entity::new(server.ids.object.get_next_id().unwrap(), hull); instance.spawn(&hull, &server.view_ctx()); let racks = bindings .into_iter() From d43bd980e069c0b9c1e6902866bf1a75c9f26683 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:38:01 -0400 Subject: [PATCH 48/66] feat(vehicles): add read-only ship identity and cargo audit Track summon futures before detached launch and reservation waits. Observe retained retirement references without extending gameplay lifetimes, expose item/root/rack state through the GM slave root, and frame bounded JSON chunks with an explicit completeness checksum and terminator. Report consistent:false because spawn queue retained references and direct world removals lack a shared audit boundary. Source tests are authored but intentionally unexecuted; parent owns all Cargo and live validation. Co-Authored-By: OpenAI Codex --- .../services/commands/scripts/sub/slaves.rs | 34 ++ .../aaemu-game/src/systems/vehicles/audit.rs | 455 ++++++++++++++++ .../src/systems/vehicles/audit_tests.rs | 506 ++++++++++++++++++ .../aaemu-game/src/systems/vehicles/mod.rs | 17 + .../aaemu-game/src/systems/vehicles/slaves.rs | 146 ++++- 5 files changed, 1138 insertions(+), 20 deletions(-) create mode 100644 rust/crates/aaemu-game/src/systems/vehicles/audit.rs create mode 100644 rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs diff --git a/rust/crates/aaemu-game/src/systems/services/commands/scripts/sub/slaves.rs b/rust/crates/aaemu-game/src/systems/services/commands/scripts/sub/slaves.rs index 28d34aa581..8179c6e45e 100644 --- a/rust/crates/aaemu-game/src/systems/services/commands/scripts/sub/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/services/commands/scripts/sub/slaves.rs @@ -488,8 +488,42 @@ impl SubCommand for SlaveSaveSubCommand { } /// `SlaveCmd`. +#[derive(Default)] +pub struct SlaveAuditSubCommand { + base: SubCommandBase, +} + +impl SubCommand for SlaveAuditSubCommand { + fn base(&self) -> &SubCommandBase { + &self.base + } + + fn execute_args( + &self, + ctx: &CommandContext<'_>, + _trigger: &str, + args: &[String], + out: &mut dyn MessageOutput, + ) -> anyhow::Result<()> { + use crate::systems::vehicles::audit; + // Raw args deliberately enforce exact arity (the generic typed-parameter loader + // ignores extra positional arguments). Authorization remains on the slave root. + let request = audit::Request::parse(args)?; + let snapshot = audit::snapshot(ctx.server()?, &request); + for chunk in audit::chunks(&request, &snapshot)? { + out.send_message(&chunk); + } + Ok(()) + } + + fn send_help_message(&self, out: &mut dyn MessageOutput) { + out.send_message("/slave audit ; read-only, aaemu-slave-audit/1"); + } +} + pub fn slave_cmd() -> RootCommand { RootCommand::new(&["slave"], "[slave]", "Root command to manage Slaves", "") + .register(Arc::new(SlaveAuditSubCommand::default()), &["audit"]) .register(Arc::new(SlaveInformationSubCommand::default()), &["info"]) .register( Arc::new(SlavePositionSubCommand::default()), diff --git a/rust/crates/aaemu-game/src/systems/vehicles/audit.rs b/rust/crates/aaemu-game/src/systems/vehicles/audit.rs new file mode 100644 index 0000000000..650af66c77 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/vehicles/audit.rs @@ -0,0 +1,455 @@ +//! Read-only ship diagnostics. This is observation, never a second ownership index. +//! +//! The item operation scope must precede the publication gate. These protect summon item / +//! hull publication together, but do NOT protect the spawn manager's direct world removals, +//! every phase timer, or world-instance creation. Consequently v1 always says consistent:false. +//! A complete authority cut needs a spawn-manager reference snapshot under a boundary shared +//! with its queue drain and world removal. Its current public accessor exposes IDs only. +//! Transform, visibility, phase and queue deadlines are explicitly temporal samples. A settled +//! snapshot cannot prove an interval between calls. Release manifests must supply binary/HEAD +//! provenance; this module does not guess the source commit from a developer checkout. + +use std::collections::BTreeMap; +use std::sync::{Arc, Mutex, Weak}; + +use serde::Serialize; +use serde_json::{json, Value}; + +use crate::models::doodad::Doodad; +use crate::models::item::Item; +use crate::models::slave::Slave; +use crate::models::unit::BaseUnitType; +use crate::server::GameServer; +use crate::systems::npcs::spawn_manager; +use crate::world::{DoodadRef, Entity, SlaveRef}; + +use super::slaves; + +pub const PROTOCOL: &str = "aaemu-slave-audit/1"; +pub const PREFIX: &str = "AAEMU_SLAVE_AUDIT/1"; +const CAPABILITY: &str = "ship-audit/1;prepoll-leases;weak-retirements;sampled-queues"; +const MAX_BYTES: usize = 65_536; +const CHUNK_BYTES: usize = 160; + +#[derive(Debug, Clone)] +pub struct Request { + pub character_id: u32, + pub item_id: u64, + pub nonce: String, +} + +impl Request { + pub fn parse(args: &[String]) -> anyhow::Result { + anyhow::ensure!( + args.len() == 3, + "usage: /slave audit " + ); + anyhow::ensure!( + args[..2] + .iter() + .all(|s| !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit())), + "IDs must be unsigned decimal integers" + ); + let character_id = args[0].parse::()?; + let item_id = args[1].parse::()?; + anyhow::ensure!(character_id != 0 && item_id != 0, "IDs must be nonzero"); + let nonce = &args[2]; + anyhow::ensure!( + (1..=32).contains(&nonce.len()) + && nonce + .bytes() + .all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'-'), + "nonce must be 1..32 ASCII letters, digits, '_' or '-'" + ); + Ok(Self { + character_id, + item_id, + nonce: nonce.clone(), + }) + } +} + +#[derive(Debug, Clone, Serialize)] +pub(super) struct Job { + id: u64, + kind: &'static str, + owner: u32, + item: u64, + pub(super) phase: &'static str, + root: Option, + generation: Option, +} + +#[derive(Debug)] +struct Retirement { + world: u32, + slave: Weak>, + doodads: Vec>>, +} + +#[derive(Debug, Default)] +struct State { + sequence: u64, + jobs: BTreeMap, + retirements: Vec, +} + +/// Leases describe actual futures and never decide whether those futures may publish. +#[derive(Debug, Clone, Default)] +pub(super) struct Diagnostics(Arc>); + +#[derive(Debug)] +pub(super) struct Lease { + state: Arc>, + id: u64, +} + +impl Diagnostics { + pub(super) fn summon(&self, owner: u32, item: u64) -> Lease { + self.job("summon", owner, item, "queued", None, None) + } + + pub(super) fn retirement(&self, slave: &SlaveRef, generation: u64) -> Lease { + let (owner, item, instance) = { + let d = slave.data(); + ( + d.summoner_id, + d.summoning_item_id, + d.unit.transform.instance_id, + ) + }; + self.retiring(instance, slave, &[]); + self.job( + "retirement", + owner, + item, + "waiting_timer", + Some(slave.obj_id), + Some(generation), + ) + } + + fn job( + &self, + kind: &'static str, + owner: u32, + item: u64, + phase: &'static str, + root: Option, + generation: Option, + ) -> Lease { + let mut state = self.0.lock().unwrap_or_else(|e| e.into_inner()); + state.sequence += 1; + let id = state.sequence; + state.jobs.insert( + id, + Job { + id, + kind, + owner, + item, + phase, + root, + generation, + }, + ); + Lease { + state: self.0.clone(), + id, + } + } + + /// Weak handles retain neither the hull nor its children beyond existing queue/task owners. + pub(super) fn retiring(&self, world: u32, slave: &SlaveRef, doodads: &[DoodadRef]) { + let mut state = self.0.lock().unwrap_or_else(|e| e.into_inner()); + state.retirements.retain(|r| r.slave.strong_count() != 0); + if let Some(existing) = state + .retirements + .iter_mut() + .find(|r| r.slave.ptr_eq(&Arc::downgrade(slave))) + { + for d in doodads { + let weak = Arc::downgrade(d); + if !existing.doodads.iter().any(|w| w.ptr_eq(&weak)) { + existing.doodads.push(weak); + } + } + } else { + state.retirements.push(Retirement { + world, + slave: Arc::downgrade(slave), + doodads: doodads.iter().map(Arc::downgrade).collect(), + }); + } + } + + pub(super) fn jobs(&self, request: &Request) -> Vec { + self.0 + .lock() + .unwrap_or_else(|e| e.into_inner()) + .jobs + .values() + .filter(|j| j.owner == request.character_id || j.item == request.item_id) + .cloned() + .collect() + } +} + +impl Lease { + pub(super) fn phase(&self, phase: &'static str) { + if let Some(job) = self + .state + .lock() + .unwrap_or_else(|e| e.into_inner()) + .jobs + .get_mut(&self.id) + { + job.phase = phase; + } + } +} + +impl Drop for Lease { + fn drop(&mut self) { + // Also runs for an unpolled future, cancellation, and unwind. Recovering poison here + // avoids a second panic during unwind; this lock never guards gameplay authority. + self.state + .lock() + .unwrap_or_else(|e| e.into_inner()) + .jobs + .remove(&self.id); + } +} + +fn item_snapshot(server: &GameServer, id: u64) -> Value { + let Some(item) = server.items.item_by_id(id) else { + return Value::Null; + }; + let containers: Vec<_> = server + .items + .all_containers() + .into_iter() + .filter_map(|c| { + let c = c.lock().expect("container poisoned"); + let matches: Vec<_> = c + .items + .iter() + .filter(|i| i.id == id) + .map(item_fields) + .collect(); + (!matches.is_empty()).then(|| { + json!({"id": c.container_id, "kind": c.kind.type_name(), + "owner_id": c.owner_id, "slot_type": c.slot_type, "mate_id": c.mate_id, + "size": c.container_size(), "items": matches}) + }) + }) + .collect(); + json!({"lookup": item_fields(&item), "containers": containers}) +} + +fn item_fields(i: &Item) -> Value { + json!({"id": i.id, "template_id": i.template_id, "class": i.class.type_name(), + "owner_id": i.owner_id, "slot_type": i.slot_type, "slot": i.slot, "count": i.count, + "grade": i.grade, "flags": i.flags, "dirty": i.dirty, + "saved_slave_db_id": i.details.slave_db_id, + "detail_type_and_body_hex": hex(&i.detail_type_and_details())}) +} + +/// No grants, find-or-create container calls, saves, SQL, or repairs. All guards are synchronous. +pub fn snapshot(server: &GameServer, request: &Request) -> Value { + let _items = server.systems.economy.operation_scope(); + let summons = &server.systems.vehicles.slave_summons; + let _publication = summons.publication_scope(); + let (sample, retiring) = { + let mut state = summons + .diagnostics + .0 + .lock() + .unwrap_or_else(|e| e.into_inner()); + state.sequence += 1; + ( + state.sequence, + state + .retirements + .iter() + .filter_map(|r| { + Some(( + r.world, + r.slave.upgrade()?, + r.doodads + .iter() + .filter_map(Weak::upgrade) + .collect::>(), + )) + }) + .collect::>(), + ) + }; + let jobs = summons.diagnostics.jobs(request); + let retirement_references: Vec<_> = retiring.iter().map(|(_, s, _)| s.clone()).collect(); + let mut worlds = server.world.worlds(); + worlds.sort_by_key(|w| w.id); + let mut references = Vec::new(); + for world in &worlds { + for slave in slaves::all_slaves(world) { + references.push((world.id, slave, Vec::new())); + } + } + for (world, slave, doodads) in retiring { + if let Some((_, _, existing)) = references + .iter_mut() + .find(|(_, s, _)| Arc::ptr_eq(s, &slave)) + { + existing.extend(doodads); + } else { + references.push((world, slave, doodads)); + } + } + references.sort_by_key(|(w, s, _)| (*w, s.obj_id)); + let owner_roots = slaves::owned_roots(server, request.character_id); + let owner_object_lookups: Vec<_> = server.world.all_characters().into_iter() + .filter(|p| p.character_id == request.character_id) + .map(|p| json!({"character_id": p.character_id, "object_id": p.obj_id, "connection_id": p.conn.id, + "worlds": worlds.iter().map(|w| json!({"world_instance": w.id, + "get_active_slave_by_owner_obj_id": slaves::get_active_slave_by_owner_obj_id(w, p.obj_id).map(|s| s.obj_id)})).collect::>()})).collect(); + let mut candidates = Vec::new(); + for (instance, slave, mut doodads) in references { + // Copy one entity, then release its data guard before any world or item lookup. + let d = slave.data().clone(); + if d.summoner_id != request.character_id && d.summoning_item_id != request.item_id { + continue; + } + let world = worlds.iter().find(|w| w.id == instance); + let registered = world.is_some_and(|w| { + w.slave(slave.obj_id) + .is_some_and(|s| Arc::ptr_eq(&s, &slave)) + }); + if let Some(world) = world { + for rack in world.all_doodads() { + let matches = { + let r = rack.data(); + r.parent_obj_id == slave.obj_id + || r.transform.parent_obj_id == slave.obj_id + || d.attached_doodads.contains(&rack.obj_id) + }; + if matches && !doodads.iter().any(|r| Arc::ptr_eq(r, &rack)) { + doodads.push(rack); + } + } + } + doodads.sort_by_key(|r| r.obj_id); + let racks: Vec<_> = doodads.iter().map(|rack| { + let r = rack.data().clone(); + let registered = world.is_some_and(|w| w.doodad(rack.obj_id).is_some_and(|live| Arc::ptr_eq(&live, rack))); + json!({"object_id": rack.obj_id, "db_id": r.db_id, "template_id": r.template_id, + "parent": r.parent_obj_id, "transform_parent": r.transform.parent_obj_id, + "attach": r.attach_point, "owner_id": r.owner_id, "owner_db_id": r.owner_db_id, + "owner_type": r.owner_type, "registered": registered, "persistent": r.is_persistent, + "phase": r.func_group_id, "phase_time_ms": r.phase_time_ms, + "interaction_counts": r.phase.interaction_counts, "deleted": r.phase.deleted, + "func_task": r.phase.func_task, "item_id": r.item_id, "item_template_id": r.item_template_id, + "item": if r.item_id == 0 { Value::Null } else { item_snapshot(server, r.item_id) }}) + }).collect(); + let rack_attach: Vec<_> = doodads.iter().map(|r| r.data().attach_point).collect(); + let missing: Vec<_> = (60..=79u8).filter(|p| !rack_attach.contains(p)).collect(); + let duplicate: Vec<_> = (60..=79u8) + .filter(|p| rack_attach.iter().filter(|a| *a == p).count() > 1) + .collect(); + candidates.push(json!({"world_instance": instance, "object_id": slave.obj_id, + "transport_id": d.unit.tl_id, "db_id": d.id, "template_id": d.unit.template_id, + "model_id": d.unit.model_id, "parent": d.unit.transform.parent_obj_id, + "attach": d.attach_point_id, "summoner_id": d.summoner_id, "summoner_object_id": d.summoner_obj_id, + "summoning_item_id": d.summoning_item_id, "owner_type": d.owner_type as u8, + "owner_id": d.unit.owner_id, "owner_object_id": d.owner_obj_id, + "visible": slave.is_visible(), "dead": d.unit.is_dead(), "leave_generation": d.leave_task, + "registered": registered, "owner_root_lookup_member": owner_roots.iter().any(|(_, s)| Arc::ptr_eq(s, &slave)), + "observed_retirement_reference": retirement_references.iter().any(|s| Arc::ptr_eq(s, &slave)), + "item_live_root_lookup_member": registered && d.owner_type == BaseUnitType::Character && !d.unit.is_dead() && d.summoning_item_id == request.item_id, + "local_transform_sample": [d.unit.transform.x, d.unit.transform.y, d.unit.transform.z, d.unit.transform.rot_x, d.unit.transform.rot_y, d.unit.transform.rot_z], + "attached_slaves": d.attached_slaves, "attached_doodads": d.attached_doodads, + "missing_rack_attach": missing, "duplicate_rack_attach": duplicate, "doodads": racks})); + } + let queues: Vec<_> = worlds.iter().map(|world| { + let manager = server.systems.npcs.spawns.get(world.id); + let rows: Vec<_> = manager.as_ref().map(|m| m.pending_despawns()).unwrap_or_default().into_iter() + .filter(|(id, _)| candidates.iter().any(|c| c["world_instance"] == world.id && (c["object_id"] == *id || c["attached_slaves"].as_array().is_some_and(|a| a.iter().any(|v| v.as_u64() == Some(u64::from(*id)))) || c["attached_doodads"].as_array().is_some_and(|a| a.iter().any(|v| v.as_u64() == Some(u64::from(*id))))))) + .map(|(id, at)| json!({"object_id": id, "due_in_ms_sample": at.map(|t| t.saturating_duration_since(spawn_manager::now()).as_millis())})).collect(); + json!({"world_instance": world.id, "matching_despawns_sample": rows}) + }).collect(); + json!({"protocol": PROTOCOL, "nonce": request.nonce, "character_id": request.character_id, + "item_id": request.item_id, "source_capability": CAPABILITY, "package_version": env!("CARGO_PKG_VERSION"), + "source_head": Value::Null, "provenance": "exact binary/source identity requires release manifest", + "sample_sequence": sample, "consistent": false, "authority_consistent": false, + "pending_supported": true, "retirement_consistent": false, + "unsupported": ["spawn queue retained references/direct world removals have no shared audit boundary", "phase/transform/visibility and queue deadlines are temporal samples; no interval proof"], + "publication_scope_held": true, "item_operation_scope_held": true, + "world_instances": worlds.iter().map(|w| w.id).collect::>(), + "summon_item": item_snapshot(server, request.item_id), + "jobs": jobs, "pending_summons": jobs.iter().filter(|j| j.kind == "summon").count(), + "pending_retirement_tasks": jobs.iter().filter(|j| j.kind == "retirement").count(), + "identity_state": summons.audit_identity(request.character_id, request.item_id), + "owner_object_lookups": owner_object_lookups, + "item_has_other_live_root": slaves::item_has_other_live_root(server, request.item_id, request.character_id), + "item_root_lookup": candidates.iter().filter(|c| c["item_live_root_lookup_member"] == true).map(|c| json!({"world_instance": c["world_instance"], "object_id": c["object_id"]})).collect::>(), + "owner_root_lookup": owner_roots.iter().map(|(w, s)| json!({"world_instance": w.id, "object_id": s.obj_id})).collect::>(), + "candidates": candidates, "queues": queues}) +} + +fn hex(bytes: &[u8]) -> String { + const DIGITS: &[u8; 16] = b"0123456789abcdef"; + bytes + .iter() + .flat_map(|b| { + [ + DIGITS[(b >> 4) as usize] as char, + DIGITS[(b & 15) as usize] as char, + ] + }) + .collect() +} + +/// FNV-1a/64 is a completeness checksum, not an authenticity or cryptographic claim. +fn digest(bytes: &[u8]) -> String { + format!( + "{:016x}", + bytes + .iter() + .fold(0xcbf29ce484222325u64, |h, b| (h ^ u64::from(*b)) + .wrapping_mul(0x100000001b3)) + ) +} + +/// ASCII hex permits splitting UTF-8 JSON at byte boundaries. Every line is < 450 bytes; +/// max 410 data records + END. Consumers require all unique indices, exact length, digest, +/// matching nonce/sequence and END. END means transport completeness, never an audit pass. +pub fn chunks(request: &Request, snapshot: &Value) -> anyhow::Result> { + let mut bytes = serde_json::to_vec(snapshot)?; + if bytes.len() > MAX_BYTES { + bytes = serde_json::to_vec(&json!({"protocol": PROTOCOL, "nonce": request.nonce, + "character_id": request.character_id, "item_id": request.item_id, + "sample_sequence": snapshot["sample_sequence"], "consistent": false, + "pending_supported": false, "unsupported": ["snapshot exceeds 65536 byte transport limit"], "source_capability": CAPABILITY}))?; + } + let sequence = &snapshot["sample_sequence"]; + let sum = digest(&bytes); + let count = bytes.len().div_ceil(CHUNK_BYTES); + let mut lines: Vec<_> = bytes + .chunks(CHUNK_BYTES) + .enumerate() + .map(|(i, b)| { + format!( + "{PREFIX} {} {sequence} DATA {}/{count} {} fnv1a64:{sum} hex:{}", + request.nonce, + i + 1, + bytes.len(), + hex(b) + ) + }) + .collect(); + lines.push(format!( + "{PREFIX} {} {sequence} END {count} {} fnv1a64:{sum}", + request.nonce, + bytes.len() + )); + Ok(lines) +} diff --git a/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs new file mode 100644 index 0000000000..f4ea3f85bb --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs @@ -0,0 +1,506 @@ +//! Deterministic source tests; no runtime DB, live stack, or asset dependency. + +use super::*; +use crate::data::items::{ItemTemplate, TemplateKind}; +use crate::data::GameData; +use crate::models::doodad::Doodad; +use crate::systems::vehicles::audit::{self, Request}; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use futures::{poll, FutureExt}; +use serde_json::{json, Value}; + +fn request() -> Request { + Request::parse(&["7".into(), "4001".into(), "test_N-1".into()]).unwrap() +} + +fn fixture() -> (Arc, TestClient, PlayerRef) { + let mut data = GameData::empty(); + data.items.templates.insert( + 23398, + ItemTemplate { + kind: TemplateKind::SummonSlave { slave_id: 75 }, + ..ItemTemplate::plain(23398, 1) + }, + ); + data.systems.vehicles.slave_templates.insert( + 75, + SlaveTemplate { + id: 75, + ..Default::default() + }, + ); + let server = Arc::new(test_server_with(data)); + server.set_self(); + let client = TestClient::new(&server, 7, 1007); + let owner = spawn_player( + &server, + &client, + test_character(7, "Owner", 100.0, 100.0), + 700, + ); + let bag = owner + .data() + .inventory + .get(slot_type::INVENTORY) + .unwrap() + .clone(); + let mut item = Item::new(0); + item.id = 4001; + item.class = ItemClass::SummonSlave; + item.template_id = 23398; + item.owner_id = 7; + item.slot_type = slot_type::INVENTORY; + item.count = 1; + item.details.slave_db_id = 123; + bag.lock().unwrap().items.push(item); + server.items.add_container(bag); + (server, client, owner) +} + +#[tokio::test] +async fn audit_pending_before_poll_and_early_completion_release() { + let (server, _client, owner) = fixture(); + let future = create_for_owner(&server, &owner, 4001, 23398, false, None, None, 0.0); + let snap = audit::snapshot(&server, &request()); + assert_eq!(snap["pending_summons"], 1); + assert_eq!(snap["jobs"][0]["phase"], "queued"); + assert!(snap["candidates"].as_array().unwrap().is_empty()); + drop(future); // Never polled, so no reservation/DB/gameplay work has run. + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); + let world = server.world.world(0).unwrap(); + let unpolled = create( + &server, + &world, + Some(&owner), + 75, + server.items.item_by_id(4001), + false, + None, + ); + assert_eq!( + audit::snapshot(&server, &request())["jobs"][0]["phase"], + "queued" + ); + drop(unpolled); + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); + assert!( + create_for_owner(&server, &owner, 4001, 0, false, None, None, 0.0) + .await + .is_none() + ); + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); +} + +#[tokio::test] +async fn audit_real_owner_and_item_waiters_release_on_cancellation() { + let (server, _client, owner) = fixture(); + let summons = &server.systems.vehicles.slave_summons; + *summons.test_loader.lock().unwrap() = Some(TestSlaveLoader(Arc::new(|_, _| { + Box::pin(std::future::pending()) + }))); + let mut active = Box::pin(create_for_owner( + &server, &owner, 4001, 23398, false, None, None, 0.0, + )); + assert!(poll!(&mut active).is_pending()); + let mut waiter = Box::pin(create_for_owner( + &server, &owner, 4001, 23398, false, None, None, 0.0, + )); + assert!(poll!(&mut waiter).is_pending()); + let snap = audit::snapshot(&server, &request()); + assert_eq!(snap["pending_summons"], 2); + assert_eq!(snap["jobs"][0]["phase"], "active"); + assert_eq!(snap["jobs"][1]["phase"], "waiting_owner"); + drop(waiter); + drop(active); + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); + let item_lock = summons + .reservation(SummonKey::Item(4001)) + .lock_owned() + .await; + let mut waiter = Box::pin(create_for_owner( + &server, &owner, 4001, 23398, false, None, None, 0.0, + )); + assert!(poll!(&mut waiter).is_pending()); + assert_eq!( + audit::snapshot(&server, &request())["jobs"][0]["phase"], + "waiting_item" + ); + drop(waiter); + drop(item_lock); + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); + assert!(summons.reservation(SummonKey::Owner(7)).try_lock().is_ok()); +} + +#[tokio::test] +async fn audit_real_loader_panic_releases_job_and_authority_reservations() { + let (server, _client, owner) = fixture(); + let summons = &server.systems.vehicles.slave_summons; + *summons.test_loader.lock().unwrap() = Some(TestSlaveLoader(Arc::new(|_, _| { + Box::pin(async { panic!("audit loader unwind") }) + }))); + let future = create_for_owner(&server, &owner, 4001, 23398, false, None, None, 0.0); + assert!(std::panic::AssertUnwindSafe(future) + .catch_unwind() + .await + .is_err()); + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); + assert!(summons.reservation(SummonKey::Owner(7)).try_lock().is_ok()); + assert!(summons + .reservation(SummonKey::Item(4001)) + .try_lock() + .is_ok()); +} + +#[tokio::test] +async fn audit_detached_skill_is_pending_before_runtime_polls_it() { + let (server, _client, owner) = fixture(); + let entered = Arc::new(tokio::sync::Semaphore::new(0)); + let signal = entered.clone(); + *server + .systems + .vehicles + .slave_summons + .test_loader + .lock() + .unwrap() = Some(TestSlaveLoader(Arc::new(move |_, _| { + let signal = signal.clone(); + Box::pin(async move { + signal.add_permits(1); + Err(sqlx::Error::RowNotFound) + }) + }))); + create_from_skill( + &server, + &owner, + &SkillCaster::Item { + obj_id: owner.obj_id, + item_id: 4001, + item_template_id: 23398, + type1: 0, + type2: 0, + }, + None, + 0.0, + ); + assert_eq!( + audit::snapshot(&server, &request())["jobs"][0]["phase"], + "queued" + ); + entered.acquire().await.unwrap().forget(); + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); +} + +fn hull(world: &WorldInstance, object: u32, owner: u32, item: u64, child: bool) -> SlaveRef { + let mut slave = Slave::new(object + 1000, 75); + slave.summoner_id = owner; + slave.summoning_item_id = item; + slave.owner_type = if child { + BaseUnitType::Slave + } else { + BaseUnitType::Character + }; + slave.unit.hp = 10; + slave.unit.transform.instance_id = world.id; + let slave = Entity::new(object, slave); + world.add_object(&slave); // Hidden objects must be included without visibility filtering. + slave +} + +#[tokio::test] +async fn audit_retirement_task_leases_release_on_abort_and_panic() { + let (server, _client, _owner) = fixture(); + let world = server.world.world(0).unwrap(); + let root = hull(&world, 850, 7, 4001, false); + let diagnostics = &server.systems.vehicles.slave_summons.diagnostics; + let lease = diagnostics.retirement(&root, 1); + let task = tokio::spawn(async move { + let _lease = lease; + std::future::pending::<()>().await; + }); + // No await since construction: the task has not been polled on this runtime. + assert_eq!( + audit::snapshot(&server, &request())["pending_retirement_tasks"], + 1 + ); + task.abort(); + assert!(task.await.unwrap_err().is_cancelled()); + assert_eq!( + audit::snapshot(&server, &request())["pending_retirement_tasks"], + 0 + ); + let lease = diagnostics.retirement(&root, 2); + let task: tokio::task::JoinHandle<()> = tokio::spawn(async move { + let _lease = lease; + panic!("retirement task unwind"); + }); + assert!(task.await.unwrap_err().is_panic()); + assert_eq!( + audit::snapshot(&server, &request())["pending_retirement_tasks"], + 0 + ); +} + +#[tokio::test] +async fn audit_observation_does_not_extend_retired_hull_lifetime() { + let (server, _client, _owner) = fixture(); + let world = server.world.world(0).unwrap(); + let root = hull(&world, 851, 7, 4001, false); + audit_retirement(&server, &world, &root); + world.remove_object(root.obj_id); + assert_eq!(Arc::strong_count(&root), 1); + assert_eq!( + audit::snapshot(&server, &request())["candidates"] + .as_array() + .unwrap() + .len(), + 1 + ); + assert_eq!(Arc::strong_count(&root), 1); + drop(root); + assert!(audit::snapshot(&server, &request())["candidates"] + .as_array() + .unwrap() + .is_empty()); +} + +#[tokio::test] +async fn audit_all_worlds_hidden_dead_children_retiring_and_owner_item_isolation() { + let (server, _client, _owner) = fixture(); + let world = server.world.world(0).unwrap(); + let other = server + .world + .create_world_instance(world.template.clone(), 42); + let root = hull(&world, 800, 7, 4001, false); + let child = hull(&other, 801, 7, 0, true); + child.data().unit.hp = 0; + let foreign_item = hull(&other, 802, 8, 4001, false); + let _unrelated = hull(&other, 803, 8, 4002, false); + let retiring = hull(&world, 804, 7, 4001, false); + let retirement = server + .systems + .vehicles + .slave_summons + .diagnostics + .retirement(&retiring, 88); + audit_retirement(&server, &world, &retiring); + server + .systems + .npcs + .spawns + .get_or_create(&world) + .add_despawn( + &server, + WorldObject::from(&retiring), + Some(spawn_manager::now()), + ); + world.remove_object(retiring.obj_id); + let _unrelated_job = server + .systems + .vehicles + .slave_summons + .diagnostics + .summon(8, 4002); + let snap = audit::snapshot(&server, &request()); + assert_eq!(snap["world_instances"], json!([0, 42])); + let candidates = snap["candidates"].as_array().unwrap(); + assert_eq!(candidates.len(), 4); + let get = |id: u32| candidates.iter().find(|c| c["object_id"] == id).unwrap(); + assert_eq!(get(root.obj_id)["visible"], false); + assert_eq!(get(root.obj_id)["owner_root_lookup_member"], true); + assert_eq!(get(child.obj_id)["dead"], true); + assert_eq!(get(child.obj_id)["owner_root_lookup_member"], false); + assert_eq!( + get(foreign_item.obj_id)["item_live_root_lookup_member"], + true + ); + assert_eq!(get(retiring.obj_id)["registered"], false); + assert_eq!(snap["pending_retirement_tasks"], 1); + assert_eq!(snap["pending_summons"], 0); + assert_eq!( + snap["queues"][0]["matching_despawns_sample"][0]["object_id"], + retiring.obj_id + ); + assert_eq!(snap["consistent"], false); + drop(retirement); + assert_eq!( + audit::snapshot(&server, &request())["pending_retirement_tasks"], + 0 + ); +} + +#[tokio::test] +async fn audit_twenty_real_rack_references_and_items_are_read_only() { + let (server, _client, _owner) = fixture(); + let world = server.world.world(0).unwrap(); + let root = hull(&world, 900, 7, 4001, false); + let system = + server + .items + .container_for_character(7, slot_type::SYSTEM, 0, &server.ids.container); + let mut racks = Vec::new(); + for attach in 60..=79u8 { + let mut item = Item::new(0); + item.id = 10_000 + u64::from(attach); + item.template_id = 20090; + item.count = 1; + item.owner_id = 7; + item.slot_type = slot_type::SYSTEM; + let mut rack = Doodad::new(3446); + rack.db_id = 100 + u32::from(attach); + rack.attach_point = attach; + rack.parent_obj_id = root.obj_id; + rack.transform.parent_obj_id = root.obj_id; + rack.func_group_id = 8265; + rack.item_id = item.id; + rack.item_template_id = item.template_id; + system.lock().unwrap().items.push(item); + let rack = Entity::new(1000 + u32::from(attach), rack); + world.add_object(&rack); + root.data().attached_doodads.push(rack.obj_id); + racks.push(rack); + } + let root_before = root.data().clone(); + let racks_before: Vec<_> = racks.iter().map(|r| r.data().clone()).collect(); + let items_before = system.lock().unwrap().items.clone(); + let dirty_before = system.lock().unwrap().dirty; + let removed_before = server.items.removed_items(); + let containers_before = server.items.all_containers().len(); + let snap = audit::snapshot(&server, &request()); + assert_eq!(snap["summon_item"]["lookup"]["saved_slave_db_id"], 123); + let candidate = &snap["candidates"][0]; + assert_eq!(candidate["doodads"].as_array().unwrap().len(), 20); + assert_eq!(candidate["missing_rack_attach"], json!([])); + for rack in candidate["doodads"].as_array().unwrap() { + let attach = rack["attach"].as_u64().unwrap(); + assert_eq!(rack["item"]["lookup"]["id"], 10_000 + attach); + assert_eq!( + rack["item"]["containers"][0]["slot_type"], + slot_type::SYSTEM + ); + assert_eq!(rack["item"]["containers"][0]["items"][0]["count"], 1); + } + assert_eq!(*root.data(), root_before); + assert_eq!( + racks.iter().map(|r| r.data().clone()).collect::>(), + racks_before + ); + assert_eq!(system.lock().unwrap().items, items_before); + assert_eq!(system.lock().unwrap().dirty, dirty_before); + assert_eq!(server.items.removed_items(), removed_before); + assert_eq!(server.items.all_containers().len(), containers_before); +} + +#[test] +fn audit_request_rejects_malformed_ids_nonce_and_extra_arguments() { + for args in [ + vec!["7", "1"], + vec!["0", "1", "n"], + vec!["7", "0", "n"], + vec!["-1", "1", "n"], + vec!["+7", "1", "n"], + vec!["4294967296", "1", "n"], + vec!["7", "18446744073709551616", "n"], + vec!["7", "1", "bad|nonce"], + vec!["7", "1", "n", "extra"], + vec!["7", "1", ""], + vec!["7", "1", "é"], + ] { + assert!( + Request::parse(&args.iter().map(|s| (*s).into()).collect::>()).is_err(), + "{args:?}" + ); + } + assert!(Request::parse(&["7".into(), "1".into(), "x".repeat(33)]).is_err()); + assert!(Request::parse(&[u32::MAX.to_string(), u64::MAX.to_string(), "x".repeat(32)]).is_ok()); +} + +// A strict independent consumer: reject missing, stale, duplicate, corrupt or partial replies. +fn reassemble(lines: &[String]) -> Option { + let end: Vec<_> = lines.last()?.split_ascii_whitespace().collect(); + if end.len() != 7 || end[0] != audit::PREFIX || end[3] != "END" { + return None; + } + let count = end[4].parse::().ok()?; + let length = end[5].parse::().ok()?; + if lines.len() != count + 1 { + return None; + } + let mut bytes = Vec::new(); + for (index, line) in lines[..count].iter().enumerate() { + let fields: Vec<_> = line.split_ascii_whitespace().collect(); + if fields.len() != 8 + || fields[..3] != end[..3] + || fields[3] != "DATA" + || fields[4] != format!("{}/{count}", index + 1) + || fields[5] != end[5] + || fields[6] != end[6] + { + return None; + } + let payload = fields[7].strip_prefix("hex:")?; + if !payload.len().is_multiple_of(2) { + return None; + } + for i in (0..payload.len()).step_by(2) { + bytes.push(u8::from_str_radix(payload.get(i..i + 2)?, 16).ok()?); + } + } + let hash = bytes.iter().fold(0xcbf29ce484222325u64, |h, b| { + (h ^ u64::from(*b)).wrapping_mul(0x100000001b3) + }); + if bytes.len() != length || end[6] != format!("fnv1a64:{hash:016x}") { + return None; + } + let value: Value = serde_json::from_slice(&bytes).ok()?; + if value["nonce"] != end[1] || value["sample_sequence"].to_string() != end[2] { + return None; + } + Some(value) +} + +#[test] +fn audit_chunks_are_bounded_complete_and_reject_corrupt_or_stale_data() { + let req = request(); + let value = json!({"nonce": req.nonce, "sample_sequence": 83, "payload": "船".repeat(300)}); + let lines = audit::chunks(&req, &value).unwrap(); + assert!(lines.iter().all(|l| l.len() < 450)); + assert_eq!(reassemble(&lines), Some(value)); + assert!(reassemble(&lines[..lines.len() - 1]).is_none()); + let mut missing = lines.clone(); + missing.remove(1); + assert!(reassemble(&missing).is_none()); + let mut duplicate = lines.clone(); + duplicate[1] = duplicate[0].clone(); + assert!(reassemble(&duplicate).is_none()); + let mut stale = lines.clone(); + stale[0] = stale[0].replace("test_N-1", "old"); + assert!(reassemble(&stale).is_none()); + let mut corrupt = lines.clone(); + corrupt[0].push_str("00"); + assert!(reassemble(&corrupt).is_none()); + let huge = json!({"nonce": req.nonce, "sample_sequence": 83, "payload": "x".repeat(70_000)}); + let unsupported = reassemble(&audit::chunks(&req, &huge).unwrap()).unwrap(); + assert_eq!(unsupported["consistent"], false); + assert!(unsupported.get("payload").is_none()); +} + +#[tokio::test] +async fn audit_invalid_command_and_gm_authorization_use_existing_root() { + use crate::systems::services::commands::scripts::harness; + let server = harness::server(); + let gm = harness::pc(&server, 7, "Observer", 100.0, 100.0); + let (_, denied) = harness::run_at(&server, &gm.p, "slave audit 7 4001 valid", 0).await; + assert!(denied.iter().all(|s| !s.starts_with(audit::PREFIX))); + for command in [ + "slave audit 7 4001 bad|nonce", + "slave audit 7 4001 n extra", + "slave audit 0 4001 n", + ] { + let (_, lines) = harness::run(&server, &gm.p, command).await; + assert!(lines.iter().all(|s| !s.starts_with(audit::PREFIX))); + } + let (_, lines) = harness::run(&server, &gm.p, "slave audit 7 4001 valid").await; + assert_eq!(reassemble(&lines).unwrap()["consistent"], false); + // This also verifies requesting an absent owner/item does not create any containers/items. + assert!(server.items.all_containers().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 b5b6b9e198..9d7476f9f3 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs @@ -21,6 +21,7 @@ //! | [`hooks`] | physics / economy hooks, the skills / social hook wrappers | //! | [`packets`] | every vehicle C->S / S->C packet | +pub mod audit; pub mod data; pub mod effects; pub mod harpoon; @@ -534,8 +535,16 @@ pub fn force_dismount_and_despawn( continue; }; let player = player.clone(); + let lease = server + .systems + .vehicles + .slave_summons + .diagnostics + .retirement(&slave, gen); rt.spawn(async move { + let task_lease = lease; tokio::time::sleep(Duration::from_millis(time_to_despawn_ms)).await; + task_lease.phase("active"); let _items = server.systems.economy.operation_scope(); let _publication = server .systems @@ -577,8 +586,16 @@ pub fn force_dismount_and_despawn_test_slave( return res; }; let (player, slave) = (player.clone(), slave.clone()); + let lease = server + .systems + .vehicles + .slave_summons + .diagnostics + .retirement(&slave, gen); rt.spawn(async move { + let task_lease = lease; tokio::time::sleep(Duration::from_millis(time_to_despawn_ms)).await; + task_lease.phase("active"); let _items = server.systems.economy.operation_scope(); let _publication = server.systems.vehicles.slave_summons.publication_scope(); if slave.data().leave_task != gen { diff --git a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs index 13c0cb6b0f..cb73718aa3 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs @@ -76,6 +76,7 @@ enum SummonKey { /// publication with departure. No object lock or synchronous guard crosses an await. #[derive(Debug, Default)] pub(crate) struct SlaveSummons { + pub(super) diagnostics: super::audit::Diagnostics, reservations: Mutex>>>, pub(super) departing: Mutex>, /// Serializes complete synchronous hull publication/removal, including nested callbacks. @@ -114,6 +115,34 @@ impl std::fmt::Debug for TestPublicationHook { } impl SlaveSummons { + /// Observe the actual reservation table; never acquire or create an authority reservation. + pub(super) fn audit_identity(&self, owner: u32, item: u64) -> serde_json::Value { + let reservations = self + .reservations + .lock() + .expect("slave reservations poisoned"); + let mut rows = Vec::new(); + for (key, weak) in reservations.iter() { + let matches = match key { + SummonKey::Owner(id) => *id == owner, + SummonKey::Item(id) => *id == item, + }; + if !matches { + continue; + } + if let Some(lock) = weak.upgrade() { + rows.push(serde_json::json!({"key": match key { SummonKey::Owner(_) => "owner", SummonKey::Item(_) => "item" }, "held_sample": lock.try_lock().is_err()})); + } + } + rows.sort_by_key(|r| r["key"].as_str().unwrap_or_default().to_owned()); + drop(reservations); + let saves = self.pending_saves.lock().expect("slave saves poisoned"); + let pending: Vec<_> = saves.iter().filter(|(id, rows)| **id == item || rows.iter().any(|r| r.summoner == owner)).map(|(id, rows)| serde_json::json!({"item": id, "rows": rows.iter().map(|r| serde_json::json!({"db_id": r.id, "item": r.item_id, "summoner": r.summoner, "owner_id": r.owner_id, "owner_type": r.owner_type, "attach": r.attach_point, "template": r.template_id})).collect::>()})).collect(); + serde_json::json!({"reservations_sample": rows, + "departing_connection": self.departing.lock().expect("slave departures poisoned").get(&owner).copied(), + "pending_hull_saves": pending}) + } + pub(crate) fn publication_scope(&self) -> spawn_manager::ReentrantGuard<'_> { self.publication_gate.lock() } @@ -423,7 +452,7 @@ pub(super) fn owned_roots( .collect() } -fn item_has_other_live_root(server: &GameServer, item_id: u64, owner_id: u32) -> bool { +pub(super) fn item_has_other_live_root(server: &GameServer, item_id: u64, owner_id: u32) -> bool { server.world.worlds().into_iter().any(|world| { all_slaves(&world).into_iter().any(|slave| { let d = slave.data(); @@ -1543,6 +1572,26 @@ fn spawn_manager_of( server.systems.npcs.spawns.get(world_id) } +fn audit_retirement(server: &GameServer, world: &WorldInstance, root: &SlaveRef) { + let (children, doodads) = { + let d = root.data(); + (d.attached_slaves.clone(), d.attached_doodads.clone()) + }; + let doodads: Vec<_> = doodads + .into_iter() + .filter_map(|id| world.doodad(id)) + .collect(); + let diagnostics = &server.systems.vehicles.slave_summons.diagnostics; + diagnostics.retiring(world.id, root, &doodads); + for child in children.into_iter().filter_map(|id| world.slave(id)) { + diagnostics.retiring(world.id, &child, &[]); + } +} + +#[cfg(test)] +#[path = "audit_tests.rs"] +mod audit_tests; + /// `Delete(owner, objId, ignoreAttachedItemWarning)`. pub fn delete( server: &GameServer, @@ -1613,6 +1662,7 @@ fn try_delete( if !can_delete(&world, &slave, owner, ignore_attached_item_warning) { return false; } + audit_retirement(server, &world, &slave); save(server, &slave); let (attached_chars, tl) = { let d = slave.data(); @@ -1907,8 +1957,16 @@ pub fn create_from_skill( return; }; let owner = owner.clone(); + // Construct the lease before the detached future exists, so even a never-polled task + // remains pending evidence. The captured lease drops on no runtime, abort and unwind. + let lease = server + .systems + .vehicles + .slave_summons + .diagnostics + .summon(owner.character_id, item_id); let fut = async move { - create_for_owner( + create_for_owner_job( &server, &owner, item_id, @@ -1917,6 +1975,7 @@ pub fn create_from_skill( None, placement, max_range, + lease, ) .await; }; @@ -2015,7 +2074,37 @@ fn validated_summon_placement( /// `Create(owner, skillData, hideSpawnEffect, positionOverride)`. #[allow(clippy::too_many_arguments)] -pub async fn create_for_owner( +pub fn create_for_owner<'a>( + server: &'a GameServer, + owner: &'a PlayerRef, + item_id: u64, + item_template_id: u32, + hide_spawn_effect: bool, + position_override: Option, + placement: Option, + max_range: f32, +) -> impl std::future::Future> + Send + 'a { + let lease = server + .systems + .vehicles + .slave_summons + .diagnostics + .summon(owner.character_id, item_id); + create_for_owner_job( + server, + owner, + item_id, + item_template_id, + hide_spawn_effect, + position_override, + placement, + max_range, + lease, + ) +} + +#[allow(clippy::too_many_arguments)] +async fn create_for_owner_job( server: &GameServer, owner: &PlayerRef, item_id: u64, @@ -2024,7 +2113,9 @@ pub async fn create_for_owner( position_override: Option, placement: Option, max_range: f32, + lease: super::audit::Lease, ) -> Option { + lease.phase("validating"); let world = player_world(server, owner)?; if item_id == 0 || item_template_id == 0 { return None; @@ -2063,33 +2154,41 @@ pub async fn create_for_owner( position_override, placement, max_range, + &lease, ) .await } /// `Create(owner, null, templateId, item, hideSpawnEffect, positionOverride)` with the DB parts /// (saved slave, its persistent doodads, its saved child slaves). -pub async fn create( - server: &GameServer, - world: &Arc, - owner: Option<&PlayerRef>, +pub fn create<'a>( + server: &'a GameServer, + world: &'a Arc, + owner: Option<&'a PlayerRef>, template_id: u32, item: Option, hide_spawn_effect: bool, position_override: Option, -) -> Option { - create_with_placement( - server, - world, - owner, - template_id, - item, - hide_spawn_effect, - position_override, - None, - 0.0, - ) - .await +) -> impl std::future::Future> + Send + 'a { + let lease = server.systems.vehicles.slave_summons.diagnostics.summon( + owner.map_or(0, |o| o.character_id), + item.as_ref().map_or(0, |i| i.id), + ); + async move { + create_with_placement( + server, + world, + owner, + template_id, + item, + hide_spawn_effect, + position_override, + None, + 0.0, + &lease, + ) + .await + } } #[allow(clippy::too_many_arguments)] @@ -2103,6 +2202,7 @@ async fn create_with_placement( mut position_override: Option, placement: Option, max_range: f32, + lease: &super::audit::Lease, ) -> Option { server .game_data @@ -2119,6 +2219,7 @@ async fn create_with_placement( let summons = &server.systems.vehicles.slave_summons; let owner_id = owner.map_or(0, |o| o.character_id); // Acquire in one order. Owned async guards release on all errors and future cancellation. + lease.phase("waiting_owner"); let _owner_reservation = match owner { Some(_) => Some( summons @@ -2128,6 +2229,7 @@ async fn create_with_placement( ), None => None, }; + lease.phase("waiting_item"); let _item_reservation = match (&item, owner) { (Some(item), Some(_)) if item.id != 0 => Some( summons @@ -2137,6 +2239,7 @@ async fn create_with_placement( ), _ => None, }; + lease.phase("active"); let mut item = match (item, owner) { (Some(item), Some(owner)) => { let item = owned_summon_item(server, owner, item.id, item.template_id)?; @@ -3501,6 +3604,9 @@ pub fn do_die( let _items = server.systems.economy.operation_scope(); let _publication = server.systems.vehicles.slave_summons.publication_scope(); let obj = WorldObject::from(slave); + if let Some(world) = server.world.world_of(&obj) { + audit_retirement(server, &world, slave); + } crate::systems::skills::skill::interrupt_skills(server, &obj); crate::systems::skills::buffs::fire_unit_event( server, From 9a342dd46d9bd417ac997db80d14f27f9972cb37 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:38:18 -0400 Subject: [PATCH 49/66] fix(economy): order item scopes before manager locks Enter the reentrant item scope before auction and housing operation locks at financial capture and callback-bearing mutation boundaries. Preserve existing manager order, deferred callbacks and synchronous guard lifetimes. Add bounded contention regressions for financial capture, auction listing/bidding, a real housing sale payment and construction refusal. Validation is source-only: scoped rustfmt and git diff checks; runtime checks remain with the parent. Co-Authored-By: Codex --- rust/crates/aaemu-game/src/managers/save.rs | 1 + .../aaemu-game/src/systems/economy/auction.rs | 12 +- .../aaemu-game/src/systems/economy/craft.rs | 3 +- .../aaemu-game/src/systems/economy/mail.rs | 1 + .../src/systems/economy/operation_scope.rs | 8 + .../systems/economy/operation_scope_tests.rs | 267 +++++++++++++++++- .../src/systems/housing/dominion/runtime.rs | 3 + .../aaemu-game/src/systems/housing/manager.rs | 2 + .../aaemu-game/src/systems/housing/ops.rs | 7 + .../src/systems/npcs/doodad/funcs/items.rs | 2 + .../services/commands/scripts/dominion.rs | 2 + .../aaemu-game/src/systems/social/dominion.rs | 2 + 12 files changed, 305 insertions(+), 5 deletions(-) diff --git a/rust/crates/aaemu-game/src/managers/save.rs b/rust/crates/aaemu-game/src/managers/save.rs index fa194c5aa4..4647fce3d9 100644 --- a/rust/crates/aaemu-game/src/managers/save.rs +++ b/rust/crates/aaemu-game/src/managers/save.rs @@ -30,6 +30,7 @@ pub(crate) struct FinancialSnapshot { /// Capture property transactions before any database await. Claim/capture, tax payments, /// certificates, receipts and wallets must describe the same logical operation boundary. pub(crate) fn capture_financial_snapshot(server: &GameServer) -> FinancialSnapshot { + let _items = server.systems.economy.operation_scope(); let _auction = server.systems.economy.auction.operation_lock(); let _housing = server .systems diff --git a/rust/crates/aaemu-game/src/systems/economy/auction.rs b/rust/crates/aaemu-game/src/systems/economy/auction.rs index cfc4997fe8..cffa4504a9 100644 --- a/rust/crates/aaemu-game/src/systems/economy/auction.rs +++ b/rust/crates/aaemu-game/src/systems/economy/auction.rs @@ -711,7 +711,8 @@ impl AuctionManager { .extend(failed); } - /// Serialises the auction operations (outermost lock; mails are sent while it is held). + /// Serialises auction operations inside the item operation scope. Mail callbacks may + /// start ItemTxn while this lock is held, so mutating entries acquire the scope first. fn op(&self) -> MutexGuard<'_, ()> { self.op.lock().unwrap_or_else(|e| e.into_inner()) } @@ -720,6 +721,11 @@ impl AuctionManager { self.op() } + #[cfg(test)] + pub(super) fn try_operation_lock(&self) -> std::sync::TryLockResult> { + self.op.try_lock() + } + pub(crate) fn prepare_save(&self, server: &GameServer) -> AuctionSaveBatch { let ids = self.deleted_ids(); let versions = self @@ -875,6 +881,7 @@ impl AuctionManager { /// `CancelAuctionLot(player, auctionId)`: only the seller may cancel a lot without bids. /// Return the original escrow item, preserving its ID and details. pub fn cancel_auction_lot(&self, server: &GameServer, player: &PlayerRef, auction_id: u64) { + let _items = server.systems.economy.operation_scope(); let _op = self.op(); let Some(lot) = self.lot(auction_id) else { tracing::warn!("AuctionLot with ID {auction_id} not found."); @@ -936,6 +943,7 @@ impl AuctionManager { lot_id: u64, mut bid: AuctionBid, ) { + let _items = server.systems.economy.operation_scope(); let _op = self.op(); let Some(mut lot) = self.lot(lot_id) else { tracing::warn!("Invalid auctionItem passed to BidOnAuctionLot."); @@ -1165,6 +1173,7 @@ impl AuctionManager { /// `UpdateAuctionHouse()` (`AuctionHouseTask`). pub fn update_auction_house(&self, server: &GameServer, now: DateTime) { tracing::trace!("Updating Auction House!"); + let _items = server.systems.economy.operation_scope(); let _op = self.op(); self.retry_pending_settlements(server); let expired: Vec = self @@ -1241,6 +1250,7 @@ impl AuctionManager { buyout_price: i32, duration: u8, ) { + let _items = server.systems.economy.operation_scope(); let _op = self.op(); let mut txn = ItemTxn::begin(server); // Only the player's own unbound inventory item can enter auction escrow. diff --git a/rust/crates/aaemu-game/src/systems/economy/craft.rs b/rust/crates/aaemu-game/src/systems/economy/craft.rs index 9aa9761b3b..5cee696c4b 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft.rs @@ -656,7 +656,8 @@ pub fn end_craft(server: &GameServer, player: &PlayerRef) { } // Keep the permission check and product/material commit together with house transfers - // and permission changes. Economy transactions are acquired after this housing lock. + // and permission changes. Enter the item scope before housing; ItemTxn follows it. + let _items = server.systems.economy.operation_scope(); let housing_bench = server .world .object(state.doodad_id) diff --git a/rust/crates/aaemu-game/src/systems/economy/mail.rs b/rust/crates/aaemu-game/src/systems/economy/mail.rs index 8d27b8e36c..d9e9d6e2ba 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail.rs @@ -1565,6 +1565,7 @@ pub fn pay_housing_tax( mail_id: i64, auto_use_aa_point: bool, ) -> bool { + let _items = server.systems.economy.operation_scope(); let operation = server .systems .housing diff --git a/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs b/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs index 2403b65753..a14ebabc2b 100644 --- a/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs +++ b/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs @@ -1,5 +1,13 @@ //! Synchronous operation boundary around callback-bearing world/item changes. The inner //! economy ops mutex stays non-reentrant; only this outer scope permits same-thread entry. +//! +//! Acquire this scope before callback-bearing manager/publication locks. Financial capture +//! keeps its existing auction -> housing -> authority order inside the scope, followed by +//! ops -> object/container leaf locks (at most one object data guard). Mutation callbacks +//! run after ops/object guards drop and may then enter ItemTxn again on the same thread. +//! Snapshot-only manager locks which never wait for an item operation need no scope. +//! ItemTxn::unlocked remains guardless: callers under a character lock must not acquire +//! this scope to compensate. use std::marker::PhantomData; use std::rc::Rc; diff --git a/rust/crates/aaemu-game/src/systems/economy/operation_scope_tests.rs b/rust/crates/aaemu-game/src/systems/economy/operation_scope_tests.rs index 7766738467..35124d1a14 100644 --- a/rust/crates/aaemu-game/src/systems/economy/operation_scope_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/operation_scope_tests.rs @@ -1,8 +1,16 @@ use super::*; +use crate::data::items::ItemTemplate; +use crate::data::GameData; +use crate::models::character::Inventory; +use crate::models::container::slot_type; +use crate::models::house::House; use crate::models::item_task::ItemFx; -use crate::test_support::{spawn_player, test_character, test_server, TestClient}; -use crate::world::PlayerRef; -use std::sync::atomic::{AtomicUsize, Ordering}; +use crate::systems::housing; +use crate::test_support::{ + spawn_player, test_character, test_server, test_server_with, TestClient, +}; +use crate::world::{Entity, HouseRef, PlayerRef}; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use std::sync::mpsc; use std::time::Duration; @@ -102,3 +110,256 @@ async fn item_callbacks_reenter_the_outer_scope_after_releasing_ops() { assert_eq!(callback.0.load(Ordering::SeqCst), 1); assert!(!System::ops_held_on_this_thread()); } + +/// A publication callback reaches the same managers as financial/property operations, +/// then starts an ordinary item operation. try_lock makes an ordering regression fail +/// immediately instead of deadlocking the test's publication thread. +struct PublicationCallback { + active: AtomicBool, + calls: AtomicUsize, +} + +impl hooks::QuestItemHooks for PublicationCallback { + fn on_items_acquired(&self, server: &GameServer, _player: &PlayerRef, _id: u32, _count: i32) { + if !self.active.load(Ordering::SeqCst) { + return; + } + assert!(!System::ops_held_on_this_thread()); + { + let _auction = server + .systems + .economy + .auction + .try_operation_lock() + .expect("waiting operation must not hold auction before the outer scope"); + let _housing = server + .systems + .housing + .operation_lock + .try_lock() + .expect("waiting operation must not hold housing before the outer scope"); + } + let _callback = inventory::ItemTxn::begin(server); + self.calls.fetch_add(1, Ordering::SeqCst); + } +} + +fn contend_with_publication( + server: &Arc, + operation: impl FnOnce(&GameServer) + Send + 'static, +) { + let callback = Arc::new(PublicationCallback { + active: AtomicBool::new(true), + calls: AtomicUsize::new(0), + }); + server + .systems + .economy + .hooks + .quests + .install(callback.clone()); + let publication = server.systems.economy.operation_scope(); + let worker_server = server.clone(); + let runtime = tokio::runtime::Handle::current(); + let (done, received) = mpsc::channel(); + let worker = std::thread::spawn(move || { + let _runtime = runtime.enter(); + operation(&worker_server); + done.send(()).unwrap(); + }); + // This observes the real gate's waiter count, not a pre-entry barrier. The worker + // cannot finish until publication releases its scope, and holds no manager yet. + server.systems.economy.wait_until_operation_blocked(); + assert!(received.try_recv().is_err()); + let mut txn = inventory::ItemTxn::begin(server); + txn.env.fx.push(ItemFx::Acquired { + owner: 1, + template_id: 1, + count: 1, + }); + drop(txn); + assert_eq!(callback.calls.load(Ordering::SeqCst), 1); + callback.active.store(false, Ordering::SeqCst); + drop(publication); + received + .recv_timeout(Duration::from_secs(5)) + .expect("operation must finish after publication releases the scope"); + worker.join().unwrap(); +} + +const LISTED_ITEM: u32 = 5001; +const HOUSE: u32 = 300; + +fn property_server() -> (Arc, PlayerRef) { + let mut data = GameData::empty(); + for id in [LISTED_ITEM, housing::manager::APPRAISAL_CERTIFICATE] { + data.items + .templates + .insert(id, ItemTemplate::plain(id, 100)); + } + data.systems + .housing + .add_template(housing::data::HousingTemplate { + id: HOUSE, + is_sellable: true, + ..Default::default() + }); + let server = Arc::new(test_server_with(data)); + server.set_self(); + server + .systems + .housing + .hooks + .install(Arc::new(bridges::EconomyForHousing)); + let client = TestClient::new(&server, 1, 1001); + let mut character = test_character(1, "Owner", 100.0, 100.0); + character.inventory = Inventory::new(1, 50, 50, &server.items, &server.ids.container); + let player = spawn_player(&server, &client, character, 0x100); + player.data().money = 100_000; + server.names.add_character(1, "Owner", 1001); + (server, player) +} + +fn give_property_item(server: &GameServer, player: &PlayerRef, template: u32, count: i32) -> u64 { + let item = server + .items + .create( + template, + count, + 0, + 1, + &server.game_data.items, + &server.ids.item, + 0, + ) + .unwrap(); + let id = item.id; + inventory::Inv::of(player) + .bag() + .lock() + .unwrap() + .add_new_item(item, -1, &server.game_data.items) + .unwrap(); + id +} + +fn sale_house(server: &GameServer, player: &PlayerRef) -> HouseRef { + let house = Entity::new( + server.ids.object.get_next_id().unwrap(), + House::new(1, HOUSE), + ); + { + let mut h = house.data(); + h.unit.owner_id = player.character_id; + h.protection_end_date = housing::manager::now() + 3600; + h.current_step = -1; + } + house +} + +#[tokio::test] +async fn financial_capture_waits_before_auction_and_housing_callback_locks() { + let (server, _) = property_server(); + contend_with_publication(&server, |server| { + let snapshot = crate::managers::save::capture_financial_snapshot(server); + assert_eq!(snapshot.characters.len(), 1); + }); +} + +#[tokio::test] +async fn auction_list_and_bid_wait_before_publication_callback_locks() { + let (server, seller) = property_server(); + let item = give_property_item(&server, &seller, LISTED_ITEM, 1); + let listing_seller = seller.clone(); + contend_with_publication(&server, move |server| { + server.systems.economy.auction.post_lot_on_auction( + server, + &listing_seller, + item, + 10, + 1000, + auction::auction_duration::HOURS_6, + ); + }); + let lot = server.systems.economy.auction.all_lots().pop().unwrap(); + assert_eq!(lot.item_id(), item); + assert_eq!( + server.items.item_by_id(item).unwrap().slot_type, + slot_type::AUCTION + ); + let client = TestClient::new(&server, 2, 1002); + let buyer = spawn_player( + &server, + &client, + test_character(2, "Buyer", 101.0, 100.0), + 0x101, + ); + buyer.data().money = 100; + let bidder = buyer.clone(); + contend_with_publication(&server, move |server| { + server.systems.economy.auction.bid_on_auction_lot( + server, + &bidder, + lot.id, + auction::AuctionBid { + lot_id: lot.id, + money: 20, + ..Default::default() + }, + ); + }); + assert_eq!(buyer.data().money, 80); + assert_eq!(server.systems.economy.auction.all_lots()[0].bidder_id, 2); +} + +#[tokio::test] +async fn housing_sale_waits_before_callback_locks_then_uses_real_economy_bridge() { + let (server, seller) = property_server(); + let certificate = + give_property_item(&server, &seller, housing::manager::APPRAISAL_CERTIFICATE, 2); + let house = sale_house(&server, &seller); + let listed_house = house.clone(); + contend_with_publication(&server, move |server| { + assert!(housing::ops::set_for_sale( + server, + &listed_house, + 100_000, + 0, + Some(&seller) + )); + }); + assert_eq!(house.data().sell_price, 100_000); + assert_eq!(server.items.item_by_id(certificate).unwrap().count, 1); +} + +#[tokio::test] +async fn housing_build_refusal_waits_before_callback_locks() { + let (server, player) = property_server(); + let item = give_property_item(&server, &player, LISTED_ITEM, 1); + contend_with_publication(&server, move |server| { + // Owned item but no design mapping: the normal construction refusal must still + // enter in the same order and leave its item and wallet untouched. + housing::ops::build( + server, + &player, + 1001, + &housing::packets::CSCreateHousePacket { + design_id: HOUSE, + x: 100.0, + y: 100.0, + z: 100.0, + z_rot: 0.0, + item_id: item, + money_amount: 0, + ht: 0, + auto_use_aa_point: false, + }, + ); + assert_eq!(player.data().money, 100_000); + }); + assert_eq!( + server.items.item_by_id(item).unwrap().slot_type, + slot_type::INVENTORY + ); + assert!(server.systems.housing.manager.all().is_empty()); +} diff --git a/rust/crates/aaemu-game/src/systems/housing/dominion/runtime.rs b/rust/crates/aaemu-game/src/systems/housing/dominion/runtime.rs index bf40dd2fdd..b25207a7fe 100644 --- a/rust/crates/aaemu-game/src/systems/housing/dominion/runtime.rs +++ b/rust/crates/aaemu-game/src/systems/housing/dominion/runtime.rs @@ -390,6 +390,7 @@ pub fn complete_effect(server: &GameServer, args: &EffectArgs<'_>) { ) else { return; }; + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -565,6 +566,7 @@ pub fn handle_tower_death(server: &GameServer, victim: &WorldObject) -> bool { let Some((zone, identity)) = tower_identity(server, house) else { return false; }; + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -726,6 +728,7 @@ pub fn start_tick(server: &Arc) { } } { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing diff --git a/rust/crates/aaemu-game/src/systems/housing/manager.rs b/rust/crates/aaemu-game/src/systems/housing/manager.rs index 17cdedcc7e..f3bfeddafb 100644 --- a/rust/crates/aaemu-game/src/systems/housing/manager.rs +++ b/rust/crates/aaemu-game/src/systems/housing/manager.rs @@ -1090,6 +1090,7 @@ pub fn pay_weekly_tax_for(server: &GameServer, house: &HouseRef, payer_id: Optio /// `CheckHousingTaxes()` (the `HousingTaxTask`, every 10 s). pub fn check_housing_taxes(server: &GameServer) { + let _items = server.systems.economy.operation_scope(); let manager = &server.systems.housing.manager; if manager.checking_tax.swap(true, Ordering::SeqCst) { return; @@ -1392,6 +1393,7 @@ pub fn reconcile_bound_doodads(server: &GameServer) -> (usize, usize) { /// `RemoveDeadHouse(house)` (`House.OnDeath`). pub fn remove_dead_house(server: &GameServer, house: &HouseRef) { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing diff --git a/rust/crates/aaemu-game/src/systems/housing/ops.rs b/rust/crates/aaemu-game/src/systems/housing/ops.rs index bac0bcf95c..d28e08e21e 100644 --- a/rust/crates/aaemu-game/src/systems/housing/ops.rs +++ b/rust/crates/aaemu-game/src/systems/housing/ops.rs @@ -165,6 +165,7 @@ pub fn house_tax_info(server: &GameServer, player: &PlayerRef, tl: u16) { /// `Build(connection, designId, posX, posY, posZ, zRot, itemId, moneyAmount, ht, /// autoUseAaPoint)`. pub fn build(server: &GameServer, player: &PlayerRef, account_id: u32, p: &CSCreateHousePacket) { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -494,6 +495,7 @@ pub fn demolish( failed_to_pay_tax: bool, force_restore_all_decor: bool, ) { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -1006,6 +1008,7 @@ pub fn set_for_sale( buyer_id: u32, seller: Option<&PlayerRef>, ) -> bool { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -1106,6 +1109,7 @@ fn zone_group_text(server: &GameServer, house: &House) -> String { /// `CancelForSale(house, returnCertificates)`. pub fn cancel_for_sale(server: &GameServer, house: &HouseRef, return_certificates: bool) -> bool { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -1218,6 +1222,7 @@ pub fn update_furniture_owner( /// `BuyHouse(houseTlId, money, character)`. pub fn buy_house(server: &GameServer, tl: u16, money: u32, player: &PlayerRef) -> bool { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -1373,6 +1378,7 @@ pub fn decorate_house( player: &PlayerRef, p: &CSDecorateHousePacket, ) -> Result { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -1605,6 +1611,7 @@ fn craft_building_with_payment( used_skill: u32, pay: impl FnOnce() -> Option, ) -> Result<(), BuildActionError> { + let _items = server.systems.economy.operation_scope(); let operation = server .systems .housing diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs index 4f57518925..7c2bd7e251 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs @@ -213,6 +213,7 @@ pub fn recover_item( let Some(player) = DoodadCtx::as_player(caster) else { return; }; + let _items = ctx.server.systems.economy.operation_scope(); let _operation = ctx .server .systems @@ -514,6 +515,7 @@ pub fn consume_changer( let Some(player) = DoodadCtx::as_player(caster) else { return; }; + let _items = ctx.server.systems.economy.operation_scope(); let _operation = ctx .server .systems diff --git a/rust/crates/aaemu-game/src/systems/services/commands/scripts/dominion.rs b/rust/crates/aaemu-game/src/systems/services/commands/scripts/dominion.rs index e97fdd924f..28f02d8b98 100644 --- a/rust/crates/aaemu-game/src/systems/services/commands/scripts/dominion.rs +++ b/rust/crates/aaemu-game/src/systems/services/commands/scripts/dominion.rs @@ -126,6 +126,7 @@ fn participation( ); return Ok(()); }; + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -309,6 +310,7 @@ impl Command for Dominion { CommandManager::send_default_help_text(self, out); return Ok(()); }; + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing diff --git a/rust/crates/aaemu-game/src/systems/social/dominion.rs b/rust/crates/aaemu-game/src/systems/social/dominion.rs index a92e3dbcb8..f27bcbb33b 100644 --- a/rust/crates/aaemu-game/src/systems/social/dominion.rs +++ b/rust/crates/aaemu-game/src/systems/social/dominion.rs @@ -373,6 +373,7 @@ pub(crate) fn is_expedition_leader( /// Match the original native IsDominionOwner gate and its inclusive 0..50 slider. pub fn update_tax_rate(server: &GameServer, player: &PlayerRef, zone: u16, tax_rate: i32) { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -445,6 +446,7 @@ pub fn declare_effect(server: &GameServer, args: &EffectArgs<'_>) { { return; } + let _items = server.systems.economy.operation_scope(); let operation = server .systems .housing From 325c9a92dadc63a003837414561049d6beb169ba Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:48:19 -0400 Subject: [PATCH 50/66] fix(testclient): enforce control privacy and lifecycle budgets --- rust/crates/aaemu-testclient/src/control.rs | 598 ++++++++++++++----- rust/crates/aaemu-testclient/src/game.rs | 116 +++- rust/crates/aaemu-testclient/src/main.rs | 57 +- rust/crates/aaemu-testclient/src/record.rs | 75 ++- rust/crates/aaemu-testclient/src/scenario.rs | 259 +++++++- 5 files changed, 929 insertions(+), 176 deletions(-) diff --git a/rust/crates/aaemu-testclient/src/control.rs b/rust/crates/aaemu-testclient/src/control.rs index 9f38e48b37..f23931d624 100644 --- a/rust/crates/aaemu-testclient/src/control.rs +++ b/rust/crates/aaemu-testclient/src/control.rs @@ -7,7 +7,7 @@ //! tracing goes to stderr. Events preceding a response have `seq <= response.event_seq`. //! This boundary orders observations; it does not imply that a server action has settled. -use std::collections::HashSet; +use std::collections::{HashSet, VecDeque}; use std::future::Future; use std::io::{BufRead, Write}; use std::path::Path; @@ -19,7 +19,7 @@ use aaemu_testclient::scenario::{self, BotConfig, ControlSession}; use anyhow::{bail, ensure, Context}; use serde::{Deserialize, Serialize}; use serde_json::{json, Value}; -use tokio::sync::{mpsc, oneshot}; +use tokio::sync::{mpsc, oneshot, watch}; use tokio::time::Instant; const PROTOCOL: &str = "aaemu-control/1"; @@ -31,6 +31,9 @@ const MAX_PUMP_MS: u64 = 5000; const MAX_DEADLINE_MS: u64 = 600_000; const COMMAND_TIMEOUT: Duration = Duration::from_secs(5); const CONNECT_TIMEOUT: Duration = Duration::from_secs(60); +const INPUT_QUEUE: usize = 16; +const OUTPUT_BYTES: usize = 8 * 1024 * 1024; +const OUTPUT_COUNT: usize = 4096; pub(crate) fn describe() -> Value { json!({ @@ -51,11 +54,15 @@ pub(crate) fn describe() -> Value { "id_bytes": 64, "commands": MAX_COMMANDS, "pump_ms": MAX_PUMP_MS, "command_ms": COMMAND_TIMEOUT.as_millis(), "connect_ms": CONNECT_TIMEOUT.as_millis(), "deadline_ms": MAX_DEADLINE_MS, - "event_queue_bytes": 8 * 1024 * 1024, "event_queue_count": 2048 + "event_queue_bytes": 8 * 1024 * 1024, "event_queue_count": 2048, + "input_queue_count": INPUT_QUEUE, "output_queue_bytes": OUTPUT_BYTES, + "output_queue_count": OUTPUT_COUNT }, "incremental_game_capture": true, "capture_create_new": true, "auth_frames_omitted": true, + "opaque_game_batches": "control fails closed; ordinary scenario captures unchanged", + "eof": "cancels active action and discards queued commands", "capture_start": "post-lobby character select/spawn (each session)", "handshake_before_network": true, "initial_character": "existing configured name, never first/create", @@ -276,10 +283,42 @@ fn read_line(reader: &mut impl BufRead) -> Result>, &'static str> } } -enum Input { - Line(Vec), - End, - Fault(&'static str), +/// Terminal notification cannot sit behind queued gameplay. In particular EOF cancels +/// the active action and invalidates every queued line before another action is polled. +struct Input { + lines: mpsc::Receiver>, + terminal: watch::Receiver>, +} + +fn read_input( + mut reader: impl BufRead, + lines: mpsc::Sender>, + terminal: watch::Sender>, +) { + let reason = loop { + match read_line(&mut reader) { + Ok(Some(line)) => match lines.try_send(line) { + Ok(()) => {} + Err(mpsc::error::TrySendError::Full(_)) => break "input_queue_limit", + Err(mpsc::error::TrySendError::Closed(_)) => return, + }, + Ok(None) => break "eof", + Err(code) => break code, + } + }; + terminal.send_replace(Some(reason)); +} + +async fn termination(terminal: &mut watch::Receiver>) -> &'static str { + loop { + let reason = *terminal.borrow_and_update(); + if let Some(reason) = reason { + return reason; + } + if terminal.changed().await.is_err() { + return "eof"; + } + } } struct Output { @@ -289,23 +328,13 @@ struct Output { /// Detached, bounded stdio workers avoid Tokio's uncancellable blocking stdin read keeping /// the runtime alive after deadline. They own no sockets and are never joined on shutdown. -fn stdio() -> anyhow::Result<(mpsc::Receiver, mpsc::Sender)> { - let (input_tx, input_rx) = mpsc::channel(1); +fn stdio() -> anyhow::Result<(Input, mpsc::Sender)> { + let (input_tx, input_rx) = mpsc::channel(INPUT_QUEUE); + let (terminal_tx, terminal_rx) = watch::channel(None); std::thread::Builder::new() .name("control-input".into()) .spawn(move || { - let mut stdin = std::io::stdin().lock(); - loop { - let message = match read_line(&mut stdin) { - Ok(Some(line)) => Input::Line(line), - Ok(None) => Input::End, - Err(code) => Input::Fault(code), - }; - let terminal = !matches!(&message, Input::Line(_)); - if input_tx.blocking_send(message).is_err() || terminal { - break; - } - } + read_input(std::io::stdin().lock(), input_tx, terminal_tx); })?; let (output_tx, mut output_rx) = mpsc::channel::(1); // Use an owned OS handle rather than holding Rust's global stdout lock. A blocked @@ -334,48 +363,75 @@ fn stdio() -> anyhow::Result<(mpsc::Receiver, mpsc::Sender)> { } } })?; - Ok((input_rx, output_tx)) + Ok(( + Input { + lines: input_rx, + terminal: terminal_rx, + }, + output_tx, + )) +} + +struct QueuedOutput { + bytes: Vec, + until: Instant, +} + +struct InFlight { + ack: oneshot::Receiver>, + until: Instant, + len: usize, } struct Reporter { output: mpsc::Sender, deadline: Instant, + budget: Instant, seq: u64, + queue: VecDeque, + queued_bytes: usize, + flight: Option, } impl Reporter { - async fn write(&mut self, mut value: Value) -> anyhow::Result<()> { + fn new(output: mpsc::Sender, deadline: Instant) -> Self { + Self { + output, + deadline, + budget: deadline, + seq: 0, + queue: VecDeque::new(), + queued_bytes: 0, + flight: None, + } + } + + fn write(&mut self, mut value: Value) -> anyhow::Result<()> { value["protocol"] = PROTOCOL.into(); let mut bytes = serde_json::to_vec(&value)?; bytes.push(b'\n'); - let (ack, completed) = oneshot::channel(); - // A blocked/broken output must not hold game sockets indefinitely. Allow a small - // terminal reporting window after the network deadline; no gameplay runs then. - let until = (Instant::now() + Duration::from_secs(1)) - .min(self.deadline + Duration::from_millis(200)); - tokio::time::timeout_at(until, async { - self.output - .send(Output { bytes, ack }) - .await - .context("stdout worker closed")?; - completed.await.context("stdout worker stopped")??; - Ok::<_, anyhow::Error>(()) - }) - .await - .context("stdout deadline")??; + ensure!( + self.queue.len() + usize::from(self.flight.is_some()) < OUTPUT_COUNT + && bytes.len() <= OUTPUT_BYTES.saturating_sub(self.queued_bytes), + "stdout queue limit" + ); + self.queued_bytes += bytes.len(); + self.queue.push_back(QueuedOutput { + bytes, + until: self.budget, + }); Ok(()) } - async fn events(&mut self, rec: &Recorder) -> anyhow::Result<()> { + fn events(&mut self, rec: &Recorder) -> anyhow::Result<()> { for event in rec.take_live_events()? { self.seq += 1; - self.write(json!({"type": "event", "seq": self.seq, "event": event})) - .await?; + self.write(json!({"type": "event", "seq": self.seq, "event": event}))?; } Ok(()) } - async fn response( + fn response( &mut self, id: Option, result: Result, @@ -386,7 +442,76 @@ impl Reporter { Err(code) => json!({"type": "response", "id": id, "ok": false, "error": {"code": code}, "event_seq": self.seq}), }; - self.write(value).await + self.write(value) + } + + fn has_work(&self) -> bool { + self.flight.is_some() || !self.queue.is_empty() + } + + fn next_deadline(&self) -> Option { + self.queue + .iter() + .map(|queued| queued.until) + .chain(self.flight.as_ref().map(|flight| flight.until)) + .min() + } + + /// One cancellation-safe output step, polled alongside action/EOF/deadline futures. + /// The ack and queued bytes live on Reporter, so losing a select race never loses them. + /// Every frame retains the shared action budget at enqueue time; acknowledgments cannot + /// restart a command's deadline. A one-second stalled-writer ceiling is additional. + async fn progress(&mut self) -> anyhow::Result<()> { + if self.flight.is_none() { + let Some(front) = self.queue.front() else { + return std::future::pending().await; + }; + let until = self + .next_deadline() + .unwrap_or(front.until) + .min(Instant::now() + Duration::from_secs(1)); + ensure!(Instant::now() < until, "stdout budget exhausted"); + let permit = tokio::time::timeout_at(until, self.output.reserve()) + .await + .context("stdout budget")? + .context("stdout worker closed")?; + let queued = self.queue.pop_front().context("stdout queue empty")?; + let len = queued.bytes.len(); + let (ack, completed) = oneshot::channel(); + permit.send(Output { + bytes: queued.bytes, + ack, + }); + self.flight = Some(InFlight { + ack: completed, + until, + len, + }); + } + let flight = self.flight.as_mut().context("stdout ack missing")?; + ensure!(Instant::now() < flight.until, "stdout budget exhausted"); + tokio::time::timeout_at(flight.until, &mut flight.ack) + .await + .context("stdout budget")? + .context("stdout worker stopped")??; + let flight = self.flight.take().context("stdout ack missing")?; + self.queued_bytes -= flight.len; + Ok(()) + } + + /// Called only after sockets are closed. Earlier command budgets remain in force. + async fn finish(&mut self) -> anyhow::Result<()> { + let until = (Instant::now() + Duration::from_secs(1)) + .min(self.deadline + Duration::from_millis(200)); + tokio::time::timeout_at(until, async { + while self.has_work() { + self.progress().await?; + } + Ok::<_, anyhow::Error>(()) + }) + .await + .context("terminal stdout budget")??; + Ok(()) } } @@ -428,10 +553,8 @@ impl Controller { let old = self.session.take(); let old_self_obj = old.as_ref().map(|s| s.game.state.self_obj); let had_session = old.is_some(); - if let Some(ControlSession { game, stream, .. }) = old { - // StreamClient owns one unsplit socket and no background task. - drop(stream); - game.disconnect_hard().await; + if let Some(session) = old { + session.disconnect_hard().await; } json!({"reason": reason, "t_ms": self.started.elapsed().as_millis(), "session_generation": self.generation, "old_self_obj": old_self_obj, @@ -440,7 +563,7 @@ impl Controller { "closure_scope": "local socket handles", "sent_leave_world": false}) } - async fn execute(&mut self, cmd: Command) -> anyhow::Result { + async fn execute(&mut self, cmd: Command, until: Instant) -> anyhow::Result { match cmd { Command::Hello => { ensure!(!self.handshaken, "already handshaken"); @@ -475,7 +598,11 @@ impl Controller { let game = &mut self.session.as_mut().context("no connected session")?.game; match command { Command::Pump(p) => { - let until = Instant::now() + Duration::from_millis(p.ms); + let until = (Instant::now() + Duration::from_millis(p.ms)).min( + until + .checked_sub(Duration::from_millis(20)) + .unwrap_or(until), + ); while Instant::now() < until { game.recv_within(until.saturating_duration_since(Instant::now())) .await?; @@ -484,7 +611,7 @@ impl Controller { Command::Gm(p) => scenario::control_gm(game, &p.command).await?, Command::Tp(p) => { self.clock = self.clock.wrapping_add(1500); - scenario::control_tp(game, p.x, p.y, p.z, self.clock).await?; + scenario::control_tp(game, p.x, p.y, p.z, self.clock, until).await?; } Command::RawCs(opcode, body) => game.send_cs(opcode, &body).await?, _ => unreachable!("handled lifecycle method"), @@ -521,29 +648,28 @@ enum Completion { Stopped(&'static str), } -/// Keep capture/event delivery and EOF detection alive while the shared session code runs. -/// One look-ahead command is allowed; subsequent input remains backpressured. +/// No output branch awaits a batch. Action receive/keep-alive, terminal input, and +/// command/global timers remain independently pollable while an output ack is delayed. async fn drive( future: impl Future>, until: Instant, rec: &Recorder, report: &mut Reporter, - input: &mut mpsc::Receiver, - pending: &mut Option, + input: &mut Input, ) -> anyhow::Result { tokio::pin!(future); let mut tick = tokio::time::interval(Duration::from_millis(20)); loop { + let output_pending = report.has_work(); + let output_until = report.next_deadline().unwrap_or(report.deadline); tokio::select! { biased; + reason = termination(&mut input.terminal) => return Ok(Completion::Stopped(reason)), _ = tokio::time::sleep_until(until) => return Ok(Completion::Stopped("command_deadline")), + _ = tokio::time::sleep_until(output_until), if output_pending => bail!("stdout budget exhausted"), result = &mut future => return Ok(Completion::Done(result)), - message = input.recv(), if pending.is_none() => match message { - Some(line @ Input::Line(_)) => *pending = Some(line), - Some(Input::Fault(code)) => return Ok(Completion::Stopped(code)), - Some(Input::End) | None => return Ok(Completion::Stopped("eof")), - }, - _ = tick.tick() => report.events(rec).await?, + result = report.progress(), if output_pending => { result?; }, + _ = tick.tick() => report.events(rec)?, } } } @@ -551,56 +677,55 @@ async fn drive( async fn serve( controller: &mut Controller, report: &mut Reporter, - input: &mut mpsc::Receiver, + input: &mut Input, ) -> anyhow::Result<&'static str> { - let mut pending = None; let mut ids = HashSet::new(); let mut count = 0; let mut next_poll = Instant::now(); - report - .write(json!({"type": "capabilities", "capabilities": describe()})) - .await?; + report.write(json!({"type": "capabilities", "capabilities": describe()}))?; loop { + if let Some(reason) = *input.terminal.borrow() { + return Ok(reason); + } if Instant::now() >= report.deadline { return Ok("deadline"); } - // Poll independently of stdin readiness: a stream of state/rawcs requests must - // not starve receive/keep-alive work, even with one look-ahead request queued. + // Poll receive/keep-alive even if stdin continuously supplies commands. if Instant::now() >= next_poll { - let idle = tokio::time::timeout_at(report.deadline, controller.idle()).await; - if !matches!(idle, Ok(Ok(()))) { - let closed = controller.disconnect("session_error").await; - report - .write(json!({"type": "lifecycle", "closed": closed})) - .await?; + let rec = controller.rec.clone(); + let idle = async { + controller.idle().await?; + Ok(Value::Null) + }; + match drive(idle, report.deadline, &rec, report, input).await? { + Completion::Done(Ok(_)) => {} + Completion::Done(Err(_)) => { + let closed = controller.disconnect("session_error").await; + report.write(json!({"type": "lifecycle", "closed": closed}))?; + } + Completion::Stopped("command_deadline") => return Ok("deadline"), + Completion::Stopped(reason) => return Ok(reason), } - report.events(&controller.rec).await?; + report.events(&rec)?; next_poll = Instant::now() + Duration::from_millis(50); } - let message = if let Some(message) = pending.take() { - Some(message) - } else { - tokio::select! { - biased; - _ = tokio::time::sleep_until(report.deadline) => return Ok("deadline"), - _ = tokio::time::sleep_until(next_poll) => continue, - message = input.recv() => message, - } - }; - let line = match message { - Some(Input::Line(line)) => line, - Some(Input::Fault(code)) => { - report.response(None, Err(code)).await?; - return Ok(code); - } - Some(Input::End) | None => return Ok("eof"), + let output_pending = report.has_work(); + let output_until = report.next_deadline().unwrap_or(report.deadline); + let line = tokio::select! { + biased; + reason = termination(&mut input.terminal) => return Ok(reason), + _ = tokio::time::sleep_until(report.deadline) => return Ok("deadline"), + _ = tokio::time::sleep_until(output_until), if output_pending => bail!("stdout budget exhausted"), + _ = tokio::time::sleep_until(next_poll) => continue, + result = report.progress(), if output_pending => { result?; continue; }, + line = input.lines.recv() => match line { Some(line) => line, None => return Ok("eof") }, }; if Instant::now() >= report.deadline { return Ok("deadline"); } count += 1; if count > MAX_COMMANDS { - report.response(None, Err("command_limit")).await?; + report.response(None, Err("command_limit"))?; return Ok("command_limit"); } let (id, cmd) = match parse(&line) { @@ -608,11 +733,11 @@ async fn serve( Err(e) => { if let Some(id) = &e.id { if !ids.insert(id.clone()) { - report.response(None, Err("duplicate_id")).await?; + report.response(None, Err("duplicate_id"))?; return Ok("duplicate_id"); } } - report.response(e.id, Err(e.code)).await?; + report.response(e.id, Err(e.code))?; if e.fatal { return Ok(e.code); } @@ -620,20 +745,18 @@ async fn serve( } }; if !ids.insert(id.clone()) { - report.response(None, Err("duplicate_id")).await?; + report.response(None, Err("duplicate_id"))?; return Ok("duplicate_id"); } if !controller.handshaken && !matches!(&cmd, Command::Hello) { - report.response(Some(id), Err("handshake_required")).await?; + report.response(Some(id), Err("handshake_required"))?; return Ok("handshake_required"); } if (controller.handshaken && matches!(&cmd, Command::Hello)) || matches!(&cmd, Command::Reconnect(id) if !reconnect_allowed(controller.session.is_some(), controller.character_id, *id)) { - report - .response(Some(id), Err("invalid_session_state")) - .await?; + report.response(Some(id), Err("invalid_session_state"))?; continue; } let closing = matches!(&cmd, Command::Close); @@ -643,48 +766,32 @@ async fn serve( } else { COMMAND_TIMEOUT }; - // Pump's requested maximum may equal the ordinary action ceiling. - let allowance = if matches!(&cmd, Command::Pump(_)) { - allowance + Duration::from_millis(100) - } else { - allowance - }; let until = (Instant::now() + allowance).min(report.deadline); + report.budget = until; controller.rec.step(&format!("control.{count}")); let rec = controller.rec.clone(); - let done = drive( - controller.execute(cmd), - until, - &rec, - report, - input, - &mut pending, - ) - .await?; + let done = drive(controller.execute(cmd, until), until, &rec, report, input).await?; let mut stop = None; let result = match done { Completion::Done(Ok(value)) => Ok(value), Completion::Done(Err(error)) => { tracing::debug!("control action failed: {error:#}"); let closed = controller.disconnect("session_error").await; - report - .write(json!({"type": "lifecycle", "closed": closed})) - .await?; + report.write(json!({"type": "lifecycle", "closed": closed}))?; Err("session_error") } Completion::Stopped(code) => { let closed = controller.disconnect(code).await; - report - .write(json!({"type": "lifecycle", "closed": closed})) - .await?; + report.write(json!({"type": "lifecycle", "closed": closed}))?; if code != "command_deadline" || Instant::now() >= report.deadline { stop = Some(code); } Err(code) } }; - report.events(&rec).await?; - report.response(Some(id), result).await?; + report.events(&rec)?; + report.response(Some(id), result)?; + report.budget = report.deadline; if closing { return Ok("close"); } @@ -706,11 +813,7 @@ pub(crate) async fn run(cfg: BotConfig, capture: &Path, deadline_ms: u64) -> any let started = Instant::now(); let rec = Recorder::incremental_game(capture)?; let (mut input, output) = stdio()?; - let mut report = Reporter { - output, - deadline: started + Duration::from_millis(deadline_ms), - seq: 0, - }; + let mut report = Reporter::new(output, started + Duration::from_millis(deadline_ms)); let mut controller = Controller { cfg, rec: rec.clone(), @@ -735,11 +838,11 @@ pub(crate) async fn run(cfg: BotConfig, capture: &Path, deadline_ms: u64) -> any let closed = controller.disconnect(reason).await; let flushed = rec.flush_live(); if outcome.is_ok() { - report.events(&rec).await?; - report - .write(json!({"type": "closed", "closed": closed})) - .await?; + report.budget = report.deadline + Duration::from_millis(200); + report.events(&rec)?; + report.write(json!({"type": "closed", "closed": closed}))?; } + report.finish().await?; flushed?; let reason = outcome?; ensure!( @@ -866,17 +969,31 @@ mod tests { assert!(reconnect_allowed(false, Some(42), 42)); } + fn input_pair() -> ( + Input, + mpsc::Sender>, + watch::Sender>, + ) { + let (lines, rx) = mpsc::channel(INPUT_QUEUE); + let (terminal, stopped) = watch::channel(None); + ( + Input { + lines: rx, + terminal: stopped, + }, + lines, + terminal, + ) + } + #[tokio::test] async fn eof_cancels_an_active_action_without_waiting_for_its_timeout() { let rec = Recorder::new(false); let (output, _reader) = mpsc::channel(1); - let mut report = Reporter { - output, - deadline: Instant::now() + CONNECT_TIMEOUT, - seq: 0, - }; - let (sender, mut input) = mpsc::channel(1); - sender.send(Input::End).await.unwrap(); + let until = Instant::now() + CONNECT_TIMEOUT; + let mut report = Reporter::new(output, until); + let (mut input, _lines, terminal) = input_pair(); + terminal.send_replace(Some("eof")); let released = Arc::new(AtomicBool::new(false)); let resource = Released(released.clone()); let result = drive( @@ -884,11 +1001,10 @@ mod tests { let _resource = resource; std::future::pending().await }, - report.deadline, + until, &rec, &mut report, &mut input, - &mut None, ) .await .unwrap(); @@ -900,12 +1016,9 @@ mod tests { async fn expired_deadline_cancels_even_when_input_is_idle() { let rec = Recorder::new(false); let (output, _reader) = mpsc::channel(1); - let mut report = Reporter { - output, - deadline: Instant::now(), - seq: 0, - }; - let (_sender, mut input) = mpsc::channel(1); + let until = Instant::now(); + let mut report = Reporter::new(output, until); + let (mut input, _lines, _terminal) = input_pair(); let released = Arc::new(AtomicBool::new(false)); let resource = Released(released.clone()); let result = drive( @@ -913,15 +1026,204 @@ mod tests { let _resource = resource; std::future::pending().await }, - report.deadline, + until, &rec, &mut report, &mut input, - &mut None, ) .await .unwrap(); assert!(matches!(result, Completion::Stopped("command_deadline"))); assert!(released.load(Ordering::SeqCst)); } + fn live_recorder() -> Recorder { + let rec = Recorder::incremental_game_to(std::io::sink()); + rec.control_game_ready(true); + rec + } + + #[tokio::test] + async fn delayed_output_acks_do_not_suspend_game_keepalive_or_command_deadline() { + use aaemu_commons::net::FrameCodec; + use aaemu_game::opcodes::{pp, sc}; + use aaemu_testclient::game::GameClient; + use aaemu_testclient::record::{Channel, Dir}; + use futures::StreamExt; + use std::sync::atomic::AtomicUsize; + use tokio_util::codec::FramedRead; + + let rec = live_recorder(); + let (io, peer) = tokio::io::duplex(64 * 1024); + let mut game = GameClient::from_io(io, rec.clone()); + game.account_id = 1; + game.ping_every = Duration::from_millis(20); + let peer = tokio::spawn(async move { + let mut peer = FramedRead::new(peer, FrameCodec); + let mut pings = 0; + while let Some(packet) = peer.next().await { + let packet = packet.unwrap(); + assert_eq!(packet[1], 2); + assert_eq!(u16::from_le_bytes([packet[2], packet[3]]), pp::PingPacket); + pings += 1; + } + pings + }); + let (output, mut consumed) = mpsc::channel::(1); + let acknowledgments = Arc::new(AtomicUsize::new(0)); + let counted = acknowledgments.clone(); + let consumer = tokio::spawn(async move { + while let Some(packet) = consumed.recv().await { + tokio::time::sleep(Duration::from_millis(25)).await; + if packet.ack.send(Ok(())).is_err() { + break; + } + counted.fetch_add(1, Ordering::SeqCst); + } + }); + let until = Instant::now() + Duration::from_millis(300); + let mut report = Reporter::new(output, until + Duration::from_secs(1)); + report.budget = until; + // This batch needs at least 800ms of acknowledgments. The action has 300ms. + for _ in 0..32 { + rec.push( + Channel::Game, + Dir::S2C, + 1, + sc::SCErrorMsgPacket, + "ambient", + &[7, 0], + ); + } + report.events(&rec).unwrap(); + let (mut input, _lines, _terminal) = input_pair(); + let action = async { + loop { + if let Err(error) = game.recv_within(Duration::from_millis(5)).await { + return Err::(error); + } + } + }; + let done = tokio::time::timeout( + Duration::from_secs(2), + drive(action, until, &rec, &mut report, &mut input), + ) + .await + .unwrap() + .unwrap(); + assert!(matches!(done, Completion::Stopped("command_deadline"))); + assert!(acknowledgments.load(Ordering::SeqCst) >= 2); + assert!(acknowledgments.load(Ordering::SeqCst) < 32); + assert!(report.has_work()); + game.disconnect_hard().await; + let pings = tokio::time::timeout(Duration::from_secs(1), peer) + .await + .unwrap() + .unwrap(); + assert!( + pings >= 2, + "slow output starved the actual GameClient keep-alive path" + ); + consumer.abort(); + let _ = consumer.await; + } + + #[tokio::test] + async fn active_action_plus_pending_rawcs_and_eof_never_sends_queued_gameplay() { + use aaemu_commons::net::FrameCodec; + use aaemu_testclient::game::GameClient; + use futures::StreamExt; + use tokio_util::codec::FramedRead; + + let rec = live_recorder(); + let (io, peer) = tokio::io::duplex(64 * 1024); + let mut game = GameClient::from_io(io, rec.clone()); + game.account_id = 1; + let peer = tokio::spawn(async move { + let mut peer = FramedRead::new(peer, FrameCodec); + let mut packets = Vec::new(); + while let Some(packet) = peer.next().await { + packets.push(packet.unwrap()); + } + packets + }); + let (output, _consumer) = mpsc::channel(1); + let until = Instant::now() + Duration::from_secs(1); + let mut report = Reporter::new(output, until); + let (mut input, lines, terminal) = input_pair(); + let (started, ready) = oneshot::channel(); + let producer = tokio::spawn(async move { + ready.await.unwrap(); + let mut raw = request("rawcs", json!({"opcode":58,"body_hex":"abcd"})); + raw.push(b'\n'); + // The real bounded input worker sees a queued rawcs followed by EOF. + read_input(Cursor::new(raw), lines, terminal); + }); + let action = async { + let _ = started.send(()); + loop { + if let Err(error) = game.recv_within(Duration::from_millis(10)).await { + return Err::(error); + } + } + }; + let done = drive(action, until, &rec, &mut report, &mut input) + .await + .unwrap(); + assert!(matches!(done, Completion::Stopped("eof"))); + producer.await.unwrap(); + let queued = input.lines.try_recv().unwrap(); + assert!(matches!(parse(&queued), Ok((_, Command::RawCs(58, _))))); + game.disconnect_hard().await; + let packets = tokio::time::timeout(Duration::from_secs(1), peer) + .await + .unwrap() + .unwrap(); + assert!(!packets.is_empty()); + assert!( + packets.iter().all(|packet| packet[1] == 2), + "queued rawcs or CSLeaveWorld escaped after EOF" + ); + } + + #[test] + fn input_queue_overflow_signals_terminal_without_blocking_the_reader() { + let (mut input, lines, terminal) = input_pair(); + read_input( + Cursor::new(b"{}\n".repeat(INPUT_QUEUE + 1)), + lines, + terminal, + ); + assert_eq!(*input.terminal.borrow(), Some("input_queue_limit")); + let mut count = 0; + while input.lines.try_recv().is_ok() { + count += 1; + } + assert_eq!(count, INPUT_QUEUE); + } + + #[tokio::test] + async fn earlier_command_output_budget_applies_even_behind_a_longer_lived_head() { + let rec = live_recorder(); + let (output, _consumer) = mpsc::channel(1); + let until = Instant::now() + CONNECT_TIMEOUT; + let mut report = Reporter::new(output, until); + report.write(json!({"type":"capabilities"})).unwrap(); + report.budget = Instant::now(); + report + .response(Some(RequestId::Number(1)), Ok(Value::Null)) + .unwrap(); + let (mut input, _lines, _terminal) = input_pair(); + let polled = Arc::new(AtomicBool::new(false)); + let observed = polled.clone(); + let action = async move { + observed.store(true, Ordering::SeqCst); + Ok(Value::Null) + }; + let result = drive(action, until, &rec, &mut report, &mut input).await; + assert!(result.is_err()); + assert!( + !polled.load(Ordering::SeqCst), + "expired output budget allowed later gameplay" + ); + } } diff --git a/rust/crates/aaemu-testclient/src/game.rs b/rust/crates/aaemu-testclient/src/game.rs index ba6739ed2b..ccf2b7a2b6 100644 --- a/rust/crates/aaemu-testclient/src/game.rs +++ b/rust/crates/aaemu-testclient/src/game.rs @@ -12,7 +12,7 @@ use aaemu_commons::PacketStream; use aaemu_game::opcodes::{cs, name_of, pp, sc}; use anyhow::{anyhow, bail, Context}; use futures::{SinkExt, StreamExt}; -use tokio::net::tcp::OwnedWriteHalf; +use tokio::io::{AsyncRead, AsyncWrite}; use tokio::net::TcpStream; use tokio::sync::mpsc; use tokio_util::codec::{FramedRead, FramedWrite}; @@ -64,6 +64,80 @@ pub struct CharInfo { pub name: String, } +/// Consume one complete native `Character.Write` record. The list has no entry lengths; +/// stopping after id/name would parse the next character from equipment or model bytes. +fn read_character(s: &mut PacketStream) -> anyhow::Result { + use aaemu_game::models::container::{equip_slot, EQUIPMENT_CONTAINER_SIZE}; + use aaemu_game::models::item::detail_body_len; + use aaemu_game::models::unit_model::UnitCustomModelParams; + + let id = s.read_u32()?; + let name = s.read_string()?; + s.read_u8()?; // race + s.read_u8()?; // gender + s.read_u8()?; // level + s.read_i32()?; // hp + s.read_i32()?; // mp + s.read_u32()?; // zone + s.read_u32()?; // faction + s.read_string()?; // faction name (variable length) + s.read_u32()?; // expedition + s.read_u32()?; // family + for slot in 0..EQUIPMENT_CONTAINER_SIZE { + let template = s.read_u32()?; + // Native appearance slots use BodyPart.Write (template only), including nonzero ids. + if template == 0 || (equip_slot::FACE..=equip_slot::BEARD).contains(&slot) { + continue; + } + s.read_u64()?; // instance id + s.read_u8()?; // grade + s.read_u8()?; // flags + s.read_i32()?; // count + let detail = s.read_u8()?; + let len = detail_body_len(detail); + anyhow::ensure!(detail == 0 || len != 0, "unknown equipment detail type"); + s.read_bytes(len)?; + s.read_i64()?; // create time + s.read_i32()?; // lifespan + s.read_u32()?; // made unit id + s.read_u8()?; // world id + s.read_i64()?; // unsecure time + s.read_i64()?; // unpack time + } + s.read_bytes(3)?; // abilities + s.read_i64()?; // x + s.read_i64()?; // y + s.read_f32()?; // z + let _: UnitCustomModelParams = s.read()?; + s.read_i16()?; // labor + s.read_i64()?; // labor modified + s.read_i16()?; // dead count + s.read_i64()?; // dead time + s.read_i32()?; // rez wait + s.read_i64()?; // rez time + s.read_i32()?; // rez penalty + s.read_i64()?; // last world leave + s.read_i64()?; // money + s.read_i64()?; // money amount + s.read_i16()?; // crime + s.read_i32()?; // infamy + s.read_i16()?; // trials + s.read_i64()?; // delete request + s.read_i64()?; // transfer request + s.read_i64()?; // delete delay + s.read_i32()?; // consumed labor + s.read_i64()?; // loyalty + s.read_i64()?; // money2 + s.read_i64()?; // money amount + s.read_bool()?; // auto AA point + s.read_i32()?; // prev point + s.read_i32()?; // point + s.read_i32()?; // gift + s.read_i64()?; // updated + s.read_u8()?; // force name change + Ok(CharInfo { id, name }) +} + /// A unit seen in `SCUnitStatePacket`. #[derive(Clone, Debug, PartialEq)] pub struct UnitInfo { @@ -317,12 +391,14 @@ impl GameState { } else if p.is_sc(sc::SCCharacterListPacket) { let last = s.read_bool()?; let n = s.read_u8()?; - if n > 0 { - // Only the first entry can be located without decoding a whole Character. - let id = s.read_u32()?; - let name = s.read_string()?; - if !st.characters.iter().any(|c| c.id == id) { - st.characters.push(CharInfo { id, name }); + // Parse atomically: a malformed later entry must not authorize a partial list. + let characters = (0..n) + .map(|_| read_character(&mut s)) + .collect::>>()?; + anyhow::ensure!(s.remaining() == 0, "trailing character-list bytes"); + for character in characters { + if !st.characters.iter().any(|c| c.id == character.id) { + st.characters.push(character); } } st.char_list_done |= last; @@ -472,7 +548,7 @@ impl GameState { } pub struct GameClient { - writer: Option>, + writer: Option, FrameCodec>>, reader: SocketReader, rx: mpsc::Receiver>, rec: Recorder, @@ -513,6 +589,24 @@ impl GameClient { .with_context(|| format!("connecting to game server {addr}"))?; sock.set_nodelay(true)?; let (rd, wr) = sock.into_split(); + Ok(Self::from_parts(rd, wr, rec)) + } + + /// Use the same packet/state client over an owned async transport (including in-memory + /// deterministic fixtures). Production TCP keeps its native owned socket halves. + pub fn from_io( + io: impl AsyncRead + AsyncWrite + Unpin + Send + 'static, + rec: Recorder, + ) -> Self { + let (rd, wr) = tokio::io::split(io); + Self::from_parts(rd, wr, rec) + } + + fn from_parts( + rd: impl AsyncRead + Unpin + Send + 'static, + wr: impl AsyncWrite + Unpin + Send + 'static, + rec: Recorder, + ) -> Self { let (tx, rx) = mpsc::channel(256); let reader = tokio::spawn(async move { let mut reader = FramedRead::new(rd, FrameCodec); @@ -534,8 +628,8 @@ impl GameClient { } } }); - Ok(Self { - writer: Some(FramedWrite::new(wr, FrameCodec)), + Self { + writer: Some(FramedWrite::new(Box::new(wr), FrameCodec)), reader: SocketReader(Some(reader)), rx, rec, @@ -546,7 +640,7 @@ impl GameClient { ping_every: Duration::from_secs(3), last_ping: None, started: Instant::now(), - }) + } } pub fn recorder(&self) -> &Recorder { diff --git a/rust/crates/aaemu-testclient/src/main.rs b/rust/crates/aaemu-testclient/src/main.rs index 9b6993580b..a42dd48c31 100644 --- a/rust/crates/aaemu-testclient/src/main.rs +++ b/rust/crates/aaemu-testclient/src/main.rs @@ -78,10 +78,28 @@ impl Args { } fn bot_config(args: &Args) -> anyhow::Result { + bot_config_with(args, read_config) +} + +fn read_config(path: &str) -> anyhow::Result { + std::fs::read_to_string(path).with_context(|| format!("reading {path}")) +} + +fn control_config( + args: &Args, + read: impl FnOnce(&str) -> anyhow::Result, +) -> anyhow::Result { + // Discard the entire cause chain. Serde errors can quote a value supplied for password + // (e.g. an unquoted number), and main's Result termination uses Debug formatting. + bot_config_with(args, read).map_err(|_| anyhow::anyhow!("invalid control config")) +} + +fn bot_config_with( + args: &Args, + read: impl FnOnce(&str) -> anyhow::Result, +) -> anyhow::Result { let mut v: serde_json::Value = match args.get("config") { - Some(p) => serde_json::from_str( - &std::fs::read_to_string(p).with_context(|| format!("reading {p}"))?, - )?, + Some(p) => serde_json::from_str(&read(p)?)?, None => serde_json::json!({}), }; let obj = v.as_object_mut().context("config must be a JSON object")?; @@ -206,7 +224,7 @@ async fn main() -> anyhow::Result<()> { } args.get("config") .context("control requires --config ")?; - let cfg = bot_config(&args).context("invalid control config")?; + let cfg = control_config(&args, read_config)?; let capture = Path::new(args.get("capture").context("control requires --capture")?); let deadline_ms = args.get("deadline-ms").unwrap_or("570000").parse()?; return control::run(cfg, capture, deadline_ms).await; @@ -304,3 +322,34 @@ async fn main() -> anyhow::Result<()> { } Ok(()) } + +#[cfg(test)] +mod control_config_tests { + use super::*; + + #[test] + fn numeric_password_never_reaches_any_user_visible_error_format() { + const SECRET: &str = "782643915027481"; + let args = Args { + cmd: "control".into(), + flags: HashMap::from([("config".into(), "private.json".into())]), + }; + let text = format!( + r#"{{"login":"127.0.0.1:1","user":"owner","character":"Owner","password":{SECRET}}}"# + ); + let error = control_config(&args, |_| Ok(text)).unwrap_err(); + for visible in [ + format!("{error}"), + format!("{error:#}"), + format!("{error:?}"), + ] { + assert!(visible.contains("invalid control config")); + assert!(!visible.contains(SECRET)); + } + assert_eq!(error.chain().count(), 1); + // File/parse/flag errors are also scrubbed rather than attached as causes. + let error = control_config(&args, |_| anyhow::bail!("private cause {SECRET}")).unwrap_err(); + assert!(!format!("{error:?}").contains(SECRET)); + assert_eq!(error.chain().count(), 1); + } +} diff --git a/rust/crates/aaemu-testclient/src/record.rs b/rust/crates/aaemu-testclient/src/record.rs index cb539d3afe..2d7044987f 100644 --- a/rust/crates/aaemu-testclient/src/record.rs +++ b/rust/crates/aaemu-testclient/src/record.rs @@ -76,11 +76,17 @@ impl std::fmt::Debug for LiveCapture { fn public_game_event(channel: Channel, dir: Dir, level: u8, opcode: u16) -> bool { use aaemu_game::opcodes::{cs, sc}; + // Credential-bearing game transitions in the 1.2 tables: enter-world cookie (C2S), + // stream token (S2C), and the reconnect token delivered after character selection. + // Login/stream channels are never public, regardless of session readiness. channel == Channel::Game && !(level == 1 && match dir { Dir::C2S => opcode == cs::X2EnterWorldPacket, - Dir::S2C => opcode == sc::X2EnterWorldResponsePacket, + Dir::S2C => matches!( + opcode, + sc::X2EnterWorldResponsePacket | sc::SCReconnectAuthPacket + ), }) } @@ -113,9 +119,13 @@ impl Recorder { .write(true) .create_new(true) .open(path)?; - Ok(Self::with_live_sink(Box::new(std::io::BufWriter::new( - file, - )))) + Ok(Self::incremental_game_to(std::io::BufWriter::new(file))) + } + + /// The same bounded incremental capture with a caller-owned sink, e.g. an in-memory + /// writer for deterministic transport/loop tests. Authentication policy is identical. + pub fn incremental_game_to(sink: impl Write + Send + 'static) -> Self { + Self::with_live_sink(Box::new(sink)) } fn with_live_sink(sink: Box) -> Self { @@ -193,6 +203,15 @@ impl Recorder { { return; } + // Compressed batches have no per-packet lengths. Without decoding every contained + // opcode we cannot rule out embedded authentication. Fail closed in control mode; + // normal scenario recorders keep their existing raw-batch capture behavior. + if channel == Channel::Game && !matches!(level, 1 | 2) { + if let Some(live) = i.live.as_mut() { + live.failed = true; + return; + } + } let ev = Event { t_ms: i.start.elapsed().as_millis() as u64, channel, @@ -313,6 +332,7 @@ mod tests { (Channel::Stream, Dir::C2S, 1), (Channel::Game, Dir::C2S, cs::X2EnterWorldPacket), (Channel::Game, Dir::S2C, sc::X2EnterWorldResponsePacket), + (Channel::Game, Dir::S2C, sc::SCReconnectAuthPacket), ] { rec.push(channel, dir, 1, opcode, "auth", b"private"); } @@ -321,6 +341,7 @@ mod tests { assert_eq!(persisted.flushes, 1); let event: Event = serde_json::from_slice(&persisted.bytes).unwrap(); assert_eq!(event.body_bytes(), [7, 0]); + assert!(!String::from_utf8_lossy(&persisted.bytes).contains(&hex::encode(b"private"))); drop(persisted); assert_eq!(rec.take_live_events().unwrap(), vec![event]); assert!(rec.take_live_events().unwrap().is_empty()); @@ -333,6 +354,52 @@ mod tests { assert_eq!(sink.0.lock().unwrap().flushes, 1); } + #[test] + fn reconnect_token_after_readiness_is_absent_from_capture_and_stdout_events() { + let sink = Sink::default(); + let rec = Recorder::with_live_sink(Box::new(sink.clone())); + rec.control_game_ready(true); + rec.push( + Channel::Game, + Dir::S2C, + 1, + sc::SCReconnectAuthPacket, + "SCReconnectAuthPacket", + &[0x78, 0x56, 0x34, 0x12], + ); + push(&rec); + let stdout_events = rec.take_live_events().unwrap(); + assert_eq!(stdout_events.len(), 1); + assert_eq!(stdout_events[0].opcode, sc::SCErrorMsgPacket); + let persisted = sink.0.lock().unwrap(); + let capture_events: Vec = String::from_utf8_lossy(&persisted.bytes) + .lines() + .map(|line| serde_json::from_str(line).unwrap()) + .collect(); + assert_eq!(capture_events, stdout_events); + assert!(!String::from_utf8_lossy(&persisted.bytes).contains("78563412")); + } + + #[test] + fn opaque_post_ready_batches_cannot_bypass_auth_filter() { + let sink = Sink::default(); + let rec = Recorder::with_live_sink(Box::new(sink.clone())); + rec.control_game_ready(true); + push(&rec); + let before = sink.0.lock().unwrap().bytes.clone(); + // Inflated batch: zero header, reconnect opcode, credential. No safe boundaries. + rec.push( + Channel::Game, + Dir::S2C, + 4, + 1, + "CompressedGamePackets", + &[0, 0, 1, 0, 9, 8, 7, 6], + ); + assert_eq!(sink.0.lock().unwrap().bytes, before); + assert!(rec.take_live_events().is_err()); + } + #[test] fn queue_or_sink_failure_is_observable_and_never_silently_resumes() { let sink = Sink::default(); diff --git a/rust/crates/aaemu-testclient/src/scenario.rs b/rust/crates/aaemu-testclient/src/scenario.rs index 8665892078..4ca8f57e43 100644 --- a/rust/crates/aaemu-testclient/src/scenario.rs +++ b/rust/crates/aaemu-testclient/src/scenario.rs @@ -557,6 +557,10 @@ async fn open_lobby( p.is_sc(sc::SCCharacterListPacket) && p.body.first() == Some(&1) }) .await?; + ensure!( + game.state.char_list_done, + "incomplete character-list metadata" + ); game.drain(Duration::from_millis(300), Duration::from_secs(2)) .await?; r.end(s, format!("{} character(s)", game.state.characters.len())); @@ -610,6 +614,20 @@ pub struct ControlSession { _login: LoginClient, } +impl ControlSession { + /// Release this session's stream, login, and both game halves without application logout. + pub async fn disconnect_hard(self) { + let Self { + game, + stream, + _login: login, + } = self; + drop(stream); + drop(login); + game.disconnect_hard().await; + } +} + fn control_character( characters: &[crate::game::CharInfo], requested: &str, @@ -631,6 +649,70 @@ mod control_character_tests { use super::control_character; use crate::game::CharInfo; + // Literal SCCharacterList wire body: last=true, count=2. First entry has a full + // equipment item (55-byte detail), nonzero BodyPart ids, faction text, and a Face + // model with a three-byte modifier. Second entry has a Hair model. No server encoder + // or preconstructed CharInfo vector participates in this regression. + const TWO_CHARACTERS: &str = concat!( + "01020a0000000500466972737401020a6f000000de0000004d00000054000000070046616374696f6e04000000050000", + "004f1a0000887766554433221101020100000001000102030405060708090a0b0c0d0e0f101112131415161718191a1b", + "1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435360b000000000000000c0000000d0000000e0f000000", + "000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000000000000000000000000000000000fb030000fc030000fd030000", + "fe030000ff0300000004000001040000000000000000000001020300a000000000000000400100000000000000f04103", + "5b0000005c0000005d0000005e0000000000003f0000803f0000803e01000200640000000000003f650000000000003f", + "660000000000003f670000000000003f6e0000006f000000700000000000403f78000000790000007a0000007b000000", + "7c000000030007080964006500000000000000020067000000000000006800000069000000000000006a0000006b0000", + "00000000006c000000000000006d000000000000006e006f000000700071000000000000007200000000000000730000", + "0000000000740000007500000000000000760000000000000077000000000000000178000000790000007a0000007b00", + "000000000000002a00000005004f776e657201020a6f000000de0000004d00000054000000070046616374696f6e0400", + "000005000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "00000000000000000000000000000000000000000000000000000000000000000000fb030000fc030000fd030000fe03", + "0000ff0300000004000001040000000000000000000001020300a000000000000000400100000000000000f041015b00", + "000064006500000000000000020067000000000000006800000069000000000000006a0000006b000000000000006c00", + "0000000000006d000000000000006e006f00000070007100000000000000720000000000000073000000000000007400", + "00007500000000000000760000000000000077000000000000000178000000790000007a0000007b0000000000000000", + ); + + #[test] + fn native_two_character_packet_selects_its_second_existing_id() { + use crate::game::{GameState, Packet, LEVEL_GAME}; + use aaemu_game::opcodes::sc; + let body = hex::decode(TWO_CHARACTERS).unwrap(); + let mut state = GameState::default(); + state + .observe(&Packet { + level: LEVEL_GAME, + opcode: sc::SCCharacterListPacket, + body: body.clone(), + }) + .unwrap(); + assert!(state.char_list_done); + assert_eq!( + state.characters.iter().map(|c| c.id).collect::>(), + [10, 42] + ); + assert_eq!( + control_character(&state.characters, "Owner", None).unwrap(), + 42 + ); + assert_eq!( + control_character(&state.characters, "ignored", Some(42)).unwrap(), + 42 + ); + assert_eq!(state.characters[1].name, "Owner"); + let mut truncated = GameState::default(); + assert!(truncated + .observe(&Packet { + level: LEVEL_GAME, + opcode: sc::SCCharacterListPacket, + body: body[..body.len() - 1].to_vec() + }) + .is_err()); + assert!(truncated.characters.is_empty()); + assert!(!truncated.char_list_done); + } + #[test] fn control_never_falls_back_to_first_or_creates_a_missing_character() { let characters = [ @@ -696,16 +778,32 @@ pub async fn control_tp( y: f32, z: f32, clock: u32, + until: tokio::time::Instant, ) -> anyhow::Result<()> { - game.state.last_teleport = None; - game.chat(0, &format!("/move {x} {y} {z}")).await?; - game.wait_sc(sc::SCTeleportUnitPacket).await?; - let at = game.state.self_pos; - game.teleport_ended(at).await?; - game.move_to(at, clock).await?; - game.drain(Duration::from_millis(1500), Duration::from_secs(8)) - .await?; - Ok(()) + tokio::time::timeout_at(until, async { + game.state.last_teleport = None; + game.chat(0, &format!("/move {x} {y} {z}")).await?; + game.wait_sc(sc::SCTeleportUnitPacket).await?; + let at = game + .state + .last_teleport + .context("teleport position missing")?; + game.teleport_ended(at).await?; + game.move_to(at, clock).await?; + // The completion boundary is the received teleport and the two sent acknowledgments. + // Ambient traffic is not an action acknowledgment and need never become quiet. + // Pump any immediate replies for a small slice of the *remaining* action budget. + let remaining = until.saturating_duration_since(tokio::time::Instant::now()); + let max = remaining + .saturating_sub(Duration::from_millis(20)) + .min(Duration::from_millis(100)); + if !max.is_zero() { + game.drain(Duration::from_millis(10), max).await?; + } + Ok::<_, anyhow::Error>(()) + }) + .await + .context("teleport command deadline")? } async fn run_inner( @@ -2261,3 +2359,146 @@ mod mate_revive_tests { assert_eq!("cometsboon".parse::().unwrap(), Kind::CometsBoon); } } + +#[cfg(test)] +mod control_session_tests { + use super::*; + use aaemu_commons::net::FrameCodec; + use aaemu_game::opcodes::cs; + use futures::{SinkExt, StreamExt}; + use tokio::io::{AsyncReadExt, AsyncWriteExt}; + use tokio::net::TcpListener; + use tokio_util::codec::Framed; + + fn frame(opcode: u16, body: &[u8]) -> Vec { + let mut frame = vec![0xdd, 1, 0, 0]; + frame.extend_from_slice(&opcode.to_le_bytes()); + frame.extend_from_slice(body); + frame + } + + #[tokio::test] + async fn teleport_completes_under_continuous_ambient_traffic() { + let (io, peer) = tokio::io::duplex(64 * 1024); + let rec = Recorder::new(true); + let mut game = GameClient::from_io(io, rec.clone()); + game.state.self_obj = 42; + let (stop, mut stopped) = tokio::sync::oneshot::channel(); + let peer = tokio::spawn(async move { + let mut peer = Framed::new(peer, FrameCodec); + let chat = peer.next().await.unwrap().unwrap(); + assert_eq!( + u16::from_le_bytes([chat[4], chat[5]]), + cs::CSSendChatMessagePacket + ); + let mut teleport = PacketStream::new(); + teleport + .write_u8(0) + .write_i16(0) + .write_position(10.0, 20.0, 30.0) + .write_f32(30.0); + peer.send(frame(sc::SCTeleportUnitPacket, teleport.as_bytes())) + .await + .unwrap(); + let mut ambient = tokio::time::interval(Duration::from_millis(1)); + let mut sent = 0; + let mut acks = Vec::new(); + let mut stop_requested = false; + loop { + if stop_requested && acks.len() == 2 { + return (sent, acks); + } + tokio::select! { + _ = &mut stopped, if !stop_requested => stop_requested=true, + _ = ambient.tick() => { + peer.send(frame(sc::SCErrorMsgPacket, &[7,0])).await.unwrap(); + sent += 1; + }, + incoming = peer.next() => { + let bytes = incoming.unwrap().unwrap(); + acks.push(u16::from_le_bytes([bytes[4], bytes[5]])); + }, + } + } + }); + let until = tokio::time::Instant::now() + Duration::from_secs(5); + tokio::time::timeout( + Duration::from_secs(1), + control_tp(&mut game, 10.0, 20.0, 30.0, 1500, until), + ) + .await + .unwrap() + .unwrap(); + // The fixture keeps draining acknowledgments after this stop signal. + let _ = stop.send(()); + let (sent, acks) = tokio::time::timeout(Duration::from_secs(1), peer) + .await + .unwrap() + .unwrap(); + assert!(sent > 1); + assert_eq!(acks, [cs::CSTeleportEndedPacket, cs::CSMoveUnitPacket]); + assert_eq!(game.state.observed_self_pos, Some((10.0, 20.0, 30.0))); + game.disconnect_hard().await; + } + + #[tokio::test] + async fn hard_close_releases_real_game_reader_writer_and_stream_without_logout() { + // Ephemeral loopback fixtures only: no AAEmu process, login handshake, or database. + let game_listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let stream_listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let login_listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let rec = Recorder::new(true); + let mut game = GameClient::connect( + &game_listener.local_addr().unwrap().to_string(), + rec.clone(), + ) + .await + .unwrap(); + let mut game_peer = game_listener.accept().await.unwrap().0; + let stream = StreamClient::connect( + &stream_listener.local_addr().unwrap().to_string(), + rec.clone(), + ) + .await + .unwrap(); + let mut stream_peer = stream_listener.accept().await.unwrap().0; + let login = LoginClient::connect( + &login_listener.local_addr().unwrap().to_string(), + rec.clone(), + ) + .await + .unwrap(); + let mut login_peer = login_listener.accept().await.unwrap().0; + let packet = frame(sc::SCErrorMsgPacket, &[7, 0]); + game_peer + .write_all(&(packet.len() as u16).to_le_bytes()) + .await + .unwrap(); + game_peer.write_all(&packet).await.unwrap(); + game.recv_within(Duration::from_secs(1)) + .await + .unwrap() + .unwrap(); + let session = ControlSession { + game, + stream, + _login: login, + }; + tokio::time::timeout(Duration::from_secs(1), session.disconnect_hard()) + .await + .unwrap(); + for peer in [&mut game_peer, &mut stream_peer, &mut login_peer] { + let mut bytes = Vec::new(); + tokio::time::timeout(Duration::from_secs(1), peer.read_to_end(&mut bytes)) + .await + .unwrap() + .unwrap(); + assert!( + bytes.is_empty(), + "close must emit no application logout or other packets" + ); + } + assert_eq!(rec.events().len(), 1); + assert_eq!(rec.events()[0].opcode, sc::SCErrorMsgPacket); + } +} From cfc5e93aa1d973181eb152e5e948376be981754b Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:49:30 -0400 Subject: [PATCH 51/66] fix(vehicles): preserve ship audit rack allocation identity Discover current racks only for the registered hull allocation and a matching transform parent and instance. Preserve captured weak references as explicit historical evidence, exclude them from current rack summaries, and prevent retirement capture from resolving recycled cached IDs into another allocation. Add deterministic source regressions for reused hull/rack IDs, stale cached child IDs, stale model parents and wrong instances. Keep the observational consistency flags false and disclose queue, HP and world-removal limits. Scoped rustfmt and diff checks pass; tests intentionally remain unexecuted for parent validation. Co-Authored-By: OpenAI Codex --- .../aaemu-game/src/systems/vehicles/audit.rs | 36 ++++- .../src/systems/vehicles/audit_tests.rs | 140 ++++++++++++++++++ .../aaemu-game/src/systems/vehicles/slaves.rs | 11 +- 3 files changed, 178 insertions(+), 9 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/vehicles/audit.rs b/rust/crates/aaemu-game/src/systems/vehicles/audit.rs index 650af66c77..b2b2dd940f 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/audit.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/audit.rs @@ -3,6 +3,8 @@ //! The item operation scope must precede the publication gate. These protect summon item / //! hull publication together, but do NOT protect the spawn manager's direct world removals, //! every phase timer, or world-instance creation. Consequently v1 always says consistent:false. +//! HP writers can also change the live-root lookup predicate before vehicle death protection. +//! Queue, HP and world removal observations do not constitute an atomic authority snapshot. //! A complete authority cut needs a spawn-manager reference snapshot under a boundary shared //! with its queue drain and world removal. Its current public accessor exposes IDs only. //! Transform, visibility, phase and queue deadlines are explicitly temporal samples. A settled @@ -255,6 +257,12 @@ fn item_fields(i: &Item) -> Value { "detail_type_and_body_hex": hex(&i.detail_type_and_details())}) } +/// Cached attached object IDs and Doodad.parent_obj_id can outlive a parent relation. The +/// registered hull allocation is checked separately before using this live transform relation. +pub(super) fn rack_parent_matches(rack: &Doodad, instance: u32, hull: u32) -> bool { + rack.transform.instance_id == instance && rack.transform.parent_obj_id == hull +} + /// No grants, find-or-create container calls, saves, SQL, or repairs. All guards are synchronous. pub fn snapshot(server: &GameServer, request: &Request) -> Value { let _items = server.systems.economy.operation_scope(); @@ -324,13 +332,15 @@ pub fn snapshot(server: &GameServer, request: &Request) -> Value { w.slave(slave.obj_id) .is_some_and(|s| Arc::ptr_eq(&s, &slave)) }); - if let Some(world) = world { + let retained_doodads = doodads.clone(); + // An old departure future can retain a hull after its object ID was recycled. Only + // the registered allocation may discover racks through numeric world parent fields. + // For an unregistered hull keep only weak references captured from its own lifetime. + if let Some(world) = world.filter(|_| registered) { for rack in world.all_doodads() { let matches = { let r = rack.data(); - r.parent_obj_id == slave.obj_id - || r.transform.parent_obj_id == slave.obj_id - || d.attached_doodads.contains(&rack.obj_id) + rack_parent_matches(&r, instance, slave.obj_id) }; if matches && !doodads.iter().any(|r| Arc::ptr_eq(r, &rack)) { doodads.push(rack); @@ -340,17 +350,26 @@ pub fn snapshot(server: &GameServer, request: &Request) -> Value { doodads.sort_by_key(|r| r.obj_id); let racks: Vec<_> = doodads.iter().map(|rack| { let r = rack.data().clone(); - let registered = world.is_some_and(|w| w.doodad(rack.obj_id).is_some_and(|live| Arc::ptr_eq(&live, rack))); + let rack_registered = world.is_some_and(|w| w.doodad(rack.obj_id).is_some_and(|live| Arc::ptr_eq(&live, rack))); + let current = registered && rack_registered && rack_parent_matches(&r, instance, slave.obj_id); json!({"object_id": rack.obj_id, "db_id": r.db_id, "template_id": r.template_id, "parent": r.parent_obj_id, "transform_parent": r.transform.parent_obj_id, "attach": r.attach_point, "owner_id": r.owner_id, "owner_db_id": r.owner_db_id, - "owner_type": r.owner_type, "registered": registered, "persistent": r.is_persistent, + "owner_type": r.owner_type, "registered": rack_registered, "persistent": r.is_persistent, + "captured_retirement_reference": retained_doodads.iter().any(|old| Arc::ptr_eq(old, rack)), + "current_hull_association": current, + "association": if current { "registered_hull_parent" } else { "retained_hull_lifetime" }, "phase": r.func_group_id, "phase_time_ms": r.phase_time_ms, "interaction_counts": r.phase.interaction_counts, "deleted": r.phase.deleted, "func_task": r.phase.func_task, "item_id": r.item_id, "item_template_id": r.item_template_id, "item": if r.item_id == 0 { Value::Null } else { item_snapshot(server, r.item_id) }}) }).collect(); - let rack_attach: Vec<_> = doodads.iter().map(|r| r.data().attach_point).collect(); + // Historical references remain visible above but never count as current racks/cargo. + let rack_attach: Vec<_> = racks + .iter() + .filter(|r| r["current_hull_association"] == true) + .filter_map(|r| r["attach"].as_u64().map(|a| a as u8)) + .collect(); let missing: Vec<_> = (60..=79u8).filter(|p| !rack_attach.contains(p)).collect(); let duplicate: Vec<_> = (60..=79u8) .filter(|p| rack_attach.iter().filter(|a| *a == p).count() > 1) @@ -367,6 +386,7 @@ pub fn snapshot(server: &GameServer, request: &Request) -> Value { "item_live_root_lookup_member": registered && d.owner_type == BaseUnitType::Character && !d.unit.is_dead() && d.summoning_item_id == request.item_id, "local_transform_sample": [d.unit.transform.x, d.unit.transform.y, d.unit.transform.z, d.unit.transform.rot_x, d.unit.transform.rot_y, d.unit.transform.rot_z], "attached_slaves": d.attached_slaves, "attached_doodads": d.attached_doodads, + "rack_summary_scope": "current_registered_hull_parent", "missing_rack_attach": missing, "duplicate_rack_attach": duplicate, "doodads": racks})); } let queues: Vec<_> = worlds.iter().map(|world| { @@ -381,7 +401,7 @@ pub fn snapshot(server: &GameServer, request: &Request) -> Value { "source_head": Value::Null, "provenance": "exact binary/source identity requires release manifest", "sample_sequence": sample, "consistent": false, "authority_consistent": false, "pending_supported": true, "retirement_consistent": false, - "unsupported": ["spawn queue retained references/direct world removals have no shared audit boundary", "phase/transform/visibility and queue deadlines are temporal samples; no interval proof"], + "unsupported": ["spawn queue retained references/direct world removals have no shared audit boundary", "HP writers affect live-root membership outside publication protection; world enumeration/removal has no shared snapshot boundary", "phase/transform/visibility and queue deadlines are temporal samples; no interval proof"], "publication_scope_held": true, "item_operation_scope_held": true, "world_instances": worlds.iter().map(|w| w.id).collect::>(), "summon_item": item_snapshot(server, request.item_id), diff --git a/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs index f4ea3f85bb..7eaf9d8a69 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs @@ -263,6 +263,146 @@ async fn audit_observation_does_not_extend_retired_hull_lifetime() { .is_empty()); } +fn rack( + world: &WorldInstance, + object: u32, + parent: u32, + attach: u8, + item: u64, +) -> crate::world::DoodadRef { + let mut data = Doodad::new(3446); + data.db_id = object + 1000; + data.parent_obj_id = parent; + data.transform.parent_obj_id = parent; + data.transform.instance_id = world.id; + data.attach_point = attach; + data.item_id = item; + data.item_template_id = 20090; + data.func_group_id = 8265; + let rack = Entity::new(object, data); + world.add_object(&rack); + rack +} + +#[tokio::test] +async fn audit_reused_hull_and_rack_ids_preserve_each_allocation() { + let (server, _client, _owner) = fixture(); + let world = server.world.world(0).unwrap(); + let old = hull(&world, 860, 7, 4001, false); + let old_rack = rack(&world, 861, old.obj_id, 60, 10_060); + old.data().attached_doodads.push(old_rack.obj_id); + old.data().leave_task = 88; + let _departure = server + .systems + .vehicles + .slave_summons + .diagnostics + .retirement(&old, 88); + audit_retirement(&server, &world, &old); + // The invalidated departure future still owns old handles after world removal. Both + // numeric IDs are then reused, while the captured weak references still name the old Arcs. + old.data().leave_task = 0; + world.remove_object(old_rack.obj_id); + world.remove_object(old.obj_id); + let replacement = hull(&world, old.obj_id, 7, 4001, false); + replacement.data().id = 2860; + let new_rack = rack(&world, old_rack.obj_id, replacement.obj_id, 60, 20_060); + new_rack.data().db_id = 2861; + // A later observation of the old timer must not capture the replacement via cached IDs. + audit_retirement(&server, &world, &old); + // Deliberately leave the new hull's cache empty: valid world-parent discovery still works. + let snap = audit::snapshot(&server, &request()); + let candidates = snap["candidates"].as_array().unwrap(); + assert_eq!(candidates.len(), 2); + let historic = candidates + .iter() + .find(|c| c["registered"] == false) + .unwrap(); + let current = candidates.iter().find(|c| c["registered"] == true).unwrap(); + assert_eq!(historic["object_id"], current["object_id"]); + assert_eq!(historic["db_id"], 1860); + assert_eq!(current["db_id"], 2860); + let old_rows = historic["doodads"].as_array().unwrap(); + let new_rows = current["doodads"].as_array().unwrap(); + assert_eq!(old_rows.len(), 1); + assert_eq!(new_rows.len(), 1); + assert_eq!(old_rows[0]["db_id"], 1861); + assert_eq!(old_rows[0]["item_id"], 10_060); + assert_eq!(old_rows[0]["registered"], false); + assert_eq!(old_rows[0]["captured_retirement_reference"], true); + assert_eq!(old_rows[0]["association"], "retained_hull_lifetime"); + assert_eq!(old_rows[0]["current_hull_association"], false); + assert_eq!(new_rows[0]["db_id"], 2861); + assert_eq!(new_rows[0]["item_id"], 20_060); + assert_eq!(new_rows[0]["registered"], true); + assert_eq!(new_rows[0]["captured_retirement_reference"], false); + assert_eq!(new_rows[0]["association"], "registered_hull_parent"); + assert_eq!(new_rows[0]["current_hull_association"], true); + assert!(historic["missing_rack_attach"] + .as_array() + .unwrap() + .contains(&json!(60))); + assert!(!current["missing_rack_attach"] + .as_array() + .unwrap() + .contains(&json!(60))); + assert_eq!(historic["duplicate_rack_attach"], json!([])); + assert_eq!(current["duplicate_rack_attach"], json!([])); + assert_eq!(snap["consistent"], false); + assert_eq!(snap["authority_consistent"], false); +} + +#[tokio::test] +async fn audit_registered_hull_ignores_recycled_cached_child_id() { + let (server, _client, _owner) = fixture(); + let world = server.world.world(0).unwrap(); + let root = hull(&world, 870, 7, 4001, false); + let old_rack = rack(&world, 871, root.obj_id, 60, 10_060); + root.data().attached_doodads.push(old_rack.obj_id); + audit_retirement(&server, &world, &root); + world.remove_object(old_rack.obj_id); + // A recycled cached ID alone is not a live transform relation. + let _unrelated = rack(&world, old_rack.obj_id, 999, 60, 20_060); + // Nor is a stale model parent, without the matching transform relation. + let stale_model_parent = rack(&world, 874, 999, 63, 20_063); + stale_model_parent.data().parent_obj_id = root.obj_id; + // A valid transform parent in a different instance is not this hull's current rack either. + let wrong_instance = rack(&world, 872, root.obj_id, 61, 20_061); + wrong_instance.data().transform.instance_id = 42; + root.data().attached_doodads.push(wrong_instance.obj_id); + // Re-capturing retirement evidence must not promote stale cached IDs to historical refs. + audit_retirement(&server, &world, &root); + let live = rack(&world, 873, root.obj_id, 62, 20_062); + let snap = audit::snapshot(&server, &request()); + let candidate = &snap["candidates"][0]; + assert_eq!(candidate["registered"], true); + let rows = candidate["doodads"].as_array().unwrap(); + // The legitimate old weak reference survives as history; the unrelated allocations do not. + assert_eq!(rows.len(), 2); + let historic = rows.iter().find(|r| r["item_id"] == 10_060).unwrap(); + assert_eq!(historic["captured_retirement_reference"], true); + assert_eq!(historic["current_hull_association"], false); + assert_eq!(historic["association"], "retained_hull_lifetime"); + let current = rows.iter().find(|r| r["object_id"] == live.obj_id).unwrap(); + assert_eq!(current["current_hull_association"], true); + assert!(rows + .iter() + .all(|r| r["item_id"] != 20_060 && r["item_id"] != 20_061 && r["item_id"] != 20_063)); + assert!(candidate["missing_rack_attach"] + .as_array() + .unwrap() + .contains(&json!(60))); + assert!(candidate["missing_rack_attach"] + .as_array() + .unwrap() + .contains(&json!(61))); + assert!(!candidate["missing_rack_attach"] + .as_array() + .unwrap() + .contains(&json!(62))); + assert_eq!(candidate["duplicate_rack_attach"], json!([])); +} + #[tokio::test] async fn audit_all_worlds_hidden_dead_children_retiring_and_owner_item_isolation() { let (server, _client, _owner) = fixture(); diff --git a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs index cb73718aa3..f811d35d4b 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs @@ -1573,6 +1573,15 @@ fn spawn_manager_of( } fn audit_retirement(server: &GameServer, world: &WorldInstance, root: &SlaveRef) { + let diagnostics = &server.systems.vehicles.slave_summons.diagnostics; + if !world + .slave(root.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, root)) + { + // Numeric cached children cannot identify this lifetime after the hull ID was reused. + diagnostics.retiring(world.id, root, &[]); + return; + } let (children, doodads) = { let d = root.data(); (d.attached_slaves.clone(), d.attached_doodads.clone()) @@ -1580,8 +1589,8 @@ fn audit_retirement(server: &GameServer, world: &WorldInstance, root: &SlaveRef) let doodads: Vec<_> = doodads .into_iter() .filter_map(|id| world.doodad(id)) + .filter(|rack| super::audit::rack_parent_matches(&rack.data(), world.id, root.obj_id)) .collect(); - let diagnostics = &server.systems.vehicles.slave_summons.diagnostics; diagnostics.retiring(world.id, root, &doodads); for child in children.into_iter().filter_map(|id| world.slave(id)) { diagnostics.retiring(world.id, &child, &[]); From 6a406e5da2d319bc61cc073e761d4d3c08a005d9 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 18:52:41 -0400 Subject: [PATCH 52/66] fix(vehicles): retain audit authority flag in oversized fallback Explicitly return authority_consistent:false alongside consistent:false when the audit exceeds its transport limit. Assert both flags after reassembling the oversized-response regression. Co-Authored-By: OpenAI Codex --- rust/crates/aaemu-game/src/systems/vehicles/audit.rs | 2 +- rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/rust/crates/aaemu-game/src/systems/vehicles/audit.rs b/rust/crates/aaemu-game/src/systems/vehicles/audit.rs index b2b2dd940f..0647b809d0 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/audit.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/audit.rs @@ -447,7 +447,7 @@ pub fn chunks(request: &Request, snapshot: &Value) -> anyhow::Result if bytes.len() > MAX_BYTES { bytes = serde_json::to_vec(&json!({"protocol": PROTOCOL, "nonce": request.nonce, "character_id": request.character_id, "item_id": request.item_id, - "sample_sequence": snapshot["sample_sequence"], "consistent": false, + "sample_sequence": snapshot["sample_sequence"], "consistent": false, "authority_consistent": false, "pending_supported": false, "unsupported": ["snapshot exceeds 65536 byte transport limit"], "source_capability": CAPABILITY}))?; } let sequence = &snapshot["sample_sequence"]; diff --git a/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs index 7eaf9d8a69..bd172bf12c 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs @@ -621,6 +621,7 @@ fn audit_chunks_are_bounded_complete_and_reject_corrupt_or_stale_data() { let huge = json!({"nonce": req.nonce, "sample_sequence": 83, "payload": "x".repeat(70_000)}); let unsupported = reassemble(&audit::chunks(&req, &huge).unwrap()).unwrap(); assert_eq!(unsupported["consistent"], false); + assert_eq!(unsupported["authority_consistent"], false); assert!(unsupported.get("payload").is_none()); } From 05974c46d2bc9ae8da030ad377593d9dc6c07643 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 19:02:56 -0400 Subject: [PATCH 53/66] docs(audit): record passing cargo and database regressions --- rust/crates/aaemu-game/PORTING.md | 6 +++-- rust/docs/audit-repair-status.json | 40 +++++++++++++++++------------- 2 files changed, 27 insertions(+), 19 deletions(-) diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 353934e8fe..a07085848c 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -309,8 +309,10 @@ items. Metadata matching does not establish allocation generation. Cargo and ambiguous item references, plus saved containers, may be retained after the last rack disappears; reconciliation and orphan collection remain open. Regression sources cover shuffled twenty-rack cycles, stale sources, failed recovery, -allocator reuse and private-MySQL saved aliases. Source review is complete; -exact-head execution and live reconnect acceptance are still pending. +allocator reuse and private-MySQL saved aliases. At `7ac9af6eb`, the game unit suite, +real-compact twenty-rack cycles and both private-MySQL cargo fixtures pass. Local +combined-source CI and live reconnect acceptance remain pending; the asynchronous +hull identity repair requires separate review and validation. ### systems::social diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json index 37be750e48..4b6e472fb8 100644 --- a/rust/docs/audit-repair-status.json +++ b/rust/docs/audit-repair-status.json @@ -46,9 +46,9 @@ }, { "id": "housing-bench-plaque-permissions", - "status": "merged_pending_validation", + "status": "unit_and_data_passed_full_gate_pending", "commit": "e2e9744b59d094b2ceb74c63626336664071a59f", - "note": "New flow fixtures corrected to initialize Construction19; strict200LP assertions awaiting rerun." + "note": "Construction19 fixtures corrected; full game unit suite and ignored compact plaque-pack checks pass at7ac." }, { "id": "craft-bench-pack-and-required-doodad", @@ -379,9 +379,9 @@ }, { "id": "trade-ship-cargo-reference-atomicity", - "status": "source_reviewed_merged_pending_validation", + "status": "unit_and_data_passed_full_gate_pending", "owner": "audit-tradeship", - "note": "Exact equipped-source deposit and checked recovery are integrated. Original-reference cleanup protects foreign/recycled items; ambiguous cargo and saved containers are conservatively retained. Allocation-generation proof and reconciliation/GC remain open. Cargo tests, ignored MySQL/compact checks and live acceptance are pending.", + "note": "Reviewed cargo source8c plus root fixture-ID correction7ac pass game unit suite, native Merchant all20rack cycles, private MySQL saved-alias and recycled-GUID cases. Reconnect identity repair is separate and still under review. Conservative cargo/container retention and reconciliation/GC limits remain.", "commit": "8c2e977b5ba6b7660e4739964465e0b1e97b9d7b" }, { @@ -412,19 +412,16 @@ "result": "held_at_memory_reserve_before_completion", "minimum_free_gib": 5.938747406005859 }, - "current_full_lane_ci": "pending", + "current_full_lane_ci": "pending_after_remaining_source_integration", "current_live": "pending", "game_unit_tests": { - "head": "1f53a66bdd0ab289ae2a26abbbaff084cddfcaff", - "passed": 2813, - "failed": 6, - "ignored": 145, - "result": "completed_with_fixture_failures", - "fixture_corrections": [ - "395386180", - "5dfd7282b" - ], - "corrected_execution": "pending; subsequent builds held at memory reserve before tests ran" + "head": "7ac9af6eb3b7d0b511310d7865dc10a1f6bf2712", + "passed": 2833, + "failed": 0, + "ignored": 148, + "result": "passed", + "minimum_free_gib": 7.448451995849609, + "source_unchanged": true }, "latest_corrected_builds": { "head": "5dfd7282b71ec84655b44b861b24991502dd5ff2", @@ -453,10 +450,19 @@ "database_scope": "private 3317 lane_audit_final_game; connection-local temporary tables" }, "remote_checks": { - "head": "5dfd7282b71ec84655b44b861b24991502dd5ff2", + "head": "7ac9af6eb3b7d0b511310d7865dc10a1f6bf2712", "passed": 12, "failed": 0, - "scope": "draft PR46 before cargo integration" + "scope": "Draft PR46 Windows/Linux build/tests/Clippy plus coverage, formatting, packet checks and other configured jobs." + }, + "selected_ignored_current_checks": { + "head": "7ac9af6eb3b7d0b511310d7865dc10a1f6bf2712", + "binary_sha256": "fbb66fed5ca0f4c21ce8ac222e175be332f870ab266a82e3ffec09d76d227f68", + "passed": 16, + "failed": 0, + "compact_checks": 10, + "private_mysql_checks": 6, + "scope": "Explicit ignored tests; private 3317 lane_audit_final_game uses connection-local temporary tables. Includes Merchant twenty-rack cycles and both cargo persistence/allocator-reuse fixtures." } } } From 0d8e410d3dc20d88dce2b593c3fbdc7672897cb1 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 19:10:06 -0400 Subject: [PATCH 54/66] fix(testclient): bound and filter native batches and report timeouts --- rust/crates/aaemu-testclient/src/control.rs | 227 +++++- rust/crates/aaemu-testclient/src/game.rs | 719 ++++++++++++++++++- rust/crates/aaemu-testclient/src/record.rs | 69 +- rust/crates/aaemu-testclient/src/scenario.rs | 15 +- 4 files changed, 982 insertions(+), 48 deletions(-) diff --git a/rust/crates/aaemu-testclient/src/control.rs b/rust/crates/aaemu-testclient/src/control.rs index f23931d624..6950d3db11 100644 --- a/rust/crates/aaemu-testclient/src/control.rs +++ b/rust/crates/aaemu-testclient/src/control.rs @@ -31,9 +31,12 @@ const MAX_PUMP_MS: u64 = 5000; const MAX_DEADLINE_MS: u64 = 600_000; const COMMAND_TIMEOUT: Duration = Duration::from_secs(5); const CONNECT_TIMEOUT: Duration = Duration::from_secs(60); +// Included in (never added to) command/connect/global ceilings. Socket cleanup and one +// completion retain this slice even when the gameplay action never receives an answer. +const REPORT_RESERVE: Duration = Duration::from_millis(250); const INPUT_QUEUE: usize = 16; const OUTPUT_BYTES: usize = 8 * 1024 * 1024; -const OUTPUT_COUNT: usize = 4096; +const OUTPUT_COUNT: usize = 8192; pub(crate) fn describe() -> Value { json!({ @@ -54,20 +57,26 @@ pub(crate) fn describe() -> Value { "id_bytes": 64, "commands": MAX_COMMANDS, "pump_ms": MAX_PUMP_MS, "command_ms": COMMAND_TIMEOUT.as_millis(), "connect_ms": CONNECT_TIMEOUT.as_millis(), "deadline_ms": MAX_DEADLINE_MS, - "event_queue_bytes": 8 * 1024 * 1024, "event_queue_count": 2048, + "cleanup_report_ms": REPORT_RESERVE.as_millis(), + "event_queue_bytes": 8 * 1024 * 1024, "event_queue_count": 8192, "input_queue_count": INPUT_QUEUE, "output_queue_bytes": OUTPUT_BYTES, "output_queue_count": OUTPUT_COUNT }, "incremental_game_capture": true, "capture_create_new": true, "auth_frames_omitted": true, - "opaque_game_batches": "control fails closed; ordinary scenario captures unchanged", + "opaque_game_batches": "unsupported structures rejected; supported native DD04 expanded", + "game_batches": "validated native DD04 expanded into ordinary level-1 events; auth entries omitted; unknown/nested structures rejected", + "batch_limits": {"frame_bytes": aaemu_testclient::game::MAX_GAME_FRAME, + "inflated_bytes": aaemu_testclient::game::MAX_BATCH_BYTES, + "packets": aaemu_testclient::game::MAX_BATCH_PACKETS}, "eof": "cancels active action and discards queued commands", "capture_start": "post-lobby character select/spawn (each session)", "handshake_before_network": true, "initial_character": "existing configured name, never first/create", "state_source": "client_observation", "automatic_retry": false, + "command_timeout": "one command_deadline response after socket closure; control remains disconnected for state, explicit same-character reconnect, or close", "hard_close": "local game write/read halves and stream; no CSLeaveWorld; FIN/RST, not logout", "completion": "one response per input line; event_seq is an observation boundary", "cleanup": "close, EOF, input/output failure or deadline closes only this session" @@ -767,18 +776,44 @@ async fn serve( COMMAND_TIMEOUT }; let until = (Instant::now() + allowance).min(report.deadline); + // Local state/cleanup remain usable in the global reporting slice; they do not + // wait for a gameplay acknowledgment. Network actions stop before that slice. + let work_until = if matches!( + &cmd, + Command::State | Command::Close | Command::DisconnectHard + ) { + until + } else { + until + .checked_sub(REPORT_RESERVE) + .unwrap_or_else(Instant::now) + .max(Instant::now()) + }; report.budget = until; controller.rec.step(&format!("control.{count}")); let rec = controller.rec.clone(); - let done = drive(controller.execute(cmd, until), until, &rec, report, input).await?; + let done = drive( + controller.execute(cmd, work_until), + work_until, + &rec, + report, + input, + ) + .await?; let mut stop = None; let result = match done { Completion::Done(Ok(value)) => Ok(value), - Completion::Done(Err(error)) => { - tracing::debug!("control action failed: {error:#}"); - let closed = controller.disconnect("session_error").await; + Completion::Done(Err(_)) => { + // Native parser failures can retain input. No Display/Debug/cause logging. + tracing::debug!("control action failed"); + let code = if Instant::now() >= work_until { + "command_deadline" + } else { + "session_error" + }; + let closed = controller.disconnect(code).await; report.write(json!({"type": "lifecycle", "closed": closed}))?; - Err("session_error") + Err(code) } Completion::Stopped(code) => { let closed = controller.disconnect(code).await; @@ -1226,4 +1261,180 @@ mod tests { "expired output budget allowed later gameplay" ); } + async fn timeout_serve_case(end_with_eof: bool) { + use aaemu_testclient::game::GameClient; + use aaemu_testclient::login::LoginClient; + use aaemu_testclient::stream::StreamClient; + use std::sync::Mutex; + use tokio::io::AsyncReadExt; + use tokio::net::TcpListener; + + // Source-only fixture: ephemeral loopback transports, no emulator/auth/DB. Start + // with an established session so the full serve path executes the real tp method. + let rec = live_recorder(); + let game_listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let stream_listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let login_listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let mut game = GameClient::connect( + &game_listener.local_addr().unwrap().to_string(), + rec.clone(), + ) + .await + .unwrap(); + let game_peer = game_listener.accept().await.unwrap().0; + let stream = StreamClient::connect( + &stream_listener.local_addr().unwrap().to_string(), + rec.clone(), + ) + .await + .unwrap(); + let stream_peer = stream_listener.accept().await.unwrap().0; + let login = LoginClient::connect( + &login_listener.local_addr().unwrap().to_string(), + rec.clone(), + ) + .await + .unwrap(); + let login_peer = login_listener.accept().await.unwrap().0; + game.account_id = 1; + game.state.selected_char = 42; + game.state.self_obj = 77; + game.state.observed_self_pos = Some((1.0, 2.0, 3.0)); + let peers = [game_peer, stream_peer, login_peer].map(|mut peer| { + tokio::spawn(async move { + let mut bytes = Vec::new(); + peer.read_to_end(&mut bytes).await.unwrap(); + bytes + }) + }); + let cfg: BotConfig = serde_json::from_value(json!({"login":"127.0.0.1:1","user":"fixture", + "password":"fixture-only","character":"Owner"})) + .unwrap(); + let started = Instant::now(); + let mut controller = Controller { + cfg, + rec: rec.clone(), + session: Some(ControlSession::new(game, stream, login)), + handshaken: true, + character_id: Some(42), + generation: 1, + started, + clock: 40000, + }; + let until = started + Duration::from_millis(800); + let (output, mut consumed) = mpsc::channel::(1); + let records = Arc::new(Mutex::new(Vec::::new())); + let saved = records.clone(); + let (observed, mut responses) = mpsc::channel::(4); + let consumer = tokio::spawn(async move { + while let Some(frame) = consumed.recv().await { + let value: Value = serde_json::from_slice(&frame.bytes).unwrap(); + saved.lock().unwrap().push(value.clone()); + frame.ack.send(Ok(())).unwrap(); + if value["type"] == "response" { + observed.send(value).await.unwrap(); + } + } + }); + let mut report = Reporter::new(output, until); + let (mut input, lines, terminal) = input_pair(); + let tp = json!({"protocol":PROTOCOL,"id":1,"method":"tp","params":{"x":10,"y":20,"z":30}}); + lines.send(serde_json::to_vec(&tp).unwrap()).await.unwrap(); + let (finished, done) = oneshot::channel(); + let serving = async { + let result = serve(&mut controller, &mut report, &mut input).await; + let _ = finished.send(()); + result + }; + let script = async move { + let timeout = responses.recv().await.unwrap(); + assert_eq!(timeout["id"], 1); + assert_eq!(timeout["ok"], false); + assert_eq!(timeout["error"]["code"], "command_deadline"); + // All three peer read tasks must observe EOF before any follow-up gameplay. + let mut evidence = Vec::new(); + for peer in peers { + evidence.push( + tokio::time::timeout(Duration::from_secs(1), peer) + .await + .unwrap() + .unwrap(), + ); + } + let state = json!({"protocol":PROTOCOL,"id":2,"method":"state","params":{}}); + lines + .send(serde_json::to_vec(&state).unwrap()) + .await + .unwrap(); + let state = responses.recv().await.unwrap(); + assert_eq!(state["id"], 2); + assert_eq!(state["ok"], true); + assert_eq!(state["result"]["connected"], false); + assert_eq!(state["result"]["character_id"], 42); + if end_with_eof { + terminal.send_replace(Some("eof")); + } + // Keep stdin open in the deadline case until serve itself returns. + let keep_input = (lines, terminal); + let _ = done.await; + drop(keep_input); + evidence + }; + let (result, evidence) = tokio::time::timeout(Duration::from_secs(3), async { + tokio::join!(serving, script) + }) + .await + .unwrap(); + assert_eq!( + result.unwrap(), + if end_with_eof { "eof" } else { "deadline" } + ); + assert!(controller.session.is_none()); + report.finish().await.unwrap(); + { + let records = records.lock().unwrap(); + assert_eq!( + records + .iter() + .filter(|r| r["type"] == "response" && r["id"] == 1) + .count(), + 1 + ); + assert_eq!( + records + .iter() + .filter(|r| r["type"] == "lifecycle" + && r["closed"]["reason"] == "command_deadline" + && r["closed"]["game_read_closed"] == true + && r["closed"]["game_write_closed"] == true + && r["closed"]["stream_closed"] == true) + .count(), + 1 + ); + } + assert!(evidence[1].is_empty() && evidence[2].is_empty()); + let mut wire = evidence[0].as_slice(); + let mut chats = 0; + while !wire.is_empty() { + let len = usize::from(u16::from_le_bytes([wire[0], wire[1]])); + let frame = &wire[2..2 + len]; + if frame[1] == 1 { + let opcode = u16::from_le_bytes([frame[4], frame[5]]); + assert_ne!(opcode, aaemu_game::opcodes::cs::CSLeaveWorldPacket); + if opcode == aaemu_game::opcodes::cs::CSSendChatMessagePacket { + chats += 1; + } + } + wire = &wire[2 + len..]; + } + assert_eq!(chats, 1, "tp must be attempted once, never retried"); + consumer.abort(); + let _ = consumer.await; + } + + #[tokio::test] + async fn full_serve_timeout_reports_once_closes_sockets_and_remains_controllable() { + timeout_serve_case(true).await; + timeout_serve_case(false).await; + } } diff --git a/rust/crates/aaemu-testclient/src/game.rs b/rust/crates/aaemu-testclient/src/game.rs index ccf2b7a2b6..197aa5b647 100644 --- a/rust/crates/aaemu-testclient/src/game.rs +++ b/rust/crates/aaemu-testclient/src/game.rs @@ -1,10 +1,10 @@ //! Game server client (C2G / G2C + the proxy channel) for the 1.2 protocol. //! //! Every frame payload is `[0xDD][level]...`: level 1 (game) carries `[hash][count][u16 opcode]`, -//! level 2 (proxy / CryNetwork) just `[u16 opcode]`. 1.2 traffic is neither encrypted nor -//! compressed. +//! level 2 (proxy / CryNetwork) just `[u16 opcode]`. Traffic is unencrypted; native level-4 +//! game batches carry raw DEFLATE. -use std::collections::{HashMap, HashSet}; +use std::collections::{HashMap, HashSet, VecDeque}; use std::time::{Duration, Instant}; use aaemu_commons::net::FrameCodec; @@ -24,6 +24,235 @@ pub const LEVEL_PROXY: u8 = 2; /// `CompressedGamePackets` (`DD04`). pub const LEVEL_COMPRESSED: u8 = 4; +/// The transport has a u16 frame length. Batches may compress at most 1 MiB into that +/// frame and contain at most 4096 entries (enough for the native all-skill cooldown reset). +/// Every expanded entry must also fit a normal level-1 frame. Limits apply before copies +/// and before inflater output growth, not just when events reach the recorder. +pub const MAX_GAME_FRAME: usize = u16::MAX as usize; +pub const MAX_BATCH_BYTES: usize = 1024 * 1024; +pub const MAX_BATCH_PACKETS: usize = 4096; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum BatchError { + Inflate, + Limit, + Structure, + Unsupported, +} + +impl std::fmt::Display for BatchError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(match self { + Self::Inflate => "invalid DD04 compression", + Self::Limit => "DD04 limit exceeded", + Self::Structure => "invalid DD04 structure", + Self::Unsupported => "unsupported DD04 opcode", + }) + } +} +impl std::error::Error for BatchError {} + +/// miniz_oxide 0.8.9 core::decompress writes only into the supplied slice and returns +/// (status, input consumed, output written). Unlike DecompressError, status contains no +/// partial plaintext. A fixed 1 MiB output slice bounds allocation even for a tiny bomb. +/// Requiring all input consumed also rejects trailing or concatenated deflate streams. +fn inflate_batch(input: &[u8]) -> Result, BatchError> { + use miniz_oxide::inflate::core::{decompress, inflate_flags, DecompressorOxide}; + use miniz_oxide::inflate::TINFLStatus; + if input.len() > MAX_GAME_FRAME - 4 { + return Err(BatchError::Limit); + } + let mut output = vec![0; MAX_BATCH_BYTES]; + let mut inflater = Box::::default(); + let (status, used, written) = decompress( + &mut inflater, + input, + &mut output, + 0, + inflate_flags::TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF, + ); + match status { + TINFLStatus::Done if used == input.len() => { + output.truncate(written); + Ok(output) + } + TINFLStatus::HasMoreOutput => Err(BatchError::Limit), + _ => Err(BatchError::Inflate), + } +} + +fn batch_caster(s: &mut PacketStream) -> anyhow::Result<()> { + let kind = s.read_u8()?; + aaemu_game::systems::skills::types::SkillCaster::read(kind, s)?; + Ok(()) +} + +fn batch_cast_action(s: &mut PacketStream) -> anyhow::Result<()> { + // CastAction has a native writer but no reader (types.rs, CastAction.Write). + let len = match s.read_u8()? { + 0 => 6, + 1 => 14, + 2 => 13, + 3 => 11, + 4 => 7, + _ => bail!(BatchError::Structure), + }; + s.read_bytes(len)?; + Ok(()) +} + +fn batch_plot_object(s: &mut PacketStream) -> anyhow::Result<()> { + // PlotObject.Write: Unit = type1+BC; Position = type2+position9+rotation3. + let len = match s.read_u8()? { + 1 => 3, + 2 => 12, + _ => bail!(BatchError::Structure), + }; + s.read_bytes(len)?; + Ok(()) +} + +/// Consume exactly one native body. No boundary scanning or treating remaining bytes as +/// an unknown body: an unsupported opcode rejects the *whole* batch before publication. +/// Covers every current CompressedGamePackets producer: plots, damage/heal and reset_all. +fn batch_body(dir: Dir, opcode: u16, s: &mut PacketStream) -> anyhow::Result<()> { + if dir == Dir::C2S { + if opcode == cs::X2EnterWorldPacket { + s.read_bytes(29)?; + return Ok(()); + } + bail!(BatchError::Unsupported); + } + match opcode { + sc::SCReconnectAuthPacket => { + s.read_u32()?; + } + sc::X2EnterWorldResponsePacket => { + s.read_bytes(17)?; // reason, gm, stream token, port, world time + s.read_bytes_sized()?; // pubKeySize / pubKey (both native u16-sized) + s.read_string()?; + } + sc::SCSkillCooldownResetPacket => { + s.read_bytes(12)?; + } + sc::SCSkillEndedPacket | sc::SCPlotEndedPacket => { + s.read_bytes(2)?; + } + sc::SCErrorMsgPacket => { + s.read_bytes(9)?; + } + sc::SCCastingStoppedPacket => { + s.read_bytes(6)?; + } + sc::SCBuffRemovedPacket | sc::SCBuffLearnedPacket | sc::SCSkillStoppedPacket => { + s.read_bytes(7)?; + } + sc::SCUnitDamagedPacket => { + batch_cast_action(s)?; + batch_caster(s)?; + s.read_bytes(7)?; // casterBC, targetBC, crime + s.read_pisc_w(3)?; + s.read_pisc_w(3)?; + s.read_bytes(5)?; // holdable, hit type, flag, result + } + sc::SCUnitHealedPacket => { + batch_cast_action(s)?; + batch_caster(s)?; + s.read_bytes(14)?; // targetBC, heal/hit, value, zero, result + } + sc::SCPlotEventPacket => { + s.read_bytes(10)?; // tl, event, skill + batch_plot_object(s)?; + batch_plot_object(s)?; + s.read_bytes(18)?; // item, objectBC, casting, zeroBC, zeroi16 + let count = s.read_u8()?; + s.read_bytes(usize::from(count) * 3)?; + let flag = s.read_u8()?; + if flag & 8 != 0 { + s.read_bytes(13 * 4)?; + } + } + sc::SCBuffCreatedPacket => { + batch_caster(s)?; + s.read_bytes(22)?; // caster, ownerBC, index, buff, level, ability, skill + s.read_pisc_w(4)?; + } + sc::SCSkillStartedPacket | sc::SCSkillFiredPacket => { + use aaemu_game::systems::skills::types::{SkillCastTarget, SkillObject}; + s.read_bytes(6)?; // skill and transport ids + batch_caster(s)?; + let kind = s.read_u8()?; + SkillCastTarget::read(kind, s)?; + let flag = s.read_u8()?; + anyhow::ensure!(flag <= 7, "invalid skill object type"); + SkillObject::read(flag, s)?; + if opcode == sc::SCSkillFiredPacket { + s.read_bytes(10)?; + } else { + s.read_bytes(5)?; // real/base cast, synergy + let extra = s.read_u8()?; + anyhow::ensure!(extra & !7 == 0, "invalid skill extra flags"); + if extra & 1 != 0 { + s.read_u8()?; + } + if extra & 2 != 0 { + s.read_u16()?; + } + if extra & 4 != 0 { + s.read_u32()?; + } + } + } + _ => bail!(BatchError::Unsupported), + } + Ok(()) +} + +/// Shared native batch validation for GameClient and Recorder. The input is the already +/// bounded inflated body, whose entries are [u16 zero][u16 opcode][native body]. No nesting +/// exists in this format. Any nonzero header, bad count/trailing bytes, or unknown body is +/// rejected atomically with a fixed error, never with input bytes or an underlying cause. +pub(crate) fn split_game_batch( + dir: Dir, + count: u16, + body: &[u8], +) -> Result, BatchError> { + if body.len() > MAX_BATCH_BYTES || usize::from(count) > MAX_BATCH_PACKETS { + return Err(BatchError::Limit); + } + let mut stream = PacketStream::from_bytes(body.to_vec()); + let mut packets = Vec::with_capacity(usize::from(count)); + for _ in 0..count { + if stream.read_u16().map_err(|_| BatchError::Structure)? != 0 { + return Err(BatchError::Structure); + } + let opcode = stream.read_u16().map_err(|_| BatchError::Structure)?; + let start = stream.pos(); + if let Err(error) = batch_body(dir, opcode, &mut stream) { + return Err( + if error.downcast_ref::() == Some(&BatchError::Unsupported) { + BatchError::Unsupported + } else { + BatchError::Structure + }, + ); + } + let end = stream.pos(); + if end - start > MAX_GAME_FRAME - 6 { + return Err(BatchError::Limit); + } + packets.push(Packet { + level: LEVEL_GAME, + opcode, + body: body[start..end].to_vec(), + }); + } + if stream.remaining() != 0 { + return Err(BatchError::Structure); + } + Ok(packets) +} + /// A received G2C / proxy packet. #[derive(Debug)] pub struct Packet { @@ -551,6 +780,7 @@ pub struct GameClient { writer: Option, FrameCodec>>, reader: SocketReader, rx: mpsc::Receiver>, + expanded: VecDeque, rec: Recorder, count: u8, pub account_id: u32, @@ -617,8 +847,8 @@ impl GameClient { break; } } - Some(Err(e)) => { - tracing::warn!("game socket read error: {e}"); + Some(Err(_)) => { + tracing::warn!("game socket read failed"); break; } None => { @@ -632,6 +862,7 @@ impl GameClient { writer: Some(FramedWrite::new(Box::new(wr), FrameCodec)), reader: SocketReader(Some(reader)), rx, + expanded: VecDeque::new(), rec, count: 0, account_id: 0, @@ -652,8 +883,18 @@ impl GameClient { pub async fn disconnect_hard(mut self) { drop(self.writer.take()); self.reader.close().await; - // Preserve frames the reader had already delivered before it was stopped. - while let Ok(frame) = self.rx.try_recv() { + // Earlier accepted events are already flushed. Drain already-delivered evidence + // in order for a bounded cleanup slice; do not let an inbound backlog consume the + // command's reporting reserve. No socket remains open while this work runs. + let until = Instant::now() + Duration::from_millis(25); + while Instant::now() < until { + if let Some(packet) = self.expanded.pop_front() { + self.accept(packet); + continue; + } + let Ok(frame) = self.rx.try_recv() else { + break; + }; let _ = self.decode(frame); } self.rx.close(); @@ -705,33 +946,43 @@ impl GameClient { Ok(()) } - fn decode(&mut self, frame: Vec) -> anyhow::Result { - if frame.len() < 4 { - bail!("short game frame ({} bytes)", frame.len()); + fn decode(&mut self, frame: Vec) -> anyhow::Result> { + if frame.len() > MAX_GAME_FRAME { + bail!(BatchError::Limit); + } + if frame.len() < 4 || frame[0] != 0xdd { + bail!("invalid game frame"); } let level = frame[1]; if level == LEVEL_COMPRESSED { - // `CompressedGamePackets`: [dd][04][u16 count][raw deflate of - // ([u16 0][u16 typeId][body])*]. The inner packets carry no lengths; the capture - // keeps the inflated batch (C# and Rust compress differently, the content is what - // must match). let count = u16::from_le_bytes([frame[2], frame[3]]); - let body = miniz_oxide::inflate::decompress_to_vec(&frame[4..]) - .map_err(|e| anyhow!("DD04 inflate failed: {e:?}"))?; - let p = Packet { - level, - opcode: count, - body, - }; + if usize::from(count) > MAX_BATCH_PACKETS { + bail!(BatchError::Limit); + } + let body = inflate_batch(&frame[4..])?; + if self.rec.is_incremental() { + // Validate the whole batch before any entry reaches a capture or state. + self.expanded + .extend(split_game_batch(Dir::S2C, count, &body)?); + return Ok(self.expanded.pop_front().map(|packet| self.accept(packet))); + } + // Ordinary scenario captures keep their existing aggregate inflated body. self.rec.push( Channel::Game, Dir::S2C, level, count, "CompressedGamePackets", - &p.body, + &body, ); - return Ok(p); + return Ok(Some(Packet { + level, + opcode: count, + body, + })); + } + if !matches!(level, LEVEL_GAME | LEVEL_PROXY) { + bail!("unsupported game frame level"); } let (opcode, body) = if level == LEVEL_GAME { if frame.len() < 6 { @@ -752,13 +1003,24 @@ impl GameClient { opcode, body, }; - self.rec - .push(Channel::Game, Dir::S2C, level, opcode, p.name(), &p.body); - if let Err(e) = self.observe(&p) { + Ok(Some(self.accept(p))) + } + + fn accept(&mut self, packet: Packet) -> Packet { + self.rec.push( + Channel::Game, + Dir::S2C, + packet.level, + packet.opcode, + packet.name(), + &packet.body, + ); + if self.observe(&packet).is_err() { self.state.observation_errors += 1; - tracing::debug!("could not parse {}: {e}", p.name()); + // Native/parser errors can retain input; never format their Display/Debug/cause. + tracing::debug!(packet = packet.name(), "could not parse game packet"); } - Ok(p) + packet } /// `PingPacket` (proxy): `tPhy`, `ping` and `local`, like the client's keep-alive. @@ -784,6 +1046,9 @@ impl GameClient { /// Next packet, or `None` after `wait` without one. Sends keep-alive pings as needed. pub async fn recv_within(&mut self, wait: Duration) -> anyhow::Result> { self.keep_alive().await?; + if let Some(packet) = self.expanded.pop_front() { + return Ok(Some(self.accept(packet))); + } let wait = wait.min(self.ping_every); match tokio::time::timeout(wait, self.rx.recv()).await { Err(_) => Ok(None), @@ -791,7 +1056,7 @@ impl GameClient { self.state.disconnected = true; Err(anyhow!("game server closed the connection")) } - Ok(Some(frame)) => Ok(Some(self.decode(frame)?)), + Ok(Some(frame)) => self.decode(frame), } } @@ -1397,3 +1662,399 @@ mod facing_tests { } } } + +#[cfg(test)] +mod compressed_batch_tests { + use super::*; + use crate::record::Event; + use aaemu_game::net::packet::encode; + use aaemu_game::packets::g2c::{SCReconnectAuthPacket, X2EnterWorldResponsePacket}; + use aaemu_game::systems::skills::packets::*; + use aaemu_game::systems::skills::types::{ + CastAction, HealHitType, HealType, PlotObject, SkillCaster, + }; + use std::io::Write; + use std::sync::{Arc, Mutex}; + + #[derive(Clone, Default)] + struct Bytes(Arc>>); + impl Write for Bytes { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.lock().unwrap().extend_from_slice(bytes); + Ok(bytes.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + fn safe_native_batch() -> CompressedGamePackets { + let mut batch = CompressedGamePackets::new(); + batch.add(&SCSkillCooldownResetPacket { + obj_id: 42, + skill_id: 15307, + tag_id: 0, + gcd: false, + }); + batch.add(&SCPlotEventPacket { + tl: 7, + event_id: 8, + skill_id: 15307, + caster: PlotObject::Unit(42), + target: PlotObject::Position { + x: 1.0, + y: 2.0, + z: 3.0, + roll: 0, + pitch: 0, + yaw: 0, + }, + obj_id: 43, + casting_time: 100, + flag: 8, + item_id: 100, + target_unit_count: 2, + }); + batch.add(&SCUnitDamagedPacket::new( + CastAction::Plot { + plot_id: 1, + tl_id: 7, + event_id: 8, + skill_id: 15307, + }, + SkillCaster::Item { + obj_id: 42, + item_id: 100, + item_template_id: 23398, + type1: 0, + type2: 0, + }, + 42, + 43, + 20000, + 1000, + )); + batch.add(&SCUnitHealedPacket { + cast_action: CastAction::Buff { + buff_id: 1, + owner_obj_id: 42, + index: 2, + }, + skill_caster: SkillCaster::Mount { + obj_id: 42, + mount_skill_template_id: 3, + }, + target_id: 43, + heal_type: HealType::Health, + heal_hit_type: HealHitType::HealHit, + value: 400, + }); + batch.add(&SCBuffCreatedPacket { + skill_caster: SkillCaster::Unit(42), + caster_id: 1, + owner_obj_id: 42, + index: 2, + buff_id: 3, + caster_level: 10, + ab_level: 10, + skill_id: 15307, + charge: 300, + duration: 20000, + tick: 100.0, + }); + batch.add(&SCSkillEndedPacket { tl: 7 }); + batch.add(&SCBuffRemovedPacket { + obj_id: 42, + index: 2, + }); + batch.add(&aaemu_game::packets::world::SCErrorMsgPacket::new( + 7, 0, false, + )); + let mut started = SCSkillStartedPacket::new( + 15307, + 7, + SkillCaster::Unit(42), + aaemu_game::systems::skills::types::SkillCastTarget::Position { + obj_id: 0, + x: 1.0, + y: 2.0, + z: 3.0, + rot: 0.0, + obj_id1: 0, + obj_id2: 0, + }, + aaemu_game::systems::skills::types::SkillObject::Text("safe".into()), + ); + started + .set_skill_result(2) + .set_result_ushort(300) + .set_result_uint(400); + batch.add(&started); + batch.add(&SCSkillFiredPacket { + id: 15307, + tl: 7, + caster: SkillCaster::Unit(42), + target: aaemu_game::systems::skills::types::SkillCastTarget::Doodad(43), + skill_object: aaemu_game::systems::skills::types::SkillObject::None, + computed_delay: 100, + channeling_time: 0, + fire_anim_id: 1, + }); + batch + } + + fn client(rec: Recorder) -> GameClient { + let (io, _peer) = tokio::io::duplex(64 * 1024); + GameClient::from_io(io, rec) + } + + fn control_events(frame: Vec) -> (Vec, Vec) { + let sink = Bytes::default(); + let rec = Recorder::incremental_game_to(sink.clone()); + rec.control_game_ready(true); + let mut game = client(rec.clone()); + game.decode(frame).unwrap(); + while let Some(packet) = game.expanded.pop_front() { + game.accept(packet); + } + let output = rec.take_live_events().unwrap(); + let capture = String::from_utf8(sink.0.lock().unwrap().clone()) + .unwrap() + .lines() + .map(|line| serde_json::from_str(line).unwrap()) + .collect(); + (output, capture) + } + + #[tokio::test] + async fn real_repo_encoded_plot_combat_and_cooldown_batches_reach_both_sinks() { + let batch = safe_native_batch(); + let (events, capture) = control_events(encode(&batch)); + assert_eq!(events, capture); + assert_eq!(events.len(), batch.len()); + for (event, (opcode, body)) in events.iter().zip(&batch.packets) { + assert_eq!(event.level, LEVEL_GAME); + assert_eq!(event.opcode, *opcode); + assert_eq!(event.body_bytes(), *body); + } + let mut large = CompressedGamePackets::new(); + for skill in 0..1024 { + large.add(&SCSkillCooldownResetPacket { + obj_id: 42, + skill_id: skill, + tag_id: 0, + gcd: false, + }); + } + assert_eq!(control_events(encode(&large)).0.len(), 1024); + assert!(control_events(encode(&CompressedGamePackets::new())) + .0 + .is_empty()); + } + + #[tokio::test] + async fn mixed_auth_batches_only_publish_the_safe_inner_packets() { + const TOKEN: u32 = u32::from_le_bytes(*b"KEY!"); + let safe = safe_native_batch(); + let mut mixed = CompressedGamePackets::new(); + mixed.add(&SCReconnectAuthPacket { token: TOKEN }); + mixed.packets.extend(safe.packets.clone()); + mixed.add(&X2EnterWorldResponsePacket { + reason: 0, + gm: true, + token: TOKEN, + port: 25250, + world_time: 0, + }); + let (events, capture) = control_events(encode(&mixed)); + assert_eq!(events, capture); + assert_eq!(events.len(), safe.len()); + for event in &events { + assert_eq!(event.level, 1); + assert!(!matches!( + event.opcode, + sc::SCReconnectAuthPacket | sc::X2EnterWorldResponsePacket + )); + assert!(!event.body.contains("4b455921")); + } + // A recorder receiving an already-inflated aggregate uses the identical splitter. + let sink = Bytes::default(); + let rec = Recorder::incremental_game_to(sink.clone()); + rec.control_game_ready(true); + rec.push( + Channel::Game, + Dir::S2C, + 4, + mixed.len() as u16, + "CompressedGamePackets", + &mixed.raw_payload(), + ); + let direct = rec.take_live_events().unwrap(); + assert_eq!( + direct + .iter() + .map(|e| (e.opcode, e.body.clone())) + .collect::>(), + events + .iter() + .map(|e| (e.opcode, e.body.clone())) + .collect::>() + ); + assert!(!String::from_utf8_lossy(&sink.0.lock().unwrap()).contains("4b455921")); + // C2S's credential transition is X2EnterWorld (native 29-byte body). + let mut auth = PacketStream::new(); + auth.write_u32(0) + .write_u32(0) + .write_u32(1) + .write_u32(TOKEN) + .write_i32(0) + .write_u8(0) + .write_u64(0); + let mut inbound = CompressedGamePackets::new(); + inbound + .packets + .push((cs::X2EnterWorldPacket, auth.into_bytes())); + let sink = Bytes::default(); + let rec = Recorder::incremental_game_to(sink.clone()); + rec.control_game_ready(true); + rec.push( + Channel::Game, + Dir::C2S, + 4, + 1, + "CompressedGamePackets", + &inbound.raw_payload(), + ); + assert!(rec.take_live_events().unwrap().is_empty()); + assert!(sink.0.lock().unwrap().is_empty()); + // Ordinary private scenario captures preserve their existing inflated aggregate. + let ordinary = Recorder::new(true); + let mut game = client(ordinary.clone()); + let packet = game.decode(encode(&mixed)).unwrap().unwrap(); + assert_eq!(packet.level, 4); + assert_eq!(ordinary.events()[0].body_bytes(), mixed.raw_payload()); + assert_eq!(ordinary.events().len(), 1); + } + + fn redacted(error: &anyhow::Error) { + for text in [ + format!("{error}"), + format!("{error:#}"), + format!("{error:?}"), + ] { + for secret in ["KEY!", "4b455921", "75, 69, 89, 33"] { + assert!(!text.contains(secret), "payload in formatted parser error"); + } + } + } + + #[tokio::test] + async fn malformed_compressed_auth_never_reaches_errors_or_debug_logs() { + let mut raw = PacketStream::new(); + raw.write_u16(0) + .write_u16(sc::SCReconnectAuthPacket) + .write_raw(b"KEY!"); + let mut bad = deflate_stored(raw.as_bytes()); + bad[0] = 0; // valid non-final stored block produces the secret before the invalid block + bad.push(7); // final reserved BTYPE=3 + let mut frame = vec![0xdd, 4, 1, 0]; + frame.extend_from_slice(&bad); + let logs = Bytes::default(); + let writer = logs.clone(); + let subscriber = tracing_subscriber::fmt() + .without_time() + .with_ansi(false) + .with_max_level(tracing::Level::DEBUG) + .with_writer(move || writer.clone()) + .finish(); + let _guard = tracing::subscriber::set_default(subscriber); + let sink = Bytes::default(); + let rec = Recorder::incremental_game_to(sink.clone()); + rec.control_game_ready(true); + let mut game = client(rec.clone()); + let error = game.decode(frame).unwrap_err(); + assert_eq!( + error.downcast_ref::(), + Some(&BatchError::Inflate) + ); + redacted(&error); + tracing::debug!(debug=?error,display=%error,"sanitized batch error"); + // The observation path also avoids formatting errors with retained native input. + game.decode(aaemu_game::net::packet::encode_raw( + 1, + sc::X2EnterWorldResponsePacket, + b"KEY!", + )) + .unwrap(); + let logs = String::from_utf8(logs.0.lock().unwrap().clone()).unwrap(); + assert!(logs.contains("sanitized batch error")); + for secret in ["KEY!", "4b455921", "75, 69, 89, 33"] { + assert!(!logs.contains(secret)); + } + assert!(rec.take_live_events().unwrap().is_empty()); + assert!(sink.0.lock().unwrap().is_empty()); + } + + #[tokio::test] + async fn count_nested_unknown_truncated_and_trailing_batches_fail_atomically() { + let safe = safe_native_batch(); + let raw = safe.raw_payload(); + let mut nonzero = raw.clone(); + nonzero[0] = 1; + let mut trailing = raw.clone(); + trailing.push(0xff); + let mut inner = CompressedGamePackets::new(); + inner.add(&SCSkillEndedPacket { tl: 7 }); + let mut nested = CompressedGamePackets::new(); + nested.add(&inner); + let cases = [ + (safe.len() as u16, nonzero), + (safe.len() as u16, trailing), + (safe.len() as u16 + 1, raw.clone()), + (safe.len() as u16 - 1, raw.clone()), + (safe.len() as u16, raw[..raw.len() - 1].to_vec()), + (1, vec![0, 0, 0xff, 0xff, b'K', b'E', b'Y', b'!']), + (1, nested.raw_payload()), + (1, encode(&inner)), // nested DD04 level header is not an inner zero/opcode header + ]; + for (count, body) in cases { + let sink = Bytes::default(); + let rec = Recorder::incremental_game_to(sink.clone()); + rec.control_game_ready(true); + let mut game = client(rec.clone()); + let mut frame = vec![0xdd, 4]; + frame.extend_from_slice(&count.to_le_bytes()); + frame.extend_from_slice(&deflate_stored(&body)); + redacted(&game.decode(frame).unwrap_err()); + assert!(rec.take_live_events().unwrap().is_empty()); + assert!(sink.0.lock().unwrap().is_empty()); + } + } + + #[tokio::test] + async fn inflater_refuses_bombs_and_frame_count_limits_before_unbounded_growth() { + // Only cap+1 plaintext bytes are needed to test a bomb; no huge fixture allocation. + let bomb = miniz_oxide::deflate::compress_to_vec(&vec![b'A'; MAX_BATCH_BYTES + 1], 9); + assert!(bomb.len() < MAX_GAME_FRAME - 4); + assert_eq!(inflate_batch(&bomb).unwrap_err(), BatchError::Limit); + let exact = miniz_oxide::deflate::compress_to_vec(&vec![b'A'; MAX_BATCH_BYTES], 9); + assert_eq!(inflate_batch(&exact).unwrap().len(), MAX_BATCH_BYTES); + let mut trailing = exact; + trailing.extend_from_slice(&[0xaa; 64]); + assert_eq!(inflate_batch(&trailing).unwrap_err(), BatchError::Inflate); + let mut game = client(Recorder::new(false)); + let error = game.decode(vec![0; MAX_GAME_FRAME + 1]).unwrap_err(); + redacted(&error); + let mut frame = vec![0xdd, 4]; + frame.extend_from_slice(&((MAX_BATCH_PACKETS + 1) as u16).to_le_bytes()); + frame.extend_from_slice(&deflate_stored(&[])); + assert_eq!( + game.decode(frame).unwrap_err().downcast_ref::(), + Some(&BatchError::Limit) + ); + assert_eq!( + split_game_batch(Dir::S2C, 0, &vec![0; MAX_BATCH_BYTES + 1]).unwrap_err(), + BatchError::Limit + ); + } +} diff --git a/rust/crates/aaemu-testclient/src/record.rs b/rust/crates/aaemu-testclient/src/record.rs index 2d7044987f..37ebbfe132 100644 --- a/rust/crates/aaemu-testclient/src/record.rs +++ b/rust/crates/aaemu-testclient/src/record.rs @@ -54,7 +54,7 @@ struct Inner { } /// Control mode drains this bounded queue to stdout; ordinary recorders still keep a Vec. -const MAX_PENDING_EVENTS: usize = 2048; +const MAX_PENDING_EVENTS: usize = 8192; const MAX_PENDING_BYTES: usize = 8 * 1024 * 1024; struct LiveCapture { @@ -175,6 +175,10 @@ impl Recorder { self.0.lock().unwrap_or_else(|e| e.into_inner()) } + pub(crate) fn is_incremental(&self) -> bool { + self.inner().live.is_some() + } + /// Starts a new scenario step; later frames are tagged with it. pub fn step(&self, name: &str) { self.inner().step = name.to_string(); @@ -193,6 +197,42 @@ impl Recorder { name: &str, body: &[u8], ) { + if channel == Channel::Game + && level == crate::game::LEVEL_COMPRESSED + && self.is_incremental() + { + if !self + .inner() + .live + .as_ref() + .is_some_and(|live| live.game_ready) + { + return; + } + // The caller supplies the inflated native body, just as an ordinary aggregate + // capture does. Share GameClient's atomic splitter, then apply the same auth + // policy to each entry. Never publish an outer batch containing a token. + match crate::game::split_game_batch(dir, opcode, body) { + Ok(packets) => { + for packet in packets { + self.push( + channel, + dir, + packet.level, + packet.opcode, + crate::game::packet_name(dir, packet.level, packet.opcode), + &packet.body, + ); + } + } + Err(_) => { + if let Some(live) = self.inner().live.as_mut() { + live.failed = true; + } + } + } + return; + } let mut i = self.inner(); if !i.enabled { return; @@ -203,9 +243,7 @@ impl Recorder { { return; } - // Compressed batches have no per-packet lengths. Without decoding every contained - // opcode we cannot rule out embedded authentication. Fail closed in control mode; - // normal scenario recorders keep their existing raw-batch capture behavior. + // Unknown levels have no validated public framing. DD04 is handled above. if channel == Channel::Game && !matches!(level, 1 | 2) { if let Some(live) = i.live.as_mut() { live.failed = true; @@ -381,13 +419,13 @@ mod tests { } #[test] - fn opaque_post_ready_batches_cannot_bypass_auth_filter() { + fn auth_only_post_ready_batch_never_retains_outer_or_inner_secret_bytes() { let sink = Sink::default(); let rec = Recorder::with_live_sink(Box::new(sink.clone())); rec.control_game_ready(true); push(&rec); let before = sink.0.lock().unwrap().bytes.clone(); - // Inflated batch: zero header, reconnect opcode, credential. No safe boundaries. + // A valid native reconnect-only batch must be filtered, not retained as raw DD04. rec.push( Channel::Game, Dir::S2C, @@ -397,6 +435,25 @@ mod tests { &[0, 0, 1, 0, 9, 8, 7, 6], ); assert_eq!(sink.0.lock().unwrap().bytes, before); + let events = rec.take_live_events().unwrap(); + assert_eq!(events.len(), 1); + assert_eq!(events[0].opcode, sc::SCErrorMsgPacket); + } + + #[test] + fn malformed_batch_is_rejected_before_any_partial_event_or_secret_is_published() { + let sink = Sink::default(); + let rec = Recorder::with_live_sink(Box::new(sink.clone())); + rec.control_game_ready(true); + rec.push( + Channel::Game, + Dir::S2C, + 4, + 1, + "CompressedGamePackets", + &[0, 0, 1, 0, 9, 8, 7, 6, 0xff], + ); + assert!(sink.0.lock().unwrap().bytes.is_empty()); assert!(rec.take_live_events().is_err()); } diff --git a/rust/crates/aaemu-testclient/src/scenario.rs b/rust/crates/aaemu-testclient/src/scenario.rs index 4ca8f57e43..892fd66e9d 100644 --- a/rust/crates/aaemu-testclient/src/scenario.rs +++ b/rust/crates/aaemu-testclient/src/scenario.rs @@ -615,6 +615,15 @@ pub struct ControlSession { } impl ControlSession { + /// Own the three connections of an already established session. + pub fn new(game: GameClient, stream: StreamClient, login: LoginClient) -> Self { + Self { + game, + stream, + _login: login, + } + } + /// Release this session's stream, login, and both game halves without application logout. pub async fn disconnect_hard(self) { let Self { @@ -758,11 +767,7 @@ pub async fn connect_control( let id = control_character(&game.state.characters, &cfg.character, character_id)?; rec.control_game_ready(true); select_and_spawn(&mut game, id, &mut r).await?; - Ok(ControlSession { - game, - stream, - _login: login, - }) + Ok(ControlSession::new(game, stream, login)) } /// Use the scenario's GM chat path without printing command text or replies. From 54f98af143f8458175dc76ffe9afad132ec3b680 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 19:16:21 -0400 Subject: [PATCH 55/66] fix(world): coordinate spawn callbacks and saved cargo publication Acquire the item operation scope before callback-bearing spawn locks and their outer instance/command entries. Keep pure spawn bookkeeping bare and quest NPC components deferred until character and ops guards are released. Validate prepared cargo receipts against the exact live hull and actual unique System escrow before item metadata or prior hull replacement. Reject recovered or aliased references while allowing a different inactive saved hull to restore valid cargo belonging to another player. Add bounded source regressions for real craft-to-quest NPC spawning versus expired-item doodad cleanup, the exact-item and exact-pack recovery ABA, and inactive-hull restoration. Validation here is limited to scoped rustfmt and git diff checks; no Cargo, runtime or DB execution. Co-Authored-By: Codex --- .../aaemu-game/src/systems/economy/craft.rs | 3 + .../economy/craft_publication_tests.rs | 247 ++++++++++++++++ .../src/systems/economy/operation_scope.rs | 3 + .../src/systems/instances/tower_def.rs | 6 + .../src/systems/instances/worlds.rs | 2 + .../aaemu-game/src/systems/npcs/bridges.rs | 1 + .../src/systems/npcs/doodad/funcs/items.rs | 10 + .../src/systems/npcs/doodad/spawner.rs | 6 + .../src/systems/npcs/npc/spawner.rs | 5 + .../src/systems/npcs/spawn_manager.rs | 152 +++++++++- .../aaemu-game/src/systems/quests/bridges.rs | 2 + .../services/commands/scripts/despawn.rs | 1 + .../systems/vehicles/ship_identity_tests.rs | 270 ++++++++++++++++++ .../aaemu-game/src/systems/vehicles/slaves.rs | 16 ++ 14 files changed, 723 insertions(+), 1 deletion(-) create mode 100644 rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs diff --git a/rust/crates/aaemu-game/src/systems/economy/craft.rs b/rust/crates/aaemu-game/src/systems/economy/craft.rs index 5cee696c4b..55cdc005f3 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft.rs @@ -33,6 +33,9 @@ use crate::systems::HookSlot; use crate::world::{DoodadRef, PlayerRef, WorldObject}; use super::craft_data::Craft; +#[cfg(test)] +#[path = "craft_publication_tests.rs"] +mod publication_tests; use super::error_message; use super::inventory::{self, Inv, ItemTxn, Out}; use super::item_handlers::{active, sync_client_packet}; diff --git a/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs b/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs new file mode 100644 index 0000000000..3da92fbea7 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs @@ -0,0 +1,247 @@ +//! The real craft -> quest component -> force_spawn callback contends with an expired +//! source-item doodad's real cleanup. Channel/gate waits are bounded on both threads. +use super::*; +use crate::data::items::ItemTemplate; +use crate::data::GameData; +use crate::models::character::Inventory; +use crate::models::doodad::{doodad_owner_type, Doodad}; +use crate::systems::economy::bridges::EconomyForNpcs; +use crate::systems::economy::craft_data::{Craft, CraftProduct}; +use crate::systems::npcs::doodad::spawner::{NpcSpawnerDef, SpawnerBase}; +use crate::systems::npcs::doodad::templates::DoodadTemplate; +use crate::systems::npcs::npc::data::NpcTemplate; +use crate::systems::npcs::npc::spawner_data::{NpcSpawnerData, NpcSpawnerNpc, NpcSpawnerTemplate}; +use crate::systems::npcs::spawn_manager; +use crate::systems::quests::{ + self, events, + model::kind, + templates::{ActKind, QuestComponentTemplate, QuestTemplate}, +}; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use crate::world::Entity; +use std::sync::mpsc; +use std::time::Duration; + +struct CraftQuest(mpsc::SyncSender<()>); +impl CraftHooks for CraftQuest { + fn on_craft(&self, server: &GameServer, player: &PlayerRef, craft_id: u32) { + assert!(!crate::systems::economy::System::ops_held_on_this_thread()); + self.0.send(()).unwrap(); + // The timer has reached the real outer gate. With reversed ordering it would + // already own spawn_lock here and the following quest callback would deadlock. + server.systems.economy.wait_until_operation_blocked(); + events::on_craft(server, player, craft_id); + } +} + +#[tokio::test] +async fn expired_source_item_doodad_contends_with_craft_quest_npc_spawn() { + const SOURCE: u32 = 4001; + const PRODUCT: u32 = 4002; + let mut data = GameData::empty(); + for id in [SOURCE, PRODUCT] { + data.items.templates.insert(id, ItemTemplate::plain(id, 1)); + } + data.systems.economy.craft.crafts.insert( + 1, + Craft { + id: 1, + craft_products: vec![CraftProduct { + craft_id: 1, + item_id: PRODUCT, + amount: 1, + ..Default::default() + }], + ..Default::default() + }, + ); + let q = &mut data.systems.quests; + q.add_template(QuestTemplate { + id: 1, + ..Default::default() + }); + for (id, step, spawner) in [ + (10, kind::START, 0), + (11, kind::PROGRESS, 0), + (12, kind::READY, 10), + ] { + q.add_component(QuestComponentTemplate { + id, + quest_id: 1, + kind_id: step, + npc_spawner_id: spawner, + ..Default::default() + }); + } + q.add_act( + 11, + 11, + 11, + 1, + ActKind::ObjCraft { + craft_id: 1, + use_alias: false, + alias_id: 0, + highlight_doodad_id: 0, + highlight_doodad_phase: -1, + }, + ); + q.add_act( + 12, + 12, + 12, + 0, + ActKind::ConReportNpc { + npc_id: 500, + use_alias: false, + alias_id: 0, + }, + ); + q.finish(); + data.systems.npcs.npc.templates.insert( + 500, + NpcTemplate { + id: 500, + ..Default::default() + }, + ); + data.systems.npcs.npc_spawners = NpcSpawnerData::from_parts( + vec![NpcSpawnerTemplate { + id: 10, + max_population: 1, + ..Default::default() + }], + vec![NpcSpawnerNpc { + id: 100, + npc_spawner_template_id: 10, + member_id: 500, + member_type: "Npc".into(), + weight: 1.0, + unit_id: 0, + }], + ) + .unwrap(); + data.systems.npcs.doodad.templates.insert( + 7000, + DoodadTemplate { + id: 7000, + ..Default::default() + }, + ); + let server = Arc::new(test_server_with(data)); + server.set_self(); + quests::install_hooks(&server); + server + .systems + .npcs + .hooks + .economy + .install(Arc::new(EconomyForNpcs)); + let client = TestClient::new(&server, 1, 1001); + let mut character = test_character(1, "Crafter", 100.0, 100.0); + character.inventory = Inventory::new(1, 50, 50, &server.items, &server.ids.container); + let player = spawn_player(&server, &client, character, 0x100); + let world = server.world.world(0).unwrap(); + let manager = server.systems.npcs.spawns.get_or_create(&world); + let mut base = SpawnerBase { + unit_id: 500, + ..Default::default() + }; + base.position.x = 101.0; + base.position.y = 100.0; + base.position.z = 100.0; + manager + .add_npc_spawner( + &server, + NpcSpawnerDef { + base, + count: 1, + npc_spawner_ids: Vec::new(), + }, + ) + .unwrap(); + events::add_quest(&server, &player, 1, false); + server.systems.quests.run_queued_evaluations(&server); + assert_eq!(player.data().quests.active[0].step, kind::PROGRESS); + assert!(world.all_npcs().is_empty()); + let source = server + .items + .create( + SOURCE, + 1, + 0, + 1, + &server.game_data.items, + &server.ids.item, + 0, + ) + .unwrap(); + let source_id = source.id; + Inv::of(&player) + .get(slot_type::SYSTEM) + .unwrap() + .lock() + .unwrap() + .add_new_item(source, -1, &server.game_data.items) + .unwrap(); + let mut doodad = Doodad::new(7000); + doodad.owner_type = doodad_owner_type::CHARACTER; + doodad.owner_id = 1; + doodad.item_id = source_id; + doodad.item_template_id = SOURCE; + let doodad = Entity::new(server.ids.object.get_next_id().unwrap(), doodad); + world.spawn(&doodad, &server.view_ctx()); + manager.add_player_doodad(doodad.clone()); + manager.add_despawn( + &server, + WorldObject::from(&doodad), + Some(spawn_manager::now()), + ); + server.systems.economy.craft.update(1, |state| { + state.current_craft = Some(1); + state.count = 1; + }); + let (start, ready) = mpsc::sync_channel(1); + server + .systems + .economy + .craft + .hooks + .install(Arc::new(CraftQuest(start))); + let (tick_done, tick_result) = mpsc::channel(); + let (craft_done, craft_result) = mpsc::channel(); + let runtime = tokio::runtime::Handle::current(); + let (tick_server, tick_runtime) = (server.clone(), runtime.clone()); + let tick = std::thread::spawn(move || { + let _runtime = tick_runtime.enter(); + ready.recv_timeout(Duration::from_secs(5)).unwrap(); + manager.check_respawns_tick(&tick_server); + tick_done.send(()).unwrap(); + }); + let (craft_server, crafter) = (server.clone(), player.clone()); + let craft = std::thread::spawn(move || { + let _runtime = runtime.enter(); + end_craft(&craft_server, &crafter); + craft_done.send(()).unwrap(); + }); + craft_result + .recv_timeout(Duration::from_secs(5)) + .expect("craft/quest/spawn cycle must finish"); + tick_result + .recv_timeout(Duration::from_secs(5)) + .expect("expired source cleanup must finish"); + craft.join().unwrap(); + tick.join().unwrap(); + assert_eq!( + Inv::of(&player).items_count_in(slot_type::INVENTORY, PRODUCT, -1), + 1 + ); + assert_eq!(player.data().quests.active[0].step, kind::READY); + let npcs = world.all_npcs(); + assert_eq!(npcs.len(), 1); + assert_eq!(npcs[0].data().unit.template_id, 500); + assert!(world.doodad(doodad.obj_id).is_none()); + assert!(doodad.data().phase.deleted); + assert!(server.items.item_by_id(source_id).is_none()); + assert!(server.items.removed_items().contains(&source_id)); +} diff --git a/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs b/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs index a14ebabc2b..02f8c0cb7d 100644 --- a/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs +++ b/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs @@ -8,6 +8,9 @@ //! Snapshot-only manager locks which never wait for an item operation need no scope. //! ItemTxn::unlocked remains guardless: callers under a character lock must not acquire //! this scope to compensate. +//! Callback-bearing spawn chains enter scope -> spawn lock -> spawner/instance leaf locks +//! before item callbacks. The bare spawn lock stays available for pure bookkeeping; adding +//! an implicit scope there would invert callers which already hold character/object locks. use std::marker::PhantomData; use std::rc::Rc; diff --git a/rust/crates/aaemu-game/src/systems/instances/tower_def.rs b/rust/crates/aaemu-game/src/systems/instances/tower_def.rs index 2c0267d2d7..d82a45e453 100644 --- a/rust/crates/aaemu-game/src/systems/instances/tower_def.rs +++ b/rust/crates/aaemu-game/src/systems/instances/tower_def.rs @@ -362,6 +362,7 @@ pub fn initialize(server: &GameServer) -> anyhow::Result<()> { } pub fn start(server: &GameServer, key: EventKey, zone_id: u32) -> anyhow::Result<()> { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let event = prepare(server, key, zone_id)?; let first_wave_after = event.def.first_wave_after; @@ -430,6 +431,7 @@ fn spawn_controllers(server: &GameServer, key: EventKey, id: u32) -> anyhow::Res /// Advance exactly one wave. GM requests cannot skip waves or replay an active wave. pub fn next_wave(server: &GameServer, key: EventKey, step: u32) -> anyhow::Result<()> { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let (zone_id, targets, removed, removed_doodads) = { let mut state = manager(server) @@ -518,6 +520,7 @@ pub fn end(server: &GameServer, key: EventKey) -> anyhow::Result<()> { } fn end_event(server: &GameServer, key: EventKey, keep_corpses: bool) -> anyhow::Result<()> { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let event = manager(server) .state @@ -773,6 +776,7 @@ pub fn on_death(server: &GameServer, victim: &WorldObject) { let Some(npc) = victim.as_npc() else { return; }; + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let (world_id, zone_id, template) = { let n = npc.data(); @@ -837,6 +841,7 @@ fn wave_complete(p: &TowerDefProg, kills: &HashMap, elapsed: f32) -> b } pub fn tick(server: &GameServer) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); schedule_tick(server); let now = spawn_manager::now(); @@ -1064,6 +1069,7 @@ fn broadcast(server: &GameServer, world_id: u32, packet: impl ServerPacket + Clo /// End events before an instance is removed, while its NPCs are still reachable. pub fn cleanup_world(server: &GameServer, world_id: u32) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let keys: Vec<_> = manager(server) .state diff --git a/rust/crates/aaemu-game/src/systems/instances/worlds.rs b/rust/crates/aaemu-game/src/systems/instances/worlds.rs index 0a42fd9bb5..9f8beb8c5e 100644 --- a/rust/crates/aaemu-game/src/systems/instances/worlds.rs +++ b/rust/crates/aaemu-game/src/systems/instances/worlds.rs @@ -174,6 +174,7 @@ pub fn world_name(world: &WorldInstance) -> String { /// `WorldManager.RemoveWorld(worldInstanceId)`. pub fn remove_world(server: &GameServer, world_id: u32) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); super::tower_def::cleanup_world(server, world_id); if !server.world.remove_world(world_id) { @@ -190,6 +191,7 @@ pub fn release_world_id(server: &GameServer, world_id: u32) { /// `WorldInstance.CleanupInstance()`: stops the respawn loop, removes the spawners and what they /// spawned, then despawns whatever is left; the instance's `SpawnManager` is dropped. pub fn cleanup_instance(server: &GameServer, world_id: u32) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); super::tower_def::cleanup_world(server, world_id); let spawns = &server.systems.npcs.spawns; diff --git a/rust/crates/aaemu-game/src/systems/npcs/bridges.rs b/rust/crates/aaemu-game/src/systems/npcs/bridges.rs index aad824bfd6..f0943af958 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/bridges.rs @@ -875,6 +875,7 @@ fn npc_spawner_spawn_effect( e: &crate::systems::skills::data::effects::NpcSpawnerSpawnEffect, args: &EffectArgs<'_>, ) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); tracing::info!( "NpcSpawnerSpawnEffect: SpawnerId={}, LifeTime={}, UseSummonerAggroTarget={}, ActivationState={}", diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs index 7c2bd7e251..f9edf65cd9 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs @@ -26,6 +26,16 @@ pub(crate) fn cargo_empty_phase( let d = rack.data(); (d.owner_type, d.template_id, d.func_group_id) }; + cargo_empty_phase_for(server, owner_type, template_id, group) +} + +/// The same authored transition for a prefetched row, without allocating a live rack. +pub(crate) fn cargo_empty_phase_for( + server: &crate::server::GameServer, + owner_type: u8, + template_id: u32, + group: u32, +) -> Option { if owner_type != doodad_owner_type::SLAVE { return None; } diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/spawner.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/spawner.rs index 7ff2b0047b..29376db9aa 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/spawner.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/spawner.rs @@ -387,6 +387,7 @@ impl DoodadSpawner { { return false; } + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); if spawn { if spawner.last().is_none() { @@ -585,6 +586,7 @@ impl DoodadSpawner { item_id: u64, char_obj_id: u32, ) -> Option { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); self.reset_for_spawn(); // C#: WorldManager.GetCharacterByObjId(charId).ParentWorld (null -> exception). @@ -610,6 +612,7 @@ impl DoodadSpawner { /// `Spawn(objId)` (initial spawn and respawns). Only `objId == 0` creates a doodad. pub fn spawn(self: &Arc, server: &GameServer, obj_id: u32) -> Option { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); // TODO (C#): clean up each doodad using the same call self.reset_for_spawn(); @@ -667,6 +670,7 @@ impl DoodadSpawner { /// `Despawn(doodad)`. pub fn despawn(&self, server: &GameServer, doodad: &DoodadRef) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let spawns = &server.systems.npcs.spawns; // Spawn replaces the local list, but the world can still contain older linked spawns. @@ -769,6 +773,7 @@ impl DoodadSpawner { /// `DoDespawn(doodad)` (`Doodad.DoDespawn` / `DoodadSpawnerDoDespawnTask`). pub fn do_despawn(self: &Arc, server: &GameServer, doodad: &DoodadRef) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let (template_id, obj_id, func_group_id) = { let d = doodad.data(); @@ -822,6 +827,7 @@ impl DoodadSpawner { /// `DoSpawn()`: spawns `Last` (with the game schedule checks). pub fn do_spawn(self: &Arc, server: &GameServer) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let schedule = &server.game_data.systems.npcs.schedule; let last_obj_id = self.last().map_or(0, |l| l.obj_id); diff --git a/rust/crates/aaemu-game/src/systems/npcs/npc/spawner.rs b/rust/crates/aaemu-game/src/systems/npcs/npc/spawner.rs index 8b8bb9a514..67b7b94906 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/npc/spawner.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/npc/spawner.rs @@ -411,6 +411,7 @@ impl NpcSpawner { /// `Update()`: despawn (schedule / no player around) has priority over spawning. pub fn update(self: &Arc, server: &GameServer) { + let _items = server.systems.economy.operation_scope(); let _lock = server.systems.npcs.spawns.spawn_lock(); let mut did_action = false; if self.can_despawn_npcs(server) { @@ -439,6 +440,7 @@ impl NpcSpawner { warm_present: bool, budget: i64, ) -> usize { + let _items = server.systems.economy.operation_scope(); let _lock = server.systems.npcs.spawns.spawn_lock(); let mut did_action = false; if self.can_despawn_npcs(server) { @@ -945,6 +947,7 @@ impl NpcSpawner { /// cannot block or duplicate it. Corpse despawn timers, other placements and other instances /// stay intact; a cancelled id is released only when no world object or corpse timer owns it. pub fn force_spawn(self: &Arc, server: &GameServer, _obj_id: u32) -> Option { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); if self.spawned_map().is_empty() { let t = self.template(); @@ -1255,6 +1258,7 @@ impl NpcSpawner { /// living population and the still-reserved respawn deadlines all still apply, and a failed /// pass leaves the spawner unscheduled so it is retried. pub fn do_spawn_bounded(self: &Arc, server: &GameServer, budget: i64) -> usize { + let _items = server.systems.economy.operation_scope(); if budget <= 0 { return 0; } @@ -1614,6 +1618,7 @@ impl NpcSpawner { ) { // Creation, event ownership and population bookkeeping must finish before an // event can end and delete the summoner's descendants. + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let Some(template) = server .game_data diff --git a/rust/crates/aaemu-game/src/systems/npcs/spawn_manager.rs b/rust/crates/aaemu-game/src/systems/npcs/spawn_manager.rs index a15c63ba30..2dda286d30 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/spawn_manager.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/spawn_manager.rs @@ -121,6 +121,148 @@ impl PersistentDoodads { } Ok(Self { rows: prepared }) } + + /// Called inside the item/publication scopes, before replacing any hull. Compare the + /// fetched receipt, not the before/after emptiness of the hull: a store/recover ABA can + /// leave an empty live rack while SQL has captured its former loaded reference. + pub(crate) fn validate_slave_cargo( + &self, + server: &GameServer, + hull_id: u32, + live_hull: Option<&crate::world::SlaveRef>, + ) -> anyhow::Result<()> { + use crate::models::container::slot_type; + use crate::models::item::ItemClass; + use crate::systems::npcs::doodad::funcs::items::cargo_empty_phase_for; + + let mut row_ids = HashSet::new(); + let mut packs = HashSet::new(); + anyhow::ensure!( + live_hull.is_none_or(|h| h.data().id == hull_id), + "cargo preflight has a different live hull identity" + ); + for prepared in &self.rows { + let row = &prepared.row; + anyhow::ensure!( + row.owner_type == doodad_owner_type::SLAVE + && row.house_id == hull_id + && row_ids.insert(row.id), + "persistent doodad batch has a duplicate or different hull identity" + ); + let cargo = server + .game_data + .systems + .npcs + .doodad + .doodad_func_groups(row.template_id) + .iter() + .any(|group| { + cargo_empty_phase_for(server, row.owner_type, row.template_id, group.id) + .is_some() + }); + if !cargo { + continue; + } + if row.item_id == 0 { + anyhow::ensure!( + row.item_template_id == 0 + && cargo_empty_phase_for( + server, + row.owner_type, + row.template_id, + row.current_phase_id + ) + .is_none(), + "saved empty cargo rack has loaded metadata" + ); + continue; + } + anyhow::ensure!( + cargo_empty_phase_for( + server, + row.owner_type, + row.template_id, + row.current_phase_id + ) + .is_some(), + "saved cargo item is not in its loaded phase" + ); + anyhow::ensure!(packs.insert(row.item_id), "aliased saved cargo item"); + // A live version of this exact persistent hull must agree with the fetched + // loaded receipt. Other inactive summon items have no live rack to compare. + if let Some(hull) = live_hull { + let world = server + .world + .world_of(&WorldObject::from(hull)) + .ok_or_else(|| anyhow::anyhow!("cargo hull is no longer live"))?; + let matched = world.all_doodads().into_iter().any(|rack| { + let d = rack.data(); + !d.phase.deleted + && d.db_id == row.id + && d.owner_type == row.owner_type + && d.owner_id == row.owner_id + && d.owner_db_id == hull_id + && d.template_id == row.template_id + && d.attach_point == row.attach_point + && d.parent_obj_id == hull.obj_id + && d.transform.parent_obj_id == hull.obj_id + && d.func_group_id == row.current_phase_id + && d.item_id == row.item_id + && d.item_template_id == row.item_template_id + }); + anyhow::ensure!(matched, "saved cargo receipt changed during hull load"); + } + // System escrow alone is insufficient: the same GUID could now be stored on + // a different live hull. Include hidden/retiring registry objects in this scan. + for world in server.world.worlds() { + for rack in world.all_doodads() { + let d = rack.data(); + if !d.phase.deleted && d.item_id == row.item_id { + anyhow::ensure!( + live_hull.is_some_and(|h| d.parent_obj_id == h.obj_id) + && d.db_id == row.id + && d.owner_db_id == hull_id, + "saved cargo item is referenced by another live rack" + ); + } + } + } + let holder = server + .items + .holding_container(row.item_id) + .ok_or_else(|| anyhow::anyhow!("saved cargo item left escrow"))?; + { + let holder = holder.lock().expect("container poisoned"); + anyhow::ensure!( + holder.slot_type == slot_type::SYSTEM + && holder.get_item_by_id(row.item_id).is_some_and(|item| { + item.slot_type == slot_type::SYSTEM + && item.owner_id == u64::from(holder.owner_id) + && item.template_id == row.item_template_id + && item.class == ItemClass::Backpack + && item.count == 1 + }), + "saved cargo item no longer matches its escrow receipt" + ); + } + let occurrences: usize = server + .items + .all_containers() + .iter() + .map(|container| { + container + .lock() + .expect("container poisoned") + .items + .iter() + .filter(|item| item.id == row.item_id) + .count() + }) + .sum(); + anyhow::ensure!(occurrences == 1, "saved cargo item has multiple holders"); + } + Ok(()) + } } #[cfg(test)] @@ -431,7 +573,10 @@ impl SpawnManagers { v } - /// `lock (_spawnLock)`. + /// `lock (_spawnLock)`. Callback-bearing entries acquire the economy operation scope + /// before this lock and before their own manager/object locks. Keep this primitive bare: + /// pure bookkeeping does not enter the economy, and a caller under a character lock + /// cannot safely acquire the item scope here. Quest NPC components remain deferred. pub fn spawn_lock(&self) -> ReentrantGuard<'_> { self.spawn_lock.lock() } @@ -2021,6 +2166,7 @@ impl SpawnManager { /// One iteration of `CheckRespawns` (the 1 s respawn / despawn thread). pub fn check_respawns_tick(&self, server: &GameServer) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); for e in Self::ready( &self.respawns, @@ -2141,6 +2287,7 @@ impl SpawnManager { if group == 0 { return 0; } + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let spawners: Vec<_> = { let inner = self.inner(); @@ -2444,6 +2591,7 @@ impl SpawnManager { /// the instance is left to track, so a deliberately emptied instance cannot leave a growing /// set of placements whose 9 999 999 s respawn timers never drain). pub fn despawn_all(&self, server: &GameServer) -> usize { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let spawns = &server.systems.npcs.spawns; let mut res = 0; @@ -2484,6 +2632,7 @@ impl SpawnManager { /// `DeleteAllSpawners()`: removes every spawner and what they spawned. pub fn delete_all_spawners(&self, server: &GameServer) { + let _items = server.systems.economy.operation_scope(); // Serialized with the activation pass so a stale queue cannot create NPCs between // despawning a placement's old members and detaching / resetting it. let _serial = server.systems.npcs.spawns.spawn_lock(); @@ -2952,6 +3101,7 @@ fn spawner_has_nonresident_live_npc( /// `World.NpcWarmRetentionSeconds` (residents stay after their first preparation) and expired /// ordinary ones are reclaimed within the same per-tick budget, counted in actual NPCs. pub fn active_region_tick_stats(server: &GameServer) -> ActivationStats { + let _items = server.systems.economy.operation_scope(); // The whole pass holds the spawners' reentrant lock: creation, despawn, placement reload and // delete-all serialize against the queued candidates (sync fn, never held across an await). let _serial = server.systems.npcs.spawns.spawn_lock(); diff --git a/rust/crates/aaemu-game/src/systems/quests/bridges.rs b/rust/crates/aaemu-game/src/systems/quests/bridges.rs index 7063a7dc20..584560163e 100644 --- a/rust/crates/aaemu-game/src/systems/quests/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/quests/bridges.rs @@ -681,6 +681,8 @@ impl crate::systems::economy::cash_shop::CashShopQuestHooks for QuestsForEconomy } /// Execute authored component NPC behavior after releasing the quest owner's lock. +/// Keep this on the deferred path: `with_quests` also drops ops before calling it, so +/// callback-bearing spawners can enter item scope -> spawn lock without character inversion. pub(crate) fn run_npc_component( server: &GameServer, player: &PlayerRef, diff --git a/rust/crates/aaemu-game/src/systems/services/commands/scripts/despawn.rs b/rust/crates/aaemu-game/src/systems/services/commands/scripts/despawn.rs index 68bab59890..043b0fc4e7 100644 --- a/rust/crates/aaemu-game/src/systems/services/commands/scripts/despawn.rs +++ b/rust/crates/aaemu-game/src/systems/services/commands/scripts/despawn.rs @@ -14,6 +14,7 @@ impl Despawn { /// `ObjectIdManager.Instance.ReleaseId(obj.ObjId); obj.Delete();` pub(crate) fn release_and_delete(server: &GameServer, obj: &WorldObject) { + let _items = server.systems.economy.operation_scope(); if let WorldObject::Npc(npc) = obj { // Deviation: an NPC that still has a queued respawn / corpse timer (a dead spawner NPC) // keeps its object id until the spawn manager's timers are done with it. Releasing it diff --git a/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs index 1b5f8a1d14..50c4fe1362 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs @@ -618,6 +618,276 @@ async fn persistent_batch_validation_and_stale_parent_have_no_world_side_effects assert!(manager.get_all_player_doodads().is_empty()); } +fn cargo_identity_data() -> GameData { + use crate::systems::npcs::doodad::templates::DoodadFunc; + let mut data = identity_data(); + data.items.templates.insert( + 29203, + ItemTemplate { + kind: TemplateKind::Backpack { backpack_type: 1 }, + ..ItemTemplate::plain(29203, 1) + }, + ); + for (group, kind, next) in [ + (8264, "DoodadFuncConsumeChanger", 8265), + (8265, "DoodadFuncRecoverItem", 8264), + ] { + data.systems.npcs.doodad.funcs_by_groups.insert( + group, + vec![DoodadFunc { + group_id: group, + func_type: kind.into(), + next_phase: next, + ..Default::default() + }], + ); + } + data +} + +fn original_pack(server: &GameServer, owner: &PlayerRef, slot: u8) -> u64 { + use crate::systems::economy::inventory::Inv; + let inventory = crate::models::character::Inventory::new( + owner.character_id, + 50, + 50, + &server.items, + &server.ids.container, + ); + owner.data().inventory = inventory; + let id = loop { + let id = u64::from(server.ids.item.get_next_id().unwrap()); + if server.items.item_by_id(id).is_none() { + break id; + } + }; + let pack = Item::create( + id, + server.game_data.items.template(29203).unwrap(), + 1, + 0, + 1, + &server.game_data.items, + 0, + ); + let container = Inv::of(owner).get(slot).unwrap(); + let position = if slot == slot_type::EQUIPMENT { + i32::from(crate::models::container::equip_slot::BACKPACK) + } else { + -1 + }; + container + .lock() + .unwrap() + .add_new_item(pack, position, &server.game_data.items) + .unwrap(); + id +} + +#[tokio::test] +async fn prefetched_loaded_rack_then_same_pack_recovery_refuses_same_item_replacement() { + use crate::systems::economy::bridges::EconomyForNpcs; + use crate::systems::economy::inventory::Inv; + use crate::systems::npcs::hooks::{CargoRecovery, EconomyBridge}; + use crate::systems::npcs::{doodad::db, spawn_manager::PersistentDoodads}; + let server = server_with(cargo_identity_data()); + install_memory_loader(&server); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let hull = root(&server, &owner, item_id, MERCHANT); + let rack = loaded_rack(&server, &hull); + { + let mut d = rack.data(); + d.item_id = 0; + d.item_template_id = 0; + d.func_group_id = 8264; + d.is_persistent = true; + d.parent_obj_id = hull.obj_id; + } + server + .systems + .npcs + .spawns + .get(0) + .unwrap() + .add_player_doodad(rack.clone()); + let pack_id = original_pack(&server, &owner, slot_type::EQUIPMENT); + let expected = server.items.item_by_id(pack_id).unwrap(); + let release = Arc::new(Semaphore::new(0)); + let entered = Arc::new(AtomicUsize::new(0)); + let (weak, loading_owner, loading_rack, permits, calls) = ( + Arc::downgrade(&server), + owner.clone(), + rack.clone(), + release.clone(), + entered.clone(), + ); + *server + .systems + .npcs + .spawns + .test_persistent_loader + .lock() + .unwrap() = Some(Arc::new(move |_, _| { + let server = weak.upgrade().unwrap(); + // Initial hull preflight saw an empty rack. SQL captures the loaded state while + // the same real pack is in System escrow, then pauses after preparing that row. + assert!(EconomyForNpcs.try_store_doodad_item( + &server, + &loading_owner, + &loading_rack, + &expected, + 1 + )); + loading_rack.data().func_group_id = 8265; + let row = db::snapshot(&server, &loading_rack).unwrap(); + assert_eq!(row.item_id, pack_id); + let prepared = PersistentDoodads::prepare(&server, vec![row]).unwrap(); + calls.fetch_add(1, Ordering::SeqCst); + let permits = permits.clone(); + Box::pin(async move { + permits.acquire_owned().await.unwrap().forget(); + Ok(prepared) + }) + })); + client.drain(); + let mut creation = Box::pin(summon(&server, &owner, item_id, MERCHANT_ITEM)); + assert!(poll!(creation.as_mut()).is_pending()); + assert_eq!(entered.load(Ordering::SeqCst), 1); + assert_eq!( + server.items.item_by_id(pack_id).unwrap().slot_type, + slot_type::SYSTEM + ); + assert!(matches!( + EconomyForNpcs.recover_doodad_cargo(&server, &owner, &rack), + CargoRecovery::Recovered + )); + rack.data().func_group_id = 8264; + assert_eq!( + Inv::of(&owner) + .equipped(crate::models::container::equip_slot::BACKPACK) + .unwrap() + .id, + pack_id + ); + let hull_before = hull.data().clone(); + let rack_before = rack.data().clone(); + let item_before = server.items.item_by_id(item_id).unwrap(); + let pack_before = server.items.item_by_id(pack_id).unwrap(); + release.add_permits(1); + assert!( + tokio::time::timeout(std::time::Duration::from_secs(5), creation) + .await + .unwrap() + .is_none() + ); + assert!(Arc::ptr_eq(&roots(&server, 1)[0], &hull)); + assert_eq!(*hull.data(), hull_before); + assert_eq!(*rack.data(), rack_before); + assert_eq!(server.items.item_by_id(item_id).unwrap(), item_before); + assert_eq!(server.items.item_by_id(pack_id).unwrap(), pack_before); + let occurrences: usize = server + .items + .all_containers() + .iter() + .map(|c| { + c.lock() + .unwrap() + .items + .iter() + .filter(|i| i.id == pack_id) + .count() + }) + .sum(); + assert_eq!(occurrences, 1); + assert_eq!(server.world.world(0).unwrap().all_doodads().len(), 1); + assert_eq!( + server + .systems + .npcs + .spawns + .get(0) + .unwrap() + .get_all_player_doodads() + .len(), + 1 + ); + assert!(!server.items.removed_items().contains(&pack_id)); + assert!(!ops(&client.drain()).contains(&sc::SCSlaveCreatedPacket)); +} + +#[tokio::test] +async fn different_inactive_saved_hull_restores_another_owners_system_cargo() { + use crate::systems::npcs::spawn_manager::PersistentDoodads; + let server = server_with(cargo_identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let active = root(&server, &owner, item_id, SHIP_HULL); + let contributor_client = TestClient::new(&server, 2, 2); + let contributor = spawn_player( + &server, + &contributor_client, + test_character(2, "Contributor", 100.0, 100.0), + PB, + ); + let pack_id = original_pack(&server, &contributor, slot_type::SYSTEM); + let mut row = saved_rack_row(777); + row.item_id = pack_id; + row.item_template_id = 29203; + { + let prepared = PersistentDoodads::prepare(&server, vec![row.clone()]).unwrap(); + let _items = server.systems.economy.operation_scope(); + assert!(prepared.validate_slave_cargo(&server, 777, None).is_ok()); + } + let target_item = loop { + let id = u64::from(server.ids.item.get_next_id().unwrap()); + if server.items.item_by_id(id).is_none() { + break id; + } + }; + second_item(&server, &owner, target_item, MERCHANT_ITEM); + server + .items + .update_item(target_item, |item| item.details.slave_db_id = 777) + .unwrap(); + install_memory_loader(&server); + let weak = Arc::downgrade(&server); + *server + .systems + .npcs + .spawns + .test_persistent_loader + .lock() + .unwrap() = Some(Arc::new(move |_, parent| { + assert_eq!(parent, 777); + let prepared = + PersistentDoodads::prepare(&weak.upgrade().unwrap(), vec![row.clone()]).unwrap(); + Box::pin(async move { Ok(prepared) }) + })); + let restored = tokio::time::timeout( + std::time::Duration::from_secs(5), + summon(&server, &owner, target_item, MERCHANT_ITEM), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(persistent_id(&restored), 777); + assert_eq!(restored.data().summoning_item_id, target_item); + assert!(!Arc::ptr_eq(&restored, &active)); + assert_eq!(roots(&server, 1).len(), 1); + assert!(Arc::ptr_eq(&roots(&server, 1)[0], &restored)); + let racks = server.world.world(0).unwrap().all_doodads(); + assert_eq!(racks.len(), 1); + assert_eq!(racks[0].data().item_id, pack_id); + assert_eq!(racks[0].data().parent_obj_id, restored.obj_id); + assert_eq!( + server.items.item_by_id(pack_id).unwrap().slot_type, + slot_type::SYSTEM + ); + assert_eq!(server.items.item_by_id(pack_id).unwrap().owner_id, 2); + assert!(!server.items.removed_items().contains(&pack_id)); +} + #[tokio::test] async fn merchant_loaded_refusal_preserves_hull_rider_gunner_and_item_identity() { let server = server_with(identity_data()); diff --git a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs index f811d35d4b..d2828bb3d1 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs @@ -2389,6 +2389,22 @@ async fn create_with_placement( return None; } } + if let Some(saved) = &loaded.saved { + let live_hull = prior.iter().map(|(_, hull)| hull).find(|hull| { + let h = hull.data(); + h.id == saved.id + && item + .as_ref() + .is_some_and(|item| h.summoning_item_id == item.id) + }); + if let Err(error) = loaded + .doodads + .validate_slave_cargo(server, saved.id, live_hull) + { + tracing::warn!("SlaveManager.Create cargo preflight: {error}"); + return None; + } + } // Commit the actual item update before altering the prior hull. A missing or moved // source (including an unlocked quest mutation) must fail at this boundary. let committed = if let (Some(owner), Some(item)) = (owner, &item) { From 99f4713b89bb637288b854a99ec042480b17b21a Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 19:20:10 -0400 Subject: [PATCH 56/66] test(testclient): propagate receive errors directly --- rust/crates/aaemu-testclient/src/control.rs | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/rust/crates/aaemu-testclient/src/control.rs b/rust/crates/aaemu-testclient/src/control.rs index 6950d3db11..f9faded4ac 100644 --- a/rust/crates/aaemu-testclient/src/control.rs +++ b/rust/crates/aaemu-testclient/src/control.rs @@ -1133,9 +1133,7 @@ mod tests { let (mut input, _lines, _terminal) = input_pair(); let action = async { loop { - if let Err(error) = game.recv_within(Duration::from_millis(5)).await { - return Err::(error); - } + game.recv_within(Duration::from_millis(5)).await?; } }; let done = tokio::time::timeout( @@ -1196,9 +1194,7 @@ mod tests { let action = async { let _ = started.send(()); loop { - if let Err(error) = game.recv_within(Duration::from_millis(10)).await { - return Err::(error); - } + game.recv_within(Duration::from_millis(10)).await?; } }; let done = drive(action, until, &rec, &mut report, &mut input) From ce4b860e9ea4a5d91ee029a0cda354b14d72bce8 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 19:40:33 -0400 Subject: [PATCH 57/66] test(vehicles): compare audit receipt values without allocations --- rust/crates/aaemu-game/PORTING.md | 34 +++++++++++++++ .../src/systems/vehicles/audit_tests.rs | 3 +- .../systems/vehicles/ship_identity_tests.rs | 2 +- rust/docs/audit-repair-status.json | 43 +++++++++++++++++-- 4 files changed, 76 insertions(+), 6 deletions(-) diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 035df89b62..d7e50d1020 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -402,6 +402,40 @@ Cross-subsystem: mates are despawned on dungeon entry and `PlayerCanEnter` check | `BaseUnit.GetDistanceTo` for shipyard targets (skill range check, `Skill.cs` `max_range`) | `systems/skills/geometry.rs` (`distance_to`), `systems/vehicles/shipyards.rs` (`shipyard_radius`) | deviation | **Deviation:** the C# measured skill range to the shipyard's center point (shipyard models are prefab models without an actor radius, so `ModelSize` was 0), which made the shipyard build skills (`min_range 0`, `max_range 4`) unusable anywhere but the exact center of a drydock ("Target is too far"). The Rust subtracts the shipyard template's `build_radius * Scale`, like the house `GardenRadius` rule. | | Mate / slave / transfer / shipyard C2G and G2C packets | `systems/vehicles/packets.rs` | done | 18 C->S, 16 S->C (byte-exact tests). `CSChangeSlaveTargetPacket` has no 1.2 opcode (0xfff). | | Hooks / physics | `systems/vehicles/{hooks,ship_physics}.rs` | done | `VehicleItemHooks` (`EndCraft`, economy). Ship physics and water call `systems::ai::physics` directly (`AddShip` / `RemoveShip`, helm request, driver seat, `GetWaterSurface` / `IsWater`); `ShipPhysicsHooks` (harpoon lines / tension / lifetime, `Throttle` / `Steering` after a move) and the radar ship lists are installed here. The npcs / social hooks call the mate / slave / dismount functions directly. | +#### Summon replacement and retained cargo (2026-10-25) + +Player summons use root-only owner lookup across worlds and serialize requests by +owner and persistent summon item. Session/departure generations and allocation +identity are checked again after loading. Saved hull, child and doodad rows load +before replacement; query failures, item-update failures, loaded-hull removal +refusal and invalid explicit placement stop without replacing the prior hull. +Invalid placement now refuses rather than falling back to another position. + +The final synchronous publication boundary coordinates ordinary item operations, +direct despawn and current-session identity. Loaded cargo receipts are checked +against the exact live hull/rack allocation and unique matching System escrow +before metadata changes or deletion. This rejects a stale loaded row fetched +before its original pack was recovered. Different inactive saved hulls can still +restore legitimate cargo belonging to another player. The existing 600-second +offline retention and delayed portal rendering remain intentional. + +The per-server item outer scope is thread-bound and reentrant; the inner economy +ops mutex remains nonreentrant. Callback-bearing paths acquire the outer scope +before existing auction/housing/spawn locks; callbacks retain their normal +placement outside ops/object guards. No synchronous guard spans an await. +Guardless quest item operations and direct writes bypassing coordinated APIs +remain explicit limits, rather than a claim of global lock freedom. + +The read-only `/slave audit` command reports registered and retained allocations, +pending task leases, item identities and rack observations with bounded replies. +It explicitly returns `consistent:false` and `authority_consistent:false`: queue, +HP, world-removal and temporal phase/transform observations do not share a global +snapshot boundary. Normalized, filtered headless control captures supplement these +observations; they do not establish native UI behavior or original compressed wire +bytes. Deterministic flow tests cover the concurrency cases separately. The +combined source has passed independent reviews and all-target compilation; +combined executable tests, final lane CI and live acceptance remain pending. + ### systems::services | Area (C#) | Rust | Status | Notes | diff --git a/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs index bd172bf12c..5075d9de61 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs @@ -592,7 +592,8 @@ fn reassemble(lines: &[String]) -> Option { return None; } let value: Value = serde_json::from_slice(&bytes).ok()?; - if value["nonce"] != end[1] || value["sample_sequence"].to_string() != end[2] { + let sequence: u64 = serde_json::from_str(end[2]).ok()?; + if value["nonce"] != end[1] || value["sample_sequence"].as_u64()? != sequence { return None; } Some(value) diff --git a/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs index 50c4fe1362..937623c934 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs @@ -672,7 +672,7 @@ fn original_pack(server: &GameServer, owner: &PlayerRef, slot: u8) -> u64 { ); let container = Inv::of(owner).get(slot).unwrap(); let position = if slot == slot_type::EQUIPMENT { - i32::from(crate::models::container::equip_slot::BACKPACK) + crate::models::container::equip_slot::BACKPACK } else { -1 }; diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json index 4b6e472fb8..ecc0f4a38c 100644 --- a/rust/docs/audit-repair-status.json +++ b/rust/docs/audit-repair-status.json @@ -386,9 +386,10 @@ }, { "id": "trade-ship-live-root-identity-after-reconnect", - "status": "implementing", + "status": "source_reviewed_merged_pending_execution", "owner": "audit-ship-session", - "note": "Source proves failed loaded-hull deletion can be ignored by summon; root lookup includes child cannons. Async session/identity invariants under repair." + "note": "Three source review rounds clean after item publication, query-error/orphan, callback spawn-lock ordering and stale cargo receipt fixes. Combined compilation passes; new executable tests and live acceptance pending. Intentional600s retention remains. Guardless/direct-write limitations explicit.", + "commit": "54f98af143f8458175dc76ffe9afad132ec3b680" }, { "id": "lane-allocation-concurrency", @@ -396,6 +397,18 @@ "owner": "audit-lane-lock", "note": "15 isolated root Python tests passed; original allocator fails concurrent allocation. Two real concurrent probe lanes received distinct prefixes and were removed. Windows/Linux workflow now runs the suite.", "commit": "090f515b6" + }, + { + "id": "headless-control-reconnect-test-interface", + "status": "source_reviewed_merged_pending_execution", + "commit": "0d8e410d3dc20d88dce2b593c3fbdc7672897cb1", + "note": "Three source review rounds clean; bounded filtered/normalized events, exact character reconnect and socket/deadline handling. Executable validation pending." + }, + { + "id": "ship-identity-observational-diagnostics", + "status": "source_reviewed_merged_pending_execution", + "commit": "6a406e5da2d319bc61cc073e761d4d3c08a005d9", + "note": "Source review findings closed; both consistency flags remain false. Supporting observations only, not a globally atomic authority proof." } ], "recent_validation": { @@ -412,8 +425,8 @@ "result": "held_at_memory_reserve_before_completion", "minimum_free_gib": 5.938747406005859 }, - "current_full_lane_ci": "pending_after_remaining_source_integration", - "current_live": "pending", + "current_full_lane_ci": "pending_after_focused_checks", + "current_live": "pending_source_gate_and_reviewed_release", "game_unit_tests": { "head": "7ac9af6eb3b7d0b511310d7865dc10a1f6bf2712", "passed": 2833, @@ -463,6 +476,28 @@ "compact_checks": 10, "private_mysql_checks": 6, "scope": "Explicit ignored tests; private 3317 lane_audit_final_game uses connection-local temporary tables. Includes Merchant twenty-rack cycles and both cargo persistence/allocator-reuse fixtures." + }, + "combined_compilation": { + "head": "243953bdab1c077a93e02e71948f24ac03d5744a", + "result": "passed_game_and_testclient_all_targets", + "native_exit": 0, + "minimum_free_gib": 9.208076477050781, + "elapsed_seconds": 133.625 + }, + "combined_clippy": { + "head": "243953bdab1c077a93e02e71948f24ac03d5744a", + "result": "failed_two_test_helper_lints", + "findings": [ + "audit receipt comparison allocation", + "redundant i32 backpack-index conversion" + ], + "correction": "corrected in current candidate; rerun pending" + }, + "combined_seam_review": { + "head": "243953bdab1c077a93e02e71948f24ac03d5744a", + "tree": "742610fc88eec28566af33df34aae9086870d2c2", + "result": "no_new_concrete_P1_P2_within_declared_source_scope", + "execution": "none" } } } From f53dd86cc7558ff9a4463bc26c17bbf82adc9665 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 19:52:44 -0400 Subject: [PATCH 58/66] test(game): exercise quest spawning and stabilize damage fixtures --- .../systems/economy/craft_publication_tests.rs | 11 ++++++++--- .../src/systems/skills/modifier_flow_tests.rs | 15 ++++++++++++--- 2 files changed, 20 insertions(+), 6 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs b/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs index 3da92fbea7..60794c1c4f 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs @@ -31,6 +31,9 @@ impl CraftHooks for CraftQuest { // already own spawn_lock here and the following quest callback would deadlock. server.systems.economy.wait_until_operation_blocked(); events::on_craft(server, player, craft_id); + // Run the queued component while this callback still owns the outer item + // scope, so the actual quest-driven spawn contends with expired cleanup. + server.systems.quests.run_queued_evaluations(server); } } @@ -62,8 +65,8 @@ async fn expired_source_item_doodad_contends_with_craft_quest_npc_spawn() { }); for (id, step, spawner) in [ (10, kind::START, 0), - (11, kind::PROGRESS, 0), - (12, kind::READY, 10), + (11, kind::PROGRESS, 10), + (12, kind::READY, 0), ] { q.add_component(QuestComponentTemplate { id, @@ -156,10 +159,11 @@ async fn expired_source_item_doodad_contends_with_craft_quest_npc_spawn() { NpcSpawnerDef { base, count: 1, - npc_spawner_ids: Vec::new(), + npc_spawner_ids: vec![10], }, ) .unwrap(); + assert_eq!(manager.get_npc_spawner(10).len(), 1); events::add_quest(&server, &player, 1, false); server.systems.quests.run_queued_evaluations(&server); assert_eq!(player.data().quests.active[0].step, kind::PROGRESS); @@ -237,6 +241,7 @@ async fn expired_source_item_doodad_contends_with_craft_quest_npc_spawn() { 1 ); assert_eq!(player.data().quests.active[0].step, kind::READY); + assert_eq!(player.data().quests.active[0].objectives[0], 1); let npcs = world.all_npcs(); assert_eq!(npcs.len(), 1); assert_eq!(npcs[0].data().unit.template_id, 500); diff --git a/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs b/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs index 3d5464fef2..7f81fcec1f 100644 --- a/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs @@ -427,7 +427,9 @@ async fn modifier_existing_skill_damage_is_still_applied_once() { add_boost( &mut data, 901, - vec![bonus(UnitAttribute::MainhandDps, 100_000)], + // Keep both f32 weapon-damage endpoints exact before floor/ceil, so + // random sampling cannot obscure whether the modifier was applied once. + vec![bonus(UnitAttribute::MainhandDps, 80_000)], ); let mut damage = skills::tests::damage_effect(1, 0); damage.use_fixed_damage = false; @@ -449,11 +451,18 @@ async fn modifier_existing_skill_damage_is_still_applied_once() { ); client.drain(); cast(&server, &player, npc.obj_id, &skill); - assert_eq!(effects(&mut client), vec![(npc.obj_id, 100)]); + assert_eq!(effects(&mut client), vec![(npc.obj_id, 80)]); + assert_eq!(npc.data().unit.hp, 920); apply_boost(&server, &player, 900); client.drain(); cast(&server, &player, npc.obj_id, &skill); - assert_eq!(effects(&mut client), vec![(npc.obj_id, 110)]); + assert_eq!(effects(&mut client), vec![(npc.obj_id, 88)]); + assert_eq!(npc.data().unit.hp, 832); + skills::buffs::remove_buff(&server, &WorldObject::from(&player), 900); + client.drain(); + cast(&server, &player, npc.obj_id, &skill); + assert_eq!(effects(&mut client), vec![(npc.obj_id, 80)]); + assert_eq!(npc.data().unit.hp, 752); } #[tokio::test] From ec6114da3d7dc0960dba2ef7fdc0fb6491896c6d Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 20:05:12 -0400 Subject: [PATCH 59/66] test(testclient): account for native position quantization --- rust/crates/aaemu-testclient/src/game.rs | 3 ++- rust/crates/aaemu-testclient/src/scenario.rs | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/rust/crates/aaemu-testclient/src/game.rs b/rust/crates/aaemu-testclient/src/game.rs index 197aa5b647..0986fd294d 100644 --- a/rust/crates/aaemu-testclient/src/game.rs +++ b/rust/crates/aaemu-testclient/src/game.rs @@ -1596,7 +1596,8 @@ mod observed_position_tests { body: body.as_bytes().to_vec(), }) .unwrap(); - assert_eq!(state.observed_self_pos, Some((10.0, 20.0, 30.0))); + // The native position codec quantizes the authored Z=30 to 29.9995. + assert_eq!(state.observed_self_pos, Some((10.0, 20.0, 29.9995))); assert_eq!(state.self_pos, (900.0, 900.0, 900.0)); assert_eq!(state.observation_seq, 1); } diff --git a/rust/crates/aaemu-testclient/src/scenario.rs b/rust/crates/aaemu-testclient/src/scenario.rs index 892fd66e9d..ac2768a7f8 100644 --- a/rust/crates/aaemu-testclient/src/scenario.rs +++ b/rust/crates/aaemu-testclient/src/scenario.rs @@ -2442,7 +2442,8 @@ mod control_session_tests { .unwrap(); assert!(sent > 1); assert_eq!(acks, [cs::CSTeleportEndedPacket, cs::CSMoveUnitPacket]); - assert_eq!(game.state.observed_self_pos, Some((10.0, 20.0, 30.0))); + // Assert the server's decoded position, including native Z quantization. + assert_eq!(game.state.observed_self_pos, Some((10.0, 20.0, 29.9995))); game.disconnect_hard().await; } From 578a6a7e68a8ea663eafdb5487f5f8d8f2a09180 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 20:11:21 -0400 Subject: [PATCH 60/66] fix(testclient): check deadlines before polling control work Guard every action poll and input parse with synchronous EOF and deadline checks. Recompute output deadlines when starting a write and retain all earlier queued and in-flight budgets. Add deterministic ready-action, EOF, output-ack, and serve regressions without changing protocol or timeout reserves. --- rust/crates/aaemu-testclient/src/control.rs | 241 ++++++++++++++++++-- 1 file changed, 226 insertions(+), 15 deletions(-) diff --git a/rust/crates/aaemu-testclient/src/control.rs b/rust/crates/aaemu-testclient/src/control.rs index f9faded4ac..3efc632379 100644 --- a/rust/crates/aaemu-testclient/src/control.rs +++ b/rust/crates/aaemu-testclient/src/control.rs @@ -330,6 +330,31 @@ async fn termination(terminal: &mut watch::Receiver>) -> &' } } +/// Timer futures provide wakeups, but an already-expired timer can initially poll Pending. +/// Check synchronously before polling gameplay or consuming another command. EOF retains +/// priority, including a closed input worker that has not published a terminal value. +fn check_stop( + terminal: &watch::Receiver>, + until: Instant, + output_until: Option, + deadline_reason: &'static str, +) -> anyhow::Result> { + if let Some(reason) = *terminal.borrow() { + return Ok(Some(reason)); + } + if terminal.has_changed().is_err() { + return Ok(Some("eof")); + } + let now = Instant::now(); + if now >= until { + return Ok(Some(deadline_reason)); + } + if let Some(until) = output_until { + ensure!(now < until, "stdout budget exhausted"); + } + Ok(None) +} + struct Output { bytes: Vec, ack: oneshot::Sender>, @@ -471,6 +496,9 @@ impl Reporter { /// Every frame retains the shared action budget at enqueue time; acknowledgments cannot /// restart a command's deadline. A one-second stalled-writer ceiling is additional. async fn progress(&mut self) -> anyhow::Result<()> { + if let Some(until) = self.next_deadline() { + ensure!(Instant::now() < until, "stdout budget exhausted"); + } if self.flight.is_none() { let Some(front) = self.queue.front() else { return std::future::pending().await; @@ -484,6 +512,7 @@ impl Reporter { .await .context("stdout budget")? .context("stdout worker closed")?; + ensure!(Instant::now() < until, "stdout budget exhausted"); let queued = self.queue.pop_front().context("stdout queue empty")?; let len = queued.bytes.len(); let (ack, completed) = oneshot::channel(); @@ -496,6 +525,9 @@ impl Reporter { until, len, }); + // Starting a write can introduce an earlier stalled-writer ceiling. Return + // control so drive/serve recompute it before any further action poll. + return Ok(()); } let flight = self.flight.as_mut().context("stdout ack missing")?; ensure!(Instant::now() < flight.until, "stdout budget exhausted"); @@ -503,6 +535,7 @@ impl Reporter { .await .context("stdout budget")? .context("stdout worker stopped")??; + ensure!(Instant::now() < flight.until, "stdout budget exhausted"); let flight = self.flight.take().context("stdout ack missing")?; self.queued_bytes -= flight.len; Ok(()) @@ -667,17 +700,29 @@ async fn drive( input: &mut Input, ) -> anyhow::Result { tokio::pin!(future); + let until = until.min(report.deadline); + let terminal = input.terminal.clone(); let mut tick = tokio::time::interval(Duration::from_millis(20)); loop { - let output_pending = report.has_work(); - let output_until = report.next_deadline().unwrap_or(report.deadline); + let output_until = report.next_deadline(); + if let Some(reason) = check_stop(&terminal, until, output_until, "command_deadline")? { + return Ok(Completion::Stopped(reason)); + } tokio::select! { biased; reason = termination(&mut input.terminal) => return Ok(Completion::Stopped(reason)), _ = tokio::time::sleep_until(until) => return Ok(Completion::Stopped("command_deadline")), - _ = tokio::time::sleep_until(output_until), if output_pending => bail!("stdout budget exhausted"), - result = &mut future => return Ok(Completion::Done(result)), - result = report.progress(), if output_pending => { result?; }, + _ = tokio::time::sleep_until(output_until.unwrap_or(until)), if output_until.is_some() => bail!("stdout budget exhausted"), + result = std::future::poll_fn(|cx| { + // A select can remain suspended across many executor polls. The loop + // check alone does not guard a ready action on a later wakeup. + match check_stop(&terminal, until, output_until, "command_deadline") { + Ok(Some(reason)) => std::task::Poll::Ready(Ok(Completion::Stopped(reason))), + Err(error) => std::task::Poll::Ready(Err(error)), + Ok(None) => future.as_mut().poll(cx).map(|result| Ok(Completion::Done(result))), + } + }) => return result, + result = report.progress(), if output_until.is_some() => { result?; }, _ = tick.tick() => report.events(rec)?, } } @@ -693,12 +738,14 @@ async fn serve( let mut next_poll = Instant::now(); report.write(json!({"type": "capabilities", "capabilities": describe()}))?; loop { - if let Some(reason) = *input.terminal.borrow() { + if let Some(reason) = check_stop( + &input.terminal, + report.deadline, + report.next_deadline(), + "deadline", + )? { return Ok(reason); } - if Instant::now() >= report.deadline { - return Ok("deadline"); - } // Poll receive/keep-alive even if stdin continuously supplies commands. if Instant::now() >= next_poll { let rec = controller.rec.clone(); @@ -718,19 +765,28 @@ async fn serve( report.events(&rec)?; next_poll = Instant::now() + Duration::from_millis(50); } - let output_pending = report.has_work(); - let output_until = report.next_deadline().unwrap_or(report.deadline); + let output_until = report.next_deadline(); + if let Some(reason) = + check_stop(&input.terminal, report.deadline, output_until, "deadline")? + { + return Ok(reason); + } let line = tokio::select! { biased; reason = termination(&mut input.terminal) => return Ok(reason), _ = tokio::time::sleep_until(report.deadline) => return Ok("deadline"), - _ = tokio::time::sleep_until(output_until), if output_pending => bail!("stdout budget exhausted"), + _ = tokio::time::sleep_until(output_until.unwrap_or(report.deadline)), if output_until.is_some() => bail!("stdout budget exhausted"), _ = tokio::time::sleep_until(next_poll) => continue, - result = report.progress(), if output_pending => { result?; continue; }, + result = report.progress(), if output_until.is_some() => { result?; continue; }, line = input.lines.recv() => match line { Some(line) => line, None => return Ok("eof") }, }; - if Instant::now() >= report.deadline { - return Ok("deadline"); + if let Some(reason) = check_stop( + &input.terminal, + report.deadline, + report.next_deadline(), + "deadline", + )? { + return Ok(reason); } count += 1; if count > MAX_COMMANDS { @@ -1071,6 +1127,63 @@ mod tests { assert!(matches!(result, Completion::Stopped("command_deadline"))); assert!(released.load(Ordering::SeqCst)); } + + #[tokio::test] + async fn already_expired_command_or_global_deadline_never_polls_ready_action() { + for global_expired in [false, true] { + let rec = Recorder::new(false); + let (output, _consumer) = mpsc::channel(1); + let expired = Instant::now(); + let later = expired + CONNECT_TIMEOUT; + let (command_until, global_until) = if global_expired { + (later, expired) + } else { + (expired, later) + }; + let mut report = Reporter::new(output, global_until); + let (mut input, _lines, _terminal) = input_pair(); + let polled = AtomicBool::new(false); + let action = async { + polled.store(true, Ordering::SeqCst); + Ok(Value::Null) + }; + let result = drive(action, command_until, &rec, &mut report, &mut input) + .await + .unwrap(); + assert!(matches!(result, Completion::Stopped("command_deadline"))); + assert!( + !polled.load(Ordering::SeqCst), + "an already-expired ceiling allowed ready gameplay" + ); + } + } + + #[tokio::test] + async fn eof_precedes_expired_budgets_without_polling_ready_action() { + for published in [false, true] { + let rec = Recorder::new(false); + let (output, _consumer) = mpsc::channel(1); + let until = Instant::now(); + let mut report = Reporter::new(output, until); + report.write(json!({"type":"capabilities"})).unwrap(); + let (mut input, _lines, terminal) = input_pair(); + if published { + terminal.send_replace(Some("eof")); + } + drop(terminal); + let polled = AtomicBool::new(false); + let action = async { + polled.store(true, Ordering::SeqCst); + Ok(Value::Null) + }; + let result = drive(action, until, &rec, &mut report, &mut input) + .await + .unwrap(); + assert!(matches!(result, Completion::Stopped("eof"))); + assert!(!polled.load(Ordering::SeqCst)); + } + } + fn live_recorder() -> Recorder { let rec = Recorder::incremental_game_to(std::io::sink()); rec.control_game_ready(true); @@ -1257,6 +1370,104 @@ mod tests { "expired output budget allowed later gameplay" ); } + + #[tokio::test] + async fn expired_output_budget_blocks_ready_action_with_an_ack_in_flight() { + for expired_flight in [false, true] { + let rec = live_recorder(); + let (output, mut consumer) = mpsc::channel(1); + let until = Instant::now() + CONNECT_TIMEOUT; + let mut report = Reporter::new(output, until); + report.write(json!({"type":"capabilities"})).unwrap(); + // Start a real output write, but withhold its acknowledgment. No sleep or + // timer-driver behavior is needed to inject an expired queue/ack budget. + report.progress().await.unwrap(); + let unacknowledged = consumer.try_recv().unwrap(); + assert!(report.flight.is_some()); + if expired_flight { + report.flight.as_mut().unwrap().until = Instant::now(); + } else { + report.budget = Instant::now(); + } + report + .response(Some(RequestId::Number(1)), Ok(Value::Null)) + .unwrap(); + let (mut input, _lines, _terminal) = input_pair(); + let polled = AtomicBool::new(false); + let action = async { + polled.store(true, Ordering::SeqCst); + Ok(Value::Null) + }; + let result = drive(action, until, &rec, &mut report, &mut input).await; + assert!(result.is_err()); + assert!(!polled.load(Ordering::SeqCst)); + // Terminal draining must also honor the earlier queued budget while a + // longer-lived ack is in flight, rather than consuming that ack first. + assert!(report.progress().await.is_err()); + assert!(consumer.try_recv().is_err()); + drop(unacknowledged); + } + } + + #[tokio::test] + async fn serve_checks_expired_budgets_before_consuming_queued_gameplay() { + for (expired_flight, eof) in [(false, false), (true, false), (false, true)] { + let rec = live_recorder(); + let cfg = serde_json::from_value(json!({"login":"127.0.0.1:1","user":"fixture", + "password":"fixture-only","character":"Owner"})) + .unwrap(); + // No sockets: any attempted rawcs would produce a session error. Leaving + // the request queued proves serve stops before parsing or executing it. + let mut controller = Controller { + cfg, + rec, + session: None, + handshaken: true, + character_id: Some(42), + generation: 1, + started: Instant::now(), + clock: 40000, + }; + let until = Instant::now() + CONNECT_TIMEOUT; + let (output, mut consumer) = mpsc::channel(1); + let mut report = Reporter::new(output, until); + report.write(json!({"type":"capabilities"})).unwrap(); + let unacknowledged = if expired_flight { + report.progress().await.unwrap(); + report.flight.as_mut().unwrap().until = Instant::now(); + Some(consumer.try_recv().unwrap()) + } else { + None + }; + report.budget = if expired_flight { + until + } else { + Instant::now() + }; + report + .response(Some(RequestId::Number(1)), Ok(Value::Null)) + .unwrap(); + let (mut input, lines, terminal) = input_pair(); + let rawcs = request("rawcs", json!({"opcode":58,"body_hex":"abcd"})); + lines.try_send(rawcs.clone()).unwrap(); + if eof { + terminal.send_replace(Some("eof")); + } + let queued = report.queue.len(); + let result = serve(&mut controller, &mut report, &mut input).await; + if eof { + assert_eq!(result.unwrap(), "eof"); + } else { + assert!(result.is_err()); + } + assert_eq!(input.lines.try_recv().unwrap(), rawcs); + assert_eq!(report.queue.len(), queued + 1); // Only serve's capabilities. + assert!(consumer.try_recv().is_err()); + assert!(controller.session.is_none()); + drop(unacknowledged); + } + } + async fn timeout_serve_case(end_with_eof: bool) { use aaemu_testclient::game::GameClient; use aaemu_testclient::login::LoginClient; From a22e211982ae3faa8696ef045552abe3155f0de0 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 20:13:03 -0400 Subject: [PATCH 61/66] test(economy): reserve object identities in craft contention fixture --- .../systems/economy/craft_publication_tests.rs | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs b/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs index 60794c1c4f..9912c6e139 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs @@ -143,7 +143,8 @@ async fn expired_source_item_doodad_contends_with_craft_quest_npc_spawn() { let client = TestClient::new(&server, 1, 1001); let mut character = test_character(1, "Crafter", 100.0, 100.0); character.inventory = Inventory::new(1, 50, 50, &server.items, &server.ids.container); - let player = spawn_player(&server, &client, character, 0x100); + let player_obj_id = server.ids.object.get_next_id().unwrap(); + let player = spawn_player(&server, &client, character, player_obj_id); let world = server.world.world(0).unwrap(); let manager = server.systems.npcs.spawns.get_or_create(&world); let mut base = SpawnerBase { @@ -195,6 +196,10 @@ async fn expired_source_item_doodad_contends_with_craft_quest_npc_spawn() { doodad.item_template_id = SOURCE; let doodad = Entity::new(server.ids.object.get_next_id().unwrap(), doodad); world.spawn(&doodad, &server.view_ctx()); + assert_ne!(doodad.obj_id, player.obj_id); + assert!(world + .doodad(doodad.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, &doodad))); manager.add_player_doodad(doodad.clone()); manager.add_despawn( &server, @@ -246,7 +251,16 @@ async fn expired_source_item_doodad_contends_with_craft_quest_npc_spawn() { assert_eq!(npcs.len(), 1); assert_eq!(npcs[0].data().unit.template_id, 500); assert!(world.doodad(doodad.obj_id).is_none()); + assert!(world.object(doodad.obj_id).is_none()); assert!(doodad.data().phase.deleted); + assert!(!manager + .get_all_player_doodads() + .iter() + .any(|live| Arc::ptr_eq(live, &doodad))); + assert!(!manager.has_pending_timers(doodad.obj_id)); + assert!(world + .object(player.obj_id) + .is_some_and(|live| live.same(&WorldObject::from(&player)))); assert!(server.items.item_by_id(source_id).is_none()); assert!(server.items.removed_items().contains(&source_id)); } From 296de984e429928df00bf7fd504a06967a708a1b Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 20:19:08 -0400 Subject: [PATCH 62/66] docs: record verified control tests and remaining acceptance gates --- rust/crates/aaemu-game/PORTING.md | 7 ++++++- rust/docs/audit-repair-status.json | 29 ++++++++++++++++++----------- 2 files changed, 24 insertions(+), 12 deletions(-) diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index d7e50d1020..e3bfb4229c 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -434,7 +434,12 @@ snapshot boundary. Normalized, filtered headless control captures supplement the observations; they do not establish native UI behavior or original compressed wire bytes. Deterministic flow tests cover the concurrency cases separately. The combined source has passed independent reviews and all-target compilation; -combined executable tests, final lane CI and live acceptance remain pending. +all 57 Testclient library and 16 control/config tests pass at `96a67a5a7`. +These include literal native decoding, filtered compressed batches, real loopback +socket closure and timeout completion. Synchronous checks reject expired output, +command and global budgets before polling gameplay: an already-expired Tokio +timer alone can initially return Pending. Final combined Game tests, lane CI and +live acceptance remain pending. ### systems::services diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json index ecc0f4a38c..7b9dc22759 100644 --- a/rust/docs/audit-repair-status.json +++ b/rust/docs/audit-repair-status.json @@ -381,7 +381,7 @@ "id": "trade-ship-cargo-reference-atomicity", "status": "unit_and_data_passed_full_gate_pending", "owner": "audit-tradeship", - "note": "Reviewed cargo source8c plus root fixture-ID correction7ac pass game unit suite, native Merchant all20rack cycles, private MySQL saved-alias and recycled-GUID cases. Reconnect identity repair is separate and still under review. Conservative cargo/container retention and reconciliation/GC limits remain.", + "note": "Reviewed cargo source8c plus root fixture-ID correction7ac pass game unit suite, native Merchant all20rack cycles, private MySQL saved-alias and recycled-GUID cases. Reconnect identity source review is clean; final combined execution and live acceptance remain pending. Conservative cargo/container retention and reconciliation/GC limits remain.", "commit": "8c2e977b5ba6b7660e4739964465e0b1e97b9d7b" }, { @@ -400,9 +400,9 @@ }, { "id": "headless-control-reconnect-test-interface", - "status": "source_reviewed_merged_pending_execution", - "commit": "0d8e410d3dc20d88dce2b593c3fbdc7672897cb1", - "note": "Three source review rounds clean; bounded filtered/normalized events, exact character reconnect and socket/deadline handling. Executable validation pending." + "status": "source_reviewed_package_tests_passed_final_gate_live_pending", + "commit": "578a6a7e68a8ea663eafdb5487f5f8d8f2a09180", + "note": "Fourth source review clean after an executed regression exposed expired Tokio timer first-poll behavior. Synchronous guards preserve EOF priority and reject expired command/global/output budgets before action polling. At96a67a5, all57 library and16 control/config tests pass, including real loopback hard-close and timeout flows. Final lane CI and live acceptance remain pending; captures are normalized and filtered." }, { "id": "ship-identity-observational-diagnostics", @@ -485,13 +485,20 @@ "elapsed_seconds": 133.625 }, "combined_clippy": { - "head": "243953bdab1c077a93e02e71948f24ac03d5744a", - "result": "failed_two_test_helper_lints", - "findings": [ - "audit receipt comparison allocation", - "redundant i32 backpack-index conversion" - ], - "correction": "corrected in current candidate; rerun pending" + "head": "ce4b860e9ea4a5d91ee029a0cda354b14d72bce8", + "result": "passed_game_and_testclient_all_targets_D_warnings", + "native_exit": 0, + "minimum_free_gib": 6.0239105224609375, + "elapsed_seconds": 109.36 + }, + "testclient_package": { + "head": "96a67a5a7a31a90ea66fdf42deecdbd42885fdb0", + "library_passed": 57, + "binary_passed": 16, + "failed": 0, + "native_exit": 0, + "minimum_free_gib": 10.375419616699219, + "source_unchanged": true }, "combined_seam_review": { "head": "243953bdab1c077a93e02e71948f24ac03d5744a", From e54757453f35dd373822ec053beec216a2292676 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 20:25:48 -0400 Subject: [PATCH 63/66] test(economy): retain spawn manager for cleanup assertions --- .../aaemu-game/src/systems/economy/craft_publication_tests.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs b/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs index 9912c6e139..ae947f131d 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs @@ -221,10 +221,11 @@ async fn expired_source_item_doodad_contends_with_craft_quest_npc_spawn() { let (craft_done, craft_result) = mpsc::channel(); let runtime = tokio::runtime::Handle::current(); let (tick_server, tick_runtime) = (server.clone(), runtime.clone()); + let tick_manager = manager.clone(); let tick = std::thread::spawn(move || { let _runtime = tick_runtime.enter(); ready.recv_timeout(Duration::from_secs(5)).unwrap(); - manager.check_respawns_tick(&tick_server); + tick_manager.check_respawns_tick(&tick_server); tick_done.send(()).unwrap(); }); let (craft_server, crafter) = (server.clone(), player.clone()); From 8aca3ea39459a5c814659b94815e43ffc78b8852 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 21:09:17 -0400 Subject: [PATCH 64/66] test(vehicles): match signed persisted doodad phases --- .../aaemu-game/src/systems/vehicles/ship_identity_tests.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs index 937623c934..97d2c24de2 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs @@ -1474,7 +1474,7 @@ async fn private_mysql_ship_save_fence_query_failure_retry_and_restart() { .flush() .await .unwrap(); - let rows_before_failed_racks: Vec<(u32, u32, u64)> = + let rows_before_failed_racks: Vec<(u32, i32, u64)> = sqlx::query_as("SELECT id, current_phase_id, item_id FROM doodads ORDER BY id") .fetch_all(&pool) .await @@ -1504,7 +1504,7 @@ async fn private_mysql_ship_save_fence_query_failure_retry_and_restart() { rack_count, 1, "a failed rack query must not seed default persistent rows" ); - let rows_after_failed_racks: Vec<(u32, u32, u64)> = + let rows_after_failed_racks: Vec<(u32, i32, u64)> = sqlx::query_as("SELECT id, current_phase_id, item_id FROM doodads ORDER BY id") .fetch_all(&pool) .await From 198b7d4821df6d930c14c8a5d38c64846a43efe1 Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Sun, 25 Oct 2026 21:41:12 -0400 Subject: [PATCH 65/66] test(testclient): make ambient teleport fixture deterministic --- rust/crates/aaemu-testclient/src/scenario.rs | 62 +++++++++++++++----- 1 file changed, 48 insertions(+), 14 deletions(-) diff --git a/rust/crates/aaemu-testclient/src/scenario.rs b/rust/crates/aaemu-testclient/src/scenario.rs index ac2768a7f8..f0c3b4fba0 100644 --- a/rust/crates/aaemu-testclient/src/scenario.rs +++ b/rust/crates/aaemu-testclient/src/scenario.rs @@ -2384,6 +2384,8 @@ mod control_session_tests { #[tokio::test] async fn teleport_completes_under_continuous_ambient_traffic() { + use crate::record::{Channel, Dir}; + let (io, peer) = tokio::io::duplex(64 * 1024); let rec = Recorder::new(true); let mut game = GameClient::from_io(io, rec.clone()); @@ -2405,26 +2407,42 @@ mod control_session_tests { peer.send(frame(sc::SCTeleportUnitPacket, teleport.as_bytes())) .await .unwrap(); - let mut ambient = tokio::time::interval(Duration::from_millis(1)); + let ambient = frame(sc::SCErrorMsgPacket, &[7, 0]); let mut sent = 0; + // Guarantee traffic after the teleport without depending on timer resolution. + for _ in 0..2 { + peer.send(ambient.clone()).await.unwrap(); + sent += 1; + } + let (mut writer, mut reader) = peer.split(); let mut acks = Vec::new(); let mut stop_requested = false; - loop { - if stop_requested && acks.len() == 2 { - return (sent, acks); - } - tokio::select! { - _ = &mut stopped, if !stop_requested => stop_requested=true, - _ = ambient.tick() => { - peer.send(frame(sc::SCErrorMsgPacket, &[7,0])).await.unwrap(); + { + // Keep a pending send alive across ACKs; backpressure must not block reads/stop. + let sending = async { + loop { + writer.send(ambient.clone()).await.unwrap(); sent += 1; - }, - incoming = peer.next() => { - let bytes = incoming.unwrap().unwrap(); - acks.push(u16::from_le_bytes([bytes[4], bytes[5]])); - }, + tokio::task::yield_now().await; + } + }; + tokio::pin!(sending); + loop { + if stop_requested && acks.len() == 2 { + break; + } + tokio::select! { + biased; + _ = &mut stopped, if !stop_requested => stop_requested = true, + incoming = reader.next() => { + let bytes = incoming.unwrap().unwrap(); + acks.push(u16::from_le_bytes([bytes[4], bytes[5]])); + }, + _ = &mut sending => unreachable!("ambient sender runs until stopped"), + } } } + (sent, acks) }); let until = tokio::time::Instant::now() + Duration::from_secs(5); tokio::time::timeout( @@ -2434,6 +2452,22 @@ mod control_session_tests { .await .unwrap() .unwrap(); + assert!( + rec.events() + .iter() + .filter(|event| { + event.channel == Channel::Game + && event.dir == Dir::S2C + && event.level == crate::game::LEVEL_GAME + }) + .skip_while(|event| event.opcode != sc::SCTeleportUnitPacket) + .skip(1) + .filter(|event| { + event.opcode == sc::SCErrorMsgPacket && event.body_bytes() == [7, 0] + }) + .count() + >= 2 + ); // The fixture keeps draining acknowledgments after this stop signal. let _ = stop.send(()); let (sent, acks) = tokio::time::timeout(Duration::from_secs(1), peer) From 87be9290006c75bd414c38474f7506c5c1d66d5a Mon Sep 17 00:00:00 2001 From: Nick Messer Date: Mon, 26 Oct 2026 06:37:44 -0400 Subject: [PATCH 66/66] docs: record qualified Merchant cargo validation --- rust/crates/aaemu-game/PORTING.md | 23 ++++- rust/docs/audit-repair-status.json | 153 ++++++++++++++++++++++++----- 2 files changed, 150 insertions(+), 26 deletions(-) diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index e3bfb4229c..9ec47922e9 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -309,10 +309,25 @@ items. Metadata matching does not establish allocation generation. Cargo and ambiguous item references, plus saved containers, may be retained after the last rack disappears; reconciliation and orphan collection remain open. Regression sources cover shuffled twenty-rack cycles, stale sources, failed recovery, -allocator reuse and private-MySQL saved aliases. At `7ac9af6eb`, the game unit suite, -real-compact twenty-rack cycles and both private-MySQL cargo fixtures pass. Local -combined-source CI and live reconnect acceptance remain pending; the asynchronous -hull identity repair requires separate review and validation. +allocator reuse and private-MySQL saved aliases. At `198b7d482`, the official lane +check, the game unit suite, the real-compact twenty-rack cycles and both private-MySQL +cargo fixtures pass. A bounded headless live run with one fresh owner (80 positive rack +operations over four passes, forty drops, twenty pickups) kept the twenty original +item IDs through every cycle and ended with twenty System ground references and twenty +empty saved racks; an independent cargo and SQL audit found no P1/P2 for that +positive run. The same run's bag-full negative left items, racks and phases unchanged, +and a hard close with reselect kept the same loaded hull registered with a single +current root. In a second summon of the same item the skill executed (started, fired, +ended); the subsequent loaded-hull replacement was refused with error 801 +(`SLAVE_EQUIPMENT_LOADED_ITEM`), the loaded hull, racks, cargo and phases were +preserved and only the initial SCSlaveCreated appears in the captures. That shows +loaded-hull preservation; unloaded replacement and completion of the 600-second +timer were not exercised in this live run. This is observational evidence on the +Rust-server path, not retail parity or global atomicity; the post-STOP SQL proves +persisted state, not save order, and the process stop was forced, so the logs are not +warning- or error-free. Independent cargo/SQL and control reviews support this +bounded observation with that replacement-refusal qualification; wider audit items +remain open. ### systems::social diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json index 7b9dc22759..47a3debc4c 100644 --- a/rust/docs/audit-repair-status.json +++ b/rust/docs/audit-repair-status.json @@ -379,16 +379,16 @@ }, { "id": "trade-ship-cargo-reference-atomicity", - "status": "unit_and_data_passed_full_gate_pending", + "status": "ci_selected_checks_and_bounded_live_observation_verified", "owner": "audit-tradeship", - "note": "Reviewed cargo source8c plus root fixture-ID correction7ac pass game unit suite, native Merchant all20rack cycles, private MySQL saved-alias and recycled-GUID cases. Reconnect identity source review is clean; final combined execution and live acceptance remain pending. Conservative cargo/container retention and reconciliation/GC limits remain.", + "note": "At198b7d482 the official lane CI, the game unit suite and the explicit native Merchant all20rack cycle, private MySQL saved-alias and recycled-GUID checks pass. Independent cargo/SQL audit R36 found no P1/P2 for the positive 80-operation rack run; the R37 control audit found no P1 and its single P2 evidence qualification is resolved by explicit wording. The bag-negative and hard-close/reselect controls pass; in the second same-item resummon attempt the skill executed (started, fired, ended) and the subsequent loaded-hull replacement was refused with SCErrorMsg 801 SLAVE_EQUIPMENT_LOADED_ITEM, so it shows loaded-hull preservation; unloaded replacement and 600 s timer completion were not exercised in this live run. Conservative cargo/container retention and reconciliation/GC limits remain.", "commit": "8c2e977b5ba6b7660e4739964465e0b1e97b9d7b" }, { "id": "trade-ship-live-root-identity-after-reconnect", - "status": "source_reviewed_merged_pending_execution", + "status": "source_reviewed_ci_selected_checks_and_bounded_live_observation", "owner": "audit-ship-session", - "note": "Three source review rounds clean after item publication, query-error/orphan, callback spawn-lock ordering and stale cargo receipt fixes. Combined compilation passes; new executable tests and live acceptance pending. Intentional600s retention remains. Guardless/direct-write limitations explicit.", + "note": "Three source review rounds clean after item publication, query-error/orphan, callback spawn-lock ordering and stale cargo receipt fixes. At198b7d482 the official lane CI and the selected ship save-fence/query-failure/restart checks pass. One bounded headless hard-close reselect left the same loaded hull registered and visible with a single current root, and in the second same-item summon attempt the skill executed and the subsequent loaded-hull replacement was refused with 801, leaving hull, racks, cargo and phases unchanged; unloaded replacement and 600 s timer completion were not exercised in this live run. Intentional600s retention remains. Guardless/direct-write limitations explicit.", "commit": "54f98af143f8458175dc76ffe9afad132ec3b680" }, { @@ -400,15 +400,15 @@ }, { "id": "headless-control-reconnect-test-interface", - "status": "source_reviewed_package_tests_passed_final_gate_live_pending", + "status": "source_reviewed_package_tests_and_lane_ci_passed_bounded_live_use", "commit": "578a6a7e68a8ea663eafdb5487f5f8d8f2a09180", - "note": "Fourth source review clean after an executed regression exposed expired Tokio timer first-poll behavior. Synchronous guards preserve EOF priority and reject expired command/global/output budgets before action polling. At96a67a5, all57 library and16 control/config tests pass, including real loopback hard-close and timeout flows. Final lane CI and live acceptance remain pending; captures are normalized and filtered." + "note": "Fourth source review clean after an executed regression exposed expired Tokio timer first-poll behavior. Synchronous guards preserve EOF priority and reject expired command/global/output budgets before action polling. At96a67a5, all57 library and16 control/config tests pass, including real loopback hard-close and timeout flows; both counts are unchanged in the198b7d482 lane CI. The bounded live reconnect control used it without a deadline overrun (see current_live); captures are normalized and filtered." }, { "id": "ship-identity-observational-diagnostics", - "status": "source_reviewed_merged_pending_execution", + "status": "source_reviewed_ci_passed_live_observational", "commit": "6a406e5da2d319bc61cc073e761d4d3c08a005d9", - "note": "Source review findings closed; both consistency flags remain false. Supporting observations only, not a globally atomic authority proof." + "note": "Source review findings closed; the diagnostic, authority and retirement consistency flags all remain false. Supporting observations only, not a globally atomic authority proof; live use at198b7d482 stays observational." } ], "recent_validation": { @@ -425,16 +425,123 @@ "result": "held_at_memory_reserve_before_completion", "minimum_free_gib": 5.938747406005859 }, - "current_full_lane_ci": "pending_after_focused_checks", - "current_live": "pending_source_gate_and_reviewed_release", + "current_full_lane_ci": { + "head": "198b7d4821df6d930c14c8a5d38c64846a43efe1", + "tree": "6795208a05103b9b090120606b166a59a0c88497", + "result": "passed", + "command": "Scripts/lane.sh check (cargo xtask ci)", + "native_exit": 0, + "elapsed_seconds": 91.10899999999674, + "minimum_free_gib": 12.508186340332031, + "source_unchanged": true, + "testclient_library_passed": 57, + "testclient_binary_passed": 16, + "scope": "Local official lane check; the full source build passed at the same head and tree." + }, + "current_live": { + "status": "bounded_observational_controls_verified_with_loaded_hull_replacement_refused_801", + "executed_source_head": "198b7d4821df6d930c14c8a5d38c64846a43efe1", + "executed_source_tree": "6795208a05103b9b090120606b166a59a0c88497", + "scope": "Observed only on the executed source head above. Later documentation-only commits and checks do not change what was observed; the final documentation HEAD was not run live.", + "runtime_artifacts": "8 target/runtime EXE/PDB hashes and 4 native GUID/age pairs matched the executed source; no Rust source change since.", + "supporting_external_harness": { + "scope": "External PowerShell/Python driver and offline helper tests; not committed Rust tests and not retail proof.", + "helper_tests_passed": 191, + "helper_tests_skipped": 0, + "helper_test_manifest_sha256": "e9bf4b93b0d478b2c5241482feadc30ce4dd209bbf25fd488b7c5d00a1abbec2", + "helper_test_manifest_scope": "external main 191-test helper manifest", + "grid_preflight_mock_tests_passed": 209, + "grid_preflight_suites": "75+50+84 in three separate unittest processes", + "independent_source_review": "R33 and R34 clear" + }, + "ground_grid_preflight": { + "review": "R35 independent raw/persistence/stop audit clear", + "water_nodes_observed": 20, + "instance": 0, + "pitch_metres": 6, + "min_depth_observed": 58.03979, + "surface_height": 100, + "cached_zone_observed": 180, + "spare_pack_drop_recover_roundtrips": 1, + "same_item_guid_after_recover": true, + "wrapper_elapsed_seconds": 43.703, + "exit": "OS exit 0, STOP0; same spare item back in equipment slot 26; no surviving doodad references.", + "prior_cargo_affected": false, + "scope": "20 sampled water nodes plus one same-GUID spare drop/recover on the headless Rust-server path", + "not_proven": "static objects; open water beyond the sampled nodes; the actual cast zone" + }, + "full_merchant_run": { + "driver_status": "OBSERVATIONAL_SCENARIO_COMPLETE", + "driver_elapsed_seconds": 362.078, + "fresh_owners": 1, + "reported_counts": { + "loads": 40, + "unloads": 40, + "drops": 40, + "pickups": 20, + "negative_cases": 1, + "hard_drops": 1, + "reconnects": 1, + "resummon_attempts": 1 + }, + "reported_counts_note": "resummon_attempts is the raw driver count of one accepted same-item skill attempt: the skill executed, then the subsequent loaded-hull replacement was refused with 801. It is not a successful new hull.", + "run_conditions": "No retries, cap changes, original-item destroy, regrant or cooldown clearing; timing budgets unchanged; control cleanup completed.", + "initial_verifier_correction": "The initial read-only SQL verifier assumed character owner_type 1 instead of 254 and filtered saved racks by owner_id instead of house_id. Corrected source-derived filters returned unchanged common rows plus the 20 saved racks; no runtime or data retry.", + "r36_independent_cargo_sql_audit": { + "result": "CLEAR, no P1/P2 for the positive cargo run", + "positive_rack_operations": 80, + "racks_attached": "all 20 (attachment points 60..79) in 4 passes", + "drops": 40, + "pickups": 20, + "accepted_skill_timelines": 143, + "original_add_payloads_with_identical_immutable_fields": 160, + "unique_original_item_ids_kept_identical": 20, + "final_ground_references": 20, + "final_item_container": "System", + "final_saved_racks_empty": 20, + "glider_retained_in_bag": true, + "summon_item_and_saved_hull_retained": true, + "post_stop_sql_closure_checks_passed": 8, + "destroy_calls": "only recorded filler items (template 6735)", + "labor": "one natural credit of +10, no debit", + "wire_note": "Sanitized, expanded wire summaries; not original compressed or retail captures." + }, + "r37_independent_control_audit": { + "result": "No P1; one P2 evidence qualification, resolved by the explicit resummon wording below (skill executed, subsequent loaded-hull replacement refused with 801). No rerun.", + "scope": "Negative, hard-close reconnect, same-item resummon attempt, root identity, deadlines, logs and cleanup; source and sanitized/normalized captures only, no private configuration or secrets read.", + "bag_negative": "One accepted negative on an attached rack: skill timeline started, fired, then ended with error 207; nothing else in the window. Bag 50/50 (5 existing plus 45 recorded filler items); real glider kept in its equipment cell; all inventory, rack and phase state unchanged; no item-task or phase packets. The 45 destroy calls hit only the recorded fillers (not originals, glider or summon); the glider was legally swapped into the bag.", + "hard_close": "Game and Stream connections both closed without a LeaveWorld; the same character was reselected once (connection 1 to 5); the same hull stayed registered and visible; retirement job generation 1 stayed waiting on its timer, still pending; reconnect leave generation reset to 0.", + "resummon_attempt": "The second same-item skill executed (accepted timeline: started, fired, ended), then SCErrorMsg 801 SLAVE_EQUIPMENT_LOADED_ITEM refused the subsequent loaded-hull replacement: the existing hull (template 75), all 20 racks, cargo and phases were preserved, drift 0, and only the initial SCSlaveCreated appears in the captures. So it shows loaded-hull preservation and a single root after reconnect; unloaded replacement and 600 s timer completion were not exercised in this live run.", + "root_identity": "91 audit chunk groups, all from the observer, with valid FNV checksums and nonces; 90 post-summon samples show a single current root and no other live root; the three consistency flags remain false. These are temporal observations, not global authority.", + "deadlines": "2892 requests, 2892 ok, none past their deadline; 141 operations (all 140 positive at 2.49 s or less, negative 1.58 s); 362.078 s total with 181.567 s reserve and a 537.015 s effective cap inside 540 s; no retries, cooldown clearing or cap changes. Reconnect used 16.9 s of its 20 s budget (3.1 s margin).", + "logs": "138 WARN lines (136 TeleportEnded, 1 slow tick, 1 expected negative Doodad item-reference refusal) and 1 ERROR (Login link, after the forced Login-before-Game STOP); 0 panics; startup excluded. The stop was forced, not a graceful shutdown, and the logs are not warning- or error-free.", + "cleanup": "All 8 runtime artifact hashes match; independent STOP0 with no owned Login/Game/Testclient process and 0 of the 5 lane ports. Authentication entries are omitted by the source and rejected by the adapter.", + "minor_qualifications": "The stage label after the negative was persisted but the rolling deadlines stayed valid. The observer was a living character 2.83 m from node 79, which is not a static-object mask." + } + }, + "full_merchant80_acceptance": "Accepted for this one bounded headless run: 80 positive rack operations, 40 drops, 20 pickups, original-20 identity and final persisted SQL closure, with qualified controls. The same-item skill executed; subsequent loaded-hull replacement was refused with 801 and the existing hull was preserved. This is not a full-scenario pass, retail parity or global proof; the wider audit remains in_progress.", + "final_stop": "Independent STOP0: no owned Login/Game/Testclient process or lane listener (0 of the 5 lane ports); the 8 runtime artifact hashes, the clean source at the executed head and the 26 verified helper pins unchanged; shared MySQL TCP responds only.", + "proof_limits": [ + "One bounded fresh owner on the headless Rust-server path; not retail parity, all world actors, all interleavings or global atomicity.", + "Post-STOP0 SQL proves the persisted end state only, not the exact save time or save order; DB item details are not asserted byte-identical to the wire serializer.", + "The doodad wire carries no item GUID; the native-to-item mapping is correlated and bound by the persisted row after STOP0.", + "The diagnostic, authority and retirement consistency flags remain false; queued, HP, world, phase and sampling exclusions and guardless or direct writes remain.", + "The 600 s offline hull retention and the root-versus-portal rendering distinction remain intentional.", + "The final 20 originals are legal world ground doodads in System, not bag items; backpack type 3 cannot be stowed. The glider is a type 2 bag item.", + "In the same-item resummon attempt the skill executed and the subsequent loaded-hull replacement was refused with 801; unloaded replacement, replacement of a retired hull and 600 s retirement-timer completion were not exercised in this live run.", + "Process stop was forced and the logs contain warnings and one Login-link error; the run is not claimed clean or gracefully shut down.", + "Passing CI closes no unrelated finding; the open wider-audit items are unchanged (9 timed zone bans, pStat contribution storage, 41 missing native attachment points, orphan reconciliation/GC; AoE rank/reset and immediate buff-break timing remain compatibility policy; tester-incident root cause is unattributed)." + ] + }, "game_unit_tests": { - "head": "7ac9af6eb3b7d0b511310d7865dc10a1f6bf2712", - "passed": 2833, + "head": "198b7d4821df6d930c14c8a5d38c64846a43efe1", + "passed": 2878, "failed": 0, - "ignored": 148, + "ignored": 149, "result": "passed", - "minimum_free_gib": 7.448451995849609, - "source_unchanged": true + "minimum_free_gib": 12.508186340332031, + "source_unchanged": true, + "scope": "Game package inside the official lane check." }, "latest_corrected_builds": { "head": "5dfd7282b71ec84655b44b861b24991502dd5ff2", @@ -463,19 +570,21 @@ "database_scope": "private 3317 lane_audit_final_game; connection-local temporary tables" }, "remote_checks": { - "head": "7ac9af6eb3b7d0b511310d7865dc10a1f6bf2712", + "head": "198b7d4821df6d930c14c8a5d38c64846a43efe1", "passed": 12, "failed": 0, "scope": "Draft PR46 Windows/Linux build/tests/Clippy plus coverage, formatting, packet checks and other configured jobs." }, "selected_ignored_current_checks": { - "head": "7ac9af6eb3b7d0b511310d7865dc10a1f6bf2712", - "binary_sha256": "fbb66fed5ca0f4c21ce8ac222e175be332f870ab266a82e3ffec09d76d227f68", - "passed": 16, + "head": "198b7d4821df6d930c14c8a5d38c64846a43efe1", + "binary_sha256": "51af57b83663b74078c8ab7ac3972f124ba2d291b7319b7d53a2eaa43213dcaa", + "attach_binary_sha256": "b06ba24f7d211585737d536f486114c0ca550ce10c03bc3662680544fecbae22", + "passed": 20, "failed": 0, - "compact_checks": 10, - "private_mysql_checks": 6, - "scope": "Explicit ignored tests; private 3317 lane_audit_final_game uses connection-local temporary tables. Includes Merchant twenty-rack cycles and both cargo persistence/allocator-reuse fixtures." + "compact_checks": 12, + "private_mysql_checks": 8, + "environment_skips": 0, + "scope": "Explicit ignored tests run one selector per process; private 3317 lane_audit_final_game uses connection-local temporary tables. Includes Merchant twenty-rack cycles, both cargo persistence/allocator-reuse fixtures, ship query-failure/retry/save-fence/restart, legacy intentional-empty equipment and lobby/mail checks. Only these 20 explicit selectors; the other ignored tests were not run." }, "combined_compilation": { "head": "243953bdab1c077a93e02e71948f24ac03d5744a",