Kill item variable accessors. YES.

library/include/dfhack/modules/Creatures.h

@@ -543,7 +543,7 @@ namespace DFHack
         int16_t unk_280;
         int32_t unk_284;
 
-        std::vector<t_item *> inventory;   // 288 - vector of item pointers
+        std::vector<df_item *> inventory;   // 288 - vector of item pointers
         std::vector<int32_t> owned_items;  // 298 - vector of item IDs
         std::vector<uint32_t> unk_2a8;
         std::vector<uint32_t> unk_2b8;
@@ -763,8 +763,8 @@ namespace DFHack
 
         bool ReadJob(const df_creature * unit, std::vector<t_material> & mat);
 
-        bool ReadInventoryByIdx(const uint32_t index, std::vector<t_item *> & item);
+        bool ReadInventoryByIdx(const uint32_t index, std::vector<df_item *> & item);
-        bool ReadInventoryByPtr(const df_creature * unit, std::vector<t_item *> & item);
+        bool ReadInventoryByPtr(const df_creature * unit, std::vector<df_item *> & item);
 
         bool ReadOwnedItemsByIdx(const uint32_t index, std::vector<int32_t> & item);
         bool ReadOwnedItemsByPtr(const df_creature * unit, std::vector<int32_t> & item);

library/include/dfhack/modules/Items.h

@@ -109,21 +109,221 @@ struct t_itemref : public t_virtual
 };
 
 /**
- * Basic item data, read as a single chunk
+ * A partial mirror of a DF base type for items
  * \ingroup grp_items
  */
