#include "KillRewarder.h"

Public Member Functions
	KillRewarder (Player killer, Unit victim, bool isBattleGround)

void	Reward ()

Unit *	GetVictim ()

Player *	GetKiller ()

Private Member Functions
void	_InitXP (Player *player)

void	_InitGroupData ()

void	_RewardHonor (Player *player)

void	_RewardXP (Player *player, float rate)

void	_RewardReputation (Player *player)

void	_RewardKillCredit (Player *player)

void	_RewardPlayer (Player *player, bool isDungeon)

void	_RewardGroup ()

Private Attributes
Player *	_killer

Unit *	_victim

Group *	_group

float	_groupRate

Player *	_maxNotGrayMember

uint32	_count

uint32	_aliveSumLevel

uint32	_sumLevel

uint32	_xp

bool	_isFullXP

uint8	_maxLevel

bool	_isBattleGround

bool	_isPvP

Detailed Description

Constructor & Destructor Documentation

◆ KillRewarder()

KillRewarder::KillRewarder	(	Player *	killer,
		Unit *	victim,
		bool	isBattleGround
	)

                                                                            :
// 1. Initialize internal variables to default values.
        _killer(killer), _victim(victim), _group(killer->GetGroup()),
        _groupRate(1.0f), _maxNotGrayMember(nullptr), _count(0), _aliveSumLevel(0), _sumLevel(0), _xp(0),
        _isFullXP(false), _maxLevel(0), _isBattleGround(isBattleGround), _isPvP(false)
{
    // mark the credit as pvp if victim is player
    if (victim->IsPlayer())
        _isPvP = true;
        // or if its owned by player and its not a vehicle
    else if (victim->GetCharmerOrOwnerGUID().IsPlayer())
        _isPvP = !victim->IsVehicle();
 
    _InitGroupData();
}

References _InitGroupData(), _isPvP, Unit::GetCharmerOrOwnerGUID(), Object::IsPlayer(), ObjectGuid::IsPlayer(), and Unit::IsVehicle().

Member Function Documentation

◆ _InitGroupData()

void KillRewarder::_InitGroupData ( )

private

{
    if (_group)
    {
        // 2. In case when player is in group, initialize variables necessary for group calculations:
        for (GroupReference* itr = _group->GetFirstMember(); itr != nullptr; itr = itr->next())
            if (Player* member = itr->GetSource())
                if ((_killer == member || member->IsAtGroupRewardDistance(_victim)))
                {
                    const uint8 lvl = member->GetLevel();
                    if (member->IsAlive())
                    {
                        // 2.1. _count - number of alive group members within reward distance;
                        ++_count;
                        // 2.2. _aliveSumLevel - sum of levels of alive group members within reward distance;
                        _aliveSumLevel += lvl;
                        // 2.3. _maxLevel - maximum level of alive group member within reward distance;
                        if (_maxLevel < lvl)
                        {
                            _maxLevel = lvl;
                        }
                        // 2.4. _maxNotGrayMember - maximum level of alive group member within reward distance,
                        //      for whom victim is not gray;
                        uint32 grayLevel = Acore::XP::GetGrayLevel(lvl);
                        if (_victim->GetLevel() > grayLevel && (!_maxNotGrayMember || _maxNotGrayMember->GetLevel() < lvl))
                        {
                            _maxNotGrayMember = member;
                        }
                    }
                    // 2.5. _sumLevel - sum of levels of group members within reward distance;
                    _sumLevel += lvl;
                }
        // 2.6. _isFullXP - flag identifying that for all group members victim is not gray,
        //      so 100% XP will be rewarded (50% otherwise).
        _isFullXP = _maxNotGrayMember && (_maxLevel == _maxNotGrayMember->GetLevel());
    }
    else
        _count = 1;
}

References _aliveSumLevel, _count, _group, _isFullXP, _killer, _maxLevel, _maxNotGrayMember, _sumLevel, _victim, Group::GetFirstMember(), Acore::XP::GetGrayLevel(), Unit::GetLevel(), and Player::IsAtGroupRewardDistance().

Referenced by KillRewarder().

◆ _InitXP()

void KillRewarder::_InitXP ( Player * player )

private

