#include "GameObject.h"

Inheritance diagram for GameObject:

Public Member Functions
	GameObject ()

	~GameObject () override

void	BuildValuesUpdate (uint8 updateType, ByteBuffer data, Player target) override

void	AddToWorld () override

void	RemoveFromWorld () override

void	CleanupsBeforeDelete (bool finalCleanup=true) override

uint32	GetDynamicFlags () const override

void	ReplaceAllDynamicFlags (uint32 flag) override

virtual bool	Create (ObjectGuid::LowType guidlow, uint32 name_id, Map *map, uint32 phaseMask, float x, float y, float z, float ang, G3D::Quat const &rotation, uint32 animprogress, GOState go_state, uint32 artKit=0)

void	Update (uint32 p_time) override

GameObjectTemplate const *	GetGOInfo () const

GameObjectTemplateAddon const *	GetTemplateAddon () const

GameObjectData const *	GetGameObjectData () const

GameObjectValue const *	GetGOValue () const

bool	IsTransport () const

bool	IsDestructibleBuilding () const

ObjectGuid::LowType	GetSpawnId () const

void	SetWorldRotationAngles (float z_rot, float y_rot, float x_rot)

void	SetWorldRotation (G3D::Quat const &rot)

void	SetTransportPathRotation (float qx, float qy, float qz, float qw)

G3D::Quat const &	GetWorldRotation () const

int64	GetPackedWorldRotation () const

G3D::Quat	GetFinalWorldRotation () const

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

void	SaveToDB (bool saveAddon=false)

void	SaveToDB (uint32 mapid, uint8 spawnMask, uint32 phaseMask, bool saveAddon=false)

virtual bool	LoadFromDB (ObjectGuid::LowType guid, Map *map)

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

void	DeleteFromDB ()

void	SetOwnerGUID (ObjectGuid owner)

ObjectGuid	GetOwnerGUID () const

Unit *	GetOwner () const

void	SetSpellId (uint32 id)

uint32	GetSpellId () const

time_t	GetRespawnTime () const

time_t	GetRespawnTimeEx () const

void	SetRespawnTime (int32 respawn)

void	SetRespawnDelay (int32 respawn)

void	Respawn ()

bool	isSpawned () const

bool	isSpawnedByDefault () const

void	SetSpawnedByDefault (bool b)

uint32	GetRespawnDelay () const

void	Refresh ()

void	DespawnOrUnsummon (Milliseconds delay=0ms, Seconds forcedRespawnTime=0s)

void	Delete ()

void	GetFishLoot (Loot fishLoot, Player lootOwner, bool junk=false)

GameobjectTypes	GetGoType () const

void	SetGoType (GameobjectTypes type)

GOState	GetGoState () const

void	SetGoState (GOState state)

uint8	GetGoArtKit () const

void	SetGoArtKit (uint8 artkit)

uint8	GetGoAnimProgress () const

void	SetGoAnimProgress (uint8 animprogress)

void	SetPhaseMask (uint32 newPhaseMask, bool update) override

void	EnableCollision (bool enable)

GameObjectFlags	GetGameObjectFlags () const

bool	HasGameObjectFlag (GameObjectFlags flags) const

void	SetGameObjectFlag (GameObjectFlags flags)

void	RemoveGameObjectFlag (GameObjectFlags flags)

void	ReplaceAllGameObjectFlags (GameObjectFlags flags)

void	Use (Unit *user)

LootState	getLootState () const

void	SetLootState (LootState s, Unit *unit=nullptr)

uint16	GetLootMode () const

bool	HasLootMode (uint16 lootMode) const

void	SetLootMode (uint16 lootMode)

void	AddLootMode (uint16 lootMode)

void	RemoveLootMode (uint16 lootMode)

void	ResetLootMode ()

void	AddToSkillupList (ObjectGuid const &playerGuid)

bool	IsInSkillupList (ObjectGuid const &playerGuid) const

void	AddUniqueUse (Player *player)

void	AddUse ()

uint32	GetUseCount () const

uint32	GetUniqueUseCount () const

void	SaveRespawnTime () override

void	SaveRespawnTime (uint32 forceDelay)

Player *	GetLootRecipient () const

Group *	GetLootRecipientGroup () const

void	SetLootRecipient (Creature *creature)

void	SetLootRecipient (Map *map)

bool	IsLootAllowedFor (Player const *player) const

bool	HasLootRecipient () const

void	SetLootGenerationTime ()

uint32	GetLootGenerationTime () const

GameObject *	GetLinkedTrap ()

void	SetLinkedTrap (GameObject *linkedTrap)

bool	hasQuest (uint32 quest_id) const override

bool	hasInvolvedQuest (uint32 quest_id) const override

bool	ActivateToQuest (Player *target) const

void	UseDoorOrButton (uint32 time_to_restore=0, bool alternative=false, Unit *user=nullptr)

void	ResetDoorOrButton ()

void	TriggeringLinkedGameObject (uint32 trapEntry, Unit *target)

bool	IsNeverVisible () const override

bool	IsAlwaysVisibleFor (WorldObject const *seer) const override

bool	IsInvisibleDueToDespawn () const override

uint8	getLevelForTarget (WorldObject const *target) const override

GameObject *	LookupFishingHoleAround (float range)

void	CastSpell (Unit *target, uint32 spell)

void	SendCustomAnim (uint32 anim)

bool	IsInRange2d (float x, float y, float radius) const

bool	IsInRange3d (float x, float y, float z, float radius) const

void	ModifyHealth (int32 change, Unit *attackerOrHealer=nullptr, uint32 spellId=0)

void	SetDestructibleBuildingModifyState (bool allow)

void	SetDestructibleState (GameObjectDestructibleState state, Player *eventInvoker=nullptr, bool setHealth=false)

GameObjectDestructibleState	GetDestructibleState () const

void	EventInform (uint32 eventId)

virtual uint32	GetScriptId () const

GameObjectAI *	AI () const

std::string const &	GetAIName () const

void	SetDisplayId (uint32 displayid)

uint32	GetDisplayId () const

void	GetRespawnPosition (float &x, float &y, float &z, float *ori=nullptr) const

void	SetPosition (float x, float y, float z, float o)

void	SetPosition (const Position &pos)

bool	IsStaticTransport () const

bool	IsMotionTransport () const

Transport *	ToTransport ()

Transport const *	ToTransport () const

StaticTransport *	ToStaticTransport ()

StaticTransport const *	ToStaticTransport () const

MotionTransport *	ToMotionTransport ()

MotionTransport const *	ToMotionTransport () const

float	GetStationaryX () const override

float	GetStationaryY () const override

float	GetStationaryZ () const override

float	GetStationaryO () const override

float	GetInteractionDistance () const

void	UpdateModelPosition ()

bool	IsAtInteractDistance (Position const &pos, float radius) const

bool	IsAtInteractDistance (Player const player, SpellInfo const spell=nullptr) const

bool	IsWithinDistInMap (Player const *player) const

SpellInfo const *	GetSpellForLock (Player const *player) const

bool	ValidateGameobjectType () const

bool	IsInstanceGameobject () const

uint8	GameobjectStateToInt (GOState *state) const

bool	IsAllowedToSaveToDB () const

void	AllowSaveToDB (bool enable)

void	SaveStateToDB ()

std::string	GetDebugInfo () const override

bool	IsUpdateNeeded () override

bool	IsWithinDistInMap (WorldObject const *obj, float dist2compare, bool is3D=true, bool incOwnRadius=true, bool incTargetRadius=true) const

Public Member Functions inherited from WorldObject
	~WorldObject () override

void	_Create (ObjectGuid::LowType guidlow, HighGuid guidhigh, uint32 phaseMask)

void	AddToWorld () override

void	RemoveFromWorld () override

void	GetNearPoint2D (WorldObject const searcher, float &x, float &y, float distance, float absAngle, Position const startPos=nullptr) const

void	GetNearPoint2D (float &x, float &y, float distance, float absAngle, Position const *startPos=nullptr) const

void	GetNearPoint (WorldObject const searcher, float &x, float &y, float &z, float searcher_size, float distance2d, float absAngle, float controlZ=0, Position const startPos=nullptr) const

void	GetVoidClosePoint (float &x, float &y, float &z, float size, float distance2d=0, float relAngle=0, float controlZ=0) const

bool	GetClosePoint (float &x, float &y, float &z, float size, float distance2d=0, float angle=0, WorldObject const *forWho=nullptr, bool force=false) const

void	MovePosition (Position &pos, float dist, float angle)

Position	GetNearPosition (float dist, float angle)

void	MovePositionToFirstCollision (Position &pos, float dist, float angle)

Position	GetFirstCollisionPosition (float startX, float startY, float startZ, float destX, float destY)

Position	GetFirstCollisionPosition (float destX, float destY, float destZ)

Position	GetFirstCollisionPosition (float dist, float angle)

Position	GetRandomNearPosition (float radius)

void	GetContactPoint (WorldObject const *obj, float &x, float &y, float &z, float distance2d=CONTACT_DISTANCE) const

void	GetChargeContactPoint (WorldObject const *obj, float &x, float &y, float &z, float distance2d=CONTACT_DISTANCE) const

float	GetObjectSize () const

virtual float	GetCombatReach () const

void	UpdateGroundPositionZ (float x, float y, float &z) const

void	UpdateAllowedPositionZ (float x, float y, float &z, float *groundZ=nullptr) const

void	GetRandomPoint (const Position &srcPos, float distance, float &rand_x, float &rand_y, float &rand_z) const

Position	GetRandomPoint (const Position &srcPos, float distance) const

uint32	GetInstanceId () const

uint32	GetPhaseMask () const

bool	InSamePhase (WorldObject const *obj) const

bool	InSamePhase (uint32 phasemask) const

uint32	GetZoneId () const

uint32	GetAreaId () const

void	GetZoneAndAreaId (uint32 &zoneid, uint32 &areaid) const

bool	IsOutdoors () const

LiquidData const &	GetLiquidData () const

InstanceScript *	GetInstanceScript () const

std::string const &	GetName () const

void	SetName (std::string const &newname)

float	GetDistance (WorldObject const *obj) const

float	GetDistance (const Position &pos) const

float	GetDistance (float x, float y, float z) const

float	GetDistance2d (WorldObject const *obj) const

float	GetDistance2d (float x, float y) const

float	GetDistanceZ (WorldObject const *obj) const

bool	IsSelfOrInSameMap (WorldObject const *obj) const

bool	IsInMap (WorldObject const *obj) const

bool	IsWithinDist3d (float x, float y, float z, float dist) const

bool	IsWithinDist3d (const Position *pos, float dist) const

bool	IsWithinDist2d (float x, float y, float dist) const

bool	IsWithinDist2d (const Position *pos, float dist) const

bool	IsWithinDist (WorldObject const *obj, float dist2compare, bool is3D=true, bool incOwnRadius=true, bool incTargetRadius=true) const

bool	IsWithinDistInMap (WorldObject const *obj, float dist2compare, bool is3D=true, bool incOwnRadius=true, bool incTargetRadius=true) const

bool	IsWithinLOS (float x, float y, float z, VMAP::ModelIgnoreFlags ignoreFlags=VMAP::ModelIgnoreFlags::Nothing, LineOfSightChecks checks=LINEOFSIGHT_ALL_CHECKS) const

bool	IsWithinLOSInMap (WorldObject const *obj, VMAP::ModelIgnoreFlags ignoreFlags=VMAP::ModelIgnoreFlags::Nothing, LineOfSightChecks checks=LINEOFSIGHT_ALL_CHECKS, Optional< float > collisionHeight={ }, Optional< float > combatReach={ }) const

Position	GetHitSpherePointFor (Position const &dest, Optional< float > collisionHeight={ }, Optional< float > combatReach={ }) const

void	GetHitSpherePointFor (Position const &dest, float &x, float &y, float &z, Optional< float > collisionHeight={ }, Optional< float > combatReach={ }) const

bool	GetDistanceOrder (WorldObject const obj1, WorldObject const obj2, bool is3D=true) const

bool	IsInRange (WorldObject const *obj, float minRange, float maxRange, bool is3D=true) const

bool	IsInRange2d (float x, float y, float minRange, float maxRange) const

bool	IsInRange3d (float x, float y, float z, float minRange, float maxRange) const

bool	isInFront (WorldObject const *target, float arc=M_PI) const

bool	isInBack (WorldObject const *target, float arc=M_PI) const

bool	IsInBetween (WorldObject const obj1, WorldObject const obj2, float size=0) const

virtual void	SendMessageToSet (WorldPacket const *data, bool self) const

virtual void	SendMessageToSetInRange (WorldPacket const *data, float dist, bool self) const

virtual void	SendMessageToSet (WorldPacket const data, Player const skipped_rcvr) const

void	PlayDistanceSound (uint32 sound_id, Player *target=nullptr)

void	PlayDirectSound (uint32 sound_id, Player *target=nullptr)

void	PlayRadiusSound (uint32 sound_id, float radius)

void	PlayDirectMusic (uint32 music_id, Player *target=nullptr)

void	PlayRadiusMusic (uint32 music_id, float radius)

template<typename Worker >
void	DoForAllVisiblePlayers (Worker &&worker)

template<typename Worker >
void	DoForAllVisibleWorldObjects (Worker &&worker)

void	DestroyForVisiblePlayers ()

void	SendObjectDeSpawnAnim (ObjectGuid guid)

void	AddObjectToRemoveList ()

float	GetGridActivationRange () const

float	GetVisibilityRange () const

virtual float	GetSightRange (WorldObject const *target=nullptr) const

bool	CanSeeOrDetect (WorldObject const *obj, bool ignoreStealth=false, bool distanceCheck=false, bool checkAlert=false) const

void	SendPlayMusic (uint32 Music, bool OnlySelf)

virtual void	SetMap (Map *map)

virtual void	ResetMap ()

Map *	GetMap () const

Map *	FindMap () const

void	SetZoneScript ()

void	ClearZoneScript ()

ZoneScript *	GetZoneScript () const

TempSummon *	SummonCreature (uint32 id, const Position &pos, TempSummonType spwtype=TEMPSUMMON_MANUAL_DESPAWN, uint32 despwtime=0, uint32 vehId=0, SummonPropertiesEntry const *properties=nullptr, bool visibleBySummonerOnly=false) const

TempSummon *	SummonCreature (uint32 id, float x, float y, float z, float ang=0, TempSummonType spwtype=TEMPSUMMON_MANUAL_DESPAWN, uint32 despwtime=0, SummonPropertiesEntry const *properties=nullptr, bool visibleBySummonerOnly=false)

GameObject *	SummonGameObject (uint32 entry, float x, float y, float z, float ang, float rotation0, float rotation1, float rotation2, float rotation3, uint32 respawnTime, bool checkTransport=true, GOSummonType summonType=GO_SUMMON_TIMED_OR_CORPSE_DESPAWN)

Creature *	SummonTrigger (float x, float y, float z, float ang, uint32 dur, bool setLevel=false, CreatureAI (GetAI)(Creature *)=nullptr)

void	SummonCreatureGroup (uint8 group, std::list< TempSummon * > *list=nullptr)

void	SummonGameObjectGroup (uint8 group, std::list< GameObject * > *list=nullptr)

Creature *	FindNearestCreature (uint32 entry, float range, bool alive=true) const

GameObject *	FindNearestGameObject (uint32 entry, float range, bool onlySpawned=false) const

GameObject *	FindNearestGameObjectOfType (GameobjectTypes type, float range) const

Player *	SelectNearestPlayer (float distance=0) const

void	GetGameObjectListWithEntryInGrid (std::list< GameObject * > &lList, uint32 uiEntry, float fMaxSearchRange) const

void	GetGameObjectListWithEntryInGrid (std::list< GameObject * > &gameobjectList, std::vector< uint32 > const &entries, float maxSearchRange) const

void	GetCreatureListWithEntryInGrid (std::list< Creature * > &lList, uint32 uiEntry, float fMaxSearchRange) const

void	GetCreatureListWithEntryInGrid (std::list< Creature * > &creatureList, std::vector< uint32 > const &entries, float maxSearchRange) const

void	GetDeadCreatureListInGrid (std::list< Creature * > &lList, float maxSearchRange, bool alive=false) const

virtual void	UpdateObjectVisibility (bool forced=true, bool fromUpdate=false)

virtual void	UpdateObjectVisibilityOnCreate ()

void	BuildUpdate (UpdateDataMapType &data_map) override

void	GetCreaturesWithEntryInRange (std::list< Creature * > &creatureList, float radius, uint32 entry)

void	SetPositionDataUpdate ()

void	UpdatePositionData ()

void	AddToObjectUpdate () override

void	RemoveFromObjectUpdate () override

void	AddToNotify (uint16 f)

void	RemoveFromNotify (uint16 f)

bool	isNeedNotify (uint16 f) const

uint16	GetNotifyFlags () const

bool	NotifyExecuted (uint16 f) const

void	SetNotified (uint16 f)

void	ResetAllNotifies ()

bool	isActiveObject () const

void	setActive (bool isActiveObject)

VisibilityDistanceType	GetVisibilityOverrideType () const

bool	IsVisibilityOverridden () const

bool	IsZoneWideVisible () const

bool	IsFarVisible () const

float	GetVisibilityOverrideDistance () const

void	SetVisibilityDistanceOverride (VisibilityDistanceType type)

bool	IsInWintergrasp () const

Transport *	GetTransport () const

float	GetTransOffsetX () const

float	GetTransOffsetY () const

float	GetTransOffsetZ () const

float	GetTransOffsetO () const

uint32	GetTransTime () const

int8	GetTransSeat () const

virtual ObjectGuid	GetTransGUID () const

void	SetTransport (Transport *t)

float	GetMapWaterOrGroundLevel (Position pos, float *ground=nullptr) const

float	GetMapWaterOrGroundLevel (float x, float y, float z, float *ground=nullptr) const

float	GetMapHeight (float x, float y, float z, bool vmap=true, float distanceToSearch=50.0f) const

float	GetFloorZ () const

float	GetMinHeightInWater () const
	Get the minimum height of a object that should be in water to start floating/swim.

virtual float	GetCollisionHeight () const

virtual float	GetCollisionWidth () const

virtual float	GetCollisionRadius () const

void	AddAllowedLooter (ObjectGuid guid)

void	ResetAllowedLooters ()

void	SetAllowedLooters (GuidUnorderedSet const looters)

bool	HasAllowedLooter (ObjectGuid guid) const

GuidUnorderedSet const &	GetAllowedLooters () const

void	RemoveAllowedLooter (ObjectGuid guid)

bool	CanBeAddedToMapUpdateList ()

std::string	GetDebugInfo () const override

ObjectVisibilityContainer &	GetObjectVisibilityContainer ()

ObjectVisibilityContainer const &	GetObjectVisibilityContainer () const

Public Member Functions inherited from Object
virtual	~Object ()

bool	IsInWorld () const

ObjectGuid	GetGUID () const

PackedGuid const &	GetPackGUID () const

uint32	GetEntry () const

void	SetEntry (uint32 entry)

float	GetObjectScale () const

virtual void	SetObjectScale (float scale)

bool	HasDynamicFlag (uint32 flag) const

virtual void	SetDynamicFlag (uint32 flag)

virtual void	RemoveDynamicFlag (uint32 flag)

TypeID	GetTypeId () const

bool	isType (uint16 mask) const

virtual void	BuildCreateUpdateBlockForPlayer (UpdateData data, Player target)

void	SendUpdateToPlayer (Player *player)

void	BuildValuesUpdateBlockForPlayer (UpdateData data, Player target)

void	BuildOutOfRangeUpdateBlock (UpdateData *data) const

void	BuildMovementUpdateBlock (UpdateData *data, uint32 flags=0) const

virtual void	DestroyForPlayer (Player *target, bool onDeath=false) const

int32	GetInt32Value (uint16 index) const

uint32	GetUInt32Value (uint16 index) const

uint64	GetUInt64Value (uint16 index) const

float	GetFloatValue (uint16 index) const

uint8	GetByteValue (uint16 index, uint8 offset) const

uint16	GetUInt16Value (uint16 index, uint8 offset) const

ObjectGuid	GetGuidValue (uint16 index) const

void	SetInt32Value (uint16 index, int32 value)

void	SetUInt32Value (uint16 index, uint32 value)

void	UpdateUInt32Value (uint16 index, uint32 value)

void	SetUInt64Value (uint16 index, uint64 value)

void	SetFloatValue (uint16 index, float value)

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

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

void	SetInt16Value (uint16 index, uint8 offset, int16 value)

void	SetGuidValue (uint16 index, ObjectGuid value)

void	SetStatFloatValue (uint16 index, float value)

void	SetStatInt32Value (uint16 index, int32 value)

bool	AddGuidValue (uint16 index, ObjectGuid value)

bool	RemoveGuidValue (uint16 index, ObjectGuid value)

void	ApplyModUInt32Value (uint16 index, int32 val, bool apply)

void	ApplyModInt32Value (uint16 index, int32 val, bool apply)

void	ApplyModUInt64Value (uint16 index, int32 val, bool apply)

void	ApplyModPositiveFloatValue (uint16 index, float val, bool apply)

void	ApplyModSignedFloatValue (uint16 index, float val, bool apply)

void	SetFlag (uint16 index, uint32 newFlag)

void	RemoveFlag (uint16 index, uint32 oldFlag)

void	ToggleFlag (uint16 index, uint32 flag)

bool	HasFlag (uint16 index, uint32 flag) const

void	ApplyModFlag (uint16 index, uint32 flag, bool apply)

void	SetByteFlag (uint16 index, uint8 offset, uint8 newFlag)

void	RemoveByteFlag (uint16 index, uint8 offset, uint8 newFlag)

bool	HasByteFlag (uint16 index, uint8 offset, uint8 flag) const

void	SetFlag64 (uint16 index, uint64 newFlag)

void	RemoveFlag64 (uint16 index, uint64 oldFlag)

void	ToggleFlag64 (uint16 index, uint64 flag)

bool	HasFlag64 (uint16 index, uint64 flag) const

void	ApplyModFlag64 (uint16 index, uint64 flag, bool apply)

void	ClearUpdateMask (bool remove)

uint16	GetValuesCount () const

void	BuildFieldsUpdate (Player *, UpdateDataMapType &)

void	SetFieldNotifyFlag (uint16 flag)

void	RemoveFieldNotifyFlag (uint16 flag)

void	ForceValuesUpdateAtIndex (uint32)

bool	IsPlayer () const

Player *	ToPlayer ()

Player const *	ToPlayer () const

bool	IsCreature () const

Creature *	ToCreature ()

Creature const *	ToCreature () const

bool	IsUnit () const

Unit *	ToUnit ()

Unit const *	ToUnit () const

bool	IsGameObject () const

GameObject *	ToGameObject ()

GameObject const *	ToGameObject () const

bool	IsCorpse () const

Corpse *	ToCorpse ()

Corpse const *	ToCorpse () const

bool	IsDynamicObject () const

DynamicObject *	ToDynObject ()

DynamicObject const *	ToDynObject () const

bool	IsItem () const

virtual void	Heartbeat ()

template<typename... T>
bool	EntryEquals (T... entries) const

Public Member Functions inherited from WorldLocation
	WorldLocation (uint32 _mapId=MAPID_INVALID, float x=0.f, float y=0.f, float z=0.f, float o=0.f)

	WorldLocation (uint32 mapId, Position const &position)

void	WorldRelocate (const WorldLocation &loc)

void	WorldRelocate (uint32 mapId=MAPID_INVALID, float x=0.f, float y=0.f, float z=0.f, float o=0.f)

void	SetMapId (uint32 mapId)

uint32	GetMapId () const

void	GetWorldLocation (uint32 &mapId, float &x, float &y) const

void	GetWorldLocation (uint32 &mapId, float &x, float &y, float &z) const

void	GetWorldLocation (uint32 &mapId, float &x, float &y, float &z, float &o) const

void	GetWorldLocation (WorldLocation *location) const

WorldLocation	GetWorldLocation () const

std::string	GetDebugInfo () const

Public Member Functions inherited from Position
	Position (float x=0, float y=0, float z=0, float o=0)

	Position (Position const &loc)

	Position (Position &&)=default

Position &	operator= (const Position &)=default

Position &	operator= (Position &&)=default

bool	operator== (Position const &a) const

bool	operator!= (Position const &a)

bool	operator!= (Position const &a) const

	operator G3D::Vector3 () const

void	Relocate (float x, float y)

void	Relocate (float x, float y, float z)

void	Relocate (float x, float y, float z, float orientation)

void	Relocate (const Position &pos)

void	Relocate (const Position *pos)

void	RelocatePolarOffset (float angle, float dist, float z=0.0f)

void	RelocateOffset (const Position &offset)

void	SetOrientation (float orientation)

float	GetPositionX () const

float	GetPositionY () const

float	GetPositionZ () const

float	GetOrientation () const

void	GetPosition (float &x, float &y) const

void	GetPosition (float &x, float &y, float &z) const

void	GetPosition (float &x, float &y, float &z, float &o) const

Position	GetPosition () const

Position::PositionXYZStreamer	PositionXYZStream ()

Position::PositionXYZOStreamer	PositionXYZOStream ()

bool	IsPositionValid () const

float	GetExactDist2dSq (const float x, const float y) const

float	GetExactDist2dSq (Position const &pos) const

float	GetExactDist2dSq (Position const *pos) const

float	GetExactDist2d (const float x, const float y) const

float	GetExactDist2d (Position const &pos) const

float	GetExactDist2d (Position const *pos) const

float	GetExactDistSq (float x, float y, float z) const

float	GetExactDistSq (Position const &pos) const

float	GetExactDistSq (Position const *pos) const

float	GetExactDist (float x, float y, float z) const

float	GetExactDist (Position const &pos) const

float	GetExactDist (Position const *pos) const

void	GetPositionOffsetTo (const Position &endPos, Position &retOffset) const

Position	GetPositionWithOffset (Position const &offset) const

float	GetAngle (const Position *pos) const

float	GetAngle (float x, float y) const

float	GetAbsoluteAngle (float x, float y) const

float	GetAbsoluteAngle (Position const &pos) const

float	GetAbsoluteAngle (Position const *pos) const

float	GetRelativeAngle (const Position *pos) const

float	GetRelativeAngle (float x, float y) const

float	ToAbsoluteAngle (float relAngle) const

void	GetSinCos (float x, float y, float &vsin, float &vcos) const

bool	IsInDist2d (float x, float y, float dist) const

bool	IsInDist2d (const Position *pos, float dist) const

bool	IsInDist (float x, float y, float z, float dist) const

bool	IsInDist (const Position *pos, float dist) const

bool	IsWithinBox (const Position &center, float xradius, float yradius, float zradius) const

bool	HasInArc (float arcangle, const Position *pos, float targetRadius=0.0f) const

bool	HasInLine (Position const *pos, float width) const

bool	HasInLine (Position const *pos, float objSize, float width) const

std::string	ToString () const

Public Member Functions inherited from GridObject< GameObject >
bool	IsInGrid () const

void	AddToGrid (GridRefMgr< GameObject > &m)

void	RemoveFromGrid ()

Static Public Member Functions
static void	SetGoArtKit (uint8 artkit, GameObject *go, ObjectGuid::LowType lowguid=0)

Static Public Member Functions inherited from Object
static ObjectGuid	GetGUID (Object const *o)

Static Public Member Functions inherited from Position
static float	NormalizeOrientation (float o)

Public Attributes
Loot	loot

uint32	m_groupLootTimer

uint32	lootingGroupLowGUID

GameObjectModel *	m_model

Public Attributes inherited from WorldObject
FlaggedValuesArray32< int32, uint32, StealthType, TOTAL_STEALTH_TYPES >	m_stealth

FlaggedValuesArray32< int32, uint32, StealthType, TOTAL_STEALTH_TYPES >	m_stealthDetect

FlaggedValuesArray32< int32, uint32, InvisibilityType, TOTAL_INVISIBILITY_TYPES >	m_invisibility

FlaggedValuesArray32< int32, uint32, InvisibilityType, TOTAL_INVISIBILITY_TYPES >	m_invisibilityDetect

