//! The 1.12 surface as a gate: every global the engine puts in a bare VM is one the 1.12.1 client //! has (`reference/1.12-globals.tsv`) or a commented entry on [`BEYOND_1_12`], since addons branch //! on a global's presence; no prefix excuses an engine name, as a host seam belongs in Rust. The //! production load, core and layer, is `benilla-app`'s `ui_script::surface_gate`; what 1.12 has //! and benilla lacks is `scripts/api-coverage.sh`'s count. use std::collections::HashSet; use super::common::script; /// Globals the engine exposes that 1.12 does not, each with its reason. The list is exact. const BEYOND_1_12: &[&str] = &[ // Our Lua runtime is 5.1 where 1.12's is 5.0: 1.12's base library does not export `_G` (an // addon reaches the globals with `getfenv(0)`); ours does, as our `getglobal`/`setglobal` are // written over it. "_G", ]; /// `reference/1.12-globals.tsv`'s names. fn reference() -> HashSet { let path = concat!( env!("CARGO_MANIFEST_DIR"), "/../../reference/1.12-globals.tsv" ); let text = std::fs::read_to_string(path).unwrap_or_else(|e| { panic!("reading {path}: {e} — regenerate with scripts/gen-reference-globals.py") }); let names: HashSet = text .lines() .filter(|l| !l.starts_with('#')) .filter_map(|l| l.split('\t').next().map(str::to_string)) .collect(); assert!( names.len() > 19_000, "the reference table looks truncated ({} names) — regenerate it", names.len() ); names } /// The string keys of a bare VM's `_G`. fn engine_globals() -> HashSet { script() .eval::>( "local out = {} \ for k in pairs(getfenv(0)) do if type(k) == 'string' then table.insert(out, k) end end \ return out", ) .expect("dump _G") .into_iter() .collect() } /// Every global the engine exposes is one 1.12 has, or a listed exception. #[test] fn the_engine_adds_no_global_past_1_12() { let known = reference(); let mut beyond: Vec = engine_globals() .into_iter() .filter(|n| !known.contains(n) && !BEYOND_1_12.contains(&n.as_str())) .collect(); beyond.sort_unstable(); assert!( beyond.is_empty(), "the engine exposes {} global(s) the 1.12.1 client does not:\n {}\n\n\ 1.12 is the target. Give it its 1.12 spelling, move a host seam into Rust, or add it to \ `BEYOND_1_12` in this file WITH the reason it has to stay — an addon that \ feature-detects an unexplained superset takes a path we cannot honour.", beyond.len(), beyond.join(" ") ); } /// The exception list is exact: no entry outlives its global, and none excuses a 1.12 name. #[test] fn the_exception_list_is_exact() { let known = reference(); let ours = engine_globals(); let wrong: Vec<&str> = BEYOND_1_12 .iter() .copied() .filter(|n| known.contains(*n) || !ours.contains(*n)) .collect(); assert!( wrong.is_empty(), "excused as beyond 1.12, but 1.12 has them or the engine no longer exposes them: {wrong:?}" ); } /// The globals 1.12.1 does not have, each once benilla's: the Era verbs (the 1.12 way in each /// comment) and the host hooks with no caller. An addon that tests for one takes a path 1.12 never /// does. #[test] fn the_era_globals_and_the_uncalled_hooks_are_absent() { let s = script(); for (name, instead) in [ ( "UnitAura", "UnitBuff/UnitDebuff (0x519500, 0x5198f0), GetPlayerBuff (0x4e45d0)", ), ("CancelUnitBuff", "CancelPlayerBuff (0x4e49a0)"), ( "GetCursorInfo", "CursorHasItem/CursorHasSpell/CursorHasMoney (0x4895d0..0x489630)", ), ( "GetInventoryItemID", "the id inside GetInventoryItemLink (0x4c8c10)", ), ("GetPlayerFacing", "the minimap arrow model's GetFacing"), ( "GetTradePartnerName", r#"UnitName("NPC") (TradeFrame.lua:43)"#, ), ( "IsGossipOptionCoded", "GOSSIP_ENTER_CODE, then SelectGossipOption(index, code)", ), ("UnitIsAFK", "no unit AFK predicate"), ("UnitIsDND", "no unit DND predicate"), ( "BenillaGetContainerItemID", "the id inside GetContainerItemLink", ), ("BenillaGetItemStats", "no caller"), ("BenillaGetMerchantItemStats", "no caller"), ("BenillaGetBuybackItemStats", "no caller"), ("BenillaSetBoothTexture", "no caller; SetPortraitTexture"), ("BenillaTakeLootSlot", "a LootButton's own click (0x4c1820)"), ] { assert!( s.eval::(&format!("return {name} == nil")).unwrap(), "{name} is a global; 1.12 has {instead}" ); } } /// The strata table (`0x8119f8`) has eight rows, `BACKGROUND` to `TOOLTIP`, walked by `0x6f17d0`: /// `SetFrameStrata("BLIZZARD")` raises `%s:SetFrameStrata(): Unknown frame strata: %s` naming the /// frame or `` (`0x774450`) and leaves the stratum, and the XML attribute warns and skips /// (`0x769978`). #[test] fn blizzard_is_no_frame_strata() { let s = script(); s.run(r#"f = CreateFrame("Frame", "StrataProbe") f:SetFrameStrata("HIGH") g = CreateFrame("Frame")"#) .unwrap(); for (call, who) in [ (r#"f:SetFrameStrata("BLIZZARD")"#, "StrataProbe"), (r#"g:SetFrameStrata("BLIZZARD")"#, ""), ] { let e = s.run(call).expect_err(call).to_string(); assert!( e.contains(&format!( "{who}:SetFrameStrata(): Unknown frame strata: BLIZZARD" )), "{call}: {e}" ); } assert_eq!( s.eval::("return f:GetFrameStrata()").unwrap(), "HIGH", "the stratum stays" ); assert!(crate::script::object::strata_from_str("BLIZZARD").is_none()); assert!(crate::script::object::strata_from_str("tooltip").is_some()); } /// `SetDrawLayer` (`0x79a780`) reads the layer name alone against the five-row table (`0x811a80`): /// a third argument orders nothing, and a name off the table raises the Usage line (`0x87c42c`). #[test] fn set_draw_layer_reads_the_layer_alone() { let s = script(); s.run( r#" f = CreateFrame("Frame", "LayerProbe") a = f:CreateTexture("LayerProbeA", "ARTWORK") b = f:CreateTexture("LayerProbeB", "ARTWORK") a:SetDrawLayer("ARTWORK", 7) b:SetDrawLayer("ARTWORK", -7) "#, ) .unwrap(); let sub = |name: &str| { let rh = { let t: mlua::Table = s.lua().globals().get(name).unwrap(); crate::script::region::region_handle_of(s.lua(), &t).unwrap() }; s.model_ref().arena.region(rh).unwrap().sub_level }; assert_eq!((sub("LayerProbeA"), sub("LayerProbeB")), (0, 0)); assert_eq!( s.eval::("return a:GetDrawLayer()").unwrap(), "ARTWORK" ); for (call, who) in [ (r#"a:SetDrawLayer("NOPE")"#, "LayerProbeA"), ("a:SetDrawLayer(2)", "LayerProbeA"), ("f:CreateTexture():SetDrawLayer()", ""), ] { let e = s.run(call).expect_err(call).to_string(); assert!( e.contains(&format!(r#"Usage: {who}:SetDrawLayer("layer")"#)), "{call}: {e}" ); } assert_eq!( s.eval::("return a:GetDrawLayer()").unwrap(), "ARTWORK", "a refused name leaves the layer" ); } /// `SetTexture` has no colour form (`0x781970`): a number takes the path leg through /// `lua_isstring` (`0x781b23`) and loads as its decimal name, so `SetNormalTexture(1, 1, 1, 0)` /// is the file `"1"`; a boolean or no argument raises the Usage line (`0x87a1b4`, the highlight /// setter's own at `0x87a240`). #[test] fn a_state_texture_setter_reads_a_number_as_a_path() { let s = script(); s.run( r#" b = CreateFrame("Button", "StateProbe") b:SetNormalTexture(1, 1, 1, 0) c = CreateFrame("CheckButton", "CheckProbe") c:SetCheckedTexture(3) "#, ) .unwrap(); assert_eq!( s.eval::("return b:GetNormalTexture():GetTexture()") .unwrap(), "1", "the path \"1\", not a solid white fill" ); assert_eq!( s.eval::("return c:GetCheckedTexture():GetTexture()") .unwrap(), "3" ); for (call, usage) in [ ( "b:SetPushedTexture(true)", r#"Usage: StateProbe:SetPushedTexture(texture or "texture" or nil)"#, ), ( "b:SetDisabledTexture()", r#"Usage: StateProbe:SetDisabledTexture(texture or "texture" or nil)"#, ), ( "CreateFrame('Button'):SetHighlightTexture(false)", r#"Usage: :SetHighlightTexture(texture or "texture" or nil [, "blendmode")"#, ), ] { let e = s.run(call).expect_err(call).to_string(); assert!(e.contains(usage), "{call}: {e}"); } } /// `PickupContainerItem` (`0x4f9b30`) returns nothing on every path. #[test] fn pickup_container_item_answers_nothing() { let s = script(); for call in ["PickupContainerItem(0, 1)", "PickupContainerItem(4, 16)"] { assert_eq!(s.arity(call).unwrap(), 0, "{call}"); } } /// `Texture:GetTexture()` (`0x79ba70`/`0x79baf0`/`0x835708`): one value, nil when unset, the path /// without its extension, and the literal `"Solid Texture"` for a colour fill. #[test] fn get_texture_returns_the_stripped_path_and_solid_texture_for_a_fill() { let s = crate::script::UiScript::new().unwrap(); s.run( r#" f = CreateFrame("Frame", "GTF") tex = f:CreateTexture("GTFTex", "ARTWORK") fill = f:CreateTexture("GTFFill", "ARTWORK") "#, ) .unwrap(); assert_eq!( s.eval::>("return GTFTex:GetTexture()") .unwrap(), None ); assert_eq!( s.arity("GTFTex:GetTexture()").unwrap(), 1, "exactly one return value" ); s.run(r#"GTFTex:SetTexture("Interface\\Icons\\Spell_Fire_FlameBolt")"#) .unwrap(); assert_eq!( s.eval::("return GTFTex:GetTexture()").unwrap(), "Interface\\Icons\\Spell_Fire_FlameBolt" ); s.run(r#"GTFTex:SetTexture("Interface\\Icons\\Foo.blp")"#) .unwrap(); assert_eq!( s.eval::("return GTFTex:GetTexture()").unwrap(), "Interface\\Icons\\Foo" ); s.run("GTFFill:SetTexture(1, 0, 0, 1)").unwrap(); assert_eq!( s.eval::("return GTFFill:GetTexture()").unwrap(), "Solid Texture", "a colour-filled region reports a NAME — `if not tex then` must not fire" ); s.run(r#"GTFFill:SetTexture("Interface\\Buttons\\UI-Quickslot2")"#) .unwrap(); assert_eq!( s.eval::("return GTFFill:GetTexture()").unwrap(), "Interface\\Buttons\\UI-Quickslot2" ); } /// A FontString's shadow accessors; `GetShadowColor` returns four values, alpha included /// (`0x79dd2f`, `mov eax,0x4`). #[test] fn region_shadow_accessors_round_trip_four_values() { let s = crate::script::UiScript::new().unwrap(); s.run(r#"f = CreateFrame("Frame", "SHF") fs = f:CreateFontString("SHFText", "ARTWORK")"#) .unwrap(); assert_eq!( s.arity("SHFText:GetShadowColor()").unwrap(), 4, "GetShadowColor returns FOUR values — three drops the alpha" ); assert_eq!(s.arity("SHFText:GetShadowOffset()").unwrap(), 2); s.run("SHFText:SetShadowColor(0, 0, 0, 0.3) SHFText:SetShadowOffset(1, -1)") .unwrap(); let (r, g, b, a) = s .eval::<(f32, f32, f32, f32)>("return SHFText:GetShadowColor()") .unwrap(); assert_eq!((r, g, b, a), (0.0, 0.0, 0.0, 0.3), "the alpha survives"); assert_eq!( s.eval::<(f32, f32)>("return SHFText:GetShadowOffset()") .unwrap(), (1.0, -1.0) ); s.run("SHFText:SetShadowOffset(2, -2)").unwrap(); assert_eq!( s.eval::("local _,_,_,a = SHFText:GetShadowColor() return a") .unwrap(), 0.3, "setting the offset alone keeps the colour" ); } /// `Region:SetParent` (`0x7a1550`, reached by both leaf lookups' fallback: `0x79c650`, `0x79ee50`) /// moves the region's draw-list membership and leaves its anchors alone; a non-Frame argument /// raises (`IsA(FrameTag)` at `0x7a16ea`). #[test] fn region_set_parent_relinks_the_draw_owner_and_leaves_anchors_alone() { /// The resolved rect of the one texture quad whose path contains `needle`, if it draws at all. fn tex_rect(s: &crate::script::UiScript, needle: &str) -> Option { s.extract().iter().find_map(|q| match &q.content { crate::script::QuadContent::Texture { path: Some(p), .. } if p.contains(needle) => { Some(q.rect.expect("resolved rect")) } _ => None, }) } let mut s = crate::script::UiScript::new().unwrap(); s.set_screen_size(800.0, 600.0); s.run( r#" A = CreateFrame("Frame", "SPOwnerA") A:SetPoint("BOTTOMLEFT", 0, 0) A:SetWidth(100); A:SetHeight(50) B = CreateFrame("Frame", "SPOwnerB") B:SetPoint("BOTTOMLEFT", 300, 0) B:SetWidth(100); B:SetHeight(50) Spark = A:CreateTexture("SPSpark", "ARTWORK") Spark:SetTexture("Interface\\SPGlow") Spark:SetWidth(24); Spark:SetHeight(24) Spark:SetPoint("TOPLEFT", 4, -4) "#, ) .unwrap(); s.resolve(); // A is [bottom 0, left 0, top 50, right 100]: TOPLEFT +(4,-4), 24x24 ⇒ 4..28 x 22..46. let before = tex_rect(&s, "SPGlow").expect("the spark draws under A"); assert_eq!(before, crate::layout::Rect::new(22.0, 4.0, 46.0, 28.0)); assert_eq!( s.arity("Spark:SetParent(B)").unwrap(), 0, "SetParent returns zero values on every path" ); s.resolve(); assert_eq!( tex_rect(&s, "SPGlow"), Some(before), "the anchors are untouched — the spark still resolves against A, 300px from B" ); s.run("B:Hide()").unwrap(); assert_eq!( tex_rect(&s, "SPGlow"), None, "the spark hides with its NEW owner" ); s.run("B:Show() A:Hide()").unwrap(); s.resolve(); assert_eq!( tex_rect(&s, "SPGlow"), Some(before), "and not with the frame it is merely anchored to" ); for bad in ["Spark:SetParent(Spark)", "Spark:SetParent(5)"] { let e = s .run(bad) .expect_err("a non-frame parent must raise") .to_string(); assert!( e.contains("expected frame"), "wanted the reference's 'expected frame' rejection, got: {e}" ); } // A missing argument is `TNONE`, which never reaches the nil branch. assert!(s.run("Spark:SetParent()").is_err(), "no argument raises"); // nil detaches the region without destroying it. s.run("A:Show() Spark:SetParent(nil)").unwrap(); s.resolve(); assert_eq!( tex_rect(&s, "SPGlow"), None, "a detached region draws nothing" ); s.run("Spark:SetParent(A)").unwrap(); s.resolve(); assert_eq!( tex_rect(&s, "SPGlow"), Some(before), "and re-parenting restores it" ); } /// `Button:SetFont` (`0x780880`) returns nothing, discarding the shared impl's `1`/nil /// (`xor eax,eax`), and sets the button's normal font without touching the label pointer /// (`+0x338`), so a bare Button makes no label; `GetFont` returns three values off that font. #[test] fn button_set_font_returns_nothing_and_is_a_no_op_without_a_label() { let s = crate::script::UiScript::new().unwrap(); s.run( r#" Bare = CreateFrame("Button", "SFBare") Labelled = CreateFrame("Button", "SFLabelled") Labelled:SetText("Show Keybinds") "#, ) .unwrap(); assert_eq!( s.arity(r#"SFBare:SetFont("Fonts\\FRIZQT__.TTF", 8)"#) .unwrap(), 0, "SetFont returns ZERO values — the delegate's 1/nil is discarded by a Button" ); assert!( s.eval::("return SFBare:GetFontString() == nil") .unwrap(), "no label existed and none was lazily created" ); assert_eq!( s.arity("SFBare:GetFont()").unwrap(), 3, "GetFont returns THREE values" ); assert_eq!( s.eval::<(String, f32, String)>("return SFBare:GetFont()") .unwrap(), ("Fonts\\FRIZQT__.TTF".to_string(), 8.0, String::new()) ); // Nothing set: still three values, the path and height nil. assert_eq!(s.arity("SFLabelled:GetFont()").unwrap(), 3); assert!(s .eval::("local f = SFLabelled:GetFont() return f == nil") .unwrap()); s.run(r#"SFBare:SetFont("Fonts\\SKURRI.TTF", 12, "THICKOUTLINE")"#) .unwrap(); assert_eq!( s.eval::("local _, _, flags = SFBare:GetFont() return flags") .unwrap(), "THICKOUTLINE" ); // Both arguments are required (`lua_isstring` + `lua_isnumber`, else the usage error). assert!(s.run(r#"SFBare:SetFont("Fonts\\SKURRI.TTF")"#).is_err()); // Unset locally, GetFont reads through the normal state's font object. s.run( r#" CreateFont("SFInherited") SFInherited:SetFont("Fonts\\MORPHEUS.TTF", 14) SFLabelled:SetTextFontObject(SFInherited) "#, ) .unwrap(); assert_eq!( s.eval::<(String, f32)>("local p, h = SFLabelled:GetFont() return p, h") .unwrap(), ("Fonts\\MORPHEUS.TTF".to_string(), 14.0) ); // A local SetFont outranks that object on the label's paint too. s.run(r#"SFLabelled:SetFont("Fonts\\SKURRI.TTF", 9)"#) .unwrap(); let (font, height) = s .extract() .iter() .find_map(|q| match &q.content { crate::script::QuadContent::Text { text: Some(t), font, font_height, .. } if t == "Show Keybinds" => Some((font.clone(), *font_height)), _ => None, }) .expect("the labelled button draws its text"); assert_eq!( (font.as_deref(), height), (Some("Fonts\\SKURRI.TTF"), Some(9.0)), "the button's own font repaints the label over the inherited font object" ); } /// FontString's `SetNonSpaceWrap`/`CanNonSpaceWrap` (`0x79e9f0`/`0x79ead0`): on by default, the /// getter answers `1` or nil, and a bare `SetNonSpaceWrap()` turns it on. #[test] fn non_space_wrap_defaults_on_and_answers_one_or_nil() { let s = crate::script::UiScript::new().unwrap(); s.run(r#"f = CreateFrame("Frame", "NSF") fs = f:CreateFontString("NSFText", "ARTWORK")"#) .unwrap(); assert_eq!( s.eval::>("return NSFText:CanNonSpaceWrap()") .unwrap(), Some(1), "default on, answered as 1" ); assert!( !s.eval::("return NSFText:CanNonSpaceWrap() == true") .unwrap(), "it must NOT be a boolean — an addon comparing against 1 would break" ); s.run("NSFText:SetNonSpaceWrap(false)").unwrap(); assert_eq!( s.eval::>("return NSFText:CanNonSpaceWrap()") .unwrap(), None, "off answers nil, not 0 and not false" ); s.run("NSFText:SetNonSpaceWrap()").unwrap(); assert_eq!( s.eval::>("return NSFText:CanNonSpaceWrap()") .unwrap(), Some(1), "a bare SetNonSpaceWrap() turns it ON" ); } /// EditBox's registrar table (`.data 0x87bb68`, 48 entries, `mov edx,0x30` at `0x799ab5`) opens /// with the font block each text-bearing type re-declares over the shared impls (`0x79f210`, /// `0x79fb40`): its sixteen font verbs answer, and other tables' names do not leak onto it. #[test] fn editbox_carries_the_font_block_its_registrar_table_declares() { let s = crate::script::UiScript::new().unwrap(); s.run(r#"EB = CreateFrame("EditBox", "EBFont")"#).unwrap(); for name in [ "SetFontObject", "GetFontObject", "SetFont", "GetFont", "SetTextColor", "GetTextColor", "SetShadowColor", "GetShadowColor", "SetShadowOffset", "GetShadowOffset", "SetSpacing", "GetSpacing", "SetJustifyH", "GetJustifyH", "SetJustifyV", "GetJustifyV", ] { assert_eq!( s.eval::(&format!("return type(EBFont.{name})")) .unwrap(), "function", "EditBox table entry '{name}' is missing" ); } for name in [ // Not on EditBox's table. "CopyFontObject", "SetNonSpaceWrap", "CanNonSpaceWrap", "SetTextHeight", "GetStringWidth", ] { assert!( s.eval::(&format!("return EBFont.{name} == nil")) .unwrap(), "'{name}' must NOT answer on an EditBox" ); } } /// Each EditBox font binding returns what the shared implementation returns (no `mov eax,N` or /// `xor eax,eax` after the call), so unlike `Button:SetFont` (`0x780880`), `EditBox:SetFont` /// (`0x797210` → `0x79f210`) answers the number `1` or nil (`0x79f345`/`0x79f361`), and /// `GetShadowColor` returns four values (`0x79f9b3 mov eax,0x4`). #[test] fn editbox_font_block_return_shapes_are_the_shared_implementations() { let s = crate::script::UiScript::new().unwrap(); s.run( r#" EB = CreateFrame("EditBox", "EBShape") CreateFont("EBProbeFont") EBProbeFont:SetFont("Fonts\\FRIZQT__.TTF", 14) "#, ) .unwrap(); for call in [ "SetFontObject(EBProbeFont)", "SetTextColor(1, 0, 0)", "SetShadowColor(0, 0, 0, 0.3)", "SetShadowOffset(1, -1)", r#"SetJustifyH("CENTER")"#, r#"SetJustifyV("TOP")"#, ] { assert_eq!( s.arity(&format!("EBShape:{call}")).unwrap(), 0, "EditBox:{call} must return ZERO values" ); } for (call, want) in [ ("GetFontObject()", 1), ("GetFont()", 3), ("GetTextColor()", 4), ("GetShadowColor()", 4), ("GetShadowOffset()", 2), ("GetJustifyH()", 1), ("GetJustifyV()", 1), ] { assert_eq!( s.arity(&format!("EBShape:{call}")).unwrap(), want, "EditBox:{call} must return {want} value(s)" ); } assert_eq!( s.arity(r#"EBShape:SetFont("Fonts\\SKURRI.TTF", 12)"#) .unwrap(), 1, "EditBox:SetFont returns one value, unlike Button:SetFont" ); assert_eq!( s.eval::(r#"return type(EBShape:SetFont("Fonts\\SKURRI.TTF", 12))"#) .unwrap(), "number", "the number 1, never the boolean true" ); assert!(s .eval::(r#"return EBShape:SetFont("Fonts\\SKURRI.TTF", 12) == 1"#) .unwrap()); // An unloadable (empty) path answers nil, not an error. assert!(s .eval::(r#"return EBShape:SetFont("", 12) == nil"#) .unwrap()); // Both arguments are gated (`lua_isstring` + `lua_isnumber`, else the usage error). assert!(s.run(r#"EBShape:SetFont("Fonts\\SKURRI.TTF")"#).is_err()); assert_eq!( s.eval::<(f32, f32, f32, f32)>("return EBShape:GetShadowColor()") .unwrap(), (0.0, 0.0, 0.0, 0.3) ); assert_eq!( s.eval::<(f32, f32)>("return EBShape:GetShadowOffset()") .unwrap(), (1.0, -1.0) ); // GetFontObject answers the object, not its name. assert_eq!( s.eval::("return type(EBShape:GetFontObject())") .unwrap(), "table" ); } /// `Dewdrop-2.0.lua:1673-1675`'s shape: an anonymous EditBox under a frame, then /// `SetFontObject(ChatFontNormal)`. #[test] fn the_dewdrop_editbox_font_shape_resolves_and_paints() { let s = crate::script::UiScript::new().unwrap(); s.run( r#" CreateFont("ChatFontNormal") ChatFontNormal:SetFont("Fonts\\ARIALN.TTF", 11) ChatFontNormal:SetTextColor(0.9, 0.9, 0.9) editBoxFrame = CreateFrame("Frame", "DewdropEBFrame") local editBox = CreateFrame("EditBox", nil, editBoxFrame) editBoxFrame.editBox = editBox editBox:SetFontObject(ChatFontNormal) editBox:SetWidth(160) editBox:SetHeight(13) "#, ) .unwrap(); assert!(s .eval::("return DewdropEBFrame.editBox:GetFontObject() == ChatFontNormal") .unwrap()); // The object's paint reaches the box's own FontString (`[this+0x324]`, what the shim passes). assert_eq!( s.eval::<(String, f32)>("local p, h = DewdropEBFrame.editBox:GetFont() return p, h") .unwrap(), ("Fonts\\ARIALN.TTF".to_string(), 11.0) ); let (r, g, b, _) = s .eval::<(f32, f32, f32, f32)>("return DewdropEBFrame.editBox:GetTextColor()") .unwrap(); assert_eq!((r, g, b), (0.9, 0.9, 0.9)); // `AceGUIWidget-Slider.lua:204-210` ends the same shape with this. s.run(r#"DewdropEBFrame.editBox:SetJustifyH("CENTER")"#) .unwrap(); } /// The justify enum (`.rdata 0x811ad0`) keeps both axes in one dword, bits 0-2 horizontal and 3-5 /// vertical: an unknown token raises (`0x87c77c`), and a token from the other axis masks to /// nothing, so `GetJustifyH()` answers `"UNKNOWN"` (`0x6f1a00`, `.data 0x838044`). #[test] fn editbox_justify_masks_to_its_axis_and_answers_unknown() { let s = crate::script::UiScript::new().unwrap(); s.run(r#"EB = CreateFrame("EditBox", "EBJustify")"#) .unwrap(); // A fresh EditBox is LEFT: its ctor turns the font default `0x212` (CENTER | MIDDLE | 0x200) // into `0x211` (`0x779bcd`, stored at `0x779be4`). assert_eq!( s.eval::("return EBJustify:GetJustifyH()").unwrap(), "LEFT" ); assert_eq!( s.eval::("return EBJustify:GetJustifyV()").unwrap(), "MIDDLE" ); s.run(r#"EBJustify:SetJustifyH("LEFT") EBJustify:SetJustifyV("BOTTOM")"#) .unwrap(); assert_eq!( s.eval::<(String, String)>("return EBJustify:GetJustifyH(), EBJustify:GetJustifyV()") .unwrap(), ("LEFT".to_string(), "BOTTOM".to_string()) ); s.run(r#"EBJustify:SetJustifyH("TOP")"#).unwrap(); assert_eq!( s.eval::("return EBJustify:GetJustifyH()").unwrap(), "UNKNOWN", "a vertical token on SetJustifyH clears the axis rather than centering it" ); assert_eq!( s.eval::("return EBJustify:GetJustifyV()").unwrap(), "BOTTOM", "and it leaves the vertical axis untouched" ); assert!(s.run(r#"EBJustify:SetJustifyH("SIDEWAYS")"#).is_err()); } /// `EditBox:SetJustifyV` reaches the getter (`0x79fd73` reads the font instance) but never the /// pixels: `SetMultiLine 0x77a4a0`, which the ctor always calls (`0x779c2f`), clears the vertical /// inherit bits (`CSimpleFontString+0x124`, over the drawn justify `+0x120`) and writes TOP or /// MIDDLE itself; nothing sets those bits back, so `0x77086e` masks the setter's value out. #[test] fn editbox_justify_v_echoes_but_multiline_alone_decides_the_pixels() { let mut s = crate::script::UiScript::new().unwrap(); s.set_screen_size(800.0, 600.0); s.run( r#" EB = CreateFrame("EditBox", "EBJV") EBJV:SetPoint("CENTER", 0, 0) EBJV:SetWidth(120) EBJV:SetHeight(40) EBJV:SetText("typed") "#, ) .unwrap(); /// The vertical justification the box's text actually draws with. fn drawn_v(s: &crate::script::UiScript) -> crate::script::JustifyV { s.extract() .iter() .find_map(|q| match &q.content { crate::script::QuadContent::Text { text: Some(t), justify_v, .. } if t == "typed" => Some(*justify_v), _ => None, }) .expect("the box draws its text") } // A single-line box renders MIDDLE, the `0x77a599` leg. assert_eq!(drawn_v(&s), crate::script::JustifyV::Middle); s.run(r#"EBJV:SetJustifyV("TOP")"#).unwrap(); assert_eq!( s.eval::("return EBJV:GetJustifyV()").unwrap(), "TOP", "the getter reads the font instance and echoes faithfully" ); assert_eq!( drawn_v(&s), crate::script::JustifyV::Middle, "SetJustifyV is masked out of the rendered justify — multiLine alone decides it" ); // Multi-line moves it, the `0x77a509` leg. s.run("EBJV:SetMultiLine(true)").unwrap(); assert_eq!(drawn_v(&s), crate::script::JustifyV::Top); assert_eq!( s.eval::("return EBJV:GetJustifyV()").unwrap(), "TOP" ); } /// `Texture:SetDesaturated` (`0x79c1e0`) answers `shaderSupported`, `1` or nil; benilla's renderer /// greys, so it answers `1`, and stock `ItemButtonTemplate.lua:69` keeps the caller's tint rather /// than its 0.5 fallback. #[test] fn set_desaturated_reports_shader_support_and_does_not_raise() { let s = crate::script::UiScript::new().unwrap(); s.run(r#"f = CreateFrame("Frame", "DsF") tex = f:CreateTexture("DsTex", "ARTWORK")"#) .unwrap(); s.run("DsTex:SetDesaturated(true)").unwrap(); assert!( s.eval::("return DsTex:SetDesaturated(true) == 1") .unwrap(), "shaderSupported must be 1 (1|nil C shape), not true" ); assert_eq!( s.arity("DsTex:SetDesaturated(true)").unwrap(), 1, "one return value" ); // `SetItemButtonDesaturated`'s branch, transcribed: a truthy answer keeps the caller's tint. s.run( r#" local shaderSupported = DsTex:SetDesaturated(true) local r, g, b = 0.65, 0.65, 0.65 if not shaderSupported then r, g, b = 0.5, 0.5, 0.5 end DsTex:SetVertexColor(r, g, b) "#, ) .unwrap(); let (r, g, b) = s .eval::<(f32, f32, f32)>("return DsTex:GetVertexColor()") .unwrap(); assert!( (r - 0.65).abs() < 1e-6 && (g - 0.65).abs() < 1e-6 && (b - 0.65).abs() < 1e-6, "the shader arm keeps the caller's tint, got {r},{g},{b}" ); s.run("DsTex:SetDesaturated(nil) DsTex:SetDesaturated(false)") .unwrap(); } /// `UnitCreatureType` (`0x51a280`) answers the type the snapshot carries, which the app resolved /// as `0x605570` does (form, else template, else race), for a creature and a player alike: nil /// for a token that names no unit or a snapshot with no type (`0x51a2b8`, `0x51a2c3`). #[test] fn unit_creature_type_answers_the_snapshots_resolved_type() { let mut s = script(); let typed = |word: Option<&str>, is_player: bool| { Some(crate::script::UnitState { exists: true, is_player, creature_type_name: word.map(str::to_string), ..Default::default() }) }; s.set_unit("target", typed(Some("Beast"), false)); // A shapeshifted player carries the form's type, an unshifted one the race's. s.set_unit("player", typed(Some("Beast"), true)); s.set_unit("party1", typed(Some("Humanoid"), true)); // A player with no descriptor behind the snapshot carries none, and answers nil. s.set_unit("party2", typed(None, true)); for (token, word) in [ ("target", "Beast"), ("player", "Beast"), ("party1", "Humanoid"), ] { assert_eq!( s.eval::(&format!(r#"return UnitCreatureType("{token}")"#)) .unwrap(), word, "{token}" ); } // An unresolved token and a typeless snapshot are nil; a missing argument fails // `lua_isstring` and raises. for token in ["party2", "party4"] { assert!( s.eval::(&format!(r#"return UnitCreatureType("{token}") == nil"#)) .unwrap(), "{token}" ); } let err = s .run("UnitCreatureType()") .expect_err("a missing arg must raise"); assert!( format!("{err}").contains("Usage: UnitCreatureType"), "got {err}" ); } /// `GetInventorySlotInfo` (`0x4c81b0`) matches the whole name case-insensitively (`0x4c8215`, /// `_strnicmp`) and returns three values, the third the number 1 for `RangedSlot` alone; a miss /// raises the reference's message, with no `Usage:` and no name. #[test] fn get_inventory_slot_info_folds_case_and_flags_only_the_ranged_slot() { let s = script(); for name in ["AmmoSlot", "ammoSlot", "AMMOSLOT"] { assert_eq!( s.eval::(&format!("return GetInventorySlotInfo('{name}')")) .unwrap(), 0, "{name} must fold to AmmoSlot" ); } assert_eq!( s.eval::("return GetInventorySlotInfo('MAINHANDSLOT')") .unwrap(), 16 ); assert_eq!(s.arity("GetInventorySlotInfo('HeadSlot')").unwrap(), 3); let (id, art) = s .eval::<(i64, String)>("return GetInventorySlotInfo('HeadSlot')") .unwrap(); assert_eq!(id, 1); // The DBC string verbatim, lowercase directory and `.blp`: the binding pushes `[esi+4]` as is. assert_eq!(art, "interface\\paperdoll\\UI-PaperDoll-Slot-Head.blp"); assert!(s .eval::("local _,_,r = GetInventorySlotInfo('RangedSlot') return r == 1") .unwrap()); assert!(s .eval::("local _,_,r = GetInventorySlotInfo('HeadSlot') return r == nil") .unwrap()); // `Bag1`..`Bag12` are SlotNumbers 64..75 (64..69 the bank bags) and share one string offset // with `Bag0Slot`..`Bag3Slot`, so all sixteen answer the same art. assert_eq!( s.eval::("return GetInventorySlotInfo('Bag1')") .unwrap(), 64 ); assert_eq!( s.eval::("return GetInventorySlotInfo('bag12')") .unwrap(), 75, "the new rows fold case like every other" ); assert_eq!( s.eval::("local _,a = GetInventorySlotInfo('Bag6') return a") .unwrap(), s.eval::("local _,a = GetInventorySlotInfo('Bag0Slot') return a") .unwrap(), "all sixteen bag rows share one string-block offset" ); // `Bag1` (64) and `Bag1Slot` (21) are different rows. assert_eq!( s.eval::("return GetInventorySlotInfo('Bag1Slot')") .unwrap(), 21 ); let err = s .run("GetInventorySlotInfo('NoSuchSlot')") .expect_err("an unknown slot name must raise"); let err = format!("{err}"); assert!( err.contains("Invalid inventory slot in GetInventorySlotInfo"), "got {err}" ); assert!( !err.contains("NoSuchSlot"), "the reference does not interpolate the offending name: {err}" ); } /// Every Region-map name (`0xcf54b4`, 19 entries) is callable on a Texture and a FontString, whose /// lookups fall back to it (FontString's `0x79ee20` chains its own `0xcf5400`); a Font object's /// lookup (`0x7a1100`) has no fallback. #[test] fn every_region_map_method_is_callable_on_a_texture_and_a_fontstring() { /// All 19, `GetObjectType`/`IsObjectType` (`0x7a11d0`/`0x7a1290`) among them. const REGION_MAP: [&str; 19] = crate::script::REGION_MAP_METHODS; let mut s = crate::script::UiScript::new().unwrap(); s.set_screen_size(800.0, 600.0); s.run( r#" RMOwner = CreateFrame("Frame", "RMOwner") RMOwner:SetPoint("BOTTOMLEFT", 0, 0) RMOwner:SetWidth(100); RMOwner:SetHeight(50) RMTex = RMOwner:CreateTexture("RMTex", "ARTWORK") RMStr = RMOwner:CreateFontString("RMStr", "ARTWORK") "#, ) .unwrap(); let mut absent: Vec = Vec::new(); for kind in ["RMTex", "RMStr"] { for name in REGION_MAP { if !s .eval::(&format!("return type({kind}.{name}) == 'function'")) .unwrap_or(false) { absent.push(format!("{kind}:{name}")); } } } assert!( absent.is_empty(), "the Region map 0xcf54b4 is missing from our regions: {absent:?}" ); } /// The Region-map readers where a region differs from a frame: `GetParent` is the owner frame /// (`TheoryCraftUI.lua:720` calls it on a FontString), and `GetPoint` answers a sibling region. #[test] fn the_region_map_readers_answer_the_way_the_edges_do() { let mut s = crate::script::UiScript::new().unwrap(); s.set_screen_size(800.0, 600.0); s.run( r#" RRFrame = CreateFrame("Frame", "RRFrame") RRFrame:SetPoint("BOTTOMLEFT", 100, 200) RRFrame:SetWidth(200); RRFrame:SetHeight(100) RRPlate = RRFrame:CreateTexture("RRPlate", "ARTWORK") RRPlate:SetPoint("TOPLEFT", 10, -10) RRPlate:SetWidth(50); RRPlate:SetHeight(20) -- the sibling-region anchor the real XML uses everywhere RRLabel = RRFrame:CreateFontString("RRLabel", "OVERLAY") RRLabel:SetPoint("LEFT", RRPlate, "RIGHT", 4, 0) "#, ) .unwrap(); s.resolve(); assert!( s.eval::("return RRPlate:GetParent() == RRFrame") .unwrap(), "a region's parent is the frame that created it" ); assert!( s.eval::("return RRLabel:GetParent():GetName() == 'RRFrame'") .unwrap(), "…and it is a real frame handle, not a bare id" ); // GetCenter agrees with the edge readers by construction, so none of them is scaled alone. let (cx, cy): (f64, f64) = s.eval("return RRPlate:GetCenter()").unwrap(); let (l, r, t, b): (f64, f64, f64, f64) = s .eval("return RRPlate:GetLeft(), RRPlate:GetRight(), RRPlate:GetTop(), RRPlate:GetBottom()") .unwrap(); assert_eq!((cx, cy), ((l + r) * 0.5, (t + b) * 0.5)); assert_eq!(s.eval::("return RRPlate:GetNumPoints()").unwrap(), 1); assert_eq!( s.eval::("return RRLabel:GetNumPoints()").unwrap(), 1, "the sibling-anchored label carries its one point" ); // Frames and regions share an id space, so `relativeTo` must come back as the region handle, // not a frame wrapper onto its id. let (p, rp, x, y): (String, String, f64, f64) = s .eval("local p, _, rp, x, y = RRLabel:GetPoint(1) return p, rp, x, y") .unwrap(); assert_eq!((p.as_str(), rp.as_str(), x, y), ("LEFT", "RIGHT", 4.0, 0.0)); assert!( s.eval::("local _, rel = RRLabel:GetPoint(1) return rel == RRPlate") .unwrap(), "relativeTo is the sibling REGION handle itself" ); assert_eq!( s.arity("RRPlate:GetPoint(7)").unwrap(), 0, "an out-of-range index pushes no value (`0x7a240d`)" ); } /// A region's `GetObjectType`/`IsObjectType` (`0x7a11d0`/`0x7a1290`). #[test] fn the_type_identity_verbs_answer_what_the_binary_answers() { let s = crate::script::UiScript::new().unwrap(); s.run( r#" TIOwner = CreateFrame("Frame", "TIOwner") TITex = TIOwner:CreateTexture("TITex", "ARTWORK") TIStr = TIOwner:CreateFontString("TIStr", "ARTWORK") TIAnon = TIOwner:CreateTexture(nil, "ARTWORK") "#, ) .unwrap(); // One value each (`lua_pushstring`); extra arguments are ignored. assert_eq!( s.eval::("return TITex:GetObjectType()").unwrap(), "Texture" ); assert_eq!( s.eval::("return TIStr:GetObjectType()").unwrap(), "FontString" ); assert_eq!( s.arity("TITex:GetObjectType('ignored')").unwrap(), 1, "one value, and a stray argument is ignored rather than an arity error" ); // The chain is two deep: the leaf, then Region. for (obj, leaf) in [("TITex", "Texture"), ("TIStr", "FontString")] { assert_eq!( s.eval::(&format!("return {obj}:IsObjectType('{leaf}')")) .unwrap(), 1, "{obj} is its own leaf type" ); assert_eq!( s.eval::(&format!("return {obj}:IsObjectType('Region')")) .unwrap(), 1, "{obj} is a Region" ); // 1.12.1 has no LayoutFrame, ScriptObject or Object type at all. for absent in ["LayoutFrame", "ScriptObject", "Object", "Frame", "Font"] { assert!( s.eval::>(&format!("return {obj}:IsObjectType('{absent}')")) .unwrap() .is_none(), "{obj}:IsObjectType('{absent}') must be nil — 1.12 has no such type in the chain" ); } } assert!(s .eval::>("return TITex:IsObjectType('FontString')") .unwrap() .is_none()); // Case-insensitive and whole-string (`SStrCmpI`). for spelling in ["texture", "TEXTURE", "TeXtUrE", "region", "REGION"] { assert_eq!( s.eval::(&format!("return TITex:IsObjectType('{spelling}')")) .unwrap(), 1, "'{spelling}' must match — the compare folds case" ); } for partial in ["Tex", "TextureX", "Regio", ""] { assert!( s.eval::>(&format!("return TITex:IsObjectType('{partial}')")) .unwrap() .is_none(), "'{partial}' must NOT match — whole-string, not a prefix" ); } assert_eq!( s.eval::("return type(TITex:IsObjectType('Texture'))") .unwrap(), "number", "the reference pushes tag 3 (number); tag 1 (boolean) is never written" ); for arg in ["'Texture'", "'nope'"] { assert_eq!( s.arity(&format!("TITex:IsObjectType({arg})")).unwrap(), 1, "exactly one value on both the hit and the miss path" ); } // A number passes `lua_isstring` and never matches a type name. assert!( s.eval::>("return TITex:IsObjectType(5)") .unwrap() .is_none(), "a number argument is accepted and quietly answers nil, NOT a raise" ); for bad in ["", "nil", "true", "{}", "print"] { let err = s .run(&format!("TITex:IsObjectType({bad})")) .expect_err(&format!("IsObjectType({bad}) must raise")) .to_string(); assert!( err.contains(r#"Usage: TITex:IsObjectType("TYPE")"#), "the raise carries the reference's Usage text and the region's name: {err}" ); } let anon = s .run("TIAnon:IsObjectType(nil)") .expect_err("anonymous region raises too") .to_string(); assert!( anon.contains(r#"Usage: :IsObjectType("TYPE")"#), "an anonymous region reports , as GetName()'s absence does: {anon}" ); } /// Frames also carry 1.12's frame-side pair, `GetFrameType 0x773640`/`IsFrameType 0x773700` /// (`CSimpleFrameScript.cpp`), beside `CScriptRegion`'s `GetObjectType`/`IsObjectType`. #[test] fn the_frame_side_type_identity_verbs_are_1_12s_own_names() { let s = crate::script::UiScript::new().unwrap(); s.run( r#" FTFrame = CreateFrame("Frame", "FTFrame") FTButton = CreateFrame("Button", "FTButton") FTModel = CreateFrame("Model", nil, FTFrame) FTTex = FTFrame:CreateTexture("FTTex", "ARTWORK") "#, ) .unwrap(); // Both read the same per-class type-name slot (`[edx+0x1c]`). for (obj, leaf) in [ ("FTFrame", "Frame"), ("FTButton", "Button"), ("FTModel", "Model"), ] { assert_eq!( s.eval::(&format!("return {obj}:GetFrameType()")) .unwrap(), leaf ); assert_eq!( s.eval::(&format!("return {obj}:GetObjectType()")) .unwrap(), leaf, "the two names must never disagree — they read one slot" ); } // How Cartographer's `LookNFeel.lua:368` finds the world map's player arrow. assert!( s.eval::(r#"return FTModel:GetFrameType() == "Model" and not FTModel:GetName()"#) .unwrap(), "an anonymous Model must answer its type AND a nil name — LookNFeel.lua:368" ); assert_eq!( s.eval::("return FTButton:IsFrameType('Button')") .unwrap(), 1 ); assert_eq!( s.eval::("return FTButton:IsFrameType('frame')") .unwrap(), 1 ); assert_eq!( s.eval::("return FTButton:IsFrameType('REGION')") .unwrap(), 1 ); for absent in ["LayoutFrame", "ScriptObject", "Object", "Slider", "Fram"] { assert!( s.eval::>(&format!("return FTButton:IsFrameType('{absent}')")) .unwrap() .is_none(), "{absent} is not in a Button's chain" ); } // A region has no frame-side pair: the two registrars are distinct. assert!(s.eval::("return FTTex.GetFrameType == nil").unwrap()); assert!(s.eval::("return FTTex.IsFrameType == nil").unwrap()); } /// A frame's type chain follows the reference's 23-class roster, a hardcoded list per class rather /// than a runtime parent walk. #[test] fn a_frames_type_chain_matches_the_roster() { let s = crate::script::UiScript::new().unwrap(); // (CreateFrame kind, GetObjectType string, full chain) let cases: &[(&str, &str, &[&str])] = &[ ("Frame", "Frame", &["Frame", "Region"]), ("Button", "Button", &["Button", "Frame", "Region"]), ( "CheckButton", "CheckButton", &["CheckButton", "Button", "Frame", "Region"], ), ("EditBox", "EditBox", &["EditBox", "Frame", "Region"]), ("StatusBar", "StatusBar", &["StatusBar", "Frame", "Region"]), ("Slider", "Slider", &["Slider", "Frame", "Region"]), ( "ScrollFrame", "ScrollFrame", &["ScrollFrame", "Frame", "Region"], ), ( "MessageFrame", "MessageFrame", &["MessageFrame", "Frame", "Region"], ), // Not via MessageFrame, despite the name (roster `0x787940`). ( "ScrollingMessageFrame", "ScrollingMessageFrame", &["ScrollingMessageFrame", "Frame", "Region"], ), // Capital HTML, unlike the `SimpleHtml` variant; addons compare the string with `==`. ( "SimpleHTML", "SimpleHTML", &["SimpleHTML", "Frame", "Region"], ), ( "ColorSelect", "ColorSelect", &["ColorSelect", "Frame", "Region"], ), ( "GameTooltip", "GameTooltip", &["GameTooltip", "Frame", "Region"], ), ("Minimap", "Minimap", &["Minimap", "Frame", "Region"]), // `PlayerModel` derives from `Model` (`0x505830`/`0x5057c0`), so a `SetUnit` portrait pane // has `SetCamera` too; `DressUpModel`, like `TabardModel`, derives from `PlayerModel`: the // roster's maximum depth, 5. ( "PlayerModel", "PlayerModel", &["PlayerModel", "Model", "Frame", "Region"], ), ( "DressUpModel", "DressUpModel", &["DressUpModel", "PlayerModel", "Model", "Frame", "Region"], ), ]; for (kind, leaf, chain) in cases { s.run(&format!(r#"TC = CreateFrame("{kind}")"#)) .unwrap_or_else(|e| panic!("CreateFrame(\"{kind}\"): {e}")); assert_eq!( &s.eval::("return TC:GetObjectType()").unwrap(), leaf, "{kind}:GetObjectType()" ); for want in *chain { assert_eq!( s.eval::(&format!("return TC:IsObjectType('{want}')")) .unwrap(), 1, "{kind} must be a {want}" ); } for (other, other_leaf, _) in cases { if chain.contains(other_leaf) { continue; } assert!( s.eval::>(&format!("return TC:IsObjectType('{other_leaf}')")) .unwrap() .is_none(), "{kind}'s chain must NOT contain {other_leaf} (via {other})" ); } } s.run(r#"TCNamed = CreateFrame("Button", "TCNamed")"#) .unwrap(); assert_eq!( s.eval::("return type(TCNamed:IsObjectType('button'))") .unwrap(), "number", "case-folded hit is the number 1" ); let err = s .run("TCNamed:IsObjectType({})") .expect_err("a table argument raises") .to_string(); assert!( err.contains(r#"Usage: TCNamed:IsObjectType("TYPE")"#), "the frame's Usage text names the frame: {err}" ); } /// Every name on the full region table the VM holds is in a leaf list: `script::region` copies /// names out of it into the Texture and FontString leaves, and one in neither is unreachable. #[test] fn every_installed_region_method_lands_in_a_leaf() { use crate::script::{ FONTSTRING_ONLY_METHODS, REGION_LEAF_SHARED, REGION_MAP_METHODS, TEXTURE_ONLY_METHODS, }; let s = crate::script::UiScript::new().unwrap(); let full: mlua::Table = s .lua() .named_registry_value(crate::script::REG_REGION_METHODS_FOR_TEST) .expect("the full region method table"); let mut known: std::collections::HashSet<&str> = std::collections::HashSet::new(); known.extend(REGION_MAP_METHODS); known.extend(REGION_LEAF_SHARED); known.extend(TEXTURE_ONLY_METHODS); known.extend(FONTSTRING_ONLY_METHODS); let mut orphans: Vec = Vec::new(); for pair in full.pairs::() { let (name, _) = pair.expect("region method entry"); if !known.contains(name.as_str()) { orphans.push(name); } } orphans.sort(); assert!( orphans.is_empty(), "installed on the region table but in NO leaf list, so no region can call them: {orphans:?}" ); } /// The Environment Detail pair, `SetWorldDetail 0x488dd0`/`GetWorldDetail 0x488d70`. #[test] fn set_world_detail_writes_the_stop_table_and_validates_like_the_reference() { let s = script(); s.register_cvars([ (crate::script::CVAR_WORLD_DETAIL, "1"), (crate::script::CVAR_FRILL_DENSITY, "32"), (crate::script::CVAR_SMALL_CULL, "0.04"), ]); let frill = |s: &crate::script::UiScript| s.cvar(crate::script::CVAR_FRILL_DENSITY); let stop = |s: &crate::script::UiScript| s.cvar(crate::script::CVAR_WORLD_DETAIL); // The preset tables at `0x804518` and `0x804524`, verbatim: {16, 32, 48} and `smallCull`'s // f32 {0.07, 0.04, 0.01} printed "%f". for (n, want, cull) in [ (0, "16", "0.070000"), (1, "32", "0.040000"), (2, "48", "0.010000"), ] { s.run(&format!("SetWorldDetail({n})")).unwrap(); assert_eq!( frill(&s).as_deref(), Some(want), "stop {n} writes frillDensity" ); assert_eq!( s.cvar(crate::script::CVAR_SMALL_CULL).as_deref(), Some(cull), "stop {n} writes smallCull" ); assert_eq!( s.eval::("return GetWorldDetail()").unwrap(), n, "and the getter reads that stop back in the SAME tick — the host has not drained yet" ); } assert_eq!( crate::script::WORLD_DETAIL_STOPS, [16, 32, 48], "the table is the reference's, not a transcription that can drift" ); // Truncation is toward zero (`0x40a2b0` sets RC = chop), so -0.5 is stop 0 and accepted. s.run("SetWorldDetail(2.9)").unwrap(); assert_eq!(frill(&s).as_deref(), Some("48")); s.run("SetWorldDetail(-0.5)").unwrap(); assert_eq!( frill(&s).as_deref(), Some("16"), "-0.5 truncates to 0, which is in range: only <= -1 raises" ); // `lua_isnumber` accepts a numeric string. s.run(r#"SetWorldDetail("2")"#).unwrap(); assert_eq!(frill(&s).as_deref(), Some("48")); for bad in [ "SetWorldDetail(3)", "SetWorldDetail(-1)", "SetWorldDetail(99)", ] { let e = s.run(bad).unwrap_err().to_string(); assert!( e.contains("value must be in the range 0, 2"), "{bad} must raise 0x8423b8 verbatim, got: {e}" ); } for bad in [ "SetWorldDetail()", "SetWorldDetail(nil)", r#"SetWorldDetail("x")"#, "SetWorldDetail({})", ] { let e = s.run(bad).unwrap_err().to_string(); assert!( e.contains("Usage: SetWorldDetail(value)"), "{bad} must raise 0x8423e8 verbatim, got: {e}" ); } s.run("SetWorldDetail(1)").unwrap(); assert_eq!( s.arity("SetWorldDetail(1)").unwrap(), 0, "every `ret` in 0x488dd0 leaves eax = 0" ); assert_eq!(s.arity("GetWorldDetail()").unwrap(), 1); assert_eq!( s.eval::("return type(GetWorldDetail())").unwrap(), "number" ); // The getter ignores an argument; pfUI's hook passes one. assert_eq!(s.eval::("return GetWorldDetail(7)").unwrap(), 1); assert_eq!(stop(&s).as_deref(), Some("1")); } /// pfUI's `hdgraphic` module (`modules/hdgraphic.lua:4-39`), which hooks both verbs to drive /// `frillDensity` past the top stop, run against the bindings. #[test] fn the_pfui_hdgraphic_extended_arm_runs() { let s = script(); s.register_cvars([ (crate::script::CVAR_WORLD_DETAIL, "1"), (crate::script::CVAR_FRILL_DENSITY, "32"), ]); s.run( r#" local HookSetWorldDetail = SetWorldDetail function SetWorldDetail(arg) HookSetWorldDetail((arg > 2 and 2 or arg)) if arg > 2 then ConsoleExec("frillDensity " .. (arg+1)*16) else ConsoleExec("frillDensity 24") end end local HookGetWorldDetail = GetWorldDetail function GetWorldDetail(arg) local frill = tonumber(GetCVar("frillDensity")) return frill > 48 and frill/16-1 or HookGetWorldDetail() end "#, ) .unwrap(); assert_eq!( s.eval::("SetWorldDetail(9); return GetWorldDetail()") .unwrap(), 9, "the extended stop round-trips through frillDensity, which is the module's whole point" ); assert_eq!( s.cvar(crate::script::CVAR_FRILL_DENSITY).as_deref(), Some("160"), "(9+1)*16 — inside the reference's own [1, 256], which is why its range is wider than its slider" ); // The low arm falls through to the stock getter. assert_eq!( s.eval::("SetWorldDetail(2); return GetWorldDetail()") .unwrap(), 2 ); } /// `ShowNameplates 0x489450`, `HideNameplates 0x489460`, `ShowFriendNameplates 0x489470` and /// `HideFriendNameplates 0x489480` read no argument and return nothing: four 10-byte bodies over /// two setters, differing only in an `or`/`and` mask. They write bits `0x1` and `0x8` of the /// runtime dword `[0xc4da34]` and no CVar: 1.12 registers none (no `0x63db90` site names a plate). #[test] fn the_nameplate_verbs_write_two_runtime_bits_and_no_cvar() { use crate::script::{PLATE_BIT_ENEMY as ENEMY, PLATE_BIT_FRIEND as FRIEND}; let mut s = script(); s.run("ShowNameplates()").unwrap(); assert_eq!(s.take_nameplate_bit_writes().apply(0), ENEMY); assert!( s.take_nameplate_bit_writes().is_empty(), "a drain empties the queue" ); s.run("HideNameplates()").unwrap(); assert_eq!( s.take_nameplate_bit_writes().apply(ENEMY | FRIEND), FRIEND, "the friendly bit is a separate setter — hiding enemies must not touch it" ); s.run("ShowFriendNameplates()").unwrap(); assert_eq!( s.take_nameplate_bit_writes().apply(0), FRIEND, "...and back the other way" ); s.run("HideFriendNameplates()").unwrap(); assert_eq!(s.take_nameplate_bit_writes().apply(FRIEND), 0); // In call order, the last write per bit standing, as the setters `or`/`and` the live dword. s.run("ShowFriendNameplates() HideFriendNameplates() HideNameplates() ShowNameplates()") .unwrap(); assert_eq!(s.take_nameplate_bit_writes().apply(FRIEND), ENEMY); // The frame loop's latches, bits `0x2` and `0x4`, are no verb's to touch. s.run("HideNameplates() HideFriendNameplates()").unwrap(); assert_eq!(s.take_nameplate_bit_writes().apply(0xff), !(ENEMY | FRIEND)); s.run("ShowNameplates(false)").unwrap(); assert_eq!( s.take_nameplate_bit_writes().apply(0), ENEMY, "the verb IS the value — a falsy argument does not invert it" ); for call in ["HideNameplates(1, 2, 3)", "ShowFriendNameplates({})"] { s.run(call) .unwrap_or_else(|e| panic!("{call} must not raise: {e}")); } let _ = s.take_nameplate_bit_writes(); assert_eq!( s.arity("ShowNameplates()").unwrap(), 0, "zero values — observably different from nil for a caller that counts" ); assert!( s.take_cvar_changes().is_empty(), "no CVar written: the dword is not a setting" ); for name in ["nameplateShowEnemies", "nameplateShowFriends"] { assert_eq!(s.cvar(name), None, "{name}: no plate CVar is registered"); } } /// The host seams benilla's own interface used are gone, now that it speaks 1.12 alone: the key /// capture, the error-log reads, the chat forwarders and the uncalled binding-set probe. #[test] fn the_layers_host_seams_are_gone() { let s = script(); for name in [ "BenillaBindCapture", "BenillaCharacterBindingsExist", "BenillaGetNumScriptErrors", "BenillaGetScriptErrorInfo", "BenillaClearScriptErrors", "SubmitChatInput", "BenillaChatTabPressed", ] { assert!( s.eval::(&format!("return {name} == nil")).unwrap(), "{name} is still a global" ); } }