TrinityCore: GameObject Class Reference

GameObject::m_SkillupList

uint16 m_LootMode

Definition: GameObject.h:1120

void GameObject::AddToSkillupList ( ObjectGuid const & PlayerGuidLow )

inline

992 { m_SkillupList.insert(PlayerGuidLow); }

GuidSet m_SkillupList

Definition: GameObject.h:1101

Here is the caller graph for this function:

void GameObject::AddToWorld ( )

overridevirtual

Register the gameobject for guid lookup

Reimplemented from Object.

 {
  if (!IsInWorld())
  {
  if (m_zoneScript)
  m_zoneScript->OnGameObjectCreate(this);
 
  GetMap()->GetObjectsStore().Insert<GameObject>(GetGUID(), this);
  if (m_spawnId)
  GetMap()->GetGameObjectBySpawnIdStore().insert(std::make_pair(m_spawnId, this));
 
  // The state can be changed after GameObject::Create but before GameObject::AddToWorld
  bool toggledState = GetGoType() == GAMEOBJECT_TYPE_CHEST ? getLootState() == GO_READY : (GetGoState() == GO_STATE_READY || IsTransport());
  if (m_model)
  {
  if (Transport* trans = ToTransport())
  trans->SetDelayedAddModelToMap();
  else
  GetMap()->InsertGameObjectModel(*m_model);
  }
 
  EnableCollision(toggledState);
  WorldObject::AddToWorld();
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::AddUniqueUse ( Player * player )

 {
     AddUse();
     m_unique_users.insert(player->GetGUID());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::AddUse ( )

inline

1000 { ++m_usetimes; }

GameObject::m_usetimes

uint32 m_usetimes

Definition: GameObject.h:1105

Here is the caller graph for this function:

GameObjectAI* GameObject::AI ( ) const

inline

1061 { return m_AI; }

GameObject::m_AI

GameObjectAI * m_AI

Definition: GameObject.h:1132

Here is the caller graph for this function:

bool GameObject::AIM_Initialize ( )

protected

 {
     delete m_AI;
 
     m_AI = FactorySelector::SelectGameObjectAI(this);
 
     if (!m_AI)
         return false;
 
     m_AI->InitializeAI();
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::BuildValuesUpdate	(	uint8	updatetype,
		ByteBuffer *	data,
		Player *	target
	)		const

overridevirtual

Reimplemented from Object.

 {
     if (!target)
         return;
 
     bool isStoppableTransport = GetGoType() == GAMEOBJECT_TYPE_TRANSPORT && !m_goValue.Transport.StopFrames->empty();
     bool forcedFlags = GetGoType() == GAMEOBJECT_TYPE_CHEST && GetGOInfo()->chest.usegrouplootrules && HasLootRecipient();
     bool targetIsGM = target->IsGameMaster();
 
     ByteBuffer fieldBuffer;
 
     UpdateMask updateMask;
     updateMask.SetCount(m_valuesCount);
 
     uint32* flags = GameObjectUpdateFieldFlags;
     uint32 visibleFlag = UF_FLAG_PUBLIC;
     if (GetOwnerGUID() == target->GetGUID())
         visibleFlag |= UF_FLAG_OWNER;
 
     for (uint16 index = 0; index < m_valuesCount; ++index)
     {
         if (_fieldNotifyFlags & flags[index] ||
             ((updateType == UPDATETYPE_VALUES ? _changesMask.GetBit(index) : m_uint32Values[index]) && (flags[index] & visibleFlag)) ||
             (index == GAMEOBJECT_FLAGS && forcedFlags))
         {
             updateMask.SetBit(index);
 
             if (index == OBJECT_DYNAMIC_FLAGS)
             {
                 uint16 dynFlags = 0;
                 int16 pathProgress = -1;
                 switch (GetGoType())
                 {
                     case GAMEOBJECT_TYPE_QUESTGIVER:
                         if (ActivateToQuest(target))
                             dynFlags |= GO_DYNFLAG_LO_ACTIVATE;
                         break;
                     case GAMEOBJECT_TYPE_CHEST:
                     case GAMEOBJECT_TYPE_GOOBER:
                         if (ActivateToQuest(target))
                             dynFlags |= GO_DYNFLAG_LO_ACTIVATE | GO_DYNFLAG_LO_SPARKLE;
                         else if (targetIsGM)
                             dynFlags |= GO_DYNFLAG_LO_ACTIVATE;
                         break;
                     case GAMEOBJECT_TYPE_GENERIC:
                         if (ActivateToQuest(target))
                             dynFlags |= GO_DYNFLAG_LO_SPARKLE;
                         break;
                     case GAMEOBJECT_TYPE_TRANSPORT:
                     case GAMEOBJECT_TYPE_MAP_OBJ_TRANSPORT:
                     {
                         if (uint32 transportPeriod = GetTransportPeriod())
                         {
                             float timer = float(m_goValue.Transport.PathProgress % transportPeriod);
                             pathProgress = int16(timer / float(transportPeriod) * 65535.0f);
                         }
                         break;
                     }
                     default:
                         break;
                 }
 
                 fieldBuffer << uint16(dynFlags);
                 fieldBuffer << int16(pathProgress);
             }
             else if (index == GAMEOBJECT_FLAGS)
             {
                 uint32 goFlags = m_uint32Values[GAMEOBJECT_FLAGS];
                 if (GetGoType() == GAMEOBJECT_TYPE_CHEST)
                     if (GetGOInfo()->chest.usegrouplootrules && !IsLootAllowedFor(target))
                         goFlags |= GO_FLAG_LOCKED | GO_FLAG_NOT_SELECTABLE;
 
                 fieldBuffer << goFlags;
             }
             else if (index == GAMEOBJECT_LEVEL)
             {
                 if (isStoppableTransport)
                     fieldBuffer << uint32(m_goValue.Transport.PathProgress);
                 else
                     fieldBuffer << m_uint32Values[index];
             }
             else if (index == GAMEOBJECT_BYTES_1)
             {
                 uint32 bytes1 = m_uint32Values[index];
                 if (isStoppableTransport && GetGoState() == GO_STATE_TRANSPORT_ACTIVE)
                 {
                     if ((m_goValue.Transport.StateUpdateTimer / 20000) & 1)
                     {
                         bytes1 &= 0xFFFFFF00;
                         bytes1 |= GO_STATE_TRANSPORT_STOPPED;
                     }
                 }
 
                 fieldBuffer << bytes1;
             }
             else
                 fieldBuffer << m_uint32Values[index];                // other cases
         }
     }
 
     *data << uint8(updateMask.GetBlockCount());
     updateMask.AppendToPacket(data);
     data->append(fieldBuffer);
 }

Here is the call graph for this function:

void GameObject::CastSpell	(	Unit *	target,
		uint32	spell,
		bool	triggered = `true`
	)

 {
     SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
     if (!spellInfo)
         return;
 
     bool self = false;
     for (SpellEffectInfo const* effect : spellInfo->GetEffectsForDifficulty(GetMap()->GetDifficultyID()))
     {
         if (effect && effect->TargetA.GetTarget() == TARGET_UNIT_CASTER)
         {
             self = true;
             break;
         }
     }
 
     if (self)
     {
         if (target)
             target->CastSpell(target, spellInfo, triggered);
         return;
     }
 
     //summon world trigger
     Creature* trigger = SummonTrigger(GetPositionX(), GetPositionY(), GetPositionZ(), 0, spellInfo->CalcCastTime() + 100);
     if (!trigger)
         return;
 
     if (Unit* owner = GetOwner())
     {
         trigger->setFaction(owner->getFaction());
         if (owner->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE))
             trigger->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PVP_ATTACKABLE);
         // needed for GO casts for proper target validation checks
         trigger->SetOwnerGUID(owner->GetGUID());
         trigger->CastSpell(target ? target : trigger, spellInfo, triggered, nullptr, nullptr, owner->GetGUID());
     }
     else
     {
         trigger->setFaction(14);
         // Set owner guid for target if no owner available - needed by trigger auras
         // - trigger gets despawned and there's no caster avalible (see AuraEffect::TriggerSpell())
         trigger->CastSpell(target ? target : trigger, spellInfo, triggered, nullptr, nullptr, target ? target->GetGUID() : ObjectGuid::Empty);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::CleanupsBeforeDelete ( bool finalCleanup = true )

overridevirtual

Reimplemented from WorldObject.

Reimplemented in Transport.

 {
     WorldObject::CleanupsBeforeDelete(finalCleanup);
 
     if (m_uint32Values)                                      // field array can be not exist if GameOBject not loaded
         RemoveFromOwner();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::ClearSkillupList ( )

inline

997 { m_SkillupList.clear(); }

GameObject::m_SkillupList

GuidSet m_SkillupList

Definition: GameObject.h:1101

bool GameObject::Create	(	ObjectGuid::LowType	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,
		GOState	go_state,
		uint32	artKit = `0`
	)

 {
     ASSERT(map);
     SetMap(map);
 
     Relocate(x, y, z, ang);
     m_stationaryPosition.Relocate(x, y, z, ang);
     if (!IsPositionValid())
     {
         TC_LOG_ERROR("misc", "Gameobject (GUID: " UI64FMTD " Spawn id: " UI64FMTD " Entry: %u) not created. Suggested coordinates isn't valid (X: %f Y: %f)", guidlow, GetSpawnId(), name_id, x, y);
         return false;
     }
 
     SetZoneScript();
     if (m_zoneScript)
     {
         name_id = m_zoneScript->GetGameObjectEntry(guidlow, name_id);
         if (!name_id)
             return false;
     }
 
     GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(name_id);
     if (!goinfo)
     {
         TC_LOG_ERROR("sql.sql", "Gameobject (GUID: " UI64FMTD " Spawn id: " UI64FMTD " Entry: %u) not created: non-existing entry in `gameobject_template`. Map: %u (X: %f Y: %f Z: %f)", guidlow, GetSpawnId(), name_id, map->GetId(), x, y, z);
         return false;
     }
 
     if (goinfo->type == GAMEOBJECT_TYPE_MAP_OBJ_TRANSPORT)
     {
         TC_LOG_ERROR("sql.sql", "Gameobject (GUID: " UI64FMTD " Spawn id: " UI64FMTD " Entry: %u) not created: gameobject type GAMEOBJECT_TYPE_MAP_OBJ_TRANSPORT cannot be manually created.", guidlow, GetSpawnId(), name_id);
         return false;
     }
 
     if (goinfo->type == GAMEOBJECT_TYPE_TRANSPORT)
         m_updateFlag |= UPDATEFLAG_TRANSPORT;
 
     Object::_Create(ObjectGuid::Create<HighGuid::GameObject>(map->GetId(), goinfo->entry, guidlow));
 
     m_goInfo = goinfo;
 
     if (goinfo->type >= MAX_GAMEOBJECT_TYPE)
     {
         TC_LOG_ERROR("sql.sql", "Gameobject (GUID: " UI64FMTD " Spawn id: " UI64FMTD " Entry: %u) not created: non-existing GO type '%u' in `gameobject_template`. It will crash client if created.", guidlow, GetSpawnId(), name_id, goinfo->type);
         return false;
     }
 
     SetFloatValue(GAMEOBJECT_PARENTROTATION+0, rotation0);
     SetFloatValue(GAMEOBJECT_PARENTROTATION+1, rotation1);
 
     UpdateRotationFields(rotation2, rotation3);              // GAMEOBJECT_FACING, GAMEOBJECT_ROTATION, GAMEOBJECT_PARENTROTATION+2/3
 
     SetObjectScale(goinfo->size);
 
     SetUInt32Value(GAMEOBJECT_FACTION, goinfo->faction);
     SetUInt32Value(GAMEOBJECT_FLAGS, goinfo->flags);
 
     SetEntry(goinfo->entry);
 
     // set name for logs usage, doesn't affect anything ingame
     SetName(goinfo->name);
 
     SetDisplayId(goinfo->displayId);
 
     m_model = CreateModel();
     // GAMEOBJECT_BYTES_1, index at 0, 1, 2 and 3
     SetGoType(GameobjectTypes(goinfo->type));
     SetGoState(go_state);
     SetGoArtKit(artKit);
 
     switch (goinfo->type)
     {
         case GAMEOBJECT_TYPE_FISHINGHOLE:
             SetGoAnimProgress(animprogress);
             m_goValue.FishingHole.MaxOpens = urand(GetGOInfo()->fishingHole.minRestock, GetGOInfo()->fishingHole.maxRestock);
             break;
         case GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING:
             // TODO: Get the values somehow, no longer in gameobject_template
             m_goValue.Building.Health = 20000/*goinfo->destructibleBuilding.intactNumHits + goinfo->destructibleBuilding.damagedNumHits*/;
             m_goValue.Building.MaxHealth = m_goValue.Building.Health;
             SetGoAnimProgress(255);
             SetUInt32Value(GAMEOBJECT_PARENTROTATION, m_goInfo->destructibleBuilding.DestructibleModelRec);
             break;
         case GAMEOBJECT_TYPE_TRANSPORT:
         {
             m_goValue.Transport.AnimationInfo = sTransportMgr->GetTransportAnimInfo(goinfo->entry);
             m_goValue.Transport.PathProgress = getMSTime();
             if (m_goValue.Transport.AnimationInfo)
                 m_goValue.Transport.PathProgress -= m_goValue.Transport.PathProgress % GetTransportPeriod();    // align to period
             m_goValue.Transport.CurrentSeg = 0;
             m_goValue.Transport.StateUpdateTimer = 0;
             m_goValue.Transport.StopFrames = new std::vector<uint32>();
             if (goinfo->transport.Timeto2ndfloor > 0)
                 m_goValue.Transport.StopFrames->push_back(goinfo->transport.Timeto2ndfloor);
             if (goinfo->transport.Timeto3rdfloor > 0)
                 m_goValue.Transport.StopFrames->push_back(goinfo->transport.Timeto3rdfloor);
             if (goinfo->transport.Timeto4thfloor > 0)
                 m_goValue.Transport.StopFrames->push_back(goinfo->transport.Timeto4thfloor);
             if (goinfo->transport.Timeto5thfloor > 0)
                 m_goValue.Transport.StopFrames->push_back(goinfo->transport.Timeto5thfloor);
             if (goinfo->transport.Timeto6thfloor > 0)
                 m_goValue.Transport.StopFrames->push_back(goinfo->transport.Timeto6thfloor);
             if (goinfo->transport.Timeto7thfloor > 0)
                 m_goValue.Transport.StopFrames->push_back(goinfo->transport.Timeto7thfloor);
             if (goinfo->transport.Timeto8thfloor > 0)
                 m_goValue.Transport.StopFrames->push_back(goinfo->transport.Timeto8thfloor);
             if (goinfo->transport.Timeto9thfloor > 0)
                 m_goValue.Transport.StopFrames->push_back(goinfo->transport.Timeto9thfloor);
             if (goinfo->transport.Timeto10thfloor > 0)
                 m_goValue.Transport.StopFrames->push_back(goinfo->transport.Timeto10thfloor);
             if (goinfo->transport.startOpen)
                 SetTransportState(GO_STATE_TRANSPORT_STOPPED, goinfo->transport.startOpen - 1);
             else
                 SetTransportState(GO_STATE_TRANSPORT_ACTIVE);
 
             SetGoAnimProgress(animprogress);
             break;
         }
         case GAMEOBJECT_TYPE_FISHINGNODE:
             SetGoAnimProgress(0);
             break;
         case GAMEOBJECT_TYPE_TRAP:
             if (GetGOInfo()->trap.stealthed)
             {
                 m_stealth.AddFlag(STEALTH_TRAP);
                 m_stealth.AddValue(STEALTH_TRAP, 70);
             }
 
             if (GetGOInfo()->trap.stealthAffected)
             {
                 m_invisibility.AddFlag(INVISIBILITY_TRAP);
                 m_invisibility.AddValue(INVISIBILITY_TRAP, 300);
             }
             break;
         default:
             SetGoAnimProgress(animprogress);
             break;
     }
 
     if (GameObjectAddon const* addon = sObjectMgr->GetGameObjectAddon(GetSpawnId()))
     {
         if (addon->InvisibilityValue)
         {
             m_invisibility.AddFlag(addon->invisibilityType);
             m_invisibility.AddValue(addon->invisibilityType, addon->InvisibilityValue);
         }
     }
 
     LastUsedScriptID = GetGOInfo()->ScriptId;
     AIM_Initialize();
 
     // Initialize loot duplicate count depending on raid difficulty
     if (map->Is25ManRaid())
         loot.maxDuplicates = 3;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

GameObjectModel * GameObject::CreateModel ( )

protected

 {
     return GameObjectModel::Create(Trinity::make_unique<GameObjectModelOwnerImpl>(this), sWorld->GetDataPath());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::Delete ( )

 {
     SetLootState(GO_NOT_READY);
     RemoveFromOwner();
 
     SendObjectDeSpawnAnim(GetGUID());
 
     SetGoState(GO_STATE_READY);
     SetUInt32Value(GAMEOBJECT_FLAGS, GetGOInfo()->flags);
 
     uint32 poolid = GetSpawnId() ? sPoolMgr->IsPartOfAPool<GameObject>(GetSpawnId()) : 0;
     if (poolid)
         sPoolMgr->UpdatePool<GameObject>(poolid, GetSpawnId());
     else
         AddObjectToRemoveList();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::DeleteFromDB ( )

 {
     GetMap()->RemoveGORespawnTime(m_spawnId);
     sObjectMgr->DeleteGOData(m_spawnId);
 
     PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_GAMEOBJECT);
 
     stmt->setUInt64(0, m_spawnId);
 
     WorldDatabase.Execute(stmt);
 
     stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_EVENT_GAMEOBJECT);
 
     stmt->setUInt64(0, m_spawnId);
 
     WorldDatabase.Execute(stmt);
 }

Here is the call graph for this function:

void GameObject::EnableCollision ( bool enable )

 {
     if (!m_model)
         return;
 
     /*if (enable && !GetMap()->ContainsGameObjectModel(*m_model))
         GetMap()->InsertGameObjectModel(*m_model);*/
 
     m_model->enable(enable ? GetPhaseMask() : 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::EventInform	(	uint32	eventId,
		WorldObject *	invoker = `NULL`
	)

 {
     if (!eventId)
         return;
 
     if (AI())
         AI()->EventInform(eventId);
 
     if (GetZoneScript())
         GetZoneScript()->ProcessEvent(this, eventId);
 
     if (BattlegroundMap* bgMap = GetMap()->ToBattlegroundMap())
         if (bgMap->GetBG())
             bgMap->GetBG()->ProcessEvent(this, eventId, invoker);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint16 GameObject::GetAIAnimKitId ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

1086 { return _animKitId; }

GameObject::_animKitId

uint16 _animKitId

Definition: GameObject.h:1133

std::string GameObject::GetAIName ( ) const

 {
     if (GameObjectTemplate const* got = sObjectMgr->GetGameObjectTemplate(GetEntry()))
         return got->AIName;
 
     return "";
 }

Here is the call graph for this function:

Here is the caller graph for this function:

GameObjectDestructibleState GameObject::GetDestructibleState ( ) const

inline

         {
             if (HasFlag(GAMEOBJECT_FLAGS, GO_FLAG_DESTROYED))
                 return GO_DESTRUCTIBLE_DESTROYED;
             if (HasFlag(GAMEOBJECT_FLAGS, GO_FLAG_DAMAGED))
                 return GO_DESTRUCTIBLE_DAMAGED;
             return GO_DESTRUCTIBLE_INTACT;
         }

Here is the caller graph for this function:

uint32 GameObject::GetDisplayId ( ) const

inline

1065 { return GetUInt32Value(GAMEOBJECT_DISPLAYID); }

Object::GetUInt32Value

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

GAMEOBJECT_DISPLAYID

Definition: UpdateFields.h:318

Here is the caller graph for this function:

uint32 GameObject::GetFaction ( ) const

inline

1067 { return GetUInt32Value(GAMEOBJECT_FACTION); }

Object::GetUInt32Value

uint32 GetUInt32Value(uint16 index) const

Definition: Object.cpp:300

GAMEOBJECT_FACTION

Definition: UpdateFields.h:321

void GameObject::getFishLoot	(	Loot *	loot,
		Player *	loot_owner
	)

 {
     fishloot->clear();
 
     uint32 zone, subzone;
     uint32 defaultzone = 1;
     GetZoneAndAreaId(zone, subzone);
 
     // if subzone loot exist use it
     fishloot->FillLoot(subzone, LootTemplates_Fishing, loot_owner, true, true);
     if (fishloot->empty())  //use this becase if zone or subzone has set LOOT_MODE_JUNK_FISH,Even if no normal drop, fishloot->FillLoot return true. it wrong.
     {
         //subzone no result,use zone loot
         fishloot->FillLoot(zone, LootTemplates_Fishing, loot_owner, true, true);
         //use zone 1 as default, somewhere fishing got nothing,becase subzone and zone not set, like Off the coast of Storm Peaks.
         if (fishloot->empty())
             fishloot->FillLoot(defaultzone, LootTemplates_Fishing, loot_owner, true, true);
     }
 }

Here is the call graph for this function:

void GameObject::getFishLootJunk	(	Loot *	loot,
		Player *	loot_owner
	)

 {
     fishloot->clear();
 
     uint32 zone, subzone;
     uint32 defaultzone = 1;
     GetZoneAndAreaId(zone, subzone);
 
     // if subzone loot exist use it
     fishloot->FillLoot(subzone, LootTemplates_Fishing, loot_owner, true, true, LOOT_MODE_JUNK_FISH);
     if (fishloot->empty())  //use this becase if zone or subzone has normal mask drop, then fishloot->FillLoot return true.
     {
         //use zone loot
         fishloot->FillLoot(zone, LootTemplates_Fishing, loot_owner, true, true, LOOT_MODE_JUNK_FISH);
         if (fishloot->empty())
             //use zone 1 as default
             fishloot->FillLoot(defaultzone, LootTemplates_Fishing, loot_owner, true, true, LOOT_MODE_JUNK_FISH);
     }
 }

Here is the call graph for this function:

uint8 GameObject::GetGoAnimProgress ( ) const

inline

972 { return GetByteValue(GAMEOBJECT_BYTES_1, 3); }

Definition: UpdateFields.h:323

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition: Object.cpp:318

Here is the caller graph for this function:

uint8 GameObject::GetGoArtKit ( ) const

inline

970 { return GetByteValue(GAMEOBJECT_BYTES_1, 2); }

Definition: UpdateFields.h:323

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition: Object.cpp:318

Here is the caller graph for this function:

GameObjectData const* GameObject::GetGOData ( ) const

inline

895 { return m_goData; }

GameObject::m_goData

GameObjectData const * m_goData

Definition: GameObject.h:1112

Here is the caller graph for this function:

GameObjectTemplate const* GameObject::GetGOInfo ( ) const

inline

894 { return m_goInfo; }

GameObject::m_goInfo

GameObjectTemplate const * m_goInfo

Definition: GameObject.h:1111

Here is the caller graph for this function:

GOState GameObject::GetGoState ( ) const

inline

966 { return GOState(GetByteValue(GAMEOBJECT_BYTES_1, 0)); }

Definition: UpdateFields.h:323

GOState

Definition: GameObject.h:820

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition: Object.cpp:318

Here is the caller graph for this function:

GameobjectTypes GameObject::GetGoType ( ) const

inline

964 { return GameobjectTypes(GetByteValue(GAMEOBJECT_BYTES_1, 1)); }

GameobjectTypes

Definition: SharedDefines.h:2063

Definition: UpdateFields.h:323

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition: Object.cpp:318

Here is the caller graph for this function:

GameObjectValue const* GameObject::GetGOValue ( ) const

inline

896 { return &m_goValue; }

GameObject::m_goValue

GameObjectValue m_goValue

Definition: GameObject.h:1113

Here is the caller graph for this function:

float GameObject::GetInteractionDistance ( ) const

Todo:: find out how the client calculates the maximal usage distance to spellless working

 {
     switch (GetGoType())
     {
         // gameobjects like guildbanks and mailboxes - 10.0 is a just an abitrary choosen number
         case GAMEOBJECT_TYPE_GUILD_BANK:
         case GAMEOBJECT_TYPE_MAILBOX:
             return 10.0f;
         case GAMEOBJECT_TYPE_FISHINGHOLE:
         case GAMEOBJECT_TYPE_FISHINGNODE:
             return 20.0f + CONTACT_DISTANCE; // max spell range
         default:
             return INTERACTION_DISTANCE;
     }
 }

Here is the call graph for this function:

uint8 GameObject::getLevelForTarget ( WorldObject const * target ) const

inlineoverridevirtual

Reimplemented from WorldObject.

         {
             if (Unit* owner = GetOwner())
                 return owner->getLevelForTarget(target);
 
             return 1;
         }

uint16 GameObject::GetLootMode ( ) const

inline

985 { return m_LootMode; }

GAMEOBJECT_FIELD_CREATED_BY

uint16 m_LootMode

Definition: GameObject.h:1120

Player * GameObject::GetLootRecipient ( ) const

 {
     if (!m_lootRecipient)
         return NULL;
     return ObjectAccessor::FindConnectedPlayer(m_lootRecipient);
 }

Here is the call graph for this function:

Group * GameObject::GetLootRecipientGroup ( ) const

 {
     if (!m_lootRecipientGroup)
         return NULL;
     return sGroupMgr->GetGroupByGUID(m_lootRecipientGroup);
 }

Here is the caller graph for this function:

LootState GameObject::getLootState ( ) const

inline

981 { return m_lootState; }

GameObject::m_lootState

LootState m_lootState

Definition: GameObject.h:1096

Here is the caller graph for this function:

std::string const & GameObject::GetNameForLocaleIdx ( LocaleConstant locale_idx ) const

overridevirtual

Reimplemented from WorldObject.

 {
     if (loc_idx != DEFAULT_LOCALE)
     {
         uint8 uloc_idx = uint8(loc_idx);
         if (GameObjectLocale const* cl = sObjectMgr->GetGameObjectLocale(GetEntry()))
             if (cl->Name.size() > uloc_idx && !cl->Name[uloc_idx].empty())
                 return cl->Name[uloc_idx];
     }
 
     return GetName();
 }

Here is the call graph for this function:

Unit * GameObject::GetOwner ( ) const

 {
     return ObjectAccessor::GetUnit(*this, GetOwnerGUID());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ObjectGuid GameObject::GetOwnerGUID ( ) const

inline

925 { return GetGuidValue(GAMEOBJECT_FIELD_CREATED_BY); }

Definition: UpdateFields.h:317

Object::GetGuidValue

ObjectGuid const & GetGuidValue(uint16 index) const

Definition: Object.cpp:332

Here is the caller graph for this function:

uint32 GameObject::GetRespawnDelay ( ) const

inline

959 { return m_respawnDelayTime; }

GameObject::m_respawnDelayTime

uint32 m_respawnDelayTime

Definition: GameObject.h:1095

Here is the caller graph for this function:

void GameObject::GetRespawnPosition	(	float &	x,
		float &	y,
		float &	z,
		float *	ori = `NULL`
	)		const

 {
     if (m_spawnId)
     {
         if (GameObjectData const* data = sObjectMgr->GetGOData(GetSpawnId()))
         {
             x = data->posX;
             y = data->posY;
             z = data->posZ;
             if (ori)
                 *ori = data->orientation;
             return;
         }
     }
 
     x = GetPositionX();
     y = GetPositionY();
     z = GetPositionZ();
     if (ori)
         *ori = GetOrientation();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

time_t GameObject::GetRespawnTime ( ) const

inline

935 { return m_respawnTime; }

GameObject::m_respawnTime

time_t m_respawnTime

Definition: GameObject.h:1094

Here is the caller graph for this function:

time_t GameObject::GetRespawnTimeEx ( ) const

inline

         {
             time_t now = time(NULL);
             if (m_respawnTime > now)
                 return m_respawnTime;
             else
                 return now;
         }

Here is the caller graph for this function:

uint64 GameObject::GetRotation ( ) const

inline

1059 { return m_rotation; }

GameObject::m_rotation

uint64 m_rotation

Definition: GameObject.h:1115

virtual uint32 GameObject::GetScriptId ( ) const

inlinevirtual

1060 { return GetGOInfo()->ScriptId; }

GameObjectTemplate::ScriptId

GameObjectTemplate const * GetGOInfo() const

Definition: GameObject.h:894

uint32 ScriptId

Definition: GameObject.h:625

Here is the caller graph for this function:

ObjectGuid::LowType GameObject::GetSpawnId ( ) const

inline

902 { return m_spawnId; }

GameObject::m_spawnId

ObjectGuid::LowType m_spawnId

For new or temporary gameobjects is 0 for saved it is lowguid.

Definition: GameObject.h:1110

Here is the caller graph for this function:

uint32 GameObject::GetSpellId ( ) const

inline

933 { return m_spellId;}

GameObject::m_spellId

uint32 m_spellId

Definition: GameObject.h:1093

Here is the caller graph for this function:

float GameObject::GetStationaryO ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

1079 { if (GetGOInfo()->type != GAMEOBJECT_TYPE_MAP_OBJ_TRANSPORT) return m_stationaryPosition.GetOrientation(); return GetOrientation(); }

Position m_stationaryPosition

Definition: GameObject.h:1116

Position::GetOrientation

float GetOrientation() const

Definition: Position.h:107

Definition: SharedDefines.h:2080

GameObjectTemplate const * GetGOInfo() const

Definition: GameObject.h:894

float GameObject::GetStationaryX ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

1076 { if (GetGOInfo()->type != GAMEOBJECT_TYPE_MAP_OBJ_TRANSPORT) return m_stationaryPosition.GetPositionX(); return GetPositionX(); }

Position m_stationaryPosition

Definition: GameObject.h:1116

Definition: SharedDefines.h:2080

GameObjectTemplate const * GetGOInfo() const

Definition: GameObject.h:894

Position::GetPositionX

float GetPositionX() const

Definition: Position.h:104

float GameObject::GetStationaryY ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

1077 { if (GetGOInfo()->type != GAMEOBJECT_TYPE_MAP_OBJ_TRANSPORT) return m_stationaryPosition.GetPositionY(); return GetPositionY(); }

Position m_stationaryPosition

Definition: GameObject.h:1116

Definition: SharedDefines.h:2080

Position::GetPositionY

float GetPositionY() const

Definition: Position.h:105

GameObjectTemplate const * GetGOInfo() const

Definition: GameObject.h:894

float GameObject::GetStationaryZ ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

1078 { if (GetGOInfo()->type != GAMEOBJECT_TYPE_MAP_OBJ_TRANSPORT) return m_stationaryPosition.GetPositionZ(); return GetPositionZ(); }

Position m_stationaryPosition

Definition: GameObject.h:1116

Definition: SharedDefines.h:2080

Position::GetPositionZ

float GetPositionZ() const

Definition: Position.h:106

GameObject::m_unique_users

GameObjectTemplate const * GetGOInfo() const

Definition: GameObject.h:894

uint32 GameObject::GetTransportPeriod ( ) const

virtual

Reimplemented in Transport.

 {
     ASSERT(GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT);
     if (m_goValue.Transport.AnimationInfo)
         return m_goValue.Transport.AnimationInfo->TotalTime;
 
     return 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32 GameObject::GetUniqueUseCount ( ) const

inline

1003 { return uint32(m_unique_users.size()); }

GuidSet m_unique_users

Definition: GameObject.h:1104

G3D::uint32

uint32_t uint32

Definition: g3dmath.h:168

Here is the caller graph for this function:

uint32 GameObject::GetUseCount ( ) const

inline

1002 { return m_usetimes; }

GameObject::m_usetimes

uint32 m_usetimes

Definition: GameObject.h:1105

Here is the caller graph for this function:

bool GameObject::hasInvolvedQuest ( uint32 quest_id ) const

overridevirtual

Reimplemented from Object.

 {
     QuestRelationBounds qir = sObjectMgr->GetGOQuestInvolvedRelationBounds(GetEntry());
     for (QuestRelations::const_iterator itr = qir.first; itr != qir.second; ++itr)
     {
         if (itr->second == quest_id)
             return true;
     }
     return false;
 }

Here is the call graph for this function:

bool GameObject::HasLootMode ( uint16 lootMode ) const

inline

986 { return (m_LootMode & lootMode) != 0; }

GameObject::m_lootRecipientGroup

uint16 m_LootMode

Definition: GameObject.h:1120

bool GameObject::HasLootRecipient ( ) const

inline

1013 { return !m_lootRecipient.IsEmpty() || !m_lootRecipientGroup.IsEmpty(); }

ObjectGuid m_lootRecipientGroup

Definition: GameObject.h:1119

GameObject::m_lootRecipient

ObjectGuid m_lootRecipient

Definition: GameObject.h:1118

ObjectGuid::IsEmpty

bool IsEmpty() const

Definition: ObjectGuid.h:242

Here is the caller graph for this function:

bool GameObject::hasQuest ( uint32 quest_id ) const

overridevirtual

Reimplemented from Object.

 {
     QuestRelationBounds qr = sObjectMgr->GetGOQuestRelationBounds(GetEntry());
     for (QuestRelations::const_iterator itr = qr.first; itr != qr.second; ++itr)
     {
         if (itr->second == quest_id)
             return true;
     }
     return false;
 }

Here is the call graph for this function:

bool GameObject::IsAlwaysVisibleFor ( WorldObject const * seer ) const

overridevirtual

Reimplemented from WorldObject.

 {
     if (WorldObject::IsAlwaysVisibleFor(seer))
         return true;
 
     if (IsTransport() || IsDestructibleBuilding())
         return true;
 
     if (!seer)
         return false;
 
     // Always seen by owner and friendly units
     if (!GetOwnerGUID().IsEmpty())
     {
         if (seer->GetGUID() == GetOwnerGUID())
             return true;
 
         Unit* owner = GetOwner();
         if (Unit const* unitSeer = seer->ToUnit())
             if (owner && owner->IsFriendlyTo(unitSeer))
                 return true;
     }
 
     return false;
 }

Here is the call graph for this function:

bool GameObject::IsDestructibleBuilding ( ) const

 {
     GameObjectTemplate const* gInfo = GetGOInfo();
     if (!gInfo)
         return false;
 
     return gInfo->type == GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool GameObject::IsDynTransport ( ) const

 {
     // If something is marked as a transport, don't transmit an out of range packet for it.
     GameObjectTemplate const* gInfo = GetGOInfo();
     if (!gInfo)
         return false;
 
     return gInfo->type == GAMEOBJECT_TYPE_MAP_OBJ_TRANSPORT || (gInfo->type == GAMEOBJECT_TYPE_TRANSPORT && m_goValue.Transport.StopFrames->empty());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool GameObject::IsInRange	(	float	x,
		float	y,
		float	z,
		float	radius
	)		const

Check if the distance between the 2 objects is 0, can happen if both objects are on the same position. The code below this check wont crash if dist is 0 because 0/0 in float operations is valid, and returns infinite

 {
     GameObjectDisplayInfoEntry const* info = sGameObjectDisplayInfoStore.LookupEntry(m_goInfo->displayId);
     if (!info)
         return IsWithinDist3d(x, y, z, radius);
 
     float sinA = std::sin(GetOrientation());
     float cosA = std::cos(GetOrientation());
     float dx = x - GetPositionX();
     float dy = y - GetPositionY();
     float dz = z - GetPositionZ();
     float dist = std::sqrt(dx*dx + dy*dy);
     if (G3D::fuzzyEq(dist, 0.0f))
         return true;
 
     float sinB = dx / dist;
     float cosB = dy / dist;
     dx = dist * (cosA * cosB + sinA * sinB);
     dy = dist * (cosA * sinB - sinA * cosB);
     return dx < info->GeoBoxMax.X + radius && dx > info->GeoBoxMin.X - radius
         && dy < info->GeoBoxMax.Y + radius && dy > info->GeoBoxMin.Y - radius
         && dz < info->GeoBoxMax.Z + radius && dz > info->GeoBoxMin.Z - radius;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool GameObject::IsInSkillupList ( ObjectGuid const & playerGuid ) const

inline

         {
             return m_SkillupList.count(playerGuid) > 0;
         }

Here is the caller graph for this function:

bool GameObject::IsInvisibleDueToDespawn ( ) const

overridevirtual

Reimplemented from WorldObject.

 {
     if (WorldObject::IsInvisibleDueToDespawn())
         return true;
 
     // Despawned
     if (!isSpawned())
         return true;
 
     return false;
 }

Here is the call graph for this function:

bool GameObject::IsLootAllowedFor ( Player const * player ) const

 {
     if (!m_lootRecipient && !m_lootRecipientGroup)
         return true;
 
     if (player->GetGUID() == m_lootRecipient)
         return true;
 
     Group const* playerGroup = player->GetGroup();
     if (!playerGroup || playerGroup != GetLootRecipientGroup()) // if we dont have a group we arent the recipient
         return false;                                           // if go doesnt have group bound it means it was solo killed by someone else
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool GameObject::IsNeverVisible ( ) const

overridevirtual

Reimplemented from WorldObject.

 {
     if (WorldObject::IsNeverVisible())
         return true;
 
     if (GetGoType() == GAMEOBJECT_TYPE_SPELL_FOCUS && GetGOInfo()->spellFocus.serverOnly == 1)
         return true;
 
     return false;
 }

Here is the call graph for this function:

bool GameObject::isSpawned ( ) const

inline

         {
             return m_respawnDelayTime == 0 ||
                 (m_respawnTime > 0 && !m_spawnedByDefault) ||
                 (m_respawnTime == 0 && m_spawnedByDefault);
         }

Here is the caller graph for this function:

bool GameObject::isSpawnedByDefault ( ) const

inline

957 { return m_spawnedByDefault; }

GameObject::m_spawnedByDefault

bool m_spawnedByDefault

Definition: GameObject.h:1098

Here is the caller graph for this function:

bool GameObject::IsTransport ( ) const

 {
     // If something is marked as a transport, don't transmit an out of range packet for it.
     GameObjectTemplate const* gInfo = GetGOInfo();
     if (!gInfo)
         return false;
 
     return gInfo->type == GAMEOBJECT_TYPE_TRANSPORT || gInfo->type == GAMEOBJECT_TYPE_MAP_OBJ_TRANSPORT;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool GameObject::LoadFromDB	(	ObjectGuid::LowType	spawnId,
		Map *	map
	)

inline

911 { return LoadGameObjectFromDB(spawnId, map, false); }

GameObject::LoadGameObjectFromDB

bool LoadGameObjectFromDB(ObjectGuid::LowType spawnId, Map *map, bool addToMap=true)

Definition: GameObject.cpp:858

bool GameObject::LoadGameObjectFromDB	(	ObjectGuid::LowType	spawnId,
		Map *	map,
		bool	addToMap = `true`
	)

 {
     GameObjectData const* data = sObjectMgr->GetGOData(spawnId);
     if (!data)
     {
         TC_LOG_ERROR("sql.sql", "Gameobject (GUID: " UI64FMTD ") not found in table `gameobject`, can't load. ", spawnId);
         return false;
     }
 
     uint32 entry = data->id;
     //uint32 map_id = data->mapid;                          // already used before call
     uint32 phaseMask = data->phaseMask;
     float x = data->posX;
     float y = data->posY;
     float z = data->posZ;
     float ang = data->orientation;
 
     float rotation0 = data->rotation0;
     float rotation1 = data->rotation1;
     float rotation2 = data->rotation2;
     float rotation3 = data->rotation3;
 
     uint32 animprogress = data->animprogress;
     GOState go_state = data->go_state;
     uint32 artKit = data->artKit;
 
     m_spawnId = spawnId;
     if (!Create(map->GenerateLowGuid<HighGuid::GameObject>(), entry, map, phaseMask, x, y, z, ang, rotation0, rotation1, rotation2, rotation3, animprogress, go_state, artKit))
         return false;
 
     if (data->phaseid)
         SetInPhase(data->phaseid, false, true);
 
     if (data->phaseGroup)
     {
         // Set the gameobject in all the phases of the phasegroup
         for (auto ph : sDB2Manager.GetPhasesForGroup(data->phaseGroup))
             SetInPhase(ph, false, true);
     }
 
     if (data->spawntimesecs >= 0)
     {
         m_spawnedByDefault = true;
 
         if (!GetGOInfo()->GetDespawnPossibility() && !GetGOInfo()->IsDespawnAtAction())
         {
             SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_NODESPAWN);
             m_respawnDelayTime = 0;
             m_respawnTime = 0;
         }
         else
         {
             m_respawnDelayTime = data->spawntimesecs;
             m_respawnTime = GetMap()->GetGORespawnTime(m_spawnId);
 
             // ready to respawn
             if (m_respawnTime && m_respawnTime <= time(NULL))
             {
                 m_respawnTime = 0;
                 GetMap()->RemoveGORespawnTime(m_spawnId);
             }
         }
     }
     else
     {
         m_spawnedByDefault = false;
         m_respawnDelayTime = -data->spawntimesecs;
         m_respawnTime = 0;
     }
 
     m_goData = data;
 
     if (addToMap && !GetMap()->AddToMap(this))
         return false;
 
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

GameObject * GameObject::LookupFishingHoleAround ( float range )

 {
     GameObject* ok = NULL;
 
     CellCoord p(Trinity::ComputeCellCoord(GetPositionX(), GetPositionY()));
     Cell cell(p);
     Trinity::NearestGameObjectFishingHole u_check(*this, range);
     Trinity::GameObjectSearcher<Trinity::NearestGameObjectFishingHole> checker(this, ok, u_check);
 
     TypeContainerVisitor<Trinity::GameObjectSearcher<Trinity::NearestGameObjectFishingHole>, GridTypeMapContainer > grid_object_checker(checker);
     cell.Visit(p, grid_object_checker, *GetMap(), *this, range);
 
     return ok;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::ModifyHealth	(	int32	change,
		Unit *	attackerOrHealer = `NULL`,
		uint32	spellId = `0`
	)

Todo:: : pass attackerOrHealer instead of player

 {
     if (!m_goValue.Building.MaxHealth || !change)
         return;
 
     // prevent double destructions of the same object
     if (change < 0 && !m_goValue.Building.Health)
         return;
 
     if (int32(m_goValue.Building.Health) + change <= 0)
         m_goValue.Building.Health = 0;
     else if (int32(m_goValue.Building.Health) + change >= int32(m_goValue.Building.MaxHealth))
         m_goValue.Building.Health = m_goValue.Building.MaxHealth;
     else
         m_goValue.Building.Health += change;
 
     // Set the health bar, value = 255 * healthPct;
     SetGoAnimProgress(m_goValue.Building.Health * 255 / m_goValue.Building.MaxHealth);
 
     Player* player = attackerOrHealer ? attackerOrHealer->GetCharmerOrOwnerPlayerOrPlayerItself() : NULL;
 
     // dealing damage, send packet
     if (player)
     {
         WorldPackets::GameObject::DestructibleBuildingDamage packet;
         packet.Caster = attackerOrHealer->GetGUID(); // todo: this can be a GameObject
         packet.Target = GetGUID();
         packet.Damage = -change;
         packet.Owner = player->GetGUID();
         packet.SpellID = spellId;
         player->SendDirectMessage(packet.Write());
     }
 
     GameObjectDestructibleState newState = GetDestructibleState();
 
     if (!m_goValue.Building.Health)
         newState = GO_DESTRUCTIBLE_DESTROYED;
     else if (m_goValue.Building.Health <= 10000/*GetGOInfo()->destructibleBuilding.damagedNumHits*/) // TODO: Get health somewhere
         newState = GO_DESTRUCTIBLE_DAMAGED;
     else if (m_goValue.Building.Health == m_goValue.Building.MaxHealth)
         newState = GO_DESTRUCTIBLE_INTACT;
 
     if (newState == GetDestructibleState())
         return;
 
     SetDestructibleState(newState, player, false);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::Refresh ( )

 {
     // Do not refresh despawned GO from spellcast (GO's from spellcast are destroyed after despawn)
     if (m_respawnTime > 0 && m_spawnedByDefault)
         return;
 
     if (isSpawned())
         GetMap()->AddToMap(this);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::RelocateStationaryPosition	(	float	x,
		float	y,
		float	z,
		float	o
	)

inline

1080 { m_stationaryPosition.Relocate(x, y, z, o); }

Position m_stationaryPosition

Definition: GameObject.h:1116

Position::Relocate

void Relocate(float x, float y)

Definition: Position.h:67

G3D::z

G3D::int16 z

Definition: Vector3int16.h:46

G3D::y

G3D::int16 y

Definition: Vector2int16.h:38

G3D::x

G3D::int16 x

Definition: Vector2int16.h:37

Here is the caller graph for this function:

void GameObject::RemoveFromOwner ( )

private

 {
     ObjectGuid ownerGUID = GetOwnerGUID();
     if (!ownerGUID)
         return;
 
     if (Unit* owner = ObjectAccessor::GetUnit(*this, ownerGUID))
     {
         owner->RemoveGameObject(this, false);
         ASSERT(!GetOwnerGUID());
         return;
     }
 
     // This happens when a mage portal is despawned after the caster changes map (for example using the portal)
     TC_LOG_DEBUG("misc", "Removed GameObject (%s SpellId: %u LinkedGO: %u) that just lost any reference to the owner (%s) GO list",
         GetGUID().ToString().c_str(), m_spellId, GetGOInfo()->GetLinkedGameObjectEntry(), ownerGUID.ToString().c_str());
     SetOwnerGUID(ObjectGuid::Empty);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::RemoveFromWorld ( )

overridevirtual

Remove the gameobject from the accessor

Reimplemented from WorldObject.

 {
     if (IsInWorld())
     {
         if (m_zoneScript)
             m_zoneScript->OnGameObjectRemove(this);
 
         RemoveFromOwner();
         if (m_model)
             if (GetMap()->ContainsGameObjectModel(*m_model))
                 GetMap()->RemoveGameObjectModel(*m_model);
 
         WorldObject::RemoveFromWorld();
 
         if (m_spawnId)
             Trinity::Containers::MultimapErasePair(GetMap()->GetGameObjectBySpawnIdStore(), m_spawnId, this);
         GetMap()->GetObjectsStore().Remove<GameObject>(GetGUID());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::RemoveLootMode ( uint16 lootMode )

inline

989 { m_LootMode &= ~lootMode; }

uint16 m_LootMode

Definition: GameObject.h:1120

void GameObject::ResetDoorOrButton ( )

 {
     if (m_lootState == GO_READY || m_lootState == GO_JUST_DEACTIVATED)
         return;
 
     SwitchDoorOrButton(false);
     SetLootState(GO_JUST_DEACTIVATED);
     m_cooldownTime = 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::ResetLootMode ( )

inline

990 { m_LootMode = LOOT_MODE_DEFAULT; }

LOOT_MODE_DEFAULT

Definition: SharedDefines.h:69

uint16 m_LootMode

Definition: GameObject.h:1120

Here is the caller graph for this function:

void GameObject::Respawn ( )

 {
     if (m_spawnedByDefault && m_respawnTime > 0)
     {
         m_respawnTime = time(NULL);
         GetMap()->RemoveGORespawnTime(m_spawnId);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SaveRespawnTime ( )

overridevirtual

Reimplemented from WorldObject.

 {
     if (m_goData && m_goData->dbData && m_respawnTime > time(NULL) && m_spawnedByDefault)
         GetMap()->SaveGORespawnTime(m_spawnId, m_respawnTime);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SaveToDB ( )

 {
     // this should only be used when the gameobject has already been loaded
     // preferably after adding to map, because mapid may not be valid otherwise
     GameObjectData const* data = sObjectMgr->GetGOData(m_spawnId);
     if (!data)
     {
         TC_LOG_ERROR("misc", "GameObject::SaveToDB failed, cannot get gameobject data!");
         return;
     }
 
     SaveToDB(GetMapId(), data->spawnMask, data->phaseMask);
 }

Here is the call graph for this function:

void GameObject::SaveToDB	(	uint32	mapid,
		uint32	spawnMask,
		uint32	phaseMask
	)

 {
     const GameObjectTemplate* goI = GetGOInfo();
 
     if (!goI)
         return;
 
     if (!m_spawnId)
         m_spawnId = sObjectMgr->GenerateGameObjectSpawnId();
 
     // update in loaded data (changing data only in this place)
     GameObjectData& data = sObjectMgr->NewGOData(m_spawnId);
 
     // data->guid = guid must not be updated at save
     data.id = GetEntry();
     data.mapid = mapid;
     data.phaseMask = phaseMask;
     data.posX = GetPositionX();
     data.posY = GetPositionY();
     data.posZ = GetPositionZ();
     data.orientation = GetOrientation();
     data.rotation0 = GetFloatValue(GAMEOBJECT_PARENTROTATION+0);
     data.rotation1 = GetFloatValue(GAMEOBJECT_PARENTROTATION+1);
     data.rotation2 = GetFloatValue(GAMEOBJECT_PARENTROTATION+2);
     data.rotation3 = GetFloatValue(GAMEOBJECT_PARENTROTATION+3);
     data.spawntimesecs = m_spawnedByDefault ? m_respawnDelayTime : -(int32)m_respawnDelayTime;
     data.animprogress = GetGoAnimProgress();
     data.go_state = GetGoState();
     data.spawnMask = spawnMask;
     data.artKit = GetGoArtKit();
 
     // Update in DB
     SQLTransaction trans = WorldDatabase.BeginTransaction();
 
     uint8 index = 0;
 
     PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_GAMEOBJECT);
     stmt->setUInt64(0, m_spawnId);
     trans->Append(stmt);
 
     stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_GAMEOBJECT);
     stmt->setUInt64(index++, m_spawnId);
     stmt->setUInt32(index++, GetEntry());
     stmt->setUInt16(index++, uint16(mapid));
     stmt->setUInt8(index++, spawnMask);
     stmt->setFloat(index++, GetPositionX());
     stmt->setFloat(index++, GetPositionY());
     stmt->setFloat(index++, GetPositionZ());
     stmt->setFloat(index++, GetOrientation());
     stmt->setFloat(index++, GetFloatValue(GAMEOBJECT_PARENTROTATION));
     stmt->setFloat(index++, GetFloatValue(GAMEOBJECT_PARENTROTATION+1));
     stmt->setFloat(index++, GetFloatValue(GAMEOBJECT_PARENTROTATION+2));
     stmt->setFloat(index++, GetFloatValue(GAMEOBJECT_PARENTROTATION+3));
     stmt->setInt32(index++, int32(m_respawnDelayTime));
     stmt->setUInt8(index++, GetGoAnimProgress());
     stmt->setUInt8(index++, uint8(GetGoState()));
     trans->Append(stmt);
 
     WorldDatabase.CommitTransaction(trans);
 }

Here is the call graph for this function:

void GameObject::SendCustomAnim ( uint32 anim )

 {
     WorldPackets::GameObject::GameObjectCustomAnim customAnim;
     customAnim.ObjectGUID = GetGUID();
     customAnim.CustomAnim = anim;
     SendMessageToSet(customAnim.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SetAnimKitId	(	uint16	animKitId,
		bool	oneshot
	)

 {
     if (_animKitId == animKitId)
         return;
 
     if (animKitId && !sAnimKitStore.LookupEntry(animKitId))
         return;
 
     if (!oneshot)
         _animKitId = animKitId;
     else
         _animKitId = 0;
 
     WorldPackets::GameObject::GameObjectActivateAnimKit activateAnimKit;
     activateAnimKit.ObjectGUID = GetGUID();
     activateAnimKit.AnimKitID = animKitId;
     activateAnimKit.Maintain = !oneshot;
     SendMessageToSet(activateAnimKit.Write(), true);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SetDestructibleState	(	GameObjectDestructibleState	state,
		Player *	eventInvoker = `NULL`,
		bool	setHealth = `false`
	)

 {
     // the user calling this must know he is already operating on destructible gameobject
     ASSERT(GetGoType() == GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING);
 
     switch (state)
     {
         case GO_DESTRUCTIBLE_INTACT:
             RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_DAMAGED | GO_FLAG_DESTROYED);
             SetDisplayId(m_goInfo->displayId);
             if (setHealth)
             {
                 m_goValue.Building.Health = m_goValue.Building.MaxHealth;
                 SetGoAnimProgress(255);
             }
             EnableCollision(true);
             break;
         case GO_DESTRUCTIBLE_DAMAGED:
         {
             EventInform(m_goInfo->destructibleBuilding.DamagedEvent, eventInvoker);
             sScriptMgr->OnGameObjectDamaged(this, eventInvoker);
 
             RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_DESTROYED);
             SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_DAMAGED);
 
             uint32 modelId = m_goInfo->displayId;
             if (DestructibleModelDataEntry const* modelData = sDestructibleModelDataStore.LookupEntry(m_goInfo->destructibleBuilding.DestructibleModelRec))
                 if (modelData->StateDamaged.DisplayID)
                     modelId = modelData->StateDamaged.DisplayID;
             SetDisplayId(modelId);
 
             if (setHealth)
             {
                 m_goValue.Building.Health = 10000/*m_goInfo->destructibleBuilding.damagedNumHits*/;
                 uint32 maxHealth = m_goValue.Building.MaxHealth;
                 // in this case current health is 0 anyway so just prevent crashing here
                 if (!maxHealth)
                     maxHealth = 1;
                 SetGoAnimProgress(m_goValue.Building.Health * 255 / maxHealth);
             }
             break;
         }
         case GO_DESTRUCTIBLE_DESTROYED:
         {
             sScriptMgr->OnGameObjectDestroyed(this, eventInvoker);
             EventInform(m_goInfo->destructibleBuilding.DestroyedEvent, eventInvoker);
             if (eventInvoker)
                 if (Battleground* bg = eventInvoker->GetBattleground())
                     bg->DestroyGate(eventInvoker, this);
 
             RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_DAMAGED);
             SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_DESTROYED);
 
             uint32 modelId = m_goInfo->displayId;
             if (DestructibleModelDataEntry const* modelData = sDestructibleModelDataStore.LookupEntry(m_goInfo->destructibleBuilding.DestructibleModelRec))
                 if (modelData->StateDestroyed.DisplayID)
                     modelId = modelData->StateDestroyed.DisplayID;
             SetDisplayId(modelId);
 
             if (setHealth)
             {
                 m_goValue.Building.Health = 0;
                 SetGoAnimProgress(0);
             }
             EnableCollision(false);
             break;
         }
         case GO_DESTRUCTIBLE_REBUILDING:
         {
             EventInform(m_goInfo->destructibleBuilding.RebuildingEvent, eventInvoker);
             RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_DAMAGED | GO_FLAG_DESTROYED);
 
             uint32 modelId = m_goInfo->displayId;
             if (DestructibleModelDataEntry const* modelData = sDestructibleModelDataStore.LookupEntry(m_goInfo->destructibleBuilding.DestructibleModelRec))
                 if (modelData->StateRebuilding.DisplayID)
                     modelId = modelData->StateRebuilding.DisplayID;
             SetDisplayId(modelId);
 
             // restores to full health
             if (setHealth)
             {
                 m_goValue.Building.Health = m_goValue.Building.MaxHealth;
                 SetGoAnimProgress(255);
             }
             EnableCollision(true);
             break;
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SetDisplayId ( uint32 displayid )

 {
     SetUInt32Value(GAMEOBJECT_DISPLAYID, displayid);
     UpdateModel();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SetFaction ( uint32 faction )

inline

1068 { SetUInt32Value(GAMEOBJECT_FACTION, faction); }

Object::SetUInt32Value

void SetUInt32Value(uint16 index, uint32 value)

Definition: Object.cpp:996

GAMEOBJECT_FACTION

Definition: UpdateFields.h:321

Here is the caller graph for this function:

void GameObject::SetGoAnimProgress ( uint8 animprogress )

inline

973 { SetByteValue(GAMEOBJECT_BYTES_1, 3, animprogress); }

Definition: UpdateFields.h:323

Object::SetByteValue

void SetByteValue(uint16 index, uint8 offset, uint8 value)

Definition: Object.cpp:1080

Here is the caller graph for this function:

void GameObject::SetGoArtKit ( uint8 artkit )

 {
     SetByteValue(GAMEOBJECT_BYTES_1, 2, kit);
     GameObjectData* data = const_cast<GameObjectData*>(sObjectMgr->GetGOData(m_spawnId));
     if (data)
         data->artKit = kit;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SetGoArtKit	(	uint8	artkit,
		GameObject *	go,
		ObjectGuid::LowType	lowguid = `UI64LIT(0)`
	)

static

 {
     const GameObjectData* data = NULL;
     if (go)
     {
         go->SetGoArtKit(artkit);
         data = go->GetGOData();
     }
     else if (lowguid)
         data = sObjectMgr->GetGOData(lowguid);
 
     if (data)
         const_cast<GameObjectData*>(data)->artKit = artkit;
 }

Here is the call graph for this function:

void GameObject::SetGoState ( GOState state )

 {
     SetByteValue(GAMEOBJECT_BYTES_1, 0, state);
     sScriptMgr->OnGameObjectStateChanged(this, state);
     if (m_model && !IsTransport())
     {
         if (!IsInWorld())
             return;
 
         // startOpen determines whether we are going to add or remove the LoS on activation
         bool collision = false;
         if (state == GO_STATE_READY)
             collision = !collision;
 
         EnableCollision(collision);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SetGoType ( GameobjectTypes type )

inline

965 { SetByteValue(GAMEOBJECT_BYTES_1, 1, type); }

Definition: UpdateFields.h:323

Object::SetByteValue

void SetByteValue(uint16 index, uint8 offset, uint8 value)

Definition: Object.cpp:1080

Here is the caller graph for this function:

bool GameObject::SetInPhase	(	uint32	id,
		bool	update,
		bool	apply
	)

overridevirtual

Reimplemented from WorldObject.

 {
     bool res = WorldObject::SetInPhase(id, update, apply);
     if (m_model && m_model->isEnabled())
         EnableCollision(true);
 
     return res;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SetLootMode ( uint16 lootMode )

inline

987 { m_LootMode = lootMode; }

GameObject::m_spawnedByDefault

uint16 m_LootMode

Definition: GameObject.h:1120

void GameObject::SetLootRecipient ( Unit * unit )

 {
     // set the player whose group should receive the right
     // to loot the creature after it dies
     // should be set to NULL after the loot disappears
 
     if (!unit)
     {
         m_lootRecipient.Clear();
         m_lootRecipientGroup.Clear();
         return;
     }
 
     if (unit->GetTypeId() != TYPEID_PLAYER && !unit->IsVehicle())
         return;
 
     Player* player = unit->GetCharmerOrOwnerPlayerOrPlayerItself();
     if (!player)                                             // normal creature, no player involved
         return;
 
     m_lootRecipient = player->GetGUID();
     if (Group* group = player->GetGroup())
         m_lootRecipientGroup = group->GetGUID();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SetLootState	(	LootState	s,
		Unit *	unit = `NULL`
	)

 {
     m_lootState = state;
     if (unit)
         m_lootStateUnitGUID = unit->GetGUID();
     else
         m_lootStateUnitGUID.Clear();
 
     AI()->OnStateChanged(state, unit);
     sScriptMgr->OnGameObjectLootStateChanged(this, state, unit);
 
     if (GetGoType() == GAMEOBJECT_TYPE_DOOR) // only set collision for doors on SetGoState
         return;
 
     if (m_model)
     {
         bool collision = false;
         // Use the current go state
         if ((GetGoState() != GO_STATE_READY && (state == GO_ACTIVATED || state == GO_JUST_DEACTIVATED)) || state == GO_READY)
             collision = !collision;
 
         EnableCollision(collision);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SetOwnerGUID ( ObjectGuid owner )

inline

         {
             // Owner already found and different than expected owner - remove object from old owner
             if (!owner.IsEmpty() && !GetOwnerGUID().IsEmpty() && GetOwnerGUID() != owner)
             {
                 ABORT();
             }
             m_spawnedByDefault = false;                     // all object with owner is despawned after delay
             SetGuidValue(GAMEOBJECT_FIELD_CREATED_BY, owner);
         }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SetRespawnTime ( int32 respawn )

inline

         {
             m_respawnTime = respawn > 0 ? time(NULL) + respawn : 0;
             m_respawnDelayTime = respawn > 0 ? respawn : 0;
         }

Here is the caller graph for this function:

void GameObject::SetSpawnedByDefault ( bool b )

inline

958 { m_spawnedByDefault = b; }

bool m_spawnedByDefault

Definition: GameObject.h:1098

Here is the caller graph for this function:

void GameObject::SetSpellId ( uint32 id )

inline

         {
             m_spawnedByDefault = false;                     // all summoned object is despawned after delay
             m_spellId = id;
         }

Here is the caller graph for this function:

void GameObject::SetTransportState	(	GOState	state,
		uint32	stopFrame = `0`
	)

 {
     if (GetGoState() == state)
         return;
 
     ASSERT(GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT);
     ASSERT(state >= GO_STATE_TRANSPORT_ACTIVE);
     if (state == GO_STATE_TRANSPORT_ACTIVE)
     {
         m_goValue.Transport.StateUpdateTimer = 0;
         m_goValue.Transport.PathProgress = getMSTime();
         if (GetGoState() >= GO_STATE_TRANSPORT_STOPPED)
             m_goValue.Transport.PathProgress += m_goValue.Transport.StopFrames->at(GetGoState() - GO_STATE_TRANSPORT_STOPPED);
         SetGoState(GO_STATE_TRANSPORT_ACTIVE);
     }
     else
     {
         ASSERT(state < GOState(GO_STATE_TRANSPORT_STOPPED + MAX_GO_STATE_TRANSPORT_STOP_FRAMES));
         ASSERT(stopFrame < m_goValue.Transport.StopFrames->size());
         m_goValue.Transport.PathProgress = getMSTime() + m_goValue.Transport.StopFrames->at(stopFrame);
         SetGoState(GOState(GO_STATE_TRANSPORT_STOPPED + stopFrame));
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void GameObject::SwitchDoorOrButton	(	bool	activate,
		bool	alternative = `false`
	)

private

 {
     if (activate)
         SetFlag(GAMEOBJECT_FLAGS, GO_FLAG_IN_USE);
     else
         RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_IN_USE);
 
     if (GetGoState() == GO_STATE_READY)                      //if closed -> open
         SetGoState(alternative ? GO_STATE_ACTIVE_ALTERNATIVE : GO_STATE_ACTIVE);
     else                                                    //if open -> close
         SetGoState(GO_STATE_READY);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Transport* GameObject::ToTransport ( )

inline

1073 { if (GetGOInfo()->type == GAMEOBJECT_TYPE_MAP_OBJ_TRANSPORT) return reinterpret_cast<Transport*>(this); else return NULL; }

NULL

arena_t NULL

Definition: jemalloc_internal.h:624

Transport

Definition: Transport.h:28

Definition: SharedDefines.h:2080

GameObjectTemplate const * GetGOInfo() const

Definition: GameObject.h:894

Here is the caller graph for this function:

Transport const* GameObject::ToTransport ( ) const

inline

1074 { if (GetGOInfo()->type == GAMEOBJECT_TYPE_MAP_OBJ_TRANSPORT) return reinterpret_cast<Transport const*>(this); else return NULL; }

NULL

arena_t NULL

Definition: jemalloc_internal.h:624

Transport

Definition: Transport.h:28

Definition: SharedDefines.h:2080