Make typecasting methods *really* safe and get rid of redundant typeId/Typemask checks, thanks Zor and Machiavelli for help

--HG--
branch : trunk

src/server/game/Entities/Item/Item.cpp

@@ -257,6 +257,16 @@ Item::Item()
     m_paidExtendedCost = 0;
 }
 
+inline Bag* Item::ToBag()
+{
+    return dynamic_cast<Bag*>(this);
+}
+
+inline const Bag* Item::ToBag() const
+{
+    return dynamic_cast<const Bag*>(this);
+}
+
 bool Item::Create(uint32 guidlow, uint32 itemid, Player const* owner)
 {
     Object::_Create(guidlow, 0, HIGHGUID_ITEM);

src/server/game/Entities/Item/Item.h

@@ -347,6 +347,9 @@ class Item : public Object
 
         void BuildUpdate(UpdateDataMapType&);
 
+        Bag* ToBag();
+        const Bag* ToBag() const;
+
     private:
         std::string m_text;
         uint8 m_slot;

src/server/game/Entities/Object/Object.cpp

@@ -1135,6 +1135,46 @@ bool Object::PrintIndexError(uint32 index, bool set) const
     return false;
 }
 
+inline Unit* Object::ToUnit()
+{
+    return dynamic_cast<Unit*>(this);
+}
+
+inline const Unit* Object::ToUnit() const
+{
+    return dynamic_cast<const Unit*>(this);
+}
+
+inline Player* Object::ToPlayer()
+{
+    return dynamic_cast<Player*>(this);
+}
+
+inline const Player* Object::ToPlayer() const
+{
+    return dynamic_cast<const Player*>(this);
+}
+
+inline Creature* Object::ToCreature()
+{
+    return dynamic_cast<Creature*>(this);
+}
+
+inline const Creature* Object::ToCreature() const
+{
+    return dynamic_cast<const Creature*>(this);
+}
+
+inline Item* Object::ToItem()
+{
+    return dynamic_cast<Item*>(this);
+}
+
+inline const Item* Object::ToItem() const
+{
+    return dynamic_cast<const Item*>(this);
+}
+
 bool Position::HasInLine(const Unit * const target, float distance, float width) const
 {
     if (!HasInArc(M_PI, target) || !target->IsWithinDist3d(m_positionX, m_positionY, m_positionZ, distance))

src/server/game/Entities/Object/Object.h

@@ -116,6 +116,7 @@ class CreatureAI;
 class ZoneScript;
 class Unit;
 class Transport;
+class Item;
 
 
 typedef UNORDERED_MAP<Player*, UpdateData> UpdateDataMapType;
@@ -320,10 +321,14 @@ class Object
         // FG: some hacky helpers
         void ForceValuesUpdateAtIndex(uint32);
 
-    Player* ToPlayer(){ if (GetTypeId() == TYPEID_PLAYER)  return reinterpret_cast<Player*>(this); else return NULL;  }
-    const Player* ToPlayer() const { if (GetTypeId() == TYPEID_PLAYER)  return (const Player*)((Player*)this); else return NULL;  }
-    Creature* ToCreature(){ if (GetTypeId() == TYPEID_UNIT) return reinterpret_cast<Creature*>(this); else return NULL; }
-    const Creature* ToCreature() const {if (GetTypeId() == TYPEID_UNIT) return (const Creature*)((Creature*)this); else return NULL; }
+        Unit* ToUnit();
+        const Unit* ToUnit() const;
+        Player* ToPlayer();
+        const Player* ToPlayer() const;
+        Creature* ToCreature();
+        const Creature* ToCreature() const;
+        Item* ToItem();
+        const Item* ToItem() const;
 
     protected:
 

src/server/game/Entities/Unit/Unit.cpp

@@ -16740,6 +16740,36 @@ uint32 Unit::GetRemainingDotDamage(uint64 caster, uint32 spellId, uint8 effectIn
     return amount;
 }
 
+inline Pet* Unit::ToPet()
+{
+    return dynamic_cast<Pet*>(this);
+}
+
+inline const Pet* Unit::ToPet() const
+{
+    return dynamic_cast<const Pet*>(this);
+}
+
+inline Totem* Unit::ToTotem()
+{
+    return dynamic_cast<Totem*>(this);
+}
+
+inline const Totem* Unit::ToTotem() const
+{
+    return dynamic_cast<const Totem*>(this);
+}
+
+inline TempSummon* Unit::ToTempSummon()
+{
+    return dynamic_cast<TempSummon*>(this);
+}
+
+inline const TempSummon* Unit::ToTempSummon() const
+{
+    return dynamic_cast<const TempSummon*>(this);
+}
+
 void CharmInfo::SetIsCommandAttack(bool val)
 {
     m_isCommandAttack = val;

src/server/game/Entities/Unit/Unit.h

@@ -1980,10 +1980,12 @@ class Unit : public WorldObject
         virtual bool isBeingLoaded() const { return false;}
         bool IsDuringRemoveFromWorld() const {return m_duringRemoveFromWorld;}
 
-        Pet* ToPet(){ if (isPet()) return reinterpret_cast<Pet*>(this); else return NULL; }
-        Totem* ToTotem(){ if (isTotem()) return reinterpret_cast<Totem*>(this); else return NULL; }
-        TempSummon* ToTempSummon() { if (isSummon()) return reinterpret_cast<TempSummon*>(this); else return NULL; }
-        const TempSummon* ToTempSummon() const { if (isSummon()) return reinterpret_cast<const TempSummon*>(this); else return NULL; }
+        Pet* ToPet();
+        const Pet* ToPet() const;
+        Totem* ToTotem();
+        const Totem* ToTotem() const;
+        TempSummon* ToTempSummon();
+        const TempSummon* ToTempSummon() const;
 
     protected:
         explicit Unit ();