#include "Pet.h"

Inheritance diagram for Pet:

Public Member Functions
	Pet (Player *owner, PetType type=MAX_PET_TYPE)

	~Pet () override=default

void	AddToWorld () override

void	RemoveFromWorld () override

float	GetNativeObjectScale () const override

void	SetDisplayId (uint32 modelId) override

PetType	getPetType () const

void	setPetType (PetType type)

bool	isControlled () const

bool	isTemporarySummoned () const

bool	IsPermanentPetFor (Player *owner) const

bool	Create (ObjectGuid::LowType guidlow, Map *map, uint32 phaseMask, uint32 Entry, uint32 pet_number)

bool	CreateBaseAtCreature (Creature *creature)

bool	CreateBaseAtCreatureInfo (CreatureTemplate const cinfo, Unit owner)

bool	CreateBaseAtTamed (CreatureTemplate const cinfo, Map map, uint32 phaseMask)

bool	LoadPetFromDB (Player *owner, uint32 petEntry, uint32 petnumber, bool current, uint32 healthPct=0)

bool	isBeingLoaded () const override

void	SavePetToDB (PetSaveMode mode)

void	FillPetInfo (PetStable::PetInfo *petInfo) const

void	Remove (PetSaveMode mode, bool returnreagent=false)

void	setDeathState (DeathState s, bool despawn=false) override

void	Update (uint32 diff) override

uint8	GetPetAutoSpellSize () const override

uint32	GetPetAutoSpellOnPos (uint8 pos) const override

void	LoseHappiness ()

HappinessState	GetHappinessState ()

void	GivePetXP (uint32 xp)

void	GivePetLevel (uint8 level)

void	SynchronizeLevelWithOwner ()

bool	HaveInDiet (ItemTemplate const *item) const

uint32	GetCurrentFoodBenefitLevel (uint32 itemlevel) const

void	SetDuration (Milliseconds dur)

Milliseconds	GetDuration () const

void	ToggleAutocast (SpellInfo const *spellInfo, bool apply)

bool	HasSpell (uint32 spell) const override

void	LearnPetPassives ()

void	CastPetAuras (bool current)

void	CastWhenWillAvailable (uint32 spellid, Unit spellTarget, Unit oldTarget, bool spellIsPositive=false)

void	ClearCastWhenWillAvailable ()

void	RemoveSpellCooldown (uint32 spell_id, bool update)

void	_SaveSpellCooldowns (CharacterDatabaseTransaction trans)

void	_SaveAuras (CharacterDatabaseTransaction trans)

void	_SaveSpells (CharacterDatabaseTransaction trans)

void	_LoadSpellCooldowns (PreparedQueryResult result)

void	_LoadAuras (PreparedQueryResult result, uint32 timediff)

void	_LoadSpells (PreparedQueryResult result)

bool	addSpell (uint32 spellId, ActiveStates active=ACT_DECIDE, PetSpellState state=PETSPELL_NEW, PetSpellType type=PETSPELL_NORMAL)

bool	learnSpell (uint32 spell_id)

void	learnSpellHighRank (uint32 spellid)

void	InitLevelupSpellsForLevel ()

bool	unlearnSpell (uint32 spell_id, bool learn_prev, bool clear_ab=true)

bool	removeSpell (uint32 spell_id, bool learn_prev, bool clear_ab=true)

void	CleanupActionBar ()

std::string	GenerateActionBarData () const

void	InitPetCreateSpells ()

bool	resetTalents ()

void	InitTalentForLevel ()

uint8	GetMaxTalentPointsForLevel (uint8 level)

uint8	GetFreeTalentPoints ()

void	SetFreeTalentPoints (uint8 points)

uint64	GetAuraUpdateMaskForRaid () const

void	SetAuraUpdateMaskForRaid (uint8 slot)

void	ResetAuraUpdateMaskForRaid ()

DeclinedName const *	GetDeclinedNames () const

Player *	GetOwner () const

void	SetLoading (bool load)

bool	HasTempSpell () const

std::string	GetDebugInfo () const override

Public Member Functions inherited from Guardian
	Guardian (SummonPropertiesEntry const *properties, ObjectGuid owner, bool isWorldObject)

void	InitStats (uint32 duration) override

bool	InitStatsForLevel (uint8 level)

void	InitSummon () override

bool	UpdateStats (Stats stat) override

bool	UpdateAllStats () override

void	UpdateArmor () override

void	UpdateMaxHealth () override

void	UpdateMaxPower (Powers power) override

void	UpdateAttackPowerAndDamage (bool ranged=false) override

void	UpdateDamagePhysical (WeaponAttackType attType) override

std::string	GetDebugInfo () const override

Public Member Functions inherited from Minion
	Minion (SummonPropertiesEntry const *properties, ObjectGuid owner, bool isWorldObject)

void	InitStats (uint32 duration) override

void	RemoveFromWorld () override

Unit *	GetOwner () const

float	GetFollowAngle () const override

void	SetFollowAngle (float angle)

bool	IsPetGhoul () const

bool	IsGuardianPet () const

void	setDeathState (DeathState s, bool despawn=false) override

std::string	GetDebugInfo () const override

Public Member Functions inherited from TempSummon
	TempSummon (SummonPropertiesEntry const *properties, ObjectGuid owner, bool isWorldObject)

	~TempSummon () override=default

void	Update (uint32 time) override

virtual void	InitStats (uint32 lifetime)

virtual void	InitSummon ()

virtual void	UnSummon (uint32 msTime=0)

void	RemoveFromWorld () override

void	SetTempSummonType (TempSummonType type)

void	SaveToDB (uint32, uint8, uint32) override

WorldObject *	GetSummoner () const

Unit *	GetSummonerUnit () const

Creature *	GetSummonerCreatureBase () const

GameObject *	GetSummonerGameObject () const

ObjectGuid	GetSummonerGUID () const

TempSummonType	GetSummonType () const

uint32	GetTimer ()

void	SetTimer (uint32 t)

void	SetVisibleBySummonerOnly (bool visibleBySummonerOnly)

bool	IsVisibleBySummonerOnly () const

std::string	GetDebugInfo () const override

Public Member Functions inherited from Creature
	Creature (bool isWorldObject=false)

	~Creature () override

void	AddToWorld () override

void	RemoveFromWorld () override

float	GetNativeObjectScale () const override

void	SetObjectScale (float scale) override

void	SetDisplayId (uint32 modelId) override

void	DisappearAndDie ()

bool	isVendorWithIconSpeak () const

bool	Create (ObjectGuid::LowType guidlow, Map map, uint32 phaseMask, uint32 Entry, uint32 vehId, float x, float y, float z, float ang, const CreatureData data=nullptr)

bool	LoadCreaturesAddon (bool reload=false)

void	SelectLevel (bool changelevel=true)

void	LoadEquipment (int8 id=1, bool force=false)

ObjectGuid::LowType	GetSpawnId () const

void	Update (uint32 time) override

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

void	SetCorpseDelay (uint32 delay)

void	SetCorpseRemoveTime (uint32 delay)

uint32	GetCorpseDelay () const

bool	IsRacialLeader () const

bool	IsCivilian () const

bool	IsTrigger () const

bool	IsGuard () const

CreatureMovementData const &	GetMovementTemplate () const

bool	CanWalk () const

bool	CanSwim () const override
	This method check the current flag/status of a creature and its inhabit type.

bool	CanEnterWater () const override

bool	CanFly () const override

bool	CanHover () const

MovementGeneratorType	GetDefaultMovementType () const override
	-------—End of Pet responses methods-------—

void	SetDefaultMovementType (MovementGeneratorType mgt)

void	SetReactState (ReactStates st)

ReactStates	GetReactState () const

bool	HasReactState (ReactStates state) const

void	InitializeReactState ()

bool	isCanInteractWithBattleMaster (Player *player, bool msg) const

bool	isCanTrainingAndResetTalentsOf (Player *player) const

bool	IsValidTrainerForPlayer (Player player, uint32 npcFlags=nullptr) const

bool	CanCreatureAttack (Unit const *victim, bool skipDistCheck=false) const

void	LoadSpellTemplateImmunity ()

bool	IsImmunedToSpell (SpellInfo const spellInfo, Spell const spell=nullptr) override

bool	HasMechanicTemplateImmunity (uint32 mask) const

bool	IsImmunedToSpellEffect (SpellInfo const *spellInfo, uint32 index) const override

bool	isElite () const

bool	isWorldBoss () const

bool	IsDungeonBoss () const

bool	IsImmuneToKnockback () const

bool	IsAvoidingAOE () const

uint8	getLevelForTarget (WorldObject const *target) const override

bool	IsInEvadeMode () const

bool	IsEvadingAttacks () const

bool	AIM_Initialize (CreatureAI *ai=nullptr)

void	Motion_Initialize ()

CreatureAI *	AI () const

bool	SetWalk (bool enable) override

bool	SetDisableGravity (bool disable, bool packetOnly=false, bool updateAnimationTier=true) override

bool	SetSwim (bool enable) override

bool	SetCanFly (bool enable, bool packetOnly=false) override

bool	SetWaterWalking (bool enable, bool packetOnly=false) override

bool	SetFeatherFall (bool enable, bool packetOnly=false) override

bool	SetHover (bool enable, bool packetOnly=false, bool updateAnimationTier=true) override

bool	HasSpellFocus (Spell const *focusSpell=nullptr) const

uint32	GetShieldBlockValue () const override

SpellSchoolMask	GetMeleeDamageSchoolMask (WeaponAttackType=BASE_ATTACK, uint8=0) const override

void	SetMeleeDamageSchool (SpellSchools school)

void	_AddCreatureSpellCooldown (uint32 spell_id, uint16 categoryId, uint32 end_time)

void	AddSpellCooldown (uint32 spell_id, uint32, uint32 end_time, bool needSendToClient=false, bool forceSendToSpectator=false) override

bool	HasSpellCooldown (uint32 spell_id) const override

uint32	GetSpellCooldown (uint32 spell_id) const

void	ProhibitSpellSchool (SpellSchoolMask idSchoolMask, uint32 unTimeMs) override

bool	IsSpellProhibited (SpellSchoolMask idSchoolMask) const

bool	HasSpell (uint32 spellID) const override

void	UpdateMovementFlags ()

uint32	GetRandomId (uint32 id1, uint32 id2, uint32 id3)

bool	UpdateEntry (uint32 entry, const CreatureData *data=nullptr, bool changelevel=true, bool updateAI=false)

bool	UpdateEntry (uint32 entry, bool updateAI)

bool	UpdateStats (Stats stat) override

bool	UpdateAllStats () override

void	UpdateResistances (uint32 school) override

void	UpdateArmor () override

void	UpdateMaxHealth () override

void	UpdateMaxPower (Powers power) override

void	UpdateAttackPowerAndDamage (bool ranged=false) override

void	CalculateMinMaxDamage (WeaponAttackType attType, bool normalized, bool addTotalPct, float &minDamage, float &maxDamage, uint8 damageIndex) override

void	SetCanDualWield (bool value) override

int8	GetOriginalEquipmentId () const

uint8	GetCurrentEquipmentId ()

void	SetCurrentEquipmentId (uint8 id)

float	GetSpellDamageMod (int32 Rank)

VendorItemData const *	GetVendorItems () const

uint32	GetVendorItemCurrentCount (VendorItem const *vItem)

uint32	UpdateVendorItemCurrentCount (VendorItem const *vItem, uint32 used_count)

TrainerSpellData const *	GetTrainerSpells () const

CreatureTemplate const *	GetCreatureTemplate () const

CreatureData const *	GetCreatureData () const

void	SetDetectionDistance (float dist)

CreatureAddon const *	GetCreatureAddon () const

std::string const &	GetAIName () const

std::string	GetScriptName () const

uint32	GetScriptId () const

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

void	setDeathState (DeathState s, bool despawn=false) override

bool	LoadFromDB (ObjectGuid::LowType guid, Map *map, bool allowDuplicate=false)

bool	LoadCreatureFromDB (ObjectGuid::LowType guid, Map *map, bool addToMap=true, bool gridLoad=false, bool allowDuplicate=false)

void	SaveToDB ()

virtual void	SaveToDB (uint32 mapid, uint8 spawnMask, uint32 phaseMask)

virtual void	DeleteFromDB ()

ObjectGuid	GetLootRecipientGUID () const

Player *	GetLootRecipient () const

ObjectGuid::LowType	GetLootRecipientGroupGUID () const

Group *	GetLootRecipientGroup () const

bool	hasLootRecipient () const

bool	isTappedBy (Player const *player) const

bool	CanGeneratePickPocketLoot () const

void	SetPickPocketLootTime ()

void	ResetPickPocketLootTime ()

void	SetLootRecipient (Unit *unit, bool withGroup=true)

void	AllLootRemovedFromCorpse ()

uint16	GetLootMode () const

bool	HasLootMode (uint16 lootMode) const

void	SetLootMode (uint16 lootMode)

void	AddLootMode (uint16 lootMode)

void	RemoveLootMode (uint16 lootMode)

void	ResetLootMode ()

SpellInfo const *	reachWithSpellAttack (Unit *victim)

SpellInfo const *	reachWithSpellCure (Unit *victim)

bool	CanStartAttack (Unit const *u) const

float	GetAggroRange (Unit const *target) const

float	GetAttackDistance (Unit const *player) const

float	GetDetectionRange () const

void	SendAIReaction (AiReaction reactionType)

Unit *	SelectNearestTarget (float dist=0, bool playerOnly=false) const

Unit *	SelectNearestTargetInAttackDistance (float dist) const

void	DoFleeToGetAssistance ()

void	CallForHelp (float fRadius, Unit *target=nullptr)

void	CallAssistance (Unit *target=nullptr)

void	SetNoCallAssistance (bool val)

void	SetNoSearchAssistance (bool val)

bool	HasSearchedAssistance ()

bool	CanAssistTo (Unit const u, Unit const enemy, bool checkfaction=true) const

bool	_IsTargetAcceptable (Unit const *target) const

bool	CanIgnoreFeignDeath () const

void	UpdateMoveInLineOfSightState ()

bool	IsMoveInLineOfSightDisabled ()

bool	IsMoveInLineOfSightStrictlyDisabled ()

void	RemoveCorpse (bool setSpawnTime=true, bool skipVisibility=false)

void	DespawnOrUnsummon (Milliseconds msTimeToDespawn, Seconds forcedRespawnTimer)

void	DespawnOrUnsummon (uint32 msTimeToDespawn=0)

void	DespawnOnEvade (Seconds respawnDelay=20s)

time_t const &	GetRespawnTime () const

time_t	GetRespawnTimeEx () const

void	SetRespawnTime (uint32 respawn)

void	Respawn (bool force=false)

void	SaveRespawnTime () override

uint32	GetRespawnDelay () const

void	SetRespawnDelay (uint32 delay)

uint32	GetCombatPulseDelay () const

void	SetCombatPulseDelay (uint32 delay)

float	GetWanderDistance () const

void	SetWanderDistance (float dist)

void	DoImmediateBoundaryCheck ()

void	SendZoneUnderAttackMessage (Player *attacker)
	Send a message to LocalDefense channel for players opposition team in the zone.

void	SetInCombatWithZone ()

bool	hasQuest (uint32 quest_id) const override

bool	hasInvolvedQuest (uint32 quest_id) const override

bool	isRegeneratingHealth ()

void	SetRegeneratingHealth (bool c)

void	SetRegeneratingPower (bool c)

virtual uint8	GetPetAutoSpellSize () const

virtual uint32	GetPetAutoSpellOnPos (uint8 pos) const

void	SetCannotReachTarget (ObjectGuid const &target=ObjectGuid::Empty)

bool	CanNotReachTarget () const

bool	IsNotReachableAndNeedRegen () const

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

void	SetPosition (const Position &pos)

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

void	SetHomePosition (const Position &pos)

void	GetHomePosition (float &x, float &y, float &z, float &ori) const

Position const &	GetHomePosition () const

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

void	SetTransportHomePosition (const Position &pos)

void	GetTransportHomePosition (float &x, float &y, float &z, float &ori) const

Position const &	GetTransportHomePosition () const

uint32	GetWaypointPath () const

void	LoadPath (uint32 pathid)

uint32	GetCurrentWaypointID () const

void	UpdateWaypointID (uint32 wpID)

void	SearchFormation ()

CreatureGroup const *	GetFormation () const

CreatureGroup *	GetFormation ()

void	SetFormation (CreatureGroup *formation)

Unit *	SelectVictim ()

void	SetDisableReputationGain (bool disable)

bool	IsReputationGainDisabled () const

bool	IsDamageEnoughForLootingAndReward () const

void	LowerPlayerDamageReq (uint32 unDamage, bool damagedByPlayer=true)

void	ResetPlayerDamageReq ()

uint32	GetPlayerDamageReq () const

uint32	GetOriginalEntry () const

void	SetOriginalEntry (uint32 entry)

void	SetTarget (ObjectGuid guid=ObjectGuid::Empty) override

void	FocusTarget (Spell const focusSpell, WorldObject const target)

void	ReleaseFocus (Spell const *focusSpell)

bool	IsMovementPreventedByCasting () const override

time_t	GetLastDamagedTime () const

std::shared_ptr< time_t > const &	GetLastDamagedTimePtr () const

void	SetLastDamagedTime (time_t val)

void	SetLastDamagedTimePtr (std::shared_ptr< time_t > const &val)

bool	IsFreeToMove ()

bool	HasSwimmingFlagOutOfCombat () const

void	RefreshSwimmingFlag (bool recheck=false)

void	SetAssistanceTimer (uint32 value)

void	ModifyThreatPercentTemp (Unit *victim, int32 percent, Milliseconds duration)

void	ResumeChasingVictim ()
	Helper to resume chasing current victim.

std::string	GetDebugInfo () const override

Public Member Functions inherited from Unit
	~Unit () override

UnitAI *	GetAI ()

void	SetAI (UnitAI *newAI)

void	AddToWorld () override

void	RemoveFromWorld () override

void	CleanupBeforeRemoveFromMap (bool finalCleanup)

void	CleanupsBeforeDelete (bool finalCleanup=true) override

uint32	GetDynamicFlags () const override

void	ReplaceAllDynamicFlags (uint32 flag) override

DiminishingLevels	GetDiminishing (DiminishingGroup group)

void	IncrDiminishing (DiminishingGroup group)

float	ApplyDiminishingToDuration (DiminishingGroup group, int32 &duration, Unit *caster, DiminishingLevels Level, int32 limitduration)

void	ApplyDiminishingAura (DiminishingGroup group, bool apply)

void	ClearDiminishings ()

float	GetSpellMaxRangeForTarget (Unit const target, SpellInfo const spellInfo) const

float	GetSpellMinRangeForTarget (Unit const target, SpellInfo const spellInfo) const

void	Update (uint32 time) override

void	setAttackTimer (WeaponAttackType type, int32 time)

void	resetAttackTimer (WeaponAttackType type=BASE_ATTACK)

int32	getAttackTimer (WeaponAttackType type) const

bool	isAttackReady (WeaponAttackType type=BASE_ATTACK) const

bool	haveOffhandWeapon () const

bool	CanDualWield () const

virtual void	SetCanDualWield (bool value)

float	GetCombatReach () const override

float	GetMeleeReach () const

bool	IsWithinRange (Unit const *obj, float dist) const

bool	IsWithinCombatRange (Unit const *obj, float dist2compare) const

bool	IsWithinMeleeRange (Unit const *obj, float dist=0.f) const

float	GetMeleeRange (Unit const *target) const

virtual SpellSchoolMask	GetMeleeDamageSchoolMask (WeaponAttackType attackType=BASE_ATTACK, uint8 damageIndex=0) const =0

bool	GetRandomContactPoint (Unit const *target, float &x, float &y, float &z, bool force=false) const

void	_addAttacker (Unit *pAttacker)

void	_removeAttacker (Unit *pAttacker)

Unit *	getAttackerForHelper () const

bool	Attack (Unit *victim, bool meleeAttack)

void	CastStop (uint32 except_spellid=0, bool withInstant=true)

bool	AttackStop ()

void	RemoveAllAttackers ()

AttackerSet const &	getAttackers () const

bool	GetMeleeAttackPoint (Unit *attacker, Position &pos)

bool	isAttackingPlayer () const

Unit *	GetVictim () const

void	CombatStop (bool includingCast=false)

void	CombatStopWithPets (bool includingCast=false)

void	StopAttackFaction (uint32 faction_id)

void	StopAttackingInvalidTarget ()

Unit *	SelectNearbyTarget (Unit *exclude=nullptr, float dist=NOMINAL_MELEE_RANGE) const

Unit *	SelectNearbyNoTotemTarget (Unit *exclude=nullptr, float dist=NOMINAL_MELEE_RANGE) const

void	SendMeleeAttackStop (Unit *victim=nullptr)

void	SendMeleeAttackStart (Unit victim, Player sendTo=nullptr)

void	AddUnitState (uint32 f)

bool	HasUnitState (const uint32 f) const

void	ClearUnitState (uint32 f)

uint32	GetUnitState () const

bool	CanFreeMove () const

uint32	HasUnitTypeMask (uint32 mask) const

void	AddUnitTypeMask (uint32 mask)

uint32	GetUnitTypeMask () const

bool	IsSummon () const

bool	IsGuardian () const

bool	IsControllableGuardian () const

bool	IsPet () const

bool	IsHunterPet () const

bool	IsTotem () const

bool	IsVehicle () const

uint8	getLevel () const

uint8	GetLevel () const

uint8	getLevelForTarget (WorldObject const *) const override

void	SetLevel (uint8 lvl, bool showLevelChange=true)

uint8	getRace (bool original=false) const

void	setRace (uint8 race)

uint32	getRaceMask () const

uint8	getClass () const

uint32	getClassMask () const

uint8	getGender () const

float	GetStat (Stats stat) const

void	SetStat (Stats stat, int32 val)

uint32	GetArmor () const

void	SetArmor (int32 val)

uint32	GetResistance (SpellSchools school) const

uint32	GetResistance (SpellSchoolMask mask) const

void	SetResistance (SpellSchools school, int32 val)

uint32	GetHealth () const

uint32	GetMaxHealth () const

bool	IsFullHealth () const

bool	HealthBelowPct (int32 pct) const

bool	HealthBelowPctDamaged (int32 pct, uint32 damage) const

bool	HealthAbovePct (int32 pct) const

bool	HealthAbovePctHealed (int32 pct, uint32 heal) const

float	GetHealthPct () const

uint32	CountPctFromMaxHealth (int32 pct) const

uint32	CountPctFromCurHealth (int32 pct) const

float	GetPowerPct (Powers power) const

void	SetHealth (uint32 val)

void	SetMaxHealth (uint32 val)

void	SetFullHealth ()

int32	ModifyHealth (int32 val)

int32	GetHealthGain (int32 dVal)

Powers	getPowerType () const

void	setPowerType (Powers power)

uint32	GetPower (Powers power) const

uint32	GetMaxPower (Powers power) const

void	SetPower (Powers power, uint32 val, bool withPowerUpdate=true, bool fromRegenerate=false)

void	SetMaxPower (Powers power, uint32 val)

int32	ModifyPower (Powers power, int32 val, bool withPowerUpdate=true)

int32	ModifyPowerPct (Powers power, float pct, bool apply=true)

uint32	GetAttackTime (WeaponAttackType att) const

void	SetAttackTime (WeaponAttackType att, uint32 val)

void	ApplyAttackTimePercentMod (WeaponAttackType att, float val, bool apply)

void	ApplyCastTimePercentMod (float val, bool apply)

UnitFlags	GetUnitFlags () const

bool	HasUnitFlag (UnitFlags flags) const

void	SetUnitFlag (UnitFlags flags)

void	RemoveUnitFlag (UnitFlags flags)

void	ReplaceAllUnitFlags (UnitFlags flags)

UnitFlags2	GetUnitFlags2 () const

bool	HasUnitFlag2 (UnitFlags2 flags) const

void	SetUnitFlag2 (UnitFlags2 flags)

void	RemoveUnitFlag2 (UnitFlags2 flags)

void	ReplaceAllUnitFlags2 (UnitFlags2 flags)

SheathState	GetSheath () const

virtual void	SetSheath (SheathState sheathed)

uint32	GetFaction () const

void	SetFaction (uint32 faction)

FactionTemplateEntry const *	GetFactionTemplateEntry () const

ReputationRank	GetReactionTo (Unit const *target, bool checkOriginalFaction=false) const

ReputationRank	GetFactionReactionTo (FactionTemplateEntry const factionTemplateEntry, Unit const target) const

bool	IsHostileTo (Unit const *unit) const

bool	IsHostileToPlayers () const

bool	IsFriendlyTo (Unit const *unit) const

bool	IsNeutralToAll () const

bool	IsInPartyWith (Unit const *unit) const

bool	IsInRaidWith (Unit const *unit) const

void	GetPartyMembers (std::list< Unit * > &units)

bool	IsContestedGuard () const

bool	IsInSanctuary () const

