Unit.cpp File Reference

#include "Unit.h"
#include "AbstractFollower.h"
#include "AreaDefines.h"
#include "ArenaSpectator.h"
#include "Battlefield.h"
#include "BattlefieldMgr.h"
#include "Battleground.h"
#include "CellImpl.h"
#include "CharacterCache.h"
#include "CharmInfo.h"
#include "Chat.h"
#include "ChatPackets.h"
#include "ChatTextBuilder.h"
#include "CombatPackets.h"
#include "Common.h"
#include "ConditionMgr.h"
#include "Creature.h"
#include "CreatureAIImpl.h"
#include "CreatureGroups.h"
#include "DisableMgr.h"
#include "DynamicVisibility.h"
#include "Errors.h"
#include "GameObjectAI.h"
#include "GameTime.h"
#include "GridNotifiersImpl.h"
#include "Group.h"
#include "Log.h"
#include "MapMgr.h"
#include "MoveSpline.h"
#include "MoveSplineInit.h"
#include "MovementGenerator.h"
#include "ObjectAccessor.h"
#include "ObjectMgr.h"
#include "OutdoorPvP.h"
#include "PassiveAI.h"
#include "Pet.h"
#include "PetAI.h"
#include "PetPackets.h"
#include "Player.h"
#include "ReputationMgr.h"
#include "ScriptMgr.h"
#include "SharedDefines.h"
#include "Spell.h"
#include "SpellAuraDefines.h"
#include "SpellAuraEffects.h"
#include "SpellAuras.h"
#include "SpellInfo.h"
#include "SpellMgr.h"
#include "TemporarySummon.h"
#include "Totem.h"
#include "TotemAI.h"
#include "Transport.h"
#include "UpdateFieldFlags.h"
#include "UpdateFields.h"
#include "Util.h"
#include "Vehicle.h"
#include "World.h"
#include "WorldPacket.h"
#include <algorithm>
#include <cmath>
#include <limits>

Go to the source code of this file.

Classes
class	SplineHandler
class	AuraMunchingQueue

Functions
void	ApplyMoveSpeedRates (float npcRate, float playerRate)
void	createProcFlags (SpellInfo const *spellInfo, WeaponAttackType attackType, bool positive, uint32 &procAttacker, uint32 &procVictim)
void	ApplyPercentModFloatVar (float &var, float val, bool apply)

Variables
static constexpr std::array< float, MAX_MOVE_TYPE >	DefaultMoveSpeed
std::array< float, MAX_MOVE_TYPE >	baseMoveSpeed = DefaultMoveSpeed
std::array< float, MAX_MOVE_TYPE >	playerBaseMoveSpeed = DefaultMoveSpeed

Function Documentation

ApplyMoveSpeedRates()

void ApplyMoveSpeedRates	(	float	npcRate,
		float	playerRate
	)

{
    for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i)
    {
        baseMoveSpeed[i] = DefaultMoveSpeed[i] * npcRate;
        playerBaseMoveSpeed[i] = DefaultMoveSpeed[i] * playerRate;
    }
}

References baseMoveSpeed, DefaultMoveSpeed, MAX_MOVE_TYPE, and playerBaseMoveSpeed.

Referenced by World::LoadConfigSettings(), TEST_F(), and TEST_F().

ApplyPercentModFloatVar()

void ApplyPercentModFloatVar	(	float &	var,
		float	val,
		bool	apply
	)

{
    var *= (apply ? (100.0f + val) / 100.0f : 100.0f / (100.0f + val));
}

Referenced by Unit::ApplyAttackTimePercentMod(), and Unit::ApplyCastTimePercentMod().

createProcFlags()

void createProcFlags	(	SpellInfo const *	spellInfo,
		WeaponAttackType	attackType,
		bool	positive,
		uint32 &	procAttacker,
		uint32 &	procVictim
	)

