create thing m_type

src/otclient/core/creature.cpp

@@ -45,8 +45,6 @@ Creature::Creature() : Thing()
 
 void Creature::draw(const Point& p)
 {
-    const ThingType& type = getType();
-
     // TODO: activate on attack, follow, discover how 'attacked' works
     if(m_showSquareColor) {
         g_graphics.bindColor(Outfit::getColor(m_squareColor));
@@ -54,7 +52,7 @@ void Creature::draw(const Point& p)
     }
 
     // Render creature
-    for(m_yPattern = 0; m_yPattern < type.dimensions[ThingType::PatternY]; m_yPattern++) {
+    for(m_yPattern = 0; m_yPattern < m_type->dimensions[ThingType::PatternY]; m_yPattern++) {
 
         // continue if we dont have this addon.
         if(m_yPattern > 0 && !(m_outfit.getAddons() & (1 << (m_yPattern-1))))
@@ -65,7 +63,7 @@ void Creature::draw(const Point& p)
         internalDraw(p + m_walkOffset, 0);
 
         // draw mask if exists
-        if(type.dimensions[ThingType::Layers] > 1) {
+        if(m_type->dimensions[ThingType::Layers] > 1) {
             // switch to blend color mode
             g_graphics.bindBlendFunc(Fw::BlendColorzing);
 
@@ -194,7 +192,7 @@ void Creature::walk(const Position& position, bool inverse)
 
         ItemPtr ground = g_map.getTile(position)->getGround();
         if(ground)
-            groundSpeed = ground->getType().parameters[ThingType::GroundSpeed];
+            groundSpeed = ground->getType()->parameters[ThingType::GroundSpeed];
 
         float walkTime = walkTimeFactor * 1000.0 * (float)groundSpeed / m_speed;
         walkTime = (walkTime == 0) ? 1000 : walkTime;
@@ -208,7 +206,6 @@ void Creature::walk(const Position& position, bool inverse)
 
 void Creature::updateWalk()
 {
-    const ThingType& type = getType();
     if(m_walking) {
         int elapsedTicks = g_clock.ticks() - m_walkStartTicks;
         int totalPixelsWalked = std::min((int)round(elapsedTicks / m_walkTimePerPixel), 32);
@@ -240,8 +237,8 @@ void Creature::updateWalk()
         }
 
         int totalWalkTileTicks = (int)m_walkTimePerPixel*32 * 0.5;
-        if(type.dimensions[ThingType::AnimationPhases] > 0)
-            m_animation = (g_clock.ticks() % totalWalkTileTicks) / (totalWalkTileTicks / (type.dimensions[ThingType::AnimationPhases] - 1)) + 1;
+        if(m_type->dimensions[ThingType::AnimationPhases] > 0)
+            m_animation = (g_clock.ticks() % totalWalkTileTicks) / (totalWalkTileTicks / (m_type->dimensions[ThingType::AnimationPhases] - 1)) + 1;
         else
             m_animation = 0;
         g_dispatcher.scheduleEvent(std::bind(&Creature::updateWalk, asCreature()), m_walkTimePerPixel);
@@ -320,7 +317,13 @@ void Creature::setDirection(Otc::Direction direction)
     m_direction = direction;
 }
 
-const ThingType& Creature::getType()
+void Creature::setOutfit(const Outfit& outfit)
+{
+    m_outfit = outfit;
+    m_type = getType();
+}
+
+ThingType *Creature::getType()
 {
     return g_thingsType.getThingType(m_outfit.getType(), ThingsType::Creature);
 }

src/otclient/core/creature.h

@@ -39,7 +39,7 @@ public:
     void setName(const std::string& name);
     void setHealthPercent(uint8 healthPercent);
     void setDirection(Otc::Direction direction);
-    void setOutfit(const Outfit& outfit) { m_outfit = outfit; }
+    void setOutfit(const Outfit& outfit);
     void setLight(const Light& light) { m_light = light; }
     void setSpeed(uint16 speed) { m_speed = speed; }
     void setSkull(uint8 skull) { m_skull = skull; }
@@ -58,7 +58,7 @@ public:
     uint8 getShield() { return m_shield; }
     uint8 getEmblem() { return m_emblem; }
     bool getImpassable() { return m_impassable; }
-    const ThingType& getType();
+    ThingType *getType();
 
     virtual void walk(const Position& position, bool inverse = true);
     virtual void cancelWalk(Otc::Direction direction);

src/otclient/core/effect.cpp

@@ -53,7 +53,7 @@ void Effect::startAnimation()
     }, TICKS_PER_FRAME * getAnimationPhases());
 }
 
-const ThingType& Effect::getType()
+ThingType *Effect::getType()
 {
     return g_thingsType.getThingType(m_id, ThingsType::Effect);
 }

src/otclient/core/effect.h

@@ -40,7 +40,7 @@ public:
     void startAnimation();
     void updateAnimation();
 
-    const ThingType& getType();
+    ThingType *getType();
 
     EffectPtr asEffect() { return std::static_pointer_cast<Effect>(shared_from_this()); }
 

src/otclient/core/item.cpp

@@ -34,23 +34,19 @@ Item::Item() : Thing()
 
 void Item::draw(const Point& p)
 {
-    const ThingType& type = getType();
+    if(m_type->dimensions[ThingType::AnimationPhases] > 1)
+        m_animation = (g_clock.ticks() % (TICKS_PER_FRAME * m_type->dimensions[ThingType::AnimationPhases])) / TICKS_PER_FRAME;
 
-    if(type.dimensions[ThingType::AnimationPhases] > 1)
-        m_animation = (g_clock.ticks() % (TICKS_PER_FRAME * type.dimensions[ThingType::AnimationPhases])) / TICKS_PER_FRAME;
-
-    for(int b = 0; b < type.dimensions[ThingType::Layers]; b++)
+    for(int b = 0; b < m_type->dimensions[ThingType::Layers]; b++)
         internalDraw(p, b);
 }
 
 void Item::setPosition(const Position& position)
 {
-    const ThingType& type = getType();
-
-    if(type.properties[ThingType::IsGround]) {
-        m_xPattern = position.x % type.dimensions[ThingType::PatternX];
-        m_yPattern = position.y % type.dimensions[ThingType::PatternY];
-        m_zPattern = position.z % type.dimensions[ThingType::PatternZ];
+    if(m_type->properties[ThingType::IsGround]) {
+        m_xPattern = position.x % m_type->dimensions[ThingType::PatternX];
+        m_yPattern = position.y % m_type->dimensions[ThingType::PatternY];
+        m_zPattern = position.z % m_type->dimensions[ThingType::PatternZ];
     }
 
     Thing::setPosition(position);
@@ -58,9 +54,7 @@ void Item::setPosition(const Position& position)
 
 void Item::setData(int data)
 {
-    const ThingType& type = getType();
-
-    if(type.properties[ThingType::IsStackable] && type.dimensions[ThingType::PatternX] == 4 && type.dimensions[ThingType::PatternY] == 2) {
+    if(m_type->properties[ThingType::IsStackable] && m_type->dimensions[ThingType::PatternX] == 4 && m_type->dimensions[ThingType::PatternY] == 2) {
         if(data < 5) {
             m_xPattern = data-1;
             m_yPattern = 0;
@@ -82,15 +76,15 @@ void Item::setData(int data)
             m_yPattern = 1;
         }
     }
-    else if(type.properties[ThingType::IsHangable]) {
-        if(type.properties[ThingType::HookSouth]) {
-            m_xPattern = type.dimensions[ThingType::PatternX] >= 2 ? 1 : 0;
+    else if(m_type->properties[ThingType::IsHangable]) {
+        if(m_type->properties[ThingType::HookSouth]) {
+            m_xPattern = m_type->dimensions[ThingType::PatternX] >= 2 ? 1 : 0;
         }
-        else if(type.properties[ThingType::HookEast]) {
-            m_xPattern = type.dimensions[ThingType::PatternX] >= 3 ? 2 : 0;
+        else if(m_type->properties[ThingType::HookEast]) {
+            m_xPattern = m_type->dimensions[ThingType::PatternX] >= 3 ? 2 : 0;
         }
     }
-    else if(type.properties[ThingType::IsFluid] || type.properties[ThingType::IsFluidContainer]) {
+    else if(m_type->properties[ThingType::IsFluid] || m_type->properties[ThingType::IsFluidContainer]) {
         int color = 0;
         // TODO: find out what the heck does it mean 4, 7, 12, 13, 14, 16, 17. options are already there
         switch(data) {
@@ -153,14 +147,14 @@ void Item::setData(int data)
             break;
         }
 
-        m_xPattern = (color % 4) % type.dimensions[ThingType::PatternX];
-        m_yPattern = (color / 4) % type.dimensions[ThingType::PatternY];
+        m_xPattern = (color % 4) % m_type->dimensions[ThingType::PatternX];
+        m_yPattern = (color / 4) % m_type->dimensions[ThingType::PatternY];
     }
 
     m_data = data;
 }
 
-const ThingType& Item::getType()
+ThingType *Item::getType()
 {
     return g_thingsType.getThingType(m_id, ThingsType::Item);
 }

src/otclient/core/item.h

@@ -41,7 +41,7 @@ public:
     void setData(int data);
 
     int getData() { return m_data; }
-    const ThingType& getType();
+    ThingType *getType();
 
     ItemPtr asItem() { return std::static_pointer_cast<Item>(shared_from_this()); }
 

src/otclient/core/map.cpp

@@ -134,8 +134,8 @@ int Map::getFirstVisibleFloor()
                 while(upperPos.z >= firstFloor) {
                     if(TilePtr tile = m_tiles[upperPos]) {
                         if(ThingPtr firstThing = tile->getThing(0)) {
-                            const ThingType type = firstThing->getType();
-                            if((type.properties[ThingType::IsGround] || type.properties[ThingType::IsOnBottom]) && !type.properties[ThingType::DontHide]) {
+                            ThingType *type = firstThing->getType();
+                            if((type->properties[ThingType::IsGround] || type->properties[ThingType::IsOnBottom]) && !type->properties[ThingType::DontHide]) {
                                 firstFloor = upperPos.z + 1;
                                 break;
                             }
@@ -143,8 +143,8 @@ int Map::getFirstVisibleFloor()
                     }
                     if(TilePtr tile = m_tiles[perspectivePos]) {
                         if(ThingPtr firstThing = tile->getThing(0)) {
-                            const ThingType type = firstThing->getType();
-                            if((type.properties[ThingType::IsGround] || type.properties[ThingType::IsOnBottom]) && !type.properties[ThingType::DontHide]) {
+                            ThingType *type = firstThing->getType();
+                            if((type->properties[ThingType::IsGround] || type->properties[ThingType::IsOnBottom]) && !type->properties[ThingType::DontHide]) {
                                 firstFloor = perspectivePos.z + 1;
                                 break;
                             }

src/otclient/core/missile.cpp

@@ -117,7 +117,7 @@ void Missile::setPath(const Position& fromPosition, const Position& toPosition)
     }, m_duration);
 }
 
-const ThingType& Missile::getType()
+ThingType *Missile::getType()
 {
     return g_thingsType.getThingType(m_id, ThingsType::Missile);
 }

src/otclient/core/missile.h

@@ -41,7 +41,7 @@ public:
 
     void setPath(const Position& fromPosition, const Position& toPosition);
 
-    const ThingType& getType();
+    ThingType *getType();
 
     MissilePtr asMissile() { return std::static_pointer_cast<Missile>(shared_from_this()); }
 

src/otclient/core/outfit.cpp

@@ -22,6 +22,11 @@
 
 #include "outfit.h"
 
+Outfit::Outfit()
+{
+    m_type = 0;
+}
+
 Color Outfit::getColor(int color)
 {
     if(color >= HSI_H_STEPS * HSI_SI_VALUES)
@@ -78,37 +83,37 @@ Color Outfit::getColor(int color)
         return Color(loc7, loc7, loc7);
     }
 
-    float loc4 = 0, loc5 = 0, loc6 = 0;
+    float red = 0, green = 0, blue = 0;
 
     if(loc1 < 1.0/6.0) {
-        loc4 = loc3;
-        loc6 = loc3 * (1 - loc2);
-        loc5 = loc6 + (loc3 - loc6) * 6 * loc1;
+        red = loc3;
+        blue = loc3 * (1 - loc2);
+        green = blue + (loc3 - blue) * 6 * loc1;
     }
     else if (loc1 < 2.0/6.0) {
-        loc5 = loc3;
-        loc6 = loc3 * (1 - loc2);
-        loc4 = loc5 - (loc3 - loc6) * (6 * loc1 - 1);
+        green = loc3;
+        blue = loc3 * (1 - loc2);
+        red = green - (loc3 - blue) * (6 * loc1 - 1);
     }
     else if(loc1 < 3.0/6.0) {
-        loc5 = loc3;
-        loc4 = loc3 * (1 - loc2);
-        loc6 = loc4 + (loc3 - loc4) * (6 * loc1 - 2);
+        green = loc3;
+        red = loc3 * (1 - loc2);
+        blue = red + (loc3 - red) * (6 * loc1 - 2);
     }
     else if (loc1 < 4.0/6.0) {
-        loc6 = loc3;
-        loc4 = loc3 * (1 - loc2);
-        loc5 = loc6 - (loc3 - loc4) * (6 * loc1 - 3);
+        blue = loc3;
+        red = loc3 * (1 - loc2);
+        green = blue - (loc3 - red) * (6 * loc1 - 3);
     }
     else if (loc1 < 5.0/6.0) {
-        loc6 = loc3;
-        loc5 = loc3 * (1 - loc2);
-        loc4 = loc5 + (loc3 - loc5) * (6 * loc1 - 4);
+        blue = loc3;
+        green = loc3 * (1 - loc2);
+        red = green + (loc3 - green) * (6 * loc1 - 4);
     }
     else {
-        loc4 = loc3;
-        loc5 = loc3 * (1 - loc2);
-        loc6 = loc4 - (loc3 - loc5) * (6 * loc1 - 5);
+        red = loc3;
+        green = loc3 * (1 - loc2);
+        blue = red - (loc3 - green) * (6 * loc1 - 5);
     }
-    return Color(int(loc4 * 255), int(loc5 * 255), int(loc6 * 255));
+    return Color(int(red * 255), int(green * 255), int(blue * 255));
 }

src/otclient/core/outfit.h

@@ -33,6 +33,8 @@ class Outfit
     };
 
 public:
+    Outfit();
+
     static Color getColor(int color);
 
     void setType(int type) { m_type = type; }

src/otclient/core/thing.cpp

@@ -34,42 +34,45 @@ Thing::Thing() : m_id(0)
 
 void Thing::internalDraw(const Point& p, int layers, Otc::SpriteMask mask)
 {
-    const ThingType& type = getType();
+    for(int yi = 0; yi < m_type->dimensions[ThingType::Height]; yi++) {
+        for(int xi = 0; xi < m_type->dimensions[ThingType::Width]; xi++) {
+            int sprIndex = ((((((m_animation % m_type->dimensions[ThingType::AnimationPhases])
+                            * m_type->dimensions[ThingType::PatternZ] + m_zPattern)
+                            * m_type->dimensions[ThingType::PatternY] + m_yPattern)
+                            * m_type->dimensions[ThingType::PatternX] + m_xPattern)
+                            * m_type->dimensions[ThingType::Layers] + layers)
+                            * m_type->dimensions[ThingType::Height] + yi)
+                            * m_type->dimensions[ThingType::Width] + xi;
 
-    for(int yi = 0; yi < type.dimensions[ThingType::Height]; yi++) {
-        for(int xi = 0; xi < type.dimensions[ThingType::Width]; xi++) {
-            int sprIndex = ((((((m_animation % type.dimensions[ThingType::AnimationPhases])
-                            * type.dimensions[ThingType::PatternZ] + m_zPattern)
-                            * type.dimensions[ThingType::PatternY] + m_yPattern)
-                            * type.dimensions[ThingType::PatternX] + m_xPattern)
-                            * type.dimensions[ThingType::Layers] + layers)
-                            * type.dimensions[ThingType::Height] + yi)
-                            * type.dimensions[ThingType::Width] + xi;
-
-            int spriteId = type.sprites[sprIndex];
+            int spriteId = m_type->sprites[sprIndex];
             if(!spriteId)
                 continue;
 
             TexturePtr spriteTex = g_sprites.getSpriteTexture(spriteId, mask);
 
-            Rect drawRect((p.x - xi*32) - type.parameters[ThingType::DisplacementX],
-                          (p.y - yi*32) - type.parameters[ThingType::DisplacementY],
+            Rect drawRect((p.x - xi*32) - m_type->parameters[ThingType::DisplacementX],
+                          (p.y - yi*32) - m_type->parameters[ThingType::DisplacementY],
                           32, 32);
             g_graphics.drawTexturedRect(drawRect, spriteTex);
         }
     }
 }
 
+void Thing::setId(uint32 id)
+{
+    m_id = id;
+    m_type = getType();
+}
+
 int Thing::getStackPriority()
 {
-    const ThingType& type = getType();
-    if(type.properties[ThingType::IsGround])
+    if(m_type->properties[ThingType::IsGround])
         return 0;
-    else if(type.properties[ThingType::IsGroundBorder])
+    else if(m_type->properties[ThingType::IsGroundBorder])
         return 1;
-    else if(type.properties[ThingType::IsOnBottom])
+    else if(m_type->properties[ThingType::IsOnBottom])
         return 2;
-    else if(type.properties[ThingType::IsOnTop])
+    else if(m_type->properties[ThingType::IsOnTop])
         return 3;
     else if(asCreature())
         return 4;

src/otclient/core/thing.h

@@ -41,14 +41,14 @@ public:
 
     virtual void draw(const Point& p) = 0;
 
-    void setId(uint32 id) { m_id = id; }
+    void setId(uint32 id);
     virtual void setPosition(const Position& position) { m_position = position; }
 
     uint32 getId() const { return m_id; }
     Position getPosition() const { return m_position; }
     int getStackPriority();
-    virtual const ThingType& getType() = 0;
-    int getAnimationPhases() { return getType().dimensions[ThingType::AnimationPhases]; }
+    virtual ThingType *getType() = 0;
+    int getAnimationPhases() { return m_type->dimensions[ThingType::AnimationPhases]; }
 
     void setXPattern(int xPattern) { m_xPattern = xPattern; }
     void setYPattern(int yPattern) { m_yPattern = yPattern; }
@@ -67,6 +67,7 @@ protected:
 
     uint32 m_id;
     Position m_position;
+    ThingType *m_type;
 
     int m_xPattern, m_yPattern, m_zPattern, m_animation;
 };

src/otclient/core/thingstype.cpp

@@ -111,7 +111,7 @@ void ThingsType::parseThingType(std::stringstream& fin, ThingType& thingType)
         thingType.sprites[i] = Fw::getU16(fin);
 }
 
-ThingType& ThingsType::getThingType(uint16 id, Categories category)
+ThingType *ThingsType::getThingType(uint16 id, Categories category)
 {
     if(category == Item)
         id -= 100;
@@ -122,8 +122,8 @@ ThingType& ThingsType::getThingType(uint16 id, Categories category)
     if(id >= m_things[category].size()) {
         //logTraceErrorOnce("got an invalid type");
         static ThingType emptyType;
-        return emptyType;
+        return &emptyType;
     }
 
-    return m_things[category][id];
+    return &m_things[category][id];
 }

src/otclient/core/thingstype.h

@@ -43,7 +43,7 @@ public:
 
     void parseThingType(std::stringstream& fin, ThingType& thingType);
 
-    ThingType& getThingType(uint16 id, Categories category);
+    ThingType *getThingType(uint16 id, Categories category);
 
     uint32 getSignature() { return m_signature; }
 

src/otclient/core/tile.cpp

@@ -42,11 +42,11 @@ void Tile::draw(const Point& p)
 
     // first bottom items
     for(const ThingPtr& thing : m_things) {
-        const ThingType& type = thing->getType();
-        if(!type.properties[ThingType::IsGround] && !type.properties[ThingType::IsGroundBorder] && !type.properties[ThingType::IsOnBottom])
+        ThingType *type = thing->getType();
+        if(!type->properties[ThingType::IsGround] && !type->properties[ThingType::IsGroundBorder] && !type->properties[ThingType::IsOnBottom])
             break;
         thing->draw(p - m_drawElevation);
-        m_drawElevation += type.parameters[ThingType::Elevation];
+        m_drawElevation += type->parameters[ThingType::Elevation];
         if(m_drawElevation > MAX_DRAW_ELEVATION)
             m_drawElevation = MAX_DRAW_ELEVATION;
     }
@@ -54,11 +54,11 @@ void Tile::draw(const Point& p)
     // now common items
     for(auto it = m_things.rbegin(); it != m_things.rend(); ++it) {
         const ThingPtr& thing = *it;
-        const ThingType& type = thing->getType();
-        if(thing->asCreature() || type.properties[ThingType::IsOnTop] || type.properties[ThingType::IsOnBottom] || type.properties[ThingType::IsGroundBorder] || type.properties[ThingType::IsGround])
+        ThingType *type = thing->getType();
+        if(thing->asCreature() || type->properties[ThingType::IsOnTop] || type->properties[ThingType::IsOnBottom] || type->properties[ThingType::IsGroundBorder] || type->properties[ThingType::IsGround])
             break;
         thing->draw(p - m_drawElevation);
-        m_drawElevation += type.parameters[ThingType::Elevation];
+        m_drawElevation += type->parameters[ThingType::Elevation];
         if(m_drawElevation > MAX_DRAW_ELEVATION)
             m_drawElevation = MAX_DRAW_ELEVATION;
     }
@@ -68,8 +68,8 @@ void Tile::draw(const Point& p)
     for(int xi = -1; xi <= 1; ++xi) {
         for(int yi = -1; yi <= 1; ++yi) {
             for(CreaturePtr creature : g_map.getTile(m_position + Position(xi, yi, 0))->getCreatures()) {
-                const ThingType& type = creature->getType();
-                Rect creatureRect(p.x + xi*32 + creature->getWalkOffset().x - type.parameters[ThingType::DisplacementX], p.y + yi*32 + creature->getWalkOffset().y - type.parameters[ThingType::DisplacementY], 32, 32);
+                ThingType *type = creature->getType();
+                Rect creatureRect(p.x + xi*32 + creature->getWalkOffset().x - type->parameters[ThingType::DisplacementX], p.y + yi*32 + creature->getWalkOffset().y - type->parameters[ThingType::DisplacementY], 32, 32);
                 Rect thisTileRect(p.x, p.y, 32, 32);
 
                 // only render creatures where bottom right is inside our rect
@@ -86,8 +86,8 @@ void Tile::draw(const Point& p)
 
     // top items
     for(const ThingPtr& thing : m_things) {
-        const ThingType& type = thing->getType();
-        if(type.properties[ThingType::IsOnTop])
+        ThingType *type = thing->getType();
+        if(type->properties[ThingType::IsOnTop])
             thing->draw(p);
     }
 }
@@ -179,8 +179,8 @@ ItemPtr Tile::getGround()
     ThingPtr firstObject = getThing(0);
     if(!firstObject)
         return nullptr;
-    const ThingType& type = firstObject->getType();
-    if(type.properties[ThingType::IsGround])
+    ThingType *type = firstObject->getType();
+    if(type->properties[ThingType::IsGround])
         return firstObject->asItem();
     return nullptr;
 }
@@ -191,8 +191,8 @@ bool Tile::isWalkable()
         return false;
 
     for(const ThingPtr& thing : m_things) {
-        const ThingType& type = thing->getType();
-        if(type.properties[ThingType::NotWalkable])
+        ThingType *type = thing->getType();
+        if(type->properties[ThingType::NotWalkable])
             return false;
     }
     return true;
@@ -203,8 +203,8 @@ bool Tile::isFullGround()
     ThingPtr ground = getThing(0);
     if(!ground)
         return false;
-    const ThingType& type = ground->getType();
-    if(type.properties[ThingType::IsGround] && type.properties[ThingType::IsFullGround])
+    ThingType *type = ground->getType();
+    if(type->properties[ThingType::IsGround] && type->properties[ThingType::IsFullGround])
         return true;
     return false;
 }
@@ -213,8 +213,8 @@ bool Tile::isFullyOpaque()
 {
     ThingPtr firstObject = getThing(0);
     if(firstObject) {
-        const ThingType& type = firstObject->getType();
-        if(type.properties[ThingType::IsFullGround])
+        ThingType *type = firstObject->getType();
+        if(type->properties[ThingType::IsFullGround])
             return true;
     }
     return false;
@@ -223,8 +223,8 @@ bool Tile::isFullyOpaque()
 bool Tile::isLookPossible()
 {
     for(const ThingPtr& thing : m_things) {
-        const ThingType& type = thing->getType();
-        if(type.properties[ThingType::BlockProjectile])
+        ThingType *type = thing->getType();
+        if(type->properties[ThingType::BlockProjectile])
             return false;
     }
     return true;

src/otclient/net/protocolgameparse.cpp

@@ -1110,8 +1110,8 @@ ItemPtr ProtocolGame::internalGetItem(InputMessage& msg, uint16 id)
         id = msg.getU16();
     item->setId(id);
 
-    const ThingType& itemType = item->getType();
-    if(itemType.properties[ThingType::IsStackable] || itemType.properties[ThingType::IsFluidContainer] || itemType.properties[ThingType::IsFluid])
+    ThingType *itemType = item->getType();
+    if(itemType->properties[ThingType::IsStackable] || itemType->properties[ThingType::IsFluidContainer] || itemType->properties[ThingType::IsFluid])
         item->setData(msg.getU8());
 
     return item;