mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-16 16:10:36 +00:00
4fd3fc4dacd7d798a5fdcd243ba1140eada477dc
1493
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
4fd3fc4dac |
docs(model): Project3DPointTo2D ignores the view insets and translation
The ModelScene paint frames the camera over the view rect (the frame's rect less its insets, moved by its translation), and Project3DPointTo2D frames it over the whole rect. That looked like a gap, so retail was probed: a 400x200 scene with its camera at (-10, 0, 0) projected the origin to (142.22, 71.11) plainly, with SetViewInsets(100, 0, 0, 0) and with SetViewTranslation(50, 0). The comment above Project now records this, so the whole-rect framing stays. |
||
|
|
02da787331 |
refactor(storm): one wrapper for SMemAlloc and SMemFree
Storm's SMemAlloc (FUN_STORM_SMEM_ALLOC, 0x006462E0) and SMemFree (FUN_STORM_SMEM_FREE, 0x00646430), both __stdcall with four arguments, were called by hand in thirteen files, through AddOns::EngineIO's typedefs, local typedefs, Event::Custom's own pair and Frame::Subclass::Allocate. storm/Memory.h now holds Storm::Alloc, with a zero-fill option for the flag bit 3 (Offsets::STORM_SMEM_FLAG_ZERO_FILL), and Storm::Free. Every caller uses them, with the same file and line labels as before; the EngineIO typedefs, Custom's pair and Subclass::Allocate are gone. |
||
|
|
e2174e1656 |
refactor(frame): one wrapper for the layout sub-object's calls
Every region and frame carries a layout sub-object at +0x24 (4.3.4's
CLayoutFrame; OFF_REGION_ANCHOR, OFF_FRAME_LAYOUT_SUBOBJECT for a frame),
and three engine calls on it were wrapped by hand in sixteen files, each
with its own typedef and often its own AnchorOf / LayoutOf / FrameOf
helper:
- CLayoutFrame::GetRect (FUN_REGION_GET_RECT, 0x00768320), the
{bottom, left, top, right} rect, false before layout;
- IsResizePending (FUN_REGION_LAYOUT_DIRTY, 0x00768310);
- CLayoutFrame::Resize (FUN_LAYOUT_RESIZE, 0x007680E0), 1 to lay out now,
0 to mark for the layout pass.
frame/Layout.h now holds them, taking the region or frame itself, with
Of and OwnerOf for the sub-object and back, and GetResolvedRect for the
read the edge getters make (Script GetLeft 0x007A1A19: a pending resize
run now, then the rect). Frame::Subclass::FrameOfLayout is replaced by
OwnerOf.
|
||
|
|
aa3a600e33 |
refactor(gx): one save and restore of the device transforms
The draws that leave the UI pass's transforms saved and restored the device projection, view and viewport by hand, each with its own typedefs: the ModelScene paint (as SimpleModelDraw 0x0076D240 does), the portrait bake, ClipChildren's ScrollFrame-shaped draw (0x00787220), and the ModelScene projection, which reads the camera's matrices back. AlphaGradient read the projection and viewport the same way, and the scene and the bake each wrapped CameraSetDeviceTransforms (FUN_CAMERA_SET_DEVICE_TRANSFORMS, 0x007ADA40). gx/Device.h now wraps FUN_GX_GET/SET_PROJECTION, FUN_GX_GET/SET_VIEW and FUN_GX_GET/SET_VIEWPORT, and Gx::SavedTransforms saves all three for a scope and restores them at its end. Model::Camera::SetDeviceTransforms wraps the camera call. Only AlphaGradient's hooks on the two setters still name the addresses. The projection now also puts back the viewport, unchanged. The bake reads and disables fog just before it saves the transforms; the restore order is the same as before. |
||
|
|
ba6912a533 |
refactor(model): one copy of a unit's model without its items
The portrait bake and the ModelScene actor's SetModelByUnit both copied a unit's model with CreateModelFromModel (FUN_M2SCENE_COPY_MODEL, 0x00707400, flags 0) and stripped the copy's helm, shoulders and held items with DetachAllItemModels (FUN_DETACH_ALL_ITEM_MODELS, 0x0047A230), each with its own typedefs. M2::CopyWithoutItems does the two steps; both callers use it. |
||
|
|
4d18fb833f |
refactor(model): call the M2 tint, alpha and child lookup through M2.h
CM2Model's SetDiffuseColor (FUN_M2MODEL_SET_DIFFUSE_COLOR, 0x00710CF0) was wrapped by hand in VisualKit and SceneActor, FindChild (FUN_M2MODEL_FIND_CHILD, 0x00712F00) in Outfit and SceneActor, and VisualKit called SetAlpha (FUN_M2MODEL_SET_ALPHA, 0x00710CB0) directly next to the M2::SetAlpha wrapper. M2.h gains SetDiffuse and FindChild, and the three files call M2:: for all three. |
||
|
|
b35bbd1be4 |
refactor(model): share the ModelScene argument checks
Scene.cpp and SceneActor.cpp each had NumberArgs and FloatArg, the same loop that raises the engine's "Usage: <owner>:<usage>" error when an argument is not a number, with the frame and actor arguments in a different order. One NumberArgs, which takes the owner's display name, and one FloatArg are now declared in model/Scene.h and used by both files. |
||
|
|
c447a0d796 |
refactor(frame): one wrapper for each draw-layer invalidate
CSimpleFrame::NotifyLayerChanged (FUN_FRAME_NOTIFY_LAYER_CHANGED, 0x0076A990, __thiscall (frame, layer)) was wrapped by hand in Cooldown, ModelScene and ClipChildren, and CScriptRegion::NotifyLayerChanged (FUN_REGION_NOTIFY_LAYER_CHANGED, 0x0077FDF0, __thiscall (region)) in the inline-texture pool and the texture wrap. Each file carried its own typedef for the same engine call. frame/LayerChange.h now holds the two: NotifyFrame and NotifyRegion. All five files call them. |
||
|
|
1992acac2a |
refactor(frame): share the frame-class plumbing in Frame::Subclass
Cooldown and ModelScene each carried their own copy of the parts every frame class this DLL adds needs: a type id, IsA, IsObjectType, GetObjectType, GetScriptMethod, the deleting destructor and its layout thunk, the vtable build, and a factory body that allocates the block with SMemAlloc (FUN_STORM_SMEM_ALLOC, zero-filled), runs the engine class's constructor and installs the vtables. The copies had already drifted: Cooldown compared type names with _stricmp, ModelScene with Storm's SStrCmpI. Frame::Subclass::Class now holds a class's name, the engine class it extends (vtable, layout vtable, constructor), its size and a function that releases its own fields, plus its type id, method hash and vtable copies. Templates on that object give the shared overrides, BuildVTables, New and RegisterFactory (FUN_FRAMEXML_REGISTER_FACTORY). Both classes now answer IsObjectType through Game::StrCmpI and take CSimpleFrame's script resolver (+0x0C), which Cooldown's copied vtable already held. |
||
|
|
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. |
||
|
|
25ad97bde0 |
fix(model): UndressSlot does nothing without a character component
Model::Outfit::UndressSlot cleared and detached a held lane even when the pane or actor had no character component. It called DetachHeldItemSlot and zeroed the lane on a creature model, or on a pane whose component at OFF_DRESSUPMODEL_COMPONENT was not built yet. Before the Outfit split, DressUpModel:UndressSlot returned early in that case. The check is back in the shared helper, so DressUpModel and the ModelScene actor both return before they touch a lane or a component slot. Undress (ClearModel, 0x00504490) still clears both lanes without a component, as vanilla's own does. |
||
|
|
ff6e2ef817 |
docs: document the ModelScene frame, its actors and C_ModelInfo
API.md gains a ModelScene section: CreateFrame("ModelScene") and its XML
attributes with the scene's starting camera, light and fog; the camera,
view inset and translation, Project3DPointTo2D, light, fog, draw layer,
pause and overlapped-model methods; every actor method (model sources,
unit dressing, placement, bounding boxes, animation and pause, spell
visual kits, mount seating), the actor scripts and <Actor> templates;
and the four C_ModelInfo getters. C_MountJournal.GetMountFromItem joins
the Mount section and GetCursorDelta the Input section.
README.md adds a Model scenes highlight, the ModelScene, ModelSceneActor,
ModelInfo and Mount rows, GetCursorDelta in the in-game and glue tables,
and Enum.ModelBlendOperation.
|
||
|
|
4c946f61e9 |
fix(model): end one-shot actor animations, drop a replaced one's end
M2SceneAdvance (0x007074D8) updates only the models on the scene's animate list, and that update (CM2Model::Update, 0x00719370) is what queues a sequence's end callback; the paint's animate pass then empties the list. Actors put their models on the list after the scene frame's clock had advanced, so no actor model was ever updated: a looping animation still played (its pose comes from the scene clock), but a one-shot one such as AttackUnarmed stopped on its last frame and OnAnimFinished never ran. The scene's update now links every ready actor model (Link) before the clock runs, the order the Model frame's own clock (0x0076D7F0) uses. A new animation also drops an end still pending for the one it replaces. The engine reports a replaced play to the done callback as reason 1, which the actor ignores; an end queued in the same advance reached the actor as if the new animation had ended. Two actors whose animations ended in one advance then saw OnAnimFinished for the animation the other's script had just given them. |
||
|
|
d259e5b2ce |
feat(model): pause a ModelScene actor, show a unit's creature display
SetPaused(paused[, affectsGlobalPause]) holds one actor's animation while the rest of the scene plays on. It uses the engine's own resume: the key bone's place in its sequence is read once the model has loaded with CM2Model::GetKeyBoneAnimState (0x00711FE0) and set back each update with SetKeyBoneAnimTime (0x007127F0). The model stays on the scene's animate list, so a paused actor still moves, turns and takes the light, and its sequence never reaches its end. Unpaused, it plays on from that frame. GetPaused returns the actor's own flag and the global one, set as the retail probe read them back: the default sets both, and affectsGlobalPause false sets only the actor's own. SetModelByUnitCreatureDisplayID(unit) shows the display the unit shows now (UNIT_FIELD_DISPLAYID) the way SetModelByCreatureDisplayID shows one. Retail's pet tab calls it with "pet". |
||
|
|
9298f027f2 |
feat(model): frame a scene's picture with view insets and translation
SetViewInsets(left, right, top, bottom) and SetViewTranslation(x, y), with their getters and the XML <ViewInsets left right top bottom> child, frame the camera's picture inside the ModelScene. Both are in the frame's own units, with y up. The paint gives the camera's CameraSetDeviceTransforms (0x007ADA40) the frame's rect less the insets and moved by the translation, converted to layout units with PixelToInternal(length * effective scale). The camera takes its aspect from that rect, as it does from the frame's. The device projection is then read back (0x0058B090), scaled and shifted in clip space so that the view rect lands where it lies in the frame, and set again (0x0058B040). The viewport stays the frame's rect, so drawing still stops at the frame's edges, and negative insets let the view reach past them. Project3DPointTo2D keeps projecting over the frame's rect and ignores both settings, which is what retail does. |
||
|
|
580bcac32a |
feat(model): project scene points to the frame, store overlapped models
The ModelScene mixin calls two scene methods the frame did not have: OnLoad calls SetAllowOverlappedModels(true) for StoreModelSceneMixinTemplate, and Transform3DPointTo2D calls Project3DPointTo2D. Project3DPointTo2D runs the point through the matrices the paint draws with. It saves the device projection and view (0x0058B090 / 0x0058B0B0), runs CameraSetDeviceTransforms (0x007ADA40) over the frame's rect, reads both back and restores them. The view looks from the origin, so the point goes in relative to the camera eye. The matrices are row-vector, and the perspective matrix (0x005C3CC0) puts 1 at m11, so w' is the view depth. A |w'| under 0.001 projects nothing, the rule of the engine's own projector (0x005C4F30). The result is in the frame's units times its effective scale, from the bottom-left of the frame, as InternalToPixel gives the rect's extent. A point behind the camera still projects. Depth is 1 at the near clip and 0 at the far clip, by distance along the camera's forward axis. SetAllowOverlappedModels stores its flag (default false). 1.12 draws a model frame whatever overlaps it, so the flag has nothing to gate. |
||
|
|
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. |
||
|
|
2eb9821914 |
feat(model): show a unit on a ModelScene actor
ModelSceneActor:SetModelByUnit copies the unit's model the way 1.12.1's character panes do in AttachUnitModel (0x005059A0): the unit's own character component is pumped forced (UpdateCharacterComponent 0x00477860), its model (+0xD8) is copied into the scene's M2 scene with CreateModelFromModel (0x00707400, which carries the helm, shoulders and held items), the effect and spell attachments come off (DetachAllItemModels 0x0047A230), and the hand grips close (CloseHand 0x00479660). What DressUpModel's SetModelInstance (0x00504350) adds comes next: a clone of the unit's component (CloneCharacterComponent 0x00476CB0, on a pool component with the model AddRef'd) and the two held-item lanes from unit vtable +0x98. The actor pumps the clone on every update, as the DressUpModel paint (0x00504470) pumps its own, so outfit changes show at once; OnModelLoaded waits for its first composite. On top: retail's Dress, Undress(includeWeapons), UndressSlot, SetSheathed / GetSheathed, SetAutoDress / GetAutoDress, IsGeoReady and GetModelUnitGUID. Undress mirrors ClearModel (0x00504490); sheathing is the unit's AttachHandItem step (AttachItemModel 0x0047A0C0 with the sheathed flag). The lane, weapon and undress steps move out of Model::DressUp into Model::Outfit, which the DressUpModel pane and the actor share. One change on the pane: UndressSlot on a held slot no longer needs the component. PumpDresser takes the engine's force argument, which the old typedef called an unused pointer. |
||
|
|
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. |
||
|
|
8e0b130733 |
refactor(coord): push script coordinates through one engine chain
Every script coordinate the engine pushes (GetLeft, GetStringWidth, GetFont's height, GetCursorPosition, OnCursorChanged) is DivideByScreenScaleX(GetScaledScreenAspect() * [0x007FFD68] * value): 0x0041AD70, then the 1024.0f read from .rdata, then 0x0041AE40, with the quotient stored from ST0 as a double. Game::InternalToPixel did the same arithmetic from the globals in double precision, while the edit-box caret, the font height getters and texture tiling each kept a private copy of the engine chain. InternalToPixel now makes the engine's calls in the engine's order, rounding the float product once as the engine's fstp dword does, and the three modules use it. PixelToInternal reads the 1024 from the same .rdata float, so the UI_COORD_SCALE_UNIT constant is gone. |
||
|
|
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. |
||
|
|
b65c9e0319 |
fix(spell): never auto-unshift out of Spirit of Redemption
3.3.5's and 4.4.2's SpellShapeshiftForm.dbc give Spirit of Redemption (form 32) flags 0x4100, which include SHAPESHIFT_FORM_FLAG_NO_AUTO_UNSHIFT (0x100). So the later clients' CGUnit_C::CanAutoUnshift refuses it, and no cast, interaction or item use cancels it. 1.12's row has flags 0, so with autoUnshift on, our CanAutoUnshift allowed it. A priest in Spirit of Redemption who cast a NOT_SHAPESHIFT spell, right-clicked an NPC or object, used an item or opened the flight map sent CMSG_CANCEL_AURA for it. The later-client flags that 1.12's rows lack now sit in one table: CAN_INTERACT on the druid forms and Ghost Wolf (read only while autoUnshift is on, as before), and NO_AUTO_UNSHIFT on form 32, which CanAutoUnshift reads unconditionally, as 4.3.4 does. With it, every autoUnshift site leaves Spirit of Redemption on and keeps 1.12's own refusal. The comment on FormCanInteract also records why a locked object still unshifts. It opens by a spell (Opening 6478 for chests and barrels), and the server's CheckCast form test refuses that spell on 1.12's spell data, which keeps SPELL_ATTR_NOT_SHAPESHIFT (3.3.5 dropped it).v1.20.5 |
||
|
|
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. |
||
|
|
dc8d4caf12 |
fix(loot): skip corpses that stay lootable after LootAllCorpses (#133)
* fix(loot): skip corpses that stay lootable after LootAllCorpses A corpse whose remaining loot this player can never take keeps UNIT_DYNFLAG_LOOTABLE set: quest items for quests they don't have, condition-gated loot, and the like. The per-corpse re-check still passes, so a caller that runs C_Loot.LootAllCorpses from a timer re-opens the same corpse on every walk and re-sends the refused CMSG_LOOT_ITEM, which never clears. Loot mode now remembers every corpse it opened and released. Later walks skip a remembered corpse while it is still visible and lootable; the entry is dropped once the corpse stops being lootable or leaves the object manager. A corpse that merely left render range is dropped too, so it gets one retry when the player comes back. ScanNearbyLoot stays read-only and keeps reporting the corpse. 1.12 has no per-slot "cannot loot" flag (GetLootSlotInfo has no `locked` return), so one refused request per corpse is unavoidable; this only stops it from repeating on every walk. * docs(loot): describe the LootAllCorpses corpse skip Explain why a corpse that stays lootable after the walk is skipped by later walks, and when the skip entry is dropped. * fix(loot): skip only corpses that open empty in LootAllCorpses The previous change remembered every corpse the loot walk opened. The most common reason a corpse stays UNIT_DYNFLAG_LOOTABLE is full bags, so those corpses were never looted again by the walk, even after the player freed bag space. Rolls and master-loot assignments in progress had the same problem. The server never sends a player a loot slot that player cannot take: another member's quest item and condition-gated loot are left out of SMSG_LOOT_RESPONSE, while the corpse stays lootable for as long as any loot remains. So the stuck corpse opens to an EMPTY window, with no coin and no populated VAR_LOOT_SLOTS entry. Loot mode now remembers a corpse only when the scraped window is empty. A window with anything in it (full bags, a roll, a master-loot slot) is retried. An entry is forgotten: - on the first world tick where its unit is gone or no longer lootable. This replaces the prune at walk start, which missed a corpse that left view and came back, and a creature that respawned with the same GUID and died again, between two walks; - all at once on QUEST_LOG_UPDATE (event 0x134, observed through the shared FUN_FIRE_EVENT_NO_ARGS interceptor and never swallowed), because quest items are per-player loot and a quest change can put an item into a window that was empty. The memory moves out of the per-walk ScanCtx into its own vector. The API reference now describes the skip as a contract only. --------- Co-authored-by: Brues <5278969+brues-code@users.noreply.github.com> |
||
|
|
20069f3815 |
docs(api): sort the reference's sections alphabetically
Seven sections were out of place in the body: ChatBubbles (after Mount), Bindings (after Focus), APIDocumentation, CVar, MerchantFrame, NamePlate and PvP. The contents list shared the last four. Both are now in the same case-insensitive order, with one blank line between contents groups (DeathInfo and Sound had none). The ClassicAPI namespace section had no contents entry; it has one now. The PVP_TIMER_UPDATE entry moves from the PvP section to Events, between PLAYER_SWING_RANGE_UPDATE and QUEST_ACCEPTED. It now names the PvP timer and links the two timer functions, and the PvP section links to it. |
||
|
|
f2fa112f0a |
feat(mount): add C_MountJournal.GetMountFromSpell and GetMountInfoExtraByID
1.12.1 has no mount table, so a mount's ID is the ID of the spell that summons it: GetMountFromSpell(458) returns 458. A spell is a mount when one of its effects applies SPELL_AURA_MOUNTED (78); Spell.dbc is read directly, so mounts the player has not learned resolve too. On Turtle every mount item carries spell 46499 "Add Mount to Collection" instead of its mount spell (the server maps item to spell from its own table), so only the mount spell gives a mount ID. GetMountInfoExtraByID returns the nine retail values. The display ID is the one the server mounts the player on: the mount aura's misc value is a creature entry, and the client's creature cache holds that creature's display (SMSG_CREATURE_QUERY_RESPONSE carries the template's first display, and every mount creature has exactly one). An uncached creature returns nil and starts the cache load through the new Creature::Info::RequestLoad, which C_CreatureInfo.RequestLoadCreatureByID now uses too; CREATURE_DATA_LOAD_RESULT fires when the data lands. Verified in game: 23219 (Swift Mistsaber) returns 14332. Mount type and model scene default to 230 and 4. Seven mounts take retail's values instead (the six Qiraji battle tanks use scene 44, the Riding Turtle type 231), each checked by name against Turtle's Spell.dbc. The seat animation is 91 (Mount), the animation 1.12.1's world mount plays on the rider. |
||
|
|
fca967c827 |
refactor(spell): test a spell's auras through one HasAuraEffect
Six places asked the same question of a Spell.dbc record: does one of its three effects apply aura N (EffectApplyAuraName, +0x16C, int32[3])? Each had its own loop: the combat log's damage-shield lookup, crowd-control classification and its snare test, tracking-spell detection, C_SpellBook.GetPlayerSpellsByAura, and the aura-source periodic-damage gate (which also hard-coded 3 for the effect count). Spell::Lookup now has FindAuraEffect (the index of the first effect that applies the aura, or -1, for callers that read that effect's other columns) and HasAuraEffect on top of it, next to the existing HasEffect. All six call it. Code that pairs an aura with the same effect's misc value, amount or effect code (Cancel, Interruptible, BonusDamage, StatAccum, EffectInfo) keeps its own per-effect reads. |
||
|
|
24404b5a23 |
fix(swing): report only a held main-hand reset at attack start
SMSG_ATTACKSTART re-fired PLAYER_SWING(MainHand) whenever the main-hand swing was still running. That was meant for a cast reset recorded before the attack (held back because no swing was coming yet), but the server also sends SMSG_ATTACKSTART on a target switch mid-attack. Unit::Attack then resets only the off-hand timer; the main-hand swing keeps going. The event carried just the time left in that swing, so listeners read a nearly finished swing as a fresh, short one. Each swing type now carries a held flag, set only by a reset recorded without notify and cleared when that type's PLAYER_SWING fires. The attack-start path reports the main hand only while it is held. Fixes brues-code/SuperCleveRoidMacros#11v1.20.4 |
||
|
|
a106d86969 |
fix(unit): consult the name cache only when no unit object is held
UnitClassBase and UnitRaceBase now follow stock Script_UnitClass (0x00518350) and Script_UnitRace (0x00518200) branch for branch. "player" reads the selected-character record; any other token goes through GetGUIDFromName + ClntObjMgrObjectPtr(TYPEMASK_UNIT) and reads the held object's descriptor byte (+0x79 class, +0x78 race). The NameCache record (+0x140 / +0x138, null callback) is peeked only when no object is held. Before, the NameCache was also peeked when a held object's byte was 0. That never changed a result (creatures are not in the NameCache) but resolved the token twice and did not match the engine's branch. The comments and API.md also claimed creatures return nil, that class IDs run 1-9, and that UnitClass has a third return. None of that is true: creatures go through the same ChrClasses/ChrRaces lookup as in UnitClass/UnitRace, Druid is 11, and stock returns exactly two values.v1.20.3 |
||
|
|
fac3be3a0b |
refactor(lua): take integer enum and constants entries as arrays
RegisterIntegerEnum and RegisterConstants took their entries with a count beside them, written as sizeof(t) / sizeof(t[0]), std::size, or a literal. They now take Game::ArrayRef<EnumIntegerEntry>, as RegisterFrameMethods does, so the count comes from the array's type. The documentation recorders RecordEnum and RecordConstants take the same view. All 34 call sites pass only the array. The six literal counts were checked against their arrays first: each was the full length, so every Enum.* and Constants.* table gets the same entries as before. Five files that included <iterator> only for std::size drop it. |
||
|
|
b49c107778 |
refactor(lua): take frame-method tables as arrays, not pointer and count
Every RegisterFrameMethods call passed its method table and doc table with a count beside each: sizeof(t) / sizeof(t[0]), std::size, or a literal. The literals had to be kept in step with the tables by hand. Game::ArrayRef<T> is a view over a file-scope array that takes the count from the array's type, the way Doc::FieldList already did for a function's arguments and returns. FieldList is now ArrayRef<Field>, Doc::MethodList is ArrayRef<Method>, and RegisterFrameMethods takes (context, methods, docs). The table and count still go to the engine's frame-method iterator (FUN_REGISTER_FRAME_METHODS) unchanged, and to the documentation recorder. All 84 call sites pass only the arrays. The 16 literal counts were checked against their tables first: each was the full length, so every registry gets the same methods as before. |
||
|
|
53b7f79440 |
fix(model): release dress builders and stopped effects with their frame
/reload crashed with an access violation in the model release (0x007103A3, inside FUN_MODEL_INSTANCE_RELEASE 0x007103A0) when SetDisplayInfo had dressed a few panes. 1.12.1 reloads in two steps. CGGameUI::Shutdown (0x00490BD0) deletes the CSimpleTop, which destroys every frame. A Model frame's teardown, DestroyModelFrame (0x0076CA50, from the CSimpleModel and CGCharacterModelBase destructors), releases the frame's M2 scene at +0x314, and the scene frees every model in it, even one that something else still holds a reference on. Only then does CGGameUI::Initialize (0x0048FBF0) reset the Lua state, which runs FrameScript_Initialize and our reload cleanups. DisplayInfo's cleanup destroyed each kept compositor there (FUN_CHARCOMP_DESTROY 0x00476000), and the compositor released its reference to a model that was already freed. VisualKit's cleanup detached and released stopped one-shot effects that live in the same freed scene. Model::Teardown hooks DestroyModelFrame and runs its subscribers before the original, while the frame's scene and models are intact, which is where the engine frees what its own frames hold. DisplayInfo drops the frame's dress job there, and VisualKit records each stopped effect's pane (in the done callback's user data) and discards that pane's effects there. Their reload cleanups keep only the pointer-keyed state. The ReloadAutoRegister doc now says that the cleanups run after the frames are gone, so they may forget pointers but never release an engine object tied to a frame. |
||
|
|
7b21453469 |
refactor(model): share the engine model calls across the model modules
The model modules each declared their own pointers to the same 1.12.1 engine functions: the instance gates FUN_MODEL_INSTANCE_LOADED (0x007103D0) and FUN_MODEL_INSTANCE_READY, AddRef / Release (0x00710390 / 0x007103A0), FUN_M2SCENE_CREATE_MODEL, FUN_M2MODEL_PLAY_ANIMATION, the done callback, the item visuals, the render callback, the M2 data lookup FUN_M2_LOOKUP_INDEX (0x00710310), and the pane's model, scene, SetModelInstance virtual (vtable +0x90) and SetDisplay. model/M2.h now holds one typed wrapper for each, and every module calls through it. - Game::Lua::ResolvePlayerModel / ResolveDressUpModel join the per-type resolvers, replacing four ResolvePane copies and five inline ResolveTypedObject calls. Game::Lua::TYPE_NONE replaces the local kTypeNone in Rotation and frame/CreateFrame. - Offsets.h has the full INVTYPE list, 0..28, named by the engine's own key table at 0x0083DDB0. It replaces the four scattered INVTYPE_* entries and the local copies in DressUp and ItemDisplay, and the try-on result switch reads by name. - DisplayInfo keeps its dress jobs in a map by frame, like the other modules, in place of the fixed 8-slot pool and its eviction. - DressUp names the held lane's bytes (item class, inventory type, sheathe type) and detaches a lane in one place. - ItemDisplay::OwnVisual is the one test for a display's own ItemVisuals row (GetItemDescVisual 0x0062EC70), used by SetItem and by TryOn's enchant glow. Both own-record panes share Pane::DisplayRecord, and the SetDisplayInfo records are cleared on /reload as the SetItem records are. |
||
|
|
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>
|
||
|
|
d825bcbdda |
fix(spell): stand, dismount and unshift only when the cast is sent
autoStand / autoDismount / autoUnshift ran their actions as soon as the caster-state check (CheckCasterStateForSpell, 0x006094F0) passed. In the 1.12.1 cast request (TryCastSpell, 0x006E4B60) that check comes before the target arm (0x006E5250), so a cast that then found no target still dismounted the player and showed "You have no target" (Charge with nothing targeted). A targeting cursor the player cancelled did the same. The caster check now only keeps what its rungs noted, and the actions run at the send. SendCast (0x006E54F0) builds the cast packet; its five callers all pass the global pending cast: the arm's two immediate sends and the object / location / trade-slot binders, which the targeting cursor's click also runs. The arm's only caller is the cast request, after the caster check, so every send follows a check of the same cast. Each action runs only if its state still holds, since the player can stand, dismount or leave the form while the cursor is up. The send redirects must all apply before the rungs are patched. Item use had the same ordering gap. Its form refusal (0x005D914D) comes before the toggle test, which turns off a use aura that is already up instead of casting (0x005D9157..0x005D9237). Re-using such an item while shapeshifted dropped the form as well. The refusal now only notes the unshift; it runs at the bind-on-use test (0x005D91D3), which every path past the toggle reaches, and the toggle's cancel call clears it. Fixes #132 |
||
|
|
6b36bb10e6 |
fix(spell): report GetSpellPowerCost in displayed power units
The engine's cost helper (FUN_006E31B0) answers in stored units, and
1.12.1 stores rage in tenths, so Shield Slam's 20 rage came back as
cost = 200. Divide by the engine's own display divisor
(GetPowerDisplayDivisor, 0x006E7130: [0x0086F978 + 4*type], 1 for a
negative type; table {1, 10, 1, 1, 1000}) before pushing, the same way
the engine and our UnitPower / GetSpellInfo / combat-log paths do.
Every power amount surfaced to Lua now goes through one helper,
Unit::Power::DisplayDivisor, which calls that engine function. That
retires the duplicate FUN_GET_POWER_DISPLAY_DIVISOR offset, the two
local typedef copies, and UnitPower's direct read of the divisor table
(VAR_UNIT_POWER_DIVISOR_TABLE, now removed).
Fixes #129
v1.20.2
|
||
|
|
6628dcca19 |
fix(loot): keep LootAllCorpses walking past refused and stale corpses
The walk ignored the server's refusal. A failed CMSG_LOOT ("too far
away", not ours, ...) arrives as SMSG_LOOT_RESPONSE with loot type 0;
CGPlayer_C::ReadLootResponse (0x005EB900) shows the error and clears the
held loot target (+0x1D28) without opening a window, and the release
response (0x005EC090) clears it the same way. The walk only advanced on
the loot controller hook or a 180-frame timeout, so each refusal stalled
it for seconds. It now advances as soon as the held target is no longer
the corpse it sent for.
A send the engine refused dropped the whole queue. LootUnit (0x005DF2A0)
sends nothing while the mover flags & 0x20FF are set (moving, turning,
falling), and the walk treated each refusal as "skip this corpse", so
moving during a walk skipped every corpse left. A refused send now stays
the current corpse and is retried each tick; after 3 s the walk ends.
The queue's range check went stale. Range was tested once when the walk
began, but each corpse costs a round trip and the player can move in
between. With CanAutoInteract set, CanLootNow (0x005EC110) skips its own
reach test, so the request went out and the server refused it. Each
corpse is now checked for existence, DYNFLAG_LOOTABLE and reach right
before its send, and skipped when it fails.
The reach test is CanLootNow's own: both units' +0x1F0 reach plus the
engine's leeway, at least its minimum, with both constants read live
(VAR_MELEE_REACH_LEEWAY / VAR_MELEE_REACH_MIN) instead of local copies.
It and the lootable test move to Loot::Request, shared by
GetNearbyLootableUnits and the walk. The step timeout uses Time::Clock
instead of a frame count.
|
||
|
|
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.v1.20.1 |
||
|
|
c0b403ba05 |
feat(model): add PlayerModel:ApplySpellVisualKit
PlayerModel:ApplySpellVisualKit(spellVisualKitID [, oneShot]) shows a SpellVisualKit's effects on the pane's model. In the world, 1.12.1 plays a kit on a unit (0x0060EDF0), through effect objects, spell durations and the unit's own animation, and a pane has none of these. The engine's own kit on a bare model is the char-select ghost (0x004727F0), and this is that routine for any kit on the pane's model: - Each of the nine effect columns (+0x0C) is created as a model from its SpellVisualEffectName file, in the pane's scene. It is attached at the column's attachment (20, 34, 19, 21, 22, 17, 23, 24, 25) when the model has that attachment (0x00712CB0, 0x00712F70), as in 0x00472780. The effects get the frame's light through LightChildren. - Procedure kind 1 sets the tint (an 0xRRGGBB colour stored as a float, scaled by 1/255) and kind 14 the alpha, clamped to 0..1. Both are plain stores (0x00710CF0, 0x00710CB0), as the ghost kit makes them. The kit's animation and sound do not play, which matches retail. An effect model's sequence plays one time. Without oneShot, each effect gets the world's loop callback (KitEffectLoopCallback, 0x0060ED00): a clean end (reason 0) plays the animation again. With oneShot, each effect gets EffectDoneCallback's test (0x005FBF50) and CEffect::Stop's model steps (0x006203E0): clear the callback and hide the model, so its emitters stop and the particles already out finish. A FrameTick drain, which runs after the strata walk, then mirrors DrainDyingEffects (0x0061F680). It detaches a stopped effect (0x00713020) once HasLiveParticles (0x007135C0) is false, or at once when its model has already dropped it. A model's destructor detaches its children first (0x0070E3F5), so the drain never reaches a freed parent. The effects are children of the pane's model, so SetUnit, SetItem or a hide and show clears them.v1.20.0 |
||
|
|
f6b98bc3ec |
fix(dbc): reject negative IDs in DBC::Record
DBC::Record checked the ID against the store's count as a signed int. A DBC column uses -1 for "none", and -1 passed that check, so the helper returned records[0xFFFFFFFF]. On 32-bit that wraps to records[-1], the heap word in front of the index array. A caller that passed an unchecked column read a garbage "record": an empty SpellVisualKit effect column gave the pointer 0xF and crashed. The engine rejects these IDs before it compares with the count: the char-select ghost kit's effect step tests the ID with a signed jl at 0x00472797, then a jg against the count. Record now compares unsigned, so it rejects 0, every negative ID, an ID above the count, and an unloaded store, whose count is -1. PvP::Arena had its own copy of the lookup with the same signed compare. It now calls DBC::Record. |
||
|
|
8f4f574174 |
feat(model): add PlayerModel:SetItem
PlayerModel:SetItem(itemID [, appearanceModID, itemVisualID]) shows one item's own model in the pane: a weapon, shield, helm, shoulder, quiver or ammo, with its skin texture and its glow. A 1.12.1 pane shows whatever its display record names (+0x3F0). SetDisplay (0x00505CB0) stores the record and builds it when the pane is visible, the show path (0x00505D49) builds it again, and the SetUnit helper (0x00505B50) clears it. SetItem gives the pane a record of its own and passes it to SetDisplay. The AttachDisplayModel (0x00505A70) co-hook in Model::DisplayInfo then builds the item instead of a creature. So hide, show, SetUnit, SetDisplayInfo and SetKeepModelOnHide handle an item with no new hooks. The model is built from 1.12.1's own steps: - the item folder by inventory type, from the engine's own Item\ObjectComponents\ path strings (0x00838CD8 on); - model name 0, else name 1, with the texture of the same index; - for a head item, the helm builder's (0x004799A0) path, with the player's race prefix (ChrRaces +0x18) and sex letter (0x00838AB4); - AttachItemModelFile's (0x004798C0) steps: create the model in the pane's scene, load the skin with the item-model status (0x00B424F0) and filter 3, bind it as texture type 2 (0x00710EC0), and attach the item visuals (0x00479700); - AttachDisplayModel's install: SetModelInstance (vtable +0x90), the pane's done callback (0x005062A0 through 0x00711BB0), Stand, and the release of the creation reference. The display's own ItemVisuals row wins over itemVisualID, the rule GetItemDescVisual (0x0062EC70) applies to enchants. The visual's child models get the frame's light and fog callback, now a shared LightChildren helper, so they are not drawn black. An uncached item is queued through Item::Data::WarmCache, and each visible pane that still shows it is built again when the item loads. |
||
|
|
43a989dd56 |
feat(model): add PlayerModel:FreezeAnimation
FreezeAnimation(animation, variation, frame) holds the model in one pose of an animation until the pane loads a new model, as SetAnimation does. frame is the time into the animation in milliseconds, the unit of M2 sequence times. The engine's sequence time is start + (ftol(elapsed * speed) + offset) mod length. So the pane's arm plays the animation through PlayAnimation (0x007121A0) at speed 0 and writes frame to bone 0's slot offset (+0xB8, bone states 0x118 bytes each at [model+0x90]). Speed 0 also puts the end stamp on the start stamp. Update (0x00719370) would then queue the done callback on the next frame, and the pane's done callback (0x005062A0) would arm Stand. The arm therefore sets the slot's done latch (+0xC0), the flag Update itself sets once it has reported done. A held animation never ends. SetAnimation and FreezeAnimation now also mark the pane for one re-arm. A call with the animation that already plays then still starts or ends a freeze, where the per-paint compare alone would skip it. |
||
|
|
0caddb8fe6 |
feat(model): add PlayerModel animation, keep-on-hide and unit methods
Adds SetAnimation, SetDoBlend/GetDoBlend, HasAnimation, SetKeepModelOnHide/GetKeepModelOnHide, CanSetUnit and GetDisplayInfo to PlayerModel (and so to DressUpModel and TabardModel). SetUnit now returns whether the unit exists, and SetCreature takes an optional display ID. Animation. A 1.12.1 pane rests on Stand: its per-paint UpdateModel (0x00505C50) arms Stand (PlayAnimation 0x007121A0 with id 0) whenever key bone -1 plays anything else and no turn is pending. A deadline of 0 counts as passed, so any other animation lasted one frame. SetAnimation gives the pane a resting animation and variation of its own. With one set, UpdateModel is hooked to arm that animation in Stand's place, using the pane's blend setting. Every other pane runs the stock function. The pane's done callback (0x005062A0) arms Stand when the animation ends, so the next paint starts it again and it loops. CSimpleModelFFX's SetModelInstance (0x0076CD30), which every pane model build and hide goes through, clears it, so a new model rests on Stand again. SetRotation turns without the shuffle while a resting animation other than Stand is set. HasAnimation is PlayAnimation's own test on the raw id: the lookup at shared data +0x24 must give an index below the sequence count at +0x1C. It is false until the model has loaded. Keep on hide. The pane's Hide (0x00505CE0) drops its model through slot 36, and its Show (0x00505D00) builds a new one from the unit or display record. With keep on, Hide runs only the base hide (0x0076AD50) and Show runs only the base show (0x0076AE10) while the pane still holds its model. The model then comes back with its try-ons and animation. The SetUnit helper (0x00505B50, behind SetUnit, RefreshUnit and Dress) and SetDisplay (0x00505CB0) only store the new subject while the pane is hidden, so they drop a kept model first. The next Show then builds the new one. Off is the default and matches the stock client. Units and displays. SetUnit runs the engine's method (0x00505D70, which Turtle patches) unchanged. It then reports whether the GUID it stored resolves to a unit (type mask 8), the same test the helper uses before it builds. CanSetUnit is that resolve without the set. GetDisplayInfo reads the display record's ID, or the unit's UNIT_FIELD_DISPLAYID (+0x1F4, field 0x7D). SetCreature with a display ID shows that display through the SetDisplayInfo record. |
||
|
|
8e603a7a0b |
fix(player): make IsLoggedIn false until PLAYER_LOGIN fires
IsLoggedIn returned whether the player GUID was set. That GUID falls
back to the char-select GUID before the world loads, and on a /reload
the live GUID is already set while the addons load. So IsLoggedIn was
true while every addon's files ran, and EventUtil.ContinueOnPlayerLogin
ran its callback at once instead of waiting for PLAYER_LOGIN. An addon
that hooked another addon this way hooked it before that addon had set
itself up.
1.12.1 fires PLAYER_LOGIN from one place: the enter cascade
(0x004908C0) calls FUN_FIRE_EVENT_NO_ARGS with 0x10E at 0x00490959,
once per interface initializer run (login and reload). Its arm byte
0x00B4E260 cannot answer the question directly: the initializer sets
it after the addons load (0x0049011D) and the cascade clears it after
the fire (0x0049095E). That call is now redirected to set a flag just
before the event goes out, and the FrameScript_Initialize cleanup,
which runs before every /reload and /logout, clears it.
IsLoggedIn is now false on glue and during addon load, and true from
the PLAYER_LOGIN handlers on, through world transfers.
UnitGUID("player") keeps its char-select fallback.
|
||
|
|
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> |
||
|
|
0a3f8324ea |
fix(frame): stop a re-anchor during layout from freeing the point being read
Crash #132 at 0x00768323 (FUN_REGION_GET_RECT reading [5+0x3C]): Show lays a frame out before its children leave their layout deferral, so its OnSizeChanged ran; the ScrollBox handler read a region's size, and laying that region out reached an anchor point on a still-deferred child. The point getter (0x007A2F90 / 0x007A3070) ends the relative's deferral with FUN_REGION_LAYOUT_REALIZE(0), which ran the child's OnSizeChanged; that script re-anchored the region, freeing the point, and the getter then read the point again (0x007A2FC5) from freed heap. The getters now end the deferral themselves with the point marked busy. The point's deleting destructor (0x00767D80, the only free path) flags a busy point; a flagged getter returns the layout's undefined value without touching the point, and the point walk (0x007671A0 / 0x007671F0) is run again with the current anchors, up to ten times. Otherwise the engine's own getter reads the value, with the deferred bit hidden so a script that hid the relative again cannot start a second resolve. No hooks: the three getters/destructor are patched in the relative-point vtable (0x0081C44C, their only reference), and the six edge resolvers' calls to the walks are redirected. Adds Common::RedirectSlot for the vtable entries. |
||
|
|
6f3a8ffc1d |
feat(texture): add static creature portraits by display ID (#123)
* feat(texture): add static creature portraits by display ID * docs(api): document static creature portrait functions * Update API.md * refactor(model): bake display-ID portraits on the engine's own path SetPortraitTextureFromCreatureDisplayID now replays 1.12.1's unit portrait bake, BakePortrait (0x00524F60), call for call on a display model of its own, instead of driving a hidden PlayerModel through Lua. The display model is built the way AttachDisplayModel (0x00505A70) builds one, without a frame: M2CreateScene (0x00706E10), then CreateModelFromPath (0x00707350) on the CreatureModelData path, then ApplyCreatureDisplay (0x004797B0). A character display is dressed through the engine compositor with the same code that dresses PlayerModel:SetDisplayInfo, now shared as Model::DisplayInfo:: CreateDresser / PumpDresser / DestroyDresser. The bake's own gate, IsReady(model, 0, 1) (0x00710450), only passes for a model that something has drawn: a BLP texture gets its device texture only when GetTextureDeviceObject (0x0044ACF0) is asked with wait set. The shared M2 still loads on its own, so the gate here is IsLoaded(model, 0, 1) (0x007103D0) plus the dress, and the bake's IsReady(copy, 1, 1) makes the device textures, as it does for the copy of a unit's model. The bake itself is the engine's sequence: copy into a fresh scene, DetachAllItemModels, camera 0, PlayAnimation, save projection, view, viewport and fog (GxMasterEnable 0x0058A210 / 0x0058A1E0), the 64x64 DDC box in the bake's own float order, CameraSetDeviceTransforms, clear colour 0, ClearDevice(3), PortraitLighting, both scene passes, read back through 0x00589CF0, clear, cut the alpha mask in (0x005258A0), restore. It runs at the head of the UI render callback, the same point as an OnUpdate script that calls SetPortraitTexture, behind the bake's device gate (0x0058A260 window active, 0x0058A280 device alive). Each display ID owns one callback texture (TextureCreateWithCallback, which makes its device texture at creation). It is bound with SetImage (0x00770300) at call time and filled in place with GxTexMarkRectDirty (0x0058ACD0), the bake's own path for re-baking a cached portrait. A region the caller re-points before the bake finishes keeps what it was given, so no region is tracked: the request map, the region-destruction subscription and ClassicAPI_CancelPortraitTextureRequest are gone. The function returns nothing, as retail's does. Portraits are kept until logout, the lifetime of the engine's display-ID portrait cache (cleared in ShutdownGame). A display with no portrait camera is done once and stays transparent. Offsets.h: the portrait block is renamed to engine names with calling conventions and sources; the duplicates of FUN_M2SCENE_ANIMATE, FUN_M2MODEL_SET_ANIMATED and GetCameraById are removed, as are the made-up draw-flag and scene-count fields and the raw device-vtable slots. Model::Camera::CameraById is exposed instead of being copied. --------- Co-authored-by: z1xel <ramirezthiago@71gmail.com> Co-authored-by: Brues <5278969+brues-code@users.noreply.github.com> |