FlaggedValuesArray32< int32, uint32, ServerSideVisibilityType, TOTAL_SERVERSIDE_VISIBILITY_TYPES >	m_serverSideVisibility

FlaggedValuesArray32< int32, uint32, ServerSideVisibilityType, TOTAL_SERVERSIDE_VISIBILITY_TYPES >	m_serverSideVisibilityDetect

uint32	LastUsedScriptID

MovementInfo	m_movementInfo

ALEEventProcessor *	ALEEvents

EventProcessor	m_Events

Public Attributes inherited from Object
DataMap	CustomData

Public Attributes inherited from WorldLocation
uint32	m_mapId

Public Attributes inherited from Position
float	m_positionX = 0

float	m_positionY = 0

float	m_positionZ = 0

float	m_orientation = 0

Static Public Attributes
static std::unordered_map< int, goEventFlag >	gameObjectToEventFlag = { }

Protected Types
typedef std::map< uint32, ObjectGuid >	ChairSlotAndUser

Protected Member Functions
bool	AIM_Initialize ()

GameObjectModel *	CreateModel ()

void	UpdateModel ()

Protected Member Functions inherited from WorldObject
	WorldObject ()

virtual void	ProcessPositionDataChanged (PositionFullTerrainStatus const &data)

void	SetLocationMapId (uint32 _mapId)

void	SetLocationInstanceId (uint32 _instanceId)

virtual bool	IsAlwaysDetectableFor (WorldObject const *) const

Protected Member Functions inherited from Object
	Object ()

void	_InitValues ()

void	_Create (ObjectGuid::LowType guidlow, uint32 entry, HighGuid guidhigh)

std::string	_ConcatFields (uint16 startIndex, uint16 size) const

bool	_LoadIntoDataField (std::string const &data, uint32 startOffset, uint32 count)

uint32	GetUpdateFieldData (Player const target, uint32 &flags) const

void	BuildMovementUpdate (ByteBuffer *data, uint16 flags) const

void	AddToObjectUpdateIfNeeded ()

Protected Member Functions inherited from MovableMapObject
	MovableMapObject ()=default

Cell const &	GetCurrentCell () const

Protected Member Functions inherited from UpdatableMapObject
	UpdatableMapObject ()

Protected Attributes
uint32	m_spellId

time_t	m_respawnTime

uint32	m_respawnDelayTime

uint32	m_despawnDelay

Seconds	m_despawnRespawnTime

Seconds	m_restockTime

LootState	m_lootState

bool	m_spawnedByDefault

uint32	m_cooldownTime

std::unordered_map< ObjectGuid, int32 >	m_SkillupList

ObjectGuid	m_ritualOwnerGUID

GuidSet	m_unique_users

uint32	m_usetimes

ChairSlotAndUser	ChairListSlots

ObjectGuid::LowType	m_spawnId
	For new or temporary gameobjects is 0 for saved it is lowguid.

GameObjectTemplate const *	m_goInfo

GameObjectData const *	m_goData

GameObjectValue	m_goValue

bool	m_allowModifyDestructibleBuilding

int64	m_packedRotation

G3D::Quat	WorldRotation

Position	m_stationaryPosition

ObjectGuid	m_lootRecipient

ObjectGuid::LowType	m_lootRecipientGroup

uint16	m_LootMode

uint32	m_lootGenerationTime

ObjectGuid	m_linkedTrap

ObjectGuid	_lootStateUnitGUID

Protected Attributes inherited from WorldObject
std::string	m_name

bool	m_isActive

VisibilityDistanceType	_visibilityDistanceOverrideType

ZoneScript *	m_zoneScript

uint32	_zoneId

uint32	_areaId

float	_floorZ

bool	_outdoors

LiquidData	_liquidData

bool	_updatePositionData

Transport *	m_transport

Protected Attributes inherited from Object
uint16	m_objectType

TypeID	m_objectTypeId

uint16	m_updateFlag

union {

int32 * m_int32Values

uint32 * m_uint32Values

float * m_floatValues

};

UpdateMask	_changesMask

uint16	m_valuesCount

uint16	_fieldNotifyFlags

bool	m_objectUpdated

Private Member Functions
void	CheckRitualList ()

void	ClearRitualList ()

void	RemoveFromOwner ()

void	SwitchDoorOrButton (bool activate, bool alternative=false)

void	UpdatePackedRotation ()

bool	_IsWithinDist (WorldObject const *obj, float dist2compare, bool, bool, bool) const override
	Object distance/size - overridden from Object::_IsWithinDist. Needs to take in account proper GO size.

bool	IsWithinSightRange (Position const &pos, float dist) const override

Private Attributes
GameObjectAI *	m_AI

bool	m_saveStateOnDb = false

Additional Inherited Members
Public Types inherited from UpdatableMapObject
enum	UpdateState : uint8 { NotUpdating , PendingAdd , Updating }

Detailed Description

Member Typedef Documentation

◆ ChairSlotAndUser

typedef std::map<uint32, ObjectGuid> GameObject::ChairSlotAndUser

protected

Constructor & Destructor Documentation

◆ GameObject()

GameObject::GameObject ( )

explicit

                       : WorldObject(), MovableMapObject(),
    m_model(nullptr), m_goValue(), m_AI(nullptr)
{
    m_objectType |= TYPEMASK_GAMEOBJECT;
    m_objectTypeId = TYPEID_GAMEOBJECT;
 
    m_updateFlag = (UPDATEFLAG_LOWGUID | UPDATEFLAG_STATIONARY_POSITION | UPDATEFLAG_POSITION | UPDATEFLAG_ROTATION);
 
    m_valuesCount = GAMEOBJECT_END;
    m_respawnTime = 0;
    m_respawnDelayTime = 300;
    m_despawnDelay = 0;
    m_despawnRespawnTime = 0s;
    m_restockTime = 0s;
    m_lootState = GO_NOT_READY;
    m_spawnedByDefault = true;
    m_allowModifyDestructibleBuilding = true;
    m_usetimes = 0;
    m_spellId = 0;
    m_cooldownTime = 0;
    m_goInfo = nullptr;
    m_goData = nullptr;
    m_packedRotation = 0;
 
    m_spawnId = 0;
 
    m_lootRecipientGroup = 0;
    m_groupLootTimer = 0;
    lootingGroupLowGUID = 0;
    m_lootGenerationTime = 0;
 
    ResetLootMode(); // restore default loot mode
    loot.sourceGameObject = this;
    m_stationaryPosition.Relocate(0.0f, 0.0f, 0.0f, 0.0f);
}

References GAMEOBJECT_END, GO_NOT_READY, loot, lootingGroupLowGUID, m_allowModifyDestructibleBuilding, m_cooldownTime, m_despawnDelay, m_despawnRespawnTime, m_goData, m_goInfo, m_groupLootTimer, m_lootGenerationTime, m_lootRecipientGroup, m_lootState, Object::m_objectType, Object::m_objectTypeId, m_packedRotation, m_respawnDelayTime, m_respawnTime, m_restockTime, m_spawnedByDefault, m_spawnId, m_spellId, m_stationaryPosition, Object::m_updateFlag, m_usetimes, Object::m_valuesCount, Position::Relocate(), ResetLootMode(), Loot::sourceGameObject, TYPEID_GAMEOBJECT, TYPEMASK_GAMEOBJECT, UPDATEFLAG_LOWGUID, UPDATEFLAG_POSITION, UPDATEFLAG_ROTATION, and UPDATEFLAG_STATIONARY_POSITION.

Referenced by Create(), and MotionTransport::CreateGOPassenger().

◆ ~GameObject()

GameObject::~GameObject ( )

override

{
    delete m_AI;
    delete m_model;
    //if (m_uint32Values)                                      // field array can be not exist if GameOBject not loaded
    //    CleanupsBeforeDelete();
}

References m_AI, and m_model.

Member Function Documentation

◆ _IsWithinDist()

bool GameObject::_IsWithinDist	(	WorldObject const *	obj,
		float	dist2compare,
		bool	,
		bool	,
		bool
	)		const

inlineoverrideprivatevirtual

Object distance/size - overridden from Object::_IsWithinDist. Needs to take in account proper GO size.

Following check does check 3d distance

Reimplemented from WorldObject.

    {
        dist2compare += obj->GetObjectSize();
        return IsInRange3d(obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ(), dist2compare);
    }

References WorldObject::GetObjectSize(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), and IsInRange3d().

◆ ActivateToQuest()

bool GameObject::ActivateToQuest ( Player * target ) const

{
    if (target->HasQuestForGO(GetEntry()))
        return true;
 
    if (!GetGOInfo()->IsGameObjectForQuests())
        return false;
 
    switch (GetGoType())
    {
        case GAMEOBJECT_TYPE_QUESTGIVER:
            {
                GameObject* go = const_cast<GameObject*>(this);
                QuestGiverStatus questStatus = target->GetQuestDialogStatus(go);
                if (questStatus > DIALOG_STATUS_UNAVAILABLE)
                    return true;
                break;
            }
        case GAMEOBJECT_TYPE_CHEST:
            {
                // scan GO chest with loot including quest items
                if (target->GetQuestStatus(GetGOInfo()->chest.questId) == QUEST_STATUS_INCOMPLETE || LootTemplates_Gameobject.HaveQuestLootForPlayer(GetGOInfo()->GetLootId(), target))
                {
                    //TODO: fix this hack
                    //look for battlegroundAV for some objects which are only activated after mine gots captured by own team
                    if (GetEntry() == BG_AV_OBJECTID_MINE_N || GetEntry() == BG_AV_OBJECTID_MINE_S)
                        if (Battleground* bg = target->GetBattleground())
                            if (bg->GetBgTypeID(true) == BATTLEGROUND_AV && !bg->ToBattlegroundAV()->PlayerCanDoMineQuest(GetEntry(), target->GetTeamId()))
                                return false;
                    return true;
                }
                break;
            }
        case GAMEOBJECT_TYPE_GENERIC:
            {
                if (GetGOInfo()->_generic.questID == -1 || target->GetQuestStatus(GetGOInfo()->_generic.questID) == QUEST_STATUS_INCOMPLETE)
                    return true;
                break;
            }
        case GAMEOBJECT_TYPE_SPELL_FOCUS:
            {
                if (GetGOInfo()->spellFocus.questID > 0 && target->GetQuestStatus(GetGOInfo()->spellFocus.questID) == QUEST_STATUS_INCOMPLETE)
                    return true;
                break;
            }
        case GAMEOBJECT_TYPE_GOOBER:
            {
                if (GetGOInfo()->goober.questId == -1 || target->GetQuestStatus(GetGOInfo()->goober.questId) == QUEST_STATUS_INCOMPLETE)
                    return true;
                break;
            }
        default:
            break;
    }
 
    return false;
}

References GameObjectTemplate::_generic, BATTLEGROUND_AV, BG_AV_OBJECTID_MINE_N, BG_AV_OBJECTID_MINE_S, DIALOG_STATUS_UNAVAILABLE, GAMEOBJECT_TYPE_CHEST, GAMEOBJECT_TYPE_GENERIC, GAMEOBJECT_TYPE_GOOBER, GAMEOBJECT_TYPE_QUESTGIVER, GAMEOBJECT_TYPE_SPELL_FOCUS, Player::GetBattleground(), Object::GetEntry(), GetGOInfo(), GetGoType(), Player::GetQuestDialogStatus(), Player::GetQuestStatus(), Player::GetTeamId(), GameObjectTemplate::goober, Player::HasQuestForGO(), LootStore::HaveQuestLootForPlayer(), LootTemplates_Gameobject, QUEST_STATUS_INCOMPLETE, GameObjectTemplate::questId, GameObjectTemplate::questID, and GameObjectTemplate::spellFocus.

Referenced by BuildValuesUpdate().

◆ AddLootMode()

void GameObject::AddLootMode ( uint16 lootMode )

inline

230{ m_LootMode |= lootMode; }

GameObject::m_LootMode

uint16 m_LootMode

Definition GameObject.h:403

References m_LootMode.

◆ AddToSkillupList()

void GameObject::AddToSkillupList ( ObjectGuid const & playerGuid )

{
    int32 timer = GetMap()->IsDungeon() ? -1 : 10 * MINUTE * IN_MILLISECONDS;
    m_SkillupList[playerGuid] = timer;
}

References WorldObject::GetMap(), IN_MILLISECONDS, Map::IsDungeon(), m_SkillupList, and MINUTE.

Referenced by Spell::EffectOpenLock().

◆ AddToWorld()

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));
 
        if (m_model)
        {
            m_model->UpdatePosition();
            GetMap()->InsertGameObjectModel(*m_model);
        }
 
        EnableCollision(GetGoState() == GO_STATE_READY || IsTransport()); // pussywizard: this startOpen is unneeded here, collision depends entirely on GOState
 
        WorldObject::AddToWorld();
 
        loot.sourceWorldObjectGUID = GetGUID();
 
        sScriptMgr->OnGameObjectAddWorld(this);
    }
}

References WorldObject::AddToWorld(), EnableCollision(), Map::GetGameObjectBySpawnIdStore(), GetGoState(), Object::GetGUID(), WorldObject::GetMap(), Map::GetObjectsStore(), GO_STATE_READY, TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Insert(), Map::InsertGameObjectModel(), Object::IsInWorld(), IsTransport(), loot, m_model, m_spawnId, WorldObject::m_zoneScript, ZoneScript::OnGameObjectCreate(), Loot::sourceWorldObjectGUID, sScriptMgr, and GameObjectModel::UpdatePosition().

Referenced by Map::AddToMap().

◆ AddUniqueUse()

void GameObject::AddUniqueUse ( Player * player )

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

References AddUse(), Object::GetGUID(), and m_unique_users.

Referenced by Spell::EffectTransmitted(), and Use().

◆ AddUse()

void GameObject::AddUse ( )

inline

238{ ++m_usetimes; }

References m_usetimes.

Referenced by AddUniqueUse(), WorldSession::DoLootRelease(), go_soulwell::go_soulwellAI::GossipHello(), go_simon_cluster::OnGossipHello(), and Use().

◆ AI()

GameObjectAI * GameObject::AI ( ) const

inline

306{ return m_AI; }

References m_AI.

Referenced by Player::AddQuestAndCheckCompletion(), Spell::DoAllEffectOnTarget(), EventInform(), WorldSession::HandleGameobjectReportUse(), WorldSession::HandleGossipSelectOptionOpcode(), WorldSession::HandleQuestgiverChooseRewardOpcode(), TempSummon::InitSummon(), SmartScript::IsSmart(), SmartScript::ProcessAction(), Spell::SendLoot(), SetLootState(), MotionTransport::Update(), Update(), and Use().

◆ AIM_Initialize()

bool GameObject::AIM_Initialize ( )

protected

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

References GameObjectAI::InitializeAI(), m_AI, and FactorySelector::SelectGameObjectAI().

Referenced by Create(), StaticTransport::Create(), MotionTransport::Update(), and Update().

◆ AllowSaveToDB()

void GameObject::AllowSaveToDB ( bool enable )

inline

361{ m_saveStateOnDb = enable; };

GameObject::m_saveStateOnDb

bool m_saveStateOnDb

Definition GameObject.h:429

References m_saveStateOnDb.

Referenced by instance_deadmines::instance_deadmines_InstanceMapScript::OnGameObjectCreate(), instance_gnomeregan::instance_gnomeregan_InstanceMapScript::OnGameObjectCreate(), instance_scholomance::instance_scholomance_InstanceMapScript::OnGameObjectCreate(), instance_stratholme::instance_stratholme_InstanceMapScript::OnGameObjectCreate(), and instance_serpent_shrine::instance_serpentshrine_cavern_InstanceMapScript::OnGameObjectCreate().

◆ BuildValuesUpdate()

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

overridevirtual

Reimplemented from Object.

{
    if (!target)
        return;
 
    bool forcedFlags = GetGoType() == GAMEOBJECT_TYPE_CHEST && GetGOInfo()->chest.groupLootRules && HasLootRecipient();
    bool targetIsGM = target->IsGameMaster() && target->GetSession()->IsGMAccount();
 
    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 == GAMEOBJECT_DYNAMIC)
            {
                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;
                            if (sWorld->getBoolConfig(CONFIG_OBJECT_SPARKLES))
                                dynFlags |= GO_DYNFLAG_LO_SPARKLE;
                        }
                        else if (targetIsGM)
                            dynFlags |= GO_DYNFLAG_LO_ACTIVATE;
                        break;
                    case GAMEOBJECT_TYPE_SPELL_FOCUS:
                    case GAMEOBJECT_TYPE_GENERIC:
                        if (ActivateToQuest(target) && sWorld->getBoolConfig(CONFIG_OBJECT_SPARKLES))
                            dynFlags |= GO_DYNFLAG_LO_SPARKLE;
                        break;
                    case GAMEOBJECT_TYPE_TRANSPORT:
                        if (const StaticTransport* t = ToStaticTransport())
                            if (t->GetPauseTime())
                            {
                                if (GetGoState() == GO_STATE_READY)
                                {
                                    if (t->GetPathProgress() >= t->GetPauseTime()) // if not, send 100% progress
                                        pathProgress = int16(float(t->GetPathProgress() - t->GetPauseTime()) / float(t->GetPeriod() - t->GetPauseTime()) * 65535.0f);
                                }
                                else
                                {
                                    if (t->GetPathProgress() <= t->GetPauseTime()) // if not, send 100% progress
                                        pathProgress = int16(float(t->GetPathProgress()) / float(t->GetPauseTime()) * 65535.0f);
                                }
                            }
                        // else it's ignored
                        break;
                    case GAMEOBJECT_TYPE_MO_TRANSPORT:
                        if (const MotionTransport* t = ToMotionTransport())
                            pathProgress = int16(float(t->GetPathProgress()) / float(t->GetPeriod()) * 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 && GetGOInfo() && GetGOInfo()->chest.groupLootRules && !IsLootAllowedFor(target))
                {
                    goFlags |= GO_FLAG_LOCKED | GO_FLAG_NOT_SELECTABLE;
                }
 
                fieldBuffer << goFlags;
            }
            else
                fieldBuffer << m_uint32Values[index];                // other cases
        }
    }
 
    *data << uint8(updateMask.GetBlockCount());
    updateMask.AppendToPacket(data);
    data->append(fieldBuffer);
}

References Object::_changesMask, Object::_fieldNotifyFlags, ActivateToQuest(), ByteBuffer::append(), UpdateMask::AppendToPacket(), GameObjectTemplate::chest, CONFIG_OBJECT_SPARKLES, GAMEOBJECT_DYNAMIC, GAMEOBJECT_FLAGS, GAMEOBJECT_TYPE_CHEST, GAMEOBJECT_TYPE_GENERIC, GAMEOBJECT_TYPE_GOOBER, GAMEOBJECT_TYPE_MO_TRANSPORT, GAMEOBJECT_TYPE_QUESTGIVER, GAMEOBJECT_TYPE_SPELL_FOCUS, GAMEOBJECT_TYPE_TRANSPORT, GameObjectUpdateFieldFlags, UpdateMask::GetBit(), UpdateMask::GetBlockCount(), GetGOInfo(), GetGoState(), GetGoType(), Object::GetGUID(), GetOwnerGUID(), Player::GetSession(), GO_DYNFLAG_LO_ACTIVATE, GO_DYNFLAG_LO_SPARKLE, GO_FLAG_LOCKED, GO_FLAG_NOT_SELECTABLE, GO_STATE_READY, GameObjectTemplate::groupLootRules, HasLootRecipient(), Player::IsGameMaster(), WorldSession::IsGMAccount(), IsLootAllowedFor(), Object::m_uint32Values, Object::m_valuesCount, UpdateMask::SetBit(), UpdateMask::SetCount(), sWorld, ToMotionTransport(), ToStaticTransport(), UF_FLAG_OWNER, UF_FLAG_PUBLIC, and UPDATETYPE_VALUES.

◆ CastSpell()

void GameObject::CastSpell	(	Unit *	target,
		uint32	spell
	)

{
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
    if (!spellInfo)
        return;
 
    bool self = true;
    for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
    {
        if (spellInfo->Effects[i].TargetA.GetReferenceType() != TARGET_REFERENCE_TYPE_CASTER || spellInfo->Effects[i].TargetB.GetTarget())
        {
            self = false;
            break;
        }
    }
 
    if (self && target && target->GetGUID() != GetGUID())
    {
        target->CastSpell(target, spellInfo, true);
        return;
    }
 
    //summon world trigger
    Creature* trigger = SummonTrigger(GetPositionX(), GetPositionY(), GetPositionZ(), 0, spellInfo->CalcCastTime() + 2000, true);
    if (!trigger)
        return;
 
    if (Unit* owner = GetOwner())
    {
        trigger->SetLevel(owner->GetLevel(), false);
        trigger->SetFaction(owner->GetFaction());
        // needed for GO casts for proper target validation checks
        trigger->SetOwnerGUID(owner->GetGUID());
        // xinef: fixes some duel bugs with traps]
        if (owner->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED))
            trigger->SetUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED);
        if (owner->IsFFAPvP())
        {
            if (!trigger->HasByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP))
            {
                sScriptMgr->OnFfaPvpStateUpdate(trigger, true);
                trigger->SetByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP);
            }
 
        }
        // xinef: Remove Immunity flags
        trigger->SetImmuneToNPC(false);
        // xinef: set proper orientation, fixes cast against stealthed targets
        if (target)
            trigger->SetInFront(target);
        trigger->CastSpell(target ? target : trigger, spellInfo, true, 0, 0, owner->GetGUID());
    }
    else
    {
        // xinef: set faction of gameobject, if no faction - assume hostile
        trigger->SetFaction(GetTemplateAddon() && GetTemplateAddon()->faction ? GetTemplateAddon()->faction : 14);
        // Set owner guid for target if no owner availble - needed by trigger auras
        // - trigger gets despawned and there's no caster avalible (see AuraEffect::TriggerSpell())
        // xinef: set proper orientation, fixes cast against stealthed targets
        if (target)
            trigger->SetInFront(target);
        trigger->CastSpell(target ? target : trigger, spellInfo, true, 0, 0, target ? target->GetGUID() : ObjectGuid::Empty);
    }
}

References SpellInfo::CalcCastTime(), Unit::CastSpell(), SpellInfo::Effects, ObjectGuid::Empty, GameObjectTemplateAddon::faction, Object::GetGUID(), Object::GetGUID(), GetOwner(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), GetTemplateAddon(), Object::HasByteFlag(), MAX_SPELL_EFFECTS, Object::SetByteFlag(), Unit::SetFaction(), Unit::SetImmuneToNPC(), Unit::SetInFront(), Unit::SetLevel(), Unit::SetOwnerGUID(), Unit::SetUnitFlag(), sScriptMgr, sSpellMgr, WorldObject::SummonTrigger(), TARGET_REFERENCE_TYPE_CASTER, UNIT_BYTE2_FLAG_FFA_PVP, UNIT_FIELD_BYTES_2, and UNIT_FLAG_PLAYER_CONTROLLED.

Referenced by npc_midsummer_ribbon_pole_target::DoFlameCircleChecks(), instance_onyxias_lair::instance_onyxias_lair_InstanceMapScript::OnGameObjectCreate(), SmartScript::ProcessAction(), go_direbrew_mole_machine::go_direbrew_mole_machineAI::Reset(), npc_deaths_door_fell_cannon_target_bunny::npc_deaths_door_fell_cannon_target_bunnyAI::SpellHit(), Update(), go_suppression_device::UpdateAI(), go_witherbark_totem_bundle::go_witherbark_totem_bundleAI::UpdateAI(), and Use().

◆ CheckRitualList()

void GameObject::CheckRitualList ( )

private

{
    if (m_unique_users.empty())
        return;
 
    uint32 animSpell = GetGOInfo()->summoningRitual.animSpell;
    if (!animSpell)
        animSpell = GetSpellId();
 
    for (GuidSet::iterator itr = m_unique_users.begin(); itr != m_unique_users.end();)
    {
        if (*itr == GetOwnerGUID())
        {
            ++itr;
            continue;
        }
 
        bool erase = true;
        if (Player* channeler = ObjectAccessor::GetPlayer(*this, *itr))
            if (Spell* spell = channeler->GetCurrentSpell(CURRENT_CHANNELED_SPELL))
                if (spell->m_spellInfo->Id == animSpell)
                    erase = false;
 
        if (erase)
            m_unique_users.erase(itr++);
        else
            ++itr;
    }
}

References GameObjectTemplate::animSpell, CURRENT_CHANNELED_SPELL, GetGOInfo(), GetOwnerGUID(), ObjectAccessor::GetPlayer(), GetSpellId(), m_unique_users, and GameObjectTemplate::summoningRitual.

Referenced by Update(), and Use().

◆ CleanupsBeforeDelete()

void GameObject::CleanupsBeforeDelete ( bool finalCleanup = true )

overridevirtual

Reimplemented from WorldObject.

Reimplemented in MotionTransport, and StaticTransport.

{
    if (GetTransport() && !ToTransport())
    {
        GetTransport()->RemovePassenger(this);
        SetTransport(nullptr);
        m_movementInfo.transport.Reset();
        m_movementInfo.RemoveMovementFlag(MOVEMENTFLAG_ONTRANSPORT);
    }
 
    if (IsInWorld())
        RemoveFromWorld();
 
    if (m_uint32Values)                                      // field array can be not exist if GameOBject not loaded
        RemoveFromOwner();
}

References WorldObject::GetTransport(), Object::IsInWorld(), WorldObject::m_movementInfo, Object::m_uint32Values, MOVEMENTFLAG_ONTRANSPORT, RemoveFromOwner(), RemoveFromWorld(), MovementInfo::RemoveMovementFlag(), Transport::RemovePassenger(), MovementInfo::TransportInfo::Reset(), WorldObject::SetTransport(), ToTransport(), and MovementInfo::transport.

Referenced by MotionTransport::CleanupsBeforeDelete(), and StaticTransport::CleanupsBeforeDelete().

◆ ClearRitualList()

void GameObject::ClearRitualList ( )

private

{
    if (m_unique_users.empty())
        return;
 
    uint32 animSpell = GetGOInfo()->summoningRitual.animSpell;
    if (!animSpell)
        animSpell = GetSpellId();
 
    for (ObjectGuid const& guid : m_unique_users)
    {
        if (Player* channeler = ObjectAccessor::GetPlayer(*this, guid))
            if (Spell* spell = channeler->GetCurrentSpell(CURRENT_CHANNELED_SPELL))
                if (spell->m_spellInfo->Id == animSpell)
                {
                    spell->SendChannelUpdate(0);
                    spell->finish();
                }
    }
 
    m_unique_users.clear();
}

References GameObjectTemplate::animSpell, CURRENT_CHANNELED_SPELL, GetGOInfo(), ObjectAccessor::GetPlayer(), GetSpellId(), m_unique_users, and GameObjectTemplate::summoningRitual.

Referenced by Delete(), and Update().

◆ Create()

bool GameObject::Create	(	ObjectGuid::LowType	guidlow,
		uint32	name_id,
		Map *	map,
		uint32	phaseMask,
		float	x,
		float	y,
		float	z,
		float	ang,
		G3D::Quat const &	rotation,
		uint32	animprogress,
		GOState	go_state,
		uint32	artKit = `0`
	)

virtual

Reimplemented in StaticTransport.

