fix(unit): read the creature id from the unit's live entry, not the GUID

UnitCreatureID and C_CreatureInfo.GetCreatureID extracted the template from
GUID bits 24-47. On the (v)mangos family that is the spawn row's FIRST
creature id: Creature::CreateFromProto builds the GUID from creature_id[0]
and applies the rolled template through UpdateEntry -> SetEntry only, and a
respawn re-rolls. Turtle's creature table has up to four ids per row (6,935
of 79,773 rows use more than one), so mobs with different names reported the
same id — every Gordunni ogre from a {5236, 5238, 5239} row read 5236.

New Unit::CreatureID reads the entry the engine keys the creature NAME query
on: the instance block at [[unit+0x08]+0x0C] (FUN_00604600's own read), with
the GUID bits only as the out-of-view fallback for creature GUIDs. The
descriptor's OBJECT_FIELD_ENTRY slot reads 0 for creatures on this client,
as it does for items, so it is documented as unusable. Pet GUIDs pack the pet
number, not a template, so Guid::CreatureEntry now returns 0 for them; pets
in view report their real template from the block.

Verified in-game on Turtle: Gordunni Shaman / Battlemaster / Mage-Lord read
5236 / 5238 / 5239 while all three carry 5236 in the GUID.
This commit is contained in:
Brues
2026-09-12 23:47:08 -05:00
parent 108a91a843
commit a2be83f188
7 changed files with 164 additions and 49 deletions
+19 -10
View File
@@ -2828,9 +2828,9 @@ Stored as the `bankAutosortDisabled` console variable.
### `C_CreatureInfo.GetCreatureID(guid)`
Extracts the creature template / NPC ID from a unit GUID. The entry ID
is packed directly into bits 24-47 of the 64-bit GUID for the types that
carry one; this function does the shift and mask so addons don't have to.
Returns the creature template / NPC id for a unit GUID, or `nil`. The id is
the same one the game uses to look up the creature's name, and the same one
Wowhead and Turtle's database show in their NPC pages.
```lua
C_CreatureInfo.GetCreatureID(UnitGUID("target")) -- 1842 for Hogger
@@ -2838,10 +2838,17 @@ C_CreatureInfo.GetCreatureID(UnitGUID("pet")) -- pet's creature template ID
C_CreatureInfo.GetCreatureID(UnitGUID("player")) -- nil (no entry on players)
```
While the unit is in view, the id is read live from the unit, so it always
matches the name you see. Some spawn points pick one of several templates,
and a respawn can pick a different one. When such a unit is out of view, the
id comes from the GUID instead, and that id is the spawn point's first
template, which can differ from the unit's current name.
Accepts creature GUIDs (`0xF130xxxx…`) and pet GUIDs
(`0xF140xxxx…`). Returns `nil` for:
- non-string input or malformed GUIDs
- player GUIDs — the low 32 bits hold a player ID, not a template
- player GUIDs — a player carries no template
- a pet that is out of view — a pet GUID does not carry its template
- game-object / dynamic-object / corpse / item GUIDs — `C_CreatureInfo`
doesn't surface entry IDs for these even though the bits are in the
same range; addons that need them can shift the raw GUID themselves
@@ -17450,12 +17457,14 @@ creatureID = UnitCreatureID(unit)
/dump UnitCreatureID("pet") -- your pet's creature-template id
```
The entry id is packed into the unit's GUID (bits 24-47), so this reads it
straight from the resolved GUID — no creature cache lookup. Returns `nil` for a
player (a player GUID carries no template), an unresolvable-but-valid token
(`"target"` with nothing targeted, an empty `"partyN"` slot), and any unit whose
GUID isn't a creature or pet. Raises a Lua error on a garbage token — the
standard `UnitX` behavior. Pair with
The id is read live from the unit, so it always matches the name you see, and
it is the id Wowhead and Turtle's database show for that NPC. For a unit that
is out of view, the same fallback as `C_CreatureInfo.GetCreatureID` applies.
Returns `nil` for a player (a player carries no template), an
unresolvable-but-valid token (`"target"` with nothing targeted, an empty
`"partyN"` slot), an out-of-view pet, and any unit whose GUID isn't a creature
or pet. Raises a Lua error on a garbage token — the standard `UnitX` behavior.
Pair with
[`C_CreatureInfo.GetCreatureInfoByID`](#c_creatureinfogetcreatureinfobyidcreatureid)
to get the name from the id.
+18
View File
@@ -1551,6 +1551,24 @@ enum Offsets {
// descriptor at +0x114 — these are sibling classes under CGObject
// with class-specific descriptor offsets.
OFF_UNIT_DESCRIPTOR = 0x110,
// A creature's LIVE creature_template entry — in the INSTANCE BLOCK at
// `[unit + OFF_UNIT_GUID_PTR]` (GUID @+0x00, entry @+0x0C), the same
// shape as CGItem's block (GUID @+0x00, itemID @+0x0C). NOT the
// descriptor's OBJECT_FIELD_ENTRY slot (+0xC), which reads 0 for
// creatures exactly as it does for items (in-game probe: a Gordunni
// Mage-Lord read desc 0 / block 5239 / GUID bits 5236). This is what the
// engine keys the creature NAME query on: `FUN_00604600` resolves the unit
// and calls the creature cache with `[[unit+8] + 0xC]`; it is registered
// as the OBJECT-bank field-0xC handler (`FUN_006041f0` →
// `FUN_00468070(0, 0xC, 4, 0x604600)`). Do NOT derive a creature id from
// the GUID's entry bits instead: the server builds the GUID from the spawn
// row's FIRST creature id (`Creature::CreateFromProto` →
// `Object::_Create(guidlow, creature_id[0], …)`) and applies the rolled
// template with `UpdateEntry` → `SetEntry` only, so multi-id spawns (6,935
// Turtle rows) and respawn re-rolls put a different template behind the
// same GUID entry — Turtle's Gordunni rows are {5236, 5238, 5239} and
// every one of them carries 5236 in its GUID. Read by `Unit::CreatureID`.
OFF_UNIT_INSTANCE_ENTRY = 0x0C,
// CGCreature client-side creature-data cache row. Populated by the
// engine when an NPC GUID becomes visible (the same row the
+16 -17
View File
@@ -10,6 +10,7 @@
#include "Game.h"
#include "guid/Guid.h"
#include "unit/CreatureID.h"
#include <cstdint>
@@ -19,23 +20,23 @@ namespace {
// `C_CreatureInfo.GetCreatureID(guid) → creatureID | nil`
//
// Extracts the creature template / NPC ID from a unit GUID. Vanilla
// 1.12 packs the entry ID into bits 24-47 of the GUID for the world-
// object types that carry one (creature `0xF130`, pet `0xF140`); the
// low 24 bits are the per-spawn counter. Player GUIDs use the low 32
// bits for the player ID and have no template, so they return nil.
// The creature template / NPC ID for a unit GUID. Resolution lives in
// `Unit::CreatureID::ForGuid`: the unit's LIVE instance-block entry while the
// object is in view (the field the engine keys the creature's name on), else
// the entry packed in a creature GUID's bits 24-47. See unit/CreatureID.cpp
// for why the two differ on this server family (multi-id spawns re-roll the
// template but keep the GUID; pet GUIDs pack the pet number).
//
// Modern's `C_CreatureInfo.GetCreatureID` returns nil for any GUID
// that isn't a creature; we additionally accept pet GUIDs since
// vanilla pets carry an entry ID too (the pet's creature template,
// the same field that drives the pet bar icon). Game-object GUIDs
// have entry IDs in the same bit range but modern doesn't surface
// them through `C_CreatureInfo` — addons that need those should
// look at the GUID prefix and shift manually.
// Modern's `C_CreatureInfo.GetCreatureID` returns nil for any GUID that
// isn't a creature; we additionally answer pet GUIDs while the pet is in view
// (its template drives the pet bar icon). Game-object GUIDs carry entry IDs in
// the same bit range but modern doesn't surface them through
// `C_CreatureInfo` — addons that need those should look at the GUID prefix
// and shift manually.
//
// Returns nil for: non-string input, malformed GUIDs, non-creature /
// non-pet types, and entry IDs of 0 (the engine never assigns
// entry 0 to anything; treat as "no info").
// non-pet types, an out-of-view pet, and entry IDs of 0 (the engine never
// assigns entry 0 to anything; treat as "no info").
int __fastcall Script_GetCreatureID(void *L) {
if (!Game::Lua::IsString(L, 1)) {
Game::Lua::PushNil(L);
@@ -46,9 +47,7 @@ int __fastcall Script_GetCreatureID(void *L) {
Game::Lua::PushNil(L);
return 1;
}
// `Guid::CreatureEntry` handles the creature/pet type gate + the bits-24-47
// extraction, and returns 0 for players, non-creature types, and entry 0.
const uint32_t entryID = CreatureEntry(guid);
const uint32_t entryID = Unit::CreatureID::ForGuid(guid);
if (entryID == 0) {
Game::Lua::PushNil(L);
return 1;
+1 -2
View File
@@ -52,8 +52,7 @@ const char *FormatAsString(uint64_t guid, char *buf, std::size_t cap) {
}
uint32_t CreatureEntry(uint64_t guid) {
const Type type = Classify(guid);
if (type != Type::Creature && type != Type::Pet)
if (Classify(guid) != Type::Creature) // a pet GUID packs the pet number here
return 0;
return static_cast<uint32_t>((guid >> 24) & 0xFFFFFFu);
}
+10 -6
View File
@@ -76,12 +76,16 @@ inline bool IsGameObject(uint64_t guid) { return Classify(guid) == Type::Game
inline bool IsDynamicObject(uint64_t guid) { return Classify(guid) == Type::DynamicObject; }
inline bool IsCorpse(uint64_t guid) { return Classify(guid) == Type::Corpse; }
// The creature-template / NPC entry ID packed into a creature or pet GUID
// (bits 24-47). Vanilla puts the per-spawn counter in the low 24 bits and the
// template entry above it. Returns 0 for any other GUID type (players,
// gameobjects, items, the 0 sentinel) and when the field itself is 0 — the
// engine never assigns entry 0, so 0 uniformly means "no creature template".
// Shared by `C_CreatureInfo.GetCreatureID` and `UnitCreatureID`.
// The creature-template entry packed into a CREATURE GUID (bits 24-47; the
// per-spawn counter is the low 24 bits). Returns 0 for every other GUID type
// and when the field itself is 0 — the engine never assigns entry 0, so 0
// uniformly means "no creature template". Pet GUIDs (0xF140) deliberately
// return 0: on the (v)mangos family the pet's entry bits are the PET NUMBER
// (`Pet::Create` → `_Create(guidlow, pet_number, HIGHGUID_PET)`), not a
// template. This is only the OUT-OF-VIEW fallback — the server builds a
// creature GUID from its spawn row's first id and re-rolls the live template
// without touching the GUID, so prefer `Unit::CreatureID::ForGuid`, which
// reads the unit's live instance-block entry whenever the object is resolvable.
uint32_t CreatureEntry(uint64_t guid);
// Minimum buffer size for `FormatAsString`'s output — 16 hex digits +
+64 -14
View File
@@ -11,26 +11,78 @@
// You should have received a copy of the GNU General Public License along with
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
// `UnitCreatureID(unit)` — the creature-template / NPC id for a unit token,
// or `nil`. The token version of `C_CreatureInfo.GetCreatureID(guid)`: it
// resolves the token to a GUID and reads the same entry field the GUID packs
// into bits 24-47. Equivalent to `C_CreatureInfo.GetCreatureID(UnitGUID(unit))`
// but without the round-trip.
// `Unit::CreatureID` — the creature-template / NPC id behind a unit, and the
// Lua `UnitCreatureID(unit)` (the token twin of `C_CreatureInfo.GetCreatureID`).
//
// `nil` for: players (their GUID carries no template), an unresolvable-but-
// Three places carry an "entry", and on this server family they DISAGREE:
//
// - The unit's INSTANCE BLOCK entry (`[[unit + OFF_UNIT_GUID_PTR] +
// OFF_UNIT_INSTANCE_ENTRY]`) is the LIVE creature_template entry — the
// field the engine keys the creature NAME query on (`FUN_00604600` calls
// the creature cache with exactly this read, on creation and as the
// OBJECT-bank field-0xC handler). It is the `creature_template` primary
// key, hence also the id Wowhead / Turtle's database key NPC pages on.
// - The descriptor's OBJECT_FIELD_ENTRY slot reads 0 for creatures on this
// client (as it does for items — see the CGItem note in Offsets.h). A first
// version read it and silently fell back to the GUID bits.
// - The GUID's bits 24-47 are whatever the server put there at spawn. The
// (v)mangos family — tortoise verified — builds a creature GUID from the
// spawn row's FIRST id (`Creature::CreateFromProto` →
// `Object::_Create(guidlow, creature_id[0], …)`), then applies the rolled
// template through `UpdateEntry` → `SetEntry`. A `creature` row holds up
// to four ids (6,935 of Turtle's 79,773 rows use more than one) and a
// respawn re-rolls, so a mob whose name says template B can carry template
// A in its GUID: Turtle's Gordunni rows are {5236 Shaman, 5238
// Battlemaster, 5239 Mage-Lord}, and a Gordunni Mage-Lord probes as
// block 5239 / GUID 5236 — "different names, same creature id" when read
// from the GUID. Pet GUIDs are worse: their entry bits are the PET NUMBER
// (`Pet::Create` → `_Create(guidlow, pet_number, HIGHGUID_PET)`), never a
// template.
//
// So the id is read from the instance block whenever the object is
// resolvable, and the GUID bits are only the out-of-view fallback for
// creature GUIDs (exact on every single-id spawn, i.e. all of stock vanilla).
//
// `UnitCreatureID` returns nil for players (entry 0), an unresolvable-but-
// valid token (`target` with nothing targeted, an empty `partyN` slot), and
// any unit whose GUID isn't a creature or pet. Raises a Lua error on a
// missing / non-string `unit` argument or a garbage token — the standard
// `UnitX` "Unknown unit" behavior (via the token resolver).
// any non-creature / non-pet GUID. Raises a Lua error on a missing /
// non-string `unit` or a garbage token — the standard `UnitX` "Unknown unit"
// behavior (via the token resolver).
#include "Game.h"
#include "Offsets.h"
#include "guid/Guid.h"
#include "object/Resolve.h"
#include "unit/CreatureID.h"
#include "unit/Identity.h"
#include <cstdint>
namespace Unit::CreatureID {
uint32_t ForObject(const void *unit) {
if (unit == nullptr)
return 0;
auto *block = Game::Read<const uint8_t *>(unit, Offsets::OFF_UNIT_GUID_PTR);
if (block == nullptr)
return 0;
return Game::Read<uint32_t>(block, Offsets::OFF_UNIT_INSTANCE_ENTRY);
}
uint32_t ForGuid(uint64_t guid) {
const Guid::Type type = Guid::Classify(guid);
if (type != Guid::Type::Creature && type != Guid::Type::Pet)
return 0;
if (const void *unit = Object::ByGuid(Offsets::TYPEMASK_UNIT, guid)) {
const uint32_t entry = ForObject(unit);
if (entry != 0)
return entry;
}
// Out of view: only a creature GUID packs a template (a pet's packs the
// pet number → Guid::CreatureEntry yields 0 for it).
return Guid::CreatureEntry(guid);
}
namespace {
int __fastcall Script_UnitCreatureID(void *L) {
@@ -43,11 +95,9 @@ int __fastcall Script_UnitCreatureID(void *L) {
return 0;
// Token -> GUID (player fast-path, focus / nameplateN / markN, raw GUID),
// then the shared creature-entry extraction. A valid-but-empty token
// resolves to GUID 0 -> entry 0 -> nil; a player resolves to a player GUID
// -> entry 0 -> nil.
const uint32_t entryID =
Guid::CreatureEntry(Unit::Identity::GuidForToken(token));
// then the shared block-first lookup. A valid-but-empty token resolves to
// GUID 0 -> 0 -> nil; a player resolves to a player GUID -> 0 -> nil.
const uint32_t entryID = ForGuid(Unit::Identity::GuidForToken(token));
if (entryID == 0) {
Game::Lua::PushNil(L);
return 1;
+36
View File
@@ -0,0 +1,36 @@
// This file is part of ClassicAPI.
//
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
// of the GNU General Public License as published by the Free Software Foundation, either
// version 3 of the License, or (at your option) any later version.
//
// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
#pragma once
#include <cstdint>
// `Unit::CreatureID` — a unit's creature_template entry (the NPC id), read the
// way the engine reads it for the creature's NAME: the instance-block entry at
// `[[unit + OFF_UNIT_GUID_PTR] + OFF_UNIT_INSTANCE_ENTRY]`. See CreatureID.cpp
// for why the GUID's entry bits are only a fallback (and the descriptor slot
// is not usable at all).
namespace Unit::CreatureID {
// The live template entry of a resolved CGUnit, or 0 for a null unit, a
// missing instance block, or a player (players carry entry 0).
uint32_t ForObject(const void *unit);
// The creature id for a GUID: the live instance-block entry when the object is
// in the object table, else — for a CREATURE GUID only — the entry packed in
// the GUID (the spawn row's first template; exact whenever the spawn has one
// id). 0 for players and every non-unit GUID, and for a pet that is out of
// view (a pet GUID packs the pet number, not a template).
uint32_t ForGuid(uint64_t guid);
} // namespace Unit::CreatureID