SpellImplicitTargetInfo Class Reference

#include "SpellInfo.h"

Classes
struct	StaticData

Public Member Functions
	SpellImplicitTargetInfo ()
	SpellImplicitTargetInfo (uint32 target)
bool	IsArea () const
SpellTargetSelectionCategories	GetSelectionCategory () const
SpellTargetReferenceTypes	GetReferenceType () const
SpellTargetObjectTypes	GetObjectType () const
SpellTargetCheckTypes	GetCheckType () const
SpellTargetDirectionTypes	GetDirectionType () const
float	CalcDirectionAngle () const
Targets	GetTarget () const
uint32	GetExplicitTargetMask (bool &srcSet, bool &dstSet) const

Private Attributes
Targets	_target

Static Private Attributes
static std::array< StaticData, TOTAL_SPELL_TARGETS >	_data

Detailed Description

Constructor & Destructor Documentation

SpellImplicitTargetInfo() [1/2]

SpellImplicitTargetInfo::SpellImplicitTargetInfo ( )

inline

: _target(Targets(0)) {}

SpellImplicitTargetInfo() [2/2]

SpellImplicitTargetInfo::SpellImplicitTargetInfo

(

uint32

target

)

{
    _target = Targets(target);
}

References _target.

Member Function Documentation

CalcDirectionAngle()

float SpellImplicitTargetInfo::CalcDirectionAngle

(

)

const

{
    switch (GetDirectionType())
    {
        case TARGET_DIR_FRONT:
            return 0.0f;
        case TARGET_DIR_BACK:
            return static_cast<float>(M_PI);
        case TARGET_DIR_RIGHT:
            return static_cast<float>(-M_PI / 2);
        case TARGET_DIR_LEFT:
            return static_cast<float>(M_PI / 2);
        case TARGET_DIR_FRONT_RIGHT:
            return static_cast<float>(-M_PI / 4);
        case TARGET_DIR_BACK_RIGHT:
            return static_cast<float>(-3 * M_PI / 4);
        case TARGET_DIR_BACK_LEFT:
            return static_cast<float>(3 * M_PI / 4);
        case TARGET_DIR_FRONT_LEFT:
            return static_cast<float>(M_PI / 4);
        case TARGET_DIR_RANDOM:
            return float(rand_norm()) * static_cast<float>(2 * M_PI);
        default:
            return 0.0f;
    }
}

References GetDirectionType(), rand_norm(), TARGET_DIR_BACK, TARGET_DIR_BACK_LEFT, TARGET_DIR_BACK_RIGHT, TARGET_DIR_FRONT, TARGET_DIR_FRONT_LEFT, TARGET_DIR_FRONT_RIGHT, TARGET_DIR_LEFT, TARGET_DIR_RANDOM, and TARGET_DIR_RIGHT.

Referenced by Spell::SelectImplicitCasterDestTargets(), Spell::SelectImplicitDestDestTargets(), and Spell::SelectImplicitTargetDestTargets().

GetCheckType()

SpellTargetCheckTypes SpellImplicitTargetInfo::GetCheckType

(

)

const

{
    return _data[_target].SelectionCheckType;
}

References _data, and _target.

Referenced by GetExplicitTargetMask(), Spell::SelectImplicitAreaTargets(), Spell::SelectImplicitChainTargets(), Spell::SelectImplicitConeTargets(), and Spell::SelectImplicitNearbyTargets().

GetDirectionType()

SpellTargetDirectionTypes SpellImplicitTargetInfo::GetDirectionType

(

)

const

{
    return _data[_target].DirectionType;
}

References _data, and _target.

Referenced by CalcDirectionAngle().

GetExplicitTargetMask()

uint32 SpellImplicitTargetInfo::GetExplicitTargetMask	(	bool &	srcSet,
		bool &	dstSet
	)		const