{
    ASSERT(map);
    SetMap(map);
 
    Relocate(x, y, z, ang);
    m_stationaryPosition.Relocate(x, y, z, ang);
    if (!IsPositionValid())
    {
        LOG_ERROR("entities.gameobject", "Gameobject (GUID: {} Entry: {}) not created. Suggested coordinates isn't valid (X: {} Y: {})", guidlow, name_id, x, y);
        return false;
    }
 
    SetPhaseMask(phaseMask, false);
 
    UpdatePositionData();
 
    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)
    {
        LOG_ERROR("sql.sql", "Gameobject (GUID: {} Entry: {}) not created: non-existing entry in `gameobject_template`. Map: {} (X: {} Y: {} Z: {})", guidlow, name_id, map->GetId(), x, y, z);
        return false;
    }
 
    Object::_Create(guidlow, goinfo->entry, HighGuid::GameObject);
 
    m_goInfo = goinfo;
 
    if (goinfo->type >= MAX_GAMEOBJECT_TYPE)
    {
        LOG_ERROR("sql.sql", "Gameobject (GUID: {} Entry: {}) not created: non-existing GO type '{}' in `gameobject_template`. It will crash client if created.", guidlow, name_id, goinfo->type);
        return false;
    }
 
    SetWorldRotation(rotation);
 
    GameObjectAddon const* gameObjectAddon = sObjectMgr->GetGameObjectAddon(GetSpawnId());
    QuaternionData parentRotation;
    if (gameObjectAddon)
        parentRotation = gameObjectAddon->ParentRotation;
 
    SetTransportPathRotation(parentRotation.x, parentRotation.y, parentRotation.z, parentRotation.w);
 
    SetObjectScale(goinfo->size);
 
    if (GameObjectTemplateAddon const* templateAddon = GetTemplateAddon())
    {
        SetUInt32Value(GAMEOBJECT_FACTION, templateAddon->faction);
        ReplaceAllGameObjectFlags((GameObjectFlags)templateAddon->flags);
    }
 
    SetEntry(goinfo->entry);
 
    // set name for logs usage, doesn't affect anything ingame
    SetName(goinfo->name);
 
    // GAMEOBJECT_BYTES_1, index at 0, 1, 2 and 3
    SetGoType(GameobjectTypes(goinfo->type));
 
    if (IsInstanceGameobject())
    {
        if (InstanceScript* instance = GetInstanceScript())
        {
            switch (uint8 state = instance->GetStoredGameObjectState(GetSpawnId()))
            {
                case 0:
                    SetGoState(GO_STATE_READY);
                    SwitchDoorOrButton(true);
                    break;
                case 1:
                case 2:
                    SetGoState((GOState)state);
                    break;
                default:
                    SetGoState(go_state);
                    break;
            }
        }
    }
    else
    {
        SetGoState(go_state);
    }
 
    SetGoArtKit(artKit);
 
    SetDisplayId(goinfo->displayId);
 
    if (!m_model)
        m_model = CreateModel();
 
    switch (goinfo->type)
    {
        case GAMEOBJECT_TYPE_FISHINGHOLE:
            SetGoAnimProgress(animprogress);
            m_goValue.FishingHole.MaxOpens = urand(GetGOInfo()->fishinghole.minSuccessOpens, GetGOInfo()->fishinghole.maxSuccessOpens);
            break;
        case GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING:
            m_goValue.Building.Health = goinfo->building.intactNumHits + goinfo->building.damagedNumHits;
            m_goValue.Building.MaxHealth = m_goValue.Building.Health;
            SetGoAnimProgress(255);
            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.invisible)
            {
                m_invisibility.AddFlag(INVISIBILITY_TRAP);
                m_invisibility.AddValue(INVISIBILITY_TRAP, 300);
            }
            break;
        default:
            SetGoAnimProgress(animprogress);
            break;
    }
 
    if (gameObjectAddon)
    {
        if (gameObjectAddon->InvisibilityValue)
        {
            m_invisibility.AddFlag(gameObjectAddon->invisibilityType);
            m_invisibility.AddValue(gameObjectAddon->invisibilityType, gameObjectAddon->InvisibilityValue);
        }
    }
 
    LastUsedScriptID = GetScriptId();
    AIM_Initialize();
 
    if (uint32 linkedEntry = GetGOInfo()->GetLinkedGameObjectEntry())
    {
        GameObject* linkedGO = new GameObject();
        if (linkedGO->Create(map->GenerateLowGuid<HighGuid::GameObject>(), linkedEntry, map, phaseMask, x, y, z, ang, rotation, 255, GO_STATE_READY))
        {
            SetLinkedTrap(linkedGO);
            map->AddToMap(linkedGO);
        }
        else
        {
            delete linkedGO;
        }
    }
 
    // Check if GameObject is Large
    if (goinfo->IsLargeGameObject())
        SetVisibilityDistanceOverride(VisibilityDistanceType::Large);
 
    // Check if GameObject is Infinite
    if (goinfo->IsInfiniteGameObject())
        SetVisibilityDistanceOverride(VisibilityDistanceType::Infinite);
 
    return true;
}

Referenced by Battleground::AddObject(), Create(), Spell::EffectDuel(), Spell::EffectSummonObject(), Spell::EffectSummonObjectWild(), Spell::EffectTransmitted(), OutdoorPvPSI::HandleDropFlag(), gobject_commandscript::HandleGameObjectAddCommand(), LoadGameObjectFromDB(), Battlefield::SpawnGameObject(), Map::SummonGameObject(), and WorldObject::SummonGameObject().

◆ CreateModel()

GameObjectModel * GameObject::CreateModel ( )

protected

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

References GameObjectModel::Create(), and sWorld.

Referenced by Create(), StaticTransport::Create(), MotionTransport::CreateMoTrans(), and UpdateModel().

◆ Delete()

void GameObject::Delete ( )

{
    SetLootState(GO_NOT_READY);
    RemoveFromOwner();
 
    SendObjectDeSpawnAnim(GetGUID());
 
    SetGoState(GO_STATE_READY);
 
    if (GameObjectTemplateAddon const* addon = GetTemplateAddon())
        ReplaceAllGameObjectFlags((GameObjectFlags)addon->flags);
 
    // Xinef: if ritual gameobject is removed, clear anim spells
    if (GetGOInfo()->type == GAMEOBJECT_TYPE_SUMMONING_RITUAL)
        ClearRitualList();
 
    uint32 poolid = m_spawnId ? sPoolMgr->IsPartOfAPool<GameObject>(m_spawnId) : 0;
    if (poolid)
        sPoolMgr->UpdatePool<GameObject>(poolid, m_spawnId);
    else
        AddObjectToRemoveList();
}

References WorldObject::AddObjectToRemoveList(), ClearRitualList(), GAMEOBJECT_TYPE_SUMMONING_RITUAL, GetGOInfo(), Object::GetGUID(), GetTemplateAddon(), GO_NOT_READY, GO_STATE_READY, m_spawnId, RemoveFromOwner(), ReplaceAllGameObjectFlags(), WorldObject::SendObjectDeSpawnAnim(), SetGoState(), SetLootState(), and sPoolMgr.

Referenced by MotionTransport::DelayedTeleportTransport(), OPvPCapturePoint::DelCapturePoint(), OPvPCapturePoint::DelObject(), npc_overlord_drakuru_betrayal::DoAction(), go_ahune_ice_stone::GossipSelect(), OutdoorPvPSI::HandleCustomSpell(), instance_razorfen_downs::instance_razorfen_downs_InstanceMapScript::OnGameObjectCreate(), go_ulduar_working_harpoon::OnGossipHello(), Unit::RemoveAllGameObjects(), Unit::RemoveGameObject(), Update(), go_blood_drenched_door::go_blood_drenched_doorAI::UpdateAI(), go_celestial_planetarium_access::go_celestial_planetarium_accessAI::UpdateAI(), and Use().

◆ DeleteFromDB()

void GameObject::DeleteFromDB ( )

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

References WorldObject::GetMap(), m_spawnId, Map::RemoveGORespawnTime(), PreparedStatementBase::SetData(), sObjectMgr, WORLD_DEL_EVENT_GAMEOBJECT, WORLD_DEL_GAMEOBJECT, and WorldDatabase.

◆ DespawnOrUnsummon()

void GameObject::DespawnOrUnsummon	(	Milliseconds	delay = `0ms`,
		Seconds	forcedRespawnTime = `0s`
	)

{
    if (delay > 0ms)
    {
        if (!m_despawnDelay || m_despawnDelay > delay.count())
        {
            m_despawnDelay = delay.count();
            m_despawnRespawnTime = forceRespawnTime;
        }
    }
    else
    {
        if (m_goData)
        {
            int32 const respawnDelay = (forceRespawnTime > 0s) ? forceRespawnTime.count() : m_goData->spawntimesecs;
            SetRespawnTime(respawnDelay);
        }
 
       // Respawn is handled by the gameobject itself.
       // If we delete it from world, it simply never respawns...
       // Uncomment this and remove the following lines if dynamic spawn is implemented.
       // Delete();
        {
            SetLootState(GO_JUST_DEACTIVATED);
            SendObjectDeSpawnAnim(GetGUID());
            SetGoState(GO_STATE_READY);
 
            if (GameObject* trap = GetLinkedTrap())
            {
                trap->DespawnOrUnsummon();
            }
 
            if (GameObjectTemplateAddon const* addon = GetTemplateAddon())
            {
                ReplaceAllGameObjectFlags((GameObjectFlags)addon->flags);
            }
 
            uint32 poolid = m_spawnId ? sPoolMgr->IsPartOfAPool<GameObject>(m_spawnId) : 0;
            if (poolid)
            {
                sPoolMgr->UpdatePool<GameObject>(poolid, m_spawnId);
            }
        }
    }
}

References Object::GetGUID(), GetLinkedTrap(), GetTemplateAddon(), GO_JUST_DEACTIVATED, GO_STATE_READY, m_despawnDelay, m_despawnRespawnTime, m_goData, m_spawnId, ReplaceAllGameObjectFlags(), WorldObject::SendObjectDeSpawnAnim(), SetGoState(), SetLootState(), SetRespawnTime(), GameObjectData::spawntimesecs, and sPoolMgr.

Referenced by Spell::EffectActivateObject(), instance_deadmines::instance_deadmines_InstanceMapScript::OnGameObjectCreate(), instance_molten_core::OnGameObjectCreate(), instance_hyjal::instance_mount_hyjal_InstanceMapScript::OnGameObjectCreate(), instance_temple_of_ahnqiraj::instance_temple_of_ahnqiraj_InstanceMapScript::OnGameObjectCreate(), go_strange_pool::OnGossipHello(), go_southfury_moonstone::OnGossipHello(), go_ancient_skull_pile::OnGossipSelect(), SmartScript::ProcessAction(), go_ahune_ice_spear::Reset(), go_skull_pile::SendActionMenu(), go_firework_show::SpawnNextFirework(), npc_midsummer_bonfire::StampOut(), and Update().

◆ EnableCollision()

void GameObject::EnableCollision ( bool enable )

{
    if (!m_model)
        return;
 
    /*if (enable && !GetMap()->ContainsGameObjectModel(*m_model))
        GetMap()->InsertGameObjectModel(*m_model);*/
 
    uint32 phaseMask = 0;
    if (enable && !sDisableMgr->IsDisabledFor(DISABLE_TYPE_GO_LOS, GetEntry(), nullptr))
        phaseMask = GetPhaseMask();
 
    m_model->enable(phaseMask);
}

References DISABLE_TYPE_GO_LOS, GameObjectModel::enable(), Object::GetEntry(), WorldObject::GetPhaseMask(), m_model, and sDisableMgr.

Referenced by AddToWorld(), instance_eye_of_eternity::OnGameObjectCreate(), instance_ulduar::instance_ulduar_InstanceMapScript::OnGameObjectCreate(), SetDestructibleState(), SetGoState(), and SetPhaseMask().

◆ EventInform()

void GameObject::EventInform ( uint32 eventId )

{
    if (!eventId)
        return;
 
    if (AI())
        AI()->EventInform(eventId);
 
    if (m_zoneScript)
        m_zoneScript->ProcessEvent(this, eventId);
}

References AI(), GameObjectAI::EventInform(), WorldObject::m_zoneScript, and ZoneScript::ProcessEvent().

Referenced by MotionTransport::DoEventIfAny(), SetDestructibleState(), and Use().

◆ GameobjectStateToInt()

uint8 GameObject::GameobjectStateToInt ( GOState * state ) const

{
    uint8 m_state = 3;
 
    if (state)
    {
        switch (*state)
        {
            case GO_STATE_ACTIVE:
                m_state = 0;
                return m_state;
            case GO_STATE_READY:
                m_state = 1;
                return m_state;
            case GO_STATE_ACTIVE_ALTERNATIVE:
                m_state = 2;
                return m_state;
        }
    }
 
    // Returning any value that is not one of the specified ones
    // Which will default into the invalid part of the switch
    return m_state;
}

References GO_STATE_ACTIVE, GO_STATE_ACTIVE_ALTERNATIVE, and GO_STATE_READY.

Referenced by SaveStateToDB().

◆ GetAIName()

std::string const & GameObject::GetAIName ( ) const

{
    return sObjectMgr->GetGameObjectTemplate(GetEntry())->AIName;
}

References Object::GetEntry(), and sObjectMgr.

Referenced by GetDebugInfo().

◆ GetDebugInfo()

std::string GameObject::GetDebugInfo ( ) const

overridevirtual

Reimplemented from Object.

Reimplemented in MotionTransport.

{
    std::stringstream sstr;
    sstr << WorldObject::GetDebugInfo() << "\n"
        << "SpawnId: " << GetSpawnId() << " GoState: " << std::to_string(GetGoState()) << " ScriptId: " << GetScriptId() << " AIName: " << GetAIName();
    return sstr.str();
}

References GetAIName(), WorldObject::GetDebugInfo(), GetGoState(), GetScriptId(), and GetSpawnId().

Referenced by MotionTransport::GetDebugInfo().

◆ GetDestructibleState()

GameObjectDestructibleState GameObject::GetDestructibleState ( ) const

inline

    {
        if (HasGameObjectFlag(GO_FLAG_DESTROYED))
            return GO_DESTRUCTIBLE_DESTROYED;
        if (HasGameObjectFlag(GO_FLAG_DAMAGED))
            return GO_DESTRUCTIBLE_DAMAGED;
        return GO_DESTRUCTIBLE_INTACT;
    }

References GO_DESTRUCTIBLE_DAMAGED, GO_DESTRUCTIBLE_DESTROYED, GO_DESTRUCTIBLE_INTACT, GO_FLAG_DAMAGED, GO_FLAG_DESTROYED, and HasGameObjectFlag().

Referenced by ModifyHealth().

◆ GetDisplayId()

uint32 GameObject::GetDisplayId ( ) const

inline

310{ return GetUInt32Value(GAMEOBJECT_DISPLAYID); }

GAMEOBJECT_DISPLAYID

@ GAMEOBJECT_DISPLAYID

Definition UpdateFields.h:398

Object::GetUInt32Value

uint32 GetUInt32Value(uint16 index) const

Definition Object.cpp:294

References GAMEOBJECT_DISPLAYID, and Object::GetUInt32Value().

Referenced by GameObjectModelOwnerImpl::GetDisplayId(), and spell_zulfarrak_unlocking::HandleOpenLock().

◆ GetDynamicFlags()

uint32 GameObject::GetDynamicFlags ( ) const

inlineoverridevirtual

Reimplemented from Object.

131{ return GetUInt32Value(GAMEOBJECT_DYNAMIC); }

References GAMEOBJECT_DYNAMIC, and Object::GetUInt32Value().

◆ GetFinalWorldRotation()

G3D::Quat GameObject::GetFinalWorldRotation ( ) const

{
    G3D::Quat worldRotation = GetWorldRotation();
    if (Transport* transport = GetTransport())
    {
        G3D::Quat transportRotation = transport->GetWorldRotation();
 
        G3D::Quat transportRotationQuat(transportRotation.x, transportRotation.y, transportRotation.z, transportRotation.w);
        G3D::Quat worldRotationQuat(worldRotation.x, worldRotation.y, worldRotation.z, worldRotation.w);
 
        G3D::Quat resultRotation = worldRotationQuat * transportRotationQuat;
 
        return G3D::Quat(resultRotation.x, resultRotation.y, resultRotation.z, resultRotation.w);
    }
    return worldRotation;
}

References WorldObject::GetTransport(), and GetWorldRotation().

Referenced by IsAtInteractDistance().

◆ GetFishLoot()

void GameObject::GetFishLoot	(	Loot *	fishLoot,
		Player *	lootOwner,
		bool	junk = `false`
	)

{
    fishLoot->clear();
 
    uint32 zone, area;
    uint32 defaultZone = 1;
    GetZoneAndAreaId(zone, area);
 
    uint16 lootMode = junk ? LOOT_MODE_JUNK_FISH : LOOT_MODE_DEFAULT;
    // Check to fill loot in the order area - zone - defaultZone.
    // This is because area and zone is not set in some places, like Off the coast of Storm Peaks.
    uint32 lootZones[] = { area, zone, defaultZone };
    for (uint32 fillZone : lootZones)
    {
        fishLoot->FillLoot(fillZone, LootTemplates_Fishing, lootOwner, true, true, lootMode);
 
        // If the loot is filled and the loot is eligible, then we break out of the loop.
        if (!fishLoot->empty() && !fishLoot->isLooted())
            break;
    }
}

References Loot::clear(), Loot::empty(), Loot::FillLoot(), WorldObject::GetZoneAndAreaId(), Loot::isLooted(), LOOT_MODE_DEFAULT, LOOT_MODE_JUNK_FISH, and LootTemplates_Fishing.

Referenced by Player::SendLoot().

◆ GetGameObjectData()

GameObjectData const * GameObject::GetGameObjectData ( ) const

inline

138{ return m_goData; }

References m_goData.

Referenced by GetScriptId(), gobject_commandscript::HandleGameObjectMoveCommand(), and SetGoArtKit().

◆ GetGameObjectFlags()

GameObjectFlags GameObject::GetGameObjectFlags ( ) const

inline

215{ return GameObjectFlags(GetUInt32Value(GAMEOBJECT_FLAGS)); }

References GAMEOBJECT_FLAGS, and Object::GetUInt32Value().

◆ GetGoAnimProgress()

uint8 GameObject::GetGoAnimProgress ( ) const

inline

208{ return GetByteValue(GAMEOBJECT_BYTES_1, 3); }

GAMEOBJECT_BYTES_1

@ GAMEOBJECT_BYTES_1

Definition UpdateFields.h:404

Object::GetByteValue

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition Object.cpp:312

References GAMEOBJECT_BYTES_1, and Object::GetByteValue().

Referenced by Spell::EffectDummy(), SaveToDB(), Update(), and Use().

◆ GetGoArtKit()

uint8 GameObject::GetGoArtKit ( ) const

inline

206{ return GetByteValue(GAMEOBJECT_BYTES_1, 2); }

References GAMEOBJECT_BYTES_1, and Object::GetByteValue().

Referenced by SaveToDB().

◆ GetGOInfo()

GameObjectTemplate const * GameObject::GetGOInfo ( ) const

inline

136{ return m_goInfo; }

References m_goInfo.

Referenced by ActivateToQuest(), BuildValuesUpdate(), Spell::CheckCast(), Spell::CheckEffectTarget(), CheckRitualList(), ClearRitualList(), Create(), StaticTransport::Create(), Delete(), WorldSession::DoLootRelease(), Spell::EffectOpenLock(), MotionTransport::EnableMovement(), BattlegroundSA::EventPlayerDamagedGO(), Player::GetDefaultGossipMenuForSource(), GetScriptId(), GetSpellForLock(), GetStationaryO(), GetStationaryX(), GetStationaryY(), GetStationaryZ(), GetTemplateAddon(), go_celestial_planetarium_access::go_celestial_planetarium_accessAI::GossipHello(), WorldSession::HandleAlterAppearance(), OutdoorPvPSI::HandleCustomSpell(), gobject_commandscript::HandleGameObjectMoveCommand(), gobject_commandscript::HandleGameObjectTurnCommand(), OPvPCapturePoint::HandlePlayerEnter(), OPvPCapturePoint::HandlePlayerLeave(), IsAtInteractDistance(), IsAtInteractDistance(), IsDestructibleBuilding(), IsMotionTransport(), IsNeverVisible(), IsStaticTransport(), IsTransport(), LoadGameObjectFromDB(), MotionTransport::LoadStaticPassengers(), ModifyHealth(), instance_naxxramas::OnGameObjectCreate(), instance_naxxramas::OnGameObjectRemove(), icecrown_citadel_teleport::OnGossipHello(), go_simon_cluster::OnGossipHello(), go_apexis_relic::OnGossipHello(), Acore::NearestGameObjectFishingHole::operator()(), Acore::GameObjectInRangeCheck::operator()(), Acore::GameObjectFocusCheck::operator()(), RemoveFromOwner(), Creature::SaveToDB(), SaveToDB(), BfCapturePoint::SendChangePhase(), OPvPCapturePoint::SendChangePhase(), Player::SendLoot(), Spell::SendLoot(), BfCapturePoint::SetCapturePointData(), SetLootState(), ToMotionTransport(), ToMotionTransport(), ToStaticTransport(), ToStaticTransport(), ToTransport(), ToTransport(), BfCapturePoint::Update(), OPvPCapturePoint::Update(), MotionTransport::Update(), OPvPCapturePointNA::Update(), Update(), Use(), and UseDoorOrButton().

◆ GetGoState()

GOState GameObject::GetGoState ( ) const

inline

◆ GetGoType()

GameobjectTypes GameObject::GetGoType ( ) const

inline

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

References GAMEOBJECT_BYTES_1, and Object::GetByteValue().

Referenced by Map::_ScriptProcessDoor(), ActivateToQuest(), Spell::AddGOTarget(), BuildValuesUpdate(), WorldSession::DoLootRelease(), InstanceScript::DoUseDoorOrButton(), Spell::EffectSummonObjectWild(), GetInteractionDistance(), go_gilded_brazier::go_gilded_brazierAI::GossipHello(), WorldSession::HandleAutostoreLootItemOpcode(), WorldSession::HandleMoverRelocation(), IsAtInteractDistance(), IsNeverVisible(), OutdoorPvP::OnGameObjectCreate(), OutdoorPvP::OnGameObjectRemove(), go_resonite_cask::OnGossipHello(), go_tablet_of_the_seven::OnGossipHello(), go_sacred_fire_of_life::OnGossipHello(), go_fel_crystalforge::OnGossipHello(), go_bashir_crystalforge::OnGossipHello(), Acore::NearestGameObjectTypeInObjectRangeCheck::operator()(), Player::PrepareGossipMenu(), SmartScript::ProcessAction(), Map::ScriptsProcess(), Spell::SendLoot(), SetDestructibleState(), SetLootState(), Update(), and Use().

◆ GetGOValue()

GameObjectValue const * GameObject::GetGOValue ( ) const

inline

139{ return &m_goValue; }

References m_goValue.

Referenced by WorldSession::DoLootRelease(), and Transport::GetPathProgress().

◆ GetInteractionDistance()

float GameObject::GetInteractionDistance ( ) const

{
    switch (GetGoType())
    {
        case GAMEOBJECT_TYPE_AREADAMAGE:
            return 0.0f;
        case GAMEOBJECT_TYPE_QUESTGIVER:
        case GAMEOBJECT_TYPE_TEXT:
        case GAMEOBJECT_TYPE_FLAGSTAND:
        case GAMEOBJECT_TYPE_FLAGDROP:
        case GAMEOBJECT_TYPE_MINI_GAME:
            return 5.5555553f;
        case GAMEOBJECT_TYPE_BINDER:
            return 10.0f;
        case GAMEOBJECT_TYPE_CHAIR:
        case GAMEOBJECT_TYPE_BARBER_CHAIR:
            return 3.0f;
        case GAMEOBJECT_TYPE_FISHINGNODE:
            return 100.0f;
        case GAMEOBJECT_TYPE_FISHINGHOLE:
            return 20.0f + CONTACT_DISTANCE; // max spell range
        case GAMEOBJECT_TYPE_CAMERA:
        case GAMEOBJECT_TYPE_MAP_OBJECT:
        case GAMEOBJECT_TYPE_DUNGEON_DIFFICULTY:
        case GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING:
        case GAMEOBJECT_TYPE_DOOR:
            return 5.0f;
        // Following values are not blizzlike
        case GAMEOBJECT_TYPE_GUILD_BANK:
        case GAMEOBJECT_TYPE_MAILBOX:
            // Successful mailbox interaction is rather critical to the client, failing it will start a minute-long cooldown until the next mail query may be executed.
            // And since movement info update is not sent with mailbox interaction query, server may find the player outside of interaction range. Thus we increase it.
            return 10.0f; // 5.0f is blizzlike
        default:
            return INTERACTION_DISTANCE;
    }
}

References CONTACT_DISTANCE, GAMEOBJECT_TYPE_AREADAMAGE, GAMEOBJECT_TYPE_BARBER_CHAIR, GAMEOBJECT_TYPE_BINDER, GAMEOBJECT_TYPE_CAMERA, GAMEOBJECT_TYPE_CHAIR, GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING, GAMEOBJECT_TYPE_DOOR, GAMEOBJECT_TYPE_DUNGEON_DIFFICULTY, GAMEOBJECT_TYPE_FISHINGHOLE, GAMEOBJECT_TYPE_FISHINGNODE, GAMEOBJECT_TYPE_FLAGDROP, GAMEOBJECT_TYPE_FLAGSTAND, GAMEOBJECT_TYPE_GUILD_BANK, GAMEOBJECT_TYPE_MAILBOX, GAMEOBJECT_TYPE_MAP_OBJECT, GAMEOBJECT_TYPE_MINI_GAME, GAMEOBJECT_TYPE_QUESTGIVER, GAMEOBJECT_TYPE_TEXT, GetGoType(), and INTERACTION_DISTANCE.

Referenced by IsAtInteractDistance().

◆ getLevelForTarget()

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

inlineoverridevirtual

Reimplemented from WorldObject.

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

References GetOwner().

◆ GetLinkedTrap()

GameObject * GameObject::GetLinkedTrap ( )

{
    return ObjectAccessor::GetGameObject(*this, m_linkedTrap);
}

References ObjectAccessor::GetGameObject(), and m_linkedTrap.

Referenced by DespawnOrUnsummon(), Spell::EffectSummonObjectWild(), Spell::EffectTransmitted(), RemoveFromWorld(), go_direbrew_mole_machine::go_direbrew_mole_machineAI::Reset(), TriggeringLinkedGameObject(), and Update().

◆ GetLootGenerationTime()

uint32 GameObject::GetLootGenerationTime ( ) const

inline

257{ return m_lootGenerationTime; }

References m_lootGenerationTime.

Referenced by Player::SendLoot().

◆ GetLootMode()

uint16 GameObject::GetLootMode ( ) const

inline

227{ return m_LootMode; }

References m_LootMode.

Referenced by gobject_commandscript::HandleGameObjectInfoCommand(), and Player::SendLoot().

◆ GetLootRecipient()

Player * GameObject::GetLootRecipient ( ) const

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

References ObjectAccessor::FindConnectedPlayer(), and m_lootRecipient.

◆ GetLootRecipientGroup()

Group * GameObject::GetLootRecipientGroup ( ) const

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

References m_lootRecipientGroup, and sGroupMgr.

Referenced by IsLootAllowedFor().

◆ getLootState()

LootState GameObject::getLootState ( ) const

inline

223{ return m_lootState; }

References m_lootState.

Referenced by InstanceScript::DoUseDoorOrButton(), Spell::EffectOpenLock(), gobject_commandscript::HandleGameObjectInfoCommand(), Player::SendLoot(), npc_rookery_hatcher::UpdateAI(), npc_unworthy_initiate::npc_unworthy_initiateAI::UpdateAI(), and Use().

◆ GetNameForLocaleIdx()

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();
}

References DEFAULT_LOCALE, Object::GetEntry(), WorldObject::GetName(), and sObjectMgr.

Referenced by gobject_commandscript::HandleGameObjectRespawn().

◆ GetOwner()

Unit * GameObject::GetOwner ( ) const

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

References GetOwnerGUID(), and ObjectAccessor::GetUnit().

Referenced by CastSpell(), Spell::EffectOpenLock(), getLevelForTarget(), go_soulwell::go_soulwellAI::GossipHello(), IsAlwaysVisibleFor(), TriggeringLinkedGameObject(), Update(), and Use().

◆ GetOwnerGUID()

ObjectGuid GameObject::GetOwnerGUID ( ) const

inline

173{ return GetGuidValue(OBJECT_FIELD_CREATED_BY); }

OBJECT_FIELD_CREATED_BY

@ OBJECT_FIELD_CREATED_BY

Definition UpdateFields.h:397

Object::GetGuidValue

