Profession, craft and loot windows follow 1.12.1 across reloads (#2308)

The profession, craft and loot windows, and two death timers, disagreed with 1.12.1 across a `/reload`, a group header and a busy frame.

- A `/reload` keeps the profession book open and unshown (`0x4fc750`), and its record waits outlive the VM. Clicking an open profession closes it, as the toggle `0x4fc910` does.
- The world-enter cascade, and so a reload or a worldport, closes the craft window silently (`0x4f5ee0`).
- The craft list heads each group once there are two (`0x4f60c0`). It sorts them with the comparators' header skip over the CRT qsort, answers `"header"` and folds.
- A replaced loot session's steps run on their own latch, stash and copier wait. An inventory failure re-signals `LOOT_OPENED` under the auto-loot byte (`0x5e3aff`).
- The release and corpse timers answer whole seconds (`0x48b5ae`, `0x48b5f0`).

Tests fail on main.

Fixes #2295
Fixes #2296
Fixes #2291
Fixes #2210
Fixes #2256
Fixes #1530

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Sam Sung
2026-10-24 02:52:53 +07:00
committed by GitHub
parent 8f137c077f
commit 9195a4d05e
20 changed files with 1225 additions and 164 deletions
+1
View File
@@ -452,6 +452,7 @@ mod tests {
tools: Vec::new(),
tooltip: CraftTooltip::Spell(7418),
spell_level: 1,
group: 0,
skill_line: None,
training_point_cost: 0,
required_level: 0,
+84 -3
View File
@@ -26,8 +26,9 @@ use crate::ui_unit::UnitFeed;
/// The open Craft window, client-local. A nonzero opener `EffectMiscValue[0]` routes here
/// (`Spell_C::TryCast` `0x6e4b60`) and is the craft type (1 Beast Training, 3 Enchanting) the
/// client keeps at `0xbdcfb8` for admission and row order. The session end clears it too: a
/// logout's fresh VM never runs the old one's `OnHide`.
/// client keeps at `0xbdcfb8` for admission and row order. The opener of the open type, the
/// world-enter init (`0x4f5ee0`) and the session end clear it too: a logout's fresh VM never runs
/// the old one's `OnHide`.
#[derive(Resource, Default)]
pub(crate) struct CraftOpen {
pub(crate) line: Option<u32>,
@@ -503,6 +504,7 @@ fn feed_craft(
// `spellLevel` at `+0x74` (column 29), not `baseLevel` (column 28).
spell_level: d.spell_level,
// The group key is the ability row's line (`0x4f61b1`), 0 with none.
group: sla.map_or(0, |a| a.skill_id),
skill_line: sla
.and_then(|a| skill_lines.catalog.line(a.skill_id))
.map(|l| l.name.clone()),
@@ -524,6 +526,12 @@ fn feed_craft(
})
})();
// The type stays open while a frame cannot resolve its book (a worldport's purge of our
// own player): only a close or the world-enter init ends it (`0x4f5fe0`, `0x4f5ee0`).
let fresh = match fresh {
None if open.line.is_some() => memo.state.clone(),
f => f,
};
// `CloseCraft` closes the VM's window and signals `CRAFT_CLOSE` in the verb (`0x4f5fef`).
let closed_in_place = !script.craft_open();
// The getters' item callbacks, kept by their calls; each record that landed rebuilds
@@ -550,7 +558,9 @@ fn feed_craft(
match (&memo.state, &fresh) {
(_, Some(f)) if opened => {
debug!("ui_craft: window opens — {} recipe(s)", f.recipes.len());
// The open's build signals the update (`0x4f661a`), then the show.
// The open's resets and build (`0x4f601c`-`0x4f6036`), whose tail signals the
// update (`0x4f661a`), then the show (`0x4f6040`).
script.craft_opened();
fires.post("CRAFT_UPDATE", vec![]);
fires.post("CRAFT_SHOW", vec![]);
}
@@ -1472,4 +1482,75 @@ mod tests {
.insert_template(DUST, Some(crate::items::test_template("Strange Dust")));
assert_eq!(heard(&mut app), ["CRAFT_UPDATE", "CRAFT_UPDATE"]);
}
/// The world-enter init `0x4f5ee0` (`0x4909c4`) zeroes the craft type (`[0xbdcfb8]`) and
/// signals nothing; `CRAFT_CLOSE` is `0x4f5fe0`'s alone. A worldport's cascade closes the
/// window under the interface that survives it with no close, and a reload's closes it under
/// the new one, which hears no show.
#[test]
fn the_world_enter_init_closes_the_window_silently() {
let (tx, _rx) = crossbeam_channel::unbounded();
let mut app = App::new();
app.init_resource::<CraftOpen>()
.init_resource::<PlayerActions>()
.init_resource::<crate::spell::SpellModifiers>()
.init_resource::<crate::net::GuidIndex>()
.init_resource::<Items>()
.insert_resource(NetCommands(tx))
.insert_resource(crate::ui_action::Spells::empty_for_tests())
.insert_resource(SkillLines {
catalog: benilla_formats::SkillLineCatalog::from_spell_lines([]),
})
.add_message::<crate::net::WorldEnterCascadeMessage>();
app.world_mut()
.spawn((ObjectStore(Default::default()), SelfPlayer));
let listening = || {
let script = UiScript::new().unwrap();
script
.run(
"HEARD = {} local f = CreateFrame('Frame') f:RegisterEvent('CRAFT_SHOW') \
f:RegisterEvent('CRAFT_UPDATE') f:RegisterEvent('CRAFT_CLOSE') \
f:SetScript('OnEvent', function() table.insert(HEARD, event) end)",
)
.unwrap();
script
};
app.insert_non_send_resource(listening());
app.add_systems(
Update,
(
crate::ui_tradeskill::reset_crafts_on_world_enter,
crate::ui_tradeskill::close_craft_on_world_enter,
feed_craft,
)
.chain(),
);
let heard = |app: &mut App| {
app.update();
app.world()
.non_send_resource::<UiScript>()
.eval::<Vec<String>>("local h = HEARD HEARD = {} return h")
.unwrap()
};
let open = |app: &mut App| {
*app.world_mut().resource_mut::<CraftOpen>() = CraftOpen {
line: Some(333),
craft_type: 3,
};
heard(app)
};
assert_eq!(open(&mut app), ["CRAFT_UPDATE", "CRAFT_SHOW"]);
app.world_mut()
.write_message(crate::net::WorldEnterCascadeMessage);
assert!(heard(&mut app).is_empty(), "a worldport closes it silently");
assert_eq!(app.world().resource::<CraftOpen>().line, None);
assert_eq!(open(&mut app), ["CRAFT_UPDATE", "CRAFT_SHOW"]);
app.insert_non_send_resource(listening());
app.world_mut()
.write_message(crate::net::WorldEnterCascadeMessage);
assert!(heard(&mut app).is_empty(), "a reload shows nothing");
assert_eq!(app.world().resource::<CraftOpen>().line, None);
}
}
+7 -2
View File
@@ -6,7 +6,7 @@ use bevy::prelude::*;
use super::{EquipError, EquipErrors};
use crate::net::{NetHandlerApp, SelfGuid};
use crate::ui_loot::LootLatch;
use crate::ui_loot::{LootLatch, LootState};
pub(super) fn register(app: &mut App) {
app.net_handler(SessionEventKind::InventoryFailure, on_inventory_failure)
@@ -56,6 +56,7 @@ fn on_inventory_failure(
In(ev): In<SessionEvent>,
mut equip_errors: ResMut<EquipErrors>,
mut latch: ResMut<LootLatch>,
mut loot: ResMut<LootState>,
) {
if let SessionEvent::InventoryFailure {
reason,
@@ -72,6 +73,9 @@ fn on_inventory_failure(
bag_slot,
};
inventory_failure(failure, &mut equip_errors, &mut latch);
// The tail, after the unlocks: `LOOT_OPENED` again under an open window and a set
// auto-loot byte (`0x5e3aff`-`0x5e3b20`), on the loot lane at the packet's place.
loot.owe_failure_tail();
}
}
@@ -86,7 +90,8 @@ struct Failure {
/// A refused inventory operation (reason 0 never arrives: `benilla_protocol::events` drops it):
/// queues the error line, and after it the unlock of both guids the packet names (`0x5e3ac0`,
/// the second only when nonzero, `0x5e3ad3`), on the refusal lane at the packet's place.
/// the second only when nonzero, `0x5e3ad3`), on the refusal lane at the packet's place; the
/// handler then owes the loot tail ([`LootState::owe_failure_tail`]).
fn inventory_failure(failure: Failure, equip_errors: &mut EquipErrors, latch: &mut LootLatch) {
let Failure {
reason,
@@ -796,3 +796,152 @@ fn a_close_and_the_next_response_in_one_frame_keep_their_order() {
Some(LOCKBOX)
);
}
/// A removal and the next response in one frame: the removal's `LOOT_SLOT_CLEARED` handlers run
/// inside its own packet (`0x4c1f77`), before the response's copier clears the bind stash
/// (`[0x847cec]`, `0x4c1df5`), so a `LootSlot` there takes the pending row (`0x4c2790(i, 1)`,
/// `0x4c27c0`) and sends it.
#[test]
fn a_replaced_sessions_handlers_read_its_own_bind_stash() {
let mut l = client();
open(
&mut l,
CORPSE,
1,
0,
vec![row(0, FELSTRIKER), row(1, LINEN)],
);
click(&mut l, 1);
assert_eq!(seen(&mut l), "LOOT_OPENED,LOOT_BIND_CONFIRM:1");
let _ = sent(&l);
run(
&mut l,
r#"local f = CreateFrame("Frame")
f:RegisterEvent("LOOT_SLOT_CLEARED")
f:SetScript("OnEvent", function() LootSlot(1) end)"#,
);
packets(
&mut l,
vec![
SessionEvent::LootRemoved { slot: 1 },
SessionEvent::LootResponse {
guid: CORPSE,
loot_type: 1,
gold: 0,
items: vec![row(0, WOOL)],
},
],
);
feed(&mut l);
assert_eq!(seen(&mut l), "LOOT_SLOT_CLEARED:2,LOOT_CLOSED,LOOT_OPENED");
assert!(
matches!(sent(&l)[..], [ClientCommand::AutostoreLootItem { slot: 0 }]),
"the old session's pending row"
);
}
/// A `CloseLoot` in a replaced session's `LOOT_SLOT_CLEARED` handler ends that session alone
/// (`0x48f200`): the next response, a pickpocket window the server starts on a cold target
/// (`0x5eb94b`), still waits on its rows' records and signals `LOOT_OPENED` at the last answer
/// (`0x4c2ac0`, `0x4c2afc`).
#[test]
fn a_replaced_sessions_close_keeps_the_next_copiers_end() {
const UNCACHED: u32 = 40_000;
let mut l = client();
open(&mut l, CORPSE, 1, 0, vec![row(0, LINEN), row(1, WOOL)]);
let _ = (seen(&mut l), sent(&l));
run(
&mut l,
r#"local f = CreateFrame("Frame")
f:RegisterEvent("LOOT_SLOT_CLEARED")
f:SetScript("OnEvent", function() CloseLoot() end)"#,
);
packets(
&mut l,
vec![
SessionEvent::LootRemoved { slot: 0 },
SessionEvent::LootResponse {
guid: CORPSE,
loot_type: 2,
gold: 0,
items: vec![row(0, UNCACHED)],
},
],
);
feed(&mut l);
assert_eq!(seen(&mut l), "LOOT_SLOT_CLEARED:1,LOOT_CLOSED");
assert!(
matches!(sent(&l)[..], [ClientCommand::LootRelease { guid: CORPSE }]),
"the old session's release"
);
let world = l.app.world_mut();
world
.resource_mut::<Items>()
.insert_template(UNCACHED, Some(crate::items::test_template("Silk Cloth")));
world.resource_scope(|world, mut loot: Mut<LootState>| {
loot.row_answered(world.resource::<Items>())
});
feed(&mut l);
assert_eq!(seen(&mut l), "LOOT_OPENED");
}
/// An inventory failure ends by signalling `LOOT_OPENED` again while a window is open
/// (`0xb71b48`) and the auto-loot byte is set (`0x5e3aff`-`0x5e3b20`): a window whose copier
/// waits on a row's record keeps the byte its interaction stored (`0x4c1ea6`, before the sweep's
/// clear at `0x4c2219`). With the byte clear the failure signals no loot event.
#[test]
fn an_inventory_failure_signals_the_window_again_under_the_byte() {
for byte in [true, false] {
let mut l = client();
l.app.world_mut().resource_mut::<AutoLootByte>().0 = byte;
run(&mut l, "ERR_INV_FULL = 'ERR_INV_FULL'");
open(&mut l, CORPSE, 1, 0, vec![row(0, LINEN), row(1, 40_000)]);
assert_eq!(seen(&mut l), "", "the copier waits on its record");
packets(
&mut l,
vec![SessionEvent::InventoryFailure {
reason: 50,
required_level: None,
item_guid: 0,
item2_guid: 0,
bag_slot: 0,
}],
);
crate::lanes::fire_in_order(l.app.world_mut());
let seen = seen(&mut l);
assert!(seen.starts_with("UI_ERROR_MESSAGE"), "{seen}");
assert_eq!(seen.ends_with(",LOOT_OPENED"), byte, "byte {byte}: {seen}");
}
}
/// The failure's tail reads whether a window is open at its own packet (`0x5e3af3`-`0x5e3aff`):
/// a response later in the same drain opens its window after it, so the tail signals nothing,
/// though the byte is set and that window's copier waits on its record.
#[test]
fn an_inventory_failure_reads_the_window_at_its_own_packet() {
let mut l = client();
run(&mut l, "ERR_INV_FULL = 'ERR_INV_FULL'");
l.app.world_mut().resource_mut::<AutoLootByte>().0 = true;
l.app.world_mut().resource_mut::<LootLatch>().0 = Some(CORPSE);
packets(
&mut l,
vec![
SessionEvent::InventoryFailure {
reason: 50,
required_level: None,
item_guid: 0,
item2_guid: 0,
bag_slot: 0,
},
SessionEvent::LootResponse {
guid: CORPSE,
loot_type: 1,
gold: 0,
items: vec![row(0, 40_000)],
},
],
);
crate::lanes::fire_in_order(l.app.world_mut());
assert_eq!(seen(&mut l), "UI_ERROR_MESSAGE:ERR_INV_FULL");
assert!(l.app.world().resource::<AutoLootByte>().0, "no sweep ran");
}
+93 -4
View File
@@ -203,6 +203,19 @@ impl Window {
}
}
/// The cells a response's handler writes over before its copier runs, as the session it replaces
/// left them: the latch (`0x5ebb60`), the bind stash (`[0x847cec]`, `0x4c1df5`) and whether a
/// copier's end waits on records (`0x4c1e77`). The steps that session's packets queued ahead of
/// the response run on these, as each packet's dispatch ran them before the response arrived.
/// The auto-loot byte is none of them: only `SetAutoLoot` writes it (`0x5df468`), never a
/// response, so every step reads it live.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
struct Cells {
latch: Option<u64>,
stash: Option<u32>,
copier_due: bool,
}
/// What a packet did that the VM has yet to hear, in its order on the loot lane: a change to the
/// window, with the window it left, or an item push.
#[derive(Clone, Debug)]
@@ -224,11 +237,16 @@ enum Step {
ended: Window,
window: Window,
ends: Option<bool>,
prior: Cells,
},
/// The copier's end a response's pending records held, run by the cache callback at the last
/// answer (`0x4c2ac0`, `0x4c2afc`), on its own session's window: a later response in the
/// frame replaced the live cells.
CopierEnd(Window),
/// An inventory failure's tail (`0x5e3af3`-`0x5e3b20`): `LOOT_OPENED` again while a window
/// is open (`0xb71b48`, as the failure's packet found it: `window_open`) and the active
/// player's auto-loot byte is set, read at the failure's place.
FailureTail { window_open: bool },
/// The sweep a close with no VM owed a disenchant window with rows left (`0x48f264` →
/// `0x4c1fa0`).
Sweep,
@@ -292,6 +310,11 @@ impl LootState {
source: None,
..self.window.clone()
};
let prior = Cells {
latch: self.window.source,
stash: self.pending_bind_confirm,
copier_due: self.copier_due,
};
self.window = Window {
source: Some(source),
gold,
@@ -308,9 +331,34 @@ impl LootState {
ended,
window: self.window.clone(),
ends: None,
prior,
});
}
/// The latch as it stood before the response's handler wrote it (`0x5ebb60`), for the steps
/// of the session it replaces.
pub(crate) fn note_replaced_latch(&mut self, latch: Option<u64>) {
if let Some(prior) = self.replaced_cells_from_back() {
prior.latch = latch;
}
}
/// The last queued response's cells, the one a handler just queued.
fn replaced_cells_from_back(&mut self) -> Option<&mut Cells> {
self.steps.iter_mut().rev().find_map(|(_, s)| match s {
Step::Opened { prior, .. } => Some(prior),
_ => None,
})
}
/// The first queued response's cells: those of the session the steps ahead of it belong to.
fn replaced_cells(&mut self) -> Option<&mut Cells> {
self.steps.iter_mut().find_map(|(_, s)| match s {
Step::Opened { prior, .. } => Some(prior),
_ => None,
})
}
/// The copier's asks at its packet (`0x4c1e77`): each row's record looked up with the callback
/// `0x4c2ac0`, the copier returning with any outstanding (`0x4c1ea6`), so its end waits for
/// the last answer ([`Step::CopierEnd`]) whatever lands before the lane fires it; with none
@@ -611,6 +659,14 @@ impl LootState {
})
}
/// Owe an inventory failure's tail to the lane, behind its line and unlocks, with whether a
/// window is open at the failure's packet (`0x5e3aff`).
pub(crate) fn owe_failure_tail(&mut self) {
self.queue(Step::FailureTail {
window_open: self.window.source.is_some(),
});
}
/// Owe the hold's sweep to the lane, from a close with no VM at hand.
pub(crate) fn owe_sweep(&mut self) {
self.sweep_owed = true;
@@ -1234,20 +1290,23 @@ fn fire_step(vm: &mut LootVm, reads: &LootReads, step: Step) {
ended,
window: w,
ends,
prior,
} => {
let replaced = vm.own().0.loot.replaced();
// The copier ends the session the VM shows (`0x4c1ccb`-`0x4c1dac`): its
// `LOOT_CLOSED` handlers run on the cells the teardown leaves, the source zeroed,
// before the new source is stored (`0x4c1dc2`), so their `CloseLoot` finds no
// window (`0x48f23f`). The stash clear comes after them (`0x4c1df5`).
// window (`0x48f23f`). The stash is the ended session's until the clear after them
// (`0x4c1df5`); the latch is already the response's (`0x5ebb60`).
let live = swap_in_cells(vm, ended);
vm.own().0.loot.pending_bind_confirm = prior.stash;
vm.turn(|script, _| {
if let Some(script) = script.filter(|s| s.shown_loot().is_some()) {
show(script, None);
}
});
restore_live(vm, live);
vm.own().0.loot.pending_bind_confirm = None;
restore_live(vm, live);
let ends = vm.turn(|script, (mut steps, _)| {
let Some(script) = script else {
return false;
@@ -1275,6 +1334,12 @@ fn fire_step(vm: &mut LootVm, reads: &LootReads, step: Step) {
end_session_open(vm, w, replaced);
}
}
Step::FailureTail { window_open } => vm.turn(|script, (steps, _)| {
let open = window_open && steps.objects.player().is_some();
if let (Some(script), true) = (script, open && steps.byte.0) {
script.fire_event("LOOT_OPENED", vec![]);
}
}),
Step::Sweep => {
if !vm.own().0.loot.sweep_owed {
return;
@@ -1361,9 +1426,13 @@ fn end_superseded_open<X: bevy::ecs::system::SystemParam + 'static>(
struct Live {
window: Window,
mark: crate::lanes::Mark,
/// The replaced session's other cells were swapped in ([`exchange_replaced_cells`]).
cells: bool,
}
/// Put `cells`, the loot cells as a step left them, in the window's place for that step's turn.
/// Put `cells`, the loot window as a step left it, in the window's place for that step's turn,
/// and, for a session a later response replaced, the latch, the stash and the copier's wait it
/// left ([`Cells`]).
fn swap_in_cells<X: bevy::ecs::system::SystemParam + 'static>(
vm: &mut VmWith<(LootSteps<'static, 'static>, X)>,
cells: Window,
@@ -1372,10 +1441,27 @@ fn swap_in_cells<X: bevy::ecs::system::SystemParam + 'static>(
Live {
window: std::mem::replace(&mut s.loot.window, cells),
mark: crate::lanes::mark(),
cells: exchange_replaced_cells(&mut s),
}
}
/// Put the live window back: the later copier rewrote every cell (`0x4c1dc2` on), so what the
/// Exchange the live [`Cells`] with those the first queued response holds for the session it
/// replaces; run twice it puts the live ones back and keeps what the turn left in the replaced
/// session's, for its next step. Whether a response is queued.
fn exchange_replaced_cells(s: &mut LootSteps) -> bool {
let Some(mut cells) = s.loot.replaced_cells().copied() else {
return false;
};
std::mem::swap(&mut s.latch.0, &mut cells.latch);
std::mem::swap(&mut s.loot.pending_bind_confirm, &mut cells.stash);
std::mem::swap(&mut s.loot.copier_due, &mut cells.copier_due);
if let Some(prior) = s.loot.replaced_cells() {
*prior = cells;
}
true
}
/// Put the live cells back: the later copier rewrote every cell (`0x4c1dc2` on), so what the
/// step's handlers changed in them goes, with the steps their calls queued.
fn restore_live<X: bevy::ecs::system::SystemParam + 'static>(
vm: &mut VmWith<(LootSteps<'static, 'static>, X)>,
@@ -1383,6 +1469,9 @@ fn restore_live<X: bevy::ecs::system::SystemParam + 'static>(
) {
let (mut s, _) = vm.own();
s.loot.window = live.window;
if live.cells {
exchange_replaced_cells(&mut s);
}
s.loot.steps.retain(|(stamp, _)| !stamp.since(live.mark));
}
+2
View File
@@ -68,6 +68,7 @@ fn on_response(
return;
}
// A fishing bobber first arms here and still does not kneel: `LootKneel` decides the pose.
let latch_before = seam.loot_latch.0;
seam.loot_latch.0 = Some(guid);
debug!(
"net: loot response {guid:#x} type {loot_type} gold {gold} {} item(s)",
@@ -76,6 +77,7 @@ fn on_response(
select.select_unit(guid);
let seam = &mut select.seam;
seam.loot.open(guid, loot_type, gold, rows);
seam.loot.note_replaced_latch(latch_before);
seam.loot.ask_rows(&items, &seam.net);
if player.is_some_and(|p| {
p.foreign_mover.is_none()
@@ -459,3 +459,43 @@ fn corpse_map_position_binding() {
assert!((x - 0.25).abs() < 1e-6 && (y - 0.75).abs() < 1e-6);
assert!(s.errors().is_empty(), "script errors: {:?}", s.errors());
}
/// Both timers answer whole seconds: the release timer truncates its milliseconds by a signed
/// divide (`0x48b5ae`-`0x48b5bd`), the reclaim delay floors them by an unsigned one
/// (`0x48b5f0`-`0x48b5f7`).
#[test]
fn the_death_timers_answer_whole_seconds() {
let mut s = UiScript::new().unwrap();
s.set_death(DeathUiState {
release_remaining: Some(299.7),
recovery_delay: 0.4,
..Default::default()
});
assert_eq!(
s.eval::<f64>("return GetReleaseTimeRemaining()").unwrap(),
299.0
);
assert_eq!(
s.eval::<f64>("return GetCorpseRecoveryDelay()").unwrap(),
0.0
);
s.set_death(DeathUiState {
release_remaining: Some(0.4),
recovery_delay: 1.6,
..Default::default()
});
assert_eq!(
s.eval::<f64>("return GetReleaseTimeRemaining()").unwrap(),
0.0
);
assert_eq!(
s.eval::<f64>("return GetCorpseRecoveryDelay()").unwrap(),
1.0
);
// No timer: `0x4962a0` answers -1000 ms, which the signed divide keeps as -1.
s.set_death(DeathUiState::default());
assert_eq!(
s.eval::<f64>("return GetReleaseTimeRemaining()").unwrap(),
-1.0
);
}
@@ -23,20 +23,6 @@ const ELSEWHERE: &[(&str, &str, &str)] = &[];
/// Pairs nothing fires on the verb's path, each with its reason.
const GAP: &[(&str, &str, &str)] = &[
(
"CollapseCraftSkillLine",
"CRAFT_UPDATE",
"the reference commits through the 21-byte thunk 0x4f6be0 (the trainer's 0x4d8c90 shape); \
a no-op here because the craft list is flat — the header law was never ported from \
TradeSkill — so there is nothing to repaint. Whether any 1.12 \
craft list carries more than one group is not established: Enchanting's does not, \
Beast Training is unchecked",
),
(
"ExpandCraftSkillLine",
"CRAFT_UPDATE",
"the same thunk and the same no-op as CollapseCraftSkillLine",
),
(
"SelectGossipOption",
"GOSSIP_ENTER_CODE",
@@ -1662,6 +1662,7 @@ fn the_feed_pushes_the_spells_the_vm_holds_before_a_hover() {
reagents: vec![],
tools: vec![],
spell_level: 0,
group: 0,
skill_line: None,
training_point_cost: 0,
required_level: 0,
+242 -23
View File
@@ -39,8 +39,9 @@ use benilla_assets::{AssetSet, LockRecover, WorldAssets};
#[derive(Resource, Default)]
pub(crate) struct TradeSkillOpens(pub(crate) Vec<u32>);
/// The open book's skill line. The Lua close and the session end clear it: a logout replaces the
/// VM without running the old `OnHide`, so the close alone never comes.
/// The open book's skill line (`[0xbde040]`). An opener of it, the Lua close and the session end
/// clear it: a logout replaces the VM without running the old `OnHide`, so the close alone never
/// comes. A `/reload` keeps it.
#[derive(Resource, Default)]
pub(crate) struct TradeSkillOpen {
pub(crate) line: Option<u32>,
@@ -88,6 +89,17 @@ pub(crate) fn reset_crafts_on_world_enter(
})
}
/// The craft init's type write (`0x4f5ee0` zeroes `[0xbdcfb8]`) on each cascade, with no event:
/// the window is closed under the VM that survives a worldport and under a reload's new one.
pub(crate) fn close_craft_on_world_enter(
mut cascades: MessageReader<crate::net::WorldEnterCascadeMessage>,
mut craft_open: ResMut<crate::ui_craft::CraftOpen>,
) {
if cascades.read().count() > 0 {
craft_open.line = None;
}
}
/// `SpellFocusObject.dbc`, the names on a "Requires: Anvil" line.
#[derive(Resource)]
pub(crate) struct SpellFocus {
@@ -116,7 +128,9 @@ impl Plugin for UiTradeSkillPlugin {
feed_trade_skill.in_set(UnitFeed),
drain_trade_skill.in_set(crate::ui_script::UiDrain),
// In the feed phase, ahead of every feed that pushes the lists.
reset_crafts_on_world_enter.in_set(crate::ui_script::UiFeed),
(reset_crafts_on_world_enter, close_craft_on_world_enter)
.in_set(crate::ui_script::UiFeed)
.before(UnitFeed),
),
);
}
@@ -152,8 +166,10 @@ fn load_spell_focus(mut commands: Commands, assets: Option<Res<WorldAssets>>) {
}
}
/// Open the book for each intercepted opener: its line is the opener's `SkillLineAbility` row
/// (3908 Tailoring is line 197), the client's `SkillLineRecIndex_Find` (`0x6de040`).
/// Toggle the book for each intercepted opener (`0x4fc910`, `0x4f6000`): its line is the opener's
/// `SkillLineAbility` row (3908 Tailoring is line 197), the client's `SkillLineRecIndex_Find`
/// (`0x6de040`). The open line's opener closes it (`0x4fc918`), the open craft type's its window
/// (`0x4f6006`); any other opens.
fn open_trade_skill(
mut opens: ResMut<TradeSkillOpens>,
mut open: ResMut<TradeSkillOpen>,
@@ -179,11 +195,19 @@ fn open_trade_skill(
.and_then(|d| u32::try_from(d.effect_misc_value[0]).ok())
.unwrap_or(0);
if craft_type != 0 {
debug!(
"ui_tradeskill: opener {spell_id} opens the CraftFrame (line {line}, craft type {craft_type})"
);
craft_open.line = Some(line);
craft_open.craft_type = craft_type;
if craft_open.line.is_some() && craft_open.craft_type == craft_type {
debug!("ui_tradeskill: opener {spell_id} closes the CraftFrame");
craft_open.line = None;
} else {
debug!(
"ui_tradeskill: opener {spell_id} opens the CraftFrame (line {line}, craft type {craft_type})"
);
craft_open.line = Some(line);
craft_open.craft_type = craft_type;
}
} else if open.line == Some(line) {
debug!("ui_tradeskill: opener {spell_id} closes skill line {line}");
open.line = None;
} else {
debug!("ui_tradeskill: opener {spell_id} opens skill line {line}");
open.line = Some(line);
@@ -593,6 +617,7 @@ fn feed_trade_skill(
commands: Res<NetCommands>,
clock: Res<crate::ui_script::UiClock>,
mut memo: Local<crate::ui_script::VmMemo<TradeMemo>>,
mut engine: Local<TradeEngine>,
) {
vm.feed(|script, cooldowns, fires| {
let Some(script) = script else {
@@ -655,19 +680,28 @@ fn feed_trade_skill(
})
})();
// The line stays open while a frame cannot resolve its book (a worldport's purge of our
// own player): only a close ends it (`0x4fc870`, `0x4fc920`).
let fresh = match fresh {
None if open.line.is_some() => memo.state.clone(),
f => f,
};
// `CloseTradeSkill` closes the VM's window and signals `TRADE_SKILL_CLOSE` in the verb
// (`0x4fc884`).
let closed_in_place = !script.trade_skill_open();
// The getters' item callbacks, kept by their calls; each record that landed rebuilds
// (`0x4fdc30` → `0x4fdc3c`), and a refusal runs it with status 0, which does nothing
// (`0x4fdc38`).
memo.item_waits.extend(script.take_trade_skill_item_waits());
let arrivals = landed(&mut memo.item_waits, &items);
let opened = match (&memo.state, &fresh) {
(None, Some(_)) => true,
(Some(l), Some(f)) => l.line != f.line,
_ => false,
};
// (`0x4fdc38`). The item cache holds them, so they outlive a VM.
engine
.item_waits
.extend(script.take_trade_skill_item_waits());
let arrivals = landed(&mut engine.item_waits, &items);
// An open is the open line's change, which a `/reload` keeps (`[0xbde040]`): the new VM
// takes the list with no event, as its world-enter init left it.
let opened = fresh.as_ref().is_some_and(|f| engine.shown != Some(f.line));
if fresh.is_some() || open.line.is_none() {
engine.shown = fresh.as_ref().map(|f| f.line);
}
// Every push is silent: the rebuilds signal, and the getters read the state at their call.
if fresh != memo.state {
script.set_trade_skill(fresh.clone());
@@ -708,9 +742,10 @@ fn feed_trade_skill(
}
// Each product record a build waited on runs its callback as it lands (`0x4fc8e0`),
// which rebuilds with flag 1 once nothing is pending.
memo.build_waits
engine
.build_waits
.extend(script.take_trade_skill_build_waits());
let built = landed(&mut memo.build_waits, &items);
let built = landed(&mut engine.build_waits, &items);
for _ in 0..built {
if script.trade_skill_record_landed()
&& script.rebuild_trade_skill_with(true, &mut |_| {})
@@ -722,14 +757,23 @@ fn feed_trade_skill(
})
}
/// What [`feed_trade_skill`] remembers from its last frame.
/// What [`feed_trade_skill`] remembers from its last frame, per VM.
#[derive(Default)]
struct TradeMemo {
/// The state it last pushed.
state: Option<TradeSkillState>,
/// The item records the getters' calls wait on, one per call.
}
/// What [`feed_trade_skill`] keeps across VMs, as the engine does across a `/reload`.
#[derive(Default)]
struct TradeEngine {
/// The line whose open it signalled; a frame that finds no line open clears it, so the next
/// session's first open signals again.
shown: Option<u32>,
/// The item records the getters' callbacks wait on in the item cache, one per call
/// (`0x4fdc30`), which no cancel removes (`0x4fc890`).
item_waits: Vec<u32>,
/// The product records the builds wait on, one per miss.
/// The product records the builds' callbacks wait on, one per miss (`0x4fc8e0`).
build_waits: Vec<u32>,
}
@@ -1906,4 +1950,179 @@ mod tests {
assert_eq!(app.world().resource::<TradeSkillOpen>().line, None);
}
/// The Bolt of Silk Cloth book behind the Tailoring opener 3908, its product's record in
/// flight, fed and opened as the client runs them; each VM installed through [`listening`].
fn silk_book() -> App {
const SILK: u32 = 4305;
let (tx, _rx) = crossbeam_channel::unbounded();
let mut app = App::new();
let mut actions = PlayerActions::default();
actions.spells.extend([3839, 3908]);
actions.profession_order.push(3839);
let mut effect_item_type = [0; 3];
effect_item_type[0] = SILK;
let bolt = SpellDisplay {
name: "Bolt of Silk Cloth".into(),
attributes: SPELL_ATTR_IS_TRADESKILL,
effects: [SPELL_EFFECT_CREATE_ITEM, 0, 0],
effect_item_type,
..Default::default()
};
let opener = SpellDisplay {
name: "Tailoring".into(),
effects: [benilla_formats::SPELL_EFFECT_TRADE_SKILL, 0, 0],
..Default::default()
};
let sla = benilla_formats::SlaInfo {
skill_id: 197,
req_skill_value: 1,
forward_spell_id: 0,
trivial_low: 1,
trivial_high: 2,
};
app.init_resource::<TradeSkillOpen>()
.init_resource::<TradeSkillOpens>()
.init_resource::<crate::ui_craft::CraftOpen>()
.insert_resource(actions)
.init_resource::<crate::net::GuidIndex>()
.init_resource::<Items>()
.init_resource::<crate::spell::Cooldowns>()
.init_resource::<crate::ui_script::UiClock>()
.insert_resource(crate::net::NetCommands(tx))
.insert_resource(Spells {
catalog: benilla_formats::SpellCatalog::from_displays(
[(3839, bolt), (3908, opener)].into_iter().collect(),
),
..Spells::empty_for_tests()
})
.insert_resource(SkillLines {
catalog: benilla_formats::SkillLineCatalog::from_abilities([
(3839, sla),
(3908, sla),
]),
});
app.world_mut()
.spawn((ObjectStore(Default::default()), SelfPlayer));
app.insert_non_send_resource(listening());
app.add_systems(Update, (open_trade_skill, feed_trade_skill).chain());
app
}
/// A VM that records the book's three events.
fn listening() -> UiScript {
let script = UiScript::new().unwrap();
script
.run(
"HEARD = {} local f = CreateFrame('Frame') f:RegisterEvent('TRADE_SKILL_SHOW') \
f:RegisterEvent('TRADE_SKILL_UPDATE') f:RegisterEvent('TRADE_SKILL_CLOSE') \
f:SetScript('OnEvent', function() table.insert(HEARD, event) end)",
)
.unwrap();
script
}
/// One frame, and what the VM heard in it.
fn heard(app: &mut App) -> Vec<String> {
app.update();
app.world()
.non_send_resource::<UiScript>()
.eval::<Vec<String>>("local h = HEARD HEARD = {} return h")
.unwrap()
}
/// A `/reload` (`0x490bd0`): the leave sweep zeroes the pending count (`0x4fc8cb`), a new VM
/// replaces the old, and the world-enter init zeroes the list (`0x4fc750` at `0x4909bf`).
fn reload(app: &mut App) {
let mut old = app.world_mut().non_send_resource_mut::<UiScript>();
old.trade_skill_cancel_waits();
let mut script = listening();
script.reset_crafts_on_world_enter();
app.insert_non_send_resource(script);
}
/// A `/reload` with the book open keeps its line (`[0xbde040]`) and signals nothing, so the
/// new interface shows no window and reads an empty list under the line. The product record
/// the old build waited on still runs its callback (`0x4fc8e0`), whose rebuild signals the
/// update into the new interface (`0x4fc900`).
#[test]
fn a_reload_keeps_the_book_open_unshown_until_a_rebuild() {
let mut app = silk_book();
app.world_mut()
.resource_mut::<TradeSkillOpens>()
.0
.push(3908);
assert_eq!(heard(&mut app), ["TRADE_SKILL_SHOW"]);
reload(&mut app);
assert!(heard(&mut app).is_empty(), "no update, no show");
let script = app.world().non_send_resource::<UiScript>();
assert_eq!(
script
.eval::<(i64, String)>("return GetNumTradeSkills(), (GetTradeSkillLine())")
.unwrap(),
(0, "Skill 197".into())
);
app.world_mut().resource_mut::<Items>().insert_template(
4305,
Some(crate::items::test_template("Bolt of Silk Cloth")),
);
assert_eq!(heard(&mut app), ["TRADE_SKILL_UPDATE"]);
assert!(
app.world()
.non_send_resource::<UiScript>()
.eval::<i64>("return GetNumTradeSkills()")
.unwrap()
> 0
);
}
/// An opener toggles the book (`0x4fc910`): the open line's opener closes it with
/// `TRADE_SKILL_CLOSE` (`0x4fc918`-`0x4fc930`), and the next opens it again. After a reload
/// the line is still open, so the first opener closes the unshown book and the second shows it.
#[test]
fn an_opener_of_the_open_line_closes_the_book() {
let mut app = silk_book();
let open = |app: &mut App| {
app.world_mut()
.resource_mut::<TradeSkillOpens>()
.0
.push(3908);
heard(app)
};
assert_eq!(open(&mut app), ["TRADE_SKILL_SHOW"]);
assert_eq!(open(&mut app), ["TRADE_SKILL_CLOSE"]);
assert_eq!(app.world().resource::<TradeSkillOpen>().line, None);
assert_eq!(open(&mut app), ["TRADE_SKILL_SHOW"]);
reload(&mut app);
assert!(heard(&mut app).is_empty());
assert_eq!(open(&mut app), ["TRADE_SKILL_CLOSE"]);
assert_eq!(open(&mut app), ["TRADE_SKILL_SHOW"]);
}
/// A frame that cannot resolve the book while its line stays open, as a worldport's purge of
/// our own player leaves it, closes nothing: only a close ends the line (`0x4fc870`,
/// `0x4fc920`), and the player's return signals no second open.
#[test]
fn a_frame_without_our_player_keeps_the_book_open() {
let mut app = silk_book();
app.world_mut()
.resource_mut::<TradeSkillOpens>()
.0
.push(3908);
assert_eq!(heard(&mut app), ["TRADE_SKILL_SHOW"]);
let me = app
.world_mut()
.query_filtered::<Entity, With<SelfPlayer>>()
.single(app.world())
.unwrap();
app.world_mut().despawn(me);
assert!(heard(&mut app).is_empty(), "no close");
app.world_mut()
.spawn((ObjectStore(Default::default()), SelfPlayer));
assert!(heard(&mut app).is_empty(), "no second open");
assert!(app
.world()
.non_send_resource::<UiScript>()
.trade_skill_open());
}
}
@@ -538,6 +538,7 @@ fn a_hovered_or_selected_craft_row_paints_its_label_white() {
tools: vec![],
tooltip: CraftTooltip::Spell(spell_id),
spell_level: 0,
group: 0,
skill_line: None,
training_point_cost: 0,
required_level: 0,
+520 -89
View File
@@ -3,11 +3,11 @@
//! window has one action button, `DoCraft(GetCraftSelectionIndex())` (`Blizzard_CraftUI.xml:667`),
//! and no Create All, so a craft intent is a bare spell id.
//!
//! Not built: the reference's header rows (`0x4f60c0`). The list is flat, `GetCraftInfo` never
//! answers `"header"` and `Expand`/`CollapseCraftSkillLine` do nothing; Enchanting, with a single
//! group, renders flat in the reference too.
//! The engine owns the row array (`0x4f60c0`): the recipes in the list's learn order, then a
//! header row per group once there are two, sorted by the craft type's comparator; every Lua
//! index is 1-based into that whole array, the displayed rows first ([`recipe`]).
use mlua::{Lua, MultiValue, Value, Variadic};
use mlua::{Lua, MultiValue, Value};
use super::binding_abi::{self, number_arg};
use super::item_stats::item_link;
@@ -122,8 +122,11 @@ pub struct CraftRecipe {
/// `Spell.dbc` `spellLevel` (`+0x74`), the Beast Training comparator's rank key. The
/// `requiredLevel` return reads the learned spell's instead (`0x4f705f` → `0x60c840`).
pub spell_level: u32,
/// The name of the recipe's group key, the skill line of the spell's ability (row `+0x04`,
/// `0x4f61b1`), for `GetCraftSkillLine`; `None` when `SkillLine.dbc` has no such row.
/// The recipe's group key (row `+0x04`): the skill line of the spell's ability (`0x4f61b1`),
/// 0 with none (`0x4f61b6`).
pub group: u32,
/// The name of [`Self::group`], for `GetCraftSkillLine` and the header row; `None` when
/// `SkillLine.dbc` has no such row.
pub skill_line: Option<String>,
/// `GetCraftInfo`'s sixth value, the training-point cost (`0x4f7078`).
pub training_point_cost: u32,
@@ -157,34 +160,191 @@ const CRAFT_TYPE_BEAST_TRAINING: u32 = 1;
/// Enchanting's craft type, the one `GetCraftDisplaySkillLine` answers for (`0x4f6ce3`).
const CRAFT_TYPE_ENCHANTING: u32 = 3;
/// The craft row order: difficulty tier (`[+0xc]`) ascending, then name (collator `0x64a4c0`),
/// then, at Beast Training only (`0x4f6920`; every other type uses `0x4f67a0`), `spellLevel`
/// ascending, which orders a pet ability's ranks.
/// One row of the array (`0xbdcf78`): a header (spell id -1, `0x4f65c5`) keyed by its group, or
/// a recipe's position in [`CraftState::recipes`].
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Row {
Header { group: u32 },
Recipe(usize),
}
/// One header of the array (`0xbdcf88`): its group key, the group's name, its member count
/// (`+4`) and whether it is collapsed (`+8`).
#[derive(Clone, Debug, PartialEq)]
pub(crate) struct Header {
group: u32,
name: Option<String>,
members: u32,
collapsed: bool,
}
/// `0x4f6ac0`: the same key ties; a key with no `SkillLine.dbc` row ties (`0x4f6b03`); else the
/// names, case-blind (`0x64a4c0`).
fn header_order(a: &Header, b: &Header) -> i32 {
if a.group == b.group {
return 0;
}
match (&a.name, &b.name) {
(Some(x), Some(y)) => crate::crt::str_cmp_i(x, y),
_ => 0,
}
}
/// The row comparators, `0x4f6920` at Beast Training and `0x4f67a0` at every other type
/// (`0x4f6765`). With headers, each recipe takes its group's position in the header array and is
/// shown unless the group is collapsed; a header row skips the scan (`0x4f67fd`, `0x4f6818`;
/// `0x4f697d`, `0x4f6998`), so it keeps position 0 and shows. Shown rows come first, then by
/// position; then a header ahead of a recipe, and two headers answer 1 (`0x4f68e9`); then the
/// difficulty bucket ascending (`0x4f68ac`), the names case-blind (`0x64a4c0`) and, at Beast
/// Training, `spellLevel` ascending (`0x4f6a5b`).
///
/// Deviation: a last `spell_id` key breaks the remaining ties (Charge's six ranks all have
/// `spellLevel` 0), because the reference leaves them to its qsort over an array benilla does not
/// reproduce; ascending id is ascending rank in every 1.12 pet-ability family.
fn recipe_order(a: &CraftRecipe, b: &CraftRecipe, craft_type: u32) -> std::cmp::Ordering {
a.difficulty
.bucket()
.cmp(&b.difficulty.bucket())
.then_with(|| collate(&a.name, &b.name))
.then_with(|| {
if craft_type == CRAFT_TYPE_BEAST_TRAINING {
a.spell_level.cmp(&b.spell_level)
} else {
std::cmp::Ordering::Equal
}
})
.then_with(|| a.spell_id.cmp(&b.spell_id))
fn row_order(a: &Row, b: &Row, headers: &[Header], c: &CraftState) -> i32 {
let group = |r: &Row| match *r {
Row::Header { .. } => None,
Row::Recipe(i) => Some(c.recipes[i].group),
};
let place = |g: Option<u32>| {
g.and_then(|g| headers.iter().position(|h| h.group == g))
.map_or((0, true), |p| (p, !headers[p].collapsed))
};
if !headers.is_empty() {
let ((pa, va), (pb, vb)) = (place(group(a)), place(group(b)));
match (va, vb) {
(false, false) => return 0,
(false, true) => return 1,
(true, false) => return -1,
_ if pa != pb => return if pb < pa { 1 } else { -1 },
_ => {}
}
}
let (ra, rb) = match (*a, *b) {
(Row::Header { .. }, Row::Header { .. }) => return 1,
(Row::Header { .. }, _) => return -1,
(_, Row::Header { .. }) => return 1,
(Row::Recipe(x), Row::Recipe(y)) => (&c.recipes[x], &c.recipes[y]),
};
let (ba, bb) = (ra.difficulty.bucket(), rb.difficulty.bucket());
if ba != bb {
return if ba > bb { 1 } else { -1 };
}
let by_name = crate::crt::str_cmp_i(&ra.name, &rb.name);
if by_name != 0 {
return by_name;
}
let by_level = if c.craft_type == CRAFT_TYPE_BEAST_TRAINING {
ra.spell_level.cmp(&rb.spell_level)
} else {
std::cmp::Ordering::Equal
};
match by_level.then_with(|| ra.spell_id.cmp(&rb.spell_id)) {
std::cmp::Ordering::Less => -1,
std::cmp::Ordering::Equal => 0,
std::cmp::Ordering::Greater => 1,
}
}
/// Approximates the case-insensitive enUS collator the craft comparators call (`0x64a4c0`; the
/// trainer rows use `0x64a480`): case-folded order, raw bytes breaking ties.
fn collate(a: &str, b: &str) -> std::cmp::Ordering {
a.to_lowercase()
.cmp(&b.to_lowercase())
.then_with(|| a.cmp(b))
/// The build `0x4f60c0` past its open check: the rows refilled with the recipes in the list's
/// order, one header per group in the order the recipes first name it (`0x4f6404`-`0x4f64cb`),
/// a header row each (`0x4f65ba`-`0x4f65f9`), a single header dropped (`0x4f65fb`), then the
/// recount and sorts.
pub(crate) fn build(model: &mut Model) {
let Some(c) = model.craft.as_ref() else {
clear(model);
return;
};
let mut headers: Vec<Header> = Vec::new();
for r in &c.recipes {
if headers.iter().all(|h| h.group != r.group) {
headers.push(Header {
group: r.group,
name: r.skill_line.clone(),
members: 0,
collapsed: false,
});
}
}
if headers.len() == 1 {
headers.clear();
}
let mut rows: Vec<Row> = (0..c.recipes.len()).map(Row::Recipe).collect();
rows.extend(headers.iter().map(|h| Row::Header { group: h.group }));
model.craft_rows = rows;
model.craft_headers = headers;
recount(model);
}
/// The counts a closed window's build zeroes ahead of its open check (`0x4f60d1`-`0x4f60e3`).
fn clear(model: &mut Model) {
model.craft_rows.clear();
model.craft_headers.clear();
model.craft_visible = 0;
}
/// `0x4f6630`: each header's collapse word from its bit by its position as the array stands
/// (`0x4f6650`-`0x4f666d`) and its member count; the displayed count less each row whose group
/// is empty and each recipe of a collapsed group (`0x4f66e1`-`0x4f673a`, a group not found
/// reading header 0); then the CRT `qsort` of the headers (`0x4f6756`) and of the rows
/// (`0x4f6785`) as the last sort left them.
fn recount(model: &mut Model) {
let Some(c) = model.craft.as_ref() else {
clear(model);
return;
};
let mask = model.craft_fold_mask;
let mut headers = std::mem::take(&mut model.craft_headers);
for (j, h) in headers.iter_mut().enumerate() {
h.collapsed = mask & (1u32 << (j & 31)) == 0;
h.members = 0;
}
let group = |r: &Row| match *r {
Row::Header { group } => group,
Row::Recipe(i) => c.recipes[i].group,
};
for r in &model.craft_rows {
if let Row::Recipe(_) = r {
for h in headers.iter_mut().filter(|h| h.group == group(r)) {
h.members += 1;
}
}
}
let mut visible = model.craft_rows.len();
if !headers.is_empty() {
for r in &model.craft_rows {
let h = headers
.iter()
.find(|h| h.group == group(r))
.unwrap_or(&headers[0]);
if h.members == 0 || (matches!(r, Row::Recipe(_)) && h.collapsed) {
visible -= 1;
}
}
}
crate::crt::qsort(&mut headers, header_order);
let mut rows = std::mem::take(&mut model.craft_rows);
crate::crt::qsort(&mut rows, |a, b| row_order(a, b, &headers, c));
model.craft_rows = rows;
model.craft_headers = headers;
model.craft_visible = visible;
}
/// The collapse writer `0x4f6be0`: the mask stored, the recount and sorts (`0x4f6630`), then
/// `CRAFT_UPDATE` in place (`0x4f6bf0`).
fn set_fold_mask(model: &mut Model, mask: u32) {
model.craft_fold_mask = mask;
recount(model);
model.raise("CRAFT_UPDATE", Vec::new());
}
/// `0x4f6b30`: a header row's position in the header array, `None` for a recipe row or an index
/// past the rows.
fn header_position(model: &Model, row: usize) -> Option<usize> {
match model.craft_rows.get(row)? {
Row::Header { group } => model.craft_headers.iter().position(|h| h.group == *group),
Row::Recipe(_) => None,
}
}
impl CraftState {
@@ -203,42 +363,42 @@ impl CraftState {
impl super::UiScript {
/// Push the open craft window's snapshot, or mark it closed with `None`, which keeps the
/// list and selection as the reference's close does (`0x4f5fe0`). A push sorts the rows and
/// keeps the selection on its spell id, clearing it when that recipe is gone.
/// list and selection as the reference's close does (`0x4f5fe0`). A push builds the rows
/// (`0x4f60c0`) from the recipes in the list's order; the selection rides its spell id.
pub fn set_craft(&mut self, state: Option<CraftState>) {
let mut model = self.model_mut();
model.craft_open = state.is_some();
match state {
None => {}
Some(mut s) => {
let craft_type = s.craft_type;
s.recipes.sort_by(|a, b| recipe_order(a, b, craft_type));
let prev_spell_id = model
.craft_selection
.checked_sub(1)
.and_then(|i| model.craft.as_ref().and_then(|c| c.recipes.get(i as usize)))
.map(|r| r.spell_id);
model.craft_selection = prev_spell_id
.and_then(|sid| s.recipes.iter().position(|r| r.spell_id == sid))
.map_or(0, |i| (i + 1) as u32);
model.craft = Some(s);
}
if let Some(s) = state {
model.craft = Some(s);
build(&mut model);
}
}
/// The open's resets (`0x4f601c`-`0x4f602c`): the selection cleared and every group expanded,
/// then the build (`0x4f6036`).
pub fn craft_opened(&mut self) {
let mut model = self.model_mut();
model.craft_selection = 0;
model.craft_fold_mask = u32::MAX;
build(&mut model);
}
/// A rebuild of the craft list (`0x4f60c0`), as the bag and item watchers run one on each of
/// their runs: while a craft window is open, the state read again where `refresh` brings the
/// watcher's change in; the rows the last push sorted sort the same. Whether the window is
/// open, for the caller's `CRAFT_UPDATE` (`0x4f661a`), signalled whether or not anything
/// changed; a closed window builds nothing (`0x4f60e3`).
/// watcher's change in, and the rows built again. Whether the window is open, for the caller's
/// `CRAFT_UPDATE` (`0x4f661a`), signalled whether or not anything changed; a closed window
/// zeroes the counts and builds nothing (`0x4f60d1`-`0x4f60e3`).
pub fn rebuild_craft(&mut self, refresh: &mut dyn FnMut(&mut CraftState)) -> bool {
let mut model = self.model_mut();
if model.craft_open {
if let Some(c) = model.craft.as_mut() {
refresh(c);
}
if !model.craft_open {
clear(&mut model);
return false;
}
model.craft_open
if let Some(c) = model.craft.as_mut() {
refresh(c);
}
build(&mut model);
true
}
/// The item records the getters' calls missed since the last take, one per call.
@@ -263,14 +423,26 @@ impl super::UiScript {
}
}
/// The recipe at a 1-based index.
fn recipe(model: &Model, index: usize) -> Option<&CraftRecipe> {
let n = index.checked_sub(1)?;
model.craft.as_ref()?.recipes.get(n)
/// The recipe at a 1-based index into the whole row array, bounded by the full count
/// (`0xbdcfc0`); `None` on a header, whose spell id -1 finds no record.
pub(crate) fn recipe(model: &Model, index: usize) -> Option<&CraftRecipe> {
match model.craft_rows.get(index.checked_sub(1)?)? {
Row::Recipe(i) => model.craft.as_ref()?.recipes.get(*i),
Row::Header { .. } => None,
}
}
fn num_recipes(model: &Model) -> usize {
model.craft.as_ref().map_or(0, |c| c.recipes.len())
/// The row's group name (`+4`): a recipe's line, or its header's.
fn row_line(model: &Model, row: usize) -> Option<&String> {
match model.craft_rows.get(row)? {
Row::Recipe(i) => model.craft.as_ref()?.recipes.get(*i)?.skill_line.as_ref(),
Row::Header { group } => model
.craft_headers
.iter()
.find(|h| h.group == *group)?
.name
.as_ref(),
}
}
fn opt_str(lua: &Lua, s: Option<&String>) -> mlua::Result<Value> {
@@ -299,21 +471,15 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
)?;
// GetCraftSkillLine(index) (`0x4f7210`): the name of the skill line in the row's group field
// (`+0x04`), nil for a row outside the list (`dec`, then an unsigned compare against the row
// count, `ds:0xbdcfc0`) or a line `SkillLine.dbc` lacks. The list here is flat: the
// reference's header rows are not built, so an index counts recipes alone.
// (`+0x04`), a header row's included, nil for a row outside the list (`dec`, then an unsigned
// compare against the row count, `ds:0xbdcfc0`) or a line `SkillLine.dbc` lacks.
g.set(
"GetCraftSkillLine",
lua.create_function(|lua, index: Value| {
let row = binding_abi::number_arg(lua, index, "Usage: GetCraftSkillLine(index)")?
.wrapping_sub(1) as u32;
let model = lua.app_data_ref::<Model>().expect("model app_data");
let line = model
.craft
.as_ref()
.and_then(|c| c.recipes.get(row as usize))
.and_then(|r| r.skill_line.as_ref());
opt_str(lua, line)
opt_str(lua, row_line(&model, row as usize))
})?,
)?;
@@ -340,12 +506,12 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
})?,
)?;
// GetNumCrafts() → the recipe count, 0 when closed.
// GetNumCrafts() (`0x4f6e70`): the displayed count (`0xbdcfc8`), headers included.
g.set(
"GetNumCrafts",
lua.create_function(|lua, ()| {
let model = lua.app_data_ref::<Model>().expect("model app_data");
Ok(num_recipes(&model) as i64)
Ok(model.craft_visible as i64)
})?,
)?;
@@ -400,16 +566,41 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
// GetCraftInfo(index) → craftName, craftSubSpellName, craftType, numAvailable, isExpanded,
// trainingPointCost, requiredLevel (`Blizzard_CraftUI.lua:168`); a miss pushes the seven too.
// `isExpanded` is always nil. The cost and the level are the app's, read off the pet bar's
// unit (`0xb714a0`) for the spell a pet-learn effect teaches (`0x4f6fe6`-`0x4f7093`).
// A header row answers its line's name, nil, `header`, 0, 1 while its mask bit by its place
// in the sorted header array is set or nil while clear (`0x4f6f4f` → `0x4f6b80`, `0x4f6bc1`),
// not the collapse word the recount stored before the sort, then 0, 0; a recipe's
// `isExpanded` is nil. The cost and the level are the app's, read off the pet bar's unit
// (`0xb714a0`) for the spell a pet-learn effect teaches (`0x4f6fe6`-`0x4f7093`).
g.set(
"GetCraftInfo",
lua.create_function(|lua, index: Value| {
// `is-number` else `Usage: GetCraftInfo(index)` (`0x84d398`, `0x4f6ea9`).
let index = binding_abi::index_arg(lua, index, "Usage: GetCraftInfo(index)")?;
let model = lua.app_data_ref::<Model>().expect("model app_data");
let header = index.checked_sub(1).and_then(|row| {
header_position(&model, row).and_then(|p| {
let collapsed = model.craft_fold_mask & (1u32 << (p & 31)) == 0;
model.craft_headers[p].name.clone().map(|n| (n, collapsed))
})
});
if let Some((name, collapsed)) = header {
return Ok(MultiValue::from_vec(vec![
Value::String(lua.create_string(&name)?),
Value::Nil,
Value::String(lua.create_string("header")?),
Value::Integer(0),
if collapsed {
Value::Nil
} else {
Value::Integer(1)
},
Value::Integer(0),
Value::Integer(0),
]));
}
let Some(r) = recipe(&model, index) else {
// `0x4f70a4`: nil, nil, nil, 0, nil, 0, 0.
// `0x4f70a4`: nil, nil, nil, 0, nil, 0, 0, a header with no `SkillLine.dbc` row
// included (`0x4f6f1a`).
return Ok(binding_abi::tuple(&[
None,
None,
@@ -553,20 +744,16 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
})?,
)?;
// SelectCraft(index) / GetCraftSelectionIndex(): the selection, 1-based with 0 for none; an
// out-of-range select clears it, and the getter answers 0 past the recipe count.
// SelectCraft(index) (`0x4f70f0` → `0x4f6050`) stores the row's spell id, 0 for a header or an
// index past the rows; GetCraftSelectionIndex() (`0x4f7130` → `0x4f6080`) answers the
// position of that spell's row plus 1, 0 for none or a spell no row holds.
g.set(
"SelectCraft",
lua.create_function(|lua, index: Value| {
// `is-number` else `Usage: SelectCraft(index)` (`0x84d3b4`, `0x4f7101`).
let index = binding_abi::index_arg32(lua, index, "Usage: SelectCraft(index)")?;
let mut model = lua.app_data_mut::<Model>().expect("model app_data");
let count = num_recipes(&model) as u32;
model.craft_selection = if index >= 1 && index <= count {
index
} else {
0
};
model.craft_selection = recipe(&model, index as usize).map_or(0, |r| r.spell_id);
Ok(())
})?,
)?;
@@ -574,9 +761,14 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
"GetCraftSelectionIndex",
lua.create_function(|lua, ()| {
let model = lua.app_data_ref::<Model>().expect("model app_data");
let count = num_recipes(&model) as u32;
let sel = model.craft_selection;
Ok(i64::from(if sel >= 1 && sel <= count { sel } else { 0 }))
let at = (sel != 0)
.then(|| {
(1..=model.craft_rows.len())
.find(|&i| recipe(&model, i).is_some_and(|r| r.spell_id == sel))
})
.flatten();
Ok(at.unwrap_or(0) as i64)
})?,
)?;
@@ -615,19 +807,52 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
})?,
)?;
// Expand/CollapseCraftSkillLine(index): no-ops over the flat list (module doc).
// Expand/CollapseCraftSkillLine(index) (`0x4f7c90`, `0x4f7c10`): an index of 0 or below
// expands or collapses every group (`0x4f7cc7`, `0x4f7c47`); else the row must be a header
// (`0x4f6b30`), whose bit by its array position is set or cleared (`0x4f7cf2`, `0x4f7c71`),
// and any other row raises. Each write re-sorts and signals `CRAFT_UPDATE` (`0x4f6be0`).
g.set(
"ExpandCraftSkillLine",
lua.create_function(|_, _args: Variadic<Value>| Ok(()))?,
lua.create_function(|lua, index: Value| {
// `is-number` else `Usage: ExpandCraftSkillLine(index)` (`0x84d5a0`, `0x4f7ca1`).
let index = number_arg(lua, index, "Usage: ExpandCraftSkillLine(index)")?;
fold(lua, index, false, "Bad skill line in ExpandCraftSkillLine")
})?,
)?;
g.set(
"CollapseCraftSkillLine",
lua.create_function(|_, _args: Variadic<Value>| Ok(()))?,
lua.create_function(|lua, index: Value| {
// `is-number` else `Usage: CollapseCraftSkillLine(index)` (`0x84d550`, `0x4f7c21`).
let index = number_arg(lua, index, "Usage: CollapseCraftSkillLine(index)")?;
fold(lua, index, true, "Bad skill line in CollapseCraftSkillLine")
})?,
)?;
Ok(())
}
/// A fold verb past its usage check: every group for an index of 0 or below, else the header
/// row's bit, or the verb's `bad` line with nothing touched (`0x4f7c5b`, `0x4f7cdc`).
fn fold(lua: &Lua, index: i32, collapse: bool, bad: &'static str) -> mlua::Result<()> {
super::tick::verb(lua, |model| {
let mask = match index.checked_sub(1).filter(|&row| row >= 0) {
None if collapse => 0,
None => u32::MAX,
Some(row) => {
let bit = 1u32 << (header_position(model, row as usize)? & 31);
if collapse {
model.craft_fold_mask & !bit
} else {
model.craft_fold_mask | bit
}
}
};
set_fold_mask(model, mask);
Some(())
})
.ok_or_else(|| mlua::Error::RuntimeError(bad.into()))
}
#[cfg(test)]
mod tests {
use super::*;
@@ -658,6 +883,7 @@ mod tests {
}],
tools: vec![("Runed Copper Rod".into(), true)],
spell_level: 0,
group: 0,
skill_line: None,
training_point_cost: 0,
required_level: 0,
@@ -863,12 +1089,216 @@ mod tests {
assert!(s
.eval::<bool>("local _,_,t = GetCraftInfo(1) return t ~= 'header'")
.unwrap());
// Expand and collapse do nothing.
s.run("ExpandCraftSkillLine(1) CollapseCraftSkillLine(1)")
.unwrap();
// One group builds no header (`0x4f65fb`), so no row folds.
assert!(s.run("CollapseCraftSkillLine(1)").is_err());
assert_eq!(s.eval::<i64>("return GetNumCrafts()").unwrap(), 2);
}
/// Made-up two-group data for the header mechanism, not a real list: no shipped craft list
/// holds two groups (every learnable Beast Training spell has a line-261 row, so the real one
/// shows a single group and no header). Three rows in line 261 and one in group 0, whose line
/// has no `SkillLine.dbc` row; the names and ids are labels only.
fn two_groups() -> CraftState {
let row = |spell_id: u32, name: &str, group: u32| {
let mut r = recipe(spell_id, name, CraftDifficulty::None, 0);
r.group = group;
r.skill_line = (group != 0).then(|| "Beast Training".to_string());
r
};
CraftState {
name: "Beast Training".into(),
display_line: None,
rank: 0,
max_rank: 0,
craft_type: CRAFT_TYPE_BEAST_TRAINING,
recipes: vec![
row(2649, "Growl", 261),
row(24604, "Furious Howl", 0),
row(1742, "Cower", 261),
row(4187, "Great Stamina", 261),
],
}
}
/// `isExpanded` reads the mask bit at the header's place in the array after the sort
/// (`0x4f6f4f` → `0x4f6b80`, `0x4f6bc1`), where the displayed rows follow the collapse words
/// the recount set before it (`0x4f6650` ahead of `0x4f6756`). A rebuild remakes the headers
/// in the order the recipes name them (`0x4f6404`), so one whose sort moves a header reads
/// the folded bit on the other group: the rows hide one group, the flag names the other.
#[test]
fn a_headers_expanded_flag_reads_its_bit_after_the_sort() {
let row = |spell_id: u32, name: &str, group: u32, line: &str| {
let mut r = recipe(spell_id, name, CraftDifficulty::None, 0);
r.group = group;
r.skill_line = Some(line.to_string());
r
};
// Made-up data: Zeta named first, Alpha sorting first.
let st = CraftState {
name: "Test".into(),
display_line: None,
rank: 0,
max_rank: 0,
craft_type: CRAFT_TYPE_BEAST_TRAINING,
recipes: vec![
row(1, "Zeta One", 270, "Zeta"),
row(2, "Alpha One", 261, "Alpha"),
row(3, "Alpha Two", 261, "Alpha"),
],
};
let mut s = UiScript::new().unwrap();
s.set_craft(Some(st.clone()));
let header = |s: &UiScript, line: &str| {
(1..=2)
.find(|i| {
s.eval::<bool>(&format!("return GetCraftInfo({i}) == '{line}'"))
.unwrap()
})
.unwrap()
};
let expanded = |s: &UiScript, line: &str| {
let at = header(s, line);
s.eval::<Option<i64>>(&format!("local _,_,_,_,e = GetCraftInfo({at}) return e"))
.unwrap()
};
s.run(&format!("CollapseCraftSkillLine({})", header(&s, "Alpha")))
.unwrap();
assert_eq!(s.eval::<i64>("return GetNumCrafts()").unwrap(), 3);
assert_eq!(
(expanded(&s, "Alpha"), expanded(&s, "Zeta")),
(None, Some(1))
);
s.set_craft(Some(st));
assert_eq!(
s.eval::<i64>("return GetNumCrafts()").unwrap(),
4,
"Zeta's word took bit 0 before the sort"
);
assert_eq!(
(expanded(&s, "Alpha"), expanded(&s, "Zeta")),
(None, Some(1)),
"Alpha holds position 0 after it"
);
}
/// The rows the stock window walks, `(name, type, isExpanded)` for each displayed index.
fn shown(s: &UiScript) -> Vec<(Option<String>, Option<String>, Option<i64>)> {
let n = s.eval::<i64>("return GetNumCrafts()").unwrap();
(1..=n)
.map(|i| {
s.eval(&format!("local n,_,t,_,e = GetCraftInfo({i}) return n,t,e"))
.unwrap()
})
.collect()
}
/// Two groups build a header row each (`0x4f60c0`, spell id -1). A header skips the
/// comparator's group scan (`0x4f697d`, `0x4f6998`), so it keeps position 0 and sorts ahead of
/// every recipe; the recipes follow by their group's place in the name-sorted headers, then
/// name. A header answers `header` and its expanded flag (`0x4f6f38`, `0x4f6f4f`); one whose
/// line has no `SkillLine.dbc` row answers the failure tuple (`0x4f6f1a`), and a header holds
/// no recipe for the row verbs.
#[test]
fn two_groups_head_each_group_ahead_of_the_recipes() {
let mut s = UiScript::new().unwrap();
s.set_craft(Some(two_groups()));
let header = |name: Option<&str>| {
(
name.map(str::to_string),
name.map(|_| "header".to_string()),
name.map(|_| 1),
)
};
let rec = |name: &str| (Some(name.to_string()), Some("none".to_string()), None);
// The CRT's `shortsort` over the build's order (`0x73f772`): the tied headers swap, so the
// nameless line 0 heads the array and its recipe leads the shown ones.
assert_eq!(
shown(&s),
[
header(None),
header(Some("Beast Training")),
rec("Furious Howl"),
rec("Cower"),
rec("Great Stamina"),
rec("Growl"),
]
);
let at = (1..=2)
.find(|i| {
s.eval::<bool>(&format!("return GetCraftInfo({i}) == 'Beast Training'"))
.unwrap()
})
.unwrap();
assert_eq!(
s.eval::<String>(&format!("return GetCraftSkillLine({at})"))
.unwrap(),
"Beast Training"
);
assert!(s
.eval::<bool>(&format!("return GetCraftIcon({at}) == nil"))
.unwrap());
s.run(&format!("SelectCraft({at}) DoCraft({at})")).unwrap();
assert_eq!(s.eval::<i64>("return GetCraftSelectionIndex()").unwrap(), 0);
assert!(s.take_craft_dos().is_empty());
assert_eq!(s.arity(&format!("GetCraftInfo({at})")).unwrap(), 7);
}
/// `CollapseCraftSkillLine` clears its header's bit and `ExpandCraftSkillLine` sets it
/// (`0x4f7c71`, `0x4f7cf2`); each re-sorts and signals `CRAFT_UPDATE` in place (`0x4f6be0`). A
/// collapsed group's recipes leave the displayed count and sort past it (`0x4f673a`), its
/// header shows with a nil `isExpanded`; an index of 0 or below folds every group
/// (`0x4f7c47`, `0x4f7cc7`); a recipe row raises (`0x4f7c5d`). The open expands every group
/// (`0x4f602c`).
#[test]
fn the_fold_verbs_fold_a_header_and_every_group_at_zero() {
use crate::script::tick::heard;
let mut s = UiScript::new().unwrap();
// Two named lines, so the header sort never ties (`0x4f6b1e`): Beast Training heads row 1.
let mut st = two_groups();
st.recipes[1].group = 270;
st.recipes[1].skill_line = Some("Pet - Wolf".into());
s.set_craft(Some(st));
heard::listen(&s, &["CRAFT_UPDATE"], Some("GetNumCrafts()"));
let at = |s: &UiScript| {
(1..=2)
.find(|i| {
s.eval::<bool>(&format!("return GetCraftInfo({i}) == 'Beast Training'"))
.unwrap()
})
.unwrap()
};
assert_eq!(at(&s), 1);
s.run(&format!("CollapseCraftSkillLine({})", at(&s)))
.unwrap();
assert_eq!(heard::take(&s), ["CRAFT_UPDATE 3"]);
let rows = shown(&s);
assert!(
rows.contains(&(Some("Beast Training".into()), Some("header".into()), None)),
"{rows:?}"
);
assert_eq!(
rows[2],
(Some("Furious Howl".into()), Some("none".into()), None)
);
let err = s.run("CollapseCraftSkillLine(3)").unwrap_err().to_string();
assert!(
err.contains("Bad skill line in CollapseCraftSkillLine"),
"{err}"
);
assert!(heard::take(&s).is_empty());
s.run(&format!("ExpandCraftSkillLine({})", at(&s))).unwrap();
assert_eq!(heard::take(&s), ["CRAFT_UPDATE 6"]);
s.run("CollapseCraftSkillLine(0)").unwrap();
assert_eq!(heard::take(&s), ["CRAFT_UPDATE 2"]);
s.craft_opened();
assert_eq!(s.eval::<i64>("return GetNumCrafts()").unwrap(), 6);
s.run("CollapseCraftSkillLine(-1) ExpandCraftSkillLine(0)")
.unwrap();
assert_eq!(heard::take(&s), ["CRAFT_UPDATE 2", "CRAFT_UPDATE 6"]);
let err = s.run("ExpandCraftSkillLine('x')").unwrap_err().to_string();
assert!(err.contains("Usage: ExpandCraftSkillLine(index)"), "{err}");
}
/// `GetCraftButtonToken` (`0x4f6c90`) pushes the word at the open craft type (`0xbdcfb8`) in
/// the table at `0x84d0f4`: `USE`, `TRAIN`, `DISGUISE`, `ENSCRIBE`, then a zero word, which
/// pushes nil. A close zeroes the type (`0x4f5fe0`), so a closed window answers `USE`.
@@ -1050,6 +1480,7 @@ mod tests {
reagents: vec![],
tools: vec![],
spell_level: level,
group: 0,
skill_line: None,
training_point_cost: 0,
required_level: 0,
+6 -2
View File
@@ -98,6 +98,8 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
})?,
)?;
// Whole seconds: the milliseconds left over 1000 by a signed, truncating divide
// (`0x48b5ae`-`0x48b5bd`); no timer is -1000 ms, so -1.
g.set(
"GetReleaseTimeRemaining",
lua.create_function(|lua, ()| {
@@ -105,15 +107,17 @@ pub(super) fn install(lua: &Lua) -> mlua::Result<()> {
Ok(model
.death
.release_remaining
.map_or(-1.0, |s| f64::from(s.max(0.0))))
.map_or(-1.0, |s| f64::from(s.max(0.0).trunc())))
})?,
)?;
// Whole seconds: the milliseconds left over 1000 by an unsigned divide, a floor
// (`0x48b5f0`-`0x48b5f7`).
g.set(
"GetCorpseRecoveryDelay",
lua.create_function(|lua, ()| {
let model = lua.app_data_ref::<Model>().expect("model app_data");
Ok(f64::from(model.death.recovery_delay.max(0.0).ceil()))
Ok(f64::from(model.death.recovery_delay.max(0.0).floor()))
})?,
)?;
+19 -1
View File
@@ -886,6 +886,9 @@ pub(crate) struct Model {
/// rows first, and the displayed count (`0xbde054`).
pub(crate) trade_skill_rows: Vec<tradeskill::view::Row>,
pub(crate) trade_skill_visible: usize,
/// The world-enter init zeroed the counts (`0x4fc750`) and no build has run since: a push
/// holds the state without rows until a rebuild (`0x4fca20`) fills them.
pub(crate) trade_skill_unbuilt: bool,
/// The header array as the last sort left it (`0xbde000`).
pub(crate) trade_skill_headers: Vec<tradeskill::view::TradeSkillGroup>,
pub(crate) trade_skill_close: bool,
@@ -917,8 +920,18 @@ pub(crate) struct Model {
pub(crate) craft_open: bool,
/// `DoCraft` spell ids; no count, as the 1.12 CraftFrame has no Create All.
pub(crate) craft_dos: Vec<u32>,
/// The 1-based selection, 0 for none, carried across a re-push by the recipe's spell id.
/// The selected spell id (`0xbdcfbc`), 0 for none, which a header or an index past the rows
/// stores (`0x4f6050`); the index answers by finding its row (`0x4f6080`).
pub(crate) craft_selection: u32,
/// The row array as the last sort left it (`0xbdcf78`, full count `0xbdcfc0`), the displayed
/// rows first, and the displayed count (`0xbdcfc8`).
pub(crate) craft_rows: Vec<craft::Row>,
pub(crate) craft_visible: usize,
/// The header array as the last sort left it (`0xbdcf88`, count `0xbdcfc4`).
pub(crate) craft_headers: Vec<craft::Header>,
/// The collapse mask (`0x84d0f0`), a clear bit a collapsed header by its array position; the
/// open sets it to all ones (`0x4f602c`).
pub(crate) craft_fold_mask: u32,
pub(crate) craft_close: bool,
/// The open loot as the app pushed it; the verbs over it are script calls
@@ -1723,6 +1736,7 @@ impl Model {
trade_skill_dos: Vec::new(),
trade_skill_rows: Vec::new(),
trade_skill_visible: 0,
trade_skill_unbuilt: false,
trade_skill_headers: Vec::new(),
trade_skill_close: false,
trade_skill_collapsed: HashSet::new(),
@@ -1736,6 +1750,10 @@ impl Model {
craft_open: false,
craft_dos: Vec::new(),
craft_selection: 0,
craft_rows: Vec::new(),
craft_visible: 0,
craft_headers: Vec::new(),
craft_fold_mask: u32::MAX,
craft_close: false,
loot: None,
loot_type: 0,
@@ -1262,6 +1262,7 @@ fn set_craft_spell_selects_the_builder_like_the_trainer_hover_does() {
reagents: vec![],
tools: vec![],
spell_level: 0,
group: 0,
skill_line: None,
training_point_cost: 0,
required_level: 0,
@@ -1511,6 +1512,7 @@ fn craft_recipe(spell_id: u32, name: &str, tooltip: CraftTooltip) -> CraftRecipe
reagents: vec![],
tools: vec![],
spell_level: 0,
group: 0,
skill_line: None,
training_point_cost: 0,
required_level: 0,
@@ -1133,11 +1133,7 @@ pub(super) fn install_methods(lua: &Lua, m: &Table) -> mlua::Result<()> {
let reagent_index = binding_abi::index_arg(lua, reagent_index, LINE)?;
let found = {
let model = lua.app_data_ref::<Model>().expect("model app_data");
let Some(c) = &model.craft else {
return Ok(());
};
let Some(recipe) = craft_index.checked_sub(1).and_then(|i| c.recipes.get(i))
else {
let Some(recipe) = crate::script::craft::recipe(&model, craft_index) else {
return Ok(());
};
reagent_index
@@ -1007,8 +1007,8 @@ pub(super) fn install_methods(lua: &Lua, m: &Table) -> mlua::Result<()> {
)?;
// GameTooltip:SetCraftSpell(craftIndex): the craft detail icon's hover
// (`Blizzard_CraftUI.xml:566`). `SetCraftSpell 0x533e90` hands a shared builder the subject the
// app resolved from the recipe's own effects (`CraftRecipe::tooltip`). `craftIndex` is a plain
// recipe position: the craft list has no headers.
// app resolved from the recipe's own effects (`CraftRecipe::tooltip`). `craftIndex` is 1-based
// into the craft rows, where a header holds no recipe.
m.set(
"SetCraftSpell",
lua.create_function(|lua, (this, craft_index): (Table, Value)| {
@@ -1017,10 +1017,7 @@ pub(super) fn install_methods(lua: &Lua, m: &Table) -> mlua::Result<()> {
binding_abi::index_arg(lua, craft_index, "Invalid craft in SetCraftSpell(index)")?;
let subject = {
let model = lua.app_data_ref::<Model>().expect("model app_data");
let Some(c) = &model.craft else {
return Ok(());
};
match craft_index.checked_sub(1).and_then(|i| c.recipes.get(i)) {
match super::craft::recipe(&model, craft_index) {
Some(r) => r.tooltip.clone(),
None => return Ok(()),
}
+19 -9
View File
@@ -169,7 +169,7 @@ impl super::UiScript {
/// selection rides its spell id (`0xbde044`); fold and subclass keys are pruned to live groups,
/// while the inv-slot mask (`0x84dd64`) is never pruned.
/// `None` marks the window closed and keeps the list and selection, as the close does
/// (`0x4fc870`).
/// (`0x4fc870`). After the world-enter init no push builds rows until a rebuild does.
pub fn set_trade_skill(&mut self, state: Option<TradeSkillState>) {
let mut model = self.model_mut();
model.trade_skill_open = state.is_some();
@@ -206,7 +206,9 @@ impl super::UiScript {
.as_ref()
.is_none_or(|t| spells(&t.recipes) != spells(&s.recipes));
model.trade_skill = Some(s);
view::build(&mut model, remake);
if !model.trade_skill_unbuilt {
view::build(&mut model, remake);
}
}
}
}
@@ -239,6 +241,7 @@ impl super::UiScript {
if let Some(t) = model.trade_skill.as_mut() {
refresh(t);
}
model.trade_skill_unbuilt = false;
let complete = view::build(&mut model, remake);
note_build(&mut model);
complete
@@ -248,6 +251,9 @@ impl super::UiScript {
/// records in flight counted and waited on as any build's. Whether its update follows.
pub fn trade_skill_open_build(&mut self) -> bool {
let mut model = self.model_mut();
if std::mem::take(&mut model.trade_skill_unbuilt) {
view::build(&mut model, true);
}
note_build(&mut model);
model.trade_skill_pending == 0
}
@@ -345,21 +351,25 @@ impl super::UiScript {
/// The world-enter inits (`0x4908c0` at `0x4909bf` and `0x4909c4`), which a login, a
/// cross-map worldport and a `/reload` all run, with no event: the tradeskill init `0x4fc750`
/// zeroes the selection (`[0xbde044]`), the visible and held counts (`[0xbde04c]`,
/// `[0xbde054]`), the line key (`[0xbde064]`), so the next push resets the filters, and the
/// armed spell (`[0xbde05c]`, `0x4fc76b`), keeping the count (`[0xbde060]`) and the open marker
/// (`[0xbde040]`); the craft init `0x4f5ee0` zeroes the craft open marker (`[0xbdcfb8]`), its
/// selection and its count (`[0xbdcfc8]`).
/// zeroes the selection (`[0xbde044]`), the row, displayed and header counts (`[0xbde04c]`,
/// `[0xbde054]`, `[0xbde050]`), the line key (`[0xbde064]`), so the next push resets the
/// filters, and the armed spell (`[0xbde05c]`, `0x4fc76b`), keeping the count (`[0xbde060]`)
/// and the open line (`[0xbde040]`), whose list waits for the next rebuild; the craft init
/// `0x4f5ee0` zeroes the craft type (`[0xbdcfb8]`), which closes its window, its selection and
/// its counts (`[0xbdcfbc]`-`[0xbdcfc8]`).
pub fn reset_crafts_on_world_enter(&mut self) {
let mut model = self.model_mut();
model.trade_skill = None;
view::build(&mut model, true);
model.trade_skill_rows.clear();
model.trade_skill_headers.clear();
model.trade_skill_visible = 0;
model.trade_skill_unbuilt = true;
model.trade_skill_selected_spell = 0;
model.trade_skill_last_line = 0;
model.trade_skill_repeat_spell = 0;
model.craft = None;
model.craft_open = false;
model.craft_selection = 0;
super::craft::build(&mut model);
}
/// Seat the repeat count a previous VM left (`[0xbde060]`), which the world-enter init keeps
@@ -1548,3 +1548,32 @@ fn the_item_stats_getter_waits_only_on_a_record_in_flight() {
.unwrap();
assert!(s.take_trade_skill_item_waits().is_empty());
}
/// The world-enter init (`0x4fc750`) zeroes the row and header counts and keeps the open line
/// (`[0xbde040]`): the line still answers, the list is empty, a push builds nothing, and only a
/// rebuild (`0x4fca20`) fills it again, with its `TRADE_SKILL_UPDATE` (`0x4fd164`).
#[test]
fn the_world_enter_init_empties_the_list_until_a_rebuild() {
use crate::script::tick::heard;
let mut s = UiScript::new().unwrap();
s.set_trade_skill(Some(two_recipe_state()));
assert_eq!(s.eval::<i64>("return GetNumTradeSkills()").unwrap(), 3);
s.reset_crafts_on_world_enter();
heard::listen(&s, &["TRADE_SKILL_UPDATE"], Some("GetNumTradeSkills()"));
assert_eq!(s.eval::<i64>("return GetNumTradeSkills()").unwrap(), 0);
assert_eq!(
s.eval::<String>("return (GetTradeSkillLine())").unwrap(),
"Tailoring"
);
assert_eq!(s.model_ref().open_professions().trade_skill, Some(197));
let mut more = two_recipe_state();
more.recipes[0].num_available = 4;
s.set_trade_skill(Some(more));
assert_eq!(s.eval::<i64>("return GetNumTradeSkills()").unwrap(), 0);
assert!(
heard::take(&s).is_empty(),
"the init and the push signal nothing"
);
s.rebuild_trade_skill(&mut |_| {});
assert_eq!(heard::take(&s), ["TRADE_SKILL_UPDATE 3"]);
}
+6 -6
View File
@@ -374,10 +374,10 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
#### ui_loot
- It is the display row, where the reference's is the item index plus one (`0x4c2885`), so an addon's `GetLootSlotInfo(arg1)` reads the row the dialog is for. ([`src/ui_loot/mod.rs:253`](../crates/benilla-app/src/ui_loot/mod.rs#L253))
- `autoLootDefault` is benilla's own option, 1.12 auto-looting only on a shift-click, and off is 1.12's behaviour. ([`src/ui_loot/mod.rs:629`](../crates/benilla-app/src/ui_loot/mod.rs#L629))
- Our close paths clear it guid-matched, where `CloseInteraction` clears it unconditionally (`0x48f2c9`), so closing an old window keeps a newer `CMSG_LOOT`'s latch. ([`src/ui_loot/mod.rs:657`](../crates/benilla-app/src/ui_loot/mod.rs#L657))
- A negative answer releases the row, where the reference's callback `0x4c2ac0` returns on a failed query and the window never opens, because an entry the server cannot describe would otherwise keep the loot shut for good. ([`src/ui_loot/mod.rs:854`](../crates/benilla-app/src/ui_loot/mod.rs#L854))
- It is the display row, where the reference's is the item index plus one (`0x4c2885`), so an addon's `GetLootSlotInfo(arg1)` reads the row the dialog is for. ([`src/ui_loot/mod.rs:271`](../crates/benilla-app/src/ui_loot/mod.rs#L271))
- `autoLootDefault` is benilla's own option, 1.12 auto-looting only on a shift-click, and off is 1.12's behaviour. ([`src/ui_loot/mod.rs:685`](../crates/benilla-app/src/ui_loot/mod.rs#L685))
- Our close paths clear it guid-matched, where `CloseInteraction` clears it unconditionally (`0x48f2c9`), so closing an old window keeps a newer `CMSG_LOOT`'s latch. ([`src/ui_loot/mod.rs:713`](../crates/benilla-app/src/ui_loot/mod.rs#L713))
- A negative answer releases the row, where the reference's callback `0x4c2ac0` returns on a failed query and the window never opens, because an entry the server cannot describe would otherwise keep the loot shut for good. ([`src/ui_loot/mod.rs:910`](../crates/benilla-app/src/ui_loot/mod.rs#L910))
#### ui_loot_roll
@@ -724,8 +724,8 @@ Each entry is the first sentence of a `Deviation:` comment, linking to where it
- A row the session owns (an env lever) is passed, because the env chose its value for this run and the file never holds it, so a reset would undo the lever and save nothing. ([`src/script/console_exec.rs:199`](../crates/benilla-ui/src/script/console_exec.rs#L199))
- The backpack is bounded by its own 16 slots, where `0x4f990f` bounds bag 0 by the player list's count (0x71), a reference bug that lets the backpack index read other containers. ([`src/script/container.rs:321`](../crates/benilla-ui/src/script/container.rs#L321))
- A row index the list no longer holds buys nothing and drops, where this path reads through a null row (`0x4f9f35`). ([`src/script/container.rs:792`](../crates/benilla-ui/src/script/container.rs#L792))
- A last `spell_id` key breaks the remaining ties (Charge's six ranks all have `spellLevel` 0), because the reference leaves them to its qsort over an array benilla does not reproduce; ascending id is ascending rank in every 1.12 pet-ability family. ([`src/script/craft.rs:164`](../crates/benilla-ui/src/script/craft.rs#L164))
- The reference reads past the table unbounded (`0x4f6c90`), so type 5 would answer "CloseCraft"; no shipped opener carries a type past 3, and benilla answers nil rather than read past it. ([`src/script/craft.rs:538`](../crates/benilla-ui/src/script/craft.rs#L538))
- A last `spell_id` key breaks the remaining ties (Charge's six ranks all have `spellLevel` 0), because the reference leaves them to its qsort over an array benilla does not reproduce; ascending id is ascending rank in every 1.12 pet-ability family. ([`src/script/craft.rs:201`](../crates/benilla-ui/src/script/craft.rs#L201))
- The reference reads past the table unbounded (`0x4f6c90`), so type 5 would answer "CloseCraft"; no shipped opener carries a type past 3, and benilla answers nil rather than read past it. ([`src/script/craft.rs:729`](../crates/benilla-ui/src/script/craft.rs#L729))
- On `Terrain` the reference keeps a spell, action, macro or pet action on the left button; we clear them, because otherwise a spell has no left-click way off the cursor. ([`src/script/cursor.rs:643`](../crates/benilla-ui/src/script/cursor.rs#L643))
- Every lock lifts here, bag contents included. The reference's walk of a bag's contents indexes the bag by its own player-array index (`0x495528`, `0x495535`), at least 19, past a bag's slots in every case but the biggest bags, so it normally unlocks none of them; a lock it strands lasts until the item's seat or stack moves, which this does not copy. ([`src/script/cursor.rs:841`](../crates/benilla-ui/src/script/cursor.rs#L841))
- Returns nothing. The handler ends `mov eax,1` with nothing pushed (`0x4895bc`), so Lua 5.0 hands back the stack top, the last argument or the function itself: an accident of the handler, not an API, and copying a stack-top leak would copy a bug. ([`src/script/cursor.rs:1070`](../crates/benilla-ui/src/script/cursor.rs#L1070))