refactor(item): name CGItem deref idioms via Item::InstanceBlock / ObjectFields

Add item/CGItem.{h,cpp} with two null-safe accessors for a CGItem's two
descriptor-like pointers:
  InstanceBlock(cgItem) -> CGItem + 0x08 (item GUID @ +0, itemID @ +0x0C)
  ObjectFields(cgItem)  -> CGItem + 0x114 (stack/flags/charges/durability/...)

Replace the 30 hand-written `*reinterpret_cast<const uint8_t *const *>(x +
OFF_ITEM_INSTANCE_BLOCK/OFF_ITEM_DESCRIPTOR)` derefs across 24 files with
these calls. Behavior-preserving: same deref, all reads were already const,
and each site keeps its own null-check and field reads. Helpers add a
cgItem null guard (strictly safer).

Author: brues-code

src/auctionhouse/PostItem.cpp

@@ -55,6 +55,7 @@
 #include "Game.h"
 #include "Offsets.h"
 #include "event/Custom.h"
+#include "item/CGItem.h"
 #include "item/ID.h"
 #include "item/Location.h"
 #include "item/Swap.h"
@@ -108,16 +109,14 @@ const uint8_t *PeekItemRecord(uint32_t itemID) {
 }
 
 int CGItemCount(const uint8_t *item) {
-    auto *desc = *reinterpret_cast<const uint8_t *const *>(
-        item + Offsets::OFF_ITEM_DESCRIPTOR);
+    auto *desc = Item::ObjectFields(item);
     if (desc == nullptr)
         return 0;
     return *reinterpret_cast<const int *>(desc + Offsets::OFF_DESCRIPTOR_STACK_COUNT);
 }
 
 uint64_t CGItemGuid(const uint8_t *item) {
-    auto *inst = *reinterpret_cast<const uint8_t *const *>(
-        item + Offsets::OFF_ITEM_INSTANCE_BLOCK);
+    auto *inst = Item::InstanceBlock(item);
     if (inst == nullptr)
         return 0;
     return *reinterpret_cast<const uint64_t *>(inst + Offsets::OFF_INSTANCE_BLOCK_GUID);

src/container/ItemInfo.cpp

@@ -50,6 +50,7 @@
 #include "Game.h"
 #include "Offsets.h"
 #include "dbc/Lookup.h"
+#include "item/CGItem.h"
 #include "item/ID.h"
 #include "item/Link.h"
 #include "item/Location.h"
@@ -80,8 +81,7 @@ bool ItemReadable(const uint8_t *item, const uint8_t *record) {
     if (record != nullptr &&
         *reinterpret_cast<const uint32_t *>(record + Offsets::OFF_ITEMSTATS_PAGE_TEXT) != 0)
         return true;
-    const uint8_t *descriptor = *reinterpret_cast<const uint8_t *const *>(
-        item + Offsets::OFF_ITEM_DESCRIPTOR);
+    const uint8_t *descriptor = Item::ObjectFields(item);
     return descriptor != nullptr &&
            *reinterpret_cast<const uint32_t *>(
                descriptor + Offsets::OFF_DESCRIPTOR_READABLE_TEXT_ID) != 0;
@@ -111,8 +111,7 @@ int __fastcall Script_C_Container_GetContainerItemInfo(void *L) {
         : nullptr;
 
     // Live per-instance descriptor fields.
-    const uint8_t *descriptor = *reinterpret_cast<const uint8_t *const *>(
-        item + Offsets::OFF_ITEM_DESCRIPTOR);
+    const uint8_t *descriptor = Item::ObjectFields(item);
     int stackCount = 0;
     bool isBound = false;
     if (descriptor != nullptr) {

src/equipmentset/Api.cpp

@@ -35,6 +35,7 @@
 #include "Offsets.h"
 #include "Set.h"
 #include "event/Custom.h"
+#include "item/CGItem.h"
 #include "item/Location.h"
 #include "item/Swap.h"
 
@@ -72,8 +73,7 @@ const char *ArgString(void *L, int idx) {
 int ResolveItemID(const uint8_t *cgItem) {
     if (cgItem == nullptr)
         return 0;
-    auto *instance = *reinterpret_cast<const uint8_t *const *>(
-        cgItem + Offsets::OFF_ITEM_INSTANCE_BLOCK);
+    auto *instance = Item::InstanceBlock(cgItem);
     if (instance == nullptr)
         return 0;
     return static_cast<int>(*reinterpret_cast<const uint32_t *>(

src/item/Bound.cpp

@@ -13,15 +13,15 @@
 
 #include "Game.h"
 #include "Offsets.h"
+#include "item/CGItem.h"
 #include "item/Location.h"
 
 #include <cstdint>
 
 namespace Item::Bound {
 
 static bool ItemIsSoulbound(const uint8_t *item) {
-    auto *descriptor = *reinterpret_cast<const uint8_t *const *>(
-        item + Offsets::OFF_ITEM_DESCRIPTOR);
+    auto *descriptor = Item::ObjectFields(item);
     if (descriptor == nullptr)
         return false;
     const uint32_t flags = *reinterpret_cast<const uint32_t *>(

src/item/CGItem.cpp

@@ -0,0 +1,34 @@
+// 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/>.
+
+#include "CGItem.h"
+
+#include "Offsets.h"
+
+namespace Item {
+
+const uint8_t *InstanceBlock(const uint8_t *cgItem) {
+    if (cgItem == nullptr)
+        return nullptr;
+    return *reinterpret_cast<const uint8_t *const *>(
+        cgItem + Offsets::OFF_ITEM_INSTANCE_BLOCK);
+}
+
+const uint8_t *ObjectFields(const uint8_t *cgItem) {
+    if (cgItem == nullptr)
+        return nullptr;
+    return *reinterpret_cast<const uint8_t *const *>(
+        cgItem + Offsets::OFF_ITEM_DESCRIPTOR);
+}
+
+} // namespace Item

src/item/CGItem.h

@@ -0,0 +1,38 @@
+// 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>
+
+// Accessors for a `CGItem`'s two descriptor-like pointers (see the "Item
+// lookups" notes in CLAUDE.md). Every item module used to spell out the same
+// `*reinterpret_cast<const uint8_t *const *>(cgItem + OFF_...)` deref; these
+// name it once.
+
+namespace Item {
+
+// The item's **instance block** (`CGItem + 0x08` dereferenced): a `uint64`
+// item GUID at `+0x00` and the `uint32` itemID at `+0x0C`. This is the block
+// the canonical inventory→cache path reads the itemID from. Returns nullptr
+// for a null `cgItem`; the stored pointer itself may still be null (callers
+// null-check the result before reading fields).
+const uint8_t *InstanceBlock(const uint8_t *cgItem);
+
+// The item's **m_objectFields descriptor** (`CGItem + 0x114` dereferenced):
+// the UpdateField block holding stack count (`+0x20`), flags (`+0x3C`),
+// spell charges (`+0x28`), durability (`+0xA0`), enchantments, etc. Distinct
+// from the instance block. Returns nullptr for a null `cgItem`.
+const uint8_t *ObjectFields(const uint8_t *cgItem);
+
+} // namespace Item

src/item/Charges.cpp

@@ -15,6 +15,7 @@
 
 #include "../Game.h"
 #include "../Offsets.h"
+#include "CGItem.h"
 
 #include <cstdlib>
 
@@ -23,8 +24,7 @@ namespace Item::Charges {
 int PushChargesForItem(void *L, const uint8_t *item) {
     if (item == nullptr)
         return 0;
-    auto *descriptor = *reinterpret_cast<const uint8_t *const *>(
-        item + Offsets::OFF_ITEM_DESCRIPTOR);
+    auto *descriptor = Item::ObjectFields(item);
     if (descriptor == nullptr)
         return 0;
     const int32_t stack = static_cast<int32_t>(*reinterpret_cast<const uint32_t *>(

src/item/Count.cpp

@@ -16,6 +16,7 @@
 #include "Game.h"
 #include "Offsets.h"
 #include "item/Arg.h"
+#include "item/CGItem.h"
 #include "item/ID.h"
 #include "item/Location.h"
 #include "object/Resolve.h"
@@ -33,8 +34,7 @@ namespace {
 int GetStackCount(const uint8_t *cgItem) {
     if (cgItem == nullptr)
         return 0;
-    auto *descriptor = *reinterpret_cast<const uint8_t *const *>(
-        cgItem + Offsets::OFF_ITEM_DESCRIPTOR);
+    auto *descriptor = Item::ObjectFields(cgItem);
     if (descriptor == nullptr)
         return 0;
     return static_cast<int>(*reinterpret_cast<const uint32_t *>(
@@ -52,8 +52,7 @@ int GetStackCount(const uint8_t *cgItem) {
 int GetUsesPerItem(const uint8_t *cgItem) {
     if (cgItem == nullptr)
         return 1;
-    auto *descriptor = *reinterpret_cast<const uint8_t *const *>(
-        cgItem + Offsets::OFF_ITEM_DESCRIPTOR);
+    auto *descriptor = Item::ObjectFields(cgItem);
     if (descriptor == nullptr)
         return 1;
     const int32_t raw = *reinterpret_cast<const int32_t *>(

src/item/Cursor.cpp

@@ -16,6 +16,7 @@
 #include "Game.h"
 #include "Offsets.h"
 #include "cursor/Info.h"
+#include "item/CGItem.h"
 #include "item/Location.h"
 
 #include <cstdint>
@@ -44,8 +45,7 @@ bool ItemLocked(const uint8_t *item) {
 // Reads a CGItem's 64-bit instance GUID into lo/hi. False if the instance
 // block pointer is absent.
 bool ReadItemGuid(const uint8_t *item, uint32_t *lo, uint32_t *hi) {
-    auto *instance = *reinterpret_cast<const uint8_t *const *>(
-        item + Offsets::OFF_ITEM_INSTANCE_BLOCK);
+    auto *instance = Item::InstanceBlock(item);
     if (instance == nullptr)
         return false;
     *lo = *reinterpret_cast<const uint32_t *>(instance + Offsets::OFF_INSTANCE_BLOCK_GUID);

src/item/Data.cpp

@@ -15,6 +15,7 @@
 #include "Offsets.h"
 #include "event/Custom.h"
 #include "item/Arg.h"
+#include "item/CGItem.h"
 #include "item/Data.h"
 #include "item/Location.h"
 #include "tick/WorldTick.h"
@@ -119,8 +120,7 @@ static int ResolveLocationToItemID(void *L, int idx) {
     const uint8_t *item = Item::Location::Resolve(L, idx);
     if (item == nullptr)
         return 0;
-    auto *instance = *reinterpret_cast<const uint8_t *const *>(
-        item + Offsets::OFF_ITEM_INSTANCE_BLOCK);
+    auto *instance = Item::InstanceBlock(item);
     if (instance == nullptr)
         return 0;
     return static_cast<int>(*reinterpret_cast<const uint32_t *>(