bool	IsPvP () const

bool	IsFFAPvP () const

void	SetPvP (bool state)

uint32	GetCreatureType () const

uint32	GetCreatureTypeMask () const

uint8	getStandState () const

bool	IsSitState () const

bool	IsStandState () const

void	SetStandState (uint8 state)

void	SetStandFlags (uint8 flags)

void	RemoveStandFlags (uint8 flags)

bool	IsMounted () const

uint32	GetMountID () const

void	Mount (uint32 mount, uint32 vehicleId=0, uint32 creatureEntry=0)

void	Dismount ()

uint16	GetMaxSkillValueForLevel (Unit const *target=nullptr) const

void	KillSelf (bool durabilityLoss=true, WeaponAttackType attackType=BASE_ATTACK, SpellInfo const spellProto=nullptr, Spell const spell=nullptr)

void	ProcDamageAndSpellFor (bool isVictim, Unit target, uint32 procFlag, uint32 procExtra, WeaponAttackType attType, SpellInfo const procSpellInfo, uint32 damage, SpellInfo const procAura=nullptr, int8 procAuraEffectIndex=-1, Spell const procSpell=nullptr, DamageInfo damageInfo=nullptr, HealInfo healInfo=nullptr, uint32 procPhase=2)

void	GetProcAurasTriggeredOnEvent (std::list< AuraApplication * > &aurasTriggeringProc, std::list< AuraApplication * > *procAuras, ProcEventInfo eventInfo)

void	TriggerAurasProcOnEvent (CalcDamageInfo &damageInfo)

void	TriggerAurasProcOnEvent (std::list< AuraApplication * > myProcAuras, std::list< AuraApplication > targetProcAuras, Unit actionTarget, uint32 typeMaskActor, uint32 typeMaskActionTarget, uint32 spellTypeMask, uint32 spellPhaseMask, uint32 hitMask, Spell spell, DamageInfo damageInfo, HealInfo *healInfo)

void	TriggerAurasProcOnEvent (ProcEventInfo &eventInfo, std::list< AuraApplication * > &procAuras)

void	HandleEmoteCommand (uint32 emoteId)

void	AttackerStateUpdate (Unit *victim, WeaponAttackType attType=BASE_ATTACK, bool extra=false, bool ignoreCasting=false)

void	CalculateMeleeDamage (Unit victim, CalcDamageInfo damageInfo, WeaponAttackType attackType=BASE_ATTACK, const bool sittingVictim=false)

void	DealMeleeDamage (CalcDamageInfo *damageInfo, bool durabilityLoss)

void	HandleProcExtraAttackFor (Unit *victim, uint32 count)

void	SetLastExtraAttackSpell (uint32 spellId)

uint32	GetLastExtraAttackSpell () const

void	AddExtraAttacks (uint32 count)

void	SetLastDamagedTargetGuid (ObjectGuid const &guid)

ObjectGuid const &	GetLastDamagedTargetGuid () const

void	CalculateSpellDamageTaken (SpellNonMeleeDamage damageInfo, int32 damage, SpellInfo const spellInfo, WeaponAttackType attackType=BASE_ATTACK, bool crit=false)

void	DealSpellDamage (SpellNonMeleeDamage damageInfo, bool durabilityLoss, Spell const spell=nullptr)

float	GetMeleeCritChanceReduction () const

float	GetRangedCritChanceReduction () const

float	GetSpellCritChanceReduction () const

uint32	GetMeleeCritDamageReduction (uint32 damage) const

uint32	GetRangedCritDamageReduction (uint32 damage) const

uint32	GetSpellCritDamageReduction (uint32 damage) const

uint32	GetMeleeDamageReduction (uint32 damage) const

uint32	GetRangedDamageReduction (uint32 damage) const

uint32	GetSpellDamageReduction (uint32 damage) const

float	MeleeSpellMissChance (Unit const *victim, WeaponAttackType attType, int32 skillDiff, uint32 spellId) const

SpellMissInfo	MeleeSpellHitResult (Unit victim, SpellInfo const spell)

SpellMissInfo	MagicSpellHitResult (Unit victim, SpellInfo const spell)

SpellMissInfo	SpellHitResult (Unit victim, SpellInfo const spell, bool canReflect=false)

SpellMissInfo	SpellHitResult (Unit victim, Spell const spell, bool canReflect=false)

float	GetUnitDodgeChance () const

float	GetUnitParryChance () const

float	GetUnitBlockChance () const

float	GetUnitMissChance (WeaponAttackType attType) const

float	GetUnitCriticalChance (WeaponAttackType attackType, Unit const *victim) const

int32	GetMechanicResistChance (SpellInfo const *spell)

bool	CanUseAttackType (uint8 attacktype) const

virtual uint32	GetShieldBlockValue () const =0

uint32	GetShieldBlockValue (uint32 soft_cap, uint32 hard_cap) const

uint32	GetUnitMeleeSkill (Unit const *target=nullptr) const

uint32	GetDefenseSkillValue (Unit const *target=nullptr) const

uint32	GetWeaponSkillValue (WeaponAttackType attType, Unit const *target=nullptr) const

float	GetWeaponProcChance () const

float	GetPPMProcChance (uint32 WeaponSpeed, float PPM, SpellInfo const *spellProto) const

MeleeHitOutcome	RollMeleeOutcomeAgainst (Unit const *victim, WeaponAttackType attType) const

MeleeHitOutcome	RollMeleeOutcomeAgainst (Unit const *victim, WeaponAttackType attType, int32 crit_chance, int32 miss_chance, int32 dodge_chance, int32 parry_chance, int32 block_chance) const

NPCFlags	GetNpcFlags () const

bool	HasNpcFlag (NPCFlags flags) const

void	SetNpcFlag (NPCFlags flags)

void	RemoveNpcFlag (NPCFlags flags)

void	ReplaceAllNpcFlags (NPCFlags flags)

bool	IsVendor () const

bool	IsTrainer () const

bool	IsQuestGiver () const

bool	IsGossip () const

bool	IsTaxi () const

bool	IsGuildMaster () const

bool	IsBattleMaster () const

bool	IsBanker () const

bool	IsInnkeeper () const

bool	IsSpiritHealer () const

bool	IsSpiritGuide () const

bool	IsTabardDesigner () const

bool	IsAuctioner () const

bool	IsArmorer () const

bool	IsServiceProvider () const

bool	IsSpiritService () const

bool	IsCritter () const

bool	IsInFlight () const

void	SetImmuneToAll (bool apply, bool keepCombat=false)

bool	IsImmuneToAll () const

void	SetImmuneToPC (bool apply, bool keepCombat=false)

bool	IsImmuneToPC () const

void	SetImmuneToNPC (bool apply, bool keepCombat=false)

bool	IsImmuneToNPC () const

bool	IsEngaged () const

bool	IsEngagedBy (Unit const *who) const

bool	IsInCombat () const

bool	IsInCombatWith (Unit const *who) const

bool	IsPetInCombat () const

void	CombatStart (Unit *target, bool initialAggro=true)

void	CombatStartOnCast (Unit *target, bool initialAggro=true, uint32 duration=0)

void	SetInCombatState (bool PvP, Unit *enemy=nullptr, uint32 duration=0)

void	SetInCombatWith (Unit *enemy, uint32 duration=0)

void	ClearInCombat ()

void	ClearInPetCombat ()

uint32	GetCombatTimer () const

void	SetCombatTimer (uint32 timer)

bool	HasAuraTypeWithFamilyFlags (AuraType auraType, uint32 familyName, uint32 familyFlags) const

virtual bool	HasSpell (uint32) const

bool	HasBreakableByDamageAuraType (AuraType type, uint32 excludeAura=0) const

bool	HasBreakableByDamageCrowdControlAura (Unit *excludeCasterChannel=nullptr) const

bool	HasStealthAura () const

bool	HasInvisibilityAura () const

bool	isFeared () const

bool	isInRoots () const

bool	IsPolymorphed () const

bool	isFrozen () const

bool	isTargetableForAttack (bool checkFakeDeath=true, Unit const *byWho=nullptr) const

bool	IsValidAttackTarget (Unit const target, SpellInfo const bySpell=nullptr) const

bool	_IsValidAttackTarget (Unit const target, SpellInfo const bySpell, WorldObject const *obj=nullptr) const

bool	IsValidAssistTarget (Unit const *target) const

bool	_IsValidAssistTarget (Unit const target, SpellInfo const bySpell) const

virtual bool	IsInWater () const

virtual bool	IsUnderWater () const

bool	isInAccessiblePlaceFor (Creature const *c) const

void	SendHealSpellLog (Unit *victim, uint32 SpellID, uint32 Damage, uint32 OverHeal, uint32 Absorb, bool critical=false)

int32	HealBySpell (HealInfo &healInfo, bool critical=false)

void	SendEnergizeSpellLog (Unit *victim, uint32 SpellID, uint32 Damage, Powers powertype)

void	EnergizeBySpell (Unit *victim, uint32 SpellID, uint32 Damage, Powers powertype)

