Player.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "Player.h"
#include "AreaTrigger.h"
#include "AccountMgr.h"
#include "AchievementMgr.h"
#include "ArenaTeam.h"
#include "ArenaTeamMgr.h"
#include "AzeriteEmpoweredItem.h"
#include "AzeriteItem.h"
#include "Bag.h"
#include "Battlefield.h"
#include "BattlefieldMgr.h"
#include "Battleground.h"
#include "BattlegroundMgr.h"
#include "BattlegroundPackets.h"
#include "BattlegroundScore.h"
#include "BattlePetMgr.h"
#include "CellImpl.h"
#include "Channel.h"
#include "ChannelMgr.h"
#include "CharacterCache.h"
#include "CharacterDatabaseCleaner.h"
#include "CharacterTemplateDataStore.h"
#include "CharacterPackets.h"
#include "CharmInfo.h"
#include "Chat.h"
#include "ChatPackets.h"
#include "ChatTextBuilder.h"
#include "CinematicMgr.h"
#include "ClubUtils.h"
#include "CombatLogPackets.h"
#include "CombatPackets.h"
#include "Common.h"
#include "ConditionMgr.h"
#include "Containers.h"
#include "CreatureAI.h"
#include "DB2Stores.h"
#include "DatabaseEnv.h"
#include "DisableMgr.h"
#include "DuelPackets.h"
#include "EquipmentSetPackets.h"
#include "Formulas.h"
#include "GameEventMgr.h"
#include "GameEventSender.h"
#include "GameObjectAI.h"
#include "Garrison.h"
#include "GarrisonMgr.h"
#include "GitRevision.h"
#include "GossipDef.h"
#include "GridNotifiers.h"
#include "GridNotifiersImpl.h"
#include "Group.h"
#include "GroupMgr.h"
#include "GameTables.h"
#include "GameTime.h"
#include "Guild.h"
#include "GuildMgr.h"
#include "InstanceLockMgr.h"
#include "InstancePackets.h"
#include "InstanceScript.h"
#include "ItemPackets.h"
#include "Language.h"
#include "LanguageMgr.h"
#include "LFGMgr.h"
#include "ListUtils.h"
#include "Log.h"
#include "Loot.h"
#include "LootItemStorage.h"
#include "LootMgr.h"
#include "LootPackets.h"
#include "Mail.h"
#include "MailPackets.h"
#include "MapManager.h"
#include "MiscPackets.h"
#include "MotionMaster.h"
#include "MovementPackets.h"
#include "ObjectAccessor.h"
#include "ObjectMgr.h"
#include "Opcodes.h"
#include "OutdoorPvP.h"
#include "OutdoorPvPMgr.h"
#include "PartyPackets.h"
#include "Pet.h"
#include "PetPackets.h"
#include "PoolMgr.h"
#include "PetitionMgr.h"
#include "PhasingHandler.h"
#include "QueryCallback.h"
#include "QueryHolder.h"
#include "QuestDef.h"
#include "QuestObjectiveCriteriaMgr.h"
#include "QuestPackets.h"
#include "RealmList.h"
#include "ReputationMgr.h"
#include "RestMgr.h"
#include "Scenario.h"
#include "SkillDiscovery.h"
#include "SocialMgr.h"
#include "Spell.h"
#include "SpellAuraEffects.h"
#include "SpellAuras.h"
#include "SpellCastRequest.h"
#include "SpellHistory.h"
#include "SpellMgr.h"
#include "SpellPackets.h"
#include "StringConvert.h"
#include "TalentPackets.h"
#include "TerrainMgr.h"
#include "ToyPackets.h"
#include "TradeData.h"
#include "TraitMgr.h"
#include "TraitPacketsCommon.h"
#include "Transport.h"
#include "UpdateData.h"
#include "Util.h"
#include "Vehicle.h"
#include "VehiclePackets.h"
#include "Vignette.h"
#include "VignettePackets.h"
#include "World.h"
#include "WorldPacket.h"
#include "WorldSession.h"
#include "WorldStateMgr.h"
#include "WorldStatePackets.h"
#include <boost/dynamic_bitset.hpp>
#include <G3D/g3dmath.h>
#include <sstream>
 
#define ZONE_UPDATE_INTERVAL (1*IN_MILLISECONDS)
 
// corpse reclaim times
#define DEATH_EXPIRE_STEP (5*MINUTE)
#define MAX_DEATH_COUNT 3
 
enum PlayerSpells
{
 SPELL_EXPERIENCE_ELIMINATED = 206662,
 SPELL_APPRENTICE_RIDING = 33389,
 SPELL_JOURNEYMAN_RIDING = 33391
};
 
static uint32 copseReclaimDelay[MAX_DEATH_COUNT] = { 30, 60, 120 };
 
uint64 const MAX_MONEY_AMOUNT = 99999999999ULL;
 
Player::Player(WorldSession* session) : Unit(true), m_sceneMgr(this)
{
 m_objectType |= TYPEMASK_PLAYER;
 m_objectTypeId = TYPEID_PLAYER;
 
 m_session = session;
 
 m_modMeleeHitChance = 7.5f;
 m_modRangedHitChance = 7.5f;
 m_modSpellHitChance = 15.0f;
 
 m_ingametime = 0;
 m_sharedQuestId = 0;
 
 m_ExtraFlags = 0;
 
 m_spellModTakingSpell = nullptr;
 
 // players always accept
 if (!GetSession()->HasPermission(rbac::RBAC_PERM_CAN_FILTER_WHISPERS))
 SetAcceptWhispers(true);
 
 m_regenInterruptTimestamp = GameTime::Now();
 m_regenTimer = 0;
 m_regenTimerCount = 0;
 m_weaponChangeTimer = 0;
 
 m_zoneUpdateId = uint32(-1);
 m_zoneUpdateTimer = 0;
 
 m_areaUpdateId = 0;
 m_team = TEAM_OTHER;
 
 m_nextSave = sWorld->getIntConfig(CONFIG_INTERVAL_SAVE);
 m_customizationsChanged = false;
 
 memset(m_items, 0, sizeof(Item*)*PLAYER_SLOTS_COUNT);
 
 m_social = nullptr;
 
 // group is initialized in the reference constructor
 SetGroupInvite(nullptr);
 m_groupUpdateMask = 0;
 m_bPassOnGroupLoot = false;
 
 m_GuildIdInvited = UI64LIT(0);
 m_ArenaTeamIdInvited = 0;
 
 m_atLoginFlags = AT_LOGIN_NONE;
 
 mSemaphoreTeleport_Near = false;
 mSemaphoreTeleport_Far = false;
 
 m_DelayedOperations = 0;
 m_bCanDelayTeleport = false;
 m_bHasDelayedTeleport = false;
 m_teleport_options = TELE_TO_NONE;
 m_newWorldCounter = 0;
 
 m_trade = nullptr;
 
 m_createTime = 0;
 m_createMode = PlayerCreateMode::Normal;
 m_cinematic = 0;
 
 m_movie = 0;
 
 PlayerTalkClass = std::make_unique<PlayerMenu>(GetSession());
 m_currentBuybackSlot = BUYBACK_SLOT_START;
 
 m_DailyQuestChanged = false;
 m_lastDailyQuestTime = 0;
 
 m_MirrorTimer.fill(DISABLED_MIRROR_TIMER);
 m_MirrorTimerFlags = UNDERWATER_NONE;
 m_MirrorTimerFlagsLast = UNDERWATER_NONE;
 
 m_hostileReferenceCheckTimer = 0;
 m_drunkTimer = 0;
 m_deathTimer = 0;
 m_deathExpireTime = 0;
 
 for (uint8 j = 0; j < PLAYER_MAX_BATTLEGROUND_QUEUES; ++j)
 {
 m_bgBattlegroundQueueID[j].bgQueueTypeId = BATTLEGROUND_QUEUE_NONE;
 m_bgBattlegroundQueueID[j].invitedToInstance = 0;
 m_bgBattlegroundQueueID[j].joinTime = 0;
 }
 
 m_logintime = GameTime::GetGameTime();
 m_Last_tick = m_logintime;
 m_Played_time = { };
 m_WeaponProficiency = 0;
 m_ArmorProficiency = 0;
 m_canParry = false;
 m_canBlock = false;
 m_canTitanGrip = false;
 m_titanGripPenaltySpellId = 0;
 
 m_temporaryUnsummonedPetNumber = 0;
 //cache for CreatedBySpell to allow
 //returning reagents for temporarily removed pets
 //when dying/logging out
 m_oldpetspell = 0;
 m_lastpetnumber = 0;
 
 m_mailsUpdated = false;
 unReadMails = 0;
 m_nextMailDelivereTime = 0;
 
 m_itemUpdateQueueBlocked = false;
 
 m_forced_speed_changes = { };
 
 m_movementForceModMagnitudeChanges = 0;
 
 
 m_HomebindTimer = 0;
 m_InstanceValid = true;
 m_dungeonDifficulty = DIFFICULTY_NORMAL;
 m_raidDifficulty = DIFFICULTY_NORMAL_RAID;
 m_legacyRaidDifficulty = DIFFICULTY_10_N;
 
 m_lastPotionId = 0;
 m_empowerMinHoldStagePercent = 1.0f;
 
 m_auraBaseFlatMod.fill(0.0f);
 m_auraBasePctMod.fill(1.0f);
 m_baseRatingValue = { };
 
 m_baseSpellPower = 0;
 m_baseManaRegen = 0;
 m_baseHealthRegen = 0;
 m_spellPenetrationItemMod = 0;
 
 // Honor System
 m_lastHonorUpdateTime = GameTime::GetGameTime();
 
 m_IsBGRandomWinner = false;
 
 // Player summoning
 m_summon_expire = 0;
 
 m_unitMovedByMe = this;
 m_playerMovingMe = this;
 m_seer = this;
 
 m_homebindAreaId = 0;
 
 m_contestedPvPTimer = 0;
 
 m_isActive = true;
 
 m_lastFallTime = 0;
 m_lastFallZ = 0;
 
 m_fishingSteps = 0;
 
 m_ControlledByPlayer = true;
 
 sWorld->IncreasePlayerCount();
 
 m_ChampioningFaction = 0;
 
 m_powerFraction.fill(0.0f);
 
 isDebugAreaTriggers = false;
 
 m_WeeklyQuestChanged = false;
 m_MonthlyQuestChanged = false;
 m_SeasonalQuestChanged = false;
 
 SetPendingBind(0, 0);
 
 _activeCheats = CHEAT_NONE;
 healthBeforeDuel = 0;
 manaBeforeDuel = 0;
 
 memset(_voidStorageItems, 0, VOID_STORAGE_MAX_SLOT * sizeof(VoidStorageItem*));
 
 _cinematicMgr = std::make_unique<CinematicMgr>(this);
 
 m_achievementMgr = std::make_unique<PlayerAchievementMgr>(this);
 m_reputationMgr = std::make_unique<ReputationMgr>(this);
 m_questObjectiveCriteriaMgr = std::make_unique<QuestObjectiveCriteriaMgr>(this);
 
 for (uint8 i = 0; i < MAX_CUF_PROFILES; ++i)
 _CUFProfiles[i] = nullptr;
 
 _advancedCombatLoggingEnabled = false;
 
 _restMgr = std::make_unique<RestMgr>(this);
 
 _usePvpItemLevels = false;
}
 
Player::~Player()
{
 // it must be unloaded already in PlayerLogout and accessed only for logged in player
 //m_social = nullptr;
 
 // Note: buy back item already deleted from DB when player was saved
 for (uint8 i = 0; i < PLAYER_SLOTS_COUNT; ++i)
 delete m_items[i];
 
 //all mailed items should be deleted, also all mail should be deallocated
 for (PlayerMails::iterator itr = m_mail.begin(); itr != m_mail.end(); ++itr)
 delete *itr;
 
 for (ItemMap::iterator iter = mMitems.begin(); iter != mMitems.end(); ++iter)
 delete iter->second; //if item is duplicated... then server may crash ... but that item should be deallocated
 
 for (size_t x = 0; x < ItemSetEff.size(); x++)
 delete ItemSetEff[x];
 
 for (uint8 i = 0; i < VOID_STORAGE_MAX_SLOT; ++i)
 delete _voidStorageItems[i];
 
 sWorld->DecreasePlayerCount();
}
 
void Player::CleanupsBeforeDelete(bool finalCleanup)
{
 TradeCancel(false);
 DuelComplete(DUEL_INTERRUPTED);
 
 Unit::CleanupsBeforeDelete(finalCleanup);
}
 
bool Player::Create(ObjectGuid::LowType guidlow, WorldPackets::Character::CharacterCreateInfo const* createInfo)
{
 //FIXME: outfitId not used in player creating
 
 Object::_Create(ObjectGuid::Create<HighGuid::Player>(guidlow));
 
 m_name = createInfo->Name;
 
 PlayerInfo const* info = sObjectMgr->GetPlayerInfo(createInfo->Race, createInfo->Class);
 if (!info)
 {
 TC_LOG_ERROR("entities.player.cheat", "Player::Create: Possible hacking attempt: Account {} tried to create a character named '{}' with an invalid race/class pair ({}/{}) - refusing to do so.",
 GetSession()->GetAccountId(), m_name, createInfo->Race, createInfo->Class);
 return false;
 }
 
 for (uint8 i = 0; i < PLAYER_SLOTS_COUNT; i++)
 m_items[i] = nullptr;
 
 ChrClassesEntry const* cEntry = sChrClassesStore.LookupEntry(createInfo->Class);
 if (!cEntry)
 {
 TC_LOG_ERROR("entities.player.cheat", "Player::Create: Possible hacking attempt: Account {} tried to create a character named '{}' with an invalid character class ({}) - refusing to do so (wrong DBC-files?)",
 GetSession()->GetAccountId(), m_name, createInfo->Class);
 return false;
 }
 
 if (!GetSession()->ValidateAppearance(Races(createInfo->Race), Classes(createInfo->Class), Gender(createInfo->Sex), MakeChrCustomizationChoiceRange(createInfo->Customizations)))
 {
 TC_LOG_ERROR("entities.player.cheat", "Player::Create: Possible hacking-attempt: Account {} tried creating a character named '{}' with invalid appearance attributes - refusing to do so",
 GetSession()->GetAccountId(), m_name);
 return false;
 }
 
 PlayerInfo::CreatePosition const& position = createInfo->UseNPE && info->createPositionNPE ? *info->createPositionNPE : info->createPosition;
 
 m_createTime = GameTime::GetGameTime();
 m_createMode = createInfo->UseNPE && info->createPositionNPE ? PlayerCreateMode::NPE : PlayerCreateMode::Normal;
 
 Relocate(position.Loc);
 
 SetMap(sMapMgr->CreateMap(position.Loc.GetMapId(), this));
 
 if (position.TransportGuid)
 {
 if (Transport* transport = ObjectAccessor::GetTransport(*this, ObjectGuid::Create<HighGuid::Transport>(*position.TransportGuid)))
 {
 transport->AddPassenger(this);
 m_movementInfo.transport.pos.Relocate(position.Loc);
 float x, y, z, o;
 position.Loc.GetPosition(x, y, z, o);
 transport->CalculatePassengerPosition(x, y, z, &o);
 Relocate(x, y, z, o);
 }
 }
 
 // set initial homebind position
 SetHomebind(*this, GetAreaId());
 
 uint8 powertype = cEntry->DisplayPower;
 
 SetObjectScale(1.0f);
 
 SetFactionForRace(createInfo->Race);
 
 if (!IsValidGender(createInfo->Sex))
 {
 TC_LOG_ERROR("entities.player.cheat", "Player::Create: Possible hacking attempt: Account {} tried to create a character named '{}' with an invalid gender ({}) - refusing to do so",
 GetSession()->GetAccountId(), m_name, createInfo->Sex);
 return false;
 }
 
 SetRace(createInfo->Race);
 SetClass(createInfo->Class);
 SetGender(Gender(createInfo->Sex));
 SetPowerType(Powers(powertype), false);
 InitDisplayIds();
 if (sWorld->getIntConfig(CONFIG_GAME_TYPE) == REALM_TYPE_PVP || sWorld->getIntConfig(CONFIG_GAME_TYPE) == REALM_TYPE_RPPVP)
 {
 SetPvpFlag(UNIT_BYTE2_FLAG_PVP);
 SetUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED);
 }
 
 SetUnitFlag2(UNIT_FLAG2_REGENERATE_POWER);
 
 SetWatchedFactionIndex(-1);
 
 SetCustomizations(Trinity::Containers::MakeIteratorPair(createInfo->Customizations.begin(), createInfo->Customizations.end()));
 SetRestState(REST_TYPE_XP, (GetSession()->IsARecruiter() || GetSession()->GetRecruiterId() != 0) ? REST_STATE_RAF_LINKED : REST_STATE_NORMAL);
 SetRestState(REST_TYPE_HONOR, REST_STATE_NORMAL);
 SetNativeGender(Gender(createInfo->Sex));
 SetInventorySlotCount(INVENTORY_DEFAULT_SIZE);
 
 // set starting level
 SetLevel(GetStartLevel(createInfo->Race, createInfo->Class, createInfo->TemplateSet));
 
 InitRunes();
 
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::Coinage), sWorld->getIntConfig(CONFIG_START_PLAYER_MONEY));
 
 // Played time
 m_Last_tick = GameTime::GetGameTime();
 m_Played_time[PLAYED_TIME_TOTAL] = 0;
 m_Played_time[PLAYED_TIME_LEVEL] = 0;
 
 // base stats and related field values
 InitStatsForLevel();
 InitTaxiNodesForLevel();
 InitTalentForLevel();
 InitializeSkillFields();
 InitPrimaryProfessions(); // to max set before any spell added
 
 // apply original stats mods before spell loading or item equipment that call before equip _RemoveStatsMods()
 UpdateMaxHealth(); // Update max Health (for add bonus from stamina)
 SetFullHealth();
 SetFullPower(POWER_MANA);
 
 // original spells
 LearnDefaultSkills();
 LearnCustomSpells();
 
 // Original action bar. Do not use Player::AddActionButton because we do not have skill spells loaded at this time
 // but checks will still be performed later when loading character from db in Player::_LoadActions
 for (PlayerCreateInfoActions::const_iterator action_itr = info->action.begin(); action_itr != info->action.end(); ++action_itr)
 {
 // create new button
 ActionButton& ab = m_actionButtons[action_itr->button];
 
 // set data
 ab.SetActionAndType(action_itr->action, ActionButtonType(action_itr->type));
 }
 
 // original items
 for (PlayerCreateInfoItem initialItem : info->item)
 StoreNewItemInBestSlots(initialItem.item_id, initialItem.item_amount, info->itemContext);
 
 // bags and main-hand weapon must equipped at this moment
 // now second pass for not equipped (offhand weapon/shield if it attempt equipped before main-hand weapon)
 // or ammo not equipped in special bag
 uint8 inventoryEnd = INVENTORY_SLOT_ITEM_START + GetInventorySlotCount();
 for (uint8 i = INVENTORY_SLOT_ITEM_START; i < inventoryEnd; i++)
 {
 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
 {
 uint16 eDest;
 // equip offhand weapon/shield if it attempt equipped before main-hand weapon
 InventoryResult msg = CanEquipItem(NULL_SLOT, eDest, pItem, false);
 if (msg == EQUIP_ERR_OK)
 {
 RemoveItem(INVENTORY_SLOT_BAG_0, i, true);
 EquipItem(eDest, pItem, true);
 }
 // move other items to more appropriate slots
 else
 {
 ItemPosCountVec sDest;
 msg = CanStoreItem(NULL_BAG, NULL_SLOT, sDest, pItem, false);
 if (msg == EQUIP_ERR_OK)
 {
 RemoveItem(INVENTORY_SLOT_BAG_0, i, true);
 StoreItem(sDest, pItem, true);
 }
 }
 }
 }
 // all item positions resolved
 
 if (ChrSpecializationEntry const* defaultSpec = sDB2Manager.GetDefaultChrSpecializationForClass(GetClass()))
 {
 SetActiveTalentGroup(defaultSpec->OrderIndex);
 SetPrimarySpecialization(defaultSpec->ID);
 }
 
 GetThreatManager().Initialize();
 
 return true;
}
 
bool Player::StoreNewItemInBestSlots(uint32 itemId, uint32 amount, ItemContext context)
{
 TC_LOG_DEBUG("entities.player.items", "Player::StoreNewItemInBestSlots: Player '{}' ({}) creates initial item (ItemID: {}, Count: {})",
 GetName(), GetGUID().ToString(), itemId, amount);
 
 // attempt equip by one
 while (amount > 0)
 {
 uint16 eDest;
 InventoryResult msg = CanEquipNewItem(NULL_SLOT, eDest, itemId, false);
 if (msg != EQUIP_ERR_OK)
 break;
 
 EquipNewItem(eDest, itemId, context, true);
 AutoUnequipOffhandIfNeed();
 --amount;
 }
 
 if (amount == 0)
 return true; // equipped
 
 // attempt store
 ItemPosCountVec sDest;
 // store in main bag to simplify second pass (special bags can be not equipped yet at this moment)
 InventoryResult msg = CanStoreNewItem(INVENTORY_SLOT_BAG_0, NULL_SLOT, sDest, itemId, amount);
 if (msg == EQUIP_ERR_OK)
 {
 StoreNewItem(sDest, itemId, true, GenerateItemRandomBonusListId(itemId), GuidSet(), context);
 return true; // stored
 }
 
 // item can't be added
 TC_LOG_ERROR("entities.player.items", "Player::StoreNewItemInBestSlots: Player '{}' ({}) can't equip or store initial item (ItemID: {}, Race: {}, Class: {}, InventoryResult: {})",
 GetName(), GetGUID().ToString(), itemId, GetRace(), GetClass(), msg);
 return false;
}
 
void Player::SendMirrorTimer(MirrorTimerType Type, uint32 MaxValue, uint32 CurrentValue, int32 Regen)
{
 if (int(MaxValue) == DISABLED_MIRROR_TIMER)
 {
 if (int(CurrentValue) != DISABLED_MIRROR_TIMER)
 StopMirrorTimer(Type);
 return;
 }
 
 SendDirectMessage(WorldPackets::Misc::StartMirrorTimer(Type, CurrentValue, MaxValue, Regen, 0, false).Write());
}
 
