From d12054da654e2fc8f07e39cbe1a9186befd691dd Mon Sep 17 00:00:00 2001 From: Sam Sung <51686767+samwhosung@users.noreply.github.com> Date: Thu, 29 Oct 2026 11:55:07 +0700 Subject: [PATCH] Death, logout and the taxi flag read live and signal at their packets (#2796) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three windows still answered from a copy a feed refreshed once a frame, and fired their events there. **Reference** - The cursor's control gate reads our unit's taxi bit at the call (`0x494b97`-`0x494ba6`). - PLAYER_CAMPING, PLAYER_QUITING, LOGOUT_CANCEL and the logout-failed line are raised by their packets' handlers (`0x5aaf17`, `0x5aaf72`, `0x5aaf26`). - The death signals fire at their packets, and the corpse range is checked each frame (`0x492130`). **Changed** - The taxi gate reads the flag off our object. - The logout replies go on the notice lane at their handlers. - The death getters (GetCorpseRecoveryDelay and the rest) read live, and the death signals fire at their packets. - `feed_on_taxi`, `feed_logout` and `feed_death` are gone. The fake world server logs a session before answering its authentication, which a loaded test run read behind. **Tests:** each getter read between two feeds, and each event between its neighbouring packets' events. Part of #2168 and #2217. šŸ¤– Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 5.5 --- crates/benilla-app/src/death/mod.rs | 726 ++++++------------ crates/benilla-app/src/death/net.rs | 147 +++- crates/benilla-app/src/field_watch.rs | 28 +- crates/benilla-app/src/game_plugins.rs | 13 +- crates/benilla-app/src/lanes.rs | 4 + .../src/lanes/arrival_live_tests.rs | 2 +- .../benilla-app/src/lanes/death_live_tests.rs | 175 +++++ crates/benilla-app/src/lanes/guard_tests.rs | 41 +- .../benilla-app/src/lanes/host_read_tests.rs | 7 +- .../src/lanes/logout_live_tests.rs | 83 ++ crates/benilla-app/src/net/io/fake.rs | 14 +- crates/benilla-app/src/script_calls.rs | 75 +- crates/benilla-app/src/script_calls/live.rs | 3 + .../src/script_calls/tests/dialogs.rs | 3 +- crates/benilla-app/src/target/click.rs | 8 +- crates/benilla-app/src/target/died.rs | 24 +- crates/benilla-app/src/ui_dialog_verbs.rs | 11 +- crates/benilla-app/src/ui_items/calls.rs | 5 + .../benilla-app/src/ui_items/requirements.rs | 11 +- crates/benilla-app/src/ui_logout.rs | 171 ++--- .../benilla-app/src/ui_script/death_tests.rs | 7 +- crates/benilla-app/src/ui_taxi/mod.rs | 70 +- crates/benilla-app/src/ui_unit.rs | 3 + .../benilla-app/src/ui_unit/field_events.rs | 12 + crates/benilla-ui/src/script/container.rs | 4 +- crates/benilla-ui/src/script/cursor.rs | 8 +- crates/benilla-ui/src/script/cursor/doll.rs | 2 +- crates/benilla-ui/src/script/cursor/equip.rs | 15 +- crates/benilla-ui/src/script/death.rs | 129 +++- crates/benilla-ui/src/script/mod.rs | 2 +- crates/benilla-ui/src/script/stat_read.rs | 9 + crates/benilla-ui/src/script/taxi.rs | 11 +- docs/DEVIATIONS.md | 11 +- 33 files changed, 1050 insertions(+), 784 deletions(-) create mode 100644 crates/benilla-app/src/lanes/death_live_tests.rs create mode 100644 crates/benilla-app/src/lanes/logout_live_tests.rs diff --git a/crates/benilla-app/src/death/mod.rs b/crates/benilla-app/src/death/mod.rs index ed5993890..a3d82bbd8 100644 --- a/crates/benilla-app/src/death/mod.rs +++ b/crates/benilla-app/src/death/mod.rs @@ -1,21 +1,24 @@ //! Death and resurrection: the wire-fed stores, the events into the Lua UI and the intents back -//! to the wire. Dead is health 0 and ghost is `PLAYER_FLAGS` bit 0x10, read off the self -//! descriptor each frame. The death state signals (`PLAYER_DEAD` or `PLAYER_ALIVE`) inside our -//! own death's handler ([`signal_death_state`]) and after each arrival's world-enter cascade -//! ([`feed_death`]), and `PLAYER_ALIVE` on release and on a pre-release res. The -//! cascade releases a body it finds dead ([`repop_on_world_enter`]). -//! `PLAYER_UNGHOST` is the ghost state's (`0x5de9c0`), signalled where it runs: the ghost bit's -//! clear ([`crate::field_watch`]) and an alive arrival (`crate::ui_unit`). +//! to the wire. Dead is health 0 and ghost is `PLAYER_FLAGS` bit 0x10. The getters read the +//! stores through the host as they run ([`DeathView`]). The death state signals (`PLAYER_DEAD` or +//! `PLAYER_ALIVE`) inside our own death's handler and after each arrival's world-enter cascade +//! ([`signal_death_state`]), and `PLAYER_ALIVE` in the health watcher's revive arm, on release +//! and on a res ([`crate::field_watch`]). The offers and the corpse-range signals that packets +//! raise go on the dialogs' lane at their handlers ([`net`]); the corpse range's own poll runs in +//! the world frame's update ([`poll_corpse`]). The cascade releases a body it finds dead +//! ([`repop_on_world_enter`]). `PLAYER_UNGHOST` is the ghost state's (`0x5de9c0`), signalled where +//! it runs: the ghost bit's clear ([`crate::field_watch`]) and an alive arrival (`crate::ui_unit`). use bevy::prelude::*; use benilla_assets::coords::wow_to_bevy; -use benilla_ui::script::{DeathAction, DeathUiState, ScriptValue, UiScript}; +use benilla_ui::script::{ + DeathAction, DeathQuery, DeathUiState, ResSicknessLevelQuery, ScriptValue, UiScript, +}; use crate::net::{ClientCommand, NetCommands, ObjectStore, Objects, SelfGuid, SelfPlayer}; use crate::query_cache::Ask; use crate::ui_action::Spells; -use crate::ui_script::UiFeed; pub(crate) mod net; @@ -42,6 +45,9 @@ pub(crate) struct ResurrectOffer { pub(crate) sickness: bool, /// The reclaim-delay gate still holds: RESURRECT, not RESURRECT_NO_TIMER. pub(crate) has_timer: bool, + /// The caster's name was asked with the callback `0x5e7ca0` (`0x5e7c82`), whose answer shows + /// the offer or forgets it. + pub(crate) waits_name: bool, } /// The release timer our own death arms (`0x5e99b0`, `0xb4e340` and its no-timer byte @@ -69,22 +75,15 @@ pub(crate) struct DeathNet { pub(crate) release: ReleaseTimer, /// When the corpse becomes reclaimable: `SMSG_CORPSE_RECLAIM_DELAY` anchored at arrival. pub(crate) reclaim_at: Option, - /// Bumped per `SMSG_CORPSE_RECLAIM_DELAY`: the 1.12 client's handler re-fires the range - /// events on each. - pub(crate) reclaim_generation: u32, /// The last `MSG_CORPSE_QUERY` answer; a not-found drops it. pub(crate) corpse: Option, - /// A pending resurrection offer; cleared when answered or when the popup times out. + /// A pending resurrection offer (`[0xc4d760]`); cleared when answered, or by a refused name. pub(crate) resurrect: Option, - /// Bumped per `SMSG_RESURRECT_REQUEST`: the offer announces per message (`0x5e7bc0` through - /// `0x5ded50`), because the stock UI can hide the popup without answering it. - pub(crate) resurrect_generation: u32, /// Our streamed corpse object's guid, which `CMSG_RECLAIM_CORPSE` carries like the 1.12 client. pub(crate) corpse_guid: Option, - /// The spirit healer awaiting the XP-loss answer; Accept sends `CMSG_SPIRIT_HEALER_ACTIVATE`. + /// The spirit healer awaiting the XP-loss answer (`[0xc4d798]`); Accept sends + /// `CMSG_SPIRIT_HEALER_ACTIVATE`. pub(crate) spirit_healer: Option, - /// Bumped per ask: a Cancel clears nothing, so only a fresh ask re-shows the dialog. - pub(crate) confirm_generation: u32, /// Water-walking is granted on our mover; mirrored, not applied: walking on the water surface /// is not built. #[allow(dead_code)] @@ -107,61 +106,85 @@ impl DeathNet { pub(crate) fn zero_release(&mut self) { self.release = ReleaseTimer::Unset; } - - /// Arm the spirit healer's XP-loss question. The reference raises it on the click with no - /// packet (`0x5df730`), and vmangos also pushes `SMSG_SPIRIT_HEALER_CONFIRM`; both come here. - pub(crate) fn ask_spirit_healer(&mut self, npc: u64) { - self.spirit_healer = Some(npc); - self.confirm_generation = self.confirm_generation.wrapping_add(1); - } } -/// The feed's memory in two scopes: the body's state survives a `/reload`, while what the VM was -/// told dies with the VM. +/// The interface's death globals beside the stores, world-scoped and cleared at the session's end: +/// the body's last state, which the corpse asks' edges compare, and the corpse-range latch. A +/// `/reload` keeps both. #[derive(Resource, Default)] -pub(crate) struct DeathFeedState { - /// World-scoped: the last `(guid, dead, ghost)` the self body showed. +pub(crate) struct DeathLatches { + /// The last `(guid, dead, ghost)` the self body showed. mirror: Option<(u64, bool, bool)>, - /// World-scoped: the corpse-range latch `[0xb4e324]`, the last verdict signalled + /// The corpse-range latch `[0xb4e324]`: whether the last verdict signalled was in range /// (`0x4920f0`), which the cascade's corpse step zeroes into whichever VM is live. - corpse_range: Option, - /// A fresh reclaim delay re-fires the range events, as the 1.12 client does (`0x4962d0`), - /// so RECOVER_CORPSE re-shows with the new delay. - reclaim_generation: u32, - /// VM-scoped: the announce latches. - vm: crate::ui_script::VmMemo, + corpse_in_range: bool, } -impl DeathFeedState { +impl DeathLatches { /// The corpse-range latch set, as a ghost in range of its corpse left it. #[cfg(test)] pub(crate) fn latch_corpse_in_range_for_test(&mut self) { - self.corpse_range = Some(CorpseRange::In); + self.corpse_in_range = true; + } + + /// `SetCorpseInRange 0x4920f0`: on a change (`0x4920f6`), the latch stored and its signal, + /// [`CorpseSignal::in_range`] for in range, `CORPSE_OUT_OF_RANGE` (399, `0x49211f`) for out. + fn set_in_range( + &mut self, + in_range: bool, + corpse: Option<&CorpsePoint>, + ) -> Option { + if std::mem::replace(&mut self.corpse_in_range, in_range) == in_range { + return None; + } + Some(if in_range { + CorpseSignal::in_range(corpse) + } else { + CorpseSignal::Out + }) } } -/// What the live VM has been told. A fresh VM's first sight of the body is no edge: a `/reload`'s -/// cascade signals no death state (`0x490168` never reaches `0x495850`), and an arrival signals it -/// after its cascade (`0x5deb65`, [`signal_death_state`]). -#[derive(Default)] -struct DeathAnnounced { - /// The last `(guid, dead, ghost)` this VM was given an event for. - last: Option<(u64, bool, bool)>, - /// Held back while a player caster's name is still resolving. - offer_generation: u32, - /// The offer whose caster's name was looked up as its packet's (`0x5e7c82`, callback - /// `0x5e7ca0`): the frames that wait on it read. - offer_asked: u32, - /// A fresh ask re-fires `CONFIRM_XP_LOSS`. - confirm_generation: u32, +/// A corpse-range event, each argumentless (`0x703e50`). +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum CorpseSignal { + /// `CORPSE_IN_RANGE` (397). + In, + /// `CORPSE_IN_INSTANCE` (398). + InInstance, + /// `CORPSE_OUT_OF_RANGE` (399). + Out, } -/// The corpse-range verdicts the reference's events distinguish. -#[derive(Clone, Copy, PartialEq, Eq)] -enum CorpseRange { - Out, - In, - InInstance, +impl CorpseSignal { + /// The in-range event for the cached corpse: [`Self::InInstance`] when the cache's display + /// map is not the corpse's own, a dungeon's entrance (`0x492102`-`0x492114`, + /// `0x4962f5`-`0x496307`). + fn in_range(corpse: Option<&CorpsePoint>) -> Self { + if corpse.is_some_and(|c| u32::try_from(c.display_map) != Ok(c.corpse_map)) { + Self::InInstance + } else { + Self::In + } + } + + /// Signalled in place. + fn fire(self, script: &mut UiScript) { + match self { + Self::In => script.fire_event("CORPSE_IN_RANGE", vec![]), + Self::InInstance => script.fire_event("CORPSE_IN_INSTANCE", vec![]), + Self::Out => script.fire_event("CORPSE_OUT_OF_RANGE", vec![]), + } + } + + /// Queued on the dialogs' lane at a handler's place. + fn queue(self, lane: &mut crate::ui_dialog_verbs::DialogLane) { + match self { + Self::In => lane.event("CORPSE_IN_RANGE", vec![]), + Self::InInstance => lane.event("CORPSE_IN_INSTANCE", vec![]), + Self::Out => lane.event("CORPSE_OUT_OF_RANGE", vec![]), + } + } } /// The corpse-range dialog radius, 40 yd inclusive: the 1.12 client compares d² ≤ `[0xb4e2ac]` @@ -172,8 +195,8 @@ const CORPSE_RANGE_SQ: f32 = 40.0 * 40.0; /// The spirit-healer dialog range: `CheckSpiritHealerDist` compares d² ≤ `[0xc4c28c]` (30.864). const SPIRIT_HEALER_RANGE_SQ: f32 = 5.5556 * 5.5556; -/// What the death snapshot reads ([`DeathView::snapshot`]): the self body, the death stores and -/// what `HasSoulstone()` walks. +/// What the death getters read through the host as they run ([`DeathQuery`]): the self body, the +/// death stores and what `HasSoulstone()` walks. #[derive(bevy::ecs::system::SystemParam)] pub(crate) struct DeathView<'w, 's> { self_q: Query<'w, 's, (&'static ObjectStore, &'static Transform), With>, @@ -200,9 +223,9 @@ impl DeathView<'_, '_> { Some((guid, store, self_t)) } - /// The snapshot the death verbs read, pushed before an event fires so its handlers read - /// current values. - fn snapshot(&self, script: &UiScript, store: &ObjectStore, self_t: &Transform) -> DeathUiState { + /// The death state as the getters read it now: the timers off the stores, and what reads + /// the live body (the healer's range, the self-res) while one is held. + fn state(&self) -> DeathUiState { let now = self.time.elapsed_secs_f64(); let death_net = &self.death_net; let release_remaining = match death_net.release { @@ -214,71 +237,77 @@ impl DeathView<'_, '_> { let recovery_delay = death_net .reclaim_at .map_or(0.0, |at| (at - now).max(0.0) as f32); - let spirit_healer_in_range = death_net.spirit_healer.is_some_and(|npc| { - self.objects - .entity(npc) - .and_then(|e| self.transforms.get(e).ok()) - .is_some_and(|t| { - t.translation.distance_squared(self_t.translation) <= SPIRIT_HEALER_RANGE_SQ - }) + let body = self.body(); + let spirit_healer_in_range = body.is_some_and(|(_, _, self_t)| { + death_net.spirit_healer.is_some_and(|npc| { + self.objects + .entity(npc) + .and_then(|e| self.transforms.get(e).ok()) + .is_some_and(|t| { + t.translation.distance_squared(self_t.translation) <= SPIRIT_HEALER_RANGE_SQ + }) + }) }); - let sickness = sickness_duration( - store.0.unit_level().unwrap_or(0), - benilla_ui::strings::Strings::Vm(script.lua()), - ); DeathUiState { release_remaining, recovery_delay, resurrect_sickness: death_net.resurrect.as_ref().is_some_and(|o| o.sickness), resurrect_has_timer: death_net.resurrect.as_ref().is_some_and(|o| o.has_timer), spirit_healer_in_range, - sickness_duration: sickness, + // Worded by the getter off [`ResSicknessLevelQuery`]. + sickness_duration: None, // `HasSoulstone()`; the dead gate is first, so the inventory walk runs only while dead. - self_res_label: resolve_self_res( - &store.0, - &self.objects, - &self.items, - self.spells.as_deref(), - ) - .map(|r| r.label().to_owned()), + self_res_label: body.and_then(|(_, store, _)| { + resolve_self_res(&store.0, &self.objects, &self.items, self.spells.as_deref()) + .map(|r| r.label().to_owned()) + }), } } } -/// Derive the death state from the self descriptor, push the snapshot, and fire the death events -/// on its edges. Our player's arrival signals the death state itself, after its world-enter -/// cascade (`0x5deb65` → `0x495850`, [`signal_death_state`]): a login, a reconnect or a worldport -/// to a dead body hears `PLAYER_DEAD`, any other `PLAYER_ALIVE`. -pub(crate) fn feed_death( - // The death stores, which the death calls write: an engine turn, its events signalled after. - mut vm: crate::script_calls::VmWith>, - mut feed: ResMut, - names: Res, - net: Res, - map: Option>, - // Our player's create this frame, which runs no watcher (`0x465d80`): its death state is the - // arrival's own signal, not an edge. - arrivals: Query<(), Added>, -) { - let arrived = !arrivals.is_empty(); - vm.turn(|script, view| { - let Some(script) = script else { +/// The death getters' family of the host's live reads. +impl crate::script_calls::live::LiveFamily for DeathView<'_, '_> { + fn answer(&mut self, ask: &mut benilla_ui::script::live::LiveAsk<'_>) -> bool { + ask.answer(|_: &DeathQuery| Some(self.state())) + || ask.answer(|_: &ResSicknessLevelQuery| { + self.body() + .map(|(_, store, _)| store.0.unit_level().unwrap_or(0)) + }) + } +} + +/// What the corpse poll reads and writes beside the host: the self body and the session, the +/// death stores, the latches and the map shown. +type CorpsePoll = ( + Query<'static, 'static, (&'static ObjectStore, &'static Transform), With>, + Res<'static, SelfGuid>, + Res<'static, crate::net::NetStatus>, + Res<'static, DeathNet>, + ResMut<'static, DeathLatches>, + Option>, +); + +/// `CheckCorpseRange 0x492130`, which the world frame's update runs every frame after its pick +/// (`0x4818c5`, in `0x481790`'s unconditional tail): a ghost on the map shown within 40 yards of +/// the cached corpse is in range (`0x492196`), and `SetCorpseInRange` signals a change in place +/// ([`DeathLatches::set_in_range`]). Ahead of it, the corpse asks of the ghost bit's edges, which +/// a `/reload` must not repeat. +pub(crate) fn poll_corpse(mut vm: crate::script_calls::VmWith, net: Res) { + let signal = { + let (self_q, self_guid, status, death_net, mut latches, map) = vm.own(); + // A disconnect keeps the self avatar with its frozen descriptor; only a live session's + // body counts. + let body = self_guid + .0 + .filter(|_| status.connected) + .and_then(|guid| Some((guid, self_q.single().ok()?))); + let Some((guid, (store, self_t))) = body else { return; }; - let Some((guid, store, self_t)) = view.body() else { - return; - }; - let death_net = &view.death_net; let dead = store.0.unit_is_dead(); let ghost = store.0.player_is_ghost(); - - // ── The snapshot, set before the events fire so their handlers read current values ── - let snapshot = view.snapshot(script, store, self_t); - script.set_death(snapshot); - - // ── The world edges: the corpse asks, which a `/reload` must not repeat. - let prev = feed.mirror.filter(|&(g, ..)| g == guid); - feed.mirror = Some((guid, dead, ghost)); + let prev = latches.mirror.filter(|&(g, ..)| g == guid); + latches.mirror = Some((guid, dead, ghost)); match (prev, dead, ghost) { // Dead to ghost (released): ask where the corpse is. (Some((_, true, false)), _, true) => { @@ -294,116 +323,52 @@ pub(crate) fn feed_death( } _ => {} } - - // ── The VM edges: a fresh VM's memo is empty, and its first sight is no edge. - let memo = feed.vm.get(script); - let prev = memo.last.filter(|&(g, ..)| g == guid && !arrived); - memo.last = Some((guid, dead, ghost)); - fire_vm_edges(script, prev.map(|(_, d, g)| (d, g)), dead, ghost); - - // ── The offer and confirm announcements ── - let ask = Ask::at( - std::mem::replace(&mut memo.offer_asked, death_net.resurrect_generation) - != death_net.resurrect_generation, - &net, - ); - if let Some(name) = - offer_announcement(memo, death_net, store.0.is_dead_or_ghost(), |offer| { - // A player caster's name is empty on the wire; hold the popup until the cache - // resolves it. - if offer.name.is_empty() { - names.resolve_player(offer.caster, ask).map(str::to_owned) - } else { - Some(offer.name.clone()) - } - }) - { - script.fire_event("RESURRECT_REQUEST", vec![ScriptValue::Str(name)]); - } - if death_net.spirit_healer.is_some() - && memo.confirm_generation != death_net.confirm_generation - { - memo.confirm_generation = death_net.confirm_generation; - // `arg1` is the XP the res costs: `PLAYER_NEXT_LEVEL_XP` Ɨ 0.05, truncated - // (`0x5df837`), and 0 without the field, as `0x5df806` pushes 0 for a non-local object. - // No stock FrameXML reads it; `UIParent.lua:399` asks `GetResSicknessDuration()`. - let xp_cost = store - .0 - .player_next_level_xp() - .map_or(0, |next| (f64::from(next) * 0.05) as i64); - script.fire_event("CONFIRM_XP_LOSS", vec![ScriptValue::Int(xp_cost)]); - } - - // ── The corpse-run range gate: only a ghost, against the query's display position; the - // coordinate transform is isometric, so the Bevy-space compare is in yards. - let range = if ghost { - death_net.corpse.map(|cp| { - // Within range on the display map: IN_RANGE when it is the corpse's map, else - // IN_INSTANCE, at a dungeon's entrance (`0x492130`, `0x4920f0`). + // Against the query's display position; the coordinate transform is isometric, so the + // Bevy-space compare is in yards. The ghost test stands in for the ghost flag's clear of + // the corpse cache, which is not built (`0x5eeac1` → `0x491f50`, #392). + let corpse = death_net.corpse.as_ref(); + let in_range = ghost + && corpse.is_some_and(|cp| { + // Deviation: `0x492130` compares the positions whatever map we stand on, so a + // ghost on another map at the corpse's coordinates reads in range for a reclaim + // the server refuses; here only the corpse's display map counts. let on_display_map = map .as_ref() .is_some_and(|m| m.0 == u32::try_from(cp.display_map).unwrap_or(u32::MAX)); - let near = on_display_map + on_display_map && wow_to_bevy(cp.position).distance_squared(self_t.translation) - <= CORPSE_RANGE_SQ; - let same_map = u32::try_from(cp.display_map) == Ok(cp.corpse_map); - match (near, same_map) { - (false, _) => CorpseRange::Out, - (true, true) => CorpseRange::In, - (true, false) => CorpseRange::InInstance, - } - }) - } else { - None - }; - if feed.reclaim_generation != death_net.reclaim_generation { - feed.reclaim_generation = death_net.reclaim_generation; - feed.corpse_range = None; // re-announce whatever holds now - } - if range != feed.corpse_range { - match range { - Some(CorpseRange::In) => script.fire_event("CORPSE_IN_RANGE", vec![]), - Some(CorpseRange::InInstance) => script.fire_event("CORPSE_IN_INSTANCE", vec![]), - // Leaving range and the ghost state ending both fire the one hide event. - Some(CorpseRange::Out) | None if feed.corpse_range.is_some() => { - script.fire_event("CORPSE_OUT_OF_RANGE", vec![]); - } - _ => {} + <= CORPSE_RANGE_SQ + }); + latches.set_in_range(in_range, corpse) + }; + if let Some(signal) = signal { + vm.run(|script| { + if let Some(script) = script { + signal.fire(script); } - feed.corpse_range = range; - } - }) + }); + } } /// `SignalDeathState 0x495850`, where our own death's `PresentUnitDeath` ends (`0x6251cc`, for /// the active player alone, `0x5fa6d0` at `0x6251c2`): with our health 0 or less (`jg` at /// `0x495876`) `PLAYER_DEAD` (`0x113`, `0x49587d`), its handlers reading the timer the death armed, /// then `ClearCursor(1, 1)` (`0x495889` → `0x495190`); else `PLAYER_ALIVE` (`0x112`, `0x495893`). -/// The VM's memo takes the state, so the feed signals no edge of it again. -pub(crate) fn signal_death( - mut vm: crate::script_calls::VmWith>, - mut feed: ResMut, -) { - signal(&mut vm, &mut feed); +/// Its handlers read the timer the death armed through the host. +pub(crate) fn signal_death(mut vm: crate::script_calls::VmWith>) { + signal(&mut vm); } /// [`signal_death`]'s body; false with no VM or no live body, which signals nothing. -fn signal( - vm: &mut crate::script_calls::VmWith>, - feed: &mut DeathFeedState, -) -> bool { +fn signal(vm: &mut crate::script_calls::VmWith>) -> bool { let dead = { - let (Some(script), set) = vm.parts() else { + let (Some(_), set) = vm.parts() else { return false; }; let view = set.p0(); - let Some((guid, store, self_t)) = view.body() else { + let Some((_, store, _)) = view.body() else { return false; }; - let snapshot = view.snapshot(script, store, self_t); - script.set_death(snapshot); - let memo = feed.vm.get(script); - memo.last = Some((guid, store.0.unit_is_dead(), store.0.player_is_ghost())); store.0.unit_health().unwrap_or(0) as i32 <= 0 }; // `0x495850`: the signal's listeners run before the cursor clears (`0x49587d`, `0x495889`). @@ -449,14 +414,14 @@ fn send_repop_request(store: &benilla_protocol::ObjectFields, net: &NetCommands) /// The corpse cache and the range latch, beside the host. type CorpseStores = ( Option>, - Option>, + Option>, ); /// `QueryCorpse 0x491f50` in the world-enter cascade (`0x490a28`), after its other sends: the /// corpse cache reset (`0x491f74` → `0x492010(-1, …)`), the range latch zeroed (`0x491f7b` → /// `0x4920f0(0)`), which signals `CORPSE_OUT_OF_RANGE` from a set latch, then, for a ghost /// (`PLAYER_FLAGS` bit 4, `0x491fad`), `MSG_CORPSE_QUERY` (`0x491fb2`). The flags watcher's -/// release and revive asks are [`feed_death`]'s. +/// release and revive asks are [`poll_corpse`]'s. pub(crate) fn query_corpse_on_world_enter( self_q: Query<&ObjectStore, With>, mut vm: crate::script_calls::VmWith, @@ -466,12 +431,7 @@ pub(crate) fn query_corpse_on_world_enter( if let Some(mut death_net) = death_net { death_net.corpse = None; } - let was_in = feed.is_some_and(|mut feed| { - matches!( - feed.corpse_range.take(), - Some(CorpseRange::In | CorpseRange::InInstance) - ) - }); + let was_in = feed.is_some_and(|mut latches| std::mem::take(&mut latches.corpse_in_range)); if was_in { vm.run(|script| { if let Some(script) = script { @@ -594,26 +554,6 @@ fn self_res( }) } -/// The sickness a spirit-healer res applies at `level`, per vmangos `Player::ResurrectPlayer`: -/// none below 11, `level - 10` minutes through 19, 10 minutes from 20. Worded with `GENERIC_MIN`, -/// the minute arm of the reference's formatter (`0x51a3a0` into `0x52fa50`). -/// -/// Deviation: the minutes come from the server's table, not from spell 15007's `Spell.dbc` -/// duration, because the aura the server applies is what the dialog must warn about. -fn sickness_duration(level: u32, strings: benilla_ui::strings::Strings<'_>) -> Option { - let minutes = match level { - 0..=10 => return None, - 11..=19 => level - 10, - _ => 10, - }; - // `GetText(token, nil, ordinal)`, the VM's own. - let template = benilla_ui::strings::plural("GENERIC_MIN", Some(minutes), strings)?; - Some(benilla_ui::strings::fill( - &template, - &[benilla_ui::strings::Arg::D(i64::from(minutes))], - )) -} - /// Drive the FFXDeath screen pass off `PLAYER_FLAGS_GHOST`, instant both ways; in the reference /// the flag's watcher `0x5ee990` also drives the death light and ambience. fn drive_death_look( @@ -830,131 +770,90 @@ impl DeathSteps<'_, '_> { } } -/// Clear [`DeathFeedState`]'s world scope on `DisconnectedMessage`, the edge [`DeathNet`] resets -/// on: a relog as a ghost must find no mirror, or the corpse query is never re-sent. -fn end_session_death_feed( - mut msgs: MessageReader, - mut feed: ResMut, -) { - if msgs.read().next().is_some() { - *feed = DeathFeedState::default(); +/// `SpiritHealerDialog 0x5df730(npc)` asking: for a ghost (`PLAYER_FLAGS` bit 0x10, `0x5df74a`), +/// the healer `npc` held as a unit (`0x5df77a`) within the interaction range (`0x5df7c1`, +/// `[0xc4c28c]`) is remembered (`0x5df7e6`), and `CONFIRM_XP_LOSS` (396, `0x5df837`) is owed with +/// the XP the res costs, `PLAYER_NEXT_LEVEL_XP` Ɨ 0.05 truncated (`0x5df815`-`0x5df827`). No stock +/// FrameXML reads the cost; `UIParent.lua:399` asks `GetResSicknessDuration()`. +#[derive(bevy::ecs::system::SystemParam)] +pub(crate) struct SpiritHealerAsk<'w, 's> { + death_net: ResMut<'w, DeathNet>, + me: Query<'w, 's, (&'static ObjectStore, &'static Transform), With>, + objects: Objects<'w, 's>, + transforms: Query<'w, 's, &'static Transform>, +} + +impl SpiritHealerAsk<'_, '_> { + /// The ask for `npc`; the cost the signal carries when its gates pass, else nothing is + /// remembered and nothing signals. + pub(crate) fn ask(&mut self, npc: u64) -> Option { + let (store, self_t) = self.me.single().ok()?; + if !store.0.player_is_ghost() { + return None; + } + let healer = self + .objects + .entity(npc) + .filter(|_| self.objects.store(npc).is_some_and(|s| s.is_unit())) + .and_then(|e| self.transforms.get(e).ok())?; + if healer.translation.distance_squared(self_t.translation) > SPIRIT_HEALER_RANGE_SQ { + return None; + } + self.death_net.spirit_healer = Some(npc); + Some( + store + .0 + .player_next_level_xp() + .map_or(0, |next| (f64::from(next) * 0.05) as i64), + ) } } -/// The death stores, the feed into the UI, the intent drain and the root and water-walk messages. +/// [`SpiritHealerAsk`] from the click on a spirit healer, which the reference raises with no +/// packet (`0x5f0130` → `0x5df730`): `CONFIRM_XP_LOSS` signalled in place with the host. +pub(crate) fn ask_spirit_healer( + In(npc): In, + mut vm: crate::script_calls::VmWith>, +) { + let Some(cost) = vm.own().ask(npc) else { + return; + }; + vm.run(|script| { + if let Some(script) = script { + script.fire_event("CONFIRM_XP_LOSS", vec![ScriptValue::Int(cost)]); + } + }); +} + +/// The death stores, the corpse poll, the intent drain and the root and water-walk messages. pub(crate) struct DeathPlugin; impl Plugin for DeathPlugin { fn build(&self, app: &mut App) { net::register(app); + crate::ui_dialog_verbs::add_dialog_lane(app); app.init_resource::() - .init_resource::() + .init_resource::() .add_systems( Update, ( - feed_death.in_set(UiFeed), + // The world frame's update, after its pick (`0x48184a`, then `0x4818c5`), as + // the area spirit healer's poll; gated, as the poll re-derives every frame. + poll_corpse + .after(crate::target::TargetUpdate) + .run_if(crate::ui_script::ingame_ui_up) + .in_set(crate::client_state::InWorldGated), drive_death_look, - // Before the feed, so the frame a session ends carries no memory of it. - end_session_death_feed.before(feed_death), ), ); } } -/// The name `RESURRECT_REQUEST` fires with this frame, if any. Per message, and only while dead -/// or a ghost (`0x5ded50` gated on `0x605f30`); an unresolved name holds without consuming it. -fn offer_announcement( - memo: &mut DeathAnnounced, - death_net: &DeathNet, - dead_or_ghost: bool, - name_of: impl FnOnce(&ResurrectOffer) -> Option, -) -> Option { - if !dead_or_ghost || memo.offer_generation == death_net.resurrect_generation { - return None; - } - let name = name_of(death_net.resurrect.as_ref()?)?; - memo.offer_generation = death_net.resurrect_generation; - Some(name) -} - #[cfg(test)] mod tests { use super::*; use bevy::ecs::system::RunSystemOnce; - fn offer(caster: u64, name: &str) -> ResurrectOffer { - ResurrectOffer { - caster, - name: name.into(), - sickness: false, - has_timer: true, - } - } - - /// The offer's packet looks a player caster's name up with the callback `0x5e7ca0` - /// (`0x5e7c82`); the frames the popup waits through read. A refused name is asked by no frame - /// after it, only by the next offer. - #[test] - fn a_refused_resurrecter_is_asked_by_the_next_offer_never_by_a_frame() { - use benilla_protocol::messages::ObjectType; - use benilla_protocol::ObjectFields; - const ME: u64 = 0x7; - const CASTER: u64 = 0x9; - let (tx, rx) = crossbeam_channel::unbounded(); - let mut app = App::new(); - app.insert_resource(NetCommands(tx)) - .insert_resource(crate::net::NetStatus { - connected: true, - last_reason: None, - }) - .init_resource::() - .init_resource::() - .init_resource::() - .init_resource::() - .init_resource::() - .init_resource::() - .init_resource::>() - .add_systems(Update, feed_death); - app.insert_non_send_resource(UiScript::new().unwrap()); - // `UNIT_FIELD_HEALTH` 0 of a `UNIT_FIELD_MAXHEALTH` 100: dead. - let dead = ObjectFields::from_pairs(&[(22, 0), (28, 100)]).into_created(ObjectType::Player); - let me = app - .world_mut() - .spawn((ObjectStore(dead), Transform::default(), SelfPlayer)) - .id(); - app.world_mut() - .resource_mut::() - .0 - .insert(ME, me); - app.world_mut().resource_mut::().0 = Some(ME); - let offer = |app: &mut App| { - net::resurrect_request_for_tests( - CASTER, - &mut app.world_mut().resource_mut::(), - ); - app.update(); - }; - app.update(); - offer(&mut app); - assert_eq!(crate::query_cache::queries(&rx).len(), 1); - app.world_mut() - .resource_mut::() - .insert_player(CASTER, String::new(), None); - for _ in 0..600 { - app.update(); - } - assert!( - crate::query_cache::queries(&rx).is_empty(), - "no frame asks a refusal" - ); - offer(&mut app); - assert_eq!( - crate::query_cache::queries(&rx).len(), - 1, - "the next offer asks again" - ); - } - /// `0x495850` signals `PLAYER_DEAD` (`0x49587d`) before it clears the cursor (`0x495889`): a /// listener still finds the coins it held. #[test] @@ -971,7 +870,7 @@ mod tests { }) .init_resource::() .init_resource::() - .init_resource::() + .init_resource::() .init_resource::() .init_resource::() .init_resource::>(); @@ -1002,48 +901,6 @@ mod tests { assert!(script.cursor_payload().is_none(), "then the clear"); } - /// PLAYER_UNGHOST hides the popup with `StaticPopup_Hide`, which runs no `OnCancel`, so no - /// Decline clears `resurrect`. - #[test] - fn every_resurrect_message_announces_while_dead_and_never_while_alive() { - let mut net = DeathNet::default(); - let mut memo = DeathAnnounced::default(); - let name = |o: &ResurrectOffer| Some(o.name.clone()); - - net.resurrect = Some(offer(1, "Healer")); - net.resurrect_generation += 1; - assert_eq!( - offer_announcement(&mut memo, &net, true, name).as_deref(), - Some("Healer") - ); - assert_eq!( - offer_announcement(&mut memo, &net, true, name), - None, - "once per message" - ); - - // Alive with the offer unanswered: a fresh VM must not announce it. - let mut reloaded = DeathAnnounced::default(); - assert_eq!(offer_announcement(&mut reloaded, &net, false, name), None); - - // Dead again, a new priest offers. - net.resurrect = Some(offer(2, "Ptwo")); - net.resurrect_generation += 1; - assert_eq!( - offer_announcement(&mut memo, &net, true, name).as_deref(), - Some("Ptwo"), - "the second offer announces" - ); - - // A name still resolving holds the announcement without consuming it. - net.resurrect_generation += 1; - assert_eq!(offer_announcement(&mut memo, &net, true, |_| None), None); - assert_eq!( - offer_announcement(&mut memo, &net, true, name).as_deref(), - Some("Ptwo") - ); - } - const STONE: u64 = 0x4000_0000_0000_5232; const SELF_RES: u32 = 20707; const FIREBALL: u32 = 133; @@ -1492,37 +1349,27 @@ mod tests { } /// A `/reload` keeps the body's mirror, so it re-sends no corpse ask; a relog must clear it. + /// A `/logout` is a session edge although `session_over` is false for it. #[test] - fn the_session_edge_clears_the_world_scoped_death_memory_and_nothing_else_does() { - let mut app = App::new(); - app.add_message::() - .insert_resource(DeathFeedState { - mirror: Some((0x1234, true, true)), - ..Default::default() - }); - - // No session edge: the memory stands. - app.world_mut() - .run_system_once(end_session_death_feed) + fn the_session_edge_clears_the_world_scoped_death_memory() { + let mut world = World::new(); + world.init_resource::(); + world.insert_resource(DeathLatches { + mirror: Some((0x1234, true, true)), + corpse_in_range: true, + }); + world + .run_system_cached_with( + net::on_session_end, + benilla_protocol::SessionEvent::Disconnected { + reason: "logged out".into(), + end: benilla_protocol::SessionEnd::LoggedOut, + }, + ) .expect("the teardown runs"); - assert_eq!( - app.world().resource::().mirror, - Some((0x1234, true, true)), - "nothing but the session edge may clear the body's own state machine" - ); - - // A `/logout` is a session edge although `session_over` is false for it. - app.world_mut() - .write_message(crate::net::DisconnectedMessage::new( - "logged out".into(), - benilla_protocol::SessionEnd::LoggedOut, - )); - app.world_mut() - .run_system_once(end_session_death_feed) - .expect("the teardown runs"); - let feed = app.world().resource::(); + let latches = world.resource::(); assert!( - feed.mirror.is_none(), + latches.mirror.is_none() && !latches.corpse_in_range, "a relog must find no mirror, or the login-while-ghost arm cannot fire" ); } @@ -1530,7 +1377,7 @@ mod tests { /// `PLAYER_FIELD_BYTES`, whose bit 0x8 our own death's timer reads (`0x5e9a27`). const BYTES: u16 = 1222; - /// A world with our player at `health`, the release-timer bit set, the death feed and the + /// A world with our player at `health`, the release-timer bit set, the death stores and the /// arrival's signal, and a VM that records each death-state event with the timer it reads. fn arrival_app(health: u32) -> App { use benilla_protocol::field::{FIELD_UNIT_HEALTH, FIELD_UNIT_MAXHEALTH}; @@ -1546,14 +1393,13 @@ mod tests { }) .init_resource::() .init_resource::() - .init_resource::() + .init_resource::() .init_resource::() .init_resource::() .init_resource::() .init_resource::>() .insert_resource(State::new(crate::client_state::ClientState::InWorld)) - .add_plugins(crate::ui_world_enter::WorldEnterPlugin) - .add_systems(Update, feed_death); + .add_plugins(crate::ui_world_enter::WorldEnterPlugin); app.insert_non_send_resource(recording_vm()); let body = ObjectFields::from_pairs(&[ (FIELD_UNIT_HEALTH, health), @@ -1632,70 +1478,6 @@ mod tests { } } -/// Run the death feed once on `world`, for a test of what it pushes. -#[cfg(test)] -pub(crate) fn run_feed_death_once(world: &mut World) { - use bevy::ecs::system::RunSystemOnce; - world - .run_system_once(feed_death) - .expect("the death feed runs"); -} - -/// The body's VM events between the last `(dead, ghost)` seen, if any, and this one. -fn fire_vm_edges(script: &mut UiScript, prev: Option<(bool, bool)>, dead: bool, ghost: bool) { - match (prev, dead, ghost) { - (Some((true, false)), d, g) if g || !d => { - // The health edge out of 0 (`0x6047f0`) unlocks every item (`0x5fefae`), then fires - // `PLAYER_ALIVE` (`0x5fefb8`). - script.unlock_all_items(); - script.fire_event("PLAYER_ALIVE", vec![]); - } - _ => {} - } -} - -#[cfg(test)] -mod edge_tests { - use benilla_ui::script::UiScript; - - /// The revive edge unlocks every item, its one `ITEM_LOCK_CHANGED` ahead of `PLAYER_ALIVE` - /// (`0x5fefae`, `0x5fefb8`); the ghost's own revive, no health edge, unlocks nothing. - #[test] - fn the_revive_edge_unlocks_every_item_before_player_alive() { - const ITEM: u64 = 0x4000_0000_0000_0042; - let mut s = UiScript::new().unwrap(); - s.run( - "SEEN = {} local f = CreateFrame('Frame') \ - f:RegisterEvent('ITEM_LOCK_CHANGED') f:RegisterEvent('PLAYER_ALIVE') \ - f:RegisterEvent('PLAYER_UNGHOST') \ - f:SetScript('OnEvent', function() table.insert(SEEN, event) end)", - ) - .unwrap(); - let seen = |s: &UiScript| { - let out = s.eval::>("return SEEN").unwrap(); - s.run("SEEN = {}").unwrap(); - out - }; - s.lock_item(ITEM); - let _ = seen(&s); - super::fire_vm_edges(&mut s, Some((true, false)), true, true); - assert_eq!( - seen(&s), - ["ITEM_LOCK_CHANGED", "PLAYER_ALIVE"], - "the release" - ); - assert!(!s.item_locked(ITEM)); - s.lock_item(ITEM); - let _ = seen(&s); - super::fire_vm_edges(&mut s, Some((true, true)), false, false); - assert!( - seen(&s).is_empty(), - "the corpse run's end: its event is the ghost bit's (`0x5de9c0`)" - ); - assert!(s.item_locked(ITEM)); - } -} - #[cfg(test)] mod self_res_tests { use std::collections::HashMap; diff --git a/crates/benilla-app/src/death/net.rs b/crates/benilla-app/src/death/net.rs index c196b42c0..42fb655cc 100644 --- a/crates/benilla-app/src/death/net.rs +++ b/crates/benilla-app/src/death/net.rs @@ -1,11 +1,15 @@ -//! The death packet handlers filling [`DeathNet`], the movement-mode forward for our own mover, -//! and the corpse-guid latch's hooks on the object lifecycle, called from the drain's object arms. +//! The death packet handlers filling [`DeathNet`], each signal they raise on the dialogs' lane at +//! the packet's place, the movement-mode forward for our own mover, and the corpse-guid latch's +//! hooks on the object lifecycle, called from the drain's object arms. use benilla_protocol::{EntityKind, MoveMode, ObjectFields, SessionEvent, SessionEventKind}; +use benilla_ui::script::ScriptValue; use bevy::prelude::*; -use super::{CorpsePoint, DeathNet, ResurrectOffer}; -use crate::net::{MoveModeMessage, NetHandlerApp, SelfGuid}; +use super::{CorpsePoint, DeathLatches, DeathNet, ResurrectOffer}; +use crate::net::{MoveModeMessage, NetHandlerApp, ObjectStore, SelfGuid, SelfPlayer}; +use crate::query_cache::Ask; +use crate::ui_dialog_verbs::DialogLane; /// Register the death handlers and the session-end listener. pub(super) fn register(app: &mut App) { @@ -19,7 +23,15 @@ pub(super) fn register(app: &mut App) { .net_handler(K::Disconnected, on_session_end); } -fn on_corpse_query(In(ev): In, mut death_net: ResMut) { +/// `MSG_CORPSE_QUERY`'s two arms of `0x48f690`: a found corpse fills the cache +/// (`0x48f7d1` → `0x492010`); a not-found resets it (`0x48f800`) and lowers the range latch +/// (`0x48f807` → `0x4920f0(0)`), whose `CORPSE_OUT_OF_RANGE` signals at the packet when it was set. +fn on_corpse_query( + In(ev): In, + mut death_net: ResMut, + mut latches: ResMut, + mut lane: ResMut, +) { if let SessionEvent::CorpseQuery { found, display_map, @@ -28,20 +40,43 @@ fn on_corpse_query(In(ev): In, mut death_net: ResMut) { } = ev { corpse_query(found, display_map, position, corpse_map, &mut death_net); + if !found { + if let Some(signal) = latches.set_in_range(false, None) { + signal.queue(&mut lane); + } + } } } +/// `SMSG_CORPSE_RECLAIM_DELAY` (`0x48f828` → `SetCorpseReclaimDelay 0x4962d0`): the delay stored, +/// then the in-range event again while the latch is set (`0x4962ec`-`0x49630d`), at the packet, so +/// `RECOVER_CORPSE` re-shows over the new delay. fn on_corpse_reclaim_delay( In(ev): In, mut death_net: ResMut, + latches: Res, + mut lane: ResMut, real_clock: Res>, ) { if let SessionEvent::CorpseReclaimDelay { delay_ms } = ev { corpse_reclaim_delay(delay_ms, real_clock.elapsed_secs_f64(), &mut death_net); + if latches.corpse_in_range { + super::CorpseSignal::in_range(death_net.corpse.as_ref()).queue(&mut lane); + } } } -fn on_resurrect_request(In(ev): In, mut death_net: ResMut) { +/// `ReadResurrectRequest 0x5e7bc0`: the offer stored (`0x5e7c13`-`0x5e7c2d`); with the active +/// player held (`0x5e7c4a`), a name on the wire shows it at once (`0x5e7c56`), else the caster's +/// name is looked up with the callback `0x5e7ca0` (`0x5e7c82`), a cached one showing it at once. +fn on_resurrect_request( + In(ev): In, + mut death_net: ResMut, + names: Res, + net: Res, + me: Query<&ObjectStore, With>, + mut lane: ResMut, +) { if let SessionEvent::ResurrectRequest { caster, name, @@ -49,13 +84,79 @@ fn on_resurrect_request(In(ev): In, mut death_net: ResMut show_resurrect_request(&me.0, &name, &mut lane), + None => { + if let Some(offer) = death_net.resurrect.as_mut() { + offer.waits_name = true; + } + } + } } } -fn on_spirit_healer_confirm(In(ev): In, mut death_net: ResMut) { +/// The callback `0x5e7ca0` for `guid`'s answer, the offer's caster whose name it waited on: a found +/// name shows the offer while the active player is held (`0x5e7d02` → `0x5e7d09`), a refused one +/// forgets it (`0x5e7d19`-`0x5e7d2b`). +pub(crate) fn resurrecter_named( + death_net: &mut DeathNet, + me: Option<&ObjectStore>, + lane: &mut DialogLane, + guid: u64, + name: Option<&str>, +) { + let Some(offer) = death_net + .resurrect + .as_mut() + .filter(|o| o.waits_name && o.caster == guid) + else { + return; + }; + offer.waits_name = false; + match name.filter(|n| !n.is_empty()) { + Some(name) => { + if let Some(me) = me { + show_resurrect_request(&me.0, name, lane); + } + } + None => death_net.resurrect = None, + } +} + +/// `ShowResurrectRequest 0x5ded50`: `RESURRECT_REQUEST` with a non-empty `name` (`0x5ded5b`) +/// while the active player is dead or a ghost (`0x5ded60` → `0x605f30`). +fn show_resurrect_request(me: &ObjectFields, name: &str, lane: &mut DialogLane) { + if !name.is_empty() && me.is_dead_or_ghost() { + lane.event( + "RESURRECT_REQUEST", + vec![ScriptValue::Str(name.to_string())], + ); + } +} + +/// `SMSG_SPIRIT_HEALER_CONFIRM`'s arm of the notice handler (`0x5e38c0` → `0x5df730`): the +/// healer's gossip re-sends it on every ask, and each that passes the ask's gates signals at its +/// packet. +fn on_spirit_healer_confirm( + In(ev): In, + mut ask: super::SpiritHealerAsk, + mut lane: ResMut, +) { if let SessionEvent::SpiritHealerConfirm { npc } = ev { - spirit_healer_confirm(npc, &mut death_net); + if let Some(cost) = ask.ask(npc) { + lane.event("CONFIRM_XP_LOSS", vec![ScriptValue::Int(cost)]); + } } } @@ -90,9 +191,15 @@ fn on_move_mode( } } -/// The death stores are session-scoped; a reconnect while dead re-sends the reclaim delay. -fn on_session_end(In(_): In, mut death_net: ResMut) { +/// The death stores and latches are session-scoped; a reconnect while dead re-sends the reclaim +/// delay, and a relog as a ghost must find no mirror, or the corpse query is never re-sent. +pub(super) fn on_session_end( + In(_): In, + mut death_net: ResMut, + mut latches: ResMut, +) { *death_net = DeathNet::default(); + *latches = DeathLatches::default(); } /// Our corpse streaming in: latch its guid for the reclaim send. The reference's latch @@ -161,11 +268,9 @@ fn corpse_query( }); } -/// `SMSG_CORPSE_RECLAIM_DELAY`, anchored at arrival on the clock the feed reads. The 1.12 client -/// re-fires the corpse-range events on each (`0x4962d0`), hence the generation bump. +/// `SMSG_CORPSE_RECLAIM_DELAY`, anchored at arrival on the clock the getters read. fn corpse_reclaim_delay(delay_ms: u32, now_secs: f64, death_net: &mut DeathNet) { death_net.reclaim_at = Some(now_secs + f64::from(delay_ms) / 1000.0); - death_net.reclaim_generation = death_net.reclaim_generation.wrapping_add(1); } /// `SMSG_RESURRECT_REQUEST`, the RESURRECT popup's data. @@ -181,20 +286,8 @@ fn resurrect_request( name, sickness, has_timer, + waits_name: false, }); - death_net.resurrect_generation = death_net.resurrect_generation.wrapping_add(1); -} - -/// A player caster's offer, its name empty on the wire, as [`resurrect_request`] records it. -#[cfg(test)] -pub(super) fn resurrect_request_for_tests(caster: u64, death_net: &mut DeathNet) { - resurrect_request(caster, String::new(), false, true, death_net); -} - -/// `SMSG_SPIRIT_HEALER_CONFIRM`: the healer's gossip re-sends it on every ask, and the reference -/// fires `CONFIRM_XP_LOSS` per arrival. -fn spirit_healer_confirm(npc: u64, death_net: &mut DeathNet) { - death_net.ask_spirit_healer(npc); } /// `SMSG_DURABILITY_DAMAGE_DEATH`, the 10% death durability loss: a combat-log line at chat type diff --git a/crates/benilla-app/src/field_watch.rs b/crates/benilla-app/src/field_watch.rs index 76478951d..6ed03ad5a 100644 --- a/crates/benilla-app/src/field_watch.rs +++ b/crates/benilla-app/src/field_watch.rs @@ -182,6 +182,13 @@ pub(crate) enum FieldNotice { /// VM's statics store the point, then `MINIMAP_PING` with the token the packet resolved /// (`0x4ee48d`). MinimapPing(crate::minimap::MemberPing), + /// The health watcher's revive arm on the active player (`0x6047ee` → `0x5fef70`): every item + /// unlocked with its one `ITEM_LOCK_CHANGED` (`0x5fefae` → `0x495460`), then `PLAYER_ALIVE` + /// (274, `0x5fefb8`). + Revived, + /// A packet handler's `DisplayError(id)` (`0x496720`): the message row's line, by its + /// `GlobalStrings` key, shown at once. + Line { key: &'static str }, } /// The notice lane: each notice stamped as a handler writes it ([`crate::lanes::stamp`]), fired @@ -305,6 +312,9 @@ pub(crate) mod id { pub(crate) const PET_BAR_UPDATE: u16 = 353; pub(crate) const AREA_SPIRIT_HEALER_IN_RANGE: u16 = 527; pub(crate) const AREA_SPIRIT_HEALER_OUT_OF_RANGE: u16 = 528; + pub(crate) const PLAYER_CAMPING: u16 = 276; + pub(crate) const PLAYER_QUITING: u16 = 277; + pub(crate) const LOGOUT_CANCEL: u16 = 278; } /// `CGPlayer_C::RefreshGuildTag` (`0x5e08e0`) on the player `guid`: `TABARD_CANSAVE_CHANGED` bare @@ -788,6 +798,17 @@ pub(crate) fn placed_values( // The unit type watchers (`0x6041f0`), on every unit. let mine = around.me == Some(guid); + // The health watcher's revive arm (`0x6047ee`-`0x6047f4`, a health of 0 or less rising above + // it) for the active player (`0x5fef9f`): `0x5fef70`'s unlock and `PLAYER_ALIVE`, ahead of the + // watcher's usable refresh. + if let Some(at) = at(UNIT_SECTION, HEALTH, List::Type).filter(|_| mine) { + let rose = block + .edge(UNIT_SECTION + HEALTH.0 / 4) + .is_some_and(|(old, new)| old as i32 <= 0 && new as i32 > 0); + if rose { + pass.push(at, FieldNotice::Revived); + } + } // The health's and the powers' for the active player (`0x60483c`, `0x604868`), the aura // state's for it or the target (`0x604898`-`0x6048b4`). for (range, runs) in [ @@ -2435,8 +2456,13 @@ mod tests { let mut me = player(); assert_eq!( block(&mut me, Some(ME), ME, &[(22, 90)]), + [FieldNotice::Revived, R, bridge(ME, 16)], + "the health, out of none: the revive arm runs first (`0x6047ee`)" + ); + assert_eq!( + block(&mut me, Some(ME), ME, &[(22, 80)]), [R, bridge(ME, 16)], - "the health" + "the health, alive" ); assert_eq!( block(&mut me, Some(ME), ME, &[(23, 480)]), diff --git a/crates/benilla-app/src/game_plugins.rs b/crates/benilla-app/src/game_plugins.rs index fefbf593b..2e857307d 100644 --- a/crates/benilla-app/src/game_plugins.rs +++ b/crates/benilla-app/src/game_plugins.rs @@ -1777,9 +1777,6 @@ pub(crate) mod schedule_tests { enum Because { /// The consumed queue is filled only by Lua asking; a frameless VM asks for nothing. FilledByVm, - /// Filled only by a server reply to a click in the interface, or (noted in the reason) - /// another player's act on us, which meets the login burst only by coincidence. - PlayerRoundTrip, /// Consumed in the window or not, the state is re-asked or re-derived once the UI is up. SelfHealing, /// The publication is driven by a `VmMemo` diff, so a new VM re-derives and re-fires it. @@ -1799,10 +1796,10 @@ pub(crate) mod schedule_tests { "the drag probe: dev-only (`WOW_PROBE_DRAG`), it starts past `WOW_PROBE_DRAG_AT` with the \ player's body in the world, and its `.drain(..)` is of the VM's own script errors, \ raised by the gesture it just made"), - ("death/mod.rs", "feed_death", Because::MemoLatched, - "`feed.vm: VmMemo`: a fresh memo takes the first snapshot as no edge and re-announces a held offer, confirm and corpse range, and skips the edges of our create's frame, whose arrival item signals the state itself"), - ("death/mod.rs", "signal", Because::MemoLatched, - "the death state's signal: our death's leg (`signal_death`), run in its packet with the VM deferred, its `PLAYER_DEAD` parked for the deaths lane, whose drain runs only with the interface up (`ingame_ui_up`); and an arrival's, run by the arrival lane's firing inside the lanes' drain, which runs only with the interface up (`ingame_ui_up`). Its memo is `feed.vm`, a `VmMemo`"), + ("death/mod.rs", "signal", Because::Deliberate, + "the death state's signal: our death's leg (`signal_death`), run in its packet with the VM deferred, its `PLAYER_DEAD` parked for the deaths lane, whose drain runs only with the interface up (`ingame_ui_up`); and an arrival's, run by the arrival lane's firing inside the lanes' drain, which runs only with the interface up (`ingame_ui_up`)"), + ("death/mod.rs", "ask_spirit_healer", Because::Deliberate, + "no system: the spirit healer click's world edit runs it, inside the input pass's click legs, with the interface up"), ("death/mod.rs", "query_corpse_on_world_enter", Because::Deliberate, "no system: a leg the arrival lane's firing runs, inside the drain, which runs only with the interface up; its take is the range latch, which it zeroes into the live VM"), ("net/objects/update.rs", "on_update_end", Because::Deliberate, @@ -1828,8 +1825,6 @@ pub(crate) mod schedule_tests { "`feed.vm: VmMemo`; a fresh VM re-fires BEGIN for a follow in progress"), ("ui_guild/lane.rs", "fire_guild", Because::Deliberate, "a lane's firing, run only by the drain, which runs only with the interface up (`ingame_ui_up`): the lane holds what the packets queue until a drain fires it, so the login's message of the day, which lands ahead of the interface, fires into the VM that comes up"), - ("ui_logout.rs", "feed_logout", Because::PlayerRoundTrip, - "both packets answer the `CMSG_LOGOUT_REQUEST`/cancel the game menu sent"), ("ui_loot/mod.rs", "drain_loot", Because::Deliberate, "its takes of `LootMoveStart` and `LootCloseAtRest` close on the engine's side and publish nothing to the VM, whose `LOOT_CLOSED` is the loot lane's; the at-rest sweep signals only on a disenchant window, which the interface's own cast opens"), ("ui_macro/mod.rs", "load_macros", Because::MemoLatched, diff --git a/crates/benilla-app/src/lanes.rs b/crates/benilla-app/src/lanes.rs index c79747d09..1e2e94389 100644 --- a/crates/benilla-app/src/lanes.rs +++ b/crates/benilla-app/src/lanes.rs @@ -535,6 +535,8 @@ mod close_parked_tests; #[cfg(test)] mod cooldown_live_tests; #[cfg(test)] +mod death_live_tests; +#[cfg(test)] mod dialog_live_tests; #[cfg(test)] mod duration_live_tests; @@ -561,6 +563,8 @@ mod item_tests; #[cfg(test)] mod item_text_live_tests; #[cfg(test)] +mod logout_live_tests; +#[cfg(test)] mod loot_live_tests; #[cfg(test)] mod loot_roll_live_tests; diff --git a/crates/benilla-app/src/lanes/arrival_live_tests.rs b/crates/benilla-app/src/lanes/arrival_live_tests.rs index a0b1c61c9..3f0ae6db8 100644 --- a/crates/benilla-app/src/lanes/arrival_live_tests.rs +++ b/crates/benilla-app/src/lanes/arrival_live_tests.rs @@ -958,7 +958,7 @@ fn the_cascades_corpse_step_signals_the_range_latch_out() { ); c.app .world_mut() - .resource_mut::() + .resource_mut::() .latch_corpse_in_range_for_test(); c.frame(vec![vec![me()]]); c.frame(vec![]); diff --git a/crates/benilla-app/src/lanes/death_live_tests.rs b/crates/benilla-app/src/lanes/death_live_tests.rs new file mode 100644 index 000000000..f35ef661e --- /dev/null +++ b/crates/benilla-app/src/lanes/death_live_tests.rs @@ -0,0 +1,175 @@ +//! The death getters as a listener reads them, and the death signals at their packets. The +//! getters read the interface's death globals at the call (`GetCorpseRecoveryDelay` `0x48b5d0`); +//! the resurrect offer shows inside its packet or its caster's name answer (`0x5e7bc0`, +//! `0x5e7ca0` → `0x5ded50`), the revive's `PLAYER_ALIVE` inside the health watcher's run +//! (`0x6047ee` → `0x5fef70`), and the reclaim delay's range event inside its handler (`0x4962d0`). + +use benilla_protocol::SessionEvent; +use benilla_ui::script::UiScript; +use bevy::prelude::*; + +use super::unit_view_tests::{client, created, fall, frame, health, values}; + +/// [`client`]'s active player. +const ME: u64 = 0x7; +/// A fall's `UNIT_COMBAT` on our dead body, as [`client`]'s spy records it. +const FELL: &str = "UNIT_COMBAT:player:0"; +const PRIEST: u64 = 0x51; + +/// [`client`] with a spy on the death signals, each with what its listener reads: the offer's +/// name and timer, the corpse's delay. +fn death_client() -> App { + let mut app = client(); + app.world_mut() + .non_send_resource_mut::() + .run( + r#" + local f = CreateFrame("Frame") + for _, e in ipairs({"RESURRECT_REQUEST", "PLAYER_ALIVE", "CORPSE_IN_RANGE", + "CONFIRM_XP_LOSS"}) do + f:RegisterEvent(e) + end + f:SetScript("OnEvent", function() + if event == "RESURRECT_REQUEST" then + table.insert(Seen, event .. ":" .. arg1 .. ":" .. tostring(ResurrectHasTimer())) + elseif event == "CORPSE_IN_RANGE" then + table.insert(Seen, event .. ":" .. GetCorpseRecoveryDelay()) + else + table.insert(Seen, event) + end + end) + "#, + ) + .unwrap(); + app +} + +/// [`death_client`] after our death's packet, the frame's signals taken. +fn dead_client() -> App { + let mut app = death_client(); + frame(&mut app, vec![values(ME, &health(0))]); + app +} + +fn offer(name: &str) -> SessionEvent { + SessionEvent::ResurrectRequest { + caster: PRIEST, + name: name.into(), + sickness: false, + has_timer: true, + } +} + +/// With no frame after the reclaim delay's packet, `GetCorpseRecoveryDelay` reads the delay +/// through the host; the VM's copy, which nothing pushes, reads none. +#[test] +fn the_recovery_delay_reads_the_stores_at_the_call() { + let mut app = dead_client(); + crate::net::handlers::dispatch( + app.world_mut(), + vec![SessionEvent::CorpseReclaimDelay { delay_ms: 30_000 }], + ); + let chunk = "return GetCorpseRecoveryDelay()"; + let live: f64 = crate::script_calls::with_hosted_vm(app.world_mut(), |s| { + s.expect("a VM").eval(chunk).expect("runs") + }); + assert!((29.0..=30.0).contains(&live), "{live}"); + let copy: f64 = crate::script_calls::eval_in_vm(app.world(), chunk); + assert_eq!(copy, 0.0); +} + +/// An offer with its caster's name on the wire signals at its packet's place, between a fall's +/// `UNIT_COMBAT` on each side, its listener reading the offer's timer. +#[test] +fn resurrect_request_fires_between_neighbouring_packets_events() { + let mut app = dead_client(); + let seen = frame(&mut app, vec![fall(5), offer("Bob"), fall(5)]); + assert_eq!(seen, [FELL, "RESURRECT_REQUEST:Bob:1", FELL]); +} + +/// A player caster's offer waits on the name its packet asked (`0x5e7c82`): nothing at the offer, +/// then the show inside the name answer's packet. +#[test] +fn a_player_casters_offer_shows_at_its_name_answer() { + let mut app = dead_client(); + assert!(frame(&mut app, vec![offer("")]).is_empty()); + let named = SessionEvent::PlayerName { + guid: PRIEST, + name: "Ann".into(), + race: 1, + gender: 0, + class: 5, + }; + let seen = frame(&mut app, vec![fall(5), named, fall(5)]); + assert_eq!(seen, [FELL, "RESURRECT_REQUEST:Ann:1", FELL]); +} + +/// The revive's health rising above 0 runs the watcher's arm inside its packet: `PLAYER_ALIVE`, +/// then the bridge's `UNIT_HEALTH`, between the falls around it. +#[test] +fn player_alive_fires_at_the_revives_packet() { + let mut app = dead_client(); + let seen = frame(&mut app, vec![fall(5), values(ME, &health(1)), fall(5)]); + assert_eq!( + seen, + [ + FELL, + "PLAYER_ALIVE", + "UNIT_HEALTH:player:1", + "UNIT_COMBAT:player:1" + ] + ); +} + +/// A reclaim delay while the range latch is set signals the in-range event again at its packet, +/// its listener reading the new delay (`0x4962da`, `0x49630d`). +#[test] +fn a_reclaim_delay_in_range_signals_at_its_packet() { + let mut app = dead_client(); + app.world_mut() + .resource_mut::() + .latch_corpse_in_range_for_test(); + let delay = SessionEvent::CorpseReclaimDelay { delay_ms: 30_000 }; + let seen = frame(&mut app, vec![fall(5), delay, fall(5)]); + assert_eq!(seen.len(), 3, "{seen:?}"); + assert_eq!((seen[0].as_str(), seen[2].as_str()), (FELL, FELL)); + let read: f64 = seen[1] + .strip_prefix("CORPSE_IN_RANGE:") + .and_then(|d| d.parse().ok()) + .unwrap_or_else(|| panic!("{seen:?}")); + assert!((29.0..=30.0).contains(&read), "{read}"); +} + +/// A spirit healer's confirm signals `CONFIRM_XP_LOSS` at its packet's place for a ghost with the +/// healer in reach (`0x5df74a`, `0x5df7c1`, `0x5df837`), and nothing for the living. +#[test] +fn confirm_xp_loss_fires_at_its_packet_for_a_ghost_in_reach() { + use benilla_protocol::field::{FIELD_PLAYER_FLAGS, FIELD_UNIT_HEALTH, FIELD_UNIT_MAXHEALTH}; + const HEALER: u64 = 0xF130_0000_1772_0050; + let confirm = || SessionEvent::SpiritHealerConfirm { npc: HEALER }; + let mut app = death_client(); + let healer = created( + HEALER, + benilla_protocol::EntityKind::Unit, + &[(FIELD_UNIT_HEALTH, 100), (FIELD_UNIT_MAXHEALTH, 100)], + ); + frame(&mut app, vec![healer]); + let alive = "UNIT_COMBAT:player:100"; + assert_eq!( + frame(&mut app, vec![fall(5), confirm(), fall(5)]), + [alive, alive], + "alive: no question" + ); + frame( + &mut app, + vec![values( + ME, + &[(FIELD_UNIT_HEALTH, 1), (FIELD_PLAYER_FLAGS, 0x10)], + )], + ); + let ghost = "UNIT_COMBAT:player:1"; + assert_eq!( + frame(&mut app, vec![fall(5), confirm(), fall(5)]), + [ghost, "CONFIRM_XP_LOSS", ghost] + ); +} diff --git a/crates/benilla-app/src/lanes/guard_tests.rs b/crates/benilla-app/src/lanes/guard_tests.rs index a46559c04..7ae04a525 100644 --- a/crates/benilla-app/src/lanes/guard_tests.rs +++ b/crates/benilla-app/src/lanes/guard_tests.rs @@ -90,23 +90,12 @@ pub(super) const NOT_YET_ON_A_LANE: &[(Row, &str, &str)] = &[ "the action slots, which `feed_actions` resolves; a handler's Lua writes them in its \ call, through the host's bar verbs", ), - ( - Row::HostHeld, - "::ui_logout::LogoutState", - "the logout state, which `feed_logout` fires from; the session verbs, acting in their \ - calls, hold it in the host", - ), ( Row::Queue, "::ui_logout::SessionPosts", "the exit and the cinematic stop a session verb posts, which nothing the script reads \ waits on", ), - ( - Row::HostHeld, - "::death::DeathNet", - "the death stores, which `feed_death` fires the offers and the corpse range from; the death verbs, acting in their calls, hold them in the host", - ), ( Row::HostHeld, "::items::Items", @@ -306,6 +295,19 @@ pub(super) const HOST_HELD_UNREAD: &[&str] = &[ // the world frame's update, after the packets. `feed_interact_npc` copies it as // `InteractNpc` right after the dispatch, for the engine's own token reads. "::ui_session::latch::InteractLatch", + // Moved here from `NOT_YET_ON_A_LANE`, so neither list grew: the session verbs read and write + // the logout bytes through the host in their calls, and quiet: the replies' handlers signal on + // the notice lane at their packets. + "::ui_logout::LogoutState", + // Quiet: the connection's state, which the session's handlers write and the death getters' + // body test reads through the host; no feed fires off it. + "::net::NetStatus", + // Moved here from `NOT_YET_ON_A_LANE`, so neither list grew: the death getters read the stores + // through the host and the death verbs hold them in their calls, and quiet: the offers and the + // corpse-range signals packets raise go on the dialogs' lane at their handlers, the revive's + // on the notice lane, and the corpse poll runs in the world frame's update, after the packets + // (`0x4818c5`). + "::death::DeathNet", // Read through the host by the taxi getters, and quiet: its events fire on the taxi lane at // their handlers. "::ui_taxi::TaxiState", @@ -360,14 +362,10 @@ pub(super) const READS_FRAME_FINAL: &[(&str, &[&str])] = &[ // `SetCVar` moves it inside its call, and the build reads it as the frame left it. "video::Widescreen"]), - ("::death::feed_death", &["Transform", "death::DeathNet", "items::Countdowns", "items::Items", - "names::NameCache", "net::GuidIndex", "net::NetStatus", "net::ObjectStore", - "net::SelfGuid"]), // The group's push, the party and raid getters' no-host fallback: the roster's cells, its // members' names and objects as the frame left them; the tokens read live at the call. ("::ui_party::feed::feed_party", &["names::NameCache", "net::GuidIndex", "net::ObjectStore", "ui_party::GroupState"]), - ("::ui_logout::feed_logout", &["ui_logout::LogoutState"]), // The engine's follow transitions, which a `FollowUnit` a handler's listener makes arms. ("::ui_follow::feed_follow", &["player::follow::FollowState", "ui_follow::FollowFeed"]), // The ammo getters' hits fire after the push that carries their record, whenever it runs. @@ -403,7 +401,6 @@ pub(super) const READS_FRAME_FINAL: &[(&str, &[&str])] = &[ ("::ui_items::locks::forget_gone_item_locks", &["net::GuidIndex"]), ("::ui_items::feed::feed_item_stats", &["items::Items", "net::HomeBind", "net::ObjectStore", "spell::mods::SpellModifiers"]), - ("::ui_taxi::feed_on_taxi", &["net::ObjectStore"]), // The getters' item callbacks, kept inside their calls, are spent as the frame left them. ("::ui_tradeskill::feed_trade_skill", &["items::Countdowns", "items::Items", "net::GuidIndex", "net::ObjectStore", "spell::cooldowns::Cooldowns", "ui_action::PlayerActions", @@ -472,6 +469,13 @@ pub(super) const READ_ONLY_TO_HANDLERS: &[&str] = &[ "::ui_items::ItemBagFamilies", // `AuctionHouse.dbc`, whose deposit rate the hello's show hands the VM. "::ui_auction::AuctionHouses", + // The corpse-range latch, which the reclaim delay's handler tests to signal again + // (`0x4962ec`); the corpse query's not-found handler and the corpse poll write it through + // their own `ResMut`. + "::death::DeathLatches", + // The connection's state, which the death getters' body test reads through the host; the + // socket's handlers write it through their own `ResMut`. + "::net::NetStatus", // The login pick, which names the character the account-data sections belong to. "::glue_session::roster::Roster", // `0xb4e314`, which the party snapshot reads; only the zone feed commits it. @@ -1776,9 +1780,8 @@ pub(super) const LANE_READS_FRAME_FINAL: &[(&str, &[&str])] = &[ ("chat setup arrivals", &["ui_chat::edit::ChannelState"]), // Our arrival's legs read and reset what later packets of its frame write, as the frame left // it: the book the replay learns, the battlefield and stone it resets and asks again for, the - // death stores its death state reads and its corpse ask resets, the class family it sets and - // the connection the clock resync asks through. - ("arrival", &["chat_bubble::BubbleConfig", "death::DeathNet", "net::NetStatus", + // corpse-range latch its corpse ask lowers, and the class family it sets. + ("arrival", &["chat_bubble::BubbleConfig", "death::DeathLatches", "spell::mods::SpellModifiers", "ui_action::PlayerActions", "ui_battlefield::Battlefield", "ui_dialog_verbs::MeetingStone"]), diff --git a/crates/benilla-app/src/lanes/host_read_tests.rs b/crates/benilla-app/src/lanes/host_read_tests.rs index 05778acb1..de4af5470 100644 --- a/crates/benilla-app/src/lanes/host_read_tests.rs +++ b/crates/benilla-app/src/lanes/host_read_tests.rs @@ -43,8 +43,8 @@ use crate::game_plugins::schedule_tests::{census, type_names_available, SyncPoin /// The most rows [`super::guard_tests::READS_FRAME_FINAL`] may hold, and the most inputs across /// them: each only falls, so lower it when a row or an input goes. -const FRAME_FINAL_FEEDS: usize = 17; -const FRAME_FINAL_INPUTS: usize = 106; +const FRAME_FINAL_FEEDS: usize = 15; +const FRAME_FINAL_INPUTS: usize = 98; /// The systems that may run after the dispatch (`apply_net_updates`) and run ahead of the drain /// (`fire_in_order`), by a suffix of the system's name, with what each writes of the state a @@ -100,9 +100,6 @@ const BETWEEN_THE_DISPATCH_AND_THE_DRAIN: &[(&str, &[&str], &str)] = &[ ("::ui_item_text::apply_reads", &["ui_item_text::ItemTextOpen"], "a click's or a bag use's read, queued in its input or its call, which the reference \ opens inside them (`0x5f58c0`, `0x4e32e0`), ahead of the packets (`0x420d23`)"), - ("::ui_logout::feed_logout", &["ui_logout::LogoutState"], - "fires and clears the signals the logout replies queue, which the session verbs read in \ - their calls, where the reference's handlers signal in place (`0x5aaef0`, `0x5aaf60`)"), ("::ui_macro::load_macros", &["ui_action::ActionSlots"], "the macro reader (`LoadMacroFiles` `0x4f0600`), run as its sections settle, moves a \ character's buttons off benilla's older numbering through the bar verbs, a move with no \ diff --git a/crates/benilla-app/src/lanes/logout_live_tests.rs b/crates/benilla-app/src/lanes/logout_live_tests.rs new file mode 100644 index 000000000..11869cf9e --- /dev/null +++ b/crates/benilla-app/src/lanes/logout_live_tests.rs @@ -0,0 +1,83 @@ +//! The logout replies' signals at their packets. `SMSG_LOGOUT_RESPONSE`'s handler signals +//! `PLAYER_CAMPING` or `PLAYER_QUITING` in place (`0x5aaef0`, `0x5aaf17`), and +//! `SMSG_LOGOUT_CANCEL_ACK`'s `LOGOUT_CANCEL` while a request is pending (`0x5aaf60`, `0x5aaf72`), +//! so each fires between the events of the packets around it. + +use benilla_protocol::SessionEvent; +use benilla_ui::script::UiScript; +use bevy::prelude::*; + +use super::unit_view_tests::{client, fall, frame}; + +/// A fall's `UNIT_COMBAT`, as [`client`]'s spy records it. +const FELL: &str = "UNIT_COMBAT:player:100"; + +/// [`client`] with the world handle seated, a write channel kept, and a spy on the logout +/// signals. +fn logout_client() -> (App, crossbeam_channel::Receiver) { + let mut app = client(); + let (tx, rx) = crossbeam_channel::unbounded(); + app.insert_resource(crate::net::NetCommands(tx)); + app.world_mut() + .resource_mut::() + .seat_world_handle_for_test(); + app.world_mut() + .non_send_resource_mut::() + .run( + r#" + local f = CreateFrame("Frame") + for _, e in ipairs({"PLAYER_CAMPING", "PLAYER_QUITING", "LOGOUT_CANCEL"}) do + f:RegisterEvent(e) + end + f:SetScript("OnEvent", function() table.insert(Seen, event) end) + "#, + ) + .unwrap(); + (app, rx) +} + +/// Run `chunk` with the host lent. +fn run(app: &mut App, chunk: &str) { + crate::script_calls::with_hosted_vm(app.world_mut(), |s| s.expect("a VM").run(chunk)) + .expect("runs"); +} + +/// The response's `PLAYER_CAMPING` fires at its packet's place, between a fall's `UNIT_COMBAT` on +/// each side. +#[test] +fn player_camping_fires_between_neighbouring_packets_events() { + let (mut app, _rx) = logout_client(); + run(&mut app, "Logout()"); + let response = SessionEvent::LogoutResponse { + reason: 0, + instant: false, + }; + let seen = frame(&mut app, vec![fall(5), response, fall(5)]); + assert_eq!(seen, [FELL, "PLAYER_CAMPING", FELL]); +} + +/// A quit's response signals `PLAYER_QUITING` at its packet, the quit byte its request stored +/// (`0x5ab053`) added to the id (`0x5aaf0c`). +#[test] +fn player_quiting_fires_at_its_packet() { + let (mut app, _rx) = logout_client(); + run(&mut app, "Quit()"); + let response = SessionEvent::LogoutResponse { + reason: 0, + instant: false, + }; + let seen = frame(&mut app, vec![fall(5), response, fall(5)]); + assert_eq!(seen, [FELL, "PLAYER_QUITING", FELL]); +} + +/// A cancel ack while a request is pending signals `LOGOUT_CANCEL` at its packet. +#[test] +fn logout_cancel_fires_at_the_acks_packet() { + let (mut app, _rx) = logout_client(); + run(&mut app, "Logout()"); + let seen = frame( + &mut app, + vec![fall(5), SessionEvent::LogoutCancelled, fall(5)], + ); + assert_eq!(seen, [FELL, "LOGOUT_CANCEL", FELL]); +} diff --git a/crates/benilla-app/src/net/io/fake.rs b/crates/benilla-app/src/net/io/fake.rs index 3977a4523..db401b7f6 100644 --- a/crates/benilla-app/src/net/io/fake.rs +++ b/crates/benilla-app/src/net/io/fake.rs @@ -681,13 +681,18 @@ pub(crate) fn world(listener: TcpListener, keys: Receiver) -> World { let Some(key) = last else { return; }; - // Held and counted before the client can see the session open, so a drop never misses - // it and `open` never reads behind the client's authentication. + // Held, counted and logged before the client can see the session open, so a drop never + // misses it and neither `open` nor `authentications` reads behind its authentication. if let Ok(link) = s.try_clone() { link_log.lock().unwrap().push(link); } let sessions = Arc::clone(&sessions); sessions.fetch_add(1, Ordering::SeqCst); + let index = { + let mut all = session_log.lock().unwrap(); + all.push(Vec::new()); + all.len() - 1 + }; let mut crypto = HeaderCrypto::from_session_key(key); let reply = addon_reply.lock().unwrap().clone(); if let Some((body, false)) = &reply { @@ -723,11 +728,6 @@ pub(crate) fn world(listener: TcpListener, keys: Receiver) -> World { let refuse_flag = Arc::clone(&refuse_flag); let refuse_wait = Arc::clone(&refuse_wait); let trailing = Arc::clone(&trailing); - let index = { - let mut all = session_log.lock().unwrap(); - all.push(Vec::new()); - all.len() - 1 - }; thread::spawn(move || { while let Some(packet) = recv_packet(&mut s, Some(&mut crypto)) { let op = u16::from_le_bytes([packet[2], packet[3]]); diff --git a/crates/benilla-app/src/script_calls.rs b/crates/benilla-app/src/script_calls.rs index 8af223127..da6047263 100644 --- a/crates/benilla-app/src/script_calls.rs +++ b/crates/benilla-app/src/script_calls.rs @@ -3574,16 +3574,75 @@ mod tests { assert!(script.cursor_item().is_none()); } - /// A taxi passenger has no control but passes the gate (`0x494ba6`-`0x494ba9`). + /// `PickupContainerItem`'s control gate reads our taxi flag off the object as the call runs + /// (`0x4f9b87`-`0x4f9ba3`, the pair `0x494b97`-`0x494ba6` tests): without control, the store's + /// bit, written after every push, admits the pickup, and once cleared the next call is refused, + /// whatever the VM's copy says. + #[test] + fn the_pickup_gate_reads_the_taxi_flag_off_our_object_at_the_call() { + let mut f = frame(false); + with_bar_helm(&mut f, 0); + f.app + .world_mut() + .non_send_resource_mut::() + .set_player_control(false); + let me = f.app.world().resource::().0[&ME]; + let flags = |f: &mut Frame, flags: u32| { + f.app + .world_mut() + .get_mut::(me) + .expect("our store") + .0 + .merge(benilla_protocol::ObjectFields::from_pairs(&[(46, flags)])); + }; + flags(&mut f, 0x8 | crate::player::UNIT_FLAG_TAXI_FLIGHT); + run(&mut f, "PickupContainerItem(0, 1)"); + assert!( + f.app + .world() + .non_send_resource::() + .cursor_item() + .is_some(), + "on a taxi: picked up" + ); + run(&mut f, "ClearCursor()"); + flags(&mut f, 0x8); + f.app + .world_mut() + .non_send_resource_mut::() + .set_on_taxi(true); + run(&mut f, "PickupContainerItem(0, 1)"); + assert!( + f.app + .world() + .non_send_resource::() + .cursor_item() + .is_none(), + "landed: refused, the VM's copy unread" + ); + } + + /// A taxi passenger has no control but passes the gate, which reads the flag off our object at + /// the call (`0x494b97`-`0x494ba9`): the store's bit, set after every push, passes it, and the + /// VM's copy says nothing while the host is lent. #[test] fn a_bar_equip_on_a_taxi_passes_the_control_gate() { let mut f = frame(false); with_bar_helm(&mut f, 0); - { - let mut script = f.app.world_mut().non_send_resource_mut::(); - script.set_player_control(false); - script.set_on_taxi(true); - } + f.app + .world_mut() + .non_send_resource_mut::() + .set_player_control(false); + let me = f.app.world().resource::().0[&ME]; + f.app + .world_mut() + .get_mut::(me) + .expect("our store") + .0 + .merge(benilla_protocol::ObjectFields::from_pairs(&[( + 46, + 0x8 | crate::player::UNIT_FLAG_TAXI_FLIGHT, + )])); run(&mut f, "UseAction(1, 0)"); let sent: Vec<_> = f.rx.try_iter().collect(); assert!( @@ -4691,14 +4750,14 @@ mod tests { ); let (writers, unhosted) = vm_writers_and_the_unhosted(&mut app); // The census reads the client's systems: a hundred writers at least in either build, and - // where the build carries type names, a feed, a death feed and a frame poll among them. + // where the build carries type names, a feed and two frame polls among them. assert!( writers.len() >= 100, "the census reads the client's VM writers: {} read", writers.len() ); if writers.iter().any(|w| w.contains("benilla_app::")) { - for name in ["feed_logout", "feed_death", "poll_area_spirit_healer"] { + for name in ["feed_framerate", "poll_corpse", "poll_area_spirit_healer"] { assert!( writers.iter().any(|w| w.contains(name)), "the census reads the client's VM writers, `{name}` among them" diff --git a/crates/benilla-app/src/script_calls/live.rs b/crates/benilla-app/src/script_calls/live.rs index 0dd09a0ed..9872f531d 100644 --- a/crates/benilla-app/src/script_calls/live.rs +++ b/crates/benilla-app/src/script_calls/live.rs @@ -146,6 +146,9 @@ live_reads! { loot: crate::ui_loot::LootLive<'static, 'static>, /// The listed group loot rolls, their items' records and the clock their bars read. loot_rolls: crate::ui_loot_roll::LootRollLive<'static>, + /// The death stores' timers, the offer, the healer's range and the self-res; absent in a + /// harness without the death stores. + death: Option>, /// The game clock's hour and minute. game_time: crate::net::GameTimeLive<'static>, /// The joined-channel slot array. diff --git a/crates/benilla-app/src/script_calls/tests/dialogs.rs b/crates/benilla-app/src/script_calls/tests/dialogs.rs index 75c9d1f43..f18a1782e 100644 --- a/crates/benilla-app/src/script_calls/tests/dialogs.rs +++ b/crates/benilla-app/src/script_calls/tests/dialogs.rs @@ -269,6 +269,7 @@ fn the_death_verbs_send_inside_their_calls() { name: "Priest".into(), sickness: false, has_timer: false, + waits_name: false, }); } eval::<()>( @@ -303,7 +304,7 @@ fn accept_xp_loss_sends_inside_its_call_within_range() { unit_at(&mut app, HEALER, yards); app.world_mut() .resource_mut::() - .ask_spirit_healer(HEALER); + .spirit_healer = Some(HEALER); eval::<()>(&mut app, "AcceptXPLoss() RandomRoll(1, 2) AcceptXPLoss()"); let expected: &[&str] = if sends { &[ diff --git a/crates/benilla-app/src/target/click.rs b/crates/benilla-app/src/target/click.rs index 1571bf8c8..05a1948a9 100644 --- a/crates/benilla-app/src/target/click.rs +++ b/crates/benilla-app/src/target/click.rs @@ -308,7 +308,6 @@ fn click_select( pub(crate) struct ServiceArms<'w> { /// The last `SMSG_QUESTGIVER_STATUS` per guid (`[unit+0xcb8]`), read by bit 1's `0x5df490`. pub(crate) quest: Res<'w, crate::ui_quest::QuestGiver>, - pub(crate) death: ResMut<'w, crate::death::DeathNet>, /// Bit 6 sends through the cache the proximity poll writes, so the two agree on the healer. pub(crate) spirit: ResMut<'w, crate::ui_dialog_verbs::AreaSpiritHealer>, /// The NPC whose window is open (`[0xb4e2d0]`), checked before the ladder. @@ -1148,7 +1147,12 @@ impl Dispatch<'_, '_> { debug!( "right-click interact: {guid:#x} (spirit healer — CONFIRM_XP_LOSS, no packet)" ); - self.service.death.ask_spirit_healer(guid); + // `0x5df730` with the guid, its gates and its signal, with the world in hand. + self.feedback + .edits + .push_world(Box::new(move |world: &mut World| { + let _ = world.run_system_cached_with(crate::death::ask_spirit_healer, guid); + })); } ServiceAction::AcquireSpiritGuide => { debug!("right-click interact: {guid:#x} (spirit guide — adopting, 0x2E2)"); diff --git a/crates/benilla-app/src/target/died.rs b/crates/benilla-app/src/target/died.rs index dc38f85a0..6d0474119 100644 --- a/crates/benilla-app/src/target/died.rs +++ b/crates/benilla-app/src/target/died.rs @@ -211,7 +211,7 @@ pub(super) struct Died<'w, 's> { seam: AttackSeam<'w, 's>, /// The release timer our own death arms. death: ResMut<'w, crate::death::DeathNet>, - /// The real clock the release timer counts on, as the death feed reads it. + /// The real clock the release timer counts on, as the death getters read it. time: Res<'w, Time>, group: Res<'w, crate::ui_party::GroupState>, names: Res<'w, crate::names::NameCache>, @@ -631,9 +631,11 @@ mod tests { let bit = |set: bool| u32::from(set) * 0x8; c.values(ME, &[(FIELD_UNIT_HEALTH, 0), (BYTES, bit(armed))]); c.values(ME, &[(BYTES, bit(!armed))]); - crate::death::run_feed_death_once(c.world()); - let left: f64 = - crate::script_calls::eval_in_vm(c.world(), "return GetReleaseTimeRemaining()"); + let left: f64 = crate::script_calls::with_hosted_vm(c.world(), |s| { + s.expect("a VM") + .eval("return GetReleaseTimeRemaining()") + .expect("runs") + }); let at_death = dead_reads(&mut c); assert_eq!(at_death.len(), 1, "armed {armed}: {at_death:?}"); for read in [left, at_death[0]] { @@ -648,9 +650,8 @@ mod tests { /// Our own death's `PresentUnitDeath` (`0x6058ae`) ends in `SignalDeathState` for the active /// player (`0x5fa6d0` at `0x6251c2`, `0x6251cc` → `0x495850`): `PLAYER_DEAD` inside the death's - /// packet, after `0x5e99b0` armed the timer, so its handlers read the whole window, and the - /// frame's feed signals it no second time. A second death past the first window reads a fresh - /// one. + /// packet, after `0x5e99b0` armed the timer, so its handlers read the whole window, and + /// nothing signals it a second time. A second death past the first window reads a fresh one. #[test] fn our_own_death_signals_player_dead_in_its_packet_over_the_timer_it_armed() { let mut c = dying_client(); @@ -658,15 +659,8 @@ mod tests { let first = dead_reads(&mut c); assert_eq!(first.len(), 1, "PLAYER_DEAD in the packet: {first:?}"); assert!(first[0] > 359.0, "the whole window: {first:?}"); - crate::death::run_feed_death_once(c.world()); - assert_eq!( - dead_reads(&mut c).len(), - 1, - "the feed signals it no second time" - ); c.values(ME, &[(FIELD_UNIT_HEALTH, 100)]); - crate::death::run_feed_death_once(c.world()); c.world() .resource_mut::>() .update_with_duration(std::time::Duration::from_secs(400)); @@ -674,8 +668,6 @@ mod tests { let second = dead_reads(&mut c); assert_eq!(second.len(), 2, "{second:?}"); assert!(second[1] > 359.0, "a fresh window: {second:?}"); - crate::death::run_feed_death_once(c.world()); - assert_eq!(dead_reads(&mut c).len(), 2); } /// `SignalDeathState` clears the cursor after `PLAYER_DEAD` (`ClearCursor(1, 1)`, `0x495889` diff --git a/crates/benilla-app/src/ui_dialog_verbs.rs b/crates/benilla-app/src/ui_dialog_verbs.rs index 7fdd30450..623939b0f 100644 --- a/crates/benilla-app/src/ui_dialog_verbs.rs +++ b/crates/benilla-app/src/ui_dialog_verbs.rs @@ -527,14 +527,18 @@ fn stone_notice( /// it (`0x55f426`): each meeting-stone member line waiting on the name (`0x4ca510`), which a /// refusal spends silently, and the duel's held challenge ([`crate::ui_duel`]). #[derive(bevy::ecs::system::SystemParam)] -pub(crate) struct DialogNameAnswers<'w> { +pub(crate) struct DialogNameAnswers<'w, 's> { /// Each absent in a harness without the dialogs. lane: Option>, stone: Option>, duel: Option>, + /// The resurrect offer whose caster's name it waited on, and the active player its show + /// tests. + death: Option>, + me: Query<'w, 's, &'static ObjectStore, With>, } -impl DialogNameAnswers<'_> { +impl DialogNameAnswers<'_, '_> { /// `guid`'s answer just filed in `names`. pub(crate) fn answered(&mut self, guid: u64, names: &NameCache) { let Some(lane) = self.lane.as_deref_mut() else { @@ -554,6 +558,9 @@ impl DialogNameAnswers<'_> { if let Some(duel) = self.duel.as_deref_mut() { crate::ui_duel::name_answered(duel, lane, guid, name); } + if let Some(death) = self.death.as_deref_mut() { + crate::death::net::resurrecter_named(death, self.me.single().ok(), lane, guid, name); + } } } diff --git a/crates/benilla-app/src/ui_items/calls.rs b/crates/benilla-app/src/ui_items/calls.rs index 07f1bbd7e..82e55f61d 100644 --- a/crates/benilla-app/src/ui_items/calls.rs +++ b/crates/benilla-app/src/ui_items/calls.rs @@ -279,6 +279,11 @@ fn answer_pending_equip( // item, then the equip goes out ahead of its clear. A slot emptied under the dialog sends // nothing (`0x5e18da`). PendingEquip::AutoEquip { bag, slot, .. } => { + // The setter's control gate reads our taxi flag off the object (`0x494ba6`), here + // with the host out applying the accept. + script.set_on_taxi( + store.is_some_and(|s| s.0.unit_flags() & crate::player::UNIT_FLAG_TAXI_FLIGHT != 0), + ); script.auto_equip_slot(bag, slot, true); } } diff --git a/crates/benilla-app/src/ui_items/requirements.rs b/crates/benilla-app/src/ui_items/requirements.rs index 5d2c248a5..e375c585d 100644 --- a/crates/benilla-app/src/ui_items/requirements.rs +++ b/crates/benilla-app/src/ui_items/requirements.rs @@ -160,10 +160,15 @@ impl RequirementsLive<'_, '_> { Some(player_req_state(store, &inputs)) } - /// Seat the requirement state and the known spells in `script`, where the app's own reads - /// inside a call's apply, with no host to ask, find them: the item use's requirement gate - /// (`0x5d8e0e`) and the bar's equip question (`0x5e1650`). + /// Seat the requirement state, the known spells and our taxi flag in `script`, where the + /// app's own reads inside a call's apply, with no host to ask, find them: the item use's + /// requirement gate (`0x5d8e0e`), the bar's equip question (`0x5e1650`) and the cursor + /// setter's control gate, which reads the flag off our object (`0x494b97`-`0x494ba6`). pub(crate) fn seat(&mut self, script: &mut benilla_ui::script::UiScript) { + script.set_on_taxi( + self.player() + .is_some_and(|s| s.0.unit_flags() & crate::player::UNIT_FLAG_TAXI_FLIGHT != 0), + ); script.set_player_req_state(self.req().unwrap_or_default()); if let Some(actions) = self.actions.as_deref() { script.set_known_spells(actions.spells.iter().copied().collect()); diff --git a/crates/benilla-app/src/ui_logout.rs b/crates/benilla-app/src/ui_logout.rs index 687d5f5cf..5db001e12 100644 --- a/crates/benilla-app/src/ui_logout.rs +++ b/crates/benilla-app/src/ui_logout.rs @@ -20,26 +20,47 @@ use bevy::ecs::system::SystemParam; use bevy::prelude::*; use crate::net::{ClientCommand, LoggedOutMessage, NetCommands, SelfGuid}; -use crate::ui_script::UiFeed; /// The refusal line for every non-zero reason, never `PLAYER_LOGOUT_FAILED_ERROR`: message `0x180` /// of the `DisplayError` at `0x5aaf26`, a key so the player's `GlobalStrings.lua` supplies it. const LOGOUT_FAILED_KEY: &str = "ERR_LOGOUT_FAILED"; -/// What the wire told us to say next, queued because a cancel can land in its response's frame. +/// What a logout reply signals inside its handler, on the notice lane at the packet's place. #[derive(Clone, Copy, Debug, PartialEq, Eq)] enum LogoutSignal { - /// A timed logout started: `PLAYER_CAMPING`. + /// A timed logout started: `PLAYER_CAMPING` (276, `0x5aaf17`). Camping, - /// The same for a quit: `PLAYER_QUITING`. + /// The same for a quit: `PLAYER_QUITING` (277), the quit byte added to the id (`0x5aaf0c`). Quiting, - /// The logout was cancelled: `LOGOUT_CANCEL`. + /// The logout was cancelled: `LOGOUT_CANCEL` (278, `0x5aaf72`). Cancelled, - /// Refused: an error line, no dialog. + /// Refused: the error line, no dialog (`0x5aaf26`). Refused, } -/// The pending session exit and the signals owed to the UI. +impl LogoutSignal { + /// The notice that signals it. + fn notice(self) -> crate::field_watch::FieldNotice { + use crate::field_watch::{id, FieldNotice}; + match self { + Self::Camping => FieldNotice::Global { + id: id::PLAYER_CAMPING, + }, + Self::Quiting => FieldNotice::Global { + id: id::PLAYER_QUITING, + }, + Self::Cancelled => FieldNotice::Global { + id: id::LOGOUT_CANCEL, + }, + Self::Refused => FieldNotice::Line { + key: LOGOUT_FAILED_KEY, + }, + } + } +} + +/// The session's logout bytes, which the replies' handlers and the session verbs read and write +/// in place. #[derive(Resource, Default)] pub(crate) struct LogoutState { /// The reference's `[session+0x1b1c]`, the one bit the wire lacks, as a quit is also @@ -56,7 +77,6 @@ pub(crate) struct LogoutState { /// the quit byte (`0x5ab020`-`0x5ab02a`), so a `Logout()` on a worldport's loading screen sends /// nothing. world_handle: bool, - signals: Vec, } impl LogoutState { @@ -65,38 +85,38 @@ impl LogoutState { self.pending } - /// `SMSG_LOGOUT_RESPONSE`, the module doc's table; an instant logout signals nothing. - pub(crate) fn apply_response(&mut self, reason: u32, instant: bool) { + /// `SMSG_LOGOUT_RESPONSE` (`0x5aaef0`), the module doc's table: what it signals, nothing for + /// an instant logout. + fn apply_response(&mut self, reason: u32, instant: bool) -> Option { // Logged: the server's inputs (combat, resting, account level) are invisible from here. info!("logout: server answered reason={reason} instant={instant}"); if reason != 0 { // `0x5aaf21`: the error line, and the pending flag clears so the player can retry. self.pending = false; - self.signals.push(LogoutSignal::Refused); - return; + return Some(LogoutSignal::Refused); } if instant { - return; + return None; } - self.signals.push(if self.quitting { + Some(if self.quitting { LogoutSignal::Quiting } else { LogoutSignal::Camping - }); + }) } /// `SMSG_LOGOUT_CANCEL_ACK` (`0x5b4680`, then `0x5aaf60`). `CancelLogout` clears the pending - /// byte as it sends (`0x5aafc2`), so the ack of the player's own cancel fires nothing. - pub(crate) fn apply_cancelled(&mut self) { - self.call_off(); + /// byte as it sends (`0x5aafc2`), so the ack of the player's own cancel signals nothing. + fn apply_cancelled(&mut self) -> Option { + self.call_off() } /// The world left, `0x5aae70(0)`: by a world load (`0x401bd4`), by the logout's completion /// (`0x5aaeb3` → `0x5aaf4f`, ahead of the teardown at `0x5aaeca`), and by a refused login - /// (`0x5aad76` → `0x5aaf4f`). A completed logout that was not forced fires `LOGOUT_CANCEL`. - pub(crate) fn apply_left_world(&mut self) { + /// (`0x5aad76` → `0x5aaf4f`). A completed logout that was not forced signals `LOGOUT_CANCEL`. + fn apply_left_world(&mut self) -> Option { self.world_handle = false; - self.call_off(); + self.call_off() } /// The world handle seated, as a test of the verbs in the world needs it. @@ -107,41 +127,11 @@ impl LogoutState { /// `LOGOUT_CANCEL` only while a request is pending (`0x5aaf63`-`0x5aaf6b`, /// `0x5aae88`-`0x5aae90`), then the byte clears (`0x5aaf77`, `0x5aae9c`). - fn call_off(&mut self) { - if std::mem::take(&mut self.pending) { - self.signals.push(LogoutSignal::Cancelled); - } + fn call_off(&mut self) -> Option { + std::mem::take(&mut self.pending).then_some(LogoutSignal::Cancelled) } } -/// Fire the signals in wire order: the events the stock CAMP and QUIT dialogs hang off, and the -/// refusal line. -fn feed_logout( - mut vm: crate::script_calls::VmWith>, - mut sink: crate::ui_action::MessageSink, -) { - let signals = std::mem::take(&mut vm.own().signals); - if signals.is_empty() { - return; - } - vm.run(|script| { - let Some(script) = script else { - return; - }; - for signal in signals { - match signal { - LogoutSignal::Camping => script.fire_event("PLAYER_CAMPING", Vec::new()), - LogoutSignal::Quiting => script.fire_event("PLAYER_QUITING", Vec::new()), - LogoutSignal::Cancelled => script.fire_event("LOGOUT_CANCEL", Vec::new()), - LogoutSignal::Refused => { - let line = crate::ui_action::keyed_line(script, LOGOUT_FAILED_KEY); - crate::ui_action::show_messages(script, &mut sink, "ui_logout", line); - } - } - } - }) -} - /// What a session verb posts past its call, which nothing the script reads waits on: the process's /// exit, as `ForceQuit` posts the context's close (`0x48ab60` → `0x401560`), which /// [`exit_on_logout_complete`] takes, and the cinematic's stop, which schedules the end's fade @@ -313,10 +303,7 @@ impl Plugin for UiLogoutPlugin { .init_resource::() .add_systems( Update, - ( - feed_logout.in_set(UiFeed), - exit_on_logout_complete.in_set(crate::ui_script::UiDrain), - ), + exit_on_logout_complete.in_set(crate::ui_script::UiDrain), ) .add_systems( PreUpdate, @@ -385,8 +372,14 @@ mod net { .net_handler(K::CharacterLoginFailed, on_narration); } - fn on_narration(In(ev): In, mut logout: ResMut) { - match ev { + /// Each reply's signal goes on the notice lane at its packet's place, as the reference's + /// handlers signal in place (`0x5aaf17`, `0x5aaf26`, `0x5aaf72`, `0x5aae96`). + fn on_narration( + In(ev): In, + mut logout: ResMut, + mut lane: ResMut, + ) { + let signal = match ev { SessionEvent::LogoutResponse { reason, instant } => { logout.apply_response(reason, instant) } @@ -400,7 +393,10 @@ mod net { } | SessionEvent::LoggedOut | SessionEvent::CharacterLoginFailed { .. } => logout.apply_left_world(), - _ => {} + _ => None, + }; + if let Some(signal) = signal { + lane.write(signal.notice()); } } } @@ -416,31 +412,32 @@ mod tests { #[test] fn the_response_decides_which_dialog_if_any() { let mut s = LogoutState::default(); - s.apply_response(0, true); - assert!(s.signals.is_empty(), "an instant logout shows no dialog"); - - s.apply_response(0, false); - assert_eq!(s.signals, vec![LogoutSignal::Camping]); + assert_eq!( + s.apply_response(0, true), + None, + "an instant logout shows no dialog" + ); + assert_eq!(s.apply_response(0, false), Some(LogoutSignal::Camping)); let mut s = LogoutState { quitting: true, pending: true, - signals: Vec::new(), ..LogoutState::default() }; - s.apply_response(0, false); - assert_eq!(s.signals, vec![LogoutSignal::Quiting], "a quit says so"); + assert_eq!( + s.apply_response(0, false), + Some(LogoutSignal::Quiting), + "a quit says so" + ); // In combat: the error line (`0x5aaf21`) and the pending byte cleared (`0x5aaf2e`); the // quit byte stays, as only a request writes it (`0x5ab053`). let mut s = LogoutState { quitting: true, pending: true, - signals: Vec::new(), ..LogoutState::default() }; - s.apply_response(1, false); - assert_eq!(s.signals, vec![LogoutSignal::Refused]); + assert_eq!(s.apply_response(1, false), Some(LogoutSignal::Refused)); assert!(s.quitting, "the refusal leaves the quit byte"); assert!( !s.pending, @@ -462,6 +459,14 @@ mod tests { (app, rx) } + /// What the logout replies' handlers put on the notice lane, taken. + fn notices(app: &mut App) -> Vec { + app.world_mut() + .resource_mut::() + .drain() + .collect() + } + /// Run `chunk` with the host lent; what it sent of the logout's and the roll's packets. fn sent_by( app: &mut App, @@ -541,16 +546,12 @@ mod tests { let mut s = LogoutState { quitting: true, pending: true, - signals: Vec::new(), ..LogoutState::default() }; - s.apply_cancelled(); - assert_eq!(s.signals, vec![LogoutSignal::Cancelled]); + assert_eq!(s.apply_cancelled(), Some(LogoutSignal::Cancelled)); assert!(!s.pending); assert!(s.quitting, "the ack leaves the quit byte"); - s.signals.clear(); - s.apply_cancelled(); - assert!(s.signals.is_empty(), "nothing pending, nothing fired"); + assert_eq!(s.apply_cancelled(), None, "nothing pending, nothing fired"); } /// The ack of the player's own cancel fires nothing: `CancelLogout` (`0x5aaf80`) clears the @@ -566,7 +567,7 @@ mod tests { app.world_mut(), vec![SessionEvent::LogoutCancelled, SessionEvent::LogoutCancelled], ); - assert!(app.world().resource::().signals.is_empty()); + assert!(notices(&mut app).is_empty()); } /// A world load leaves the world first (`0x401bd4` → `0x5aae70(0)`), which fires @@ -595,7 +596,7 @@ mod tests { crate::net::handlers::dispatch(app.world_mut(), vec![port()]); let logout = app.world().resource::(); assert!(logout.pending, "the packet only posts the load"); - assert!(logout.signals.is_empty()); + assert!(notices(&mut app).is_empty()); assert_eq!(cancelled(&app), 0); app.world_mut() .run_system_cached(leave_world) @@ -623,14 +624,13 @@ mod tests { let (mut app, rx) = client(); assert_eq!(sent_by(&mut app, &rx, "Logout()"), ["logout"]); crate::net::handlers::dispatch(app.world_mut(), vec![SessionEvent::LoggedOut]); - let logout = app.world().resource::(); - assert!(!logout.pending); - assert_eq!(logout.signals, [LogoutSignal::Cancelled]); + assert!(!app.world().resource::().pending); + assert_eq!(notices(&mut app), [LogoutSignal::Cancelled.notice()]); let (mut app, rx) = client(); assert_eq!(sent_by(&mut app, &rx, "ForceLogout()"), ["force"]); crate::net::handlers::dispatch(app.world_mut(), vec![SessionEvent::LoggedOut]); - assert!(app.world().resource::().signals.is_empty()); + assert!(notices(&mut app).is_empty()); } /// `SMSG_CHARACTER_LOGIN_FAILED` (`0x5b45f0` → `0x5aad70`) leaves the world first @@ -643,9 +643,8 @@ mod tests { app.world_mut(), vec![SessionEvent::CharacterLoginFailed { result: 1 }], ); - let logout = app.world().resource::(); - assert!(!logout.pending); - assert_eq!(logout.signals, [LogoutSignal::Cancelled]); + assert!(!app.world().resource::().pending); + assert_eq!(notices(&mut app), [LogoutSignal::Cancelled.notice()]); } /// A world load zeroes the world handle (`0x401bd4` → `0x5aae70(0)`, stored at `0x5aae82`) diff --git a/crates/benilla-app/src/ui_script/death_tests.rs b/crates/benilla-app/src/ui_script/death_tests.rs index 8ce2128aa..f3c17e9fd 100644 --- a/crates/benilla-app/src/ui_script/death_tests.rs +++ b/crates/benilla-app/src/ui_script/death_tests.rs @@ -1,5 +1,5 @@ //! The stock death popups (`StaticPopup.lua`): release, self-resurrect, resurrect offers, the -//! spirit healer's confirm and the corpse run, driven as the app's death feed drives them. +//! spirit healer's confirm and the corpse run, driven over the VM's copy of the death state. use benilla_ui::script::{DeathAction, DeathUiState, ScriptValue, UiScript}; @@ -495,7 +495,10 @@ fn the_death_timers_answer_whole_seconds() { 1.0 ); // No timer: `0x4962a0` answers -1000 ms, which the signed divide keeps as -1. - s.set_death(DeathUiState::default()); + s.set_death(DeathUiState { + release_remaining: None, + ..Default::default() + }); assert_eq!( s.eval::("return GetReleaseTimeRemaining()").unwrap(), -1.0 diff --git a/crates/benilla-app/src/ui_taxi/mod.rs b/crates/benilla-app/src/ui_taxi/mod.rs index 5b44d793b..ff453f50a 100644 --- a/crates/benilla-app/src/ui_taxi/mod.rs +++ b/crates/benilla-app/src/ui_taxi/mod.rs @@ -9,9 +9,10 @@ use bevy::prelude::*; #[cfg(test)] use benilla_ui::script::UiScript; +#[cfg(test)] use crate::net::{ObjectStore, SelfPlayer}; -use crate::player::UNIT_FLAG_TAXI_FLIGHT; -use crate::ui_script::{SweepApp, SweepLeg, UiFeed}; + +use crate::ui_script::{SweepApp, SweepLeg}; use crate::ui_session::{LatchApp, LatchedWindow, NpcWindow}; mod calls; @@ -210,32 +211,6 @@ pub(crate) struct FlightMasterStatus { pub(crate) known: bool, } -/// Push `UnitOnTaxi("player")`: the reference's verb (`0x517a40`) answers bit 20 of -/// `UNIT_FIELD_FLAGS` (`0x517a86`), which vmangos sets only for a flight -/// (`FlightPathMovementGenerator`). Any other server spline, such as a fear, is not a taxi: stock -/// `UIParent.lua:474-478` closes the windows on `PLAYER_CONTROL_LOST` unless on a taxi. No self -/// store reads as not on a taxi. -fn feed_on_taxi( - mut hosted_vm: crate::script_calls::HostedVm, - self_q: Query<&ObjectStore, With>, - mut last: Local>>, -) { - hosted_vm.run(|script| { - let Some(script) = script else { - return; - }; - let last = last.get(script); - let on_taxi = self_q - .iter() - .next() - .is_some_and(|s| s.0.unit_flags() & UNIT_FLAG_TAXI_FLIGHT != 0); - if *last != Some(on_taxi) { - script.set_on_taxi(on_taxi); - *last = Some(on_taxi); - } - }) -} - mod net; pub(crate) struct UiTaxiPlugin; @@ -248,7 +223,7 @@ impl Plugin for UiTaxiPlugin { .init_resource::() .add_latched_window::() .add_sweep_leg(SweepLeg::Taxi, leave_world) - .add_systems(Update, (load_taxi_catalogs, feed_on_taxi.in_set(UiFeed))); + .add_systems(Update, load_taxi_catalogs); } } @@ -265,43 +240,6 @@ mod tests { use benilla_protocol::field::FIELD_UNIT_FLAGS; use benilla_protocol::ObjectFields; - /// The feed pushes the ride with the bit and clears it without; it reads nothing about server - /// splines. - #[test] - fn the_feed_pushes_the_taxi_flight_flag() { - let mut app = App::new(); - app.add_systems(Update, feed_on_taxi); - app.insert_non_send_resource(UiScript::new().unwrap()); - let me = app - .world_mut() - .spawn(( - SelfPlayer, - ObjectStore(ObjectFields::from_pairs(&[(FIELD_UNIT_FLAGS, 0x1000)])), - )) - .id(); - let on_taxi = |app: &mut App| -> bool { - app.update(); - app.world().non_send_resource::().on_taxi() - }; - assert!(!on_taxi(&mut app), "no TAXI_FLIGHT bit: nil"); - - app.world_mut() - .entity_mut(me) - .insert(ObjectStore(ObjectFields::from_pairs(&[( - FIELD_UNIT_FLAGS, - 0x1000 | UNIT_FLAG_TAXI_FLIGHT, - )]))); - assert!(on_taxi(&mut app), "the bit set: 1"); - - app.world_mut() - .entity_mut(me) - .insert(ObjectStore(ObjectFields::from_pairs(&[( - FIELD_UNIT_FLAGS, - 0, - )]))); - assert!(!on_taxi(&mut app), "landed: nil again"); - } - /// The map's fares take the flight master's discount and the express leg sends the raw route /// sum (`0x4dc3d0` against `0x4dc96f`). Honored, a PvP-flagged flight master and honor rank /// byte 6 make 0.15: Sentinel Hill's direct 110 shows 94, and Thelsamar's route through diff --git a/crates/benilla-app/src/ui_unit.rs b/crates/benilla-app/src/ui_unit.rs index 41fbf515d..9f73dadb9 100644 --- a/crates/benilla-app/src/ui_unit.rs +++ b/crates/benilla-app/src/ui_unit.rs @@ -995,6 +995,9 @@ impl benilla_ui::script::SelfRead for StoreObject<'_> { fn action_bar_toggles(&self) -> u8 { self.0 .0.player_action_bar_toggles().unwrap_or(0) } + fn on_taxi(&self) -> bool { + self.0 .0.unit_flags() & crate::player::UNIT_FLAG_TAXI_FLIGHT != 0 + } } /// `PLAYER_FLAGS` bit 7, free-for-all PvP (vmangos `Player.h:322`). diff --git a/crates/benilla-app/src/ui_unit/field_events.rs b/crates/benilla-app/src/ui_unit/field_events.rs index ccc63a43a..fa2d0c3a2 100644 --- a/crates/benilla-app/src/ui_unit/field_events.rs +++ b/crates/benilla-app/src/ui_unit/field_events.rs @@ -623,6 +623,15 @@ pub(crate) fn fire( vec![ScriptValue::Int(i64::from(free_repop))], ), FieldNotice::MinimapPing(ping) => ping.fire(script), + FieldNotice::Revived => { + script.unlock_all_items(); + script.fire_event("PLAYER_ALIVE", vec![]); + } + FieldNotice::Line { key } => { + if let Some(line) = crate::ui_action::keyed_line(script, key) { + crate::ui_action::show_now(script, sink, "ui_unit", line); + } + } FieldNotice::PvpPreference { on } => { let (toast, verbose) = super::pvp_announcement(on); // The verbose sentence is no catalog row, so it goes `unkeyed` to chat: @@ -780,6 +789,9 @@ fn global_event(id: u16) -> Option<&'static str> { id::PET_BAR_UPDATE => "PET_BAR_UPDATE", id::AREA_SPIRIT_HEALER_IN_RANGE => "AREA_SPIRIT_HEALER_IN_RANGE", id::AREA_SPIRIT_HEALER_OUT_OF_RANGE => "AREA_SPIRIT_HEALER_OUT_OF_RANGE", + id::PLAYER_CAMPING => "PLAYER_CAMPING", + id::PLAYER_QUITING => "PLAYER_QUITING", + id::LOGOUT_CANCEL => "LOGOUT_CANCEL", id::INSPECT_HONOR_UPDATE => "INSPECT_HONOR_UPDATE", id::PLAYERBANKBAGSLOTS_CHANGED => "PLAYERBANKBAGSLOTS_CHANGED", id::PLAYER_FARSIGHT_FOCUS_CHANGED => "PLAYER_FARSIGHT_FOCUS_CHANGED", diff --git a/crates/benilla-ui/src/script/container.rs b/crates/benilla-ui/src/script/container.rs index c8cb823f3..30c471f9a 100644 --- a/crates/benilla-ui/src/script/container.rs +++ b/crates/benilla-ui/src/script/container.rs @@ -541,7 +541,7 @@ fn use_cleared( if let (UseArm::Item(UseFork::Equip), Some(item)) = (arm, equip) { // Without control the equip arm returns before it locks or sends, unless on a taxi // (`0x4fa3ce`-`0x4fa3ec`). - return cursor::equip::has_cursor_control(model).then_some(item); + return cursor::equip::has_cursor_control(lua, model).then_some(item); } // The use dispatcher's gates (`0x5d8d00`), each showing its line and ending the call before // the arm's lock (`0x5edcd9`): the requirement check ahead of the read, letter, open and @@ -627,7 +627,7 @@ fn pickup_container_item( ) -> ContainerClick { // Without control and off a taxi the click ends before anything is read // (`0x4f9b87`-`0x4f9ba3`). - if !cursor::equip::has_cursor_control(model) { + if !cursor::equip::has_cursor_control(lua, model) { return ContainerClick::Done; } // The slot as the click finds it now, by its own place. diff --git a/crates/benilla-ui/src/script/cursor.rs b/crates/benilla-ui/src/script/cursor.rs index 576554fe6..a2c982df0 100644 --- a/crates/benilla-ui/src/script/cursor.rs +++ b/crates/benilla-ui/src/script/cursor.rs @@ -548,9 +548,9 @@ impl Setter { } /// Whether the setter runs, by the player-control flag `[0xb4b3e4]`. - fn admits(self, model: &Model) -> bool { + fn admits(self, lua: &Lua, model: &Model) -> bool { match self { - Setter::Item => equip::has_cursor_control(model), + Setter::Item => equip::has_cursor_control(lua, model), Setter::Controlled => model.player_control, Setter::Free => true, } @@ -571,7 +571,7 @@ pub(crate) fn set_cursor( payload: impl FnOnce(&Model) -> Option, ) -> bool { let admitted = verb(lua, |model| { - if !setter.admits(model) { + if !setter.admits(lua, model) { return false; } clear( @@ -801,7 +801,7 @@ pub(crate) fn split_container_item( let item = { let model = lua.app_data_ref::().expect("model app_data"); // Without control and off a taxi the split ends first (`0x4f9fdb`-`0x4f9ff7`). - if !equip::has_cursor_control(&model) { + if !equip::has_cursor_control(lua, &model) { return Ok(false); } // The slot resolver (`0x4fa00a`), through the bag lookup `0x4f93e0`. diff --git a/crates/benilla-ui/src/script/cursor/doll.rs b/crates/benilla-ui/src/script/cursor/doll.rs index 6eaab6a3b..25ddaa310 100644 --- a/crates/benilla-ui/src/script/cursor/doll.rs +++ b/crates/benilla-ui/src/script/cursor/doll.rs @@ -77,7 +77,7 @@ pub(super) fn doll_click( ) -> DollClick { // Without control and off a taxi the click ends before the cursor is read // (`0x4c7345`-`0x4c7360`). - if !super::equip::has_cursor_control(model) { + if !super::equip::has_cursor_control(lua, model) { return DollClick::Done(false); } // Lua 0, the 0-based slot -1, is the ammo leg (`0x4c73a6`). diff --git a/crates/benilla-ui/src/script/cursor/equip.rs b/crates/benilla-ui/src/script/cursor/equip.rs index 7d9521f40..bc0b1c0a5 100644 --- a/crates/benilla-ui/src/script/cursor/equip.rs +++ b/crates/benilla-ui/src/script/cursor/equip.rs @@ -235,11 +235,18 @@ pub(crate) fn auto_equip_cursor_item(lua: &Lua, model: &mut Model) -> bool { /// `SetCursorItem`'s control gate (`0x494b8d`): without control of the character /// (`[0xb4b3e4]`, `SMSG_CLIENT_CONTROL_UPDATE`) the set returns before its clear, unless the -/// player is on a taxi (`UNIT_FLAG_TAXI_FLIGHT`). The UseContainerItem equip arm -/// (`0x4fa3ce`-`0x4fa3ec`), `PickupContainerItem` (`0x4f9b87`-`0x4f9ba3`) and +/// player is on a taxi (`UNIT_FLAG_TAXI_FLIGHT`), read off the active player's object at the call +/// (`0x494b97`-`0x494ba6`) through the lent host, else off `model`'s copy. The UseContainerItem +/// equip arm (`0x4fa3ce`-`0x4fa3ec`), `PickupContainerItem` (`0x4f9b87`-`0x4f9ba3`) and /// `PickupInventoryItem` (`0x4c7345`-`0x4c7360`) test the same pair first. -pub(crate) fn has_cursor_control(model: &Model) -> bool { - model.player_control || model.taxi_riding +pub(crate) fn has_cursor_control(lua: &Lua, model: &Model) -> bool { + use crate::script::SelfRead; + if model.player_control { + return true; + } + let mut live = None; + crate::script::host::read_host(lua, |h| h.read_self(&mut |own| live = Some(own.on_taxi()))); + live.unwrap_or_else(|| model.on_taxi()) } /// `0x5e1840`: `SetCursorItem(1, …)` puts the item on the cursor, its inner clear dropping and diff --git a/crates/benilla-ui/src/script/death.rs b/crates/benilla-ui/src/script/death.rs index f707d5a13..a024c0aea 100644 --- a/crates/benilla-ui/src/script/death.rs +++ b/crates/benilla-ui/src/script/death.rs @@ -1,15 +1,70 @@ //! The release, reclaim, resurrect and self-res verbs and the getters the `DEATH`, -//! `RECOVER_CORPSE`, `RESURRECT` and `XP_LOSS` dialogs call, over a snapshot the app pushes. -//! The three predicates answer `1` or nil, as the reference does (`ResurrectHasSickness` -//! `0x48aa00`, `ResurrectHasTimer` `0x48aa30`, `CheckSpiritHealerDist` `0x48d120`). +//! `RECOVER_CORPSE`, `RESURRECT` and `XP_LOSS` dialogs call, each reading the death state through +//! the lent host as it runs ([`DeathQuery`]), as the reference's read their globals at the call +//! (`GetCorpseRecoveryDelay` `0x48b5d0`). The three predicates answer `1` or nil, as the reference +//! does (`ResurrectHasSickness` `0x48aa00`, `ResurrectHasTimer` `0x48aa30`, +//! `CheckSpiritHealerDist` `0x48d120`). use mlua::{Lua, Value}; use super::binding_abi::flag; +use super::live::{ask, LiveQuery}; use super::Model; -/// The death snapshot the app pushes each frame. -#[derive(Clone, Debug, Default, PartialEq)] +/// The death state the getters read through the host as they run; the VM's copy of it +/// ([`super::UiScript::set_death`]) answers only with no host to ask. +pub struct DeathQuery; + +impl LiveQuery for DeathQuery { + type Answer = DeathUiState; +} + +/// The active player's level, which `GetResSicknessDuration` words the sickness by; `None` with +/// no active player held. +pub struct ResSicknessLevelQuery; + +impl LiveQuery for ResSicknessLevelQuery { + type Answer = u32; +} + +/// The death state as the getters read it now: the host's, else the VM's copy, which only a test +/// sets (every production entry that runs Lua lends the host). +fn state(lua: &Lua) -> DeathUiState { + ask(lua, &DeathQuery).unwrap_or_else(|| { + lua.app_data_ref::() + .expect("model app_data") + .death + .clone() + }) +} + +/// The sickness a spirit-healer res applies at `level`, per vmangos `Player::ResurrectPlayer`: +/// none below 11, `level - 10` minutes through 19, 10 minutes from 20. Worded with `GENERIC_MIN`, +/// the minute arm of the reference's formatter (`0x51a3a0` into `0x52fa50`). +/// +/// Deviation: the minutes come from the server's table, not from spell 15007's `Spell.dbc` +/// duration, because the aura the server applies is what the dialog must warn about. +pub(crate) fn sickness_duration( + level: u32, + strings: crate::strings::Strings<'_>, +) -> Option { + let minutes = match level { + 0..=10 => return None, + 11..=19 => level - 10, + _ => 10, + }; + // `GetText(token, nil, ordinal)`, the VM's own. + let template = crate::strings::plural("GENERIC_MIN", Some(minutes), strings)?; + Some(crate::strings::fill( + &template, + &[crate::strings::Arg::D(i64::from(minutes))], + )) +} + +/// The death state the getters read: the VM's copy when no host is lent to answer +/// [`DeathQuery`]. A fresh copy is the state `UI_Init` leaves: the release timer zeroed +/// (`0x490131`), which reads 0, and nothing offered. +#[derive(Clone, Debug, PartialEq)] pub struct DeathUiState { /// Seconds until the server force-releases, counted from death against the 6-minute /// `CORPSE_REPOP_TIME` the wire never carries. `None` (`PLAYER_FIELD_BYTES` bit `0x08` clear, @@ -24,8 +79,9 @@ pub struct DeathUiState { pub resurrect_has_timer: bool, /// The confirming spirit healer is in dialog range (`CheckSpiritHealerDist`). pub spirit_healer_in_range: bool, - /// The sickness duration a spirit-healer res would apply ("N minutes"); `None` below the - /// sickness level picks `XP_LOSS_NO_SICKNESS` (`UIParent.lua:399-408`). + /// The VM's copy of the sickness duration a spirit-healer res would apply ("N minutes"); + /// `None` below the sickness level picks `XP_LOSS_NO_SICKNESS` (`UIParent.lua:399-408`). The + /// host answers the level instead ([`ResSicknessLevelQuery`]), which the getter words. pub sickness_duration: Option, /// `HasSoulstone()`'s label (`0x48ac80`), stamped on the DEATH dialog's second button: /// `PLAYER_SELF_RES_SPELL`'s `Spell.dbc` name (3026 and 20758-20761 "Use Soulstone", 21169 @@ -33,6 +89,20 @@ pub struct DeathUiState { pub self_res_label: Option, } +impl Default for DeathUiState { + fn default() -> Self { + Self { + release_remaining: Some(0.0), + recovery_delay: 0.0, + resurrect_sickness: false, + resurrect_has_timer: false, + spirit_healer_in_range: false, + sickness_duration: None, + self_res_label: None, + } + } +} + /// The death verbs the host applies inside their calls ([`super::ScriptCall::Death`]). #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum DeathAction { @@ -63,7 +133,7 @@ pub enum DeathAction { } impl super::UiScript { - /// Push this frame's death snapshot, before the event dispatch. + /// Set the VM's copy of the death state, which the getters read with no host to ask. pub fn set_death(&mut self, state: DeathUiState) { self.model_mut().death = state; } @@ -109,9 +179,7 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> { g.set( "GetReleaseTimeRemaining", lua.create_function(|lua, ()| { - let model = lua.app_data_ref::().expect("model app_data"); - Ok(model - .death + Ok(state(lua) .release_remaining .map_or(-1.0, |s| f64::from(s.max(0.0).trunc()))) })?, @@ -121,40 +189,36 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> { // (`0x48b5f0`-`0x48b5f7`). g.set( "GetCorpseRecoveryDelay", - lua.create_function(|lua, ()| { - let model = lua.app_data_ref::().expect("model app_data"); - Ok(f64::from(model.death.recovery_delay.max(0.0).floor())) - })?, + lua.create_function(|lua, ()| Ok(f64::from(state(lua).recovery_delay.max(0.0).floor())))?, )?; g.set( "ResurrectHasSickness", - lua.create_function(|lua, ()| { - let model = lua.app_data_ref::().expect("model app_data"); - Ok(flag(model.death.resurrect_sickness)) - })?, + lua.create_function(|lua, ()| Ok(flag(state(lua).resurrect_sickness)))?, )?; g.set( "ResurrectHasTimer", - lua.create_function(|lua, ()| { - let model = lua.app_data_ref::().expect("model app_data"); - Ok(flag(model.death.resurrect_has_timer)) - })?, + lua.create_function(|lua, ()| Ok(flag(state(lua).resurrect_has_timer)))?, )?; g.set( "CheckSpiritHealerDist", - lua.create_function(|lua, ()| { - let model = lua.app_data_ref::().expect("model app_data"); - Ok(flag(model.death.spirit_healer_in_range)) - })?, + lua.create_function(|lua, ()| Ok(flag(state(lua).spirit_healer_in_range)))?, )?; g.set( "GetResSicknessDuration", lua.create_function(|lua, ()| { - let model = lua.app_data_ref::().expect("model app_data"); - Ok(match &model.death.sickness_duration { - Some(s) => Value::String(lua.create_string(s)?), + let duration = match ask(lua, &ResSicknessLevelQuery) { + Some(level) => sickness_duration(level, crate::strings::Strings::Vm(lua)), + None => lua + .app_data_ref::() + .expect("model app_data") + .death + .sickness_duration + .clone(), + }; + Ok(match duration { + Some(s) => Value::String(lua.create_string(&s)?), None => Value::Nil, }) })?, @@ -165,9 +229,8 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> { g.set( "HasSoulstone", lua.create_function(|lua, ()| { - let model = lua.app_data_ref::().expect("model app_data"); - Ok(match &model.death.self_res_label { - Some(s) => Value::String(lua.create_string(s)?), + Ok(match state(lua).self_res_label { + Some(s) => Value::String(lua.create_string(&s)?), None => Value::Nil, }) })?, diff --git a/crates/benilla-ui/src/script/mod.rs b/crates/benilla-ui/src/script/mod.rs index 1789ddebd..65c293504 100644 --- a/crates/benilla-ui/src/script/mod.rs +++ b/crates/benilla-ui/src/script/mod.rs @@ -319,7 +319,7 @@ pub use cvars::{ CVAR_WORLD_DETAIL, IN_WORLD_READ_ONLY_CVARS, LUA_CVAR_LIMIT, VIDEO_DEFAULT_CVARS, WORLD_DETAIL_STOPS, }; -pub use death::{DeathAction, DeathUiState}; +pub use death::{DeathAction, DeathQuery, DeathUiState, ResSicknessLevelQuery}; pub use dialog_live::{ meeting_stone_text, AreaSpiritHealerSecsQuery, BinderPendingQuery, CanResetInstancesQuery, InstanceBootSecsQuery, InstanceTypeQuery, MeetingStoneQuery, MeetingStoneStatus, diff --git a/crates/benilla-ui/src/script/stat_read.rs b/crates/benilla-ui/src/script/stat_read.rs index e065220b9..99e515fc7 100644 --- a/crates/benilla-ui/src/script/stat_read.rs +++ b/crates/benilla-ui/src/script/stat_read.rs @@ -227,6 +227,9 @@ pub trait SelfRead { fn combo_target(&self) -> u64; /// `PLAYER_FIELD_BYTES` byte 2 (`+0x102a`), `GetActionBarToggles`' (`0x4e768c`). fn action_bar_toggles(&self) -> u8; + /// `UNIT_FIELD_FLAGS` bit 20 (`+0xa0`, `UNIT_FLAG_TAXI_FLIGHT`), which the cursor setter's + /// control gate reads off the object at the call (`0x494b97`-`0x494ba6`). + fn on_taxi(&self) -> bool; /// Whether an active player is held (`0x468550` → `0x468460`), `CanReadUnitInventory`'s /// first test (`0x4944c9`); only [`NoPlayer`] holds none. fn held(&self) -> bool { @@ -283,6 +286,9 @@ impl SelfRead for NoPlayer { fn action_bar_toggles(&self) -> u8 { 0 } + fn on_taxi(&self) -> bool { + false + } fn held(&self) -> bool { false } @@ -332,6 +338,9 @@ impl SelfRead for Model { fn action_bar_toggles(&self) -> u8 { self.action_bar_toggles.unwrap_or(0) } + fn on_taxi(&self) -> bool { + self.taxi_riding + } } /// `f` over the unit object held under `guid` and its combat stats through the lent host, as of diff --git a/crates/benilla-ui/src/script/taxi.rs b/crates/benilla-ui/src/script/taxi.rs index d55cc50a5..5a16d9e3e 100644 --- a/crates/benilla-ui/src/script/taxi.rs +++ b/crates/benilla-ui/src/script/taxi.rs @@ -112,17 +112,14 @@ impl super::UiScript { self.model_mut().taxi = state; } - /// Whether the player is riding a taxi (`UNIT_FLAG_TAXI_FLIGHT`), for the equip control gate - /// (`0x494ba6`); `UnitOnTaxi` reads the flag off the unit itself. + /// Seat the VM's copy of the active player's taxi flag (`UNIT_FLAG_TAXI_FLIGHT`), which the + /// cursor control gate reads with no host to ask (`0x494ba6`): the app seats it off our + /// object before a call's apply reaches the gate, and with the host lent the gate reads the + /// object itself. pub fn set_on_taxi(&mut self, riding: bool) { self.model_mut().taxi_riding = riding; } - /// What [`Self::set_on_taxi`] last pushed. - pub fn on_taxi(&self) -> bool { - self.model_ref().taxi_riding - } - /// The taxi calls a harness's VM kept ([`Self::keep_calls`]), in call order. pub fn take_taxi_calls(&mut self) -> Vec { self.take_calls_where(|call| match call { diff --git a/docs/DEVIATIONS.md b/docs/DEVIATIONS.md index c743b4ce2..edd743fd6 100644 --- a/docs/DEVIATIONS.md +++ b/docs/DEVIATIONS.md @@ -36,7 +36,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it - [benilla-lua](#benilla-lua): 11 - [benilla-protocol](#benilla-protocol): 29 - [benilla-srp](#benilla-srp): 2 -- [benilla-ui](#benilla-ui): 134 +- [benilla-ui](#benilla-ui): 135 - [benilla-world](#benilla-world): 49 ### benilla-app @@ -129,7 +129,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it #### death -- The minutes come from the server's table, not from spell 15007's `Spell.dbc` duration, because the aura the server applies is what the dialog must warn about. ([`src/death/mod.rs:601`](../crates/benilla-app/src/death/mod.rs#L601)) +- `0x492130` compares the positions whatever map we stand on, so a ghost on another map at the corpse's coordinates reads in range for a reclaim the server refuses; here only the corpse's display map counts. ([`src/death/mod.rs:332`](../crates/benilla-app/src/death/mod.rs#L332)) #### entities @@ -286,8 +286,8 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it #### target -- The reference's arm reads the last object's stop (`0x611336` before `0x610383` stores this one's), so its first walk has no stop. ([`src/target/click.rs:742`](../crates/benilla-app/src/target/click.rs#L742)) -- It runs on the first frame with none, so an arrival that sends no stop (mid-air, rooted, under a held turn key) acts at once or on landing or release, where the reference waits for the next ground stop and can act long after, wherever the player then is. ([`src/target/click.rs:1689`](../crates/benilla-app/src/target/click.rs#L1689)) +- The reference's arm reads the last object's stop (`0x611336` before `0x610383` stores this one's), so its first walk has no stop. ([`src/target/click.rs:741`](../crates/benilla-app/src/target/click.rs#L741)) +- It runs on the first frame with none, so an arrival that sends no stop (mid-air, rooted, under a held turn key) acts at once or on landing or release, where the reference waits for the next ground stop and can act long after, wherever the player then is. ([`src/target/click.rs:1693`](../crates/benilla-app/src/target/click.rs#L1693)) - The rank is held to 7, the top of the ring scale's eight entries (`0..=7`), where the reference keeps any value; a server rank past 7 would index outside our palette. ([`src/target/relations.rs:487`](../crates/benilla-app/src/target/relations.rs#L487)) - TAB uses Classic Era's screen-space priority, not 1.12's ±30° facing cone and snapshot cursor (`0x493f60`), because the cone skips a close mob in front of the camera, which sits behind the character. ([`src/target/scan.rs:3`](../crates/benilla-app/src/target/scan.rs#L3)) - Our own body is never a candidate. The reference's friendly scan picks the player at some facings (`CanAssist(P, P)` is true, `0x6061e0`; the cone test `0x47f220`), but our scoring always puts the player dead centre at distance 0, so CTRL-TAB would pick us on every press. ([`src/target/scan.rs:194`](../crates/benilla-app/src/target/scan.rs#L194)) @@ -771,6 +771,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it - Always empty, because a refresh rate is only selectable through an exclusive mode-set and benilla has none. ([`src/script/cvars.rs:1010`](../crates/benilla-ui/src/script/cvars.rs#L1010)) - 1.12 has no such CVar; it exists because our Graphics page needs somewhere to keep the stop, and takes the API's name. ([`src/script/cvars.rs:1118`](../crates/benilla-ui/src/script/cvars.rs#L1118)) - The getter reads `CVAR_WORLD_DETAIL`, where the reference's reads only `smallCull` (`0x488d77`), because benilla's stop follows the knob that draws: a console `frillDensity` write moves the ground clutter and `WorldDetail` with it, and no renderer reads `smallCull` (its callback's `[0x868620]` has no reader). ([`src/script/cvars.rs:1146`](../crates/benilla-ui/src/script/cvars.rs#L1146)) +- The minutes come from the server's table, not from spell 15007's `Spell.dbc` duration, because the aura the server applies is what the dialog must warn about. ([`src/script/death.rs:45`](../crates/benilla-ui/src/script/death.rs#L45)) - The promotion's IME legs (`0x77d417`–`0x77d431`) and the IME writer's `or 6` (`0x77acde`, in `0x77ac60`) are not modelled: benilla has no IME composition. ([`src/script/editbox/flush.rs:28`](../crates/benilla-ui/src/script/editbox/flush.rs#L28)) - The nameplate glow is shown but never drawn, because its additive rim reads as hard edge lines in our linear-blending pipeline; the lit plate brightens its bar instead. ([`src/script/extract.rs:223`](../crates/benilla-ui/src/script/extract.rs#L223)) - A host of 0x80 bytes or more is refused. The reference copies the host into a 0x80-byte buffer (`0x5abc7c`-`0x5abc9c`) and writes its terminator one byte past the end, and the cut host could end in a whitelisted suffix the real one does not; this takes the safe side. ([`src/script/glue_core.rs:424`](../crates/benilla-ui/src/script/glue_core.rs#L424)) @@ -820,7 +821,7 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it - A format that ends in `%` reads past its terminator in the client (`0x4135c3`), into whatever memory follows the string; here the output ends there. ([`src/script/stdlib.rs:637`](../crates/benilla-ui/src/script/stdlib.rs#L637)) - With `#` and one byte of room, `_store_number` writes no digit and its reversal swaps before it tests (`0x413ab3`), trading the last byte written for the stale byte after it in the caller's buffer, which then ends the client's answer; here the output is kept. ([`src/script/stdlib.rs:688`](../crates/benilla-ui/src/script/stdlib.rs#L688)) - The reference reads uninitialised fields before the seed; we answer the first legal design because that value is undefined. ([`src/script/tabard.rs:122`](../crates/benilla-ui/src/script/tabard.rs#L122)) -- Returns nothing. The handler ends `mov eax,1` with nothing pushed (`0x4dcd7c`), so Lua 5.0 hands back the stack top, the node argument: an accident of the handler, not an API, and copying a stack-top leak would copy a bug. ([`src/script/taxi.rs:238`](../crates/benilla-ui/src/script/taxi.rs#L238)) +- Returns nothing. The handler ends `mov eax,1` with nothing pushed (`0x4dcd7c`), so Lua 5.0 hands back the stack top, the node argument: an accident of the handler, not an API, and copying a stack-top leak would copy a bug. ([`src/script/taxi.rs:235`](../crates/benilla-ui/src/script/taxi.rs#L235)) - `0x530a52` lays it out at once; getters resolve first, so only OnSizeChanged fires later. ([`src/script/tooltip/size.rs:180`](../crates/benilla-ui/src/script/tooltip/size.rs#L180)) - The reference anchors a Font object through its +0x24 with no type test (`0x5313c9`), undefined; benilla raises the owner line. ([`src/script/tooltip/verbs.rs:51`](../crates/benilla-ui/src/script/tooltip/verbs.rs#L51)) - No time line follows, where the reference's rides the record's `+0xc` (`0x532bdf`), a byte an empty record keeps from its history. 0 after `ClearBuffRecord 0x4e4490` prints a lone "0 seconds remaining" (`0x4e447e`); else it is whatever the last occupant left, as `ResetBuffCache 0x4e40c0` and the compaction's tail reset (`0x4e4237`) call `0x4e44b0` with slot -1, which writes `+0x0` and `+0x4` alone (`0x4e44bc`-`0x4e44c0`). ([`src/script/tooltip_aura.rs:238`](../crates/benilla-ui/src/script/tooltip_aura.rs#L238))