ObjectGuid GetGuidValue(uint16 index) const

Definition Object.cpp:326

References Object::GetGuidValue(), and OBJECT_FIELD_CREATED_BY.

Referenced by Unit::AddGameObject(), BuildValuesUpdate(), CheckRitualList(), WorldSession::DoLootRelease(), GetOwner(), SmartScript::GetTargets(), WorldSession::HandleAutostoreLootItemOpcode(), WorldSession::HandleLootMoneyOpcode(), IsAlwaysVisibleFor(), RemoveFromOwner(), Unit::RemoveGameObject(), Player::SendLoot(), SetOwnerGUID(), Update(), and Use().

◆ GetPackedWorldRotation()

int64 GameObject::GetPackedWorldRotation ( ) const

inline

151{ return m_packedRotation; }

References m_packedRotation.

◆ GetRespawnDelay()

uint32 GameObject::GetRespawnDelay ( ) const

inline

197{ return m_respawnDelayTime; }

References m_respawnDelayTime.

Referenced by gobject_commandscript::HandleGameObjectTargetCommand(), and Player::SendLoot().

◆ GetRespawnPosition()

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

{
    if (m_spawnId)
    {
        if (GameObjectData const* data = sObjectMgr->GetGameObjectData(m_spawnId))
        {
            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();
}

References Position::GetOrientation(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), m_spawnId, and sObjectMgr.

◆ GetRespawnTime()

time_t GameObject::GetRespawnTime ( ) const

inline

183{ return m_respawnTime; }

References m_respawnTime.

Referenced by spell_q9452_cast_net::CheckCast(), Spell::EffectDummy(), and Player::SendLoot().

◆ GetRespawnTimeEx()

time_t GameObject::GetRespawnTimeEx ( ) const

{
    time_t now = GameTime::GetGameTime().count();
    if (m_respawnTime > now)
        return m_respawnTime;
    else
        return now;
}

References GameTime::GetGameTime(), and m_respawnTime.

Referenced by gobject_commandscript::HandleGameObjectTargetCommand().

◆ GetScriptId()

uint32 GameObject::GetScriptId ( ) const

virtual

{
    if (GameObjectData const* gameObjectData = GetGameObjectData())
        if (uint32 scriptId = gameObjectData->ScriptId)
            return scriptId;
 
    return GetGOInfo()->ScriptId;
}

References gameObjectData, GetGameObjectData(), GetGOInfo(), and GameObjectTemplate::ScriptId.

Referenced by Create(), GetDebugInfo(), ScriptMgr::GetDialogStatus(), ScriptMgr::GetGameObjectAI(), WorldSession::HandleGossipSelectOptionOpcode(), ScriptMgr::OnAddCreaturePassenger(), ScriptMgr::OnAddPassenger(), ScriptMgr::OnGameObjectDamaged(), ScriptMgr::OnGameObjectDestroyed(), ScriptMgr::OnGameObjectLootStateChanged(), ScriptMgr::OnGameObjectModifyHealth(), ScriptMgr::OnGameObjectStateChanged(), ScriptMgr::OnGameObjectUpdate(), ScriptMgr::OnGossipHello(), ScriptMgr::OnGossipSelect(), ScriptMgr::OnGossipSelectCode(), ScriptMgr::OnQuestAccept(), ScriptMgr::OnQuestReward(), ScriptMgr::OnRelocate(), ScriptMgr::OnRemovePassenger(), and ScriptMgr::OnTransportUpdate().

◆ GetSpawnId()

ObjectGuid::LowType GameObject::GetSpawnId ( ) const

inline

144{ return m_spawnId; }

References m_spawnId.

Referenced by Create(), StaticTransport::Create(), WorldSession::DoLootRelease(), GetDebugInfo(), SmartScript::GetScript(), gobject_commandscript::HandleGameObjectDeleteCommand(), gobject_commandscript::HandleGameObjectMoveCommand(), gobject_commandscript::HandleGameObjectRespawn(), gobject_commandscript::HandleGameObjectTurnCommand(), OPvPCapturePoint::HandleOpenGo(), instance_deadmines::instance_deadmines_InstanceMapScript::OnGameObjectCreate(), OutdoorPvP::OnGameObjectCreate(), OutdoorPvP::OnGameObjectRemove(), and SaveStateToDB().

◆ GetSpellForLock()

SpellInfo const * GameObject::GetSpellForLock ( Player const * player ) const

{
    if (!player)
    {
        return nullptr;
    }
 
    uint32 lockId = GetGOInfo()->GetLockId();
    if (!lockId)
    {
        return nullptr;
    }
 
    LockEntry const* lock = sLockStore.LookupEntry(lockId);
    if (!lock)
    {
        return nullptr;
    }
 
    for (uint8 i = 0; i < MAX_LOCK_CASE; ++i)
    {
        if (!lock->Type[i])
        {
            continue;
        }
 
        if (lock->Type[i] == LOCK_KEY_SPELL)
        {
            if (SpellInfo const* spell = sSpellMgr->GetSpellInfo(lock->Index[i]))
            {
                return spell;
            }
        }
 
        if (lock->Type[i] != LOCK_KEY_SKILL)
        {
            break;
        }
 
        for (auto&& playerSpell : player->GetSpellMap())
        {
            if (SpellInfo const* spell = sSpellMgr->GetSpellInfo(playerSpell.first))
            {
                for (auto&& effect : spell->Effects)
                {
                    if (effect.Effect == SPELL_EFFECT_OPEN_LOCK && ((uint32) effect.MiscValue) == lock->Index[i])
                    {
                        if (effect.CalcValue(player) >= int32(lock->Skill[i]))
                        {
                            return spell;
                        }
                    }
                }
            }
        }
    }
 
    return nullptr;
}

References GetGOInfo(), GameObjectTemplate::GetLockId(), Player::GetSpellMap(), LockEntry::Index, LOCK_KEY_SKILL, LOCK_KEY_SPELL, MAX_LOCK_CASE, LockEntry::Skill, sLockStore, SPELL_EFFECT_OPEN_LOCK, sSpellMgr, and LockEntry::Type.

Referenced by IsAtInteractDistance().

◆ GetSpellId()

uint32 GameObject::GetSpellId ( ) const

inline

181{ return m_spellId;}

References m_spellId.

Referenced by Unit::AddGameObject(), CheckRitualList(), ClearRitualList(), Unit::RemoveGameObject(), Update(), and Use().

◆ GetStationaryO()

float GameObject::GetStationaryO ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

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

References GAMEOBJECT_TYPE_MO_TRANSPORT, GetGOInfo(), Position::GetOrientation(), and m_stationaryPosition.

Referenced by StaticTransport::RelocateToProgress().

◆ GetStationaryX()

float GameObject::GetStationaryX ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

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

References GAMEOBJECT_TYPE_MO_TRANSPORT, GetGOInfo(), Position::GetPositionX(), and m_stationaryPosition.

Referenced by StaticTransport::RelocateToProgress().

◆ GetStationaryY()

float GameObject::GetStationaryY ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

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

References GAMEOBJECT_TYPE_MO_TRANSPORT, GetGOInfo(), Position::GetPositionY(), and m_stationaryPosition.

Referenced by StaticTransport::RelocateToProgress().

◆ GetStationaryZ()

float GameObject::GetStationaryZ ( ) const

inlineoverridevirtual

Reimplemented from WorldObject.

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

References GAMEOBJECT_TYPE_MO_TRANSPORT, GetGOInfo(), Position::GetPositionZ(), and m_stationaryPosition.

Referenced by StaticTransport::RelocateToProgress().

◆ GetTemplateAddon()

GameObjectTemplateAddon const * GameObject::GetTemplateAddon ( ) const

{
    return sObjectMgr->GetGameObjectTemplateAddon(GetGOInfo()->entry);
}

References GetGOInfo(), and sObjectMgr.

Referenced by CastSpell(), Create(), StaticTransport::Create(), MotionTransport::CreateMoTrans(), Delete(), DespawnOrUnsummon(), Spell::EffectActivateObject(), Player::SendLoot(), and Update().

◆ GetUniqueUseCount()

uint32 GameObject::GetUniqueUseCount ( ) const

inline

241{ return m_unique_users.size(); }

References m_unique_users.

Referenced by Update(), and Use().

◆ GetUseCount()

uint32 GameObject::GetUseCount ( ) const

inline

240{ return m_usetimes; }

References m_usetimes.

Referenced by WorldSession::DoLootRelease().

◆ GetWorldRotation()

G3D::Quat const & GameObject::GetWorldRotation ( ) const

inline

150{ return WorldRotation; }

GameObject::WorldRotation

G3D::Quat WorldRotation

Definition GameObject.h:398

References WorldRotation.

Referenced by GetFinalWorldRotation().

◆ HasGameObjectFlag()

bool GameObject::HasGameObjectFlag ( GameObjectFlags flags ) const

inline

216{ return HasFlag(GAMEOBJECT_FLAGS, flags) != 0; }

Object::HasFlag

bool HasFlag(uint16 index, uint32 flag) const

Definition Object.cpp:871

References GAMEOBJECT_FLAGS, and Object::HasFlag().

Referenced by GetDestructibleState(), WorldSession::HandleGameobjectReportUse(), and Use().

◆ hasInvolvedQuest()

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;
}

References Object::GetEntry(), and sObjectMgr.

◆ HasLootMode()

bool GameObject::HasLootMode ( uint16 lootMode ) const

inline

228{ return m_LootMode & lootMode; }

References m_LootMode.

◆ HasLootRecipient()

bool GameObject::HasLootRecipient ( ) const

inline

253{ return m_lootRecipient || m_lootRecipientGroup; }

References m_lootRecipient, and m_lootRecipientGroup.

Referenced by BuildValuesUpdate().

◆ hasQuest()

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;
}

References Object::GetEntry(), and sObjectMgr.

◆ IsAllowedToSaveToDB()

bool GameObject::IsAllowedToSaveToDB ( ) const

inline

356{ return m_saveStateOnDb; };

References m_saveStateOnDb.

Referenced by SetGoState().

◆ IsAlwaysVisibleFor()

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 (ObjectGuid guid = GetOwnerGUID())
    {
        if (seer->GetGUID() == guid)
            return true;
 
        Unit* owner = GetOwner();
        if (owner)
        {
            if (seer->IsUnit() && owner->IsFriendlyTo(seer->ToUnit()))
                return true;
        }
    }
 
    return false;
}

References Object::GetGUID(), GetOwner(), GetOwnerGUID(), WorldObject::IsAlwaysVisibleFor(), IsDestructibleBuilding(), Unit::IsFriendlyTo(), IsTransport(), Object::IsUnit(), and Object::ToUnit().

◆ IsAtInteractDistance() [1/2]

bool GameObject::IsAtInteractDistance	(	Player const *	player,
		SpellInfo const *	spell = `nullptr`
	)		const

{
    if (spell || (spell = GetSpellForLock(player)))
    {
        float maxRange = spell->GetMaxRange(spell->IsPositive());
 
        if (GetGoType() == GAMEOBJECT_TYPE_SPELL_FOCUS)
        {
            return maxRange * maxRange >= GetExactDistSq(player);
        }
 
        if (sGameObjectDisplayInfoStore.LookupEntry(GetGOInfo()->displayId))
        {
            return IsAtInteractDistance(*player, maxRange);
        }
    }
 
    return IsAtInteractDistance(*player, GetInteractionDistance());
}

References GAMEOBJECT_TYPE_SPELL_FOCUS, Position::GetExactDistSq(), GetGOInfo(), GetGoType(), GetInteractionDistance(), SpellInfo::GetMaxRange(), GetSpellForLock(), IsAtInteractDistance(), SpellInfo::IsPositive(), and sGameObjectDisplayInfoStore.

◆ IsAtInteractDistance() [2/2]

bool GameObject::IsAtInteractDistance	(	Position const &	pos,
		float	radius
	)		const

{
    if (GameObjectDisplayInfoEntry const* displayInfo = sGameObjectDisplayInfoStore.LookupEntry(GetGOInfo()->displayId))
    {
        float scale = GetObjectScale();
 
        float minX = displayInfo->minX * scale - radius;
        float minY = displayInfo->minY * scale - radius;
        float minZ = displayInfo->minZ * scale - radius;
        float maxX = displayInfo->maxX * scale + radius;
        float maxY = displayInfo->maxY * scale + radius;
        float maxZ = displayInfo->maxZ * scale + radius;
 
        G3D::Quat finalRotation = GetFinalWorldRotation();
        G3D::Quat finalRotationQuat(finalRotation.x, finalRotation.y, finalRotation.z, finalRotation.w);
 
        return G3D::CoordinateFrame {{finalRotationQuat}, {GetPositionX(), GetPositionY(), GetPositionZ()}}.toWorldSpace(G3D::Box {{minX, minY, minZ}, {maxX, maxY, maxZ}}).contains({pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ()});
    }
 
    return GetExactDist(&pos) <= radius;
}

References Position::GetExactDist(), GetFinalWorldRotation(), GetGOInfo(), Object::GetObjectScale(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), and sGameObjectDisplayInfoStore.

Referenced by IsAtInteractDistance(), and IsWithinDistInMap().

◆ IsDestructibleBuilding()

bool GameObject::IsDestructibleBuilding ( ) const

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

References GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING, GetGOInfo(), and GameObjectTemplate::type.

Referenced by IsAlwaysVisibleFor(), and ModifyHealth().

◆ IsInRange2d()

bool GameObject::IsInRange2d	(	float	x,
		float	y,
		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 IsWithinDist2d(x, y, radius);
 
    float sinA = std::sin(GetOrientation());
    float cosA = cos(GetOrientation());
    float dx = x - GetPositionX();
    float dy = y - GetPositionY();
    float dist = std::sqrt(dx * dx + dy * dy);
    if (G3D::fuzzyEq(dist, 0.0f))
        return true;
 
    float scale = GetObjectScale();
    float sinB = dx / dist;
    float cosB = dy / dist;
    dx = dist * (cosA * cosB + sinA * sinB);
    dy = dist * (cosA * sinB - sinA * cosB);
    return dx < (info->maxX * scale) + radius && dx >(info->minX * scale) - radius
        && dy < (info->maxY * scale) + radius && dy >(info->minY * scale) - radius;
}

References GameObjectTemplate::displayId, Object::GetObjectScale(), Position::GetOrientation(), Position::GetPositionX(), Position::GetPositionY(), WorldObject::IsWithinDist2d(), m_goInfo, GameObjectDisplayInfoEntry::maxX, GameObjectDisplayInfoEntry::maxY, GameObjectDisplayInfoEntry::minX, GameObjectDisplayInfoEntry::minY, and sGameObjectDisplayInfoStore.

Referenced by IsWithinSightRange().

◆ IsInRange3d()

bool GameObject::IsInRange3d	(	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 = 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 scale = GetObjectScale();
    float sinB = dx / dist;
    float cosB = dy / dist;
    dx = dist * (cosA * cosB + sinA * sinB);
    dy = dist * (cosA * sinB - sinA * cosB);
    return dx < (info->maxX * scale) + radius && dx > (info->minX * scale) - radius
           && dy < (info->maxY * scale) + radius && dy > (info->minY * scale) - radius
           && dz < (info->maxZ * scale) + radius && dz > (info->minZ * scale) - radius;
}

References GameObjectTemplate::displayId, Object::GetObjectScale(), Position::GetOrientation(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), WorldObject::IsWithinDist3d(), m_goInfo, GameObjectDisplayInfoEntry::maxX, GameObjectDisplayInfoEntry::maxY, GameObjectDisplayInfoEntry::maxZ, GameObjectDisplayInfoEntry::minX, GameObjectDisplayInfoEntry::minY, GameObjectDisplayInfoEntry::minZ, and sGameObjectDisplayInfoStore.

Referenced by _IsWithinDist(), Acore::GameObjectInRangeCheck::operator()(), Acore::AnyPlayerExactPositionInGameObjectRangeCheck::operator()(), and Acore::WorldObjectSpellAreaTargetCheck::operator()().

◆ IsInSkillupList()

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

{
    for (auto const& itr : m_SkillupList)
    {
        if (itr.first == playerGuid)
        {
            return true;
        }
    }
 
    return false;
}

References m_SkillupList.

Referenced by Spell::EffectOpenLock().

◆ IsInstanceGameobject()

bool GameObject::IsInstanceGameobject ( ) const

{
    // Avoid checking for unecessary gameobjects whose
    // states don't matter for the dungeon progression
    if (!ValidateGameobjectType())
    {
        return false;
    }
 
    if (auto* map = FindMap())
    {
        if (map->IsDungeon() || map->IsRaid())
        {
            return true;
        }
    }
    return false;
}

References WorldObject::FindMap(), and ValidateGameobjectType().

Referenced by Create(), SaveStateToDB(), and SetGoState().

◆ IsInvisibleDueToDespawn()

bool GameObject::IsInvisibleDueToDespawn ( ) const

overridevirtual

Reimplemented from WorldObject.

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

References WorldObject::IsInvisibleDueToDespawn(), and isSpawned().

◆ IsLootAllowedFor()

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

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

References Player::GetGroup(), Object::GetGUID(), GetLootRecipientGroup(), WorldObject::HasAllowedLooter(), Player::HasPendingBind(), m_lootRecipient, and m_lootRecipientGroup.

Referenced by BuildValuesUpdate().

◆ IsMotionTransport()

bool GameObject::IsMotionTransport ( ) const

inline

319{ return GetGOInfo()->type == GAMEOBJECT_TYPE_MO_TRANSPORT; }

References GAMEOBJECT_TYPE_MO_TRANSPORT, GetGOInfo(), and GameObjectTemplate::type.

◆ IsNeverVisible()

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;
}

References GAMEOBJECT_TYPE_SPELL_FOCUS, GetGOInfo(), GetGoType(), WorldObject::IsNeverVisible(), and GameObjectTemplate::serverOnly.

◆ isSpawned()

bool GameObject::isSpawned ( ) const

inline

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

References m_respawnDelayTime, m_respawnTime, and m_spawnedByDefault.

Referenced by spell_q10612_10613_the_fel_and_the_furious::HandleScriptEffect(), SmartGameObjectAI::InitializeAI(), IsInvisibleDueToDespawn(), GameObjectModelOwnerImpl::IsSpawned(), Acore::NearestGameObjectFishingHole::operator()(), Acore::NearestGameObjectEntryInObjectRangeCheck::operator()(), Acore::GameObjectFocusCheck::operator()(), Refresh(), Map::ScriptsProcess(), Spell::SendLoot(), Update(), and go_tadpole_cage::go_tadpole_cageAI::UpdateAI().

◆ isSpawnedByDefault()

bool GameObject::isSpawnedByDefault ( ) const

inline

195{ return m_spawnedByDefault; }

References m_spawnedByDefault.

Referenced by GameEventMgr::GameEventSpawn(), Player::SendLoot(), and Update().

◆ IsStaticTransport()

bool GameObject::IsStaticTransport ( ) const

inline

318{ return GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT; }

References GAMEOBJECT_TYPE_TRANSPORT, GetGOInfo(), and GameObjectTemplate::type.

Referenced by Unit::isInAccessiblePlaceFor().

◆ IsTransport()

bool GameObject::IsTransport ( ) const

{
    return GetGOInfo() && (GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT || GetGOInfo()->type == GAMEOBJECT_TYPE_MO_TRANSPORT);
}

References GAMEOBJECT_TYPE_MO_TRANSPORT, GAMEOBJECT_TYPE_TRANSPORT, GetGOInfo(), and GameObjectTemplate::type.

Referenced by AddToWorld(), GameObjectModelOwnerImpl::GetPhaseMask(), IsAlwaysVisibleFor(), IsUpdateNeeded(), ObjectVisibilityContainer::LinkWorldObjectVisibility(), and SetGoState().

◆ IsUpdateNeeded()

bool GameObject::IsUpdateNeeded ( )

overridevirtual

Reimplemented from WorldObject.

{
    if (WorldObject::IsUpdateNeeded())
        return true;
 
    if (GetMap()->isCellMarked(GetCurrentCell().GetCellCoord().GetId()))
        return true;
 
    if (!GetObjectVisibilityContainer().GetVisiblePlayersMap().empty())
        return true;
 
    if (IsTransport())
        return true;
 
    return false;
}

References MovableMapObject::GetCurrentCell(), WorldObject::GetMap(), WorldObject::GetObjectVisibilityContainer(), IsTransport(), and WorldObject::IsUpdateNeeded().

◆ IsWithinDistInMap() [1/2]

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

{
    return IsInMap(player) && InSamePhase(player) && IsAtInteractDistance(player);
}

References WorldObject::InSamePhase(), IsAtInteractDistance(), and WorldObject::IsInMap().

Referenced by WorldSession::DoLootRelease(), WorldSession::HandleAutostoreLootItemOpcode(), WorldSession::HandleGameobjectReportUse(), WorldSession::HandleLootMoneyOpcode(), Acore::GameObjectFocusCheck::operator()(), Player::SendLoot(), BfCapturePoint::Update(), OPvPCapturePoint::Update(), and OPvPCapturePointNA::Update().

◆ IsWithinDistInMap() [2/2]

bool WorldObject::IsWithinDistInMap	(	WorldObject const *	obj,
		float	dist2compare,
		bool	is3D = `true`,
		bool	incOwnRadius = `true`,
		bool	incTargetRadius = `true`
	)		const

{
    return obj && IsInMap(obj) && InSamePhase(obj) && _IsWithinDist(obj, dist2compare, is3D, incOwnRadius, incTargetRadius);
}

References CorpseUpdateFieldFlags, DynamicObjectUpdateFieldFlags, GameObjectUpdateFieldFlags, Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), Object::GetGUID(), Object::GetTypeId(), Object::HasDynamicFlag(), Player::IsInSameRaidWith(), ItemUpdateFieldFlags, SPELL_AURA_EMPATHY, Object::ToCorpse(), Object::ToGameObject(), Object::ToUnit(), TYPEID_CONTAINER, TYPEID_CORPSE, TYPEID_DYNAMICOBJECT, TYPEID_GAMEOBJECT, TYPEID_ITEM, TYPEID_OBJECT, TYPEID_PLAYER, TYPEID_UNIT, UF_FLAG_ITEM_OWNER, UF_FLAG_OWNER, UF_FLAG_PARTY_MEMBER, UF_FLAG_PRIVATE, UF_FLAG_PUBLIC, UF_FLAG_SPECIAL_INFO, UNIT_DYNFLAG_SPECIALINFO, and UnitUpdateFieldFlags.

◆ IsWithinSightRange()

bool GameObject::IsWithinSightRange	(	Position const &	pos,
		float	dist
	)		const

overrideprivatevirtual

Reimplemented from WorldObject.

{
    return IsInRange2d(pos.GetPositionX(), pos.GetPositionY(), dist);
}

References Position::GetPositionX(), Position::GetPositionY(), and IsInRange2d().

◆ LoadFromDB()

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

inlinevirtual

Reimplemented in StaticTransport.

159{ return LoadGameObjectFromDB(guid, map, false); }

GameObject::LoadGameObjectFromDB

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

Definition GameObject.cpp:1099

References LoadGameObjectFromDB().

Referenced by GridObjectLoader::LoadGameObjects().

◆ LoadGameObjectFromDB()

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

virtual

Reimplemented in StaticTransport.

{
    GameObjectData const* data = sObjectMgr->GetGameObjectData(spawnId);
 
    if (!data)
    {
        LOG_ERROR("sql.sql", "Gameobject (GUID: {}) 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;
 
    uint32 animprogress = data->animprogress;
    GOState go_state = data->go_state;
    uint32 artKit = data->artKit;
 
    m_goData = data;
    m_spawnId = spawnId;
 
    if (!Create(map->GenerateLowGuid<HighGuid::GameObject>(), entry, map, phaseMask, x, y, z, ang, data->rotation, animprogress, go_state, artKit))
        return false;
 
    if (data->spawntimesecs >= 0)
    {
        m_spawnedByDefault = true;
 
        if (!GetGOInfo()->GetDespawnPossibility() && !GetGOInfo()->IsDespawnAtAction())
        {
            SetGameObjectFlag(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 <= GameTime::GetGameTime().count())
            {
                m_respawnTime = 0;
                GetMap()->RemoveGORespawnTime(m_spawnId);
            }
        }
    }
    else
    {
        m_spawnedByDefault = false;
        m_respawnDelayTime = -data->spawntimesecs;
        m_respawnTime = 0;
    }
 
    if (addToMap && !GetMap()->AddToMap(this))
        return false;
 
    return true;
}

References GameObjectData::animprogress, GameObjectData::artKit, Create(), GameObject, Map::GenerateLowGuid(), GameTime::GetGameTime(), GetGOInfo(), Map::GetGORespawnTime(), WorldObject::GetMap(), GO_FLAG_NODESPAWN, GameObjectData::go_state, GameObjectData::id, LOG_ERROR, m_goData, m_respawnDelayTime, m_respawnTime, m_spawnedByDefault, m_spawnId, SpawnData::orientation, SpawnData::phaseMask, SpawnData::posX, SpawnData::posY, SpawnData::posZ, Map::RemoveGORespawnTime(), GameObjectData::rotation, SetGameObjectFlag(), sObjectMgr, and GameObjectData::spawntimesecs.

Referenced by ObjectMgr::AddGOData(), MotionTransport::CreateGOPassenger(), GameEventMgr::GameEventSpawn(), gobject_commandscript::HandleGameObjectAddCommand(), gobject_commandscript::HandleGameObjectLoadCommand(), gobject_commandscript::HandleGameObjectMoveCommand(), gobject_commandscript::HandleGameObjectTurnCommand(), and LoadFromDB().

◆ LookupFishingHoleAround()

GameObject * GameObject::LookupFishingHoleAround ( float range )

{
    GameObject* ok = nullptr;
 
    Acore::NearestGameObjectFishingHole u_check(*this, range);
    Acore::GameObjectSearcher<Acore::NearestGameObjectFishingHole> checker(this, ok, u_check);
 
    Cell::VisitObjects(this, checker, range);
    return ok;
}

References Cell::VisitObjects().

Referenced by Use().

◆ ModifyHealth()

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

Todo:: : is there any packet for healing?

{
    if (!IsDestructibleBuilding())
        return;
 
    // if this building doesn't have health, return
    if (!m_goValue.Building.MaxHealth)
        return;
 
    sScriptMgr->OnGameObjectModifyHealth(this, attackerOrHealer, change, sSpellMgr->GetSpellInfo(spellId));
 
    // if the health isn't being changed, return
    if (!change)
        return;
 
    if (!m_allowModifyDestructibleBuilding)
        change = 0;
 
    // 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->GetCharmerOrOwnerPlayerOrPlayerItself();
 
    // dealing damage, send packet
    if (player)
    {
        WorldPacket data(SMSG_DESTRUCTIBLE_BUILDING_DAMAGE, 8 + 8 + 8 + 4 + 4);
        data << GetPackGUID();
        data << attackerOrHealer->GetPackGUID();
        data << player->GetPackGUID();
        data << uint32(-change);                    // change  < 0 triggers SPELL_BUILDING_HEAL combat log event
        // change >= 0 triggers SPELL_BUILDING_DAMAGE event
        data << uint32(spellId);
        player->SendDirectMessage(&data);
    }
 
    GameObjectDestructibleState newState = GetDestructibleState();
 
    if (!m_goValue.Building.Health)
        newState = GO_DESTRUCTIBLE_DESTROYED;
    else if (m_goValue.Building.Health <= GetGOInfo()->building.damagedNumHits)
        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);
}

References GameObjectValue::Building, GameObjectTemplate::damagedNumHits, Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), GetDestructibleState(), GetGOInfo(), Object::GetPackGUID(), GO_DESTRUCTIBLE_DAMAGED, GO_DESTRUCTIBLE_DESTROYED, GO_DESTRUCTIBLE_INTACT, GameObjectValue::Health, IsDestructibleBuilding(), m_allowModifyDestructibleBuilding, m_goValue, GameObjectValue::MaxHealth, Player::SendDirectMessage(), SetDestructibleState(), SetGoAnimProgress(), SMSG_DESTRUCTIBLE_BUILDING_DAMAGE, sScriptMgr, and sSpellMgr.