{
    uint32 targetMask = 0;
    if (GetTarget() == TARGET_DEST_TRAJ)
    {
        if (!srcSet)
            targetMask = TARGET_FLAG_SOURCE_LOCATION;
        if (!dstSet)
            targetMask |= TARGET_FLAG_DEST_LOCATION;
    }
    else
    {
        switch (GetReferenceType())
        {
            case TARGET_REFERENCE_TYPE_SRC:
                if (srcSet)
                    break;
                targetMask = TARGET_FLAG_SOURCE_LOCATION;
                break;
            case TARGET_REFERENCE_TYPE_DEST:
                if (dstSet)
                    break;
                targetMask = TARGET_FLAG_DEST_LOCATION;
                break;
            case TARGET_REFERENCE_TYPE_TARGET:
                switch (GetObjectType())
                {
                    case TARGET_OBJECT_TYPE_GOBJ:
                        targetMask = TARGET_FLAG_GAMEOBJECT;
                        break;
                    case TARGET_OBJECT_TYPE_GOBJ_ITEM:
                        targetMask = TARGET_FLAG_GAMEOBJECT_ITEM;
                        break;
                    case TARGET_OBJECT_TYPE_UNIT_AND_DEST:
                    case TARGET_OBJECT_TYPE_UNIT:
                    case TARGET_OBJECT_TYPE_DEST:
                        switch (GetCheckType())
                        {
                            case TARGET_CHECK_ENEMY:
                                targetMask = TARGET_FLAG_UNIT_ENEMY;
                                break;
                            case TARGET_CHECK_ALLY:
                                targetMask = TARGET_FLAG_UNIT_ALLY;
                                break;
                            case TARGET_CHECK_PARTY:
                                targetMask = TARGET_FLAG_UNIT_PARTY;
                                break;
                            case TARGET_CHECK_RAID:
                                targetMask = TARGET_FLAG_UNIT_RAID;
                                break;
                            case TARGET_CHECK_PASSENGER:
                                targetMask = TARGET_FLAG_UNIT_PASSENGER;
                                break;
                            case TARGET_CHECK_RAID_CLASS:
                                [[fallthrough]];
                            default:
                                targetMask = TARGET_FLAG_UNIT;
                                break;
                        }
                        break;
                    default:
                        break;
                }
                break;
            default:
                break;
        }
    }
 
    switch (GetObjectType())
    {
        case TARGET_OBJECT_TYPE_SRC:
            srcSet = true;
            break;
        case TARGET_OBJECT_TYPE_DEST:
        case TARGET_OBJECT_TYPE_UNIT_AND_DEST:
            dstSet = true;
            break;
        default:
            break;
    }
    return targetMask;
}

References GetCheckType(), GetObjectType(), GetReferenceType(), GetTarget(), TARGET_CHECK_ALLY, TARGET_CHECK_ENEMY, TARGET_CHECK_PARTY, TARGET_CHECK_PASSENGER, TARGET_CHECK_RAID, TARGET_CHECK_RAID_CLASS, TARGET_DEST_TRAJ, TARGET_FLAG_DEST_LOCATION, TARGET_FLAG_GAMEOBJECT, TARGET_FLAG_GAMEOBJECT_ITEM, TARGET_FLAG_SOURCE_LOCATION, TARGET_FLAG_UNIT, TARGET_FLAG_UNIT_ALLY, TARGET_FLAG_UNIT_ENEMY, TARGET_FLAG_UNIT_PARTY, TARGET_FLAG_UNIT_PASSENGER, TARGET_FLAG_UNIT_RAID, TARGET_OBJECT_TYPE_DEST, TARGET_OBJECT_TYPE_GOBJ, TARGET_OBJECT_TYPE_GOBJ_ITEM, TARGET_OBJECT_TYPE_SRC, TARGET_OBJECT_TYPE_UNIT, TARGET_OBJECT_TYPE_UNIT_AND_DEST, TARGET_REFERENCE_TYPE_DEST, TARGET_REFERENCE_TYPE_SRC, and TARGET_REFERENCE_TYPE_TARGET.

GetObjectType()

SpellTargetObjectTypes SpellImplicitTargetInfo::GetObjectType