-struct t_item : public t_virtual
+class df_item
 {
-    // vptr                0x0 + 4
+public:
-    int16_t x;          // 0x4 + 2
+    int16_t x;
-    int16_t y;          // 0x6 + 2
+    int16_t y;
-    int16_t z;          // 0x8 + 2
+    int16_t z;
-    // 2B padding          0xA + 2
+    t_itemflags flags;
-    t_itemflags flags;  // 0xC + 4
+    uint32_t age;
-    uint32_t age ;      // 0x10 + 4
+    uint32_t id;
-    uint32_t id;        // 0x14 + 4
+    std::vector<void *> unk1;
-    std::vector<void *> unk1;// Used by tasked items.
     std::vector<t_itemref *> itemrefs;
+public:
+    // 0x0
+    virtual int32_t getType();
+    virtual int32_t getSubtype();
+    virtual int32_t getSubMaterial();
+    virtual int16_t getMaterial();
+    // 0x10
+    /*
+     hm, [4] looks complicated                    *
+     takes a parameter
+     looks like 0x017081A4 is a vector of something
+     this one sets an item property at offset 0xA0
+     (0.31.25 Windows SDL)
+     */
+    virtual void fn4(void);
+    virtual void setMaterial(int16_t mat);
+    virtual void setSubMaterial (int32_t submat);
+    // another one? really? 
+    virtual int16_t getMaterial2();
+    // 0x20
+    // more of the same?
+    virtual int32_t getSubMaterial2();
+    virtual void fn9(void);
+    virtual void fn10(void);
+    virtual void fn11(void);
+    // 0x30
+    virtual void fn12(void);
+    virtual void fn13(void);
+    virtual void fn14(void);
+    virtual void fn15(void);
+    // 0x40
+    virtual void fn16(void);
+    virtual void fn17(void);
+    virtual void fn18(void);
+    virtual void fn19(void);
+    // 0x50
+    virtual void fn20(void);
+    virtual void fn21(void);
+    virtual void fn22(void);
+    virtual void fn23(void);
+    // 0x60
+    virtual void fn24(void);
+    virtual void fn25(void);
+    virtual void fn26(void);
+    virtual void fn27(void);
+    // 0x70
+    virtual void fn28(void);
+    virtual void fn29(void);
+    virtual void fn30(void);
+    virtual void fn31(void);
+    // 0x80
+    virtual void fn32(void);
+    virtual void fn33(void);
+    virtual void fn34(void);
+    virtual void fn35(void);
+    // 0x90
+    virtual void fn36(void);
+    virtual void fn37(void);
+    virtual void fn38(void);
+    virtual void fn39(void);
+    // 0xA0
+    virtual void fn40(void);
+    virtual void fn41(void);
+    virtual void fn42(void);
+    virtual void fn43(void);
+    // 0xB0
+    virtual void fn44(void);
+    virtual void fn45(void);
+    virtual void fn46(void);
+    virtual void fn47(void);
+    // 0xC0
+    virtual void fn48(void);
+    virtual void fn49(void);
+    virtual void fn50(void);
+    virtual int16_t getWear(void); // 0 = normal, 1 = x, 2 = X, 3 = XX
+    // 0xD0
+    virtual void setWear(int16_t wear); // also zeroes wear timer?
+    virtual void fn53(void);
+    virtual void fn54(void);
+    virtual void fn55(void);
+    // 0xE0
+    virtual void fn56(void);
+    virtual void fn57(void);
+    virtual void fn58(void);
+    virtual void fn59(void);
+    // 0xF0
+    virtual void fn60(void);
+    virtual void fn61(void);
+    virtual void fn62(void);
+    virtual void fn63(void);
+    // 0x100
+    virtual void fn64(void);
+    virtual void fn65(void);
+    virtual void fn66(void);
+    virtual void fn67(void);
+    // 0x110
+    virtual void fn68(void);
+    virtual void fn69(void);
+    virtual void fn70(void);
+    virtual void fn71(void);
+    // 0x120
+    virtual void fn72(void);
+    virtual void fn73(void);
+    virtual void fn74(void);
+    virtual void fn75(void);
+    // 0x130
+    virtual void fn76(void);
+    virtual void fn77(void);
+    virtual void fn78(void);
+    virtual void fn79(void);
+    // 0x140
+    virtual void fn80(void);
+    virtual void fn81(void);
+    virtual void fn82(void);
+    virtual void fn83(void);
+    // 0x150
+    virtual void fn84(void);
+    virtual void fn85(void);
+    virtual void fn86(void);
+    virtual void fn87(void);
+    // 0x160
+    virtual void fn88(void);
+    virtual void fn89(void);
+    virtual void fn90(void);
+    virtual void fn91(void);
+    // 0x170
+    virtual void fn92(void);
+    virtual void fn93(void);
+    virtual void fn94(void);
+    virtual void fn95(void);
+    // 0x180
+    virtual void fn96(void);
+    virtual void fn97(void);
+    virtual void fn98(void);
+    virtual void fn99(void);
+    // 0x190
+    virtual void fn100(void);
+    virtual void fn101(void);
+    virtual void fn102(void);
+    virtual void fn103(void);
+    // 0x1A0
+    virtual void fn104(void);
+    virtual void fn105(void);
+    virtual void fn106(void);
+    virtual void fn107(void);
+    // 0x1B0
+    virtual void fn108(void);
+    virtual void fn109(void);
+    virtual void fn110(void);
+    virtual void fn111(void);
+    // 0x1C0
+    virtual void fn112(void);
+    virtual void fn113(void);
+    virtual void fn114(void);
+    virtual void fn115(void);
+    // 0x1D0
+    virtual void fn116(void);
+    virtual void fn117(void);
+    virtual void fn118(void);
+    virtual void fn119(void);
+    // 0x1E0
+    virtual void fn120(void);
+    virtual void fn121(void);
+    virtual void fn122(void);
+    virtual void fn123(void);
+    // 0x1F0
+    virtual void fn124(void);
+    virtual void fn125(void);
+    virtual void fn126(void);
+    virtual void fn127(void);
+    // 0x200
+    virtual void fn128(void);
+    virtual void fn129(void);
+    virtual void fn130(void);
+    virtual void fn131(void);
+    // 0x210
+    virtual void fn132(void);
+    virtual int32_t getStackSize( void );
+    virtual void fn134(void);
+    virtual void fn135(void);
+    // 0x220
+    virtual void fn136(void);
+    virtual void fn137(void);
+    virtual void fn138(void);
+    virtual void fn139(void);
+    // 0x230
+    virtual void fn140(void);
+    virtual void fn141(void);
+    virtual void fn142(void);
+    virtual void fn143(void);
+    // 0x240
+    virtual void fn144(void);
+    virtual void fn145(void);
+    virtual void fn146(void);
+    virtual void fn147(void);
+    // 0x250
+    virtual void fn148(void);
+    virtual void fn149(void);
+    virtual void fn150(void);
+    virtual int16_t getQuality( void );
+    // more follows for sure... bleh.
 };
 
 /**
@@ -132,13 +332,14 @@ struct t_item : public t_virtual
  */
 struct dfh_item
 {
-    t_item * base;
+    df_item * base;
     t_material matdesc;
     int32_t quantity;
     int32_t quality;
     int16_t wear_level;
 };
 