Referenced by Spell::EffectGameObjectDamage(), and Spell::EffectGameObjectRepair().

◆ Refresh()

void GameObject::Refresh ( )

{
    // not refresh despawned not casted GO (despawned casted GO destroyed in all cases anyway)
    if (m_respawnTime > 0 && m_spawnedByDefault)
        return;
 
    if (isSpawned())
        GetMap()->AddToMap(this);
}

References Map::AddToMap(), WorldObject::GetMap(), isSpawned(), m_respawnTime, and m_spawnedByDefault.

Referenced by BattlegroundSA::ResetObjs().

◆ RemoveFromOwner()

void GameObject::RemoveFromOwner ( )

private

{
    ObjectGuid ownerGUID = GetOwnerGUID();
    if (!ownerGUID)
        return;
 
    if (Unit* owner = ObjectAccessor::GetUnit(*this, ownerGUID))
    {
        owner->RemoveGameObject(this, false);
        ASSERT(!GetOwnerGUID());
        return;
    }
 
    LOG_DEBUG("entities.gameobject", "Delete GameObject ({} Entry: {} SpellId {} LinkedGO {}) that lost references to owner {} GO list.",
        GetGUID().ToString(), GetGOInfo()->entry, m_spellId, GetGOInfo()->GetLinkedGameObjectEntry(), ownerGUID.ToString());
 
    SetOwnerGUID(ObjectGuid::Empty);
}

References ASSERT, ObjectGuid::Empty, GetGOInfo(), Object::GetGUID(), GetOwnerGUID(), ObjectAccessor::GetUnit(), LOG_DEBUG, m_spellId, SetOwnerGUID(), ObjectGuid::ToString(), and Position::ToString().

Referenced by CleanupsBeforeDelete(), Delete(), RemoveFromWorld(), and Use().

◆ RemoveFromWorld()

void GameObject::RemoveFromWorld ( )

overridevirtual

Remove the gameobject from the accessor

Reimplemented from Object.

{
    if (IsInWorld())
    {
        sScriptMgr->OnGameObjectRemoveWorld(this);
 
        if (m_zoneScript)
            m_zoneScript->OnGameObjectRemove(this);
 
        RemoveFromOwner();
 
        if (m_model)
            if (GetMap()->ContainsGameObjectModel(*m_model))
                GetMap()->RemoveGameObjectModel(*m_model);
 
        if (Transport* transport = GetTransport())
            transport->RemovePassenger(this, true);
 
        // If linked trap exists, despawn it
        if (GameObject* linkedTrap = GetLinkedTrap())
        {
            linkedTrap->Delete();
        }
 
        WorldObject::RemoveFromWorld();
 
        if (m_spawnId)
            Acore::Containers::MultimapErasePair(GetMap()->GetGameObjectBySpawnIdStore(), m_spawnId, this);
        GetMap()->GetObjectsStore().Remove<GameObject>(GetGUID());
    }
}

References Object::GetGUID(), GetLinkedTrap(), WorldObject::GetMap(), Map::GetObjectsStore(), WorldObject::GetTransport(), Object::IsInWorld(), m_model, m_spawnId, WorldObject::m_zoneScript, Acore::Containers::MultimapErasePair(), ZoneScript::OnGameObjectRemove(), TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Remove(), RemoveFromOwner(), WorldObject::RemoveFromWorld(), Map::RemoveGameObjectModel(), and sScriptMgr.

Referenced by CleanupsBeforeDelete(), BattlegroundIC::PostUpdateImpl(), Map::RemoveFromMap(), and go_bear_trap::go_bear_trapAI::UpdateAI().

◆ RemoveGameObjectFlag()

void GameObject::RemoveGameObjectFlag ( GameObjectFlags flags )

inline

218{ RemoveFlag(GAMEOBJECT_FLAGS, flags); }

Object::RemoveFlag

void RemoveFlag(uint16 index, uint32 oldFlag)

Definition Object.cpp:842

References GAMEOBJECT_FLAGS, and Object::RemoveFlag().

◆ RemoveLootMode()

void GameObject::RemoveLootMode ( uint16 lootMode )

inline

231{ m_LootMode &= ~lootMode; }

References m_LootMode.

◆ ReplaceAllDynamicFlags()

void GameObject::ReplaceAllDynamicFlags ( uint32 flag )

inlineoverridevirtual

Reimplemented from Object.

132{ SetUInt32Value(GAMEOBJECT_DYNAMIC, flag); }

References GAMEOBJECT_DYNAMIC, and Object::SetUInt32Value().

◆ ReplaceAllGameObjectFlags()

void GameObject::ReplaceAllGameObjectFlags ( GameObjectFlags flags )

inline

219{ SetUInt32Value(GAMEOBJECT_FLAGS, flags); }

References GAMEOBJECT_FLAGS, and Object::SetUInt32Value().

Referenced by boss_thorim::CloseDoors(), Create(), StaticTransport::Create(), MotionTransport::CreateMoTrans(), boss_thorim::DamageTaken(), Delete(), DespawnOrUnsummon(), instance_sunken_temple::instance_sunken_temple_InstanceMapScript::OnGameObjectCreate(), and Update().

◆ ResetDoorOrButton()

void GameObject::ResetDoorOrButton ( )

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

References GO_JUST_DEACTIVATED, GO_READY, m_cooldownTime, m_lootState, SetLootState(), and SwitchDoorOrButton().

Referenced by InstanceScript::DoUseDoorOrButton(), Spell::EffectActivateObject(), go_bristlelimb_cage::OnGossipHello(), FrozenThroneResetWorker::operator()(), Update(), and npc_unworthy_initiate::npc_unworthy_initiateAI::UpdateAI().

◆ ResetLootMode()

void GameObject::ResetLootMode ( )

inline

232{ m_LootMode = LOOT_MODE_DEFAULT; }

References LOOT_MODE_DEFAULT, and m_LootMode.

Referenced by GameObject().

◆ Respawn()

void GameObject::Respawn ( )

{
    if (m_spawnedByDefault && m_respawnTime > 0)
    {
        m_respawnTime = GameTime::GetGameTime().count();
        GetMap()->RemoveGORespawnTime(m_spawnId);
    }
}

References GameTime::GetGameTime(), WorldObject::GetMap(), m_respawnTime, m_spawnedByDefault, m_spawnId, and Map::RemoveGORespawnTime().

Referenced by go_suppression_device::Activate(), and Acore::RespawnDo::operator()().

◆ SaveRespawnTime() [1/2]

void GameObject::SaveRespawnTime ( )

inlineoverridevirtual

Reimplemented from WorldObject.

243{ SaveRespawnTime(0); }

GameObject::SaveRespawnTime

void SaveRespawnTime() override

Definition GameObject.h:243

References SaveRespawnTime().

Referenced by go_strange_pool::OnGossipHello(), Map::RemoveFromMap(), SaveRespawnTime(), and Update().

◆ SaveRespawnTime() [2/2]

void GameObject::SaveRespawnTime ( uint32 forceDelay )

{
    if (m_goData && m_goData->dbData && (forceDelay || m_respawnTime > GameTime::GetGameTime().count()) && m_spawnedByDefault)
    {
        time_t respawnTime = forceDelay ? GameTime::GetGameTime().count() + forceDelay : m_respawnTime;
        GetMap()->SaveGORespawnTime(m_spawnId, respawnTime);
    }
}

References SpawnData::dbData, GameTime::GetGameTime(), WorldObject::GetMap(), m_goData, m_respawnTime, m_spawnedByDefault, m_spawnId, and Map::SaveGORespawnTime().

◆ SaveStateToDB()

void GameObject::SaveStateToDB ( )

{
    if (IsInstanceGameobject())
    {
        if (InstanceScript* instance = GetInstanceScript())
        {
            GOState param = GetGoState();
            instance->StoreGameObjectState(GetSpawnId(), GameobjectStateToInt(&param));
 
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INSERT_INSTANCE_SAVED_DATA);
            stmt->SetData(0, GetInstanceId());
            stmt->SetData(1, GetSpawnId());
            stmt->SetData(2, GameobjectStateToInt(&param));
            CharacterDatabase.Execute(stmt);
        }
    }
}

References CHAR_INSERT_INSTANCE_SAVED_DATA, CharacterDatabase, GameobjectStateToInt(), GetGoState(), WorldObject::GetInstanceId(), WorldObject::GetInstanceScript(), GetSpawnId(), IsInstanceGameobject(), and PreparedStatementBase::SetData().

Referenced by SetGoState().

◆ SaveToDB() [1/2]

void GameObject::SaveToDB ( bool saveAddon = false )

{
    // 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->GetGameObjectData(m_spawnId);
    if (!data)
    {
        LOG_ERROR("entities.gameobject", "GameObject::SaveToDB failed, cannot get gameobject data!");
        return;
    }
 
    SaveToDB(GetMapId(), data->spawnMask, data->phaseMask, saveAddon);
}

References WorldLocation::GetMapId(), LOG_ERROR, m_spawnId, SpawnData::phaseMask, SaveToDB(), sObjectMgr, and SpawnData::spawnMask.

Referenced by SaveToDB().

◆ SaveToDB() [2/2]

void GameObject::SaveToDB	(	uint32	mapid,
		uint8	spawnMask,
		uint32	phaseMask,
		bool	saveAddon = `false`
	)

{
    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.id = GetEntry();
    data.mapid = mapid;
    data.phaseMask = phaseMask;
    data.posX = GetPositionX();
    data.posY = GetPositionY();
    data.posZ = GetPositionZ();
    data.orientation = GetOrientation();
    data.rotation = WorldRotation;
    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
    WorldDatabaseTransaction trans = WorldDatabase.BeginTransaction();
 
    uint8 index = 0;
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_DEL_GAMEOBJECT);
    stmt->SetData(0, m_spawnId);
    trans->Append(stmt);
 
    stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_GAMEOBJECT);
    stmt->SetData(index++, m_spawnId);
    stmt->SetData(index++, GetEntry());
    stmt->SetData(index++, uint16(mapid));
    stmt->SetData(index++, spawnMask);
    stmt->SetData(index++, GetPhaseMask());
    stmt->SetData(index++, GetPositionX());
    stmt->SetData(index++, GetPositionY());
    stmt->SetData(index++, GetPositionZ());
    stmt->SetData(index++, GetOrientation());
    stmt->SetData(index++, WorldRotation.x);
    stmt->SetData(index++, WorldRotation.y);
    stmt->SetData(index++, WorldRotation.z);
    stmt->SetData(index++, WorldRotation.w);
    stmt->SetData(index++, int32(m_respawnDelayTime));
    stmt->SetData(index++, GetGoAnimProgress());
    stmt->SetData(index++, uint8(GetGoState()));
    trans->Append(stmt);
 
    if (saveAddon && !sObjectMgr->GetGameObjectAddon(m_spawnId))
    {
        index = 0;
        stmt = WorldDatabase.GetPreparedStatement(WORLD_INS_GAMEOBJECT_ADDON);
        stmt->SetData(index++, m_spawnId);
        trans->Append(stmt);
    }
 
    WorldDatabase.CommitTransaction(trans);
    sScriptMgr->OnGameObjectSaveToDB(this);
}

References GameObjectData::animprogress, GameObjectData::artKit, Object::GetEntry(), GetGoAnimProgress(), GetGoArtKit(), GetGOInfo(), GetGoState(), Position::GetOrientation(), WorldObject::GetPhaseMask(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), GameObjectData::go_state, GameObjectData::id, m_respawnDelayTime, m_spawnedByDefault, m_spawnId, SpawnData::mapid, SpawnData::orientation, SpawnData::phaseMask, SpawnData::posX, SpawnData::posY, SpawnData::posZ, GameObjectData::rotation, PreparedStatementBase::SetData(), sObjectMgr, SpawnData::spawnMask, GameObjectData::spawntimesecs, sScriptMgr, WORLD_DEL_GAMEOBJECT, WORLD_INS_GAMEOBJECT, WORLD_INS_GAMEOBJECT_ADDON, WorldDatabase, and WorldRotation.

◆ SendCustomAnim()

void GameObject::SendCustomAnim ( uint32 anim )

{
    WorldPacket data(SMSG_GAMEOBJECT_CUSTOM_ANIM, 8 + 4);
    data << GetGUID();
    data << uint32(anim);
    SendMessageToSet(&data, true);
}

References Object::GetGUID(), WorldObject::SendMessageToSet(), and SMSG_GAMEOBJECT_CUSTOM_ANIM.

Referenced by Spell::EffectActivateObject(), Spell::EffectDummy(), go_gong_of_bethekk::OnGossipHello(), brann_bronzebeard::brann_bronzebeardAI::SwitchHeadVisaul(), Update(), go_suppression_device::UpdateAI(), and Use().

◆ SetDestructibleBuildingModifyState()

void GameObject::SetDestructibleBuildingModifyState ( bool allow )

inline

291{ m_allowModifyDestructibleBuilding = allow; }

References m_allowModifyDestructibleBuilding.

◆ SetDestructibleState()

void GameObject::SetDestructibleState	(	GameObjectDestructibleState	state,
		Player *	eventInvoker = `nullptr`,
		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:
            RemoveGameObjectFlag(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->building.damagedEvent);
 
                sScriptMgr->OnGameObjectDamaged(this, eventInvoker);
 
                if (BattlegroundMap* bgMap = GetMap()->ToBattlegroundMap())
                    if (Battleground* bg = bgMap->GetBG())
                        bg->EventPlayerDamagedGO(eventInvoker, this, m_goInfo->building.damagedEvent);
 
                RemoveGameObjectFlag(GO_FLAG_DESTROYED);
                SetGameObjectFlag(GO_FLAG_DAMAGED);
 
                uint32 modelId = m_goInfo->building.damagedDisplayId;
                if (DestructibleModelDataEntry const* modelData = sDestructibleModelDataStore.LookupEntry(m_goInfo->building.destructibleData))
                    if (modelData->DamagedDisplayId)
                        modelId = modelData->DamagedDisplayId;
                SetDisplayId(modelId);
 
                if (setHealth)
                {
                    m_goValue.Building.Health = m_goInfo->building.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->building.destroyedEvent);
 
                if (BattlegroundMap* bgMap = GetMap()->ToBattlegroundMap())
                {
                    if (Battleground* bg = bgMap->GetBG())
                    {
                        bg->EventPlayerDamagedGO(eventInvoker, this, m_goInfo->building.destroyedEvent);
                        bg->DestroyGate(eventInvoker, this);
                    }
                }
 
                RemoveGameObjectFlag(GO_FLAG_DAMAGED);
                SetGameObjectFlag(GO_FLAG_DESTROYED);
 
                uint32 modelId = m_goInfo->building.destroyedDisplayId;
                if (DestructibleModelDataEntry const* modelData = sDestructibleModelDataStore.LookupEntry(m_goInfo->building.destructibleData))
                    if (modelData->DestroyedDisplayId)
                        modelId = modelData->DestroyedDisplayId;
                SetDisplayId(modelId);
 
                if (setHealth)
                {
                    m_goValue.Building.Health = 0;
                    SetGoAnimProgress(0);
                }
                EnableCollision(false);
                break;
            }
        case GO_DESTRUCTIBLE_REBUILDING:
            {
                EventInform(m_goInfo->building.rebuildingEvent);
                RemoveGameObjectFlag(GO_FLAG_DAMAGED | GO_FLAG_DESTROYED);
 
                uint32 modelId = m_goInfo->displayId;
                if (DestructibleModelDataEntry const* modelData = sDestructibleModelDataStore.LookupEntry(m_goInfo->building.destructibleData))
                    if (modelData->RebuildingDisplayId)
                        modelId = modelData->RebuildingDisplayId;
                SetDisplayId(modelId);
 
                // restores to full health
                if (setHealth)
                {
                    m_goValue.Building.Health = m_goValue.Building.MaxHealth;
                    SetGoAnimProgress(255);
                }
                EnableCollision(true);
                break;
            }
    }
}

References ASSERT, GameObjectValue::Building, GameObjectTemplate::building, GameObjectTemplate::damagedDisplayId, GameObjectTemplate::damagedEvent, GameObjectTemplate::damagedNumHits, GameObjectTemplate::destroyedDisplayId, GameObjectTemplate::destroyedEvent, GameObjectTemplate::destructibleData, GameObjectTemplate::displayId, EnableCollision(), EventInform(), GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING, GetGoType(), WorldObject::GetMap(), GO_DESTRUCTIBLE_DAMAGED, GO_DESTRUCTIBLE_DESTROYED, GO_DESTRUCTIBLE_INTACT, GO_DESTRUCTIBLE_REBUILDING, GO_FLAG_DAMAGED, GO_FLAG_DESTROYED, GameObjectValue::Health, m_goInfo, m_goValue, GameObjectValue::MaxHealth, GameObjectTemplate::rebuildingEvent, RemoveGameObjectFlag(), sDestructibleModelDataStore, SetDisplayId(), SetGameObjectFlag(), SetGoAnimProgress(), and sScriptMgr.

Referenced by Spell::EffectGameObjectSetDestructionState(), BfWGGameObjectBuilding::Init(), ModifyHealth(), instance_eye_of_eternity::OnGameObjectCreate(), instance_trial_of_the_crusader::instance_trial_of_the_crusader_InstanceMapScript::OnGameObjectCreate(), FrozenThroneResetWorker::operator()(), BattlegroundIC::PostUpdateImpl(), and BfWGGameObjectBuilding::Rebuild().

◆ SetDisplayId()

void GameObject::SetDisplayId ( uint32 displayid )

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

References GAMEOBJECT_DISPLAYID, Object::SetUInt32Value(), and UpdateModel().

Referenced by Create(), StaticTransport::Create(), MotionTransport::CreateMoTrans(), and SetDestructibleState().

◆ SetGameObjectFlag()

void GameObject::SetGameObjectFlag ( GameObjectFlags flags )

inline

217{ SetFlag(GAMEOBJECT_FLAGS, flags); }

Object::SetFlag

void SetFlag(uint16 index, uint32 newFlag)

Definition Object.cpp:827

References GAMEOBJECT_FLAGS, and Object::SetFlag().

◆ SetGoAnimProgress()

void GameObject::SetGoAnimProgress ( uint8 animprogress )

inline

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

Object::SetByteValue

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

Definition Object.cpp:739

References GAMEOBJECT_BYTES_1, and Object::SetByteValue().

Referenced by Create(), StaticTransport::Create(), MotionTransport::CreateMoTrans(), ModifyHealth(), and SetDestructibleState().

◆ SetGoArtKit() [1/2]

void GameObject::SetGoArtKit ( uint8 artkit )

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

References GameObjectData::artKit, GAMEOBJECT_BYTES_1, m_spawnId, Object::SetByteValue(), and sObjectMgr.

Referenced by Create(), StaticTransport::Create(), Spell::EffectActivateObject(), and SetGoArtKit().

◆ SetGoArtKit() [2/2]

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

static

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

References GetGameObjectData(), SetGoArtKit(), and sObjectMgr.

◆ SetGoState()

void GameObject::SetGoState ( GOState state )

{
    SetByteValue(GAMEOBJECT_BYTES_1, 0, state);
 
    sScriptMgr->OnGameObjectStateChanged(this, state);
 
    if (m_model)
    {
        if (!IsInWorld())
            return;
 
        // pussywizard: this startOpen is unneeded here, collision depends entirely on current GOState
        EnableCollision(state == GO_STATE_READY || IsTransport());
        // pussywizard: commented out everything below
 
        // startOpen determines whether we are going to add or remove the LoS on activation
        /*bool startOpen = (GetGoType() == GAMEOBJECT_TYPE_DOOR || GetGoType() == GAMEOBJECT_TYPE_BUTTON ? GetGOInfo()->door.startOpen : false);
 
        if (GetGameObjectData() && GetGameObjectData()->go_state == GO_STATE_READY)
            startOpen = !startOpen;
 
        if (state == GO_STATE_ACTIVE || state == GO_STATE_ACTIVE_ALTERNATIVE)
            EnableCollision(startOpen);
        else if (state == GO_STATE_READY)
            EnableCollision(!startOpen);*/
    }
    /* Whenever a gameobject inside an instance changes
     * save it's state on the database to be loaded properly
     * on server restart or crash.
     */
    if (IsInstanceGameobject() && IsAllowedToSaveToDB())
    {
        SaveStateToDB();
    }
}

References EnableCollision(), GAMEOBJECT_BYTES_1, GO_STATE_READY, IsAllowedToSaveToDB(), IsInstanceGameobject(), Object::IsInWorld(), IsTransport(), m_model, SaveStateToDB(), Object::SetByteValue(), and sScriptMgr.

◆ SetGoType()

void GameObject::SetGoType ( GameobjectTypes type )

inline

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

References GAMEOBJECT_BYTES_1, and Object::SetByteValue().

Referenced by Create(), StaticTransport::Create(), and MotionTransport::CreateMoTrans().

◆ SetLinkedTrap()

void GameObject::SetLinkedTrap ( GameObject * linkedTrap )

inline

260{ m_linkedTrap = linkedTrap->GetGUID(); }

References Object::GetGUID(), and m_linkedTrap.

Referenced by Create().

◆ SetLootGenerationTime()

void GameObject::SetLootGenerationTime ( )

{
    m_lootGenerationTime = GameTime::GetGameTime().count();
}

References GameTime::GetGameTime(), and m_lootGenerationTime.

Referenced by Player::SendLoot().

◆ SetLootMode()

void GameObject::SetLootMode ( uint16 lootMode )

inline

229{ m_LootMode = lootMode; }

References m_LootMode.

Referenced by instance_dire_maul::instance_dire_maul_InstanceMapScript::OnGameObjectCreate().

◆ SetLootRecipient() [1/2]

void GameObject::SetLootRecipient ( Creature * creature )

{
    // set the player whose group should receive the right
    // to loot the creature after it dies
    // should be set to nullptr after the loot disappears
    if (!creature)
    {
        m_lootRecipient.Clear();
        m_lootRecipientGroup = 0;
        ResetAllowedLooters();
        return;
    }
 
    m_lootRecipient = creature->GetLootRecipientGUID();
    m_lootRecipientGroup = creature->GetLootRecipientGroupGUID();
    SetAllowedLooters(creature->GetAllowedLooters());
}

References ObjectGuid::Clear(), WorldObject::GetAllowedLooters(), Creature::GetLootRecipientGroupGUID(), Creature::GetLootRecipientGUID(), m_lootRecipient, m_lootRecipientGroup, WorldObject::ResetAllowedLooters(), and WorldObject::SetAllowedLooters().

Referenced by boss_thorim::DamageTaken(), and instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::OnGameObjectCreate().

◆ SetLootRecipient() [2/2]

void GameObject::SetLootRecipient ( Map * map )

{
    Group* group = nullptr;
    Map::PlayerList const& PlayerList = map->GetPlayers();
    for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
    {
        if (Player* groupMember = i->GetSource())
        {
            if (groupMember->IsGameMaster() || groupMember->IsSpectator())
            {
                continue;
            }
 
            if (!m_lootRecipient)
            {
                m_lootRecipient = groupMember->GetGUID();
            }
 
            Group* memberGroup = groupMember->GetGroup();
            if (memberGroup && !group)
            {
                group = memberGroup;
                m_lootRecipientGroup = group->GetGUID().GetCounter();
            }
 
            if (memberGroup == group)
            {
                AddAllowedLooter(groupMember->GetGUID());
            }
        }
    }
 
    if (!group)
    {
        AddAllowedLooter(m_lootRecipient);
    }
}

References WorldObject::AddAllowedLooter(), MapRefMgr::begin(), MapRefMgr::end(), ObjectGuid::GetCounter(), Group::GetGUID(), Map::GetPlayers(), m_lootRecipient, and m_lootRecipientGroup.

◆ SetLootState()

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

{
    m_lootState = state;
 
    if (unit)
        _lootStateUnitGUID = unit->GetGUID();
    else
        _lootStateUnitGUID.Clear();
 
    AI()->OnStateChanged(state, unit);
    sScriptMgr->OnGameObjectLootStateChanged(this, state, unit);
 
    // Start restock timer if the chest is partially looted or not looted at all
    if (GetGoType() == GAMEOBJECT_TYPE_CHEST && state == GO_ACTIVATED && GetGOInfo()->chest.chestRestockTime > 0 && m_restockTime == 0s)
    {
        m_restockTime = GameTime::GetGameTime() + Seconds(GetGOInfo()->chest.chestRestockTime);
    }
 
    // pussywizard: lootState has nothing to do with collision, it depends entirely on GOState. Loot state is for timed close/open door and respawning, which then sets GOState
    /*if (m_model)
    {
        // startOpen determines whether we are going to add or remove the LoS on activation
        bool startOpen = (GetGoType() == GAMEOBJECT_TYPE_DOOR || GetGoType() == GAMEOBJECT_TYPE_BUTTON ? GetGOInfo()->door.startOpen : false);
 
        // Use the current go state
        if (GetGoState() == GO_STATE_ACTIVE)
            startOpen = !startOpen;
 
        if (state == GO_ACTIVATED || state == GO_JUST_DEACTIVATED)
            EnableCollision(startOpen);
        else if (state == GO_READY)
            EnableCollision(!startOpen);
    }*/
}

References _lootStateUnitGUID, AI(), GameObjectTemplate::chestRestockTime, ObjectGuid::Clear(), GAMEOBJECT_TYPE_CHEST, GameTime::GetGameTime(), GetGOInfo(), GetGoType(), Object::GetGUID(), GO_ACTIVATED, m_lootState, m_restockTime, GameObjectAI::OnStateChanged(), and sScriptMgr.

Referenced by go_suppression_device::Activate(), Delete(), DespawnOrUnsummon(), WorldSession::DoLootRelease(), Spell::EffectOpenLock(), spell_q9452_cast_net::HandleActiveObject(), spell_q10612_10613_the_fel_and_the_furious::HandleScriptEffect(), go_eredar_twins_blaze::InitializeAI(), instance_deadmines::instance_deadmines_InstanceMapScript::OnGameObjectCreate(), instance_oculus::instance_oculus_InstanceMapScript::OnGameObjectCreate(), go_massive_seaforium_charge::OnGossipHello(), go_ulduar_working_harpoon::OnGossipHello(), SmartScript::ProcessAction(), go_direbrew_mole_machine::go_direbrew_mole_machineAI::Reset(), ResetDoorOrButton(), Map::ScriptsProcess(), Player::SendLoot(), boss_flame_leviathan::TurnHealStations(), Update(), Use(), and UseDoorOrButton().

◆ SetOwnerGUID()

void GameObject::SetOwnerGUID ( ObjectGuid owner )

inline

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

References ABORT, GetOwnerGUID(), m_spawnedByDefault, OBJECT_FIELD_CREATED_BY, and Object::SetGuidValue().

Referenced by Unit::AddGameObject(), Spell::EffectTransmitted(), go_eredar_twins_blaze::InitializeAI(), Unit::RemoveAllGameObjects(), RemoveFromOwner(), Unit::RemoveGameObject(), and Use().

◆ SetPhaseMask()

void GameObject::SetPhaseMask	(	uint32	newPhaseMask,
		bool	update
	)

overridevirtual

Reimplemented from WorldObject.

{
    WorldObject::SetPhaseMask(newPhaseMask, update);
 
    if (m_model && m_model->isEnabled())
        EnableCollision(true);
}

References EnableCollision(), GameObjectModel::isEnabled(), m_model, and WorldObject::SetPhaseMask().

Referenced by Create(), StaticTransport::Create(), instance_eye_of_eternity::OnGameObjectCreate(), instance_blackwing_lair::OnGameObjectCreate(), and instance_halls_of_reflection::OnGameObjectCreate().

◆ SetPosition() [1/2]

void GameObject::SetPosition ( const Position & pos )

inline

316{ SetPosition(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation()); }

GameObject::SetPosition

void SetPosition(float x, float y, float z, float o)

Definition GameObject.cpp:2877

References Position::GetOrientation(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), and SetPosition().

Referenced by SetPosition().

◆ SetPosition() [2/2]

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

