#include "SpellAuras.h"

Public Member Functions
Unit *	GetTarget () const

Aura *	GetBase () const

uint8	GetSlot () const

uint8	GetFlags () const

uint8	GetEffectMask () const

bool	HasEffect (uint8 effect) const

bool	IsPositive () const

bool	IsSelfcasted () const

uint8	GetEffectsToApply () const

void	SetRemoveMode (AuraRemoveMode mode)

AuraRemoveMode	GetRemoveMode () const

void	SetNeedClientUpdate ()

bool	IsNeedClientUpdate () const

void	BuildUpdatePacket (ByteBuffer &data, bool remove) const

void	ClientUpdate (bool remove=false)

bool	IsActive (uint8 effIdx)

void	SetDisableMask (uint8 effIdx)

void	RemoveDisableMask (uint8 effIdx)

Private Member Functions
	AuraApplication (Unit target, Unit caster, Aura *base, uint8 effMask)

void	_Remove ()

void	_InitFlags (Unit *caster, uint8 effMask)

void	_HandleEffect (uint8 effIndex, bool apply)

Private Attributes
Unit *const	_target

Aura *const	_base

AuraRemoveMode	_removeMode: 8

uint8	_slot

uint8	_flags

uint8	_effectsToApply

bool	_needClientUpdate: 1

uint8	_disableMask

Friends
void	Unit::_ApplyAura (AuraApplication *aurApp, uint8 effMask)

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

void	Unit::_ApplyAuraEffect (Aura *aura, uint8 effIndex)

void	Unit::RemoveAura (AuraApplication *aurApp, AuraRemoveMode mode)

AuraApplication *	Unit::_CreateAuraApplication (Aura *aura, uint8 effMask)

Detailed Description

Constructor & Destructor Documentation

◆ AuraApplication()

AuraApplication::AuraApplication	(	Unit *	target,
		Unit *	caster,
		Aura *	base,
		uint8	effMask
	)

explicitprivate

                                                                                     :
    _target(target), _base(aura), _removeMode(AURA_REMOVE_NONE), _slot(MAX_AURAS),
    _flags(AFLAG_NONE), _effectsToApply(effMask), _needClientUpdate(false), _disableMask(0)
{
    ASSERT(GetTarget() && GetBase());
 
    if (GetBase()->CanBeSentToClient())
    {
        // Try find slot for aura
        uint8 slot = MAX_AURAS;
        // Lookup for auras already applied from spell
        if (AuraApplication* foundAura = GetTarget()->GetAuraApplication(GetBase()->GetId(), GetBase()->GetCasterGUID(), GetBase()->GetCastItemGUID()))
        {
            // allow use single slot only by auras from same caster
            slot = foundAura->GetSlot();
        }
        else
        {
            Unit::VisibleAuraMap const* visibleAuras = GetTarget()->GetVisibleAuras();
            // lookup for free slots in units visibleAuras
            Unit::VisibleAuraMap::const_iterator itr = visibleAuras->find(0);
            for (uint32 freeSlot = 0; freeSlot < MAX_AURAS; ++itr, ++freeSlot)
            {
                if (itr == visibleAuras->end() || itr->first != freeSlot)
                {
                    slot = freeSlot;
                    break;
                }
            }
        }
 
        // Register Visible Aura
        if (slot < MAX_AURAS)
        {
            _slot = slot;
            GetTarget()->SetVisibleAura(slot, this);
            SetNeedClientUpdate();
            LOG_DEBUG("spells.aura", "Aura: {} Effect: {} put to unit visible auras slot: {}", GetBase()->GetId(), GetEffectMask(), slot);
        }
        else
        {
            LOG_ERROR("spells.aura", "Aura: {} Effect: {} could not find empty unit visible slot", GetBase()->GetId(), GetEffectMask());
        }
    }
    _InitFlags(caster, effMask);
}

References _InitFlags(), _slot, ASSERT, GetBase(), GetEffectMask(), GetTarget(), Unit::GetVisibleAuras(), LOG_DEBUG, LOG_ERROR, MAX_AURAS, SetNeedClientUpdate(), and Unit::SetVisibleAura().