void Player::StopMirrorTimer(MirrorTimerType Type)
{
 m_MirrorTimer[Type] = DISABLED_MIRROR_TIMER;
 SendDirectMessage(WorldPackets::Misc::StopMirrorTimer(Type).Write());
}
 
bool Player::IsImmuneToEnvironmentalDamage() const
{
 // check for GM and death state included in isAttackableByAOE
 return !isTargetableForAttack(false);
}
 
uint32 Player::EnvironmentalDamage(EnviromentalDamage type, uint32 damage)
{
 if (IsImmuneToEnvironmentalDamage())
 return 0;
 
 damage *= GetTotalAuraMultiplier(SPELL_AURA_MOD_ENVIRONMENTAL_DAMAGE_TAKEN);
 
 // Absorb, resist some environmental damage type
 uint32 absorb = 0;
 uint32 resist = 0;
 switch (type)
 {
 case DAMAGE_LAVA:
 case DAMAGE_SLIME:
 {
 DamageInfo dmgInfo(this, this, damage, nullptr, type == DAMAGE_LAVA ? SPELL_SCHOOL_MASK_FIRE : SPELL_SCHOOL_MASK_NATURE, DIRECT_DAMAGE, BASE_ATTACK);
 Unit::CalcAbsorbResist(dmgInfo);
 absorb = dmgInfo.GetAbsorb();
 resist = dmgInfo.GetResist();
 damage = dmgInfo.GetDamage();
 break;
 }
 default:
 break;
 }
 
 Unit::DealDamageMods(nullptr, this, damage, &absorb);
 
 WorldPackets::CombatLog::EnvironmentalDamageLog packet;
 packet.Victim = GetGUID();
 packet.Type = type != DAMAGE_FALL_TO_VOID ? type : DAMAGE_FALL;
 packet.Amount = damage;
 packet.Absorbed = absorb;
 packet.Resisted = resist;
 
 uint32 final_damage = Unit::DealDamage(this, this, damage, nullptr, SELF_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, nullptr, false);
 
 packet.LogData.Initialize(this);
 SendCombatLogMessage(&packet);
 
 if (!IsAlive())
 {
 if (type == DAMAGE_FALL) // DealDamage does not apply item durability loss from self-induced damage.
 {
 TC_LOG_DEBUG("entities.player", "Player::EnvironmentalDamage: Player '{}' ({}) fall to death, losing {}% durability",
 GetName(), GetGUID().ToString(), sWorld->getRate(RATE_DURABILITY_LOSS_ON_DEATH));
 DurabilityLossAll(sWorld->getRate(RATE_DURABILITY_LOSS_ON_DEATH), false);
 // durability lost message
 SendDurabilityLoss(this, uint32(sWorld->getRate(RATE_DURABILITY_LOSS_ON_DEATH) * 100.0f));
 }
 
 UpdateCriteria(CriteriaType::DieFromEnviromentalDamage, 1, type);
 }
 
 return final_damage;
}
 
int32 Player::getMaxTimer(MirrorTimerType timer) const
{
 switch (timer)
 {
 case FATIGUE_TIMER:
 return MINUTE * IN_MILLISECONDS;
 case BREATH_TIMER:
 {
 if (!IsAlive() || HasAuraType(SPELL_AURA_WATER_BREATHING) || GetSession()->GetSecurity() >= AccountTypes(sWorld->getIntConfig(CONFIG_DISABLE_BREATHING)))
 return DISABLED_MIRROR_TIMER;
 
 int32 UnderWaterTime = 3 * MINUTE * IN_MILLISECONDS;
 UnderWaterTime *= GetTotalAuraMultiplier(SPELL_AURA_MOD_WATER_BREATHING);
 return UnderWaterTime;
 }
 case FIRE_TIMER:
 {
 if (!IsAlive())
 return DISABLED_MIRROR_TIMER;
 return 1 * IN_MILLISECONDS;
 }
 default:
 return 0;
 }
}
 
void Player::UpdateMirrorTimers()
{
 // Desync flags for update on next HandleDrowning
 if (m_MirrorTimerFlags)
 m_MirrorTimerFlagsLast = ~m_MirrorTimerFlags;
}
 
void Player::StopMirrorTimers()
{
 StopMirrorTimer(FATIGUE_TIMER);
 StopMirrorTimer(BREATH_TIMER);
 StopMirrorTimer(FIRE_TIMER);
}
 
bool Player::IsMirrorTimerActive(MirrorTimerType type) const
{
 return m_MirrorTimer[type] == getMaxTimer(type);
}
 
void Player::HandleDrowning(uint32 time_diff)
{
 if (!m_MirrorTimerFlags)
 return;
 
 auto getEnvironmentalDamage = [&](EnviromentalDamage damageType)
 {
 uint8 damagePercent = 10;
 if (damageType == DAMAGE_DROWNING || damageType == DAMAGE_EXHAUSTED)
 damagePercent *= 2;
 
 uint32 damage = GetMaxHealth() * damagePercent / 100;
 
 // Randomize damage
 damage += urand(0, pow(10, std::max(0, (int32)log10(damage) - 1)));
 
 return damage;
 };
 
 // In water
 if (m_MirrorTimerFlags & UNDERWATER_INWATER)
 {
 // Breath timer not activated - activate it
 if (m_MirrorTimer[BREATH_TIMER] == DISABLED_MIRROR_TIMER)
 {
 m_MirrorTimer[BREATH_TIMER] = getMaxTimer(BREATH_TIMER);
 SendMirrorTimer(BREATH_TIMER, m_MirrorTimer[BREATH_TIMER], m_MirrorTimer[BREATH_TIMER], -1);
 }
 else // If activated - do tick
 {
 m_MirrorTimer[BREATH_TIMER] -= time_diff;
 // Timer limit - need deal damage
 if (m_MirrorTimer[BREATH_TIMER] < 0)
 {
 m_MirrorTimer[BREATH_TIMER] += 1 * IN_MILLISECONDS;
 // Calculate and deal damage
 uint32 damage = getEnvironmentalDamage(DAMAGE_DROWNING);
 EnvironmentalDamage(DAMAGE_DROWNING, damage);
 }
 else if (!(m_MirrorTimerFlagsLast & UNDERWATER_INWATER)) // Update time in client if need
 SendMirrorTimer(BREATH_TIMER, getMaxTimer(BREATH_TIMER), m_MirrorTimer[BREATH_TIMER], -1);
 }
 }
 else if (m_MirrorTimer[BREATH_TIMER] != DISABLED_MIRROR_TIMER) // Regen timer
 {
 int32 UnderWaterTime = getMaxTimer(BREATH_TIMER);
 // Need breath regen
 m_MirrorTimer[BREATH_TIMER] += 10 * time_diff;
 if (m_MirrorTimer[BREATH_TIMER] >= UnderWaterTime || !IsAlive())
 StopMirrorTimer(BREATH_TIMER);
 else if (m_MirrorTimerFlagsLast & UNDERWATER_INWATER)
 SendMirrorTimer(BREATH_TIMER, UnderWaterTime, m_MirrorTimer[BREATH_TIMER], 10);
 }
 
 // In dark water
 if (m_MirrorTimerFlags & UNDERWATER_INDARKWATER)
 {
 // Fatigue timer not activated - activate it
 if (m_MirrorTimer[FATIGUE_TIMER] == DISABLED_MIRROR_TIMER)
 {
 m_MirrorTimer[FATIGUE_TIMER] = getMaxTimer(FATIGUE_TIMER);
 SendMirrorTimer(FATIGUE_TIMER, m_MirrorTimer[FATIGUE_TIMER], m_MirrorTimer[FATIGUE_TIMER], -1);
 }
 else
 {
 m_MirrorTimer[FATIGUE_TIMER] -= time_diff;
 // Timer limit - need deal damage or teleport ghost to graveyard
 if (m_MirrorTimer[FATIGUE_TIMER] < 0)
 {
 m_MirrorTimer[FATIGUE_TIMER] += 1 * IN_MILLISECONDS;
 if (IsAlive()) // Calculate and deal damage
 {
 uint32 damage = getEnvironmentalDamage(DAMAGE_EXHAUSTED);
 EnvironmentalDamage(DAMAGE_EXHAUSTED, damage);
 }
 else if (HasPlayerFlag(PLAYER_FLAGS_GHOST)) // Teleport ghost to graveyard
 RepopAtGraveyard();
 }
 else if (!(m_MirrorTimerFlagsLast & UNDERWATER_INDARKWATER))
 SendMirrorTimer(FATIGUE_TIMER, getMaxTimer(FATIGUE_TIMER), m_MirrorTimer[FATIGUE_TIMER], -1);
 }
 }
 else if (m_MirrorTimer[FATIGUE_TIMER] != DISABLED_MIRROR_TIMER) // Regen timer
 {
 int32 DarkWaterTime = getMaxTimer(FATIGUE_TIMER);
 m_MirrorTimer[FATIGUE_TIMER] += 10 * time_diff;
 if (m_MirrorTimer[FATIGUE_TIMER] >= DarkWaterTime || !IsAlive())
 StopMirrorTimer(FATIGUE_TIMER);
 else if (m_MirrorTimerFlagsLast & UNDERWATER_INDARKWATER)
 SendMirrorTimer(FATIGUE_TIMER, DarkWaterTime, m_MirrorTimer[FATIGUE_TIMER], 10);
 }
 
 if (m_MirrorTimerFlags & (UNDERWATER_INLAVA /*| UNDERWATER_INSLIME*/) && !(_lastLiquid && _lastLiquid->SpellID))
 {
 // Breath timer not activated - activate it
 if (m_MirrorTimer[FIRE_TIMER] == DISABLED_MIRROR_TIMER)
 m_MirrorTimer[FIRE_TIMER] = getMaxTimer(FIRE_TIMER);
 else
 {
 m_MirrorTimer[FIRE_TIMER] -= time_diff;
 if (m_MirrorTimer[FIRE_TIMER] < 0)
 {
 m_MirrorTimer[FIRE_TIMER] += 1 * IN_MILLISECONDS;
 // Calculate and deal damage
 uint32 damage = getEnvironmentalDamage(DAMAGE_LAVA);
 if (m_MirrorTimerFlags & UNDERWATER_INLAVA)
 EnvironmentalDamage(DAMAGE_LAVA, damage);
 // need to skip Slime damage in Undercity,
 // maybe someone can find better way to handle environmental damage
 //else if (m_zoneUpdateId != 1497)
 // EnvironmentalDamage(DAMAGE_SLIME, damage);
 }
 }
 }
 else
 m_MirrorTimer[FIRE_TIMER] = DISABLED_MIRROR_TIMER;
 
 // Recheck timers flag
 m_MirrorTimerFlags &= ~UNDERWATER_EXIST_TIMERS;
 for (uint8 i = 0; i < MAX_TIMERS; ++i)
 {
 if (m_MirrorTimer[i] != DISABLED_MIRROR_TIMER)
 {
 m_MirrorTimerFlags |= UNDERWATER_EXIST_TIMERS;
 break;
 }
 }
 m_MirrorTimerFlagsLast = m_MirrorTimerFlags;
}
 
void Player::HandleSobering()
{
 m_drunkTimer = 0;
 
 uint8 currentDrunkValue = GetDrunkValue();
 uint8 drunk = currentDrunkValue ? --currentDrunkValue : 0;
 SetDrunkValue(drunk);
}
 
DrunkenState Player::GetDrunkenstateByValue(uint8 value)
{
 if (value >= 90)
 return DRUNKEN_SMASHED;
 if (value >= 50)
 return DRUNKEN_DRUNK;
 if (value)
 return DRUNKEN_TIPSY;
 return DRUNKEN_SOBER;
}
 
void Player::SetDrunkValue(uint8 newDrunkValue, uint32 itemId /*= 0*/)
{
 bool isSobering = newDrunkValue < GetDrunkValue();
 uint32 oldDrunkenState = Player::GetDrunkenstateByValue(GetDrunkValue());
 if (newDrunkValue > 100)
 newDrunkValue = 100;
 
 // select drunk percent or total SPELL_AURA_MOD_FAKE_INEBRIATE amount, whichever is higher for visibility updates
 int32 drunkPercent = std::max<int32>(newDrunkValue, GetTotalAuraModifier(SPELL_AURA_MOD_FAKE_INEBRIATE));
 if (drunkPercent)
 {
 m_invisibilityDetect.AddFlag(INVISIBILITY_DRUNK);
 m_invisibilityDetect.SetValue(INVISIBILITY_DRUNK, drunkPercent);
 }
 else if (!HasAuraType(SPELL_AURA_MOD_FAKE_INEBRIATE) && !newDrunkValue)
 m_invisibilityDetect.DelFlag(INVISIBILITY_DRUNK);
 
 uint32 newDrunkenState = Player::GetDrunkenstateByValue(newDrunkValue);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_playerData).ModifyValue(&UF::PlayerData::Inebriation), newDrunkValue);
 UpdateObjectVisibility();
 
 if (!isSobering)
 m_drunkTimer = 0; // reset sobering timer
 
 if (newDrunkenState == oldDrunkenState)
 return;
 
 WorldPackets::Misc::CrossedInebriationThreshold data;
 data.Guid = GetGUID();
 data.Threshold = newDrunkenState;
 data.ItemID = itemId;
 
 SendMessageToSet(data.Write(), true);
}
 
void Player::Update(uint32 p_time)
{
 if (!IsInWorld())
 return;
 
 // undelivered mail
 if (m_nextMailDelivereTime && m_nextMailDelivereTime <= GameTime::GetGameTime())
 {
 SendNewMail();
 ++unReadMails;
 
 // It will be recalculate at mailbox open (for unReadMails important non-0 until mailbox open, it also will be recalculated)
 m_nextMailDelivereTime = 0;
 }
 
 // Update cinematic location, if 500ms have passed and we're doing a cinematic now.
 _cinematicMgr->m_cinematicDiff += p_time;
 if (_cinematicMgr->m_cinematicCamera && _cinematicMgr->m_activeCinematic && GetMSTimeDiffToNow(_cinematicMgr->m_lastCinematicCheck) > CINEMATIC_UPDATEDIFF)
 {
 _cinematicMgr->m_lastCinematicCheck = GameTime::GetGameTimeMS();
 _cinematicMgr->UpdateCinematicLocation(p_time);
 }
 
 //used to implement delayed far teleport
 SetCanDelayTeleport(true);
 Unit::Update(p_time);
 SetCanDelayTeleport(false);
 
 // Unit::Update updates the spell history and spell states. We can now check if we can launch another pending cast.
 if (CanExecutePendingSpellCastRequest())
 ExecutePendingSpellCastRequest();
 
 time_t now = GameTime::GetGameTime();
 
 UpdatePvPFlag(now);
 
 UpdateContestedPvP(p_time);
 
 UpdateDuelFlag(now);
 
 CheckDuelDistance(now);
 
 UpdateAfkReport(now);
 
 if (GetCombatManager().HasPvPCombat())
 if (Aura* aura = GetAura(SPELL_PVP_RULES_ENABLED))
 if (!aura->IsPermanent())
 aura->SetDuration(aura->GetSpellInfo()->GetMaxDuration());
 
 Unit::AIUpdateTick(p_time);
 
 // Update items that have just a limited lifetime
 if (now > m_Last_tick)
 UpdateItemDuration(uint32(now - m_Last_tick));
 
 // check every second
 if (now > m_Last_tick + 1)
 UpdateSoulboundTradeItems();
 
 // If mute expired, remove it from the DB
 if (GetSession()->m_muteTime && GetSession()->m_muteTime < now)
 {
 GetSession()->m_muteTime = 0;
 LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_MUTE_TIME);
 stmt->setInt64(0, 0); // Set the mute time to 0
 stmt->setString(1, "");
 stmt->setString(2, "");
 stmt->setUInt32(3, GetSession()->GetAccountId());
 LoginDatabase.Execute(stmt);
 }
 
 if (!m_timedquests.empty())
 {
 QuestSet::iterator iter = m_timedquests.begin();
 while (iter != m_timedquests.end())
 {
 QuestStatusData& q_status = m_QuestStatus[*iter];
 if (q_status.Timer <= p_time)
 {
 uint32 quest_id = *iter;
 ++iter; // current iter will be removed in FailQuest
 FailQuest(quest_id);
 }
 else
 {
 q_status.Timer -= p_time;
 m_QuestStatusSave[*iter] = QUEST_DEFAULT_SAVE_TYPE;
 ++iter;
 }
 }
 }
 
 m_achievementMgr->UpdateTimedCriteria(Milliseconds(p_time));
 
 DoMeleeAttackIfReady();
 
 if (HasPlayerFlag(PLAYER_FLAGS_RESTING))
 _restMgr->Update(now);
 
 if (m_weaponChangeTimer > 0)
 {
 if (p_time >= m_weaponChangeTimer)
 m_weaponChangeTimer = 0;
 else
 m_weaponChangeTimer -= p_time;
 }
 
 if (m_zoneUpdateTimer > 0)
 {
 if (p_time >= m_zoneUpdateTimer)
 {
 // On zone update tick check if we are still in an inn if we are supposed to be in one
 if (_restMgr->HasRestFlag(REST_FLAG_IN_TAVERN))
 {
 AreaTriggerEntry const* atEntry = sAreaTriggerStore.LookupEntry(_restMgr->GetInnTriggerID());
 if (!atEntry || !IsInAreaTrigger(atEntry))
 _restMgr->RemoveRestFlag(REST_FLAG_IN_TAVERN);
 }
 
 uint32 newzone, newarea;
 GetZoneAndAreaId(newzone, newarea);
 
 if (m_zoneUpdateId != newzone)
 UpdateZone(newzone, newarea); // also update area
 else
 {
 // use area updates as well
 // needed for free far all arenas for example
 if (m_areaUpdateId != newarea)
 UpdateArea(newarea);
 
 m_zoneUpdateTimer = ZONE_UPDATE_INTERVAL;
 }
 }
 else
 m_zoneUpdateTimer -= p_time;
 }
 
 if (IsAlive())
 {
 m_regenTimer += p_time;
 RegenerateAll();
 }
 
 if (m_deathState == JUST_DIED)
 KillPlayer();
 
 if (m_nextSave > 0)
 {
 if (p_time >= m_nextSave)
 {
 // m_nextSave reset in SaveToDB call
 SaveToDB();
 TC_LOG_DEBUG("entities.player", "Player::Update: Player '{}' ({}) saved", GetName(), GetGUID().ToString());
 }
 else
 m_nextSave -= p_time;
 }
 
 //Handle Water/drowning
 HandleDrowning(p_time);
 
 // Played time
 if (now > m_Last_tick)
 {
 uint32 elapsed = uint32(now - m_Last_tick);
 m_Played_time[PLAYED_TIME_TOTAL] += elapsed; // Total played time
 m_Played_time[PLAYED_TIME_LEVEL] += elapsed; // Level played time
 m_Last_tick = now;
 }
 
 if (GetDrunkValue())
 {
 m_drunkTimer += p_time;
 if (m_drunkTimer > 9 * IN_MILLISECONDS)
 HandleSobering();
 }
 
 if (HasPendingBind())
 {
 if (_pendingBindTimer <= p_time)
 {
 // Player left the instance
 if (_pendingBindId == GetInstanceId())
 ConfirmPendingBind();
 SetPendingBind(0, 0);
 }
 else
 _pendingBindTimer -= p_time;
 }
 
 // not auto-free ghost from body in instances
 if (m_deathTimer > 0 && !GetMap()->Instanceable() && !HasAuraType(SPELL_AURA_PREVENT_RESURRECTION))
 {
 if (p_time >= m_deathTimer)
 {
 m_deathTimer = 0;
 BuildPlayerRepop();
 RepopAtGraveyard();
 }
 else
 m_deathTimer -= p_time;
 }
 
 UpdateEnchantTime(p_time);
 UpdateHomebindTime(p_time);
 
 if (!_instanceResetTimes.empty())
 {
 for (InstanceTimeMap::iterator itr = _instanceResetTimes.begin(); itr != _instanceResetTimes.end();)
 {
 if (itr->second < now)
 _instanceResetTimes.erase(itr++);
 else
 ++itr;
 }
 }
 
 Pet* pet = GetPet();
 if (pet && !pet->IsWithinDistInMap(this, GetMap()->GetVisibilityRange()) && !pet->isPossessed())
 //if (pet && !pet->IsWithinDistInMap(this, GetMap()->GetVisibilityDistance()) && (GetCharmGUID() && (pet->GetGUID() != GetCharmGUID())))
 RemovePet(pet, PET_SAVE_NOT_IN_SLOT, true);
 
 if (IsAlive())
 {
 if (m_hostileReferenceCheckTimer <= p_time)
 {
 m_hostileReferenceCheckTimer = 15 * IN_MILLISECONDS;
 if (!GetMap()->IsDungeon())
 GetCombatManager().EndCombatBeyondRange(GetVisibilityRange(), true);
 }
 else
 m_hostileReferenceCheckTimer -= p_time;
 }
 
 //we should execute delayed teleports only for alive(!) players
 //because we don't want player's ghost teleported from graveyard
 if (IsHasDelayedTeleport() && IsAlive())
 TeleportTo(m_teleport_dest, m_teleport_options);
}
 
void Player::Heartbeat()
{
 Unit::Heartbeat();
 
 // Group update
 SendUpdateToOutOfRangeGroupMembers();
 
 // Indoor/Outdoor aura requirements
 CheckOutdoorsAuraRequirements();
}
 
void Player::setDeathState(DeathState s)
{
 bool oldIsAlive = IsAlive();
 
 if (s == JUST_DIED)
 {
 if (!oldIsAlive)
 {
 TC_LOG_ERROR("entities.player", "Player::setDeathState: Attempted to kill a dead player '{}' ({})", GetName(), GetGUID().ToString());
 return;
 }
 
 // clear all pending spell cast requests when dying
 CancelPendingCastRequest();
 
 // drunken state is cleared on death
 SetDrunkValue(0);
 SetPower(POWER_COMBO_POINTS, 0);
 
 ClearResurrectRequestData();
 
 //FIXME: is pet dismissed at dying or releasing spirit? if second, add setDeathState(DEAD) to HandleRepopRequest and define pet unsummon here with (s == DEAD)
 RemovePet(nullptr, PET_SAVE_NOT_IN_SLOT, true);
 
 InitializeSelfResurrectionSpells();
 
 FailQuestsWithFlag(QUEST_FLAGS_COMPLETION_NO_DEATH);
 
 UpdateCriteria(CriteriaType::DieOnMap, 1);
 UpdateCriteria(CriteriaType::DieAnywhere, 1);
 UpdateCriteria(CriteriaType::DieInInstance, 1);
 
 // reset all death criterias
 FailCriteria(CriteriaFailEvent::Death, 0);
 }
 
 Unit::setDeathState(s);
 
 if (IsAlive() && !oldIsAlive)
 //clear aura case after resurrection by another way (spells will be applied before next death)
 ClearSelfResSpell();
}
 