SpellCastResult	CastSpell (SpellCastTargets const &targets, SpellInfo const spellInfo, CustomSpellValues const value, TriggerCastFlags triggerFlags=TRIGGERED_NONE, Item castItem=nullptr, AuraEffect const triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastSpell (Unit victim, uint32 spellId, bool triggered, Item castItem=nullptr, AuraEffect const *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastSpell (Unit victim, uint32 spellId, TriggerCastFlags triggerFlags=TRIGGERED_NONE, Item castItem=nullptr, AuraEffect const *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastSpell (Unit victim, SpellInfo const spellInfo, bool triggered, Item castItem=nullptr, AuraEffect const triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastSpell (Unit victim, SpellInfo const spellInfo, TriggerCastFlags triggerFlags=TRIGGERED_NONE, Item castItem=nullptr, AuraEffect const triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastSpell (float x, float y, float z, uint32 spellId, bool triggered, Item castItem=nullptr, AuraEffect const triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastSpell (GameObject go, uint32 spellId, bool triggered, Item castItem=nullptr, AuraEffect *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastCustomSpell (Unit victim, uint32 spellId, int32 const bp0, int32 const bp1, int32 const bp2, bool triggered, Item castItem=nullptr, AuraEffect const triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastCustomSpell (uint32 spellId, SpellValueMod mod, int32 value, Unit victim, bool triggered, Item castItem=nullptr, AuraEffect const *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastCustomSpell (uint32 spellId, SpellValueMod mod, int32 value, Unit victim=nullptr, TriggerCastFlags triggerFlags=TRIGGERED_NONE, Item castItem=nullptr, AuraEffect const *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

SpellCastResult	CastCustomSpell (uint32 spellId, CustomSpellValues const &value, Unit victim=nullptr, TriggerCastFlags triggerFlags=TRIGGERED_NONE, Item castItem=nullptr, AuraEffect const *triggeredByAura=nullptr, ObjectGuid originalCaster=ObjectGuid::Empty)

Aura *	AddAura (uint32 spellId, Unit *target)

Aura *	AddAura (SpellInfo const spellInfo, uint8 effMask, Unit target)

void	SetAuraStack (uint32 spellId, Unit *target, uint32 stack)

void	SendPlaySpellVisual (uint32 id)

void	SendPlaySpellImpact (ObjectGuid guid, uint32 id)

void	BuildCooldownPacket (WorldPacket &data, uint8 flags, uint32 spellId, uint32 cooldown)

void	BuildCooldownPacket (WorldPacket &data, uint8 flags, PacketCooldowns const &cooldowns)

void	DeMorph ()

void	SendAttackStateUpdate (CalcDamageInfo *damageInfo)

void	SendAttackStateUpdate (uint32 HitInfo, Unit *target, uint8 SwingType, SpellSchoolMask damageSchoolMask, uint32 Damage, uint32 AbsorbDamage, uint32 Resist, VictimState TargetState, uint32 BlockedAmount)

void	SendSpellNonMeleeDamageLog (SpellNonMeleeDamage *log)

void	SendSpellNonMeleeReflectLog (SpellNonMeleeDamage log, Unit attacker)

void	SendSpellNonMeleeDamageLog (Unit target, SpellInfo const spellInfo, uint32 Damage, SpellSchoolMask damageSchoolMask, uint32 AbsorbedDamage, uint32 Resist, bool PhysicalDamage, uint32 Blocked, bool CriticalHit=false, bool Split=false)

void	SendPeriodicAuraLog (SpellPeriodicAuraLogInfo *pInfo)

void	SendSpellMiss (Unit *target, uint32 spellID, SpellMissInfo missInfo)

void	SendSpellDamageResist (Unit *target, uint32 spellId)

void	SendSpellDamageImmune (Unit *target, uint32 spellId)

void	NearTeleportTo (Position &pos, bool casting=false, bool vehicleTeleport=false, bool withPet=false, bool removeTransport=false)

void	NearTeleportTo (float x, float y, float z, float orientation, bool casting=false, bool vehicleTeleport=false, bool withPet=false, bool removeTransport=false)

void	SendTameFailure (uint8 result)

void	SendTeleportPacket (Position &pos)

virtual bool	UpdatePosition (float x, float y, float z, float ang, bool teleport=false)

bool	UpdatePosition (const Position &pos, bool teleport=false)

void	UpdateOrientation (float orientation)
	Only server-side orientation update, does not broadcast to client.

void	UpdateHeight (float newZ)
	Only server-side height update, does not broadcast to client.

void	KnockbackFrom (float x, float y, float speedXY, float speedZ)

void	JumpTo (float speedXY, float speedZ, bool forward=true)

void	JumpTo (WorldObject *obj, float speedZ)

void	SendMonsterMove (float NewPosX, float NewPosY, float NewPosZ, uint32 TransitTime, SplineFlags sf=SPLINEFLAG_WALK_MODE)

void	MonsterMoveWithSpeed (float x, float y, float z, float speed)

void	SendMovementFlagUpdate (bool self=false)

virtual bool	SetWalk (bool enable)

virtual bool	SetDisableGravity (bool disable, bool packetOnly=false, bool updateAnimationTier=true)

virtual bool	SetSwim (bool enable)

virtual bool	SetCanFly (bool enable, bool packetOnly=false)

virtual bool	SetWaterWalking (bool enable, bool packetOnly=false)

virtual bool	SetFeatherFall (bool enable, bool packetOnly=false)

virtual bool	SetHover (bool enable, bool packetOnly=false, bool updateAnimationTier=true)

void	SendMovementWaterWalking (Player *sendTo)

void	SendMovementFeatherFall (Player *sendTo)

void	SendMovementHover (Player *sendTo)

void	SetInFront (WorldObject const *target)

void	SetFacingTo (float ori)

void	SetFacingToObject (WorldObject *object)

void	SendChangeCurrentVictimOpcode (HostileReference *pHostileReference)

void	SendClearThreatListOpcode ()

void	SendRemoveFromThreatListOpcode (HostileReference *pHostileReference)

void	SendThreatListUpdate ()

void	SendClearTarget ()

void	BuildHeartBeatMsg (WorldPacket *data) const

bool	IsAlive () const

bool	isDying () const

bool	isDead () const

DeathState	getDeathState ()

virtual void	setDeathState (DeathState s, bool despawn=false)

ObjectGuid	GetOwnerGUID () const

void	SetOwnerGUID (ObjectGuid owner)

ObjectGuid	GetCreatorGUID () const

void	SetCreatorGUID (ObjectGuid creator)

ObjectGuid	GetMinionGUID () const

void	SetMinionGUID (ObjectGuid guid)

ObjectGuid	GetCharmerGUID () const

void	SetCharmerGUID (ObjectGuid owner)

ObjectGuid	GetCharmGUID () const

void	SetPetGUID (ObjectGuid guid)

ObjectGuid	GetPetGUID () const

void	SetCritterGUID (ObjectGuid guid)

ObjectGuid	GetCritterGUID () const

bool	IsControlledByPlayer () const

bool	IsCreatedByPlayer () const

ObjectGuid	GetCharmerOrOwnerGUID () const

ObjectGuid	GetCharmerOrOwnerOrOwnGUID () const

bool	IsCharmedOwnedByPlayerOrPlayer () const

Player *	GetSpellModOwner () const

Unit *	GetOwner () const

Guardian *	GetGuardianPet () const

Minion *	GetFirstMinion () const

Unit *	GetCharmer () const

Unit *	GetCharm () const

Unit *	GetCharmerOrOwner () const

Unit *	GetCharmerOrOwnerOrSelf () const

Player *	GetCharmerOrOwnerPlayerOrPlayerItself () const

Player *	GetAffectingPlayer () const

void	SetMinion (Minion *minion, bool apply)

void	GetAllMinionsByEntry (std::list< Creature * > &Minions, uint32 entry)

void	RemoveAllMinionsByEntry (uint32 entry)

void	SetCharm (Unit *target, bool apply)

Unit *	GetNextRandomRaidMemberOrPet (float radius)

bool	SetCharmedBy (Unit charmer, CharmType type, AuraApplication const aurApp=nullptr)

void	RemoveCharmedBy (Unit *charmer)

void	RestoreFaction ()

Unit *	GetFirstControlled () const

void	RemoveAllControlled (bool onDeath=false)

bool	IsCharmed () const

bool	isPossessed () const

bool	isPossessedByPlayer () const

bool	isPossessing () const

bool	isPossessing (Unit *u) const

CharmInfo *	GetCharmInfo ()

CharmInfo *	InitCharmInfo ()

void	DeleteCharmInfo ()

void	UpdateCharmAI ()

SharedVisionList const &	GetSharedVisionList ()

void	AddPlayerToVision (Player *player)

void	RemovePlayerFromVision (Player *player)

bool	HasSharedVision () const

void	RemoveBindSightAuras ()

void	RemoveCharmAuras ()

Pet *	CreateTamedPetFrom (Creature *creatureTarget, uint32 spell_id=0)

Pet *	CreateTamedPetFrom (uint32 creatureEntry, uint32 spell_id=0)

bool	InitTamedPet (Pet *pet, uint8 level, uint32 spell_id)

Aura *	_TryStackingOrRefreshingExistingAura (SpellInfo const newAura, uint8 effMask, Unit caster, int32 baseAmount=nullptr, Item castItem=nullptr, ObjectGuid casterGUID=ObjectGuid::Empty, bool periodicReset=false)

void	_AddAura (UnitAura aura, Unit caster)

AuraApplication *	_CreateAuraApplication (Aura *aura, uint8 effMask)

void	_ApplyAuraEffect (Aura *aura, uint8 effIndex)

void	_ApplyAura (AuraApplication *aurApp, uint8 effMask)

void	_UnapplyAura (AuraApplicationMap::iterator &i, AuraRemoveMode removeMode)

void	_UnapplyAura (AuraApplication *aurApp, AuraRemoveMode removeMode)

void	_RemoveNoStackAuraApplicationsDueToAura (Aura *aura)

void	_RemoveNoStackAurasDueToAura (Aura *aura)

bool	_IsNoStackAuraDueToAura (Aura appliedAura, Aura existingAura) const

void	_RegisterAuraEffect (AuraEffect *aurEff, bool apply)

AuraMap &	GetOwnedAuras ()

AuraMap const &	GetOwnedAuras () const

void	RemoveOwnedAura (AuraMap::iterator &i, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

void	RemoveOwnedAura (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

void	RemoveOwnedAura (Aura *aura, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

Aura *	GetOwnedAura (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, Aura *except=nullptr) const

AuraApplicationMap &	GetAppliedAuras ()

AuraApplicationMap const &	GetAppliedAuras () const

void	RemoveAura (AuraApplicationMap::iterator &i, AuraRemoveMode mode=AURA_REMOVE_BY_DEFAULT)

void	RemoveAura (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

void	RemoveAura (AuraApplication *aurApp, AuraRemoveMode mode=AURA_REMOVE_BY_DEFAULT)

void	RemoveAura (Aura *aur, AuraRemoveMode mode=AURA_REMOVE_BY_DEFAULT)

void	RemoveAppliedAuras (std::function< bool(AuraApplication const *)> const &check)

void	RemoveOwnedAuras (std::function< bool(Aura const *)> const &check)

void	RemoveAppliedAuras (uint32 spellId, std::function< bool(AuraApplication const *)> const &check)

void	RemoveOwnedAuras (uint32 spellId, std::function< bool(Aura const *)> const &check)

void	RemoveAurasDueToSpell (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

void	RemoveAuraFromStack (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, AuraRemoveMode removeMode=AURA_REMOVE_BY_DEFAULT)

void	RemoveAurasDueToSpellByDispel (uint32 spellId, uint32 dispellerSpellId, ObjectGuid casterGUID, Unit *dispeller, uint8 chargesRemoved=1)

void	RemoveAurasDueToSpellBySteal (uint32 spellId, ObjectGuid casterGUID, Unit *stealer)

void	RemoveAurasDueToItemSpell (uint32 spellId, ObjectGuid castItemGuid)

void	RemoveAurasByType (AuraType auraType, ObjectGuid casterGUID=ObjectGuid::Empty, Aura *except=nullptr, bool negative=true, bool positive=true)

void	RemoveNotOwnSingleTargetAuras ()

void	RemoveAurasWithInterruptFlags (uint32 flag, uint32 except=0, bool isAutoshot=false)

void	RemoveAurasWithAttribute (uint32 flags)

void	RemoveAurasWithFamily (SpellFamilyNames family, uint32 familyFlag1, uint32 familyFlag2, uint32 familyFlag3, ObjectGuid casterGUID)

void	RemoveAurasWithMechanic (uint32 mechanic_mask, AuraRemoveMode removemode=AURA_REMOVE_BY_DEFAULT, uint32 except=0)

void	RemoveMovementImpairingAuras (bool withRoot)

void	RemoveAurasByShapeShift ()

void	RemoveAreaAurasDueToLeaveWorld ()

void	RemoveAllAuras ()

void	RemoveArenaAuras ()

void	RemoveAllAurasOnDeath ()

void	RemoveAllAurasRequiringDeadTarget ()

void	RemoveAllAurasExceptType (AuraType type)

void	RemoveEvadeAuras ()

void	DelayOwnedAuras (uint32 spellId, ObjectGuid caster, int32 delaytime)

void	_RemoveAllAuraStatMods ()

void	_ApplyAllAuraStatMods ()

AuraEffectList const &	GetAuraEffectsByType (AuraType type) const

AuraList &	GetSingleCastAuras ()

AuraList const &	GetSingleCastAuras () const

AuraEffect *	GetAuraEffect (uint32 spellId, uint8 effIndex, ObjectGuid casterGUID=ObjectGuid::Empty) const

AuraEffect *	GetAuraEffectOfRankedSpell (uint32 spellId, uint8 effIndex, ObjectGuid casterGUID=ObjectGuid::Empty) const

AuraEffect *	GetAuraEffect (AuraType type, SpellFamilyNames name, uint32 iconId, uint8 effIndex) const

AuraEffect *	GetAuraEffect (AuraType type, SpellFamilyNames family, uint32 familyFlag1, uint32 familyFlag2, uint32 familyFlag3, ObjectGuid casterGUID=ObjectGuid::Empty) const

AuraEffect *	GetAuraEffectDummy (uint32 spellid) const

AuraEffect *	GetDummyAuraEffect (SpellFamilyNames name, uint32 iconId, uint8 effIndex) const

AuraApplication *	GetAuraApplication (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, AuraApplication *except=nullptr) const

Aura *	GetAura (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0) const

AuraApplication *	GetAuraApplicationOfRankedSpell (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0, AuraApplication *except=nullptr) const

Aura *	GetAuraOfRankedSpell (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0) const

void	GetDispellableAuraList (Unit *caster, uint32 dispelMask, DispelChargesList &dispelList)

bool	HasAuraEffect (uint32 spellId, uint8 effIndex, ObjectGuid caster=ObjectGuid::Empty) const

uint32	GetAuraCount (uint32 spellId) const

bool	HasAura (uint32 spellId, ObjectGuid casterGUID=ObjectGuid::Empty, ObjectGuid itemCasterGUID=ObjectGuid::Empty, uint8 reqEffMask=0) const

bool	HasAuraType (AuraType auraType) const

bool	HasAuraTypeWithCaster (AuraType auratype, ObjectGuid caster) const

bool	HasAuraTypeWithMiscvalue (AuraType auratype, int32 miscvalue) const

bool	HasAuraTypeWithAffectMask (AuraType auratype, SpellInfo const *affectedSpell) const

bool	HasAuraTypeWithValue (AuraType auratype, int32 value) const

bool	HasAuraTypeWithTriggerSpell (AuraType auratype, uint32 triggerSpell) const

bool	HasNegativeAuraWithInterruptFlag (uint32 flag, ObjectGuid guid=ObjectGuid::Empty)

bool	HasVisibleAuraType (AuraType auraType) const

bool	HasNegativeAuraWithAttribute (uint32 flag, ObjectGuid guid=ObjectGuid::Empty)

bool	HasAuraWithMechanic (uint32 mechanicMask) const

AuraEffect *	IsScriptOverriden (SpellInfo const *spell, int32 script) const

uint32	GetDiseasesByCaster (ObjectGuid casterGUID, uint8 mode=0)

uint32	GetDoTsByCaster (ObjectGuid casterGUID) const

int32	GetTotalAuraModifierAreaExclusive (AuraType auratype) const

int32	GetTotalAuraModifier (AuraType auratype) const

float	GetTotalAuraMultiplier (AuraType auratype) const

int32	GetMaxPositiveAuraModifier (AuraType auratype)

int32	GetMaxNegativeAuraModifier (AuraType auratype) const

int32	GetTotalAuraModifierByMiscMask (AuraType auratype, uint32 misc_mask) const

float	GetTotalAuraMultiplierByMiscMask (AuraType auratype, uint32 misc_mask) const

int32	GetMaxPositiveAuraModifierByMiscMask (AuraType auratype, uint32 misc_mask, const AuraEffect *except=nullptr) const

int32	GetMaxNegativeAuraModifierByMiscMask (AuraType auratype, uint32 misc_mask) const

int32	GetTotalAuraModifierByMiscValue (AuraType auratype, int32 misc_value) const

float	GetTotalAuraMultiplierByMiscValue (AuraType auratype, int32 misc_value) const

int32	GetMaxPositiveAuraModifierByMiscValue (AuraType auratype, int32 misc_value) const

int32	GetMaxNegativeAuraModifierByMiscValue (AuraType auratype, int32 misc_value) const

int32	GetTotalAuraModifierByAffectMask (AuraType auratype, SpellInfo const *affectedSpell) const

float	GetTotalAuraMultiplierByAffectMask (AuraType auratype, SpellInfo const *affectedSpell) const

int32	GetMaxPositiveAuraModifierByAffectMask (AuraType auratype, SpellInfo const *affectedSpell) const

int32	GetMaxNegativeAuraModifierByAffectMask (AuraType auratype, SpellInfo const *affectedSpell) const

float	GetResistanceBuffMods (SpellSchools school, bool positive) const

void	SetResistanceBuffMods (SpellSchools school, bool positive, float val)

void	ApplyResistanceBuffModsMod (SpellSchools school, bool positive, float val, bool apply)

void	ApplyResistanceBuffModsPercentMod (SpellSchools school, bool positive, float val, bool apply)

void	InitStatBuffMods ()

void	ApplyStatBuffMod (Stats stat, float val, bool apply)

void	ApplyStatPercentBuffMod (Stats stat, float val, bool apply)

void	SetCreateStat (Stats stat, float val)

void	SetCreateHealth (uint32 val)

uint32	GetCreateHealth () const

void	SetCreateMana (uint32 val)

uint32	GetCreateMana () const

uint32	GetCreatePowers (Powers power) const

float	GetPosStat (Stats stat) const

float	GetNegStat (Stats stat) const

float	GetCreateStat (Stats stat) const

void	SetCurrentCastedSpell (Spell *pSpell)

virtual void	ProhibitSpellSchool (SpellSchoolMask, uint32)

void	InterruptSpell (CurrentSpellTypes spellType, bool withDelayed=true, bool withInstant=true, bool bySelf=false)

void	FinishSpell (CurrentSpellTypes spellType, bool ok=true)

bool	IsNonMeleeSpellCast (bool withDelayed, bool skipChanneled=false, bool skipAutorepeat=false, bool isAutoshoot=false, bool skipInstant=true) const

void	InterruptNonMeleeSpells (bool withDelayed, uint32 spellid=0, bool withInstant=true, bool bySelf=false)

Spell *	GetCurrentSpell (CurrentSpellTypes spellType) const

Spell *	GetCurrentSpell (uint32 spellType) const

Spell *	FindCurrentSpellBySpellId (uint32 spell_id) const

int32	GetCurrentSpellCastTime (uint32 spell_id) const

virtual bool	IsMovementPreventedByCasting () const

ShapeshiftForm	GetShapeshiftForm () const

void	SetShapeshiftForm (ShapeshiftForm form)

bool	IsInFeralForm () const

bool	IsInDisallowedMountForm () const

bool	HandleStatModifier (UnitMods unitMod, UnitModifierType modifierType, float amount, bool apply)

void	SetModifierValue (UnitMods unitMod, UnitModifierType modifierType, float value)

float	GetModifierValue (UnitMods unitMod, UnitModifierType modifierType) const

float	GetTotalStatValue (Stats stat, float additionalValue=0.0f) const

float	GetTotalAuraModValue (UnitMods unitMod) const

SpellSchools	GetSpellSchoolByAuraGroup (UnitMods unitMod) const

Stats	GetStatByAuraGroup (UnitMods unitMod) const

Powers	GetPowerTypeByAuraGroup (UnitMods unitMod) const

bool	CanModifyStats () const

void	SetCanModifyStats (bool modifyStats)

virtual bool	UpdateStats (Stats stat)=0

virtual bool	UpdateAllStats ()=0

virtual void	UpdateResistances (uint32 school)=0

virtual void	UpdateAllResistances ()

virtual void	UpdateArmor ()=0

virtual void	UpdateMaxHealth ()=0

virtual void	UpdateMaxPower (Powers power)=0

virtual void	UpdateAttackPowerAndDamage (bool ranged=false)=0

virtual void	UpdateDamagePhysical (WeaponAttackType attType)

float	GetTotalAttackPowerValue (WeaponAttackType attType, Unit *pVictim=nullptr) const

float	GetWeaponDamageRange (WeaponAttackType attType, WeaponDamageRange type, uint8 damageIndex=0) const

void	SetBaseWeaponDamage (WeaponAttackType attType, WeaponDamageRange damageRange, float value, uint8 damageIndex=0)

virtual void	CalculateMinMaxDamage (WeaponAttackType attType, bool normalized, bool addTotalPct, float &minDamage, float &maxDamage, uint8 damageIndex=0)=0

uint32	CalculateDamage (WeaponAttackType attType, bool normalized, bool addTotalPct, uint8 itemDamagesMask=0)

float	GetAPMultiplier (WeaponAttackType attType, bool normalized)

bool	isInFrontInMap (Unit const *target, float distance, float arc=M_PI) const

bool	isInBackInMap (Unit const *target, float distance, float arc=M_PI) const

bool	IsVisible () const

void	SetVisible (bool x)

void	SetModelVisible (bool on)

uint32	GetPhaseByAuras () const

void	SetPhaseMask (uint32 newPhaseMask, bool update) override

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

bool	CanHaveThreatList () const

void	AddThreat (Unit victim, float fThreat, SpellSchoolMask schoolMask=SPELL_SCHOOL_MASK_NORMAL, SpellInfo const threatSpell=nullptr)

float	ApplyTotalThreatModifier (float fThreat, SpellSchoolMask schoolMask=SPELL_SCHOOL_MASK_NORMAL)

void	TauntApply (Unit *victim)

void	TauntFadeOut (Unit *taunter)

ThreatMgr &	GetThreatMgr ()

ThreatMgr const &	GetThreatMgr () const

void	addHatedBy (HostileReference *pHostileReference)

void	removeHatedBy (HostileReference *)

HostileRefMgr &	getHostileRefMgr ()

VisibleAuraMap const *	GetVisibleAuras ()

AuraApplication *	GetVisibleAura (uint8 slot)

void	SetVisibleAura (uint8 slot, AuraApplication *aur)

void	RemoveVisibleAura (uint8 slot)

uint32	GetInterruptMask () const

void	AddInterruptMask (uint32 mask)

void	UpdateInterruptMask ()

virtual float	GetNativeObjectScale () const

virtual void	RecalculateObjectScale ()

uint32	GetDisplayId () const

virtual void	SetDisplayId (uint32 modelId)

uint32	GetNativeDisplayId () const

void	RestoreDisplayId ()

void	SetNativeDisplayId (uint32 modelId)

void	setTransForm (uint32 spellid)

uint32	getTransForm () const

void	_RegisterDynObject (DynamicObject *dynObj)

void	_UnregisterDynObject (DynamicObject *dynObj)

DynamicObject *	GetDynObject (uint32 spellId)

bool	RemoveDynObject (uint32 spellId)

void	RemoveAllDynObjects ()

GameObject *	GetGameObject (uint32 spellId) const

void	AddGameObject (GameObject *gameObj)

void	RemoveGameObject (GameObject *gameObj, bool del)

void	RemoveGameObject (uint32 spellid, bool del)

void	RemoveAllGameObjects ()

void	ModifyAuraState (AuraStateType flag, bool apply)

uint32	BuildAuraStateUpdateForTarget (Unit *target) const

bool	HasAuraState (AuraStateType flag, SpellInfo const spellProto=nullptr, Unit const Caster=nullptr) const

void	UnsummonAllTotems (bool onDeath=false)

Unit *	GetMagicHitRedirectTarget (Unit victim, SpellInfo const spellInfo)

Unit *	GetMeleeHitRedirectTarget (Unit victim, SpellInfo const spellInfo=nullptr)

int32	SpellBaseDamageBonusDone (SpellSchoolMask schoolMask)

int32	SpellBaseDamageBonusTaken (SpellSchoolMask schoolMask, bool isDoT=false)

float	SpellPctDamageModsDone (Unit victim, SpellInfo const spellProto, DamageEffectType damagetype)

uint32	SpellDamageBonusDone (Unit victim, SpellInfo const spellProto, uint32 pdamage, DamageEffectType damagetype, uint8 effIndex, float TotalMod=0.0f, uint32 stack=1)

uint32	SpellDamageBonusTaken (Unit caster, SpellInfo const spellProto, uint32 pdamage, DamageEffectType damagetype, uint32 stack=1)

int32	SpellBaseHealingBonusDone (SpellSchoolMask schoolMask)

int32	SpellBaseHealingBonusTaken (SpellSchoolMask schoolMask)

float	SpellPctHealingModsDone (Unit victim, SpellInfo const spellProto, DamageEffectType damagetype)

uint32	SpellHealingBonusDone (Unit victim, SpellInfo const spellProto, uint32 healamount, DamageEffectType damagetype, uint8 effIndex, float TotalMod=0.0f, uint32 stack=1)

uint32	SpellHealingBonusTaken (Unit caster, SpellInfo const spellProto, uint32 healamount, DamageEffectType damagetype, uint32 stack=1)

uint32	MeleeDamageBonusDone (Unit pVictim, uint32 damage, WeaponAttackType attType, SpellInfo const spellProto=nullptr, SpellSchoolMask damageSchoolMask=SPELL_SCHOOL_MASK_NORMAL)

uint32	MeleeDamageBonusTaken (Unit attacker, uint32 pdamage, WeaponAttackType attType, SpellInfo const spellProto=nullptr, SpellSchoolMask damageSchoolMask=SPELL_SCHOOL_MASK_NORMAL)

bool	isSpellBlocked (Unit victim, SpellInfo const spellProto, WeaponAttackType attackType=BASE_ATTACK)

bool	isBlockCritical ()

float	SpellDoneCritChance (Unit const , SpellInfo const spellProto, SpellSchoolMask schoolMask, WeaponAttackType attackType, bool skipEffectCheck) const

float	SpellTakenCritChance (Unit const caster, SpellInfo const spellProto, SpellSchoolMask schoolMask, float doneChance, WeaponAttackType attackType, bool skipEffectCheck) const

void	SetLastManaUse (uint32 spellCastTime)

bool	IsUnderLastManaUseEffect () const

void	SetContestedPvP (Player *attackedPlayer=nullptr, bool lookForNearContestedGuards=true)

uint32	GetCastingTimeForBonus (SpellInfo const *spellProto, DamageEffectType damagetype, uint32 CastingTime) const

float	CalculateDefaultCoefficient (SpellInfo const *spellInfo, DamageEffectType damagetype) const

void	CastDelayedSpellWithPeriodicAmount (Unit *caster, uint32 spellId, AuraType auraType, int32 addAmount, uint8 effectIndex=0)

void	ApplySpellImmune (uint32 spellId, uint32 op, uint32 type, bool apply, SpellImmuneBlockType blockType=SPELL_BLOCK_TYPE_ALL)

void	ApplySpellDispelImmunity (SpellInfo const *spellProto, DispelType type, bool apply)

virtual bool	IsImmunedToSpell (SpellInfo const spellInfo, Spell const spell=nullptr)

bool	IsImmunedToDamage (SpellSchoolMask meleeSchoolMask) const

bool	IsImmunedToDamage (SpellInfo const *spellInfo) const

bool	IsImmunedToDamage (Spell const *spell) const

bool	IsImmunedToSchool (SpellSchoolMask meleeSchoolMask) const

bool	IsImmunedToSchool (SpellInfo const *spellInfo) const

bool	IsImmunedToSchool (Spell const *spell) const

bool	IsImmunedToDamageOrSchool (SpellSchoolMask meleeSchoolMask) const

bool	IsImmunedToDamageOrSchool (SpellInfo const *spellInfo) const

virtual bool	IsImmunedToSpellEffect (SpellInfo const *spellInfo, uint32 index) const

void	UpdateSpeed (UnitMoveType mtype, bool forced)

float	GetSpeed (UnitMoveType mtype) const

float	GetSpeedRate (UnitMoveType mtype) const

void	SetSpeed (UnitMoveType mtype, float rate, bool forced=false)

void	SetSpeedRate (UnitMoveType mtype, float rate)

float	ApplyEffectModifiers (SpellInfo const *spellProto, uint8 effect_index, float value) const

int32	CalculateSpellDamage (Unit const target, SpellInfo const spellProto, uint8 effect_index, int32 const *basePoints=nullptr) const

int32	CalcSpellDuration (SpellInfo const *spellProto)

int32	ModSpellDuration (SpellInfo const spellProto, Unit const target, int32 duration, bool positive, uint32 effectMask)

void	ModSpellCastTime (SpellInfo const spellProto, int32 &castTime, Spell spell=nullptr)

float	CalculateLevelPenalty (SpellInfo const *spellProto) const

void	addFollower (FollowerReference *pRef)

void	removeFollower (FollowerReference *)

MotionMaster *	GetMotionMaster ()

const MotionMaster *	GetMotionMaster () const

virtual MovementGeneratorType	GetDefaultMovementType () const
	-------—End of Pet responses methods-------—

bool	IsStopped () const

void	StopMoving ()

void	StopMovingOnCurrentPos ()

virtual void	PauseMovement (uint32 timer=0, uint8 slot=0)

void	ResumeMovement (uint32 timer=0, uint8 slot=0)

void	AddUnitMovementFlag (uint32 f)

void	RemoveUnitMovementFlag (uint32 f)

bool	HasUnitMovementFlag (uint32 f) const

uint32	GetUnitMovementFlags () const

void	SetUnitMovementFlags (uint32 f)

void	AddExtraUnitMovementFlag (uint16 f)

void	RemoveExtraUnitMovementFlag (uint16 f)

uint16	HasExtraUnitMovementFlag (uint16 f) const

uint16	GetExtraUnitMovementFlags () const

void	SetExtraUnitMovementFlags (uint16 f)

void	SetControlled (bool apply, UnitState state, Unit *source=nullptr, bool isFear=false)

void	DisableRotate (bool apply)

void	DisableSpline ()

uint8	GetComboPoints (Unit const *who=nullptr) const
	--------—Combo point system----------------—

uint8	GetComboPoints (ObjectGuid const &guid) const

Unit *	GetComboTarget () const

ObjectGuid const	GetComboTargetGUID () const

void	AddComboPoints (Unit *target, int8 count)

void	AddComboPoints (int8 count)

void	ClearComboPoints ()

void	SendComboPoints ()

void	AddComboPointHolder (Unit *unit)

void	RemoveComboPointHolder (Unit *unit)

void	ClearComboPointHolders ()

void	SendPetActionFeedback (uint8 msg)
	-------—Pet responses methods--------------—

void	SendPetTalk (uint32 pettalk)

void	SendPetAIReaction (ObjectGuid guid)

void	propagateSpeedChange ()
	-------—End of Pet responses methods-------—

void	ClearAllReactives ()

void	StartReactiveTimer (ReactiveType reactive)

void	UpdateReactives (uint32 p_time)

void	UpdateAuraForGroup (uint8 slot)

bool	CanProc ()

void	SetCantProc (bool apply)

void	AddPetAura (PetAura const *petSpell)

void	RemovePetAura (PetAura const *petSpell)

void	CastPetAura (PetAura const *aura)

bool	IsPetAura (Aura const *aura)

uint32	GetModelForForm (ShapeshiftForm form, uint32 spellId) const

uint32	GetModelForTotem (PlayerTotemType totemType)

void	SetRedirectThreat (ObjectGuid guid, uint32 pct)

void	ResetRedirectThreat ()

void	ModifyRedirectThreat (int32 amount)

uint32	GetRedirectThreatPercent ()

Unit *	GetRedirectThreatTarget () const

bool	CreateVehicleKit (uint32 id, uint32 creatureEntry)

void	RemoveVehicleKit ()

Vehicle *	GetVehicleKit () const

Vehicle *	GetVehicle () const

bool	IsOnVehicle (Unit const *vehicle) const

Unit *	GetVehicleBase () const

Creature *	GetVehicleCreatureBase () const

ObjectGuid	GetTransGUID () const override

TransportBase *	GetDirectTransport () const
	Returns the transport this unit is on directly (if on vehicle and transport, return vehicle)

bool	HandleSpellClick (Unit *clicker, int8 seatId=-1)

void	EnterVehicle (Unit *base, int8 seatId=-1)

void	EnterVehicleUnattackable (Unit *base, int8 seatId=-1)

void	ExitVehicle (Position const *exitPosition=nullptr)

void	ChangeSeat (int8 seatId, bool next=true)

void	_ExitVehicle (Position const *exitPosition=nullptr)

void	_EnterVehicle (Vehicle vehicle, int8 seatId, AuraApplication const aurApp=nullptr)

void	BuildMovementPacket (ByteBuffer *data) const

virtual bool	CanSwim () const
	this method checks the current flag of a unit

bool	IsLevitating () const

bool	IsWalking () const

bool	isMoving () const

bool	isTurning () const

bool	IsHovering () const

bool	isSwimming () const

virtual bool	CanFly () const =0

bool	IsFlying () const

bool	IsFalling () const

float	GetHoverHeight () const

virtual bool	CanEnterWater () const =0

void	RewardRage (uint32 damage, uint32 weaponSpeedHitFactor, bool attacker)

virtual float	GetFollowAngle () const

void	OutDebugInfo () const

virtual bool	isBeingLoaded () const

bool	IsDuringRemoveFromWorld () const

Pet *	ToPet ()

Totem *	ToTotem ()

TempSummon *	ToTempSummon ()

const TempSummon *	ToTempSummon () const

void	AddPointedBy (SafeUnitPointer *sup)

void	RemovePointedBy (SafeUnitPointer *sup)

void	ExecuteDelayedUnitRelocationEvent ()

void	ExecuteDelayedUnitAINotifyEvent ()

virtual bool	HasSpellCooldown (uint32) const

virtual bool	HasSpellItemCooldown (uint32, uint32) const

virtual void	AddSpellCooldown (uint32, uint32, uint32, bool needSendToClient=false, bool forceSendToSpectator=false)

bool	CanApplyResilience () const

void	PetSpellFail (SpellInfo const spellInfo, Unit target, uint32 result)

int32	CalculateAOEDamageReduction (int32 damage, uint32 schoolMask, Unit *caster) const

ObjectGuid	GetTarget () const

virtual void	SetTarget (ObjectGuid=ObjectGuid::Empty)=0

void	SetInstantCast (bool set)

bool	CanInstantCast () const

virtual void	Talk (std::string_view text, ChatMsg msgType, Language language, float textRange, WorldObject const *target)

virtual void	Say (std::string_view text, Language language, WorldObject const *target=nullptr)

virtual void	Yell (std::string_view text, Language language, WorldObject const *target=nullptr)

virtual void	TextEmote (std::string_view text, WorldObject const *target=nullptr, bool isBossEmote=false)

virtual void	Whisper (std::string_view text, Language language, Player *target, bool isBossWhisper=false)

virtual void	Talk (uint32 textId, ChatMsg msgType, float textRange, WorldObject const *target)

virtual void	Say (uint32 textId, WorldObject const *target=nullptr)

virtual void	Yell (uint32 textId, WorldObject const *target=nullptr)

virtual void	TextEmote (uint32 textId, WorldObject const *target=nullptr, bool isBossEmote=false)

virtual void	Whisper (uint32 textId, Player *target, bool isBossWhisper=false)

float	GetCollisionHeight () const override
	Return collision height sent to client.

float	GetCollisionWidth () const override
	this method gets the diameter of a Unit by DB if any value is defined, otherwise it gets the value by the DBC

float	GetCollisionRadius () const override
	this method gets the radius of a Unit by DB if any value is defined, otherwise it gets the value by the DBC

void	ProcessPositionDataChanged (PositionFullTerrainStatus const &data) override

virtual void	ProcessTerrainStatusUpdate ()

bool	CanRestoreMana (SpellInfo const *spellInfo) const

std::string	GetDebugInfo () const override

uint32	GetOldFactionId () const

Public Member Functions inherited from WorldObject
	~WorldObject () override

virtual void	Update (uint32)

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

virtual void	SetPhaseMask (uint32 newPhaseMask, bool update)

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)

virtual std::string const &	GetNameForLocaleIdx (LocaleConstant) const

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 useBoundingRadius=true) const

bool	IsWithinDistInMap (WorldObject const *obj, float dist2compare, bool is3D=true, bool useBoundingRadius=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	CleanupsBeforeDelete (bool finalCleanup=true)

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

virtual void	SendMessageToSetInRange (WorldPacket const data, float dist, bool, bool includeMargin=false, Player const skipped_rcvr=nullptr) const

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

virtual uint8	getLevelForTarget (WorldObject const *) const

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

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

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

void	SendObjectDeSpawnAnim (ObjectGuid guid)

virtual void	SaveRespawnTime ()

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)

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	GetCreatureListWithEntryInGrid (std::list< Creature * > &lList, uint32 uiEntry, float fMaxSearchRange) const

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

void	DestroyForNearbyPlayers ()

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

void	BuildUpdate (UpdateDataMapType &data_map, UpdatePlayerSet &player_set) 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)

bool	IsFarVisible () const

bool	IsVisibilityOverridden () const

void	SetVisibilityDistanceOverride (VisibilityDistanceType type)

void	SetWorldObject (bool apply)

bool	IsPermanentWorldObject () const

bool	IsWorldObject () const

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)

virtual float	GetStationaryX () const

virtual float	GetStationaryY () const

virtual float	GetStationaryZ () const

virtual float	GetStationaryO () 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

std::string	GetDebugInfo () const override

Public Member Functions inherited from Object
virtual	~Object ()

bool	IsInWorld () const

virtual void	AddToWorld ()

virtual void	RemoveFromWorld ()

ObjectGuid	GetGUID () const

PackedGuid const &	GetPackGUID () const

uint32	GetEntry () const

void	SetEntry (uint32 entry)

float	GetObjectScale () const

virtual void	SetObjectScale (float scale)

virtual uint32	GetDynamicFlags () const

bool	HasDynamicFlag (uint32 flag) const

virtual void	SetDynamicFlag (uint32 flag)

virtual void	RemoveDynamicFlag (uint32 flag)

virtual void	ReplaceAllDynamicFlags (uint32 flag)

TypeID	GetTypeId () const

bool	isType (uint16 mask) const

virtual void	BuildCreateUpdateBlockForPlayer (UpdateData data, Player target) const

void	SendUpdateToPlayer (Player *player)

void	BuildValuesUpdateBlockForPlayer (UpdateData data, Player target) const

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	ApplyPercentModFloatValue (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

virtual bool	hasQuest (uint32) const

virtual bool	hasInvolvedQuest (uint32) const

virtual void	BuildUpdate (UpdateDataMapType &, UpdatePlayerSet &)

void	BuildFieldsUpdate (Player *, UpdateDataMapType &) const

void	SetFieldNotifyFlag (uint16 flag)

void	RemoveFieldNotifyFlag (uint16 flag)

void	ForceValuesUpdateAtIndex (uint32)

bool	IsPlayer () const

Player *	ToPlayer ()

Player const *	ToPlayer () const

Creature *	ToCreature ()

Creature const *	ToCreature () const

Unit *	ToUnit ()

Unit const *	ToUnit () const

GameObject *	ToGameObject ()

GameObject const *	ToGameObject () const

Corpse *	ToCorpse ()

Corpse const *	ToCorpse () const

DynamicObject *	ToDynObject ()

DynamicObject const *	ToDynObject () const

virtual std::string	GetDebugInfo () 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)

	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

std::string	ToString () const

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

void	AddToGrid (GridRefMgr< Creature > &m)

void	RemoveFromGrid ()

Static Public Member Functions
static std::pair< PetStable::PetInfo const *, PetSaveMode >	GetLoadPetInfo (PetStable const &stable, uint32 petEntry, uint32 petnumber, bool current)

static void	DeleteFromDB (ObjectGuid::LowType guidlow)

static void	resetTalentsForAllPetsOf (Player owner, Pet online_pet=nullptr)

Static Public Member Functions inherited from Creature
static float	_GetDamageMod (int32 Rank)

Static Public Member Functions inherited from Unit
static float	GetEffectiveResistChance (Unit const owner, SpellSchoolMask schoolMask, Unit const victim)

static void	DealDamageMods (Unit const victim, uint32 &damage, uint32 absorb)

static uint32	DealDamage (Unit attacker, Unit victim, uint32 damage, CleanDamage const cleanDamage=nullptr, DamageEffectType damagetype=DIRECT_DAMAGE, SpellSchoolMask damageSchoolMask=SPELL_SCHOOL_MASK_NORMAL, SpellInfo const spellProto=nullptr, bool durabilityLoss=true, bool allowGM=false, Spell const *spell=nullptr)

static void	Kill (Unit killer, Unit victim, bool durabilityLoss=true, WeaponAttackType attackType=BASE_ATTACK, SpellInfo const spellProto=nullptr, Spell const spell=nullptr)

static int32	DealHeal (Unit healer, Unit victim, uint32 addhealth)

static void	ProcDamageAndSpell (Unit actor, Unit victim, uint32 procAttacker, uint32 procVictim, uint32 procEx, uint32 amount, WeaponAttackType attType=BASE_ATTACK, SpellInfo const procSpellInfo=nullptr, SpellInfo const procAura=nullptr, int8 procAuraEffectIndex=-1, Spell const procSpell=nullptr, DamageInfo damageInfo=nullptr, HealInfo *healInfo=nullptr, uint32 procPhase=2)

static void	ApplyResilience (Unit const victim, float crit, int32 *damage, bool isCrit, CombatRating type)

static uint32	SpellCriticalDamageBonus (Unit const caster, SpellInfo const spellProto, uint32 damage, Unit const *victim)

static uint32	SpellCriticalHealingBonus (Unit const caster, SpellInfo const spellProto, uint32 damage, Unit const *victim)

static bool	IsDamageReducedByArmor (SpellSchoolMask damageSchoolMask, SpellInfo const *spellInfo=nullptr, uint8 effIndex=MAX_SPELL_EFFECTS)

static uint32	CalcArmorReducedDamage (Unit const attacker, Unit const victim, const uint32 damage, SpellInfo const *spellInfo, uint8 attackerLevel=0, WeaponAttackType attackType=MAX_ATTACK)

static void	CalcAbsorbResist (DamageInfo &dmgInfo, bool Splited=false)

static void	CalcHealAbsorb (HealInfo &healInfo)

static void	HandleSafeUnitPointersOnDelete (Unit *thisUnit)

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
PetSpellMap	m_spells

AutoSpellList	m_autospells

uint32	m_usedTalentCount

bool	m_removed

Public Attributes inherited from TempSummon
const SummonPropertiesEntry *const	m_Properties

Public Attributes inherited from Creature
struct {
::Spell const * Spell = nullptr

uint32 Delay = 0

ObjectGuid Target

float Orientation = 0.0f

}	_spellFocusInfo

Loot	loot

uint32	m_spells [MAX_CREATURE_SPELLS]

CreatureSpellCooldowns	m_CreatureSpellCooldowns

uint32	m_ProhibitSchoolTime [7]

uint32	m_groupLootTimer

uint32	lootingGroupLowGUID

float	m_SightDistance

float	m_CombatDistance

bool	m_isTempWorldObject

uint32	m_moveCircleMovementTime = MOVE_CIRCLE_CHECK_INTERVAL

uint32	m_moveBackwardsMovementTime = MOVE_BACKWARDS_CHECK_INTERVAL

Public Attributes inherited from Unit
uint32	m_extraAttacks

bool	m_canDualWield

ControlSet	m_Controlled

SafeUnitPointer	m_movedByPlayer

ObjectGuid	m_SummonSlot [MAX_SUMMON_SLOT]

ObjectGuid	m_ObjectSlot [MAX_GAMEOBJECT_SLOT]

float	m_modMeleeHitChance

float	m_modRangedHitChance

float	m_modSpellHitChance

int32	m_baseSpellCritChance

float	m_threatModifier [MAX_SPELL_SCHOOL]

float	m_modAttackSpeedPct [3]

EventProcessor	m_Events

SpellImmuneList	m_spellImmune [MAX_SPELL_IMMUNITY]

uint32	m_lastSanctuaryTime

PetAuraSet	m_petAuras

bool	IsAIEnabled

bool	NeedChangeAI

bool	m_ControlledByPlayer

bool	m_CreatedByPlayer

std::set< SafeUnitPointer * >	SafeUnitPointerSet

Position	m_last_notify_position

uint32	m_last_notify_mstime

uint16	m_delayed_unit_relocation_timer

uint16	m_delayed_unit_ai_notify_timer

bool	bRequestForcedVisibilityUpdate

Movement::MoveSpline *	movespline

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

ElunaEventProcessor *	elunaEvents

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

Protected Attributes
Player *	m_owner

int32	m_happinessTimer

PetType	m_petType

Milliseconds	m_duration

uint64	m_auraRaidUpdateMask

bool	m_loading

Milliseconds	m_petRegenTimer

std::unique_ptr< DeclinedName >	m_declinedname

Unit *	m_tempspellTarget

Unit *	m_tempoldTarget

bool	m_tempspellIsPositive

uint32	m_tempspell

Protected Attributes inherited from Minion
const ObjectGuid	m_owner

float	m_followAngle

Protected Attributes inherited from Creature
VendorItemCounts	m_vendorItemCounts

ObjectGuid	m_lootRecipient

ObjectGuid::LowType	m_lootRecipientGroup

time_t	m_corpseRemoveTime
	Timers.

time_t	m_respawnTime

time_t	m_respawnedTime

uint32	m_respawnDelay

uint32	m_corpseDelay

float	m_wanderDistance

uint32	m_boundaryCheckTime

uint16	m_transportCheckTimer

uint32	lootPickPocketRestoreTime

uint32	m_combatPulseTime

uint32	m_combatPulseDelay

ReactStates	m_reactState

MovementGeneratorType	m_defaultMovementType

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

uint8	m_equipmentId

int8	m_originalEquipmentId

bool	m_AlreadyCallAssistance

bool	m_AlreadySearchedAssistance

bool	m_regenHealth

bool	m_regenPower

bool	m_AI_locked

SpellSchoolMask	m_meleeDamageSchoolMask

uint32	m_originalEntry

bool	m_moveInLineOfSightDisabled

bool	m_moveInLineOfSightStrictlyDisabled

Position	m_homePosition

Position	m_transportHomePosition

bool	DisableReputationGain

CreatureTemplate const *	m_creatureInfo

CreatureData const *	m_creatureData

float	m_detectionDistance

uint16	m_LootMode

Protected Attributes inherited from Unit
UnitAI *	i_AI

UnitAI *	i_disabledAI

uint8	m_realRace

uint8	m_race

bool	m_AutoRepeatFirstCast

int32	m_attackTimer [MAX_ATTACK]

float	m_createStats [MAX_STATS]

AttackerSet	m_attackers

Unit *	m_attacking

DeathState	m_deathState

int32	m_procDeep

DynObjectList	m_dynObj

GameObjectList	m_gameObj

uint32	m_transform

Spell *	m_currentSpells [CURRENT_MAX_SPELL]

AuraMap	m_ownedAuras

AuraApplicationMap	m_appliedAuras

AuraList	m_removedAuras

AuraMap::iterator	m_auraUpdateIterator

uint32	m_removedAurasCount

AuraEffectList	m_modAuras [TOTAL_AURAS]

AuraList	m_scAuras

AuraApplicationList	m_interruptableAuras

AuraStateAurasMap	m_auraStateAuras

uint32	m_interruptMask

float	m_auraModifiersGroup [UNIT_MOD_END][MODIFIER_TYPE_END]

float	m_weaponDamage [MAX_ATTACK][MAX_WEAPON_DAMAGE_RANGE][MAX_ITEM_PROTO_DAMAGES]

bool	m_canModifyStats

VisibleAuraMap	m_visibleAuras

float	m_speed_rate [MAX_MOVE_TYPE]

CharmInfo *	m_charmInfo

SharedVisionList	m_sharedVision

MotionMaster *	i_motionMaster

uint32	m_reactiveTimer [MAX_REACTIVE]

int32	m_regenTimer

ThreatMgr	m_ThreatMgr

CharmThreatMap	_charmThreatInfo

Vehicle *	m_vehicle

Vehicle *	m_vehicleKit

uint32	m_unitTypeMask

LiquidTypeEntry const *	_lastLiquid

bool	m_applyResilience

bool	_instantCast

uint32	m_rootTimes

Protected Attributes inherited from WorldObject
std::string	m_name

bool	m_isActive

bool	m_isFarVisible

Optional< float >	m_visibilityDistanceOverride

const bool	m_isWorldObject

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	SaveToDB (uint32, uint8, uint32) override

void	DeleteFromDB () override

Additional Inherited Members
Public Types inherited from Unit
typedef std::unordered_set< Unit * >	AttackerSet

typedef std::set< Unit * >	ControlSet

typedef std::multimap< uint32, Aura * >	AuraMap

typedef std::pair< AuraMap::const_iterator, AuraMap::const_iterator >	AuraMapBounds

typedef std::pair< AuraMap::iterator, AuraMap::iterator >	AuraMapBoundsNonConst

typedef std::multimap< uint32, AuraApplication * >	AuraApplicationMap

typedef std::pair< AuraApplicationMap::const_iterator, AuraApplicationMap::const_iterator >	AuraApplicationMapBounds

typedef std::pair< AuraApplicationMap::iterator, AuraApplicationMap::iterator >	AuraApplicationMapBoundsNonConst

typedef std::multimap< AuraStateType, AuraApplication * >	AuraStateAurasMap

typedef std::pair< AuraStateAurasMap::const_iterator, AuraStateAurasMap::const_iterator >	AuraStateAurasMapBounds

typedef std::list< AuraEffect * >	AuraEffectList

typedef std::list< Aura * >	AuraList

typedef std::list< AuraApplication * >	AuraApplicationList

typedef std::list< DiminishingReturn >	Diminishing

typedef GuidUnorderedSet	ComboPointHolderSet

typedef std::map< uint8, AuraApplication * >	VisibleAuraMap

typedef std::set< PetAura const * >	PetAuraSet

Static Public Attributes inherited from Creature
static constexpr uint32	MOVE_CIRCLE_CHECK_INTERVAL = 3000

static constexpr uint32	MOVE_BACKWARDS_CHECK_INTERVAL = 2000

Protected Types inherited from Unit
typedef std::list< DynamicObject * >	DynObjectList

typedef GuidList	GameObjectList

typedef std::map< ObjectGuid, float >	CharmThreatMap

Protected Member Functions inherited from Creature
bool	CreateFromProto (ObjectGuid::LowType guidlow, uint32 Entry, uint32 vehId, const CreatureData *data=nullptr)

bool	InitEntry (uint32 entry, const CreatureData *data=nullptr)

void	RegenerateHealth ()

void	Regenerate (Powers power)

bool	IsInvisibleDueToDespawn () const override

bool	CanAlwaysSee (WorldObject const *obj) const override

bool	IsAlwaysDetectableFor (WorldObject const *seer) const override

Protected Member Functions inherited from Unit
	Unit (bool isWorldObject)

void	BuildValuesUpdate (uint8 updatetype, ByteBuffer data, Player target) const override

void	_UpdateSpells (uint32 time)

void	_DeleteRemovedAuras ()

void	_UpdateAutoRepeatSpell ()

bool	IsAlwaysVisibleFor (WorldObject const *seer) const override

bool	IsAlwaysDetectableFor (WorldObject const *seer) const override

void	SetFeared (bool apply, Unit *fearedBy=nullptr, bool isFear=false)

void	SetConfused (bool apply)

void	SetStunned (bool apply)

void	SetRooted (bool apply, bool isStun=false)

Protected Member Functions inherited from WorldObject
	WorldObject (bool isWorldObject)

virtual void	ProcessPositionDataChanged (PositionFullTerrainStatus const &data)

void	SetLocationMapId (uint32 _mapId)

void	SetLocationInstanceId (uint32 _instanceId)

virtual bool	IsNeverVisible () const

virtual bool	IsAlwaysVisibleFor (WorldObject const *) const

virtual bool	IsInvisibleDueToDespawn () const

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

virtual void	BuildValuesUpdate (uint8 updatetype, ByteBuffer data, Player target) const

virtual void	AddToObjectUpdate ()=0

virtual void	RemoveFromObjectUpdate ()=0

void	AddToObjectUpdateIfNeeded ()

Protected Member Functions inherited from MovableMapObject
	MovableMapObject ()=default

Static Protected Member Functions inherited from Creature
static float	_GetHealthMod (int32 Rank)

Detailed Description

Constructor & Destructor Documentation

◆ Pet()

Pet::Pet	(	Player *	owner,
		PetType	type = `MAX_PET_TYPE`
	)

explicit

                                    : Guardian(nullptr, owner ? owner->GetGUID() : ObjectGuid::Empty, true),
    m_usedTalentCount(0),
    m_removed(false),
    m_owner(owner),
    m_happinessTimer(PET_LOSE_HAPPINES_INTERVAL),
    m_petType(type),
    m_duration(0),
    m_auraRaidUpdateMask(0),
    m_loading(false),
    m_petRegenTimer(PET_FOCUS_REGEN_INTERVAL),
    m_tempspellTarget(nullptr),
    m_tempoldTarget(nullptr),
    m_tempspellIsPositive(false),
    m_tempspell(0)
{
    ASSERT(m_owner && m_owner->GetTypeId() == TYPEID_PLAYER);
 
    m_unitTypeMask |= UNIT_MASK_PET;
 
    if (type == HUNTER_PET)
        m_unitTypeMask |= UNIT_MASK_HUNTER_PET;
 
    if (!(m_unitTypeMask & UNIT_MASK_CONTROLABLE_GUARDIAN))
    {
        m_unitTypeMask |= UNIT_MASK_CONTROLABLE_GUARDIAN;
        InitCharmInfo();
    }
 
    m_name = "Pet";
}

References ASSERT, Object::GetTypeId(), HUNTER_PET, Unit::InitCharmInfo(), WorldObject::m_name, m_owner, Unit::m_unitTypeMask, TYPEID_PLAYER, UNIT_MASK_CONTROLABLE_GUARDIAN, UNIT_MASK_HUNTER_PET, and UNIT_MASK_PET.

◆ ~Pet()

Pet::~Pet ( )

overridedefault

Member Function Documentation

◆ _LoadAuras()

void Pet::_LoadAuras	(	PreparedQueryResult	result,
		uint32	timediff
	)

{
    LOG_DEBUG("entities.pet", "Loading auras for pet {}", GetGUID().ToString());
 
    if (result)
    {
        do
        {
            int32 damage[3];
            int32 baseDamage[3];
            Field* fields = result->Fetch();
            ObjectGuid caster_guid = ObjectGuid(fields[0].Get<uint64>());
            // nullptr guid stored - pet is the caster of the spell - see Pet::_SaveAuras
            if (!caster_guid)
                caster_guid = GetGUID();
            uint32 spellid = fields[1].Get<uint32>();
            uint8 effmask = fields[2].Get<uint8>();
            uint8 recalculatemask = fields[3].Get<uint8>();
            uint8 stackcount = fields[4].Get<uint8>();
            damage[0] = fields[5].Get<int32>();
            damage[1] = fields[6].Get<int32>();
            damage[2] = fields[7].Get<int32>();
            baseDamage[0] = fields[8].Get<int32>();
            baseDamage[1] = fields[9].Get<int32>();
            baseDamage[2] = fields[10].Get<int32>();
            int32 maxduration = fields[11].Get<int32>();
            int32 remaintime = fields[12].Get<int32>();
            uint8 remaincharges = fields[13].Get<uint8>();
 
            SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellid);
            if (!spellInfo)
            {
                LOG_ERROR("entities.pet", "Unknown aura (spellid {}), ignore.", spellid);
                continue;
            }
 
            // avoid higher level auras if any, and adjust
            SpellInfo const* scaledSpellInfo = spellInfo->GetAuraRankForLevel(GetLevel());
            if (scaledSpellInfo != spellInfo)
                spellInfo = scaledSpellInfo;
 
            // again after level check
            if (!spellInfo)
                continue;
 
            // negative effects should continue counting down after logout
            if (remaintime != -1 && (!spellInfo->IsPositive() || spellInfo->HasAttribute(SPELL_ATTR4_AURA_EXPIRES_OFFLINE)))
            {
                if (remaintime / IN_MILLISECONDS <= int32(timediff))
                {
                    continue;
                }
 
                remaintime -= timediff * IN_MILLISECONDS;
            }
 
            // prevent wrong values of remaincharges
            if (spellInfo->ProcCharges)
            {
                if (remaincharges <= 0 || remaincharges > spellInfo->ProcCharges)
                    remaincharges = spellInfo->ProcCharges;
            }
            else
                remaincharges = 0;
 
            if (Aura* aura = Aura::TryCreate(spellInfo, effmask, this, nullptr, &baseDamage[0], nullptr, caster_guid))
            {
                if (!aura->CanBeSaved())
                {
                    aura->Remove();
                    continue;
                }
                aura->SetLoadedState(maxduration, remaintime, remaincharges, stackcount, recalculatemask, &damage[0]);
                aura->ApplyForTargets();
                LOG_DEBUG("entities.pet", "Added aura spellid {}, effectmask {}", spellInfo->Id, effmask);
            }
        } while (result->NextRow());
    }
}

References Field::Get(), SpellInfo::GetAuraRankForLevel(), Object::GetGUID(), Unit::GetLevel(), IN_MILLISECONDS, LOG_DEBUG, LOG_ERROR, SPELL_ATTR4_AURA_EXPIRES_OFFLINE, sSpellMgr, Position::ToString(), and Aura::TryCreate().

◆ _LoadSpellCooldowns()

void Pet::_LoadSpellCooldowns ( PreparedQueryResult result )

{
    m_CreatureSpellCooldowns.clear();
 
    if (result)
    {
        time_t curTime = GameTime::GetGameTime().count();
 
        PacketCooldowns cooldowns;
        WorldPacket data;
 
        do
        {
            Field* fields = result->Fetch();
 
            uint32 spell_id = fields[0].Get<uint32>();
            uint16 category = fields[1].Get<uint16>();
            time_t db_time  = time_t(fields[2].Get<uint32>());
 
            if (!sSpellMgr->GetSpellInfo(spell_id))
            {
                LOG_ERROR("entities.pet", "Pet {} have unknown spell {} in `pet_spell_cooldown`, skipping.", m_charmInfo->GetPetNumber(), spell_id);
                continue;
            }
 
            // skip outdated cooldown
            if (db_time <= curTime)
                continue;
 
            uint32 cooldown = (db_time - curTime) * IN_MILLISECONDS;
            cooldowns[spell_id] = cooldown;
            _AddCreatureSpellCooldown(spell_id, category, cooldown);
 
            LOG_DEBUG("entities.pet", "Pet (Number: {}) spell {} cooldown loaded ({} secs).", m_charmInfo->GetPetNumber(), spell_id, uint32(db_time - curTime));
        } while (result->NextRow());
 
        if (!cooldowns.empty() && GetOwner())
        {
            BuildCooldownPacket(data, SPELL_COOLDOWN_FLAG_NONE, cooldowns);
            GetOwner()->GetSession()->SendPacket(&data);
        }
    }
}

References Creature::_AddCreatureSpellCooldown(), Unit::BuildCooldownPacket(), Field::Get(), GameTime::GetGameTime(), GetOwner(), CharmInfo::GetPetNumber(), Player::GetSession(), IN_MILLISECONDS, LOG_DEBUG, LOG_ERROR, Unit::m_charmInfo, Creature::m_CreatureSpellCooldowns, WorldSession::SendPacket(), SPELL_COOLDOWN_FLAG_NONE, and sSpellMgr.

◆ _LoadSpells()

void Pet::_LoadSpells ( PreparedQueryResult result )

{
    if (result)
    {
        do
        {
            Field* fields = result->Fetch();
 
            addSpell(fields[0].Get<uint32>(), ActiveStates(fields[1].Get<uint8>()), PETSPELL_UNCHANGED);
        } while (result->NextRow());
    }
}

References addSpell(), and PETSPELL_UNCHANGED.

◆ _SaveAuras()

void Pet::_SaveAuras ( CharacterDatabaseTransaction trans )

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PET_AURAS);
    stmt->SetData(0, m_charmInfo->GetPetNumber());
    trans->Append(stmt);
 
    for (AuraMap::const_iterator itr = m_ownedAuras.begin(); itr != m_ownedAuras.end(); ++itr)
    {
        // check if the aura has to be saved
        if (!itr->second->CanBeSaved() || IsPetAura(itr->second))
            continue;
 
        Aura* aura = itr->second;
        if (aura->GetDuration() < 60 * IN_MILLISECONDS)
            continue;
 
        // dont save infinite negative auras! (lavas, transformations etc)
        if (aura->IsPermanent() && !aura->GetSpellInfo()->IsPositive())
            continue;
 
        // pussywizard: don't save auras that cannot be cancelled (needed for ICC buff on pets/summons)
        if (aura->GetSpellInfo()->HasAttribute(SPELL_ATTR0_NO_AURA_CANCEL))
            continue;
 
        // xinef: don't save hidden auras
        if (aura->GetSpellInfo()->HasAttribute(SPELL_ATTR1_NO_AURA_ICON))
            continue;
 
        // Xinef: Dont save auras with model change
        if (aura->GetSpellInfo()->HasAura(SPELL_AURA_TRANSFORM))
            continue;
 
        // xinef: don's save auras with interrupt flags on map change
        if (aura->GetSpellInfo()->AuraInterruptFlags & AURA_INTERRUPT_FLAG_CHANGE_MAP)
            continue;
 
        int32 damage[MAX_SPELL_EFFECTS];
        int32 baseDamage[MAX_SPELL_EFFECTS];
        uint8 effMask = 0;
        uint8 recalculateMask = 0;
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (aura->GetEffect(i))
            {
                baseDamage[i] = aura->GetEffect(i)->GetBaseAmount();
                damage[i] = aura->GetEffect(i)->GetAmount();
                effMask |= (1 << i);
                if (aura->GetEffect(i)->CanBeRecalculated())
                    recalculateMask |= (1 << i);
            }
            else
            {
                baseDamage[i] = 0;
                damage[i] = 0;
            }
        }
 
        // don't save guid of caster in case we are caster of the spell - guid for pet is generated every pet load, so it won't match saved guid anyways
        ObjectGuid casterGUID = (itr->second->GetCasterGUID() == GetGUID()) ? ObjectGuid::Empty : itr->second->GetCasterGUID();
 
        uint8 index = 0;
 
        CharacterDatabasePreparedStatement* stmt2 = CharacterDatabase.GetPreparedStatement(CHAR_INS_PET_AURA);
        stmt2->SetData(index++, m_charmInfo->GetPetNumber());
        stmt2->SetData(index++, casterGUID.GetRawValue());
        stmt2->SetData(index++, itr->second->GetId());
        stmt2->SetData(index++, effMask);
        stmt2->SetData(index++, recalculateMask);
        stmt2->SetData(index++, itr->second->GetStackAmount());
        stmt2->SetData(index++, damage[0]);
        stmt2->SetData(index++, damage[1]);
        stmt2->SetData(index++, damage[2]);
        stmt2->SetData(index++, baseDamage[0]);
        stmt2->SetData(index++, baseDamage[1]);
        stmt2->SetData(index++, baseDamage[2]);
        stmt2->SetData(index++, itr->second->GetMaxDuration());
        stmt2->SetData(index++, itr->second->GetDuration());
        stmt2->SetData(index++, itr->second->GetCharges());
        trans->Append(stmt2);
    }
}

References AURA_INTERRUPT_FLAG_CHANGE_MAP, SpellInfo::AuraInterruptFlags, AuraEffect::CanBeRecalculated(), CHAR_DEL_PET_AURAS, CHAR_INS_PET_AURA, CharacterDatabase, ObjectGuid::Empty, AuraEffect::GetAmount(), AuraEffect::GetBaseAmount(), Aura::GetDuration(), Aura::GetEffect(), Object::GetGUID(), CharmInfo::GetPetNumber(), ObjectGuid::GetRawValue(), Aura::GetSpellInfo(), SpellInfo::HasAttribute(), SpellInfo::HasAura(), IN_MILLISECONDS, Aura::IsPermanent(), Unit::IsPetAura(), SpellInfo::IsPositive(), Unit::m_charmInfo, Unit::m_ownedAuras, MAX_SPELL_EFFECTS, PreparedStatementBase::SetData(), SPELL_ATTR0_NO_AURA_CANCEL, SPELL_ATTR1_NO_AURA_ICON, and SPELL_AURA_TRANSFORM.

Referenced by SavePetToDB().

◆ _SaveSpellCooldowns()

void Pet::_SaveSpellCooldowns ( CharacterDatabaseTransaction trans )

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PET_SPELL_COOLDOWNS);
    stmt->SetData(0, m_charmInfo->GetPetNumber());
    trans->Append(stmt);
 
    time_t curTime = GameTime::GetGameTime().count();
    uint32 curMSTime = GameTime::GetGameTimeMS().count();
    uint32 infTime   = curMSTime + infinityCooldownDelayCheck;
 
    // remove oudated and save active
    CreatureSpellCooldowns::iterator itr, itr2;
    for (itr = m_CreatureSpellCooldowns.begin(); itr != m_CreatureSpellCooldowns.end();)
    {
        itr2 = itr;
        ++itr;
 
        if (itr2->second.end <= curMSTime + 1000)
        {
            m_CreatureSpellCooldowns.erase(itr2);
        }
        else if (itr2->second.end <= infTime)
        {
            uint32 cooldown = ((itr2->second.end - curMSTime) / IN_MILLISECONDS) + curTime;
            stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_PET_SPELL_COOLDOWN);
            stmt->SetData(0, m_charmInfo->GetPetNumber());
            stmt->SetData(1, itr2->first);
            stmt->SetData(2, itr2->second.category);
            stmt->SetData(3, cooldown);
            trans->Append(stmt);
        }
    }
}

References CHAR_DEL_PET_SPELL_COOLDOWNS, CHAR_INS_PET_SPELL_COOLDOWN, CharacterDatabase, GameTime::GetGameTime(), GameTime::GetGameTimeMS(), CharmInfo::GetPetNumber(), IN_MILLISECONDS, infinityCooldownDelayCheck, Unit::m_charmInfo, Creature::m_CreatureSpellCooldowns, and PreparedStatementBase::SetData().

Referenced by SavePetToDB().

◆ _SaveSpells()

void Pet::_SaveSpells ( CharacterDatabaseTransaction trans )

{
    for (PetSpellMap::iterator itr = m_spells.begin(), next = m_spells.begin(); itr != m_spells.end(); itr = next)
    {
        ++next;
 
        // prevent saving family passives to DB
        if (itr->second.type == PETSPELL_FAMILY)
            continue;
 
        CharacterDatabasePreparedStatement* stmt;
 
        switch (itr->second.state)
        {
            case PETSPELL_REMOVED:
                stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PET_SPELL_BY_SPELL);
                stmt->SetData(0, m_charmInfo->GetPetNumber());
                stmt->SetData(1, itr->first);
                trans->Append(stmt);
 
                m_spells.erase(itr);
                continue;
            case PETSPELL_CHANGED:
                stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PET_SPELL_BY_SPELL);
                stmt->SetData(0, m_charmInfo->GetPetNumber());
                stmt->SetData(1, itr->first);
                trans->Append(stmt);
 
                stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_PET_SPELL);
                stmt->SetData(0, m_charmInfo->GetPetNumber());
                stmt->SetData(1, itr->first);
                stmt->SetData(2, itr->second.active);
                trans->Append(stmt);
 
                break;
            case PETSPELL_NEW:
                stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_PET_SPELL);
                stmt->SetData(0, m_charmInfo->GetPetNumber());
                stmt->SetData(1, itr->first);
                stmt->SetData(2, itr->second.active);
                trans->Append(stmt);
                break;
            case PETSPELL_UNCHANGED:
                continue;
        }
        itr->second.state = PETSPELL_UNCHANGED;
    }
}