{
    // pussywizard: do not call for MotionTransport and other gobjects not in grid
 
    if (!Acore::IsValidMapCoord(x, y, z, o))
        return;
 
    GetMap()->GameObjectRelocation(this, x, y, z, o);
}

References Map::GameObjectRelocation(), WorldObject::GetMap(), and Acore::IsValidMapCoord().

Referenced by instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::OnGameObjectCreate().

◆ SetRespawnDelay()

void GameObject::SetRespawnDelay ( int32 respawn )

{
    m_respawnDelayTime = respawn > 0 ? respawn : 0;
}

References m_respawnDelayTime.

Referenced by go_strange_pool::OnGossipHello(), and SetRespawnTime().

◆ SetRespawnTime()

void GameObject::SetRespawnTime ( int32 respawn )

{
    m_respawnTime = respawn > 0 ? GameTime::GetGameTime().count() + respawn : 0;
    SetRespawnDelay(respawn);
    if (respawn && !m_spawnedByDefault)
    {
        UpdateObjectVisibility(true);
    }
}

References GameTime::GetGameTime(), m_respawnTime, m_spawnedByDefault, SetRespawnDelay(), and WorldObject::UpdateObjectVisibility().

Referenced by OPvPCapturePoint::DelCapturePoint(), OPvPCapturePoint::DelObject(), DespawnOrUnsummon(), Spell::EffectDuel(), Spell::EffectDummy(), Spell::EffectOpenLock(), Spell::EffectSummonObject(), Spell::EffectSummonObjectWild(), Spell::EffectTransmitted(), spell_q9452_cast_net::HandleActiveObject(), OutdoorPvPSI::HandleCustomSpell(), OutdoorPvPSI::HandleDropFlag(), gobject_commandscript::HandleGameObjectAddCommand(), instance_ulduar::instance_ulduar_InstanceMapScript::OnGameObjectCreate(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::OnGameObjectCreate(), go_ulduar_working_harpoon::OnGossipHello(), Unit::RemoveAllGameObjects(), Unit::RemoveGameObject(), Map::ScriptsProcess(), BattlegroundIC::SetupBattleground(), Map::SummonGameObject(), WorldObject::SummonGameObject(), and Update().

◆ SetSpawnedByDefault()

void GameObject::SetSpawnedByDefault ( bool b )

inline

196{ m_spawnedByDefault = b; }

References m_spawnedByDefault.

Referenced by Map::SummonGameObject(), and WorldObject::SummonGameObject().

◆ SetSpellId()

void GameObject::SetSpellId ( uint32 id )

inline

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

References m_spawnedByDefault, and m_spellId.

Referenced by Spell::EffectDuel(), Spell::EffectSummonObject(), Spell::EffectSummonObjectWild(), Spell::EffectTransmitted(), Map::SummonGameObject(), WorldObject::SummonGameObject(), and Use().

◆ SetTransportPathRotation()

void GameObject::SetTransportPathRotation	(	float	qx,
		float	qy,
		float	qz,
		float	qw
	)

{
    SetFloatValue(GAMEOBJECT_PARENTROTATION + 0, qx);
    SetFloatValue(GAMEOBJECT_PARENTROTATION + 1, qy);
    SetFloatValue(GAMEOBJECT_PARENTROTATION + 2, qz);
    SetFloatValue(GAMEOBJECT_PARENTROTATION + 3, qw);
}

References GAMEOBJECT_PARENTROTATION, and Object::SetFloatValue().

Referenced by Create(), StaticTransport::Create(), MotionTransport::CreateMoTrans(), and BattlegroundSA::ResetObjs().

◆ SetWorldRotation()

void GameObject::SetWorldRotation ( G3D::Quat const & rot )

{
    G3D::Quat rotation = rot;
    // If the quaternion is zero (e.g. dynamically spawned GOs with no rotation),
    // fall back to computing rotation from orientation to avoid NaN from unitize()
    if (G3D::fuzzyEq(rotation.magnitude(), 0.0f))
        rotation = G3D::Quat::fromAxisAngleRotation(G3D::Vector3::unitZ(), GetOrientation());
    rotation.unitize();
    WorldRotation = rotation;
    UpdatePackedRotation();
}

References Position::GetOrientation(), UpdatePackedRotation(), and WorldRotation.

Referenced by Create(), MotionTransport::CreateMoTrans(), and SetWorldRotationAngles().

◆ SetWorldRotationAngles()

void GameObject::SetWorldRotationAngles	(	float	z_rot,
		float	y_rot,
		float	x_rot
	)

{
    SetWorldRotation(G3D::Quat(G3D::Matrix3::fromEulerAnglesZYX(z_rot, y_rot, x_rot)));
}

References SetWorldRotation().

Referenced by StaticTransport::Create().

◆ SwitchDoorOrButton()

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

private

{
    if (activate)
        SetGameObjectFlag(GO_FLAG_IN_USE);
    else
        RemoveGameObjectFlag(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);
}

References GetGoState(), GO_FLAG_IN_USE, GO_STATE_ACTIVE, GO_STATE_ACTIVE_ALTERNATIVE, GO_STATE_READY, RemoveGameObjectFlag(), SetGameObjectFlag(), and SetGoState().

Referenced by Create(), ResetDoorOrButton(), and UseDoorOrButton().

◆ ToMotionTransport() [1/2]

MotionTransport * GameObject::ToMotionTransport ( )

inline

327{ if (GetGOInfo()->type == GAMEOBJECT_TYPE_MO_TRANSPORT) return reinterpret_cast<MotionTransport*>(this); else return nullptr; }

References GAMEOBJECT_TYPE_MO_TRANSPORT, and GetGOInfo().

Referenced by BuildValuesUpdate(), go_commandscript::DoTeleportToTransport(), ResetEncounterEvent::Execute(), npc_commandscript::HandleNpcAddCommand(), npc_gunship::npc_gunshipAI::JustDied(), npc_high_overlord_saurfang_igb::npc_high_overlord_saurfang_igbAI::npc_high_overlord_saurfang_igbAI(), npc_muradin_bronzebeard_igb::npc_muradin_bronzebeard_igbAI::npc_muradin_bronzebeard_igbAI(), instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::ProcessEvent(), Creature::SaveToDB(), npc_high_overlord_saurfang_igb::npc_high_overlord_saurfang_igbAI::sGossipSelect(), npc_muradin_bronzebeard_igb::npc_muradin_bronzebeard_igbAI::sGossipSelect(), npc_high_overlord_saurfang_igb::npc_high_overlord_saurfang_igbAI::UpdateAI(), npc_muradin_bronzebeard_igb::npc_muradin_bronzebeard_igbAI::UpdateAI(), and UpdateHomePosition().

◆ ToMotionTransport() [2/2]

MotionTransport const * GameObject::ToMotionTransport ( ) const

inline

328{ if (GetGOInfo()->type == GAMEOBJECT_TYPE_MO_TRANSPORT) return reinterpret_cast<MotionTransport const*>(this); else return nullptr; }

References GAMEOBJECT_TYPE_MO_TRANSPORT, and GetGOInfo().

◆ ToStaticTransport() [1/2]

StaticTransport * GameObject::ToStaticTransport ( )

inline

324{ if (GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT) return reinterpret_cast<StaticTransport*>(this); else return nullptr; }

References GAMEOBJECT_TYPE_TRANSPORT, and GetGOInfo().

Referenced by BuildValuesUpdate(), instance_ulduar::instance_ulduar_InstanceMapScript::OnPlayerEnter(), instance_ulduar::instance_ulduar_InstanceMapScript::SetData(), and instance_icecrown_citadel::instance_icecrown_citadel_InstanceMapScript::Update().

◆ ToStaticTransport() [2/2]

StaticTransport const * GameObject::ToStaticTransport ( ) const

inline

325{ if (GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT) return reinterpret_cast<StaticTransport const*>(this); else return nullptr; }

References GAMEOBJECT_TYPE_TRANSPORT, and GetGOInfo().

◆ ToTransport() [1/2]

Transport * GameObject::ToTransport ( )

inline

321{ if (GetGOInfo()->type == GAMEOBJECT_TYPE_MO_TRANSPORT || GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT) return reinterpret_cast<Transport*>(this); else return nullptr; }

References GAMEOBJECT_TYPE_MO_TRANSPORT, GAMEOBJECT_TYPE_TRANSPORT, and GetGOInfo().

Referenced by MotionTransport::AddPassenger(), StaticTransport::AddPassenger(), Object::BuildMovementUpdate(), CleanupsBeforeDelete(), Map::GetTransport(), Player::LoadFromDB(), npc_gunship_boarding_addAI::MovementInform(), Map::RemoveAllObjectsInRemoveList(), MotionTransport::RemovePassenger(), and StaticTransport::RemovePassenger().

◆ ToTransport() [2/2]

Transport const * GameObject::ToTransport ( ) const

inline

322{ if (GetGOInfo()->type == GAMEOBJECT_TYPE_MO_TRANSPORT || GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT) return reinterpret_cast<Transport const*>(this); else return nullptr; }

References GAMEOBJECT_TYPE_MO_TRANSPORT, GAMEOBJECT_TYPE_TRANSPORT, and GetGOInfo().

◆ TriggeringLinkedGameObject()

void GameObject::TriggeringLinkedGameObject	(	uint32	trapEntry,
		Unit *	target
	)

{
    GameObjectTemplate const* trapInfo = sObjectMgr->GetGameObjectTemplate(trapEntry);
    if (!trapInfo || trapInfo->type != GAMEOBJECT_TYPE_TRAP)
        return;
 
    SpellInfo const* trapSpell = sSpellMgr->GetSpellInfo(trapInfo->trap.spellId);
    if (!trapSpell)                                          // checked at load already
        return;
 
    // xinef: many spells have range 0 but radius > 0
    float range = float(target->GetSpellMaxRangeForTarget(GetOwner(), trapSpell));
    if (range < 1.0f)
        range = 5.0f;
 
    // found correct GO
    // xinef: we should use the trap (checks for despawn type)
    if (GameObject* trapGO = GetLinkedTrap())
    {
        trapGO->Use(target); // trapGO->CastSpell(target, trapInfo->trap.spellId);
    }
}

References GAMEOBJECT_TYPE_TRAP, GetLinkedTrap(), GetOwner(), Unit::GetSpellMaxRangeForTarget(), sObjectMgr, GameObjectTemplate::spellId, sSpellMgr, GameObjectTemplate::trap, and GameObjectTemplate::type.

Referenced by Spell::SendLoot(), and Use().

◆ Update()

void GameObject::Update ( uint32 p_time )

overridevirtual

Todo:: This is activation radius. Casting radius must be selected from spell data.

Todo:

Todo:: Move activated state code to GO_ACTIVATED, in this place just check for activation and set state.

Reimplemented from WorldObject.

Reimplemented in MotionTransport, and StaticTransport.

{
    WorldObject::Update(diff);
 
    if (AI())
        AI()->UpdateAI(diff);
    else if (!AIM_Initialize())
        LOG_ERROR("entities.gameobject", "Could not initialize GameObjectAI");
 
    if (m_despawnDelay)
    {
        if (m_despawnDelay > diff)
        {
            m_despawnDelay -= diff;
        }
        else
        {
            m_despawnDelay = 0;
            DespawnOrUnsummon(0ms, m_despawnRespawnTime);
        }
    }
 
    for (std::unordered_map<ObjectGuid, int32>::iterator itr = m_SkillupList.begin(); itr != m_SkillupList.end();)
    {
        if (itr->second > 0)
        {
            if (itr->second > static_cast<int32>(diff))
            {
                itr->second -= static_cast<int32>(diff);
                ++itr;
            }
            else
            {
                itr = m_SkillupList.erase(itr);
            }
        }
        else
        {
            ++itr;
        }
    }
 
    switch (m_lootState)
    {
        case GO_NOT_READY:
            {
                switch (GetGoType())
                {
                    case GAMEOBJECT_TYPE_TRAP:
                        {
                            // Arming Time for GAMEOBJECT_TYPE_TRAP (6)
                            GameObjectTemplate const* goInfo = GetGOInfo();
                            // Bombs
                            if (goInfo->trap.type == 2)
                                m_cooldownTime = GameTime::GetGameTimeMS().count() + 10 * IN_MILLISECONDS; // Hardcoded tooltip value
                            else if (GetOwner())
                                m_cooldownTime = GameTime::GetGameTimeMS().count() + goInfo->trap.startDelay * IN_MILLISECONDS;
 
                            m_lootState = GO_READY;
                            break;
                        }
                    case GAMEOBJECT_TYPE_FISHINGNODE:
                        {
                            // fishing code (bobber ready)
                            if (GameTime::GetGameTime().count() > m_respawnTime - FISHING_BOBBER_READY_TIME)
                            {
                                // splash bobber (bobber ready now)
                                Unit* caster = GetOwner();
                                if (caster && caster->IsPlayer())
                                {
                                    SetGoState(GO_STATE_ACTIVE);
                                    ReplaceAllGameObjectFlags(GO_FLAG_NODESPAWN);
 
                                    UpdateData udata;
                                    WorldPacket packet;
                                    BuildValuesUpdateBlockForPlayer(&udata, caster->ToPlayer());
                                    udata.BuildPacket(packet);
                                    caster->ToPlayer()->SendDirectMessage(&packet);
 
                                    SendCustomAnim(GetGoAnimProgress());
                                }
 
                                m_lootState = GO_READY;                 // can be successfully open with some chance
                            }
                            return;
                        }
                    case GAMEOBJECT_TYPE_SUMMONING_RITUAL:
                        {
                            if (GameTime::GetGameTimeMS().count() < m_cooldownTime)
                                return;
                            GameObjectTemplate const* info = GetGOInfo();
 
                            CheckRitualList();
 
                            if (GetUniqueUseCount() < info->summoningRitual.reqParticipants)
                            {
                                SetLootState(GO_READY);
                                return;
                            }
 
                            Unit* owner = GetOwner();
                            Unit* spellCaster = owner ? owner : ObjectAccessor::GetPlayer(*this, m_ritualOwnerGUID);
                            if (!spellCaster)
                            {
                                SetLootState(GO_JUST_DEACTIVATED);
                                return;
                            }
 
                            uint32 spellId = info->summoningRitual.spellId;
 
                            if (spellId == 62330)                       // GO store nonexistent spell, replace by expected
                            {
                                // spell have reagent and mana cost but it not expected use its
                                // it triggered spell in fact casted at currently channeled GO
                                spellId = 61993;
                            }
 
                            // Cast casterTargetSpell at a random GO user
                            // on the current DB there is only one gameobject that uses this (Ritual of Doom)
                            // and its required target number is 1 (outter for loop will run once)
                            if (info->summoningRitual.casterTargetSpell && info->summoningRitual.casterTargetSpell != 1) // No idea why this field is a bool in some cases
                                for (uint32 i = 0; i < info->summoningRitual.casterTargetSpellTargets; i++)
                                    // m_unique_users can contain only player GUIDs
                                    if (Player* target = ObjectAccessor::GetPlayer(*this, Acore::Containers::SelectRandomContainerElement(m_unique_users)))
                                        spellCaster->CastSpell(target, info->summoningRitual.casterTargetSpell, true);
 
                            // finish owners spell
                            // xinef: properly process event cooldowns
                            if (owner)
                            {
                                if (Spell* spell = owner->GetCurrentSpell(CURRENT_CHANNELED_SPELL))
                                {
                                    spell->SendChannelUpdate(0);
                                    spell->finish(false);
                                }
                            }
 
                            // can be deleted now
                            if (!info->summoningRitual.ritualPersistent)
                                SetLootState(GO_JUST_DEACTIVATED);
                            else
                                SetLootState(GO_READY);
 
                            ClearRitualList();
                            spellCaster->CastSpell(spellCaster, spellId, true);
                            return;
                        }
                    case GAMEOBJECT_TYPE_CHEST:
                        if (m_restockTime > GameTime::GetGameTime())
                        {
                            return;
                        }
                        // If there is no restock timer, or if the restock timer passed, the chest becomes ready to loot
                        m_restockTime = 0s;
                        m_lootState = GO_READY;
                        AddToObjectUpdateIfNeeded();
                        break;
                    default:
                        m_lootState = GO_READY;                         // for other GOis same switched without delay to GO_READY
                        break;
                }
                [[fallthrough]];
            }
        case GO_READY:
            {
                if (m_respawnTime > 0)                          // timer on
                {
                    time_t now = GameTime::GetGameTime().count();
                    if (m_respawnTime <= now)            // timer expired
                    {
                        ObjectGuid dbtableHighGuid = ObjectGuid::Create<HighGuid::GameObject>(GetEntry(), m_spawnId);
                        time_t linkedRespawntime = GetMap()->GetLinkedRespawnTime(dbtableHighGuid);
                        if (linkedRespawntime)             // Can't respawn, the master is dead
                        {
                            ObjectGuid targetGuid = sObjectMgr->GetLinkedRespawnGuid(dbtableHighGuid);
                            if (targetGuid == dbtableHighGuid) // if linking self, never respawn (check delayed to next day)
                                SetRespawnTime(DAY);
                            else
                                m_respawnTime = (now > linkedRespawntime ? now : linkedRespawntime) + urand(5, MINUTE); // else copy time from master and add a little
                            SaveRespawnTime(); // also save to DB immediately
                            return;
                        }
 
                        m_respawnTime = 0;
                        m_SkillupList.clear();
                        m_usetimes = 0;
 
                        switch (GetGoType())
                        {
                            case GAMEOBJECT_TYPE_FISHINGNODE:   //  can't fish now
                                {
                                    Unit* caster = GetOwner();
                                    if (caster && caster->IsPlayer())
                                    {
                                        caster->ToPlayer()->RemoveGameObject(this, false);
 
                                        WorldPacket data(SMSG_FISH_ESCAPED, 0);
                                        caster->ToPlayer()->SendDirectMessage(&data);
                                    }
                                    // can be delete
                                    m_lootState = GO_JUST_DEACTIVATED;
                                    return;
                                }
                            case GAMEOBJECT_TYPE_DOOR:
                            case GAMEOBJECT_TYPE_BUTTON:
                                //we need to open doors if they are closed (add there another condition if this code breaks some usage, but it need to be here for battlegrounds)
                                if (GetGoState() != GO_STATE_READY)
                                    ResetDoorOrButton();
                                break;
                            case GAMEOBJECT_TYPE_FISHINGHOLE:
                                // Initialize a new max fish count on respawn
                                m_goValue.FishingHole.MaxOpens = urand(GetGOInfo()->fishinghole.minSuccessOpens, GetGOInfo()->fishinghole.maxSuccessOpens);
                                break;
                            default:
                                break;
                        }
 
                        if (!m_spawnedByDefault)        // despawn timer
                        {
                            // can be despawned or destroyed
                            SetLootState(GO_JUST_DEACTIVATED);
                            return;
                        }
 
                        // Xinef: Call AI Reset (required for example in SmartAI to clear one time events)
                        if (AI())
                            AI()->Reset();
 
                        // respawn timer
                        uint32 poolid = m_spawnId ? sPoolMgr->IsPartOfAPool<GameObject>(m_spawnId) : 0;
                        if (poolid)
                            sPoolMgr->UpdatePool<GameObject>(poolid, m_spawnId);
                        else
                            GetMap()->AddToMap(this);
                    }
                }
 
                if (isSpawned())
                {
                    // traps can have time and can not have
                    GameObjectTemplate const* goInfo = GetGOInfo();
                    if (goInfo->type == GAMEOBJECT_TYPE_TRAP)
                    {
                        if (GameTime::GetGameTimeMS().count() < m_cooldownTime)
                            break;
 
                        // Type 2 - Bomb (will go away after casting it's spell)
                        if (goInfo->trap.type == 2)
                        {
                            SetLootState(GO_ACTIVATED);
                            break;
                        }
 
                        float radius = float(goInfo->trap.diameter) * 0.5f;
                        if (!goInfo->trap.diameter)
                        {
                            // Cast in other case (at some triggering/linked go/etc explicit call)
                            if (goInfo->trap.cooldown != 3 || m_respawnTime > 0)
                            {
                                break;
                            }
 
                            radius = 3.f;
                        }
 
                        // Type 0 and 1 - trap (type 0 will not get removed after casting a spell)
                        Unit* owner = GetOwner();
                        Unit* target = nullptr;                            // pointer to appropriate target if found any
 
                        // Note: this hack with search required until GO casting not implemented
                        // search unfriendly creature
                        if (owner && goInfo->trap.autoCloseTime != -1) // hunter trap
                        {
                            Acore::NearestAttackableNoTotemUnitInObjectRangeCheck checker(this, owner, radius);
                            Acore::UnitSearcher<Acore::NearestAttackableNoTotemUnitInObjectRangeCheck> searcher(this, target, checker);
                            Cell::VisitObjects(this, searcher, radius);
                        }
                        else                                        // environmental trap
                        {
                            // environmental damage spells already have around enemies targeting but this not help in case not existed GO casting support
                            // affect only players
                            Player* player = nullptr;
                            Acore::AnyPlayerInObjectRangeCheck checker(this, radius, true, true);
                            Acore::PlayerSearcher<Acore::AnyPlayerInObjectRangeCheck> searcher(this, player, checker);
                            Cell::VisitObjects(this, searcher, radius);
                            target = player;
                        }
 
                        if (target)
                        {
                            SetLootState(GO_ACTIVATED, target);
                        }
                    }
                    else if (uint32 max_charges = goInfo->GetCharges())
                    {
                        if (m_usetimes >= max_charges)
                        {
                            m_usetimes = 0;
                            SetLootState(GO_JUST_DEACTIVATED);      // can be despawned or destroyed
                        }
                    }
                }
 
                break;
            }
        case GO_ACTIVATED:
            {
                switch (GetGoType())
                {
                    case GAMEOBJECT_TYPE_DOOR:
                    case GAMEOBJECT_TYPE_BUTTON:
                        if (GetGOInfo()->GetAutoCloseTime() && GameTime::GetGameTimeMS().count() >= m_cooldownTime)
                            ResetDoorOrButton();
                        break;
                    case GAMEOBJECT_TYPE_GOOBER:
                        if (GameTime::GetGameTimeMS().count() >= m_cooldownTime)
                        {
                            RemoveGameObjectFlag(GO_FLAG_IN_USE);
 
                            SetLootState(GO_JUST_DEACTIVATED);
                        }
                        break;
                    case GAMEOBJECT_TYPE_CHEST:
                        if (m_groupLootTimer)
                        {
                            if (m_groupLootTimer <= diff)
                            {
                                Group* group = sGroupMgr->GetGroupByGUID(lootingGroupLowGUID);
                                if (group)
                                    group->EndRoll(&loot, GetMap());
                                m_groupLootTimer = 0;
                                lootingGroupLowGUID = 0;
                            }
                            else
                            {
                                m_groupLootTimer -= diff;
                            }
                        }
 
                        // Non-consumable chest was partially looted and restock time passed, restock all loot now
                        if (GetGOInfo()->chest.consumable == 0 && GameTime::GetGameTime() >= m_restockTime)
                        {
                            m_restockTime = 0s;
                            m_lootState = GO_READY;
                            AddToObjectUpdateIfNeeded();
                        }
                        break;
                    case GAMEOBJECT_TYPE_TRAP:
                    {
                        GameObjectTemplate const* goInfo = GetGOInfo();
                        if (goInfo->trap.type == 2)
                        {
                            if (goInfo->trap.spellId)
                                CastSpell(nullptr, goInfo->trap.spellId);  // FIXME: null target won't work for target type 1
                            SetLootState(GO_JUST_DEACTIVATED);
                        }
                        else if (Unit* target = ObjectAccessor::GetUnit(*this, _lootStateUnitGUID))
                        {
                            if (goInfo->trap.spellId)
                                CastSpell(target, goInfo->trap.spellId);
 
                            m_cooldownTime = GameTime::GetGameTimeMS().count() + (goInfo->trap.cooldown ? goInfo->trap.cooldown : uint32(4)) * IN_MILLISECONDS; // template or 4 seconds
 
                            if (goInfo->trap.type == 1)
                                SetLootState(GO_JUST_DEACTIVATED);
                            else if (!goInfo->trap.type)
                                SetLootState(GO_READY);
 
                            // Battleground gameobjects have data2 == 0 && data5 == 3
                            if (!goInfo->trap.diameter && goInfo->trap.cooldown == 3)
                                if (Player* player = target->ToPlayer())
                                    if (Battleground* bg = player->GetBattleground())
                                        bg->HandleTriggerBuff(this);
                        }
                        break;
                    }
                    default:
                        break;
                }
                break;
            }
        case GO_JUST_DEACTIVATED:
            {
                // If nearby linked trap exists, despawn it
                if (GameObject* linkedTrap = GetLinkedTrap())
                {
                    linkedTrap->DespawnOrUnsummon();
                }
 
                //if Gameobject should cast spell, then this, but some GOs (type = 10) should be destroyed
                if (GetGoType() == GAMEOBJECT_TYPE_GOOBER)
                {
                    SetGoState(GO_STATE_READY);
 
                    //any return here in case battleground traps
                    // Xinef: Do not return here for summoned gos that should be deleted few lines below
                    // Xinef: Battleground objects are treated as spawned by default
                    if (GameObjectTemplateAddon const* addon = GetTemplateAddon())
                        if ((addon->flags & GO_FLAG_NODESPAWN) && isSpawnedByDefault())
                            return;
                }
 
                loot.clear();
 
                // Do not delete chests or goobers that are not consumed on loot, while still allowing them to despawn when they expire if summoned
                bool isSummonedAndExpired = (GetOwner() || GetSpellId()) && m_respawnTime == 0;
                if ((GetGoType() == GAMEOBJECT_TYPE_CHEST || GetGoType() == GAMEOBJECT_TYPE_GOOBER) && !GetGOInfo()->IsDespawnAtAction() && !isSummonedAndExpired)
                {
                    if (GetGoType() == GAMEOBJECT_TYPE_CHEST && GetGOInfo()->chest.chestRestockTime > 0)
                    {
                        // Start restock timer when the chest is fully looted
                        m_restockTime = GameTime::GetGameTime() + Seconds(GetGOInfo()->chest.chestRestockTime);
                        SetLootState(GO_NOT_READY);
                        AddToObjectUpdateIfNeeded();
                    }
                    else
                    {
                        SetLootState(GO_READY);
                    }
 
                    UpdateObjectVisibility();
                    return;
                }
                else if (GetOwnerGUID() || GetSpellId())
                {
                    SetRespawnTime(0);
                    Delete();
                    return;
                }
 
                SetLootState(GO_READY);
 
                //burning flags in some battlegrounds, if you find better condition, just add it
                if (GetGOInfo()->IsDespawnAtAction() || GetGoAnimProgress() > 0)
                {
                    SendObjectDeSpawnAnim(GetGUID());
                    //reset flags
                    if (GameObjectTemplateAddon const* addon = GetTemplateAddon())
                        ReplaceAllGameObjectFlags((GameObjectFlags)addon->flags);
                }
 
                if (!m_respawnDelayTime)
                    return;
 
                if (!m_spawnedByDefault)
                {
                    m_respawnTime = 0;
                    DestroyForVisiblePlayers(); // xinef: old UpdateObjectVisibility();
                    return;
                }
 
                uint32 dynamicRespawnDelay = GetMap()->ApplyDynamicModeRespawnScaling(this, m_respawnDelayTime);
                m_respawnTime = GameTime::GetGameTime().count() + dynamicRespawnDelay;
 
                // if option not set then object will be saved at grid unload
                if (GetMap()->IsDungeon())
                    SaveRespawnTime();
 
                DestroyForVisiblePlayers(); // xinef: old UpdateObjectVisibility();
                break;
            }
    }
 
    sScriptMgr->OnGameObjectUpdate(this, diff);
}

Referenced by StaticTransport::Update().

◆ UpdateModel()

void GameObject::UpdateModel ( )

protected

{
    if (!IsInWorld())
        return;
    if (m_model)
        if (GetMap()->ContainsGameObjectModel(*m_model))
            GetMap()->RemoveGameObjectModel(*m_model);
    delete m_model;
    m_model = CreateModel();
    if (m_model)
        GetMap()->InsertGameObjectModel(*m_model);
}

References CreateModel(), WorldObject::GetMap(), Map::InsertGameObjectModel(), Object::IsInWorld(), m_model, and Map::RemoveGameObjectModel().

Referenced by SetDisplayId().

◆ UpdateModelPosition()

void GameObject::UpdateModelPosition ( )

{
    if (!m_model)
        return;
 
    if (GetMap()->ContainsGameObjectModel(*m_model))
    {
        GetMap()->RemoveGameObjectModel(*m_model);
        m_model->UpdatePosition();
        GetMap()->InsertGameObjectModel(*m_model);
    }
}

References WorldObject::GetMap(), Map::InsertGameObjectModel(), m_model, Map::RemoveGameObjectModel(), and GameObjectModel::UpdatePosition().

Referenced by Map::GameObjectRelocation(), MotionTransport::UpdatePosition(), and StaticTransport::UpdatePosition().

◆ UpdatePackedRotation()

void GameObject::UpdatePackedRotation ( )

private

{
    static const int32 PACK_YZ = 1 << 20;
    static const int32 PACK_X = PACK_YZ << 1;
    static const int32 PACK_YZ_MASK = (PACK_YZ << 1) - 1;
    static const int32 PACK_X_MASK = (PACK_X << 1) - 1;
    int8 w_sign = (WorldRotation.w >= 0.f ? 1 : -1);
    int64 x = int32(WorldRotation.x * PACK_X)  * w_sign & PACK_X_MASK;
    int64 y = int32(WorldRotation.y * PACK_YZ) * w_sign & PACK_YZ_MASK;
    int64 z = int32(WorldRotation.z * PACK_YZ) * w_sign & PACK_YZ_MASK;
    m_packedRotation = z | (y << 21) | (x << 42);
}

References m_packedRotation, and WorldRotation.

Referenced by SetWorldRotation().

◆ Use()

void GameObject::Use ( Unit * user )

{
    // Xinef: we cannot use go with not selectable flags
    if (HasGameObjectFlag(GO_FLAG_NOT_SELECTABLE))
        return;
 
    // by default spell caster is user
    Unit* spellCaster = user;
    uint32 spellId = 0;
    uint32 triggeredFlags = TRIGGERED_NONE;
 
    if (Player* playerUser = user->ToPlayer())
    {
        if (sScriptMgr->OnGossipHello(playerUser, this))
            return;
 
        if (AI()->GossipHello(playerUser, false))
            return;
    }
 
    // If cooldown data present in template
    if (uint32 cooldown = GetGOInfo()->GetCooldown())
    {
        if (GameTime::GetGameTimeMS().count() < m_cooldownTime)
            return;
 
        m_cooldownTime = GameTime::GetGameTimeMS().count() + cooldown * IN_MILLISECONDS;
    }
 
    if (user->IsPlayer() && GetGoType() != GAMEOBJECT_TYPE_TRAP) // workaround for GO casting
        if (!m_goInfo->IsUsableMounted())
            user->RemoveAurasByType(SPELL_AURA_MOUNTED);
 
    switch (GetGoType())
    {
        case GAMEOBJECT_TYPE_DOOR:                          //0
            //doors/buttons never really despawn, only reset to default state/flags
            UseDoorOrButton(0, false, user);
            return;
        case GAMEOBJECT_TYPE_BUTTON:                        //1
            //doors/buttons never really despawn, only reset to default state/flags
            UseDoorOrButton(0, false, user);
 
            // Xinef: properly link possible traps
            if (uint32 trapEntry = GetGOInfo()->button.linkedTrap)
                TriggeringLinkedGameObject(trapEntry, user);
            return;
        case GAMEOBJECT_TYPE_QUESTGIVER:                    //2
            {
                if (!user->IsPlayer())
                    return;
 
                Player* player = user->ToPlayer();
 
                player->PrepareGossipMenu(this, GetGOInfo()->questgiver.gossipID, true);
                player->SendPreparedGossip(this);
                return;
            }
        case GAMEOBJECT_TYPE_TRAP:                          //6
            {
                GameObjectTemplate const* goInfo = GetGOInfo();
                if (goInfo->trap.spellId)
                    CastSpell(user, goInfo->trap.spellId);
 
                m_cooldownTime = GameTime::GetGameTimeMS().count() + (goInfo->trap.cooldown ? goInfo->trap.cooldown :  uint32(4)) * IN_MILLISECONDS; // template or 4 seconds
 
                if (goInfo->trap.type == 1)         // Deactivate after trigger
                    SetLootState(GO_JUST_DEACTIVATED);
 
                return;
            }
        //Sitting: Wooden bench, chairs enzz
        case GAMEOBJECT_TYPE_CHAIR:                         //7
            {
                GameObjectTemplate const* info = GetGOInfo();
                if (!info)
                    return;
 
                if (!user->IsPlayer())
                    return;
 
                if (ChairListSlots.empty())        // this is called once at first chair use to make list of available slots
                {
                    if (info->chair.slots > 0)     // sometimes chairs in DB have error in fields and we dont know number of slots
                        for (uint32 i = 0; i < info->chair.slots; ++i)
                            ChairListSlots[i].Clear(); // Last user of current slot set to 0 (none sit here yet)
                    else
                        ChairListSlots[0].Clear();     // error in DB, make one default slot
                }
 
                Player* player = user->ToPlayer();
 
                // a chair may have n slots. we have to calculate their positions and teleport the player to the nearest one
 
                float lowestDist = DEFAULT_VISIBILITY_DISTANCE;
 
                uint32 nearest_slot = 0;
                float x_lowest = GetPositionX();
                float y_lowest = GetPositionY();
 
                // the object orientation + 1/2 pi
                // every slot will be on that straight line
                float orthogonalOrientation = GetOrientation() + M_PI * 0.5f;
                // find nearest slot
                bool found_free_slot = false;
                for (ChairSlotAndUser::iterator itr = ChairListSlots.begin(); itr != ChairListSlots.end(); ++itr)
                {
                    // the distance between this slot and the center of the go - imagine a 1D space
                    float relativeDistance = (info->size * itr->first) - (info->size * (info->chair.slots - 1) / 2.0f);
 
                    float x_i = GetPositionX() + relativeDistance * cos(orthogonalOrientation);
                    float y_i = GetPositionY() + relativeDistance * std::sin(orthogonalOrientation);
 
                    if (itr->second)
                    {
                        if (Player* ChairUser = ObjectAccessor::GetPlayer(*this, itr->second))
                        {
                            if (ChairUser->IsSitState() && ChairUser->getStandState() != UNIT_STAND_STATE_SIT && ChairUser->GetExactDist2d(x_i, y_i) < 0.1f)
                                continue;        // This seat is already occupied by ChairUser. NOTE: Not sure if the ChairUser->getStandState() != UNIT_STAND_STATE_SIT check is required.
                            else
                                itr->second.Clear(); // This seat is unoccupied.
                        }
                        else
                            itr->second.Clear();     // The seat may of had an occupant, but they're offline.
                    }
 
                    found_free_slot = true;
 
                    // calculate the distance between the player and this slot
                    float thisDistance = player->GetDistance2d(x_i, y_i);
 
                    if (thisDistance <= lowestDist)
                    {
                        nearest_slot = itr->first;
                        lowestDist = thisDistance;
                        x_lowest = x_i;
                        y_lowest = y_i;
                    }
                }
 
                if (found_free_slot)
                {
                    ChairSlotAndUser::iterator itr = ChairListSlots.find(nearest_slot);
                    if (itr != ChairListSlots.end())
                    {
                        itr->second = player->GetGUID(); //this slot in now used by player
                        player->TeleportTo(GetMapId(), x_lowest, y_lowest, GetPositionZ(), GetOrientation(), TELE_TO_NOT_LEAVE_TRANSPORT | TELE_TO_NOT_LEAVE_COMBAT | TELE_TO_NOT_UNSUMMON_PET);
                        player->SetStandState(UNIT_STAND_STATE_SIT_LOW_CHAIR + info->chair.height);
                        return;
                    }
                }
 
                return;
            }
        //big gun, its a spell/aura
        case GAMEOBJECT_TYPE_GOOBER:                        //10
            {
                GameObjectTemplate const* info = GetGOInfo();
 
                // xinef: Goober cannot be used with this flag, skip
                if (HasGameObjectFlag(GO_FLAG_IN_USE))
                    return;
 
                if (user->IsPlayer())
                {
                    Player* player = user->ToPlayer();
 
                    if (info->goober.pageId)                    // show page...
                    {
                        WorldPacket data(SMSG_GAMEOBJECT_PAGETEXT, 8);
                        data << GetGUID();
                        player->SendDirectMessage(&data);
                    }
                    else if (info->goober.gossipID)
                    {
                        player->PrepareGossipMenu(this, info->goober.gossipID);
                        player->SendPreparedGossip(this);
                    }
 
                    if (info->goober.eventId)
                    {
                        LOG_DEBUG("maps.script", "Goober ScriptStart id {} for GO entry {} (spawnId {}).", info->goober.eventId, GetEntry(), m_spawnId);
                        GetMap()->ScriptsStart(sEventScripts, info->goober.eventId, player, this);
                        EventInform(info->goober.eventId);
                    }
 
                    // possible quest objective for active quests
                    if (info->goober.questId && sObjectMgr->GetQuestTemplate(info->goober.questId))
                    {
                        //Quest require to be active for GO using
                        if (player->GetQuestStatus(info->goober.questId) != QUEST_STATUS_INCOMPLETE)
                            break;
                    }
 
                    if (Battleground* bg = player->GetBattleground())
                        bg->EventPlayerUsedGO(player, this);
 
                    if (Group* group = player->GetGroup())
                    {
                        for (GroupReference const* itr = group->GetFirstMember(); itr != nullptr; itr = itr->next())
                        {
                            if (Player* member = itr->GetSource())
                            {
                                if (member->IsAtGroupRewardDistance(this))
                                {
                                    member->KillCreditGO(info->entry, GetGUID());
                                }
                            }
                        }
                    }
                    else
                    {
                        player->KillCreditGO(info->entry, GetGUID());
                    }
                }
 
                if (uint32 trapEntry = info->goober.linkedTrapId)
                    TriggeringLinkedGameObject(trapEntry, user);
 
                if (info->GetAutoCloseTime())
                {
                    SetGameObjectFlag(GO_FLAG_IN_USE);
                    SetLootState(GO_ACTIVATED, user);
                    if (!info->goober.customAnim)
                        SetGoState(GO_STATE_ACTIVE);
                }
 
                // this appear to be ok, however others exist in addition to this that should have custom (ex: 190510, 188692, 187389)
                if (info->goober.customAnim)
                    SendCustomAnim(GetGoAnimProgress());
 
                m_cooldownTime = GameTime::GetGameTimeMS().count() + info->GetAutoCloseTime();
 
                // cast this spell later if provided
                spellId = info->goober.spellId;
                spellCaster = user;
 
                break;
            }
        case GAMEOBJECT_TYPE_CAMERA:                        //13
            {
                GameObjectTemplate const* info = GetGOInfo();
                if (!info)
                    return;
 
                if (!user->IsPlayer())
                    return;
 
                Player* player = user->ToPlayer();
 
                if (info->camera.cinematicId)
                    player->GetCinematicMgr().StartCinematic(info->camera.cinematicId);
 
                if (info->camera.eventID)
                {
                    GetMap()->ScriptsStart(sEventScripts, info->camera.eventID, player, this);
                    EventInform(info->camera.eventID);
                }
 
                return;
            }
        //fishing bobber
        case GAMEOBJECT_TYPE_FISHINGNODE:                   //17
            {
                Player* player = user->ToPlayer();
                if (!player)
                    return;
 
                if (player->GetGUID() != GetOwnerGUID())
                    return;
 
                switch (getLootState())
                {
                    case GO_READY:                              // ready for loot
                        {
                            uint32 zone, subzone;
                            GetZoneAndAreaId(zone, subzone);
 
                            int32 zoneSkill = sObjectMgr->GetFishingBaseSkillLevel(subzone);
                            if (!zoneSkill)
                                zoneSkill = sObjectMgr->GetFishingBaseSkillLevel(zone);
 
                            //provide error, no fishable zone or area should be 0
                            if (!zoneSkill)
                                LOG_ERROR("sql.sql", "Fishable areaId {} are not properly defined in `skill_fishing_base_level`.", subzone);
 
                            // no miss skill is zone skill + 95 since at least patch 2.1
                            int32 const noMissSkill = zoneSkill + 95;
 
                            int32 const skill = player->GetSkillValue(SKILL_FISHING);
 
                            int32 chance;
                            // fishing pool catches are 100%
                            //TODO: find reasonable value for fishing hole search
                            GameObject* fishingHole = LookupFishingHoleAround(20.0f + CONTACT_DISTANCE);
                            if (fishingHole)
                                chance = 100;
                            else if (skill < noMissSkill)
                            {
                                chance = int32(pow((double)skill / noMissSkill, 2) * 100);
                                if (chance < 1)
                                    chance = 1;
                            }
                            else
                                chance = 100;
 
                            int32 const roll = irand(1, 100);
 
                            LOG_DEBUG("entities.gameobject", "Fishing check (skill: {} zone min skill: {} no-miss skill: {} chance {} roll: {})", skill, zoneSkill, noMissSkill, chance, roll);
 
                            if (sScriptMgr->OnPlayerUpdateFishingSkill(player, skill, zoneSkill, chance, roll))
                                player->UpdateFishingSkill();
                            // but you will likely cause junk in areas that require a high fishing skill (not yet implemented)
                            if (chance >= roll)
                            {
                                //TODO: I do not understand this hack. Need some explanation.
                                // prevent removing GO at spell cancel
                                RemoveFromOwner();
                                SetOwnerGUID(player->GetGUID());
                                SetSpellId(0); // prevent removing unintended auras at Unit::RemoveGameObject
 
                                // fishing pool catch
                                if (fishingHole)
                                {
                                    fishingHole->Use(player);
                                    SetLootState(GO_JUST_DEACTIVATED);
                                }
                                else
                                    player->SendLoot(GetGUID(), LOOT_FISHING);
                            }
                            else // else: junk
                                player->SendLoot(GetGUID(), LOOT_FISHING_JUNK);
                            break;
                        }
                    case GO_JUST_DEACTIVATED:                   // nothing to do, will be deleted at next update
                        break;
                    default:
                        {
                            SetLootState(GO_JUST_DEACTIVATED);
 
                            WorldPacket data(SMSG_FISH_NOT_HOOKED, 0);
                            player->SendDirectMessage(&data);
                            break;
                        }
                }
                player->FinishSpell(CURRENT_CHANNELED_SPELL, true);
                return;
            }
 
        case GAMEOBJECT_TYPE_SUMMONING_RITUAL:              //18
            {
                if (!user->IsPlayer())
                    return;
 
                Player* player = user->ToPlayer();
                Unit* owner = GetOwner();
                GameObjectTemplate const* info = GetGOInfo();
 
                // ritual owner is set for GO's without owner (not summoned)
                if (!m_ritualOwnerGUID && !owner)
                    m_ritualOwnerGUID = player->GetGUID();
 
                if (owner)
                {
                    if (!owner->IsPlayer())
                        return;
 
                    // accept only use by player from same group as owner, excluding owner itself (unique use already added in spell effect)
                    if (player == owner->ToPlayer() || (info->summoningRitual.castersGrouped && !player->IsInSameRaidWith(owner->ToPlayer())))
                        return;
 
                    // expect owner to already be channeling, so if not...
                    if (!owner->GetCurrentSpell(CURRENT_CHANNELED_SPELL))
                        return;
                }
                else
                {
                    Player* ritualOwner = ObjectAccessor::GetPlayer(*this, m_ritualOwnerGUID);
                    if (!ritualOwner)
                        return;
                    if (player != ritualOwner && (info->summoningRitual.castersGrouped && !player->IsInSameRaidWith(ritualOwner)))
                        return;
                }
 
                CheckRitualList();
 
                if (GetUniqueUseCount() == info->summoningRitual.reqParticipants)
                    return;
 
                if (info->summoningRitual.animSpell)
                    player->CastSpell(player, info->summoningRitual.animSpell, true);
                else
                    player->CastSpell(player, GetSpellId(),
                        TriggerCastFlags(TRIGGERED_IGNORE_EFFECTS
                                       | TRIGGERED_IGNORE_POWER_AND_REAGENT_COST
                                       | TRIGGERED_CAST_DIRECTLY));
 
                AddUniqueUse(player);
 
                // full amount unique participants including original summoner
                if (GetUniqueUseCount() == info->summoningRitual.reqParticipants)
                {
                    SetLootState(GO_NOT_READY);
 
                    // channel ready, maintain this
                    m_cooldownTime = GameTime::GetGameTimeMS().count() + 5 * IN_MILLISECONDS;
                }
 
                return;
            }
        case GAMEOBJECT_TYPE_SPELLCASTER:                   //22
            {
                GameObjectTemplate const* info = GetGOInfo();
                if (!info)
                    return;
 
                if (info->spellcaster.partyOnly)
                {
                    if (!user->IsPlayer())
                        return;
                    if (ObjectGuid ownerGuid = GetOwnerGUID())
                    {
                        if (user->GetGUID() != ownerGuid)
                        {
                            Group* group = user->ToPlayer()->GetGroup();
                            if (!group)
                                return;
                            if (!group->IsMember(ownerGuid))
                                return;
                        }
                    }
                }
 
                spellId = info->spellcaster.spellId;
                break;
            }
        case GAMEOBJECT_TYPE_MEETINGSTONE:                  //23
            {
                GameObjectTemplate const* info = GetGOInfo();
 
                if (!user->IsPlayer())
                    return;
 
                Player* player = user->ToPlayer();
 
                Player* targetPlayer = ObjectAccessor::FindPlayer(player->GetTarget());
 
                // accept only use by player from same raid as caster
                if (!targetPlayer || !targetPlayer->IsInSameRaidWith(player))
                    return;
 
                //required lvl checks!
                uint8 level = player->GetLevel();
                if (level < info->meetingstone.minLevel)
                    return;
                level = targetPlayer->GetLevel();
                if (level < info->meetingstone.minLevel)
                    return;
 
                spellId = 23598;                            // Meeting Stone Summon
 
                break;
            }
 
        case GAMEOBJECT_TYPE_FLAGSTAND:                     // 24
            {
                if (!user->IsPlayer())
                    return;
 
                Player* player = user->ToPlayer();
 
                if (player->CanUseBattlegroundObject(this))
                {
                    // in battleground check
                    Battleground* bg = player->GetBattleground();
                    if (!bg)
                        return;
 
                    if (player->GetVehicle())
                        return;
 
                    player->RemoveAurasByType(SPELL_AURA_MOD_STEALTH);
                    player->RemoveAurasByType(SPELL_AURA_MOD_INVISIBILITY);
                    // BG flag click
                    // AB:
                    // 15001
                    // 15002
                    // 15003
                    // 15004
                    // 15005
                    bg->EventPlayerClickedOnFlag(player, this);
                    return;                                     //we don;t need to delete flag ... it is despawned!
                }
                break;
            }
 
        case GAMEOBJECT_TYPE_FISHINGHOLE:                   // 25
            {
                if (!user->IsPlayer())
                    return;
 
                Player* player = user->ToPlayer();
 
                player->SendLoot(GetGUID(), LOOT_FISHINGHOLE);
                player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_FISH_IN_GAMEOBJECT, GetGOInfo()->entry);
                return;
            }
 
        case GAMEOBJECT_TYPE_FLAGDROP:                      // 26
            {
                if (!user->IsPlayer())
                    return;
 
                Player* player = user->ToPlayer();
 
                if (player->CanUseBattlegroundObject(this))
                {
                    // in battleground check
                    Battleground* bg = player->GetBattleground();
                    if (!bg)
                        return;
 
                    if (player->GetVehicle())
                        return;
 
                    player->RemoveAurasByType(SPELL_AURA_MOD_STEALTH);
                    player->RemoveAurasByType(SPELL_AURA_MOD_INVISIBILITY);
                    // BG flag dropped
                    // WS:
                    // 179785 - Silverwing Flag
                    // 179786 - Warsong Flag
                    // EotS:
                    // 184142 - Netherstorm Flag
                    GameObjectTemplate const* info = GetGOInfo();
                    if (info)
                    {
                        if (GameObject::gameObjectToEventFlag.find(info->entry) != GameObject::gameObjectToEventFlag.end())
                        {
                            GameObject::gameObjectToEventFlag[info->entry](player, this, bg);
                        }
                        else
                        {
                            switch (info->entry)
                            {
                                case 179785:                        // Silverwing Flag
                                case 179786:                        // Warsong Flag
                                    if (bg->GetBgTypeID(true) == BATTLEGROUND_WS)
                                        bg->EventPlayerClickedOnFlag(player, this);
                                    break;
                                case 184142:                        // Netherstorm Flag
                                    if (bg->GetBgTypeID(true) == BATTLEGROUND_EY)
                                        bg->EventPlayerClickedOnFlag(player, this);
                                    break;
                            }
                        }
                    }
                    //this cause to call return, all flags must be deleted here!!
                    spellId = 0;
                    Delete();
                }
                break;
            }
        case GAMEOBJECT_TYPE_BARBER_CHAIR:                  //32
            {
                GameObjectTemplate const* info = GetGOInfo();
                if (!info)
                    return;
 
                if (!user->IsPlayer())
                    return;
 
                Player* player = user->ToPlayer();
 
                // fallback, will always work
                player->TeleportTo(GetMapId(), GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation(), TELE_TO_NOT_LEAVE_TRANSPORT | TELE_TO_NOT_LEAVE_COMBAT | TELE_TO_NOT_UNSUMMON_PET);
 
                WorldPacket data(SMSG_ENABLE_BARBER_SHOP, 0);
                player->SendDirectMessage(&data);
 
                player->SetStandState(UNIT_STAND_STATE_SIT_LOW_CHAIR + info->barberChair.chairheight);
                return;
            }
        default:
            if (GetGoType() >= MAX_GAMEOBJECT_TYPE)
                LOG_ERROR("entities.gameobject", "GameObject::Use(): unit ({}, name: {}) tries to use object ({}, name: {}) of unknown type ({})",
                               user->GetGUID().ToString(), user->GetName(), GetGUID().ToString(),  GetGOInfo()->name, GetGoType());
            break;
    }
 
    if (!spellId)
        return;
 
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
    if (!spellInfo)
    {
        if (!user->IsPlayer() || !sOutdoorPvPMgr->HandleCustomSpell(user->ToPlayer(), spellId, this))
            LOG_ERROR("entities.gameobject", "WORLD: unknown spell id {} at use action for gameobject (Entry: {} GoType: {})", spellId, GetEntry(), GetGoType());
        else
            LOG_DEBUG("outdoorpvp", "WORLD: {} non-dbc spell was handled by OutdoorPvP", spellId);
        return;
    }
 
    if (m_goInfo->IsUsableMounted())
        triggeredFlags |= TRIGGERED_IGNORE_CASTER_MOUNTED_OR_ON_VEHICLE;
 
    if (Player* player = user->ToPlayer())
        sOutdoorPvPMgr->HandleCustomSpell(player, spellId, this);
 
    if (spellCaster)
    {
        if ((spellCaster->CastSpell(user, spellInfo, TriggerCastFlags(triggeredFlags)) == SPELL_CAST_OK) && GetGoType() == GAMEOBJECT_TYPE_SPELLCASTER)
            AddUse();
    }
    else
        CastSpell(user, spellId);
}