void Player::ToggleAFK()
{
 if (isAFK())
 RemovePlayerFlag(PLAYER_FLAGS_AFK);
 else
 SetPlayerFlag(PLAYER_FLAGS_AFK);
 
 // afk player not allowed in battleground
 if (!IsGameMaster() && isAFK() && InBattleground() && !InArena())
 LeaveBattleground();
}
 
void Player::ToggleDND()
{
 if (isDND())
 RemovePlayerFlag(PLAYER_FLAGS_DND);
 else
 SetPlayerFlag(PLAYER_FLAGS_DND);
}
 
uint16 Player::GetChatFlags() const
{
 uint16 tag = CHAT_FLAG_NONE;
 
 if (isGMChat())
 tag |= CHAT_FLAG_GM;
 if (isDND())
 tag |= CHAT_FLAG_DND;
 if (isAFK())
 tag |= CHAT_FLAG_AFK;
 if (IsDeveloper())
 tag |= CHAT_FLAG_DEV;
 if (m_activePlayerData->TimerunningSeasonID)
 tag |= CHAT_FLAG_TIMERUNNING;
 
 return tag;
}
 
bool Player::TeleportTo(uint32 mapid, float x, float y, float z, float orientation, TeleportToOptions options /*= TELE_TO_NONE*/, Optional<uint32> instanceId /*= {}*/)
{
 return TeleportTo({ .Location = WorldLocation(mapid, x, y, z, orientation), .InstanceId = instanceId }, options);
}
 
bool Player::TeleportTo(WorldLocation const& loc, TeleportToOptions options, Optional<uint32> instanceId)
{
 return TeleportTo({ .Location = loc, .InstanceId = instanceId }, options);
}
 
bool Player::TeleportTo(TeleportLocation const& teleportLocation, TeleportToOptions options /*= TELE_TO_NONE*/)
{
 if (!MapManager::IsValidMapCoord(teleportLocation.Location))
 {
 TC_LOG_ERROR("maps", "Player::TeleportTo: Invalid map ({}) or invalid coordinates ({}) given when teleporting player '{}' ({}, MapID: {}, {}).",
 teleportLocation.Location.GetMapId(), teleportLocation.Location.ToString(), GetGUID().ToString(), GetName(), GetMapId(), GetPosition().ToString());
 return false;
 }
 
 if (!GetSession()->HasPermission(rbac::RBAC_PERM_SKIP_CHECK_DISABLE_MAP) && DisableMgr::IsDisabledFor(DISABLE_TYPE_MAP, teleportLocation.Location.GetMapId(), this))
 {
 TC_LOG_ERROR("entities.player.cheat", "Player::TeleportTo: Player '{}' ({}) tried to enter a forbidden map (MapID: {})", GetGUID().ToString(), GetName(), teleportLocation.Location.GetMapId());
 SendTransferAborted(teleportLocation.Location.GetMapId(), TRANSFER_ABORT_MAP_NOT_ALLOWED);
 return false;
 }
 
 // preparing unsummon pet if lost (we must get pet before teleportation or will not find it later)
 Pet* pet = GetPet();
 
 MapEntry const* mEntry = sMapStore.LookupEntry(teleportLocation.Location.GetMapId());
 
 // don't let enter battlegrounds without assigned battleground id (for example through areatrigger)...
 // don't let gm level > 1 either
 if (!InBattleground() && mEntry->IsBattlegroundOrArena())
 return false;
 
 // client without expansion support
 if (GetSession()->GetExpansion() < mEntry->Expansion())
 {
 TC_LOG_DEBUG("maps", "Player '{}' ({}) using client without required expansion tried teleporting to non accessible map (MapID: {})",
 GetName(), GetGUID().ToString(), teleportLocation.Location.GetMapId());
 
 if (TransportBase* transport = GetTransport())
 {
 transport->RemovePassenger(this);
 RepopAtGraveyard(); // teleport to near graveyard if on transport, looks blizz like :)
 }
 
 SendTransferAborted(teleportLocation.Location.GetMapId(), TRANSFER_ABORT_INSUF_EXPAN_LVL, mEntry->Expansion());
 
 return false; // normal client can't teleport to this map...
 }
 else
 TC_LOG_DEBUG("maps", "Player {} ({}) is being teleported to map (MapID: {})", GetName(), GetGUID().ToString(), teleportLocation.Location.GetMapId());
 
 if (m_vehicle)
 ExitVehicle();
 
 // reset movement flags at teleport, because player will continue move with these flags after teleport
 SetUnitMovementFlags(GetUnitMovementFlags() & MOVEMENTFLAG_MASK_HAS_PLAYER_STATUS_OPCODE);
 m_movementInfo.ResetJump();
 DisableSpline();
 GetMotionMaster()->Remove(EFFECT_MOTION_TYPE);
 
 if (TransportBase* transport = GetTransport())
 if (!teleportLocation.TransportGuid || teleportLocation.TransportGuid != transport->GetTransportGUID())
 if (!(options & TELE_TO_NOT_LEAVE_TRANSPORT))
 transport->RemovePassenger(this);
 
 // The player was ported to another map and loses the duel immediately.
 // We have to perform this check before the teleport, otherwise the
 // ObjectAccessor won't find the flag.
 if (duel && GetMapId() != teleportLocation.Location.GetMapId() && GetMap()->GetGameObject(m_playerData->DuelArbiter))
 DuelComplete(DUEL_FLED);
 
 if (GetMapId() == teleportLocation.Location.GetMapId() && (!teleportLocation.InstanceId || GetInstanceId() == teleportLocation.InstanceId))
 {
 //lets reset far teleport flag if it wasn't reset during chained teleport
 SetSemaphoreTeleportFar(false);
 //setup delayed teleport flag
 SetDelayedTeleportFlag(IsCanDelayTeleport());
 //if teleport spell is cast in Unit::Update() func
 //then we need to delay it until update process will be finished
 if (IsHasDelayedTeleport())
 {
 SetSemaphoreTeleportNear(true);
 //lets save teleport destination for player
 m_teleport_dest = teleportLocation;
 m_teleport_options = options;
 return true;
 }
 
 if (!(options & TELE_TO_NOT_UNSUMMON_PET))
 {
 //same map, only remove pet if out of range for new position
 if (pet && !pet->IsWithinDist3d(&teleportLocation.Location, GetMap()->GetVisibilityRange()))
 UnsummonPetTemporaryIfAny();
 }
 
 if (!IsAlive() && options & TELE_REVIVE_AT_TELEPORT)
 ResurrectPlayer(0.5f);
 
 if (!(options & TELE_TO_NOT_LEAVE_COMBAT))
 CombatStop();
 
 // this will be used instead of the current location in SaveToDB
 m_teleport_dest = teleportLocation;
 m_teleport_options = options;
 SetFallInformation(0, GetPositionZ());
 
 // code for finish transfer called in WorldSession::HandleMovementOpcodes()
 // at client packet CMSG_MOVE_TELEPORT_ACK
 SetSemaphoreTeleportNear(true);
 // near teleport, triggering send CMSG_MOVE_TELEPORT_ACK from client at landing
 if (!GetSession()->PlayerLogout())
 SendTeleportPacket(m_teleport_dest);
 }
 else
 {
 if (GetClass() == CLASS_DEATH_KNIGHT && GetMapId() == 609 && !IsGameMaster() && !HasSpell(50977))
 {
 SendTransferAborted(teleportLocation.Location.GetMapId(), TRANSFER_ABORT_UNIQUE_MESSAGE, 1);
 return false;
 }
 
 // far teleport to another map
 Map* oldmap = IsInWorld() ? GetMap() : nullptr;
 // check if we can enter before stopping combat / removing pet / totems / interrupting spells
 
 // Check enter rights before map getting to avoid creating instance copy for player
 // this check not dependent from map instance copy and same for all instance copies of selected map
 if (TransferAbortParams abortParams = Map::PlayerCannotEnter(teleportLocation.Location.GetMapId(), this))
 {
 SendTransferAborted(teleportLocation.Location.GetMapId(), abortParams.Reason, abortParams.Arg, abortParams.MapDifficultyXConditionId);
 return false;
 }
 
 // Seamless teleport can happen only if cosmetic maps match
 if (!oldmap ||
 (oldmap->GetEntry()->CosmeticParentMapID != int32(teleportLocation.Location.GetMapId()) && int32(GetMapId()) != mEntry->CosmeticParentMapID &&
 !((oldmap->GetEntry()->CosmeticParentMapID != -1) ^ (oldmap->GetEntry()->CosmeticParentMapID != mEntry->CosmeticParentMapID))))
 options &= ~TELE_TO_SEAMLESS;
 
 //lets reset near teleport flag if it wasn't reset during chained teleports
 SetSemaphoreTeleportNear(false);
 //setup delayed teleport flag
 SetDelayedTeleportFlag(IsCanDelayTeleport());
 //if teleport spell is cast in Unit::Update() func
 //then we need to delay it until update process will be finished
 if (IsHasDelayedTeleport())
 {
 SetSemaphoreTeleportFar(true);
 //lets save teleport destination for player
 m_teleport_dest = teleportLocation;
 m_teleport_options = options;
 return true;
 }
 
 SetSelection(ObjectGuid::Empty);
 
 CombatStop();
 
 ResetContestedPvP();
 
 // remove player from battleground on far teleport (when changing maps)
 if (Battleground const* bg = GetBattleground())
 {
 // Note: at battleground join battleground id set before teleport
 // and we already will found "current" battleground
 // just need check that this is targeted map or leave
 if (bg->GetMapId() != teleportLocation.Location.GetMapId())
 LeaveBattleground(false); // don't teleport to entry point
 }
 
 // remove arena spell coldowns/buffs now to also remove pet's cooldowns before it's temporarily unsummoned
 if (mEntry->IsBattleArena() && !IsGameMaster())
 {
 RemoveArenaSpellCooldowns(true);
 RemoveArenaAuras();
 if (pet)
 pet->RemoveArenaAuras();
 }
 
 // remove pet on map change
 if (pet)
 UnsummonPetTemporaryIfAny();
 
 // remove all dyn objects
 RemoveAllDynObjects();
 
 // remove all areatriggers entities
 RemoveAllAreaTriggers();
 
 // stop spellcasting
 // not attempt interrupt teleportation spell at caster teleport
 if (!(options & TELE_TO_SPELL))
 if (IsNonMeleeSpellCast(true))
 InterruptNonMeleeSpells(true);
 
 //remove auras before removing from map...
 RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags::Moving | SpellAuraInterruptFlags::Turning);
 
 if (!GetSession()->PlayerLogout() && !(options & TELE_TO_SEAMLESS))
 {
 // send transfer packets
 WorldPackets::Movement::TransferPending transferPending;
 transferPending.MapID = teleportLocation.Location.GetMapId();
 transferPending.OldMapPosition = teleportLocation.Location.GetPosition();
 if (teleportLocation.TransportGuid.has_value())
 {
 transferPending.Ship.emplace();
 if (TransportSpawn const* transportSpawn = sTransportMgr->GetTransportSpawn(teleportLocation.TransportGuid->GetCounter()))
 {
 transferPending.Ship->ID = transportSpawn->TransportGameObjectId;
 if (dynamic_cast<Transport*>(GetTransport()))
 transferPending.Ship->OriginMapID = GetMapId();
 else
 transferPending.Ship->OriginMapID = -1;
 }
 }
 
 SendDirectMessage(transferPending.Write());
 
 RemovePlayerLocalFlag(PLAYER_LOCAL_FLAG_OVERRIDE_TRANSPORT_SERVER_TIME);
 SetTransportServerTime(0);
 }
 
 // remove from old map now
 if (oldmap)
 oldmap->RemovePlayerFromMap(this, false);
 
 m_teleport_dest = teleportLocation;
 m_teleport_options = options;
 SetFallInformation(0, GetPositionZ());
 // if the player is saved before worldportack (at logout for example)
 // this will be used instead of the current location in SaveToDB
 
 if (!GetSession()->PlayerLogout())
 {
 ++m_newWorldCounter;
 
 WorldPackets::Movement::SuspendToken suspendToken;
 suspendToken.SequenceIndex = m_movementCounter; // not incrementing
 suspendToken.Reason = options & TELE_TO_SEAMLESS ? 2 : 1;
 SendDirectMessage(suspendToken.Write());
 }
 
 // move packet sent by client always after far teleport
 // code for finish transfer to new map called in WorldSession::HandleMoveWorldportAckOpcode at client packet
 SetSemaphoreTeleportFar(true);
 }
 return true;
}
 
bool Player::TeleportToBGEntryPoint()
{
 if (m_bgData.joinPos.m_mapId == MAPID_INVALID)
 return false;
 
 ScheduleDelayedOperation(DELAYED_BG_MOUNT_RESTORE);
 ScheduleDelayedOperation(DELAYED_BG_TAXI_RESTORE);
 ScheduleDelayedOperation(DELAYED_BG_GROUP_RESTORE);
 return TeleportTo(m_bgData.joinPos);
}
 
void Player::ProcessDelayedOperations()
{
 if (m_DelayedOperations == 0)
 return;
 
 if (m_DelayedOperations & DELAYED_RESURRECT_PLAYER)
 ResurrectUsingRequestDataImpl();
 
 if (m_DelayedOperations & DELAYED_SAVE_PLAYER)
 SaveToDB();
 
 if (m_DelayedOperations & DELAYED_SPELL_CAST_DESERTER)
 CastSpell(this, 26013, true); // Deserter
 
 if (m_DelayedOperations & DELAYED_BG_MOUNT_RESTORE)
 {
 if (m_bgData.mountSpell)
 {
 CastSpell(this, m_bgData.mountSpell, true);
 m_bgData.mountSpell = 0;
 }
 }
 
 if (m_DelayedOperations & DELAYED_BG_TAXI_RESTORE)
 {
 if (m_bgData.HasTaxiPath())
 {
 m_taxi.AddTaxiDestination(m_bgData.taxiPath[0]);
 m_taxi.AddTaxiDestination(m_bgData.taxiPath[1]);
 m_bgData.ClearTaxiPath();
 
 ContinueTaxiFlight();
 }
 }
 
 if (m_DelayedOperations & DELAYED_BG_GROUP_RESTORE)
 {
 if (Group* g = GetGroup())
 g->SendUpdateToPlayer(GetGUID());
 }
 
 //we have executed ALL delayed ops, so clear the flag
 m_DelayedOperations = 0;
}
 
void Player::AddToWorld()
{
 Unit::AddToWorld();
 
 for (uint8 i = PLAYER_SLOT_START; i < PLAYER_SLOT_END; ++i)
 if (m_items[i])
 m_items[i]->AddToWorld();
}
 
void Player::RemoveFromWorld()
{
 // cleanup
 if (IsInWorld())
 {
 StopCastingCharm();
 StopCastingBindSight();
 UnsummonPetTemporaryIfAny();
 UnsummonBattlePetTemporaryIfAny();
 SetPower(POWER_COMBO_POINTS, 0);
 m_session->DoLootReleaseAll();
 m_lootRolls.clear();
 sOutdoorPvPMgr->HandlePlayerLeaveZone(this, m_zoneUpdateId);
 sBattlefieldMgr->HandlePlayerLeaveZone(this, m_zoneUpdateId);
 }
 
 // Remove items from world before self - player must be found in Item::RemoveFromObjectUpdate
 for (uint8 i = PLAYER_SLOT_START; i < PLAYER_SLOT_END; ++i)
 if (m_items[i])
 m_items[i]->RemoveFromWorld();
 
 Unit::RemoveFromWorld();
 
 for (ItemMap::iterator iter = mMitems.begin(); iter != mMitems.end(); ++iter)
 iter->second->RemoveFromWorld();
 
 if (WorldObject* viewpoint = GetViewpoint())
 {
 TC_LOG_ERROR("entities.player", "Player::RemoveFromWorld: Player '{}' ({}) has viewpoint (Entry:{}, Type: {}) when removed from world",
 GetName(), GetGUID().ToString(), viewpoint->GetEntry(), viewpoint->GetTypeId());
 SetViewpoint(viewpoint, false);
 }
}
 
void Player::SetObjectScale(float scale)
{
 Unit::SetObjectScale(scale);
 SetBoundingRadius(scale * DEFAULT_PLAYER_BOUNDING_RADIUS);
 SetCombatReach(scale * DEFAULT_PLAYER_COMBAT_REACH);
 if (IsInWorld())
 SendMovementSetCollisionHeight(GetCollisionHeight(), WorldPackets::Movement::UpdateCollisionHeightReason::Scale);
}
 
bool Player::IsImmunedToSpellEffect(SpellInfo const* spellInfo, SpellEffectInfo const& spellEffectInfo, WorldObject const* caster,
 bool requireImmunityPurgesEffectAttribute /*= false*/) const
{
 // players are immune to taunt (the aura and the spell effect).
 if (spellEffectInfo.IsAura(SPELL_AURA_MOD_TAUNT))
 return true;
 if (spellEffectInfo.IsEffect(SPELL_EFFECT_ATTACK_ME))
 return true;
 
 return Unit::IsImmunedToSpellEffect(spellInfo, spellEffectInfo, caster, requireImmunityPurgesEffectAttribute);
}
 
void Player::RegenerateAll()
{
 m_regenTimerCount += m_regenTimer;
 
 for (Powers power = POWER_MANA; power < MAX_POWERS; power = Powers(power + 1))
 if (power != POWER_RUNES)
 Regenerate(power);
 
 // Runes act as cooldowns, and they don't need to send any data
 if (GetClass() == CLASS_DEATH_KNIGHT)
 {
 uint32 regeneratedRunes = 0;
 uint32 regenIndex = 0;
 while (regeneratedRunes < MAX_RECHARGING_RUNES && m_runes->CooldownOrder.size() > regenIndex)
 {
 uint8 runeToRegen = m_runes->CooldownOrder[regenIndex];
 uint32 runeCooldown = GetRuneCooldown(runeToRegen);
 if (runeCooldown > m_regenTimer)
 {
 SetRuneCooldown(runeToRegen, runeCooldown - m_regenTimer);
 ++regenIndex;
 }
 else
 SetRuneCooldown(runeToRegen, 0);
 
 ++regeneratedRunes;
 }
 }
 
 if (m_regenTimerCount >= 2000)
 {
 // Not in combat or they have regeneration
 if (!IsInCombat() || IsPolymorphed() || m_baseHealthRegen || HasAuraType(SPELL_AURA_MOD_REGEN_DURING_COMBAT) || HasAuraType(SPELL_AURA_MOD_HEALTH_REGEN_IN_COMBAT))
 RegenerateHealth();
 
 m_regenTimerCount -= 2000;
 }
 
 m_regenTimer = 0;
}
 
void Player::Regenerate(Powers power)
{
 // Skip regeneration for power type we cannot have
 uint32 powerIndex = GetPowerIndex(power);
 if (powerIndex == MAX_POWERS || powerIndex >= MAX_POWERS_PER_CLASS)
 return;
 
 if (HasAuraTypeWithValue(SPELL_AURA_PREVENT_REGENERATE_POWER, power))
 return;
 
 int32 curValue = GetPower(power);
 
 // TODO: updating haste should update UnitData::PowerRegenFlatModifier for certain power types
 PowerTypeEntry const* powerType = sDB2Manager.GetPowerTypeEntry(power);
 if (!powerType)
 return;
 
 float addvalue = 0.0f;
 if (!IsInCombat())
 {
 if (powerType->GetFlags().HasFlag(PowerTypeFlags::UseRegenInterrupt) && m_regenInterruptTimestamp + Milliseconds(powerType->RegenInterruptTimeMS) >= GameTime::Now())
 return;
 
 addvalue = (powerType->RegenPeace + m_unitData->PowerRegenFlatModifier[powerIndex]) * 0.001f * m_regenTimer;
 }
 else
 addvalue = (powerType->RegenCombat + m_unitData->PowerRegenInterruptedFlatModifier[powerIndex]) * 0.001f * m_regenTimer;
 
 static Rates const RatesForPower[MAX_POWERS] =
 {
 RATE_POWER_MANA,
 RATE_POWER_RAGE_LOSS,
 RATE_POWER_FOCUS,
 RATE_POWER_ENERGY,
 RATE_POWER_COMBO_POINTS_LOSS,
 MAX_RATES, // runes
 RATE_POWER_RUNIC_POWER_LOSS,
 RATE_POWER_SOUL_SHARDS,
 RATE_POWER_LUNAR_POWER,
 RATE_POWER_HOLY_POWER,
 MAX_RATES, // alternate
 RATE_POWER_MAELSTROM,
 RATE_POWER_CHI,
 RATE_POWER_INSANITY,
 MAX_RATES, // burning embers, unused
 MAX_RATES, // demonic fury, unused
 RATE_POWER_ARCANE_CHARGES,
 RATE_POWER_FURY,
 RATE_POWER_PAIN,
 RATE_POWER_ESSENCE,
 MAX_RATES, // runes
 MAX_RATES, // runes
 MAX_RATES, // runes
 MAX_RATES, // alternate
 MAX_RATES, // alternate
 MAX_RATES, // alternate
 };
 
 if (RatesForPower[power] != MAX_RATES)
 addvalue *= sWorld->getRate(RatesForPower[power]);
 
 // Mana regen calculated in Player::UpdateManaRegen()
 if (power != POWER_MANA)
 {
 addvalue *= GetTotalAuraMultiplierByMiscValue(SPELL_AURA_MOD_POWER_REGEN_PERCENT, power);
 
 addvalue += GetTotalAuraModifierByMiscValue(SPELL_AURA_MOD_POWER_REGEN, power) * ((power != POWER_ENERGY) ? m_regenTimerCount : m_regenTimer) / (5 * IN_MILLISECONDS);
 }
 
 int32 minPower = powerType->MinPower;
 int32 maxPower = GetMaxPower(power);
 
 if (powerType->CenterPower)
 {
 if (curValue > powerType->CenterPower)
 {
 addvalue = -std::abs(addvalue);
 minPower = powerType->CenterPower;
 }
 else if (curValue < powerType->CenterPower)
 {
 addvalue = std::abs(addvalue);
 maxPower = powerType->CenterPower;
 }
 else
 return;
 }
 
 addvalue += m_powerFraction[powerIndex];
 int32 integerValue = int32(std::fabs(addvalue));
 
 if (addvalue < 0.0f)
 {
 if (curValue <= minPower)
 return;
 }
 else if (addvalue > 0.0f)
 {
 if (curValue >= maxPower)
 return;
 }
 else
 return;
 
 bool forcesSetPower = false;
 if (addvalue < 0.0f)
 {
 if (curValue > minPower + integerValue)
 {
 curValue -= integerValue;
 m_powerFraction[powerIndex] = addvalue + integerValue;
 }
 else
 {
 curValue = minPower;
 m_powerFraction[powerIndex] = 0;
 forcesSetPower = true;
 }
 }
 else
 {
 if (curValue + integerValue <= maxPower)
 {
 curValue += integerValue;
 m_powerFraction[powerIndex] = addvalue - integerValue;
 }
 else
 {
 curValue = maxPower;
 m_powerFraction[powerIndex] = 0;
 forcesSetPower = true;
 }
 }
 
 if (GetCommandStatus(CHEAT_POWER))
 curValue = maxPower;
 
 if (m_regenTimerCount >= 2000 || forcesSetPower)
 SetPower(power, curValue);
 else
 {
 // throttle packet sending
 DoWithSuppressingObjectUpdates([&]()
 {
 SetUpdateFieldValue(m_values.ModifyValue(&Unit::m_unitData).ModifyValue(&UF::UnitData::Power, powerIndex), curValue);
 const_cast<UF::UnitData&>(*m_unitData).ClearChanged(&UF::UnitData::Power, powerIndex);
 });
 }
}
 