+
 /**
  * Type for holding item improvements. broken/unused.
  * \ingroup grp_items
@@ -162,20 +363,17 @@ public:
     bool Start();
     bool Finish();
 
-    bool readItemVector(std::vector<t_item *> &items);
+    bool readItemVector(std::vector<df_item *> &items);
-    t_item * findItemByID(int32_t id);
+    df_item * findItemByID(int32_t id);
 
     /// get a string describing an item
     std::string getItemDescription(const dfh_item & item, Materials * Materials);
     /// get a short name for an item
-    std::string getItemClass(int32_t index);
     std::string getItemClass(const dfh_item & item);
     /// read an item, including the extra attributes
-    bool readItem(t_item * itembase, dfh_item & item);
+    bool readItem(df_item * itembase, dfh_item & item);
     /// write item base (position and flags only = t_item part of dfh_item)
     bool writeItem(const dfh_item & item);
-    /// dump offsets used by accessors to a string
-    std::string dumpAccessors(const dfh_item & item);
 
     /// who owns this item we already read?
     int32_t getItemOwnerID(const dfh_item & item);

library/modules/Creatures.cpp

@@ -551,7 +551,7 @@ bool Creatures::ReadJob(const t_creature * furball, vector<t_material> & mat)
     return true;
 }
 */