(

)

const

{
    return _data[_target].ObjectType;
}

References _data, and _target.

Referenced by SpellScript::TargetHook::CheckEffect(), GetExplicitTargetMask(), SpellEffectInfo::GetMissingTargetMask(), SpellEffectInfo::GetProvidedTargetMask(), Spell::SelectEffectImplicitTargets(), Spell::SelectImplicitAreaTargets(), Spell::SelectImplicitChainTargets(), Spell::SelectImplicitConeTargets(), and Spell::SelectImplicitNearbyTargets().

GetReferenceType()

SpellTargetReferenceTypes SpellImplicitTargetInfo::GetReferenceType

(

)

const

{
    return _data[_target].ReferenceType;
}

References _data, and _target.

Referenced by SpellScript::TargetHook::CheckEffect(), GetExplicitTargetMask(), Spell::SelectEffectImplicitTargets(), Spell::SelectImplicitAreaTargets(), Spell::SelectImplicitChannelTargets(), Spell::SelectImplicitConeTargets(), and Spell::SelectImplicitNearbyTargets().

GetSelectionCategory()

SpellTargetSelectionCategories SpellImplicitTargetInfo::GetSelectionCategory

(

)

const

{
    return _data[_target].SelectionCategory;
}

References _data, and _target.

Referenced by SpellScript::TargetHook::CheckEffect(), IsArea(), Spell::SelectEffectImplicitTargets(), and Spell::SelectImplicitChainTargets().

GetTarget()

Targets SpellImplicitTargetInfo::GetTarget

(

)

const

{
    return _target;
}

References _target.

Referenced by Spell::CallScriptDestinationTargetSelectHandlers(), Spell::CallScriptObjectAreaTargetSelectHandlers(), Spell::CallScriptObjectTargetSelectHandlers(), GetExplicitTargetMask(), Spell::SelectEffectImplicitTargets(), Spell::SelectImplicitCasterDestTargets(), Spell::SelectImplicitCasterObjectTargets(), Spell::SelectImplicitChainTargets(), Spell::SelectImplicitChannelTargets(), Spell::SelectImplicitDestDestTargets(), and Spell::SelectImplicitTargetDestTargets().

IsArea()

bool SpellImplicitTargetInfo::IsArea

(

)

const

{
    return GetSelectionCategory() == TARGET_SELECT_CATEGORY_AREA || GetSelectionCategory() == TARGET_SELECT_CATEGORY_CONE;
}

References GetSelectionCategory(), TARGET_SELECT_CATEGORY_AREA, and TARGET_SELECT_CATEGORY_CONE.

Referenced by SpellEffectInfo::IsTargetingArea().

Member Data Documentation

_data

std::array< SpellImplicitTargetInfo::StaticData, TOTAL_SPELL_TARGETS > SpellImplicitTargetInfo::_data

staticprivate

{
private:
    Targets _target;
public:
    SpellImplicitTargetInfo() : _target(Targets(0)) {}
    SpellImplicitTargetInfo(uint32 target);
 
    bool IsArea() const;
    SpellTargetSelectionCategories GetSelectionCategory() const;
    SpellTargetReferenceTypes GetReferenceType() const;
    SpellTargetObjectTypes GetObjectType() const;
    SpellTargetCheckTypes GetCheckType() const;
    SpellTargetDirectionTypes GetDirectionType() const;
    float CalcDirectionAngle() const;
 
    Targets GetTarget() const;
    uint32 GetExplicitTargetMask(bool& srcSet, bool& dstSet) const;
 
private:
    struct StaticData
    {
        SpellTargetObjectTypes ObjectType;    // type of object returned by target type
        SpellTargetReferenceTypes ReferenceType; // defines which object is used as a reference when selecting target
        SpellTargetSelectionCategories SelectionCategory;
        SpellTargetCheckTypes SelectionCheckType; // defines selection criteria
        SpellTargetDirectionTypes DirectionType; // direction for cone and dest targets
    };
 
    static std::array<StaticData, TOTAL_SPELL_TARGETS> _data;
};
 
