UnitAI.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 "UnitAI.h"
#include "Containers.h"
#include "Creature.h"
#include "CreatureAIImpl.h"
#include "MotionMaster.h"
#include "Player.h"
#include "Spell.h"
#include "SpellAuraEffects.h"
#include "SpellAuras.h"
#include "SpellInfo.h"
#include "SpellMgr.h"
 
void UnitAI::AttackStart(Unit* victim)
{
    if (victim && me->Attack(victim, true))
        me->GetMotionMaster()->MoveChase(victim);
}
 
void UnitAI::InitializeAI()
{
    if (!me->isDead())
        Reset();
}
 
void UnitAI::OnCharmed(bool isNew)
{
    if (!isNew)
        me->ScheduleAIChange();
}
 
void UnitAI::AttackStartCaster(Unit* victim, float dist)
{
    if (victim && me->Attack(victim, false))
        me->GetMotionMaster()->MoveChase(victim, dist);
}
 
void UnitAI::DoMeleeAttackIfReady()
{
    if (me->HasUnitState(UNIT_STATE_CASTING))
        return;
 
    Unit* victim = me->GetVictim();
 
    if (!me->IsWithinMeleeRange(victim))
        return;
 
    //Make sure our attack is ready and we aren't currently casting before checking distance
    if (me->isAttackReady())
    {
        me->AttackerStateUpdate(victim);
        me->resetAttackTimer();
    }
 
    if (me->haveOffhandWeapon() && me->isAttackReady(OFF_ATTACK))
    {
        me->AttackerStateUpdate(victim, OFF_ATTACK);
        me->resetAttackTimer(OFF_ATTACK);
    }
}
 
bool UnitAI::DoSpellAttackIfReady(uint32 spell)
{
    if (me->HasUnitState(UNIT_STATE_CASTING) || !me->isAttackReady())
        return true;
 
    if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spell))
    {
        if (me->IsWithinCombatRange(me->GetVictim(), spellInfo->GetMaxRange(false)))
        {
            me->CastSpell(me->GetVictim(), spell, false);
            me->resetAttackTimer();
            return true;
        }
    }
 
    return false;
}
 
Unit* UnitAI::SelectTarget(SelectTargetMethod targetType, uint32 position, float dist, bool playerOnly, bool withTank, int32 aura)
{
    return SelectTarget(targetType, position, DefaultTargetSelector(me, dist, playerOnly, withTank, aura));
}
 
void UnitAI::SelectTargetList(std::list<Unit*>& targetList, uint32 num, SelectTargetMethod targetType, uint32 offset, float dist, bool playerOnly, bool withTank, int32 aura)
{
    SelectTargetList(targetList, num, targetType, offset, DefaultTargetSelector(me, dist, playerOnly, withTank, aura));
}
 
SpellCastResult UnitAI::DoCast(uint32 spellId)
{
    Unit* target = nullptr;
 
    switch (AISpellInfo[spellId].target)
    {
        default:
        case AITARGET_SELF:
            target = me;
            break;
        case AITARGET_VICTIM:
            target = me->GetVictim();
            break;
        case AITARGET_ENEMY:
        {
            if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId))
            {
                bool playerOnly = spellInfo->HasAttribute(SPELL_ATTR3_ONLY_TARGET_PLAYERS);
                target = SelectTarget(SelectTargetMethod::Random, 0, spellInfo->GetMaxRange(false), playerOnly);
            }
            break;
        }
        case AITARGET_ALLY:
            target = me;
            break;
        case AITARGET_BUFF:
            target = me;
            break;
        case AITARGET_DEBUFF:
        {
            if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId))
            {
                bool playerOnly = spellInfo->HasAttribute(SPELL_ATTR3_ONLY_TARGET_PLAYERS);
                float range = spellInfo->GetMaxRange(false);
 
                DefaultTargetSelector targetSelector(me, range, playerOnly, true, -(int32)spellId);
                if (!(spellInfo->AuraInterruptFlags & AURA_INTERRUPT_FLAG_NOT_VICTIM)
                    && targetSelector(me->GetVictim()))
                    target = me->GetVictim();
                else
                    target = SelectTarget(SelectTargetMethod::Random, 0, targetSelector);
            }
            break;
        }
    }
 
    if (target)
        return me->CastSpell(target, spellId, false);
 
    return SPELL_FAILED_BAD_TARGETS;
}
 