References CHAR_DEL_PET_SPELL_BY_SPELL, CHAR_INS_PET_SPELL, CharacterDatabase, CharmInfo::GetPetNumber(), Unit::m_charmInfo, m_spells, PETSPELL_CHANGED, PETSPELL_FAMILY, PETSPELL_NEW, PETSPELL_REMOVED, PETSPELL_UNCHANGED, and PreparedStatementBase::SetData().

Referenced by SavePetToDB().

◆ addSpell()

bool Pet::addSpell	(	uint32	spellId,
		ActiveStates	active = `ACT_DECIDE`,
		PetSpellState	state = `PETSPELL_NEW`,
		PetSpellType	type = `PETSPELL_NORMAL`
	)

{
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
    if (!spellInfo)
    {
        // do pet spell book cleanup
        if (state == PETSPELL_UNCHANGED)                    // spell load case
        {
            LOG_ERROR("entities.pet", "Pet::addSpell: Non-existed in SpellStore spell #{} request, deleting for all pets in `pet_spell`.", spellId);
 
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INVALID_PET_SPELL);
            stmt->SetData(0, spellId);
            CharacterDatabase.Execute(stmt);
        }
        else
            LOG_ERROR("entities.pet", "Pet::addSpell: Non-existed in SpellStore spell #{} request.", spellId);
 
        return false;
    }
 
    auto const& itr = m_spells.find(spellId);
    if (itr != m_spells.end())
    {
        if (itr->second.state == PETSPELL_REMOVED)
        {
            m_spells.erase(itr);
            state = PETSPELL_CHANGED;
        }
        else if (state == PETSPELL_UNCHANGED && itr->second.state != PETSPELL_UNCHANGED)
        {
            // can be in case spell loading but learned at some previous spell loading
            itr->second.state = PETSPELL_UNCHANGED;
 
            ToggleAutocast(spellInfo, active == ACT_ENABLED);
            return false;
        }
        else
            return false;
    }
 
    PetSpell newspell;
    newspell.state = state;
    newspell.type = type;
 
    if (active == ACT_DECIDE)                               // active was not used before, so we save it's autocast/passive state here
    {
        if (spellInfo->IsAutocastable())
            newspell.active = ACT_DISABLED;
        else
            newspell.active = ACT_PASSIVE;
    }
    else
        newspell.active = active;
 
    // talent: unlearn all other talent ranks (high and low)
    if (TalentSpellPos const* talentPos = GetTalentSpellPos(spellId))
    {
        if (TalentEntry const* talentInfo = sTalentStore.LookupEntry(talentPos->talent_id))
        {
            for (uint32 rankSpellId : talentInfo->RankID)
            {
                // skip learning spell and no rank spell case
                if (!rankSpellId || rankSpellId == spellId)
                    continue;
 
                // skip unknown ranks
                if (!HasSpell(rankSpellId))
                    continue;
                removeSpell(rankSpellId, false, false);
            }
        }
    }
    else if (spellInfo->IsRanked())
    {
        for (auto const& [spellID, petSpell] : m_spells)
        {
            if (petSpell.state == PETSPELL_REMOVED)
                continue;
 
            SpellInfo const* oldRankSpellInfo = sSpellMgr->GetSpellInfo(spellID);
 
            if (!oldRankSpellInfo)
                continue;
 
            if (spellInfo->IsDifferentRankOf(oldRankSpellInfo))
            {
                // replace by new high rank
                if (spellInfo->IsHighRankOf(oldRankSpellInfo))
                {
                    newspell.active = petSpell.active;
 
                    if (newspell.active == ACT_ENABLED)
                        ToggleAutocast(oldRankSpellInfo, false);
 
                    unlearnSpell(spellID, false, false);
                    break;
                }
                // ignore new lesser rank
                else
                    return false;
            }
        }
    }
 
    m_spells[spellId] = newspell;
 
    if (spellInfo->IsPassive())
        CastSpell(this, spellId, true);
    else
        m_charmInfo->AddSpellToActionBar(spellInfo);
 
    // unapply aura stats if dont meet requirements
    if (Aura* aura = GetAura(spellId))
    {
        if (aura->GetSpellInfo()->CasterAuraState == AURA_STATE_HEALTHLESS_35_PERCENT ||
                aura->GetSpellInfo()->CasterAuraState == AURA_STATE_HEALTH_ABOVE_75_PERCENT ||
                aura->GetSpellInfo()->CasterAuraState == AURA_STATE_HEALTHLESS_20_PERCENT )
            if (!HasAuraState((AuraStateType)aura->GetSpellInfo()->CasterAuraState))
            {
                aura->HandleAllEffects(aura->GetApplicationOfTarget(GetGUID()), AURA_EFFECT_HANDLE_REAL, false);
            }
    }
 
    ToggleAutocast(spellInfo, (newspell.active == ACT_ENABLED));
 
    uint32 talentCost = GetTalentSpellCost(spellId);
    if (talentCost)
    {
        int32 free_points = GetMaxTalentPointsForLevel(GetLevel());
        m_usedTalentCount += talentCost;
        // update free talent points
        free_points -= m_usedTalentCount;
        SetFreeTalentPoints(free_points > 0 ? free_points : 0);
    }
    return true;
}