void Player::InterruptPowerRegen(Powers power)
{
 uint32 powerIndex = GetPowerIndex(power);
 if (powerIndex == MAX_POWERS || powerIndex >= MAX_POWERS_PER_CLASS)
 return;
 
 m_regenInterruptTimestamp = GameTime::Now();
 m_powerFraction[powerIndex] = 0.0f;
 SendDirectMessage(WorldPackets::Combat::InterruptPowerRegen(power).Write());
}
 
void Player::RegenerateHealth()
{
 uint32 curValue = GetHealth();
 uint32 maxValue = GetMaxHealth();
 
 if (curValue >= maxValue)
 return;
 
 float HealthIncreaseRate = sWorld->getRate(RATE_HEALTH);
 float addValue = 0.0f;
 
 // polymorphed case
 if (IsPolymorphed())
 addValue = float(GetMaxHealth()) / 3.0f;
 // normal regen case (maybe partly in combat case)
 else if (!IsInCombat() || HasAuraType(SPELL_AURA_MOD_REGEN_DURING_COMBAT))
 {
 addValue = HealthIncreaseRate;
 
 if (!IsInCombat())
 {
 if (GetLevel() < 15)
 addValue = (0.20f * ((float)GetMaxHealth()) / GetLevel() * HealthIncreaseRate);
 else
 addValue = 0.015f * ((float)GetMaxHealth()) * HealthIncreaseRate;
 
 addValue *= GetTotalAuraMultiplier(SPELL_AURA_MOD_HEALTH_REGEN_PERCENT);
 
 addValue += GetTotalAuraModifier(SPELL_AURA_MOD_REGEN) * 0.4f;
 }
 else if (HasAuraType(SPELL_AURA_MOD_REGEN_DURING_COMBAT))
 ApplyPct(addValue, GetTotalAuraModifier(SPELL_AURA_MOD_REGEN_DURING_COMBAT));
 
 if (!IsStandState())
 addValue *= 1.5f;
 }
 
 // always regeneration bonus (including combat)
 addValue += GetTotalAuraModifier(SPELL_AURA_MOD_HEALTH_REGEN_IN_COMBAT);
 addValue += m_baseHealthRegen / 2.5f;
 
 if (addValue < 0.0f)
 addValue = 0.0f;
 
 ModifyHealth(int32(addValue));
}
 
void Player::ResetAllPowers()
{
 SetFullHealth();
 
 switch (GetPowerType())
 {
 case POWER_MANA:
 SetFullPower(POWER_MANA);
 break;
 case POWER_RAGE:
 SetPower(POWER_RAGE, 0);
 break;
 case POWER_ENERGY:
 SetFullPower(POWER_ENERGY);
 break;
 case POWER_RUNIC_POWER:
 SetPower(POWER_RUNIC_POWER, 0);
 break;
 case POWER_LUNAR_POWER:
 SetPower(POWER_LUNAR_POWER, 0);
 break;
 default:
 break;
 }
}
 
bool Player::CanInteractWithQuestGiver(Object* questGiver) const
{
 switch (questGiver->GetTypeId())
 {
 case TYPEID_UNIT:
 return GetNPCIfCanInteractWith(questGiver->GetGUID(), UNIT_NPC_FLAG_QUESTGIVER, UNIT_NPC_FLAG_2_NONE) != nullptr;
 case TYPEID_GAMEOBJECT:
 return GetGameObjectIfCanInteractWith(questGiver->GetGUID(), GAMEOBJECT_TYPE_QUESTGIVER) != nullptr;
 case TYPEID_PLAYER:
 return IsAlive() && questGiver->ToPlayer()->IsAlive();
 case TYPEID_ITEM:
 return IsAlive();
 default:
 break;
 }
 return false;
}
 
Creature* Player::GetNPCIfCanInteractWith(ObjectGuid const& guid, NPCFlags npcFlags, NPCFlags2 npcFlags2) const
{
 // unit checks
 if (!guid)
 return nullptr;
 
 if (!IsInWorld())
 return nullptr;
 
 if (IsInFlight())
 return nullptr;
 
 // exist (we need look pets also for some interaction (quest/etc)
 Creature* creature = ObjectAccessor::GetCreatureOrPetOrVehicle(*this, guid);
 if (!creature)
 return nullptr;
 
 // Deathstate checks
 if (!IsAlive() && !(creature->GetCreatureDifficulty()->TypeFlags & CREATURE_TYPE_FLAG_VISIBLE_TO_GHOSTS))
 return nullptr;
 
 // alive or spirit healer
 if (!creature->IsAlive() && !(creature->GetCreatureDifficulty()->TypeFlags & CREATURE_TYPE_FLAG_INTERACT_WHILE_DEAD))
 return nullptr;
 
 // appropriate npc type
 auto hasNpcFlags = [&]()
 {
 if (!npcFlags && !npcFlags2)
 return true;
 if (creature->HasNpcFlag(npcFlags))
 return true;
 if (creature->HasNpcFlag2(npcFlags2))
 return true;
 return false;
 };
 if (!hasNpcFlags())
 return nullptr;
 
 // not allow interaction under control, but allow with own pets
 if (!creature->GetCharmerGUID().IsEmpty())
 return nullptr;
 
 // not unfriendly/hostile
 if (!creature->IsInteractionAllowedWhileHostile() && creature->GetReactionTo(this) <= REP_UNFRIENDLY)
 return nullptr;
 
 if (creature->IsInCombat() && !creature->IsInteractionAllowedInCombat())
 return nullptr;
 
 // not too far, taken from CGGameUI::SetInteractTarget
 if (!creature->IsWithinDistInMap(this, creature->GetCombatReach() + 4.0f))
 return nullptr;
 
 return creature;
}
 
GameObject* Player::GetGameObjectIfCanInteractWith(ObjectGuid const& guid) const
{
 if (!guid)
 return nullptr;
 
 if (!IsInWorld())
 return nullptr;
 
 if (IsInFlight())
 return nullptr;
 
 // exist
 GameObject* go = ObjectAccessor::GetGameObject(*this, guid);
 if (!go)
 return nullptr;
 
 // Players cannot interact with gameobjects that use the "Point" icon
 if (go->GetGOInfo()->IconName == "Point")
 return nullptr;
 
 if (!go->IsWithinDistInMap(this))
 return nullptr;
 
 return go;
}
 
GameObject* Player::GetGameObjectIfCanInteractWith(ObjectGuid const& guid, GameobjectTypes type) const
{
 GameObject* go = GetGameObjectIfCanInteractWith(guid);
 if (!go)
 return nullptr;
 
 if (go->GetGoType() != type)
 return nullptr;
 
 return go;
}
 
bool Player::IsInAreaTrigger(AreaTriggerEntry const* areaTrigger) const
{
 if (!areaTrigger)
 return false;
 
 if (int32(GetMapId()) != areaTrigger->ContinentID && !GetPhaseShift().HasVisibleMapId(areaTrigger->ContinentID))
 return false;
 
 if (areaTrigger->PhaseID || areaTrigger->PhaseGroupID || areaTrigger->PhaseUseFlags)
 if (!PhasingHandler::InDbPhaseShift(this, areaTrigger->PhaseUseFlags, areaTrigger->PhaseID, areaTrigger->PhaseGroupID))
 return false;
 
 auto hasActionSetFlag = [=](AreaTriggerActionSetFlag flag)
 {
 if (AreaTriggerActionSetEntry const* areaTriggerActionSet = sAreaTriggerActionSetStore.LookupEntry(areaTrigger->AreaTriggerActionSetID))
 return areaTriggerActionSet->GetFlags().HasFlag(flag);
 return false;
 };
 
 switch (getDeathState())
 {
 case DEAD:
 if (!hasActionSetFlag(AreaTriggerActionSetFlag::AllowWhileGhost))
 return false;
 break;
 case CORPSE:
 if (!hasActionSetFlag(AreaTriggerActionSetFlag::AllowWhileDead))
 return false;
 break;
 default:
 break;
 }
 
 Position areaTriggerPos(areaTrigger->Pos.X, areaTrigger->Pos.Y, areaTrigger->Pos.Z, areaTrigger->BoxYaw);
 switch (areaTrigger->GetShapeType())
 {
 case AreaTriggerShapeType::Sphere:
 if (!IsInDist(&areaTriggerPos, areaTrigger->Radius))
 return false;
 break;
 case AreaTriggerShapeType::Box:
 if (!IsWithinBox(areaTriggerPos, areaTrigger->BoxLength / 2.f, areaTrigger->BoxWidth / 2.f, areaTrigger->BoxHeight / 2.f))
 return false;
 break;
 case AreaTriggerShapeType::Polygon:
 {
 AreaTriggerPolygon const* polygon = sObjectMgr->GetAreaTriggerPolygon(areaTrigger->ID);
 if (!polygon || (polygon->Height && GetPositionZ() > areaTrigger->Pos.Z + *polygon->Height) || !IsInPolygon2D(areaTriggerPos, polygon->Vertices))
 return false;
 break;
 }
 case AreaTriggerShapeType::Cylinder:
 if (!IsWithinVerticalCylinder(areaTriggerPos, areaTrigger->Radius, areaTrigger->BoxHeight))
 return false;
 break;
 default:
 return false;
 }
 
 return true;
}
 
void Player::SetGameMaster(bool on)
{
 if (on)
 {
 m_ExtraFlags |= PLAYER_EXTRA_GM_ON;
 SetFaction(FACTION_FRIENDLY);
 SetPlayerFlag(PLAYER_FLAGS_GM);
 SetUnitFlag2(UNIT_FLAG2_ALLOW_CHEAT_SPELLS);
 
 if (Pet* pet = GetPet())
 pet->SetFaction(FACTION_FRIENDLY);
 
 RemovePvpFlag(UNIT_BYTE2_FLAG_FFA_PVP);
 ResetContestedPvP();
 
 CombatStopWithPets();
 
 PhasingHandler::SetAlwaysVisible(this, true, false);
 m_serverSideVisibilityDetect.SetValue(SERVERSIDE_VISIBILITY_GM, GetSession()->GetSecurity());
 }
 else
 {
 PhasingHandler::SetAlwaysVisible(this, HasAuraType(SPELL_AURA_PHASE_ALWAYS_VISIBLE), false);
 
 m_ExtraFlags &= ~ PLAYER_EXTRA_GM_ON;
 RestoreFaction();
 RemovePlayerFlag(PLAYER_FLAGS_GM);
 RemoveUnitFlag2(UNIT_FLAG2_ALLOW_CHEAT_SPELLS);
 
 if (Pet* pet = GetPet())
 pet->SetFaction(GetFaction());
 
 // restore FFA PvP Server state
 if (sWorld->IsFFAPvPRealm())
 SetPvpFlag(UNIT_BYTE2_FLAG_FFA_PVP);
 
 // restore FFA PvP area state, remove not allowed for GM mounts
 UpdateArea(m_areaUpdateId);
 
 m_serverSideVisibilityDetect.SetValue(SERVERSIDE_VISIBILITY_GM, SEC_PLAYER);
 }
 
 UpdateObjectVisibility();
}
 
bool Player::CanBeGameMaster() const
{
 return GetSession()->HasPermission(rbac::RBAC_PERM_COMMAND_GM);
}
 
void Player::SetGMVisible(bool on)
{
 if (on)
 {
 m_ExtraFlags &= ~PLAYER_EXTRA_GM_INVISIBLE; //remove flag
 m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GM, SEC_PLAYER);
 }
 else
 {
 m_ExtraFlags |= PLAYER_EXTRA_GM_INVISIBLE; //add flag
 
 SetAcceptWhispers(false);
 SetGameMaster(true);
 
 m_serverSideVisibility.SetValue(SERVERSIDE_VISIBILITY_GM, GetSession()->GetSecurity());
 }
 
 for (Channel* channel : m_channels)
 channel->SetInvisible(this, !on);
}
 
bool Player::IsGroupVisibleFor(Player const* p) const
{
 switch (sWorld->getIntConfig(CONFIG_GROUP_VISIBILITY))
 {
 default: return IsInSameGroupWith(p);
 case 1: return IsInSameRaidWith(p);
 case 2: return GetEffectiveTeam() == p->GetEffectiveTeam();
 case 3: return false;
 }
}
 
bool Player::IsInSameGroupWith(Player const* p) const
{
 return p == this || (GetGroup() != nullptr &&
 GetGroup() == p->GetGroup() &&
 GetGroup()->SameSubGroup(this, p));
}
 
bool Player::IsInSameRaidWith(Player const* p) const
{
 return p == this || (GetGroup() != nullptr && GetGroup() == p->GetGroup());
}
 
void Player::UninviteFromGroup()
{
 Group* group = GetGroupInvite();
 if (!group)
 return;
 
 group->RemoveInvite(this);
 
 if (group->IsCreated())
 {
 if (group->GetMembersCount() <= 1) // group has just 1 member => disband
 group->Disband(true);
 }
 else
 {
 if (group->GetInviteeCount() <= 1)
 {
 group->RemoveAllInvites();
 delete group;
 }
 }
}
 
void Player::RemoveFromGroup(Group* group, ObjectGuid guid, RemoveMethod method /* = GROUP_REMOVEMETHOD_DEFAULT*/, ObjectGuid kicker /* = ObjectGuid::Empty */, char const* reason /* = nullptr */)
{
 if (!group)
 return;
 
 group->RemoveMember(guid, method, kicker, reason);
}
 
void Player::SetXP(uint32 xp)
{
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::XP), xp);
 
 int32 playerLevelDelta = 0;
 
 // If XP < 50%, player should see scaling creature with -1 level except for level max
 if (GetLevel() < MAX_LEVEL && xp < uint32(*m_activePlayerData->NextLevelXP / 2))
 playerLevelDelta = -1;
 
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ScalingPlayerLevelDelta), playerLevelDelta);
}
 
void Player::GiveXP(uint32 xp, Unit* victim, float group_rate)
{
 if (xp < 1)
 return;
 
 if (!IsAlive() && !GetBattlegroundId())
 return;
 
 if (HasPlayerFlag(PLAYER_FLAGS_NO_XP_GAIN))
 return;
 
 if (victim && victim->GetTypeId() == TYPEID_UNIT && !victim->ToCreature()->hasLootRecipient())
 return;
 
 uint8 level = GetLevel();
 
 sScriptMgr->OnGivePlayerXP(this, xp, victim);
 
 // XP to money conversion processed in Player::RewardQuest
 if (IsMaxLevel())
 return;
 
 uint32 bonus_xp;
 bool recruitAFriend = GetsRecruitAFriendBonus(true);
 
 // RaF does NOT stack with rested experience
 if (recruitAFriend)
 bonus_xp = 2 * xp; // xp + bonus_xp must add up to 3 * xp for RaF; calculation for quests done client-side
 else
 bonus_xp = victim ? _restMgr->GetRestBonusFor(REST_TYPE_XP, xp) : 0; // XP resting bonus
 
 WorldPackets::Character::LogXPGain packet;
 packet.Victim = victim ? victim->GetGUID() : ObjectGuid::Empty;
 packet.Original = xp + bonus_xp;
 packet.Reason = victim ? LOG_XP_REASON_KILL : LOG_XP_REASON_NO_KILL;
 packet.Amount = xp;
 packet.GroupBonus = group_rate;
 SendDirectMessage(packet.Write());
 
 uint32 nextLvlXP = GetXPForNextLevel();
 uint32 newXP = GetXP() + xp + bonus_xp;
 
 while (newXP >= nextLvlXP && !IsMaxLevel())
 {
 newXP -= nextLvlXP;
 
 if (!IsMaxLevel())
 GiveLevel(level + 1);
 
 level = GetLevel();
 nextLvlXP = GetXPForNextLevel();
 }
 
 SetXP(newXP);
}
 
// Update player to next level
// Current player experience not update (must be update by caller)
void Player::GiveLevel(uint8 level)
{
 uint8 oldLevel = GetLevel();
 if (level == oldLevel)
 return;
 
 if (Guild* guild = GetGuild())
 guild->UpdateMemberData(this, GUILD_MEMBER_DATA_LEVEL, level);
 
 PlayerLevelInfo info;
 sObjectMgr->GetPlayerLevelInfo(GetRace(), GetClass(), level, &info);
 
 uint32 basemana = 0;
 sObjectMgr->GetPlayerClassLevelInfo(GetClass(), level, basemana);
 
 WorldPackets::Misc::LevelUpInfo packet;
 packet.Level = level;
 packet.HealthDelta = 0;
 
 // for (int i = 0; i < MAX_STORED_POWERS; ++i)
 packet.PowerDelta[0] = int32(basemana) - int32(GetCreateMana());
 packet.PowerDelta[1] = 0;
 packet.PowerDelta[2] = 0;
 packet.PowerDelta[3] = 0;
 packet.PowerDelta[4] = 0;
 packet.PowerDelta[5] = 0;
 packet.PowerDelta[6] = 0;
 
 for (uint8 i = STAT_STRENGTH; i < MAX_STATS; ++i)
 packet.StatDelta[i] = int32(info.stats[i]) - GetCreateStat(Stats(i));
 
 packet.NumNewTalents = DB2Manager::GetNumTalentsAtLevel(level, Classes(GetClass())) - DB2Manager::GetNumTalentsAtLevel(oldLevel, Classes(GetClass()));
 packet.NumNewPvpTalentSlots = sDB2Manager.GetPvpTalentNumSlotsAtLevel(level, Classes(GetClass())) - sDB2Manager.GetPvpTalentNumSlotsAtLevel(oldLevel, Classes(GetClass()));
 
 SendDirectMessage(packet.Write());
 
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::NextLevelXP), sObjectMgr->GetXPForLevel(level));
 
 //update level, max level of skills
 m_Played_time[PLAYED_TIME_LEVEL] = 0; // Level Played Time reset
 
 _ApplyAllLevelScaleItemMods(false);
 
 SetLevel(level);
 
 UpdateSkillsForLevel();
 LearnDefaultSkills();
 LearnSpecializationSpells();
 
 // save base values (bonuses already included in stored stats
 for (uint8 i = STAT_STRENGTH; i < MAX_STATS; ++i)
 SetCreateStat(Stats(i), info.stats[i]);
 
 SetCreateHealth(0);
 SetCreateMana(basemana);
 
 InitTalentForLevel();
 InitTaxiNodesForLevel();
 
 UpdateAllStats();
 
 _ApplyAllLevelScaleItemMods(true); // Moved to above SetFullHealth so player will have full health from Heirlooms
 
 if (Aura const* artifactAura = GetAura(ARTIFACTS_ALL_WEAPONS_GENERAL_WEAPON_EQUIPPED_PASSIVE))
 if (Item* artifact = GetItemByGuid(artifactAura->GetCastItemGUID()))
 artifact->CheckArtifactRelicSlotUnlock(this);
 
 // Only health and mana are set to maximum.
 SetFullHealth();
 for (PowerTypeEntry const* powerType : sPowerTypeStore)
 if (powerType->GetFlags().HasFlag(PowerTypeFlags::SetToMaxOnLevelUp))
 SetFullPower(Powers(powerType->PowerTypeEnum));
 
 // update level to hunter/summon pet
 if (Pet* pet = GetPet())
 pet->SynchronizeLevelWithOwner();
 
 if (MailLevelReward const* mailReward = sObjectMgr->GetMailLevelReward(level, GetRace()))
 {
 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 MailDraft(mailReward->mailTemplateId).SendMailTo(trans, this, MailSender(MAIL_CREATURE, uint64(mailReward->senderEntry)));
 CharacterDatabase.CommitTransaction(trans);
 }
 
 StartCriteria(CriteriaStartEvent::ReachLevel, level);
 UpdateCriteria(CriteriaType::ReachLevel);
 UpdateCriteria(CriteriaType::ActivelyReachLevel, level);
 if (level > oldLevel)
 UpdateCriteria(CriteriaType::GainLevels, level - oldLevel);
 
 PushQuests();
 
 sScriptMgr->OnPlayerLevelChanged(this, oldLevel);
}
 
bool Player::IsMaxLevel() const
{
 return GetLevel() >= m_activePlayerData->MaxLevel;
}
 