{
    // Get initial value of XP for kill.
    // XP is given:
    // * on battlegrounds;
    // * otherwise, not in PvP;
    // * not if killer is on vehicle.
    if (_victim && (_isBattleGround || (!_isPvP && !_killer->GetVehicle())))
        _xp = Acore::XP::Gain(player, _victim, _isBattleGround);
 
    if (_xp && !_isBattleGround && _victim) // pussywizard: npcs with relatively low hp give lower exp
        if (_victim->IsCreature())
            if (const CreatureTemplate* ct = _victim->ToCreature()->GetCreatureTemplate())
                if (ct->ModHealth <= 0.75f && ct->ModHealth >= 0.0f)
                    _xp = uint32(_xp * ct->ModHealth);
}

References _isBattleGround, _isPvP, _killer, _victim, _xp, Acore::XP::Gain(), Creature::GetCreatureTemplate(), Unit::GetVehicle(), Object::IsCreature(), and Object::ToCreature().

Referenced by _RewardGroup(), and Reward().

◆ _RewardGroup()

void KillRewarder::_RewardGroup ( )

private

{
    if (_maxLevel)
    {
        if (_maxNotGrayMember)
            // 3.1.1. Initialize initial XP amount based on maximum level of group member,
            //        for whom victim is not gray.
            _InitXP(_maxNotGrayMember);
        // To avoid unnecessary calculations and calls,
        // proceed only if XP is not ZERO or player is not on battleground
        // (battleground rewards only XP, that's why).
        if (!_isBattleGround || _xp)
        {
            const bool isDungeon = !_isPvP && sMapStore.LookupEntry(_killer->GetMapId())->IsDungeon();
            if (!_isBattleGround)
            {
                // 3.1.2. Alter group rate if group is in raid (not for battlegrounds).
                const bool isRaid = !_isPvP && sMapStore.LookupEntry(_killer->GetMapId())->IsRaid() && _group->isRaidGroup();
                _groupRate = Acore::XP::xp_in_group_rate(_count, isRaid);
            }
 
            // 3.1.3. Reward each group member (even dead or corpse) within reward distance.
            for (GroupReference* itr = _group->GetFirstMember(); itr != nullptr; itr = itr->next())
            {
                if (Player* member = itr->GetSource())
                {
                    if (_killer == member || member->IsAtGroupRewardDistance(_victim))
                    {
                        _RewardPlayer(member, isDungeon);
                        // Xinef: only count players
                        //if (_victim->IsPlayer())
                        //    member->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_SPECIAL_PVP_KILL, 1, 0, _victim);
                    }
                }
            }
        }
    }
}

References _count, _group, _groupRate, _InitXP(), _isBattleGround, _isPvP, _killer, _maxLevel, _maxNotGrayMember, _RewardPlayer(), _victim, _xp, Group::GetFirstMember(), WorldLocation::GetMapId(), Player::IsAtGroupRewardDistance(), Group::isRaidGroup(), sMapStore, and Acore::XP::xp_in_group_rate().

Referenced by Reward().

◆ _RewardHonor()

void KillRewarder::_RewardHonor ( Player * player )

private

{
    // Rewarded player must be alive.
    if (player->IsAlive())
        player->RewardHonor(_victim, _count, -1);
}

References _count, _victim, Unit::IsAlive(), and Player::RewardHonor().

Referenced by _RewardPlayer().

◆ _RewardKillCredit()

void KillRewarder::_RewardKillCredit ( Player * player )

private

{
    // 4.4. Give kill credit (player must not be in group, or he must be alive or without corpse).
    if (!_group || player->IsAlive() || !player->GetCorpse())
        if (Creature* target = _victim->ToCreature())
        {
            player->KilledMonster(target->GetCreatureTemplate(), target->GetGUID());
            player->UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE, target->GetCreatureType(), 1, target);
        }
}

References _group, _victim, ACHIEVEMENT_CRITERIA_TYPE_KILL_CREATURE_TYPE, Player::GetCorpse(), Unit::IsAlive(), Player::KilledMonster(), Object::ToCreature(), and Player::UpdateAchievementCriteria().

Referenced by _RewardPlayer().

◆ _RewardPlayer()

void KillRewarder::_RewardPlayer	(	Player *	player,
		bool	isDungeon
	)

private

{
    // 4. Reward player.
    if (!_isBattleGround)
    {
        // 4.1. Give honor (player must be alive and not on BG).
        _RewardHonor(player);
        // 4.1.1 Send player killcredit for quests with PlayerSlain
        if (_victim->IsPlayer())
            player->KilledPlayerCredit();
    }
 
    // Give XP only in PvE or in battlegrounds.
    // Give reputation and kill credit only in PvE.
    if (!_isPvP || _isBattleGround)
    {
        float xpRate = _group ? _groupRate * float(player->GetLevel()) / _aliveSumLevel : /*Personal rate is 100%.*/ 1.0f; // Group rate depends on the sum of levels.
        sScriptMgr->OnPlayerRewardKillRewarder(player, this, isDungeon, xpRate);                                              // Personal rate is 100%.
 
        if (_xp)
        {
            // 4.2. Give XP.
            _RewardXP(player, xpRate);
        }
        if (!_isBattleGround)
        {
            // If killer is in dungeon then all members receive full reputation at kill.
            _RewardReputation(player);
            _RewardKillCredit(player);
        }
    }
}