Referenced by Spell::EffectActivateObject(), spell_q9452_cast_net::HandleActiveObject(), go_sand_trap::Reset(), Spell::SendLoot(), npc_valiance_keep_cannoneer::npc_valiance_keep_cannoneerAI::UpdateAI(), and Use().

◆ UseDoorOrButton()

void GameObject::UseDoorOrButton	(	uint32	time_to_restore = `0`,
		bool	alternative = `false`,
		Unit *	user = `nullptr`
	)

{
    if (m_lootState != GO_READY)
        return;
 
    if (!time_to_restore)
        time_to_restore = GetGOInfo()->GetAutoCloseTime();
 
    SwitchDoorOrButton(true, alternative);
    SetLootState(GO_ACTIVATED, user);
 
    m_cooldownTime = GameTime::GetGameTimeMS().count() + time_to_restore;
}

References GameObjectTemplate::GetAutoCloseTime(), GameTime::GetGameTimeMS(), GetGOInfo(), GO_ACTIVATED, GO_READY, m_cooldownTime, m_lootState, SetLootState(), and SwitchDoorOrButton().

◆ ValidateGameobjectType()

bool GameObject::ValidateGameobjectType ( ) const

{
    switch (m_goInfo->type)
    {
        case GAMEOBJECT_TYPE_DOOR:
        case GAMEOBJECT_TYPE_BUTTON:
        case GAMEOBJECT_TYPE_TRAP:
        case GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING:
        case GAMEOBJECT_TYPE_TRAPDOOR:
            return true;
        default:
            return false;
    }
}

References GAMEOBJECT_TYPE_BUTTON, GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING, GAMEOBJECT_TYPE_DOOR, GAMEOBJECT_TYPE_TRAP, GAMEOBJECT_TYPE_TRAPDOOR, m_goInfo, and GameObjectTemplate::type.

Referenced by IsInstanceGameobject().

Member Data Documentation

◆ _lootStateUnitGUID

ObjectGuid GameObject::_lootStateUnitGUID

protected

Referenced by SetLootState(), and Update().

◆ ChairListSlots

ChairSlotAndUser GameObject::ChairListSlots

protected

Referenced by Use().

◆ gameObjectToEventFlag

std::unordered_map< int, goEventFlag > GameObject::gameObjectToEventFlag = { }

static

{
    //11 GAMEOBJECT_TYPE_TRANSPORT
    struct
    {
        uint32 PathProgress;
        TransportAnimation const* AnimationInfo;
    } Transport;
    //25 GAMEOBJECT_TYPE_FISHINGHOLE
    struct
    {
        uint32 MaxOpens;
    } FishingHole;
    //29 GAMEOBJECT_TYPE_CAPTURE_POINT
    struct
    {
        OPvPCapturePoint* OPvPObj;
    } CapturePoint;
    //33 GAMEOBJECT_TYPE_DESTRUCTIBLE_BUILDING
    struct
    {
        uint32 Health;
        uint32 MaxHealth;
    } Building;
};
 
enum class GameObjectActions : uint32
{
    // Name from client executable      // Comments
    None,                           // -NONE-
    AnimateCustom0,                 // Animate Custom0
    AnimateCustom1,                 // Animate Custom1
    AnimateCustom2,                 // Animate Custom2
    AnimateCustom3,                 // Animate Custom3
    Disturb,                        // Disturb                          // Triggers trap
    Unlock,                         // Unlock                           // Resets GO_FLAG_LOCKED
    Lock,                           // Lock                             // Sets GO_FLAG_LOCKED
    Open,                           // Open                             // Sets GO_STATE_ACTIVE
    OpenAndUnlock,                  // Open + Unlock                    // Sets GO_STATE_ACTIVE and resets GO_FLAG_LOCKED
    Close,                          // Close                            // Sets GO_STATE_READY
    ToggleOpen,                     // Toggle Open
    Destroy,                        // Destroy                          // Sets GO_STATE_DESTROYED
    Rebuild,                        // Rebuild                          // Resets from GO_STATE_DESTROYED
    Creation,                       // Creation
    Despawn,                        // Despawn
    MakeInert,                      // Make Inert                       // Disables interactions
    MakeActive,                     // Make Active                      // Enables interactions
    CloseAndLock,                   // Close + Lock                     // Sets GO_STATE_READY and sets GO_FLAG_LOCKED
    UseArtKit0,                     // Use ArtKit0                      // 46904: 121
    UseArtKit1,                     // Use ArtKit1                      // 36639: 81, 46903: 122
    UseArtKit2,                     // Use ArtKit2
    UseArtKit3,                     // Use ArtKit3
    SetTapList,                     // Set Tap List
};
 
