mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-16 16:10:36 +00:00
1992acac2ace6074fc8a06f3dfaf8d7a9956ea59
63
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
9a20c5326a |
fix(dressup): look a link's mount up once
DressUpItemLink went on to DressUpMountLink for an item the model cannot wear, and DressUpLink called DressUpMountLink again when that returned false. A link that was neither wearable nor a mount ran the mount lookup twice, and an uncached item started its cache load and wrote the pending mount twice. The wearable-item step is now one local function. DressUpItemLink, which 1.12.1's FrameXML (ItemRef, bags, loot, the auction house) calls alone, tries the item and then the mount. DressUpLink keeps retail's shape: the item step for item links, then one DressUpMountLink call that gets its forcedFrame. |
||
|
|
68957e42bf |
fix(dressup): keep a pending mount preview until its own creature loads
When a mount's creature is not cached, DressUpMount records the mount and waits for CREATURE_DATA_LOAD_RESULT. The handler cleared that record on any creature's result. A failed or successful load of an unrelated creature (another addon's query, a world creature) consumed it, and the preview never opened when the mount's creature arrived. The pending record now holds the creature GetMountInfoExtraByID loads: the misc value of the mount spell's SPELL_AURA_MOUNTED effect, read with C_Spell.GetSpellEffectInfo. Only that creature's result clears the record, and only a successful one opens the preview. |
||
|
|
90c88a89d5 |
feat(model): seat the player on a mount in the dressing room
A ModelScene mount actor now seats a rider the way 1.12's world mount (0x00607A00) does: CM2Model::Attach (0x00712F70) puts the rider's model on the mount's attachment 0, and the rider plays the seat animation (91). Attach takes the rider off the scene's animate list and the mount holds a reference on it, so the actor update no longer re-links a seated rider, a rider that drops its model detaches first, and a mount that drops its model unseats the rider through the CM2Model destructor (HandleClose2 0x007103A0 destroys at zero). The seated rider keeps its placement, now relative to the seat, as the world mount sets the attached rider's base transform. CalculateMountScale is the mount display's CreatureModelScale (CreatureDisplayInfo col 4, OFF_CREATUREDISPLAYINFO_SCALE): the world seats the rider at +0x98 over that scale, and +0x98 is always 1.0. DetachFromMount only detaches, leaving the seat animation, unlike the world's Dismount (0x00607CE0). M2::Attach / M2::Detach wrap the two calls for the actor and the visual kits; Detach tests the parent first, since the engine call drops a reference unconditionally. C_MountJournal.GetMountFromItem returns the mount of an item whose use spell applies SPELL_AURA_MOUNTED; an uncached item starts its load. Enum.ModelBlendOperation is registered. The dressing room gains retail's mount mode: DressUpLink, DressUpMountLink and DressUpMount show a ModelScene over DressUpFrame's backdrop, above the button row, in place of DressUpModel (whose scale 2 rect reaches over the buttons). DressUpItem returns to the player model. A mount whose creature is not cached opens when CREATURE_DATA_LOAD_RESULT arrives. Control-click previews a mount from a spell link (Turtle-shaped links too), from a cached item that is not wearable, and from the spellbook, where a mount spell then never casts. Retail's ModelSceneControlFrame is ported with its strings in every locale and GameTooltip_AddBodyLine. Its seven atlases are built in: the sprites cut from retail's CommonIcons / CommonButtons into one 128x128 palettized BLP2 near their drawn size, since a built-in texture has one mip. Held rotation counts retail's per-frame 0.05 per 1/60 s, the speed of 1.12's own rotate buttons, instead of per frame at 1.12's uncapped frame rates. |
||
|
|
f8a49dec33 |
feat(model): run retail's ModelScene Lua on the scene frame
Retail's camera registry, camera base, orbit camera, scene mixin and actor mixin come over verbatim, with their XML templates, so a scene built with SetFromModelSceneID frames, scales and orbits its actors the way retail's does. What they need from the client: Actor templates. 1.12's XML loader registers every virtual top-level node whatever its tag, so <Actor name="ModelSceneActorTemplate"> is a template that Xml::Template finds. CreateActor(name, template) loads it the way an animation group loads its own: the whole inherits chain's mixins first, then each node from the base up, then OnLoad. The parentKey, parentArray, <Scripts> and <KeyValues> readers move out of the animation loader so both use them. Scene state. Light setters write the frame's M2Light through the engine's own setters (M2LightSetType 0x0071B620, SetDirection 0x0071B6A0, SetPosition 0x0071B650, SetEnabled 0x0071B780). Fog uses the Model frame's fields (+0x3A4..+0x3B0), stored as Model's own SetFogColor, SetFogNear, SetFogFar and ClearFog store them, and starts at retail's values. The draw layer goes through the engine's layer-name functions (0x006F18B0, 0x006F1900) and marks both layers changed. SetPaused keeps the frame update but skips Model's M2SceneAdvance. The XML loader adds drawLayer, fogNear, fogFar and <FogColor> after the frame's own loader. Actor state. A blend operation for PlayAnimation. Spell visual kits use the routine behind PlayerModel:ApplySpellVisualKit, which now takes a model instead of a pane; the actor applies a kit once its model loads and takes the effects off when the kit changes. 1.12 has no animation kits, so PlayAnimationKit and StopAnimationKit change nothing. GetCursorDelta, which the orbit camera drags with, samples the top's cursor (+0x1118) once a frame at the head of the UI render callback and converts it the way GetCursorPosition (0x0048B820) does, so the delta is the difference of two GetCursorPosition values. C_PlayerInfo. GetAlternateFormInfo answers false, false: 1.12 has no alternate forms. |
||
|
|
42cdebabc3 |
feat(model): add the ModelScene frame type and C_ModelInfo
ModelScene is a 3D stage of model actors with its own camera. 1.12.1's Model frame is already one: every Model frame owns an M2 scene and a clock, and its paint (SimpleModelDraw 0x0076D240) animates and draws the whole scene, each unattached model with its own placement matrix. The stock frame only ever places one model. So a ModelScene is a CSimpleModel: the Model factory's allocation plus our fields, CSimpleModel's constructor (0x0076C8E0), then copies of its two vtables with the Model half hidden from Lua. Lookup goes to our method hash and then CSimpleFrame's, the type answers ModelScene, Frame and Region but not Model, and Model's script names and XML loader give way to the Frame ones. The layer emit queues our paint on ARTWORK. The paint repeats SimpleModelDraw call for call: save the device transforms, project through the frame's camera over its rect, clamp the viewport, clear depth, place each actor where slot 0x98 would place the one model, animate the scene from the camera eye, draw passes 0 and 1, and restore. The camera is a CCamera made and installed the way the PlayerModel pane makes its fallback camera (CameraCreate 0x007AC930, SimpleModelInstallCamera 0x0076CE80). Eye and target come from the position and forward axis. The yaw and roll properties are solved so that the view's up vector equals the requested one. The default light is set the way PlayerModel's constructor sets its own. An actor is a script object holding one model in the frame's scene. It is lit through the frame's light callback, placed with CM2Model::SetBaseTransformTRS (0x00710650), and polled for load and dressing from the frame's update, never from the paint. A display with an Extra record is dressed through the engine compositor. The bounding boxes come from GetSequenceInfo (0x00711A20) and GetBoundingBox (0x00713640). C_ModelInfo's getters read the rows of scenes 4, 44 and 596, embedded from the retail 12.1.7 exports. The four active-scene functions do nothing, as retail's own documentation says, and live in Compat.lua. The same calls on Turtle and on retail draw the same picture (scene 4's camera on the Brown Horse, centred on Z, scaled by retail's normalization). Frame::Subclass now holds the vtable copy and the per-class method hash, which Cooldown uses too. Model::DisplayInfo::CreateDisplayModel builds a display's model for both portraits and actors. |
||
|
|
de033896b1 |
feat(spell): let autoUnshift talk and use objects in the druid forms
1.12's SpellShapeshiftForm.dbc gives SHAPESHIFT_FORM_FLAG_CAN_INTERACT (0x8) only to Shadowform. 3.3.5 and 4.4.2 also give it to Cat, Travel, Aquatic, Bear, Dire Bear and Ghost Wolf, and Turtle's id 11 (Swift Travel Form) has it there too. So in the later clients, these forms pass the NPC right-click gate (CGPlayer_C::HandleOnRightClick, 0x005F0130) and the game-object use check (0x005F3130) as they are. The form cancel that comes before the range check almost never runs. In 1.12, autoUnshift cancelled every druid form at that gate, even when the NPC was out of interact range. With autoUnshift on, the redirected IsShapeShifted calls at both gates and at CanInteractNow (0x00606880) now read a form in that set as able to interact. They report "not shifted", so the engine's own 0x8 test that follows does not refuse it, and the cursor shows the NPC's service icon. The cancel stays for a form that cannot interact in either client. Neither vmangos nor tortoise-wow tests the form on an NPC or object interaction. CanInteractWithNPC and the use handlers have no form check; the only one is item use. So the client gates are the only refusal. |
||
|
|
ebfd9d034d |
feat(localization): complete and correct the Russian locale (#130)
* feat(localization): complete and correct the Russian locale
The Russian locale was 99 keys behind enUS, so a Russian client kept the
English strings for ClassicAPI's own options: the AddOn Options title and
its game-menu button, every page name, header, control label and tooltip,
the AoE Loot binding, and the generic strings the options pages gained
(FOCUS_TOKEN_NOT_FOUND, LUA_ERROR, RELOADUI, PLAYER_LIST_DELIMITER,
SYMBOLIC_NEGATIVE_NUMBER, SYMBOLIC_POSITIVE_NUMBER and the money texture
formats). All 327 keys are now present, in enUS order, so the two files
diff key by key.
Focus follows the client's modern terms — «Взять в фокус», «Сбросить
фокус», «Выбрать фокус» and «Взять цель в фокус» — matching the existing
/фокус and /сбросфокуса aliases. The rest uses the 1.12 Russian client's
vocabulary where it has one (модификация, цель, панель команд, время
восстановления, табличка с именем) and «динамическое выделение» /
«мягкая цель» for action targeting. The money strings keep their |4
plural forms, which GetCoinText expects.
Fixes:
- LARGE_NUMBER_SEPERATOR was "", which turned digit grouping off. It is
now a space, as in the tooltip's 1 234 567.
- FIRST/SECOND_NUMBER_CAP and their _NO_SPACE twins carry the leading
space, because Abbreviate concatenates the number and the suffix
directly.
- EQUIPMENT_MANAGER_ITEMS_MISSING_TOOLTIP printed a slot number where
the missing count belongs; it now takes the missing count.
- SETTINGS_BIND_KEY_TO_COMMAND_OR_CANCEL was missing a space before
«или нажмите».
- SET_FRIENDNOTE_LABEL had a |3-5 declension token, which 1.12 renders
literally.
- ITEM_SLOTS_IGNORED and ITEMS_NOT_IN_INVENTORY had wrong third plural
forms, ITEM_MOD_HIT_MELEE_RATING_SHORT had a double space, and the flat
stat labels (Защита, Уклонение, Парирование, Блок) read wrong after a
signed value, so they use the same «к …» form as the other ITEM_MOD
labels.
The TOC gains ## Notes-ruRU next to ## Notes.
* fix(localization): restore retail ruRU focus, number and log strings
Follow-up to the Russian locale completion, which had changed several
strings that the retail ruRU client already translates. Each is now
the retail text, or a correction where the new wording was wrong:
- Focus: the FOCUSTARGET / TARGETFOCUS binding labels were swapped
(FOCUSTARGET runs FocusUnit("target"), TARGETFOCUS runs
TargetUnit("focus")). All focus strings use retail ruRU's terms
again: Запомнить цель, Восстановить цель, Отменить запоминание цели,
Запомненная цель, <фокус отсутствует>.
- EVENTTRACE_LOG_DISCARD is the message logged after the log is
discarded; it had become an option-style label. Retail: Журнал
сброшен. EVENTTRACE_BUTTON_DISCARD_FILTER read "cancel all"; retail:
Сбросить все.
- FIRST/SECOND_NUMBER_CAP and their _NO_SPACE variants go back to
retail Т / М. AbbreviateNumbers appends the _NO_SPACE suffix
directly by design ("1.2K"), so " тыс." widened compact numbers.
- LARGE_NUMBER_SEPERATOR goes back to retail "" (as frFR). A plain
space also let a number wrap across lines. The separate-large-numbers
tooltip drops its "1 234 567" example, which no longer applies.
- The loose-target option read "whom the soft target follows". The
normal target is the one that follows, so it is now "обычная цель",
and the choices name the soft enemy / soft friend.
* fix(localization): pick language rules by locale name, not 4.3.4's index
1.12.1's locale index (VAR_LOCALE_INDEX, 0xC0E080) is the Wow.ini
Language+Country tag's position in the eight-entry name table at
0x8558A4 (enUS koKR frFR deDE zhCN zhTW esES xxYY), stored once at
0x402562 and 0 when nothing matches. It is never 8. The Russian branches
ported from 4.3.4 switched on 4.3.4's own slot numbers (esMX 7, ruRU 8),
so they could never run: a client whose GetLocale() is "ruRU" fell
through to the default plural rule ("5 предмета") and got no ё/е folding
in bag search.
Localization::Locale::Client() reads the same entry Script_GetLocale
(0x48D8B0) pushes, table[index], and Is(code) compares against it. The
language-rule sites now go through it:
- Text::Grammar's plural index (|4 expansion) keys koKR/frFR/zhCN/zhTW
and ruRU by name.
- Container::Search picks its accent-folding set by name, as a Folding
value instead of an index switch.
- Localization::Numbers' ClientIsAsian reuses IsAsianLocale on the name.
- AddOns::TocRewrite drops its private copy of the reader, and the
slot-8 clamp, which guarded an index that cannot occur.
The DBC column reads keep using the index, which is what it is for.
---------
Co-authored-by: Brues <5278969+brues-code@users.noreply.github.com>
|
||
|
|
55d94c80d6 |
feat(spell): apply autoStand/autoDismount/autoUnshift to interaction, loot, items, attacks and taxis
The three settings only covered casts. Each 1.12.1 gate that refuses an action for the player's stand state, mount or form now passes when the matching setting allows it, and the engine's own action (the stand setter FUN_005ED430, or CMSG_CANCEL_AURA for the mount / form aura) runs just before the action is sent. With the settings at 0 nothing changes. - NPC right-click (0x005F0130): the IsShapeShifted call at 0x005F0150 cancels a form without SpellShapeshiftForm flag 0x8 instead of showing ERR_CANT_INTERACT_SHAPESHIFTED. CanInteractNow (0x00606880), whose only caller is the hover cursor, passes the same form, so the NPC's service cursor shows. - Game objects: the use check (vtable slot 6, 0x005F3130), also the hover cursor's query, passes the mount (0x005F31A8) and the form (0x005F31E1) for an object with no Lock row. The default use's no-spell branch (0x005F35DF, before CMSG_GAMEOBJ_USE) and the mailbox and text use slots dismount (except at a mailbox, FUN_0047CFF0) and cancel the form. A locked object opens by a spell, which the cast path already handles. - Loot: the GetStandState calls of the unit (0x0060BFB7) and corpse (0x005D6C3B) right-clicks stand the player up instead of showing ERR_LOOT_NOTSTANDING. The unit loot step's mount read (0x0060BF98) passes, and LootUnit dismounts before CMSG_LOOT (0x005DF3B3). - Item use (0x005D8D00): the ERR_NO_ITEMS_WHILE_SHAPESHIFTED refusal at 0x005D914D cancels the form and continues. Turtle's exe already skips that test; the stock exe reaches it. - Attack: the mount reads in the attack cursor (0x00482659), the right-click attack (0x0060C1B4), StartAttack (0x005ECC06) and both tests of the attack resolver (0x00613039, ERR_ATTACK_MOUNTED; 0x00613142) pass. StartAttack, after all its tests (0x005ECC56), dismounts when the target is in melee reach (Combat::Swing::InMeleeRange). Otherwise it returns without attacking and shows ERR_OUT_OF_RANGE, except while click-to-move (FUN_0060F900) walks the player there. - Taxi: after the taxi map opener's TAXIMAP_OPENED tutorial call (0x004DBAA2), a map with more than one node stands the player up, dismounts and cancels the form, each when its setting is on. Every site is patched only when it holds the expected stock bytes, which both the Octo and stock 1.12.1 exes do. |
||
|
|
4726fd7c85 |
feat(model): add DressUpModel try-on hand, enchant glow, sheathing and auto-dress
TryOn now takes retail's (item [, handSlotName, spellEnchantID]) and returns an Enum.ItemTryOnReason. The pane gains IsGeoReady, SetSheathed / GetSheathed and SetAutoDress / GetAutoDress. Hand: TryOnItem (0x00504540) picks a lane at one site, 0x0050492D (mov edx,[edi+0x2C]; cmp edx,0x0D). A 6-byte call there jumps a named hand to the worker's own main-hand (0x0050495F) or off-hand (0x005049B1) path, so its CanHoldBoth (0x00504BC0) eviction, lane store and attach all still run; with no hand it replays the two instructions and the jnz reads their flags. The name is matched like GetInventorySlotInfo matches it: SStrCmpI over the PaperDollItemFrame rows, slot 16 or 17. Enchant glow: the player's AttachEnchantVisual step (0x005EED50) on the attachment AttachItemModel (0x0047A0C0) returns: FindChild (0x00712F00), then AttachItemVisuals (0x00479700) with SpellItemEnchantment +0x58, skipped when the display's own ItemVisuals row exists (GetItemDescVisual's rule, 0x0062EC70). The enchant is the argument, else the link's enchant field, which Item::Arg now parses. Sheathing re-runs the unit's AttachHandItem step on the pane's lanes with the sheathed flag. The lanes keep no display row, so the pane records one: the unit's vtable +0x9C row when SetModelInstance (slot 0x00808438) clones it, then whatever the worker's attach (0x00504AE6) installs; its two evictions (0x00504A0C, 0x00504A55) drop theirs. Each lane keeps its glow too, a player's read through GetVisibleItem + GetItemDescVisual, so a re-hung weapon keeps it. Auto-dress off runs ClearModel (0x00504490) after SetModelInstance unless Dress() is the one rebuilding. TryOn's result reads the gates the worker passes: an uncached record is DataPending, a held type installs, armor needs the component and the ready byte (+0x40C). DressUpItemLink now passes the whole link to DressUpItem, so a Control-click shows the link's enchant, and skips a cached item that IsDressableItem rejects. DressUpItem stays, since Blizzard_AuctionUI and Turtle both replace it. |
||
|
|
3e0c40184b |
feat(cursor): add expanded cursors for NPCs and the fishing bobber
Adds the expandedCursors cvar (default 0; AddOn Options > ClassicAPI > Interface > Cursor). At 1 the hover cursor shows what an NPC offers: an anvil for a repairer, a hearthstone for an innkeeper, a horseshoe for a stable master, and a quest giver's ! or ? (a blue ? for a repeatable reward). The player's fishing bobber shows a fish hook in place of the Interact gear. Each has a gray form beyond reach or when not usable. NPCs: ClassifyHoveredUnit (0x00482200) reaches its NPC flag chain at 0x00482336 for a unit the player can interact with, the unit in ESI and the beyond-reach flag in EBX. The chain's `mov ecx, [esi+0x110]` becomes a call to a thunk. At 0 it replays the instruction and the stock chain runs. At 1 it picks from the quest giver status first (CGUnit_C +0xCB8, read by the meaning of the client's status-to-marker table at 0x0080C454), then the NPC flags in service order: repair, innkeeper, flight master, trainer, spirit healer, banker, registrar/tabard/ battlemaster, auctioneer, stable master, vendor, then gossip or a quest giver IsQuestGiverToTalk (0x005DF490) accepts. It leaves through the chain's own epilogue (0x00482356). Bobber: the fishing node handler's cursor slot (vtable 0x0080BC80, slot 4; GetCursor 0x005F8760 is its one reader) points at a wrapper that runs BaseHandlerGetCursor (0x005F3070) and maps Interact/UnableInteract to the hook. The engine still decides whether the bobber is interactable and usable. Showing a mode past 41: SetCursorMode indexes a 42-slot image table, so its existing hook now sends the new modes to Cursor::Extended::Show. It calls SetCustomCursor (0x00523C40) with the mode's path, so a real file wins, and otherwise does what that function does after its load: copy the 32x32 image into slot 41 (0x00C0BD80), store mode 41, send it (SendCursorImage 0x00523790) and keep the name. The hook also records the new modes while Hover::Mode computes, so the soft-interact pick, its icon and SetUnitCursorTexture follow; a quest cursor has no icon image. Images: the 14 BLPs ship inside the DLL (src/embed/Textures, a new TEXTURES_ROOT pack). Texture::Builtin decodes each once with the engine's BLP reader from memory: BlpParse (0x005A83B0) is BlpOpen without the file read, and BlpReset never frees the file buffer. The reader moves to Texture::BlpReader, shared with the map overlays. Texture loads of the same paths, such as the option label's inline icons, get the same images. The reader refuses a DXT5 file. BlpDecodeLevel (0x005A7F00) converts a DXT level through the matrix InitConvertMatrix (0x005A4FC0) fills, and that matrix has DXT1 and DXT3 converters to BGRA8888 but none for DXT5: BlpDecodeLevel would return 1 with its SMemAlloc buffer unwritten. No shipped cursor is DXT5; the check keeps a later embedded DXT5 file, or a DXT5 map overlay, from being read as heap memory. Game paths now compare through one rule, Common::SamePath (any case, either slash), and the embedded manifests through Embed::FindFile. The embedded addons, the bindings splice and sound muting each had their own copy of the rule; they and Texture::Builtin now share it. The option's header, label and tooltip are translated for every client locale, in Blizzard's own terms for each (NSC, PNJ, 物体, 物件, ...). Release Win32 build is clean. In game, only the soft-interact quest icon was checked so far. |
||
|
|
b3e8d92b03 |
feat(localization): translate the addon options panel into zhCN (#126)
* feat(localization): translate the addon options panel into zhCN A Chinese client kept the English strings for ClassicAPI's own options: the AddOn Options window title and its game-menu button, every page name, header, control label and tooltip, and the AoE Loot binding name, which zhCN only had as a commented-out line. The generic strings enUS gained with those pages were missing from zhCN too: FOCUS_TOKEN_NOT_FOUND, LUA_ERROR, RELOADUI, PLAYER_LIST_DELIMITER, SYMBOLIC_NEGATIVE_NUMBER, SYMBOLIC_POSITIVE_NUMBER and the money texture formats. The locale files load enUS first and the file that matches GetLocale() overrides it, so English clients are unchanged and only zhCN is filled in. Terminology follows the client's own: 插件, 界面, 姓名板, 动作条 and 动作瞄准 for action targeting. The Release Win32 build embeds the new zhCN.lua in the !!!ClassicAPI pack (the packed strings were checked). Not tested in-game. * fix(localization): use Blizzard's zhCN terms in the options panel The backpack options said 背包, which zhCN uses for bags in general, so "ignore backpack" read as "ignore bags" and its tooltip contradicted itself. Use 行囊 for bag 0, as BACKPACK_TOOLTIP and BINDING_NAME_TOGGLEBACKPACK do. Junk is 垃圾 (BAG_FILTER_JUNK), and helpful spells are 有益法术, as in the self-cast option tooltips. Drop the coin-texture and signed-number format strings: they were byte-for-byte copies of enUS.lua, which always loads first. --------- Co-authored-by: Brues <5278969+brues-code@users.noreply.github.com> |
||
|
|
05fa5845b7 |
feat(baselib): debuglocals, and the error window shows locals
debuglocals([level [, skipFunctionsAndUserdata]]) returns the locals and
then the upvalues of a call level as text, one name=value line each.
It runs only while an error handler runs, as in 4.3.4. 1.12.1's error
function sets no flag for that, but while a handler runs that function
(FUN_FRAMESCRIPT_CALL_ERROR_HANDLER) is a C closure level on the stack;
ErrorCallstack's search for it moves into a header so both modules use
it. level counts as lua_getstack and debugstack do.
Each local comes from lua_getlocal (0x6FBB20, fastcall L/ar + n), then
each upvalue of the level's function (lua_getinfo "f") from
lua_getupvalue (0x6F4660, fastcall L/funcindex + n). Values are
formatted as 4.3.4's FrameScript_PackVariable does, with retail's
spacing (probed: n=7, s="hi", t=<table>{ / k=1 / }): a frame table shows
its name, read from t[0] as FrameScript_GetObject does; a table's fields
show one space in at the top level only; a function shows where it is
defined (lua_getinfo ">nS"). The text stops at 4095 bytes. The second
argument, which retail's error handler passes as true, leaves out
function and userdata values.
Where 4.3.4 would fail inside the handler, this does not: a number key
outside int range is formatted from a copy, not converted in place
(which breaks lua_next), and a key that is not a number or string prints
as its type.
Retail also lists (*temporary) lines, 5.1's names for a level's stack
slots past its locals, including a C level's arguments. 1.12.1's
lua_getlocal is 5.0's and names declared locals only; those slots are
compiler registers that 5.0 and 5.1 allocate differently, so they are
not imitated.
The error window takes the locals as retail's GetErrorData does,
debuglocals(level, true) at the stack's level, and shows them under
Locals ("<none>" when there are none).
LuaCAPI.md had lua_pushupvalues, lua_getupvalue and aux_upvalue one row
off; corrected.
|
||
|
|
04790cb6c1 |
feat(options): name the page scroll bars for skins
Each options page's MinimalScrollBar is now ClassicAPIOptionsScrollBarN, numbered like the ClassicAPIOptionsControlN controls, so a skin can find the scroll bars the same way it finds the controls. |
||
|
|
e7ecae56da |
feat(options): key binding rows for ClassicAPI's bindings
The Interact Key page gets rows for Interact With Target and Interact With Mouseover, and Bags and Items gets AoE Loot under a Loot header. A row is retail's settings-page binding row: the binding's name, then a button for each of its two keys. Left click a button and press a key, mouse button 3-5 or the wheel to bind it; Escape cancels; right click unbinds that key. The tooltip on a bound key and the page's output line use retail's strings, added to every locale with Blizzard's translations. The binding is 1.12's Key Bindings window's (Blizzard_BindingUI): the same ALT-CTRL-SHIFT chord order, the same skipped modifier keys, the same KEY_UNBOUND_ERROR check for an action that loses its last key, and the same put-back when SetBinding refuses a key. A change saves at once with SaveBindings(GetCurrentBindingSet()), so it lands in the account or character set in use, as every other control on these pages writes at once. While a button listens, a full-screen button on FULLSCREEN_DIALOG takes keys, clicks and the wheel, as retail's KeybindListener and its input blocker do. A left or right click on it cancels, and so does hiding the page. |
||
|
|
3a4d291748 |
fix(link): split links with string.split captured at load
LinkUtil.SplitLinkData and SplitLinkOptions looked up string.split on every call. BigWigs (pepopo978 fork) defines a table-returning string:split in Plugins/SpellRequests.lua, which replaces the global, so with it loaded every custom link type resolved to a table, no handler matched, and SetItemRef rejected the link as unknown. string.split is registered in C by the DLL before any addon loads, so a file-local captured when LinkUtil.lua loads always holds the real one. Fixes brues-code/pfUI#73 |
||
|
|
cc1e70a641 |
feat(debugtools): modern /etrace
/etrace and /eventtrace now open a backport of retail's Blizzard_EventTrace, the load-on-demand addon ClassicAPI_EventTrace embedded in the DLL. It replaces the old event trace frame in ClassicAPI_DebugTools, and DebugToolsSavedVars with it; the panel saves EventTraceSavedVars. What differs on 1.12.1: - RegisterAllEvents adds the frame to every event slot, so it opens the listener gate of each ClassicAPI event that builds its arguments only for a listener (UNIT_AURA_DELTA, the combat log and cast events). The panel registers all events only while it is shown or logging while hidden; otherwise it keeps PLAYER_LOGOUT, which saves its variables, since this client has no ADDONS_UNLOADING. - An engine event signalled by a number with no name arrives with a nil event and is not logged. - An event's table arguments are copied when logged, and the tooltip lists their contents. UNIT_AURA_DELTA refills the same tables on every fire, so a kept reference shows only the latest delta. - No tool windows, ImGui debug tools or secret values. The window's templates are new shared templates in !!!ClassicAPI: ButtonFrameTemplate and PortraitFrameBaseTemplate (with PortraitFrameMixin / TitledPanelMixin), UIPanelCloseButtonNoScripts, PanelResizeButtonTemplate, InputBoxInstructionsTemplate, SharedTooltipTemplate, VisibleWhilePlayingAnimGroupTemplate, and GameTooltip_AddHighlightLine / GameTooltip_AddColoredDoubleLine. Art this client lacks is drawn with its own textures: tooltip border chrome, the world map magnifier, the cancel button, a turned chat expand arrow for the resize grip, and the panel button in three slices. The scroll bars are the 1.12 bar, whose art is wider than its frame, so the lists leave room for it. Retail's search box is ClassicAPISearchBoxTemplate. Turtle's FrameXML registers its own SearchBoxTemplate first, and 1.12 keeps the first template of a name, so the retail one takes that name only through a TOC line marked [ExcludeLoadGameType turtle]. The EVENTTRACE_* strings and SLASH_EVENTTRACE1-4 come from Classic Era's GlobalStrings for each client locale but koKR. |
||
|
|
2396d44f10 |
fix(frame): GetWidth / GetHeight / GetSize keep 1.12's scaled size
For a region with no set size, 1.12's Script_GetWidth (0x007A1E00) and
Script_GetHeight (0x007A2030) return the rect span without dividing by
the region's layout scale. The value is the size times the effective
scale: a 160-high track at a UI scale of 0.91 answers 145.6.
|
||
|
|
36f3661b98 |
feat(lua): GetCallstackHeight, GetErrorCallstackHeight, SetErrorCallstackHeight
Adds the three call stack heights an error handler uses to start its
stack at the code that failed:
debugstack(GetCallstackHeight() - (GetErrorCallstackHeight() - 1))
A height counts levels as lua_getstack (0x006FBAA0) does, and so as
debugstack does: C functions and lost tail calls count, and level 1 is
the caller.
1.12.1 records no error height, but every error report runs one C
function, FrameScriptCallErrorHandler (0x00703B40, __fastcall(L)). It
pushes the seterrorhandler function (registry ref 0x008722CC), moves it
under the message and lua_calls it. Nothing calls it directly: state
open pushes it as a C closure and refs it (0x008722C8). Every script
pcall passes that closure as the errfunc, so Lua calls it at the point
of the error before the stack unwinds; a chunk that fails to compile is
reported by a pcall of it (0x00704AE0). ClassicAPI's securecall,
hooksecurefunc and script runners pass the same ref.
So while any handler runs, that closure's level sits directly above the
code that failed. GetErrorCallstackHeight walks the levels with
lua_getstack and lua_getinfo "f", finds the innermost one whose function
is 0x00703B40 (lua_tocfunction, 0x006F3720) and answers the height below
it, or nil when no error is being reported. There is no hook, and
nothing is recorded, so a handler that fails part way leaves nothing
behind.
SetErrorCallstackHeight sets the height for a handler called with no
error raised. It applies only while no 0x00703B40 level is on the stack,
so a value left set by a failed handler cannot move a later error's
stack. A new Lua state starts with no value set.
Users:
- The Lua error window takes its stack this way, so it starts at the
failing code even when another addon wraps the handler.
- CallErrorHandler and assertsafe set the height around their direct
handler call, so they report from their caller.
- Game::Lua gains GetStack, GetInfo and ToCFunction; SourceLocation uses
them in place of its own copies.
Docs: the xpcall and coroutine notes said error() returns without
raising. Stock error (0x00702970) ends in lua_error (0x006F4440) and
raises. pfUI replaces the global error with one that prints and
returns, which is what those notes described.
Tested in game: with seterrorhandler wrapping the old handler, a nil
index in a local function f showed a stack that starts at f.
|
||
|
|
4f3ee595e7 |
feat(ui): Lua error window replaces the stock error box
The Lua error window (/luaerrors) moves from the load-on-demand ClassicAPI_DebugTools into !!!ClassicAPI and becomes the client's error display. Each error opens it with the message, time, count and stack, and the arrows page through every error so far. 1.12.1's error handler is FrameXML's _ERRORMESSAGE (BasicControls.xml). It reports an error as ScriptErrors_Message:SetText(message) and then ScriptErrors:Show(), and only while the stock box is hidden. The window's OnLoad takes those two slots, the same two !BugGrabber 2.1.1 takes: SetText records the error and Show does nothing, so the stock box stays hidden and every error arrives. Errors still pass through the handler first, so: - !BugGrabber loads after !!!ClassicAPI and takes the slots back. BugSack gets the errors and the window does not open. - An addon that calls seterrorhandler (pfUI) replaces _ERRORMESSAGE, so neither shows. One that wraps the old handler still ends here. The engine's error function (0x00703B40) is C. It runs at the point of the error, before the stack unwinds, and calls the registered handler. From the SetText slot, level 1 is the slot, 2 is _ERRORMESSAGE, 3 is that C function and 4 is the code that failed, so the stack starts at debugstack(4), the level !BugGrabber's GrabError reads from the same slot. The text is ClassicAPI's ScrollingEditBoxTemplate with a MinimalScrollBar. The bottom row has Reload UI, arrows that wrap around the index label, and Close. /luaerrors opens or closes the window and /luaerrors clear empties it; the old on/off handler install is gone. Not tested in game yet. |
||
|
|
9e5c0c558a |
feat(autocomplete): C_AutoComplete name completion (API only)
Adds C_AutoComplete.GetAutoCompleteResults, C_AutoComplete.IsRecognizedName, Enum.AutoCompleteEntryFlag and Enum.AutoCompletePriority, and the cvars autoCompleteResortNamesOnRecency, autoCompleteWhenEditingFromCenter and autoCompleteUseContext. ClassicAPI only answers the queries; an addon draws the list of names. 1.12.1 keeps no autocomplete list, but it keeps every list the names come from, so each query reads them where the client keeps them: - party: the four GUIDs at VAR_PARTY_GUIDS (0x00BC6F48), names from the name cache, online from the member stats block - raid: the VAR_RAID_MEMBER_PTRS slots (0x00B712A8) and their online bit - guild: the GuildMemberInfo roster at 0x00B72704, GUID at +0x00 and the online word at +0x48 (stored at 0x004D0C22, tested by GetGuildRosterInfo at 0x004D13C5). Read only while the player's guild key is set, the test IsInGuild (0x00516DE0) makes, because the client keeps the old roster after a /gquit - friends: the 50 slots of the social singleton Whisper partners are the one list the client does not keep. The chat dispatch hook (FUN_0049A870) reports each whisper and whisper inform (types 6 and 7, not the addon language -1) with the sender GUID it already resolves. Logging out clears the list. Names match case-insensitively by UTF-8 code point; Text::Utf8::CompareI now takes a character limit. Results come most recent whisper first, then by name. A result's priority is its closest tie: friend, guild, group, whisper. GetAutoCompletePresenceID and GetAutoCompleteRealms are constant answers in Compat.lua. The three cvars are on a new Social page of the options panel. |
||
|
|
1ef8c5597a |
fix(player): UnitNameFromGUID returns the name cache's realm
CGUnit_C::GetUnitName (0x00609210) takes a realm out-pointer as its stack argument, not the flags word Offsets.h called it. For a player whose name-cache record has a non-empty server name (record +0x30) it stores a pointer to that string, and otherwise leaves the pointer alone (0x0060926B-0x00609283). Vanilla's Script_UnitName (0x00517020) passes &realm there and returns it as UnitName's second value. The record's server name is the realm string SMSG_NAME_QUERY_RESPONSE carries: Tortoise sends it empty, a cross-realm server fills it. UnitNameFromGUID pushed a hard-coded "" instead. NameFromGuid now passes the out-pointer through, as Script_UnitName does, and gains a step between the friends list and the persistent cache: the engine name cache record itself (FUN_PLAYER_INFO_LOOKUP with no callback, a passive peek), which also gives the realm for players out of range. Before, a player who whispered from far away resolved only with the persistent cache on. UnitSpellTargetName shares NameFromGuid and finds those players too. The realm is "" when the record has none, or when the name came from the friends list or the persistent cache, which stores no realm. Retail documents both returns as non-nil strings. GetNameAndServerNameFromGUID in the addon's PlayerUtil returned GetRealmName(), the local realm, for every GUID. It now returns GetPlayerInfoByGUID's realm, as retail's UnitUtil does, so a player on the local realm gets "" and code that appends "-" .. realm only when it is non-empty works. Seven files declared their own function-pointer type for 0x00609210, all with the wrong int *outFlags argument. Unit::Identity::NameForUnit is now the one wrapper. The other six callers pass no realm and behave as before. Offsets.h gives the getter's real signature (RET 4) and what it stores. API.md's GetPlayerInfoByGUID and UnitNameFromGUID entries describe the realm and the four sources. |
||
|
|
f19f13d44c |
feat(debugtools): fold pfDebug in as /profiler
pfDebug was a separate addon that profiled through ClassicAPI's own APIs: GetAddOnMemoryUsage and GetAddOnCPUUsage, GetFrameCPUUsage, GetFunctionCPUUsage, GetEventCPUUsage, and the intrinsic precall and postcall script hooks. Its code now lives in ClassicAPI_DebugTools under Profiler/, with its MIT notice (Copyright (c) 2018 Shagu). The analyzer tabs (Addons, Frames, Events, Globals) and the widget are pfDebug's, with the frame and template names renamed to ClassicAPIProfiler*. /profiler and /prof load DebugTools on demand through the same stub as /dump, then toggle the analyzer. The subcommands widget, reset and profile on|off are pfDebug's. What changed in the move: - The sampler starts only when the widget or the analyzer first opens, so a load for /dump costs nothing. It first takes every counter as it is, so the first CPU/s and KB/s cover one second, not the session. - Whether profiling runs is probed, not read from the cvar: a function is called once and GetFunctionCPUUsage must count that call. The scriptProfile cvar can already hold the next session's value. - A frame record starts at the frame's current CPU time and call count, and opening the analyzer takes every frame and event counter again, because the frame totals and the deep hooks keep counting while it is closed. pfDebug started records at 0, so the first scan and each reopen showed a frame's whole session as one second. - The /fstack lines (owner, OnUpdate and OnEvent owner and CPU, all scripts, deep allocations) are added at the end of FrameStackTooltip_OnTooltipSetFrameStack, not by hooking OnTooltipSetFrameStack. - No pfUI skin and no SavedVariables. The plain backdrop is pfDebug's own fallback. The widget no longer opens at login, because that would load DebugTools at login. README's Debug tools table gains /profiler and the new /fstack lines. |
||
|
|
4509da0966 |
build: pack each embedded addon into one gzip stream
Each embedded file was its own gzipped RCDATA resource, 175 in all.
Every stream started with an empty deflate window, so no file could
match text it shares with its neighbours, and 97 of the files are under
4 KB, where that costs the most. Each resource also cost about 50 bytes
of resource directory and padding.
cmake/pack_files.cmake, which replaces gzip_file.cmake, now joins each
addon's files at build time into one gzip stream. It holds an index,
each file's size as a decimal line and then an empty line, followed by
the files' bytes in path order. `cmake -E cat` joins them byte for
byte, in batches of 100 so the Windows command-line limit cannot fail
the build. The index goes through file(CONFIGURE NEWLINE_STYLE UNIX)
because file(WRITE) writes \r\n on Windows. The resources are now three:
Bindings.xml as a pack of one, !!!ClassicAPI, and ClassicAPI_DebugTools.
The manifest entries become {path, resourceId, index}, and
Embed::Resource(id) becomes Embed::File(id, index). On first use it
inflates the whole pack with the engine's zlib, splits it into views,
and keeps it for the life of the DLL, as before. A pack whose sizes do
not cover its bytes exactly is rejected. The load-on-demand DebugTools
pack is still inflated only when it loads.
Embedded data 323,947 -> 272,825 bytes; .rsrc 334,336 -> 274,432;
DLL 1,632,768 -> 1,573,888 bytes.
|
||
|
|
2063507fb4 |
fix(lua): ported files read wipe from the ClassicAPI mirror
The global wipe is ours only until an addon declares its own: whoever writes _G.wipe last wins, with no error. RegisterGlobalFunction mirrors every global it binds into _G.ClassicAPI at registration, before FrameXML and every addon load, so ClassicAPI.wipe is always our table.wipe C function. The nine embedded files that call the bare global now take `local wipe = ClassicAPI.wipe;` and list it as their difference from retail: ScrollBoxListView, ScrollUtil, Menu, CallbackRegistry, MixinUtil, SecureTypes and the three DebugTools table inspector files. Files that read table.wipe, as their retail sources do, are unchanged. The global stays for third-party code. |
||
|
|
090cfc3bfd |
feat(lua): global wipe, the table.wipe alias
On a stock 1.12.1 client, ScrollBoxListView, ScrollUtil, Menu and the DebugTools table inspector failed with "attempt to call global `wipe'": those ports call bare wipe(), and only Turtle's client defines that global. Stock 1.12.1 has only the table.wipe that ClassicAPI registers. 3.3.5 makes the alias in FrameScript's compat preamble, next to tinsert and tremove (wipe = tab.wipe). 1.12's preamble is older than table.wipe, so Wipe.cpp now registers the same C function as the global wipe as well as table.wipe, with a LuaGlobals descriptor. CallbackRegistry, MixinUtil and SecureTypes lose their "1.12 has no global wipe" notes and their table.wipe locals, and now match retail. |
||
|
|
92025896b5 |
feat(options): a control for every cvar, one cvar per control
The AddOn Options panel now has a control for each of the 38 cvars that ClassicAPI registers, plus the player cache, on pages grouped by feature: Interact Key, Action Targeting, Combat, Bags and Items, Interface, Text To Speech and Advanced. Each control reads and writes exactly one cvar, and writes it only when the player uses that control. The "Interact Key Icons" preset dropdown is gone: it wrote four icon cvars at once, and Cancel restored it from a snapshot that read any mixed state as "NPCs Only", which turned SoftTargetIconInteract back on. Okay, Cancel and Defaults no longer write anything on these pages. - On/off cvars are checkboxes. The soft-target enable cvars read as on for 2 or 3 and write 3 or 0; 1 is gamepad, which does nothing here. - Fixed choices (the three arc cvars, SoftTargetForce) are dropdowns. A value outside the choices shows as its number. - Open-ended numbers (ranges, icon size, shake strength, combat log retention) are number boxes, so the panel sets no maximum. Sliders are kept for documented ranges only. - Each page's controls sit in a WowScrollBox with a MinimalScrollBar. The box clips its children, and the clip also keeps the mouse off controls that are scrolled out of view. The panel's strings are globals in locales\enUS.lua, which every client loads: CLASSICAPI_* for ClassicAPI's own, and retail's GlobalStrings keys where retail has the string (COUNTDOWN_FOR_COOLDOWNS_TEXT and its tooltip, with retail's translations in the other locale files). The README cvar table gains the five cvars it was missing. |
||
|
|
e37052c67d |
feat(lua): SharedColorConstants
Port of retail's Blizzard_SharedXML/SharedColorConstants.lua, in
Blizzard's own text. It loads after ColorUtil.lua, when Color.lua has
already made the GlobalColor globals it reads, and adds
PLAYER_FACTION_COLORS_HEX, PLAYER_FACTION_BRIGHT_COLORS (the PvP
scoreboard colors) and COVENANT_COLORS.
FACTION_BAR_COLORS now holds retail's color objects in place of 1.12's
plain {r, g, b} tables. The stock code that reads it (the unit tooltip
and the reputation bars) reads only .r, .g and .b, which the objects
have; the values differ by less than 1/255.
PLAYER_FACTION_COLORS moves out of Constants.lua, because retail
defines it only here, and GetFactionColor goes back to retail's
one-line body without our nil guard.
Verified in game: FACTION_BAR_COLORS[1] is ffcc4d38 and [5] is
FACTION_GREEN_COLOR, PLAYER_FACTION_COLORS_HEX[0] is ffff2934,
PLAYER_FACTION_BRIGHT_COLORS[1] is ff00adf0, GetFactionColor("Alliance")
is ff00adf0, and COVENANT_COLORS.Kyrian is ff2aa2ff.
|
||
|
|
f8f6dc28b8 |
feat(ui): GlobalColor table from build 1.60.1.70707
C_UIColor.GetColors now returns the GlobalColor.dbc rows of build
1.60.1.70707 instead of the BC Classic 2.5.5 snapshot: 331 rows where
there were 187, in the table's own row order.
- 148 new colors, among them PVP_SCOREBOARD_*_CELL_COLOR, the
EXPANSION_COLOR_* set, and the profession, threat and power-prediction
colors.
- 10 changed values, as the newer client has them: NORMAL_FONT_COLOR
ffd200, RED_FONT_COLOR ff2020, PLAYER_FACTION_COLOR_HORDE ff2934,
PLAYER_FACTION_COLOR_ALLIANCE 00adf0, TALENT_LINK_COLOR 71d5ff, and
more. The C++ tooltips that read the table (item comparison,
equipment sets, links) take the new values. Lua globals that 1.12
FrameXML already defines keep their own values, because Color.lua
only creates the globals that do not exist.
- The four HEALTHBAR_*_HEAL_PREDICTION_GRADIENT_COLOR* rows are gone;
the newer table does not have them and nothing read them.
- A name that the DBC lists twice keeps only its last row, which is
the value the client's own Color.lua loop ends on.
COMPACT_UNIT_FRAME_FRIENDLY_HEALTH_COLOR and
CHARACTER_FRAME_SIDE_PANEL_SKILL_COLOR join the earlier duplicates.
- DEBUFF_TYPE_ENRAGE_COLOR stays as our own row, for
C_UnitAuras.GetAuraDispelTypeColor("Enrage").
Verified in game: GetColors returns 331 rows,
PVP_SCOREBOARD_HORDE_CELL_COLOR is ffff2934 and the alliance one
ff00adf0, GetAuraDispelTypeColor("Enrage") is ffff8c00, and
HEALTHBAR_MY_HEAL_PREDICTION_GRADIENT_COLOR1 is nil.
|
||
|
|
4472c81137 |
feat(lua): retail SharedXML helpers, Spline, ExportUtil and MixinUtil
Ports from retail's Blizzard_ObjectAPI, SharedXML, SharedXMLBase and
FrameXMLUtil, in Blizzard's own text, from the _forever_ build:
- ObjectCache.lua and SpellBookItemLocation.lua (ObjectAPI).
- TypeUtil.lua: ValueToBoolean and StringToBoolean.
- SortUtil.lua: SortUtil.CreateSortManager and the comparators.
- Sequencer.lua, Spline.lua (Catmull-Rom splines), TaggableObject.lua,
ObjectUpdater.lua and ExportUtil.lua (base64 export/import streams).
- AnimationSystem.lua: SetUpAnimation and CancelAnimations.
- SmoothStatusBar.lua: SmoothStatusBarMixin.
- MixinUtil.lua: DrawLine, LineMixin, SparseGridMixin,
DoublyLinkedListMixin, DirtiableMixin, DirtyPhaseMixin and more. 1.12
has no global wipe, so the file reads table.wipe, as the other ports do.
FrameDeltaLerp now takes retail's three arguments and reads the frame
time from GetTickTime(). The old form needed a fourth elapsed argument,
so SmoothStatusBar's per-frame ticker would have errored. Nothing else
called it.
DebugTools drops its private StringToBoolean copy and calls the global
one from TypeUtil for the /framestack arguments.
FadingFrame.lua is not ported: 1.12's own FrameXML defines the same
FadingFrame_* names with no-argument `this` signatures, and ZoneText
calls FadingFrame_OnUpdate() every frame.
Verified in game: StringToBoolean, ValueToBoolean and
SpellBookItemLocation return the expected values, a 2D spline's midpoint
is (5, 10), an export stream round-trips 200 and 9, the sort manager
orders {3,1,2}, the linked list enumerates 0 1 2, ObjectUpdater,
Sequencer and SetUpAnimation finish, a smoothed status bar reaches 100,
and /framestack still opens.
|
||
|
|
9967cc0839 |
feat(lua): Spell objects, ContinuableContainer and TableBuilder
Ports from retail's Blizzard_ObjectAPI and SharedXML, in Blizzard's own text, from the _forever_ build (the newest interface code on disk): - Util/Spell.lua: Spell:CreateFromSpellID and SpellMixin. - Util/ContinuableContainer.lua: one callback for a group of item and spell objects. - Util/IndexRangeDataProvider.lua: CreateIndexRangeDataProvider, which ScrollBoxListView already expected. - Util/TableBuilder.lua: CreateTableBuilder, for the existing ScrollUtil.RegisterTableBuilder. - FrameXML/CallbackRegistrant: CallbackRegistrantMixin and CallbackRegistrantTemplate. AsyncCallbackSystem.lua gets its ASYNC_SPELL type and SpellEventListener back, so it is the _forever_ text again. New in the DLL for SpellMixin: - C_Spell.IsSpellDataCached, C_Spell.RequestLoadSpellData and SPELL_DATA_LOAD_RESULT. Every spell is client data, so a spell that exists is cached, and a request fires the event before it returns: (spellID, 1), or (spellID, nil) for an ID with no spell. Retail marks the event synchronous, and AsyncCallbackSystem relies on that. - C_Spell.GetSpellDescriptionForItemLocation. The item tooltip expands a spell's text with the same arguments GetSpellDescription passes, so it returns that text. The item location is still required. Verified in game: IsSpellDataCached(133) and (999999) are true and false, Spell:CreateFromSpellID(133) calls back with (133, 1), a container with item 19019 and spell 133 calls back, CreateIndexRangeDataProvider(5) has size 5, and GetSpellDescriptionForItemLocation(133, slot 1) equals GetSpellDescription(133). |
||
|
|
d9da100110 |
feat(tradeskill): linked windows show the crafter's name
3.3.5's interface never shows whose profession a linked window holds. Port 4.3.4's TradeSkillLinkNameButton and TradeSkillFrame_SetLinkName to TradeSkillFrame and CraftFrame: "[name]" after the title, and a click on it starts a whisper. The title moves left by half the name, from its own anchor, so Turtle's -30 offset stays. |
||
|
|
d92464b86c |
feat(tradeskill): trade links follow 3.3.5
Profession links are now built and opened the way 3.3.5's CGTradeSkillInfo does it. A received link opens in the engine's own TradeSkillFrame. The ClassicAPI viewer is gone. The link is 3.3.5's format: trade:<spellID>:<rank>:<maxRank>:<GUID>:<bits>|h[<spell name>]. The first field is the profession spell, not the skill line. The GUID replaces the name. A reader whose name cache does not hold the linker sends the name query and opens the link when the answer arrives. The bits cover every SkillLineAbility row of the profession, as 3.3.5's link run does. 1.12's DBC is sorted by ID and does not group a profession's rows into one run, so the rows here are taken in ID order. A link opens only when the reader's row count matches it. The 1.12 list build (0x004FCA20) is 3.3.5's RefreshList without the link branch. Three call-site patches add that branch: - the spell list comes from the link, - the ability rows use the linker's race and class, - the rank is the linker's. Two patches on TryCastSpell's toggle calls record the cast spell (3.3.5's m_spellID). They also make a cast while a link shows open the player's own list instead of closing the window. The game shutdown drops the link, as 3.3.5's does. Enchanting gets the same in the Craft window. Its rows are filtered by castUI, because its recipes have no TRADESPELL bit. GetCraftListLink and IsCraftLinked are the Craft window's twins of the 3.3.5 functions. GetTradeSkillLine, GetCraftDisplaySkillLine and GetCraftName give the linker's values while a link shows. Util/TradeSkillLink.lua now ports 3.3.5's linked mode, which hides Create, Create All and the count controls, and keeps the link buttons. Any spell whose Effect[0] is TRADE_SKILL can be linked. 1.12's SkillLine.dbc has no canLink column. Removed: C_TradeSkillUI.GetTradeSkillListLink, GetCraftListLink and GetTradeSkillListRecipes. Old links no longer open. Not yet verified in game. |
||
|
|
6259e22480 |
feat(lua): ItemUtil from retail
Util/ItemUtil.lua is now the ItemUtil table of retail
Blizzard_FrameXMLUtil/ItemUtil.lua, in retail's own text. As its header
lists, it leaves out ItemButtonUtil and DoesAnyItemSlotMatchItemContext
(retail drives them from frames this client does not have), the transmog
mixin, the currency path of GetItemDetails, and GetCraftingReagentCount
(reagent and account banks).
New for what it calls:
- Enum.BagIndex in the DLL, with Classic Era's names and this client's
indices: Keyring -2, Bank -1, Backpack 0, Bag_1..4 = 1..4 and
BankBag_1..6 = 5..10. Era's bank bags start at 6, after its reagent
bag. The indices live in Offsets.h now, and container/Search.cpp drops
its local copies.
- C_PaperDollInfo.GetInventorySlotInfoForInvSlot in the DLL. It takes the
first PaperDollItemFrame.dbc row with that SlotNumber, and walks the
rows the way the engine's GetInventorySlotInfo (0x004C81B0) does.
- C_Container.GetContainerNumSlots and C_Container.PickupContainerItem as
Lua aliases of the stock globals in Compat.lua, next to
C_ActionBar.ShouldShowKeyring, which is always true.
- ContainerFrame_GetContainerNumSlots and NUM_TOTAL_BAG_FRAMES from
retail's ContainerFrame.lua, and GameTooltip_SuppressAutomaticCompareItem.
Nothing reads that flag, because nothing compares items automatically.
docs/API.md covers all of it, plus Item objects and
C_Item.GetItemIDForItemInfo.
Verified in game: Enum.BagIndex.Keyring is -2, the backpack has 16 slots,
ShouldShowKeyring is true, slot 18 returns the ranged row with checkRelic
true, GetEmptyEquipSlotTooltip(1) is "Head", and FilterOwnedItems({6948})
finds a Hearthstone in the bags.
|
||
|
|
474da1a5b5 |
feat(lua): Item follows retail
Util/Item.lua is now retail Blizzard_ObjectAPI/Mainline/Item.lua in
retail's own text, and its listener is retail's AsyncCallbackSystem.lua
with the item and quest listeners. There is no spell listener: every
spell is client-side data here, so there is nothing to wait for. The one
other difference is that GetItemQualityColor reads ITEM_QUALITY_COLORS,
the same entry retail's ColorManager returns.
What follows retail now:
- Load callbacks get (id, success).
- An item callback also runs when the load fails, with success nil.
TradeSkillLink's two callbacks now stop on a failure, because
re-rendering would request the missing item again.
- C_Item.RequestLoadItemDataByID runs once per item, not once per
callback.
- New methods: GetStackCount, ContinueWithCancelOnRecordLoad and
IsRecordDataCached. ContinueOnItemLoad's usage errors name the bad
itemID or link, and GetItemGUID returns the GUID an item was made from.
C_Item.GetItemIDForItemInfo is new in the DLL for ItemMixin:GetItemID's
fallback. It uses the resolver that GetItemInfoInstant uses.
Verified in game: Item:CreateFromItemID(19019) calls back with
(19019, 1), and C_Item.GetItemIDForItemInfo("item:6948") returns 6948.
|
||
|
|
6cee968a8a |
refactor(lua): ItemUtil.lua is Item.lua
The file holds retail's Item mixin (Blizzard_ObjectAPI/Mainline/Item.lua) and its ItemEventListener, not retail's ItemUtil, so it takes Item.lua's name. No code changes. |
||
|
|
8f6ff33a39 |
refactor(lua): CallbackRegistry in retail's own text
|
||
|
|
5082f3c829 |
feat(lua): TableUtil follows retail
The file is now retail Blizzard_SharedXMLBase/TableUtil.lua in retail's own syntax: the length operator, `...`, select, math.huge, table.wipe and 5.1's unpack(t, i, j) all work here now. New from retail: TableUtil.SafeCountTable / SafeCountIndexTable, tInvertToArray and CollectTableDifferences. Fixed by following retail: TableUtil.Transform returned after the first value, ContainsAllKeys now also fails on a key only the second table has, and SafeUnpack honors its startIndex. TableUtil.ExecuteOnKeys stays as the one addition retail does not have. Verified in game: ContainsAllKeys, Transform, SafePack / SafeUnpack from index 2, GetTableValueListFromEnumeration over ipairs, CollectTableDifferences, SafeCountTable and ExecuteOnKeys all return the expected values. |
||
|
|
5d0568f759 |
feat(lua): Pools follows retail, with securecallmethod
Pools.lua is now retail Blizzard_SharedXMLBase/Pools.lua, on the SecureTypes and ProxyUtil ports the Menu backport already uses. CreateObjectPool, CreateFramePool and the rest alias the secure variants as on retail, so they return proxies that expose only the pool methods. CreateFramePool takes retail's (frameType, parent, template, resetFunc, forbidden, postCreate, capacity); a table specialization goes through FrameUtil.SpecializeFrameWithMixins; CreateObjectPool works without a reset function; Pool_HideAndSetToDefaults is new. The ClassicAPI-only CreateUnsecuredActorPool and CreateUnsecuredFontStringPoolCollection are gone (nothing used them). Two differences, noted in the header: no secret-value check on release (1.12 has no secret values), and a forbidden pool makes normal frames (no CreateForbiddenFrame). The TOC loads SecureTypes and ProxyUtil before Pools, as retail's does; Pools reads both at load. SecurePoolCollectionMixin:Release calls securecallmethod, now in src/baselib/SecureCall.cpp next to securecallfunction, on both Lua states: object[method](object, ...) with a raw lookup, an error goes to the error handler and the call returns nothing. That follows retail's API documentation; it is not probed. docs/API.md covers it. Verified in game: securecallmethod returns the method's result, a frame pool hides its internals behind the proxy while acquire and release keep the count, and a frame pool collection runs a table specialization's OnLoad, acquires, and releases through securecallmethod. |
||
|
|
9a78e159e7 |
feat(lua): FrameUtil follows retail
The file is now retail Blizzard_SharedXMLBase/FrameUtil.lua. New from
retail: FrameUtil.RegisterUpdateFunction / UnregisterUpdateFunction,
DialogStyleGlobalMouseDown, SpecializeFrameWithMixins /
ReflectStandardScriptHandlers, RegisterForVariablesLoaded,
FrameUtil.CreateFrame, UpdateScaleForFit / UpdateScaleForFitSpecific,
GetScaledCenter, FitToParent, RegisterForTopLevelParentChanged /
UpdateTopLevelParent and AnimTransitionMixin. RegisterFrameForUnitEvents
forwards `...` as retail does.
AnimTransitionMixin runs on retail's Blizzard_SharedXML/
ScriptAnimationUtil.lua, ported verbatim. Its ShakeFrame scales by
retail's ShakeStrengthUI cvar, which src/ui/ShakeStrength.cpp registers
with retail's help, category and default ("1.000000"); nothing in the
engine reads it.
Not ported: the fade and flash functions, which 1.12's own UIParent.lua
defines and UIParent's OnUpdate drives (Turtle has also changed them);
RegisterFrameForEventCallbacks and its two siblings (no
frame:RegisterEventCallback); ApplyDefaultScale (no GetDefaultScale).
SetParentMaintainRenderLayering does not carry the window: 1.12 has one.
README.md lists FrameUtil, ScriptAnimationUtil and the cvar.
Verified in game: SpecializeFrameWithMixins sets and calls OnLoad and
OnShow with the frame, a SlideLeft StartAnimIn ends at its anchor
(CENTER 0 0), and ShakeFrameRandom with ShakeStrengthUI at 1.000000
returns its cancel function.
|
||
|
|
503368623f |
feat(localization): BreakUpLargeNumbers, AbbreviateNumbers, AbbreviateLargeNumbers
Retail's number formatters (LocalizationDocumentation.lua) and
C_StringUtil.GetDefaultAbbreviationBreakpoints. Retail moved them from
FrameXML into C in 12.0.0, so the behavior is taken from probes of an enUS
retail client, recorded in src/localization/Numbers.cpp:
- BreakUpLargeNumbers drops the fraction of a whole number or one 1000 or
more in size and groups it with LARGE_NUMBER_SEPERATOR while the
breakUpLargeNumbers cvar (retail's, default on) is set; other numbers
keep one decimal, rounded half away from zero. natural writes a million
or more in words ("1.2 million", "123 million").
- AbbreviateNumbers walks retail's default breakpoints, or
options.breakpointData, or the Asian table for options.locale koKR /
zhCN / zhTW. Retail's defaults name THIRD_ and FOURTH_NUMBER_CAP_NO_SPACE,
which its clients do not define, so billions and trillions carry no
letter there and here.
- AbbreviateLargeNumbers walks FrameXML's old thresholds, rounds to a whole
number outside the Asian locales, and falls back to BreakUpLargeNumbers.
The asian natural-word scales (1e4 / 1e8 / 1e12) are read off the strings,
not probed. options.config (CreateAbbreviateConfig) is not backported.
Every locale file, and a new koKR.lua, gets DECIMAL_SEPERATOR, FIRST/SECOND_NUMBER_CAP[_NO_SPACE]
and FIRST..FOURTH_NUMBER from the matching Classic GlobalStrings; the
German, Spanish and French words carry |7 plural tokens, which the grammar
pass does not expand yet.
FormattingUtil gains retail's GetCostString and GetItemCostString on top.
docs/API.md documents the four functions, the cvar and
Constants.MoneyFormattingConstants; README.md lists them.
Verified in game: every probed retail value reproduces exactly (BreakUp
with and without natural, AbbreviateNumbers with defaults, Asian locale
and custom breakpoints, AbbreviateLargeNumbers), the cvar toggles the
separators, and GetItemCostString shows the amount and item icon.
|
||
|
|
735d304a20 |
feat(currency): Constants.MoneyFormattingConstants and GetMoneyString's gold threshold
Retail exposes engine constant tables as Constants.<Name>, documented with Type "Constants" and a Values list (MoneyConstantsDocumentation.lua). Game::Lua::RegisterConstants builds Constants[sub] with the same integer entries RegisterIntegerEnum takes, and the documentation recorder has a constants kind next to the enum kind, so the API browser lists the table as constants rather than as an enumeration. Constants.MoneyFormattingConstants.GOLD_REWARD_THRESHOLD_TO_HIDE_COPPER is 10, retail's value. FormattingUtil's GetMoneyString now applies checkGoldThreshold through retail's FormatDisplayCopper: above 10 gold the copper is dropped. Verified in game: the table is present, GetMoneyString(1234567, nil, true) shows gold and silver only, and GetMoneyString(51234, nil, true) keeps its copper. |
||
|
|
29ddd78a80 |
feat(lua): FormattingUtil follows retail
The file is now retail Blizzard_SharedXML/FormattingUtil.lua (identical in retail, Classic and Classic Era), in retail's own syntax: the length and modulo operators and string methods all work here now. New from retail: FormatValueWithSign (with SYMBOLIC_NEGATIVE_NUMBER "-%s" / SYMBOLIC_POSITIVE_NUMBER "+%s", the same in every locale's GlobalStrings), MoneyStringConstants, FormatPercentageRounded, GetHighlightedNumberDifferenceString, FormatUnreadMailTooltip, FormattingUtil.AddLeadingZeroes, ReplaceGenderTokens, and GetMoneyString's color argument. GetMoneyString gives the coin-icon form, retail's default; retail uses the text-symbol form only under its colorblind mode, which 1.12 does not have. checkGoldThreshold is still not applied (it needs Constants.MoneyFormattingConstants), and GetCostString / GetItemCostString wait on BreakUpLargeNumbers / AbbreviateNumbers. GetCurrencyString and GetCurrenciesString are not ported: 1.12 has no currencies. Verified in game: coin-icon money strings with and without thousands separators, signed values, FormatLargeNumber, the highlighted number difference, and gray leading zeroes. |
||
|
|
b6c21216e3 |
fix(lua): EventUtil follows retail; queued variables-loaded callbacks are error-isolated
TriggerOnVariablesLoaded ran the ContinueOnVariablesLoaded queue in a plain loop, so one erroring callback skipped the rest, and the queue drains only once, so they never ran that session. It now uses secureexecuterange as retail does: each error goes to the error handler and the walk goes on. AreVariablesLoaded reads UIParent.variablesLoaded, as on retail, instead of a private flag. Retail's UIParent sets that field and calls TriggerOnVariablesLoaded on VARIABLES_LOADED; 1.12's FrameXML does neither, so EventUtil's own frame does both. The header no longer says 1.12 lacks select, C_AddOns or secureexecuterange; ClassicAPI provides all three. The unknown-event message uses :format and IsEmpty uses #, as on retail. Verified in game: AreVariablesLoaded and UIParent.variablesLoaded are true, a late ContinueOnVariablesLoaded callback runs at once, IsEmpty works, and ContinueAfterAllEvents rejects an unknown event. |
||
|
|
6cc9d0db90 |
fix(lua): CallbackRegistry isolates callback errors and defers mid-dispatch registrations
TriggerEvent called each callback directly, so one error left the frame's OnEvent script and skipped every callback after it in that dispatch. pfUI now runs many listeners through one EventRegistry dispatch, so one failing listener could silence the rest. Each callback now runs through securecallfunction: the error goes to the engine's script error handler and the loop goes on, which is retail's secureexecuterange contract. It is called from TriggerEvent's own loop, not through a vararg helper, because a vararg Lua function allocates an arg table per call on Lua 5.0. A callback registered for an event while that event is dispatching now waits in deferredCallbacks and joins after the outermost dispatch, as on retail. Before, its key went into the table the pairs loop was walking. UnregisterCallback clears only owners that are present, and drops pending deferrals. The rest now follows retail Blizzard_SharedXMLBase/CallbackRegistry.lua: UnregisterEvents() clears every event and UnregisterEventsByEventTable clears the listed ones; GenerateCallbackEvents checks its argument; the file's own GenerateClosure copy gives way to FunctionUtil's global (one table per call instead of two, with retail's owner + 4 argument limit). EventRegistry:OnLoad keeps all instance state, since addons derive their own registry from the instance (pfUI: CreateFromMixins(EventRegistry)). Verified in game: an erroring callback reports to the handler and the next one still runs; a callback registered mid-dispatch first runs on the next TriggerEvent. |
||
|
|
cdc3506cdd |
feat(item): IsEquippedItemType, IsCurrentItem, IsDressableItem, IsHelpfulItem, IsHarmfulItem
Ports of 4.3.4's item predicates. IsEquippedItemType runs the engine's inventory search over the equipment slots by equip location, item class or subclass name; the [equipped] macro condition now calls it instead of a Lua rebuild. IsCurrentItem reads the in-flight cast item that 1.12's IsCurrentAction checks. IsHelpfulItem / IsHarmfulItem classify the on-use spell with the IsHelpfulSpell / IsHarmfulSpell classifier. Shared: Item::Location::IDForArg (GetItemIDByName, was copied in three files) and Item::Location::Walk over FUN_INVMGR_WALK. |
||
|
|
9541dc2949 |
feat(macro): RunMacroText, GetRunningMacro, GetRunningMacroButton
RunMacroText copies the text into the body of a zeroed stack macro entry and hands it to the engine's macro runner, as 4.3.4 does with a stack MACRONODE. The runner reads only the body, so each line goes the engine's way: EXECUTE_CHAT_LINE to MacroEditBox, with # lines skipped and /stopmacro honored. Macro::RunBody keeps the running entry and button per run, saved and restored around nested runs. GetRunningMacro maps the entry's ID to its index; GetRunningMacroButton returns the button. [button] now matches the running macro's button as well as the clicked one. Macro::Execute drops its Lua ChatEdit_ParseText path and the addon RunMacro preference. The secure button's macro verb and the MACRO binding run through the engine runner with the clicked button and "LeftButton". |
||
|
|
9c50a90d34 |
feat(currency): GetCoinText
GetCoinText(amount [, separator]) and C_CurrencyInfo.GetCoinText: the non-zero gold, silver and copper parts, each from its GOLD_AMOUNT / SILVER_AMOUNT / COPPER_AMOUNT global string, joined by the separator (default ", "). Zero is the empty string. The three strings are backported to every embedded locale. |
||
|
|
ac118d5305 |
feat(unit): GetShapeshiftForm
Returns the stance-bar index of the active form, walking the bar from the last entry as 4.3.4's CGSpellBook::GetShapeshiftForm does: count + 1 for a form not on the bar, 0 for requireForm with no form byte. Each index is tested through the engine's Script_GetShapeshiftFormInfo, which holds 1.12's only full "bar spell is active" check. The [stance] / [form] macro conditions now use GetShapeshiftForm(true), as Blizzard's EvaluateStance does, so a paladin aura no longer counts as a stance. |
||
|
|
6e4efb39f7 |
feat(lua): Blizzard_Menu
Menu, MenuUtil, MenuTemplates, the Compositor and the DropdownButton intrinsic, ported from retail with SecureTypes, ProxyUtil and RegionUtil, and the Vanilla/Classic variants. The engine pieces are the earlier commits: motion focus and propagation, the click/motion split, IsMouseMotionFocus, SetTextToFit, SetToDefaults and region scale. Port changes: - The Compositor calls 1.12's frame __index function instead of indexing a method table. - 1.12's script SetFrameLevel leaves children behind, so the menu takes its level before Open() raises the elements above it, and scroll mode brings the ScrollBox and ScrollBar up through SetParent(nil) then SetParent(menu). - 1.12's SetScript does not turn mouse input on, so the menu, its elements and the auto-hide button do it where they set the mouse scripts. - One window: no GetWindow/SetWindow. No taint: no SetForbidden or secure delegate. - A submenu opens past its parent's right inset, at the parent's edge, as 1.12's dropdowns do; retail's atlases hide the overlap that 1.12's opaque borders show. The Classic atlases are 1.15 art, so the styles are drawn with 1.12's: dropdowns with UIDropDownMenuTemplate's label frame and scroll-down button, the filter dropdown with the stretched panel button, MenuStyle1/2 with DropDownList's dialog and tooltip backdrops (cleared when a menu frame is released), the dropdown check, the radio button sheet and the help frame divider's middle slice. Insets and 10 of row padding keep arrows, swatches and text clear of the opaque borders. ColorSwatchTemplate's texture sublevels become layers. WowStyle2 and the highlight radio are left out until they have 1.12 art. Retail's global nop, assertsafe and CallErrorHandler (EnvironmentUtil, ErrorUtil) replace the local copies in FunctionUtil, Pools and LinkUtil. Also GameTooltip_SetTitle, LIST_DELIMITER, IsScrollingMessageFrame and UIResetButtonTemplate. |
||
|
|
a86d5ec48f |
feat(lua): BackdropTemplate
Port retail's Blizzard_SharedXML/Backdrop: the BackdropTemplate template, BackdropTemplateMixin, and the BACKDROP_* tables (verbatim). Retail draws the backdrop with nine textures of its own because its frames lost the C backdrop; 1.12's frames still have it and it lays out the same nine slices (benilla-re ui/backdrop), so the mixin keeps retail's state and methods (backdropInfo, HasBackdropInfo, ApplyBackdrop, ClearBackdrop, GetEdgeSize, the OnLoad key values) and draws through the engine's SetBackdrop. SetBackdrop with the table already applied keeps the colours, as retail's does. GetBackdrop and the colour methods stay the engine's own. SetBorderBlendMode and backdropBorderBlendMode are not ported: Lua cannot reach the engine's edge textures. |