SpellCastResult UnitAI::DoCast(Unit* victim, uint32 spellId, CastSpellExtraArgs const& args)
{
    if (me->HasUnitState(UNIT_STATE_CASTING) && !(args.TriggerFlags & TRIGGERED_IGNORE_CAST_IN_PROGRESS))
        return SPELL_FAILED_SPELL_IN_PROGRESS;
 
    return me->CastSpell(victim, spellId, args);
}
 
SpellCastResult UnitAI::DoCastVictim(uint32 spellId, CastSpellExtraArgs const& args)
{
    if (Unit* victim = me->GetVictim())
        return DoCast(victim, spellId, args);
 
    return SPELL_FAILED_BAD_TARGETS;
}
 
float UnitAI::DoGetSpellMaxRange(uint32 spellId, bool positive)
{
    SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId);
    return spellInfo ? spellInfo->GetMaxRange(positive) : 0;
}
 
#define UPDATE_TARGET(a) {if (AIInfo->target<a) AIInfo->target=a;}
 
void UnitAI::FillAISpellInfo()
{
    AISpellInfo = new AISpellInfoType[sSpellMgr->GetSpellInfoStoreSize()];
 
    AISpellInfoType* AIInfo = AISpellInfo;
    for (uint32 i = 0; i < sSpellMgr->GetSpellInfoStoreSize(); ++i, ++AIInfo)
    {
        SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(i);
        if (!spellInfo)
            continue;
 
        if (spellInfo->HasAttribute(SPELL_ATTR0_CASTABLE_WHILE_DEAD))
            AIInfo->condition = AICOND_DIE;
        else if (spellInfo->IsPassive() || spellInfo->GetDuration() == -1)
            AIInfo->condition = AICOND_AGGRO;
        else
            AIInfo->condition = AICOND_COMBAT;
 
        if (AIInfo->cooldown < spellInfo->RecoveryTime)
            AIInfo->cooldown = spellInfo->RecoveryTime;
 
        if (spellInfo->GetMaxRange(false))
        {
            for (SpellEffectInfo const& effect : spellInfo->GetEffects())
            {
                uint32 targetType = effect.TargetA.GetTarget();
 
                if (targetType == TARGET_UNIT_TARGET_ENEMY
                    || targetType == TARGET_DEST_TARGET_ENEMY)
                    UPDATE_TARGET(AITARGET_VICTIM)
                else if (targetType == TARGET_UNIT_DEST_AREA_ENEMY)
                    UPDATE_TARGET(AITARGET_ENEMY)
 
                if (effect.Effect == SPELL_EFFECT_APPLY_AURA)
                {
                    if (targetType == TARGET_UNIT_TARGET_ENEMY)
                        UPDATE_TARGET(AITARGET_DEBUFF)
                    else if (spellInfo->IsPositive())
                        UPDATE_TARGET(AITARGET_BUFF)
                }
            }
        }
        AIInfo->realCooldown = spellInfo->RecoveryTime + spellInfo->StartRecoveryTime;
        AIInfo->maxRange = spellInfo->GetMaxRange(false) * 3 / 4;
    }
}
 