void Player::InitTalentForLevel()
{
 uint8 level = GetLevel();
 // talents base at level diff (talents = level - 9 but some can be used already)
 if (level < MIN_SPECIALIZATION_LEVEL)
 ResetTalentSpecialization();
 
 int32 talentTiers = DB2Manager::GetNumTalentsAtLevel(level, Classes(GetClass()));
 if (level < 15)
 {
 // Remove all talent points
 ResetTalents(true);
 }
 else
 {
 if (!GetSession()->HasPermission(rbac::RBAC_PERM_SKIP_CHECK_MORE_TALENTS_THAN_ALLOWED))
 for (int32 t = talentTiers; t < MAX_TALENT_TIERS; ++t)
 for (uint32 c = 0; c < MAX_TALENT_COLUMNS; ++c)
 for (TalentEntry const* talent : sDB2Manager.GetTalentsByPosition(GetClass(), t, c))
 RemoveTalent(talent);
 }
 
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::MaxTalentTiers), talentTiers);
 
 if (!GetSession()->HasPermission(rbac::RBAC_PERM_SKIP_CHECK_MORE_TALENTS_THAN_ALLOWED))
 for (uint8 spec = 0; spec < MAX_SPECIALIZATIONS; ++spec)
 for (size_t slot = sDB2Manager.GetPvpTalentNumSlotsAtLevel(level, Classes(GetClass())); slot < MAX_PVP_TALENT_SLOTS; ++slot)
 if (PvpTalentEntry const* pvpTalent = sPvpTalentStore.LookupEntry(GetPvpTalentMap(spec)[slot]))
 RemovePvpTalent(pvpTalent, spec);
 
 if (!GetSession()->PlayerLoading())
 SendTalentsInfoData(); // update at client
}
 
void Player::InitStatsForLevel(bool reapplyMods)
{
 if (reapplyMods) //reapply stats values only on .reset stats (level) command
 _RemoveAllStatBonuses();
 
 uint32 basemana = 0;
 sObjectMgr->GetPlayerClassLevelInfo(GetClass(), GetLevel(), basemana);
 
 PlayerLevelInfo info;
 sObjectMgr->GetPlayerLevelInfo(GetRace(), GetClass(), GetLevel(), &info);
 
 uint8 exp_max_lvl = GetMaxLevelForExpansion(GetSession()->GetExpansion());
 uint8 conf_max_lvl = sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL);
 if (exp_max_lvl == DEFAULT_MAX_LEVEL || exp_max_lvl >= conf_max_lvl)
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::MaxLevel), conf_max_lvl);
 else
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::MaxLevel), exp_max_lvl);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::NextLevelXP), sObjectMgr->GetXPForLevel(GetLevel()));
 if (m_activePlayerData->XP >= m_activePlayerData->NextLevelXP)
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::XP), m_activePlayerData->NextLevelXP - 1);
 
 // reset before any aura state sources (health set/aura apply)
 SetUpdateFieldValue(m_values.ModifyValue(&Unit::m_unitData).ModifyValue(&UF::UnitData::AuraState), 0);
 
 UpdateSkillsForLevel();
 
 // set default cast time multiplier
 SetModCastingSpeed(1.0f);
 SetModSpellHaste(1.0f);
 SetModHaste(1.0f);
 SetModRangedHaste(1.0f);
 SetModHasteRegen(1.0f);
 SetModTimeRate(1.0f);
 SetSpellEmpowerStage(-1);
 
 // reset size before reapply auras
 SetObjectScale(1.0f);
 
 // save base values (bonuses already included in stored stats
 for (uint8 i = STAT_STRENGTH; i < MAX_STATS; ++i)
 SetCreateStat(Stats(i), info.stats[i]);
 
 for (uint8 i = STAT_STRENGTH; i < MAX_STATS; ++i)
 SetStat(Stats(i), info.stats[i]);
 
 SetCreateHealth(0);
 
 //set create powers
 SetCreateMana(basemana);
 
 SetArmor(int32(m_createStats[STAT_AGILITY]*2), 0);
 
 InitStatBuffMods();
 
 //reset rating fields values
 for (uint16 index = 0; index < MAX_COMBAT_RATING; ++index)
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::CombatRatings, index), 0);
 
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ModHealingDonePos), 0);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ModHealingPercent), 1.0f);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ModPeriodicHealingDonePercent), 1.0f);
 for (uint8 i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
 {
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ModDamageDoneNeg, i), 0);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ModDamageDonePos, i), 0);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ModDamageDonePercent, i), 1.0f);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ModHealingDonePercent, i), 1.0f);
 }
 
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ModSpellPowerPercent), 1.0f);
 
 //reset attack power, damage and attack speed fields
 for (uint8 i = BASE_ATTACK; i < MAX_ATTACK; ++i)
 SetBaseAttackTime(WeaponAttackType(i), BASE_ATTACK_TIME);
 
 SetUpdateFieldValue(m_values.ModifyValue(&Unit::m_unitData).ModifyValue(&UF::UnitData::MinDamage), 0.0f);
 SetUpdateFieldValue(m_values.ModifyValue(&Unit::m_unitData).ModifyValue(&UF::UnitData::MaxDamage), 0.0f);
 SetUpdateFieldValue(m_values.ModifyValue(&Unit::m_unitData).ModifyValue(&UF::UnitData::MinOffHandDamage), 0.0f);
 SetUpdateFieldValue(m_values.ModifyValue(&Unit::m_unitData).ModifyValue(&UF::UnitData::MaxOffHandDamage), 0.0f);
 SetUpdateFieldValue(m_values.ModifyValue(&Unit::m_unitData).ModifyValue(&UF::UnitData::MinRangedDamage), 0.0f);
 SetUpdateFieldValue(m_values.ModifyValue(&Unit::m_unitData).ModifyValue(&UF::UnitData::MaxRangedDamage), 0.0f);
 for (uint16 i = 0; i < 3; ++i)
 {
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::WeaponDmgMultipliers, i), 1.0f);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::WeaponAtkSpeedMultipliers, i), 1.0f);
 }
 
 SetAttackPower(0);
 SetAttackPowerMultiplier(0.0f);
 SetRangedAttackPower(0);
 SetRangedAttackPowerMultiplier(0.0f);
 
 // Base crit values (will be recalculated in UpdateAllStats() at loading and in _ApplyAllStatBonuses() at reset
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::CritPercentage), 0.0f);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::OffhandCritPercentage), 0.0f);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::RangedCritPercentage), 0.0f);
 
 // Init spell schools (will be recalculated in UpdateAllStats() at loading and in _ApplyAllStatBonuses() at reset
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::SpellCritPercentage), 0.0f);
 
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ParryPercentage), 0.0f);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::BlockPercentage), 0.0f);
 
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ShieldBlock), 0);
 
 // Dodge percentage
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::DodgePercentage), 0.0f);
 
 // set armor (resistance 0) to original value (create_agility*2)
 SetArmor(int32(m_createStats[STAT_AGILITY] * 2), 0);
 SetBonusResistanceMod(SPELL_SCHOOL_NORMAL, 0);
 // set other resistance to original value (0)
 for (uint8 i = SPELL_SCHOOL_HOLY; i < MAX_SPELL_SCHOOL; ++i)
 {
 SetResistance(SpellSchools(i), 0);
 SetBonusResistanceMod(SpellSchools(i), 0);
 }
 
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ModTargetResistance), 0);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::ModTargetPhysicalResistance), 0);
 for (uint8 i = SPELL_SCHOOL_NORMAL; i < MAX_SPELL_SCHOOL; ++i)
 SetUpdateFieldValue(m_values.ModifyValue(&Unit::m_unitData).ModifyValue(&UF::UnitData::ManaCostModifier, i), 0);
 
 // Reset no reagent cost field
 SetNoRegentCostMask(flag128());
 
 // Init data for form but skip reapply item mods for form
 InitDataForForm(reapplyMods);
 
 // save new stats
 for (uint8 i = POWER_MANA; i < MAX_POWERS; ++i)
 SetMaxPower(Powers(i), uint32(GetCreatePowerValue(Powers(i))));
 
 SetMaxHealth(0); // stamina bonus will applied later
 
 // cleanup mounted state (it will set correctly at aura loading if player saved at mount.
 SetMountDisplayId(0);
 
 // cleanup unit flags (will be re-applied if need at aura load).
 RemoveUnitFlag(
 UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_REMOVE_CLIENT_CONTROL | UNIT_FLAG_NOT_ATTACKABLE_1 |
 UNIT_FLAG_IMMUNE_TO_PC | UNIT_FLAG_IMMUNE_TO_NPC | UNIT_FLAG_LOOTING |
 UNIT_FLAG_PET_IN_COMBAT | UNIT_FLAG_PACIFIED |
 UNIT_FLAG_STUNNED | UNIT_FLAG_IN_COMBAT | UNIT_FLAG_DISARMED |
 UNIT_FLAG_CONFUSED | UNIT_FLAG_FLEEING | UNIT_FLAG_UNINTERACTIBLE |
 UNIT_FLAG_SKINNABLE | UNIT_FLAG_MOUNT | UNIT_FLAG_ON_TAXI );
 SetUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED); // must be set
 
 SetUnitFlag2(UNIT_FLAG2_REGENERATE_POWER);// must be set
 
 // cleanup player flags (will be re-applied if need at aura load), to avoid have ghost flag without ghost aura, for example.
 RemovePlayerFlag(PLAYER_FLAGS_AFK | PLAYER_FLAGS_DND | PLAYER_FLAGS_GM | PLAYER_FLAGS_GHOST);
 
 RemoveVisFlag(UNIT_VIS_FLAGS_ALL); // one form stealth modified bytes
 RemovePvpFlag(UNIT_BYTE2_FLAG_FFA_PVP | UNIT_BYTE2_FLAG_SANCTUARY);
 
 // restore if need some important flags
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::LocalRegenFlags), 0);
 SetUpdateFieldValue(m_values.ModifyValue(&Player::m_activePlayerData).ModifyValue(&UF::ActivePlayerData::AuraVision), 0);
 
 if (reapplyMods) // reapply stats values only on .reset stats (level) command
 _ApplyAllStatBonuses();
 
 // set current level health and mana/energy to maximum after applying all mods.
 SetFullHealth();
 SetFullPower(POWER_MANA);
 SetFullPower(POWER_ENERGY);
 if (GetPower(POWER_RAGE) > GetMaxPower(POWER_RAGE))
 SetFullPower(POWER_RAGE);
 SetFullPower(POWER_FOCUS);
 SetPower(POWER_RUNIC_POWER, 0);
 
 // update level to hunter/summon pet
 if (Pet* pet = GetPet())
 pet->SynchronizeLevelWithOwner();
}
 
void Player::SendKnownSpells()
{
 WorldPackets::Spells::SendKnownSpells knownSpells;
 knownSpells.InitialLogin = IsLoading();
 
 knownSpells.KnownSpells.reserve(m_spells.size());
 for (PlayerSpellMap::value_type const& spell : m_spells)
 {
 if (spell.second.state == PLAYERSPELL_REMOVED)
 continue;
 
 if (!spell.second.active || spell.second.disabled)
 continue;
 
 knownSpells.KnownSpells.push_back(spell.first);
 if (spell.second.favorite)
 knownSpells.FavoriteSpells.push_back(spell.first);
 }
 
 SendDirectMessage(knownSpells.Write());
}
 
void Player::SendUnlearnSpells()
{
 WorldPackets::Spells::SendUnlearnSpells sendUnlearnSpells;
 SendDirectMessage(sendUnlearnSpells.Write());
}
 
void Player::RemoveMail(uint64 id)
{
 for (PlayerMails::iterator itr = m_mail.begin(); itr != m_mail.end(); ++itr)
 {
 if ((*itr)->messageID == id)
 {
 //do not delete item, because Player::removeMail() is called when returning mail to sender.
 m_mail.erase(itr);
 return;
 }
 }
}
 
void Player::SendMailResult(uint64 mailId, MailResponseType mailAction, MailResponseResult mailError, uint32 equipError, ObjectGuid::LowType itemGuid, uint32 itemCount) const
{
 WorldPackets::Mail::MailCommandResult result;
 
 result.MailID = mailId;
 result.Command = mailAction;
 result.ErrorCode = mailError;
 
 if (mailError == MAIL_ERR_EQUIP_ERROR)
 result.BagResult = equipError;
 else if (mailAction == MAIL_ITEM_TAKEN)
 {
 result.AttachID = itemGuid;
 result.QtyInInventory = itemCount;
 }
 SendDirectMessage(result.Write());
}
 
void Player::SendNewMail() const
{
 // deliver undelivered mail
 WorldPackets::Mail::NotifyReceivedMail notify;
 notify.Delay = 0.0f;
 
 SendDirectMessage(notify.Write());
}
 
void Player::UpdateNextMailTimeAndUnreads()
{
 // calculate next delivery time (min. from non-delivered mails
 // and recalculate unReadMail
 time_t cTime = GameTime::GetGameTime();
 m_nextMailDelivereTime = 0;
 unReadMails = 0;
 for (PlayerMails::iterator itr = m_mail.begin(); itr != m_mail.end(); ++itr)
 {
 if ((*itr)->deliver_time > cTime)
 {
 if (!m_nextMailDelivereTime || m_nextMailDelivereTime > (*itr)->deliver_time)
 m_nextMailDelivereTime = (*itr)->deliver_time;
 }
 else if (((*itr)->checked & MAIL_CHECK_MASK_READ) == 0)
 ++unReadMails;
 }
}
 
void Player::AddNewMailDeliverTime(time_t deliver_time)
{
 if (deliver_time <= GameTime::GetGameTime()) // ready now
 {
 ++unReadMails;
 SendNewMail();
 }
 else // not ready and no have ready mails
 {
 if (!m_nextMailDelivereTime || m_nextMailDelivereTime > deliver_time)
 m_nextMailDelivereTime = deliver_time;
 }
}
 
void DeleteSpellFromAllPlayers(uint32 spellId)
{
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_INVALID_SPELL_SPELLS);
 stmt->setUInt32(0, spellId);
 CharacterDatabase.Execute(stmt);
}
 
bool Player::AddTalent(TalentEntry const* talent, uint8 spec, bool learning)
{
 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(talent->SpellID, DIFFICULTY_NONE);
 if (!spellInfo)
 {
 TC_LOG_ERROR("spells", "Player::AddTalent: Spell (ID: {}) does not exist.", talent->SpellID);
 return false;
 }
 
 if (!SpellMgr::IsSpellValid(spellInfo, this, false))
 {
 TC_LOG_ERROR("spells", "Player::AddTalent: Spell (ID: {}) is invalid", talent->SpellID);
 return false;
 }
 
 PlayerTalentMap::iterator itr = GetTalentMap(spec)->find(talent->ID);
 if (itr != GetTalentMap(spec)->end())
 itr->second = PLAYERSPELL_UNCHANGED;
 else
 (*GetTalentMap(spec))[talent->ID] = learning ? PLAYERSPELL_NEW : PLAYERSPELL_UNCHANGED;
 
 if (spec == GetActiveTalentGroup())
 {
 LearnSpell(talent->SpellID, true);
 if (talent->OverridesSpellID)
 AddOverrideSpell(talent->OverridesSpellID, talent->SpellID);
 }
 
 if (learning)
 RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags2::ChangeTalent);
 
 return true;
}
 
void Player::RemoveTalent(TalentEntry const* talent)
{
 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(talent->SpellID, DIFFICULTY_NONE);
 if (!spellInfo)
 return;
 
 RemoveSpell(talent->SpellID, true);
 
 // search for spells that the talent teaches and unlearn them
 for (SpellEffectInfo const& spellEffectInfo : spellInfo->GetEffects())
 if (spellEffectInfo.IsEffect(SPELL_EFFECT_LEARN_SPELL) && spellEffectInfo.TriggerSpell > 0)
 RemoveSpell(spellEffectInfo.TriggerSpell, true);
 
 if (talent->OverridesSpellID)
 RemoveOverrideSpell(talent->OverridesSpellID, talent->SpellID);
 
 // if this talent rank can be found in the PlayerTalentMap, mark the talent as removed so it gets deleted
 PlayerTalentMap::iterator plrTalent = GetTalentMap(GetActiveTalentGroup())->find(talent->ID);
 if (plrTalent != GetTalentMap(GetActiveTalentGroup())->end())
 plrTalent->second = PLAYERSPELL_REMOVED;
}
 
void Player::AddStoredAuraTeleportLocation(uint32 spellId)
{
 StoredAuraTeleportLocation& storedLocation = m_storedAuraTeleportLocations[spellId];
 storedLocation.Loc.WorldRelocate(this);
 storedLocation.State = StoredAuraTeleportLocation::CHANGED;
}
 
void Player::RemoveStoredAuraTeleportLocation(uint32 spellId)
{
 if (StoredAuraTeleportLocation* storedLocation = Trinity::Containers::MapGetValuePtr(m_storedAuraTeleportLocations, spellId))
 storedLocation->State = StoredAuraTeleportLocation::DELETED;
}
 
WorldLocation const* Player::GetStoredAuraTeleportLocation(uint32 spellId) const
{
 if (StoredAuraTeleportLocation const* auraLocation = Trinity::Containers::MapGetValuePtr(m_storedAuraTeleportLocations, spellId))
 return &auraLocation->Loc;
 
 return nullptr;
}
 