References ACT_DECIDE, ACT_DISABLED, ACT_ENABLED, ACT_PASSIVE, PetSpell::active, CharmInfo::AddSpellToActionBar(), AURA_EFFECT_HANDLE_REAL, AURA_STATE_HEALTH_ABOVE_75_PERCENT, AURA_STATE_HEALTHLESS_20_PERCENT, AURA_STATE_HEALTHLESS_35_PERCENT, Unit::CastSpell(), CHAR_DEL_INVALID_PET_SPELL, CharacterDatabase, Unit::GetAura(), Object::GetGUID(), Unit::GetLevel(), GetMaxTalentPointsForLevel(), GetTalentSpellCost(), GetTalentSpellPos(), Unit::HasAuraState(), HasSpell(), SpellInfo::IsAutocastable(), SpellInfo::IsDifferentRankOf(), SpellInfo::IsHighRankOf(), SpellInfo::IsPassive(), SpellInfo::IsRanked(), LOG_ERROR, Unit::m_charmInfo, m_spells, m_usedTalentCount, PETSPELL_CHANGED, PETSPELL_REMOVED, PETSPELL_UNCHANGED, removeSpell(), PreparedStatementBase::SetData(), SetFreeTalentPoints(), sSpellMgr, sTalentStore, PetSpell::state, ToggleAutocast(), PetSpell::type, and unlearnSpell().

Referenced by _LoadSpells(), LearnPetPassives(), and learnSpell().

◆ AddToWorld()

void Pet::AddToWorld ( )

overridevirtual

Register the pet for guid lookup
Register the pet for guid lookup

Reimplemented from Creature.

{
    if (!IsInWorld())
    {
        GetMap()->GetObjectsStore().Insert<Pet>(GetGUID(), this);
        Unit::AddToWorld();
        Motion_Initialize();
        AIM_Initialize();
    }
 
    // pussywizard: apply ICC buff to pets
    if (GetOwnerGUID().IsPlayer() && GetMapId() == 631 && FindMap() && FindMap()->ToInstanceMap() && FindMap()->ToInstanceMap()->GetInstanceScript() && FindMap()->ToInstanceMap()->GetInstanceScript()->GetData(251 /*DATA_BUFF_AVAILABLE*/))
        if (Unit* owner = GetOwner())
            if (Player* plr = owner->ToPlayer())
            {
                SpellAreaForAreaMapBounds saBounds = sSpellMgr->GetSpellAreaForAreaMapBounds(4812);
                for (SpellAreaForAreaMap::const_iterator itr = saBounds.first; itr != saBounds.second; ++itr)
                    if ((itr->second->raceMask & plr->getRaceMask()) && !HasAura(itr->second->spellId))
                        if (SpellInfo const* si = sSpellMgr->GetSpellInfo(itr->second->spellId))
                            if (si->HasAura(SPELL_AURA_MOD_INCREASE_HEALTH_PERCENT))
                                AddAura(itr->second->spellId, this);
            }
 
    // Prevent stuck pets when zoning. Pets default to "follow" when added to world
    // so we'll reset flags and let the AI handle things
    if (GetCharmInfo() && GetCharmInfo()->HasCommandState(COMMAND_FOLLOW))
    {
        GetCharmInfo()->SetIsCommandAttack(false);
        GetCharmInfo()->SetIsCommandFollow(false);
        GetCharmInfo()->SetIsAtStay(false);
        GetCharmInfo()->SetIsFollowing(false);
        GetCharmInfo()->SetIsReturning(false);
    }
 
    if (GetOwnerGUID().IsPlayer())
    {
        sScriptMgr->OnPetAddToWorld(this);
    }
}

References Unit::AddAura(), Unit::AddToWorld(), Creature::AIM_Initialize(), COMMAND_FOLLOW, WorldObject::FindMap(), Unit::GetCharmInfo(), Object::GetGUID(), WorldObject::GetInstanceScript(), WorldObject::GetMap(), WorldLocation::GetMapId(), Map::GetObjectsStore(), GetOwner(), Unit::GetOwnerGUID(), Unit::HasAura(), TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Insert(), Object::IsInWorld(), Object::IsPlayer(), Creature::Motion_Initialize(), CharmInfo::SetIsAtStay(), CharmInfo::SetIsCommandAttack(), CharmInfo::SetIsCommandFollow(), CharmInfo::SetIsFollowing(), CharmInfo::SetIsReturning(), SPELL_AURA_MOD_INCREASE_HEALTH_PERCENT, sScriptMgr, sSpellMgr, and Object::ToPlayer().

◆ CastPetAuras()

void Pet::CastPetAuras ( bool current )

{
    Unit* owner = GetOwner();
    if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
        return;
 
    if (!IsPermanentPetFor(owner->ToPlayer()))
        return;
 
    for (PetAuraSet::const_iterator itr = owner->m_petAuras.begin(); itr != owner->m_petAuras.end();)
    {
        PetAura const* pa = *itr;
        ++itr;
 
        if (!current && pa->IsRemovedOnChangePet())
            owner->RemovePetAura(pa);
        else
            CastPetAura(pa);
    }
}

References Unit::CastPetAura(), GetOwner(), Object::GetTypeId(), IsPermanentPetFor(), PetAura::IsRemovedOnChangePet(), Unit::m_petAuras, Unit::RemovePetAura(), Object::ToPlayer(), and TYPEID_PLAYER.

Referenced by InitPetCreateSpells(), and setDeathState().

◆ CastWhenWillAvailable()

void Pet::CastWhenWillAvailable	(	uint32	spellid,
		Unit *	spellTarget,
		Unit *	oldTarget,
		bool	spellIsPositive = `false`
	)

{
    if (!spellid)
        return;
 
    if (!spellTarget)
        return;
 
    m_tempspellTarget = spellTarget;
    m_tempspell = spellid;
    m_tempspellIsPositive = spellIsPositive;
 
    if (oldTarget)
        m_tempoldTarget = oldTarget;
}

References m_tempoldTarget, m_tempspell, m_tempspellIsPositive, and m_tempspellTarget.

Referenced by WorldSession::HandlePetActionHelper().

◆ CleanupActionBar()

void Pet::CleanupActionBar ( )

{
    for (uint8 i = 0; i < MAX_UNIT_ACTION_BAR_INDEX; ++i)
        if (UnitActionBarEntry const* ab = m_charmInfo->GetActionBarEntry(i))
            if (ab->GetAction() && ab->IsActionBarForSpell())
            {
                if (!HasSpell(ab->GetAction()))
                    m_charmInfo->SetActionBar(i, 0, ACT_PASSIVE);
                else if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(ab->GetAction()))
                    ToggleAutocast(spellInfo, ab->GetType() == ACT_ENABLED);
            }
}

References ACT_ENABLED, ACT_PASSIVE, CharmInfo::GetActionBarEntry(), HasSpell(), Unit::m_charmInfo, MAX_UNIT_ACTION_BAR_INDEX, CharmInfo::SetActionBar(), sSpellMgr, and ToggleAutocast().

Referenced by LoadPetFromDB().

◆ ClearCastWhenWillAvailable()

void Pet::ClearCastWhenWillAvailable ( )

{
    m_tempspellIsPositive = false;
    m_tempspell = 0;
    m_tempspellTarget = nullptr;
    m_tempoldTarget = nullptr;
}

References m_tempoldTarget, m_tempspell, m_tempspellIsPositive, and m_tempspellTarget.

Referenced by WorldSession::HandlePetActionHelper().

◆ Create()

bool Pet::Create	(	ObjectGuid::LowType	guidlow,
		Map *	map,
		uint32	phaseMask,
		uint32	Entry,
		uint32	pet_number
	)

{
    ASSERT(map);
    SetMap(map);
 
    SetPhaseMask(phaseMask, false);
 
    Object::_Create(guidlow, pet_number, HighGuid::Pet);
 
    m_spawnId = guidlow;
    m_originalEntry = Entry;
 
    if (!InitEntry(Entry))
        return false;
 
    // Force regen flag for player pets, just like we do for players themselves
    SetUnitFlag2(UNIT_FLAG2_REGENERATE_POWER);
    SetSheath(SHEATH_STATE_MELEE);
 
    return true;
}

References Object::_Create(), ASSERT, Entry, Creature::InitEntry(), Creature::m_originalEntry, Creature::m_spawnId, WorldObject::SetMap(), Unit::SetPhaseMask(), Unit::SetSheath(), Unit::SetUnitFlag2(), SHEATH_STATE_MELEE, and UNIT_FLAG2_REGENERATE_POWER.

Referenced by CreateBaseAtTamed(), LoadPetFromDB(), and Player::SummonPet().

◆ CreateBaseAtCreature()

bool Pet::CreateBaseAtCreature ( Creature * creature )

{
    ASSERT(creature);
 
    if (!CreateBaseAtTamed(creature->GetCreatureTemplate(), creature->GetMap(), creature->GetPhaseMask()))
        return false;
 
    Relocate(creature->GetPositionX(), creature->GetPositionY(), creature->GetPositionZ(), creature->GetOrientation());
 
    if (!IsPositionValid())
    {
        LOG_ERROR("entities.pet", "Pet {} not created base at creature. Suggested coordinates isn't valid (X: {} Y: {})",
                       GetGUID().ToString(), GetPositionX(), GetPositionY());
        return false;
    }
 
    CreatureTemplate const* cinfo = GetCreatureTemplate();
    if (!cinfo)
    {
        LOG_ERROR("entities.pet", "CreateBaseAtCreature() failed, creatureInfo is missing!");
        return false;
    }
 
    SetDisplayId(creature->GetDisplayId());
 
    UpdatePositionData();
 
    if (CreatureFamilyEntry const* cFamily = sCreatureFamilyStore.LookupEntry(cinfo->family))
        SetName(cFamily->Name[sWorld->GetDefaultDbcLocale()]);
    else
        SetName(creature->GetNameForLocaleIdx(sObjectMgr->GetDBCLocaleIndex()));
 
    return true;
}

References ASSERT, CreateBaseAtTamed(), CreatureTemplate::family, Creature::GetCreatureTemplate(), Unit::GetDisplayId(), Object::GetGUID(), WorldObject::GetMap(), Creature::GetNameForLocaleIdx(), Position::GetOrientation(), WorldObject::GetPhaseMask(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Position::IsPositionValid(), LOG_ERROR, Position::Relocate(), sCreatureFamilyStore, SetDisplayId(), WorldObject::SetName(), sObjectMgr, sWorld, Position::ToString(), and WorldObject::UpdatePositionData().

Referenced by Unit::CreateTamedPetFrom().

◆ CreateBaseAtCreatureInfo()

bool Pet::CreateBaseAtCreatureInfo	(	CreatureTemplate const *	cinfo,
		Unit *	owner
	)

{
    if (!CreateBaseAtTamed(cinfo, owner->GetMap(), owner->GetPhaseMask()))
        return false;
 
    if (CreatureFamilyEntry const* cFamily = sCreatureFamilyStore.LookupEntry(cinfo->family))
        SetName(cFamily->Name[sWorld->GetDefaultDbcLocale()]);
 
    Relocate(owner->GetPositionX(), owner->GetPositionY(), owner->GetPositionZ(), owner->GetOrientation());
 
    UpdatePositionData();
 
    return true;
}

References CreateBaseAtTamed(), CreatureTemplate::family, WorldObject::GetMap(), Position::GetOrientation(), WorldObject::GetPhaseMask(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), Position::Relocate(), sCreatureFamilyStore, WorldObject::SetName(), sWorld, and WorldObject::UpdatePositionData().

Referenced by Unit::CreateTamedPetFrom().

◆ CreateBaseAtTamed()

bool Pet::CreateBaseAtTamed	(	CreatureTemplate const *	cinfo,
		Map *	map,
		uint32	phaseMask
	)

{
    LOG_DEBUG("entities.pet", "Pet::CreateBaseForTamed");
    ObjectGuid::LowType guid = map->GenerateLowGuid<HighGuid::Pet>();
    uint32 pet_number = sObjectMgr->GeneratePetNumber();
    if (!Create(guid, map, phaseMask, cinfo->Entry, pet_number))
        return false;
 
    SetMaxPower(POWER_HAPPINESS, GetCreatePowers(POWER_HAPPINESS));
    SetPower(POWER_HAPPINESS, 166500);
    setPowerType(POWER_FOCUS);
    SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP, 0);
    SetUInt32Value(UNIT_FIELD_PETEXPERIENCE, 0);
    SetUInt32Value(UNIT_FIELD_PETNEXTLEVELEXP, uint32(sObjectMgr->GetXPForLevel(GetLevel() + 1)* sWorld->getRate(RATE_XP_PET_NEXT_LEVEL)));
    ReplaceAllNpcFlags(UNIT_NPC_FLAG_NONE);
 
    if (cinfo->type == CREATURE_TYPE_BEAST)
    {
        SetUInt32Value(UNIT_FIELD_BYTES_0, 0x02020100);
        SetSheath(SHEATH_STATE_MELEE);
        SetByteFlag(UNIT_FIELD_BYTES_2, 2, UNIT_CAN_BE_RENAMED | UNIT_CAN_BE_ABANDONED);
    }
 
    return true;
}

References Create(), CREATURE_TYPE_BEAST, CreatureTemplate::Entry, Map::GenerateLowGuid(), Unit::GetCreatePowers(), Unit::GetLevel(), LOG_DEBUG, POWER_FOCUS, POWER_HAPPINESS, RATE_XP_PET_NEXT_LEVEL, Unit::ReplaceAllNpcFlags(), Object::SetByteFlag(), Unit::SetMaxPower(), Unit::SetPower(), Unit::setPowerType(), Unit::SetSheath(), Object::SetUInt32Value(), SHEATH_STATE_MELEE, sObjectMgr, sWorld, CreatureTemplate::type, UNIT_CAN_BE_ABANDONED, UNIT_CAN_BE_RENAMED, UNIT_FIELD_BYTES_0, UNIT_FIELD_BYTES_2, UNIT_FIELD_PET_NAME_TIMESTAMP, UNIT_FIELD_PETEXPERIENCE, UNIT_FIELD_PETNEXTLEVELEXP, and UNIT_NPC_FLAG_NONE.

Referenced by CreateBaseAtCreature(), and CreateBaseAtCreatureInfo().

◆ DeleteFromDB() [1/2]

void Pet::DeleteFromDB ( )

inlineoverrideprivatevirtual

Reimplemented from Creature.

    {
        ABORT();
    }

References ABORT.

Referenced by Player::DeleteFromDB(), and SavePetToDB().

◆ DeleteFromDB() [2/2]

void Pet::DeleteFromDB ( ObjectGuid::LowType guidlow )

static

{
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_PET_BY_ID);
    stmt->SetData(0, guidlow);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_PET_DECLINEDNAME);
    stmt->SetData(0, guidlow);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PET_AURAS);
    stmt->SetData(0, guidlow);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PET_SPELLS);
    stmt->SetData(0, guidlow);
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PET_SPELL_COOLDOWNS);
    stmt->SetData(0, guidlow);
    trans->Append(stmt);
 
    CharacterDatabase.CommitTransaction(trans);
}

References CHAR_DEL_CHAR_PET_BY_ID, CHAR_DEL_CHAR_PET_DECLINEDNAME, CHAR_DEL_PET_AURAS, CHAR_DEL_PET_SPELL_COOLDOWNS, CHAR_DEL_PET_SPELLS, CharacterDatabase, and PreparedStatementBase::SetData().

◆ FillPetInfo()

void Pet::FillPetInfo ( PetStable::PetInfo * petInfo ) const

{
    petInfo->PetNumber = m_charmInfo->GetPetNumber();
    petInfo->CreatureId = GetEntry();
    petInfo->DisplayId = GetNativeDisplayId();
    petInfo->Level = GetLevel();
    petInfo->Experience = GetUInt32Value(UNIT_FIELD_PETEXPERIENCE);
    petInfo->ReactState = GetReactState();
    petInfo->Name = GetName();
    petInfo->WasRenamed = !HasByteFlag(UNIT_FIELD_BYTES_2, 2, UNIT_CAN_BE_RENAMED);
    petInfo->Health = GetHealth();
    petInfo->Mana = GetPower(POWER_MANA);
    petInfo->Happiness = GetPower(POWER_HAPPINESS);
    petInfo->ActionBar = GenerateActionBarData();
    petInfo->LastSaveTime = GameTime::GetGameTime().count();
    petInfo->CreatedBySpellId = GetUInt32Value(UNIT_CREATED_BY_SPELL);
    petInfo->Type = getPetType();
}

Referenced by Unit::InitTamedPet(), SavePetToDB(), and Player::SummonPet().

◆ GenerateActionBarData()