Member Function Documentation

◆ _HandleEffect()

void AuraApplication::_HandleEffect	(	uint8	effIndex,
		bool	apply
	)

private

{
    AuraEffect* aurEff = GetBase()->GetEffect(effIndex);
    ASSERT(aurEff);
    ASSERT(HasEffect(effIndex) == (!apply));
    ASSERT((1 << effIndex) & _effectsToApply);
    LOG_DEBUG("spells.aura", "AuraApplication::_HandleEffect: {}, apply: {}: amount: {}", aurEff->GetAuraType(), apply, aurEff->GetAmount());
 
    if (apply)
    {
        ASSERT(!(_flags & (1 << effIndex)));
        _flags |= 1 << effIndex;
        aurEff->HandleEffect(this, AURA_EFFECT_HANDLE_REAL, true);
    }
    else
    {
        ASSERT(_flags & (1 << effIndex));
        _flags &= ~(1 << effIndex);
        aurEff->HandleEffect(this, AURA_EFFECT_HANDLE_REAL, false);
 
        // Remove all triggered by aura spells vs unlimited duration
        aurEff->CleanupTriggeredSpells(GetTarget());
    }
 
    // Stacking!
    if (uint32 groupId = aurEff->GetAuraGroup())
    {
        SpellGroupStackFlags sFlag = sSpellMgr->GetGroupStackFlags(groupId);
        if (!aurEff->IsPeriodic() && (sFlag & SPELL_GROUP_STACK_FLAG_EFFECT_EXCLUSIVE))
        {
            AuraApplication* strongestApp = apply ? this : nullptr;
            AuraEffect* strongestEff = apply ? aurEff : nullptr;
            int32 amount = apply ? std::abs(aurEff->GetAmount()) : 0;
            Unit* target = GetTarget();
            Unit::AuraEffectList const& auraList = target->GetAuraEffectsByType(aurEff->GetAuraType());
            for (Unit::AuraEffectList::const_iterator iter = auraList.begin(); iter != auraList.end(); ++iter)
            {
                if ((*iter)->GetAuraGroup() != groupId || (*iter) == strongestEff || (*iter)->GetBase()->IsRemoved())
                    continue;
 
                // xinef: skip different misc values
                if (aurEff->GetAuraType() != SPELL_AURA_230 /*SPELL_AURA_MOD_INCREASE_HEALTH_2*/ && aurEff->GetAuraType() != SPELL_AURA_MOD_CASTING_SPEED_NOT_STACK &&
                        aurEff->GetMiscValue() != (*iter)->GetMiscValue())
                    continue;
 
                // xinef: should not happen
                AuraApplication* aurApp = (*iter)->GetBase()->GetApplicationOfTarget(target->GetGUID());
                if (!aurApp)
                    continue;
 
                if (amount < std::abs((*iter)->GetForcedAmount()))
                {
                    // xinef: if we have strongest aura and it is active, turn it off
                    // xinef: otherwise just save new aura;
                    if (strongestApp && strongestEff && strongestApp->IsActive(strongestEff->GetEffIndex()))
                    {
                        strongestEff->HandleEffect(strongestApp, AURA_EFFECT_HANDLE_CHANGE_AMOUNT, false);
                        if (!strongestEff->GetSpellInfo()->HasAreaAuraEffect())
                            strongestEff->SetEnabled(false);
                        strongestApp->SetDisableMask(strongestEff->GetEffIndex());
                    }
                    strongestApp = aurApp;
                    strongestEff = (*iter);
                    amount = std::abs((*iter)->GetAmount());
                }
                // xinef: itered aura is weaker, deactivate if active
                else if (aurApp->IsActive((*iter)->GetEffIndex()))
                {
                    (*iter)->HandleEffect(aurApp, AURA_EFFECT_HANDLE_CHANGE_AMOUNT, false);
                    if (!(*iter)->GetSpellInfo()->HasAreaAuraEffect())
                        (*iter)->SetEnabled(false);
                    aurApp->SetDisableMask((*iter)->GetEffIndex());
                }
            }
 
            // xinef: if we have new strongest aura, and it is not active
            if (strongestApp && strongestEff && !strongestApp->IsActive(strongestEff->GetEffIndex()))
            {
                strongestApp->RemoveDisableMask(strongestEff->GetEffIndex());
                strongestEff->SetEnabled(true);
                strongestEff->HandleEffect(strongestApp, AURA_EFFECT_HANDLE_CHANGE_AMOUNT, true);
            }
        }
    }
    SetNeedClientUpdate();
}