bool Player::AddSpell(uint32 spellId, bool active, bool learning, bool dependent, bool disabled, bool loading /*= false*/, int32 fromSkill /*= 0*/, bool favorite /*= false*/, Optional<int32> traitDefinitionId /*= {}*/)
{
 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId, DIFFICULTY_NONE);
 if (!spellInfo)
 {
 // do character spell book cleanup (all characters)
 if (!IsInWorld() && !learning) // spell load case
 {
 TC_LOG_ERROR("spells", "Player::AddSpell: Spell (ID: {}) does not exist. deleting for all characters in `character_spell`.", spellId);
 
 DeleteSpellFromAllPlayers(spellId);
 }
 else
 TC_LOG_ERROR("spells", "Player::AddSpell: Spell (ID: {}) does not exist", spellId);
 
 return false;
 }
 
 if (!SpellMgr::IsSpellValid(spellInfo, this, false))
 {
 // do character spell book cleanup (all characters)
 if (!IsInWorld() && !learning) // spell load case
 {
 TC_LOG_ERROR("spells", "Player::AddSpell: Spell (ID: {}) is invalid. deleting for all characters in `character_spell`.", spellId);
 
 DeleteSpellFromAllPlayers(spellId);
 }
 else
 TC_LOG_ERROR("spells", "Player::AddSpell: Spell (ID: {}) is invalid", spellId);
 
 return false;
 }
 
 PlayerSpellState state = learning ? PLAYERSPELL_NEW : PLAYERSPELL_UNCHANGED;
 
 bool dependent_set = false;
 bool disabled_case = false;
 bool superceded_old = false;
 
 PlayerSpellMap::iterator itr = m_spells.find(spellId);
 
 // Remove temporary spell if found to prevent conflicts
 if (itr != m_spells.end() && itr->second.state == PLAYERSPELL_TEMPORARY)
 RemoveTemporarySpell(spellId);
 else if (itr != m_spells.end())
 {
 uint32 next_active_spell_id = 0;
 // fix activate state for non-stackable low rank (and find next spell for !active case)
 if (spellInfo->IsRanked())
 {
 if (uint32 next = sSpellMgr->GetNextSpellInChain(spellId))
 {
 if (HasSpell(next))
 {
 // high rank already known so this must !active
 active = false;
 next_active_spell_id = next;
 }
 }
 }
 
 // not do anything if already known in expected state
 if (itr->second.state != PLAYERSPELL_REMOVED && itr->second.active == active &&
 itr->second.dependent == dependent && itr->second.disabled == disabled)
 {
 if (!IsInWorld() && !learning) // explicitly load from DB and then exist in it already and set correctly
 itr->second.state = PLAYERSPELL_UNCHANGED;
 
 return false;
 }
 
 // dependent spell known as not dependent, overwrite state
 if (itr->second.state != PLAYERSPELL_REMOVED && !itr->second.dependent && dependent)
 {
 itr->second.dependent = dependent;
 if (itr->second.state != PLAYERSPELL_NEW)
 itr->second.state = PLAYERSPELL_CHANGED;
 dependent_set = true;
 }
 
 if (itr->second.TraitDefinitionId != traitDefinitionId)
 {
 if (itr->second.TraitDefinitionId)
 if (TraitDefinitionEntry const* traitDefinition = sTraitDefinitionStore.LookupEntry(*itr->second.TraitDefinitionId))
 RemoveOverrideSpell(traitDefinition->OverridesSpellID, spellId);
 
 itr->second.TraitDefinitionId = traitDefinitionId;
 }
 
 itr->second.favorite = favorite;
 
 // update active state for known spell
 if (itr->second.active != active && itr->second.state != PLAYERSPELL_REMOVED && !itr->second.disabled)
 {
 itr->second.active = active;
 
 if (!IsInWorld() && !learning && !dependent_set) // explicitly load from DB and then exist in it already and set correctly
 itr->second.state = PLAYERSPELL_UNCHANGED;
 else if (itr->second.state != PLAYERSPELL_NEW)
 itr->second.state = PLAYERSPELL_CHANGED;
 
 if (active)
 {
 if (spellInfo->IsPassive() && HandlePassiveSpellLearn(spellInfo))
 CastSpell(this, spellId, true);
 }
 else if (IsInWorld())
 {
 if (next_active_spell_id)
 SendSupercededSpell(spellId, next_active_spell_id);
 else
 {
 WorldPackets::Spells::UnlearnedSpells unlearnedSpells;
 unlearnedSpells.SpellID.push_back(spellId);
 SendDirectMessage(unlearnedSpells.Write());
 }
 }
 
 return active; // learn (show in spell book if active now)
 }
 
 if (itr->second.disabled != disabled && itr->second.state != PLAYERSPELL_REMOVED)
 {
 if (itr->second.state != PLAYERSPELL_NEW)
 itr->second.state = PLAYERSPELL_CHANGED;
 itr->second.disabled = disabled;
 
 if (disabled)
 return false;
 
 disabled_case = true;
 }
 else switch (itr->second.state)
 {
 case PLAYERSPELL_UNCHANGED: // known saved spell
 return false;
 case PLAYERSPELL_REMOVED: // re-learning removed not saved spell
 {
 m_spells.erase(itr);
 state = PLAYERSPELL_CHANGED;
 break; // need re-add
 }
 default: // known not saved yet spell (new or modified)
 {
 // can be in case spell loading but learned at some previous spell loading
 if (!IsInWorld() && !learning && !dependent_set)
 itr->second.state = PLAYERSPELL_UNCHANGED;
 
 return false;
 }
 }
 }
 
 if (!disabled_case) // skip new spell adding if spell already known (disabled spells case)
 {
 // non talent spell: learn low ranks (recursive call)
 if (uint32 prev_spell = sSpellMgr->GetPrevSpellInChain(spellId))
 {
 if (!IsInWorld() || disabled) // at spells loading, no output, but allow save
 AddSpell(prev_spell, active, true, true, disabled, false, fromSkill);
 else // at normal learning
 LearnSpell(prev_spell, true, fromSkill);
 }
 
 std::pair<PlayerSpellMap::iterator, bool> inserted = m_spells.emplace(std::piecewise_construct, std::forward_as_tuple(spellId), std::forward_as_tuple());
 PlayerSpell& newspell = inserted.first->second;
 // learning a previous rank might have given us this spell already from a skill autolearn, most likely with PLAYERSPELL_NEW state
 // we dont want to do double insert if this happened during load from db so we force state to CHANGED, just in case
 newspell.state = inserted.second ? state : PLAYERSPELL_CHANGED;
 newspell.active = active;
 newspell.dependent = dependent;
 newspell.disabled = disabled;
 newspell.favorite = favorite;
 if (traitDefinitionId)
 newspell.TraitDefinitionId = *traitDefinitionId;
 
 // replace spells in action bars and spellbook to bigger rank if only one spell rank must be accessible
 if (newspell.active && !newspell.disabled && spellInfo->IsRanked())
 {
 for (PlayerSpellMap::iterator itr2 = m_spells.begin(); itr2 != m_spells.end(); ++itr2)
 {
 if (itr2->second.state == PLAYERSPELL_REMOVED)
 continue;
 
 SpellInfo const* i_spellInfo = sSpellMgr->GetSpellInfo(itr2->first, DIFFICULTY_NONE);
 if (!i_spellInfo)
 continue;
 
 if (spellInfo->IsDifferentRankOf(i_spellInfo))
 {
 if (itr2->second.active)
 {
 if (spellInfo->IsHighRankOf(i_spellInfo))
 {
 if (IsInWorld()) // not send spell (re-/over-)learn packets at loading
 SendSupercededSpell(itr2->first, spellId);
 
 // mark old spell as disable (SMSG_SUPERCEDED_SPELL replace it in client by new)
 itr2->second.active = false;
 if (itr2->second.state != PLAYERSPELL_NEW)
 itr2->second.state = PLAYERSPELL_CHANGED;
 superceded_old = true; // new spell replace old in action bars and spell book.
 }
 else
 {
 if (IsInWorld()) // not send spell (re-/over-)learn packets at loading
 SendSupercededSpell(spellId, itr2->first);
 
 // mark new spell as disable (not learned yet for client and will not learned)
 newspell.active = false;
 if (newspell.state != PLAYERSPELL_NEW)
 newspell.state = PLAYERSPELL_CHANGED;
 }
 }
 }
 }
 }
 
 // return false if spell disabled
 if (newspell.disabled)
 return false;
 }
 
 bool castSpell = false;
 
 // cast talents with SPELL_EFFECT_LEARN_SPELL (other dependent spells will learned later as not auto-learned)
 // note: all spells with SPELL_EFFECT_LEARN_SPELL isn't passive
 if (!loading && spellInfo->HasAttribute(SPELL_ATTR0_CU_IS_TALENT) && spellInfo->HasEffect(SPELL_EFFECT_LEARN_SPELL))
 // ignore stance requirement for talent learn spell (stance set for spell only for client spell description show)
 castSpell = true;
 // also cast passive spells (including all talents without SPELL_EFFECT_LEARN_SPELL) with additional checks
 else if (spellInfo->IsPassive())
 castSpell = HandlePassiveSpellLearn(spellInfo);
 else if (spellInfo->HasEffect(SPELL_EFFECT_SKILL_STEP))
 castSpell = true;
 else if (spellInfo->HasAttribute(SPELL_ATTR1_CAST_WHEN_LEARNED))
 castSpell = true;
 
 if (castSpell)
 {
 CastSpellExtraArgs args;
 args.SetTriggerFlags(TRIGGERED_FULL_MASK);
 
 if (traitDefinitionId)
 {
 if (UF::TraitConfig const* traitConfig = GetTraitConfig(m_activePlayerData->ActiveCombatTraitConfigID))
 {
 int32 traitEntryIndex = traitConfig->Entries.FindIndexIf([traitDefinitionId](UF::TraitEntry const& traitEntry)
 {
 return sTraitNodeEntryStore.AssertEntry(traitEntry.TraitNodeEntryID)->TraitDefinitionID == traitDefinitionId;
 });
 int32 rank = 0;
 if (traitEntryIndex >= 0)
 rank = traitConfig->Entries[traitEntryIndex].Rank + traitConfig->Entries[traitEntryIndex].GrantedRanks;
 
 if (rank > 0)
 {
 if (std::vector<TraitDefinitionEffectPointsEntry const*> const* traitDefinitionEffectPoints = TraitMgr::GetTraitDefinitionEffectPointModifiers(*traitDefinitionId))
 {
 for (TraitDefinitionEffectPointsEntry const* traitDefinitionEffectPoint : *traitDefinitionEffectPoints)
 {
 if (traitDefinitionEffectPoint->EffectIndex >= int32(spellInfo->GetEffects().size()))
 continue;
 
 float basePoints = sDB2Manager.GetCurveValueAt(traitDefinitionEffectPoint->CurveID, rank);
 if (traitDefinitionEffectPoint->GetOperationType() == TraitPointsOperationType::Multiply)
 basePoints *= spellInfo->GetEffect(SpellEffIndex(traitDefinitionEffectPoint->EffectIndex)).CalcBaseValue(this, nullptr, 0, -1);
 
 args.AddSpellMod(SpellValueMod(SPELLVALUE_BASE_POINT0 + traitDefinitionEffectPoint->EffectIndex), basePoints);
 }
 }
 }
 }
 }
 
 CastSpell(this, spellId, args);
 if (spellInfo->HasEffect(SPELL_EFFECT_SKILL_STEP))
 return false;
 }
 
 if (traitDefinitionId)
 if (TraitDefinitionEntry const* traitDefinition = sTraitDefinitionStore.LookupEntry(*traitDefinitionId))
 if (traitDefinition->OverridesSpellID)
 AddOverrideSpell(traitDefinition->OverridesSpellID, spellId);
 
 // update free primary prof.points (if any, can be none in case GM .learn prof. learning)
 if (uint32 freeProfs = GetFreePrimaryProfessionPoints())
 {
 if (spellInfo->IsPrimaryProfessionFirstRank())
 SetFreePrimaryProfessions(freeProfs - 1);
 }
 
 SkillLineAbilityMapBounds skill_bounds = sSpellMgr->GetSkillLineAbilityMapBounds(spellId);
 
 if (SpellLearnSkillNode const* spellLearnSkill = sSpellMgr->GetSpellLearnSkill(spellId))
 {
 // add dependent skills if this spell is not learned from adding skill already
 if (spellLearnSkill->skill != fromSkill)
 {
 uint16 skill_value = GetPureSkillValue(spellLearnSkill->skill);
 uint16 skill_max_value = GetPureMaxSkillValue(spellLearnSkill->skill);
 
 if (skill_value < spellLearnSkill->value)
 skill_value = spellLearnSkill->value;
 
 uint16 new_skill_max_value = spellLearnSkill->maxvalue;
 
 if (new_skill_max_value == 0)
 {
 if (SkillRaceClassInfoEntry const* rcInfo = sDB2Manager.GetSkillRaceClassInfo(spellLearnSkill->skill, GetRace(), GetClass()))
 {
 switch (GetSkillRangeType(rcInfo))
 {
 case SKILL_RANGE_LANGUAGE:
 skill_value = 300;
 new_skill_max_value = 300;
 break;
 case SKILL_RANGE_LEVEL:
 new_skill_max_value = GetMaxSkillValueForLevel();
 break;
 case SKILL_RANGE_MONO:
 new_skill_max_value = 1;
 break;
 case SKILL_RANGE_RANK:
 {
 SkillTiersEntry const* tier = sObjectMgr->GetSkillTier(rcInfo->SkillTierID);
 new_skill_max_value = tier->GetValueForTierIndex(spellLearnSkill->step - 1);
 break;
 }
 default:
 break;
 }
 
 if (rcInfo->Flags & SKILL_FLAG_ALWAYS_MAX_VALUE)
 skill_value = new_skill_max_value;
 }
 }
 
 if (skill_max_value < new_skill_max_value)
 skill_max_value = new_skill_max_value;
 
 SetSkill(spellLearnSkill->skill, spellLearnSkill->step, skill_value, skill_max_value);
 }
 }
 else
 {
 // not ranked skills
 for (SkillLineAbilityMap::const_iterator _spell_idx = skill_bounds.first; _spell_idx != skill_bounds.second; ++_spell_idx)
 {
 SkillLineEntry const* pSkill = sSkillLineStore.LookupEntry(_spell_idx->second->SkillLine);
 if (!pSkill)
 continue;
 
 if (_spell_idx->second->SkillLine == fromSkill)
 continue;
 
 // Runeforging special case
 if ((_spell_idx->second->AcquireMethod == SKILL_LINE_ABILITY_LEARNED_ON_SKILL_LEARN && !HasSkill(_spell_idx->second->SkillLine)) || ((_spell_idx->second->SkillLine == SKILL_RUNEFORGING) && _spell_idx->second->TrivialSkillLineRankHigh == 0))
 if (SkillRaceClassInfoEntry const* rcInfo = sDB2Manager.GetSkillRaceClassInfo(_spell_idx->second->SkillLine, GetRace(), GetClass()))
 LearnDefaultSkill(rcInfo);
 }
 }
 
 // learn dependent spells
 SpellLearnSpellMapBounds spell_bounds = sSpellMgr->GetSpellLearnSpellMapBounds(spellId);
 
 for (SpellLearnSpellMap::const_iterator itr2 = spell_bounds.first; itr2 != spell_bounds.second; ++itr2)
 {
 if (!itr2->second.AutoLearned)
 {
 if (!IsInWorld() || !itr2->second.Active) // at spells loading, no output, but allow save
 AddSpell(itr2->second.Spell, itr2->second.Active, true, true, false);
 else // at normal learning
 LearnSpell(itr2->second.Spell, true);
 }
 
 if (itr2->second.OverridesSpell && itr2->second.Active)
 AddOverrideSpell(itr2->second.OverridesSpell, itr2->second.Spell);
 }
 
 if (!GetSession()->PlayerLoading())
 {
 // not ranked skills
 for (SkillLineAbilityMap::const_iterator _spell_idx = skill_bounds.first; _spell_idx != skill_bounds.second; ++_spell_idx)
 {
 UpdateCriteria(CriteriaType::LearnTradeskillSkillLine, _spell_idx->second->SkillLine);
 UpdateCriteria(CriteriaType::LearnSpellFromSkillLine, _spell_idx->second->SkillLine);
 }
 
 UpdateCriteria(CriteriaType::LearnOrKnowSpell, spellId);
 }
 
 // needs to be when spell is already learned, to prevent infinite recursion crashes
 if (sDB2Manager.GetMount(spellId))
 GetSession()->GetCollectionMgr()->AddMount(spellId, MOUNT_STATUS_NONE, false, IsInWorld() ? false : true);
 
 // return true (for send learn packet) only if spell active (in case ranked spells) and not replace old spell
 return active && !disabled && !superceded_old;
}
 
void Player::AddTemporarySpell(uint32 spellId)
{
 PlayerSpellMap::iterator itr = m_spells.find(spellId);
 // spell already added - do not do anything
 if (itr != m_spells.end())
 return;
 PlayerSpell* newspell = &m_spells[spellId];
 newspell->state = PLAYERSPELL_TEMPORARY;
 newspell->active = true;
 newspell->dependent = false;
 newspell->disabled = false;
}
 
void Player::RemoveTemporarySpell(uint32 spellId)
{
 PlayerSpellMap::iterator itr = m_spells.find(spellId);
 // spell already not in list - do not do anything
 if (itr == m_spells.end())
 return;
 // spell has other state than temporary - do not change it
 if (itr->second.state != PLAYERSPELL_TEMPORARY)
 return;
 m_spells.erase(itr);
}
 
bool Player::HandlePassiveSpellLearn(SpellInfo const* spellInfo)
{
 // note: form passives activated with shapeshift spells be implemented by HandleShapeshiftBoosts instead of spell_learn_spell
 // talent dependent passives activated at form apply have proper stance data
 ShapeshiftForm form = GetShapeshiftForm();
 bool need_cast = (!spellInfo->Stances || (form && (spellInfo->Stances & (UI64LIT(1) << (form - 1)))) ||
 (!form && (spellInfo->HasAttribute(SPELL_ATTR2_ALLOW_WHILE_NOT_SHAPESHIFTED_CASTER_FORM))));
 
 // Check EquippedItemClass
 // passive spells which apply aura and have an item requirement are to be added manually, instead of casted
 if (spellInfo->EquippedItemClass >= 0)
 {
 for (SpellEffectInfo const& spellEffectInfo : spellInfo->GetEffects())
 {
 if (spellEffectInfo.IsAura())
 {
 if (!HasAura(spellInfo->Id) && HasItemFitToSpellRequirements(spellInfo))
 AddAura(spellInfo->Id, this);
 return false;
 }
 }
 }
 
 //Check CasterAuraStates
 return need_cast && (!spellInfo->CasterAuraState || HasAuraState(AuraStateType(spellInfo->CasterAuraState)));
}
 
void Player::LearnSpell(uint32 spell_id, bool dependent, int32 fromSkill /*= 0*/, bool suppressMessaging /*= false*/, Optional<int32> traitDefinitionId /*= {}*/)
{
 PlayerSpellMap::iterator itr = m_spells.find(spell_id);
 
 bool disabled = (itr != m_spells.end()) ? itr->second.disabled : false;
 bool active = disabled ? itr->second.active : true;
 bool favorite = itr != m_spells.end() ? itr->second.favorite : false;
 
 bool learning = AddSpell(spell_id, active, true, dependent, false, false, fromSkill, favorite, traitDefinitionId);
 
 // prevent duplicated entires in spell book, also not send if not in world (loading)
 if (learning && IsInWorld())
 {
 WorldPackets::Spells::LearnedSpells learnedSpells;
 WorldPackets::Spells::LearnedSpellInfo& learnedSpellInfo = learnedSpells.ClientLearnedSpellData.emplace_back();
 learnedSpellInfo.SpellID = spell_id;
 learnedSpellInfo.IsFavorite = favorite;
 learnedSpellInfo.TraitDefinitionID = traitDefinitionId;
 learnedSpells.SuppressMessaging = suppressMessaging;
 SendDirectMessage(learnedSpells.Write());
 }
 
 // learn all disabled higher ranks and required spells (recursive)
 if (disabled)
 {
 if (uint32 nextSpell = sSpellMgr->GetNextSpellInChain(spell_id))
 {
 PlayerSpellMap::iterator iter = m_spells.find(nextSpell);
 if (iter != m_spells.end() && iter->second.disabled)
 LearnSpell(nextSpell, false, fromSkill);
 }
 
 SpellsRequiringSpellMapBounds spellsRequiringSpell = sSpellMgr->GetSpellsRequiringSpellBounds(spell_id);
 for (SpellsRequiringSpellMap::const_iterator itr2 = spellsRequiringSpell.first; itr2 != spellsRequiringSpell.second; ++itr2)
 {
 PlayerSpellMap::iterator iter2 = m_spells.find(itr2->second);
 if (iter2 != m_spells.end() && iter2->second.disabled)
 LearnSpell(itr2->second, false, fromSkill);
 }
 }
 else
 UpdateQuestObjectiveProgress(QUEST_OBJECTIVE_LEARNSPELL, spell_id, 1);
}
 
void Player::RemoveSpell(uint32 spell_id, bool disabled /*= false*/, bool learn_low_rank /*= true*/, bool suppressMessaging /*= false*/)
{
 PlayerSpellMap::iterator itr = m_spells.find(spell_id);
 if (itr == m_spells.end())
 return;
 
 if (itr->second.state == PLAYERSPELL_REMOVED || (disabled && itr->second.disabled) || itr->second.state == PLAYERSPELL_TEMPORARY)
 return;
 
 // unlearn non talent higher ranks (recursive)
 if (uint32 nextSpell = sSpellMgr->GetNextSpellInChain(spell_id))
 {
 SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(nextSpell, DIFFICULTY_NONE);
 if (HasSpell(nextSpell) && !spellInfo->HasAttribute(SPELL_ATTR0_CU_IS_TALENT))
 RemoveSpell(nextSpell, disabled, false);
 }
 //unlearn spells dependent from recently removed spells
 SpellsRequiringSpellMapBounds spellsRequiringSpell = sSpellMgr->GetSpellsRequiringSpellBounds(spell_id);
 for (SpellsRequiringSpellMap::const_iterator itr2 = spellsRequiringSpell.first; itr2 != spellsRequiringSpell.second; ++itr2)
 RemoveSpell(itr2->second, disabled);
 
 // re-search, it can be corrupted in prev loop
 itr = m_spells.find(spell_id);
 if (itr == m_spells.end())
 return; // already unleared
 
 bool cur_active = itr->second.active;
 bool cur_dependent = itr->second.dependent;
 Optional<int32> traitDefinitionId = itr->second.TraitDefinitionId;
 
 if (disabled)
 {
 itr->second.disabled = disabled;
 if (itr->second.state != PLAYERSPELL_NEW)
 itr->second.state = PLAYERSPELL_CHANGED;
 }
 else
 {
 if (itr->second.state == PLAYERSPELL_NEW)
 m_spells.erase(itr);
 else
 itr->second.state = PLAYERSPELL_REMOVED;
 }
 
 RemoveOwnedAura(spell_id, GetGUID());
 
 // remove pet auras
 for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
 if (PetAura const* petSpell = sSpellMgr->GetPetAura(spell_id, i))
 RemovePetAura(petSpell);
 
 // update free primary prof.points (if not overflow setting, can be in case GM use before .learn prof. learning)
 SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell_id, DIFFICULTY_NONE);
 if (spellInfo && spellInfo->IsPrimaryProfessionFirstRank())
 {
 uint32 freeProfs = GetFreePrimaryProfessionPoints()+1;
 if (freeProfs <= sWorld->getIntConfig(CONFIG_MAX_PRIMARY_TRADE_SKILL))
 SetFreePrimaryProfessions(freeProfs);
 }
 
 // remove dependent skill
 SpellLearnSkillNode const* spellLearnSkill = sSpellMgr->GetSpellLearnSkill(spell_id);
 if (spellLearnSkill)
 {
 uint32 prev_spell = sSpellMgr->GetPrevSpellInChain(spell_id);
 if (!prev_spell) // first rank, remove skill
 SetSkill(spellLearnSkill->skill, 0, 0, 0);
 else
 {
 // search prev. skill setting by spell ranks chain
 SpellLearnSkillNode const* prevSkill = sSpellMgr->GetSpellLearnSkill(prev_spell);
 while (!prevSkill && prev_spell)
 {
 prev_spell = sSpellMgr->GetPrevSpellInChain(prev_spell);
 prevSkill = sSpellMgr->GetSpellLearnSkill(sSpellMgr->GetFirstSpellInChain(prev_spell));
 }
 
 if (!prevSkill) // not found prev skill setting, remove skill
 SetSkill(spellLearnSkill->skill, 0, 0, 0);
 else // set to prev. skill setting values
 {
 uint16 skill_value = GetPureSkillValue(prevSkill->skill);
 uint16 skill_max_value = GetPureMaxSkillValue(prevSkill->skill);
 
 uint16 new_skill_max_value = prevSkill->maxvalue;
 
 if (new_skill_max_value == 0)
 {
 if (SkillRaceClassInfoEntry const* rcInfo = sDB2Manager.GetSkillRaceClassInfo(prevSkill->skill, GetRace(), GetClass()))
 {
 switch (GetSkillRangeType(rcInfo))
 {
 case SKILL_RANGE_LANGUAGE:
 skill_value = 300;
 new_skill_max_value = 300;
 break;
 case SKILL_RANGE_LEVEL:
 new_skill_max_value = GetMaxSkillValueForLevel();
 break;
 case SKILL_RANGE_MONO:
 new_skill_max_value = 1;
 break;
 case SKILL_RANGE_RANK:
 {
 SkillTiersEntry const* tier = sObjectMgr->GetSkillTier(rcInfo->SkillTierID);
 new_skill_max_value = tier->GetValueForTierIndex(prevSkill->step - 1);
 break;
 }
 default:
 break;
 }
 
 if (rcInfo->Flags & SKILL_FLAG_ALWAYS_MAX_VALUE)
 skill_value = new_skill_max_value;
 }
 }
 else if (skill_value > prevSkill->value)
 skill_value = prevSkill->value;
 
 if (skill_max_value > new_skill_max_value)
 skill_max_value = new_skill_max_value;
 
 if (skill_value > new_skill_max_value)
 skill_value = new_skill_max_value;
 
 SetSkill(prevSkill->skill, prevSkill->step, skill_value, skill_max_value);
 }
 }
 }
 
 // remove dependent spells
 SpellLearnSpellMapBounds spell_bounds = sSpellMgr->GetSpellLearnSpellMapBounds(spell_id);
 
 for (SpellLearnSpellMap::const_iterator itr2 = spell_bounds.first; itr2 != spell_bounds.second; ++itr2)
 {
 bool hasOtherSpellTeachingThis = std::ranges::any_of(sSpellMgr->GetSpellLearnedBySpellMapBounds(itr2->second.Spell), [&](SpellLearnSpellNode const* learnNode)
 {
 if (learnNode->SourceSpell == spell_id)
 return false;
 if (!learnNode->Active)
 return false;
 return HasSpell(learnNode->SourceSpell);
 }, &SpellLearnedBySpellMap::value_type::second);
 
 if (hasOtherSpellTeachingThis)
 continue;
 
 RemoveSpell(itr2->second.Spell, disabled);
 if (itr2->second.OverridesSpell)
 RemoveOverrideSpell(itr2->second.OverridesSpell, itr2->second.Spell);
 }
 
 // activate lesser rank in spellbook/action bar, and cast it if need
 bool prev_activate = false;
 
 if (uint32 prev_id = sSpellMgr->GetPrevSpellInChain(spell_id))
 {
 // if ranked non-stackable spell: need activate lesser rank and update dendence state
 if (cur_active && spellInfo->IsRanked())
 {
 // need manually update dependence state (learn spell ignore like attempts)
 PlayerSpellMap::iterator prev_itr = m_spells.find(prev_id);
 if (prev_itr != m_spells.end())
 {
 if (prev_itr->second.dependent != cur_dependent)
 {
 prev_itr->second.dependent = cur_dependent;
 if (prev_itr->second.state != PLAYERSPELL_NEW)
 prev_itr->second.state = PLAYERSPELL_CHANGED;
 }
 
 // now re-learn if need re-activate
 if (!prev_itr->second.active && learn_low_rank)
 {
 if (AddSpell(prev_id, true, false, prev_itr->second.dependent, prev_itr->second.disabled))
 {
 // downgrade spell ranks in spellbook and action bar
 SendSupercededSpell(spell_id, prev_id);
 prev_activate = true;
 }
 }
 }
 }
 }
 
 if (traitDefinitionId)
 if (TraitDefinitionEntry const* traitDefinition = sTraitDefinitionStore.LookupEntry(*traitDefinitionId))
 RemoveOverrideSpell(traitDefinition->OverridesSpellID, spell_id);
 
 m_overrideSpells.erase(spell_id);
 
 if (m_canTitanGrip)
 {
 if (spellInfo && spellInfo->IsPassive() && spellInfo->HasEffect(SPELL_EFFECT_TITAN_GRIP))
 {
 RemoveAurasDueToSpell(m_titanGripPenaltySpellId);
 SetCanTitanGrip(false);
 }
 }
 
 if (m_canDualWield)
 {
 if (spellInfo && spellInfo->IsPassive() && spellInfo->HasEffect(SPELL_EFFECT_DUAL_WIELD))
 SetCanDualWield(false);
 }
 
 if (sWorld->getBoolConfig(CONFIG_OFFHAND_CHECK_AT_SPELL_UNLEARN))
 AutoUnequipOffhandIfNeed();
 
 // remove from spell book if not replaced by lesser rank
 if (!prev_activate)
 {
 WorldPackets::Spells::UnlearnedSpells unlearnedSpells;
 unlearnedSpells.SpellID.push_back(spell_id);
 unlearnedSpells.SuppressMessaging = suppressMessaging;
 SendDirectMessage(unlearnedSpells.Write());
 }
}
 