std::string Pet::GenerateActionBarData ( ) const

{
    std::ostringstream oss;
 
    for (uint32 i = ACTION_BAR_INDEX_START; i < ACTION_BAR_INDEX_END; ++i)
    {
        oss << uint32(m_charmInfo->GetActionBarEntry(i)->GetType()) << ' '
            << uint32(m_charmInfo->GetActionBarEntry(i)->GetAction()) << ' ';
    }
 
    return oss.str();
}

References ACTION_BAR_INDEX_END, ACTION_BAR_INDEX_START, UnitActionBarEntry::GetAction(), CharmInfo::GetActionBarEntry(), UnitActionBarEntry::GetType(), and Unit::m_charmInfo.

Referenced by FillPetInfo(), and SavePetToDB().

◆ GetAuraUpdateMaskForRaid()

uint64 Pet::GetAuraUpdateMaskForRaid ( ) const

inline

135{ return m_auraRaidUpdateMask; }

References m_auraRaidUpdateMask.

Referenced by WorldSession::BuildPartyMemberStatsChangedPacket().

◆ GetCurrentFoodBenefitLevel()

uint32 Pet::GetCurrentFoodBenefitLevel ( uint32 itemlevel ) const

{
    // -5 or greater food level
    if (GetLevel() <= itemlevel + 5)                         //possible to feed level 60 pet with level 55 level food for full effect
        return 35000;
    // -10..-6
    else if (GetLevel() <= itemlevel + 10)                   //pure guess, but sounds good
        return 17000;
    // -14..-11
    else if (GetLevel() <= itemlevel + 14)                   //level 55 food gets green on 70, makes sense to me
        return 8000;
    // -15 or less
    else
        return 0;                                           //food too low level
}

References Unit::GetLevel().

Referenced by Spell::CheckCast(), and Spell::EffectFeedPet().

◆ GetDebugInfo()

std::string Pet::GetDebugInfo ( ) const

overridevirtual

Reimplemented from Guardian.

{
    std::stringstream sstr;
    sstr << Guardian::GetDebugInfo() << "\n"
        << std::boolalpha
        << "PetType: " << std::to_string(getPetType()) << " "
        << "PetNumber: " << m_charmInfo->GetPetNumber();
    return sstr.str();
}

References Guardian::GetDebugInfo(), CharmInfo::GetPetNumber(), getPetType(), and Unit::m_charmInfo.

◆ GetDeclinedNames()

DeclinedName const * Pet::GetDeclinedNames ( ) const

inline

139{ return m_declinedname.get(); }

Pet::m_declinedname

std::unique_ptr< DeclinedName > m_declinedname

Definition: Pet.h:158

References m_declinedname.

◆ GetDuration()

Milliseconds Pet::GetDuration ( ) const

inline

90{ return m_duration; }

References m_duration.

Referenced by Player::PetSpellInitialize().

◆ GetFreeTalentPoints()

uint8 Pet::GetFreeTalentPoints ( )

inline

130{ return GetByteValue(UNIT_FIELD_BYTES_1, 1); }

UNIT_FIELD_BYTES_1

@ UNIT_FIELD_BYTES_1

Definition: UpdateFields.h:131

Object::GetByteValue

uint8 GetByteValue(uint16 index, uint8 offset) const

Definition: Object.cpp:323

References Object::GetByteValue(), and UNIT_FIELD_BYTES_1.

Referenced by Player::BuildPetTalentsInfoData(), and Player::LearnPetTalent().

◆ GetHappinessState()

HappinessState Pet::GetHappinessState ( )

{
    if (GetPower(POWER_HAPPINESS) < HAPPINESS_LEVEL_SIZE)
        return UNHAPPY;
    else if (GetPower(POWER_HAPPINESS) >= HAPPINESS_LEVEL_SIZE * 2)
        return HAPPY;
    else
        return CONTENT;
}

References CONTENT, Unit::GetPower(), HAPPINESS_LEVEL_SIZE, HAPPY, POWER_HAPPINESS, and UNHAPPY.

Referenced by Guardian::UpdateDamagePhysical().

◆ GetLoadPetInfo()

std::pair< PetStable::PetInfo const *, PetSaveMode > Pet::GetLoadPetInfo	(	PetStable const &	stable,
		uint32	petEntry,
		uint32	petnumber,
		bool	current
	)

static

{
    if (petnumber)
    {
        // Known petnumber entry
        if (stable.CurrentPet && stable.CurrentPet->PetNumber == petnumber)
            return { &stable.CurrentPet.value(), PET_SAVE_AS_CURRENT };
 
        for (std::size_t stableSlot = 0; stableSlot < stable.StabledPets.size(); ++stableSlot)
            if (stable.StabledPets[stableSlot] && stable.StabledPets[stableSlot]->PetNumber == petnumber)
                return { &stable.StabledPets[stableSlot].value(), PetSaveMode(PET_SAVE_FIRST_STABLE_SLOT + stableSlot) };
 
        for (PetStable::PetInfo const& pet : stable.UnslottedPets)
            if (pet.PetNumber == petnumber)
                return { &pet, PET_SAVE_NOT_IN_SLOT };
    }
    else if (current)
    {
        // Current pet (slot 0)
        if (stable.CurrentPet)
            return { &stable.CurrentPet.value(), PET_SAVE_AS_CURRENT };
    }
    else if (petEntry)
    {
        // known petEntry entry (unique for summoned pet, but non unique for hunter pet (only from current or not stabled pets)
        if (stable.CurrentPet && stable.CurrentPet->CreatureId == petEntry)
            return { &stable.CurrentPet.value(), PET_SAVE_AS_CURRENT };
 
        for (PetStable::PetInfo const& pet : stable.UnslottedPets)
            if (pet.CreatureId == petEntry)
                return { &pet, PET_SAVE_NOT_IN_SLOT };
    }
    else
    {
        // Any current or other non-stabled pet (for hunter "call pet")
        if (stable.CurrentPet)
            return { &stable.CurrentPet.value(), PET_SAVE_AS_CURRENT };
 
        if (!stable.UnslottedPets.empty())
            return { &stable.UnslottedPets.front(), PET_SAVE_NOT_IN_SLOT };
    }
 
    return { nullptr, PET_SAVE_AS_DELETED };
}

References PetStable::PetInfo::CreatureId, PetStable::CurrentPet, PET_SAVE_AS_CURRENT, PET_SAVE_AS_DELETED, PET_SAVE_FIRST_STABLE_SLOT, PET_SAVE_NOT_IN_SLOT, PetStable::PetInfo::PetNumber, PetStable::StabledPets, and PetStable::UnslottedPets.

Referenced by Spell::CheckCast(), and LoadPetFromDB().

◆ GetMaxTalentPointsForLevel()

uint8 Pet::GetMaxTalentPointsForLevel ( uint8 level )

{
    uint8 points = (level >= 20) ? ((level - 16) / 4) : 0;
    // Mod points from owner SPELL_AURA_MOD_PET_TALENT_POINTS
    if (Unit* owner = GetOwner())
        points += owner->GetTotalAuraModifier(SPELL_AURA_MOD_PET_TALENT_POINTS);
 
    sScriptMgr->OnCalculateMaxTalentPointsForLevel(this, level, points);
 
    return points;
}

References GetOwner(), SPELL_AURA_MOD_PET_TALENT_POINTS, and sScriptMgr.

Referenced by addSpell(), InitTalentForLevel(), removeSpell(), and resetTalents().

◆ GetNativeObjectScale()

float Pet::GetNativeObjectScale ( ) const

overridevirtual

Reimplemented from Creature.

{
    CreatureFamilyEntry const* creatureFamily = sCreatureFamilyStore.LookupEntry(GetCreatureTemplate()->family);
    if (creatureFamily && creatureFamily->minScale > 0.0f && getPetType() == HUNTER_PET)
    {
        float scale;
        if (GetLevel() >= creatureFamily->maxScaleLevel)
            scale = creatureFamily->maxScale;
        else if (GetLevel() <= creatureFamily->minScaleLevel)
            scale = creatureFamily->minScale;
        else
            scale = creatureFamily->minScale + float(GetLevel() - creatureFamily->minScaleLevel) / creatureFamily->maxScaleLevel * (creatureFamily->maxScale - creatureFamily->minScale);
 
        if (CreatureDisplayInfoEntry const* displayInfo = sCreatureDisplayInfoStore.LookupEntry(GetNativeDisplayId()))
            if (displayInfo->scale > 1.f && GetCreatureTemplate()->IsExotic())
                scale *= displayInfo->scale;
 
        return scale;
    }
 
    return Guardian::GetNativeObjectScale();
}

References Creature::GetCreatureTemplate(), Unit::GetLevel(), Unit::GetNativeDisplayId(), Creature::GetNativeObjectScale(), getPetType(), HUNTER_PET, CreatureTemplate::IsExotic(), CreatureFamilyEntry::maxScale, CreatureFamilyEntry::maxScaleLevel, CreatureFamilyEntry::minScale, CreatureFamilyEntry::minScaleLevel, sCreatureDisplayInfoStore, and sCreatureFamilyStore.

◆ GetOwner()

Player * Pet::GetOwner ( ) const

{
    return m_owner;
}

References m_owner.

Referenced by _LoadSpellCooldowns(), AddToWorld(), CastPetAuras(), Spell::CheckCast(), Spell::EffectLearnPetSpell(), GetMaxTalentPointsForLevel(), GivePetXP(), WorldSession::HandlePetRename(), InitTalentForLevel(), Remove(), removeSpell(), resetTalents(), SavePetToDB(), SetDisplayId(), SynchronizeLevelWithOwner(), and Update().

◆ GetPetAutoSpellOnPos()

uint32 Pet::GetPetAutoSpellOnPos ( uint8 pos ) const

inlineoverridevirtual

Reimplemented from Creature.

    {
        if (pos >= m_autospells.size())
            return 0;
        else
            return m_autospells[pos];
    }

References m_autospells.

◆ GetPetAutoSpellSize()

uint8 Pet::GetPetAutoSpellSize ( ) const

inlineoverridevirtual

Reimplemented from Creature.

73{ return m_autospells.size(); }

References m_autospells.

◆ getPetType()

PetType Pet::getPetType ( ) const

inline

◆ GivePetLevel()

void Pet::GivePetLevel ( uint8 level )

{
    if (!level || level == GetLevel())
        return;
 
    if (getPetType() == HUNTER_PET)
    {
        SetUInt32Value(UNIT_FIELD_PETEXPERIENCE, 0);
        SetUInt32Value(UNIT_FIELD_PETNEXTLEVELEXP, uint32(sObjectMgr->GetXPForLevel(level)*sWorld->getRate(RATE_XP_PET_NEXT_LEVEL)));
    }
 
    InitStatsForLevel(level);
    InitLevelupSpellsForLevel();
    InitTalentForLevel();
}

References Unit::GetLevel(), getPetType(), HUNTER_PET, InitLevelupSpellsForLevel(), Guardian::InitStatsForLevel(), InitTalentForLevel(), RATE_XP_PET_NEXT_LEVEL, Object::SetUInt32Value(), sObjectMgr, sWorld, UNIT_FIELD_PETEXPERIENCE, and UNIT_FIELD_PETNEXTLEVELEXP.

Referenced by GivePetXP(), and SynchronizeLevelWithOwner().

◆ GivePetXP()

void Pet::GivePetXP ( uint32 xp )

{
    if (getPetType() != HUNTER_PET)
        return;
 
    xp *= sWorld->getRate(RATE_XP_PET);
 
    if (xp < 1)
        return;
 
    if (!IsAlive())
        return;
 
    uint8 maxlevel = std::min((uint8)sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL), GetOwner()->GetLevel());
    uint8 petlevel = GetLevel();
 
    // If pet is detected to be at, or above(?) the players level, don't hand out XP
    if (petlevel >= maxlevel)
        return;
 
    uint32 nextLvlXP = GetUInt32Value(UNIT_FIELD_PETNEXTLEVELEXP);
    uint32 curXP = GetUInt32Value(UNIT_FIELD_PETEXPERIENCE);
    uint32 newXP = curXP + xp;
 
    // Check how much XP the pet should receive, and hand off have any left from previous levelups
    while (newXP >= nextLvlXP && petlevel < maxlevel)
    {
        // Subtract newXP from amount needed for nextlevel, and give pet the level
        newXP -= nextLvlXP;
        ++petlevel;
 
        GivePetLevel(petlevel);
 
        nextLvlXP = GetUInt32Value(UNIT_FIELD_PETNEXTLEVELEXP);
    }
    // Not affected by special conditions - give it new XP
    SetUInt32Value(UNIT_FIELD_PETEXPERIENCE, petlevel < maxlevel ? newXP : 0);
}

References CONFIG_MAX_PLAYER_LEVEL, Unit::GetLevel(), GetOwner(), getPetType(), Object::GetUInt32Value(), GivePetLevel(), HUNTER_PET, Unit::IsAlive(), RATE_XP_PET, Object::SetUInt32Value(), sWorld, UNIT_FIELD_PETEXPERIENCE, and UNIT_FIELD_PETNEXTLEVELEXP.

◆ HasSpell()

bool Pet::HasSpell ( uint32 spell ) const

overridevirtual

Reimplemented from Creature.

{
    PetSpellMap::const_iterator itr = m_spells.find(spell);
    return itr != m_spells.end() && itr->second.state != PETSPELL_REMOVED;
}

References m_spells, and PETSPELL_REMOVED.

Referenced by addSpell(), Player::BuildPetTalentsInfoData(), CleanupActionBar(), pet_commandscript::HandlePetLearnCommand(), pet_commandscript::HandlePetUnlearnCommand(), and Player::LearnPetTalent().

◆ HasTempSpell()

bool Pet::HasTempSpell ( ) const

inline

146{ return m_tempspell != 0; }

References m_tempspell.

Referenced by PetAI::UpdateAI().

◆ HaveInDiet()

bool Pet::HaveInDiet ( ItemTemplate const * item ) const

{
    if (!item->FoodType)
        return false;
 
    CreatureTemplate const* cInfo = GetCreatureTemplate();
    if (!cInfo)
        return false;
 
    CreatureFamilyEntry const* cFamily = sCreatureFamilyStore.LookupEntry(cInfo->family);
    if (!cFamily)
        return false;
 
    uint32 diet = cFamily->petFoodMask;
    uint32 FoodMask = 1 << (item->FoodType - 1);
    return diet & FoodMask;
}

References CreatureTemplate::family, ItemTemplate::FoodType, Creature::GetCreatureTemplate(), CreatureFamilyEntry::petFoodMask, and sCreatureFamilyStore.

Referenced by Spell::CheckCast().

◆ InitLevelupSpellsForLevel()

void Pet::InitLevelupSpellsForLevel ( )

{
    uint8 level = GetLevel();
 
    if (PetLevelupSpellSet const* levelupSpells = GetCreatureTemplate()->family ? sSpellMgr->GetPetLevelupSpellList(GetCreatureTemplate()->family) : nullptr)
    {
        // PetLevelupSpellSet ordered by levels, process in reversed order
        for (PetLevelupSpellSet::const_reverse_iterator itr = levelupSpells->rbegin(); itr != levelupSpells->rend(); ++itr)
        {
            // will called first if level down
            if (itr->first > level && sScriptMgr->CanUnlearnSpellSet(this, itr->first, itr->second))
                unlearnSpell(itr->second, true);                 // will learn prev rank if any
            // will called if level up
            else
                learnSpell(itr->second);                        // will unlearn prev rank if any
        }
    }
 
    int32 petSpellsId = GetCreatureTemplate()->PetSpellDataId ? -(int32)GetCreatureTemplate()->PetSpellDataId : GetEntry();
 
    // default spells (can be not learned if pet level (as owner level decrease result for example) less first possible in normal game)
    if (PetDefaultSpellsEntry const* defSpells = sSpellMgr->GetPetDefaultSpellsEntry(petSpellsId))
    {
        for (uint32 spellId : defSpells->spellid)
        {
            SpellInfo const* spellEntry = sSpellMgr->GetSpellInfo(spellId);
            if (!spellEntry)
                continue;
 
            // will called first if level down
            if (spellEntry->SpellLevel > level && sScriptMgr->CanUnlearnSpellDefault(this, spellEntry))
                unlearnSpell(spellEntry->Id, true);
            // will called if level up
            else
                learnSpell(spellEntry->Id);
        }
    }
}

References Creature::GetCreatureTemplate(), Object::GetEntry(), Unit::GetLevel(), SpellInfo::Id, learnSpell(), CreatureTemplate::PetSpellDataId, SpellInfo::SpellLevel, sScriptMgr, sSpellMgr, and unlearnSpell().

Referenced by GivePetLevel(), and InitPetCreateSpells().

◆ InitPetCreateSpells()

void Pet::InitPetCreateSpells ( )

{
    m_charmInfo->InitPetActionBar();
    m_spells.clear();
 
    LearnPetPassives();
    InitLevelupSpellsForLevel();
 
    CastPetAuras(false);
}

References CastPetAuras(), InitLevelupSpellsForLevel(), CharmInfo::InitPetActionBar(), LearnPetPassives(), Unit::m_charmInfo, and m_spells.

Referenced by Unit::InitTamedPet(), and Player::SummonPet().

◆ InitTalentForLevel()

void Pet::InitTalentForLevel ( )

{
    uint8 level = GetLevel();
    uint32 talentPointsForLevel = GetMaxTalentPointsForLevel(level);
 
    Unit* owner = GetOwner();
    if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
        return;
 
    // Reset talents in case low level (on level down) or wrong points for level (hunter can unlearn TP increase talent)
    if (talentPointsForLevel == 0 || m_usedTalentCount > talentPointsForLevel)
        resetTalents(); // Remove all talent points
 
    SetFreeTalentPoints(talentPointsForLevel - m_usedTalentCount);
 
    if (!m_loading)
        owner->ToPlayer()->SendTalentsInfoData(true);
}

References Unit::GetLevel(), GetMaxTalentPointsForLevel(), GetOwner(), Object::GetTypeId(), m_loading, m_usedTalentCount, resetTalents(), Player::SendTalentsInfoData(), SetFreeTalentPoints(), Object::ToPlayer(), and TYPEID_PLAYER.

Referenced by Player::CreatePet(), Spell::EffectCreateTamedPet(), Spell::EffectTameCreature(), GivePetLevel(), and Player::SummonPet().

◆ isBeingLoaded()

bool Pet::isBeingLoaded ( ) const

inlineoverridevirtual

Reimplemented from Unit.

64{ return m_loading; }

References m_loading.

◆ isControlled()

bool Pet::isControlled ( ) const

inline

53{ return getPetType() == SUMMON_PET || getPetType() == HUNTER_PET; }

SUMMON_PET

@ SUMMON_PET

Definition: PetDefines.h:31

References getPetType(), HUNTER_PET, and SUMMON_PET.

Referenced by Unit::GetRandomContactPoint(), Unit::Kill(), LoadPetFromDB(), Player::RemovePet(), SavePetToDB(), SetDisplayId(), Player::UnsummonPetTemporaryIfAny(), Update(), and Unit::UpdateAuraForGroup().

◆ IsPermanentPetFor()

bool Pet::IsPermanentPetFor ( Player * owner ) const

{
    switch (getPetType())
    {
        case SUMMON_PET:
            switch (owner->getClass())
            {
                case CLASS_WARLOCK:
                    return GetCreatureTemplate()->type == CREATURE_TYPE_DEMON;
                case CLASS_DEATH_KNIGHT:
                    return GetCreatureTemplate()->type == CREATURE_TYPE_UNDEAD;
                case CLASS_MAGE:
                    return GetEntry() == 37994;
                default:
                    return false;
            }
        case HUNTER_PET:
            return true;
        default:
            return false;
    }
}

References CLASS_DEATH_KNIGHT, CLASS_MAGE, CLASS_WARLOCK, CREATURE_TYPE_DEMON, CREATURE_TYPE_UNDEAD, Unit::getClass(), Creature::GetCreatureTemplate(), Object::GetEntry(), getPetType(), HUNTER_PET, SUMMON_PET, and CreatureTemplate::type.

Referenced by CastPetAuras(), reset_commandscript::HandleResetTalentsCommand(), LoadPetFromDB(), and Player::PetSpellInitialize().

◆ isTemporarySummoned()

bool Pet::isTemporarySummoned ( ) const

inline

54{ return m_duration > 0s; }

References m_duration.

Referenced by LoadPetFromDB(), and Player::UnsummonPetTemporaryIfAny().

◆ LearnPetPassives()

void Pet::LearnPetPassives ( )

{
    CreatureTemplate const* cInfo = GetCreatureTemplate();
    if (!cInfo)
        return;
 
    CreatureFamilyEntry const* cFamily = sCreatureFamilyStore.LookupEntry(cInfo->family);
    if (!cFamily)
        return;
 
    PetFamilySpellsStore::const_iterator petStore = sPetFamilySpellsStore.find(cFamily->ID);
    if (petStore != sPetFamilySpellsStore.end())
    {
        // For general hunter pets skill 270
        // Passive 01~10, Passive 00 (20782, not used), Ferocious Inspiration (34457)
        // Scale 01~03 (34902~34904, bonus from owner, not used)
        for (uint32 spellId : petStore->second)
            addSpell(spellId, ACT_DECIDE, PETSPELL_NEW, PETSPELL_FAMILY);
    }
}

References ACT_DECIDE, addSpell(), CreatureTemplate::family, Creature::GetCreatureTemplate(), CreatureFamilyEntry::ID, PETSPELL_FAMILY, PETSPELL_NEW, sCreatureFamilyStore, and sPetFamilySpellsStore.

Referenced by InitPetCreateSpells().

◆ learnSpell()

bool Pet::learnSpell ( uint32 spell_id )

{
    // prevent duplicated entires in spell book
    if (!addSpell(spell_id))
        return false;
 
    if (!m_loading)
    {
        WorldPackets::Pet::PetLearnedSpell packet;
        packet.SpellID = spell_id;
        m_owner->SendDirectMessage(packet.Write());
        m_owner->PetSpellInitialize();
    }
 
    return true;
}

References addSpell(), m_loading, m_owner, Player::PetSpellInitialize(), Player::SendDirectMessage(), WorldPackets::Pet::PetLearnedSpell::SpellID, and WorldPackets::Pet::PetLearnedSpell::Write().

Referenced by Spell::EffectLearnPetSpell(), pet_commandscript::HandlePetLearnCommand(), InitLevelupSpellsForLevel(), Player::LearnPetTalent(), learnSpellHighRank(), and removeSpell().

◆ learnSpellHighRank()

void Pet::learnSpellHighRank ( uint32 spellid )

{
    learnSpell(spellid);
 
    if (uint32 next = sSpellMgr->GetNextSpellInChain(spellid))
        learnSpellHighRank(next);
}

References learnSpell(), learnSpellHighRank(), and sSpellMgr.

Referenced by learn_commandscript::HandleLearnAllMyPetTalentsCommand(), and learnSpellHighRank().

◆ LoadPetFromDB()

bool Pet::LoadPetFromDB	(	Player *	owner,
		uint32	petEntry,
		uint32	petnumber,
		bool	current,
		uint32	healthPct = `0`
	)

Todo:: pets should be summoned from real cast instead of just faking it?