Unit* UnitAI::FinalizeTargetSelection(std::list<Unit*>& targetList, SelectTargetMethod targetType)
{
    // maybe nothing fulfills the predicate
    if (targetList.empty())
        return nullptr;
 
    switch (targetType)
    {
        case SelectTargetMethod::MaxThreat:
        case SelectTargetMethod::MinThreat:
        case SelectTargetMethod::MaxDistance:
        case SelectTargetMethod::MinDistance:
            return targetList.front();
        case SelectTargetMethod::Random:
            return Trinity::Containers::SelectRandomContainerElement(targetList);
        default:
            break;
    }
 
    return nullptr;
}
 
bool UnitAI::PrepareTargetListSelection(std::list<Unit*>& targetList, SelectTargetMethod targetType, uint32 offset)
{
    targetList.clear();
    ThreatManager& mgr = me->GetThreatManager();
    // shortcut: we're gonna ignore the first <offset> elements, and there's at most <offset> elements, so we ignore them all - nothing to do here
    if (mgr.GetThreatListSize() <= offset)
        return false;
 
    if (targetType == SelectTargetMethod::MaxDistance || targetType == SelectTargetMethod::MinDistance)
    {
        for (ThreatReference const* ref : mgr.GetUnsortedThreatList())
        {
            if (ref->IsOffline())
                continue;
 
            targetList.push_back(ref->GetVictim());
        }
    }
    else
    {
        Unit* currentVictim = mgr.GetCurrentVictim();
        if (currentVictim)
            targetList.push_back(currentVictim);
 
        for (ThreatReference const* ref : mgr.GetSortedThreatList())
        {
            if (ref->IsOffline())
                continue;
 
            Unit* thisTarget = ref->GetVictim();
            if (thisTarget != currentVictim)
                targetList.push_back(thisTarget);
        }
    }
 
    // shortcut: the list isn't gonna get any larger
    if (targetList.size() <= offset)
    {
        targetList.clear();
        return false;
    }
 
    // right now, list is unsorted for DISTANCE types - re-sort by SelectTargetMethod::MaxDistance
    if (targetType == SelectTargetMethod::MaxDistance || targetType == SelectTargetMethod::MinDistance)
        targetList.sort(Trinity::ObjectDistanceOrderPred(me, targetType == SelectTargetMethod::MinDistance));
 
    // now the list is MAX sorted, reverse for MIN types
    if (targetType == SelectTargetMethod::MinThreat)
        targetList.reverse();
 
    // ignore the first <offset> elements
    while (offset)
    {
        targetList.pop_front();
        --offset;
    }
 
    return true;
}
 
void UnitAI::FinalizeTargetListSelection(std::list<Unit*>& targetList, uint32 num, SelectTargetMethod targetType)
{
    if (targetList.size() <= num)
        return;
 
    if (targetType == SelectTargetMethod::Random)
        Trinity::Containers::RandomResize(targetList, num);
    else
        targetList.resize(num);
}
 
std::string UnitAI::GetDebugInfo() const
{
    std::stringstream sstr;
    sstr << std::boolalpha
         << "Me: " << (me ? me->GetDebugInfo() : "NULL");
    return sstr.str();
}
 
DefaultTargetSelector::DefaultTargetSelector(Unit const* unit, float dist, bool playerOnly, bool withTank, int32 aura)
    : _me(unit), _dist(dist), _playerOnly(playerOnly), _exception(!withTank ? unit->GetThreatManager().GetLastVictim() : nullptr), _aura(aura)
{
}
 
bool DefaultTargetSelector::operator()(Unit const* target) const
{
    if (!_me)
        return false;
 
    if (!target)
        return false;
 
    if (_exception && target == _exception)
        return false;
 
    if (_playerOnly && (target->GetTypeId() != TYPEID_PLAYER))
        return false;
 
    if (_dist > 0.0f && !_me->IsWithinCombatRange(target, _dist))
        return false;
 
    if (_dist < 0.0f && _me->IsWithinCombatRange(target, -_dist))
        return false;
 
    if (_aura)
    {
        if (_aura > 0)
        {
            if (!target->HasAura(_aura))
                return false;
        }
        else
        {
            if (target->HasAura(-_aura))
                return false;
        }
    }
 
    return true;
}
 