References _effectsToApply, _flags, ASSERT, AURA_EFFECT_HANDLE_CHANGE_AMOUNT, AURA_EFFECT_HANDLE_REAL, AuraEffect::CleanupTriggeredSpells(), AuraEffect::GetAmount(), Aura::GetApplicationOfTarget(), Unit::GetAuraEffectsByType(), AuraEffect::GetAuraGroup(), AuraEffect::GetAuraType(), AuraEffect::GetBase(), GetBase(), Aura::GetEffect(), AuraEffect::GetEffIndex(), Object::GetGUID(), AuraEffect::GetMiscValue(), AuraEffect::GetSpellInfo(), GetTarget(), AuraEffect::HandleEffect(), SpellInfo::HasAreaAuraEffect(), HasEffect(), IsActive(), AuraEffect::IsPeriodic(), Aura::IsRemoved(), LOG_DEBUG, RemoveDisableMask(), SetDisableMask(), AuraEffect::SetEnabled(), SetNeedClientUpdate(), SPELL_AURA_230, SPELL_AURA_MOD_CASTING_SPEED_NOT_STACK, SPELL_GROUP_STACK_FLAG_EFFECT_EXCLUSIVE, and sSpellMgr.

Referenced by Unit::_ApplyAura(), Unit::_ApplyAuraEffect(), Unit::_UnapplyAura(), and Unit::RemoveAura().

◆ _InitFlags()

void AuraApplication::_InitFlags	(	Unit *	caster,
		uint8	effMask
	)

private

{
    // mark as selfcasted if needed
    _flags |= (GetBase()->GetCasterGUID() == GetTarget()->GetGUID()) ? AFLAG_CASTER : AFLAG_NONE;
 
    // aura is casted by self or an enemy
    // one negative effect and we know aura is negative
    if (IsSelfcasted() || !caster || !caster->IsFriendlyTo(GetTarget()))
    {
        bool negativeFound = false;
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (((1 << i) & effMask) && !GetBase()->GetSpellInfo()->IsPositiveEffect(i))
            {
                negativeFound = true;
                break;
            }
        }
        _flags |= negativeFound ? AFLAG_NEGATIVE : AFLAG_POSITIVE;
    }
    // aura is casted by friend
    // one positive effect and we know aura is positive
    else
    {
        bool positiveFound = false;
        for (uint8 i = 0; i < MAX_SPELL_EFFECTS; ++i)
        {
            if (((1 << i) & effMask) && GetBase()->GetSpellInfo()->IsPositiveEffect(i))
            {
                positiveFound = true;
                break;
            }
        }
        _flags |= positiveFound ? AFLAG_POSITIVE : AFLAG_NEGATIVE;
    }
}

References _flags, AFLAG_CASTER, AFLAG_NEGATIVE, AFLAG_NONE, AFLAG_POSITIVE, GetBase(), Aura::GetCasterGUID(), Object::GetGUID(), GetTarget(), Unit::IsFriendlyTo(), IsSelfcasted(), and MAX_SPELL_EFFECTS.

Referenced by AuraApplication().

◆ _Remove()

void AuraApplication::_Remove ( )

private