References _aliveSumLevel, _group, _groupRate, _isBattleGround, _isPvP, _RewardHonor(), _RewardKillCredit(), _RewardReputation(), _RewardXP(), _victim, _xp, Unit::GetLevel(), Object::IsPlayer(), Player::KilledPlayerCredit(), and sScriptMgr.

Referenced by _RewardGroup(), and Reward().

◆ _RewardReputation()

void KillRewarder::_RewardReputation ( Player * player )

private

{
    // 4.3. Give reputation (player must not be on BG).
    // Even dead players and corpses are rewarded.
    player->RewardReputation(_victim);
}

References _victim, and Player::RewardReputation().

Referenced by _RewardPlayer().

◆ _RewardXP()

void KillRewarder::_RewardXP	(	Player *	player,
		float	rate
	)

private

{
    uint32 xp(_xp);
    if (_group)
    {
        // 4.2.1. If player is in group, adjust XP:
        //        * set to 0 if player's level is more than maximum level of not gray member;
        //        * cut XP in half if _isFullXP is false.
        if (_maxNotGrayMember && player->IsAlive() &&
            _maxNotGrayMember->GetLevel() >= player->GetLevel())
            xp = _isFullXP ?
                 uint32(xp * rate) :             // Reward FULL XP if all group members are not gray.
                 uint32(xp * rate / 2) + 1;      // Reward only HALF of XP if some of group members are gray.
        else
            xp = 0;
    }
    if (xp)
    {
        // 4.2.2. Apply auras modifying rewarded XP (SPELL_AURA_MOD_XP_PCT).
        Unit::AuraEffectList const& auras = player->GetAuraEffectsByType(SPELL_AURA_MOD_XP_PCT);
        for (Unit::AuraEffectList::const_iterator i = auras.begin(); i != auras.end(); ++i)
            AddPct(xp, (*i)->GetAmount());
 
        // 4.2.3. Give XP to player.
        sScriptMgr->OnPlayerGiveXP(player, xp, _victim, PlayerXPSource::XPSOURCE_KILL);
        player->GiveXP(xp, _victim, _groupRate);
        if (Pet* pet = player->GetPet())
            // 4.2.4. If player has pet, reward pet with XP (100% for single player, 50% for group case).
            pet->GivePetXP(_group ? xp / 2 : xp);
    }
}

References _group, _groupRate, _isFullXP, _maxNotGrayMember, _victim, _xp, AddPct(), Unit::GetAuraEffectsByType(), Unit::GetLevel(), Player::GetPet(), Player::GiveXP(), Unit::IsAlive(), SPELL_AURA_MOD_XP_PCT, sScriptMgr, and XPSOURCE_KILL.

Referenced by _RewardPlayer().

◆ GetKiller()

Player * KillRewarder::GetKiller ( )

{
    return _killer;
}

References _killer.

◆ GetVictim()

Unit * KillRewarder::GetVictim ( )

{
    return _victim;
}

References _victim.

◆ Reward()

void KillRewarder::Reward ( )

{
    // 3. Reward killer (and group, if necessary).
    if (_group)
        // 3.1. If killer is in group, reward group.
        _RewardGroup();
    else
    {
        // 3.2. Reward single killer (not group case).
        // 3.2.1. Initialize initial XP amount based on killer's level.
        _InitXP(_killer);
        // To avoid unnecessary calculations and calls,
        // proceed only if XP is not ZERO or player is not on battleground
        // (battleground rewards only XP, that's why).
        if (!_isBattleGround || _xp)
            // 3.2.2. Reward killer.
            if (_killer->IsInMap(_victim)) // pussywizard: killer may be on other map (crashfix), when killing in a group same map is required, so its not a problem
                _RewardPlayer(_killer, false);
    }
 
    // 5. Credit instance encounter.
    if (Creature* victim = _victim->ToCreature())
        if (victim->IsDungeonBoss())
            if (Map* map = _victim->FindMap())
                map->UpdateEncounterState(ENCOUNTER_CREDIT_KILL_CREATURE, _victim->GetEntry(), _victim);
}