-bool Creatures::ReadInventoryByIdx(const uint32_t index, std::vector<t_item *> & item)
+bool Creatures::ReadInventoryByIdx(const uint32_t index, std::vector<df_item *> & item)
 {
     if(!d->Started) return false;
     if(index >= creatures->size()) return false;
@@ -559,7 +559,7 @@ bool Creatures::ReadInventoryByIdx(const uint32_t index, std::vector<t_item *> &
     return this->ReadInventoryByPtr(temp, item);
 }
 
-bool Creatures::ReadInventoryByPtr(const df_creature * temp, std::vector<t_item *> & items)
+bool Creatures::ReadInventoryByPtr(const df_creature * temp, std::vector<df_item *> & items)
 {
     if(!d->Started) return false;
     items = temp->inventory;

library/modules/Items.cpp

@@ -42,6 +42,7 @@ using namespace std;
 #include "dfhack/modules/Creatures.h"
 #include "ModuleFactory.h"
 #include <dfhack/Core.h>
+#include <dfhack/Virtual.h>
 
 using namespace DFHack;
 
@@ -50,381 +51,11 @@ Module* DFHack::createItems()
     return new Items();
 }
 
-enum accessor_type {ACCESSOR_CONSTANT, ACCESSOR_INDIRECT, ACCESSOR_DOUBLE_INDIRECT};
-
-/* this is used to store data about the way accessors work */
-class Accessor
-{
-public:
-    enum DataWidth {
-        Data32 = 0,
-        DataSigned16,
-        DataUnsigned16
-    };
-private:
-    accessor_type type;
-    int32_t constant;
-    int32_t offset1;
-    int32_t offset2;
-    Process * p;
-    DataWidth dataWidth;
-    uint32_t method;
-public:
-    Accessor(uint32_t function, Process * p);
-    Accessor(accessor_type type, int32_t constant, uint32_t offset1, uint32_t offset2, uint32_t dataWidth, Process * p);
-    std::string dump();
-    int32_t getValue(t_item * objectPtr);
-    bool isConstant();
-};
-class ItemImprovementDesc
-{
-private:
-    Accessor * AType;
-    Process * p;
-public:
-    ItemImprovementDesc(uint32_t VTable, Process * p);
-    bool getImprovement(uint32_t descptr, t_improvement & imp);
-    uint32_t vtable;
-    uint32_t maintype;
-};
-
-class ItemDesc
-{
-private:
-    Accessor * AMainType;
-    Accessor * ASubType;
-    Accessor * ASubIndex;
-    Accessor * AIndex;
-    Accessor * AQuality;
-    Accessor * AQuantity;
-    Accessor * AWear;
-    Process * p;
-    bool hasDecoration;
-    int idFieldOffset;
-public:
-    ItemDesc(void * VTable, Process * p);
-    bool readItem(t_item * itemptr, dfh_item & item);
-    std::string dumpAccessors();
-    std::string className;
-    void * vtable;
-    uint32_t mainType;
-    std::vector<ItemImprovementDesc> improvement;
-};
-
-inline bool do_match(uint32_t &ptr, uint64_t val, int size, uint64_t mask, uint64_t check)
-{
-    if ((val & mask) == check) {
-        ptr += size;
-        return true;
-    }
-    return false;
-}
-
-static bool match_MEM_ACCESS(uint32_t &ptr, uint64_t v, int isize, int in_reg, int &out_reg, int &offset)
-{
-    // ESP & EBP are hairy
-    if (in_reg == 4 || in_reg == 5)
-        return false;
-
-    if ((v & 7) != in_reg)
-        return false;
-
-    out_reg = (v>>3) & 7;
-
-    switch ((v>>6)&3) {
-        case 0: // MOV REG2, [REG]
-            offset = 0;
-            ptr += isize+1;
-            return true;
-        case 1: // MOV REG2, [REG+offset8]
-            offset = (signed char)(v >> 8);
-            ptr += isize+2;
-            return true;
-        case 2: // MOV REG2, [REG+offset32]
-            offset = (signed int)(v >> 8);
-            ptr += isize+5;
-            return true;
-        default:
-            return false;
-    }
-}
-
-static bool match_MOV_MEM(uint32_t &ptr, uint64_t v, int in_reg, int &out_reg, int &offset, Accessor::DataWidth &size) 
-{
-    int prefix = 0;
-    size = Accessor::Data32;
-    if ((v & 0xFF) == 0x8B) { // MOV
-        v >>= 8;
-        prefix = 1;
-    }
-    else if ((v & 0xFFFF) == 0x8B66) { // MOV 16-bit
-        v >>= 16;
-        prefix = 2;
-        size = Accessor::DataUnsigned16;
-    }
-    else if ((v & 0xFFFF) == 0xBF0F) { // MOVSX
-        v >>= 16;
-        prefix = 2;
-        size = Accessor::DataSigned16;
-    }
-    else if ((v & 0xFFFF) == 0xB70F) { // MOVZ
-        v >>= 16;
-        prefix = 2;
-        size = Accessor::DataUnsigned16;
-    }
-    else
-        return false;
-
-    return match_MEM_ACCESS(ptr, v, prefix, in_reg, out_reg, offset);
-}
-
-Accessor::Accessor(uint32_t function, Process *p)
-{
-    this->p = p;
-    this->type = ACCESSOR_CONSTANT;
-    if(!p)
-    {
-        this->constant = 0;
-        return;
-    }
-    method = function;
-    uint32_t temp = function;
-    int data_reg = -1;
-    uint64_t v = p->readQuad(temp);
-
-    if (do_match(temp, v, 2, 0xFFFF, 0xC033) ||
-        do_match(temp, v, 2, 0xFFFF, 0xC031)) // XOR EAX, EAX
-    {
-        data_reg = 0;
-        this->constant = 0;
-    }
-    else if (do_match(temp, v, 3, 0xFFFFFF, 0xFFC883)) // OR EAX, -1
-    {
-        data_reg = 0;
-        this->constant = -1;
-    }
-    else if (do_match(temp, v, 5, 0xFF, 0xB8)) // MOV EAX,imm
-    {
-        data_reg = 0;
-        this->constant = (v>>8) & 0xFFFFFFFF;
-    }
-    else
-    {
-        DataWidth xsize;
-        int ptr_reg = 1, tmp; // ECX
-
-        // MOV REG,[ESP+4]
-        if (do_match(temp, v, 4, 0xFFFFC7FFU, 0x0424448B))
-        {
-            ptr_reg = (v>>11)&7;
-            v = p->readQuad(temp);
-        }
-
-        if (match_MOV_MEM(temp, v, ptr_reg, tmp, this->offset1, xsize)) {
-            data_reg = tmp;
-            this->type = ACCESSOR_INDIRECT;
-            this->dataWidth = xsize;
-
-            if (xsize == Data32)
-            {
-                v = p->readQuad(temp);
-
-                if (match_MOV_MEM(temp, v, data_reg, tmp, this->offset2, xsize)) {
-                    data_reg = tmp;
-                    this->type = ACCESSOR_DOUBLE_INDIRECT;
-                    this->dataWidth = xsize;
-                }
-            }
-        }
-    }
-
-    v = p->readQuad(temp);
-
-    if (data_reg == 0 && do_match(temp, v, 1, 0xFF, 0xC3)) // RET
-        return;
-    else
-    {
-        this->type = ACCESSOR_CONSTANT;
-        this->constant = 0;
-        printf("bad accessor @0x%x\n", function);
-    }
-}
-
-bool Accessor::isConstant()
-{
-    if(this->type == ACCESSOR_CONSTANT)
-        return true;
-    else
-        return false;
-}
-
-string Accessor::dump()
-{
-    stringstream sstr;
-    sstr << hex << "method @0x" << method << dec << " ";
-    switch(type)
-    {
-        case ACCESSOR_CONSTANT:
-            sstr << "Constant: " << dec << constant;
-            break;
-        case ACCESSOR_INDIRECT:
-            switch(dataWidth)
-            {
-                case Data32:
-                    sstr << "int32_t ";
-                    break;
-                case DataSigned16:
-                    sstr << "int16_t ";
-                    break;
-                case DataUnsigned16:
-                    sstr << "uint16_t ";
-                    break;
-                default:
-                    sstr << "unknown ";
-                    break;
-            }
-            sstr << hex << "[obj + 0x" << offset1 << " ]";
-            break;
-        case ACCESSOR_DOUBLE_INDIRECT:
-            switch(dataWidth)
-            {
-                case Data32:
-                    sstr << "int32_t ";
-                    break;
-                case DataSigned16:
-                    sstr << "int16_t ";
-                    break;
-                case DataUnsigned16:
-                    sstr << "uint16_t ";
-                    break;
-                default:
-                    sstr << "unknown ";
-                    break;
-            }
-            sstr << hex << "[ [obj + 0x" << offset1 << " ] + 0x" << offset2 << " ]";
-            break;
-    }
-    return sstr.str();
-}
-
-int32_t Accessor::getValue(t_item * objectPtr)
-{
-    int32_t offset = this->offset1;
-
-    switch(this->type)
-    {
-    case ACCESSOR_CONSTANT:
-        return this->constant;
-        break;
-    case ACCESSOR_DOUBLE_INDIRECT:
-        objectPtr = (t_item *) p->readDWord((uint32_t)objectPtr + this->offset1);
-        offset = this->offset2;
-        // fallthrough
-    case ACCESSOR_INDIRECT:
-        switch(this->dataWidth)
-        {
-        case Data32:
-            return p->readDWord((uint32_t)objectPtr + offset);
-        case DataSigned16:
-            return (int16_t) p->readWord((uint32_t)objectPtr + offset);
-        case DataUnsigned16:
-            return (uint16_t) p->readWord((uint32_t)objectPtr + offset);
-        default:
-            return -1;
-        }
-        break;
-    default:
-        return -1;
-    }
-}
-
-// FIXME: turn into a proper factory with caching
-Accessor * buildAccessor (OffsetGroup * I, Process * p, const char * name, void * vtable)
-{
-    int32_t offset;
-    if(I->getSafeOffset(name,offset))
-    {
-        return new Accessor( p->readDWord( (uint32_t)vtable + offset ), p);
-    }
-    else
-    {
-        fprintf(stderr,"Missing offset for item accessor \"%s\"\n", name);
-        return new Accessor(-1,0); // dummy accessor. always returns -1
-    }
-}
-
-ItemDesc::ItemDesc(void * VTable, Process *p)
-{
-    OffsetGroup * Items = p->getDescriptor()->getGroup("Items");
-
-    /* 
-     * FIXME: and what about types, different sets of methods depending on class?
-     * what about more complex things than constants and integers?
-     * If this is to be generally useful, it needs much more power.
-     */ 
-    AMainType = buildAccessor(Items, p, "item_type_accessor", VTable);
-    ASubType = buildAccessor(Items, p, "item_subtype_accessor", VTable);
-    ASubIndex = buildAccessor(Items, p, "item_subindex_accessor", VTable);
-    AIndex = buildAccessor(Items, p, "item_index_accessor", VTable);
-    AQuality = buildAccessor(Items, p, "item_quality_accessor", VTable);
-    AWear = buildAccessor(Items, p, "item_wear_accessor", VTable);
-    AQuantity = buildAccessor(Items, p, "item_quantity_accessor", VTable);
-
-    idFieldOffset = Items->getOffset("id");
-
-    this->vtable = VTable;
-    this->p = p;
-    this->className = p->readClassName((void *) VTable).substr(5);
-    this->className.resize(this->className.size()-2);
-
-    this->hasDecoration = false;
-    if(AMainType->isConstant())
-        mainType = this->AMainType->getValue(0);
-    else
-    {
-        cerr << "Bad item main type accessor: " << AMainType->dump() << endl;
-        mainType = 0;
-    }
-}
-
-string ItemDesc::dumpAccessors()
-{
-    std::stringstream outss;
-    outss << "MainType  :" << AMainType->dump() << endl;
-    outss << "ASubType  :" << ASubType->dump() << endl;
-    outss << "ASubIndex :" << ASubIndex->dump() << endl;
-    outss << "AIndex    :" << AIndex->dump() << endl;
-    outss << "AQuality  :" << AQuality->dump() << endl;
-    outss << "AQuantity :" << AQuantity->dump() << endl;
-    outss << "AWear     :" << AWear->dump() << endl;
-    return outss.str();
-}
-
-
-bool ItemDesc::readItem(t_item * itemptr, DFHack::dfh_item &item)
-{
-    item.base = itemptr;
-    item.matdesc.itemType = AMainType->getValue(itemptr);
-    item.matdesc.subType = ASubType->getValue(itemptr);
-    item.matdesc.subIndex = ASubIndex->getValue(itemptr);
-    item.matdesc.index = AIndex->getValue(itemptr);
-    item.quality = AQuality->getValue(itemptr);
-    item.quantity = AQuantity->getValue(itemptr);
-    // FIXME: use templates. seriously.
-    // Note: this accessor returns a 32-bit value with the higher
-    // half sometimes containing garbage, so the cast is essential:
-    item.wear_level = (int16_t)this->AWear->getValue(itemptr);
-    return true;
-}
-
 class Items::Private
 {
     public:
-        DFContextShared *d;
         Process * owner;
-        std::map<int32_t, ItemDesc *> descType;
+        std::map<int32_t, df_item *> idLookupTable;
-        std::map<void *, ItemDesc *> descVTable;
-        std::map<int32_t, t_item *> idLookupTable;
         uint32_t refVectorOffset;
         uint32_t idFieldOffset;
         uint32_t itemVectorAddress;
@@ -519,16 +150,16 @@ bool Items::Finish()
     return true;
 }
 
-bool Items::readItemVector(std::vector<t_item *> &items)
+bool Items::readItemVector(std::vector<df_item *> &items)
 {
-    std::vector <t_item *> *p_items = (std::vector <t_item *> *) d->itemVectorAddress;
+    std::vector <df_item *> *p_items = (std::vector <df_item *> *) d->itemVectorAddress;
 
     d->idLookupTable.clear();
     items.resize(p_items->size());
 
     for (unsigned i = 0; i < p_items->size(); i++)
     {
-        t_item * ptr = p_items->at(i);
+        df_item * ptr = p_items->at(i);
         items[i] = ptr;
         d->idLookupTable[ptr->id] = ptr;
     }
@@ -536,14 +167,14 @@ bool Items::readItemVector(std::vector<t_item *> &items)
     return true;
 }
 
-t_item * Items::findItemByID(int32_t id)
+df_item * Items::findItemByID(int32_t id)
 {
     if (id < 0)
         return 0;
 
     if (d->idLookupTable.empty())
     {
-        std::vector<t_item *> tmp;
+        std::vector<df_item *> tmp;
         readItemVector(tmp);
     }
 
@@ -553,36 +184,23 @@ t_item * Items::findItemByID(int32_t id)
 Items::~Items()
 {
     Finish();
-    std::map<void *, ItemDesc *>::iterator it;
-    it = d->descVTable.begin();
-    while (it != d->descVTable.end())
-    {
-        delete (*it).second;
-        ++it;
-    }
-    d->descType.clear();
-    d->descVTable.clear();
     delete d;
 }
 
-bool Items::readItem(t_item * itembase, DFHack::dfh_item &item)
+bool Items::readItem(df_item * itembase, DFHack::dfh_item &item)
-{
-    std::map<void *, ItemDesc *>::iterator it;
-    Process * p = d->owner;
-    ItemDesc * desc;
-
-    void * vtable = itembase->vptr;
-    it = d->descVTable.find(vtable);
-    if(it == d->descVTable.end())
 {
-        desc = new ItemDesc(vtable, p);
+    if(!itembase)
-        d->descVTable[vtable] = desc;
+        return false;
-        d->descType[desc->mainType] = desc;
+    df_item * itreal = (df_item *) itembase;
-    }
+    item.base = itembase;
-    else
+    item.matdesc.itemType = itreal->getType();
-        desc = it->second;
+    item.matdesc.subType = itreal->getSubtype();
-
+    item.matdesc.index = itreal->getMaterial();
-    return desc->readItem(itembase, item);
+    item.matdesc.subIndex = itreal->getSubMaterial();
+    item.wear_level = itreal->getWear();
+    item.quality = itreal->getQuality();
+    item.quantity = itreal->getStackSize();
+    return true;
 }
 
 int32_t Items::getItemOwnerID(const DFHack::dfh_item &item)
@@ -670,34 +288,9 @@ bool Items::removeItemOwner(dfh_item &item, Creatures *creatures)
 
 std::string Items::getItemClass(const dfh_item & item)
 {
-    return getItemClass(item.matdesc.itemType);
+    t_virtual * virt = (t_virtual *) item.base;
-}
+    return virt->getClassName();
-
+    //return getItemClass(item.matdesc.itemType);
-std::string Items::getItemClass(int32_t index)
-{
-    std::map<int32_t, ItemDesc *>::iterator it;
-    std::string out;
-
-    it = d->descType.find(index);
-    if(it == d->descType.end())
-    {
-        /* these are dummy values for mood decoding */
-        switch(index)
-        {
-            case 0: return "bar";
-            case 1: return "cut gem";
-            case 2: return "block";
-            case 3: return "raw gem";
-            case 4: return "raw stone";
-            case 5: return "log";
-            case 54: return "leather";
-            case 57: return "cloth";
-            case -1: return "probably bone or shell, but I really don't know";
-            default: return "unknown";
-        }
-    }
-    out = it->second->className;
-    return out;
 }
 
 std::string Items::getItemDescription(const dfh_item & item, Materials * Materials)
@@ -725,15 +318,6 @@ std::string Items::getItemDescription(const dfh_item & item, Materials * Materia
             break;
         default: outss << "Crazy quality " << item.quality << " "; break;
     }
-    outss << Materials->getDescription(item.matdesc) << " " << getItemClass(item.matdesc.itemType);
+    outss << Materials->getDescription(item.matdesc) << " " << getItemClass(item);
     return outss.str();
 }
-
-/// dump offsets used by accessors of a valid item to a string
-std::string Items::dumpAccessors(const dfh_item & item)
-{
-    std::map< void *, ItemDesc* >::const_iterator it = d->descVTable.find(item.base->vptr);
-    if(it != d->descVTable.end())
-        return it->second->dumpAccessors();
-    return "crud";
-}

library/modules/Materials.cpp

@@ -396,8 +396,10 @@ std::string Materials::getDescription(const t_material & mat)
             else
                 if(mat.index<0)
                     return "any inorganic";
-                else
+                else if (mat.index < inorganic.size())
                     return this->inorganic[mat.index].id;
+                else
+                    return "INDEX OUT OF BOUNDS!";
         }
         else
         {

plugins/autodump.cpp

@@ -78,7 +78,7 @@ DFhackCExport command_result df_autodump (Core * c, vector <string> & parameters
     DFHack::Items * Items = c->getItems();
     DFHack::Maps *Maps = c->getMaps();
 
-    vector <t_item*> p_items;
+    vector <df_item*> p_items;
     if(!Items->readItemVector(p_items))
     {
         c->con.printerr("Can't access the item vector.\n");
@@ -130,7 +130,7 @@ DFhackCExport command_result df_autodump (Core * c, vector <string> & parameters
     // proceed with the dumpification operation
     for(std::size_t i=0; i< numItems; i++)
     {
-        t_item * itm = p_items[i];
+        df_item * itm = p_items[i];
         DFCoord pos_item(itm->x, itm->y, itm->z);
 
         // keep track how many items are at places. all items.

plugins/cleanowned.cpp

@@ -99,7 +99,7 @@ DFhackCExport command_result df_cleanowned (Core * c, vector <string> & paramete
     ok &= Creatures->Start(num_creatures);
     ok &= Tran->Start();
 
-    vector<t_item *> p_items;
+    vector<df_item *> p_items;
     ok &= Items->readItemVector(p_items);
     if(!ok)
     {
@@ -111,7 +111,7 @@ DFhackCExport command_result df_cleanowned (Core * c, vector <string> & paramete
 
     for (std::size_t i=0; i < p_items.size(); i++)
     {
-        t_item * curItem = p_items[i];
+        df_item * curItem = p_items[i];
         DFHack::dfh_item itm;
         Items->readItem(curItem, itm);
 
@@ -132,7 +132,7 @@ DFhackCExport command_result df_cleanowned (Core * c, vector <string> & paramete
             }
         }
 
-        std::string name = Items->getItemClass(itm.matdesc.itemType);
+        std::string name = Items->getItemClass(itm);
 
         if (itm.base->flags.rotten)
         {

plugins/devel/itemhacks.cpp

@@ -187,7 +187,7 @@ DFhackCExport command_result df_dumpitems (Core * c, vector <string> & parameter
     int32_t x,y,z;
     Gui->getCursorCoords(x,y,z);
 
-    std::vector<t_item *> p_items;
+    std::vector<df_item *> p_items;
     Items->readItemVector(p_items);
     uint32_t size = p_items.size();
 
@@ -231,13 +231,12 @@ DFhackCExport command_result df_dumpitems (Core * c, vector <string> & parameter
 
         c->con.print(
             "%5d: addr:0x%08x %6d %08x (%s) vptr:0x%08x [%d]\n"
-            "       *%d %s - %s\n",
+            "       %d %s\n",
             i, itm.base, itm.base->id, itm.base->flags.whole,
             location,
-            itm.base->vptr,
+            ((t_virtual *)itm.base)->vptr,
             itm.wear_level,
             itm.quantity,
-            Items->getItemClass(itm.matdesc.itemType).c_str(),
             Items->getItemDescription(itm, Materials).c_str()
         );
         chooser->postPrint(&itm);

plugins/devel/kittens.cpp

@@ -109,7 +109,7 @@ DFhackCExport command_result plugin_onupdate ( Core * c )
 DFhackCExport command_result mapitems (Core * c, vector <string> & parameters)
 {
     c->Suspend();
-    vector <t_item *> vec_items;
+    vector <df_item *> vec_items;
     Gui * g = c-> getGui();
     Maps* m = c->getMaps();
     Items* it = c->getItems();
@@ -141,7 +141,7 @@ DFhackCExport command_result mapitems (Core * c, vector <string> & parameters)
             auto iter_it = vec_items.begin();
             while (iter_it != vec_items.end())
             {
-                t_item * itm = *iter_it;
+                df_item * itm = *iter_it;
                 if(itm->x == cx && itm->y == cy && itm->z == cz)
                 {
                     c->con.print("%d\n",itm->id);

tools/examples/dfitemdump.cpp

@@ -94,7 +94,7 @@ int main (int argc, char *argv[])
             itm.base.vtable,
             itm.wear_level,
             itm.quantity,
-            Items->getItemClass(itm.matdesc.itemType).c_str(),
+            Items->getItemClass(itm).c_str(),
             Items->getItemDescription(itm, Materials).c_str()
         );