mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-16 16:10:36 +00:00
v1.17.13
186
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
2d887df71c |
fix(compat): stop Outfitter's minimap button acting as if dragged
Outfitter never initializes OutfitterMinimapButton.IsDragging, so a read before the first drag falls through to the region:IsDragging() method and is truthy. Its update frame then calls UpdateDragPosition every frame with an unset CursorStartX. Set the field to false on load. |
||
|
|
42ed0d27c7 |
Port the later clients' Cooldown API (#112)
* Add retail Cooldown methods and OnCooldownDone Port the post-4.3.4 Cooldown API onto the native CGCooldown frame: Clear, Pause/Resume/SetPaused/IsPaused, GetCooldownTimes, GetCooldownDuration, GetCooldownDisplayDuration, SetCooldownDuration, SetCooldownFromExpirationTime, the modRate argument, SetDrawSwipe, SetDrawBling, SetSwipeColor, SetEdgeColor, the drawSwipe/drawBling XML attributes, and the OnCooldownDone script (via Frame::ExtraScripts). Behavior follows retail probes, not the generated doc strings: the getters report the end flash once the sweep ends, modRate scales the flash and the display duration but not the sweep, and a reverse cooldown flashes and hides like any other. Add CooldownFrame_Set, CooldownFrame_Clear and CooldownFrame_SetDisplayAsPercentage to the embedded addon. * List the new Cooldown methods in the README table * Add Cooldown swipe, edge and bling textures SetSwipeTexture, SetEdgeTexture and SetBlingTexture, and the <SwipeTexture>, <EdgeTexture> and <BlingTexture> XML elements, split 4.3.4's star texture into three slots. An empty file is the engine's solid texture tinted by the slot colour, and Interface\Cooldown\edge maps to the built-in edge texels. A setter without r, g, b keeps the colour, as retail does. Slots left unset get 4.3.4's textures at the first SetCooldown, so the defaults stay 4.3.4's. The swipe's texcoords now map its positions over the frame so a custom texture lines up. * Add Cooldown rotation SetRotation / GetRotation and the XML rotation attribute (degrees) move where the sweep starts, clockwise from the top, as retail does. The sweep is now one polygon along the frame's outline in place of 4.3.4's four octant functions, with the same timing (each half side an eighth of the duration) and, at rotation 0, the same shape. The one difference is 4.3.4's reverse octant 1, which drew one triangle twice. * Add Cooldown countdown numbers Every Cooldown gets a countdown font string (FRIZQT__ 16 OUTLINE, centred), shown while retail's countdownForCooldowns CVar is 1; the CVar defaults to 0, so the default look stays 4.3.4's. The text follows retail: seconds, then m:ss below the abbreviation threshold, then whole minutes, hours and days rounded up, and nothing for cooldowns no longer than the minimum duration or during the flash. Adds SetHideCountdownNumbers / GetHideCountdownNumbers, GetCountdownFontString, SetCountdownAbbrevThreshold / GetCountdownAbbrevThreshold, SetMinimumCountdownDuration / GetMinimumCountdownDuration and the hideCountdownNumbers and minimumCountdownDuration XML attributes. * Add the Cooldown countdown milliseconds threshold SetCountdownMillisecondsThreshold / GetCountdownMillisecondsThreshold: below the threshold the numbers show tenths, rounded up, as retail does (threshold 5: 4.973 shows 5.0, 3.24 shows 3.3, 0.039 shows 0.1). The default is 0, so the numbers stay whole seconds. * Fix the Cooldown review findings - A zero-length timer (a new frame, SetCooldown(t, 0)) hides without the bling flash or OnCooldownDone, instead of flashing and reporting (now, 1000) from the getters. - Countdown text rounds up with integer math (700 ms read "0.8") and picks its unit on the rounded-up seconds (59.4 s read "60", not "1:00"). - SetMinimumCountdownDuration and minimumCountdownDuration clamp to the uint32 range. - The edge texcoord rotation uses the guarded done fraction (0/0 gave NaN). - Texture slots are one array with per-slot tag, default file and draw layer (Offsets::DRAWLAYER_*), replacing the ternaries and bare 2/3. - The header lists where the state machine follows retail over 4.3.4. edge.blp is now served to every texture load by texture/Builtin.cpp, a hook on TextureCreateFromBlp that falls back to the DLL's texels only when SFile has no such file; TextureCreate caches and ref-counts it like a file. Cooldown loads it by path and drops its edge special case. Frame::Region::CreateTexture / CreateFontString replace the hand-rolled pool-alloc + ctor copies in Cooldown, LinePool, BarTexture, SoftTargetIcon and InlineTexturePool. |
||
|
|
443c78c453 | Backport TOTAL_MEM_*_ABBR and ADDON_MEM_*_ABBR locale strings | ||
|
|
a97909e36c |
Route non-Turtle spell links to SetItemRef; one SetItemRef hook
Turtle's SpellChatLinks.lua overrides ChatFrame_OnHyperlinkShow and handles spell: links itself, so those clicks never reach SetItemRef -- and its spell:(%d+):(%w+):(%w+) pattern silently drops anything shaped differently, including our own spell:<id>:0 links (GetSpellLink). Wrap ChatFrame_OnHyperlinkShow to route those back through SetItemRef (the Spell handler shows them); Turtle-shaped links pass through. Also folds TradeSkillLink's second SetItemRef override into a LinkUtil.RegisterLinkHandler, leaving exactly one override to chain. Adds a GetSpellInfoFromHyperlink helper. |
||
|
|
80d3e5d8d7 |
refactor(playercache): drop the visible-object scan, import the engine cache on enable
The scan read names through CGUnit_C::GetUnitName, whose only filled rows come from the NameCache writer the module already hooks, so it re-read data the hook had mirrored. The one real gap was rows the engine resolved while the cache was off; enabling now imports them by walking the engine NameCache (Unit::Identity::ForEachCachedPlayer). Removes C_PlayerCache.SetScanEnabled/IsScanEnabled, the NameCacheScanEnabled setting and the "Scan nearby players" option. |
||
|
|
bfcd95504e | fix(addon options) Correct header | ||
|
|
bea82687a4 | refactor(addon options) Move Player Cache settings to their own subcategory | ||
|
|
3009c6d8d2 |
fix(addon): splice the AddOn Options menu button on first show
Addons that load after us insert their own game menu buttons by taking Key Bindings' anchor too. ShaguTweaks anchors "Advanced Options" under Interface Options, which put it on top of our button. Waiting for the menu's first show lets every addon place its buttons first, so ours goes right above Key Bindings wherever it ended up. |
||
|
|
b83bb5b52b |
feat(frame): draw the Cooldown sweep natively, as 4.3.4's CGCooldown
A Cooldown was vanilla's indicator Model with CooldownFrameTemplate loaded into it, so SetReverse and SetDrawEdge stored flags that changed nothing, and every cooldown paid a Model's per-frame cost. Cooldown is now a CSimpleFrame subclass built the way CGCooldown::Create builds it: one SMemAlloc block, the engine's frame constructor, and copies of CSimpleFrame's two vtables with 4.3.4's overrides in their 1.12 slots (update, layer emit, alpha, size change, LoadXML, identity, destructor). It runs 4.3.4's sweep / flash / reverse state machine and queues the star fan, flash and edge as layer-batch strips animated in place. - The five methods live in a class method hash of their own, so only a Cooldown has them; it is released after CGGameUI's unregister pass. - GetObjectType / GetFrameType answer through the engine's virtuals; the Lua re-registrations are gone. - star4.blp ships with 1.12; edge.blp does not, so its 16x16 image is created in memory through TextureCreateWithCallback. - A Cooldown inheriting the stock Model CooldownFrameTemplate applies 4.3.4's template (setAllPoints, hidden); reverse / drawEdge XML attributes are read. - CooldownFrame_SetTimer calls SetCooldown on a Cooldown and keeps 1.12's body for the Models stock buttons use. - Mask.cpp's path loader moves to texture/Load; frame/RenderBatch queues quads into a layer batch. Verified in-game: sweep, flash and hide; reverse with the edge line; stock action-button cooldowns unchanged; repeated /reload. |
||
|
|
19b6232e43 |
feat(addon): backport the Interface Options panel for addon categories (#85)
* feat(addon): backport the Interface Options panel for addon categories Later clients list addon option panels in InterfaceOptionsFrame; addons register them with InterfaceOptions_AddCategory (Ace3's AddToBlizOptions does it for every Ace3 addon) and open them with InterfaceOptionsFrame_OpenToCategory. Vanilla has neither, so Ace3 addons fail while initializing - Zygor Guides Viewer 2.0's OnInitialize stopped there, before its waypoint arrow and taxi data were set up. FrameXML/InterfaceOptions.lua/.xml in the bundled addon: the frame with its background as first region, the AddOns category list (buttons / buttonHeight / update, a FauxScrollFrame named InterfaceOptionsFrameAddOnsList), an empty Categories list, the panel container, Okay / Cancel / Defaults, InterfaceOptionsListButtonTemplate, and the later-client panel protocol (name, parent nesting with collapse, okay / cancel / default / refresh). Names match later clients because addons and libraries use them directly. Vanilla's own options stay where they are. Verified in-game (1.12.1 client via VanillaFixes, Zygor Guides Viewer 2.0): Zygor's AceConfigDialog-3.0 panels register under AddOns and open, and their pages were used throughout testing (with the SetParent level and scroll-clip fixes, sent separately). Not checked specifically: Okay, Cancel and Defaults calling each panel's handlers, and collapsing a category with children. * feat(addon): open Interface Options from the game menu, Escape cancels The backported InterfaceOptionsFrame had no way in for the player and closed on Escape without calling any panel's cancel. Wired the way 3.3.5 does it, with one code path for Stock and Turtle: - AddOn Options button in GameMenuFrame. It takes over Key Bindings' anchor (Interface Options on Stock, Options on Turtle) and Key Bindings moves under it, so pfUI's top-of-menu buttons are untouched. Not "AddOns": later clients use that for the addon list. The window title shares the new ADDON_OPTIONS string. - Native center panel via UIPanelWindows + Show/HideUIPanel instead of UISpecialFrames; closing returns to lastFrame (the game menu), like Turtle's own OptionsFrame. - Escape clicks InterfaceOptionsFrameCancel after static popups, the 3.3.5 ToggleGameMenu order. - Shown panel kept in InterfaceOptionsFramePanelContainer.displayedPanel, where addons read it. Verified in-game on Turtle with pfUI: button placement and menu sizing. * feat(addon): add a ClassicAPI page to AddOn Options Registers ClassicAPI in the backported InterfaceOptionsFrame with Controls, Combat and Text To Speech pages under it: - ClassicAPI: player cache (C_PlayerCache.SetEnabled / SetScanEnabled; scan is greyed out while the cache is off). - Controls: Enable Interact Key, Interact Key Icons, Auto Stand, Auto Dismount, Auto Cancel Form. - Combat: Enable Action Targeting, Enable Friendly Action Targeting, Cast action keybinds on key down, Stop Auto Attack. - Text To Speech: voice, rate, volume. Where retail's Settings has the option, the label, tooltip and value mapping are copied from Blizzard_SettingsDefinitions_Frame (soft targeting toggles 3 = Any / 1 = Gamepad; Interact Key Icons drives the same four cvars as retail's three presets). The 18 retail strings are added to every locale from Blizzard's own translations. Player cache, cast settings and friendly soft targeting have no retail labels, so those strings are ClassicAPI's own (English). Changes apply at once; Cancel / Escape restores each page to what it held when first shown, Defaults resets the shown page via GetCVarDefault. Not yet verified in-game. * docs(readme): drop the InterfaceOptions row from the API table The table lists engine API; the InterfaceOptions functions are FrameXML. They stay documented in docs/API.md. --------- Co-authored-by: Brues <5278969+brues-code@users.noreply.github.com> |
||
|
|
52e17d05c1 |
feat(item): per-school spell damage, penetration and statTable in GetItemStats
Single-school MOD_DAMAGE_DONE equip spells now land on per-school keys (ITEM_MOD_FIRE_SPELL_DAMAGE_DONE_SHORT, ...) instead of reading as generic spell damage; an all-magic mask stays on ITEM_MOD_SPELL_DAMAGE_DONE_SHORT. Damage and healing stay split, as the server sums them from separate auras (13 by school, 135 alone). Newly decoded equip auras: - 123 MOD_TARGET_RESISTANCE, split by mask: armor bit -> ITEM_MOD_ARMOR_PENETRATION_RATING, magic bits -> ITEM_MOD_SPELL_PENETRATION (both positive) - 158 MOD_SHIELD_BLOCKVALUE -> ITEM_MOD_BLOCK_VALUE - 161 MOD_HEALTH_REGEN_IN_COMBAT -> ITEM_MOD_HEALTH_REGEN GetItemStats / GetItemStatDelta take the engine's optional statTable (filled in place, not wiped), return nothing on a cache miss, and the delta is now item1 - item2, matching the 3.3.5 and 4.3.4 binaries. Labels for the nine new keys in all seven locales, plus English fallbacks for the compare tooltip. |
||
|
|
3e4db9279e |
perf(debugtools): stop the event trace churning memory
The trace kept 1000 entries under an index that only grows, so each of its 22 column tables rehashed and reallocated every few events. Entries now go into a ring of fixed slots. An event no longer redraws the list (OnUpdate redraws it once per frame while shown), packs its arguments into a table, or formats its time and marker text; that text is built when a row is drawn. /etrace clear now rebuilds all 19 argument columns. |
||
|
|
62cabb2acb |
Add the combat log: COMBAT_LOG_EVENT, filters and kept entries (#108)
* feat(combatlog): add COMBAT_LOG_EVENT and CombatLogGetCurrentEventInfo Port 4.3.4's combat log events (UnitCombatLog_C.cpp) in its argument layout: timestamp, subevent, hideCaster, source and dest GUID, name, flags and raid flags, then the spell prefix and the subevent suffix. - Swing, range, spell and periodic damage, misses, heals, energize, drain and leech, damage shields, split damage and environmental damage, read from the combat log messages through Net::PacketDispatch. - Spell misses from the one function every miss goes through, so a missile's miss is sent when it arrives. - Object flags and raid flags from the fields 4.3.4 reads. Names follow the 1.12 combat log namer's steps. - CombatLogGetCurrentEventInfo returns the values only while the events are being sent, as on Classic Era. - Event::Custom::FireValues sends an event with Lua values, so booleans and nils land where 4.3.4 puts them. - COMBATLOG_OBJECT_* constants in the addon. Overkill, overhealing and healing absorbs are 0: the server does not send them. * feat(combatlog): add casts, auras, dispels, interrupts and deaths Port 4.3.4's layer 2 combat log subevents: SPELL_CAST_START/SUCCESS/ FAILED, SPELL_AURA_APPLIED/REMOVED and their _DOSE forms, SPELL_DISPEL, SPELL_DISPEL_FAILED, SPELL_INTERRUPT, SPELL_EXTRA_ATTACKS, SPELL_DRAIN, SPELL_LEECH, SPELL_RESURRECT, SPELL_DURABILITY_DAMAGE(_ALL), SPELL_INSTAKILL, UNIT_DIED, UNIT_DESTROYED and PARTY_KILL, plus proc resists as SPELL_MISSED. Casts come from SPELL_START / SPELL_GO and the cast-fail log line, effects from SPELLLOGEXECUTE as the 1.12 client reads it, auras from the engine's aura handlers through a new Aura::Source change observer that carries the bound caster, and deaths from the death presentation. * feat(combatlog): add filters, kept entries and CombatLog_Object_IsA Port 4.3.4's UnitCombatLog_C_Scripts surface: CombatLogAddFilter / ResetFilter, the kept-entry functions (GetNumEntries, SetCurrentEntry, GetCurrentEntry, AdvanceEntry, ClearEntries), the retention time with its combatLogRetentionTime CVar, and CombatLog_Object_IsA. COMBAT_LOG_EVENT now fires only for entries that match the filters. Entries and filters clear on the return to the login screen. Adds the COMBATLOG_FILTER_* masks from 4.3.4's Constants.lua. * docs(combatlog): move the combat log events into the Events section * fix(combatlog): bound the execute-log loop and the retention time - Stop an execute log's target loop at an effect that carries nothing, so a huge target count cannot spin. - Clamp the retention time to what the wrap-safe age test can measure. - Bound GetCurrentEntry's index by the entry count. - List ENCHANT_APPLIED and ENCHANT_REMOVED among the subevents that do not fire, and note why effect 59 casts log SPELL_CAST_SUCCESS. |
||
|
|
fd7843b8b3 |
feat(aura): add RAID and CANCELABLE filters, fix stale player timers
Use the engine's own aura tests where C_UnitAuras guessed or gave up: - RAID calls the two tests behind UnitBuff/UnitDebuff's raid-filter argument (castable buff 0x4B3870, known dispel type 0x4B3920); isRaid reports the same answer. - CANCELABLE / NOT_CANCELABLE read the descriptor's cancelable bit. - PLAYER also counts a caster whose charmer or creator is the player (totems, guardians, charmed units), as 4.3.4's IsAuraCaster does. The charmer-or-creator read moves to Unit::Identity::OwnerGuid. - Filter tokens and spell-name lookups ignore case (SStrCmpI). - castByPlayer (UnitAura position 13) is a player caster only, as in 4.3.4; isFromPlayerOrPlayerPet keeps pets. - canApplyAura: the player or pet knows the spell and it applies an aura. - Player timers look up the buff record by slot and honour its until-cancelled flag, so a permanent aura no longer reads the stale expiry its slot kept from an earlier aura. Corrects the player-buff record and visible-aura comments in Offsets.h. |
||
|
|
9ab6627d90 |
feat(unit): add InteractUnit and the INTERACTTARGET / INTERACTMOUSEOVER bindings
InteractUnit(unit [, exactMatch]) is 4.3.4's Script_InteractUnit. It resolves the argument the way 4.3.4 does: - "mouseover" reads the hovered-object GUID, which in 1.12 is any object type (units, game objects, corpses). - A unit token resolves to its GUID. - Any other text runs the engine's by-name search with TYPEMASK_OBJECT. It then calls 1.12's own OnSpriteRightClick (0x00492820), the function a world right-click runs, so targeting, the object's right-click and the autoloot modifier all come from the engine. 4.3.4's taint gate is dropped because 1.12 has no secure environment. Both bindings are spliced into the TARGETING group, as in 4.3.4. Their names are added to every locale, using Blizzard's strings. |
||
|
|
90b4691130 |
fix(debugtools): show all 19 event arguments in the event trace
The event trace passed only arg1..arg9 from its XML OnEvent and kept nine argument columns, so it never showed arg10 that 1.12 already sends with every CHAT_MSG_*, nor anything after it. The engine sets at most arg1..arg19 for an event, so the trace now passes and stores all 19, with trailing nils marking the end as before. |
||
|
|
7cd891e86c |
fix(bindings): follow 4.3.4's bindings, modified clicks and key state
Modified clicks: IsModifiedClick, GetModifiedClick, SetModifiedClick, GetNumModifiedClickActions and GetModifiedClickAction, with 4.3.4's <ModifiedClick> Bindings.xml node and its 18 defaults. Each binding set loads, saves and copies them through co-hooks on the engine's own binding-set steps, in 4.3.4's "modifiedclick" file lines. [mod:] asks IsModifiedClick, as 4.3.4's macro conditions do. Direct actions run as 4.3.4's ExecKey runs them: SPELL / ITEM / MACRO on key release through 1.12's spellbook, item and macro functions, cast at you for SELFCAST and at your focus for FOCUSCAST; CLICK sends the frame a mouse down and up, with 4.3.4's virtual-click button logic built from the button's own methods. RunBinding no longer runs them. While a key binding runs, its own modifiers count as released for every modifier read, the engine's IsKeyDown included. Overrides follow 4.3.4: two lists per key, checked inside the key lookup at both of 1.12's lookup steps; GetBindingAction takes checkOverride; isPriority is loose; "" removes; the owner must be a frame. ActionButtonUseKeyDown (default 0) and 4.3.4's action-button key handlers, ported onto 1.12's bars. |
||
|
|
4b47059788 |
feat(debugtools): build /fstack with GameTooltip:SetFrameStack
Replace the Lua EnumerateFrames walk with the engine method, as Blizzard_DebugTools does. /fstack also accepts "true" for hidden frames. |
||
|
|
5962ccc83d |
fix(frame): follow 4.3.4's attribute system and unit-frame mouseover
Compared against 4.3.4's CSimpleFrame attribute code and CGWorldFrame::OnLayerUpdate: - OnAttributeChanged gets (self, name, value) as real arguments, like 4.3.4's RunOnAttributeChangedScript, plus the this/arg1/arg2 globals. It used to fire through the no-argument invoker with globals only, so a modern function(self, name, value) saw name == nil. The engine's runners only carry %d/%s values, so Frame::ScriptArgs gains RunWithValues for arguments already on the Lua stack. - No recursion guard: a handler that sets attributes fires their handlers too, as in 4.3.4. The guard silenced every nested OnAttributeChanged on every frame. - SetAttribute requires the value argument; the 3-arg GetAttribute form needs exactly four arguments and treats a nil prefix/suffix as empty; usage errors name the frame like the engine's (GetName ?: <unnamed>). - The mouseover unit of a hovered frame comes from FrameXML's SecureButton_GetModifiedUnit, pcalled under the engine's error handler, as 4.3.4 does, so unitsuffix and modifier-qualified unit attributes count. 4.3.4 asks protected frames; with no protection in 1.12 the analog is a frame that has attributes. The mouseover tooltip stays (4.3.4 shows it only over the world frame). - SecureStateDriver.lua is 4.3.4's file again: it drives itself through SecureStateDriverManager attributes and reads OnUpdate's elapsed, both of which the guard and the old no-argument handlers had ruled out. - Game::Lua::ObjectLuaRef / PushObject / ObjectDisplayName replace the copies in ScriptArgs and Modern. Verified in-game: handler arguments and globals, a nested handler firing, both usage errors, the nil-prefix lookup, mouseover following shift-unit / unit, and a visibility state driver. |
||
|
|
9d3bdfb6ad |
feat(focus): follow 4.3.4's focus, and give every unit event to focus, nameplates and marks
Every unit event the engine fires now reaches focus, nameplateN and
markN, as 4.3.4 does for its focus: the unit gets a script-registration
bit, so the engine watches its fields, and whatever the engine fires
for the unit fires for the token too.
- A co-hook on the registration recompute (FUN_0060c520) keeps bit
0x8000 on units with one of these tokens. Post-init runs it too, so a
unit coming back into range is watched again. 0x2000 is SuperWoW's
and WeirdUtils' sparkle bit on every unit.
- nampower replaces the broadcast (0x00515E50) and the combat feedback
(0x00494600) with detours that never call the original, so neither
can be co-hooked. Their 38 + 4 CALL/JMP sites, which no loaded DLL
touches, are redirected to functions that call the original address
and then fire for the unit's tokens. Sites are found by a .text scan
and patched only when the counts match Ghidra's xrefs.
- The tokens gain UNIT_COMBAT, UNIT_NAME_UPDATE, UNIT_PORTRAIT_UPDATE,
UNIT_MODEL_CHANGED, UNIT_CLASSIFICATION_CHANGED and group-stat
updates. TokenObserver now serves only focustarget: with SuperWoW
every unit is engine-watched, so an observer would double-fire.
Focus drop rules follow 4.3.4 where 1.12 has the data: out of range is
kept for you, your pet, a party or raid member or their pet (the
engine's own target rule); death while not friendly, or arrival already
dead and not friendly; becoming not selectable. Death and the flag act
on the change. 1.12 has no duel exception and no SMSG_BREAK_TARGET.
%f in sent chat (4.3.4's ChatParserParseText) becomes the focus's name,
with a {rtN} prefix when marked, or FOCUS_TOKEN_NOT_FOUND.
The .text bounds move into Offsets.h (shared with interface/Export).
The focus still survives /reload; focustarget events stay as a
ClassicAPI extension.
|
||
|
|
af4a379311 |
feat(equipmentset): follow 4.3.4's equipment manager
UseEquipmentSet now behaves like 4.3.4's CGEquipmentManager: - in combat only the weapon slots swap (one COMBAT_SWAP message); - missing items and full bags report through UI_ERROR_MESSAGE; - bank items are used only while the bank is open, and then equip straight from the bank; - a swap in flight or an item on the cursor refuses the call. EQUIPMENT_SWAP_FINISHED now fires when the swap settles instead of during the call: success when the paperdoll matches, failure on an SMSG_INVENTORY_CHANGE_FAILURE for one of the moved items, or when the paperdoll stops changing short of the target. Its failure value is nil, not 0. CanUseEquipmentSets and the set buttons are blocked meanwhile. GetEquipmentSetInfo uses 4.3.4's GetSetStatus counts and strict IsSetEquipped; GetItemIDs and GetItemLocations return all 19 slots with the 0/1/-1 markers; set buttons also grey when a replaced item is locked. Set names go through a port of ScrubString. Item tooltips get the "Equipment Sets:" line (dontShowEquipmentSetsOnItems hides it). |
||
|
|
721f32ac77 |
feat(map): keep the closed world map on the player's zone (#71)
* feat(map): keep the closed world map on the player's zone
GetPlayerMapPosition("player") reads the map the world map is set to,
open or closed, and returns 0,0 off it. The 3.x FrameXML resets that
map to the player's zone in WorldMapFrame_OnHide and in WatchFrame's
PLAYER_ENTERING_WORLD and (map closed) ZONE_CHANGED_NEW_AREA handlers;
vanilla has neither, so after zoning the closed map stays on the old
zone. Do the same resets from the bundled addon. Zygor Guides Viewer's
travel steps read the player's position this way.
Verified in-game (1.12.1 client via VanillaFixes, Zygor Guides Viewer 2.0):
after logging in, the closed world map is on the player's zone (Darkshore)
and GetPlayerMapPosition("player") returns the player's position there.
Not checked yet: changing zones with the map closed (the
ZONE_CHANGED_NEW_AREA reset) and closing the map on another zone (the
OnHide reset).
* docs(map): describe the closed world map without version history
State what the map does and when it goes back to the player's zone,
and add that a zone change does not move the map while it is open.
Remove the 3.x and vanilla comparison and the FrameXML handler names;
the code comment in Util/WorldMap.lua already records them.
* docs(readme): keep Highlights for major features
Single-behavior fixes (faction while loading, <Script file> paths, the
closed world map, the quest completed line, SetParent frame levels,
frame alpha, OnSizeChanged sizes) each had a row in the Modern client
behaviors table. Remove those rows and point to docs/API.md, where each
fix keeps its own section.
---------
Co-authored-by: Brues <5278969+brues-code@users.noreply.github.com>
|
||
|
|
47b258ad95 |
fix(text): size, space and align inline icons by the engine's own rules
The inline-texture backport placed icons with hand-tuned constants: a 0.18 x font lead/trail pad, a 0.6 x font vertical centre, a -1px region nudge, and written sizes taken as raw screen pixels. Replace all of them with the rules from the 3.3.5 / 4.3.4 clients (decompiled; the size formula's helpers confirmed against the real 4.3.4 binary): - A written size multiplies by fontPx / (14 x ddcWidthScale), so it follows the text's size, the UI scale and the resolution, and then by the fontstring's layout scale, as 3.3.5 does. Size defaults follow ParseEmbeddedTexture: ":0:2" is a width ratio, ":20:0" is font-wide. - An icon starts at the previous glyph's ink edge (bearing + cell width) plus the face's outline gap, found by replaying the run's placements with the emitter's own glyph helpers; the next glyph starts at the rounded icon edge. - Vertical alignment follows the node's justify-V (node+0x50). - Offsets move only the drawn icon; a positive offsetY now moves it up. GetCoinTextureString now matches 3.3.5: default height 14, a space between denominations, and retail's 2:0 coin offset in the strings. The four Coordinate statics at 0x00832A40 get their real names (VAR_COORD_DDC_WIDTH_SCALE and siblings). Known gap: the fs-level wrap callers can't see the fontstring, so they budget icons at layout scale 1. |
||
|
|
7ccbbaaf68 |
fix(compat): stop Turtle's Toggle Movement button erroring
Turtle's Options frame sets GroupFrame_ToggleMovement(state) directly as the button's OnClick. With modern script args the handler receives the button as `state`, and `1 - state` errors (Turtle_GroupUI.lua:409). Wrap the global so only a number reaches the original. |
||
|
|
85619155f8 |
feat(equipmentset): add C_EquipmentSet.PickupEquipmentSet
Equipment sets become action-bar buttons, as in 3.3.5: action type 0x20000000 | setID and cursor type 13. The set can be picked up, placed, dragged off, and swapped with other actions. The button shows the set icon, name and tooltip, and grays out while a set item is locked. A click fires WEAR_EQUIPMENT_SET(setID) and the embedded EquipmentManager equips the set. The server drops action type 0x20 without saving it, so placements are kept in the per-character equipment-set file. The server is sent an empty slot, and the saved buttons are merged into the SMSG_ACTION_BUTTONS buffer at login. GetActionInfo and GetCursorInfo report "equipmentset", name. |
||
|
|
a33146241e |
feat(macro): make [button:N] read the click it is running inside
The condition existed but was a stub: it matched only "1" / "leftbutton" and always passed, because nothing on this client could say which mouse button had driven the current click. GetMouseButtonClicked can now answer that, so the condition asks it. Numbers use the modern API order -- 1 left, 2 RIGHT, 3 middle, 4, 5 -- which is deliberately NOT the order of the engine's internal click bitmask (where 2 is the middle button); that mask never reaches Lua. A name is matched as written, so [button:rightbutton] and [button:2] are the same test, case-insensitively. Outside a click the answer stays "left button". That is not a cosmetic default: Macro::ShowTooltip re-evaluates conditional directives off the world tick with no click in progress, so a nil-means-no-match rule would change which icon a `/cast [button:2] X; Y` macro displays at rest. The engine's own no-argument Button:Click() means the left button, so it is also the honest resting answer for a state-driver poll. Verified in-game with all five buttons, both directly from OnClick and through a real macro body -- click -> attribute macro -> EXECUTE_CHAT_LINE -> SlashCmdList -> SecureCmdOptionParse, which confirms the click context survives the whole chain -- plus the name form, the btn alias, and the no-click resting answer. |
||
|
|
449841b4eb |
fix(debugtools): draw the title bars above the backdrop, fit the scroll bar
The Backdrop of each frame draws its background and border into the BACKGROUND layer, and it is applied after the textures declared in the XML, so a title bar in that layer ends up underneath it. On ScriptErrorsFrame, whose backdrop is the 32px dialog border, the header came out behind the window edge; on EventTraceFrame and TableInspectorFrame the bar is a translucent one inside the frame, so it was buried rather than misplaced. Every Blizzard frame that uses UI-DialogBox-Header puts it in ARTWORK. The title text of all three is in OVERLAY and still reads over the top. ScriptErrorsFrame is also the only frame here that takes its scroll bar from UIPanelScrollFrameTemplate, which hangs the bar off the right edge of the scroll frame rather than inside it, so the bar ran past the border. Narrow the scroll frame, and its child edit box with it, to end where the Close button does. Blizzard's own measurements do not carry over: its ScriptErrorsFrame inherits UIPanelDialogTemplate, a thin GearManager border, not this backdrop. The other two frames place their sliders by hand and already sat inside. |
||
|
|
bf79ee1d93 |
feat(macro): add /stopmacro
Stops the rest of the macro body, split the way 3.3.5 splits it: the command is addon Lua, and the flag belongs to the body runner, which is what makes "stop the rest of THIS macro" mean anything. The runner clears the flag for each body it starts and restores the previous value when that body ends, so a line that runs another macro re-enters the runner and the inner /stopmacro ends the inner body only. A stray StopMacro() outside a macro leaves nothing armed for the next one. Each line is dispatched synchronously through ChatEdit_SendText into its handler, so the flag is already set when the fire returns. The command binds ClassicAPI.StopMacro rather than the bare global. StopMacro is a plain name in a crowded space, and the global is only ours until an addon declares one of its own -- after which the command would set THEIR flag and the macro would keep running with nothing to show for it. The mirror captured our function at registration. |
||
|
|
4f99a1ed95 |
feat(macro): add /castsequence, /castrandom and /userandom
Ports the three remaining cast-family commands from FrameXML, including the macro icon, which is half the feature: a sequence whose button does not show the current step is barely usable. The sequence state lives in Lua and the icon asks for it by name. That is Blizzard's own split -- 3.3.5's macro code calls the Lua global QueryCastSequence through lua_pcall and takes the item over the spell -- so execution and display read one index and cannot disagree about which step is current. Macro::ShowTooltip mirrors that call for any option line that came from a castsequence command. The random pair is faithful to 3.3.5 rather than nicer than it: the binary has no query beside QueryCastSequence, so a comma list reaches the resolver whole, names nothing, and greys the button. Being a static line it also ends the collection, so a /castrandom above a /cast takes the icon. #showtooltip gives one of these macros an icon. QueryCastSequence stops answering if the contested-command pass hands /castsequence to another macro addon: our table only advances while our handler runs, so a frozen step one on a sequence somebody else drives would be worse than no icon at all. Three adaptations the 1.12 client forces: item detection uses the carried-item test, since there is no name to item lookup here; the cast events carry the spell in different argument positions per event; and CastSpellByName takes no unit, so a targeted step routes through C_Spell.CastAtUnit like /cast already does. /cast, /use and both random commands now share one action dispatch instead of four copies of it. |
||
|
|
108a91a843 |
feat(api): describe the API in the code, browse it with /classicapi
docs/API.md is 18.7k lines and its anchors are signature slugs, so editing a signature breaks the 281 internal and 88 README links into it. Blizzard solved the same problem by shipping the API as data plus a browser addon, and warcraft.wiki.gg renders those same tables. One set of descriptors can feed all three. Each registration now carries one next to it: typed arguments and returns, nilability, defaults, and a sentence. Events, enumerations and returned table shapes are described the same way. No Script_* body changed. Game.h gains namespace Game::Doc (Field with Req/Opt/Vararg, FieldList, Function, Method, Structure, Event) and a trailing descriptor argument on all six Game::Lua::Register* plus Event::Custom::AutoReserve. api/Documentation.cpp records every registration on the first pass of each Lua state and seals it, so /reload re-registers but records nothing and the environment comes from which pass saw the name. Export is lazy: nothing is materialized until C_APIDocumentation.GetSystem asks for one system, because eager export would build thousands of tables per reload for a slash command. _classicapi_UndocumentedAPI lists what still has no descriptor. AddOns/!!!ClassicAPI/APIDocumentation/ ports Blizzard_APIDocumentation's eight files. Named /classicapi, not /api: the browser holds only what ClassicAPI adds, so /api would have implied the whole 1.12 surface. Two deliberate differences from the retail source, both noted in the file headers: a system search also matches its namespace, since that is the name people type; and an undocumented function says so, because an empty signature otherwise reads as a real one. LinkUtil gains the SetItemRef to LinkUtil.ProcessLink dispatch. That handler registry was dead code; a new link type now registers a handler instead of stacking another SetItemRef override. Also defines assertsafe there, which was undefined and only mattered once the function went live. Documented: the C_Spell and C_SpellBook surface, the spell globals, both spellbook enumerations, the 13 UNIT_SPELLCAST_* events, GameTooltip as the widget-method example and C_Glue as the glue and mixed-environment example. 66 of 692 function registrations. tools/New-ApiDocSkeletons.ps1 emits paste-ready skeletons to make the rest of the sweep tractable. Verified in game: the browser lists, searches, and prints detail; links render and click through; right-click copies and shift-click dumps. |
||
|
|
d4ac5dc210 |
fix(slash): only give back a command that is still ours
The contested-command heal cleared any key we added whose command string another addon also claimed. Both halves of that test read the live table a frame later, so an addon that takes one of our keys OVER broke it. SuperCleveRoidMacros registers into our own `CANCELAURA` key: it replaces the handler with its conditional one and writes `SLASH_CANCELAURA2 = "/unbuff"` over our alias. The heal then tested `/unbuff` -- a command we never registered -- and on a hit cleared the key, deleting that addon's `/cancelaura` rather than handing ours back. `/unbuff` kept working through its own owner, so the symptom was `/cancelaura` alone falling through to `ChatEdit_ParseText`'s "Type '/help'" message. Snapshot the handler and the command strings at file scope, while the table holds exactly what this file registered, and skip a key whose handler is no longer ours. Taking a key over is already how an addon wins a command, so there is nothing left to resolve. The `/petattack` case that motivated the heal is unchanged: that addon registers a rival key beside ours, our handler stays in our key, and the contested string is one we registered. Reported downstream as brues-code/SuperCleveRoidMacros#6. |
||
|
|
fedccf5b95 |
fix(macro): give a contested slash command back to whoever owned it
Vanilla has no `/petattack`, so the conditional slash-command registry ADDS it. SuperCleveRoidMacros ships the same command under its own SlashCmdList key -- `PETATTACK` where we register `PET_ATTACK` -- and both set a `SLASH_*` string of "/petattack". Neither ever overwrites the other, so loading first decides nothing: `ChatEdit_ParseText` walks SlashCmdList with `pairs` and takes the first match, making the winner hash order. When ours won, `/petattack [hastarget,alive,harm]` fed that addon's conditions to `SecureCmdOptionParse`, which does not know `hastarget` or `alive`, so no clause matched and the line did nothing. Rejecting a condition we cannot evaluate is right by itself -- retail does the same -- so the fault is owning the command at all. A command we add and someone else already binds is handed back. Splitting one command across two condition parsers would be worse than one owner: the dialects disagree, and ours deliberately differs from 3.3.5 for an `[@unit]`-only group. Only added commands are given up. One we replace (`/cast`, `/target`) has no second entry to lose to, and an addon that wraps ours still chains through it. The check runs a frame after load, not at file scope -- this addon loads first, so nothing is registered to detect yet -- and not on PLAYER_LOGIN, which has already fired during a `/reload` and would run the check immediately to the same empty result. The addon load pass is synchronous, so one frame is enough on both paths. A command registered by a load-on-demand addon later keeps its own entry, and its coin flip. |
||
|
|
0ba73b8457 |
fix(macro): leave GetMacroInfo alone and expose the shown icon instead
`Macro::Info` re-registered `GetMacroInfo` to answer with the icon a `?` macro's `#showtooltip` resolved to, so the Macro UI's list would match the action button. But the Macro UI seeds its icon selector from that same return -- `MacroFrame_Update` sets `MacroPopupFrame.selectedIconTexture` from it, and `MacroPopupFrame_Update` checks the grid button whose name matches -- so opening the selector on such a macro pre-selected an icon the player never picked, in the one place that edits the stored icon. Saving was never at risk (an unclicked selector leaves `selectedIcon` nil and `EditMacro` then leaves the icon alone), but the display was wrong. One return cannot serve both readers, and the one that edits state has the stronger claim, so `GetMacroInfo` goes back to the engine's: it is the read side of the icon `C_Macro.EditMacro` writes, and every addon that captures it now gets the stored icon. The icon a macro SHOWS becomes something a caller asks for, through `C_Macro.GetMacroIcon`. It reads the macro icon getter this DLL already hooks, so the `?` rule and the active-icon choice stay in one place and the answer matches what the action button and the drag cursor get. Util/MacroIconSelection.lua paints the Macro UI's list buttons from it after the stock update, which is additive -- an empty slot or a macro with a chosen icon answers with what stock already drew. Dropping the re-registration also takes a commonly captured global out of the override chain. |
||
|
|
3191c4dcfc |
fix(macro): leave a macro alone when its conditions are not ours
A macro written for another macro addon names conditions this parser does not have. SuperCleveRoidMacros' `[alive]` is one. The `#showtooltip` reader scans every macro body, so it met that condition and printed "SecureCmdOptionParse: unknown condition 'alive'" at login, about a macro that works. Worse than the noise: a condition we cannot evaluate cannot pass, so its group fails. A macro with no unconditional fallback clause then matched nothing, and the reader wrote 0 over the spellID the engine's own parse had put in the per-macro cache - costing that button its cooldown, range and usable state. `SecureCmdOptionParse` now records the keywords it does not own on its cached parse and returns the first one as a third value. It still names them, once each, for a caller the player drove. The reader passes the new `quiet` flag and reads that value instead: on a foreign dialect it resolves nothing, writes nothing, and stops re-evaluating until the body changes. The engine's parse stays in the cache, and the addon that owns those conditions can still claim the macro through `C_Macro.SetMacroDisplay`. Such an entry also stays out of `dirty`, because a dirty entry nothing evaluates would keep `HasPendingWork` true and re-run the catch-up on every reader. Moving the warn-once bookkeeping from parse time to call time also stops a quiet scan from consuming the one warning a keyword gets, so a condition the player later types is still named. This is not a load-order fault. SuperCleveRoidMacros creates `_G.CleveRoids` at the top of Init.lua, and that same file sets `ClassicAPIMacroDisplay`, which lifts our wholesale yield on purpose so it can publish per macro. The window is between our first tick and its first publish, which it cannot make until the player object exists. |
||
|
|
373dce8202 |
ShaguTweaks nil check
Fixes #49 |
||
|
|
36c367a6d6 |
feat(macro): native #showtooltip, conditional slash commands, and a display API for addons (#48)
* feat(macro): native #showtooltip/#show, conditional /cast and /use
Backport the macro display system to the engine:
- Macro::ShowTooltip resolves `#showtooltip [cond] value` / `#show` (and
the bare form over the macro's /cast and /use lines, first match wins)
through the Lua SecureCmdOptionParse on the world tick and writes the
result into the engine's per-macro spell cache (+0x564/+0x568), which
every action reader already consumes. Repaints go through the engine's
own slot-changed notifier. Item targets are cached alongside.
Re-evaluates on modifier / mouseover / target / combat changes and every
200 ms otherwise. Yields entirely when SuperCleveRoidMacros is loaded.
- The `?` icon rule is a co-hook on the macro icon getter, so action
buttons and the drag cursor both show the resolved icon; GetMacroInfo,
GameTooltip:SetAction, GetActionCooldown, GetActionCount and
IsConsumableAction are re-registered in front of the engine for macro
slots with a resolved directive and tail-call it otherwise.
- Macro::RunBody re-implements the engine's body runner so `#` lines
never reach chat; Macro::Execute skips them too.
- /cast and /use in the embedded addon (3.3.5 handler shape): items
first, [@unit] via C_Spell.CastAtUnit, 1..19 = inventory slot, other
numbers stay spellIDs. SecureCmdOptionParse: a group whose only piece
is @unit passes only while the unit exists (3.3.5 passes it
unconditionally). C_Item.GetItemCount accepts names. GetMacroItem
added; GetMacroSpell now reflects the directive.
- Offsets.h: 0x004F0F40 was the macroID -> MacroEntry resolver,
mislabeled as a spell-state cache; renamed FUN_MACRO_ID_TO_ENTRY, with
the action-bar / macro-runner constants this needs added and verified.
* feat(unit): add IsUnitToken for token-vs-name dispatch
Vanilla ships each "act on a unit" verb as two Lua entries, one taking a
unit token and one taking a character name, and each errors on the other
kind of input. Conditional slash commands need to accept either, because
SecureCmdOptionParse hands back a token for `/target [@focus]` and a name
for `/target Bob` through the same variable.
IsUnitToken(value) answers which one a string is by calling the engine's
own token resolver inside lua_pcall and reporting whether it returned or
threw. Consulting the resolver rather than matching a token list here
keeps the answer correct for every family it knows, including this
client's native GUID literals and our own focus / nameplateN / markN,
which unit/TokenExtensions.cpp hooks onto the same function. It reports
whether the text names a token, not whether a unit is there, so "target"
with nothing targeted is still true.
if IsUnitToken(x) then TargetUnit(x) else TargetByName(x) end
Additive on purpose. Merging the pairs into a modern TargetUnit /
AssistUnit / FollowUnit was written and reverted: those names are common
enough for other DLLs and addons to replace that re-registration is
silently last-one-wins, with no error and no trampoline to chain. That
mechanism is only safe for names nobody else contends.
Offsets.h records two findings from decompiling the resolver. The throw
is raised by its callee, not by FUN_RESOLVE_UNIT_TOKEN, which is a thin
wrapper returning 0 on a miss. And this client reaches the error through
a patched fallthrough that first parses a 0x<hex> GUID literal, so GUID
unit tokens resolve natively with no SuperWoW loaded.
* feat(addon): backport the conditional slash commands
Adds 27 commands that take [conditions] through SecureCmdOptionParse,
following the 3.3.5 SecureCmdList handler shapes: targeting
(/targetexact, /cleartarget, /targetlasttarget, /targetlastenemy,
/targetenemy, /targetfriend, /targetenemyplayer, /targetfriendplayer,
/targetparty, /targetraid), casting and state (/stopcasting, /cancelaura,
/cancelform, /dismount), equipment (/equip, /equipslot), action bars
(/changeactionbar, /swapactionbar) and the pet family.
/target, /assist and /follow gain conditions by replacing the FrameXML
handlers, which is the only way to add them. Plain input keeps working:
each routes through IsUnitToken to the engine's token entry or its
by-name entry, where the old handler always went by name.
Three natives have a different shape here than the 3.3.5 handlers assume,
so those bodies are not straight ports. PetAttack takes no target and
always sends the pet at the current target. ChangeActionBarPage takes no
page and only fires ACTIONBAR_PAGE_CHANGED, so CURRENT_ACTIONBAR_PAGE is
set first. Pet autocast is a spellbook-slot toggle with no enable and
disable entries, so a name is resolved against the pet book and on/off
read the state and toggle only on a mismatch. /cancelaura needs no buff
walk, since CancelSpellByName already matches a player buff by name.
Not ported for want of a native: /targetlastfriend, and the /mt and /ma
family, which needs party assignments the client does not have.
Command names come from the locale files, with the localized name taken
from the matching Blizzard GlobalStrings and the English one alongside.
zhCN ships English for all 27. The short aliases retail also carries
(/eq, /tar) are left out, since those collide with addon shorthands.
* fix(macro): resolve item link values in #showtooltip
`#showtooltip` over a `/use item:6948` line showed no icon. The directive
evaluator built its item argument as `{0, 0, value}`, hardcoding the whole
value as a NAME, so the `item:N` and pasted-link forms could never match
and the value fell through to the spell lookup. `/use` itself was fine,
which is why the macro cast the item but the button stayed blank.
The link parsing already existed for the Lua entries. Split it out as
`Item::Arg::ResolveString` and call that instead of hand-building the
argument, so both paths read the forms the same way.
A bare number keeps skipping the item lookup: `ResolveString` reads "6948"
as an itemID, and a bare number that is not an equipment slot has to stay
a spellID per the documented `/cast 5019` rule.
An explicit itemID now also resolves when none is carried, falling back to
the ID after the bag and equipment walk misses. The icon and tooltip come
from the item record, and the tooltip path already handled an unheld item
through a hyperlink, so a macro naming an item in the bank or one written
before looting it now displays. Names are still limited to what you hold,
since 1.12 has no name-keyed item cache.
* fix(macro): make [@cursor] work in /cast, /use and #showtooltip
`/use [@cursor] item:4390` did nothing and its `#showtooltip` showed the
question mark. Two causes, both in the addon.
The parser rejected the clause. A group whose only piece is `@unit` passes
only while that unit exists, and the existence test ran UnitExists on
`cursor`, which is not a unit token. The engine raises there, the pcall
caught it, and the group failed. `none` was already exempt; `cursor` joins
it, since both name something other than a unit and neither can be tested
that way.
Nothing routed the target once it did pass. `SecureCmdUseItem` sent every
target through UseItemByName, which takes a unit GUID, and the spell branch
had only the on-unit and default cases. A `cursor` target now goes to
C_Item.UseAtCursor and C_Spell.CastAtCursor, which were written as the
`[@cursor]` analogs but had no caller. SecureCmdItemParse has already
turned a bag or inventory slot into a link, so one item call covers every
value form.
`#showtooltip` needed no change: the value resolves once the clause passes.
* feat(macro): accept a character name as a macro target
`/cast [target=Feral] Rejuvenation` did nothing. A `@unit` or `target=unit`
piece takes a character name as well as a unit token, but nothing here
turned a name into something the unit functions accept, and the existence
gate ran UnitExists on it, which raises for a string that names no token.
`UnitTokenFromName(name [, exactMatch])` runs the engine's own by-name
search — `FUN_UNIT_FIND_BY_NAME`, the one behind TargetByName, AssistByName
and FollowByName — and reports the winner as a token: a standard one when
it fits, else the GUID literal, which this client's resolver takes too. It
walks party, then raid, then every loaded unit, so it reaches units no
token names. Prefix match by default, nearest first, like TargetByName.
`GroupPasses` now resolves a named target once and uses it for both jobs:
the bare-group existence test (`[@Feral][] Spell` falls through when they
are not around) and the conditions, which previously raised on a name.
The pcall that already guarded the existence test is what tells a token
from a name, so a token target costs no more than before.
The slash handlers resolve the target the same way before handing it to
CastAtUnit, UseItemByName, FocusUnit or StartAttack, and drop the command
when a named unit is not around.
* feat(macro): drop a ground-target item at your feet with [@player]
`/use [@player] item:4390` sent the grenade through UseItemByName, which
passes a target GUID but never commits the placement, so the reticle came
up instead of the grenade landing. Route a `player` target to
`C_Item.UseAtUnit` instead, which commits at the unit's position.
Only your own position is offered. Aiming a ground-target item at another
unit is not something the game lets you do by hand, so the slash handler
does not either; every other unit target keeps going to UseItemByName.
`C_Item.UseAtUnit` now dispatches with the unit's GUID rather than a zero
target, matching `C_Spell.CastAtUnit`. Without that, routing `@player`
through it would have cost a non-ground item its target: a bandage or a
scroll would fire at the current selection instead of at you. It now
covers both kinds of on-use item, the way CastAtUnit covers both kinds of
spell.
* fix(macro): stop /cast [@unit] aiming ground spells at that unit
The same aim the item side was just denied: `/cast [@target] Flamestrike`
dropped the reticle on the target with no click, for any unit. Placing a
ground spell somewhere you could not put it by hand is aim the player has
not earned, and it should not differ between a spell and a grenade.
`/cast [@player]` and `/cast [@cursor]` still place, since both name a
position you can already aim at. Every other unit still has the spell cast
on it when it takes a unit target, which is what `@unit` is for; only the
ground-placement leg is dropped, leaving the reticle up exactly as casting
by hand does.
`C_Spell.CastAtUnit` keeps the whole primitive and gains a third argument
for the choice, defaulting to placing so the API and its callers are
unchanged. The restriction lives in the slash handler, the same split the
item side uses, where `C_Item.UseAtUnit` stays unrestricted and only
`/use` limits itself to `@player`.
`Spell::AtCursor::GroundPlacementPending` reports whether the in-flight
placement is a ground one, so the handler can leave that reticle up while
still cancelling a placement for a unit the engine did not accept. Leaving
that armed would strand the cursor.
* fix(item): stop a bad unit raising out of C_Item.UseItemByName
The optional `unit` went straight to the engine's token resolver, which
raises for a string that names no token. Both the code comment and the
API docs promised the opposite, that an unrecognized string is no target,
matching the no-op contract the item argument already has.
It is reachable without an addon calling the function directly: secure
button attributes and key bindings both feed it a configured string, so a
`unit="foo"` attribute raised inside a click handler.
Probe with Unit::TokenResolve::IsUnitToken first and treat anything else
as no target, which makes the documented contract true.
C_Item.UseAtUnit keeps raising, which is deliberate and now stated in its
docs: it is the companion of C_Spell.CastAtUnit, which documents the same
behavior as matching UnitHealth("garbage").
* feat(macro): let an addon publish its own macro display
`C_Macro.SetMacroDisplay(macroSlot, value)` hands a macro's resolution to
the display path, for an addon that parses macros itself. It is aimed at
SuperCleveRoidMacros, which today replaces ten action globals plus
GameTooltip.SetAction to put its answers on the bar, and borrows an
unrelated action slot to get a range check for a macro.
None of that is needed. Writing the spell into the engine's own per-macro
cache is what makes cooldown, range, usable, current and auto-repeat
correct for a macro button, with nothing overridden, and the icon then
reaches two places a Lua override cannot: the cursor while a macro is
dragged, and the macro window grid, both of which come from an engine
getter we hook.
The value takes the forms a `#showtooltip` value takes, so a publisher
hands over what it would have written in the macro. Three states: a value
to show, false for claimed-but-nothing-matched, nil to release.
Ownership is per macro. A published one is not parsed or re-evaluated by
us and is honored even while yielding; the rest stay ours. Nothing is
re-evaluated for the publisher, but a published resolution is re-applied
whenever the engine's re-parse overwrites the cache, so a macro edit
cannot silently replace it.
The wholesale stand-down when SuperCleveRoidMacros is loaded is lifted by
`CleveRoids.ClassicAPIMacroDisplay`, which a build sets to say it drives
us. Forks without it keep the all-or-nothing yield, so an older one cannot
end up fighting for the same buttons.
* fix(macro): accept the !Name prefix in /cast and #showtooltip
`#showtooltip` over `/cast !Shoot` showed nothing and the line cast
nothing: the `!` prefix, which asks for a toggle ability to be started
but never turned off, was never part of vanilla and no name resolver
knew it.
Split it in two.
The NAME is normalized in the one co-hook on the engine's single
name -> spellbook-slot resolver, which already owned the numeric
spellID form (so `spell/CastByID.cpp` becomes `spell/NameResolve.cpp`).
`FUN_RESOLVE_SPELL_NAME_TO_BOOK_ID` calls that resolver, so a single
strip covers the runtime cast, `Spell::Arg`, the `#showtooltip`
resolution and the engine's own macro parser -- which is what lets
`IsAutoRepeatAction` light a `/cast !Shoot` button even while macro
display is yielded to SuperCleveRoidMacros.
The BEHAVIOR stays in Lua: `SecureCmdCast` strips the prefix and casts
through the existing `CastSpellNoToggle`, which asks the engine whether
the ability is already up first. `CastSpellByName` cannot carry it --
re-registering that global is off limits and nampower already co-hooks
it.
`CastSpellNoToggle` gains the `placeGroundSpell` argument that
`C_Spell.CastAtUnit` has, so `/cast [@target] !X` keeps the rule that
only your own feet and the cursor place a ground-target spell. It also
tolerates a `!` on its own input now, since its auto-repeat name
compare is ours rather than the engine's.
* feat(item): take an item location wherever an item action takes an item
`C_Item.UseAtCursor`, `UseAtUnit`, `UseItemByName` and `EquipItemByName`
took an item reference only - an itemID, `item:N`, a link, or a name - and
resolved it by searching the bags for the first match. Holding two stacks of
the same item, or two copies enchanted differently, there was no way to say
which one you meant.
They now also take an item location: `{bagID=B, slotIndex=S}`,
`{equipmentSlotIndex=N}`, or an item GUID string - the shapes
`C_Item.GetItemID` already took. A location names one exact item.
`Item::Location::FindItemArgOrLocation` owns the overload; the old `Resolve`
(locations, pointer) and the new `ResolveItemArgOrLocation` (either, pointer)
are wrappers over it, so the classification and the walk live in one place.
None of the four call sites resolves anything itself any more.
A table is only ever a location, and so is a string that parses as a strict
`0x` + 16 hex digit GUID, which no item link or item name can look like. The
form is decided from the argument alone and committed to: a location resolve
STOMPS the Lua stack (`PackBagSlot` overwrites the first slots with its own
arguments), so falling back to the reference forms after one had run would
re-read the argument as whatever it left behind - a bag index read as an
itemID, which names an unrelated item.
`EquipItemByName` needs the source coordinates too, since the swap packet
carries them, which is what the detail form is for. An
`{equipmentSlotIndex=N}` location names a worn item, so with a `dstSlot` it
routes to `Item::Swap::FromPaperdoll` - that is how a ring 11<->12, trinket
13<->14 or weapon 16<->17 move is expressed. Without a `dstSlot` there is no
slot for the engine to pick, so that combination does nothing.
Its `lua_settop(L, 0)` ahead of `ClearCursor` is gone: `Script_ClearCursor`
(`0x004895B0`) is `FUN_00495190(1, 1)` and a return - no arguments, no stack
reads. Dropping it lets the item resolve run after the cursor clear, which a
location needs: while an item is held its slot reads empty, so the location
it came from would otherwise resolve to nothing.
* refactor: centralize the item constants and the icon-path build
Four copies of the ItemStats displayInfoID -> `Interface\Icons\<name>`
chain had accumulated - `item/GetData`, `item/Info`, `container/ItemInfo`
and the new `item/Icon` - and they had already drifted: two checked for an
empty icon name and two did not. `Item::Icon::PathForDisplayInfoID` is now
the one builder and the other three call it, so a change to that chain has
a single site. `PathForItemID` is it plus the cache lookup.
`action/ItemState` had local constants shadowing values already in
`Offsets.h`: `kItemSpellSlots` for `ITEMSTATS_SPELL_SLOT_COUNT`, and a bare
`trigger == 0` for `ITEM_SPELLTRIGGER_ON_USE`. `INVTYPE_AMMO` / `THROWN`
existed in two files, and the engine runner's `0x400` macro line buffer in
two more, so those move to `Offsets.h` as well - `INVTYPE_*` next to the
string table they index, `MACRO_LINE_BUFFER_SIZE` next to the delimiters.
CLAUDE.md's rule, and duplicated offsets drifting is exactly what it was
written for.
* fix(macro): indented directives, release, and icon-getter re-entry
Three defects found reviewing the `#showtooltip` work, plus dead code.
A directive typed with a leading space was lost AND leaked to chat.
`ParseDirective` and the two `#`-line filters all tested byte 0, but the
tokenizer splits on `\r\n` only, so ` #showtooltip` arrives with its space:
the parse missed it, and then `Macro::RunBody` / `Macro::Execute` failed to
recognize the comment and dispatched the line through `EXECUTE_CHAT_LINE` -
the /say this feature exists to stop. All three skip blanks now, as does
`CastCommandArgs` so an indented `/cast` line is still collected, and the
runner dispatches the trimmed line so an indented command works at all.
`C_Macro.SetMacroDisplay(slot, nil)` left the publisher's spell in place.
`Release` cleared our entry and asked for a rescan, but `Rescan` only marks
an entry dirty when it has a directive with options - so for a macro with
no directive of its own, nothing ever rewrote `+0x564`, and the button, its
tooltip, cooldown and auto-repeat state stayed on the published spell until
the engine happened to re-parse. It now hands the field back to the engine
by running the engine's own parser, then repaints.
The macro icon getter could run Lua from under a click. `FUN_MACRO_ICON_PATH`
has two callers and one is `FUN_MACRO_PICKUP`, inside the UseAction core, so
`Lookup`'s catch-up could evaluate conditions through `SecureCmdOptionParse`
and fire `ACTIONBAR_SLOT_CHANGED` into addon handlers while the drag was on
the stack - the re-entrancy hazard CLAUDE.md records for `Tooltip::SetEvents`.
`LookupPassive` reads only what the entries already hold; the world tick
does the work and repaints, so a resolution can be one tick behind an edit.
Also drop `Active()` (no callers) and `RunBody`'s unused trampoline, and
correct the header's reference to a module that does not exist: the icon
comes from `Macro::IconPath`, not `Action::Texture`.
* fix(slash): five conditional-command defects, and cheaper option passes
`/cast 5019` could consume an item. A bare number that is not an
equipment slot is a spellID, but it reached the item lookup, which reads a
number as an itemID - so carrying item 5019 used it instead of casting the
spell. `Macro::ShowTooltip::ResolveValue` already guarded this exact case,
so the button showed the spell while the click used an item.
Every bare `/targetenemy` stepped backwards. The cycling selectors pass
the parsed value as their reverse flag, and a clause that matches with no
value yields the empty string - which is a true boolean in Lua. Six
commands were affected in their most common form.
`/cast [@none] Spell` did nothing. `@none` names no unit, but only
`@cursor` was exempted from the token resolve, so `none` went to the
by-name search and the cast was dropped. It now means no unit, which is
the untargeted form of the verb; `/target [@none]` clears the target, as
documented. The other unit verbs no longer feed `none` to that search
either - it matches on the START of a name, so it would find a Nonek.
`/assist [@target] Bob` ignored Bob. `/target` and `/follow` both let a
trailing name win over an explicit `target=target`; assist did not.
`/use [@player] 0 1` used the wrong item. The position branches ran before
the bag branch, so a named slot was thrown away and the item re-found by
link - the first match anywhere, which with two stacks is the wrong one.
Every form now resolves to one item and goes through one call, which also
means a slot is aimed by `@unit` like a name is, and that `/use` always
uses: clicking a bag slot sells the item at a merchant and repairs it
under the repair cursor (`Script_UseContainerItem` branches on the
merchant GUID and on cursor mode 0x11), which a typed command must not do.
`GroupPasses` also stopped paying for an answer it discards. A group with
conditions only needs a token, so it asks `IsUnitToken` rather than
`pcall(UnitExists)` - the conditions test existence themselves. The
existence path keeps its single pcall, and a name, which costs an
object-manager search, is remembered for the rest of the pass.
|
||
|
|
fe9e7dddcd |
fix(color): keep ColorMixin on the standard color globals
An addon that carries a copy of Blizzard's own definition -- a plain
NORMAL_FONT_COLOR = {r=1.0, g=0.82, b=0} and its friends -- assigns it
over ours at file scope, so every addon that loads after it finds a color
with no methods. pfUI's who list then fails on NORMAL_FONT_COLOR:GetRGB()
(brues-code/pfUI#56).
Re-apply the color globals after each addon loads, not only at our own
load, and mix ColorMixin INTO the table that is there instead of replacing
it: the values that addon chose stay, and each reference it already handed
out gets the methods too. ITEM_QUALITY_COLORS entries are repaired on the
same pass. This replaces the SpecialTalentUI special case.
C_UIColor.GetColors() makes a color object for each of its 187 rows, so
the values are kept from the first call and each later pass costs one
lookup per tag. Only a color that is absent or has lost its methods is
touched; a tag holding something else, and a <TAG>_CODE string that is
already set, are left alone.
|
||
|
|
e26f8958e9 |
fix(compat): let a ClassicAPI-aware addon opt out of its whole shim
pfUI's `handlesHookScript` and ShaguTweaks' `API.classicapi_version` now return at the top of the compat callback instead of gating one branch inside it. An addon that advertises ClassicAPI awareness handles its own color globals, HookScript path and event registrations, so no part of the shim should run against it. Previously the pfUI flag suppressed only the CreateFrame shim while the RAID_CLASS_COLORS override and the UpdateColors no-op still applied, and a ClassicAPI-aware ShaguTweaks still had its libpredict events unregistered underneath it. The "brues" X-Website tag now gates the pfUI HookScript shim on its own, so an unflagged fork carrying that tag behaves as before. |
||
|
|
f0a83f1f31 |
fix(compat): restore Compost:Erase when a 5.1-stubbed copy wins
Compost-2.0 rev 17406 replaces most of its own body with stubs once it believes it is on Lua 5.1, and our 5.1 syntax backport makes its loadstring probe pass. Losing GetTable and Reclaim is harmless -- both are pure recycling hints -- but Erase is not: callers hand it a live table and expect its keys gone, and the stub takes no parameter at all. So every call site that clears in place, rather than assigning the returned table, silently stops clearing. One addon shipping that revision hands it to every other Ace2 addon, because AceLibrary arbitrates on the highest $Revision and ignores load order. Puppeteer is the reported casualty: PTUnit:ClearAuras erases its debuff-type and aura-ID sets in place, so a dispel type never leaves the set once applied and a cursed raid member keeps its debuff colour after the curse is cleaned. Restore an in-place Erase, picked by behaviour rather than by revision or addon name so a Compost that already clears is left alone. Checked on every ADDON_LOADED because AceLibrary can upgrade a library at any point during load and an upgrade installs the new copy's functions over ours; the verdict is cached against the function that earned it, so a repeat check costs two identity comparisons and reuses one probe table. |
||
|
|
b39c16578b |
feat(addon): add the /startattack and /stopattack slash commands
Blizzard ships both in FrameXML's ChatFrame.lua; the handlers here are 3.3.5a's verbatim, routed to ClassicAPI's StartAttack / StopAttack. Every locale file gets the client's own command names, taken from the per-locale GlobalStrings dumps: /angriffstart, /empezarataque, /lanceattaque, /начатьатаку, /開始攻擊 and their stop counterparts, next to the English names. Gives users a clean /startattack without the macro-addon trick of placing the Attack spell on an action slot to read its state. Refs #46 |
||
|
|
be03d45f0c |
feat(frame): add frame:RegisterUnitEvent, unit-aware IsEventRegistered
Modern ports call frame:RegisterUnitEvent("UNIT_HEALTH", "player") to receive
an event for one unit instead of for every unit. Vanilla has no such method, so
the call errored, and FrameUtil.RegisterFrameForUnitEvents was left out of the
FrameXML backport for the same reason.
The engine already owns registration and dispatch, so this is only a filter.
Chain membership delegates to the engine's own Script_RegisterEvent; the filter
is stored per frame here; the check is one gate on the per-frame OnEvent fire,
where the dispatcher has already set _G.event and calls the arg'd script runner
with the OnEvent slot. Suppressing there also covers HookScript chains and
Frame::ScriptArgs' positional path, both downstream, as retail does.
Semantics follow Blizzard's 5.4.8 implementation, where the filter lives on the
subscriber node and the node's kind is fixed at creation: RegisterEvent over a
filtered registration keeps the filter, RegisterUnitEvent over a plain one stays
plain, RegisterUnitEvent over a filtered one replaces the units, and no usable
unit is a plain RegisterEvent. The filter dies with the node, through co-hooks
on Frame::UnregisterEvent and Frame::UnregisterAllEvents -- the latter also
being the CScriptObject destructor's path, so frame destruction is covered.
Two divergences from 5.4.8, both additive. Unit tokens are kept as strings and
compared case-insensitively, since focus/nameplateN/markN are not in the
engine's canonical token table. And the unit count is not capped: 5.4.8 reads
exactly two units and folds each token index into a byte of one dword, and
retail later filled that dword and documents four, but we have no dword to fill,
so every string argument past the event name is a unit.
The filter applies only when the event's first argument is a string. A
number-first event, or a no-arg event (dispatched through a runner this never
sees), fires as with RegisterEvent -- one rule that holds on every dispatch
path, and one that fails toward an extra event rather than a lost one.
FUN_FRAME_RUN_SCRIPT_WITH_CONTEXT was already hooked by Frame::ClickEvents for
PreClick/PostClick, and MinHook allows only one hook per address -- a second
aborts the entire install. Frame::RunnerHook now owns that hook and fans out to
subscribers claiming disjoint slot addresses; ClickEvents moves onto it with no
behavior change.
Verified in-game: 28 assertions over the branch table above, the
PreClick/OnClick/PostClick bracket still firing in order through the shared
runner, and a capture window in which a filtered frame received only its own
token (20 of 20) while a plain control frame on the same events took 115 fires
across six token spellings.
|
||
|
|
d14f0b44c1 |
fix(compat): restore vanilla script args for LunaUnitFrames headers
Fixes #41. LunaUnitFrames sets SetupGroupHeader(groupType) as its group headers' OnEvent while also calling it directly with a group name. As a handler it relies on groupType being nil so it falls back to this.unitGroup. Our modern script arguments hand it `self` instead, so it looks the header up by frame rather than by name, gets nothing, and indexes nil at units.lua:358. The addon is correct vanilla code. A function that is both called directly and used as a script handler is an ordinary vanilla idiom, and passing positional arguments to handlers breaks it wherever the first parameter means something other than self. Adds CAPI_VanillaScriptArgsCompat(frame, script), which rewraps one handler in a no-parameter closure so the extra arguments stop there and the original runs with the empty argument list it was written for. The globals survive the nesting, so it still reads `this` and `event`. Same shape as the existing CAPI_MouseoverClearedCompat. Only the group headers need it. SetupRaidHeader takes the header frame itself, so `self` is already the value it wants. This covers one addon, not the class. Any addon using the same idiom hits the same failure, and each will need its own entry here until handlers opt in to modern arguments rather than receiving them unconditionally. |
||
|
|
8e1429bfac |
feat(texture): publish raid target markers as atlases
All eight markers live in one 4x4 sheet on this client, and the per-marker files other clients ship are absent here — the art directory holds only UI-RaidTargetingIcons.blp. So naming a single marker requires a sheet plus a sub-rect, which is what an atlas is. A port referencing an individual marker file otherwise gets nothing. Blizzard publishes no atlas names for these. Checked: zero hits for raidtarget / targeting / raidmarker in UiTextureAtlasMember, and current Classic Era still draws them by computing texcoords in SetRaidTargetIconTexture and by per-file |T markup in chat. The names here therefore follow the standalone marker filenames other clients ship, so an addon written against those finds the art under the name it already knows. This lives in the addon rather than AtlasData.h on purpose: the DLL's built-in table means "names Blizzard defined", and adding invented ones there would quietly corrupt that contract. Cell math matches the chat marker tokens, and markers 4 and 8 were confirmed on screen. Also adds CreateAtlasMarkup alongside the existing texture markup helper. |
||
|
|
622882725f |
feat(map): C_Map user waypoint (Tier 3)
Add the eight user-waypoint calls and USER_WAYPOINT_UPDATED: set, get, has, clear, per-map position, the two hyperlink converters, and the can-set check. The pin is one piece of session state (a uiMapID, a 0..1 position and an optional z) that survives a UI reload. GetUserWaypointPositionForMap re-projects it onto any other map through world coordinates, so a zone pin resolves on its continent and back. The hyperlink is the standard worldmap:uiMapID:x:y payload with both coordinates scaled by 10000, and the parser accepts a whole link or the bare payload. UiMapPoint's factories go in the addon, matching where retail ships them. Extract the shared vector2 marshalling to map/Vector2.h so the waypoint and coordinate modules don't each carry a copy. |
||
|
|
bd1bd9f5d8 |
feat(aura): slot-batching API and lazy caster match
C_UnitAuras.GetAuraSlots / GetAuraDataBySlot / UnitAuraBySlot: enumerate a unit's auras once into opaque slot ids and fetch each by id, so a full scan walks the aura array once instead of once per index (the by-index getters re-walk from slot 0 on every call). Slot ids cover live descriptor slots, the stealth / range cache fallback, and the out-of-range group array, so the slot path keeps every source the by-index path had. GetAuraSlots also takes a table as a 5th argument (ClassicAPI extension) and fills it in place, returning `continuationToken, n`. Lua 5.0 allocates an `arg` table for EVERY vararg call (luaD_precall 0x006F6050 -> adjust_varargs 0x006F6200 -> luaH_new, verified in Ghidra), so a Lua helper receiving the retail multi-return costs one table per batch. The fill form keeps per-frame scans allocation-free; AuraUtil.ForEachAura / FindAura use it with a per-nesting-depth buffer pool instead of retail's vararg helpers. The descriptor walkers (FindNthSlot, FindSlotBySpellID/Name, GetUnitAuras) now evaluate IsPlayerCast only when the filter restricts on caster. It scans the Aura::Source cache (~1000 entries in a raid) and was paid for every populated slot on every call, PLAYER token or not. Cache-fallback eligibility is centralized (EligibleFallbacks / EligibleGroupFallbacks) so the by-index, bulk, and by-slot paths share one ordering, which is the ordinal an opaque cache slot id encodes. |
||
|
|
695077b6da |
refactor(callbacks): lighter EventRegistry dispatch
Modernize the frame-event forwarder: OnEvent now takes its (self, event, ...)
positionally (modern script args, on by default) and forwards straight to
TriggerEvent — dropping the DispatchGameEvent hop and the unpack(arg) repack,
and forwarding the exact arg count instead of a padded arg1..arg9 (which
silently dropped args for events that emit more than nine). A fallback reads
the event/arg globals when SetModernScriptArgs is off, so the registry stays
robust to that switch.
Keep the ordinary {[event]=count} ref-count table rather than storing counts
as frame attributes: SetAttribute is heavier per call (it lowercases the name,
runs the secure-attribute parsing, and fires OnAttributeChanged) for the same
steady-state memory, so a plain table is lighter on the register/unregister
path.
|
||
|
|
8b106ae0d6 |
fix(addons): define global HookScript for ModernSpellBook
ModernSpellBook's MSB_Spellbook.lua re-hooks its "show all ranks" checkbox by calling HookScript(frame, "OnClick", handler) as a GLOBAL. That global never existed on any client -- HookScript has always been the widget method frame:HookScript, which our DLL provides -- so the call errors with "attempt to call global 'HookScript' (a nil value)". Define the global in AddOnCompat, forwarding to the method, gated on the addon being present so the global namespace stays clean otherwise. |
||
|
|
5279c463ed |
feat(slash): add /click handler and SLASH_CLICK locale strings
Register SlashCmdList["CLICK"], routing through SecureCmdOptionParse and GetClickFrame to click a named button. Parse name + button only: 1.12's Button:Click has no down/up path (verified in the base vmethod), so the retail `down` arg has nothing to act on and a nil button defaults to LeftButton natively. Add SLASH_CLICK1/2 to all locale files from Classic Era GlobalStrings. |
||
|
|
6ca6af1497 | fix(slash): route /focus, /clearfocus, /equipset through SecureCmdOptionParse | ||
|
|
be6dc200fe |
fix(addon): restore MouseIsOver's stock 1/nil return contract
The embedded addon replaces FrameXML's MouseIsOver with a wrapper over the native region:IsMouseOver(), which returns a boolean. Stock 1.12's MouseIsOver (UIParent.lua:1718) returns 1 on hit and nil otherwise, and vanilla-era addons compare against that literal - Quiver gates every widget click on `MouseIsOver(f) == 1`, which `true` silently fails, deadening its entire config dialog (buttons, checkboxes, icon clicks). Return 1/nil from the wrapper. 1 is truthy, so modern-style `if MouseIsOver(f) then` callers are unaffected. |