{
    if (spellInfo)
    {
        switch (spellInfo->DmgClass)
        {
            case SPELL_DAMAGE_CLASS_MAGIC:
                if (positive)
                {
                    procAttacker |= PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS;
                    procVictim   |= PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_POS;
                }
                else
                {
                    procAttacker |= PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG;
                    procVictim   |= PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG;
                }
                break;
            case SPELL_DAMAGE_CLASS_NONE:
                if (positive)
                {
                    procAttacker |= PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS;
                    procVictim   |= PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_POS;
                }
                else
                {
                    procAttacker |= PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG;
                    procVictim   |= PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_NEG;
                }
                break;
            case SPELL_DAMAGE_CLASS_MELEE:
                procAttacker = PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS;
                if (attackType == OFF_ATTACK)
                    procAttacker |= PROC_FLAG_DONE_OFFHAND_ATTACK;
                else
                    procAttacker |= PROC_FLAG_DONE_MAINHAND_ATTACK;
                procVictim = PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS;
                break;
            case SPELL_DAMAGE_CLASS_RANGED:
                // Auto attack
                if (spellInfo->HasAttribute(SPELL_ATTR2_AUTO_REPEAT))
                {
                    procAttacker = PROC_FLAG_DONE_RANGED_AUTO_ATTACK;
                    procVictim   = PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK;
                }
                else // Ranged spell attack
                {
                    procAttacker = PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS;
                    procVictim   = PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS;
                }
                break;
            default:
                if (spellInfo->EquippedItemClass == ITEM_CLASS_WEAPON &&
                        spellInfo->EquippedItemSubClassMask & (1 << ITEM_SUBCLASS_WEAPON_WAND)
                        && spellInfo->HasAttribute(SPELL_ATTR2_AUTO_REPEAT)) // Wands auto attack
                {
                    procAttacker = PROC_FLAG_DONE_RANGED_AUTO_ATTACK;
                    procVictim   = PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK;
                }
                break;
        }
    }
    else if (attackType == BASE_ATTACK)
    {
        procAttacker = PROC_FLAG_DONE_MELEE_AUTO_ATTACK | PROC_FLAG_DONE_MAINHAND_ATTACK;
        procVictim   = PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK;
    }
    else if (attackType == OFF_ATTACK)
    {
        procAttacker = PROC_FLAG_DONE_MELEE_AUTO_ATTACK | PROC_FLAG_DONE_OFFHAND_ATTACK;
        procVictim   = PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK;
    }
}

References BASE_ATTACK, SpellInfo::DmgClass, SpellInfo::EquippedItemClass, SpellInfo::EquippedItemSubClassMask, SpellInfo::HasAttribute(), ITEM_CLASS_WEAPON, ITEM_SUBCLASS_WEAPON_WAND, OFF_ATTACK, PROC_FLAG_DONE_MAINHAND_ATTACK, PROC_FLAG_DONE_MELEE_AUTO_ATTACK, PROC_FLAG_DONE_OFFHAND_ATTACK, PROC_FLAG_DONE_RANGED_AUTO_ATTACK, PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_NEG, PROC_FLAG_DONE_SPELL_MAGIC_DMG_CLASS_POS, PROC_FLAG_DONE_SPELL_MELEE_DMG_CLASS, PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_NEG, PROC_FLAG_DONE_SPELL_NONE_DMG_CLASS_POS, PROC_FLAG_DONE_SPELL_RANGED_DMG_CLASS, PROC_FLAG_TAKEN_MELEE_AUTO_ATTACK, PROC_FLAG_TAKEN_RANGED_AUTO_ATTACK, PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_NEG, PROC_FLAG_TAKEN_SPELL_MAGIC_DMG_CLASS_POS, PROC_FLAG_TAKEN_SPELL_MELEE_DMG_CLASS, PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_NEG, PROC_FLAG_TAKEN_SPELL_NONE_DMG_CLASS_POS, PROC_FLAG_TAKEN_SPELL_RANGED_DMG_CLASS, SPELL_ATTR2_AUTO_REPEAT, SPELL_DAMAGE_CLASS_MAGIC, SPELL_DAMAGE_CLASS_MELEE, SPELL_DAMAGE_CLASS_NONE, and SPELL_DAMAGE_CLASS_RANGED.

Referenced by Unit::CalcAbsorbResist().

Variable Documentation

baseMoveSpeed

std::array<float, MAX_MOVE_TYPE> baseMoveSpeed = DefaultMoveSpeed

Referenced by ApplyMoveSpeedRates(), Spell::CalculateJumpSpeeds(), Unit::GetSpeed(), TEST_F(), TEST_F(), and Unit::UpdateSpeed().

DefaultMoveSpeed

constexpr std::array<float, MAX_MOVE_TYPE> DefaultMoveSpeed

staticconstexpr

Initial value:

=
{
    2.5f,                  
    7.0f,                  
    4.5f,                  
    4.722222f,             
    2.5f,                  
    3.141594f,             
    7.0f,                  
    4.5f,                  
    3.14f                  
}

{
    2.5f,                  // MOVE_WALK
    7.0f,                  // MOVE_RUN
    4.5f,                  // MOVE_RUN_BACK
    4.722222f,             // MOVE_SWIM
    2.5f,                  // MOVE_SWIM_BACK
    3.141594f,             // MOVE_TURN_RATE
    7.0f,                  // MOVE_FLIGHT
    4.5f,                  // MOVE_FLIGHT_BACK
    3.14f                  // MOVE_PITCH_RATE
};

Referenced by ApplyMoveSpeedRates().

playerBaseMoveSpeed

std::array<float, MAX_MOVE_TYPE> playerBaseMoveSpeed = DefaultMoveSpeed

Referenced by ApplyMoveSpeedRates(), Spell::CalculateJumpSpeeds(), Unit::GetSpeed(), TEST_F(), TEST_F(), and Unit::UpdateSpeed().