void Player::SetSpellFavorite(uint32 spellId, bool favorite)
{
 auto itr = m_spells.find(spellId);
 if (itr == m_spells.end())
 return;
 
 itr->second.favorite = favorite;
 if (itr->second.state == PLAYERSPELL_UNCHANGED)
 itr->second.state = PLAYERSPELL_CHANGED;
}
 
void Player::RemoveArenaSpellCooldowns(bool removeActivePetCooldowns)
{
 // remove cooldowns on spells that have < 10 min CD
 GetSpellHistory()->ResetCooldowns([](SpellHistory::CooldownStorageType::iterator itr)
 {
 SpellInfo const* spellInfo = sSpellMgr->AssertSpellInfo(itr->first, DIFFICULTY_NONE);
 return spellInfo->RecoveryTime < 10 * MINUTE * IN_MILLISECONDS
 && spellInfo->CategoryRecoveryTime < 10 * MINUTE * IN_MILLISECONDS
 && !spellInfo->HasAttribute(SPELL_ATTR6_DO_NOT_RESET_COOLDOWN_IN_ARENA);
 }, true);
 
 // pet cooldowns
 if (removeActivePetCooldowns)
 if (Pet* pet = GetPet())
 pet->GetSpellHistory()->ResetAllCooldowns();
}
 
uint32 Player::GetNextResetTalentsCost() const
{
 // The first time reset costs 1 gold
 if (GetTalentResetCost() < 1*GOLD)
 return 1*GOLD;
 // then 5 gold
 else if (GetTalentResetCost() < 5*GOLD)
 return 5*GOLD;
 // After that it increases in increments of 5 gold
 else if (GetTalentResetCost() < 10*GOLD)
 return 10*GOLD;
 else
 {
 uint64 months = (GameTime::GetGameTime() - GetTalentResetTime())/MONTH;
 if (months > 0)
 {
 // This cost will be reduced by a rate of 5 gold per month
 int32 new_cost = int32(GetTalentResetCost() - 5*GOLD*months);
 // to a minimum of 10 gold.
 return (new_cost < 10*GOLD ? 10*GOLD : new_cost);
 }
 else
 {
 // After that it increases in increments of 5 gold
 int32 new_cost = GetTalentResetCost() + 5*GOLD;
 // until it hits a cap of 50 gold.
 if (new_cost > 50*GOLD)
 new_cost = 50*GOLD;
 return new_cost;
 }
 }
}
 
bool Player::ResetTalents(bool noCost)
{
 sScriptMgr->OnPlayerTalentsReset(this, noCost);
 
 // not need after this call
 if (HasAtLoginFlag(AT_LOGIN_RESET_TALENTS))
 RemoveAtLoginFlag(AT_LOGIN_RESET_TALENTS, true);
 
 uint32 cost = 0;
 
 if (!noCost && !sWorld->getBoolConfig(CONFIG_NO_RESET_TALENT_COST))
 {
 cost = GetNextResetTalentsCost();
 
 if (!HasEnoughMoney(uint64(cost)))
 {
 SendBuyError(BUY_ERR_NOT_ENOUGHT_MONEY, nullptr, 0, 0);
 return false;
 }
 }
 
 RemovePet(nullptr, PET_SAVE_NOT_IN_SLOT, true);
 
 for (uint32 talentId = 0; talentId < sTalentStore.GetNumRows(); ++talentId)
 {
 TalentEntry const* talentInfo = sTalentStore.LookupEntry(talentId);
 if (!talentInfo)
 continue;
 
 // unlearn only talents for character class
 // some spell learned by one class as normal spells or know at creation but another class learn it as talent,
 // to prevent unexpected lost normal learned spell skip another class talents
 if (talentInfo->ClassID != GetClass())
 continue;
 
 // skip non-existent talent ranks
 if (talentInfo->SpellID == 0)
 continue;
 
 RemoveTalent(talentInfo);
 }
 
 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 _SaveTalents(trans);
 _SaveSpells(trans);
 CharacterDatabase.CommitTransaction(trans);
 
 if (!noCost)
 {
 ModifyMoney(-(int64)cost);
 UpdateCriteria(CriteriaType::MoneySpentOnRespecs, cost);
 UpdateCriteria(CriteriaType::TotalRespecs, 1);
 
 SetTalentResetCost(cost);
 SetTalentResetTime(GameTime::GetGameTime());
 }
 
 /* when prev line will dropped use next line
 if (Pet* pet = GetPet())
 {
 if (pet->getPetType() == HUNTER_PET && !pet->GetCreatureTemplate()->IsTameable(CanTameExoticPets()))
 RemovePet(nullptr, PET_SAVE_NOT_IN_SLOT, true);
 }
 */
 
 return true;
}
 
void Player::ResetPvpTalents()
{
 for (uint8 spec = 0; spec < MAX_SPECIALIZATIONS; ++spec)
 for (uint32 talentId : GetPvpTalentMap(spec))
 if (PvpTalentEntry const* talentInfo = sPvpTalentStore.LookupEntry(talentId))
 RemovePvpTalent(talentInfo, spec);
}
 
Mail* Player::GetMail(uint64 id)
{
 for (PlayerMails::iterator itr = m_mail.begin(); itr != m_mail.end(); ++itr)
 if ((*itr)->messageID == id)
 return (*itr);
 
 return nullptr;
}
 
void Player::BuildCreateUpdateBlockForPlayer(UpdateData* data, Player* target) const
{
 if (target == this)
 {
 for (uint8 i = EQUIPMENT_SLOT_START; i < BANK_SLOT_BAG_END; ++i)
 {
 if (m_items[i] == nullptr)
 continue;
 
 m_items[i]->BuildCreateUpdateBlockForPlayer(data, target);
 }
 
 for (uint8 i = REAGENT_SLOT_START; i < CHILD_EQUIPMENT_SLOT_END; ++i)
 {
 if (m_items[i] == nullptr)
 continue;
 
 m_items[i]->BuildCreateUpdateBlockForPlayer(data, target);
 }
 }
 
 Unit::BuildCreateUpdateBlockForPlayer(data, target);
}
 
UF::UpdateFieldFlag Player::GetUpdateFieldFlagsFor(Player const* target) const
{
 UF::UpdateFieldFlag flags = Unit::GetUpdateFieldFlagsFor(target);
 if (IsInSameRaidWith(target))
 flags |= UF::UpdateFieldFlag::PartyMember;
 
 return flags;
}
 
void Player::BuildValuesCreate(ByteBuffer* data, Player const* target) const
{
 UF::UpdateFieldFlag flags = GetUpdateFieldFlagsFor(target);
 std::size_t sizePos = data->wpos();
 *data << uint32(0);
 *data << uint8(flags);
 m_objectData->WriteCreate(*data, flags, this, target);
 m_unitData->WriteCreate(*data, flags, this, target);
 m_playerData->WriteCreate(*data, flags, this, target);
 if (target == this)
 m_activePlayerData->WriteCreate(*data, flags, this, target);
 
 data->put<uint32>(sizePos, data->wpos() - sizePos - 4);
}
 
void Player::BuildValuesUpdate(ByteBuffer* data, Player const* target) const
{
 UF::UpdateFieldFlag flags = GetUpdateFieldFlagsFor(target);
 std::size_t sizePos = data->wpos();
 *data << uint32(0);
 *data << uint32(m_values.GetChangedObjectTypeMask() & ~(uint32(target != this) << TYPEID_ACTIVE_PLAYER));
 
 if (m_values.HasChanged(TYPEID_OBJECT))
 m_objectData->WriteUpdate(*data, flags, this, target);
 
 if (m_values.HasChanged(TYPEID_UNIT))
 m_unitData->WriteUpdate(*data, flags, this, target);
 
 if (m_values.HasChanged(TYPEID_PLAYER))
 m_playerData->WriteUpdate(*data, flags, this, target);
 
 if (target == this && m_values.HasChanged(TYPEID_ACTIVE_PLAYER))
 m_activePlayerData->WriteUpdate(*data, flags, this, target);
 
 data->put<uint32>(sizePos, data->wpos() - sizePos - 4);
}
 
void Player::BuildValuesUpdateWithFlag(ByteBuffer* data, UF::UpdateFieldFlag flags, Player const* target) const
{
 UpdateMask<NUM_CLIENT_OBJECT_TYPES> valuesMask;
 valuesMask.Set(TYPEID_UNIT);
 valuesMask.Set(TYPEID_PLAYER);
 
 std::size_t sizePos = data->wpos();
 *data << uint32(0);
 *data << uint32(valuesMask.GetBlock(0));
 
 UF::UnitData::Mask mask;
 m_unitData->AppendAllowedFieldsMaskForFlag(mask, flags);
 m_unitData->WriteUpdate(*data, mask, true, this, target);
 
 UF::PlayerData::Mask mask2;
 m_playerData->AppendAllowedFieldsMaskForFlag(mask2, flags);
 m_playerData->WriteUpdate(*data, mask2, true, this, target);
 
 data->put<uint32>(sizePos, data->wpos() - sizePos - 4);
}
 
void Player::BuildValuesUpdateForPlayerWithMask(UpdateData* data, UF::ObjectData::Mask const& requestedObjectMask,
 UF::UnitData::Mask const& requestedUnitMask, UF::PlayerData::Mask const& requestedPlayerMask,
 UF::ActivePlayerData::Mask const& requestedActivePlayerMask, Player const* target) const
{
 UF::UpdateFieldFlag flags = GetUpdateFieldFlagsFor(target);
 UpdateMask<NUM_CLIENT_OBJECT_TYPES> valuesMask;
 if (requestedObjectMask.IsAnySet())
 valuesMask.Set(TYPEID_OBJECT);
 
 UF::UnitData::Mask unitMask = requestedUnitMask;
 m_unitData->FilterDisallowedFieldsMaskForFlag(unitMask, flags);
 if (unitMask.IsAnySet())
 valuesMask.Set(TYPEID_UNIT);
 
 UF::PlayerData::Mask playerMask = requestedPlayerMask;
 m_playerData->FilterDisallowedFieldsMaskForFlag(playerMask, flags);
 if (playerMask.IsAnySet())
 valuesMask.Set(TYPEID_PLAYER);
 
 if (target == this && requestedActivePlayerMask.IsAnySet())
 valuesMask.Set(TYPEID_ACTIVE_PLAYER);
 
 ByteBuffer& buffer = PrepareValuesUpdateBuffer(data);
 std::size_t sizePos = buffer.wpos();
 buffer << uint32(0);
 buffer << uint32(valuesMask.GetBlock(0));
 
 if (valuesMask[TYPEID_OBJECT])
 m_objectData->WriteUpdate(buffer, requestedObjectMask, true, this, target);
 
 if (valuesMask[TYPEID_UNIT])
 m_unitData->WriteUpdate(buffer, unitMask, true, this, target);
 
 if (valuesMask[TYPEID_PLAYER])
 m_playerData->WriteUpdate(buffer, playerMask, true, this, target);
 
 if (valuesMask[TYPEID_ACTIVE_PLAYER])
 m_activePlayerData->WriteUpdate(buffer, requestedActivePlayerMask, true, this, target);
 
 buffer.put<uint32>(sizePos, buffer.wpos() - sizePos - 4);
 
 data->AddUpdateBlock();
}
 
void Player::ValuesUpdateForPlayerWithMaskSender::operator()(Player const* player) const
{
 UpdateData udata(Owner->GetMapId());
 WorldPacket packet;
 
 Owner->BuildValuesUpdateForPlayerWithMask(&udata, ObjectMask.GetChangesMask(), UnitMask.GetChangesMask(),
 PlayerMask.GetChangesMask(), ActivePlayerMask.GetChangesMask(), player);
 
 udata.BuildPacket(&packet);
 player->SendDirectMessage(&packet);
}
 
void Player::DestroyForPlayer(Player* target) const
{
 Unit::DestroyForPlayer(target);
 
 if (target == this)
 {
 for (uint8 i = EQUIPMENT_SLOT_START; i < BANK_SLOT_BAG_END; ++i)
 {
 if (m_items[i] == nullptr)
 continue;
 
 m_items[i]->DestroyForPlayer(target);
 }
 
 for (uint8 i = REAGENT_SLOT_START; i < CHILD_EQUIPMENT_SLOT_END; ++i)
 {
 if (m_items[i] == nullptr)
 continue;
 
 m_items[i]->DestroyForPlayer(target);
 }
 }
}
 
void Player::ClearUpdateMask(bool remove)
{
 m_values.ClearChangesMask(&Player::m_playerData);
 m_values.ClearChangesMask(&Player::m_activePlayerData);
 Unit::ClearUpdateMask(remove);
}
 
bool Player::HasSpell(uint32 spell) const
{
 PlayerSpellMap::const_iterator itr = m_spells.find(spell);
 return (itr != m_spells.end() && itr->second.state != PLAYERSPELL_REMOVED &&
 !itr->second.disabled);
}
 
bool Player::HasTalent(uint32 talentId, uint8 group) const
{
 PlayerTalentMap::const_iterator itr = GetTalentMap(group)->find(talentId);
 return (itr != GetTalentMap(group)->end() && itr->second != PLAYERSPELL_REMOVED);
}
 
bool Player::HasActiveSpell(uint32 spell) const
{
 PlayerSpellMap::const_iterator itr = m_spells.find(spell);
 return (itr != m_spells.end() && itr->second.state != PLAYERSPELL_REMOVED &&
 itr->second.active && !itr->second.disabled);
}
 
void Player::DeleteFromDB(ObjectGuid playerguid, uint32 accountId, bool updateRealmChars, bool deleteFinally)
{
 // Avoid realm-update for non-existing account
 if (accountId == 0)
 updateRealmChars = false;
 
 // Convert guid to low GUID for CharacterNameData, but also other methods on success
 ObjectGuid::LowType guid = playerguid.GetCounter();
 uint32 charDeleteMethod = sWorld->getIntConfig(CONFIG_CHARDELETE_METHOD);
 CharacterCacheEntry const* characterInfo = sCharacterCache->GetCharacterCacheByGuid(playerguid);
 std::string name;
 if (characterInfo)
 name = characterInfo->Name;
 
 if (deleteFinally)
 charDeleteMethod = CHAR_DELETE_REMOVE;
 else if (characterInfo) // To avoid a query, we select loaded data. If it doesn't exist, return.
 {
 // Define the required variables
 uint32 charDeleteMinLvl;
 
 if (characterInfo->Class == CLASS_DEATH_KNIGHT)
 charDeleteMinLvl = sWorld->getIntConfig(CONFIG_CHARDELETE_DEATH_KNIGHT_MIN_LEVEL);
 else if (characterInfo->Class == CLASS_DEMON_HUNTER)
 charDeleteMinLvl = sWorld->getIntConfig(CONFIG_CHARDELETE_DEMON_HUNTER_MIN_LEVEL);
 else
 charDeleteMinLvl = sWorld->getIntConfig(CONFIG_CHARDELETE_MIN_LEVEL);
 
 // if we want to finalize the character removal or the character does not meet the level requirement of either heroic or non-heroic settings,
 // we set it to mode CHAR_DELETE_REMOVE
 if (characterInfo->Level < charDeleteMinLvl)
 charDeleteMethod = CHAR_DELETE_REMOVE;
 }
 
 LoginDatabaseTransaction loginTransaction = LoginDatabase.BeginTransaction();
 LoginDatabasePreparedStatement* loginStmt = nullptr;
 
 CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 if (ObjectGuid::LowType guildId = sCharacterCache->GetCharacterGuildIdByGuid(playerguid))
 if (Guild* guild = sGuildMgr->GetGuildById(guildId))
 guild->DeleteMember(trans, playerguid, false, false);
 
 // remove from arena teams
 LeaveAllArenaTeams(playerguid);
 
 // the player was uninvited already on logout so just remove from group
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GROUP_MEMBER);
 stmt->setUInt64(0, guid);
 PreparedQueryResult resultGroup = CharacterDatabase.Query(stmt);
 
 if (resultGroup)
 if (Group* group = sGroupMgr->GetGroupByDbStoreId((*resultGroup)[0].GetUInt32()))
 RemoveFromGroup(group, playerguid);
 
 // Remove signs from petitions (also remove petitions if owner);
 RemovePetitionsAndSigns(playerguid);
 
 switch (charDeleteMethod)
 {
 // Completely remove from the database
 case CHAR_DELETE_REMOVE:
 {
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_COD_ITEM_MAIL);
 stmt->setUInt64(0, guid);
 PreparedQueryResult resultMail = CharacterDatabase.Query(stmt);
 
 if (resultMail)
 {
 std::unordered_map<uint64, std::vector<Item*>> itemsByMail;
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAILITEMS);
 stmt->setUInt64(0, guid);
 PreparedQueryResult resultItems = CharacterDatabase.Query(stmt);
 
 if (resultItems)
 {
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAILITEMS_ARTIFACT);
 stmt->setUInt64(0, guid);
 PreparedQueryResult artifactResult = CharacterDatabase.Query(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAILITEMS_AZERITE);
 stmt->setUInt64(0, guid);
 PreparedQueryResult azeriteResult = CharacterDatabase.Query(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAILITEMS_AZERITE_MILESTONE_POWER);
 stmt->setUInt64(0, guid);
 PreparedQueryResult azeriteItemMilestonePowersResult = CharacterDatabase.Query(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAILITEMS_AZERITE_UNLOCKED_ESSENCE);
 stmt->setUInt64(0, guid);
 PreparedQueryResult azeriteItemUnlockedEssencesResult = CharacterDatabase.Query(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAILITEMS_AZERITE_EMPOWERED);
 stmt->setUInt64(0, guid);
 PreparedQueryResult azeriteEmpoweredItemResult = CharacterDatabase.Query(stmt);
 
 std::unordered_map<ObjectGuid::LowType, ItemAdditionalLoadInfo> additionalData;
 ItemAdditionalLoadInfo::Init(&additionalData, artifactResult, azeriteResult, azeriteItemMilestonePowersResult,
 azeriteItemUnlockedEssencesResult, azeriteEmpoweredItemResult);
 
 do
 {
 Field* fields = resultItems->Fetch();
 uint64 mailId = fields[53].GetUInt64();
 if (Item* mailItem = _LoadMailedItem(playerguid, nullptr, mailId, nullptr, fields, Trinity::Containers::MapGetValuePtr(additionalData, fields[0].GetUInt64())))
 itemsByMail[mailId].push_back(mailItem);
 
 } while (resultItems->NextRow());
 }
 
 do
 {
 Field* mailFields = resultMail->Fetch();
 
 uint64 mail_id = mailFields[0].GetUInt64();
 uint8 mailType = mailFields[1].GetUInt8();
 uint16 mailTemplateId= mailFields[2].GetUInt16();
 ObjectGuid::LowType sender = mailFields[3].GetUInt64();
 std::string subject = mailFields[4].GetString();
 std::string body = mailFields[5].GetString();
 uint64 money = mailFields[6].GetUInt64();
 bool has_items = mailFields[7].GetBool();
 
 // We can return mail now
 // So firstly delete the old one
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_MAIL_BY_ID);
 stmt->setUInt64(0, mail_id);
 trans->Append(stmt);
 
 // Mail is not from player
 if (mailType != MAIL_NORMAL)
 {
 if (has_items)
 {
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_MAIL_ITEM_BY_ID);
 stmt->setUInt64(0, mail_id);
 trans->Append(stmt);
 }
 continue;
 }
 
 MailDraft draft(subject, body);
 if (mailTemplateId)
 draft = MailDraft(mailTemplateId, false); // items are already included
 
 auto itemsItr = itemsByMail.find(mail_id);
 if (itemsItr != itemsByMail.end())
 {
 for (Item* item : itemsItr->second)
 draft.AddItem(item);
 
 // MailDraft will take care of freeing memory
 itemsByMail.erase(itemsItr);
 }
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_MAIL_ITEM_BY_ID);
 stmt->setUInt64(0, mail_id);
 trans->Append(stmt);
 
 uint32 pl_account = sCharacterCache->GetCharacterAccountIdByGuid(playerguid);
 
 draft.AddMoney(money).SendReturnToSender(pl_account, guid, sender, trans);
 }
 while (resultMail->NextRow());
 
 // Free remaining items
 for (auto&& kvp : itemsByMail)
 for (Item* item : kvp.second)
 delete item;
 }
 
 // Unsummon and delete for pets in world is not required: player deleted from CLI or character list with not loaded pet.
 // NOW we can finally clear other DB data related to character
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_PET_IDS);
 stmt->setUInt64(0, guid);
 PreparedQueryResult resultPets = CharacterDatabase.Query(stmt);
 
 if (resultPets)
 {
 do
 {
 uint32 petguidlow = (*resultPets)[0].GetUInt32();
 Pet::DeleteFromDB(petguidlow);
 } while (resultPets->NextRow());
 }
 
 // Delete char from social list of online chars
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_SOCIAL);
 stmt->setUInt64(0, guid);
 
 if (PreparedQueryResult resultFriends = CharacterDatabase.Query(stmt))
 {
 do
 {
 if (Player* playerFriend = ObjectAccessor::FindPlayer(ObjectGuid::Create<HighGuid::Player>((*resultFriends)[0].GetUInt64())))
 {
 playerFriend->GetSocial()->RemoveFromSocialList(playerguid, SOCIAL_FLAG_ALL);
 sSocialMgr->SendFriendStatus(playerFriend, FRIEND_REMOVED, playerguid);
 }
 } while (resultFriends->NextRow());
 }
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_CUSTOMIZATIONS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PLAYER_ACCOUNT_DATA);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_DECLINED_NAME);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACTION);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_ARENA_STATS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_AURA_EFFECT);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_AURA);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PLAYER_BGDATA);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_BATTLEGROUND_RANDOM);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_CUF_PROFILES);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PLAYER_CURRENCY);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_GIFT);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_PLAYER_HOMEBIND);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_INSTANCE_LOCK_BY_GUID);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_INVENTORY);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_QUESTSTATUS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_QUESTSTATUS_OBJECTIVES);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_QUESTSTATUS_REWARDED);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_REPUTATION);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SPELL);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SPELL_COOLDOWNS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SPELL_CHARGES);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_GEMS_BY_OWNER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_TRANSMOG_BY_OWNER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_ARTIFACT_BY_OWNER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_ARTIFACT_POWERS_BY_OWNER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_MODIFIERS_BY_OWNER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_AZERITE_BY_OWNER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_AZERITE_MILESTONE_POWER_BY_OWNER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_AZERITE_UNLOCKED_ESSENCE_BY_OWNER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_AZERITE_EMPOWERED_BY_OWNER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ITEM_INSTANCE_BY_OWNER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SOCIAL_BY_FRIEND);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SOCIAL_BY_GUID);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_MAIL);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_MAIL_ITEMS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_PET_BY_OWNER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_PET_DECLINEDNAME_BY_OWNER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACHIEVEMENTS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_ACHIEVEMENT_PROGRESS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_EQUIPMENTSETS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_TRANSMOG_OUTFITS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_EVENTLOG_BY_PLAYER);
 stmt->setUInt64(0, guid);
 stmt->setUInt64(1, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GUILD_BANK_EVENTLOG_BY_PLAYER);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_GLYPHS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_QUESTSTATUS_DAILY);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_QUESTSTATUS_WEEKLY);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_QUESTSTATUS_MONTHLY);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_QUESTSTATUS_SEASONAL);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_TALENT);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_SKILLS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_STATS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_VOID_STORAGE_ITEM_BY_CHAR_GUID);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_FISHINGSTEPS);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_FAVORITE_AUCTIONS_BY_CHAR);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHARACTER_AURA_STORED_LOCATIONS_BY_GUID);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 loginStmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_BATTLE_PET_DECLINED_NAME_BY_OWNER);
 loginStmt->setInt64(0, guid);
 loginStmt->setInt32(1, sRealmList->GetCurrentRealmId().Realm);
 loginTransaction->Append(loginStmt);
 
 loginStmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_BATTLE_PETS_BY_OWNER);
 loginStmt->setInt64(0, guid);
 loginStmt->setInt32(1, sRealmList->GetCurrentRealmId().Realm);
 loginTransaction->Append(loginStmt);
 
 Corpse::DeleteFromDB(playerguid, trans);
 
 Garrison::DeleteFromDB(guid, trans);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_TRAIT_ENTRIES_BY_CHAR);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_CHAR_TRAIT_CONFIGS_BY_CHAR);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 
 sCharacterCache->DeleteCharacterCacheEntry(playerguid, name);
 break;
 }
 // The character gets unlinked from the account, the name gets freed up and appears as deleted ingame
 case CHAR_DELETE_UNLINK:
 {
 stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_DELETE_INFO);
 stmt->setUInt64(0, guid);
 trans->Append(stmt);
 sCharacterCache->UpdateCharacterInfoDeleted(playerguid, true, "");
 break;
 }
 default:
 TC_LOG_ERROR("entities.player.cheat", "Player::DeleteFromDB: Tried to delete player ({}) with unsupported delete method ({}).",
 playerguid.ToString(), charDeleteMethod);
 
 if (trans->GetSize() > 0)
 CharacterDatabase.CommitTransaction(trans);
 return;
 }
 
 LoginDatabase.CommitTransaction(loginTransaction);
 CharacterDatabase.CommitTransaction(trans);
 
 if (updateRealmChars)
 sWorld->UpdateRealmCharCount(accountId);
}
 
