src/game/Object.h

   1 /*
   2  * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 #ifndef _OBJECT_H
  20 #define _OBJECT_H
  21
  22 #include "Common.h"
  23 #include "ByteBuffer.h"
  24 #include "UpdateFields.h"
  25 #include "UpdateData.h"
  26 #include "GameSystem/GridReference.h"
  27 #include "ObjectDefines.h"
  28
  29 #include <set>
  30 #include <string>
  31
  32 #define CONTACT_DISTANCE            0.5f
  33 #define INTERACTION_DISTANCE        5.0f
  34 #define ATTACK_DISTANCE             5.0f
  35 #define MAX_VISIBILITY_DISTANCE  (5*SIZE_OF_GRID_CELL/2.0f) // max distance for visible object show, limited by active zone for player based at cell size (active zone = 5x5 cells)
  36 #define DEFAULT_VISIBILITY_DISTANCE (SIZE_OF_GRID_CELL)     // default visible distance
  37
  38 #define DEFAULT_WORLD_OBJECT_SIZE   0.388999998569489f      // player size, also currently used (correctly?) for any non Unit world objects
  39
  40 enum TypeMask
  41 {
  42     TYPEMASK_OBJECT         = 0x0001,
  43     TYPEMASK_ITEM           = 0x0002,
  44     TYPEMASK_CONTAINER      = 0x0006,                       // TYPEMASK_ITEM | 0x0004
  45     TYPEMASK_UNIT           = 0x0008,
  46     TYPEMASK_PLAYER         = 0x0010,
  47     TYPEMASK_GAMEOBJECT     = 0x0020,
  48     TYPEMASK_DYNAMICOBJECT  = 0x0040,
  49     TYPEMASK_CORPSE         = 0x0080
  50 };
  51
  52 enum TypeID
  53 {
  54     TYPEID_OBJECT        = 0,
  55     TYPEID_ITEM          = 1,
  56     TYPEID_CONTAINER     = 2,
  57     TYPEID_UNIT          = 3,
  58     TYPEID_PLAYER        = 4,
  59     TYPEID_GAMEOBJECT    = 5,
  60     TYPEID_DYNAMICOBJECT = 6,
  61     TYPEID_CORPSE        = 7
  62 };
  63
  64 #define NUM_CLIENT_OBJECT_TYPES             8
  65
  66 uint32 GuidHigh2TypeId(uint32 guid_hi);
  67
  68 enum TempSummonType
  69 {
  70     TEMPSUMMON_TIMED_OR_DEAD_DESPAWN       = 1,             // despawns after a specified time OR when the creature disappears
  71     TEMPSUMMON_TIMED_OR_CORPSE_DESPAWN     = 2,             // despawns after a specified time OR when the creature dies
  72     TEMPSUMMON_TIMED_DESPAWN               = 3,             // despawns after a specified time
  73     TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT = 4,             // despawns after a specified time after the creature is out of combat
  74     TEMPSUMMON_CORPSE_DESPAWN              = 5,             // despawns instantly after death
  75     TEMPSUMMON_CORPSE_TIMED_DESPAWN        = 6,             // despawns after a specified time after death
  76     TEMPSUMMON_DEAD_DESPAWN                = 7,             // despawns when the creature disappears
  77     TEMPSUMMON_MANUAL_DESPAWN              = 8              // despawns when UnSummon() is called
  78 };
  79
  80 enum PhaseMasks
  81 {
  82     PHASEMASK_NORMAL   = 0x00000001,
  83     PHASEMASK_ANYWHERE = 0xFFFFFFFF
  84 };
  85
  86 class WorldPacket;
  87 class UpdateData;
  88 class ByteBuffer;
  89 class WorldSession;
  90 class Creature;
  91 class Player;
  92 class Map;
  93 class UpdateMask;
  94 class InstanceData;
  95
  96 typedef UNORDERED_MAP<Player*, UpdateData> UpdateDataMapType;
  97
  98 struct WorldLocation
  99 {
 100     uint32 mapid;
 101     float x;
 102     float y;
 103     float z;
 104     float o;
 105     explicit WorldLocation(uint32 _mapid = 0, float _x = 0, float _y = 0, float _z = 0, float _o = 0)
 106         : mapid(_mapid), x(_x), y(_y), z(_z), o(_o) {}
 107     WorldLocation(WorldLocation const &loc)
 108         : mapid(loc.mapid), x(loc.x), y(loc.y), z(loc.z), o(loc.o) {}
 109 };
 110
 111 class MANGOS_DLL_SPEC Object
 112 {
 113     public:
 114         virtual ~Object ( );
 115
 116         const bool& IsInWorld() const { return m_inWorld; }
 117         virtual void AddToWorld()
 118         {
 119             if(m_inWorld)
 120                 return;
 121
 122             m_inWorld = true;
 123
 124             // synchronize values mirror with values array (changes will send in updatecreate opcode any way
 125             ClearUpdateMask(true);
 126         }
 127         virtual void RemoveFromWorld()
 128         {
 129             // if we remove from world then sending changes not required
 130             if(m_uint32Values)
 131                 ClearUpdateMask(true);
 132             m_inWorld = false;
 133         }
 134
 135         const uint64& GetGUID() const { return GetUInt64Value(0); }
 136         uint32 GetGUIDLow() const { return GUID_LOPART(GetUInt64Value(0)); }
 137         uint32 GetGUIDMid() const { return GUID_ENPART(GetUInt64Value(0)); }
 138         uint32 GetGUIDHigh() const { return GUID_HIPART(GetUInt64Value(0)); }
 139         const ByteBuffer& GetPackGUID() const { return m_PackGUID; }
 140         uint32 GetEntry() const { return GetUInt32Value(OBJECT_FIELD_ENTRY); }
 141         void SetEntry(uint32 entry) { SetUInt32Value(OBJECT_FIELD_ENTRY, entry); }
 142
 143         uint8 GetTypeId() const { return m_objectTypeId; }
 144         bool isType(uint16 mask) const { return (mask & m_objectType); }
 145
 146         virtual void BuildCreateUpdateBlockForPlayer( UpdateData *data, Player *target ) const;
 147         void SendUpdateToPlayer(Player* player);
 148
 149         void BuildValuesUpdateBlockForPlayer( UpdateData *data, Player *target ) const;
 150         void BuildOutOfRangeUpdateBlock( UpdateData *data ) const;
 151         void BuildMovementUpdateBlock( UpdateData * data, uint32 flags = 0 ) const;
 152         void BuildUpdate(UpdateDataMapType &);
 153
 154         virtual void DestroyForPlayer( Player *target ) const;
 155
 156         const int32& GetInt32Value( uint16 index ) const
 157         {
 158             ASSERT( index < m_valuesCount || PrintIndexError( index , false) );
 159             return m_int32Values[ index ];
 160         }
 161
 162         const uint32& GetUInt32Value( uint16 index ) const
 163         {
 164             ASSERT( index < m_valuesCount || PrintIndexError( index , false) );
 165             return m_uint32Values[ index ];
 166         }
 167
 168         const uint64& GetUInt64Value( uint16 index ) const
 169         {
 170             ASSERT( index + 1 < m_valuesCount || PrintIndexError( index , false) );
 171             return *((uint64*)&(m_uint32Values[ index ]));
 172         }
 173
 174         const float& GetFloatValue( uint16 index ) const
 175         {
 176             ASSERT( index < m_valuesCount || PrintIndexError( index , false ) );
 177             return m_floatValues[ index ];
 178         }
 179
 180         uint8 GetByteValue( uint16 index, uint8 offset) const
 181         {
 182             ASSERT( index < m_valuesCount || PrintIndexError( index , false) );
 183             ASSERT( offset < 4 );
 184             return *(((uint8*)&m_uint32Values[ index ])+offset);
 185         }
 186
 187         uint16 GetUInt16Value( uint16 index, uint8 offset) const
 188         {
 189             ASSERT( index < m_valuesCount || PrintIndexError( index , false) );
 190             ASSERT( offset < 2 );
 191             return *(((uint16*)&m_uint32Values[ index ])+offset);
 192         }
 193
 194         void SetInt32Value(  uint16 index,        int32  value );
 195         void SetUInt32Value( uint16 index,       uint32  value );
 196         void SetUInt64Value( uint16 index, const uint64 &value );
 197         void SetFloatValue(  uint16 index,       float   value );
 198         void SetByteValue(   uint16 index, uint8 offset, uint8 value );
 199         void SetUInt16Value( uint16 index, uint8 offset, uint16 value );
 200         void SetInt16Value(  uint16 index, uint8 offset, int16 value ) { SetUInt16Value(index,offset,(uint16)value); }
 201         void SetStatFloatValue( uint16 index, float value);
 202         void SetStatInt32Value( uint16 index, int32 value);
 203
 204         void ApplyModUInt32Value(uint16 index, int32 val, bool apply);
 205         void ApplyModInt32Value(uint16 index, int32 val, bool apply);
 206         void ApplyModUInt64Value(uint16 index, int32 val, bool apply);
 207         void ApplyModPositiveFloatValue( uint16 index, float val, bool apply);
 208         void ApplyModSignedFloatValue( uint16 index, float val, bool apply);
 209
 210         void ApplyPercentModFloatValue(uint16 index, float val, bool apply)
 211         {
 212             val = val != -100.0f ? val : -99.9f ;
 213             SetFloatValue(index, GetFloatValue(index) * (apply?(100.0f+val)/100.0f : 100.0f / (100.0f+val)) );
 214         }
 215
 216         void SetFlag( uint16 index, uint32 newFlag );
 217         void RemoveFlag( uint16 index, uint32 oldFlag );
 218
 219         void ToggleFlag( uint16 index, uint32 flag)
 220         {
 221             if(HasFlag(index, flag))
 222                 RemoveFlag(index, flag);
 223             else
 224                 SetFlag(index, flag);
 225         }
 226
 227         bool HasFlag( uint16 index, uint32 flag ) const
 228         {
 229             ASSERT( index < m_valuesCount || PrintIndexError( index , false ) );
 230             return (m_uint32Values[ index ] & flag) != 0;
 231         }
 232
 233         void SetByteFlag( uint16 index, uint8 offset, uint8 newFlag );
 234         void RemoveByteFlag( uint16 index, uint8 offset, uint8 newFlag );
 235
 236         void ToggleFlag( uint16 index, uint8 offset, uint8 flag )
 237         {
 238             if(HasByteFlag(index, offset, flag))
 239                 RemoveByteFlag(index, offset, flag);
 240             else
 241                 SetByteFlag(index, offset, flag);
 242         }
 243
 244         bool HasByteFlag( uint16 index, uint8 offset, uint8 flag ) const
 245         {
 246             ASSERT( index < m_valuesCount || PrintIndexError( index , false ) );
 247             ASSERT( offset < 4 );
 248             return (((uint8*)&m_uint32Values[index])[offset] & flag) != 0;
 249         }
 250
 251         void ApplyModFlag( uint16 index, uint32 flag, bool apply)
 252         {
 253             if(apply) SetFlag(index,flag); else RemoveFlag(index,flag);
 254         }
 255
 256         void SetFlag64( uint16 index, uint64 newFlag )
 257         {
 258             uint64 oldval = GetUInt64Value(index);
 259             uint64 newval = oldval | newFlag;
 260             SetUInt64Value(index,newval);
 261         }
 262
 263         void RemoveFlag64( uint16 index, uint64 oldFlag )
 264         {
 265             uint64 oldval = GetUInt64Value(index);
 266             uint64 newval = oldval & ~oldFlag;
 267             SetUInt64Value(index,newval);
 268         }
 269
 270         void ToggleFlag64( uint16 index, uint64 flag)
 271         {
 272             if(HasFlag64(index, flag))
 273                 RemoveFlag64(index, flag);
 274             else
 275                 SetFlag64(index, flag);
 276         }
 277
 278         bool HasFlag64( uint16 index, uint64 flag ) const
 279         {
 280             ASSERT( index < m_valuesCount || PrintIndexError( index , false ) );
 281             return (GetUInt64Value( index ) & flag) != 0;
 282         }
 283
 284         void ApplyModFlag64( uint16 index, uint64 flag, bool apply)
 285         {
 286             if(apply) SetFlag64(index,flag); else RemoveFlag64(index,flag);
 287         }
 288
 289         void ClearUpdateMask(bool remove);
 290         void SendUpdateObjectToAllExcept(Player* exceptPlayer);
 291
 292         bool LoadValues(const char* data);
 293
 294         uint16 GetValuesCount() const { return m_valuesCount; }
 295
 296         void InitValues() { _InitValues(); }
 297
 298         virtual bool hasQuest(uint32 /* quest_id */) const { return false; }
 299         virtual bool hasInvolvedQuest(uint32 /* quest_id */) const { return false; }
 300     protected:
 301
 302         Object ( );
 303
 304         void _InitValues();
 305         void _Create (uint32 guidlow, uint32 entry, HighGuid guidhigh);
 306
 307         virtual void _SetUpdateBits(UpdateMask *updateMask, Player *target) const;
 308
 309         virtual void _SetCreateBits(UpdateMask *updateMask, Player *target) const;
 310         void _BuildMovementUpdate(ByteBuffer * data, uint8 flags, uint32 flags2 ) const;
 311         void _BuildValuesUpdate(uint8 updatetype, ByteBuffer *data, UpdateMask *updateMask, Player *target ) const;
 312
 313         uint16 m_objectType;
 314
 315         uint8 m_objectTypeId;
 316         uint8 m_updateFlag;
 317
 318         union
 319         {
 320             int32  *m_int32Values;
 321             uint32 *m_uint32Values;
 322             float  *m_floatValues;
 323         };
 324
 325         uint32 *m_uint32Values_mirror;
 326
 327         uint16 m_valuesCount;
 328
 329         bool m_objectUpdated;
 330
 331     private:
 332         bool m_inWorld;
 333
 334         ByteBuffer m_PackGUID;
 335
 336         // for output helpfull error messages from asserts
 337         bool PrintIndexError(uint32 index, bool set) const;
 338         Object(const Object&);                              // prevent generation copy constructor
 339         Object& operator=(Object const&);                   // prevent generation assigment operator
 340 };
 341
 342 class MANGOS_DLL_SPEC WorldObject : public Object
 343 {
 344     public:
 345         virtual ~WorldObject ( ) {}
 346
 347         virtual void Update ( uint32 /*time_diff*/ ) { }
 348
 349         void _Create( uint32 guidlow, HighGuid guidhigh, uint32 mapid, uint32 phaseMask);
 350
 351         void Relocate(float x, float y, float z, float orientation)
 352         {
 353             m_positionX = x;
 354             m_positionY = y;
 355             m_positionZ = z;
 356             m_orientation = orientation;
 357         }
 358
 359         void Relocate(float x, float y, float z)
 360         {
 361             m_positionX = x;
 362             m_positionY = y;
 363             m_positionZ = z;
 364         }
 365
 366         void Relocate(WorldLocation const & loc)
 367         {
 368             SetMapId(loc.mapid);
 369             Relocate(loc.x, loc.y, loc.z, loc.o);
 370         }
 371
 372         void SetOrientation(float orientation) { m_orientation = orientation; }
 373
 374         float GetPositionX( ) const { return m_positionX; }
 375         float GetPositionY( ) const { return m_positionY; }
 376         float GetPositionZ( ) const { return m_positionZ; }
 377         void GetPosition( float &x, float &y, float &z ) const
 378             { x = m_positionX; y = m_positionY; z = m_positionZ; }
 379         void GetPosition( WorldLocation &loc ) const
 380             { loc.mapid = GetMapId(); GetPosition(loc.x, loc.y, loc.z); loc.o = GetOrientation(); }
 381         float GetOrientation( ) const { return m_orientation; }
 382         void GetNearPoint2D( float &x, float &y, float distance, float absAngle) const;
 383         void GetNearPoint( WorldObject const* searcher, float &x, float &y, float &z, float searcher_size, float distance2d,float absAngle) const;
 384         void GetClosePoint(float &x, float &y, float &z, float size, float distance2d = 0, float angle = 0) const
 385         {
 386             // angle calculated from current orientation
 387             GetNearPoint(NULL,x,y,z,size,distance2d,GetOrientation() + angle);
 388         }
 389         void GetContactPoint( const WorldObject* obj, float &x, float &y, float &z, float distance2d = CONTACT_DISTANCE) const
 390         {
 391             // angle to face `obj` to `this` using distance includes size of `obj`
 392             GetNearPoint(obj,x,y,z,obj->GetObjectSize(),distance2d,GetAngle( obj ));
 393         }
 394
 395         float GetObjectSize() const
 396         {
 397             return ( m_valuesCount > UNIT_FIELD_BOUNDINGRADIUS ) ? m_floatValues[UNIT_FIELD_BOUNDINGRADIUS] : DEFAULT_WORLD_OBJECT_SIZE;
 398         }
 399         bool IsPositionValid() const;
 400         void UpdateGroundPositionZ(float x, float y, float &z) const;
 401
 402         void GetRandomPoint( float x, float y, float z, float distance, float &rand_x, float &rand_y, float &rand_z ) const;
 403
 404         void SetMapId(uint32 newMap) { m_mapId = newMap; }
 405         uint32 GetMapId() const { return m_mapId; }
 406
 407         virtual void SetPhaseMask(uint32 newPhaseMask, bool update);
 408         uint32 GetPhaseMask() const { return m_phaseMask; }
 409         bool InSamePhase(WorldObject const* obj) const { return InSamePhase(obj->GetPhaseMask()); }
 410         bool InSamePhase(uint32 phasemask) const { return (GetPhaseMask() & phasemask); }
 411
 412         uint32 GetZoneId() const;
 413         uint32 GetAreaId() const;
 414         void GetZoneAndAreaId(uint32& zoneid, uint32& areaid) const;
 415
 416         InstanceData* GetInstanceData();
 417
 418         const char* GetName() const { return m_name.c_str(); }
 419         void SetName(const std::string& newname) { m_name=newname; }
 420
 421         virtual const char* GetNameForLocaleIdx(int32 /*locale_idx*/) const { return GetName(); }
 422
 423         float GetDistance( const WorldObject* obj ) const;
 424         float GetDistance(float x, float y, float z) const;
 425         float GetDistance2d(const WorldObject* obj) const;
 426         float GetDistance2d(float x, float y) const;
 427         float GetDistanceZ(const WorldObject* obj) const;
 428         bool IsInMap(const WorldObject* obj) const
 429         {
 430             return IsInWorld() && obj->IsInWorld() && GetMapId()==obj->GetMapId() &&
 431                 GetInstanceId()==obj->GetInstanceId() && InSamePhase(obj);
 432         }
 433         bool IsWithinDist3d(float x, float y, float z, float dist2compare) const;
 434         bool IsWithinDist2d(float x, float y, float dist2compare) const;
 435         bool _IsWithinDist(WorldObject const* obj, float dist2compare, bool is3D) const;
 436         bool IsWithinDist(WorldObject const* obj, float dist2compare, bool is3D = true) const
 437                                                             // use only if you will sure about placing both object at same map
 438         {
 439             return obj && _IsWithinDist(obj,dist2compare,is3D);
 440         }
 441         bool IsWithinDistInMap(WorldObject const* obj, float dist2compare, bool is3D = true) const
 442         {
 443             return obj && IsInMap(obj) && _IsWithinDist(obj,dist2compare,is3D);
 444         }
 445         bool IsWithinLOS(float x, float y, float z) const;
 446         bool IsWithinLOSInMap(const WorldObject* obj) const;
 447         bool GetDistanceOrder(WorldObject const* obj1, WorldObject const* obj2, bool is3D = true) const;
 448         bool IsInRange(WorldObject const* obj, float minRange, float maxRange, bool is3D = true) const;
 449         bool IsInRange2d(float x, float y, float minRange, float maxRange) const;
 450         bool IsInRange3d(float x, float y, float z, float minRange, float maxRange) const;
 451
 452         float GetAngle( const WorldObject* obj ) const;
 453         float GetAngle( const float x, const float y ) const;
 454         bool HasInArc( const float arcangle, const WorldObject* obj ) const;
 455
 456         virtual void SendMessageToSet(WorldPacket *data, bool self);
 457         virtual void SendMessageToSetInRange(WorldPacket *data, float dist, bool self);
 458         void BuildHeartBeatMsg( WorldPacket *data ) const;
 459         void BuildTeleportAckMsg( WorldPacket *data, float x, float y, float z, float ang) const;
 460
 461         void MonsterSay(const char* text, uint32 language, uint64 TargetGuid);
 462         void MonsterYell(const char* text, uint32 language, uint64 TargetGuid);
 463         void MonsterTextEmote(const char* text, uint64 TargetGuid, bool IsBossEmote = false);
 464         void MonsterWhisper(const char* text, uint64 receiver, bool IsBossWhisper = false);
 465         void MonsterSay(int32 textId, uint32 language, uint64 TargetGuid);
 466         void MonsterYell(int32 textId, uint32 language, uint64 TargetGuid);
 467         void MonsterTextEmote(int32 textId, uint64 TargetGuid, bool IsBossEmote = false);
 468         void MonsterWhisper(int32 textId, uint64 receiver, bool IsBossWhisper = false);
 469         void MonsterYellToZone(int32 textId, uint32 language, uint64 TargetGuid);
 470         void BuildMonsterChat(WorldPacket *data, uint8 msgtype, char const* text, uint32 language, char const* name, uint64 TargetGuid) const;
 471
 472         void PlayDistanceSound(uint32 sound_id, Player* target = NULL);
 473         void PlayDirectSound(uint32 sound_id, Player* target = NULL);
 474
 475         void SendObjectDeSpawnAnim(uint64 guid);
 476
 477         virtual void SaveRespawnTime() {}
 478
 479         uint32 GetInstanceId() const { return m_InstanceId; }
 480         void SetInstanceId(uint32 val) { m_InstanceId = val; }
 481
 482         void AddObjectToRemoveList();
 483
 484         // main visibility check function in normal case (ignore grey zone distance check)
 485         bool isVisibleFor(Player const* u) const { return isVisibleForInState(u,false); }
 486
 487         // low level function for visibility change code, must be define in all main world object subclasses
 488         virtual bool isVisibleForInState(Player const* u, bool inVisibleList) const = 0;
 489
 490         Map      * GetMap() const;
 491         Map const* GetBaseMap() const;
 492         Creature* SummonCreature(uint32 id, float x, float y, float z, float ang,TempSummonType spwtype,uint32 despwtime);
 493
 494     protected:
 495         explicit WorldObject();
 496         std::string m_name;
 497
 498     private:
 499         uint32 m_mapId;                                     // object at map with map_id
 500         uint32 m_InstanceId;                                // in map copy with instance id
 501         uint32 m_phaseMask;                                 // in area phase state
 502
 503         float m_positionX;
 504         float m_positionY;
 505         float m_positionZ;
 506         float m_orientation;
 507 };
 508 #endif