// For containers:  [GO_NOT_READY]->GO_READY (close)->GO_ACTIVATED (open) ->GO_JUST_DEACTIVATED->GO_READY        -> ...
// For bobber:      GO_NOT_READY  ->GO_READY (close)->GO_ACTIVATED (open) ->GO_JUST_DEACTIVATED-><deleted>
// For door(closed):[GO_NOT_READY]->GO_READY (close)->GO_ACTIVATED (open) ->GO_JUST_DEACTIVATED->GO_READY(close) -> ...
// For door(open):  [GO_NOT_READY]->GO_READY (open) ->GO_ACTIVATED (close)->GO_JUST_DEACTIVATED->GO_READY(open)  -> ...
enum LootState
{
    GO_NOT_READY,
    GO_READY,                                               // can be ready but despawned, and then not possible activate until spawn
    GO_ACTIVATED,
    GO_JUST_DEACTIVATED
};
 
// 5 sec for bobber catch
#define FISHING_BOBBER_READY_TIME 5
 
class GameObject : public WorldObject, public GridObject<GameObject>, public MovableMapObject, public UpdatableMapObject
{
public:
    explicit GameObject();
    ~GameObject() override;
 
    void BuildValuesUpdate(uint8 updateType, ByteBuffer* data, Player* target) override;
 
    void AddToWorld() override;
    void RemoveFromWorld() override;
    void CleanupsBeforeDelete(bool finalCleanup = true) override;
 
    uint32 GetDynamicFlags() const override { return GetUInt32Value(GAMEOBJECT_DYNAMIC); }
    void ReplaceAllDynamicFlags(uint32 flag) override { SetUInt32Value(GAMEOBJECT_DYNAMIC, flag); }
 
    virtual bool Create(ObjectGuid::LowType guidlow, uint32 name_id, Map* map, uint32 phaseMask, float x, float y, float z, float ang, G3D::Quat const& rotation, uint32 animprogress, GOState go_state, uint32 artKit = 0);
    void Update(uint32 p_time) override;
    [[nodiscard]] GameObjectTemplate const* GetGOInfo() const { return m_goInfo; }
    [[nodiscard]] GameObjectTemplateAddon const* GetTemplateAddon() const;
    [[nodiscard]] GameObjectData const* GetGameObjectData() const { return m_goData; }
    [[nodiscard]] GameObjectValue const* GetGOValue() const { return &m_goValue; }
 
    [[nodiscard]] bool IsTransport() const;
    [[nodiscard]] bool IsDestructibleBuilding() const;
 
    [[nodiscard]] ObjectGuid::LowType GetSpawnId() const { return m_spawnId; }
 
    // z_rot, y_rot, x_rot - rotation angles around z, y and x axes
    void SetWorldRotationAngles(float z_rot, float y_rot, float x_rot);
    void SetWorldRotation(G3D::Quat const& rot);
    void SetTransportPathRotation(float qx, float qy, float qz, float qw);
    [[nodiscard]] G3D::Quat const& GetWorldRotation() const { return WorldRotation; }
    [[nodiscard]] int64 GetPackedWorldRotation() const { return m_packedRotation; }
    [[nodiscard]] G3D::Quat GetFinalWorldRotation() const;
 
    // overwrite WorldObject function for proper name localization
    [[nodiscard]] std::string const& GetNameForLocaleIdx(LocaleConstant locale_idx) const override;
 
    void SaveToDB(bool saveAddon = false);
    void SaveToDB(uint32 mapid, uint8 spawnMask, uint32 phaseMask, bool saveAddon = false);
    virtual bool LoadFromDB(ObjectGuid::LowType guid, Map* map) { return LoadGameObjectFromDB(guid, map, false); }
    virtual bool LoadGameObjectFromDB(ObjectGuid::LowType guid, Map* map, bool addToMap = true);
    void DeleteFromDB();
 
    void SetOwnerGUID(ObjectGuid owner)
    {
        // Owner already found and different than expected owner - remove object from old owner
        if (owner && GetOwnerGUID() && GetOwnerGUID() != owner)
        {
            ABORT();
        }
        m_spawnedByDefault = false;                     // all object with owner is despawned after delay
        SetGuidValue(OBJECT_FIELD_CREATED_BY, owner);
    }
    [[nodiscard]] ObjectGuid GetOwnerGUID() const { return GetGuidValue(OBJECT_FIELD_CREATED_BY); }
    [[nodiscard]] Unit* GetOwner() const;
 
    void SetSpellId(uint32 id)
    {
        m_spawnedByDefault = false;                     // all summoned object is despawned after delay
        m_spellId = id;
    }
    [[nodiscard]] uint32 GetSpellId() const { return m_spellId;}
 
    [[nodiscard]] time_t GetRespawnTime() const { return m_respawnTime; }
    [[nodiscard]] time_t GetRespawnTimeEx() const;
 
    void SetRespawnTime(int32 respawn);
    void SetRespawnDelay(int32 respawn);
    void Respawn();
    [[nodiscard]] bool isSpawned() const
    {
        return m_respawnDelayTime == 0 ||
               (m_respawnTime > 0 && !m_spawnedByDefault) ||
               (m_respawnTime == 0 && m_spawnedByDefault);
    }
    [[nodiscard]] bool isSpawnedByDefault() const { return m_spawnedByDefault; }
    void SetSpawnedByDefault(bool b) { m_spawnedByDefault = b; }
    [[nodiscard]] uint32 GetRespawnDelay() const { return m_respawnDelayTime; }
    void Refresh();
    void DespawnOrUnsummon(Milliseconds delay = 0ms, Seconds forcedRespawnTime = 0s);
    void Delete();
    void GetFishLoot(Loot* fishLoot, Player* lootOwner, bool junk = false);
    [[nodiscard]] GameobjectTypes GetGoType() const { return GameobjectTypes(GetByteValue(GAMEOBJECT_BYTES_1, 1)); }
    void SetGoType(GameobjectTypes type) { SetByteValue(GAMEOBJECT_BYTES_1, 1, type); }
    [[nodiscard]] GOState GetGoState() const { return GOState(GetByteValue(GAMEOBJECT_BYTES_1, 0)); }
    void SetGoState(GOState state);
    [[nodiscard]] uint8 GetGoArtKit() const { return GetByteValue(GAMEOBJECT_BYTES_1, 2); }
    void SetGoArtKit(uint8 artkit);
    [[nodiscard]] uint8 GetGoAnimProgress() const { return GetByteValue(GAMEOBJECT_BYTES_1, 3); }
    void SetGoAnimProgress(uint8 animprogress) { SetByteValue(GAMEOBJECT_BYTES_1, 3, animprogress); }
    static void SetGoArtKit(uint8 artkit, GameObject* go, ObjectGuid::LowType lowguid = 0);
 
    void SetPhaseMask(uint32 newPhaseMask, bool update) override;
    void EnableCollision(bool enable);
 
    GameObjectFlags GetGameObjectFlags() const { return GameObjectFlags(GetUInt32Value(GAMEOBJECT_FLAGS)); }
    bool HasGameObjectFlag(GameObjectFlags flags) const { return HasFlag(GAMEOBJECT_FLAGS, flags) != 0; }
    void SetGameObjectFlag(GameObjectFlags flags) { SetFlag(GAMEOBJECT_FLAGS, flags); }
    void RemoveGameObjectFlag(GameObjectFlags flags) { RemoveFlag(GAMEOBJECT_FLAGS, flags); }
    void ReplaceAllGameObjectFlags(GameObjectFlags flags) { SetUInt32Value(GAMEOBJECT_FLAGS, flags); }
 
    void Use(Unit* user);
 
    [[nodiscard]] LootState getLootState() const { return m_lootState; }
    // Note: unit is only used when s = GO_ACTIVATED
    void SetLootState(LootState s, Unit* unit = nullptr);
 
    [[nodiscard]] uint16 GetLootMode() const { return m_LootMode; }
    [[nodiscard]] bool HasLootMode(uint16 lootMode) const { return m_LootMode & lootMode; }
    void SetLootMode(uint16 lootMode) { m_LootMode = lootMode; }
    void AddLootMode(uint16 lootMode) { m_LootMode |= lootMode; }
    void RemoveLootMode(uint16 lootMode) { m_LootMode &= ~lootMode; }
    void ResetLootMode() { m_LootMode = LOOT_MODE_DEFAULT; }
 
    void AddToSkillupList(ObjectGuid const& playerGuid);
    [[nodiscard]] bool IsInSkillupList(ObjectGuid const& playerGuid) const;
 
    void AddUniqueUse(Player* player);
    void AddUse() { ++m_usetimes; }
 
    [[nodiscard]] uint32 GetUseCount() const { return m_usetimes; }
    [[nodiscard]] uint32 GetUniqueUseCount() const { return m_unique_users.size(); }
 
    void SaveRespawnTime() override { SaveRespawnTime(0); }
    void SaveRespawnTime(uint32 forceDelay);
 
    Loot        loot;
 
    [[nodiscard]] Player* GetLootRecipient() const;
    [[nodiscard]] Group* GetLootRecipientGroup() const;
    void SetLootRecipient(Creature* creature);
    void SetLootRecipient(Map* map);
    bool IsLootAllowedFor(Player const* player) const;
    [[nodiscard]] bool HasLootRecipient() const { return m_lootRecipient || m_lootRecipientGroup; }
    uint32 m_groupLootTimer;                            // (msecs)timer used for group loot
    uint32 lootingGroupLowGUID;                         // used to find group which is looting
    void SetLootGenerationTime();
    [[nodiscard]] uint32 GetLootGenerationTime() const { return m_lootGenerationTime; }
 
    [[nodiscard]] GameObject* GetLinkedTrap();
    void SetLinkedTrap(GameObject* linkedTrap) { m_linkedTrap = linkedTrap->GetGUID(); }
 
    [[nodiscard]] bool hasQuest(uint32 quest_id) const override;
    [[nodiscard]] bool hasInvolvedQuest(uint32 quest_id) const override;
    bool ActivateToQuest(Player* target) const;
    void UseDoorOrButton(uint32 time_to_restore = 0, bool alternative = false, Unit* user = nullptr);
    // 0 = use `gameobject`.`spawntimesecs`
    void ResetDoorOrButton();
 
    void TriggeringLinkedGameObject(uint32 trapEntry, Unit* target);
 
    [[nodiscard]] bool IsNeverVisible() const override;
    bool IsAlwaysVisibleFor(WorldObject const* seer) const override;
    [[nodiscard]] bool IsInvisibleDueToDespawn() const override;
 
    uint8 getLevelForTarget(WorldObject const* target) const override
    {
        if (Unit* owner = GetOwner())
            return owner->getLevelForTarget(target);
 
        return 1;
    }
 
    GameObject* LookupFishingHoleAround(float range);
 
    void CastSpell(Unit* target, uint32 spell);
    void SendCustomAnim(uint32 anim);
    bool IsInRange2d(float x, float y, float radius) const;
    bool IsInRange3d(float x, float y, float z, float radius) const;
 
    void ModifyHealth(int32 change, Unit* attackerOrHealer = nullptr, uint32 spellId = 0);
    void SetDestructibleBuildingModifyState(bool allow) { m_allowModifyDestructibleBuilding = allow; }
    // sets GameObject type 33 destruction flags and optionally default health for that state
    void SetDestructibleState(GameObjectDestructibleState state, Player* eventInvoker = nullptr, bool setHealth = false);
    [[nodiscard]] GameObjectDestructibleState GetDestructibleState() const
    {
        if (HasGameObjectFlag(GO_FLAG_DESTROYED))
            return GO_DESTRUCTIBLE_DESTROYED;
        if (HasGameObjectFlag(GO_FLAG_DAMAGED))
            return GO_DESTRUCTIBLE_DAMAGED;
        return GO_DESTRUCTIBLE_INTACT;
    }
 
    void EventInform(uint32 eventId);
 
    [[nodiscard]] virtual uint32 GetScriptId() const;
    [[nodiscard]] GameObjectAI* AI() const { return m_AI; }
 
    [[nodiscard]] std::string const& GetAIName() const;
    void SetDisplayId(uint32 displayid);
    [[nodiscard]] uint32 GetDisplayId() const { return GetUInt32Value(GAMEOBJECT_DISPLAYID); }
 
    GameObjectModel* m_model;
    void GetRespawnPosition(float& x, float& y, float& z, float* ori = nullptr) const;
 
    void SetPosition(float x, float y, float z, float o);
    void SetPosition(const Position& pos) { SetPosition(pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), pos.GetOrientation()); }
 
    [[nodiscard]] bool IsStaticTransport() const { return GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT; }
    [[nodiscard]] bool IsMotionTransport() const { return GetGOInfo()->type == GAMEOBJECT_TYPE_MO_TRANSPORT; }
 
    Transport* ToTransport() { if (GetGOInfo()->type == GAMEOBJECT_TYPE_MO_TRANSPORT || GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT) return reinterpret_cast<Transport*>(this); else return nullptr; }
    [[nodiscard]] Transport const* ToTransport() const { if (GetGOInfo()->type == GAMEOBJECT_TYPE_MO_TRANSPORT || GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT) return reinterpret_cast<Transport const*>(this); else return nullptr; }
 
    StaticTransport* ToStaticTransport() { if (GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT) return reinterpret_cast<StaticTransport*>(this); else return nullptr; }
    [[nodiscard]] StaticTransport const* ToStaticTransport() const { if (GetGOInfo()->type == GAMEOBJECT_TYPE_TRANSPORT) return reinterpret_cast<StaticTransport const*>(this); else return nullptr; }
 
    MotionTransport* ToMotionTransport() { if (GetGOInfo()->type == GAMEOBJECT_TYPE_MO_TRANSPORT) return reinterpret_cast<MotionTransport*>(this); else return nullptr; }
    [[nodiscard]] MotionTransport const* ToMotionTransport() const { if (GetGOInfo()->type == GAMEOBJECT_TYPE_MO_TRANSPORT) return reinterpret_cast<MotionTransport const*>(this); else return nullptr; }
 
    [[nodiscard]] float GetStationaryX() const override { if (GetGOInfo()->type != GAMEOBJECT_TYPE_MO_TRANSPORT) return m_stationaryPosition.GetPositionX(); return GetPositionX(); }
    [[nodiscard]] float GetStationaryY() const override { if (GetGOInfo()->type != GAMEOBJECT_TYPE_MO_TRANSPORT) return m_stationaryPosition.GetPositionY(); return GetPositionY(); }
    [[nodiscard]] float GetStationaryZ() const override { if (GetGOInfo()->type != GAMEOBJECT_TYPE_MO_TRANSPORT) return m_stationaryPosition.GetPositionZ(); return GetPositionZ(); }
    [[nodiscard]] float GetStationaryO() const override { if (GetGOInfo()->type != GAMEOBJECT_TYPE_MO_TRANSPORT) return m_stationaryPosition.GetOrientation(); return GetOrientation(); }
 
    [[nodiscard]] float GetInteractionDistance() const;
 
    void UpdateModelPosition();
 
    [[nodiscard]] bool IsAtInteractDistance(Position const& pos, float radius) const;
    [[nodiscard]] bool IsAtInteractDistance(Player const* player, SpellInfo const* spell = nullptr) const;
 
    [[nodiscard]] bool IsWithinDistInMap(Player const* player) const;
    using WorldObject::IsWithinDistInMap;
 
    [[nodiscard]] SpellInfo const* GetSpellForLock(Player const* player) const;
 
    static std::unordered_map<int, goEventFlag> gameObjectToEventFlag; // Gameobject -> event flag
 
    [[nodiscard]] bool ValidateGameobjectType() const;
    [[nodiscard]] bool IsInstanceGameobject() const;
    [[nodiscard]] uint8 GameobjectStateToInt(GOState* state) const;
 
    /* A check to verify if this object is available to be saved on the DB when
     * a state change occurs
     */
    [[nodiscard]] bool IsAllowedToSaveToDB() const { return m_saveStateOnDb; };
 
    /* Enable or Disable the ability to save on the database this gameobject's state
     * whenever it changes
     */
    void AllowSaveToDB(bool enable) { m_saveStateOnDb = enable; };
 
    void SaveStateToDB();
 
    std::string GetDebugInfo() const override;
 
    bool IsUpdateNeeded() override;
protected:
    bool AIM_Initialize();
    GameObjectModel* CreateModel();
    void UpdateModel();                                 // updates model in case displayId were changed
    uint32      m_spellId;
    time_t      m_respawnTime;                          // (secs) time of next respawn (or despawn if GO have owner()),
    uint32      m_respawnDelayTime;                     // (secs) if 0 then current GO state no dependent from timer
    uint32      m_despawnDelay;
    Seconds     m_despawnRespawnTime;                   // override respawn time after delayed despawn
    Seconds     m_restockTime;
    LootState   m_lootState;
    bool        m_spawnedByDefault;
    uint32      m_cooldownTime;                         // used as internal reaction delay time store (not state change reaction).
    // For traps this: spell casting cooldown, for doors/buttons: reset time.
    std::unordered_map<ObjectGuid, int32> m_SkillupList;
 
    ObjectGuid m_ritualOwnerGUID;                       // used for GAMEOBJECT_TYPE_SUMMONING_RITUAL where GO is not summoned (no owner)
    GuidSet m_unique_users;
    uint32 m_usetimes;
 
    typedef std::map<uint32, ObjectGuid> ChairSlotAndUser;
    ChairSlotAndUser ChairListSlots;
 
    ObjectGuid::LowType m_spawnId;                            
    GameObjectTemplate const* m_goInfo;
    GameObjectData const* m_goData;
    GameObjectValue m_goValue;
    bool m_allowModifyDestructibleBuilding;
 
    int64 m_packedRotation;
    G3D::Quat WorldRotation;
    Position m_stationaryPosition;
 
    ObjectGuid m_lootRecipient;
    ObjectGuid::LowType m_lootRecipientGroup;
    uint16 m_LootMode;                                  // bitmask, default LOOT_MODE_DEFAULT, determines what loot will be lootable
    uint32 m_lootGenerationTime;
 
    ObjectGuid m_linkedTrap;
 
    ObjectGuid _lootStateUnitGUID;
 
private:
    void CheckRitualList();
    void ClearRitualList();
    void RemoveFromOwner();
    void SwitchDoorOrButton(bool activate, bool alternative = false);
    void UpdatePackedRotation();
 
    bool _IsWithinDist(WorldObject const* obj, float dist2compare, bool /*is3D*/, bool /*incOwnRadius = true*/, bool /*incTargetRadius = true*/) const override
    {
        dist2compare += obj->GetObjectSize();
        return IsInRange3d(obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ(), dist2compare);
    }
 
    bool IsWithinSightRange(Position const& pos, float dist) const override;
 
    GameObjectAI* m_AI;
 
    bool m_saveStateOnDb = false;
};
#endif

Referenced by Use().

◆ loot

Loot GameObject::loot

Referenced by AddToWorld(), WorldSession::DoLootRelease(), GameObject(), WorldSession::HandleAutostoreLootItemOpcode(), gobject_commandscript::HandleGameObjectInfoCommand(), WorldSession::HandleLootMasterGiveOpcode(), WorldSession::HandleLootMoneyOpcode(), Player::SendLoot(), and Update().

◆ lootingGroupLowGUID

uint32 GameObject::lootingGroupLowGUID

Referenced by GameObject(), and Update().

◆ m_AI

GameObjectAI* GameObject::m_AI

private

Referenced by AI(), AIM_Initialize(), and ~GameObject().

◆ m_allowModifyDestructibleBuilding

bool GameObject::m_allowModifyDestructibleBuilding

protected

Referenced by GameObject(), ModifyHealth(), and SetDestructibleBuildingModifyState().

◆ m_cooldownTime

uint32 GameObject::m_cooldownTime

protected

Referenced by GameObject(), ResetDoorOrButton(), Update(), Use(), and UseDoorOrButton().

◆ m_despawnDelay

uint32 GameObject::m_despawnDelay

protected

Referenced by DespawnOrUnsummon(), GameObject(), and Update().

◆ m_despawnRespawnTime

Seconds GameObject::m_despawnRespawnTime

protected

Referenced by DespawnOrUnsummon(), GameObject(), and Update().

◆ m_goData

GameObjectData const* GameObject::m_goData

protected

Referenced by DespawnOrUnsummon(), GameObject(), GetGameObjectData(), LoadGameObjectFromDB(), StaticTransport::LoadGameObjectFromDB(), and SaveRespawnTime().

◆ m_goInfo

GameObjectTemplate const* GameObject::m_goInfo

protected

Referenced by MotionTransport::CalculateSegmentPos(), Create(), StaticTransport::Create(), MotionTransport::CreateMoTrans(), GameObject(), GetGOInfo(), IsInRange2d(), IsInRange3d(), SetDestructibleState(), Use(), and ValidateGameobjectType().

◆ m_goValue

GameObjectValue GameObject::m_goValue

protected

Referenced by Create(), StaticTransport::Create(), GetGOValue(), StaticTransport::GetPeriod(), ModifyHealth(), StaticTransport::RelocateToProgress(), SetDestructibleState(), Transport::SetPathProgress(), StaticTransport::Update(), and Update().

◆ m_groupLootTimer

uint32 GameObject::m_groupLootTimer

Referenced by GameObject(), and Update().

◆ m_linkedTrap

ObjectGuid GameObject::m_linkedTrap

protected

Referenced by GetLinkedTrap(), and SetLinkedTrap().

◆ m_lootGenerationTime

uint32 GameObject::m_lootGenerationTime

protected

Referenced by GameObject(), GetLootGenerationTime(), and SetLootGenerationTime().

◆ m_LootMode

uint16 GameObject::m_LootMode

protected

Referenced by AddLootMode(), GetLootMode(), HasLootMode(), RemoveLootMode(), ResetLootMode(), and SetLootMode().

◆ m_lootRecipient

ObjectGuid GameObject::m_lootRecipient

protected

Referenced by GetLootRecipient(), HasLootRecipient(), IsLootAllowedFor(), SetLootRecipient(), and SetLootRecipient().

◆ m_lootRecipientGroup

ObjectGuid::LowType GameObject::m_lootRecipientGroup

protected

Referenced by GameObject(), GetLootRecipientGroup(), HasLootRecipient(), IsLootAllowedFor(), SetLootRecipient(), and SetLootRecipient().

◆ m_lootState

LootState GameObject::m_lootState

protected

Referenced by GameObject(), getLootState(), ResetDoorOrButton(), SetLootState(), Update(), and UseDoorOrButton().

◆ m_model

GameObjectModel* GameObject::m_model

Referenced by AddToWorld(), Create(), StaticTransport::Create(), MotionTransport::CreateMoTrans(), EnableCollision(), RemoveFromWorld(), SetGoState(), SetPhaseMask(), UpdateModel(), UpdateModelPosition(), and ~GameObject().

◆ m_packedRotation

int64 GameObject::m_packedRotation

protected

Referenced by GameObject(), GetPackedWorldRotation(), and UpdatePackedRotation().

◆ m_respawnDelayTime

uint32 GameObject::m_respawnDelayTime

protected

Referenced by GameObject(), GetRespawnDelay(), isSpawned(), LoadGameObjectFromDB(), SaveToDB(), SetRespawnDelay(), and Update().

◆ m_respawnTime

time_t GameObject::m_respawnTime

protected

Referenced by GameObject(), GetRespawnTime(), GetRespawnTimeEx(), isSpawned(), LoadGameObjectFromDB(), Refresh(), Respawn(), SaveRespawnTime(), SetRespawnTime(), and Update().

◆ m_restockTime

Seconds GameObject::m_restockTime

protected

Referenced by GameObject(), SetLootState(), and Update().

◆ m_ritualOwnerGUID

ObjectGuid GameObject::m_ritualOwnerGUID

protected

Referenced by Update(), and Use().

◆ m_saveStateOnDb

bool GameObject::m_saveStateOnDb = false

private

Referenced by AllowSaveToDB(), and IsAllowedToSaveToDB().

◆ m_SkillupList

std::unordered_map<ObjectGuid, int32> GameObject::m_SkillupList

protected

Referenced by AddToSkillupList(), IsInSkillupList(), and Update().

◆ m_spawnedByDefault

bool GameObject::m_spawnedByDefault

protected

Referenced by GameObject(), isSpawned(), isSpawnedByDefault(), LoadGameObjectFromDB(), Refresh(), Respawn(), SaveRespawnTime(), SaveToDB(), SetOwnerGUID(), SetRespawnTime(), SetSpawnedByDefault(), SetSpellId(), and Update().

◆ m_spawnId

ObjectGuid::LowType GameObject::m_spawnId

protected

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

Referenced by AddToWorld(), Delete(), DeleteFromDB(), DespawnOrUnsummon(), GameObject(), GetRespawnPosition(), GetSpawnId(), LoadGameObjectFromDB(), StaticTransport::LoadGameObjectFromDB(), RemoveFromWorld(), Respawn(), SaveRespawnTime(), SaveToDB(), SaveToDB(), SetGoArtKit(), Update(), and Use().

◆ m_spellId

uint32 GameObject::m_spellId

protected

Referenced by GameObject(), GetSpellId(), RemoveFromOwner(), and SetSpellId().

◆ m_stationaryPosition

Position GameObject::m_stationaryPosition

protected

Referenced by Create(), StaticTransport::Create(), GameObject(), GetStationaryO(), GetStationaryX(), GetStationaryY(), and GetStationaryZ().

◆ m_unique_users

GuidSet GameObject::m_unique_users

protected

Referenced by AddUniqueUse(), CheckRitualList(), ClearRitualList(), GetUniqueUseCount(), and Update().

◆ m_usetimes

uint32 GameObject::m_usetimes

protected

Referenced by AddUse(), GameObject(), GetUseCount(), and Update().

◆ WorldRotation

G3D::Quat GameObject::WorldRotation

protected

Referenced by GetWorldRotation(), SaveToDB(), SetWorldRotation(), and UpdatePackedRotation().

The documentation for this class was generated from the following files:

azerothcore-wotlk/src/server/game/Entities/GameObject/GameObject.h
azerothcore-wotlk/src/server/game/Entities/GameObject/GameObject.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ChairSlotAndUser

Constructor & Destructor Documentation

◆ GameObject()

◆ ~GameObject()

Member Function Documentation

◆ _IsWithinDist()

◆ ActivateToQuest()

◆ AddLootMode()

◆ AddToSkillupList()

◆ AddToWorld()

◆ AddUniqueUse()

◆ AddUse()

◆ AI()

◆ AIM_Initialize()

◆ AllowSaveToDB()

◆ BuildValuesUpdate()

◆ CastSpell()

◆ CheckRitualList()

◆ CleanupsBeforeDelete()

◆ ClearRitualList()

◆ Create()

◆ CreateModel()

◆ Delete()

◆ DeleteFromDB()

◆ DespawnOrUnsummon()

◆ EnableCollision()

◆ EventInform()

◆ GameobjectStateToInt()

◆ GetAIName()

◆ GetDebugInfo()

◆ GetDestructibleState()

◆ GetDisplayId()

◆ GetDynamicFlags()

◆ GetFinalWorldRotation()

◆ GetFishLoot()

◆ GetGameObjectData()

◆ GetGameObjectFlags()

◆ GetGoAnimProgress()

◆ GetGoArtKit()

◆ GetGOInfo()

◆ GetGoState()

◆ GetGoType()

◆ GetGOValue()

◆ GetInteractionDistance()

◆ getLevelForTarget()

◆ GetLinkedTrap()

◆ GetLootGenerationTime()

◆ GetLootMode()

◆ GetLootRecipient()

◆ GetLootRecipientGroup()

◆ getLootState()

◆ GetNameForLocaleIdx()

◆ GetOwner()

◆ GetOwnerGUID()

◆ GetPackedWorldRotation()

◆ GetRespawnDelay()

◆ GetRespawnPosition()

◆ GetRespawnTime()

◆ GetRespawnTimeEx()

◆ GetScriptId()

◆ GetSpawnId()

◆ GetSpellForLock()

◆ GetSpellId()

◆ GetStationaryO()

◆ GetStationaryX()

◆ GetStationaryY()

◆ GetStationaryZ()

◆ GetTemplateAddon()