diff --git a/rust/PORT-AUDIT.md b/rust/PORT-AUDIT.md index baa0b39cef..cb8d1e983e 100644 --- a/rust/PORT-AUDIT.md +++ b/rust/PORT-AUDIT.md @@ -600,7 +600,7 @@ Public methods with no Rust counterpart by name, and their verdicts: | `CSChangeMateNamePacket.cs` | CSChangeMateNamePacket | ported | `CSChangeMateNamePacket` → `aaemu-game/src/systems/vehicles/packets.rs` | | `CSChangeMateTargetPacket.cs` | CSChangeMateTargetPacket | ported | `CSChangeMateTargetPacket` → `aaemu-game/src/systems/vehicles/packets.rs` | | `CSChangeMateUserStatePacket.cs` | CSChangeMateUserStatePacket | ported | `CSChangeMateUserStatePacket` → `aaemu-game/src/systems/vehicles/packets.rs` | -| `CSChangeSlaveEquipmentPacket.cs` | CSChangeSlaveEquipmentPacket | ported | `CSChangeSlaveEquipmentPacket` → `aaemu-game/src/systems/economy/mate_equipment.rs` | +| `CSChangeSlaveEquipmentPacket.cs` | CSChangeSlaveEquipmentPacket | ported | `CSChangeSlaveEquipmentPacket` → `aaemu-game/src/systems/vehicles/packets.rs` | | `CSChangeSlaveNamePacket.cs` | CSChangeSlaveNamePacket | ported | `CSChangeSlaveNamePacket` → `aaemu-game/src/systems/vehicles/packets.rs` | | `CSChangeSlaveTargetPacket.cs` | CSChangeSlaveTargetPacket | ported | `CSChangeSlaveTargetPacket` → `aaemu-game/src/packets/c2g_misc.rs` | | `CSChangeTargetPacket.cs` | CSChangeTargetPacket | ported | `CSChangeTargetPacket` → `aaemu-game/src/systems/skills/handlers.rs` | diff --git a/rust/crates/aaemu-commons/src/net.rs b/rust/crates/aaemu-commons/src/net.rs index 935610bd5d..a6dd4b78fd 100644 --- a/rust/crates/aaemu-commons/src/net.rs +++ b/rust/crates/aaemu-commons/src/net.rs @@ -93,4 +93,109 @@ mod tests { assert_eq!(c.decode(&mut buf).unwrap(), Some(vec![9])); assert_eq!(c.decode(&mut buf).unwrap(), None); } + + #[test] + fn frame_lengths_have_exact_wire_bytes() { + for (len, header) in [(0, [0, 0]), (258, [2, 1]), (65_535, [0xff, 0xff])] { + let payload: Vec = (0..len).map(|i| (i % 251) as u8).collect(); + let mut c = FrameCodec; + let mut buf = BytesMut::new(); + c.encode(&payload, &mut buf).unwrap(); + assert_eq!(&buf[..2], &header); + assert_eq!(&buf[2..], payload); + assert_eq!(c.decode(&mut buf).unwrap(), Some(payload)); + assert!(buf.is_empty()); + assert_eq!(c.decode(&mut buf).unwrap(), None); + } + } + + #[test] + fn decodes_at_every_fragmentation_point() { + let payload: Vec = (0..258).map(|i| (i % 251) as u8).collect(); + let mut wire = vec![2, 1]; + wire.extend_from_slice(&payload); + for split in 0..=wire.len() { + let mut c = FrameCodec; + let mut buf = BytesMut::from(&wire[..split]); + if split < wire.len() { + for _ in 0..2 { + assert_eq!(c.decode(&mut buf).unwrap(), None, "split {split}"); + assert_eq!(&buf[..], &wire[..split], "split {split}"); + } + } + buf.extend_from_slice(&wire[split..]); + assert_eq!(c.decode(&mut buf).unwrap(), Some(payload.clone())); + assert!(buf.is_empty()); + assert_eq!(c.decode(&mut buf).unwrap(), None); + } + } + + #[test] + fn coalesced_frames_preserve_incomplete_trailing_frame() { + let cases: &[(&[u8], &[u8], &[u8])] = &[ + (&[3], &[0, 9, 8, 7], &[9, 8, 7]), + (&[3, 0, 9], &[8, 7], &[9, 8, 7]), + ]; + for &(trailing, rest, payload) in cases { + let mut c = FrameCodec; + let mut buf = BytesMut::from(&[0, 0, 2, 0, 0x10, 0x20][..]); + buf.extend_from_slice(trailing); + assert_eq!(c.decode(&mut buf).unwrap(), Some(vec![])); + assert_eq!(c.decode(&mut buf).unwrap(), Some(vec![0x10, 0x20])); + assert_eq!(c.decode(&mut buf).unwrap(), None); + assert_eq!(&buf[..], trailing); + buf.extend_from_slice(rest); + assert_eq!(c.decode(&mut buf).unwrap(), Some(payload.to_vec())); + assert!(buf.is_empty()); + } + } + + #[test] + fn decode_eof_rejects_every_truncated_frame() { + let wire = [3, 0, 1, 2, 3]; + for end in 1..wire.len() { + let mut c = FrameCodec; + let mut buf = BytesMut::from(&wire[..end]); + let err = c.decode_eof(&mut buf).unwrap_err(); + assert_eq!(err.kind(), std::io::ErrorKind::Other); + assert_eq!(&buf[..], &wire[..end]); + } + } + + #[test] + fn decode_eof_drains_complete_frames_before_truncated_tail() { + let mut c = FrameCodec; + let mut buf = BytesMut::from(&[0, 0, 1, 0, 9, 2][..]); + assert_eq!(c.decode_eof(&mut buf).unwrap(), Some(vec![])); + assert_eq!(c.decode_eof(&mut buf).unwrap(), Some(vec![9])); + assert!(c.decode_eof(&mut buf).is_err()); + assert_eq!(&buf[..], &[2]); + } + + #[test] + fn decode_eof_accepts_complete_frame_and_empty_buffer() { + let mut c = FrameCodec; + let mut buf = BytesMut::new(); + assert_eq!(c.decode_eof(&mut buf).unwrap(), None); + buf.extend_from_slice(&[1, 0, 9]); + assert_eq!(c.decode_eof(&mut buf).unwrap(), Some(vec![9])); + assert!(buf.is_empty()); + assert_eq!(c.decode_eof(&mut buf).unwrap(), None); + } + + #[test] + fn oversized_encode_preserves_destination() { + let mut c = FrameCodec; + let mut buf = BytesMut::from(&[1, 0, 9][..]); + let before = buf.clone(); + let payload = vec![0; usize::from(u16::MAX) + 1]; + let err = c.encode(&payload, &mut buf).unwrap_err(); + assert_eq!(err.kind(), std::io::ErrorKind::InvalidInput); + assert_eq!(buf, before); + c.encode([8], &mut buf).unwrap(); + assert_eq!(&buf[..], &[1, 0, 9, 1, 0, 8]); + assert_eq!(c.decode(&mut buf).unwrap(), Some(vec![9])); + assert_eq!(c.decode(&mut buf).unwrap(), Some(vec![8])); + assert!(buf.is_empty()); + } } diff --git a/rust/crates/aaemu-commons/src/packet_stream.rs b/rust/crates/aaemu-commons/src/packet_stream.rs index 114bbbdead..0f548bbfdf 100644 --- a/rust/crates/aaemu-commons/src/packet_stream.rs +++ b/rust/crates/aaemu-commons/src/packet_stream.rs @@ -112,7 +112,7 @@ impl PacketStream { // ---- reads ------------------------------------------------------------------------------- fn take(&mut self, n: usize) -> Result<&[u8]> { - if self.pos + n > self.buf.len() { + if n > self.remaining() { return Err(MarshalError::EndOfStream { pos: self.pos, wanted: n, @@ -456,6 +456,8 @@ impl From> for PacketStream { mod tests { use super::*; + type Reader = fn(&mut PacketStream) -> Result<()>; + #[test] fn primitives_roundtrip() { let mut s = PacketStream::new(); @@ -477,6 +479,272 @@ mod tests { assert!(matches!(s.read_u8(), Err(MarshalError::EndOfStream { .. }))); } + #[test] + fn oversized_byte_read_preserves_cursor() { + let mut s = PacketStream::from_bytes([0x11, 0x22, 0x33]); + assert_eq!(s.read_u8().unwrap(), 0x11); + assert_eq!( + s.read_bytes(usize::MAX), + Err(MarshalError::EndOfStream { + pos: 1, + wanted: usize::MAX, + len: 3, + }) + ); + assert_eq!(s.pos(), 1); + assert_eq!(s.unread(), &[0x22, 0x33]); + assert_eq!(s.read_u16().unwrap(), 0x3322); + } + + #[test] + fn oversized_fixed_string_read_preserves_cursor() { + let mut s = PacketStream::from_bytes(b"abc".as_slice()); + assert_eq!(s.read_u8().unwrap(), b'a'); + assert_eq!( + s.read_string_fixed(usize::MAX), + Err(MarshalError::EndOfStream { + pos: 1, + wanted: usize::MAX, + len: 3, + }) + ); + assert_eq!(s.pos(), 1); + assert_eq!(s.unread(), b"bc"); + assert_eq!(s.read_string_fixed(2).unwrap(), "bc"); + } + + #[test] + fn truncated_fixed_width_reads_preserve_cursor_and_can_retry() { + let readers: &[(usize, Reader)] = &[ + (1, |s| s.read_bool().map(|_| ())), + (1, |s| s.read_u8().map(|_| ())), + (1, |s| s.read_i8().map(|_| ())), + (2, |s| s.read_i16().map(|_| ())), + (2, |s| s.read_u16().map(|_| ())), + (3, |s| s.read_bc().map(|_| ())), + (3, |s| s.read_string_fixed(3).map(|_| ())), + (4, |s| s.read_i32().map(|_| ())), + (4, |s| s.read_u32().map(|_| ())), + (4, |s| s.read_f32().map(|_| ())), + (8, |s| s.read_i64().map(|_| ())), + (8, |s| s.read_u64().map(|_| ())), + (8, |s| s.read_f64().map(|_| ())), + (9, |s| s.read_position().map(|_| ())), + ]; + for &(width, read) in readers { + for available in 0..width { + let mut s = PacketStream::from_bytes(vec![0; 1 + available]); + s.read_u8().unwrap(); + assert_eq!( + read(&mut s), + Err(MarshalError::EndOfStream { + pos: 1, + wanted: width, + len: 1 + available, + }) + ); + assert_eq!(s.pos(), 1); + assert_eq!(s.unread(), vec![0; available]); + s.write_raw(&vec![0; width - available]); + read(&mut s).unwrap(); + assert_eq!(s.pos(), 1 + width); + assert_eq!(s.remaining(), 0); + } + } + } + + #[test] + fn cursor_clamping_rollback_and_empty_reads() { + let mut s = PacketStream::from_bytes([0x11, 0x22]); + s.set_pos(usize::MAX); + assert_eq!(s.pos(), 2); + assert_eq!(s.remaining(), 0); + assert!(s.read_bytes(0).unwrap().is_empty()); + assert_eq!(s.read_string_fixed(0).unwrap(), ""); + assert!(matches!(s.read_u8(), Err(MarshalError::EndOfStream { .. }))); + assert_eq!(s.pos(), 2); + s.rollback_by(1); + assert_eq!(s.read_u8().unwrap(), 0x22); + s.rollback_by(usize::MAX); + assert_eq!(s.pos(), 0); + assert_eq!(s.read_u8().unwrap(), 0x11); + s.rollback(); + assert_eq!(s.read_u16().unwrap(), 0x2211); + s.clear(); + assert!(s.is_empty()); + assert_eq!(s.pos(), 0); + assert!(s.unread().is_empty()); + s.write_u8(0x33); + assert_eq!(s.read_u8().unwrap(), 0x33); + } + + #[test] + fn truncated_length_prefixed_reads_consume_only_complete_fields() { + let readers: [Reader; 3] = [ + |s| s.read_bytes_sized().map(|_| ()), + |s| s.read_string().map(|_| ()), + |s| s.read_packet_stream().map(|_| ()), + ]; + let wire = [3, 0, b'a', b'b', b'c']; + for read in readers { + for end in 0..wire.len() { + let mut s = PacketStream::from_bytes(&wire[..end]); + let (pos, wanted) = if end < 2 { (0, 2) } else { (2, 3) }; + assert_eq!( + read(&mut s), + Err(MarshalError::EndOfStream { + pos, + wanted, + len: end, + }) + ); + assert_eq!(s.pos(), pos); + assert_eq!(s.unread(), &wire[pos..end]); + s.write_raw(&wire[end..]); + s.rollback(); + read(&mut s).unwrap(); + assert_eq!(s.pos(), wire.len()); + } + } + } + + #[test] + fn nonpositive_i16_lengths_leave_following_bytes_unread() { + // Preserve the signed length/C# behavior, including the high-bit boundary. + for prefix in [[0, 0], [0, 0x80], [0xff, 0xff]] { + let wire = [prefix[0], prefix[1], 0x42]; + let mut s = PacketStream::from_bytes(wire); + assert!(s.read_bytes_sized().unwrap().is_empty()); + assert_eq!(s.pos(), 2); + assert_eq!(s.read_u8().unwrap(), 0x42); + + let mut s = PacketStream::from_bytes(wire); + assert_eq!(s.read_string().unwrap(), ""); + assert_eq!(s.pos(), 2); + assert_eq!(s.read_u8().unwrap(), 0x42); + + let mut s = PacketStream::from_bytes(wire); + let nested = s.read_packet_stream().unwrap(); + assert!(nested.is_empty()); + assert_eq!(nested.pos(), 0); + assert_eq!(s.pos(), 2); + assert_eq!(s.read_u8().unwrap(), 0x42); + } + } + + #[test] + fn maximum_positive_i16_length_reads_entire_payload() { + let payload = vec![0x42; i16::MAX as usize]; + let mut s = PacketStream::new(); + s.write_bytes_sized(&payload).write_u8(0x99); + assert_eq!(&s.as_bytes()[..2], &[0xff, 0x7f]); + assert_eq!(s.read_bytes_sized().unwrap(), payload); + assert_eq!(s.read_u8().unwrap(), 0x99); + } + + #[test] + fn strings_replace_invalid_utf8_and_trim_only_edge_nuls() { + let body = [0, b'a', 0xff, 0, b'b', 0]; + let mut s = PacketStream::new(); + s.write_bytes_sized(&body).write_u8(0x42); + assert_eq!(s.read_string().unwrap(), "a\u{fffd}\0b"); + assert_eq!(s.read_u8().unwrap(), 0x42); + + let mut s = PacketStream::from_bytes(body); + assert_eq!(s.read_string_fixed(body.len()).unwrap(), "a\u{fffd}\0b"); + assert_eq!(s.remaining(), 0); + } + + #[test] + fn pisc_width_boundaries_have_exact_wire_bytes() { + let cases: &[(i64, &[u8])] = &[ + (0, &[0, 0]), + (0xff, &[0, 0xff]), + (0x100, &[1, 0, 1]), + (0xffff, &[1, 0xff, 0xff]), + (0x1_0000, &[2, 0, 0, 1]), + (0xff_ffff, &[2, 0xff, 0xff, 0xff]), + (0x100_0000, &[3, 0, 0, 0, 1]), + (0xffff_ffff, &[3, 0xff, 0xff, 0xff, 0xff]), + ]; + for &(value, wire) in cases { + let mut s = PacketStream::new(); + s.write_pisc(&[value]); + assert_eq!(s.as_bytes(), wire, "value {value:#x}"); + let mut s = PacketStream::from_bytes(wire); + assert_eq!(s.read_pisc_w(1).unwrap(), [value]); + assert_eq!(s.remaining(), 0); + } + } + + #[test] + fn pisc_groups_have_exact_headers_and_partial_final_group() { + let values = [ + 0xff, + 0x100, + 0x1_0000, + 0x100_0000, + 0xffff, + 0xff_ffff, + 0xffff_ffff, + ]; + let wire = [ + 0xe4, 0xff, 0, 1, 0, 0, 1, 0, 0, 0, 1, // u8, u16, bc, u32 + 0x39, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // u16, bc, u32 + ]; + let mut s = PacketStream::new(); + s.write_pisc_w(&values); + assert_eq!(s.as_bytes(), wire); + let mut s = PacketStream::from_bytes(wire); + assert_eq!(s.read_pisc_w(values.len()).unwrap(), values); + assert_eq!(s.remaining(), 0); + } + + #[test] + fn truncated_pisc_groups_stop_before_incomplete_value() { + let wire = [ + 0xe4, 0xff, 0, 1, 0, 0, 1, 0, 0, 0, 1, // u8, u16, bc, u32 + 0x39, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, // u16, bc, u32 + ]; + // Header/value offsets and widths, including the second group's header. + for (pos, wanted) in [ + (0, 1), + (1, 1), + (2, 2), + (4, 3), + (7, 4), + (11, 1), + (12, 2), + (14, 3), + (17, 4), + ] { + for end in pos..pos + wanted { + let mut s = PacketStream::from_bytes(&wire[..end]); + assert_eq!( + s.read_pisc_w(7), + Err(MarshalError::EndOfStream { + pos, + wanted, + len: end + }) + ); + assert_eq!(s.pos(), pos); + assert_eq!(s.unread(), &wire[pos..end]); + assert_eq!(s.read_bytes(end - pos).unwrap(), wire[pos..end]); + } + } + } + + #[test] + fn empty_pisc_groups_do_not_consume_or_write_bytes() { + let mut s = PacketStream::from_bytes([0x42]); + s.write_pisc_w(&[]); + assert_eq!(s.as_bytes(), &[0x42]); + assert!(s.read_pisc_w(0).unwrap().is_empty()); + assert_eq!(s.pos(), 0); + assert_eq!(s.read_u8().unwrap(), 0x42); + } + #[test] fn pisc_roundtrip() { let vals = [5, 300, 70_000, 20_000_000, 1]; diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 1ca30539d6..7f030cced9 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -309,7 +309,7 @@ Cross-subsystem: mates are despawned on dungeon entry and `PlayerCanEnter` check | Area (C#) | Rust | Status | Notes | |---|---|---|---| -| `MateGameData`, `SlaveGameData` (templates, unit modifiers, initial items / buffs, passive buffs, doodad / healing point / slave bindings, drop doodads, mount skills, repairable slaves, `slave_attach_points*.json`), `TransferGameData` (templates, bindings, binding doodads, paths, client `transfer_path.xml` roads + `GetOwnerPaths`), `ShipyardManager.Load`, `TaxationsManager` table, `ModelManager` vehicle / ship models | `systems/vehicles/data.rs` | done | Gated test `real_compact_db_vehicle_tables` checks the row counts; `real_transfer_follows_its_client_route` loads the roads from the game_pak. | +| `MateGameData`, `SlaveGameData` (templates, unit modifiers, initial items / buffs, passive buffs, doodad / healing point / slave bindings, drop doodads, mount skills, repairable slaves, `slave_equip_slots`, `item_slave_equipments`, `allow_to_equip_slaves` / `allow_to_equip_slots`, `slave_attach_points*.json`), `TransferGameData` (templates, bindings, binding doodads, paths, client `transfer_path.xml` roads + `GetOwnerPaths`), `ShipyardManager.Load`, `TaxationsManager` table, `ModelManager` vehicle / ship models | `systems/vehicles/data.rs` | done | Gated test `real_compact_db_vehicle_tables` checks the row counts; `real_transfer_follows_its_client_route` loads the roads from the game_pak. | | `MateManager` (per instance), `CharacterMates` (load / save / spawn / despawn), `Mate` (`AddExp`, `MateXpUpdateTask`, `RegenTick`, `DoFallDamage`, `OnZoneChange`, stats) | `systems/vehicles/mates.rs`, `stats.rs` | done | Mount / dismount (`SCUnitAttached` / `SCUnitDetached`, rider becomes a transform child), rename, target, user state, mate equipment packet (item move through `VehicleItemHooks`), kill exp, stun / unmount skills, death despawn. | | `SlaveManager` (per instance), `SlaveSpawner`, `SummonSlave` details, `Slave` (`DoDie`, `DoHpChangeTrigger` / repair points, `RegenTick`, `Save`, `OnZoneChange`, stats) | `systems/vehicles/slaves.rs` | done | Create (saved slave / persistent doodads / saved child slaves from MySQL, position, boats on the water surface, doodad and slave bindings at the model attach points), bind / unbind, delete with portal-time despawn, Rider's Escape, repair cooldown, `RepairSlaveEffect`, `SendMySlaveTask`, logout (+10 min) / disconnect despawn task, `slaves` table (`AfterCharacters`). | | `TransferManager` (per instance, 100 ms tick), `TransferSpawner`, `Transfer` route following (`GoToPath`, `MoveTo`, `NextPoint`) | `systems/vehicles/transfers.rs` | done | Carriage motor + boarding part + bench doodads, `SCOneUnitMovementPacket` (transfer move type) for both parts. Spawned from `SpawnManager.SpawnAll`. | @@ -680,6 +680,21 @@ is no longer mirrored (see "Known deviations", dead NPC returned and healed). ## Known deviations from the C# +* systems::services (music): 1.2 CS123 has independent `isTooltip` / `showBuffOnly` + bool bytes (native constructor `397acd70`, serializer `397b1480`). The C# packed + ushort switch ignored uncached playing `(false,false)` and `(true,true)`. Native + `39082550` sends `(isTooltip,false)` on a cache miss and `(false,true)` for cached + playing. Requests with `showBuffOnly=false` now load notes and echo `isTooltip` + in SC1e0; `showBuffOnly=true` retains the buff-only ScoreMemorized (6010) path, + including its lack of a song-existence check. `(true,true)` is representable but + is not emitted by the observed native cache flow; it follows the same buff-only + branch. Missing-song empty replies and existing read/ownership behavior remain. + Request u64 / lookup u32 / response 32-bit widths are unchanged: native SC1e0 + sign-extends its signed32 note ID at `391e1691` before callback `391e169b`. + Arbitrary high request bits still alias the low32 song key; IDs >= 2^31 can + differ between zero-extended sheet IDs and sign-extended native cache keys. + No evidence establishes a safe ID-width or ownership-policy change here. + * systems::skills / systems::npcs (`Interaction` special effect 10): the former C# class was a TODO stub. The 1.2 `special_effects` rows put a `WorldInteractionType` in `value1` (row 11030: 19 `Use`, 36: 10 `DigTerrain`, 215: 29 `SummonBeanstalk`) and an optional doodad id in @@ -1732,6 +1747,8 @@ servers (see `rust/LIVE-TESTING.md`). Fixed porting bugs are in the git history item task packets queued earlier (the C# sends those inline first too). `quests::events::with_quests` logs an error and returns `None` when the thread already holds the ops lock instead of hanging. +* `CharacterManager.Create` saved only the `characters` row (`SaveDirectlyToDatabase`); the starting supplies (`item_containers` / `items`) waited for the next `SaveManager` run or the departure save. A server stop or crash in that window kept the character but lost its items, and the next select built empty containers. `db_character::save_new_character_locked` now writes the new character's dirty containers and items in the same transaction (`ItemManager::prepare_save_for_owner`). Creation holds the save transaction lock from before inventory registration through commit or cleanup; setup errors and failed saves discard the rejected containers/items before releasing the name and character ID, without consuming other owners' changes or queued deletions. Canceled item deletions are recorded at each starter allocation, including IDs another owner releases after setup begins, and restored on rollback. Suite `rust/verify/newchar-items.vtest` uses a fresh character on every run, including reruns of its provisioned account. + Parity status of the scripted scenarios: `login`, `lobby` and `full` (fresh character) produce the same S->C traffic as the C# servers after id / time normalisation (0 findings); a second `full` round with the existing character only differs in the saved position precision above @@ -2403,8 +2420,8 @@ two bots before the fix (a foreign `Mount` caster, an NPC-only skill and a far d - **Mount caster.** `SkillCaster::Mount { obj_id }` may name the player itself, a mate the player may use (`may_use_mate`), or a slave the player summoned (`summoner_obj_id` / `summoner_id`), - is attached to (`attached_characters`, or `parent_obj_id`), or that is mounted on a slave the - player summoned (cannon on a ship). Any other object (NPC, doodad, another player, a foreign + is attached to (`attached_characters`, or `parent_obj_id`), or that is a harpoon mounted on a + slave the player summoned. A ship cannon (kind 8 child) answers only its gunner. Any other object (NPC, doodad, another player, a foreign slave) is refused with a warning and `SCSkillStarted` carrying `NO_PERM`. - **Range of doodad and slave targets.** The C# skipped the `TooFarRange` check for every Doodad or Slave target (its own TODO asks for a bounding-box check). The Rust now allows @@ -2502,3 +2519,97 @@ running in place). Four mirrored C# bugs and one missing safeguard: `flow_tests::follow_path_command_set_walks_every_route_point` runs the real command-set shape over three routes with an elevated point and checks every point is targeted in order, the set finishes and the NPC settles in HoldPosition without further movement. + +## Slave summon placement and equipment (2026-10-22) + +- **SummonPos placement.** The 1.2 C# `SpawnSlave` special effect ignored `targetObj` and + always called `SlaveManager.Create(owner, skillData)`; the Rust port now follows the 10.x + `Skill.GetInitialTarget` / placement path. A `SummonPos` cast resolves the client-chosen spot + (world coordinates / yaw, including the `ObjId1` basis transform), validation sees that spot + (range, angle, obstacle, `target_only_water`) and the spawn uses it instead of the owner's + in-front offset. The spot is rejected (with `ErrorMessageType.SlaveSpawnErrorInvalidArea`, + 583) and the 1.2 C# in-front placement is used when it is farther than + `slaves.spawn_valid_area_range` / the skill's `MaxRange` (the smaller nonzero limit; the boat + summon 15802 has `MaxRange` 0), when a ship spot is not on water, when a land-vehicle spot is + in water, or when a 0.5 m sphere just above the surface overlaps collision (`mask::SOLID`). + Skill 15802 also needs the 10.x `unboundedPlacement` rule: a position target with + `MaxRange <= 0` is not rejected as `TooFarRange`. +- **`CSChangeSlaveEquipmentPacket`.** The 1.2 C# read only the header and logged it ("coming + soon"), so the implementation follows the 10.x packet logic (`e533e88b6`, C# `develop` + 2026-08-02) adapted to the 1.2 + client writer: `characterId u32`, `slaveTl u16`, `dbSlaveId u32`, `bts bool`, **one** item + pair and the four location bytes (`397d12a0`; the 10.x `num` and per-entry `expireTime` do not + exist in 1.2). Equip / unequip / re-slot move the item between the owner's bag and the slave's + persistent `EquipmentSlave` container (`SlotType 0xF2`, `ContainerKind::Equipment`, + `item_containers.mate_id` = slave DB id); the pre-move server snapshots are echoed in + `SCSlaveEquipmentChangedPacket(success)`, and the changed slots are broadcast as + `SCUnitEquipmentsChanged`, followed by `SCUnitPoints` when a part carries MaxHealth. Item + tasks go through the economy's `SplitOrMoveItemEx` (`ItemTaskType.Invalid`, as in C#), and the + slave model mirror is refreshed before `UpdateGearBonuses` / pool refresh. +- **Ship parts.** Items with `item_impl = 28` (`ItemImplEnum.SlaveEquipment`) are now + `ItemClass::SlaveEquipment` with `ItemDetailType.SlaveEquipment` (12 opaque detail bytes); + `read_wire_item` consumes detail bytes by detail type (gear 55, ship parts 12, ...) instead of + always reading an `EquipItem`. Bind-on-equip applies in `EquipmentSlave` too. A player-owned + slave gets its starter pack when its equipment container is first created, including a saved + legacy hull whose summon item already names its DB id. An existing empty container represents + intentional unequipping and is reused on the next summon / restart without seeding again. + NPC / spawner slaves keep the in-memory defaults. +- **Deviation from 1.2:** slave equipment persistence and the `0xF2` container do not exist in + the 1.2 C# at all; they are the 10.x design, recorded here because the 1.2 data already ships + `slave_initial_items`, `slave_equip_slots` and `item_slave_equipments`. +- **Equipment validation (1.2 data):** equipping checks the item's + `item_slave_equipments.slave_equip_pack_id` against `allow_to_equip_slaves` (the hull) and its + `slot_pack_id` against `allow_to_equip_slots` (the target slot); the hull must also declare the + slot in `slave_equip_slots`. A refused move sends `ErrorMessageType.ItemNotForPet` (204; the + 1.2 client's "can't use that item on a summon" message) and moves nothing. 10.x trusted the + client for this; its `SLAVE_EQUIP_ERROR_REQUIRE_SLOT_AND_ITEM` / `..._UNEQUIP_FIRST` (804/805) + are for the client's slot-dependency rules, not for a part the hull does not accept. +- **Equipment visuals (10.x `SpawnEquipmentVisualsFromInventory`):** every occupied equipment + slot spawns what `item_slave_equipments` maps it to at the slot's `slave_equip_slots` attach + points: a child slave (Steel Cannon 28852 -> slave 10, Harpoon Cannon 30306 -> slave 48) or a + doodad (sails, masts, lamps, planks, figureheads, bell, telescope, ...). A slot that drives two + points (front/rear lamp, both planks) spawns the visual at both. Unequipping removes exactly + that visual; a resummon respawns it from the persistent container. Static bindings are skipped + only for slots with initial equipment, so deliberately unequipped parts remain absent. An + authored default without an exact legal equipment equivalent remains a static binding. +- **Starter pack:** `slave_initial_items` rows are seeded only into slots the hull declares in + `slave_equip_slots` (slave 110 / 139 reference pack 1 without those slots; slave 21 has slot 0 + at the cannon points and no starter cannons). Missing defaults are inferred from static + bindings only when one legal item reproduces every binding of the slot (lowest item id breaks + ties deterministically). The item template must also exist: hull 21's slot-0 cannon visual + references missing item 28854, so all eight cannons remain static. Hull 14/75's static lamps + also have no equivalent equipment item. Real-data spawn regressions + cover hulls 14, 21, 75, 76 and 110; synthetic and MySQL restart tests cover initialization and + persistent empty slots (`vehicles/pr38_regression_tests.rs`). +- **Attach points:** models 511 (slave 22), 1482 (slave 132) and 1546 (slaves 139/142/143/145) + were recovered from the `$` helper nodes of the 1.2 client's `galleon_body_test.cgf`, + `boardship_body_test.cgf` and `middleship_body.cgf` (CGF units / 100, the same method and + values as the existing Clipper entry). Model 115 (`caravel.ship_body`) references a caravel + mesh that is not in the 1.2 pak, and model 117 (`galleon.cannon`, the cannon's gunner seat) is + an Entity `.chr` whose only node is its root (no `$` helpers), so those two still have no table + entry. +- **No equipment skill link:** the 1.2 C# never connected equipped parts to cannon / vehicle + skills; slave mount skills still come from `slave_mount_skills`. The child slaves spawned for + equipment are visuals with the normal child-slave behaviour, as in the 10.x reference. +- **Manned ship cannons (deviation, the C# has none of this):** a kind-8 slave mounted on another + slave (`slaves::is_manned_cannon`) has one gunner seat, attach point 1 (the `mount_attached_skills` + row of mount skill 16 / Fire Cannon 10473 -> skill 14372). `CSBindSlave` on it is refused with + `SLAVE_CANNOT_BIND` unless the character summoned the cannon, owns the carrier ship or is aboard + it (standing on it or seated on any of its points; the 1.2 data has no seat permission table, so + party / expedition membership is not required), with `SLAVE_ALREADY_HAS_MASTER` when the seat is + taken and `SLAVE_UNBIND_FIRST` when the character already rides another slave. Only the gunner + may cast the cannon's mount skills (`mount_authority::may_use_slave`): its DRIVER seat must name + the player, and the player's attach point and transform parent must match. Standing on the + cannon alone grants no shot, even when the seat is empty. The carrier's owner no + longer fires it remotely. The gunner leaves through `CSDiscardSlave`, death (`on_death_event`), + teleport / `force_dismount`, the cannon being unequipped, or the carrier being recalled, + destroyed or despawned (`unbind_child_riders`). Carrier death detaches child riders before + deleting their cannons, preserving world coordinates, clearing seats and sending `SCUnitDetached`. + The gunner sits at the model's driver helper if + `slave_attach_points*.json` has one, else at `GUNNER_SEAT_OFFSET` (0, -0.8, 0) in the cannon + frame: model 117 has no helper in the data or the pak, and no cannon-like model with a seat helper + exists, so this is a documented constant. The gunner is a transform child of the cannon, which is + a child of the ship, so the position follows the moving ship. Fire Cannon is a ballistic position + skill (4 m area, 4-120 m, fixed 130-170 damage); the area damage and the `SCSkillFired` broadcast + (the client draws the projectile from the skill's projectile 13) are covered by + `ship_cannon_gunner_seat_skill_and_leaving`. diff --git a/rust/crates/aaemu-game/app/Data/slave_attach_points.json b/rust/crates/aaemu-game/app/Data/slave_attach_points.json index 573622bb30..00b7b53005 100644 --- a/rust/crates/aaemu-game/app/Data/slave_attach_points.json +++ b/rust/crates/aaemu-game/app/Data/slave_attach_points.json @@ -2072,5 +2072,453 @@ "Z": 0.683005 } } + }, + { + "Name": "Small Sailing Ship", + "ModelId": 511, + "AttachPoints": { + "1": { + "X": 0.0, + "Y": -14.696714, + "Z": 6.208238 + }, + "9": { + "X": -4.292767, + "Y": 2.22774, + "Z": 4.420566 + }, + "10": { + "X": -4.476786, + "Y": 0.194722, + "Z": 4.48709 + }, + "11": { + "X": -4.571741, + "Y": -3.685339, + "Z": 4.641931 + }, + "12": { + "X": -4.464495, + "Y": -5.56138, + "Z": 4.74579 + }, + "13": { + "X": 4.308322, + "Y": 2.22774, + "Z": 4.420566 + }, + "14": { + "X": 4.492342, + "Y": 0.194722, + "Z": 4.48709 + }, + "15": { + "X": 4.587296, + "Y": -3.685339, + "Z": 4.641931 + }, + "16": { + "X": 4.48005, + "Y": -5.561381, + "Z": 4.745791 + }, + "17": { + "X": -0.025801, + "Y": -17.128943, + "Z": 6.531284 + }, + "19": { + "X": 0.0, + "Y": 10.391479, + "Z": 4.538411 + }, + "20": { + "X": 0.0, + "Y": -2.67354, + "Z": 4.55663 + }, + "21": { + "X": 0.0, + "Y": 10.391479, + "Z": 4.538411 + }, + "22": { + "X": 0.0, + "Y": -2.67354, + "Z": 4.556628 + }, + "23": { + "X": 0.0, + "Y": 13.82891, + "Z": 4.65069 + }, + "24": { + "X": -5.42189, + "Y": -1.698234, + "Z": -2.22113 + }, + "25": { + "X": 5.378184, + "Y": -1.698235, + "Z": -2.22113 + }, + "26": { + "X": -5.369734, + "Y": -1.676039, + "Z": 4.52554 + }, + "27": { + "X": 5.371309, + "Y": -1.6907, + "Z": 4.52554 + }, + "28": { + "X": -3.714641, + "Y": -10.47772, + "Z": 7.13656 + }, + "29": { + "X": 3.720835, + "Y": -10.465177, + "Z": 7.165107 + }, + "35": { + "X": 0.000382, + "Y": -13.99762, + "Z": 6.924236 + }, + "36": { + "X": 1.191211, + "Y": 14.183796, + "Z": 5.122476 + }, + "37": { + "X": 5.116659, + "Y": -0.73, + "Z": 3.333826 + }, + "38": { + "X": -0.246523, + "Y": -8.880871, + "Z": 5.260171 + }, + "39": { + "X": -0.929879, + "Y": -10.47738, + "Z": 1.97259 + }, + "47": { + "X": 2.427248, + "Y": -11.812762, + "Z": 5.96707 + }, + "48": { + "X": -4.162631, + "Y": -7.366074, + "Z": 1.911389 + }, + "49": { + "X": -3.885207, + "Y": -8.409836, + "Z": 1.809706 + }, + "50": { + "X": -3.664501, + "Y": -9.193998, + "Z": 1.661757 + }, + "51": { + "X": 3.809257, + "Y": -7.199599, + "Z": 1.944338 + }, + "52": { + "X": 4.052564, + "Y": -8.259335, + "Z": 1.841062 + }, + "53": { + "X": 3.627266, + "Y": -9.254662, + "Z": 1.70237 + }, + "57": { + "X": 0.0, + "Y": 20.088551, + "Z": 2.331362 + }, + "58": { + "X": -1.04452, + "Y": -14.868832, + "Z": -2.14507 + }, + "59": { + "X": 1.044517, + "Y": -14.868833, + "Z": -2.145065 + }, + "60": { + "X": 0.728445, + "Y": 2.223569, + "Z": 4.417754 + }, + "61": { + "X": -0.599329, + "Y": 2.159536, + "Z": 4.417754 + }, + "62": { + "X": -0.599328, + "Y": 3.448201, + "Z": 4.417754 + }, + "63": { + "X": 0.772781, + "Y": 3.559707, + "Z": 4.420332 + }, + "80": { + "X": 0.0, + "Y": -0.176037, + "Z": 34.136924 + }, + "81": { + "X": -0.078262, + "Y": -3.463748, + "Z": 38.546055 + } + } + }, + { + "Name": "Boardship 01", + "ModelId": 1482, + "AttachPoints": { + "1": { + "X": 0.0, + "Y": -12.510923, + "Z": 5.880291 + }, + "9": { + "X": -3.710351, + "Y": 6.579856, + "Z": 4.430594 + }, + "10": { + "X": -3.864485, + "Y": 4.429982, + "Z": 4.363184 + }, + "11": { + "X": -4.130303, + "Y": 0.244452, + "Z": 4.36447 + }, + "12": { + "X": -4.238666, + "Y": -1.731479, + "Z": 4.368301 + }, + "13": { + "X": 3.708737, + "Y": 6.579856, + "Z": 4.375907 + }, + "14": { + "X": 3.868636, + "Y": 4.448067, + "Z": 4.361554 + }, + "15": { + "X": 4.127504, + "Y": 0.32134, + "Z": 4.36428 + }, + "16": { + "X": 4.233886, + "Y": -1.706295, + "Z": 4.354098 + }, + "19": { + "X": 0.0, + "Y": 10.642557, + "Z": 4.495363 + }, + "20": { + "X": 0.0, + "Y": -1.152741, + "Z": 3.672005 + }, + "21": { + "X": 0.0, + "Y": 10.642557, + "Z": 4.495363 + }, + "22": { + "X": 0.0, + "Y": -1.152742, + "Z": 3.672005 + }, + "23": { + "X": 0.0, + "Y": 19.774658, + "Z": 5.438883 + }, + "24": { + "X": -5.171741, + "Y": 2.380774, + "Z": -2.221128 + }, + "25": { + "X": 5.159675, + "Y": 2.380774, + "Z": -2.221128 + }, + "26": { + "X": -5.139448, + "Y": 2.403407, + "Z": 4.383686 + }, + "27": { + "X": 5.134194, + "Y": 2.39589, + "Z": 4.383686 + }, + "28": { + "X": -4.000776, + "Y": -14.896173, + "Z": 7.301553 + }, + "29": { + "X": 4.028566, + "Y": -14.892327, + "Z": 7.301553 + }, + "35": { + "X": 0.0, + "Y": -11.811825, + "Z": 6.59629 + }, + "36": { + "X": 2.76042, + "Y": 15.242299, + "Z": 5.08637 + }, + "37": { + "X": -3.167246, + "Y": 12.138176, + "Z": 4.900893 + }, + "38": { + "X": -4.064834, + "Y": -4.082207, + "Z": 5.016424 + }, + "39": { + "X": 4.24207, + "Y": -8.774927, + "Z": 5.147105 + }, + "47": { + "X": 2.624988, + "Y": -17.204258, + "Z": 4.381397 + }, + "48": { + "X": -3.93576, + "Y": -8.923267, + "Z": 1.543295 + }, + "49": { + "X": -3.638052, + "Y": -10.043942, + "Z": 1.19631 + }, + "50": { + "X": -3.540766, + "Y": -11.441772, + "Z": 0.917408 + }, + "51": { + "X": 3.995122, + "Y": -8.923267, + "Z": 1.543295 + }, + "52": { + "X": 3.916255, + "Y": -10.332164, + "Z": 1.19631 + }, + "53": { + "X": 4.02451, + "Y": -11.441772, + "Z": 0.987061 + }, + "57": { + "X": 0.0, + "Y": 23.366628, + "Z": 2.45782 + }, + "58": { + "X": -1.813038, + "Y": -15.16531, + "Z": -2.88983 + }, + "59": { + "X": 1.792523, + "Y": -15.16531, + "Z": -2.88983 + }, + "60": { + "X": -0.739297, + "Y": 16.271682, + "Z": 5.179478 + }, + "61": { + "X": 0.688232, + "Y": 16.225596, + "Z": 5.181328 + }, + "62": { + "X": -0.743975, + "Y": 6.372867, + "Z": 4.397502 + }, + "63": { + "X": 0.761367, + "Y": 6.380472, + "Z": 4.401007 + }, + "80": { + "X": 0.0, + "Y": 7.78082, + "Z": 4.53405 + }, + "81": { + "X": 0.0, + "Y": -9.061644, + "Z": 9.73219 + } + } + }, + { + "Name": "Middleship", + "ModelId": 1546, + "AttachPoints": { + "1": { + "X": 0.006367, + "Y": -24.590676, + "Z": 10.10764 + }, + "10": { + "X": 0.0, + "Y": -20.147593, + "Z": 0.0 + }, + "35": { + "X": 0.006367, + "Y": -22.123501, + "Z": 11.144756 + } + } } -] \ No newline at end of file +] diff --git a/rust/crates/aaemu-game/src/data/items.rs b/rust/crates/aaemu-game/src/data/items.rs index 80eac2d9be..7c3a01d93a 100644 --- a/rust/crates/aaemu-game/src/data/items.rs +++ b/rust/crates/aaemu-game/src/data/items.rs @@ -806,6 +806,9 @@ impl ItemTemplate { /// `ItemTemplate.ClassType`. pub fn class_type(&self) -> ItemClass { + if self.impl_id == item_impl::SLAVE_EQUIPMENT { + return ItemClass::SlaveEquipment; + } match self.kind { TemplateKind::Item => ItemClass::Item, TemplateKind::Armor(_) => ItemClass::Armor, diff --git a/rust/crates/aaemu-game/src/db_character.rs b/rust/crates/aaemu-game/src/db_character.rs index 41e35d53ad..85644f1611 100644 --- a/rust/crates/aaemu-game/src/db_character.rs +++ b/rust/crates/aaemu-game/src/db_character.rs @@ -1179,13 +1179,47 @@ async fn save_active_buffs(tx: &mut Transaction<'_, MySql>, c: &Character) { /// the state it had before the call (`save_character` advances `updated` and clears the removed /// lists while it works, so it runs on a clone that is applied only after the commit). pub async fn save_directly_to_database(pool: &MySqlPool, c: &mut Character) -> bool { + save_directly(pool, c, None).await +} + +/// Character creation: [`save_directly_to_database`] plus the new character's containers and +/// items in the same transaction (the C# left them to the next world save, so a stop or crash +/// before it kept the `characters` row but lost the starting supplies; the next select then +/// built empty containers). +/// The caller holds `server.save.transaction_lock()` from before inventory registration +/// until commit or cleanup, excluding world snapshots of a partially created character. +pub(crate) async fn save_new_character_locked(server: &GameServer, c: &mut Character) -> bool { + let batch = server.items.prepare_save_for_owner(c.id); + save_directly(&server.db, c, Some((&server.items, batch))).await +} + +async fn save_directly( + pool: &MySqlPool, + c: &mut Character, + items: Option<( + &crate::managers::item::ItemManager, + crate::managers::item::ItemSaveBatch, + )>, +) -> bool { let mut saved = c.clone(); + let manager = items.as_ref().map(|(manager, _)| *manager); let res: Result<()> = async { let mut tx = pool.begin().await?; let now = Utc::now().timestamp(); - match save_character(&mut tx, &mut saved, now).await { + let written = async { + save_character(&mut tx, &mut saved, now).await?; + if let Some((manager, batch)) = items { + manager.write_prepared(&mut tx, batch).await?; + } + Ok::<(), GameError>(()) + } + .await; + match written { Ok(()) => { tx.commit().await?; + if let Some(manager) = manager { + manager.commit_save(); + } Ok(()) } Err(e) => { @@ -1802,6 +1836,100 @@ mod tests { pool.close().await; } + /// Character creation writes the starting supplies together with the `characters` row: a + /// stop before the next world save must not keep the character but lose its items. + #[tokio::test] + #[ignore = "requires private MySQL3317 via AAEMU_TEST_MYSQL; uses only temporary tables"] + async fn private_mysql_new_character_items_are_saved_with_the_character() { + use crate::systems::social::achievement_persistence::temporary_shadow_definition; + use crate::test_support::test_character; + + let Ok(url) = std::env::var("AAEMU_TEST_MYSQL") else { + return; + }; + let options = MySqlConnectOptions::from_str(&url).expect("valid private MySQL URL"); + assert_eq!( + options.get_port(), + 3317, + "only private MySQL3317 is allowed" + ); + assert!(matches!(options.get_host(), "127.0.0.1" | "localhost")); + let pool = MySqlPoolOptions::new() + .max_connections(1) + .connect_with(options) + .await + .expect("private MySQL"); + for table in [ + "items", + "item_containers", + "characters", + "options", + "abilities", + "actabilities", + "appellations", + "character_active_buffs", + "portal_book_coords", + "portal_visited_district", + "friends", + "blocked", + "skills", + "quests", + "completed_quests", + "accounts", + "character_records", + "character_achievements", + ] { + let (_, definition): (String, String) = + sqlx::query_as(&format!("SHOW CREATE TABLE `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + sqlx::query(&temporary_shadow_definition(&definition)) + .execute(&pool) + .await + .unwrap(); + } + sqlx::query("INSERT INTO `accounts` (`account_id`, `labor`) VALUES (1007, 1000)") + .execute(&pool) + .await + .unwrap(); + + let mut data = crate::data::GameData::empty(); + let mut template = crate::data::items::ItemTemplate::plain(1000, 20); + template.name = "Starter".into(); + data.items.templates.insert(1000, template); + let mut server = crate::test_support::test_server_with(data); + server.db = pool.clone(); + let mut c = test_character(7, "Newbie", 500.0, 500.0); + c.inventory = Inventory::new(7, 50, 50, &server.items, &server.ids.container); + let item = server + .items + .create(1000, 1, 0, 1, &server.game_data.items, &server.ids.item, 0) + .expect("item"); + let item_id = item.id; + c.inventory + .bag() + .lock() + .unwrap() + .add_new_item(item, 0, &server.game_data.items) + .expect("fits"); + + let _transaction = server.save.transaction_lock().await; + assert!(save_new_character_locked(&server, &mut c).await); + + let rows: i64 = sqlx::query_scalar( + "SELECT COUNT(*) FROM items i JOIN item_containers ic ON ic.container_id = i.container_id WHERE ic.owner_id = 7 AND i.id = ?", + ) + .bind(item_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(rows, 1); + // The rows are marked clean, so the next world save does not rewrite them. + assert!(server.items.prepare_save_for_owner(7).item_ids().is_empty()); + pool.close().await; + } + #[tokio::test] async fn learn_skill_load_refuses_a_skill_above_the_ability_level() { // A stored attribute-less ability_level 99 row (as a pre-fix server could write) is not diff --git a/rust/crates/aaemu-game/src/managers/character.rs b/rust/crates/aaemu-game/src/managers/character.rs index fa6cb2ad44..f3759a97a5 100644 --- a/rust/crates/aaemu-game/src/managers/character.rs +++ b/rust/crates/aaemu-game/src/managers/character.rs @@ -12,7 +12,7 @@ use crate::data::character_templates::EquipItemsTemplate; use crate::data::items::{bind_type, ItemTemplate}; use crate::db::get_account_details; use crate::db_character::{ - check_for_deleted_characters, is_character_pending_deletion, save_directly_to_database, + check_for_deleted_characters, is_character_pending_deletion, save_new_character_locked, set_delete_times, }; use crate::error::{GameError, Result}; @@ -49,11 +49,50 @@ pub struct CreateCharacterRequest { /// `ItemContainer.AcquireDefaultItem(ItemTaskType.Invalid, templateId, amount, grade)`. pub fn acquire_default_item( + server: &GameServer, + container: &ContainerRef, + template_id: u32, + amount: i32, + grade: i32, +) -> Result { + acquire_default_item_recorded( + server, + container, + template_id, + amount, + grade, + &mut Vec::new(), + ) +} + +fn create_starting_item( + server: &GameServer, + template_id: u32, + amount: i32, + grade: u8, + now: i64, + created_items: &mut Vec<(u64, bool)>, +) -> Option { + let (item, canceled_deletion) = server.items.create_with_deletion( + template_id, + amount, + grade, + server.config.id, + &server.game_data.items, + &server.ids.item, + now, + )?; + created_items.push((item.id, canceled_deletion)); + Some(item) +} + +fn acquire_default_item_recorded( server: &GameServer, container: &ContainerRef, template_id: u32, mut amount: i32, grade: i32, + created_items: &mut Vec<(u64, bool)>, ) -> Result { if amount <= 0 { return Ok(true); @@ -107,15 +146,9 @@ pub fn acquire_default_item( drop(c); while amount > 0 { let add = amount.min(template.max_count); - let Some(mut item) = server.items.create( - template_id, - add, - grade as u8, - server.config.id, - data, - &server.ids.item, - now, - ) else { + let Some(mut item) = + create_starting_item(server, template_id, add, grade as u8, now, created_items) + else { tracing::error!( "Failed to add item with ID {template_id}, possible duplicate entries!" ); @@ -181,19 +214,19 @@ fn set_equip_item_template( template_id: u32, slot: i32, grade: u8, + created_items: &mut Vec<(u64, bool)>, ) -> Option { if template_id == 0 { return None; // AddOrMoveExistingItem(null) -> false } let data = &server.game_data.items; - let Some(mut item) = server.items.create( + let Some(mut item) = create_starting_item( + server, template_id, 1, grade, - server.config.id, - data, - &server.ids.item, Utc::now().timestamp(), + created_items, ) else { // Create returned null -> AddOrMoveExistingItem(null). return None; @@ -219,6 +252,7 @@ fn equip_pack( inv: &Inventory, i: &EquipItemsTemplate, on_equip: &mut dyn FnMut(&Item), + created_items: &mut Vec<(u64, bool)>, ) { use equip_slot::*; for (slot, (id, grade)) in [ @@ -239,12 +273,35 @@ fn equip_pack( (MUSICAL, i.musical), (COSPLAY, i.cosplay), ] { - if let Some(item) = set_equip_item_template(server, inv, id, slot, grade) { + if let Some(item) = set_equip_item_template(server, inv, id, slot, grade, created_items) { on_equip(&item); } } } +/// Declared after the save lock so rejected assets disappear before saves or ID reuse. +struct NewCharacter<'a> { + server: &'a GameServer, + id: u32, + created_items: Vec<(u64, bool)>, + committed: bool, +} + +impl Drop for NewCharacter<'_> { + fn drop(&mut self) { + if !self.committed { + self.server.items.discard_new_character( + self.id, + &self.created_items, + &self.server.ids.item, + &self.server.ids.container, + ); + self.server.names.remove_character_id(self.id); + self.server.ids.character.release_id(self.id); + } + } +} + /// `CharacterManager.Create`. pub async fn create( server: &GameServer, @@ -281,11 +338,20 @@ pub async fn create( .access_level_first_character .max(access_level); } + // Inventory::new registers containers immediately. Exclude world/departure snapshots + // throughout setup, SQL commit and failure cleanup, including setup errors below. + let _transaction = server.save.transaction_lock().await; let id = server .ids .character .get_next_id() .map_err(|e| GameError::Protocol(e.to_string()))?; + let mut creation = NewCharacter { + server, + id, + created_items: Vec::new(), + committed: false, + }; server.names.add_character(id, &name, conn.account_id()); let data = &server.game_data; let template = data @@ -358,14 +424,27 @@ pub async fn create( let mut gear = |item: &Item| { crate::systems::skills::stats::update_gear_bonuses(server, &player, Some(item), None); }; - equip_pack(server, &inv, &items.items, &mut gear); + equip_pack( + server, + &inv, + &items.items, + &mut gear, + &mut creation.created_items, + ); for (i, &body) in req.body_items.iter().enumerate() { let item = if body == 0 && template.items[i] > 0 { template.items[i] } else { body }; - if let Some(item) = set_equip_item_template(server, &inv, item, i as i32 + 19, 0) { + if let Some(item) = set_equip_item_template( + server, + &inv, + item, + i as i32 + 19, + 0, + &mut creation.created_items, + ) { gear(&item); } } @@ -377,7 +456,14 @@ pub async fn create( let mut slot = 10usize; let bag = c.inventory.bag().clone(); for s in &items.supplies { - acquire_default_item(server, &bag, s.id, s.amount, i32::from(s.grade))?; + acquire_default_item_recorded( + server, + &bag, + s.id, + s.amount, + i32::from(s.grade), + &mut creation.created_items, + )?; c.set_action(slot, ActionSlotType::ItemType, u64::from(s.id)); slot += 1; } @@ -388,7 +474,14 @@ pub async fn create( .cloned() .ok_or_else(|| GameError::Protocol("no ability items for ability 0".into()))?; for s in &general.supplies { - acquire_default_item(server, &bag, s.id, s.amount, i32::from(s.grade))?; + acquire_default_item_recorded( + server, + &bag, + s.id, + s.amount, + i32::from(s.grade), + &mut creation.created_items, + )?; c.set_action(slot, ActionSlotType::ItemType, u64::from(s.id)); slot += 1; } @@ -412,7 +505,8 @@ pub async fn create( c.unit.mp = c.unit.max_mp; c.restore_saved_hp_mp(); - if save_directly_to_database(&server.db, &mut c).await { + if save_new_character_locked(server, &mut c).await { + creation.committed = true; let resp = create_character_response(&c); conn.characters.push(c); conn.send(&resp); @@ -421,13 +515,6 @@ pub async fn create( conn.send(&SCCharacterCreationFailedPacket { reason: CharacterCreateError::Failed as u8, }); - server.ids.character.release_id(id); - server.names.remove_character_id(id); - // DeleteCharacterAssets(character, true): houses / guild / family / mails are later - // phases ("fullWipe is currently not implemented yet" in C# too). - tracing::warn!( - "DeleteCharacterAssets - fullWipe is currently not implemented yet, charId: {id}" - ); } Ok(()) } diff --git a/rust/crates/aaemu-game/src/managers/character_tests.rs b/rust/crates/aaemu-game/src/managers/character_tests.rs index e9345dd403..18941fd11e 100644 --- a/rust/crates/aaemu-game/src/managers/character_tests.rs +++ b/rust/crates/aaemu-game/src/managers/character_tests.rs @@ -12,7 +12,7 @@ use crate::models::char_data::{read_action_slots, ActionSlot, ActionSlotType, MA use crate::models::character::Character; use crate::test_support::test_server_with; -use super::initialize_starting_skills; +use super::{create, initialize_starting_skills, CreateCharacterRequest}; const STARTERS: [(u8, u32); 10] = [ (1, 18132), @@ -71,6 +71,462 @@ fn new_character(ability: u8) -> Character { c } +fn creation_data() -> GameData { + use crate::data::character_templates::{ + AbilityItems, AbilitySupplyItem, CharacterTemplate, EquipItemsTemplate, + }; + use crate::data::items::{EquipTemplate, ItemTemplate, TemplateKind}; + let mut data = starting_skill_data(); + data.experience = crate::test_support::test_experience(10); + data.characters.templates.insert( + 17, + CharacterTemplate { + race: 1, + gender: 1, + num_inventory_slot: 50, + num_bank_slot: 50, + ..Default::default() + }, + ); + let mut armor = ItemTemplate::plain(2000, 1); + armor.kind = TemplateKind::Armor(EquipTemplate { + slot_type_id: 1, + ..Default::default() + }); + data.items.templates.insert(2000, armor); + for id in [2001, 2002] { + data.items + .templates + .insert(id, ItemTemplate::plain(id, 1000)); + } + data.characters.ability_items.insert( + 7, + AbilityItems { + items: EquipItemsTemplate { + headgear: (2000, 0), + ..Default::default() + }, + supplies: vec![AbilitySupplyItem { + id: 2001, + amount: 2, + grade: 0, + }], + ..Default::default() + }, + ); + data.characters.ability_items.insert( + 0, + AbilityItems { + supplies: vec![AbilitySupplyItem { + id: 2002, + amount: 300, + grade: 0, + }], + ..Default::default() + }, + ); + data +} + +fn creation_request(name: &str) -> CreateCharacterRequest { + CreateCharacterRequest { + name: name.into(), + race: 1, + gender: 1, + body_items: [0; 7], + model_params: Default::default(), + ability1: 7, + ability2: 11, + ability3: 11, + level: 1, + } +} + +#[tokio::test] +async fn create_character_starting_kit_helpers_preserve_equipment_and_stacks() { + use crate::data::character_templates::EquipItemsTemplate; + use crate::data::items::{EquipTemplate, GradeTemplate, ItemTemplate, TemplateKind}; + use crate::models::character::Inventory; + + let mut data = GameData::empty(); + data.items.config.durability_const = 1.0; + data.items.grades.insert( + 0, + GradeTemplate { + grade: 0, + grade_order: 0, + durability: 1.0, + }, + ); + data.items.templates.insert( + 6001, + ItemTemplate { + kind: TemplateKind::Armor(EquipTemplate { + slot_type_id: 3, + coverage: 10, + durability_ratio: 1.0, + durability_multiplier: 100, + ..Default::default() + }), + ..ItemTemplate::plain(6001, 1) + }, + ); + data.items.templates.insert( + 7001, + ItemTemplate { + kind: TemplateKind::BodyPart { + slot_type_id: 23, + model_id: 1, + }, + ..ItemTemplate::plain(7001, 1) + }, + ); + data.items + .templates + .insert(8001, ItemTemplate::plain(8001, 10)); + let server = test_server_with(data); + let inventory = Inventory::new(1, 50, 50, &server.items, &server.ids.container); + let kit = EquipItemsTemplate { + shirt: (6001, 0), + ..Default::default() + }; + let mut created_items = Vec::new(); + super::equip_pack(&server, &inventory, &kit, &mut |_| {}, &mut created_items); + assert!( + super::set_equip_item_template(&server, &inventory, 7001, 19, 0, &mut created_items) + .is_some() + ); + assert!(super::acquire_default_item_recorded( + &server, + inventory.bag(), + 8001, + 25, + 0, + &mut created_items + ) + .unwrap()); + + let equipment = inventory.equipment().lock().unwrap(); + let chest = equipment.get_item_by_slot(2).unwrap(); + assert_eq!(chest.template_id, 6001); + assert_eq!(chest.details.durability, 10); + assert_eq!(equipment.get_item_by_slot(19).unwrap().template_id, 7001); + drop(equipment); + let mut stacks: Vec<_> = inventory + .bag() + .lock() + .unwrap() + .items + .iter() + .map(|item| (item.slot, item.template_id, item.count)) + .collect(); + stacks.sort_unstable(); + assert_eq!(stacks, vec![(0, 8001, 10), (1, 8001, 10), (2, 8001, 5)]); +} + +#[tokio::test] +async fn new_character_setup_error_discards_inventory_before_id_reuse() { + let mut data = creation_data(); + data.skills = Default::default(); // fails after containers, equipment and supplies exist + let server = test_server_with(data); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + assert!( + create(&server, &mut client.conn, creation_request("Rejected")) + .await + .is_err() + ); + assert!( + server.items.all_containers().is_empty(), + "rejected inventory remains globally saveable" + ); + assert!(!server.names.name_exists("Rejected")); + assert_eq!(server.ids.character.get_next_id().unwrap(), 1); + assert_eq!( + server.ids.item.get_next_id().unwrap(), + crate::managers::id::ITEM_ID.first_id + ); + assert_eq!( + server.ids.container.get_next_id().unwrap(), + crate::managers::id::CONTAINER_ID.first_id + ); + assert!(client.conn.characters.is_empty()); +} + +#[tokio::test] +async fn new_character_registration_waits_for_world_save_lock() { + let server = test_server_with(creation_data()); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + let transaction = server.save.transaction_lock().await; + let creation = create(&server, &mut client.conn, creation_request("Waiting")); + tokio::pin!(creation); + assert!( + tokio::time::timeout(std::time::Duration::from_millis(50), &mut creation) + .await + .is_err() + ); + assert!( + server.items.all_containers().is_empty(), + "world save can see uncommitted starter items" + ); + assert!(!server.names.name_exists("Waiting")); + drop(transaction); + tokio::time::timeout(std::time::Duration::from_secs(2), creation) + .await + .unwrap() + .unwrap(); + assert!(server.items.all_containers().is_empty()); + assert!(!server.names.name_exists("Waiting")); +} + +#[tokio::test] +async fn new_character_cleanup_restores_a_deletion_queued_after_setup_started() { + use crate::models::character::Inventory; + let server = test_server_with(creation_data()); + let unrelated = Inventory::new(99, 50, 50, &server.items, &server.ids.container); + let deleted = server + .items + .create(2001, 4, 0, 1, &server.game_data.items, &server.ids.item, 0) + .unwrap(); + let deleted_id = deleted.id; + unrelated + .bag() + .lock() + .unwrap() + .add_new_item(deleted, 0, &server.game_data.items) + .unwrap(); + let survivor = server + .items + .create(2002, 5, 0, 1, &server.game_data.items, &server.ids.item, 0) + .unwrap(); + let survivor_id = survivor.id; + unrelated + .bag() + .lock() + .unwrap() + .add_new_item(survivor, 1, &server.game_data.items) + .unwrap(); + + let _transaction = server.save.transaction_lock().await; + let id = server.ids.character.get_next_id().unwrap(); + server.names.add_character(id, "Rejected", 1007); + let mut creation = super::NewCharacter { + server: &server, + id, + created_items: Vec::new(), + committed: false, + }; + let inventory = Inventory::new(id, 50, 50, &server.items, &server.ids.container); + assert!(server.items.removed_items().is_empty()); + // Another owner's ItemTxn can queue/release an ID AFTER setup begins: the save lock + // excludes database snapshots, not these synchronous item mutations. + { + let _economy = server.systems.economy.ops_lock(); + let mut bag = unrelated.bag().lock().unwrap(); + let index = bag.items.iter().position(|i| i.id == deleted_id).unwrap(); + bag.items.remove(index); + server.items.release_id(deleted_id, &server.ids.item); + } + server.items.mark_for_db_deletion(0x0100_0099); + super::acquire_default_item_recorded( + &server, + inventory.bag(), + 2001, + 2, + 0, + &mut creation.created_items, + ) + .unwrap(); + assert_eq!( + creation.created_items, + vec![(deleted_id, true)], + "canceled deletion must be captured at allocation" + ); + assert_eq!(server.items.removed_items(), vec![0x0100_0099]); + drop(creation); + + let mut removed = server.items.removed_items(); + removed.sort_unstable(); + assert_eq!(removed, vec![deleted_id, 0x0100_0099]); + assert!(inventory.bag().lock().unwrap().items.is_empty()); + assert!(server.items.item_by_id(deleted_id).is_none()); + assert_eq!(server.items.item_by_id(survivor_id).unwrap().count, 5); + assert_eq!(server.items.prepare_save().item_ids(), vec![survivor_id]); + assert!(server + .items + .all_containers() + .iter() + .all(|c| c.lock().unwrap().owner_id == 99)); + assert!(!server.names.name_exists("Rejected")); + assert_eq!(server.ids.character.get_next_id().unwrap(), id); +} + +#[tokio::test] +#[ignore = "requires private MySQL3317 via AAEMU_TEST_MYSQL; uses only temporary tables"] +async fn private_mysql_new_character_later_item_failure_cleans_up_before_id_reuse() { + use crate::models::character::Inventory; + use crate::systems::social::achievement_persistence::temporary_shadow_definition; + use sqlx::mysql::{MySqlConnectOptions, MySqlPoolOptions}; + use std::str::FromStr; + + let Ok(url) = std::env::var("AAEMU_TEST_MYSQL") else { + return; + }; + let options = MySqlConnectOptions::from_str(&url).expect("valid private MySQL URL"); + assert_eq!( + options.get_port(), + 3317, + "only private MySQL3317 is allowed" + ); + assert!(matches!(options.get_host(), "127.0.0.1" | "localhost")); + let pool = MySqlPoolOptions::new() + .max_connections(1) + .connect_with(options) + .await + .unwrap(); + for table in [ + "items", + "item_containers", + "characters", + "options", + "abilities", + "actabilities", + "appellations", + "character_active_buffs", + "portal_book_coords", + "portal_visited_district", + "friends", + "blocked", + "skills", + "quests", + "completed_quests", + "accounts", + "character_records", + "character_achievements", + ] { + let (_, definition): (String, String) = + sqlx::query_as(&format!("SHOW CREATE TABLE `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + sqlx::query(&temporary_shadow_definition(&definition)) + .execute(&pool) + .await + .unwrap(); + } + sqlx::query("INSERT INTO accounts (account_id, labor) VALUES (1007, 1000)") + .execute(&pool) + .await + .unwrap(); + sqlx::query("SET SESSION sql_mode='STRICT_ALL_TABLES'") + .execute(&pool) + .await + .unwrap(); + // Equipment (count 1) is written first; a LATER starter item (count 300) fails. + sqlx::query("ALTER TABLE items MODIFY `count` TINYINT UNSIGNED NOT NULL") + .execute(&pool) + .await + .unwrap(); + let mut server = test_server_with(creation_data()); + server.db = pool.clone(); + let unrelated = Inventory::new(99, 50, 50, &server.items, &server.ids.container); + let item = server + .items + .create(2001, 4, 0, 1, &server.game_data.items, &server.ids.item, 0) + .unwrap(); + let unrelated_id = item.id; + unrelated + .bag() + .lock() + .unwrap() + .add_new_item(item, 0, &server.game_data.items) + .unwrap(); + let reused_deletion = u64::from(server.ids.item.get_next_id().unwrap()); + server.items.release_id(reused_deletion, &server.ids.item); + server.items.mark_for_db_deletion(0x0100_0099); + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + + create(&server, &mut client.conn, creation_request("Rejected")) + .await + .unwrap(); + assert!(client.conn.characters.is_empty()); + assert!(client + .drain_ops() + .contains(&crate::opcodes::sc::SCCharacterCreationFailedPacket)); + for table in [ + "characters", + "items", + "item_containers", + "abilities", + "skills", + ] { + let count: i64 = sqlx::query_scalar(&format!("SELECT COUNT(*) FROM `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(count, 0, "partial SQL rollback in {table}"); + } + assert!(!server.names.name_exists("Rejected")); + assert!( + server + .items + .all_containers() + .iter() + .all(|c| c.lock().unwrap().owner_id == 99), + "rejected inventory remains cached" + ); + assert_eq!(server.items.prepare_save().item_ids(), vec![unrelated_id]); + let mut removed = server.items.removed_items(); + removed.sort_unstable(); + assert_eq!(removed, vec![reused_deletion, 0x0100_0099]); + assert_eq!(server.items.item_by_id(unrelated_id).unwrap().count, 4); + + sqlx::query("ALTER TABLE items MODIFY `count` INT NOT NULL") + .execute(&pool) + .await + .unwrap(); + create(&server, &mut client.conn, creation_request("Accepted")) + .await + .unwrap(); + let c = &client.conn.characters[0]; + assert_eq!(c.id, 1, "failed character ID must be reused"); + let counts = |container: &crate::models::container::ContainerRef| { + let mut items: Vec<_> = container + .lock() + .unwrap() + .items + .iter() + .map(|i| (i.template_id, i.count)) + .collect(); + items.sort_unstable(); + items + }; + assert_eq!(counts(c.inventory.bag()), vec![(2001, 2), (2002, 300)]); + assert_eq!(counts(c.inventory.equipment()), vec![(2000, 1)]); + let rows: Vec<(u32, i32)> = + sqlx::query_as("SELECT template_id, `count` FROM items ORDER BY template_id") + .fetch_all(&pool) + .await + .unwrap(); + assert_eq!(rows, vec![(2000, 1), (2001, 2), (2002, 300)]); + assert!(server.items.prepare_save_for_owner(1).item_ids().is_empty()); + assert_eq!(server.items.prepare_save().item_ids(), vec![unrelated_id]); + assert_eq!(server.items.removed_items(), vec![0x0100_0099]); + // The next item save cannot resurrect the rejected character's inventory. + let mut tx = pool.begin().await.unwrap(); + server.items.save(&mut tx).await.unwrap(); + tx.commit().await.unwrap(); + server.items.commit_save(); + let total: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM items") + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(total, 4); + assert_eq!(counts(unrelated.bag()), vec![(2001, 4)]); + pool.close().await; +} + #[test] fn constructor_does_not_call_deps() { let manager = CharacterData::default(); diff --git a/rust/crates/aaemu-game/src/managers/item.rs b/rust/crates/aaemu-game/src/managers/item.rs index bbab965e95..cbeddc6600 100644 --- a/rust/crates/aaemu-game/src/managers/item.rs +++ b/rust/crates/aaemu-game/src/managers/item.rs @@ -50,6 +50,16 @@ impl ItemSaveBatch { pub(crate) fn item_ids(&self) -> Vec { self.items.iter().map(|(_, _, item)| item.id).collect() } + + /// The queued item deletions of this snapshot (test assertion helper). + pub(crate) fn removed_ids(&self) -> Vec { + self.removed.clone() + } + + /// The number of container rows of this snapshot (test assertion helper). + pub(crate) fn container_count(&self) -> usize { + self.containers.len() + } } #[derive(Debug, PartialEq, Eq)] @@ -106,6 +116,20 @@ impl ItemManager { }) } + /// `FindItemContainerFor(characterId, slotType, mateId)`: the existing persistent container, + /// without creating one (`EquipSlave` uses the slave DB id as `mateId`). + pub fn find_container_for_character( + &self, + character_id: u32, + slot: u8, + mate_id: u32, + ) -> Option { + self.all_containers().into_iter().find(|c| { + let g = c.lock().expect("container poisoned"); + g.owner_id == character_id && g.slot_type == slot && g.mate_id == mate_id + }) + } + /// `GetItemContainerForCharacter(characterId, slotType, parentUnit, mateId)`: the first /// persistent container matching owner/slot/mate, or a new one (new container id unless the /// slot type is `None`, persistent unless `None`). Never call it while holding a container @@ -126,7 +150,7 @@ impl ItemManager { } } let kind = match slot { - slot_type::EQUIPMENT => ContainerKind::Equipment, + slot_type::EQUIPMENT | slot_type::EQUIPMENT_SLAVE => ContainerKind::Equipment, slot_type::EQUIPMENT_MATE => ContainerKind::MateEquipment, _ => ContainerKind::Item, }; @@ -152,6 +176,46 @@ impl ItemManager { c } + /// Discard a rejected creation while the caller holds the save transaction lock, before + /// releasing its character ID. These rows never committed: do not queue SQL deletions or + /// acknowledge another owner's pending changes. + pub(crate) fn discard_new_character( + &self, + owner_id: u32, + created_items: &[(u64, bool)], + item_ids: &IdManager, + container_ids: &IdManager, + ) { + let _create = lock(&self.create_lock); + let rejected: Vec<_> = self + .all_containers() + .into_iter() + .filter(|c| c.lock().expect("container poisoned").owner_id == owner_id) + .collect(); + lock(&self.containers).retain(|c| !rejected.iter().any(|r| Arc::ptr_eq(c, r))); + if let Some(batch) = lock(&self.pending_save).as_mut() { + batch.containers.retain(|(_, row)| row.owner_id != owner_id); + batch.items.retain(|(container, _, _)| { + !container + .as_ref() + .is_some_and(|c| rejected.iter().any(|r| Arc::ptr_eq(c, r))) + }); + } + for container in rejected { + let mut c = container.lock().expect("container poisoned"); + c.items.clear(); + container_ids.release_id(c.container_id as u32); + } + for &(id, canceled_deletion) in created_items { + // Captured at allocation: another owner can queue/release an ID during setup. + // Restore its canceled deletion before freeing the ID for another operation. + if canceled_deletion { + self.mark_for_db_deletion(id); + } + item_ids.release_id(id as u32); + } + } + /// `NewCofferContainer(characterId)`. pub fn new_coffer_container( &self, @@ -197,6 +261,10 @@ impl ItemManager { /// `GetNewId` (+ removal from the deleted-items list). pub fn new_id(&self, item_ids: &IdManager) -> Option { + self.new_id_with_deletion(item_ids).map(|(id, _)| id) + } + + fn new_id_with_deletion(&self, item_ids: &IdManager) -> Option<(u64, bool)> { let id = match item_ids.get_next_id() { Ok(id) => u64::from(id), Err(e) => { @@ -204,8 +272,10 @@ impl ItemManager { return None; } }; - lock(&self.removed).retain(|&r| r != id); - Some(id) + let mut removed = lock(&self.removed); + let before = removed.len(); + removed.retain(|&r| r != id); + Some((id, before != removed.len())) } /// `ItemManager.Create(templateId, count, grade)`. The item is not placed in a container. @@ -220,8 +290,26 @@ impl ItemManager { item_ids: &IdManager, now: i64, ) -> Option { + self.create_with_deletion(template_id, count, grade, world_id, data, item_ids, now) + .map(|(item, _)| item) + } + + /// Creation rollback needs the deletion canceled by THIS allocation, rather than a + /// snapshot taken before other owners could release more IDs. Ordinary creation ignores + /// the receipt and retains the existing new_id semantics. + #[allow(clippy::too_many_arguments)] + pub(crate) fn create_with_deletion( + &self, + template_id: u32, + count: i32, + grade: u8, + world_id: u8, + data: &ItemData, + item_ids: &IdManager, + now: i64, + ) -> Option<(Item, bool)> { let template = data.template(template_id)?; - let id = self.new_id(item_ids)?; + let (id, canceled_deletion) = self.new_id_with_deletion(item_ids)?; let treasure = if template.class_type() == ItemClass::TreasureMap { self.treasure_maps .get() @@ -229,8 +317,9 @@ impl ItemManager { } else { None }; - Some(Item::create_ex( - id, template, count, grade, world_id, data, now, treasure, + Some(( + Item::create_ex(id, template, count, grade, world_id, data, now, treasure), + canceled_deletion, )) } @@ -520,12 +609,26 @@ impl ItemManager { /// Capture before database awaits, while the caller serializes economy operations. pub(crate) fn prepare_save(&self) -> ItemSaveBatch { - let mut batch = ItemSaveBatch { - removed: lock(&self.removed).clone(), - ..Default::default() - }; + let mut batch = self.prepare_save_filtered(None); + batch.removed = lock(&self.removed).clone(); + batch + } + + /// The dirty containers and items of one character only, no queued deletions: character + /// creation writes the starting supplies together with the `characters` row, so a server + /// stop before the next world save cannot lose them. The caller holds the save transaction + /// lock (the write and [`Self::commit_save`] share the single pending-batch slot). + pub(crate) fn prepare_save_for_owner(&self, owner_id: u32) -> ItemSaveBatch { + self.prepare_save_filtered(Some(owner_id)) + } + + fn prepare_save_filtered(&self, owner: Option) -> ItemSaveBatch { + let mut batch = ItemSaveBatch::default(); for container in self.all_containers() { let snapshot = container.lock().expect("container poisoned").clone(); + if owner.is_some_and(|o| snapshot.owner_id != o) { + continue; + } if snapshot.slot_type != slot_type::NONE && snapshot.container_id > 0 && snapshot.dirty { batch @@ -540,9 +643,11 @@ impl ItemManager { } } } - for item in lock(&self.loose).iter() { - if item.slot_type != slot_type::NONE && item.dirty { - batch.items.push((None, 0, item.clone())); + if owner.is_none() { + for item in lock(&self.loose).iter() { + if item.slot_type != slot_type::NONE && item.dirty { + batch.items.push((None, 0, item.clone())); + } } } batch diff --git a/rust/crates/aaemu-game/src/managers/item_tests.rs b/rust/crates/aaemu-game/src/managers/item_tests.rs index 32a2113f14..303d5933c8 100644 --- a/rust/crates/aaemu-game/src/managers/item_tests.rs +++ b/rust/crates/aaemu-game/src/managers/item_tests.rs @@ -757,3 +757,33 @@ async fn private_mysql_load_user_items_deletes_a_merged_stack_row() { .unwrap(); assert_eq!(persisted, 8); } + +// ---- Character creation save (owner-scoped batch) ---- + +/// The creation save writes only the new character's dirty containers and items, never another +/// character's pending rows or the queued deletions (those stay with the world save). +#[test] +fn prepare_save_for_owner_selects_only_that_characters_rows() { + let manager = create_item_manager(); + let container_ids = IdManager::new(crate::managers::id::CONTAINER_ID); + let data = data_with_templates(vec![ItemTemplate::plain(1000, 20)]); + for (owner, id) in [(7u32, 0x0100_0001u64), (8, 0x0100_0002)] { + let bag = manager.container_for_character(owner, slot_type::INVENTORY, 0, &container_ids); + let mut item = create_test_item(id, 1000, 1); + item.dirty = true; + bag.lock() + .unwrap() + .add_new_item(item, 0, &data) + .expect("fits"); + } + manager.mark_for_db_deletion(0x0100_0099); + + let batch = manager.prepare_save_for_owner(7); + assert_eq!(batch.item_ids(), vec![0x0100_0001]); + assert!(batch.removed_ids().is_empty()); + assert_eq!(batch.container_count(), 1); + + let all = manager.prepare_save(); + assert_eq!(all.item_ids().len(), 2); + assert_eq!(all.removed_ids(), vec![0x0100_0099]); +} diff --git a/rust/crates/aaemu-game/src/models/container.rs b/rust/crates/aaemu-game/src/models/container.rs index 5777f51548..b3652640b5 100644 --- a/rust/crates/aaemu-game/src/models/container.rs +++ b/rust/crates/aaemu-game/src/models/container.rs @@ -24,10 +24,11 @@ pub mod slot_type { pub const TRADE: u8 = 4; pub const MAIL: u8 = 5; pub const AUCTION: u8 = 6; + pub const EQUIPMENT_SLAVE: u8 = 0xF2; pub const EQUIPMENT_MATE: u8 = 252; pub const SYSTEM: u8 = 0xFF; /// `Enum.GetValues()` order. - pub const ALL: [u8; 9] = [ + pub const ALL: [u8; 10] = [ NONE, EQUIPMENT, INVENTORY, @@ -35,6 +36,7 @@ pub mod slot_type { TRADE, MAIL, AUCTION, + EQUIPMENT_SLAVE, EQUIPMENT_MATE, SYSTEM, ]; @@ -324,6 +326,11 @@ impl ItemContainer { if item.count != 1 { return false; } + // Ship / vehicle parts are `ItemImplEnum.SlaveEquipment` templates, not character + // gear: the 10.x `EquipmentContainer.CanAccept` only checks the slot range. + if self.slot_type == slot_type::EQUIPMENT_SLAVE { + return target_slot >= 0 && target_slot < self.size; + } // `Owner == null`: not applicable to NPCs (mate gear resolves its owner by id). if !self.has_owner && !(self.kind == ContainerKind::MateEquipment && self.owner_id > 0) { @@ -710,7 +717,10 @@ impl ItemContainer { } let bt = data.template(item.template_id).map_or(0, |t| t.bind_type); if (self.slot_type == slot_type::INVENTORY && bt == bind_type::BIND_ON_PICKUP) - || (self.slot_type == slot_type::EQUIPMENT && bt == bind_type::BIND_ON_EQUIP) + || (matches!( + self.slot_type, + slot_type::EQUIPMENT | slot_type::EQUIPMENT_SLAVE + ) && bt == bind_type::BIND_ON_EQUIP) { item.flags |= ITEM_FLAG_SOUL_BOUND; item.dirty = true; diff --git a/rust/crates/aaemu-game/src/models/item.rs b/rust/crates/aaemu-game/src/models/item.rs index f5f697e369..2976322078 100644 --- a/rust/crates/aaemu-game/src/models/item.rs +++ b/rust/crates/aaemu-game/src/models/item.rs @@ -61,6 +61,8 @@ pub enum ItemClass { SummonMate, SummonSlave, TreasureMap, + /// Ship / vehicle part (`item_impl` 28, `ItemDetailType.SlaveEquipment`). + SlaveEquipment, } impl ItemClass { @@ -83,6 +85,7 @@ impl ItemClass { "SummonMate" => Self::SummonMate, "SummonSlave" => Self::SummonSlave, "TreasureMap" => Self::TreasureMap, + "SlaveEquipment" => Self::SlaveEquipment, _ => return None, }) } @@ -104,6 +107,7 @@ impl ItemClass { Self::SummonMate => "AAEmu.Game.Models.Game.Items.SummonMate", Self::SummonSlave => "AAEmu.Game.Models.Game.Items.SummonSlave", Self::TreasureMap => "AAEmu.Game.Models.Game.Items.TreasureMap", + Self::SlaveEquipment => "AAEmu.Game.Models.Game.Items.SlaveEquipment", } } @@ -125,6 +129,7 @@ impl ItemClass { Self::SummonMate => detail_type::MATE, Self::SummonSlave => detail_type::SLAVE, Self::TreasureMap => detail_type::TREASURE, + Self::SlaveEquipment => detail_type::SLAVE_EQUIPMENT, _ => detail_type::INVALID, } } @@ -139,11 +144,29 @@ impl ItemClass { Self::SummonMate => 6, Self::SummonSlave => 29, Self::TreasureMap => 24, + Self::SlaveEquipment => 12, _ => 0, } } } +/// Detail body length of a raw `ItemDetailType` byte (the bytes after the type byte), as read +/// by the 1.2 client's item detail reader `3961edf0` (the C# `ReadDetails` tables minus one). +pub fn detail_body_len(detail_type: u8) -> usize { + match detail_type { + detail_type::EQUIPMENT => 55, + detail_type::SLAVE => 29, + detail_type::MATE => 6, + detail_type::UCC => 9, + detail_type::TREASURE | detail_type::LOCATION => 24, + detail_type::BIG_FISH | detail_type::DECORATION => 16, + detail_type::MUSIC_SHEET => 8, + detail_type::GLIDER => 4, + detail_type::SLAVE_EQUIPMENT => 12, + _ => 0, + } +} + /// Class-specific detail fields (what each subclass' `ReadDetails` keeps). #[derive(Debug, Clone, Default, PartialEq)] pub struct ItemDetails { @@ -170,6 +193,9 @@ pub struct ItemDetails { /// `SummonSlave.RepairStartTime` (unix seconds, 0 = `DateTime.MinValue`). Never restored /// from the DB (the C# `ReadDetails` always falls back to `MinValue`). pub slave_repair_start_time: UnixTime, + /// `ItemDetailType.SlaveEquipment` body (opaque 12 bytes; the 1.2 C# base `Item` keeps it + /// as a raw blob). + pub slave_equipment: [u8; 12], // TreasureMap pub map_position_x: i64, pub map_position_y: i64, @@ -259,6 +285,15 @@ impl Item { ); class }); + // Ship parts keep the base `Item` type string in the C# database but always use the + // `SlaveEquipment` detail (12 opaque bytes). + let class = if template + .is_some_and(|t| t.impl_id == crate::data::items::item_impl::SLAVE_EQUIPMENT) + { + ItemClass::SlaveEquipment + } else { + class + }; let mut item = Item { class, id: row.id, @@ -534,6 +569,10 @@ impl Item { d.map_position_x = s.read_i64()?; d.map_position_y = s.read_i64()?; } + ItemClass::SlaveEquipment => { + let bytes = s.read_bytes(12)?; + d.slave_equipment.copy_from_slice(&bytes); + } _ => {} } Ok(()) @@ -601,6 +640,9 @@ impl Item { .write_i64(d.map_position_x) .write_i64(d.map_position_y); } + ItemClass::SlaveEquipment => { + s.write_raw(&d.slave_equipment); + } // Base Item.WriteDetails with DetailType Invalid writes nothing. _ => {} } diff --git a/rust/crates/aaemu-game/src/systems/ai/collision/mod.rs b/rust/crates/aaemu-game/src/systems/ai/collision/mod.rs index f3752b2532..0a104ff0b6 100644 --- a/rust/crates/aaemu-game/src/systems/ai/collision/mod.rs +++ b/rust/crates/aaemu-game/src/systems/ai/collision/mod.rs @@ -506,6 +506,25 @@ pub fn sweep_capsule( Some(st.sweep(query::capsule(a, r, hh), b - a, ent_types, 0xFFFF_FFFF, &[])) } +/// Static overlap of a sphere (`PrimitiveWorldIntersection`, zero sweep). `None` without the +/// service; `Some(false)` when nothing intersects. +pub fn overlaps_sphere( + server: &GameServer, + instance_id: u32, + center: [f32; 3], + radius: f32, + ent_types: u32, +) -> Option { + let pw = phys_world(server, instance_id)?; + let c = v(center); + let ext = radius; + let min = Vec3::new(c.x - ext, c.y - ext, c.z - ext); + let max = Vec3::new(c.x + ext, c.y + ext, c.z + ext); + ensure_box(server, &pw, min, max); + let mut st = pw.lock(); + Some(st.overlaps(query::sphere(c, radius), ent_types, 0xFFFF_FFFF, &[])) +} + /// `GetWaterLevel(pos)` (I3DEngine vt+568, 0x3013FCB0): the water-volume surface, else the /// ocean level; `None` when the point is not in water (the engine's −1e6). pub fn water_level(server: &GameServer, instance_id: u32, x: f32, y: f32, z: f32) -> Option { diff --git a/rust/crates/aaemu-game/src/systems/economy/item_effects_tests.rs b/rust/crates/aaemu-game/src/systems/economy/item_effects_tests.rs index 5c7b5c2f27..27026d1bf3 100644 --- a/rust/crates/aaemu-game/src/systems/economy/item_effects_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/item_effects_tests.rs @@ -1760,16 +1760,32 @@ async fn mate_equipment_equip_unequip_and_refusal() { #[test] fn slave_and_repair_packets_decode() { + use crate::systems::vehicles::packets::{CSChangeSlaveEquipmentPacket, WireItem}; let mut s = PacketStream::new(); - s.write_u32(5).write_u16(6).write_u32(7).write_bool(true); + s.write_u32(5) + .write_u16(6) + .write_u32(7) + .write_bool(true) + .write_u32(0) // no item in slot 1 + .write_u32(0) // no item in slot 2 + .write_u8(slot_type::INVENTORY) + .write_u8(3) + .write_u8(slot_type::EQUIPMENT_SLAVE) + .write_u8(4); let p = CSChangeSlaveEquipmentPacket::read(&mut s).unwrap(); assert_eq!( p, CSChangeSlaveEquipmentPacket { - id: 5, - tl: 6, + character_id: 5, + slave_tl: 6, db_slave_id: 7, bts: true, + item1: WireItem::default(), + item2: WireItem::default(), + slot1_type: slot_type::INVENTORY, + slot1: 3, + slot2_type: slot_type::EQUIPMENT_SLAVE, + slot2: 4, } ); let mut s = PacketStream::new(); diff --git a/rust/crates/aaemu-game/src/systems/economy/mate_equipment.rs b/rust/crates/aaemu-game/src/systems/economy/mate_equipment.rs index ad55e05531..9c335d144a 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mate_equipment.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mate_equipment.rs @@ -1,9 +1,10 @@ //! Pet / vehicle gear: `CSChangeMateEquipmentPacket` (moves between the bag and a mate's //! `MateEquipmentContainer`), the `MateEquipmentContainer.OnEnter/LeaveContainer` packets //! (`SCMateEquipmentChangedPacket`), the base `EquipmentContainer` events of a mate (the default -//! [`SummonItemHooks::on_mate_equipment_changed`]), the slave gear / slave repair packets that -//! only log in the 1.2 C# (`CSChangeSlaveEquipmentPacket`, `CSRepairSlaveItemsPacket`), and the -//! stablehand mate revive packet (`CSRepairPetItemsPacket`, handled in `vehicles::mates`). +//! [`SummonItemHooks::on_mate_equipment_changed`]), the slave repair packet that only logs in +//! the 1.2 C# (`CSRepairSlaveItemsPacket`), and the stablehand mate revive packet +//! (`CSRepairPetItemsPacket`, handled in `vehicles::mates`). The slave equipment move packet +//! lives in `vehicles::packets` with the other slave packets. use std::sync::Arc; @@ -26,22 +27,32 @@ use super::item_effect_packets::{ItemAndLocation, SCMateEquipmentChangedPacket}; use super::item_handlers::{active, sync_client_packet}; use super::item_packets::SCUnitEquipmentsChangedPacket; -/// `EquipItem.DetailBytesLength`. -const EQUIP_DETAIL_BYTES: usize = 55; +/// A raw wire item (`Item.Read` / `Item.Write`): the fields the container code needs. The detail +/// body is consumed according to its `ItemDetailType` (ship parts carry 12 bytes, gear 55). +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub struct WireItem { + pub template_id: u32, + pub id: u64, + pub grade: u8, + pub flags: u8, + pub count: i32, + pub detail_type: u8, +} -/// `new EquipItem().Read(stream)`: skips one wire item, returns its template id. -pub fn read_wire_equip_item(s: &mut PacketStream) -> Result { +/// `new Item().Read(stream)`. +pub fn read_wire_item(s: &mut PacketStream) -> Result { let template_id = s.read_u32()?; if template_id == 0 { - return Ok(0); + return Ok(WireItem::default()); } - s.read_u64()?; // Id - s.read_u8()?; // Grade - s.read_u8()?; // ItemFlags - s.read_i32()?; // Count - s.read_u8()?; // detailType - if s.remaining() >= EQUIP_DETAIL_BYTES { - s.read_bytes(EQUIP_DETAIL_BYTES)?; // ReadDetails + let id = s.read_u64()?; + let grade = s.read_u8()?; + let flags = s.read_u8()?; + let count = s.read_i32()?; + let detail_type = s.read_u8()?; + let detail_len = crate::models::item::detail_body_len(detail_type); + if detail_len > 0 && s.remaining() >= detail_len { + s.read_bytes(detail_len)?; } s.read_i64()?; // CreateTime s.read_i32()?; // LifespanMins @@ -49,7 +60,19 @@ pub fn read_wire_equip_item(s: &mut PacketStream) -> Result { s.read_u8()?; // WorldId s.read_i64()?; // UnsecureTime s.read_i64()?; // UnpackTime - Ok(template_id) + Ok(WireItem { + template_id, + id, + grade, + flags, + count, + detail_type, + }) +} + +/// `new EquipItem().Read(stream)`: skips one wire item, returns its template id. +pub fn read_wire_equip_item(s: &mut PacketStream) -> Result { + Ok(read_wire_item(s)?.template_id) } /// Adds the `MateEquipmentContainer.OnEnterContainer` / `OnLeaveContainer` packets after the @@ -377,41 +400,6 @@ pub fn change_mate_equipment( } } -/// `CSChangeSlaveEquipmentPacket` (only logs in 1.2: "coming soon"). -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub struct CSChangeSlaveEquipmentPacket { - pub id: u32, - pub tl: u16, - pub db_slave_id: u32, - pub bts: bool, -} - -impl CSChangeSlaveEquipmentPacket { - fn read_body(s: &mut PacketStream) -> Result { - let id = s.read_u32()?; - let tl = s.read_u16()?; - let db_slave_id = s.read_u32()?; - let bts = s.read_bool()?; - Ok(Self { - id, - tl, - db_slave_id, - bts, - }) - } - - fn run(self, _server: &GameServer, _conn: &mut GameConnection) { - tracing::debug!( - "ChangeSlaveEquipment, Id: {}, Tl: {}, DbSlaveId: {}, Bts: {}", - self.id, - self.tl, - self.db_slave_id, - self.bts - ); - } -} -sync_client_packet!(CSChangeSlaveEquipmentPacket); - /// `CSRepairPetItemsPacket`: the stablehand revive of dead mates (not an equipment repair). #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct CSRepairPetItemsPacket { @@ -455,7 +443,6 @@ sync_client_packet!(CSRepairSlaveItemsPacket); pub fn register(reg: &mut PacketRegistry) { reg.register::(LEVEL_PLAIN, cs::CSChangeMateEquipmentPacket); - reg.register::(LEVEL_PLAIN, cs::CSChangeSlaveEquipmentPacket); reg.register::(LEVEL_PLAIN, cs::CSRepairPetItemsPacket); reg.register::(LEVEL_PLAIN, cs::CSRepairSlaveItemsPacket); } diff --git a/rust/crates/aaemu-game/src/systems/npcs/bridges.rs b/rust/crates/aaemu-game/src/systems/npcs/bridges.rs index 91aeaeb547..dfe12d5f55 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/bridges.rs @@ -447,8 +447,12 @@ impl NpcSkillHooks for NpcSkills { server: &GameServer, player: &PlayerRef, skill_item: &crate::systems::skills::types::SkillCaster, + placement: Option, + max_range: f32, ) { - crate::systems::vehicles::slaves::create_from_skill(server, player, skill_item); + crate::systems::vehicles::slaves::create_from_skill( + server, player, skill_item, placement, max_range, + ); } fn riders_escape( diff --git a/rust/crates/aaemu-game/src/systems/services/music.rs b/rust/crates/aaemu-game/src/systems/services/music.rs index 88ac1ad920..1be3e6e94d 100644 --- a/rust/crates/aaemu-game/src/systems/services/music.rs +++ b/rust/crates/aaemu-game/src/systems/services/music.rs @@ -218,6 +218,7 @@ impl MusicManager { #[derive(Debug, Clone, PartialEq, Eq)] pub struct SCUserNoteLoadedPacket { pub song: Option, + pub is_tooltip: bool, } packet_def!( SCUserNoteLoadedPacket, @@ -228,7 +229,7 @@ impl Marshal for SCUserNoteLoadedPacket { fn write(&self, s: &mut PacketStream) { if let Some(song) = &self.song { s.write_u32(song.id) - .write_u8(1) + .write_bool(self.is_tooltip) .write_i32(song.song.encode_utf16().count() as i32) .write_str(&song.title) .write_str(&format!("{}\0", song.song)); @@ -332,7 +333,8 @@ impl ClientPacket for CSSendUserMusicPacket { #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct CSRequestMusicNotesPacket { pub id64: u64, - pub value2: u16, + pub is_tooltip: bool, + pub show_buff_only: bool, } impl ClientPacket for CSRequestMusicNotesPacket { @@ -341,7 +343,9 @@ impl ClientPacket for CSRequestMusicNotesPacket { fn read(s: &mut PacketStream) -> Result { Ok(Self { id64: s.read_u64()?, - value2: s.read_u16()?, + // Native 1.2 constructor 397acd70 / serializer 397b1480: two bool bytes. + is_tooltip: s.read_bool()?, + show_buff_only: s.read_bool()?, }) } @@ -351,34 +355,38 @@ impl ClientPacket for CSRequestMusicNotesPacket { conn: &'a mut GameConnection, ) -> BoxFuture<'a, Result<()>> { Box::pin(async move { - tracing::warn!("Request Song, id: {}, value2:{}", self.id64, self.value2); + tracing::debug!( + "Request Song, id: {}, isTooltip:{}, showBuffOnly:{}", + self.id64, + self.is_tooltip, + self.show_buff_only + ); let Some(p) = conn.active_char.clone() else { return Ok(()); }; - match self.value2 { - 1 => { - let song = server - .systems - .services - .music - .get_song_by_id(self.id64 as u32); - p.send(SCUserNoteLoadedPacket { song }); - } - 256 => { - let me = WorldObject::from(&p); - crate::systems::skills::buffs::add_buff_by_id( - server, - &me, - BUFF_SCORE_MEMORIZED, - &me, - 0, - ); - } - _ => tracing::warn!( - "Unknown song request type id: {}, value2:{}", - self.id64, - self.value2 - ), + // Native 39082550 sends (isTooltip, false) on a cache miss and + // (false, true) for cached playing. The latter only needs the buff. + if self.show_buff_only { + let me = WorldObject::from(&p); + crate::systems::skills::buffs::add_buff_by_id( + server, + &me, + BUFF_SCORE_MEMORIZED, + &me, + 0, + ); + } else { + // Keep the C# low-32-bit lookup: native SC1e0 reads signed32, + // sign-extended into the cache key at 391e1691/391e169b. + let song = server + .systems + .services + .music + .get_song_by_id(self.id64 as u32); + p.send(SCUserNoteLoadedPacket { + song, + is_tooltip: self.is_tooltip, + }); } Ok(()) }) @@ -452,10 +460,18 @@ mod tests { .write_str("T") .write_str("abc\0"); assert_eq!( - encode(&SCUserNoteLoadedPacket { song: Some(song) })[6..].to_vec(), + encode(&SCUserNoteLoadedPacket { + song: Some(song), + is_tooltip: true, + })[6..] + .to_vec(), e.into_bytes() ); - assert!(encode(&SCUserNoteLoadedPacket { song: None })[6..].is_empty()); + assert!(encode(&SCUserNoteLoadedPacket { + song: None, + is_tooltip: true, + })[6..] + .is_empty()); } #[test] @@ -497,6 +513,6 @@ mod tests { s.write_u64(5).write_u16(256); let p = CSRequestMusicNotesPacket::read(&mut PacketStream::from_bytes(s.into_bytes())).unwrap(); - assert_eq!((p.id64, p.value2), (5, 256)); + assert_eq!((p.id64, p.is_tooltip, p.show_buff_only), (5, false, true)); } } diff --git a/rust/crates/aaemu-game/src/systems/services/music_tests.rs b/rust/crates/aaemu-game/src/systems/services/music_tests.rs index c565ece88c..1285ed8708 100644 --- a/rust/crates/aaemu-game/src/systems/services/music_tests.rs +++ b/rust/crates/aaemu-game/src/systems/services/music_tests.rs @@ -5,7 +5,16 @@ //! dependencies (both are passed per call); construction has no side effects: no songs, no //! queued uploads, no MIDI cache. -use super::MusicManager; +use super::{CSRequestMusicNotesPacket, MusicManager, SongData, BUFF_SCORE_MEMORIZED}; +use crate::data::GameData; +use crate::net::registry::ClientPacket; +use crate::opcodes::sc; +use crate::systems::skills::data::BuffTemplate; +use crate::systems::skills::types::SkillCaster; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use crate::world::PlayerRef; +use crate::GameServer; +use aaemu_commons::PacketStream; #[test] fn constructor_does_not_call_deps() { @@ -14,3 +23,270 @@ fn constructor_does_not_call_deps() { assert!(manager.queued_upload(1).is_none()); assert!(manager.get_midi_cache(1).is_empty()); } + +fn request_fixture() -> (GameServer, TestClient, PlayerRef) { + let mut data = GameData::empty(); + data.systems.skills.add_buff(BuffTemplate { + id: BUFF_SCORE_MEMORIZED, + kind: 1, + ..BuffTemplate::default() + }); + let server = test_server_with(data); + crate::systems::skills::install_hooks(&server); + let mut client = TestClient::new(&server, 1, 1); + let player = spawn_player( + &server, + &client, + test_character(1, "Listener", 10.0, 10.0), + 1, + ); + client.conn.active_char = Some(player.clone()); + client.drain(); + (server, client, player) +} + +fn stored_song(id: u32) -> SongData { + // Reading does not require authorship or holding a sheet in the 1.2 server. + SongData { + id, + author_id: 2, + title: "T".into(), + song: "abc".into(), + source_item_id: 0, + } +} + +fn native_request(id: u64, is_tooltip: bool, show_buff_only: bool) -> CSRequestMusicNotesPacket { + let mut body = id.to_le_bytes().to_vec(); + body.extend([u8::from(is_tooltip), u8::from(show_buff_only)]); + let mut stream = PacketStream::from_bytes(body); + let request = CSRequestMusicNotesPacket::read(&mut stream).unwrap(); + assert_eq!(stream.remaining(), 0); + request +} + +fn expected_notes(id: u32, is_tooltip: bool) -> Vec { + let mut body = id.to_le_bytes().to_vec(); + body.extend([ + u8::from(is_tooltip), + 3, + 0, + 0, + 0, + 1, + 0, + b'T', + 4, + 0, + b'a', + b'b', + b'c', + 0, + ]); + body +} + +#[tokio::test] +async fn native_uncached_play_returns_notes() { + let (server, mut client, player) = request_fixture(); + server + .systems + .services + .music + .st() + .all_songs + .insert(7, stored_song(7)); + + // Native 39082550 cache miss: u64 noteId, isTooltip=false, showBuffOnly=false. + let request = CSRequestMusicNotesPacket::read(&mut PacketStream::from_bytes(vec![ + 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, + ])) + .unwrap(); + request.handle(&server, &mut client.conn).await.unwrap(); + assert_eq!( + client.drain(), + vec![( + sc::SCUserNoteLoadedPacket, + vec![7, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, b'T', 4, 0, b'a', b'b', b'c', 0], + )], + "native uncached playback must receive SC1e0 with isTooltip=false" + ); + assert!(!player.data().unit.buffs.check_buff(BUFF_SCORE_MEMORIZED)); +} + +#[tokio::test] +async fn native_request_flag_combinations_found_and_missing() { + for found in [true, false] { + for is_tooltip in [false, true] { + for show_buff_only in [false, true] { + let (server, mut client, player) = request_fixture(); + let observer = TestClient::new(&server, 2, 2); + let other = spawn_player( + &server, + &observer, + test_character(2, "Author", 12.0, 10.0), + 2, + ); + client.drain(); + if found { + server + .systems + .services + .music + .st() + .all_songs + .insert(7, stored_song(7)); + } + native_request(7, is_tooltip, show_buff_only) + .handle(&server, &mut client.conn) + .await + .unwrap(); + let frames = client.drain(); + let notes: Vec<_> = frames + .iter() + .filter(|(op, _)| *op == sc::SCUserNoteLoadedPacket) + .cloned() + .collect(); + let expected = if show_buff_only { + Vec::new() + } else { + vec![( + sc::SCUserNoteLoadedPacket, + if found { + expected_notes(7, is_tooltip) + } else { + Vec::new() + }, + )] + }; + assert_eq!( + notes, expected, + "found={found}, tooltip={is_tooltip}, buff={show_buff_only}" + ); + // The existing cached path adds the buff even for an unknown song ID. + assert_eq!( + player.data().unit.buffs.check_buff(BUFF_SCORE_MEMORIZED), + show_buff_only + ); + // SCUnitState also queues patron buffs when another player sees + // us; identify ScoreMemorized and verify its actual wire target. + let memorized: Vec<_> = frames + .iter() + .filter(|(op, _)| *op == sc::SCBuffCreatedPacket) + .filter_map(|(_, body)| { + let mut s = PacketStream::from_bytes(body.clone()); + let kind = s.read_u8().unwrap(); + let caster = SkillCaster::read(kind, &mut s).unwrap(); + let caster_id = s.read_u32().unwrap(); + let owner_obj_id = s.read_bc().unwrap(); + let _index = s.read_u32().unwrap(); + (s.read_u32().unwrap() == BUFF_SCORE_MEMORIZED).then_some(( + caster, + caster_id, + owner_obj_id, + )) + }) + .collect(); + assert_eq!( + memorized, + if show_buff_only { + vec![( + SkillCaster::Unit(player.obj_id), + player.character_id, + player.obj_id, + )] + } else { + Vec::new() + } + ); + assert!(!other.data().unit.buffs.check_buff(BUFF_SCORE_MEMORIZED)); + } + } + } +} + +#[tokio::test] +async fn native_request_requires_active_character() { + for is_tooltip in [false, true] { + for show_buff_only in [false, true] { + let (server, mut client, player) = request_fixture(); + server + .systems + .services + .music + .st() + .all_songs + .insert(7, stored_song(7)); + client.conn.active_char = None; + native_request(7, is_tooltip, show_buff_only) + .handle(&server, &mut client.conn) + .await + .unwrap(); + assert!(client.drain().is_empty()); + assert!(!player.data().unit.buffs.check_buff(BUFF_SCORE_MEMORIZED)); + } + } +} + +#[tokio::test] +async fn request_preserves_u32_lookup_and_response_id() { + // The legacy server casts the request's u64 to u32. Native SC1e0 consumes + // signed32 and sign-extends it (391e1691 cdq); changing either width is unsafe. + for id in [ + 0, + 7, + 0x1_0000_0007, + 0x7fff_ffff, + 0x8000_0000, + 0xffff_ffff_8000_0000, + u64::MAX, + ] { + for is_tooltip in [false, true] { + let (server, mut client, _) = request_fixture(); + let key = id as u32; + server + .systems + .services + .music + .st() + .all_songs + .insert(key, stored_song(key)); + native_request(id, is_tooltip, false) + .handle(&server, &mut client.conn) + .await + .unwrap(); + assert_eq!( + client.drain(), + vec![(sc::SCUserNoteLoadedPacket, expected_notes(key, is_tooltip))] + ); + } + } +} + +#[test] +fn native_request_flag_bytes_and_truncation() { + // Original constructor/serializer 397acd70/397b1480; retained native.tsv request_00..11. + for is_tooltip in [0, 1] { + for show_buff_only in [0, 1] { + let body = [4, 3, 2, 1, 8, 7, 6, 5, is_tooltip, show_buff_only]; + for end in 0..body.len() { + assert!( + CSRequestMusicNotesPacket::read(&mut PacketStream::from_bytes( + body[..end].to_vec() + )) + .is_err() + ); + } + let request = + CSRequestMusicNotesPacket::read(&mut PacketStream::from_bytes(body.to_vec())) + .unwrap(); + assert_eq!(request.id64, 0x0506_0708_0102_0304); + assert_eq!(request.is_tooltip, is_tooltip != 0); + assert_eq!(request.show_buff_only, show_buff_only != 0); + assert_eq!( + request, + native_request(request.id64, is_tooltip != 0, show_buff_only != 0) + ); + } + } +} diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/special/misc.rs b/rust/crates/aaemu-game/src/systems/skills/effects/special/misc.rs index 74b917e34c..3dae531dd1 100644 --- a/rust/crates/aaemu-game/src/systems/skills/effects/special/misc.rs +++ b/rust/crates/aaemu-game/src/systems/skills/effects/special/misc.rs @@ -379,7 +379,8 @@ pub fn spawn_pet(server: &GameServer, args: &EffectArgs<'_>, v: [i32; 4]) { .spawn_mount(server, p, &args.caster_caster); } -/// `SpawnSlave`: `SlaveManager.Create(owner, skillItem)`. +/// `SpawnSlave`: `SlaveManager.Create(owner, skillItem)`. `SummonPos` casts carry the spot the +/// player picked; a self-targeted summon item cast has no placement and keeps the C# offset. pub fn spawn_slave(server: &GameServer, args: &EffectArgs<'_>, v: [i32; 4]) { log_values(args, "SpawnSlave", v); let Some(p) = args.caster.as_ref().and_then(WorldObject::as_player) else { @@ -394,12 +395,37 @@ pub fn spawn_slave(server: &GameServer, args: &EffectArgs<'_>, v: [i32; 4]) { ); return; } - server - .systems - .skills - .ext - .npcs() - .spawn_slave(server, p, &args.caster_caster); + let placement = match (&args.target, &args.target_caster) { + (Target::Pos(pos), SkillCastTarget::Position { rot, .. }) => { + Some(crate::systems::skills::ext::SummonPlacement { + x: pos.pos.x, + y: pos.pos.y, + z: pos.pos.z, + yaw: *rot, + }) + } + ( + Target::Pos(pos), + SkillCastTarget::Position2 { .. } | SkillCastTarget::Position3 { .. }, + ) => Some(crate::systems::skills::ext::SummonPlacement { + x: pos.pos.x, + y: pos.pos.y, + z: pos.pos.z, + yaw: 0.0, + }), + _ => None, + }; + let max_range = args + .source + .skill() + .map_or(0.0, |s| s.template.max_range as f32); + server.systems.skills.ext.npcs().spawn_slave( + server, + p, + &args.caster_caster, + placement, + max_range, + ); } /// `AttachTo`: a character binds the target slave at attach point `value1`. diff --git a/rust/crates/aaemu-game/src/systems/skills/ext.rs b/rust/crates/aaemu-game/src/systems/skills/ext.rs index 32bab28082..745d2ffbe0 100644 --- a/rust/crates/aaemu-game/src/systems/skills/ext.rs +++ b/rust/crates/aaemu-game/src/systems/skills/ext.rs @@ -40,6 +40,16 @@ pub struct MainWorldPosition { pub pos: PositionAndRotation, } +/// The client-chosen spot of a `SummonPos` cast (`SkillCastPositionTarget` and friends). +#[derive(Debug, Clone, Copy, PartialEq)] +pub struct SummonPlacement { + pub x: f32, + pub y: f32, + pub z: f32, + /// `SkillCastPositionTarget.PosRot`. + pub yaw: f32, +} + /// Outcome of an item action that can cancel the skill and show an error (`skill.Cancelled = /// true` + `SendErrorMessage`). #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -256,8 +266,17 @@ pub trait NpcSkillHooks: Send + Sync { not_ported("SlaveManager.BindSlave"); } - /// `SlaveManager.Create(owner, skillItem)` (`SpawnSlave`). - fn spawn_slave(&self, _server: &GameServer, _player: &PlayerRef, _skill_item: &SkillCaster) { + /// `SlaveManager.Create(owner, skillItem, positionOverride)` (`SpawnSlave`). `placement` is + /// the `SummonPos` spot the client chose (`None` for a self-targeted summon item cast); + /// `max_range` is the skill template's `MaxRange` (`0` = unbounded). + fn spawn_slave( + &self, + _server: &GameServer, + _player: &PlayerRef, + _skill_item: &SkillCaster, + _placement: Option, + _max_range: f32, + ) { not_ported("SlaveManager.Create"); } diff --git a/rust/crates/aaemu-game/src/systems/skills/mount_authority.rs b/rust/crates/aaemu-game/src/systems/skills/mount_authority.rs index e35a981549..b330483c2a 100644 --- a/rust/crates/aaemu-game/src/systems/skills/mount_authority.rs +++ b/rust/crates/aaemu-game/src/systems/skills/mount_authority.rs @@ -31,15 +31,28 @@ fn summoned_by(slave: &SlaveRef, player: &PlayerRef, character_id: u32) -> bool } /// A slave (ship, cannon, cart, ...) answers the skills of its owner and of the characters -/// attached to it (driver, gunner, passengers); a cannon or a harpoon child also answers the -/// owner of the slave it is mounted on. +/// attached to it (driver, gunner, passengers); a harpoon child also answers the owner of the +/// slave it is mounted on. A ship cannon answers only the character manning it. pub(super) fn may_use_slave( server: &crate::server::GameServer, player: &PlayerRef, slave: &SlaveRef, ) -> bool { - let parent = player.data().unit.transform.parent_obj_id; + let (parent, point) = { + let player = player.data(); + (player.unit.transform.parent_obj_id, player.attached_point) + }; let character_id = player.character_id; + // A cannon mounted on a ship answers its gunner only: manning it is what grants the shot. + if crate::systems::vehicles::slaves::is_manned_cannon(server, slave) { + return parent == slave.obj_id + && point == attach_point::DRIVER + && slave + .data() + .attached_characters + .iter() + .any(|(seat, obj)| *seat == attach_point::DRIVER && *obj == player.obj_id); + } if parent == slave.obj_id || summoned_by(slave, player, character_id) { return true; } diff --git a/rust/crates/aaemu-game/src/systems/skills/skill.rs b/rust/crates/aaemu-game/src/systems/skills/skill.rs index 99b3bae24c..d0a8ae261e 100644 --- a/rust/crates/aaemu-game/src/systems/skills/skill.rs +++ b/rust/crates/aaemu-game/src/systems/skills/skill.rs @@ -346,9 +346,19 @@ fn initial_target( return Some(set_initial_target(server, caster, target_caster)); } } - Some( - T::Party | T::Raid | T::Line | T::Pet | T::SummonPos | T::SourcePos | T::CursorPos, - ) => {} + Some(T::SummonPos) => { + // 10.x `Skill.GetInitialTarget`: the chosen summon spot is the target, so range, + // angle and obstacle checks see the placement instead of the caster. + if matches!( + target_caster, + SkillCastTarget::Position { .. } + | SkillCastTarget::Position2 { .. } + | SkillCastTarget::Position3 { .. } + ) { + return Some(set_initial_target(server, caster, target_caster)); + } + } + Some(T::Party | T::Raid | T::Line | T::Pet | T::SourcePos | T::CursorPos) => {} None => { tracing::error!( "SkillTargetType not supported {} (NotSupportedException)", @@ -1707,7 +1717,15 @@ pub fn apply_effects(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { let Some(template) = data.effect(kind, id) else { continue; }; - let this_target_caster = if target.obj_id() == ctx.target_caster.obj_id() { + // Position casts (ground / ballistic / summon placement) have no unit obj id: keep the + // original target so effects can read the chosen coordinates and rotation. + let this_target_caster = if matches!( + ctx.target_caster, + SkillCastTarget::Position { .. } + | SkillCastTarget::Position2 { .. } + | SkillCastTarget::Position3 { .. } + ) || target.obj_id() == ctx.target_caster.obj_id() + { ctx.target_caster } else { SkillCastTarget::Unit(target.obj_id()) diff --git a/rust/crates/aaemu-game/src/systems/skills/validation.rs b/rust/crates/aaemu-game/src/systems/skills/validation.rs index af56e0c099..5d7cebb761 100644 --- a/rust/crates/aaemu-game/src/systems/skills/validation.rs +++ b/rust/crates/aaemu-game/src/systems/skills/validation.rs @@ -200,6 +200,10 @@ pub(super) fn check( if distance < min_range { return fail("skill_too_close_range"); } + // A position-targeted skill is cast at a spot on the ground; its template may carry + // max_range 0 because the client decides where the placement is legal (10.x + // `unboundedPlacement`; summon skill 15802 rejected every boat at 3.4 m without it). + let unbounded_placement = matches!(target, Target::Pos(_)) && template.max_range <= 0; // Doodads have no model radius and a ship's origin is far from its hull, so these targets // get an allowance on top of the skill's range (C# exempted them entirely). let extent = target.as_obj().map_or(0.0, |o| { @@ -211,7 +215,7 @@ pub(super) fn check( 0.0 } }); - if distance > max_range + extent { + if distance > max_range + extent && !unbounded_placement { return fail("skill_too_far_range"); } if template.check_obstacle && !target.as_obj().is_some_and(|o| o.same(caster)) { diff --git a/rust/crates/aaemu-game/src/systems/vehicles/data.rs b/rust/crates/aaemu-game/src/systems/vehicles/data.rs index 94cf663e0e..4469b5d360 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/data.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/data.rs @@ -220,6 +220,29 @@ pub struct SlaveInitialItem { pub item_id: u32, } +/// `SlaveEquipSlots`: one equipment slot of a hull and the model attach point it occupies. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct SlaveEquipSlot { + pub id: u32, + pub slave_id: u32, + pub attach_point_id: u8, + pub equip_slot_id: u8, + pub require_slot_id: i32, +} + +/// `ItemSlaveEquipments`: what an item spawns when it sits in a hull equipment slot (a child +/// slave and/or a doodad) and which hull / slot packs accept it. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct ItemSlaveEquipment { + pub id: u32, + pub item_id: u32, + pub slave_id: u32, + pub doodad_id: u32, + pub slave_equip_pack_id: u32, + pub slot_pack_id: u32, + pub require_item_id: u32, +} + /// `SlaveTemplate`. #[derive(Debug, Clone, PartialEq, Default)] pub struct SlaveTemplate { @@ -426,6 +449,14 @@ pub struct VehiclesData { /// `_attachPoints` (model id -> attach point -> location), points in file order. pub attach_points: HashMap>, pub slave_initial_items: HashMap>, + /// `slave_equip_slots` grouped by slave template id. + pub slave_equip_slots: HashMap>, + /// `item_slave_equipments` keyed by item id. + pub item_slave_equipments: HashMap, + /// `allow_to_equip_slaves` grouped by `slave_equip_pack_id`. + pub slave_equip_packs: HashMap>, + /// `allow_to_equip_slots` grouped by `slave_equipment_equip_slot_pack_id`. + pub slave_slot_packs: HashMap>, /// `_slaveMountSkills` (id, slave id, mount skill id) in insertion order. pub slave_mount_skills: Vec<(u32, u32, u32)>, /// `_repairableSlaves` (slave id -> repair effect id). @@ -619,6 +650,60 @@ impl VehiclesData { .push(item); Ok(()) })?; + for_each_row(ctx.conn, "SELECT * FROM slave_equip_slots", [], |r| { + let slot = SlaveEquipSlot { + id: r.u32("id")?, + slave_id: r.u32("slave_id")?, + attach_point_id: r.i32("attach_point_id")? as u8, + equip_slot_id: r.i32("equip_slot_id")? as u8, + require_slot_id: r.i32("require_slot_id")?, + }; + self.slave_equip_slots + .entry(slot.slave_id) + .or_default() + .push(slot); + Ok(()) + })?; + for_each_row(ctx.conn, "SELECT * FROM item_slave_equipments", [], |r| { + let item = ItemSlaveEquipment { + id: r.u32("id")?, + item_id: r.u32("item_id")?, + slave_id: r.u32_or("slave_id", 0)?, + doodad_id: r.u32_or("doodad_id", 0)?, + slave_equip_pack_id: r.u32_or("slave_equip_pack_id", 0)?, + slot_pack_id: r.u32_or("slot_pack_id", 0)?, + require_item_id: r.u32_or("require_item_id", 0)?, + }; + if self + .item_slave_equipments + .insert(item.item_id, item) + .is_some() + { + tracing::warn!( + "Duplicate entry for item_slave_equipments item {}", + item.item_id + ); + } + Ok(()) + })?; + for_each_row(ctx.conn, "SELECT * FROM allow_to_equip_slaves", [], |r| { + let pack_id = r.u32("slave_equip_pack_id")?; + let slave_id = r.u32("slave_id")?; + let pack = self.slave_equip_packs.entry(pack_id).or_default(); + if !pack.contains(&slave_id) { + pack.push(slave_id); + } + Ok(()) + })?; + for_each_row(ctx.conn, "SELECT * FROM allow_to_equip_slots", [], |r| { + let pack_id = r.u32("slave_equipment_equip_slot_pack_id")?; + let slot_id = r.i32("equip_slot_id")? as u8; + let pack = self.slave_slot_packs.entry(pack_id).or_default(); + if !pack.contains(&slot_id) { + pack.push(slot_id); + } + Ok(()) + })?; for_each_row(ctx.conn, "SELECT * FROM slave_initial_buffs", [], |r| { let slave_id = r.u32("slave_id")?; let buff_id = r.u32("buff_id")?; @@ -1084,6 +1169,81 @@ impl VehiclesData { self.slave_initial_items.get(&pack_id).map(Vec::as_slice) } + /// The equipment slots a hull declares (`slave_equip_slots`), in table order. + pub fn slave_equip_slots(&self, slave_id: u32) -> &[SlaveEquipSlot] { + self.slave_equip_slots + .get(&slave_id) + .map(Vec::as_slice) + .unwrap_or_default() + } + + /// The attach points an equipment slot occupies on a hull. A slot may drive more than one + /// point (front and rear lamps, both planks). + pub fn slave_equip_attach_points(&self, slave_id: u32, equip_slot_id: u8) -> Vec { + let mut points = Vec::new(); + for slot in self.slave_equip_slots(slave_id) { + if slot.equip_slot_id == equip_slot_id && !points.contains(&slot.attach_point_id) { + points.push(slot.attach_point_id); + } + } + points + } + + /// Whether `slave_id` declares `equip_slot_id` in `slave_equip_slots`. + pub fn has_slave_equip_slot(&self, slave_id: u32, equip_slot_id: u8) -> bool { + self.slave_equip_slots(slave_id) + .iter() + .any(|s| s.equip_slot_id == equip_slot_id) + } + + /// Every attach point any declared equipment slot of the hull occupies. + pub fn slave_equip_attach_point_set(&self, slave_id: u32) -> std::collections::HashSet { + self.slave_equip_slots(slave_id) + .iter() + .map(|s| s.attach_point_id) + .collect() + } + + /// `item_slave_equipments` row of an item template. + pub fn item_slave_equipment(&self, item_id: u32) -> Option<&ItemSlaveEquipment> { + self.item_slave_equipments.get(&item_id) + } + + /// `allow_to_equip_slaves` check (an empty pack accepts nothing). + pub fn slave_equip_pack_allows(&self, pack_id: u32, slave_id: u32) -> bool { + self.slave_equip_packs + .get(&pack_id) + .is_some_and(|ids| ids.contains(&slave_id)) + } + + /// `allow_to_equip_slots` check (an empty pack accepts nothing). + pub fn slot_pack_allows(&self, pack_id: u32, equip_slot_id: u8) -> bool { + self.slave_slot_packs + .get(&pack_id) + .is_some_and(|slots| slots.contains(&equip_slot_id)) + } + + /// Whether `item_id` may be equipped on `slave_id` in `equip_slot_id`: the item needs an + /// `item_slave_equipments` row, the hull must declare the slot, and the item's hull / slot + /// packs (when set) must allow it. + pub fn can_equip_item_on_slave(&self, item_id: u32, slave_id: u32, equip_slot_id: u8) -> bool { + let Some(equip) = self.item_slave_equipment(item_id) else { + return false; + }; + if !self.has_slave_equip_slot(slave_id, equip_slot_id) { + return false; + } + if equip.slave_equip_pack_id != 0 + && !self.slave_equip_pack_allows(equip.slave_equip_pack_id, slave_id) + { + return false; + } + if equip.slot_pack_id != 0 && !self.slot_pack_allows(equip.slot_pack_id, equip_slot_id) { + return false; + } + true + } + /// `GetAttachPointsForSlave(modelId)`. pub fn attach_points_for_slave(&self, model_id: u32) -> Option<&[(u8, AttachPointLocation)]> { self.attach_points.get(&model_id).map(Vec::as_slice) diff --git a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs index 21ca4bf37d..1bbedf8efc 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs @@ -46,6 +46,9 @@ const PB: u32 = 0x00F0_0002; #[path = "deck_standing_tests.rs"] mod deck_standing_tests; +#[path = "pr38_regression_tests.rs"] +mod pr38_regression_tests; + fn exp_table() -> ExperienceTable { ExperienceTable::from_templates( (1..=3u8) @@ -2913,6 +2916,32 @@ fn real_compact_db_vehicle_tables() { for point in [21, 36, 60, 61] { assert!(coupe.iter().any(|(p, _)| *p == point), "point {point}"); } + // Equipment tables: 92 slots over the seven customizable hulls, 43 item visuals, and the + // hull / slot packs. + let slots: usize = d.slave_equip_slots.values().map(Vec::len).sum(); + assert_eq!((slots, d.item_slave_equipments.len()), (92, 43)); + assert_eq!(d.slave_equip_slots[&22].len(), 27); + assert_eq!( + d.slave_equip_attach_points(22, 13), + vec![28, 29], + "the lamp slot drives the front and rear lamps" + ); + assert!(d.can_equip_item_on_slave(28852, 22, 3)); + assert!(!d.can_equip_item_on_slave(28852, 22, 0)); + assert!(!d.can_equip_item_on_slave(28852, 21, 3)); + assert!(!d.can_equip_item_on_slave(29723, 22, 3)); + assert!(!d.has_slave_equip_slot(21, 3)); + // Attach points recovered from the 1.2 client meshes. + for (slave, point) in [(22, 9), (22, 35), (132, 9), (139, 10), (139, 35)] { + let model = d.slave_templates[&slave].model_id; + let points = d + .attach_points_for_slave(model) + .unwrap_or_else(|| panic!("model {model} attach points")); + assert!( + points.iter().any(|(p, _)| *p == point), + "slave {slave} model {model} point {point}" + ); + } } /// A server whose main_world covers the real map (31 x 31 cells), with the real vehicle data. @@ -3206,3 +3235,965 @@ async fn hang_and_unhang_packets_only_mutate_the_authenticated_character() { .unwrap(); assert_eq!(pb.core().sticky_parent(), 0); } + +// --------------------------------------------------------------------------------------------- +// SummonPos summon placement (2026-10-22) +// --------------------------------------------------------------------------------------------- + +const SUMMON_POS_SKILL: u32 = 58_003; +const SLAVE_PART: u32 = 5002; + +fn summon_pos_data(spawn_range: u32) -> GameData { + use crate::systems::skills::data::effects::{EffectTemplate, SpecialEffect}; + use crate::systems::skills::data::{EffectKind, SkillTemplate}; + let mut d = slave_data(); + d.items.templates.get_mut(&SLAVE_ITEM).unwrap().use_skill_id = SUMMON_POS_SKILL; + d.systems + .vehicles + .slave_templates + .get_mut(&SLAVE_TEMPLATE) + .unwrap() + .spawn_valid_area_range = spawn_range; + d.systems.skills.add_effect( + EffectKind::SpecialEffect, + EffectTemplate::Special(SpecialEffect { + id: 1, + special_effect_type_id: 60, + value1: 0, + value2: 0, + value3: 0, + value4: 0, + }), + 1, + ); + d.systems.skills.add_skill(SkillTemplate { + id: SUMMON_POS_SKILL, + target_type: 12, // SummonPos + level_rule_no_consideration: true, + effects: vec![crate::systems::skills::tests::skill_effect( + 1, + EffectKind::SpecialEffect, + 1, + )], + ..SkillTemplate::default() + }); + d +} + +/// A client that owns `SLAVE_ITEM` in its bag and can cast the summon skill. +fn summon_pos_client( + server: &Arc, +) -> (TestClient, PlayerRef, u64, Arc) { + let mut a = TestClient::new(server, 1, 1); + let (pa, item_id) = player_with_item(server, &a, 1, PA, (100.0, 100.0), SLAVE_ITEM); + let bag = pa + .data() + .inventory + .get(slot_type::INVENTORY) + .unwrap() + .clone(); + bag.lock().unwrap().items[0].owner_id = u64::from(pa.character_id); + server.items.add_container(bag); + a.conn.active_char = Some(pa.clone()); + let world = server.world.world(0).unwrap(); + server.systems.npcs.spawns.get_or_create(&world); + a.drain(); + (a, pa, item_id, world) +} + +fn cast_summon_pos( + server: &GameServer, + client: &mut TestClient, + item_id: u64, + x: f32, + y: f32, + z: f32, + yaw: f32, +) { + use crate::systems::skills::handlers::{start_skill, CSStartSkillPacket}; + use crate::systems::skills::types::{SkillCastTarget, SkillCaster, SkillObject}; + start_skill( + server, + &mut client.conn, + CSStartSkillPacket { + skill_id: SUMMON_POS_SKILL, + caster: SkillCaster::Item { + obj_id: PA, + item_id, + item_template_id: SLAVE_ITEM, + type1: 0, + type2: 0, + }, + target: SkillCastTarget::Position { + obj_id: 0, + x, + y, + z, + rot: yaw, + obj_id1: 0, + obj_id2: 0, + }, + flag: 0, + skill_object: SkillObject::None, + }, + ); +} + +async fn wait_for_slave(world: &Arc) -> crate::world::SlaveRef { + tokio::time::timeout(Duration::from_secs(5), async { + loop { + if let Some(s) = slaves::get_active_slave_by_owner_obj_id(world, PA) { + break s; + } + tokio::time::sleep(Duration::from_millis(10)).await; + } + }) + .await + .expect("summon skill must create the vehicle") +} + +#[tokio::test] +async fn summon_pos_places_the_vehicle_at_the_chosen_spot() { + let server = server_with(summon_pos_data(50)); + crate::systems::economy::bridges::install(&server); + crate::systems::npcs::install_hooks(&server); + super::install_hooks(&server); + let (mut a, _pa, item_id, world) = summon_pos_client(&server); + cast_summon_pos(&server, &mut a, item_id, 103.0, 104.0, 200.0, 1.25); + let slave = wait_for_slave(&world).await; + let t = slave.data().unit.transform; + assert_eq!((t.x, t.y), (103.0, 104.0)); + assert!( + (t.rot_z - 1.25).abs() < 1e-6, + "yaw {}, wanted 1.25", + t.rot_z + ); + assert!( + !error_codes(&a.drain()).contains(&super::error::SLAVE_SPAWN_ERROR_INVALID_AREA), + "a valid placement must not send the invalid-area error" + ); +} + +#[tokio::test] +async fn summon_pos_outside_the_valid_area_errors_and_falls_back_in_front() { + let server = server_with(summon_pos_data(10)); + crate::systems::economy::bridges::install(&server); + crate::systems::npcs::install_hooks(&server); + super::install_hooks(&server); + let (mut a, _pa, item_id, world) = summon_pos_client(&server); + cast_summon_pos(&server, &mut a, item_id, 130.0, 100.0, 0.0, 1.25); + let slave = wait_for_slave(&world).await; + let frames = a.drain(); + assert!( + error_codes(&frames).contains(&super::error::SLAVE_SPAWN_ERROR_INVALID_AREA), + "invalid placement must send SlaveSpawnErrorInvalidArea" + ); + // C# fallback: SpawnYOffset clamped to 5 m in front, 90 degrees CCW of the owner. + let t = slave.data().unit.transform; + assert_eq!((t.x, t.y), (100.0, 105.0)); + assert!((t.rot_z - std::f32::consts::FRAC_PI_2).abs() < 1e-6); +} + +#[tokio::test] +async fn slave_equipment_equips_unequips_and_survives_a_resummon() { + use crate::models::item::ItemClass; + use crate::net::registry::ClientPacket; + use crate::systems::vehicles::packets::CSChangeSlaveEquipmentPacket; + + let mut d = slave_data(); + d.items.templates.insert( + SLAVE_PART, + ItemTemplate { + impl_id: crate::data::items::item_impl::SLAVE_EQUIPMENT, + ..ItemTemplate::plain(SLAVE_PART, 1) + }, + ); + d.systems + .vehicles + .slave_equip_slots + .entry(SLAVE_TEMPLATE) + .or_default() + .push(super::data::SlaveEquipSlot { + id: 1, + slave_id: SLAVE_TEMPLATE, + attach_point_id: 9, + equip_slot_id: 3, + require_slot_id: -1, + }); + d.systems.vehicles.item_slave_equipments.insert( + SLAVE_PART, + super::data::ItemSlaveEquipment { + id: 1, + item_id: SLAVE_PART, + slave_id: 0, + doodad_id: 0, + slave_equip_pack_id: 0, + slot_pack_id: 0, + require_item_id: 0, + }, + ); + let server = server_with(d); + crate::systems::economy::bridges::install(&server); + crate::systems::npcs::install_hooks(&server); + super::install_hooks(&server); + let mut a = TestClient::new(&server, 1, 1); + let (pa, item_id) = player_with_item(&server, &a, 1, PA, (100.0, 100.0), SLAVE_ITEM); + a.conn.active_char = Some(pa.clone()); + let world = server.world.world(0).unwrap(); + server.systems.npcs.spawns.get_or_create(&world); + let bag = pa + .data() + .inventory + .get(slot_type::INVENTORY) + .unwrap() + .clone(); + bag.lock().unwrap().items[0].owner_id = u64::from(pa.character_id); + server.items.add_container(bag.clone()); + + let item = mates::owned_item(&server, &pa, item_id).unwrap(); + let slave = slaves::create_core( + &server, + &world, + Some(&pa), + None, + SLAVE_TEMPLATE, + Some(item), + false, + None, + None, + ) + .expect("slave"); + let (tl, db_id) = { + let d = slave.data(); + (d.unit.tl_id, d.id) + }; + assert!(db_id > 0); + + let mut part = server + .items + .create( + SLAVE_PART, + 1, + 0, + 1, + &server.game_data.items, + &server.ids.item, + 0, + ) + .expect("part"); + assert_eq!(part.class, ItemClass::SlaveEquipment); + part.slot_type = slot_type::INVENTORY; + part.slot = 7; + part.owner_id = u64::from(pa.character_id); + part.dirty = true; + let part_id = part.id; + bag.lock().unwrap().items.push(part.clone()); + a.drain(); + + let character_id = pa.character_id; + let packet_body = |item1: Option<&crate::models::item::Item>, + slot1: u8, + item2: Option<&crate::models::item::Item>, + slot2: u8, + bts: bool| { + let mut s = PacketStream::new(); + s.write_u32(character_id) + .write_u16(tl) + .write_u32(db_id) + .write_bool(bts); + match item1 { + Some(i) => { + s.write(i); + } + None => { + s.write_u32(0); + } + } + match item2 { + Some(i) => { + s.write(i); + } + None => { + s.write_u32(0); + } + } + s.write_u8(slot_type::INVENTORY) + .write_u8(slot1) + .write_u8(slot_type::EQUIPMENT_SLAVE) + .write_u8(slot2); + s.into_bytes() + }; + let run = |body: Vec, a: &mut TestClient| { + let p = CSChangeSlaveEquipmentPacket::read(&mut PacketStream::from_bytes(body)).unwrap(); + futures::executor::block_on(p.handle(&server, &mut a.conn)).unwrap(); + a.drain() + }; + + // Equip bag slot 7 -> slave slot 3. + let frames = run(packet_body(Some(&part), 7, None, 3, false), &mut a); + assert!(ops(&frames).contains(&sc::SCSlaveEquipmentChangedPacket)); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 1, + "success flag" + ); + assert!(ops(&frames).contains(&sc::SCUnitEquipmentsChangedPacket)); + assert!(bag.lock().unwrap().get_item_by_slot(7).is_none()); + assert_eq!( + slave.data().equipment[3].as_ref().map(|i| i.id), + Some(part_id) + ); + let equipment = server + .items + .find_container_for_character(pa.character_id, slot_type::EQUIPMENT_SLAVE, db_id) + .expect("persistent slave equipment container"); + let stored = equipment + .lock() + .unwrap() + .get_item_by_slot(3) + .cloned() + .expect("part in the slave container"); + assert_eq!( + (stored.id, stored.slot_type), + (part_id, slot_type::EQUIPMENT_SLAVE) + ); + + // Unequip slave slot 3 -> empty bag slot 9. + let frames = run(packet_body(None, 9, Some(&stored), 3, true), &mut a); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 1 + ); + assert_eq!( + bag.lock().unwrap().get_item_by_slot(9).map(|i| i.id), + Some(part_id) + ); + assert!(slave.data().equipment[3].is_none()); + assert!(equipment.lock().unwrap().get_item_by_slot(3).is_none()); + + // Equip again, then destroy the hull and summon the saved slave: the parts must come back + // from the persistent container (item_containers.mate_id == slave DB id). + let frames = run(packet_body(Some(&stored), 9, None, 3, false), &mut a); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 1 + ); + slaves::delete(&server, Some(&pa), world.id, slave.obj_id, false); + let item = mates::owned_item(&server, &pa, item_id).unwrap(); + let again = slaves::create_core( + &server, + &world, + Some(&pa), + None, + SLAVE_TEMPLATE, + Some(item), + false, + None, + Some(slaves::SavedSlave { + id: db_id, + name: "Cart".into(), + hp: 1, + mp: 1, + }), + ) + .expect("re-summoned slave"); + assert_eq!( + again.data().equipment[3].as_ref().map(|i| i.id), + Some(part_id), + "the saved hull keeps its equipped parts" + ); +} + +const SHIP_HULL: u32 = 22; +const OTHER_HULL: u32 = 23; +const CANNON_ITEM: u32 = 28852; +const CANNON_CHILD: u32 = 10; +const SLOT20_ITEM: u32 = 5003; + +fn ship_equip_data() -> GameData { + use super::data::{ItemSlaveEquipment, SlaveEquipSlot, SlaveInitialItem}; + let mut d = slave_data(); + d.systems.vehicles.slave_templates.insert( + SHIP_HULL, + SlaveTemplate { + id: SHIP_HULL, + name: "Ship".into(), + model_id: 511, + level: 1, + slave_kind: super::data::slave_kind::MACHINE, + slave_initial_item_pack_id: 1, + // A static binding on an equipment attach point must not add a second cannon. + slave_bindings: vec![super::data::SlaveBinding { + id: 1, + owner_id: SHIP_HULL, + owner_type: "Slave".into(), + slave_id: CANNON_CHILD, + attach_point_id: 9, + }], + ..SlaveTemplate::default() + }, + ); + d.systems.vehicles.slave_templates.insert( + OTHER_HULL, + SlaveTemplate { + id: OTHER_HULL, + name: "Other".into(), + model_id: 512, + level: 1, + slave_kind: super::data::slave_kind::MACHINE, + ..SlaveTemplate::default() + }, + ); + d.systems.vehicles.slave_templates.insert( + CANNON_CHILD, + SlaveTemplate { + id: CANNON_CHILD, + name: "Steel Cannon".into(), + model_id: 117, + level: 1, + slave_kind: super::data::slave_kind::SLAVE_EQUIPMENT, + ..SlaveTemplate::default() + }, + ); + for item in [CANNON_ITEM, SLOT20_ITEM] { + d.items.templates.insert( + item, + ItemTemplate { + impl_id: crate::data::items::item_impl::SLAVE_EQUIPMENT, + ..ItemTemplate::plain(item, 1) + }, + ); + } + d.systems.vehicles.slave_initial_items.insert( + 1, + vec![ + SlaveInitialItem { + pack_id: 1, + equip_slot_id: 3, + item_id: CANNON_ITEM, + }, + // No slave_equip_slots entry: must not be seeded. + SlaveInitialItem { + pack_id: 1, + equip_slot_id: 20, + item_id: SLOT20_ITEM, + }, + ], + ); + d.systems.vehicles.slave_equip_slots.insert( + SHIP_HULL, + vec![SlaveEquipSlot { + id: 1, + slave_id: SHIP_HULL, + attach_point_id: 9, + equip_slot_id: 3, + require_slot_id: -1, + }], + ); + d.systems.vehicles.item_slave_equipments.insert( + CANNON_ITEM, + ItemSlaveEquipment { + id: 1, + item_id: CANNON_ITEM, + slave_id: CANNON_CHILD, + doodad_id: 0, + slave_equip_pack_id: 4, + slot_pack_id: 11, + require_item_id: 0, + }, + ); + d.systems + .vehicles + .slave_equip_packs + .insert(4, vec![SHIP_HULL]); + d.systems.vehicles.slave_slot_packs.insert(11, vec![3]); + d.systems.vehicles.attach_points.insert( + 511, + vec![( + 9, + WorldSpawnPosition { + x: 1.5, + y: 2.5, + z: 3.5, + ..WorldSpawnPosition::default() + }, + )], + ); + d +} + +#[tokio::test] +async fn slave_equipment_cannon_visuals_and_pack_validation() { + use crate::models::item::ItemClass; + use crate::net::registry::ClientPacket; + use crate::systems::vehicles::packets::CSChangeSlaveEquipmentPacket; + + let server = server_with(ship_equip_data()); + crate::systems::economy::bridges::install(&server); + crate::systems::npcs::install_hooks(&server); + super::install_hooks(&server); + let mut a = TestClient::new(&server, 1, 1); + let pa = spawn_player(&server, &a, test_character(1, "P1", 100.0, 100.0), PA); + a.conn.active_char = Some(pa.clone()); + let world = server.world.world(0).unwrap(); + server.systems.npcs.spawns.get_or_create(&world); + let bag = pa + .data() + .inventory + .get(slot_type::INVENTORY) + .unwrap() + .clone(); + server.items.add_container(bag.clone()); + + let hull = slaves::create_core( + &server, + &world, + Some(&pa), + None, + SHIP_HULL, + None, + false, + None, + None, + ) + .expect("hull"); + let (tl, db_id) = { + let d = hull.data(); + (d.unit.tl_id, d.id) + }; + assert!(db_id > 0); + + // The starter pack seeded the declared slot only and its cannon visual spawned. + assert_eq!( + hull.data().equipment[3].as_ref().map(|i| i.template_id), + Some(CANNON_ITEM) + ); + assert!( + hull.data().equipment[20].is_none(), + "seeding must skip equipment slots the hull does not declare" + ); + let equipment = server + .items + .find_container_for_character(pa.character_id, slot_type::EQUIPMENT_SLAVE, db_id) + .expect("persistent container"); + assert!(equipment.lock().unwrap().get_item_by_slot(20).is_none()); + let first_child = { + let ids = hull.data().attached_slaves.clone(); + assert_eq!(ids.len(), 1, "the seeded cannon must spawn its child slave"); + let child = world.slave(ids[0]).expect("child slave"); + assert_eq!(child.data().unit.template_id, CANNON_CHILD); + assert_eq!(child.data().attach_point_id, 9); + let t = child.data().unit.transform; + assert_eq!((t.x, t.y, t.z), (1.5, 2.5, 3.5)); + ids[0] + }; + + let character_id = pa.character_id; + let packet_body = |item1: Option<&crate::models::item::Item>, + slot1: u8, + item2: Option<&crate::models::item::Item>, + slot2: u8| + -> Vec { + let mut s = PacketStream::new(); + s.write_u32(character_id) + .write_u16(tl) + .write_u32(db_id) + .write_bool(false); + match item1 { + Some(i) => { + s.write(i); + } + None => { + s.write_u32(0); + } + } + match item2 { + Some(i) => { + s.write(i); + } + None => { + s.write_u32(0); + } + } + s.write_u8(slot_type::INVENTORY) + .write_u8(slot1) + .write_u8(slot_type::EQUIPMENT_SLAVE) + .write_u8(slot2); + s.into_bytes() + }; + let run = |body: Vec, a: &mut TestClient| { + let p = CSChangeSlaveEquipmentPacket::read(&mut PacketStream::from_bytes(body)).unwrap(); + futures::executor::block_on(p.handle(&server, &mut a.conn)).unwrap(); + a.drain() + }; + let stored = equipment + .lock() + .unwrap() + .get_item_by_slot(3) + .cloned() + .expect("cannon in the container"); + + // Unequip: the child slave goes away with the item. + let frames = run(packet_body(None, 9, Some(&stored), 3), &mut a); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 1 + ); + assert!(world.slave(first_child).is_none()); + assert!(hull.data().attached_slaves.is_empty()); + assert!(hull.data().equipment[3].is_none()); + + // Equip it again, then re-summon the saved hull: the persistent container respawns the visual. + let frames = run(packet_body(Some(&stored), 9, None, 3), &mut a); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 1 + ); + let respawned = hull.data().attached_slaves.clone(); + assert_eq!(respawned.len(), 1); + slaves::delete(&server, Some(&pa), world.id, hull.obj_id, false); + assert!(world.slave(respawned[0]).is_none()); + let again = slaves::create_core( + &server, + &world, + Some(&pa), + None, + SHIP_HULL, + None, + false, + None, + Some(slaves::SavedSlave { + id: db_id, + name: "Ship".into(), + hp: 1, + mp: 1, + }), + ) + .expect("re-summoned hull"); + let anew = again.data().attached_slaves.clone(); + assert_eq!( + anew.len(), + 1, + "re-summon must spawn the visual from the equipment container" + ); + assert_eq!( + again.data().equipment[3].as_ref().map(|i| i.id), + Some(stored.id) + ); + + // Bag cannon into a slot the hull does not declare: refused, no move, proper error. + let mut extra = server + .items + .create( + CANNON_ITEM, + 1, + 0, + 1, + &server.game_data.items, + &server.ids.item, + 0, + ) + .expect("extra cannon"); + assert_eq!(extra.class, ItemClass::SlaveEquipment); + extra.slot_type = slot_type::INVENTORY; + extra.slot = 7; + extra.owner_id = u64::from(pa.character_id); + extra.dirty = true; + bag.lock().unwrap().items.push(extra.clone()); + let frames = run(packet_body(Some(&extra), 7, None, 4), &mut a); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 0 + ); + assert!(error_codes(&frames).contains(&super::error::ITEM_NOT_FOR_PET)); + assert!(bag.lock().unwrap().get_item_by_slot(7).is_some()); + assert!(again.data().equipment[4].is_none()); + + // Same item on a hull whose pack does not allow it: refused as well. + let other = slaves::create_core( + &server, + &world, + Some(&pa), + None, + OTHER_HULL, + None, + false, + None, + None, + ) + .expect("other hull"); + let (other_tl, other_db) = { + let d = other.data(); + (d.unit.tl_id, d.id) + }; + let mut s = PacketStream::new(); + s.write_u32(character_id) + .write_u16(other_tl) + .write_u32(other_db) + .write_bool(false); + s.write(&extra); + s.write_u32(0); + s.write_u8(slot_type::INVENTORY) + .write_u8(7) + .write_u8(slot_type::EQUIPMENT_SLAVE) + .write_u8(3); + let frames = run(s.into_bytes(), &mut a); + assert_eq!( + *body(&frames, sc::SCSlaveEquipmentChangedPacket) + .last() + .unwrap(), + 0 + ); + assert!(error_codes(&frames).contains(&super::error::ITEM_NOT_FOR_PET)); + assert!(bag.lock().unwrap().get_item_by_slot(7).is_some()); + assert!(other.data().equipment[3].is_none()); +} + +const FIRE_CANNON: u32 = 10473; +const GUNNER_STATE_SKILL: u32 = 14372; +const CANNON_MOUNT_SKILL: u32 = 16; +const CANNON_TARGET_NPC: u32 = 901; + +/// `ship_equip_data` plus the 1.2 cannon fire skill: mount skill 16 -> skill 10473 (ballistic +/// position target, 4 m area, 4-120 m, fixed damage), attached skill 14372 at the gunner seat. +fn cannon_data() -> GameData { + use crate::systems::skills::data::effects::EffectTemplate; + use crate::systems::skills::data::{EffectKind, SkillTemplate}; + let mut d = ship_equip_data(); + d.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(crate::systems::skills::tests::damage_effect( + 183, 150, + ))), + 183, + ); + d.systems.skills.add_skill(SkillTemplate { + id: FIRE_CANNON, + target_type: 11, // BallisticPos + target_selection: 2, + // The real row is Hostile (4); this fixture has no factions. + target_relation: 5, + target_area_radius: 4, + min_range: 4, + max_range: 120, + source_mount: true, + level_rule_no_consideration: true, + effects: vec![crate::systems::skills::tests::skill_effect( + 183, + EffectKind::DamageEffect, + 183, + )], + ..SkillTemplate::default() + }); + d.systems.skills.add_skill(SkillTemplate { + id: GUNNER_STATE_SKILL, + target_type: 0, + level_rule_no_consideration: true, + ..SkillTemplate::default() + }); + d.systems + .vehicles + .mount_skills + .push(super::data::MountSkills { + id: CANNON_MOUNT_SKILL, + name: "Fire".into(), + skill_id: FIRE_CANNON, + }); + d.systems + .vehicles + .mount_attached_skills + .push(super::data::MountAttachedSkills { + id: 131, + mount_skill_id: CANNON_MOUNT_SKILL, + attach_point_id: attach_point::DRIVER, + skill_id: GUNNER_STATE_SKILL, + }); + d.systems.npcs.npc.templates.insert( + CANNON_TARGET_NPC, + NpcTemplate { + id: CANNON_TARGET_NPC, + name: "Target".into(), + level: 1, + ..NpcTemplate::default() + }, + ); + d +} + +#[tokio::test] +async fn ship_cannon_gunner_seat_skill_and_leaving() { + use crate::net::registry::ClientPacket; + use crate::systems::skills::handlers::{start_skill, CSStartSkillPacket}; + use crate::systems::skills::types::{SkillCastTarget, SkillCaster, SkillObject}; + + let server = server_with(cannon_data()); + crate::systems::economy::bridges::install(&server); + crate::systems::npcs::install_hooks(&server); + super::install_hooks(&server); + let mut a = TestClient::new(&server, 1, 1); + let mut b = TestClient::new(&server, 2, 2); + let mut c = TestClient::new(&server, 3, 3); + let pa = spawn_player(&server, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let pb = spawn_player(&server, &b, test_character(2, "Crew", 101.0, 100.0), PB); + let pc = spawn_player( + &server, + &c, + test_character(3, "Stranger", 102.0, 100.0), + 0x00F0_0003, + ); + a.conn.active_char = Some(pa.clone()); + b.conn.active_char = Some(pb.clone()); + c.conn.active_char = Some(pc.clone()); + let world = server.world.world(0).unwrap(); + server.systems.npcs.spawns.get_or_create(&world); + + let hull = slaves::create_core( + &server, + &world, + Some(&pa), + None, + SHIP_HULL, + None, + false, + None, + None, + ) + .expect("hull"); + let cannon = world + .slave(hull.data().attached_slaves[0]) + .expect("cannon child"); + let cannon_tl = u32::from(cannon.data().unit.tl_id); + assert!(slaves::is_manned_cannon(&server, &cannon)); + assert!(!slaves::is_manned_cannon(&server, &hull)); + + let target = spawn_npc_at(&server, 0x5000, CANNON_TARGET_NPC, 130.0, 130.0); + target.data().unit.hp = 1000; + target.data().unit.max_hp = 1000; + let fire = |client: &mut TestClient, x: f32, y: f32| { + start_skill( + &server, + &mut client.conn, + CSStartSkillPacket { + skill_id: FIRE_CANNON, + caster: SkillCaster::Mount { + obj_id: cannon.obj_id, + mount_skill_template_id: CANNON_MOUNT_SKILL, + }, + target: SkillCastTarget::Position { + obj_id: 0, + x, + y, + z: 100.0, + rot: 0.0, + obj_id1: 0, + obj_id2: 0, + }, + flag: 0, + skill_object: SkillObject::None, + }, + ); + }; + a.drain(); + b.drain(); + c.drain(); + + // Not manned yet: not even the ship owner may fire the cannon. + fire(&mut a, 130.0, 130.0); + assert_eq!(target.data().unit.hp, 1000); + a.drain(); + + // A stranger off the ship is refused with the bind error and is not seated. + slaves::bind_slave_by_tl(&server, &pc, cannon_tl); + assert!(error_codes(&c.drain()).contains(&super::error::SLAVE_CANNOT_BIND)); + assert!(cannon.data().attached_characters.is_empty()); + + // The ship owner mans it at the gunner seat, behind the barrel. + slaves::bind_slave_by_tl(&server, &pa, cannon_tl); + assert!(ops(&a.drain()).contains(&sc::SCUnitAttachedPacket)); + assert_eq!( + cannon.data().attached_characters, + vec![(attach_point::DRIVER, PA)] + ); + assert_eq!(pa.data().unit.transform.parent_obj_id, cannon.obj_id); + let t = pa.data().unit.transform; + assert_eq!((t.x, t.y, t.z), slaves::GUNNER_SEAT_OFFSET); + + // The gunner follows the cannon on the moving ship. + let before = world.world_pos_rot(&WorldObject::from(&pa)); + hull.data().unit.transform.x += 25.0; + hull.data().unit.transform.y -= 10.0; + let after = world.world_pos_rot(&WorldObject::from(&pa)); + assert!( + (after.x - before.x - 25.0).abs() < 1e-3, + "{before:?} {after:?}" + ); + assert!((after.y - before.y + 10.0).abs() < 1e-3); + + // Second gunner: a crew member standing on the ship is refused, one gunner per cannon. + world.attach_child(&WorldObject::from(&hull), &WorldObject::from(&pb)); + slaves::bind_slave_by_tl(&server, &pb, cannon_tl); + assert!(error_codes(&b.drain()).contains(&super::error::SLAVE_ALREADY_HAS_MASTER)); + assert_eq!(cannon.data().attached_characters.len(), 1); + // ... and cannot cast its skills either. + fire(&mut b, 130.0, 130.0); + assert_eq!(target.data().unit.hp, 1000); + b.drain(); + + // The gunner fires at a ground position: the unit in the area takes the shot. + fire(&mut a, 130.0, 130.0); + assert_eq!(target.data().unit.hp, 850, "fixed 150 damage"); + let fa = a.drain(); + assert!(ops(&fa).contains(&sc::SCSkillFiredPacket)); + assert!(ops(&fa).contains(&sc::SCUnitPointsPacket)); + assert!(ops(&b.drain()).contains(&sc::SCSkillFiredPacket)); + // Out of the 4 m area: no damage. + fire(&mut a, 60.0, 60.0); + assert_eq!(target.data().unit.hp, 850); + + // Leaving the cannon (CSDiscardSlave) frees the seat for the crew member. + let discard = super::packets::CSDiscardSlavePacket { + tl_id: cannon_tl as u16, + }; + futures::executor::block_on(discard.handle(&server, &mut a.conn)).unwrap(); + assert!(cannon.data().attached_characters.is_empty()); + assert_eq!(pa.data().unit.transform.parent_obj_id, 0); + assert!(ops(&a.drain()).contains(&sc::SCUnitDetachedPacket)); + b.drain(); + slaves::bind_slave_by_tl(&server, &pb, cannon_tl); + assert_eq!( + cannon.data().attached_characters, + vec![(attach_point::DRIVER, PB)] + ); + assert!(error_codes(&b.drain()).is_empty()); + + // The gunner dying leaves the cannon. + crate::systems::skills::combat::do_die( + &server, + &WorldObject::from(&pb), + Some(&WorldObject::from(&target)), + crate::systems::skills::types::KillReason::Damage, + ); + assert!(cannon.data().attached_characters.is_empty()); + assert_eq!(pb.data().unit.transform.parent_obj_id, 0); + + // Recalling the ship unbinds a gunner too. + slaves::bind_slave_by_tl(&server, &pa, cannon_tl); + assert_eq!(cannon.data().attached_characters.len(), 1); + slaves::delete(&server, Some(&pa), world.id, hull.obj_id, false); + assert_eq!(pa.data().attached_point, attach_point::NONE); + assert_eq!(pa.data().unit.transform.parent_obj_id, 0); + assert!(!pa.data().is_riding); + assert!(cannon.data().attached_characters.is_empty()); +} diff --git a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs index 17c430b675..30f6723fcd 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs @@ -261,10 +261,14 @@ pub mod error { pub const ITEM_FAILED_REPAIR: i16 = 23; pub const NOT_ENOUGH_MONEY: i16 = 26; pub const NOT_ENOUGH_ITEM: i16 = 27; + pub const SLAVE_CANNOT_BIND: i16 = 96; pub const SLAVE_ALREADY_HAS_MASTER: i16 = 97; pub const SLAVE_SPAWN_ITEM_LOCKED: i16 = 101; + pub const SLAVE_UNBIND_FIRST: i16 = 102; + pub const ITEM_NOT_FOR_PET: i16 = 204; pub const NOT_READY: i16 = 206; pub const SLAVE_SPAWN_ERROR_NEED_REPAIR_TIME: i16 = 540; + pub const SLAVE_SPAWN_ERROR_INVALID_AREA: i16 = 583; pub const SLAVE_EQUIPMENT_LOADED_ITEM: i16 = 801; } @@ -373,6 +377,7 @@ pub fn on_death_event(server: &GameServer, victim: &WorldObject) { match victim { WorldObject::Shipyard(s) => shipyards::on_death(server, s), WorldObject::Mate(m) => mates::on_death(server, m), + WorldObject::Player(p) => slaves::on_gunner_death(server, p), _ => {} } } diff --git a/rust/crates/aaemu-game/src/systems/vehicles/packets.rs b/rust/crates/aaemu-game/src/systems/vehicles/packets.rs index 79e1f5594e..c0684452a2 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/packets.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/packets.rs @@ -9,6 +9,8 @@ use crate::net::packet::LEVEL_PLAIN; use crate::net::registry::PacketRegistry; use crate::opcodes::{cs, sc}; use crate::packets::packet_def; +use crate::systems::economy::mate_equipment::read_wire_item; +pub use crate::systems::economy::mate_equipment::WireItem; use super::{mates, shipyards, slaves}; @@ -341,6 +343,45 @@ cs_packet!( } ); +cs_packet!( + /// `CSChangeSlaveEquipmentPacket` (1.2 body: the header, one item pair and its two + /// locations; the 10.x count/expire fields do not exist in the 1.2 client writer + /// `397d1410` / `397d12a0`). + CSChangeSlaveEquipmentPacket { + character_id: u32, + slave_tl: u16, + db_slave_id: u32, + bts: bool, + item1: WireItem, + item2: WireItem, + slot1_type: u8, + slot1: u8, + slot2_type: u8, + slot2: u8, + } + read |s| { + Ok(Self { + character_id: s.read_u32()?, + slave_tl: s.read_u16()?, + db_slave_id: s.read_u32()?, + bts: s.read_bool()?, + item1: read_wire_item(s)?, + item2: read_wire_item(s)?, + slot1_type: s.read_u8()?, + slot1: s.read_u8()?, + slot2_type: s.read_u8()?, + slot2: s.read_u8()?, + }) + } + handle |self, server, conn| { + let Some(p) = conn.active_char.clone() else { + return Ok(()); + }; + slaves::change_slave_equipment(server, &p, &self); + Ok(()) + } +); + cs_packet!( /// `CSSpawnSlavePacket` (log only in C#). CSSpawnSlavePacket { @@ -459,6 +500,7 @@ pub fn register(reg: &mut PacketRegistry) { reg.register::(LEVEL_PLAIN, cs::CSBindSlavePacket); reg.register::(LEVEL_PLAIN, cs::CSChangeSlaveNamePacket); reg.register::(LEVEL_PLAIN, cs::CSDespawnSlavePacket); + reg.register::(LEVEL_PLAIN, cs::CSChangeSlaveEquipmentPacket); reg.register::(LEVEL_PLAIN, cs::CSDestroySlavePacket); reg.register::(LEVEL_PLAIN, cs::CSDiscardSlavePacket); reg.register::(LEVEL_PLAIN, cs::CSSpawnSlavePacket); diff --git a/rust/crates/aaemu-game/src/systems/vehicles/pr38_regression_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/pr38_regression_tests.rs new file mode 100644 index 0000000000..c2291f1071 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/vehicles/pr38_regression_tests.rs @@ -0,0 +1,549 @@ +//! Regressions for legacy hull defaults, persistent empty equipment, and gunner authority/lifetime. + +use super::*; +use crate::world::SlaveRef; + +fn hull(server: &GameServer, owner: &PlayerRef, saved: Option) -> SlaveRef { + let world = server.world.world(0).unwrap(); + slaves::create_core( + server, + &world, + Some(owner), + None, + SHIP_HULL, + None, + false, + None, + saved, + ) + .expect("hull") +} + +fn saved(id: u32) -> slaves::SavedSlave { + slaves::SavedSlave { + id, + name: "Legacy hull".into(), + hp: 100, + mp: 10, + } +} + +#[tokio::test] +async fn no_starter_pack_migrates_equivalent_defaults_and_preserves_unmapped_bindings() { + let mut d = ship_equip_data(); + d.systems.vehicles.slave_initial_items.clear(); + let template = d + .systems + .vehicles + .slave_templates + .get_mut(&SHIP_HULL) + .unwrap(); + template + .slave_bindings + .push(super::super::data::SlaveBinding { + id: 2, + owner_id: SHIP_HULL, + owner_type: "Slave".into(), + slave_id: OTHER_HULL, + attach_point_id: 10, + }); + d.systems + .vehicles + .slave_equip_slots + .get_mut(&SHIP_HULL) + .unwrap() + .push(super::super::data::SlaveEquipSlot { + id: 2, + slave_id: SHIP_HULL, + attach_point_id: 10, + equip_slot_id: 4, + require_slot_id: -1, + }); + let server = server_with(d); + let a = TestClient::new(&server, 1, 1); + let owner = spawn_player(&server, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let world = server.world.world(0).unwrap(); + let first = hull(&server, &owner, None); + let db_id = first.data().id; + assert_eq!( + first.data().attached_slaves.len(), + 2, + "both authored defaults survive" + ); + assert_eq!( + first.data().equipment[3].as_ref().unwrap().template_id, + CANNON_ITEM + ); + assert!( + first.data().equipment[4].is_none(), + "no equivalent item for the static child" + ); + let container = server + .items + .find_container_for_character(1, slot_type::EQUIPMENT_SLAVE, db_id) + .unwrap(); + // Deliberate unequipping leaves a persistent, empty container. It must not seed again. + container.lock().unwrap().items.clear(); + slaves::delete(&server, Some(&owner), world.id, first.obj_id, false); + let again = hull(&server, &owner, Some(saved(db_id))); + assert!(again.data().equipment[3].is_none()); + let children = again.data().attached_slaves.clone(); + assert_eq!( + children.len(), + 1, + "only the unmapped static default returns" + ); + assert_eq!( + world.slave(children[0]).unwrap().data().unit.template_id, + OTHER_HULL + ); +} + +#[tokio::test] +async fn saved_hull_initializes_starter_equipment_only_when_container_is_created() { + let server = server_with(ship_equip_data()); + let a = TestClient::new(&server, 1, 1); + let owner = spawn_player(&server, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let first = hull(&server, &owner, Some(saved(700))); + let item = first.data().equipment[3] + .clone() + .expect("legacy hull starter cannon"); + assert_eq!(item.template_id, CANNON_ITEM); + let container = server + .items + .find_container_for_character(1, slot_type::EQUIPMENT_SLAVE, 700) + .unwrap(); + assert_eq!( + container.lock().unwrap().get_item_by_slot(3).unwrap().id, + item.id + ); + container.lock().unwrap().items.clear(); + let world = server.world.world(0).unwrap(); + slaves::delete(&server, Some(&owner), world.id, first.obj_id, false); + let again = hull(&server, &owner, Some(saved(700))); + assert!(again.data().equipment[3].is_none()); + assert!( + again.data().attached_slaves.is_empty(), + "unequipped defaults stay absent" + ); +} + +#[tokio::test] +#[ignore = "needs AAEMU_TEST_MYSQL on private MySQL3317; uses connection-local temporary tables"] +async fn private_mysql_legacy_slave_equipment_survives_restart_and_stays_unequipped() { + use sqlx::mysql::MySqlConnectOptions; + use std::str::FromStr; + + let options = MySqlConnectOptions::from_str( + &std::env::var("AAEMU_TEST_MYSQL").expect("AAEMU_TEST_MYSQL"), + ) + .unwrap(); + assert_eq!(options.get_port(), 3317); + assert!(matches!(options.get_host(), "127.0.0.1" | "localhost")); + let pool = MySqlPoolOptions::new() + .max_connections(1) + .connect_with(options) + .await + .unwrap(); + // Exercise production serializers/loaders with connection-local tables; no persistent rows + // or another session's tables are touched, even if an assertion fails. + for table in ["items", "item_containers", "slaves"] { + let (_, ddl): (String, String) = sqlx::query_as(&format!("SHOW CREATE TABLE `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + sqlx::query(&ddl.replacen("CREATE TABLE", "CREATE TEMPORARY TABLE", 1)) + .execute(&pool) + .await + .unwrap(); + } + let make_server = || { + let mut server = test_server_with(ship_equip_data()); + server.db = pool.clone(); + let server = Arc::new(server); + server.set_self(); + server + }; + let server = make_server(); + let a = TestClient::new(&server, 1, 1); + let (owner, item_id) = player_with_item(&server, &a, 1, PA, (100.0, 100.0), SLAVE_ITEM); + let bag = owner.data().inventory.bag().clone(); + bag.lock().unwrap().container_id = 900; + server.items.add_container(bag.clone()); + let item = { + let mut bag = bag.lock().unwrap(); + let item = bag.items.iter_mut().find(|i| i.id == item_id).unwrap(); + item.owner_id = 1; + item.details.slave_db_id = 700; + item.dirty = true; + item.clone() + }; + let row = slaves::SlaveRow { + id: 700, + item_id, + template_id: SHIP_HULL, + attach_point: -1, + name: "Legacy hull".into(), + owner_type: 0, + owner_id: 1, + summoner: 1, + hp: 100, + mp: 10, + x: 100.0, + y: 100.0, + z: 100.0, + }; + slaves::write_row(&mut pool.acquire().await.unwrap(), &row) + .await + .unwrap(); + let world = server.world.world(0).unwrap(); + let first = slaves::create( + &server, + &world, + Some(&owner), + SHIP_HULL, + Some(item.clone()), + false, + None, + ) + .await + .unwrap(); + assert_eq!(first.data().id, 700); + let cannon_item = first.data().equipment[3] + .clone() + .expect("legacy starter equipment"); + assert_eq!(first.data().attached_slaves.len(), 1); + let mut tx = pool.begin().await.unwrap(); + server.items.save(&mut tx).await.unwrap(); + for row in slaves::snapshot(&server, &first) { + slaves::write_row(&mut tx, &row).await.unwrap(); + } + tx.commit().await.unwrap(); + server.items.commit_save(); + + let restart = make_server(); + restart + .items + .load_user_items( + &pool, + &restart.game_data.items, + 1, + &restart.ids.container, + &restart.ids.item, + ) + .await + .unwrap(); + let a = TestClient::new(&restart, 1, 1); + let owner = spawn_player(&restart, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let world = restart.world.world(0).unwrap(); + let again = slaves::create( + &restart, + &world, + Some(&owner), + SHIP_HULL, + Some(item.clone()), + false, + None, + ) + .await + .unwrap(); + assert_eq!( + again.data().equipment[3].as_ref().unwrap().id, + cannon_item.id, + "restart preserves item identity" + ); + assert_eq!(again.data().attached_slaves.len(), 1); + let container = restart + .items + .find_container_for_character(1, slot_type::EQUIPMENT_SLAVE, 700) + .unwrap(); + let removed = { + let mut container = container.lock().unwrap(); + container.dirty = true; + container.items.remove(0) + }; + restart.items.mark_for_db_deletion(removed.id); + let mut tx = pool.begin().await.unwrap(); + restart.items.save(&mut tx).await.unwrap(); + tx.commit().await.unwrap(); + restart.items.commit_save(); + + let restart = make_server(); + restart + .items + .load_user_items( + &pool, + &restart.game_data.items, + 1, + &restart.ids.container, + &restart.ids.item, + ) + .await + .unwrap(); + let a = TestClient::new(&restart, 1, 1); + let owner = spawn_player(&restart, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let world = restart.world.world(0).unwrap(); + let empty = slaves::create( + &restart, + &world, + Some(&owner), + SHIP_HULL, + Some(item), + false, + None, + ) + .await + .unwrap(); + assert!(empty.data().equipment[3].is_none()); + assert!( + empty.data().attached_slaves.is_empty(), + "empty persisted container is intentional" + ); + pool.close().await; +} + +async fn parent_only_cannon_attack(occupied: bool) { + use crate::models::movement::{MoveTypeActorFlags, UnitMove}; + use crate::net::registry::ClientPacket; + use crate::packets::c2g_world::CSMoveUnitPacket; + use crate::systems::skills::handlers::{start_skill, CSStartSkillPacket}; + use crate::systems::skills::types::{SkillCastTarget, SkillCaster, SkillObject}; + + let server = server_with(cannon_data()); + crate::systems::economy::bridges::install(&server); + crate::systems::npcs::install_hooks(&server); + super::super::install_hooks(&server); + let mut a = TestClient::new(&server, 1, 1); + let mut b = TestClient::new(&server, 2, 2); + let owner = spawn_player(&server, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let attacker = spawn_player(&server, &b, test_character(2, "Attacker", 101.0, 100.0), PB); + a.conn.active_char = Some(owner.clone()); + b.conn.active_char = Some(attacker.clone()); + let world = server.world.world(0).unwrap(); + let carrier = hull(&server, &owner, None); + let cannon_id = carrier.data().attached_slaves[0]; + let cannon = world.slave(cannon_id).unwrap(); + if occupied { + let tl = u32::from(cannon.data().unit.tl_id); + slaves::bind_slave_by_tl(&server, &owner, tl); + } + // The authenticated movement path accepts a supporting object, but grants no gunner seat. + CSMoveUnitPacket { + obj_id: PB, + move_type: MoveType::new(MoveKind::Unit(UnitMove { + x: 0.0, + y: 0.0, + z: 0.0, + gc_id: cannon.obj_id, + gc_flags: 1, + actor_flags: MoveTypeActorFlags::STANDING_ON_OBJECT, + ..UnitMove::default() + })), + } + .handle(&server, &mut b.conn) + .await + .unwrap(); + assert_eq!(attacker.data().unit.transform.parent_obj_id, cannon.obj_id); + assert_eq!(attacker.data().attached_point, attach_point::NONE); + let target = spawn_npc_at(&server, 0x5000, CANNON_TARGET_NPC, 130.0, 130.0); + target.data().unit.hp = 1000; + target.data().unit.max_hp = 1000; + let shot = CSStartSkillPacket { + skill_id: FIRE_CANNON, + caster: SkillCaster::Mount { + obj_id: cannon.obj_id, + mount_skill_template_id: CANNON_MOUNT_SKILL, + }, + target: SkillCastTarget::Position { + obj_id: 0, + x: 130.0, + y: 130.0, + z: 100.0, + rot: 0.0, + obj_id1: 0, + obj_id2: 0, + }, + flag: 0, + skill_object: SkillObject::None, + }; + b.drain(); + start_skill(&server, &mut b.conn, shot.clone()); + assert_eq!( + target.data().unit.hp, + 1000, + "a parent pointer cannot grant a cannon shot" + ); + assert!(!ops(&b.drain()).contains(&sc::SCSkillFiredPacket)); + if occupied { + assert_eq!( + cannon.data().attached_characters, + vec![(attach_point::DRIVER, PA)] + ); + // A stale or inconsistent attachment does not authorize the registered gunner either. + world.detach_child(&WorldObject::from(&owner)); + start_skill(&server, &mut a.conn, shot.clone()); + assert_eq!(target.data().unit.hp, 1000); + world.attach_child(&WorldObject::from(&cannon), &WorldObject::from(&owner)); + owner.data().attached_point = attach_point::NONE; + start_skill(&server, &mut a.conn, shot.clone()); + assert_eq!(target.data().unit.hp, 1000); + owner.data().attached_point = attach_point::DRIVER; + } else { + let tl = u32::from(cannon.data().unit.tl_id); + slaves::bind_slave_by_tl(&server, &owner, tl); + } + start_skill(&server, &mut a.conn, shot); + assert_eq!( + target.data().unit.hp, + 850, + "the registered, attached driver can fire" + ); +} + +#[tokio::test] +async fn parent_only_attacker_cannot_fire_an_unoccupied_cannon() { + parent_only_cannon_attack(false).await; +} + +#[tokio::test] +async fn parent_only_attacker_cannot_fire_another_gunners_cannon() { + parent_only_cannon_attack(true).await; +} + +#[tokio::test] +async fn carrier_death_detaches_gunner_before_deleting_cannon() { + let server = server_with(cannon_data()); + super::super::install_hooks(&server); + let mut a = TestClient::new(&server, 1, 1); + let owner = spawn_player(&server, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let world = server.world.world(0).unwrap(); + let carrier = hull(&server, &owner, None); + let cannon_id = carrier.data().attached_slaves[0]; + let cannon = world.slave(cannon_id).unwrap(); + let tl = u32::from(cannon.data().unit.tl_id); + slaves::bind_slave_by_tl(&server, &owner, tl); + carrier + .data() + .unit + .transform + .set_position(250.0, 175.0, 90.0, 0.0, 0.0, 1.2); + let before = world.world_pos_rot(&WorldObject::from(&owner)); + a.drain(); + slaves::do_die( + &server, + &carrier, + Some(&WorldObject::from(&owner)), + crate::systems::skills::types::KillReason::Damage, + ); + assert!(world.slave(cannon.obj_id).is_none()); + assert!( + cannon.data().attached_characters.is_empty(), + "gunner seat released before removal" + ); + let player = owner.data(); + assert_eq!(player.attached_point, attach_point::NONE); + assert!(!player.is_riding); + assert_eq!(player.unit.transform.parent_obj_id, 0); + let after = player.unit.transform.local(); + drop(player); + for (a, b) in [ + (before.x, after.x), + (before.y, after.y), + (before.z, after.z), + (before.rot_z, after.rot_z), + ] { + assert!( + (a - b).abs() < 1e-4, + "world transform changed: {before:?} -> {after:?}" + ); + } + let mut detached = bc(PA); + detached.push(slaves::attach_reason::NONE); + assert_eq!(body(&a.drain(), sc::SCUnitDetachedPacket), detached); +} + +#[tokio::test] +#[ignore = "needs AAEMU_COMPACT_DB"] +async fn real_compact_db_vehicle_defaults_spawn_on_legacy_hulls() { + let Ok(db) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + rusqlite::Connection::open_with_flags(&db, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY) + .unwrap(); + let mut d = slave_data(); + d.systems.vehicles = load_real(&db, &[]); + d.items = crate::data::items::ItemData::load(&conn).unwrap(); + d.systems.npcs.doodad = + crate::systems::npcs::doodad::data::DoodadData::load_from(&conn).unwrap(); + let server = server_with(d); + let a = TestClient::new(&server, 1, 1); + let owner = spawn_player(&server, &a, test_character(1, "Owner", 100.0, 100.0), PA); + let world = server.world.world(0).unwrap(); + for id in [14, 21, 75, 76, 110] { + let template = server + .game_data + .systems + .vehicles + .slave_template(id) + .unwrap(); + assert!(server + .game_data + .systems + .vehicles + .slave_initial_item_pack(template.slave_initial_item_pack_id) + .is_none()); + let carrier = slaves::create_core( + &server, + &world, + Some(&owner), + None, + id, + None, + false, + None, + Some(saved(700 + id)), + ) + .unwrap(); + let children = carrier.data().attached_slaves.clone(); + assert_eq!( + children.len(), + template.slave_bindings.len(), + "hull {id}: all child defaults" + ); + for binding in &template.slave_bindings { + assert_eq!( + children + .iter() + .filter(|child| { + let child = world.slave(**child).unwrap(); + let child = child.data(); + child.attach_point_id as u8 == binding.attach_point_id + && child.unit.template_id == binding.slave_id + }) + .count(), + 1, + "hull {id} point {}", + binding.attach_point_id + ); + } + let doodads = carrier.data().attached_doodads.clone(); + for binding in &template.doodad_bindings { + assert_eq!( + doodads + .iter() + .filter(|child| { + let child = world.doodad(**child).unwrap(); + let child = child.data(); + child.attach_point == binding.attach_point_id + && child.template_id == binding.doodad_id + }) + .count(), + 1, + "hull {id} doodad point {}", + binding.attach_point_id + ); + } + slaves::delete(&server, Some(&owner), world.id, carrier.obj_id, false); + } +} diff --git a/rust/crates/aaemu-game/src/systems/vehicles/shipyards.rs b/rust/crates/aaemu-game/src/systems/vehicles/shipyards.rs index 5b67a2cf5e..7482e8b2e3 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/shipyards.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/shipyards.rs @@ -522,6 +522,8 @@ pub async fn shipyard_completed(server: &GameServer, shipyard: &ShipyardRef) { item_template_id, true, Some(pos), + None, + 0.0, ) .await; } diff --git a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs index 3cab8f3b1e..af828d279e 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs @@ -11,14 +11,21 @@ use rand::Rng; use sqlx::Row; use crate::data::world_templates::WorldSpawnPosition; +use crate::models::container::{slot_type, ContainerRef}; use crate::models::doodad::doodad_owner_type; use crate::models::item::{Item, ItemClass}; +use crate::models::item_task::task_type; use crate::models::slave::Slave; use crate::models::transform::Transform; use crate::models::unit::{BaseUnitType, Bonus}; use crate::packets::world::SCUnitPointsPacket; use crate::packets::world_objects::SCUnitAttachedPacket; use crate::server::GameServer; +use crate::systems::economy::inventory::{self, Inv, ItemTxn}; +use crate::systems::economy::item_effect_packets::{ + ItemAndLocation, SCSlaveEquipmentChangedPacket, +}; +use crate::systems::economy::item_packets::SCUnitEquipmentsChangedPacket; use crate::systems::npcs::doodad::spawner::SimpleSpawnerDef; use crate::systems::npcs::spawn_manager; use crate::systems::skills::effects::EffectArgs; @@ -342,6 +349,721 @@ pub fn character_slave(server: &GameServer, p: &PlayerRef) -> Option) -> bool { + if wire.template_id == 0 { + return actual.is_none(); + } + actual.is_some_and(|i| i.template_id == wire.template_id && (wire.id == 0 || i.id == wire.id)) +} + +/// Reply to one `CSChangeSlaveEquipment` entry with the pre-move server snapshots (10.x +/// `SCSlaveEquipmentChangedPacket`; the client applies the copies only when `success` is set). +fn reply_slave_equipment( + character: &PlayerRef, + p: &super::packets::CSChangeSlaveEquipmentPacket, + on_slave: Option<&Item>, + in_bag: Option<&Item>, + success: bool, +) { + character.send(SCSlaveEquipmentChangedPacket { + item_on_slave: ItemAndLocation { + item: on_slave.cloned(), + slot_type: p.slot1_type, + slot: p.slot1, + }, + item_in_bag: ItemAndLocation { + item: in_bag.cloned(), + slot_type: p.slot2_type, + slot: p.slot2, + }, + slave_tl_id: p.slave_tl, + character_id: p.character_id, + db_slave_id: p.db_slave_id, + bts: p.bts, + success, + }); +} + +/// Copies the persistent equipment container into the slave model mirror (stats and visibility +/// read the mirror). +fn mirror_slave_equipment(slave: &SlaveRef, container: &ContainerRef) { + let items = container.lock().expect("container poisoned").items.clone(); + let mut d = slave.data(); + d.equipment.fill(None); + for it in items { + let slot = it.slot.max(0) as usize; + if let Some(entry) = d.equipment.get_mut(slot) { + *entry = Some(it); + } + } +} + +/// Initial equipment, including legacy static defaults that have an exact legal item equivalent. +/// A multi-point slot is migrated only when one item reproduces every authored binding. Parts +/// without such an equivalent remain static, rather than disappearing merely because a slot exists. +fn initial_slave_equipment( + server: &GameServer, + template: &SlaveTemplate, +) -> Vec { + let data = &server.game_data.systems.vehicles; + let mut initial = data + .slave_initial_item_pack(template.slave_initial_item_pack_id) + .unwrap_or_default() + .iter() + .copied() + .filter(|item| server.game_data.items.template(item.item_id).is_some()) + .collect::>(); + for slot in data.slave_equip_slots(template.id) { + if initial + .iter() + .any(|i| i.equip_slot_id == slot.equip_slot_id) + { + continue; + } + let points = data.slave_equip_attach_points(template.id, slot.equip_slot_id); + let equivalent = data + .item_slave_equipments + .values() + .filter(|item| { + item.require_item_id == 0 + && server.game_data.items.template(item.item_id).is_some() + && data.can_equip_item_on_slave(item.item_id, template.id, slot.equip_slot_id) + && points.iter().all(|point| { + let child = template + .slave_bindings + .iter() + .find(|b| b.owner_type == "Slave" && b.attach_point_id == *point); + let doodad = template + .doodad_bindings + .iter() + .find(|b| b.attach_point_id == *point); + (child.is_some() || doodad.is_some()) + && child.map_or(0, |b| b.slave_id) == item.slave_id + && doodad.map_or(0, |b| b.doodad_id) == item.doodad_id + }) + }) + .min_by_key(|item| item.item_id); + if let Some(item) = equivalent { + initial.push(super::data::SlaveInitialItem { + pack_id: template.slave_initial_item_pack_id, + equip_slot_id: slot.equip_slot_id, + item_id: item.item_id, + }); + } + } + initial +} + +/// Static bindings remain authored defaults unless the slot has initial equipment (explicit or +/// migrated). That decision is independent of its current contents: an intentionally empty saved +/// slot must not grow its static default again on the next summon. +fn is_binding_attach_point(server: &GameServer, template: &SlaveTemplate, point: u8) -> bool { + let data = &server.game_data.systems.vehicles; + let initial = initial_slave_equipment(server, template); + if data.slave_equip_slots(template.id).iter().any(|slot| { + slot.attach_point_id == point + && initial + .iter() + .any(|i| i.equip_slot_id == slot.equip_slot_id) + }) { + return false; + } + template + .doodad_bindings + .iter() + .any(|b| b.attach_point_id == point) + || template + .slave_bindings + .iter() + .any(|b| b.attach_point_id == point) + || template + .healing_point_doodads + .iter() + .any(|b| b.attach_point_id == point) +} + +/// Removes the equipment-driven visual at one attach point (a child slave / doodad created by +/// [`spawn_or_replace_equipment_visual`]). Static bindings are never removed. +fn remove_equipment_visual_at( + server: &GameServer, + world: &Arc, + slave: &SlaveRef, + point: u8, +) { + let data = &server.game_data.systems.vehicles; + if data + .slave_template(slave.data().unit.template_id) + .is_some_and(|t| is_binding_attach_point(server, t, point)) + { + return; + } + let (attached_doodads, attached_slaves) = { + let d = slave.data(); + (d.attached_doodads.clone(), d.attached_slaves.clone()) + }; + let doodads: Vec<_> = attached_doodads + .into_iter() + .filter(|id| { + world + .doodad(*id) + .is_some_and(|dd| dd.data().attach_point == point) + }) + .collect(); + let children: Vec<_> = attached_slaves + .into_iter() + .filter(|id| { + world + .slave(*id) + .is_some_and(|s| s.data().attach_point_id as u8 == point) + }) + .collect(); + slave + .data() + .attached_doodads + .retain(|id| !doodads.contains(id)); + for id in &doodads { + if let Some(doodad) = world.doodad(*id) { + spawn_manager::backend::doodad_delete(server, world, &doodad); + } + } + slave + .data() + .attached_slaves + .retain(|id| !children.contains(id)); + for id in &children { + if let Some(child) = world.slave(*id) { + unbind_riders_of(server, &child, attach_reason::SLAVE_BINDING); + world.delete(WorldObject::from(&child)); + } + } +} + +/// `SlaveManager.SpawnEquipmentDoodad`: the doodad a ship part becomes (sails, masts, lamps, ...). +fn spawn_equipment_doodad( + server: &GameServer, + world: &Arc, + slave: &SlaveRef, + point: u8, + doodad_id: u32, + item: &Item, +) { + let Some(doodad) = + crate::systems::npcs::doodad::manager::create(server, world, 0, doodad_id, None, true) + else { + tracing::warn!( + "Slave {}: doodad template {doodad_id} missing for equipment visual", + slave.data().unit.template_id + ); + return; + }; + let slave_obj = WorldObject::from(slave); + let (owner_obj_id, owner_id, slave_db_id, faction, spawn_time) = { + let d = slave.data(); + ( + d.summoner_obj_id, + d.summoner_id, + d.id, + d.unit.faction_id, + d.spawn_time_ms, + ) + }; + { + let mut d = doodad.data(); + d.owner_obj_id = owner_obj_id; + d.parent_obj_id = slave.obj_id; + d.attach_point = point; + d.owner_id = owner_id; + d.plant_time = spawn_time / 1000; + d.owner_type = doodad_owner_type::SLAVE; + d.owner_db_id = slave_db_id; + d.data = i32::from(point); + d.faction_id = faction; + d.type2 = 1; + d.scale = 1.0; + d.transform.instance_id = world.id; + d.transform.set_position(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); + if item.flags & crate::models::item::ITEM_FLAG_HAS_UCC != 0 && item.ucc_id > 0 { + d.ucc_id = item.ucc_id; + } + } + let start = crate::systems::npcs::doodad::phase::get_func_group_id( + &server.game_data.systems.npcs.doodad, + doodad_id, + ); + crate::systems::npcs::doodad::manager::set_func_group_id(server, &doodad, start); + let dobj = WorldObject::from(&doodad); + world.attach_child(&slave_obj, &dobj); + apply_attach_point_location(server, world, slave, &dobj, point); + slave.data().attached_doodads.push(doodad.obj_id); + crate::systems::npcs::doodad::manager::init_doodad(server, world, &doodad); + crate::systems::npcs::doodad::manager::spawn(server, world, &doodad); +} + +/// `SlaveManager.SpawnEquipmentChildSlave`: the child slave a part becomes (cannons, harpoons). +fn spawn_equipment_child_slave( + server: &GameServer, + world: &Arc, + slave: &SlaveRef, + point: u8, + child_template_id: u32, +) { + let data = &server.game_data.systems.vehicles; + let Some(child_template) = data.slave_template(child_template_id).cloned() else { + tracing::warn!( + "Slave {}: child template {child_template_id} missing for equipment visual", + slave.data().unit.template_id + ); + return; + }; + let Some(child_tl) = server.ids.tl.get_next_id().ok() else { + return; + }; + let Some(child_obj_id) = server.ids.object.get_next_id().ok() else { + return; + }; + let (summoner_id, summoner_obj_id, summoner_name, faction, slave_db_id) = { + let d = slave.data(); + ( + d.summoner_id, + d.summoner_obj_id, + d.summoner_name.clone(), + d.unit.faction_id, + d.id, + ) + }; + let mut c = Slave::new(0, child_template.id); + c.unit.tl_id = child_tl as u16; + c.unit.name = child_template.name.clone(); + c.unit.level = child_template.level as u8; + c.unit.model_id = child_template.model_id; + c.unit.faction_id = faction; + c.summoner_id = summoner_id; + c.summoner_obj_id = summoner_obj_id; + c.summoner_name = summoner_name; + c.spawn_time_ms = now_ms(); + c.attach_point_id = point as i8; + c.owner_obj_id = slave.obj_id; + c.owner_type = BaseUnitType::Slave; + c.unit.owner_id = slave_db_id; + let child = Entity::new(child_obj_id, c); + let child_obj = WorldObject::from(&child); + apply_slave_bonuses(server, &child_obj, &child_template); + stats::refresh_object_pools(server, &child_obj); + let w = world.world_pos_rot(&WorldObject::from(slave)); + { + let mut d = child.data(); + d.unit.hp = d.unit.max_hp; + d.unit.mp = d.unit.max_mp; + d.unit.transform.instance_id = world.id; + d.unit + .transform + .set_position(w.x, w.y, w.z, w.rot_x, w.rot_y, w.rot_z); + } + let slave_obj = WorldObject::from(slave); + world.attach_child(&slave_obj, &child_obj); + apply_attach_point_location(server, world, slave, &child_obj, point); + slave.data().attached_slaves.push(child_obj_id); + let changes = world.spawn(&child, &server.view_ctx()); + crate::world::session::handle_zone_changes(server, changes); + let hp = child.data().unit.hp; + crate::systems::skills::combat::post_update_current_hp( + server, + &child_obj, + Some(&child_obj), + 0, + hp, + KillReason::Unknown, + ); +} + +/// `SlaveManager.SpawnOrReplaceEquipmentVisual`: at every attach point the equipment slot +/// occupies, remove the previous visual and spawn the one the item maps to (`None` unequips). +pub fn spawn_or_replace_equipment_visual( + server: &GameServer, + world: &Arc, + slave: &SlaveRef, + item: Option<&Item>, + equip_slot_id: u8, +) { + let data = &server.game_data.systems.vehicles; + let Some(template) = data.slave_template(slave.data().unit.template_id).cloned() else { + return; + }; + let points = data.slave_equip_attach_points(template.id, equip_slot_id); + if points.is_empty() { + tracing::debug!( + "No slave_equip_slots entry for slave={} slot={equip_slot_id}", + template.id + ); + return; + } + for point in points { + if is_binding_attach_point(server, &template, point) { + tracing::debug!( + "Skip equip visual at {point} on slave tpl={}: attach point is a static binding", + template.id + ); + continue; + } + remove_equipment_visual_at(server, world, slave, point); + let Some(item) = item else { + continue; + }; + let Some(visual) = data.item_slave_equipment(item.template_id) else { + tracing::warn!( + "No item_slave_equipments visual for item={} on slave tpl={} slot={equip_slot_id}", + item.template_id, + template.id + ); + continue; + }; + if visual.slave_id > 0 { + spawn_equipment_child_slave(server, world, slave, point, visual.slave_id); + } else if visual.doodad_id > 0 { + spawn_equipment_doodad(server, world, slave, point, visual.doodad_id, item); + } + } +} + +/// `SlaveManager.SpawnEquipmentVisualsFromInventory`: spawn the visual of every equipped part. +pub fn spawn_equipment_visuals_from_inventory( + server: &GameServer, + world: &Arc, + slave: &SlaveRef, +) { + let items: Vec<(u8, Item)> = { + let d = slave.data(); + d.equipment + .iter() + .enumerate() + .filter_map(|(slot, item)| { + item.as_ref() + .map(|i| (u8::try_from(slot).unwrap_or(u8::MAX), i.clone())) + }) + .collect() + }; + for (slot, item) in items { + spawn_or_replace_equipment_visual(server, world, slave, Some(&item), slot); + } +} + +/// `CSChangeSlaveEquipmentPacket` (10.x `CSChangeSlaveEquipmentPacket.Read`, adapted to the 1.2 +/// one-pair body and opcode): equip, unequip or re-slot a ship / vehicle part. The persistent +/// `EquipmentSlave` container is keyed by `(character id, slave DB id)` so the item rows survive +/// a despawn and a server restart. +pub fn change_slave_equipment( + server: &GameServer, + character: &PlayerRef, + p: &super::packets::CSChangeSlaveEquipmentPacket, +) { + tracing::debug!( + "ChangeSlaveEquipment, Char: {}, Tl: {}, DbSlaveId: {}, Bts: {}", + p.character_id, + p.slave_tl, + p.db_slave_id, + p.bts + ); + if p.character_id != character.character_id { + return; + } + let Some(world) = player_world(server, character) else { + return; + }; + let slave = (if p.slave_tl != 0 { + get_slave_by_tl_id(&world, u32::from(p.slave_tl)) + } else { + None + }) + .or_else(|| { + if p.db_slave_id != 0 { + get_slave_by_db_id(&world, p.db_slave_id) + } else { + None + } + }) + .or_else(|| get_active_slave_by_owner_obj_id(&world, character.obj_id)); + let Some(slave) = slave else { + tracing::warn!( + "ChangeSlaveEquipment: {} has no slave tl={} db={}", + character.data().unit.name, + p.slave_tl, + p.db_slave_id + ); + reply_slave_equipment(character, p, None, None, false); + return; + }; + let (slave_db_id, owned) = { + let d = slave.data(); + (d.id, d.summoner_id == character.character_id) + }; + if p.db_slave_id != 0 && slave_db_id != 0 && slave_db_id != p.db_slave_id { + tracing::warn!( + "ChangeSlaveEquipment: slave {} does not match requested db id {}", + slave.obj_id, + p.db_slave_id + ); + reply_slave_equipment(character, p, None, None, false); + return; + } + if !owned { + tracing::warn!( + "ChangeSlaveEquipment: {} does not own slave tl={} db={}", + character.data().unit.name, + p.slave_tl, + p.db_slave_id + ); + reply_slave_equipment(character, p, None, None, false); + return; + } + if slave_db_id == 0 { + reply_slave_equipment(character, p, None, None, false); + return; + } + if p.slot2_type != slot_type::EQUIPMENT_SLAVE + || !matches!( + p.slot1_type, + slot_type::INVENTORY | slot_type::EQUIPMENT_SLAVE + ) + { + tracing::warn!( + "ChangeSlaveEquipment: unsupported slots {}#{} <-> {}#{}", + p.slot1_type, + p.slot1, + p.slot2_type, + p.slot2 + ); + reply_slave_equipment(character, p, None, None, false); + return; + } + let equipment = server + .items + .find_container_for_character( + character.character_id, + slot_type::EQUIPMENT_SLAVE, + slave_db_id, + ) + .unwrap_or_else(|| { + server.items.container_for_character( + character.character_id, + slot_type::EQUIPMENT_SLAVE, + slave_db_id, + &server.ids.container, + ) + }); + let bag = Inv::of(character).bag(); + let size_ok = |c: &ContainerRef, slot: u8| { + let size = c.lock().expect("container poisoned").container_size(); + size <= 0 || i32::from(slot) < size + }; + if !size_ok(&equipment, p.slot2) + || (p.slot1_type == slot_type::EQUIPMENT_SLAVE && !size_ok(&equipment, p.slot1)) + || (p.slot1_type == slot_type::INVENTORY && !size_ok(&bag, p.slot1)) + { + tracing::warn!( + "ChangeSlaveEquipment: slot out of range {}#{} <-> {}#{}", + p.slot1_type, + p.slot1, + p.slot2_type, + p.slot2 + ); + reply_slave_equipment(character, p, None, None, false); + return; + } + let item1 = if p.slot1_type == slot_type::INVENTORY { + bag.lock() + .expect("container poisoned") + .get_item_by_slot(i32::from(p.slot1)) + .cloned() + } else { + equipment + .lock() + .expect("container poisoned") + .get_item_by_slot(i32::from(p.slot1)) + .cloned() + }; + let item2 = equipment + .lock() + .expect("container poisoned") + .get_item_by_slot(i32::from(p.slot2)) + .cloned(); + if !equipment_slot_matches(&p.item1, item1.as_ref()) + || !equipment_slot_matches(&p.item2, item2.as_ref()) + { + tracing::warn!( + "ChangeSlaveEquipment: slot contents mismatch, client {}/{} server {}/{} for {}#{} <-> {}#{}", + p.item1.template_id, + p.item2.template_id, + item1.as_ref().map_or(0, |i| i.template_id), + item2.as_ref().map_or(0, |i| i.template_id), + p.slot1_type, + p.slot1, + p.slot2_type, + p.slot2 + ); + reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), false); + return; + } + // Ship / vehicle parts only, and only where the hull / slot packs allow them. The 1.2 data + // carries the validation that the 10.x server left to the client: + // `item_slave_equipments.slave_equip_pack_id` -> `allow_to_equip_slaves` and + // `slot_pack_id` -> `allow_to_equip_slots`. + let slave_template_id = slave.data().unit.template_id; + let data = &server.game_data.systems.vehicles; + let allowed = |item: &Item, target_slot: u8| { + data.can_equip_item_on_slave(item.template_id, slave_template_id, target_slot) + }; + for (item, target_slot) in [ + (item1.as_ref(), p.slot2), + ( + (p.slot1_type == slot_type::EQUIPMENT_SLAVE) + .then_some(item2.as_ref()) + .flatten(), + p.slot1, + ), + ] { + let Some(item) = item else { continue }; + if !allowed(item, target_slot) { + tracing::warn!( + "ChangeSlaveEquipment: item {} (template {}) cannot be equipped on slave tpl={} slot {}", + item.id, + item.template_id, + slave_template_id, + target_slot + ); + error(character, super::error::ITEM_NOT_FOR_PET); + reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), false); + return; + } + } + // Source / target: the 1.2 client always puts the slave slot second. If its first slot is + // empty the second item moves to it (unequip); both filled swaps them. + let move_args = match (&item1, &item2) { + (Some(i1), _) => Some(( + if p.slot1_type == slot_type::INVENTORY { + bag.clone() + } else { + equipment.clone() + }, + equipment.clone(), + p.slot1_type, + p.slot1, + i1.id, + slot_type::EQUIPMENT_SLAVE, + p.slot2, + item2.as_ref().map_or(0, |i| i.id), + )), + (None, Some(i2)) => Some(( + equipment.clone(), + if p.slot1_type == slot_type::INVENTORY { + bag.clone() + } else { + equipment.clone() + }, + slot_type::EQUIPMENT_SLAVE, + p.slot2, + i2.id, + p.slot1_type, + p.slot1, + 0, + )), + (None, None) => None, + }; + let Some((src, dst, from_type, from_slot, from_id, to_type, to_slot, to_id)) = move_args else { + reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), false); + return; + }; + let inv = Inv::of(character); + let mut txn = ItemTxn::begin(server); + let moved = inventory::split_or_move_item_ex( + &mut txn, + &inv, + task_type::INVALID, + Some(src), + Some(dst), + from_id, + from_type, + from_slot, + to_id, + to_type, + to_slot, + 0, + ); + crate::systems::economy::fx::flush(server, txn.into_fx()); + if !moved { + reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), false); + return; + } + mirror_slave_equipment(&slave, &equipment); + let mut touched = Vec::new(); + for (slot, st) in [(p.slot1, p.slot1_type), (p.slot2, p.slot2_type)] { + if st == slot_type::EQUIPMENT_SLAVE && !touched.contains(&slot) { + touched.push(slot); + } + } + for slot in touched { + let item = equipment + .lock() + .expect("container poisoned") + .get_item_by_slot(i32::from(slot)) + .cloned(); + spawn_or_replace_equipment_visual(server, &world, &slave, item.as_ref(), slot); + } + let slave_obj = WorldObject::from(&slave); + crate::systems::skills::stats::update_vehicle_gear_bonuses( + server, + &slave_obj, + item1.as_ref(), + item2.as_ref(), + ); + stats::refresh_object_pools(server, &slave_obj); + let (hp, mp) = { + let mut d = slave.data(); + d.unit.hp = d.unit.hp.min(d.unit.max_hp); + d.unit.mp = d.unit.mp.min(d.unit.max_mp); + (d.unit.hp, d.unit.mp) + }; + let mut changed = Vec::new(); + for (slot, st) in [(p.slot1, p.slot1_type), (p.slot2, p.slot2_type)] { + if st != slot_type::EQUIPMENT_SLAVE || changed.iter().any(|(s, _)| *s == slot) { + continue; + } + let item = equipment + .lock() + .expect("container poisoned") + .get_item_by_slot(i32::from(slot)) + .cloned(); + changed.push((slot, item)); + } + if !changed.is_empty() { + broadcast( + server, + &slave_obj, + &SCUnitEquipmentsChangedPacket { + obj_id: slave.obj_id, + items: changed, + }, + false, + ); + } + broadcast( + server, + &slave_obj, + &SCUnitPointsPacket { + obj_id: slave.obj_id, + hp, + mp, + }, + true, + ); + reply_slave_equipment(character, p, item1.as_ref(), item2.as_ref(), true); +} + // --------------------------------------------------------------------------------------------- // Bind / unbind // --------------------------------------------------------------------------------------------- @@ -473,12 +1195,122 @@ pub fn bind_slave( super::ship_physics::set_driver(server, &slave, true); } world.attach_child(&WorldObject::from(&slave), &me); - // TODO (C#): move to attach point's position + // TODO (C#): move to attach point's position (done for ship cannons only: their gunner + // stands behind the barrel; every other seat keeps the C# origin placement). + let (sx, sy, sz) = if is_manned_cannon(server, &slave) { + gunner_seat_offset(server, &slave, point) + } else { + (0.0, 0.0, 0.0) + }; character .data() .unit .transform - .set_position(0.0, 0.0, 0.0, 0.0, 0.0, 0.0); + .set_position(sx, sy, sz, 0.0, 0.0, 0.0); +} + +/// Gunner seat of a cannon in the cannon's local frame when its model has no seat helper. Cannon +/// model 117 (every 1.2 cannon slave) is absent from `slave_attach_points*.json`, which only +/// covers ship / vehicle models, and no cannon-shaped model there declares a driver helper, so +/// the gunner stands 0.8 m behind the barrel pivot at its base height. +pub const GUNNER_SEAT_OFFSET: (f32, f32, f32) = (0.0, -0.8, 0.0); + +/// The gunner's seat position on a cannon: the model's own `point` helper when the attach point +/// data has one, else [`GUNNER_SEAT_OFFSET`]. +fn gunner_seat_offset(server: &GameServer, cannon: &SlaveRef, point: u8) -> (f32, f32, f32) { + let model_id = cannon.data().unit.model_id; + server + .systems + .vehicles + .attach_points_for_slave(server, model_id) + .and_then(|points| points.into_iter().find(|(p, _)| *p == point)) + .map_or(GUNNER_SEAT_OFFSET, |(_, v)| (v.x, v.y, v.z)) +} + +/// A cannon (slave kind 8) mounted on another slave: one gunner at the driver seat, the +/// `mount_attached_skills` seat of its fire skill. A cannon without a bearer keeps the plain +/// C# bind rules. +pub fn is_manned_cannon(server: &GameServer, slave: &SlaveRef) -> bool { + let (template_id, bearer) = { + let d = slave.data(); + (d.unit.template_id, d.owner_obj_id) + }; + bearer != 0 + && server + .game_data + .systems + .vehicles + .slave_template(template_id) + .is_some_and(|t| t.slave_kind == super::data::slave_kind::SLAVE_EQUIPMENT) +} + +/// Who may man a ship cannon: the cannon's summoner, the owner of the ship it is mounted on, or +/// anybody aboard that ship (standing on it or seated on any of its attach points). The C# +/// `BindSlave` has no such rule and the 1.2 data carries no seat permissions; this keeps the +/// guns to the crew. +pub fn may_man_cannon(character: &PlayerRef, cannon: &SlaveRef, world: &WorldInstance) -> bool { + let (bearer_id, summoner, summoner_id) = { + let d = cannon.data(); + (d.owner_obj_id, d.summoner_obj_id, d.summoner_id) + }; + let is_me = |obj: u32, id: u32| { + obj == character.obj_id || (character.character_id != 0 && id == character.character_id) + }; + if is_me(summoner, summoner_id) { + return true; + } + let Some(bearer) = world.slave(bearer_id) else { + return true; // Orphaned: nobody to ask. + }; + let (owner, attached) = { + let d = bearer.data(); + ( + is_me(d.summoner_obj_id, d.summoner_id), + d.attached_characters + .iter() + .any(|(_, c)| *c == character.obj_id), + ) + }; + owner || attached || character.data().unit.transform.parent_obj_id == bearer_id +} + +/// A gunner who dies leaves the cannon (a driver or passenger of a ship keeps the C# behaviour). +pub fn on_gunner_death(server: &GameServer, player: &PlayerRef) { + let Some(world) = player_world(server, player) else { + return; + }; + if let Some((cannon, _)) = get_is_mounted(&world, player.obj_id) { + if is_manned_cannon(server, &cannon) { + let tl = u32::from(cannon.data().unit.tl_id); + unbind_slave(server, player, tl, attach_reason::NONE); + } + } +} + +/// Unbinds everybody riding the cannons / harpoons mounted on `slave` (their carrier goes away). +fn unbind_child_riders(server: &GameServer, slave: &SlaveRef, reason: u8) { + let Some(world) = world_of(server, &WorldObject::from(slave)) else { + return; + }; + let children = slave.data().attached_slaves.clone(); + for id in children { + let Some(child) = world.slave(id) else { + continue; + }; + unbind_riders_of(server, &child, reason); + } +} + +fn unbind_riders_of(server: &GameServer, slave: &SlaveRef, reason: u8) { + let (tl, riders) = { + let d = slave.data(); + (u32::from(d.unit.tl_id), d.attached_characters.clone()) + }; + for (_, c) in riders { + if let Some(p) = server.world.character_by_obj_id(c) { + unbind_slave(server, &p, tl, reason); + } + } } /// `BindSlave(connection, tlId)` (`CSBindSlavePacket`). @@ -492,6 +1324,20 @@ pub fn bind_slave_by_tl(server: &GameServer, character: &PlayerRef, tl_id: u32) if slave.data().unit.is_dead() { return; } + if is_manned_cannon(server, &slave) { + if !may_man_cannon(character, &slave, &world) { + error(character, error::SLAVE_CANNOT_BIND); + return; + } + if slave.data().has_attached_at(attach_point::DRIVER) { + error(character, error::SLAVE_ALREADY_HAS_MASTER); + return; + } + if get_is_mounted(&world, character.obj_id).is_some() { + error(character, error::SLAVE_UNBIND_FIRST); + return; + } + } bind_slave( server, character, @@ -539,6 +1385,7 @@ pub fn delete( unbind_slave(server, &p, tl, attach_reason::SLAVE_BINDING); } } + unbind_child_riders(server, &slave, attach_reason::SLAVE_BINDING); let (doodad_ids, slave_ids, portal_time, template_id) = { let d = slave.data(); let portal = server @@ -795,8 +1642,15 @@ pub struct SavedChildSlave { } /// `SlaveManager.Create(owner, skillData)` (the `SpawnSlave` special effect): runs the async -/// creation on a task. -pub fn create_from_skill(server: &GameServer, owner: &PlayerRef, caster: &SkillCaster) { +/// creation on a task. `placement` is the `SummonPos` spot the client chose; it is validated +/// against the slave's `spawn_valid_area_range` / the skill range before use. +pub fn create_from_skill( + server: &GameServer, + owner: &PlayerRef, + caster: &SkillCaster, + placement: Option, + max_range: f32, +) { let SkillCaster::Item { item_id, item_template_id, @@ -810,7 +1664,17 @@ pub fn create_from_skill(server: &GameServer, owner: &PlayerRef, caster: &SkillC }; let owner = owner.clone(); let fut = async move { - create_for_owner(&server, &owner, item_id, item_template_id, false, None).await; + create_for_owner( + &server, + &owner, + item_id, + item_template_id, + false, + None, + placement, + max_range, + ) + .await; }; match tokio::runtime::Handle::try_current() { Ok(rt) => { @@ -820,7 +1684,90 @@ pub fn create_from_skill(server: &GameServer, owner: &PlayerRef, caster: &SkillC } } +/// The client-chosen `SummonPos` turned into a spawn transform, or `None` (with +/// `SlaveSpawnErrorInvalidArea`) when the spot is too far, on the wrong surface or inside +/// collision. `None` also means "no placement": the C# in-front placement is used. +fn validated_summon_placement( + server: &GameServer, + world: &WorldInstance, + owner: &PlayerRef, + template: &SlaveTemplate, + placement: Option, + max_range: f32, +) -> Option { + let p = placement?; + let invalid = |reason: &str| { + tracing::warn!( + "SlaveSpawn placement for template {} refused: {reason} at ({:.1},{:.1},{:.1})", + template.id, + p.x, + p.y, + p.z + ); + error(owner, error::SLAVE_SPAWN_ERROR_INVALID_AREA); + None + }; + let owner_pos = world.world_pos_rot(&WorldObject::from(owner)); + // `slaves.spawn_valid_area_range` is the data-side limit (50 m in the 1.2 DB); the skill's + // own MaxRange is 0 for the boat summon (15802). Use the smaller nonzero limit. + let limit = [max_range, template.spawn_valid_area_range as f32] + .into_iter() + .filter(|v| *v > 0.0) + .fold(f32::INFINITY, f32::min); + let limit = if limit.is_finite() { limit } else { 50.0 }; + let dx = p.x - owner_pos.x; + let dy = p.y - owner_pos.y; + if dx * dx + dy * dy > limit * limit { + return invalid("too far from the owner"); + } + let mut transform = Transform { + instance_id: world.id, + zone_id: owner.data().unit.transform.zone_id, + ..Default::default() + }; + transform.set_position(p.x, p.y, p.z, 0.0, 0.0, p.yaw); + if template.is_a_boat() { + if !super::ship_physics::is_water(server, world, [p.x, p.y, p.z]) { + return invalid("a ship must be summoned on water"); + } + transform.set_height(super::ship_physics::water_surface( + server, + world, + [p.x, p.y, p.z], + )); + } else { + if super::ship_physics::is_water(server, world, [p.x, p.y, p.z]) { + return invalid("a land vehicle must be summoned on ground"); + } + let ground = crate::systems::ai::collision::ground_height_or( + server, + world.id, + p.x, + p.y, + p.z, + || p.z, + ); + transform.set_height(ground); + } + // A half-metre sphere just above the surface: the hull/aabb is not needed, this only + // rejects a spot inside a rock, cliff or doodad collider. + let inside = crate::systems::ai::collision::overlaps_sphere( + server, + world.id, + [transform.x, transform.y, transform.z + 0.8], + 0.5, + crate::systems::ai::collision::query::mask::SOLID_TERRAIN + & !crate::systems::ai::collision::query::mask::TERRAIN, + ) + .unwrap_or(false); + if inside { + return invalid("inside collision"); + } + Some(transform) +} + /// `Create(owner, skillData, hideSpawnEffect, positionOverride)`. +#[allow(clippy::too_many_arguments)] pub async fn create_for_owner( server: &GameServer, owner: &PlayerRef, @@ -828,6 +1775,8 @@ pub async fn create_for_owner( item_template_id: u32, hide_spawn_effect: bool, position_override: Option, + placement: Option, + max_range: f32, ) -> Option { let world = player_world(server, owner)?; if let Some(active) = get_active_slave_by_owner_obj_id(&world, owner.obj_id) { @@ -849,6 +1798,17 @@ pub async fn create_for_owner( Some(crate::data::items::TemplateKind::SummonSlave { slave_id }) => *slave_id, _ => return None, }; + let template = server + .game_data + .systems + .vehicles + .slave_template(slave_id)? + .clone(); + let position_override = if placement.is_some() { + validated_summon_placement(server, &world, owner, &template, placement, max_range) + } else { + position_override + }; create( server, &world, @@ -1389,14 +2349,111 @@ pub(crate) fn create_spawn( d.unit.mp = d.unit.max_mp; } } - // Equip it's default items. TODO (C#): Implement vehicle customization - if let Some(pack) = data.slave_initial_item_pack(template.slave_initial_item_pack_id) { + // Equip its default items. 10.x: player-owned slave parts live in a persistent + // `EquipmentSlave` container keyed by the slave DB id (`item_containers.mate_id`), seeded + // once per hull; the model mirror drives stats and visibility packets. + if owner_id > 0 && db_id > 0 { + let existing = server.items.find_container_for_character( + owner_id, + crate::models::container::slot_type::EQUIPMENT_SLAVE, + db_id, + ); + // A saved 1.2 hull may predate EquipmentSlave containers. Container creation, not + // hull/item age, marks its one-time initialization; an existing empty one stays empty. + let is_new_equipment = existing.is_none(); + let container = existing.unwrap_or_else(|| { + server.items.container_for_character( + owner_id, + crate::models::container::slot_type::EQUIPMENT_SLAVE, + db_id, + &server.ids.container, + ) + }); + if is_new_equipment { + let pack = initial_slave_equipment(server, &template); + let now = chrono::Utc::now().timestamp(); + for initial in pack { + if !data.has_slave_equip_slot(template.id, initial.equip_slot_id) { + continue; + } + let Some(mut it) = server.items.create( + initial.item_id, + 1, + 0, + server.config.id, + &server.game_data.items, + &server.ids.item, + now, + ) else { + continue; + }; + it.slot_type = crate::models::container::slot_type::EQUIPMENT_SLAVE; + it.slot = i32::from(initial.equip_slot_id); + it.owner_id = u64::from(owner_id); + it.dirty = true; + if container + .lock() + .expect("container poisoned") + .add_new_item( + it.clone(), + i32::from(initial.equip_slot_id), + &server.game_data.items, + ) + .is_err() + { + continue; + } + let entered = { + let mut d = slave.data(); + match d.equipment.get_mut(usize::from(initial.equip_slot_id)) { + Some(slot) => { + *slot = Some(it.clone()); + true + } + None => false, + } + }; + // EquipmentContainer.OnEnterContainer: the SCUnitEquipmentsChanged broadcast + // reaches nobody (not spawned yet), then ParentUnit.UpdateGearBonuses(...). + if entered { + crate::systems::skills::stats::update_vehicle_gear_bonuses( + server, + &slave_obj, + Some(&it), + None, + ); + } + } + } else { + let items = container.lock().expect("container poisoned").items.clone(); + let mut d = slave.data(); + for it in items { + let slot = it.slot.max(0) as usize; + if let Some(entry) = d.equipment.get_mut(slot) { + *entry = Some(it); + } + } + } + } else { + let pack = initial_slave_equipment(server, &template); + // NPC / spawner slaves have no DB row: keep the 1.2 C# in-memory starter pack. let now = chrono::Utc::now().timestamp(); for initial in pack { - let Some(t) = server.game_data.items.template(initial.item_id) else { + if !data.has_slave_equip_slot(template.id, initial.equip_slot_id) { + continue; + } + let Some(it) = server.items.create_detached( + initial.item_id, + 1, + 0, + server.config.id, + &server.game_data.items, + now, + ) else { continue; }; - let mut it = Item::create(0, t, 1, 0, server.config.id, &server.game_data.items, now); + let mut it = it; + it.slot_type = crate::models::container::slot_type::EQUIPMENT_SLAVE; it.slot = i32::from(initial.equip_slot_id); let entered = { let mut d = slave.data(); @@ -1408,8 +2465,6 @@ pub(crate) fn create_spawn( None => false, } }; - // EquipmentContainer.OnEnterContainer: the SCUnitEquipmentsChanged broadcast reaches - // nobody (not spawned yet), then ParentUnit.UpdateGearBonuses(item, null). if entered { crate::systems::skills::stats::update_vehicle_gear_bonuses( server, @@ -1505,6 +2560,9 @@ fn finish_create( }; // Create all remaining doodads that where not previously loaded for binding in &template.doodad_bindings { + if !is_binding_attach_point(server, template, binding.attach_point_id) { + continue; + } let loaded_points: Vec = { let ids = slave.data().attached_doodads.clone(); ids.iter() @@ -1573,7 +2631,9 @@ fn finish_create( // Spawn Slave's slaves for binding in &template.slave_bindings { - if binding.owner_type != "Slave" { + if binding.owner_type != "Slave" + || !is_binding_attach_point(server, template, binding.attach_point_id) + { continue; } let mut child_db_id = 0u32; @@ -1628,13 +2688,13 @@ fn finish_create( let child_obj = WorldObject::from(&child); apply_slave_bonuses(server, &child_obj, &child_template); stats::refresh_object_pools(server, &child_obj); + let w = world.world_pos_rot(&slave_obj); { // TODO (C#): persistent HP for child slaves when customization is enabled let mut d = child.data(); d.unit.hp = d.unit.max_hp; d.unit.mp = d.unit.max_mp; // Transform = summonedSlave.Transform.CloneDetached(child); Parent = slave - let w = world.world_pos_rot(&slave_obj); d.unit.transform.instance_id = world.id; d.unit .transform @@ -1656,6 +2716,10 @@ fn finish_create( ); } + // Equipment-driven visuals (cannons, sails, masts, cargo, figureheads) from the parts the + // hull carries. + spawn_equipment_visuals_from_inventory(server, world, slave); + // If it's a boat, add it to boat physics if template.is_a_boat() { if owner.is_none() { @@ -1900,6 +2964,9 @@ pub fn do_die( } None => tracing::error!("Slave.DoDie without a killer (NullReferenceException)"), } + // Keep child transforms and seat lists available until every gunner has detached in world + // coordinates. Deleting a cannon first loses its riders and their detach notifications. + unbind_child_riders(server, slave, attach_reason::NONE); destroy_attached_items(server, slave); distribute_slave_drop_doodads(server, slave); mark_summoning_item_as_destroyed(server, slave); diff --git a/rust/crates/aaemu-game/src/world_flow_tests.rs b/rust/crates/aaemu-game/src/world_flow_tests.rs index 4bf322c3ad..fc20f19784 100644 --- a/rust/crates/aaemu-game/src/world_flow_tests.rs +++ b/rust/crates/aaemu-game/src/world_flow_tests.rs @@ -434,11 +434,9 @@ async fn two_players_see_each_other_move_talk_and_leave() { assert!(a.drain().is_empty()); } -/// Character creation with synthetic templates. MySQL is down, so `SaveDirectlyToDatabase` -/// fails and the C# answers `SCCharacterCreationFailedPacket(Failed)` after building the whole -/// character (its starting items stay in the item manager, as in C#). +/// A failed creation must release all assets before its name and IDs can be reused. #[tokio::test] -async fn create_character_builds_the_starting_kit_then_fails_to_save() { +async fn create_character_save_failure_releases_assets_and_allows_retry() { use crate::data::character_templates::{AbilityItems, AbilitySupplyItem, CharacterTemplate}; use crate::data::items::{EquipTemplate, GradeTemplate, ItemTemplate, TemplateKind}; use crate::data::skills::{DefaultSkill, SkillTemplate}; @@ -540,52 +538,81 @@ async fn create_character_builds_the_starting_kit_then_fails_to_save() { ability3: 11, level: 1, }; - crate::managers::character::create(&s, &mut a.conn, req.clone()) - .await - .unwrap(); + let body = |req: &CreateCharacterRequest| { + let mut body = PacketStream::new(); + body.write_str(&req.name) + .write_u8(req.race) + .write_u8(req.gender); + for item in req.body_items { + body.write_u32(item); + } + req.model_params.write(&mut body); + body.write_u8(req.ability1) + .write_u8(req.ability2) + .write_u8(req.ability3) + .write_u8(req.level); + body.into_bytes() + }; + let assert_released = || { + assert!(s.names.no_names_registered()); + assert!(!s.names.name_exists("Newbie")); + assert_eq!(s.names.get_character_id("Newbie"), 0); + assert_eq!(s.names.get_character_name(1), None); + assert_eq!(s.names.get_character_account(1), 0); + // Never look up a missing container with find-or-create: that would register a new + // empty container and hide a leak. Inspect the global cache and save snapshot instead. + assert!(s.items.all_containers().is_empty()); + let pending = s.items.prepare_save(); + assert_eq!(pending.container_count(), 0); + assert!(pending.item_ids().is_empty()); + assert!(pending.removed_ids().is_empty()); + let first_item = crate::managers::id::ITEM_ID.first_id; + for id in first_item..first_item + 5 { + assert!(s.items.item_by_id(u64::from(id)).is_none()); + } + for (ids, expected) in [ + (&s.ids.character, crate::managers::id::CHARACTER_ID.first_id), + (&s.ids.item, first_item), + (&s.ids.container, crate::managers::id::CONTAINER_ID.first_id), + ] { + let id = ids.get_next_id().unwrap(); + assert_eq!(id, expected); + ids.release_id(id); + } + }; + a.frame(&s, cs::CSCreateCharacterPacket, &body(&req)).await; assert_eq!( a.drain(), vec![(sc::SCCharacterCreationFailedPacket, vec![3])] ); - // The id and the name were released again. - assert!(s.names.no_names_registered()); + assert_released(); assert!(a.conn.characters.is_empty()); - // Starting kit: chest armor (with its MaxDurability) + face body part, supplies in stacks. - let eq = s - .items - .container_for_character(1, slot_type::EQUIPMENT, 0, &s.ids.container); - { - let eq = eq.lock().unwrap(); - let chest = eq.get_item_by_slot(2).unwrap(); - assert_eq!(chest.template_id, 6001); - assert_eq!(chest.details.durability, 10); - assert_eq!(eq.get_item_by_slot(19).unwrap().template_id, 7001); - } - let bag = s - .items - .container_for_character(1, slot_type::INVENTORY, 0, &s.ids.container); - let mut counts: Vec<(i32, i32)> = bag - .lock() - .unwrap() - .items - .iter() - .map(|i| (i.slot, i.count)) - .collect(); - counts.sort(); - assert_eq!(counts, vec![(0, 10), (1, 10), (2, 5)]); + assert_eq!(a.conn.account_id(), 1001); // the lobby session stays available for retry + assert!(a.conn.active_char.is_none()); + assert!(!a.conn.is_closing()); // Invalid names are refused before anything is created. let bad = CreateCharacterRequest { name: "bad name".into(), - ..req + ..req.clone() }; - crate::managers::character::create(&s, &mut a.conn, bad) - .await - .unwrap(); + a.frame(&s, cs::CSCreateCharacterPacket, &body(&bad)).await; assert_eq!( a.drain(), vec![(sc::SCCharacterCreationFailedPacket, vec![5])] ); + assert_released(); + + // The same normalized name and character ID can be tried again, with no inherited kit. + a.frame(&s, cs::CSCreateCharacterPacket, &body(&req)).await; + assert_eq!( + a.drain(), + vec![(sc::SCCharacterCreationFailedPacket, vec![3])] + ); + assert_released(); + assert!(a.conn.characters.is_empty()); + assert_eq!(a.conn.account_id(), 1001); + assert!(!a.conn.is_closing()); } #[tokio::test] diff --git a/rust/crates/aaemu-physics/src/entities/base.rs b/rust/crates/aaemu-physics/src/entities/base.rs index 0405fb8343..263da9698c 100644 --- a/rust/crates/aaemu-physics/src/entities/base.rs +++ b/rust/crates/aaemu-physics/src/entities/base.rs @@ -161,6 +161,10 @@ pub struct Entity { pub scale: f32, /// `+208` / `+216` colliders (entities this one is in contact with). pub colliders: Vec, + /// Port lifetime bookkeeping, not a simulated field: users of this static collider. + /// Simclass-0 AddCollider keeps no reverse `colliders` entries, so destruction needs + /// these incoming links to detach sleeping users before deferred reclamation. + pub(crate) static_collider_users: Vec, /// `+232` group leader (living). pub unk232: EntIdx, /// `+248`. @@ -228,6 +232,7 @@ impl Entity { q2: Quat::IDENTITY, scale: 1.0, colliders: Vec::new(), + static_collider_users: Vec::new(), unk232: EntIdx::NONE, unk248: 0, time_idle: 0.0, diff --git a/rust/crates/aaemu-physics/src/entities/living/solver.rs b/rust/crates/aaemu-physics/src/entities/living/solver.rs index 1540bde444..953fd6d4f6 100644 --- a/rust/crates/aaemu-physics/src/entities/living/solver.rs +++ b/rust/crates/aaemu-physics/src/entities/living/solver.rs @@ -237,15 +237,12 @@ pub fn body_for_contact(w: &mut World, e: EntIdx, will_modify: bool) -> BodyId { /// proxy's `w` and `L` are cleared. Returns 1. pub fn update(w: &mut World, e: EntIdx, dt: f32, damping: f32) -> u32 { let cols = w.ent(e).colliders.clone(); - let mut kept = Vec::new(); for c in cols { - if crate::entities::has_constraint_contacts_with(w, c, e, 0) { - kept.push(c); - } else { + if !crate::entities::has_constraint_contacts_with(w, c, e, 0) { crate::entities::remove_collider(w, c, e, true); + crate::entities::remove_collider(w, e, c, true); } } - w.ent_mut(e).colliders = kept; lm(w, e).n_contacts = 0; let Some(p) = ld(w, e).proxy else { return 1; diff --git a/rust/crates/aaemu-physics/src/entities/mod.rs b/rust/crates/aaemu-physics/src/entities/mod.rs index 174beef630..11ad6a6aa7 100644 --- a/rust/crates/aaemu-physics/src/entities/mod.rs +++ b/rust/crates/aaemu-physics/src/entities/mod.rs @@ -215,6 +215,9 @@ fn base_add_collider(w: &mut World, e: EntIdx, c: EntIdx) -> i32 { i += 1; } w.ent_mut(e).colliders.insert(i, c); + if w.ent(c).sim_class() == 0 { + w.ent_mut(c).static_collider_users.push(e); + } i as i32 } @@ -273,12 +276,22 @@ fn base_remove_collider(w: &mut World, e: EntIdx, c: EntIdx) -> i32 { match ent.colliders.iter().position(|&x| x == c) { Some(i) => { ent.colliders.remove(i); + w.ent_mut(c).static_collider_users.retain(|&user| user != e); i as i32 } None => -1, } } +/// Clear outgoing links and their static lifetime bookkeeping together. Contact/mask +/// cleanup remains in the class removal hooks, just as for `base_remove_collider`. +fn clear_colliders(w: &mut World, e: EntIdx) { + let cols = std::mem::take(&mut w.ent_mut(e).colliders); + for c in cols { + w.ent_mut(c).static_collider_users.retain(|&user| user != e); + } +} + /// Slot 53 `HasConstraintContactsWith(pent, flagsIgnore)`: rigid `0x350A9CE0`; base 0. #[must_use] pub fn has_constraint_contacts_with( @@ -331,12 +344,14 @@ pub fn class_has_contacts_with(w: &World, e: EntIdx, other: EntIdx) -> bool { /// while the external-contact stamp is negative). pub fn detach_hook(w: &mut World, e: EntIdx, mode: i32) { match &w.ent(e).kind { - EntityKind::Living(_) => return living::detach_hook(w, e, mode), - EntityKind::Particle(_) => return particle::detach_hook(w, e, mode), - EntityKind::Rigid(r) if r.wheeled.is_some() => return wheeled::detach_hook(w, e, mode), - _ => {} - } - class_detach_hook(w, e, mode); + EntityKind::Living(_) => living::detach_hook(w, e, mode), + EntityKind::Particle(_) => particle::detach_hook(w, e, mode), + EntityKind::Rigid(r) if r.wheeled.is_some() => wheeled::detach_hook(w, e, mode), + _ => class_detach_hook(w, e, mode), + } + // Particle's class hook deliberately skips the base hook. Unregister any remaining + // outgoing links here too, so no static can retain a user after its destruction. + clear_colliders(w, e); } /// Slot 54 of `CRigidEntity` (0x350A9DD0) / `CPhysicalEntity` (0x350530B0): what the derived @@ -351,14 +366,21 @@ pub fn class_detach_hook(w: &mut World, e: EntIdx, mode: i32) { } if (w.ent(e).id_bits & 0xFF00_0000) as i32 <= 0x300_0000 { w.ent_mut(e).flags |= 0x8000_0000; - let cols = w.ent(e).colliders.clone(); + let mut cols = w.ent(e).colliders.clone(); + // Static entities intentionally have no reverse collider list. Include their + // incoming users so an asleep rigid cannot retain this index beyond cleanup. + for c in std::mem::take(&mut w.ent_mut(e).static_collider_users) { + if !cols.contains(&c) { + cols.push(c); + } + } for c in cols { if c != e { remove_collider(w, c, e, true); awake(w, c, 1, 1); } } - w.ent_mut(e).colliders.clear(); + clear_colliders(w, e); let ent = w.ent(e); if ent.flags & 0x20 == 0 && ((ent.pod_refs > 0 && ((ent.id_bits & 0xFF00_0000) as i32) < 0x300_0000) diff --git a/rust/crates/aaemu-physics/tests/p7_world_api.rs b/rust/crates/aaemu-physics/tests/p7_world_api.rs index 81b04c3530..8186e5a77c 100644 --- a/rust/crates/aaemu-physics/tests/p7_world_api.rs +++ b/rust/crates/aaemu-physics/tests/p7_world_api.rs @@ -5,7 +5,7 @@ use aaemu_physics::math::{Quat, Vec3}; use aaemu_physics::oracle::check_scenario_golden; use aaemu_physics::trace::Trace; use aaemu_physics::world::api::PartDesc; -use aaemu_physics::world::World; +use aaemu_physics::world::{EntIdx, World}; fn boxp(h: f32) -> Primitive { Primitive::Box(BoxPrim { @@ -95,3 +95,163 @@ fn floating_box_through_the_api() { assert_eq!(s.pos.to_bits(), g.pos_f().to_bits(), "step {n}"); } } + +fn static_contact_world() -> (World, EntIdx, EntIdx) { + let mut w = World::with_grid(Vec3::new(0.0, 0.0, -100.0), 64, 4.0); + let ground = w + .geometry(&Primitive::Box(BoxPrim { + size: Vec3::new(10.0, 10.0, 0.5), + ..BoxPrim::default() + })) + .unwrap(); + let cube = w.geometry(&boxp(0.5)).unwrap(); + let floor = w + .add_static( + Vec3::new(32.0, 32.0, -0.5), + Quat::IDENTITY, + &[PartDesc::new(ground, 0.0)], + -1, + ) + .unwrap(); + let body = w + .add_rigid( + Vec3::new(32.0, 32.0, 1.0), + Quat::IDENTITY, + &[PartDesc::new(cube, 10.0)], + -1, + ) + .unwrap(); + let dt = 1.0 / 60.0; + for _ in 0..180 { + w.step(dt); + if aaemu_physics::entities::has_contacts_with(&w, body, floor) { + break; + } + } + assert!( + w.ent(body).colliders.contains(&floor) + && aaemu_physics::entities::has_contacts_with(&w, body, floor), + "the normal contact solver must register the static collider" + ); + (w, floor, body) +} + +fn assert_live_rigid_contacts(w: &World, body: EntIdx) { + let ent = w.ent(body); + let rigid = ent.rigid().unwrap(); + assert_eq!(ent.colliders.len(), rigid.collider_contacts.len()); + assert_eq!(ent.colliders.len(), rigid.collider_masks.len()); + assert!(ent.colliders.iter().all(|c| w.ents[c.0 as usize].is_some())); + let state = w.body_state(body); + assert!(state.pos.x.is_finite() && state.pos.y.is_finite() && state.pos.z.is_finite()); +} + +#[test] +fn sleeping_rigid_survives_static_collider_cleanup_and_wake() { + let (mut w, floor, body) = static_contact_world(); + let dt = 1.0 / 60.0; + aaemu_physics::entities::awake(&mut w, body, 0, 1); + assert_eq!(w.body_state(body).sim_class, 1); + assert!(!w.body_state(body).awake); + + assert_eq!(w.destroy_physical_entity(floor, 0), 1); + for _ in 0..8 { + w.step(dt); // includes PumpLoggedEvents and normal deferred entity cleanup + if w.ents[floor.0 as usize].is_none() { + break; + } + } + assert!(w.ents[floor.0 as usize].is_none(), "static was reclaimed"); + + // A sleeping rigid used to retain the freed static index. Awake's collider walk then + // panicked at World::ent's `expect("live entity")`, just like the live ship failure. + aaemu_physics::entities::awake(&mut w, body, 1, 1); + for _ in 0..8 { + w.step(dt); + assert_live_rigid_contacts(&w, body); + } +} + +#[test] +fn surviving_rigid_recontacts_repeated_static_replacements_after_another_user_is_freed() { + let (mut w, mut floor, first) = static_contact_world(); + let ground = w.ent(floor).parts[0].pgeom.clone(); + let cube = w.ent(first).parts[0].pgeom.clone(); + let survivor = w + .add_rigid( + Vec3::new(36.0, 32.0, 1.0), + Quat::IDENTITY, + &[PartDesc::new(cube, 10.0)], + -1, + ) + .unwrap(); + let dt = 1.0 / 60.0; + for _ in 0..180 { + w.step(dt); + if aaemu_physics::entities::has_contacts_with(&w, survivor, floor) { + break; + } + } + for body in [first, survivor] { + assert!(w.ent(body).colliders.contains(&floor)); + assert!(aaemu_physics::entities::has_contacts_with(&w, body, floor)); + aaemu_physics::entities::awake(&mut w, body, 0, 1); + assert!(!w.body_state(body).awake); + } + + // Removing one user must unregister it before the static's later destruction tries + // to detach or wake its surviving users. Reclaim through the ordinary cleanup path. + assert_eq!(w.destroy_physical_entity(first, 0), 1); + for _ in 0..8 { + w.step(dt); + } + assert!(w.ents[first.0 as usize].is_none()); + assert_live_rigid_contacts(&w, survivor); + + for _ in 0..4 { + let old = floor; + assert_eq!(w.destroy_physical_entity(old, 0), 1); + assert!( + w.body_state(survivor).awake, + "lost support wakes the sleeper" + ); + floor = w + .add_static( + Vec3::new(32.0, 32.0, -0.5), + Quat::IDENTITY, + &[PartDesc::new(ground.clone(), 0.0)], + -1, + ) + .unwrap(); + for _ in 0..180 { + w.step(dt); + assert_live_rigid_contacts(&w, survivor); + if w.ents[old.0 as usize].is_none() + && aaemu_physics::entities::has_contacts_with(&w, survivor, floor) + { + break; + } + } + assert!(w.ents[old.0 as usize].is_none()); + assert!(w.ent(survivor).colliders.contains(&floor)); + assert!(aaemu_physics::entities::has_contacts_with( + &w, survivor, floor + )); + aaemu_physics::entities::awake(&mut w, survivor, 0, 1); + assert!(!w.body_state(survivor).awake); + } + + // Also exercise the explicit contact removal path before the last user is freed. + assert!(aaemu_physics::entities::remove_collider(&mut w, survivor, floor, true) >= 0); + assert_live_rigid_contacts(&w, survivor); + assert_eq!(w.destroy_physical_entity(survivor, 0), 1); + for _ in 0..8 { + w.step(dt); + } + assert!(w.ents[survivor.0 as usize].is_none()); + assert_eq!(w.destroy_physical_entity(floor, 0), 1); + for _ in 0..8 { + w.step(dt); + } + assert!(w.ents[floor.0 as usize].is_none()); +} diff --git a/rust/crates/aaemu-testclient/src/scenario.rs b/rust/crates/aaemu-testclient/src/scenario.rs index 83ad156269..71c7ae029e 100644 --- a/rust/crates/aaemu-testclient/src/scenario.rs +++ b/rust/crates/aaemu-testclient/src/scenario.rs @@ -119,6 +119,9 @@ pub struct BotConfig { pub password: String, /// Character name used when the account has none. pub character: String, + /// Require creation of `character`, even if the account already has other characters. + #[serde(default)] + pub create_new_character: bool, #[serde(default = "default_gs")] pub game_server_id: u8, /// Skill cast on the nearest NPC (2 = melee attack). @@ -405,6 +408,48 @@ async fn finish( const QUIET: Duration = Duration::from_millis(1500); +fn character_to_select<'a>( + characters: &'a [crate::game::CharInfo], + requested: &str, + created: bool, +) -> anyhow::Result<&'a crate::game::CharInfo> { + if created { + characters + .iter() + .find(|c| c.name.eq_ignore_ascii_case(requested)) + } else { + characters.first() + } + .with_context(|| format!("no character returned for {requested} (created={created})")) +} + +#[cfg(test)] +mod creation_tests { + use super::character_to_select; + use crate::game::CharInfo; + + #[test] + fn fresh_creation_selects_the_new_character_and_never_falls_back_to_existing() { + let mut characters = vec![CharInfo { + id: 1, + name: "Existing".into(), + }]; + assert!(character_to_select(&characters, "Fresh", true).is_err()); + characters.push(CharInfo { + id: 2, + name: "Fresh".into(), + }); + assert_eq!( + character_to_select(&characters, "fresh", true).unwrap().id, + 2 + ); + assert_eq!( + character_to_select(&characters, "Fresh", false).unwrap().id, + 1 + ); + } +} + async fn run_inner( kind: Kind, cfg: &BotConfig, @@ -504,7 +549,7 @@ async fn run_inner( r.end(s, format!("{} character(s)", game.state.characters.len())); let s = r.begin("game.create"); - let created = if game.state.characters.is_empty() { + let created = if cfg.create_new_character || game.state.characters.is_empty() { game.create_character(&cfg.character).await?; let p = game .wait_for("character creation result", |p| { @@ -519,7 +564,7 @@ async fn run_inner( } else { false }; - let ch = game.state.characters[0].clone(); + let ch = character_to_select(&game.state.characters, &cfg.character, created)?.clone(); r.var("char_id", ch.id); r.end( s, diff --git a/rust/crates/aaemu-testclient/src/verify.rs b/rust/crates/aaemu-testclient/src/verify.rs index 4db6f2fbd1..f71c3f94b9 100644 --- a/rust/crates/aaemu-testclient/src/verify.rs +++ b/rust/crates/aaemu-testclient/src/verify.rs @@ -6,7 +6,7 @@ //! ```text //! # comments //! suite # optional, defaults to the file stem -//! bot [gm] # one per bot; `gm` is provisioned by Scripts/verify.sh +//! bot [gm] [fresh] # `gm` is provisioned by Scripts/verify.sh //! //! [] //!