class SpellEffectInfo
{
    SpellInfo const* _spellInfo;
    uint8 _effIndex;
public:
    uint32    Effect;
    uint32    ApplyAuraName;
    uint32    Amplitude;
    int32     DieSides;
    float     RealPointsPerLevel;
    int32     BasePoints;
    float     PointsPerComboPoint;
    float     ValueMultiplier;
    float     DamageMultiplier;
    float     BonusMultiplier;
    int32     MiscValue;
    int32     MiscValueB;
    Mechanics Mechanic;
    SpellImplicitTargetInfo TargetA;
    SpellImplicitTargetInfo TargetB;
    SpellRadiusEntry const* RadiusEntry;
    uint32    ChainTarget;
    uint32    ItemType;
    uint32    TriggerSpell;
    flag96    SpellClassMask;
    std::list<Condition*>* ImplicitTargetConditions;
 
    SpellEffectInfo() : _spellInfo(nullptr), _effIndex(0), Effect(0), ApplyAuraName(0), Amplitude(0), DieSides(0),
        RealPointsPerLevel(0), BasePoints(0), PointsPerComboPoint(0), ValueMultiplier(0), DamageMultiplier(0),
        BonusMultiplier(0), MiscValue(0), MiscValueB(0), Mechanic(MECHANIC_NONE), RadiusEntry(nullptr), ChainTarget(0),
        ItemType(0), TriggerSpell(0), ImplicitTargetConditions(nullptr) {}
    SpellEffectInfo(SpellEntry const* spellEntry, SpellInfo const* spellInfo, uint8 effIndex);
 
    bool IsEffect() const;
    bool IsEffect(SpellEffects effectName) const;
    bool IsAura() const;
    bool IsAura(AuraType aura) const;
    bool IsTargetingArea() const;
    bool IsAreaAuraEffect() const;
    bool IsFarUnitTargetEffect() const;
    bool IsFarDestTargetEffect() const;
    bool IsUnitOwnedAuraEffect() const;
 
    int32 CalcValue(Unit const* caster = nullptr, int32 const* basePoints = nullptr, Unit const* target = nullptr) const;
    int32 CalcBaseValue(int32 value) const;
    float CalcValueMultiplier(Unit* caster, Spell* spell = nullptr) const;
    float CalcDamageMultiplier(Unit* caster, Spell* spell = nullptr) const;
 
    bool HasRadius() const;
    float CalcRadius(Unit* caster = nullptr, Spell* = nullptr) const;
 
    uint32 GetProvidedTargetMask() const;
    uint32 GetMissingTargetMask(bool srcSet = false, bool destSet = false, uint32 mask = 0) const;
 
    SpellEffectImplicitTargetTypes GetImplicitTargetType() const;
    SpellTargetObjectTypes GetUsedTargetObjectType() const;
 
private:
    struct StaticData
    {
        SpellEffectImplicitTargetTypes ImplicitTargetType; // defines what target can be added to effect target list if there's no valid target type provided for effect
        SpellTargetObjectTypes UsedTargetObjectType; // defines valid target object type for spell effect
    };
 
    static std::array<StaticData, TOTAL_SPELL_EFFECTS> _data;
};
 
class AC_GAME_API SpellInfo
{
friend class SpellMgr;
 
public:
    uint32 Id;
    SpellCategoryEntry const* CategoryEntry;
    uint32 Dispel;
    uint32 Mechanic;
    uint32 Attributes;

Referenced by GetCheckType(), GetDirectionType(), GetObjectType(), GetReferenceType(), and GetSelectionCategory().

_target

Targets SpellImplicitTargetInfo::_target

private

Referenced by GetCheckType(), GetDirectionType(), GetObjectType(), GetReferenceType(), GetSelectionCategory(), GetTarget(), and SpellImplicitTargetInfo().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/Spells/SpellInfo.h
• azerothcore-wotlk/src/server/game/Spells/SpellInfo.cpp