SpellTargetSelector::SpellTargetSelector(Unit* caster, uint32 spellId) :
    _caster(caster), _spellInfo(sSpellMgr->GetSpellForDifficultyFromSpell(sSpellMgr->GetSpellInfo(spellId), caster))
{
    ASSERT(_spellInfo);
}
 
bool SpellTargetSelector::operator()(Unit const* target) const
{
    if (!target || _spellInfo->CheckTarget(_caster, target) != SPELL_CAST_OK)
        return false;
 
    // copypasta from Spell::CheckRange
    float minRange = 0.0f;
    float maxRange = 0.0f;
    float rangeMod = 0.0f;
    if (_spellInfo->RangeEntry)
    {
        if (_spellInfo->RangeEntry->Flags & SPELL_RANGE_MELEE)
        {
            rangeMod = _caster->GetCombatReach() + 4.0f / 3.0f;
            rangeMod += target->GetCombatReach();
 
            rangeMod = std::max(rangeMod, NOMINAL_MELEE_RANGE);
        }
        else
        {
            float meleeRange = 0.0f;
            if (_spellInfo->RangeEntry->Flags & SPELL_RANGE_RANGED)
            {
                meleeRange = _caster->GetCombatReach() + 4.0f / 3.0f;
                meleeRange += target->GetCombatReach();
 
                meleeRange = std::max(meleeRange, NOMINAL_MELEE_RANGE);
            }
 
            minRange = _caster->GetSpellMinRangeForTarget(target, _spellInfo) + meleeRange;
            maxRange = _caster->GetSpellMaxRangeForTarget(target, _spellInfo);
 
            rangeMod = _caster->GetCombatReach();
            rangeMod += target->GetCombatReach();
 
            if (minRange > 0.0f && !(_spellInfo->RangeEntry->Flags & SPELL_RANGE_RANGED))
                minRange += rangeMod;
        }
 
        if (_caster->isMoving() && target->isMoving() && !_caster->IsWalking() && !target->IsWalking() &&
            (_spellInfo->RangeEntry->Flags & SPELL_RANGE_MELEE || target->GetTypeId() == TYPEID_PLAYER))
            rangeMod += 8.0f / 3.0f;
    }
 
    maxRange += rangeMod;
 
    minRange *= minRange;
    maxRange *= maxRange;
 
    if (target != _caster)
    {
        if (_caster->GetExactDistSq(target) > maxRange)
            return false;
 
        if (minRange > 0.0f && _caster->GetExactDistSq(target) < minRange)
            return false;
    }
 
    return true;
}
 
bool NonTankTargetSelector::operator()(Unit const* target) const
{
    if (!target)
        return false;
 
    if (_playerOnly && target->GetTypeId() != TYPEID_PLAYER)
        return false;
 
    if (Unit* currentVictim = _source->GetThreatManager().GetCurrentVictim())
        return target != currentVictim;
 
    return target != _source->GetVictim();
}
 
bool PowerUsersSelector::operator()(Unit const* target) const
{
    if (!_me || !target)
        return false;
 
    if (target->GetPowerType() != _power)
        return false;
 
    if (_playerOnly && target->GetTypeId() != TYPEID_PLAYER)
        return false;
 
    if (_dist > 0.0f && !_me->IsWithinCombatRange(target, _dist))
        return false;
 
    if (_dist < 0.0f && _me->IsWithinCombatRange(target, -_dist))
        return false;
 
    return true;
}
 
bool FarthestTargetSelector::operator()(Unit const* target) const
{
    if (!_me || !target)
        return false;
 
    if (_playerOnly && target->GetTypeId() != TYPEID_PLAYER)
        return false;
 
    if (_dist > 0.0f && !_me->IsWithinCombatRange(target, _dist))
        return false;
 
    if (_inLos && !_me->IsWithinLOSInMap(target))
        return false;
 
    return true;
}