{
    m_loading = true;
 
    PetStable* petStable = ASSERT_NOTNULL(owner->GetPetStable());
 
    ObjectGuid::LowType ownerid = owner->GetGUID().GetCounter();
    std::pair<PetStable::PetInfo const*, PetSaveMode> info = GetLoadPetInfo(*petStable, petEntry, petnumber, current);
    PetStable::PetInfo const* petInfo = info.first;
    PetSaveMode slot = info.second;
    if (!petInfo)
    {
        m_loading = false;
        return false;
    }
 
    // Don't try to reload the current pet
    if (petStable->CurrentPet && owner->GetPet() && petStable->CurrentPet.value().PetNumber == petInfo->PetNumber)
        return false;
 
    // we are loading pet at that moment
    if (owner->IsSpectator() || owner->GetPet() || !owner->IsInWorld() || !owner->FindMap())
        return false;
 
    bool forceLoadFromDB = false;
    sScriptMgr->OnBeforeLoadPetFromDB(owner, petEntry, petnumber, current, forceLoadFromDB);
 
    if (!forceLoadFromDB && (owner->getClass() == CLASS_DEATH_KNIGHT && !owner->CanSeeDKPet())) // DK Pet exception
        return false;
 
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(petInfo->CreatedBySpellId);
 
    bool isTemporarySummon = spellInfo && spellInfo->GetDuration() > 0;
    if (current && isTemporarySummon)
        return false;
 
    if (petInfo->Type == HUNTER_PET)
    {
        CreatureTemplate const* creatureInfo = sObjectMgr->GetCreatureTemplate(petInfo->CreatureId);
        if (!creatureInfo || !creatureInfo->IsTameable(owner->CanTameExoticPets()))
            return false;
    }
 
    if (current && owner->IsPetNeedBeTemporaryUnsummoned())
    {
        owner->SetTemporaryUnsummonedPetNumber(petInfo->PetNumber);
        return false;
    }
 
    Map* map = owner->GetMap();
    ObjectGuid::LowType guid = map->GenerateLowGuid<HighGuid::Pet>();
 
    if (!Create(guid, map, owner->GetPhaseMask(), petInfo->CreatureId, petInfo->PetNumber))
        return false;
 
    setPetType(petInfo->Type);
    SetFaction(owner->GetFaction());
    SetUInt32Value(UNIT_CREATED_BY_SPELL, petInfo->CreatedBySpellId);
 
    if (IsCritter())
    {
        float px, py, pz;
        owner->GetClosePoint(px, py, pz, GetCombatReach(), PET_FOLLOW_DIST, GetFollowAngle());
        Relocate(px, py, pz, owner->GetOrientation());
 
        if (!IsPositionValid())
        {
            LOG_ERROR("entities.pet", "Pet{} not loaded. Suggested coordinates isn't valid (X: {} Y: {})",
                GetGUID().ToString(), GetPositionX(), GetPositionY());
            return false;
        }
 
        UpdatePositionData();
        map->AddToMap(ToCreature(), true);
        return true;
    }
 
    if (getPetType() == HUNTER_PET || GetCreatureTemplate()->type == CREATURE_TYPE_DEMON || GetCreatureTemplate()->type == CREATURE_TYPE_UNDEAD)
        GetCharmInfo()->SetPetNumber(petInfo->PetNumber, IsPermanentPetFor(owner)); // Show pet details tab (Shift+P) only for hunter pets, demons or undead
    else
        GetCharmInfo()->SetPetNumber(petInfo->PetNumber, false);
 
    SetDisplayId(petInfo->DisplayId);
    SetNativeDisplayId(petInfo->DisplayId);
    UpdatePositionData();
    uint8 petlevel = petInfo->Level;
    ReplaceAllNpcFlags(UNIT_NPC_FLAG_NONE);
    SetName(petInfo->Name);
 
    switch (getPetType())
    {
        case SUMMON_PET:
            petlevel = owner->GetLevel();
 
            if (IsPetGhoul())
                SetUInt32Value(UNIT_FIELD_BYTES_0, 0x400); // class = rogue
            else
                SetUInt32Value(UNIT_FIELD_BYTES_0, 0x800); // class = mage
 
            ReplaceAllUnitFlags(UNIT_FLAG_PLAYER_CONTROLLED); // this enables popup window (pet dismiss, cancel)
            break;
        case HUNTER_PET:
            SetUInt32Value(UNIT_FIELD_BYTES_0, 0x02020100); // class = warrior, gender = none, power = focus
            SetSheath(SHEATH_STATE_MELEE);
            SetByteFlag(UNIT_FIELD_BYTES_2, 2, petInfo->WasRenamed ? UNIT_CAN_BE_ABANDONED : UNIT_CAN_BE_RENAMED | UNIT_CAN_BE_ABANDONED);
 
            ReplaceAllUnitFlags(UNIT_FLAG_PLAYER_CONTROLLED);
                                                            // this enables popup window (pet abandon, cancel)
            SetMaxPower(POWER_HAPPINESS, GetCreatePowers(POWER_HAPPINESS));
            SetPower(POWER_HAPPINESS, petInfo->Happiness);
            setPowerType(POWER_FOCUS);
            break;
        default:
            if (!IsPetGhoul())
                LOG_ERROR("entities.pet", "Pet have incorrect type ({}) for pet loading.", getPetType());
            break;
    }
 
    SetUInt32Value(UNIT_FIELD_PET_NAME_TIMESTAMP, uint32(GameTime::GetGameTime().count())); // cast can't be helped here
    SetCreatorGUID(owner->GetGUID());
 
    InitStatsForLevel(petlevel);
    SetUInt32Value(UNIT_FIELD_PETEXPERIENCE, petInfo->Experience);
 
    SynchronizeLevelWithOwner();
 
    // Set pet's position after setting level, its size depends on it
    float px, py, pz;
    owner->GetClosePoint(px, py, pz, GetCombatReach(), PET_FOLLOW_DIST, GetFollowAngle());
    Relocate(px, py, pz, owner->GetOrientation());
    if (!IsPositionValid())
    {
        LOG_ERROR("entities.pet", "Pet {} not loaded. Suggested coordinates isn't valid (X: {} Y: {})",
            GetGUID().ToString(), GetPositionX(), GetPositionY());
        return false;
    }
 
    SetReactState(petInfo->ReactState);
    SetCanModifyStats(true);
 
    // set current pet as current
    // 0=current
    // 1..MAX_PET_STABLES in stable slot
    // PET_SAVE_NOT_IN_SLOT(100) = not stable slot (summoning))
    if (slot == PET_SAVE_NOT_IN_SLOT)
    {
        uint32 petInfoNumber = petInfo->PetNumber;
        if (petStable->CurrentPet)
            owner->RemovePet(nullptr, PET_SAVE_NOT_IN_SLOT);
 
        auto unslottedPetItr = std::find_if(petStable->UnslottedPets.begin(), petStable->UnslottedPets.end(), [&](PetStable::PetInfo const& unslottedPet)
        {
            return unslottedPet.PetNumber == petInfoNumber;
        });
 
        ASSERT(!petStable->CurrentPet);
        ASSERT(unslottedPetItr != petStable->UnslottedPets.end());
 
        petStable->CurrentPet = std::move(*unslottedPetItr);
        petStable->UnslottedPets.erase(unslottedPetItr);
 
        // old petInfo pointer is no longer valid, refresh it
        petInfo = &petStable->CurrentPet.value();
    }
    else if (PET_SAVE_FIRST_STABLE_SLOT <= slot && slot <= PET_SAVE_LAST_STABLE_SLOT)
    {
        auto stabledPet = std::find_if(petStable->StabledPets.begin(), petStable->StabledPets.end(), [petnumber](Optional<PetStable::PetInfo> const& pet)
        {
            return pet && pet->PetNumber == petnumber;
        });
 
        ASSERT(stabledPet != petStable->StabledPets.end());
 
        std::swap(*stabledPet, petStable->CurrentPet);
 
        // old petInfo pointer is no longer valid, refresh it
        petInfo = &petStable->CurrentPet.value();
    }
 
    // Send fake summon spell cast - this is needed for correct cooldown application for spells
    // Example: 46584 - without this cooldown (which should be set always when pet is loaded) isn't set clientside
    if (petInfo->CreatedBySpellId)
    {
        WorldPacket data(SMSG_SPELL_GO, (8 + 8 + 4 + 4 + 2));
        data << owner->GetPackGUID();
        data << owner->GetPackGUID();
        data << uint8(0);
        data << uint32(petInfo->CreatedBySpellId);
        data << uint32(256); // CAST_FLAG_UNKNOWN3
        data << uint32(0);
        owner->SendMessageToSet(&data, true);
    }
 
    owner->SetMinion(this, true);
 
    if (!isTemporarySummon)
        m_charmInfo->LoadPetActionBar(petInfo->ActionBar);
 
    map->AddToMap(ToCreature(), true);
 
    //set last used pet number (for use in BG's)
    if (owner->GetTypeId() == TYPEID_PLAYER && isControlled() && !isTemporarySummoned() && (getPetType() == SUMMON_PET || getPetType() == HUNTER_PET))
        owner->ToPlayer()->SetLastPetNumber(petInfo->PetNumber);
 
    owner->GetSession()->AddQueryHolderCallback(CharacterDatabase.DelayQueryHolder(std::make_shared<PetLoadQueryHolder>(ownerid, petInfo->PetNumber)))
        .AfterComplete([this, owner, session = owner->GetSession(), isTemporarySummon, current, lastSaveTime = petInfo->LastSaveTime, savedhealth = petInfo->Health, savedmana = petInfo->Mana, healthPct]
        (SQLQueryHolderBase const& holder)
    {
        if (session->GetPlayer() != owner || owner->GetPet() != this)
            return;
 
        // passing previous checks ensure that 'this' is still valid
        if (m_removed)
            return;
 
        InitTalentForLevel(); // set original talents points before spell loading
 
        uint32 timediff = uint32(GameTime::GetGameTime().count() - lastSaveTime);
        _LoadAuras(holder.GetPreparedResult(PetLoadQueryHolder::AURAS), timediff);
 
        // load action bar, if data broken will fill later by default spells.
        if (!isTemporarySummon)
        {
            _LoadSpells(holder.GetPreparedResult(PetLoadQueryHolder::SPELLS));
            InitTalentForLevel(); // re-init to check talent count
            _LoadSpellCooldowns(holder.GetPreparedResult(PetLoadQueryHolder::COOLDOWNS));
            LearnPetPassives();
            InitLevelupSpellsForLevel();
            if (GetMap()->IsBattleArena())
                RemoveArenaAuras();
 
            CastPetAuras(current);
        }
 
        CleanupActionBar();                                     // remove unknown spells from action bar after load
 
        LOG_DEBUG("entities.pet", "New Pet has {}", GetGUID().ToString());
 
        owner->PetSpellInitialize();
        owner->SendTalentsInfoData(true);
 
        if (owner->GetGroup())
            owner->SetGroupUpdateFlag(GROUP_UPDATE_PET);
 
        if (getPetType() == HUNTER_PET)
        {
            if (PreparedQueryResult result = holder.GetPreparedResult(PetLoadQueryHolder::DECLINED_NAMES))
            {
                m_declinedname = std::make_unique<DeclinedName>();
                Field* fields = result->Fetch();
                for (uint8 i = 0; i < MAX_DECLINED_NAME_CASES; ++i)
                    m_declinedname->name[i] = fields[i].Get<std::string>();
            }
        }
 
        uint32 curHealth = savedhealth;
        if (healthPct)
        {
            curHealth = CountPctFromMaxHealth(healthPct);
        }
 
        if (getPetType() == SUMMON_PET && !current) //all (?) summon pets come with full health when called, but not when they are current
        {
            SetPower(POWER_MANA, GetMaxPower(POWER_MANA));
            SetFullHealth();
        }
        else
        {
            if (!curHealth && getPetType() == HUNTER_PET)
                setDeathState(JUST_DIED);
            else
            {
                SetHealth(curHealth > GetMaxHealth() ? GetMaxHealth() : curHealth);
                SetPower(POWER_MANA, savedmana > GetMaxPower(POWER_MANA) ? GetMaxPower(POWER_MANA) : savedmana);
            }
        }
 
        // must be after SetMinion (owner guid check)
        //LoadTemplateImmunities();
        //LoadMechanicTemplateImmunity();
        m_loading = false;
    });
 
    return true;
}

Referenced by spell_gen_pet_summoned::HandleScript(), WorldSession::HandleStableSwapPet(), WorldSession::HandleUnstablePet(), Player::LoadPet(), Player::ResummonPetTemporaryUnSummonedIfAny(), and Player::SummonPet().

◆ LoseHappiness()

void Pet::LoseHappiness ( )

{
    uint32 curValue = GetPower(POWER_HAPPINESS);
    if (curValue <= 0)
        return;
    int32 addvalue = 670;                                   //value is 70/35/17/8/4 (per min) * 1000 / 8 (timer 7.5 secs)
    if (IsInCombat())                                        //we know in combat happiness fades faster, multiplier guess
        addvalue = int32(addvalue * 1.5f);
    ModifyPower(POWER_HAPPINESS, -addvalue);
}

References Unit::GetPower(), Unit::IsInCombat(), Unit::ModifyPower(), and POWER_HAPPINESS.

Referenced by Update().

◆ Remove()

void Pet::Remove	(	PetSaveMode	mode,
		bool	returnreagent = `false`
	)

{
    GetOwner()->RemovePet(this, mode, returnreagent);
}

References GetOwner(), and Player::RemovePet().

Referenced by Spell::EffectDismissPet(), AuraEffect::HandleModPossessPet(), TempSummon::UnSummon(), and Update().

◆ RemoveFromWorld()

void Pet::RemoveFromWorld ( )

overridevirtual

Remove the pet from the accessor
Don't call the function for Creature, normal mobs + totems go in a different storage

Reimplemented from Minion.

{
    if (IsInWorld())
    {
        Unit::RemoveFromWorld();
        GetMap()->GetObjectsStore().Remove<Pet>(GetGUID());
    }
}

References Object::GetGUID(), WorldObject::GetMap(), Map::GetObjectsStore(), Object::IsInWorld(), TypeUnorderedMapContainer< OBJECT_TYPES, KEY_TYPE >::Remove(), and Unit::RemoveFromWorld().

◆ removeSpell()

bool Pet::removeSpell	(	uint32	spell_id,
		bool	learn_prev,
		bool	clear_ab = `true`
	)

{
    PetSpellMap::iterator itr = m_spells.find(spell_id);
    if (itr == m_spells.end())
        return false;
 
    if (itr->second.state == PETSPELL_REMOVED)
        return false;
 
    if (itr->second.state == PETSPELL_NEW)
        m_spells.erase(itr);
    else
        itr->second.state = PETSPELL_REMOVED;
 
    RemoveAurasDueToSpell(spell_id);
 
    uint32 talentCost = GetTalentSpellCost(spell_id);
    if (talentCost > 0)
    {
        if (m_usedTalentCount > talentCost)
            m_usedTalentCount -= talentCost;
        else
            m_usedTalentCount = 0;
        // update free talent points
        int32 free_points = GetMaxTalentPointsForLevel(GetLevel()) - m_usedTalentCount;
        SetFreeTalentPoints(free_points > 0 ? free_points : 0);
    }
 
    if (learn_prev)
    {
        if (uint32 prev_id = sSpellMgr->GetPrevSpellInChain (spell_id))
            learnSpell(prev_id);
        else
            learn_prev = false;
    }
 
    // if remove last rank or non-ranked then update action bar at server and client if need
    if (clear_ab && !learn_prev && m_charmInfo->RemoveSpellFromActionBar(spell_id))
    {
        if (!m_loading)
        {
            // need update action bar for last removed rank
            if (Unit* owner = GetOwner())
                if (owner->GetTypeId() == TYPEID_PLAYER)
                    owner->ToPlayer()->PetSpellInitialize();
        }
    }
 
    return true;
}

References Unit::GetLevel(), GetMaxTalentPointsForLevel(), GetOwner(), GetTalentSpellCost(), learnSpell(), Unit::m_charmInfo, m_loading, m_spells, m_usedTalentCount, PETSPELL_NEW, PETSPELL_REMOVED, Unit::RemoveAurasDueToSpell(), CharmInfo::RemoveSpellFromActionBar(), SetFreeTalentPoints(), sSpellMgr, and TYPEID_PLAYER.

Referenced by addSpell(), pet_commandscript::HandlePetUnlearnCommand(), and unlearnSpell().

◆ RemoveSpellCooldown()

void Pet::RemoveSpellCooldown	(	uint32	spell_id,
		bool	update
	)

{
    m_CreatureSpellCooldowns.erase(spell_id);
 
    if (update)
    {
        if (Player* playerOwner = GetCharmerOrOwnerPlayerOrPlayerItself())
        {
            WorldPacket data(SMSG_CLEAR_COOLDOWN, 4 + 8);
            data << uint32(spell_id);
            data << GetGUID();
            playerOwner->SendDirectMessage(&data);
        }
    }
}

References Unit::GetCharmerOrOwnerPlayerOrPlayerItself(), Object::GetGUID(), Creature::m_CreatureSpellCooldowns, and SMSG_CLEAR_COOLDOWN.

Referenced by WorldSession::HandlePetActionHelper().

◆ ResetAuraUpdateMaskForRaid()

void Pet::ResetAuraUpdateMaskForRaid ( )

inline

137{ m_auraRaidUpdateMask = 0; }

References m_auraRaidUpdateMask.

◆ resetTalents()

bool Pet::resetTalents ( )

{
    Unit* owner = GetOwner();
    if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
        return false;
 
    if (!sScriptMgr->CanResetTalents(this))
        return false;
 
    // not need after this call
    if (owner->ToPlayer()->HasAtLoginFlag(AT_LOGIN_RESET_PET_TALENTS))
        owner->ToPlayer()->RemoveAtLoginFlag(AT_LOGIN_RESET_PET_TALENTS, true);
 
    CreatureTemplate const* ci = GetCreatureTemplate();
    if (!ci)
        return false;
    // Check pet talent type
    CreatureFamilyEntry const* pet_family = sCreatureFamilyStore.LookupEntry(ci->family);
    if (!pet_family || pet_family->petTalentType < 0)
        return false;
 
    Player* player = owner->ToPlayer();
 
    uint8 level = GetLevel();
    uint32 talentPointsForLevel = GetMaxTalentPointsForLevel(level);
 
    if (m_usedTalentCount == 0)
    {
        SetFreeTalentPoints(talentPointsForLevel);
        return false;
    }
 
    for (uint32 i = 0; i < sTalentStore.GetNumRows(); ++i)
    {
        TalentEntry const* talentInfo = sTalentStore.LookupEntry(i);
        if (!talentInfo)
            continue;
 
        TalentTabEntry const* talentTabInfo = sTalentTabStore.LookupEntry(talentInfo->TalentTab);
        if (!talentTabInfo)
            continue;
 
        // unlearn only talents for pets family talent type
        if (!((1 << pet_family->petTalentType) & talentTabInfo->petTalentMask))
            continue;
 
        for (uint32 talentSpellId : talentInfo->RankID)
        {
            for (PetSpellMap::const_iterator itr = m_spells.begin(); itr != m_spells.end();)
            {
                if (itr->second.state == PETSPELL_REMOVED)
                {
                    ++itr;
                    continue;
                }
                // remove learned spells (all ranks)
                uint32 itrFirstId = sSpellMgr->GetFirstSpellInChain(itr->first);
 
                // unlearn if first rank is talent or learned by talent
                if (itrFirstId == talentSpellId)
                {
                    unlearnSpell(itr->first, false);
                    itr = m_spells.begin();
                    continue;
                }
                else
                    ++itr;
            }
        }
    }
 
    SetFreeTalentPoints(talentPointsForLevel);
 
    if (!m_loading)
        player->PetSpellInitialize();
    return true;
}

References AT_LOGIN_RESET_PET_TALENTS, CreatureTemplate::family, Creature::GetCreatureTemplate(), Unit::GetLevel(), GetMaxTalentPointsForLevel(), GetOwner(), Object::GetTypeId(), Player::HasAtLoginFlag(), m_loading, m_spells, m_usedTalentCount, PETSPELL_REMOVED, Player::PetSpellInitialize(), TalentTabEntry::petTalentMask, CreatureFamilyEntry::petTalentType, TalentEntry::RankID, Player::RemoveAtLoginFlag(), sCreatureFamilyStore, SetFreeTalentPoints(), sScriptMgr, sSpellMgr, sTalentStore, sTalentTabStore, TalentEntry::TalentTab, Object::ToPlayer(), TYPEID_PLAYER, and unlearnSpell().

Referenced by reset_commandscript::HandleResetTalentsCommand(), InitTalentForLevel(), Player::ResetPetTalents(), and resetTalentsForAllPetsOf().

◆ resetTalentsForAllPetsOf()

void Pet::resetTalentsForAllPetsOf	(	Player *	owner,
		Pet *	online_pet = `nullptr`
	)

static

{
    // not need after this call
    if (owner->ToPlayer()->HasAtLoginFlag(AT_LOGIN_RESET_PET_TALENTS))
        owner->ToPlayer()->RemoveAtLoginFlag(AT_LOGIN_RESET_PET_TALENTS, true);
 
    // reset for online
    if (onlinePet)
        onlinePet->resetTalents();
 
    PetStable* petStable = owner->GetPetStable();
    if (!petStable)
        return;
 
    std::unordered_set<uint32> petIds;
    if (petStable->CurrentPet)
        petIds.insert(petStable->CurrentPet->PetNumber);
 
    for (Optional<PetStable::PetInfo> const& stabledPet : petStable->StabledPets)
        if (stabledPet)
            petIds.insert(stabledPet->PetNumber);
 
    for (PetStable::PetInfo const& unslottedPet : petStable->UnslottedPets)
        petIds.insert(unslottedPet.PetNumber);
 
    // now need only reset for offline pets (all pets except online case)
    if (onlinePet)
        petIds.erase(onlinePet->GetCharmInfo()->GetPetNumber());
 
    // no offline pets
    if (!petIds.empty())
        return;
 
    bool need_comma = false;
    std::ostringstream ss;
    ss << "DELETE FROM pet_spell WHERE guid IN (";
 
    for (uint32 id : petIds)
    {
        if (need_comma)
            ss << ',';
 
        ss << id;
 
        need_comma = true;
    }
 
    ss << ") AND spell IN (";
 
    need_comma = false;
    for (uint32 spell : sPetTalentSpells)
    {
        if (need_comma)
            ss << ',';
 
        ss << spell;
 
        need_comma = true;
    }
 
    ss << ')';
 
    CharacterDatabase.Execute(ss.str().c_str());
}

References AT_LOGIN_RESET_PET_TALENTS, CharacterDatabase, PetStable::CurrentPet, Unit::GetCharmInfo(), CharmInfo::GetPetNumber(), Player::GetPetStable(), Player::HasAtLoginFlag(), PetStable::PetInfo::PetNumber, Player::RemoveAtLoginFlag(), resetTalents(), sPetTalentSpells, PetStable::StabledPets, Object::ToPlayer(), and PetStable::UnslottedPets.

Referenced by WorldSession::HandlePlayerLoginFromDB(), and reset_commandscript::HandleResetTalentsCommand().

◆ SavePetToDB()

void Pet::SavePetToDB ( PetSaveMode mode )

{
    // not save not player pets
    if (!GetOwnerGUID().IsPlayer())
        return;
 
    // dont allow to save pet when it is loaded, possibly bugs action bar!, save only fully controlled creature
    Player* owner = GetOwner()->ToPlayer();
    if (!owner || m_loading || !GetEntry() || !isControlled())
        return;
 
    // not save pet as current if another pet temporary unsummoned
    if (mode == PET_SAVE_AS_CURRENT && owner->GetTemporaryUnsummonedPetNumber() &&
            owner->GetTemporaryUnsummonedPetNumber() != m_charmInfo->GetPetNumber())
    {
        // pet will lost anyway at restore temporary unsummoned
        if (getPetType() == HUNTER_PET)
            return;
 
        // for warlock case
        mode = PET_SAVE_NOT_IN_SLOT;
    }
 
    uint32 curhealth = GetHealth();
    uint32 curmana = GetPower(POWER_MANA);
 
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
    // save auras before possibly removing them
    _SaveAuras(trans);
 
    // stable and not in slot saves
    if (mode > PET_SAVE_AS_CURRENT)
        RemoveAllAuras();
 
    _SaveSpells(trans);
    _SaveSpellCooldowns(trans);
    CharacterDatabase.CommitTransaction(trans);
 
    // current/stable/not_in_slot
    if (mode >= PET_SAVE_AS_CURRENT)
    {
        ObjectGuid::LowType ownerLowGUID = GetOwnerGUID().GetCounter();
        trans = CharacterDatabase.BeginTransaction();
        // remove current data
 
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_PET_BY_ID);
        stmt->SetData(0, m_charmInfo->GetPetNumber());
        trans->Append(stmt);
 
        // prevent existence another hunter pet in PET_SAVE_AS_CURRENT and PET_SAVE_NOT_IN_SLOT
        if (getPetType() == HUNTER_PET && (mode == PET_SAVE_AS_CURRENT || mode > PET_SAVE_LAST_STABLE_SLOT))
        {
            stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_PET_BY_SLOT);
            stmt->SetData(0, ownerLowGUID);
            stmt->SetData(1, uint8(PET_SAVE_AS_CURRENT));
            stmt->SetData(2, uint8(PET_SAVE_LAST_STABLE_SLOT));
            trans->Append(stmt);
        }
 
        // save pet
        std::string actionBar = GenerateActionBarData();
 
        if (owner->GetPetStable()->CurrentPet && owner->GetPetStable()->CurrentPet->PetNumber == m_charmInfo->GetPetNumber())
        {
            FillPetInfo(&owner->GetPetStable()->CurrentPet.value());
        }
 
        stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_CHAR_PET);
        stmt->SetData(0, m_charmInfo->GetPetNumber());
        stmt->SetData(1, GetEntry());
        stmt->SetData(2, ownerLowGUID);
        stmt->SetData(3, GetNativeDisplayId());
        stmt->SetData(4, GetUInt32Value(UNIT_CREATED_BY_SPELL));
        stmt->SetData(5, uint8(getPetType()));
        stmt->SetData(6, GetLevel());
        stmt->SetData(7, GetUInt32Value(UNIT_FIELD_PETEXPERIENCE));
        stmt->SetData(8, uint8(GetReactState()));
        stmt->SetData(9, GetName());
        stmt->SetData(10, uint8(HasByteFlag(UNIT_FIELD_BYTES_2, 2, UNIT_CAN_BE_RENAMED) ? 0 : 1));
        stmt->SetData(11, uint8(mode));
        stmt->SetData(12, curhealth);
        stmt->SetData(13, curmana);
        stmt->SetData(14, GetPower(POWER_HAPPINESS));
        stmt->SetData(15, GameTime::GetGameTime().count());
        stmt->SetData(16, actionBar);
 
        trans->Append(stmt);
        CharacterDatabase.CommitTransaction(trans);
    }
    // delete
    else
    {
        RemoveAllAuras();
        DeleteFromDB(m_charmInfo->GetPetNumber());
    }
}