void Player::DeleteOldCharacters()
{
 uint32 keepDays = sWorld->getIntConfig(CONFIG_CHARDELETE_KEEP_DAYS);
 if (!keepDays)
 return;
 
 Player::DeleteOldCharacters(keepDays);
}
 
void Player::DeleteOldCharacters(uint32 keepDays)
{
 TC_LOG_INFO("entities.player", "Player::DeleteOldCharacters: Deleting all characters which have been deleted {} days before...", keepDays);
 
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHAR_OLD_CHARS);
 stmt->setUInt32(0, static_cast<uint32>(GameTime::GetGameTime() - static_cast<time_t>(keepDays) * DAY));
 PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
 if (result)
 {
 TC_LOG_DEBUG("entities.player", "Player::DeleteOldCharacters: Found {} character(s) to delete", result->GetRowCount());
 do
 {
 Field* fields = result->Fetch();
 Player::DeleteFromDB(ObjectGuid::Create<HighGuid::Player>(fields[0].GetUInt64()), fields[1].GetUInt32(), true, true);
 }
 while (result->NextRow());
 }
}
 
/* Preconditions:
 - a resurrectable corpse must not be loaded for the player (only bones)
 - the player must be in world
*/
void Player::BuildPlayerRepop()
{
 WorldPackets::Misc::PreRessurect packet;
 packet.PlayerGUID = GetGUID();
 SendDirectMessage(packet.Write());
 
 // If the player has the Wisp racial then cast the Wisp aura on them
 if (HasSpell(20585))
 CastSpell(this, 20584, true);
 CastSpell(this, 8326, true);
 
 RemoveAurasWithInterruptFlags(SpellAuraInterruptFlags::Release);
 
 // there must be SMSG.FORCE_RUN_SPEED_CHANGE, SMSG.FORCE_SWIM_SPEED_CHANGE, SMSG.MOVE_SET_WATER_WALK
 // there must be SMSG.STOP_MIRROR_TIMER
 
 // the player cannot have a corpse already on current map, only bones which are not returned by GetCorpse
 WorldLocation corpseLocation = GetCorpseLocation();
 if (corpseLocation.GetMapId() == GetMapId())
 {
 TC_LOG_ERROR("entities.player", "Player::BuildPlayerRepop: Player '{}' ({}) already has a corpse", GetName(), GetGUID().ToString());
 return;
 }
 
 // create a corpse and place it at the player's location
 Corpse* corpse = CreateCorpse();
 if (!corpse)
 {
 TC_LOG_ERROR("entities.player", "Player::BuildPlayerRepop: Error creating corpse for player '{}' ({})", GetName(), GetGUID().ToString());
 return;
 }
 GetMap()->AddToMap(corpse);
 
 // convert player body to ghost
 setDeathState(DEAD);
 SetHealth(1);
 
 SetWaterWalking(true);
 if (!GetSession()->isLogingOut() && !HasUnitState(UNIT_STATE_STUNNED))
 SetRooted(false);
 
 // BG - remove insignia related
 RemoveUnitFlag(UNIT_FLAG_SKINNABLE);
 
 int32 corpseReclaimDelay = CalculateCorpseReclaimDelay();
 
 if (corpseReclaimDelay >= 0)
 SendCorpseReclaimDelay(corpseReclaimDelay);
 
 // to prevent cheating
 corpse->ResetGhostTime();
 
 StopMirrorTimers(); //disable timers(bars)
 
 // OnPlayerRepop hook
 sScriptMgr->OnPlayerRepop(this);
}
 
void Player::ResurrectPlayer(float restore_percent, bool applySickness)
{
 SetAreaSpiritHealer(nullptr);
 
 WorldPackets::Misc::DeathReleaseLoc packet;
 packet.MapID = -1;
 SendDirectMessage(packet.Write());
 
 // speed change, land walk
 
 // remove death flag + set aura
 RemovePlayerFlag(PLAYER_FLAGS_IS_OUT_OF_BOUNDS);
 
 // This must be called always even on Players with race != RACE_NIGHTELF in case of faction change
 RemoveAurasDueToSpell(20584); // RACE_NIGHTELF speed bonuses
 RemoveAurasDueToSpell(8326); // SPELL_AURA_GHOST
 
 if (GetSession()->IsARecruiter() || (GetSession()->GetRecruiterId() != 0))
 SetDynamicFlag(UNIT_DYNFLAG_REFER_A_FRIEND);
 
 setDeathState(ALIVE);
 
 // add the flag to make sure opcode is always sent
 AddUnitMovementFlag(MOVEMENTFLAG_WATERWALKING);
 SetWaterWalking(false);
 if (!HasUnitState(UNIT_STATE_STUNNED))
 SetRooted(false);
 
 m_deathTimer = 0;
 
 // set health/powers (0- will be set in caller)
 if (restore_percent > 0.0f)
 {
 SetHealth(GetMaxHealth() * restore_percent);
 SetPower(POWER_MANA, GetMaxPower(POWER_MANA) * restore_percent);
 SetPower(POWER_RAGE, 0);
 SetPower(POWER_ENERGY, GetMaxPower(POWER_ENERGY) * restore_percent);
 SetPower(POWER_FOCUS, GetMaxPower(POWER_FOCUS) * restore_percent);
 SetPower(POWER_LUNAR_POWER, 0);
 }
 
 // trigger update zone for alive state zone updates
 uint32 newzone, newarea;
 GetZoneAndAreaId(newzone, newarea);
 UpdateZone(newzone, newarea);
 sOutdoorPvPMgr->HandlePlayerResurrects(this, newzone);
 
 // update visibility
 UpdateObjectVisibility();
 
 // recast lost by death auras of any items held in the inventory
 CastAllObtainSpells();
 
 if (!applySickness)
 return;
 
 //Characters from level 1-10 are not affected by resurrection sickness.
 //Characters from level 11-19 will suffer from one minute of sickness
 //for each level they are above 10.
 //Characters level 20 and up suffer from ten minutes of sickness.
 int32 startLevel = sWorld->getIntConfig(CONFIG_DEATH_SICKNESS_LEVEL);
 ChrRacesEntry const* raceEntry = sChrRacesStore.AssertEntry(GetRace());
 
 if (int32(GetLevel()) >= startLevel)
 {
 // set resurrection sickness
 CastSpell(this, raceEntry->ResSicknessSpellID, true);
 
 // not full duration
 if (int32(GetLevel()) < startLevel+9)
 {
 int32 delta = (int32(GetLevel()) - startLevel + 1)*MINUTE;
 
 if (Aura* aur = GetAura(raceEntry->ResSicknessSpellID, GetGUID()))
 {
 aur->SetDuration(delta*IN_MILLISECONDS);
 }
 }
 }
}
 
void Player::KillPlayer()
{
 if (IsFlying() && !GetTransport())
 GetMotionMaster()->MoveFall();
 
 SetRooted(true);
 
 StopMirrorTimers(); //disable timers(bars)
 
 setDeathState(CORPSE);
 //SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_IN_PVP);
 
 ReplaceAllDynamicFlags(UNIT_DYNFLAG_NONE);
 if (!sMapStore.LookupEntry(GetMapId())->Instanceable() && !HasAuraType(SPELL_AURA_PREVENT_RESURRECTION))
 SetPlayerLocalFlag(PLAYER_LOCAL_FLAG_RELEASE_TIMER);
 else
 RemovePlayerLocalFlag(PLAYER_LOCAL_FLAG_RELEASE_TIMER);
 
 // 6 minutes until repop at graveyard
 m_deathTimer = 6 * MINUTE * IN_MILLISECONDS;
 
 UpdateCorpseReclaimDelay(); // dependent at use SetDeathPvP() call before kill
 
 int32 corpseReclaimDelay = CalculateCorpseReclaimDelay();
 
 if (corpseReclaimDelay >= 0)
 SendCorpseReclaimDelay(corpseReclaimDelay);
 
 // don't create corpse at this moment, player might be falling
 
 // update visibility
 UpdateObjectVisibility();
}
 
void Player::OfflineResurrect(ObjectGuid const& guid, CharacterDatabaseTransaction trans)
{
 Corpse::DeleteFromDB(guid, trans);
 CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ADD_AT_LOGIN_FLAG);
 stmt->setUInt16(0, uint16(AT_LOGIN_RESURRECT));
 stmt->setUInt64(1, guid.GetCounter());
 CharacterDatabase.ExecuteOrAppend(trans, stmt);
}
 
Corpse* Player::CreateCorpse()
{
 // prevent the existence of 2 corpses for one player
 SpawnCorpseBones();
 
 Corpse* corpse = new Corpse((m_ExtraFlags & PLAYER_EXTRA_PVP_DEATH) ? CORPSE_RESURRECTABLE_PVP : CORPSE_RESURRECTABLE_PVE);
 SetPvPDeath(false);
 
 if (!corpse->Create(GetMap()->GenerateLowGuid<HighGuid::Corpse>(), this))
 {
 delete corpse;
 return nullptr;
 }
 
 _corpseLocation.WorldRelocate(*this);
 
 uint32 flags = 0;
 if (*m_unitData->PvpFlags & UNIT_BYTE2_FLAG_PVP)
 flags |= CORPSE_FLAG_PVP;
 if (InBattleground() && !InArena())
 flags |= CORPSE_FLAG_SKINNABLE; // to be able to remove insignia
 if (*m_unitData->PvpFlags & UNIT_BYTE2_FLAG_FFA_PVP)
 flags |= CORPSE_FLAG_FFA_PVP;
 
 corpse->SetRace(GetRace());
 corpse->SetSex(GetNativeGender());
 corpse->SetClass(GetClass());
 corpse->SetCustomizations(Trinity::Containers::MakeIteratorPair(m_playerData->Customizations.begin(), m_playerData->Customizations.end()));
 corpse->ReplaceAllFlags(flags);
 corpse->SetDisplayId(GetNativeDisplayId());
 corpse->SetFactionTemplate(sChrRacesStore.AssertEntry(GetRace())->FactionID);
 
 for (uint8 i = EQUIPMENT_SLOT_START; i < EQUIPMENT_SLOT_END; i++)
 {
 if (m_items[i])
 {
 uint32 itemDisplayId = m_items[i]->GetDisplayId(this);
 uint32 itemInventoryType;
 if (ItemEntry const* itemEntry = sItemStore.LookupEntry(m_items[i]->GetVisibleEntry(this)))
 itemInventoryType = itemEntry->InventoryType;
 else
 itemInventoryType = m_items[i]->GetTemplate()->GetInventoryType();
 
 corpse->SetItem(i, itemDisplayId | (itemInventoryType << 24));
 }
 }
 
 // register for player, but not show
 GetMap()->AddCorpse(corpse);
 
 corpse->UpdatePositionData();
 corpse->SetZoneScript();
 
 // we do not need to save corpses for instances
 if (!GetMap()->Instanceable())
 corpse->SaveToDB();
 
 return corpse;
}
 
void Player::SpawnCorpseBones(bool triggerSave /*= true*/)
{
 _corpseLocation.WorldRelocate();
 if (GetMap()->ConvertCorpseToBones(GetGUID()))
 if (triggerSave && !GetSession()->PlayerLogoutWithSave()) // at logout we will already store the player
 SaveToDB(); // prevent loading as ghost without corpse
}
 
Corpse* Player::GetCorpse() const
{
 return GetMap()->GetCorpseByPlayer(GetGUID());
}
 
void Player::DurabilityLossAll(double percent, bool inventory)
{
 for (uint8 i = EQUIPMENT_SLOT_START; i < EQUIPMENT_SLOT_END; i++)
 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
 DurabilityLoss(pItem, percent);
 
 if (inventory)
 {
 // bags not have durability
 // for (int i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
 
 uint8 inventoryEnd = INVENTORY_SLOT_ITEM_START + GetInventorySlotCount();
 for (uint8 i = INVENTORY_SLOT_ITEM_START; i < inventoryEnd; i++)
 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
 DurabilityLoss(pItem, percent);
 
 for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
 if (Bag* pBag = GetBagByPos(i))
 for (uint32 j = 0; j < pBag->GetBagSize(); j++)
 if (Item* pItem = GetItemByPos(i, j))
 DurabilityLoss(pItem, percent);
 }
}
 
void Player::DurabilityLoss(Item* item, double percent)
{
 if (!item)
 return;
 
 uint32 pMaxDurability = item->m_itemData->MaxDurability;
 
 if (!pMaxDurability)
 return;
 
 percent /= GetTotalAuraMultiplier(SPELL_AURA_MOD_DURABILITY_LOSS);
 
 uint32 pDurabilityLoss = uint32(pMaxDurability*percent);
 
 if (pDurabilityLoss < 1)
 pDurabilityLoss = 1;
 
 DurabilityPointsLoss(item, pDurabilityLoss);
}
 
void Player::DurabilityPointsLossAll(int32 points, bool inventory)
{
 for (uint8 i = EQUIPMENT_SLOT_START; i < EQUIPMENT_SLOT_END; i++)
 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
 DurabilityPointsLoss(pItem, points);
 
 if (inventory)
 {
 // bags not have durability
 // for (int i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
 
 uint8 inventoryEnd = INVENTORY_SLOT_ITEM_START + GetInventorySlotCount();
 for (uint8 i = INVENTORY_SLOT_ITEM_START; i < inventoryEnd; i++)
 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, i))
 DurabilityPointsLoss(pItem, points);
 
 for (uint8 i = INVENTORY_SLOT_BAG_START; i < INVENTORY_SLOT_BAG_END; i++)
 if (Bag* pBag = static_cast<Bag*>(GetItemByPos(INVENTORY_SLOT_BAG_0, i)))
 for (uint32 j = 0; j < pBag->GetBagSize(); j++)
 if (Item* pItem = GetItemByPos(i, j))
 DurabilityPointsLoss(pItem, points);
 }
}
 
void Player::DurabilityPointsLoss(Item* item, int32 points)
{
 if (HasAuraType(SPELL_AURA_PREVENT_DURABILITY_LOSS))
 return;
 
 int32 pMaxDurability = item->m_itemData->MaxDurability;
 int32 pOldDurability = item->m_itemData->Durability;
 int32 pNewDurability = pOldDurability - points;
 
 if (pNewDurability < 0)
 pNewDurability = 0;
 else if (pNewDurability > pMaxDurability)
 pNewDurability = pMaxDurability;
 
 if (pOldDurability != pNewDurability)
 {
 // modify item stats _before_ Durability set to 0 to pass _ApplyItemMods internal check
 if (pNewDurability == 0 && pOldDurability > 0 && item->IsEquipped())
 _ApplyItemMods(item, item->GetSlot(), false);
 
 item->SetDurability(pNewDurability);
 
 // modify item stats _after_ restore durability to pass _ApplyItemMods internal check
 if (pNewDurability > 0 && pOldDurability == 0 && item->IsEquipped())
 _ApplyItemMods(item, item->GetSlot(), true);
 
 item->SetState(ITEM_CHANGED, this);
 }
}
 
void Player::DurabilityPointLossForEquipSlot(EquipmentSlots slot)
{
 if (HasAuraType(SPELL_AURA_PREVENT_DURABILITY_LOSS_FROM_COMBAT))
 return;
 
 if (Item* pItem = GetItemByPos(INVENTORY_SLOT_BAG_0, slot))
 DurabilityPointsLoss(pItem, 1);
}
 
void Player::DurabilityRepairAll(bool takeCost, float discountMod, bool guildBank)
{
 // Collecting all items that can be repaired and repair costs
 std::list<std::pair<Item*, uint64>> itemRepairCostStore;
 
 // equipped, backpack, bags itself
 uint8 inventoryEnd = INVENTORY_SLOT_ITEM_START + GetInventorySlotCount();
 for (uint8 i = EQUIPMENT_SLOT_START; i < inventoryEnd; i++)
 if (Item* item = GetItemByPos(((INVENTORY_SLOT_BAG_0 << 8) | i)))
 if (uint64 cost = item->CalculateDurabilityRepairCost(discountMod))
 itemRepairCostStore.push_back(std::make_pair(item, cost));
 
 // bank, buyback and keys not repaired
 
 // items in inventory bags
 for (uint8 j = INVENTORY_SLOT_BAG_START; j < INVENTORY_SLOT_BAG_END; j++)
 for (uint8 i = 0; i < MAX_BAG_SIZE; i++)
 if (Item* item = GetItemByPos(((j << 8) | i)))
 if (uint64 cost = item->CalculateDurabilityRepairCost(discountMod))
 itemRepairCostStore.push_back(std::make_pair(item, cost));
 
 // Handling a free repair case - just repair every item without taking cost.
 if (!takeCost)
 {
 for (auto const& [item, cost] : itemRepairCostStore)
 DurabilityRepair(item->GetPos(), false, 0.f);
 
 return;