{
    uint8 slot = GetSlot();
 
    if (slot >= MAX_AURAS)
        return;
 
    if (AuraApplication* foundAura = _target->GetAuraApplication(GetBase()->GetId(), GetBase()->GetCasterGUID(), GetBase()->GetCastItemGUID()))
    {
        // Reuse visible aura slot by aura which is still applied - prevent storing dead pointers
        if (slot == foundAura->GetSlot())
        {
            if (GetTarget()->GetVisibleAura(slot) == this)
            {
                GetTarget()->SetVisibleAura(slot, foundAura);
                foundAura->SetNeedClientUpdate();
            }
            // set not valid slot for aura - prevent removing other visible aura
            slot = MAX_AURAS;
        }
    }
 
    // update for out of range group members
    if (slot < MAX_AURAS)
    {
        GetTarget()->RemoveVisibleAura(slot);
        ClientUpdate(true);
    }
}

References _target, ClientUpdate(), Unit::GetAuraApplication(), GetBase(), GetSlot(), GetTarget(), MAX_AURAS, Unit::RemoveVisibleAura(), and Unit::SetVisibleAura().

Referenced by Unit::_UnapplyAura().

◆ BuildUpdatePacket()

void AuraApplication::BuildUpdatePacket	(	ByteBuffer &	data,
		bool	remove
	)		const

{
    data << uint8(_slot);
 
    if (remove)
    {
        ASSERT(!_target->GetVisibleAura(_slot));
        data << uint32(0);
        return;
    }
    ASSERT(_target->GetVisibleAura(_slot));
 
    Aura const* aura = GetBase();
    data << uint32(aura->GetId());
    uint32 flags = _flags;
    if (aura->GetMaxDuration() > 0 && !aura->GetSpellInfo()->HasAttribute(SPELL_ATTR5_DO_NOT_DISPLAY_DURATION))
        flags |= AFLAG_DURATION;
    data << uint8(flags);
    data << uint8(aura->GetCasterLevel());
    // send stack amount for aura which could be stacked (never 0 - causes incorrect display) or charges
    // stack amount has priority over charges (checked on retail with spell 50262)
    data << uint8(aura->GetSpellInfo()->StackAmount ? aura->GetStackAmount() : aura->GetCharges());
 
    if (!(flags & AFLAG_CASTER))
        data << aura->GetCasterGUID().WriteAsPacked();
 
    if (flags & AFLAG_DURATION)
    {
        data << uint32(aura->GetMaxDuration());
        data << uint32(aura->GetDuration());
    }
}

References _flags, _slot, _target, AFLAG_CASTER, AFLAG_DURATION, ASSERT, GetBase(), Aura::GetCasterGUID(), Aura::GetCasterLevel(), Aura::GetCharges(), Aura::GetDuration(), Aura::GetId(), Aura::GetMaxDuration(), Aura::GetSpellInfo(), Aura::GetStackAmount(), Unit::GetVisibleAura(), SpellInfo::HasAttribute(), SPELL_ATTR5_DO_NOT_DISPLAY_DURATION, SpellInfo::StackAmount, and ObjectGuid::WriteAsPacked().

Referenced by ClientUpdate(), and Player::GetAurasForTarget().

◆ ClientUpdate()

void AuraApplication::ClientUpdate ( bool remove = false )

{
    _needClientUpdate = false;
 
    WorldPacket data(SMSG_AURA_UPDATE);
    data << GetTarget()->GetPackGUID();
    BuildUpdatePacket(data, remove);
 
    if (GetSlot() < MAX_AURAS)
        if (Player const* plr = GetTarget()->ToPlayer())
            if (Aura* aura = GetBase())
                if (plr->NeedSendSpectatorData() && ArenaSpectator::ShouldSendAura(aura, GetEffectMask(), GetTarget()->GetGUID(), remove))
                    ArenaSpectator::SendCommand_Aura(plr->FindMap(), plr->GetGUID(), "AUR", aura->GetCasterGUID(), aura->GetSpellInfo()->Id, aura->GetSpellInfo()->IsPositive(), aura->GetSpellInfo()->Dispel, aura->GetDuration(), aura->GetMaxDuration(), (aura->GetCharges() > 1 ? aura->GetCharges() : aura->GetStackAmount()), remove);
 
    _target->SendMessageToSet(&data, true);
}