src/game/GameObject.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 MANGOSSERVER_GAMEOBJECT_H
  20 #define MANGOSSERVER_GAMEOBJECT_H
  21
  22 #include "Common.h"
  23 #include "SharedDefines.h"
  24 #include "Object.h"
  25 #include "LootMgr.h"
  26 #include "Database/DatabaseEnv.h"
  27
  28 // GCC have alternative #pragma pack(N) syntax and old gcc version not support pack(push,N), also any gcc version not support it at some platform
  29 #if defined( __GNUC__ )
  30 #pragma pack(1)
  31 #else
  32 #pragma pack(push,1)
  33 #endif
  34
  35 // from `gameobject_template`
  36 struct GameObjectInfo
  37 {
  38     uint32  id;
  39     uint32  type;
  40     uint32  displayId;
  41     char   *name;
  42     char   *IconName;
  43     char   *castBarCaption;
  44     uint32  faction;
  45     uint32  flags;
  46     float   size;
  47     union                                                   // different GO types have different data field
  48     {
  49         //0 GAMEOBJECT_TYPE_DOOR
  50         struct
  51         {
  52             uint32 startOpen;                               //0 used client side to determine GO_ACTIVATED means open/closed
  53             uint32 lockId;                                  //1 -> Lock.dbc
  54             uint32 autoCloseTime;                           //2 secs till autoclose = autoCloseTime / 0x10000
  55             uint32 noDamageImmune;                          //3 break opening whenever you recieve damage?
  56             uint32 openTextID;                              //4 can be used to replace castBarCaption?
  57             uint32 closeTextID;                             //5
  58         } door;
  59         //1 GAMEOBJECT_TYPE_BUTTON
  60         struct
  61         {
  62             uint32 startOpen;                               //0
  63             uint32 lockId;                                  //1 -> Lock.dbc
  64             uint32 autoCloseTime;                           //2 secs till autoclose = autoCloseTime / 0x10000
  65             uint32 linkedTrap;                              //3
  66             uint32 noDamageImmune;                          //4 isBattlegroundObject
  67             uint32 large;                                   //5
  68             uint32 openTextID;                              //6 can be used to replace castBarCaption?
  69             uint32 closeTextID;                             //7
  70             uint32 losOK;                                   //8
  71         } button;
  72         //2 GAMEOBJECT_TYPE_QUESTGIVER
  73         struct
  74         {
  75             uint32 lockId;                                  //0 -> Lock.dbc
  76             uint32 questList;                               //1
  77             uint32 pageMaterial;                            //2
  78             uint32 gossipID;                                //3
  79             uint32 customAnim;                              //4
  80             uint32 noDamageImmune;                          //5
  81             uint32 openTextID;                              //6 can be used to replace castBarCaption?
  82             uint32 losOK;                                   //7
  83             uint32 allowMounted;                            //8
  84             uint32 large;                                   //9
  85         } questgiver;
  86         //3 GAMEOBJECT_TYPE_CHEST
  87         struct
  88         {
  89             uint32 lockId;                                  //0 -> Lock.dbc
  90             uint32 lootId;                                  //1
  91             uint32 chestRestockTime;                        //2
  92             uint32 consumable;                              //3
  93             uint32 minSuccessOpens;                         //4
  94             uint32 maxSuccessOpens;                         //5
  95             uint32 eventId;                                 //6 lootedEvent
  96             uint32 linkedTrapId;                            //7
  97             uint32 questId;                                 //8 not used currently but store quest required for GO activation for player
  98             uint32 level;                                   //9
  99             uint32 losOK;                                   //10
 100             uint32 leaveLoot;                               //11
 101             uint32 notInCombat;                             //12
 102             uint32 logLoot;                                 //13
 103             uint32 openTextID;                              //14 can be used to replace castBarCaption?
 104             uint32 groupLootRules;                          //15
 105         } chest;
 106         //5 GAMEOBJECT_TYPE_GENERIC
 107         struct
 108         {
 109             uint32 floatingTooltip;                         //0
 110             uint32 highlight;                               //1
 111             uint32 serverOnly;                              //2
 112             uint32 large;                                   //3
 113             uint32 floatOnWater;                            //4
 114             uint32 questID;                                 //5
 115         } _generic;
 116         //6 GAMEOBJECT_TYPE_TRAP
 117         struct
 118         {
 119             uint32 lockId;                                  //0 -> Lock.dbc
 120             uint32 level;                                   //1
 121             uint32 radius;                                  //2 radius for trap activation
 122             uint32 spellId;                                 //3
 123             uint32 charges;                                 //4 need respawn (if > 0)
 124             uint32 cooldown;                                //5 time in secs
 125             uint32 autoCloseTime;                           //6
 126             uint32 startDelay;                              //7
 127             uint32 serverOnly;                              //8
 128             uint32 stealthed;                               //9
 129             uint32 large;                                   //10
 130             uint32 stealthAffected;                         //11
 131             uint32 openTextID;                              //12 can be used to replace castBarCaption?
 132             uint32 closeTextID;                             //13
 133         } trap;
 134         //7 GAMEOBJECT_TYPE_CHAIR
 135         struct
 136         {
 137             uint32 slots;                                   //0
 138             uint32 height;                                  //1
 139             uint32 onlyCreatorUse;                          //2
 140         } chair;
 141         //8 GAMEOBJECT_TYPE_SPELL_FOCUS
 142         struct
 143         {
 144             uint32 focusId;                                 //0
 145             uint32 dist;                                    //1
 146             uint32 linkedTrapId;                            //2
 147             uint32 serverOnly;                              //3
 148             uint32 questID;                                 //4
 149             uint32 large;                                   //5
 150         } spellFocus;
 151         //9 GAMEOBJECT_TYPE_TEXT
 152         struct
 153         {
 154             uint32 pageID;                                  //0
 155             uint32 language;                                //1
 156             uint32 pageMaterial;                            //2
 157             uint32 allowMounted;                            //3
 158         } text;
 159         //10 GAMEOBJECT_TYPE_GOOBER
 160         struct
 161         {
 162             uint32 lockId;                                  //0 -> Lock.dbc
 163             uint32 questId;                                 //1
 164             uint32 eventId;                                 //2
 165             uint32 autoCloseTime;                           //3
 166             uint32 customAnim;                              //4
 167             uint32 consumable;                              //5
 168             uint32 cooldown;                                //6
 169             uint32 pageId;                                  //7
 170             uint32 language;                                //8
 171             uint32 pageMaterial;                            //9
 172             uint32 spellId;                                 //10
 173             uint32 noDamageImmune;                          //11
 174             uint32 linkedTrapId;                            //12
 175             uint32 large;                                   //13
 176             uint32 openTextID;                              //14 can be used to replace castBarCaption?
 177             uint32 closeTextID;                             //15
 178             uint32 losOK;                                   //16 isBattlegroundObject
 179             uint32 allowMounted;                            //17
 180         } goober;
 181         //11 GAMEOBJECT_TYPE_TRANSPORT
 182         struct
 183         {
 184             uint32 pause;                                   //0
 185             uint32 startOpen;                               //1
 186             uint32 autoCloseTime;                           //2 secs till autoclose = autoCloseTime / 0x10000
 187         } transport;
 188         //12 GAMEOBJECT_TYPE_AREADAMAGE
 189         struct
 190         {
 191             uint32 lockId;                                  //0
 192             uint32 radius;                                  //1
 193             uint32 damageMin;                               //2
 194             uint32 damageMax;                               //3
 195             uint32 damageSchool;                            //4
 196             uint32 autoCloseTime;                           //5 secs till autoclose = autoCloseTime / 0x10000
 197             uint32 openTextID;                              //6
 198             uint32 closeTextID;                             //7
 199         } areadamage;
 200         //13 GAMEOBJECT_TYPE_CAMERA
 201         struct
 202         {
 203             uint32 lockId;                                  //0 -> Lock.dbc
 204             uint32 cinematicId;                             //1
 205             uint32 eventID;                                 //2
 206             uint32 openTextID;                              //3 can be used to replace castBarCaption?
 207         } camera;
 208         //15 GAMEOBJECT_TYPE_MO_TRANSPORT
 209         struct
 210         {
 211             uint32 taxiPathId;                              //0
 212             uint32 moveSpeed;                               //1
 213             uint32 accelRate;                               //2
 214             uint32 startEventID;                            //3
 215             uint32 stopEventID;                             //4
 216             uint32 transportPhysics;                        //5
 217             uint32 mapID;                                   //6
 218         } moTransport;
 219         //17 GAMEOBJECT_TYPE_FISHINGNODE
 220         struct
 221         {
 222             uint32 _data0;                                  //0
 223             uint32 lootId;                                  //1
 224         } fishnode;
 225         //18 GAMEOBJECT_TYPE_SUMMONING_RITUAL
 226         struct
 227         {
 228             uint32 reqParticipants;                         //0
 229             uint32 spellId;                                 //1
 230             uint32 animSpell;                               //2
 231             uint32 ritualPersistent;                        //3
 232             uint32 casterTargetSpell;                       //4
 233             uint32 casterTargetSpellTargets;                //5
 234             uint32 castersGrouped;                          //6
 235             uint32 ritualNoTargetCheck;                     //7
 236         } summoningRitual;
 237         //20 GAMEOBJECT_TYPE_AUCTIONHOUSE
 238         struct
 239         {
 240             uint32 actionHouseID;                           //0
 241         } auctionhouse;
 242         //21 GAMEOBJECT_TYPE_GUARDPOST
 243         struct
 244         {
 245             uint32 creatureID;                              //0
 246             uint32 charges;                                 //1
 247         } guardpost;
 248         //22 GAMEOBJECT_TYPE_SPELLCASTER
 249         struct
 250         {
 251             uint32 spellId;                                 //0
 252             uint32 charges;                                 //1
 253             uint32 partyOnly;                               //2
 254         } spellcaster;
 255         //23 GAMEOBJECT_TYPE_MEETINGSTONE
 256         struct
 257         {
 258             uint32 minLevel;                                //0
 259             uint32 maxLevel;                                //1
 260             uint32 areaID;                                  //2
 261         } meetingstone;
 262         //24 GAMEOBJECT_TYPE_FLAGSTAND
 263         struct
 264         {
 265             uint32 lockId;                                  //0
 266             uint32 pickupSpell;                             //1
 267             uint32 radius;                                  //2
 268             uint32 returnAura;                              //3
 269             uint32 returnSpell;                             //4
 270             uint32 noDamageImmune;                          //5
 271             uint32 openTextID;                              //6
 272             uint32 losOK;                                   //7
 273         } flagstand;
 274         //25 GAMEOBJECT_TYPE_FISHINGHOLE                    // not implemented yet
 275         struct
 276         {
 277             uint32 radius;                                  //0 how close bobber must land for sending loot
 278             uint32 lootId;                                  //1
 279             uint32 minSuccessOpens;                         //2
 280             uint32 maxSuccessOpens;                         //3
 281             uint32 lockId;                                  //4 -> Lock.dbc; possibly 1628 for all?
 282         } fishinghole;
 283         //26 GAMEOBJECT_TYPE_FLAGDROP
 284         struct
 285         {
 286             uint32 lockId;                                  //0
 287             uint32 eventID;                                 //1
 288             uint32 pickupSpell;                             //2
 289             uint32 noDamageImmune;                          //3
 290             uint32 openTextID;                              //4
 291         } flagdrop;
 292         //27 GAMEOBJECT_TYPE_MINI_GAME
 293         struct
 294         {
 295             uint32 gameType;                                //0
 296         } miniGame;
 297         //29 GAMEOBJECT_TYPE_CAPTURE_POINT
 298         struct
 299         {
 300             uint32 radius;                                  //0
 301             uint32 spell;                                   //1
 302             uint32 worldState1;                             //2
 303             uint32 worldstate2;                             //3
 304             uint32 winEventID1;                             //4
 305             uint32 winEventID2;                             //5
 306             uint32 contestedEventID1;                       //6
 307             uint32 contestedEventID2;                       //7
 308             uint32 progressEventID1;                        //8
 309             uint32 progressEventID2;                        //9
 310             uint32 neutralEventID1;                         //10
 311             uint32 neutralEventID2;                         //11
 312             uint32 neutralPercent;                          //12
 313             uint32 worldstate3;                             //13
 314             uint32 minSuperiority;                          //14
 315             uint32 maxSuperiority;                          //15
 316             uint32 minTime;                                 //16
 317             uint32 maxTime;                                 //17
 318             uint32 large;                                   //18
 319             uint32 highlight;                               //19
 320         } capturePoint;
 321         //30 GAMEOBJECT_TYPE_AURA_GENERATOR
 322         struct
 323         {
 324             uint32 startOpen;                               //0
 325             uint32 radius;                                  //1
 326             uint32 auraID1;                                 //2
 327             uint32 conditionID1;                            //3
 328             uint32 auraID2;                                 //4
 329             uint32 conditionID2;                            //5
 330             uint32 serverOnly;                              //6
 331         } auraGenerator;
 332         //31 GAMEOBJECT_TYPE_DUNGEON_DIFFICULTY
 333         struct
 334         {
 335             uint32 mapID;                                   //0
 336             uint32 difficulty;                              //1
 337         } dungeonDifficulty;
 338         //32 GAMEOBJECT_TYPE_BARBER_CHAIR
 339         struct
 340         {
 341             uint32 chairheight;                             //0
 342             uint32 heightOffset;                            //1
 343         } barberChair;
 344         //33 GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING
 345         struct
 346         {
 347             uint32 dmgPctState1;                            //0
 348             uint32 dmgPctState2;                            //1
 349             uint32 state1Name;                              //2
 350             uint32 state2Name;                              //3
 351         } destructibleBuilding;
 352         //34 GAMEOBJECT_TYPE_TRAPDOOR
 353         struct
 354         {
 355             uint32 whenToPause;                             // 0
 356             uint32 startOpen;                               // 1
 357             uint32 autoClose;                               // 2
 358         } trapDoor;
 359
 360         // not use for specific field access (only for output with loop by all filed), also this determinate max union size
 361         struct                                              // GAMEOBJECT_TYPE_SPELLCASTER
 362         {
 363             uint32 data[24];
 364         } raw;
 365     };
 366     uint32 ScriptId;
 367 };
 368
 369 struct GameObjectLocale
 370 {
 371     std::vector<std::string> Name;
 372     std::vector<std::string> CastBarCaption;
 373 };
 374
 375 // from `gameobject`
 376 struct GameObjectData
 377 {
 378     uint32 id;                                              // entry in gamobject_template
 379     uint16 mapid;
 380     uint16 phaseMask;
 381     float posX;
 382     float posY;
 383     float posZ;
 384     float orientation;
 385     float rotation0;
 386     float rotation1;
 387     float rotation2;
 388     float rotation3;
 389     int32  spawntimesecs;
 390     uint32 animprogress;
 391     uint32 go_state;
 392     uint8 spawnMask;
 393 };
 394
 395 // GCC have alternative #pragma pack() syntax and old gcc version not support pack(pop), also any gcc version not support it at some platform
 396 #if defined( __GNUC__ )
 397 #pragma pack()
 398 #else
 399 #pragma pack(pop)
 400 #endif
 401
 402 // For containers:  [GO_NOT_READY]->GO_READY (close)->GO_ACTIVATED (open) ->GO_JUST_DEACTIVATED->GO_READY        -> ...
 403 // For bobber:      GO_NOT_READY  ->GO_READY (close)->GO_ACTIVATED (open) ->GO_JUST_DEACTIVATED-><deleted>
 404 // For door(closed):[GO_NOT_READY]->GO_READY (close)->GO_ACTIVATED (open) ->GO_JUST_DEACTIVATED->GO_READY(close) -> ...
 405 // For door(open):  [GO_NOT_READY]->GO_READY (open) ->GO_ACTIVATED (close)->GO_JUST_DEACTIVATED->GO_READY(open)  -> ...
 406 enum LootState
 407 {
 408     GO_NOT_READY = 0,
 409     GO_READY,                                               // can be ready but despawned, and then not possible activate until spawn
 410     GO_ACTIVATED,
 411     GO_JUST_DEACTIVATED
 412 };
 413
 414 class Unit;
 415
 416 // 5 sec for bobber catch
 417 #define FISHING_BOBBER_READY_TIME 5
 418
 419 class MANGOS_DLL_SPEC GameObject : public WorldObject
 420 {
 421     public:
 422         explicit GameObject();
 423         ~GameObject();
 424
 425         void AddToWorld();
 426         void RemoveFromWorld();
 427
 428         bool Create(uint32 guidlow, uint32 name_id, Map *map, uint32 phaseMask, float x, float y, float z, float ang, float rotation0, float rotation1, float rotation2, float rotation3, uint32 animprogress, uint32 go_state);
 429         void Update(uint32 p_time);
 430         static GameObject* GetGameObject(WorldObject& object, uint64 guid);
 431         GameObjectInfo const* GetGOInfo() const;
 432
 433         bool IsTransport() const;
 434
 435         void SetOwnerGUID(uint64 owner)
 436         {
 437             m_spawnedByDefault = false;                     // all object with owner is despawned after delay
 438             SetUInt64Value(OBJECT_FIELD_CREATED_BY, owner);
 439         }
 440         uint64 GetOwnerGUID() const { return GetUInt64Value(OBJECT_FIELD_CREATED_BY); }
 441         Unit* GetOwner() const;
 442
 443         uint32 GetDBTableGUIDLow() const { return m_DBTableGuid; }
 444
 445         void UpdateRotationFields(float rotation2 = 0.0f, float rotation3 = 0.0f);
 446
 447         void Say(int32 textId, uint32 language, uint64 TargetGuid) { MonsterSay(textId,language,TargetGuid); }
 448         void Yell(int32 textId, uint32 language, uint64 TargetGuid) { MonsterYell(textId,language,TargetGuid); }
 449         void TextEmote(int32 textId, uint64 TargetGuid) { MonsterTextEmote(textId,TargetGuid); }
 450         void Whisper(int32 textId, uint64 receiver) { MonsterWhisper(textId,receiver); }
 451
 452         // overwrite WorldObject function for proper name localization
 453         const char* GetNameForLocaleIdx(int32 locale_idx) const;
 454
 455         void SaveToDB();
 456         void SaveToDB(uint32 mapid, uint8 spawnMask, uint32 phaseMask);
 457         bool LoadFromDB(uint32 guid, Map *map);
 458         void DeleteFromDB();
 459         void SetLootState(LootState s) { m_lootState = s; }
 460         static uint32 GetLootId(GameObjectInfo const* info);
 461         uint32 GetLootId() const { return GetLootId(GetGOInfo()); }
 462         uint32 GetLockId() const
 463         {
 464             switch(GetGoType())
 465             {
 466                 case GAMEOBJECT_TYPE_DOOR:       return GetGOInfo()->door.lockId;
 467                 case GAMEOBJECT_TYPE_BUTTON:     return GetGOInfo()->button.lockId;
 468                 case GAMEOBJECT_TYPE_QUESTGIVER: return GetGOInfo()->questgiver.lockId;
 469                 case GAMEOBJECT_TYPE_CHEST:      return GetGOInfo()->chest.lockId;
 470                 case GAMEOBJECT_TYPE_TRAP:       return GetGOInfo()->trap.lockId;
 471                 case GAMEOBJECT_TYPE_GOOBER:     return GetGOInfo()->goober.lockId;
 472                 case GAMEOBJECT_TYPE_AREADAMAGE: return GetGOInfo()->areadamage.lockId;
 473                 case GAMEOBJECT_TYPE_CAMERA:     return GetGOInfo()->camera.lockId;
 474                 case GAMEOBJECT_TYPE_FLAGSTAND:  return GetGOInfo()->flagstand.lockId;
 475                 case GAMEOBJECT_TYPE_FISHINGHOLE:return GetGOInfo()->fishinghole.lockId;
 476                 case GAMEOBJECT_TYPE_FLAGDROP:   return GetGOInfo()->flagdrop.lockId;
 477                 default: return 0;
 478             }
 479         }
 480
 481         time_t GetRespawnTime() const { return m_respawnTime; }
 482         time_t GetRespawnTimeEx() const
 483         {
 484             time_t now = time(NULL);
 485             if(m_respawnTime > now)
 486                 return m_respawnTime;
 487             else
 488                 return now;
 489         }
 490
 491         void SetRespawnTime(int32 respawn)
 492         {
 493             m_respawnTime = respawn > 0 ? time(NULL) + respawn : 0;
 494             m_respawnDelayTime = respawn > 0 ? respawn : 0;
 495         }
 496         void Respawn();
 497         bool isSpawned() const
 498         {
 499             return m_respawnDelayTime == 0 ||
 500                 (m_respawnTime > 0 && !m_spawnedByDefault) ||
 501                 (m_respawnTime == 0 && m_spawnedByDefault);
 502         }
 503         bool isSpawnedByDefault() const { return m_spawnedByDefault; }
 504         uint32 GetRespawnDelay() const { return m_respawnDelayTime; }
 505         void Refresh();
 506         void Delete();
 507         void SetSpellId(uint32 id) { m_spellId = id;}
 508         uint32 GetSpellId() const { return m_spellId;}
 509         void getFishLoot(Loot *loot, Player* loot_owner);
 510         GameobjectTypes GetGoType() const { return GameobjectTypes(GetByteValue(GAMEOBJECT_BYTES_1, 1)); }
 511         void SetGoType(GameobjectTypes type) { SetByteValue(GAMEOBJECT_BYTES_1, 1, type); }
 512         uint8 GetGoState() const { return GetByteValue(GAMEOBJECT_BYTES_1, 0); }
 513         void SetGoState(uint8 state) { SetByteValue(GAMEOBJECT_BYTES_1, 0, state); }
 514         uint8 GetGoArtKit() const { return GetByteValue(GAMEOBJECT_BYTES_1, 2); }
 515         void SetGoArtKit(uint8 artkit) { SetByteValue(GAMEOBJECT_BYTES_1, 2, artkit); }
 516         uint8 GetGoAnimProgress() const { return GetByteValue(GAMEOBJECT_BYTES_1, 3); }
 517         void SetGoAnimProgress(uint8 animprogress) { SetByteValue(GAMEOBJECT_BYTES_1, 3, animprogress); }
 518
 519         void Use(Unit* user);
 520
 521         LootState getLootState() const { return m_lootState; }
 522
 523         void AddToSkillupList(uint32 PlayerGuidLow) { m_SkillupList.push_back(PlayerGuidLow); }
 524         bool IsInSkillupList(uint32 PlayerGuidLow) const
 525         {
 526             for (std::list<uint32>::const_iterator i = m_SkillupList.begin(); i != m_SkillupList.end(); ++i)
 527                 if (*i == PlayerGuidLow) return true;
 528             return false;
 529         }
 530         void ClearSkillupList() { m_SkillupList.clear(); }
 531
 532         void AddUniqueUse(Player* player);
 533         void AddUse() { ++m_usetimes; }
 534
 535         uint32 GetUseCount() const { return m_usetimes; }
 536         uint32 GetUniqueUseCount() const { return m_unique_users.size(); }
 537
 538         void SaveRespawnTime();
 539
 540         Loot        loot;
 541
 542         bool hasQuest(uint32 quest_id) const;
 543         bool hasInvolvedQuest(uint32 quest_id) const;
 544         bool ActivateToQuest(Player *pTarget) const;
 545         void UseDoorOrButton(uint32 time_to_restore = 0);   // 0 = use `gameobject`.`spawntimesecs`
 546
 547         uint32 GetLinkedGameObjectEntry() const
 548         {
 549             switch(GetGoType())
 550             {
 551                 case GAMEOBJECT_TYPE_CHEST:       return GetGOInfo()->chest.linkedTrapId;
 552                 case GAMEOBJECT_TYPE_SPELL_FOCUS: return GetGOInfo()->spellFocus.linkedTrapId;
 553                 case GAMEOBJECT_TYPE_GOOBER:      return GetGOInfo()->goober.linkedTrapId;
 554                 default: return 0;
 555             }
 556         }
 557
 558         uint32 GetAutoCloseTime() const
 559         {
 560             uint32 autoCloseTime = 0;
 561             switch(GetGoType())
 562             {
 563                 case GAMEOBJECT_TYPE_DOOR:          autoCloseTime = GetGOInfo()->door.autoCloseTime; break;
 564                 case GAMEOBJECT_TYPE_BUTTON:        autoCloseTime = GetGOInfo()->button.autoCloseTime; break;
 565                 case GAMEOBJECT_TYPE_TRAP:          autoCloseTime = GetGOInfo()->trap.autoCloseTime; break;
 566                 case GAMEOBJECT_TYPE_GOOBER:        autoCloseTime = GetGOInfo()->goober.autoCloseTime; break;
 567                 case GAMEOBJECT_TYPE_TRANSPORT:     autoCloseTime = GetGOInfo()->transport.autoCloseTime; break;
 568                 case GAMEOBJECT_TYPE_AREADAMAGE:    autoCloseTime = GetGOInfo()->areadamage.autoCloseTime; break;
 569                 default: break;
 570             }
 571             return autoCloseTime / 0x10000;
 572         }
 573
 574         void TriggeringLinkedGameObject( uint32 trapEntry, Unit* target);
 575
 576         bool isVisibleForInState(Player const* u, bool inVisibleList) const;
 577
 578         GameObject* LookupFishingHoleAround(float range);
 579
 580         GridReference<GameObject> &GetGridRef() { return m_gridRef; }
 581
 582         bool isActiveObject() const { return false; }
 583     protected:
 584         uint32      m_charges;                              // Spell charges for GAMEOBJECT_TYPE_SPELLCASTER (22)
 585         uint32      m_spellId;
 586         time_t      m_respawnTime;                          // (secs) time of next respawn (or despawn if GO have owner()),
 587         uint32      m_respawnDelayTime;                     // (secs) if 0 then current GO state no dependent from timer
 588         LootState   m_lootState;
 589         bool        m_spawnedByDefault;
 590         time_t      m_cooldownTime;                         // used as internal reaction delay time store (not state change reaction).
 591                                                             // For traps this: spell casting cooldown, for doors/buttons: reset time.
 592         std::list<uint32> m_SkillupList;
 593
 594         std::set<uint32> m_unique_users;
 595         uint32 m_usetimes;
 596
 597         uint32 m_DBTableGuid;                               ///< For new or temporary gameobjects is 0 for saved it is lowguid
 598         GameObjectInfo const* m_goInfo;
 599     private:
 600         void SwitchDoorOrButton(bool activate);
 601
 602         GridReference<GameObject> m_gridRef;
 603 };
 604 #endif