References _SaveAuras(), _SaveSpellCooldowns(), _SaveSpells(), CHAR_DEL_CHAR_PET_BY_ID, CHAR_DEL_CHAR_PET_BY_SLOT, CHAR_REP_CHAR_PET, CharacterDatabase, PetStable::CurrentPet, DeleteFromDB(), FillPetInfo(), GenerateActionBarData(), ObjectGuid::GetCounter(), Object::GetEntry(), GameTime::GetGameTime(), Unit::GetHealth(), Unit::GetLevel(), WorldObject::GetName(), Unit::GetNativeDisplayId(), GetOwner(), Unit::GetOwnerGUID(), CharmInfo::GetPetNumber(), Player::GetPetStable(), getPetType(), Unit::GetPower(), Creature::GetReactState(), Player::GetTemporaryUnsummonedPetNumber(), Object::GetUInt32Value(), Object::HasByteFlag(), HUNTER_PET, isControlled(), Object::IsPlayer(), Unit::m_charmInfo, m_loading, PET_SAVE_AS_CURRENT, PET_SAVE_LAST_STABLE_SLOT, PET_SAVE_NOT_IN_SLOT, POWER_HAPPINESS, POWER_MANA, Unit::RemoveAllAuras(), PreparedStatementBase::SetData(), Object::ToPlayer(), UNIT_CAN_BE_RENAMED, UNIT_CREATED_BY_SPELL, UNIT_FIELD_BYTES_2, and UNIT_FIELD_PETEXPERIENCE.

Referenced by Player::CreatePet(), Spell::EffectCreateTamedPet(), Spell::EffectLearnPetSpell(), Spell::EffectResurrectPet(), Spell::EffectTameCreature(), Player::RemovePet(), and Player::SummonPet().

◆ SaveToDB()

void Pet::SaveToDB	(	uint32	,
		uint8	,
		uint32
	)

inlineoverrideprivatevirtual

Reimplemented from TempSummon.

    {
        ABORT();
    }

References ABORT.

◆ SetAuraUpdateMaskForRaid()

void Pet::SetAuraUpdateMaskForRaid ( uint8 slot )

inline

136{ m_auraRaidUpdateMask |= (uint64(1) << slot); }

uint64

std::uint64_t uint64

Definition: Define.h:107

References m_auraRaidUpdateMask.

Referenced by Unit::UpdateAuraForGroup().

◆ setDeathState()

void Pet::setDeathState	(	DeathState	s,
		bool	despawn = `false`
	)

overridevirtual

Reimplemented from Minion.

{
    Creature::setDeathState(s);
    if (getDeathState() == CORPSE)
    {
        if (getPetType() == HUNTER_PET)
        {
            // pet corpse non lootable and non skinnable
            ReplaceAllDynamicFlags(UNIT_DYNFLAG_NONE);
            RemoveUnitFlag(UNIT_FLAG_SKINNABLE);
 
            //lose happiness when died and not in BG/Arena
            MapEntry const* mapEntry = sMapStore.LookupEntry(GetMapId());
            if (!mapEntry || (mapEntry->map_type != MAP_ARENA && mapEntry->map_type != MAP_BATTLEGROUND))
                ModifyPower(POWER_HAPPINESS, -HAPPINESS_LEVEL_SIZE);
 
            //SetUnitFlag(UNIT_FLAG_STUNNED);
        }
    }
    else if (getDeathState() == ALIVE)
    {
        //RemoveUnitFlag(UNIT_FLAG_STUNNED);
        CastPetAuras(true);
    }
}

References ALIVE, CastPetAuras(), CORPSE, Unit::getDeathState(), WorldLocation::GetMapId(), getPetType(), HAPPINESS_LEVEL_SIZE, HUNTER_PET, MAP_ARENA, MAP_BATTLEGROUND, MapEntry::map_type, Unit::ModifyPower(), POWER_HAPPINESS, Unit::RemoveUnitFlag(), Unit::ReplaceAllDynamicFlags(), Creature::setDeathState(), sMapStore, UNIT_DYNFLAG_NONE, and UNIT_FLAG_SKINNABLE.

Referenced by Spell::EffectResurrectPet(), and LoadPetFromDB().

◆ SetDisplayId()

void Pet::SetDisplayId ( uint32 modelId )

overridevirtual

Reimplemented from Creature.

{
    Guardian::SetDisplayId(modelId);
 
    if (!isControlled())
        return;
 
    if (Unit* owner = GetOwner())
        if (Player* player = owner->ToPlayer())
            if (player->GetGroup())
                player->SetGroupUpdateFlag(GROUP_UPDATE_FLAG_PET_MODEL_ID);
}

References GetOwner(), GROUP_UPDATE_FLAG_PET_MODEL_ID, isControlled(), Creature::SetDisplayId(), and Object::ToPlayer().

Referenced by CreateBaseAtCreature(), Spell::EffectResurrectPet(), and LoadPetFromDB().

◆ SetDuration()

void Pet::SetDuration ( Milliseconds dur )

inline

89{ m_duration = dur; }

References m_duration.

Referenced by Player::SummonPet().

◆ SetFreeTalentPoints()

void Pet::SetFreeTalentPoints ( uint8 points )

inline

131{ SetByteValue(UNIT_FIELD_BYTES_1, UNIT_BYTES_1_OFFSET_PET_TALENTS, points); }

UNIT_BYTES_1_OFFSET_PET_TALENTS

@ UNIT_BYTES_1_OFFSET_PET_TALENTS

Definition: Unit.h:45

Object::SetByteValue

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

Definition: Object.cpp:750

References Object::SetByteValue(), UNIT_BYTES_1_OFFSET_PET_TALENTS, and UNIT_FIELD_BYTES_1.

Referenced by addSpell(), learn_commandscript::HandleLearnAllMyPetTalentsCommand(), InitTalentForLevel(), Player::LearnPetTalent(), removeSpell(), and resetTalents().

◆ SetLoading()

void Pet::SetLoading ( bool load )

inline

144{ m_loading = load; }

References m_loading.

◆ setPetType()

void Pet::setPetType ( PetType type )

inline

52{ m_petType = type; }

References m_petType.

Referenced by LoadPetFromDB().

◆ SynchronizeLevelWithOwner()

void Pet::SynchronizeLevelWithOwner ( )

{
    Unit* owner = GetOwner();
    if (!owner || owner->GetTypeId() != TYPEID_PLAYER)
        return;
 
    switch (getPetType())
    {
        // always same level
        case SUMMON_PET:
            GivePetLevel(owner->GetLevel());
            break;
        // can't be greater owner level
        case HUNTER_PET:
            if (GetLevel() > owner->GetLevel())
                GivePetLevel(owner->GetLevel());
            else if (GetLevel() + 5 < owner->GetLevel())
                GivePetLevel(owner->GetLevel() - 5);
            break;
        default:
            break;
    }
}

References Unit::GetLevel(), GetOwner(), getPetType(), Object::GetTypeId(), GivePetLevel(), HUNTER_PET, SUMMON_PET, and TYPEID_PLAYER.

Referenced by LoadPetFromDB().

◆ ToggleAutocast()

void Pet::ToggleAutocast	(	SpellInfo const *	spellInfo,
		bool	apply
	)

{
    ASSERT(spellInfo);
 
    if (!spellInfo->IsAutocastable())
        return;
 
    PetSpellMap::iterator itr = m_spells.find(spellInfo->Id);
    if (itr == m_spells.end())
        return;
 
    auto autospellItr = std::find(m_autospells.begin(), m_autospells.end(), spellInfo->Id);
 
    if (apply)
    {
        if (autospellItr == m_autospells.end())
        {
            m_autospells.push_back(spellInfo->Id);
 
            if (itr->second.active != ACT_ENABLED)
            {
                itr->second.active = ACT_ENABLED;
                if (itr->second.state != PETSPELL_NEW)
                    itr->second.state = PETSPELL_CHANGED;
            }
        }
    }
    else
    {
        if (autospellItr != m_autospells.end())
        {
            m_autospells.erase(autospellItr);
            if (itr->second.active != ACT_DISABLED)
            {
                itr->second.active = ACT_DISABLED;
                if (itr->second.state != PETSPELL_NEW)
                    itr->second.state = PETSPELL_CHANGED;
            }
        }
    }
}

References ACT_DISABLED, ACT_ENABLED, ASSERT, SpellInfo::Id, SpellInfo::IsAutocastable(), m_autospells, m_spells, PETSPELL_CHANGED, and PETSPELL_NEW.

Referenced by addSpell(), and CleanupActionBar().

◆ unlearnSpell()

bool Pet::unlearnSpell	(	uint32	spell_id,
		bool	learn_prev,
		bool	clear_ab = `true`
	)

{
    if (removeSpell(spell_id, learn_prev, clear_ab))
    {
        if (!m_loading)
        {
            WorldPackets::Pet::PetUnlearnedSpell packet;
            packet.SpellID = spell_id;
            m_owner->SendDirectMessage(packet.Write());
        }
 
        return true;
    }
 
    return false;
}

References m_loading, m_owner, removeSpell(), Player::SendDirectMessage(), WorldPackets::Pet::PetUnlearnedSpell::SpellID, and WorldPackets::Pet::PetUnlearnedSpell::Write().

Referenced by addSpell(), InitLevelupSpellsForLevel(), and resetTalents().

◆ Update()

void Pet::Update ( uint32 diff )

overridevirtual

Reimplemented from TempSummon.

{
    auto _diff = Milliseconds(diff);
 
    if (m_removed)                                           // pet already removed, just wait in remove queue, no updates
        return;
 
    if (m_loading)
        return;
 
    switch (m_deathState)
    {
        case CORPSE:
            {
                if (getPetType() != HUNTER_PET || m_corpseRemoveTime <= GameTime::GetGameTime().count())
                {
                    Remove(PET_SAVE_NOT_IN_SLOT);               //hunters' pets never get removed because of death, NEVER!
                    return;
                }
                break;
            }
        case ALIVE:
            {
                // unsummon pet that lost owner
                Player* owner = GetOwner();
                if (!owner || (!IsWithinDistInMap(owner, GetMap()->GetVisibilityRange()) && !isPossessed()) || (isControlled() && !owner->GetPetGUID()))
                    //if (!owner || (!IsWithinDistInMap(owner, GetMap()->GetVisibilityDistance()) && (owner->GetCharmGUID() && (owner->GetCharmGUID() != GetGUID()))) || (isControlled() && !owner->GetPetGUID()))
                {
                    Remove(PET_SAVE_NOT_IN_SLOT, true);
                    return;
                }
 
                if (isControlled())
                {
                    if (owner->GetPetGUID() != GetGUID())
                    {
                        LOG_ERROR("entities.pet", "Pet {} is not pet of owner {}, removed", GetEntry(), GetOwner()->GetName());
                        ASSERT(getPetType() != HUNTER_PET, "Unexpected unlinked pet found for owner {}", owner->GetSession()->GetPlayerInfo());
                        Remove(PET_SAVE_NOT_IN_SLOT);
                        return;
                    }
                }
 
                if (m_duration > 0s)
                {
                    if (m_duration > _diff)
                        m_duration -= _diff;
                    else
                    {
                        Remove(getPetType() != SUMMON_PET ? PET_SAVE_AS_DELETED : PET_SAVE_NOT_IN_SLOT);
                        return;
                    }
                }
 
                // xinef: m_regenTimer is decrased in Creature::Update()
                // xinef: just check if we can update focus in current period
                if (getPowerType() == POWER_FOCUS)
                {
                    m_petRegenTimer -= _diff;
                    if (m_petRegenTimer <= 0s)
                    {
                        m_petRegenTimer += PET_FOCUS_REGEN_INTERVAL;
                        Regenerate(POWER_FOCUS);
                    }
                }
 
                if (m_tempspell)
                {
                    Unit* tempspellTarget = m_tempspellTarget;
                    Unit* tempoldTarget = m_tempoldTarget;
                    bool tempspellIsPositive = m_tempspellIsPositive;
                    uint32 tempspell = m_tempspell;
                    Unit* charmer = GetCharmerOrOwner();
                    if (!charmer)
                        return;
 
                    if (!GetCharmInfo())
                        return;
 
                    if (tempspellTarget && tempspellTarget->IsAlive())
                    {
                        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(tempspell);
                        if (!spellInfo)
                            return;
                        float max_range = GetSpellMaxRangeForTarget(tempspellTarget, spellInfo);
                        if (spellInfo->RangeEntry->Flags == SPELL_RANGE_MELEE)
                            max_range -= 2 * MIN_MELEE_REACH;
 
                        if (IsWithinLOSInMap(tempspellTarget) && GetDistance(tempspellTarget) < max_range)
                        {
                            if (!GetCharmInfo()->GetGlobalCooldownMgr().HasGlobalCooldown(spellInfo) && !HasSpellCooldown(tempspell))
                            {
                                StopMoving();
                                GetMotionMaster()->Clear(false);
                                GetMotionMaster()->MoveIdle();
 
                                bool oldCmdAttack = GetCharmInfo()->IsCommandAttack();
 
                                GetCharmInfo()->SetIsCommandAttack(false);
                                GetCharmInfo()->SetIsAtStay(true);
                                GetCharmInfo()->SetIsCommandFollow(false);
                                GetCharmInfo()->SetIsFollowing(false);
                                GetCharmInfo()->SetIsReturning(false);
                                GetCharmInfo()->SaveStayPosition(true);
 
                                GetCharmInfo()->SetIsCommandAttack(oldCmdAttack);
 
                                AddSpellCooldown(tempspell, 0, spellInfo->IsCooldownStartedOnEvent() ? infinityCooldownDelay : 0);
 
                                CastSpell(tempspellTarget, tempspell, false);
                                m_tempspell = 0;
                                m_tempspellTarget = nullptr;
 
                                if (tempspellIsPositive)
                                {
                                    if (tempoldTarget && tempoldTarget->IsAlive())
                                    {
                                        GetCharmInfo()->SetIsCommandAttack(true);
                                        GetCharmInfo()->SetIsAtStay(false);
                                        GetCharmInfo()->SetIsFollowing(false);
                                        GetCharmInfo()->SetIsCommandFollow(false);
                                        GetCharmInfo()->SetIsReturning(false);
 
                                        if (ToCreature() && ToCreature()->IsAIEnabled)
                                            ToCreature()->AI()->AttackStart(tempoldTarget);
                                    }
                                    else
                                    {
                                        if (IsAIEnabled)
                                            AI()->PetStopAttack();
                                        else
                                        {
                                            GetCharmInfo()->SetCommandState(COMMAND_FOLLOW);
                                            GetCharmInfo()->SetIsCommandAttack(false);
                                            GetCharmInfo()->SetIsAtStay(false);
                                            GetCharmInfo()->SetIsReturning(true);
                                            GetCharmInfo()->SetIsCommandFollow(true);
                                            GetCharmInfo()->SetIsFollowing(false);
                                            GetMotionMaster()->MoveFollow(charmer, PET_FOLLOW_DIST, GetFollowAngle());
                                        }
                                    }
 
                                    m_tempoldTarget = nullptr;
                                    m_tempspellIsPositive = false;
                                }
                            }
                        }
                    }
                    else
                    {
                        m_tempspell = 0;
                        m_tempspellTarget = nullptr;
                        m_tempoldTarget = nullptr;
                        m_tempspellIsPositive = false;
 
                        Unit* victim = charmer->GetVictim();
                        if (victim && victim->IsAlive())
                        {
                            StopMoving();
                            GetMotionMaster()->Clear(false);
                            GetMotionMaster()->MoveIdle();
 
                            GetCharmInfo()->SetIsCommandAttack(true);
                            GetCharmInfo()->SetIsAtStay(false);
                            GetCharmInfo()->SetIsFollowing(false);
                            GetCharmInfo()->SetIsCommandFollow(false);
                            GetCharmInfo()->SetIsReturning(false);
 
                            if (ToCreature() && ToCreature()->IsAIEnabled)
                                ToCreature()->AI()->AttackStart(victim);
                        }
                        else
                        {
                            StopMoving();
                            GetMotionMaster()->Clear(false);
                            GetMotionMaster()->MoveIdle();
 
                            GetCharmInfo()->SetCommandState(COMMAND_FOLLOW);
                            GetCharmInfo()->SetIsCommandAttack(false);
                            GetCharmInfo()->SetIsAtStay(false);
                            GetCharmInfo()->SetIsReturning(true);
                            GetCharmInfo()->SetIsCommandFollow(true);
                            GetCharmInfo()->SetIsFollowing(false);
                            GetMotionMaster()->MoveFollow(charmer, PET_FOLLOW_DIST, GetFollowAngle());
                        }
                    }
                }
 
                if (getPetType() == HUNTER_PET)
                {
                    m_happinessTimer -= diff;
                    if (m_happinessTimer <= int32(0))
                    {
                        LoseHappiness();
                        m_happinessTimer += PET_LOSE_HAPPINES_INTERVAL;
                    }
                }
 
                break;
            }
        default:
            break;
    }
 
    Creature::Update(diff);
}

References Creature::AddSpellCooldown(), Creature::AI(), ALIVE, ASSERT, UnitAI::AttackStart(), Unit::CastSpell(), MotionMaster::Clear(), COMMAND_FOLLOW, CORPSE, SpellRangeEntry::Flags, Unit::GetCharmerOrOwner(), Unit::GetCharmInfo(), WorldObject::GetDistance(), Object::GetEntry(), Minion::GetFollowAngle(), GameTime::GetGameTime(), Object::GetGUID(), WorldObject::GetMap(), Unit::GetMotionMaster(), WorldObject::GetName(), GetOwner(), Unit::GetPetGUID(), getPetType(), WorldSession::GetPlayerInfo(), Unit::getPowerType(), Player::GetSession(), Unit::GetSpellMaxRangeForTarget(), Unit::GetVictim(), WorldObject::GetVisibilityRange(), Creature::HasSpellCooldown(), HUNTER_PET, infinityCooldownDelay, Unit::IsAIEnabled, Unit::IsAlive(), CharmInfo::IsCommandAttack(), isControlled(), SpellInfo::IsCooldownStartedOnEvent(), Unit::isPossessed(), WorldObject::IsWithinDistInMap(), WorldObject::IsWithinLOSInMap(), LOG_ERROR, LoseHappiness(), Creature::m_corpseRemoveTime, Unit::m_deathState, m_duration, m_happinessTimer, m_loading, m_petRegenTimer, m_removed, m_tempoldTarget, m_tempspell, m_tempspellIsPositive, m_tempspellTarget, MIN_MELEE_REACH, MotionMaster::MoveFollow(), MotionMaster::MoveIdle(), PET_FOCUS_REGEN_INTERVAL, PET_FOLLOW_DIST, PET_LOSE_HAPPINES_INTERVAL, PET_SAVE_AS_DELETED, PET_SAVE_NOT_IN_SLOT, CreatureAI::PetStopAttack(), POWER_FOCUS, SpellInfo::RangeEntry, Creature::Regenerate(), Remove(), CharmInfo::SaveStayPosition(), CharmInfo::SetCommandState(), CharmInfo::SetIsAtStay(), CharmInfo::SetIsCommandAttack(), CharmInfo::SetIsCommandFollow(), CharmInfo::SetIsFollowing(), CharmInfo::SetIsReturning(), SPELL_RANGE_MELEE, sSpellMgr, Unit::StopMoving(), SUMMON_PET, Object::ToCreature(), and Creature::Update().

Member Data Documentation

◆ m_auraRaidUpdateMask

uint64 Pet::m_auraRaidUpdateMask

protected

Referenced by GetAuraUpdateMaskForRaid(), ResetAuraUpdateMaskForRaid(), and SetAuraUpdateMaskForRaid().

◆ m_autospells

AutoSpellList Pet::m_autospells

Referenced by GetPetAutoSpellOnPos(), GetPetAutoSpellSize(), and ToggleAutocast().

◆ m_declinedname

std::unique_ptr<DeclinedName> Pet::m_declinedname

protected

Referenced by GetDeclinedNames(), and LoadPetFromDB().

◆ m_duration

Milliseconds Pet::m_duration

protected

Referenced by GetDuration(), isTemporarySummoned(), SetDuration(), and Update().

◆ m_happinessTimer

int32 Pet::m_happinessTimer

protected

Referenced by Update().

◆ m_loading

bool Pet::m_loading

protected

Referenced by InitTalentForLevel(), isBeingLoaded(), learnSpell(), LoadPetFromDB(), removeSpell(), resetTalents(), SavePetToDB(), SetLoading(), unlearnSpell(), and Update().

◆ m_owner

Player* Pet::m_owner

protected

Referenced by GetOwner(), learnSpell(), Pet(), and unlearnSpell().

◆ m_petRegenTimer

Milliseconds Pet::m_petRegenTimer

protected

Referenced by Update().

◆ m_petType

PetType Pet::m_petType

protected

Referenced by getPetType(), and setPetType().

◆ m_removed

bool Pet::m_removed

Referenced by Player::RemovePet(), and Update().

◆ m_spells

PetSpellMap Pet::m_spells

Referenced by _SaveSpells(), addSpell(), HasSpell(), InitPetCreateSpells(), Player::PetSpellInitialize(), removeSpell(), resetTalents(), and ToggleAutocast().

◆ m_tempoldTarget

Unit* Pet::m_tempoldTarget

protected

Referenced by CastWhenWillAvailable(), ClearCastWhenWillAvailable(), and Update().

◆ m_tempspell

uint32 Pet::m_tempspell

protected

Referenced by CastWhenWillAvailable(), ClearCastWhenWillAvailable(), HasTempSpell(), and Update().

◆ m_tempspellIsPositive

bool Pet::m_tempspellIsPositive

protected

Referenced by CastWhenWillAvailable(), ClearCastWhenWillAvailable(), and Update().

◆ m_tempspellTarget

Unit* Pet::m_tempspellTarget

protected

Referenced by CastWhenWillAvailable(), ClearCastWhenWillAvailable(), and Update().

◆ m_usedTalentCount

uint32 Pet::m_usedTalentCount

Referenced by addSpell(), InitTalentForLevel(), removeSpell(), Player::ResetPetTalents(), and resetTalents().

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Pet()

◆ ~Pet()

Member Function Documentation

◆ _LoadAuras()

◆ _LoadSpellCooldowns()

◆ _LoadSpells()

◆ _SaveAuras()

◆ _SaveSpellCooldowns()

◆ _SaveSpells()

◆ addSpell()

◆ AddToWorld()

◆ CastPetAuras()

◆ CastWhenWillAvailable()

◆ CleanupActionBar()

◆ ClearCastWhenWillAvailable()

◆ Create()

◆ CreateBaseAtCreature()

◆ CreateBaseAtCreatureInfo()

◆ CreateBaseAtTamed()

◆ DeleteFromDB() [1/2]

◆ DeleteFromDB() [2/2]

◆ FillPetInfo()

◆ GenerateActionBarData()

◆ GetAuraUpdateMaskForRaid()

◆ GetCurrentFoodBenefitLevel()

◆ GetDebugInfo()

◆ GetDeclinedNames()

◆ GetDuration()

◆ GetFreeTalentPoints()

◆ GetHappinessState()

◆ GetLoadPetInfo()

◆ GetMaxTalentPointsForLevel()

◆ GetNativeObjectScale()

◆ GetOwner()

◆ GetPetAutoSpellOnPos()

◆ GetPetAutoSpellSize()

◆ getPetType()

◆ GivePetLevel()

◆ GivePetXP()

◆ HasSpell()

◆ HasTempSpell()

◆ HaveInDiet()

◆ InitLevelupSpellsForLevel()

◆ InitPetCreateSpells()

◆ InitTalentForLevel()

◆ isBeingLoaded()

◆ isControlled()

◆ IsPermanentPetFor()

◆ isTemporarySummoned()

◆ LearnPetPassives()

◆ learnSpell()

◆ learnSpellHighRank()

◆ LoadPetFromDB()

◆ LoseHappiness()

◆ Remove()

◆ RemoveFromWorld()

◆ removeSpell()

◆ RemoveSpellCooldown()

◆ ResetAuraUpdateMaskForRaid()

◆ resetTalents()

◆ resetTalentsForAllPetsOf()

◆ SavePetToDB()

◆ SaveToDB()

◆ SetAuraUpdateMaskForRaid()

◆ setDeathState()

◆ SetDisplayId()

◆ SetDuration()

◆ SetFreeTalentPoints()

◆ SetLoading()

◆ setPetType()

◆ SynchronizeLevelWithOwner()

◆ ToggleAutocast()