Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-18 16:38:42 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2639 from Fredi/clean

Browse Source 
Core/AI: Code style and cleanups
This commit is contained in:
Machiavelli
2011-08-18 12:14:15 -07:00
parent fb87b41a75 0b64d726c2
commit f960fcce65
31 changed files with 430 additions and 428 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
src/server/game/AI/CoreAI/CombatAI.cpp
View File

@@ -22,7 +22,7 @@
#include "Vehicle.h"
#include "ObjectAccessor.h"
int AggressorAI::Permissible(const Creature *creature)
int AggressorAI::Permissible(const Creature* creature)
{
// have some hostile factions, it will be selected by IsHostileTo check at MoveInLineOfSight
if (!creature->isCivilian() && !creature->IsNeutralToAll())
@@ -81,7 +81,7 @@ void CombatAI::JustDied(Unit* killer)
me->CastSpell(killer, *i, true);
}
void CombatAI::EnterCombat(Unit *who)
void CombatAI::EnterCombat(Unit* who)
{
for (SpellVct::iterator i = spells.begin(); i != spells.end(); ++i)
{
@@ -127,7 +127,7 @@ void CasterAI::InitializeAI()
m_attackDist = MELEE_RANGE;
}
void CasterAI::EnterCombat(Unit *who)
void CasterAI::EnterCombat(Unit* who)
{
if (spells.empty())
return;
@@ -173,7 +173,7 @@ void CasterAI::UpdateAI(const uint32 diff)
//ArcherAI
//////////////
ArcherAI::ArcherAI(Creature *c) : CreatureAI(c)
ArcherAI::ArcherAI(Creature* c) : CreatureAI(c)
{
if (!me->m_spells[0])
sLog->outError("ArcherAI set for creature (entry = %u) with spell1=0. AI will do nothing", me->GetEntry());
@@ -187,7 +187,7 @@ ArcherAI::ArcherAI(Creature *c) : CreatureAI(c)
me->m_SightDistance = me->m_CombatDistance;
}
void ArcherAI::AttackStart(Unit *who)
void ArcherAI::AttackStart(Unit* who)
{
if (!who)
return;
@@ -222,7 +222,7 @@ void ArcherAI::UpdateAI(const uint32 /*diff*/)
//TurretAI
//////////////
TurretAI::TurretAI(Creature *c) : CreatureAI(c)
TurretAI::TurretAI(Creature* c) : CreatureAI(c)
{
if (!me->m_spells[0])
sLog->outError("TurretAI set for creature (entry = %u) with spell1=0. AI will do nothing", me->GetEntry());
@@ -242,7 +242,7 @@ bool TurretAI::CanAIAttack(const Unit* /*who*/) const
return true;
}
void TurretAI::AttackStart(Unit *who)
void TurretAI::AttackStart(Unit* who)
{
if (who)
me->Attack(who, false);
@@ -260,7 +260,7 @@ void TurretAI::UpdateAI(const uint32 /*diff*/)
//VehicleAI
//////////////
VehicleAI::VehicleAI(Creature *c) : CreatureAI(c), m_vehicle(c->GetVehicleKit()), m_IsVehicleInUse(false), m_ConditionsTimer(VEHICLE_CONDITION_CHECK_TIME)
VehicleAI::VehicleAI(Creature* c) : CreatureAI(c), m_vehicle(c->GetVehicleKit()), m_IsVehicleInUse(false), m_ConditionsTimer(VEHICLE_CONDITION_CHECK_TIME)
{
LoadConditions();
m_DoDismiss = false;
@@ -318,11 +318,11 @@ void VehicleAI::CheckConditions(const uint32 diff)
for (SeatMap::iterator itr = m_vehicle->Seats.begin(); itr != m_vehicle->Seats.end(); ++itr)
if (Unit* passenger = ObjectAccessor::GetUnit(*m_vehicle->GetBase(), itr->second.Passenger))
{
if (Player* plr = passenger->ToPlayer())
if (Player* player = passenger->ToPlayer())
{
if (!sConditionMgr->IsPlayerMeetToConditions(plr, conditions))
if (!sConditionMgr->IsPlayerMeetToConditions(player, conditions))
{
plr->ExitVehicle();
player->ExitVehicle();
return;//check other pessanger in next tick
}
}

32
src/server/game/AI/CoreAI/CombatAI.h
View File

@@ -28,10 +28,10 @@ class Creature;
class AggressorAI : public CreatureAI
{
public:
explicit AggressorAI(Creature *c) : CreatureAI(c) {}
explicit AggressorAI(Creature* c) : CreatureAI(c) {}
void UpdateAI(const uint32);
static int Permissible(const Creature *);
static int Permissible(const Creature*);
};
typedef std::vector<uint32> SpellVct;
@@ -39,14 +39,14 @@ typedef std::vector<uint32> SpellVct;
class CombatAI : public CreatureAI
{
public:
explicit CombatAI(Creature *c) : CreatureAI(c) {}
explicit CombatAI(Creature* c) : CreatureAI(c) {}
void InitializeAI();
void Reset();
void EnterCombat(Unit* who);
void JustDied(Unit* killer);
void UpdateAI(const uint32 diff);
static int Permissible(const Creature *);
static int Permissible(const Creature*);
protected:
EventMap events;
SpellVct spells;
@@ -55,7 +55,7 @@ class CombatAI : public CreatureAI
class CasterAI : public CombatAI
{
public:
explicit CasterAI(Creature *c) : CombatAI(c) { m_attackDist = MELEE_RANGE; }
explicit CasterAI(Creature* c) : CombatAI(c) { m_attackDist = MELEE_RANGE; }
void InitializeAI();
void AttackStart(Unit* victim) { AttackStartCaster(victim, m_attackDist); }
void UpdateAI(const uint32 diff);
@@ -67,11 +67,11 @@ class CasterAI : public CombatAI
struct ArcherAI : public CreatureAI
{
public:
explicit ArcherAI(Creature *c);
void AttackStart(Unit *who);
explicit ArcherAI(Creature* c);
void AttackStart(Unit* who);
void UpdateAI(const uint32 diff);
static int Permissible(const Creature *);
static int Permissible(const Creature*);
protected:
float m_minRange;
};
@@ -79,12 +79,12 @@ struct ArcherAI : public CreatureAI
struct TurretAI : public CreatureAI
{
public:
explicit TurretAI(Creature *c);
bool CanAIAttack(const Unit *who) const;
void AttackStart(Unit *who);
explicit TurretAI(Creature* c);
bool CanAIAttack(const Unit* who) const;
void AttackStart(Unit* who);
void UpdateAI(const uint32 diff);
static int Permissible(const Creature *);
static int Permissible(const Creature*);
protected:
float m_minRange;
};
@@ -94,13 +94,13 @@ struct TurretAI : public CreatureAI
struct VehicleAI : public CreatureAI
{
public:
explicit VehicleAI(Creature *c);
explicit VehicleAI(Creature* c);
void UpdateAI(const uint32 diff);
static int Permissible(const Creature *);
static int Permissible(const Creature*);
void Reset();
void MoveInLineOfSight(Unit *) {}
void AttackStart(Unit *) {}
void MoveInLineOfSight(Unit*) {}
void AttackStart(Unit*) {}
void OnCharmed(bool apply);
private:

2
src/server/game/AI/CoreAI/GameObjectAI.cpp
View File

@@ -26,4 +26,4 @@ int GameObjectAI::Permissible(const GameObject* go)
return PERMIT_BASE_NO;
}
NullGameObjectAI::NullGameObjectAI(GameObject *g) : GameObjectAI(g) {}
NullGameObjectAI::NullGameObjectAI(GameObject* g) : GameObjectAI(g) {}

4
src/server/game/AI/CoreAI/GameObjectAI.h
View File

@@ -30,7 +30,7 @@ class GameObjectAI
protected:
GameObject* const go;
public:
explicit GameObjectAI(GameObject *g) : go(g) {}
explicit GameObjectAI(GameObject* g) : go(g) {}
virtual ~GameObjectAI() {}
virtual void UpdateAI(const uint32 /*diff*/) {}
@@ -54,7 +54,7 @@ class GameObjectAI
class NullGameObjectAI : public GameObjectAI
{
public:
explicit NullGameObjectAI(GameObject *g);
explicit NullGameObjectAI(GameObject* g);
void UpdateAI(const uint32 /*diff*/) {}

4
src/server/game/AI/CoreAI/GuardAI.cpp
View File

@@ -40,8 +40,8 @@ bool GuardAI::CanSeeAlways(WorldObject const* obj)
if (!obj->isType(TYPEMASK_UNIT))
return false;
std::list<HostileReference *> t_list = me->getThreatManager().getThreatList();
for (std::list<HostileReference *>::const_iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
std::list<HostileReference*> t_list = me->getThreatManager().getThreatList();
for (std::list<HostileReference*>::const_iterator itr = t_list.begin(); itr!= t_list.end(); ++itr)
{
if (Unit* unit = Unit::GetUnit(*me, (*itr)->getUnitGuid()))
if (unit == obj)

8
src/server/game/AI/CoreAI/GuardAI.h
View File

@@ -34,15 +34,15 @@ class GuardAI : public ScriptedAI
public:
explicit GuardAI(Creature *c);
explicit GuardAI(Creature* c);
void MoveInLineOfSight(Unit *);
void MoveInLineOfSight(Unit*);
void EnterEvadeMode();
void JustDied(Unit *);
void JustDied(Unit*);
bool CanSeeAlways(WorldObject const* obj);
void UpdateAI(const uint32);
static int Permissible(const Creature *);
static int Permissible(const Creature*);
private:
uint64 i_victimGuid;

10
src/server/game/AI/CoreAI/PassiveAI.cpp
View File

@@ -20,9 +20,9 @@
#include "Creature.h"
#include "TemporarySummon.h"
PassiveAI::PassiveAI(Creature *c) : CreatureAI(c) { me->SetReactState(REACT_PASSIVE); }
PossessedAI::PossessedAI(Creature *c) : CreatureAI(c) { me->SetReactState(REACT_PASSIVE); }
NullCreatureAI::NullCreatureAI(Creature *c) : CreatureAI(c) { me->SetReactState(REACT_PASSIVE); }
PassiveAI::PassiveAI(Creature* c) : CreatureAI(c) { me->SetReactState(REACT_PASSIVE); }
PossessedAI::PossessedAI(Creature* c) : CreatureAI(c) { me->SetReactState(REACT_PASSIVE); }
NullCreatureAI::NullCreatureAI(Creature* c) : CreatureAI(c) { me->SetReactState(REACT_PASSIVE); }
void PassiveAI::UpdateAI(const uint32)
{
@@ -59,7 +59,7 @@ void PossessedAI::KilledUnit(Unit* victim)
victim->RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_LOOTABLE);
}
void CritterAI::DamageTaken(Unit* /*done_by*/, uint32 &)
void CritterAI::DamageTaken(Unit* /*done_by*/, uint32&)
{
if (!me->HasUnitState(UNIT_STAT_FLEEING))
me->SetControlled(true, UNIT_STAT_FLEEING);
@@ -72,7 +72,7 @@ void CritterAI::EnterEvadeMode()
CreatureAI::EnterEvadeMode();
}
void TriggerAI::IsSummonedBy(Unit *summoner)
void TriggerAI::IsSummonedBy(Unit* summoner)
{
if (me->m_spells[0])
me->CastSpell(me, me->m_spells[0], false, 0, 0, summoner->GetGUID());

30
src/server/game/AI/CoreAI/PassiveAI.h
View File

@@ -25,21 +25,21 @@
class PassiveAI : public CreatureAI
{
public:
explicit PassiveAI(Creature *c);
explicit PassiveAI(Creature* c);
void MoveInLineOfSight(Unit *) {}
void AttackStart(Unit *) {}
void MoveInLineOfSight(Unit*) {}
void AttackStart(Unit*) {}
void UpdateAI(const uint32);
static int Permissible(const Creature *) { return PERMIT_BASE_IDLE; }
static int Permissible(const Creature*) { return PERMIT_BASE_IDLE; }
};
class PossessedAI : public CreatureAI
{
public:
explicit PossessedAI(Creature *c);
explicit PossessedAI(Creature* c);
void MoveInLineOfSight(Unit *) {}
void MoveInLineOfSight(Unit*) {}
void AttackStart(Unit* target);
void UpdateAI(const uint32);
void EnterEvadeMode() {}
@@ -47,37 +47,37 @@ class PossessedAI : public CreatureAI
void JustDied(Unit*);
void KilledUnit(Unit* victim);
static int Permissible(const Creature *) { return PERMIT_BASE_IDLE; }
static int Permissible(const Creature*) { return PERMIT_BASE_IDLE; }
};
class NullCreatureAI : public CreatureAI
{
public:
explicit NullCreatureAI(Creature *c);
explicit NullCreatureAI(Creature* c);
void MoveInLineOfSight(Unit *) {}
void AttackStart(Unit *) {}
void MoveInLineOfSight(Unit*) {}
void AttackStart(Unit*) {}
void UpdateAI(const uint32) {}
void EnterEvadeMode() {}
void OnCharmed(bool /*apply*/) {}
static int Permissible(const Creature *) { return PERMIT_BASE_IDLE; }
static int Permissible(const Creature*) { return PERMIT_BASE_IDLE; }
};
class CritterAI : public PassiveAI
{
public:
explicit CritterAI(Creature *c) : PassiveAI(c) {}
explicit CritterAI(Creature* c) : PassiveAI(c) {}
void DamageTaken(Unit *done_by, uint32 & /*damage*/);
void DamageTaken(Unit* done_by, uint32& /*damage*/);
void EnterEvadeMode();
};
class TriggerAI : public NullCreatureAI
{
public:
explicit TriggerAI(Creature *c) : NullCreatureAI(c) {}
void IsSummonedBy(Unit *summoner);
explicit TriggerAI(Creature* c) : NullCreatureAI(c) {}
void IsSummonedBy(Unit* summoner);
};
#endif

26
src/server/game/AI/CoreAI/PetAI.cpp
View File

@@ -30,7 +30,7 @@
#include "Group.h"
#include "SpellInfo.h"
int PetAI::Permissible(const Creature *creature)
int PetAI::Permissible(const Creature* creature)
{
if (creature->isPet())
return PERMIT_BASE_SPECIAL;
@@ -38,7 +38,7 @@ int PetAI::Permissible(const Creature *creature)
return PERMIT_BASE_NO;
}
PetAI::PetAI(Creature *c) : CreatureAI(c), i_tracker(TIME_INTERVAL_LOOK)
PetAI::PetAI(Creature* c) : CreatureAI(c), i_tracker(TIME_INTERVAL_LOOK)
{
m_AllySet.clear();
UpdateAllies();
@@ -107,7 +107,7 @@ void PetAI::UpdateAI(const uint32 diff)
}
else if (owner && me->GetCharmInfo()) //no victim
{
Unit *nextTarget = SelectNextTarget();
Unit* nextTarget = SelectNextTarget();
if (me->HasReactState(REACT_PASSIVE))
_stopAttack();
@@ -134,7 +134,7 @@ void PetAI::UpdateAI(const uint32 diff)
if (!spellID)
continue;
SpellInfo const *spellInfo = sSpellMgr->GetSpellInfo(spellID);
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellID);
if (!spellInfo)
continue;
@@ -239,30 +239,30 @@ void PetAI::UpdateAI(const uint32 diff)
void PetAI::UpdateAllies()
{
Unit* owner = me->GetCharmerOrOwner();
Group *pGroup = NULL;
Group* group = NULL;
m_updateAlliesTimer = 10*IN_MILLISECONDS; //update friendly targets every 10 seconds, lesser checks increase performance
if (!owner)
return;
else if (owner->GetTypeId() == TYPEID_PLAYER)
pGroup = owner->ToPlayer()->GetGroup();
group = owner->ToPlayer()->GetGroup();
//only pet and owner/not in group->ok
if (m_AllySet.size() == 2 && !pGroup)
if (m_AllySet.size() == 2 && !group)
return;
//owner is in group; group members filled in already (no raid -> subgroupcount = whole count)
if (pGroup && !pGroup->isRaidGroup() && m_AllySet.size() == (pGroup->GetMembersCount() + 2))
if (group && !group->isRaidGroup() && m_AllySet.size() == (group->GetMembersCount() + 2))
return;
m_AllySet.clear();
m_AllySet.insert(me->GetGUID());
if (pGroup) //add group
if (group) //add group
{
for (GroupReference *itr = pGroup->GetFirstMember(); itr != NULL; itr = itr->next())
for (GroupReference *itr = group->GetFirstMember(); itr != NULL; itr = itr->next())
{
Player* Target = itr->getSource();
if (!Target || !pGroup->SameSubGroup((Player*)owner, Target))
if (!Target || !group->SameSubGroup((Player*)owner, Target))
continue;
if (Target->GetGUID() == owner->GetGUID())
@@ -289,7 +289,7 @@ void PetAI::KilledUnit(Unit* victim)
me->AttackStop();
me->GetCharmInfo()->SetIsCommandAttack(false);
Unit *nextTarget = SelectNextTarget();
Unit* nextTarget = SelectNextTarget();
if (nextTarget)
AttackStart(nextTarget);
@@ -310,7 +310,7 @@ void PetAI::AttackStart(Unit* target)
DoAttack(target, true);
}
Unit *PetAI::SelectNextTarget()
Unit* PetAI::SelectNextTarget()
{
// Provides next target selection after current target death

8
src/server/game/AI/CoreAI/PetAI.h
View File

@@ -29,20 +29,20 @@ class PetAI : public CreatureAI
{
public:
explicit PetAI(Creature *c);
explicit PetAI(Creature* c);
void EnterEvadeMode();
void JustDied(Unit* /*who*/) { _stopAttack(); }
void UpdateAI(const uint32);
static int Permissible(const Creature *);
static int Permissible(const Creature*);
void KilledUnit(Unit* /*victim*/);
void AttackStart(Unit* target);
void MovementInform(uint32 moveType, uint32 data);
private:
bool _isVisible(Unit *) const;
bool _isVisible(Unit*) const;
bool _needToStop(void);
void _stopAttack(void);
@@ -54,7 +54,7 @@ class PetAI : public CreatureAI
std::set<uint64> m_AllySet;
uint32 m_updateAlliesTimer;
Unit *SelectNextTarget();
Unit* SelectNextTarget();
void HandleReturnMovement();
void DoAttack(Unit* target, bool chase);
bool _CanAttack(Unit* target);

4
src/server/game/AI/CoreAI/ReactorAI.cpp
View File

@@ -26,7 +26,7 @@
#define REACTOR_VISIBLE_RANGE (26.46f)
int
ReactorAI::Permissible(const Creature *creature)
ReactorAI::Permissible(const Creature* creature)
{
if (creature->isCivilian() || creature->IsNeutralToAll())
return PERMIT_BASE_REACTIVE;
@@ -35,7 +35,7 @@ ReactorAI::Permissible(const Creature *creature)
}
void
ReactorAI::MoveInLineOfSight(Unit *)
ReactorAI::MoveInLineOfSight(Unit*)
{
}

6
src/server/game/AI/CoreAI/ReactorAI.h
View File

@@ -27,12 +27,12 @@ class ReactorAI : public CreatureAI
{
public:
explicit ReactorAI(Creature *c) : CreatureAI(c) {}
explicit ReactorAI(Creature* c) : CreatureAI(c) {}
void MoveInLineOfSight(Unit *);
void MoveInLineOfSight(Unit*);
void UpdateAI(const uint32);
static int Permissible(const Creature *);
static int Permissible(const Creature*);
};
#endif

10
src/server/game/AI/CoreAI/TotemAI.cpp
View File

@@ -28,7 +28,7 @@
#include "CellImpl.h"
int
TotemAI::Permissible(const Creature *creature)
TotemAI::Permissible(const Creature* creature)
{
if (creature->isTotem())
return PERMIT_BASE_PROACTIVE;
@@ -36,13 +36,13 @@ TotemAI::Permissible(const Creature *creature)
return PERMIT_BASE_NO;
}
TotemAI::TotemAI(Creature *c) : CreatureAI(c), i_victimGuid(0)
TotemAI::TotemAI(Creature* c) : CreatureAI(c), i_victimGuid(0)
{
ASSERT(c->isTotem());
}
void
TotemAI::MoveInLineOfSight(Unit *)
TotemAI::MoveInLineOfSight(Unit*)
{
}
@@ -61,7 +61,7 @@ TotemAI::UpdateAI(const uint32 /*diff*/)
return;
// Search spell
SpellInfo const *spellInfo = sSpellMgr->GetSpellInfo(me->ToTotem()->GetSpell());
SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(me->ToTotem()->GetSpell());
if (!spellInfo)
return;
@@ -99,7 +99,7 @@ TotemAI::UpdateAI(const uint32 /*diff*/)
}
void
TotemAI::AttackStart(Unit *)
TotemAI::AttackStart(Unit*)
{
// Sentry totem sends ping on attack
if (me->GetEntry() == SENTRY_TOTEM_ENTRY && me->GetOwner()->GetTypeId() == TYPEID_PLAYER)

8
src/server/game/AI/CoreAI/TotemAI.h
View File

@@ -29,14 +29,14 @@ class TotemAI : public CreatureAI
{
public:
explicit TotemAI(Creature *c);
explicit TotemAI(Creature* c);
void MoveInLineOfSight(Unit *);
void AttackStart(Unit *);
void MoveInLineOfSight(Unit*);
void AttackStart(Unit*);
void EnterEvadeMode();
void UpdateAI(const uint32);
static int Permissible(const Creature *);
static int Permissible(const Creature*);
private:
uint64 i_victimGuid;

24
src/server/game/AI/CoreAI/UnitAI.cpp
View File

@@ -91,7 +91,7 @@ Unit* UnitAI::SelectTarget(SelectAggroTarget targetType, uint32 position, float
return SelectTarget(targetType, position, DefaultTargetSelector(me, dist, playerOnly, aura));
}
void UnitAI::SelectTargetList(std::list<Unit*> &targetList, uint32 num, SelectAggroTarget targetType, float dist, bool playerOnly, int32 aura)
void UnitAI::SelectTargetList(std::list<Unit*>& targetList, uint32 num, SelectAggroTarget targetType, float dist, bool playerOnly, int32 aura)
{
SelectTargetList(targetList, DefaultTargetSelector(me, dist, playerOnly, aura), num, targetType);
}
@@ -109,9 +109,9 @@ void UnitAI::DoAddAuraToAllHostilePlayers(uint32 spellid)
std::list<HostileReference*>& threatlist = me->getThreatManager().getThreatList();
for (std::list<HostileReference*>::iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
{
if (Unit *pTemp = Unit::GetUnit(*me, (*itr)->getUnitGuid()))
if (pTemp->GetTypeId() == TYPEID_PLAYER)
me->AddAura(spellid, pTemp);
if (Unit* unit = Unit::GetUnit(*me, (*itr)->getUnitGuid()))
if (unit->GetTypeId() == TYPEID_PLAYER)
me->AddAura(spellid, unit);
}
}else
return;
@@ -124,9 +124,9 @@ void UnitAI::DoCastToAllHostilePlayers(uint32 spellid, bool triggered)
std::list<HostileReference*>& threatlist = me->getThreatManager().getThreatList();
for (std::list<HostileReference*>::iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
{
if (Unit *pTemp = Unit::GetUnit(*me, (*itr)->getUnitGuid()))
if (pTemp->GetTypeId() == TYPEID_PLAYER)
me->CastSpell(pTemp, spellid, triggered);
if (Unit* unit = Unit::GetUnit(*me, (*itr)->getUnitGuid()))
if (unit->GetTypeId() == TYPEID_PLAYER)
me->CastSpell(unit, spellid, triggered);
}
}else
return;
@@ -143,7 +143,7 @@ void UnitAI::DoCast(uint32 spellId)
case AITARGET_VICTIM: target = me->getVictim(); break;
case AITARGET_ENEMY:
{
const SpellInfo * spellInfo = sSpellMgr->GetSpellInfo(spellId);
const SpellInfo* spellInfo = sSpellMgr->GetSpellInfo(spellId);
bool playerOnly = spellInfo->AttributesEx3 & SPELL_ATTR3_ONLY_TARGET_PLAYERS;
//float range = GetSpellMaxRange(spellInfo, false);
target = SelectTarget(SELECT_TARGET_RANDOM, 0, spellInfo->GetMaxRange(false), playerOnly);
@@ -153,7 +153,7 @@ void UnitAI::DoCast(uint32 spellId)
case AITARGET_BUFF: target = me; break;
case AITARGET_DEBUFF:
{
const SpellInfo * spellInfo = sSpellMgr->GetSpellInfo(spellId);
const SpellInfo* spellInfo = sSpellMgr->GetSpellInfo(spellId);
bool playerOnly = spellInfo->AttributesEx3 & SPELL_ATTR3_ONLY_TARGET_PLAYERS;
float range = spellInfo->GetMaxRange(false);
@@ -178,8 +178,8 @@ void UnitAI::FillAISpellInfo()
{
AISpellInfo = new AISpellInfoType[sSpellMgr->GetSpellInfoStoreSize()];
AISpellInfoType *AIInfo = AISpellInfo;
const SpellInfo * spellInfo;
AISpellInfoType* AIInfo = AISpellInfo;
const SpellInfo* spellInfo;
for (uint32 i = 0; i < sSpellMgr->GetSpellInfoStoreSize(); ++i, ++AIInfo)
{
@@ -230,7 +230,7 @@ void PlayerAI::OnCharmed(bool apply) { me->IsAIEnabled = apply; }
void SimpleCharmedAI::UpdateAI(const uint32 /*diff*/)
{
Creature *charmer = me->GetCharmer()->ToCreature();
Creature* charmer = me->GetCharmer()->ToCreature();
//kill self if charm aura has infinite duration
if (charmer->IsInEvadeMode())

10
src/server/game/AI/CoreAI/UnitAI.h
View File

@@ -60,7 +60,7 @@ struct DefaultTargetSelector : public std::unary_function<Unit* , bool>
// dist: if 0: ignored, if > 0: maximum distance to the reference unit, if < 0: minimum distance to the reference unit
// playerOnly: self explaining
// aura: if 0: ignored, if > 0: the target shall have the aura, if < 0, the target shall NOT have the aura
DefaultTargetSelector(Unit const* pUnit, float dist, bool playerOnly, int32 aura) : me(pUnit), m_dist(dist), m_playerOnly(playerOnly), m_aura(aura) {}
DefaultTargetSelector(Unit const* unit, float dist, bool playerOnly, int32 aura) : me(unit), m_dist(dist), m_playerOnly(playerOnly), m_aura(aura) {}
bool operator()(Unit const* target) const
{
@@ -128,7 +128,7 @@ class UnitAI
// predicate shall extend std::unary_function<Unit* , bool>
template <class PREDICATE> Unit* SelectTarget(SelectAggroTarget targetType, uint32 position, PREDICATE const& predicate)
{
const std::list<HostileReference* > &threatlist = me->getThreatManager().getThreatList();
const std::list<HostileReference*>& threatlist = me->getThreatManager().getThreatList();
if (position >= threatlist.size())
return NULL;
@@ -172,11 +172,11 @@ class UnitAI
return NULL;
}
void SelectTargetList(std::list<Unit*> &targetList, uint32 num, SelectAggroTarget targetType, float dist = 0.0f, bool playerOnly = false, int32 aura = 0);
void SelectTargetList(std::list<Unit*>& targetList, uint32 num, SelectAggroTarget targetType, float dist = 0.0f, bool playerOnly = false, int32 aura = 0);
// Select the targets satifying the predicate.
// predicate shall extend std::unary_function<Unit* , bool>
template <class PREDICATE> void SelectTargetList(std::list<Unit*> &targetList, PREDICATE const& predicate, uint32 maxTargets, SelectAggroTarget targetType)
template <class PREDICATE> void SelectTargetList(std::list<Unit*>& targetList, PREDICATE const& predicate, uint32 maxTargets, SelectAggroTarget targetType)
{
std::list<HostileReference*> const& threatlist = me->getThreatManager().getThreatList();
if (threatlist.empty())
@@ -247,7 +247,7 @@ class PlayerAI : public UnitAI
protected:
Player* const me;
public:
explicit PlayerAI(Player* p) : UnitAI((Unit*)p), me(p) {}
explicit PlayerAI(Player* player) : UnitAI((Unit*)player), me(player) {}
void OnCharmed(bool apply);
};

32
src/server/game/AI/CreatureAI.cpp
View File

@@ -34,8 +34,8 @@ void CreatureAI::OnCharmed(bool /*apply*/)
me->IsAIEnabled = false;
}
AISpellInfoType * UnitAI::AISpellInfo;
AISpellInfoType * GetAISpellInfo(uint32 i) { return &CreatureAI::AISpellInfo[i]; }
AISpellInfoType* UnitAI::AISpellInfo;
AISpellInfoType* GetAISpellInfo(uint32 i) { return &CreatureAI::AISpellInfo[i]; }
void CreatureAI::Talk(uint8 id, uint64 WhisperGuid)
{
@@ -50,7 +50,7 @@ void CreatureAI::DoZoneInCombat(Creature* creature /*= NULL*/)
if (!creature->CanHaveThreatList())
return;
Map *map = creature->GetMap();
Map* map = creature->GetMap();
if (!map->IsDungeon()) //use IsDungeon instead of Instanceable, in case battlegrounds will be instantiated
{
sLog->outError("DoZoneInCombat call for map that isn't an instance (creature entry = %d)", creature->GetTypeId() == TYPEID_UNIT ? creature->ToCreature()->GetEntry() : 0);
@@ -63,7 +63,7 @@ void CreatureAI::DoZoneInCombat(Creature* creature /*= NULL*/)
creature->AI()->AttackStart(target);
else if (creature->isSummon())
{
if (Unit *summoner = creature->ToTempSummon()->GetSummoner())
if (Unit* summoner = creature->ToTempSummon()->GetSummoner())
{
Unit* target = summoner->getAttackerForHelper();
if (!target && summoner->CanHaveThreatList() && !summoner->getThreatManager().isThreatListEmpty())
@@ -80,23 +80,23 @@ void CreatureAI::DoZoneInCombat(Creature* creature /*= NULL*/)
return;
}
Map::PlayerList const &PlList = map->GetPlayers();
Map::PlayerList const& playerList = map->GetPlayers();
if (PlList.isEmpty())
if (playerList.isEmpty())
return;
for (Map::PlayerList::const_iterator i = PlList.begin(); i != PlList.end(); ++i)
for (Map::PlayerList::const_iterator itr = playerList.begin(); itr != playerList.end(); ++itr)
{
if (Player* pPlayer = i->getSource())
if (Player* player = itr->getSource())
{
if (pPlayer->isGameMaster())
if (player->isGameMaster())
continue;
if (pPlayer->isAlive())
if (player->isAlive())
{
creature->SetInCombatWith(pPlayer);
pPlayer->SetInCombatWith(creature);
creature->AddThreat(pPlayer, 0.0f);
creature->SetInCombatWith(player);
player->SetInCombatWith(creature);
creature->AddThreat(player, 0.0f);
}
/* Causes certain things to never leave the threat list (Priest Lightwell, etc):
@@ -112,7 +112,7 @@ void CreatureAI::DoZoneInCombat(Creature* creature /*= NULL*/)
// scripts does not take care about MoveInLineOfSight loops
// MoveInLineOfSight can be called inside another MoveInLineOfSight and cause stack overflow
void CreatureAI::MoveInLineOfSight_Safe(Unit *who)
void CreatureAI::MoveInLineOfSight_Safe(Unit* who)
{
if (m_MoveInLineOfSight_locked == true)
return;
@@ -121,7 +121,7 @@ void CreatureAI::MoveInLineOfSight_Safe(Unit *who)
m_MoveInLineOfSight_locked = false;
}
void CreatureAI::MoveInLineOfSight(Unit *who)
void CreatureAI::MoveInLineOfSight(Unit* who)
{
if (me->getVictim())
return;
@@ -146,7 +146,7 @@ void CreatureAI::EnterEvadeMode()
if (!me->GetVehicle()) // otherwise me will be in evade mode forever
{
if (Unit *owner = me->GetCharmerOrOwner())
if (Unit* owner = me->GetCharmerOrOwner())
{
me->GetMotionMaster()->Clear(false);
me->GetMotionMaster()->MoveFollow(owner, PET_FOLLOW_DIST, me->GetFollowAngle(), MOTION_SLOT_ACTIVE);

24
src/server/game/AI/CreatureAIFactory.h
View File

@@ -25,24 +25,24 @@
struct SelectableAI : public FactoryHolder<CreatureAI>, public Permissible<Creature>
{
SelectableAI(const char *id) : FactoryHolder<CreatureAI>(id) {}
SelectableAI(const char* id) : FactoryHolder<CreatureAI>(id) {}
};
template<class REAL_AI>
struct CreatureAIFactory : public SelectableAI
{
CreatureAIFactory(const char *name) : SelectableAI(name) {}
CreatureAIFactory(const char* name) : SelectableAI(name) {}
CreatureAI* Create(void *) const;
CreatureAI* Create(void*) const;
int Permit(const Creature *c) const { return REAL_AI::Permissible(c); }
int Permit(const Creature* c) const { return REAL_AI::Permissible(c); }
};
template<class REAL_AI>
inline CreatureAI*
CreatureAIFactory<REAL_AI>::Create(void *data) const
CreatureAIFactory<REAL_AI>::Create(void* data) const
{
Creature* creature = reinterpret_cast<Creature *>(data);
Creature* creature = reinterpret_cast<Creature*>(data);
return (new REAL_AI(creature));
}
@@ -53,24 +53,24 @@ typedef FactoryHolder<CreatureAI>::FactoryHolderRepository CreatureAIRepository;
//GO
struct SelectableGameObjectAI : public FactoryHolder<GameObjectAI>, public Permissible<GameObject>
{
SelectableGameObjectAI(const char *id) : FactoryHolder<GameObjectAI>(id) {}
SelectableGameObjectAI(const char* id) : FactoryHolder<GameObjectAI>(id) {}
};
template<class REAL_GO_AI>
struct GameObjectAIFactory : public SelectableGameObjectAI
{
GameObjectAIFactory(const char *name) : SelectableGameObjectAI(name) {}
GameObjectAIFactory(const char* name) : SelectableGameObjectAI(name) {}
GameObjectAI* Create(void *) const;
GameObjectAI* Create(void*) const;
int Permit(const GameObject *g) const { return REAL_GO_AI::Permissible(g); }
int Permit(const GameObject* g) const { return REAL_GO_AI::Permissible(g); }
};
template<class REAL_GO_AI>
inline GameObjectAI*
GameObjectAIFactory<REAL_GO_AI>::Create(void *data) const
GameObjectAIFactory<REAL_GO_AI>::Create(void* data) const
{
GameObject* go = reinterpret_cast<GameObject *>(data);
GameObject* go = reinterpret_cast<GameObject*>(data);
return (new REAL_GO_AI(go));
}

4
src/server/game/AI/CreatureAIImpl.h
View File

@@ -524,7 +524,7 @@ struct AISpellInfoType
float maxRange;
};
AISpellInfoType * GetAISpellInfo(uint32 i);
AISpellInfoType* GetAISpellInfo(uint32 i);
inline void CreatureAI::SetGazeOn(Unit* target)
{
@@ -615,7 +615,7 @@ inline void UnitAI::DoCastAOE(uint32 spellId, bool triggered)
me->CastSpell((Unit*)NULL, spellId, triggered);
}
inline Creature* CreatureAI::DoSummon(uint32 entry, const Position &pos, uint32 despawnTime, TempSummonType summonType)
inline Creature* CreatureAI::DoSummon(uint32 entry, const Position& pos, uint32 despawnTime, TempSummonType summonType)
{
return me->SummonCreature(entry, pos, summonType, despawnTime);
}

18
src/server/game/AI/CreatureAISelector.cpp
View File

@@ -28,9 +28,9 @@
namespace FactorySelector
{
CreatureAI* selectAI(Creature *creature)
CreatureAI* selectAI(Creature* creature)
{
const CreatureAICreator *ai_factory = NULL;
const CreatureAICreator* ai_factory = NULL;
CreatureAIRegistry& ai_registry(*CreatureAIRepository::instance());
if (creature->isPet())
@@ -77,11 +77,11 @@ namespace FactorySelector
{
int best_val = -1;
typedef CreatureAIRegistry::RegistryMapType RMT;
RMT const &l = ai_registry.GetRegisteredItems();
RMT const& l = ai_registry.GetRegisteredItems();
for (RMT::const_iterator iter = l.begin(); iter != l.end(); ++iter)
{
const CreatureAICreator *factory = iter->second;
const SelectableAI *p = dynamic_cast<const SelectableAI *>(factory);
const CreatureAICreator* factory = iter->second;
const SelectableAI* p = dynamic_cast<const SelectableAI*>(factory);
ASSERT(p != NULL);
int val = p->Permit(creature);
if (val > best_val)
@@ -99,11 +99,11 @@ namespace FactorySelector
return (ai_factory == NULL ? new NullCreatureAI(creature) : ai_factory->Create(creature));
}
MovementGenerator* selectMovementGenerator(Creature *creature)
MovementGenerator* selectMovementGenerator(Creature* creature)
{
MovementGeneratorRegistry& mv_registry(*MovementGeneratorRepository::instance());
ASSERT(creature->GetCreatureInfo() != NULL);
const MovementGeneratorCreator *mv_factory = mv_registry.GetRegistryItem(creature->GetDefaultMovementType());
const MovementGeneratorCreator* mv_factory = mv_registry.GetRegistryItem(creature->GetDefaultMovementType());
/* if (mv_factory == NULL)
{
@@ -128,9 +128,9 @@ namespace FactorySelector
}
GameObjectAI* SelectGameObjectAI(GameObject *go)
GameObjectAI* SelectGameObjectAI(GameObject* go)
{
const GameObjectAICreator *ai_factory = NULL;
const GameObjectAICreator* ai_factory = NULL;
GameObjectAIRegistry& ai_registry(*GameObjectAIRepository::instance());
ai_factory = ai_registry.GetRegistryItem(go->GetAIName());

6
src/server/game/AI/CreatureAISelector.h
View File

@@ -27,9 +27,9 @@ class GameObject;
namespace FactorySelector
{
CreatureAI* selectAI(Creature *);
MovementGenerator* selectMovementGenerator(Creature *);
GameObjectAI* SelectGameObjectAI(GameObject *);
CreatureAI* selectAI(Creature*);
MovementGenerator* selectMovementGenerator(Creature*);
GameObjectAI* SelectGameObjectAI(GameObject*);
}
#endif

268
src/server/game/AI/EventAI/CreatureEventAI.cpp
View File

@@ -48,14 +48,14 @@ bool CreatureEventAIHolder::UpdateRepeatTimer(Creature* creature, uint32 repeatM
return true;
}
int CreatureEventAI::Permissible(const Creature *creature)
int CreatureEventAI::Permissible(const Creature* creature)
{
if (creature->GetAIName() == "EventAI")
return PERMIT_BASE_SPECIAL;
return PERMIT_BASE_NO;
}
CreatureEventAI::CreatureEventAI(Creature *c) : CreatureAI(c)
CreatureEventAI::CreatureEventAI(Creature* c) : CreatureAI(c)
{
// Need make copy for filter unneeded steps and safe in case table reload
CreatureEventAI_Event_Map::const_iterator CreatureEvents = sEventAIMgr->GetCreatureEventAIMap().find(me->GetEntry());
@@ -106,16 +106,16 @@ CreatureEventAI::CreatureEventAI(Creature *c) : CreatureAI(c)
}
}
bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pActionInvoker /*=NULL*/)
bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& holder, Unit* actionInvoker /*=NULL*/)
{
if (!pHolder.Enabled || pHolder.Time)
if (!holder.Enabled || holder.Time)
return false;
//Check the inverse phase mask (event doesn't trigger if current phase bit is set in mask)
if (pHolder.Event.event_inverse_phase_mask & (1 << m_Phase))
if (holder.Event.event_inverse_phase_mask & (1 << m_Phase))
return false;
CreatureEventAI_Event const& event = pHolder.Event;
CreatureEventAI_Event const& event = holder.Event;
//Check event conditions based on the event type, also reset events
switch (event.event_type)
@@ -125,14 +125,14 @@ bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pAction
return false;
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.timer.repeatMin, event.timer.repeatMax);
holder.UpdateRepeatTimer(me, event.timer.repeatMin, event.timer.repeatMax);
break;
case EVENT_T_TIMER_OOC:
if (me->isInCombat())
return false;
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.timer.repeatMin, event.timer.repeatMax);
holder.UpdateRepeatTimer(me, event.timer.repeatMin, event.timer.repeatMax);
break;
case EVENT_T_HP:
{
@@ -145,7 +145,7 @@ bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pAction
return false;
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);
holder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);
break;
}
case EVENT_T_MANA:
@@ -159,14 +159,14 @@ bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pAction
return false;
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);
holder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);
break;
}
case EVENT_T_AGGRO:
break;
case EVENT_T_KILL:
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.kill.repeatMin, event.kill.repeatMax);
holder.UpdateRepeatTimer(me, event.kill.repeatMin, event.kill.repeatMax);
break;
case EVENT_T_DEATH:
case EVENT_T_EVADE:
@@ -175,15 +175,15 @@ bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pAction
//Spell hit is special case, param1 and param2 handled within CreatureEventAI::SpellHit
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.spell_hit.repeatMin, event.spell_hit.repeatMax);
holder.UpdateRepeatTimer(me, event.spell_hit.repeatMin, event.spell_hit.repeatMax);
break;
case EVENT_T_RANGE:
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.range.repeatMin, event.range.repeatMax);
holder.UpdateRepeatTimer(me, event.range.repeatMin, event.range.repeatMax);
break;
case EVENT_T_OOC_LOS:
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.ooc_los.repeatMin, event.ooc_los.repeatMax);
holder.UpdateRepeatTimer(me, event.ooc_los.repeatMin, event.ooc_los.repeatMax);
break;
case EVENT_T_RESET:
case EVENT_T_SPAWNED:
@@ -199,7 +199,7 @@ bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pAction
return false;
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);
holder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);
break;
}
case EVENT_T_TARGET_CASTING:
@@ -207,21 +207,21 @@ bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pAction
return false;
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.target_casting.repeatMin, event.target_casting.repeatMax);
holder.UpdateRepeatTimer(me, event.target_casting.repeatMin, event.target_casting.repeatMax);
break;
case EVENT_T_FRIENDLY_HP:
{
if (!me->isInCombat())
return false;
Unit* pUnit = DoSelectLowestHpFriendly((float)event.friendly_hp.radius, event.friendly_hp.hpDeficit);
if (!pUnit)
Unit* unit = DoSelectLowestHpFriendly((float)event.friendly_hp.radius, event.friendly_hp.hpDeficit);
if (!unit)
return false;
pActionInvoker = pUnit;
actionInvoker = unit;
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.friendly_hp.repeatMin, event.friendly_hp.repeatMax);
holder.UpdateRepeatTimer(me, event.friendly_hp.repeatMin, event.friendly_hp.repeatMax);
break;
}
case EVENT_T_FRIENDLY_IS_CC:
@@ -237,10 +237,10 @@ bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pAction
return false;
//We don't really care about the whole list, just return first available
pActionInvoker = *(pList.begin());
actionInvoker = *(pList.begin());
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.friendly_is_cc.repeatMin, event.friendly_is_cc.repeatMax);
holder.UpdateRepeatTimer(me, event.friendly_is_cc.repeatMin, event.friendly_is_cc.repeatMax);
break;
}
case EVENT_T_FRIENDLY_MISSING_BUFF:
@@ -253,24 +253,24 @@ bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pAction
return false;
//We don't really care about the whole list, just return first available
pActionInvoker = *(pList.begin());
actionInvoker = *(pList.begin());
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.friendly_buff.repeatMin, event.friendly_buff.repeatMax);
holder.UpdateRepeatTimer(me, event.friendly_buff.repeatMin, event.friendly_buff.repeatMax);
break;
}
case EVENT_T_SUMMONED_UNIT:
{
//Prevent event from occuring on no unit or non creatures
if (!pActionInvoker || pActionInvoker->GetTypeId() != TYPEID_UNIT)
if (!actionInvoker || actionInvoker->GetTypeId() != TYPEID_UNIT)
return false;
//Creature id doesn't match up
if (pActionInvoker->ToCreature()->GetEntry() != event.summon_unit.creatureId)
if (actionInvoker->ToCreature()->GetEntry() != event.summon_unit.creatureId)
return false;
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.summon_unit.repeatMin, event.summon_unit.repeatMax);
holder.UpdateRepeatTimer(me, event.summon_unit.repeatMin, event.summon_unit.repeatMax);
break;
}
case EVENT_T_TARGET_MANA:
@@ -284,7 +284,7 @@ bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pAction
return false;
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);
holder.UpdateRepeatTimer(me, event.percent_range.repeatMin, event.percent_range.repeatMax);
break;
}
case EVENT_T_REACHED_HOME:
@@ -299,49 +299,49 @@ bool CreatureEventAI::ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pAction
return false;
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.buffed.repeatMin, event.buffed.repeatMax);
holder.UpdateRepeatTimer(me, event.buffed.repeatMin, event.buffed.repeatMax);
break;
}
case EVENT_T_TARGET_BUFFED:
{
//Prevent event from occuring on no unit
if (!pActionInvoker)
if (!actionInvoker)
return false;
//Note: checked only aura for effect 0, if need check aura for effect 1/2 then
// possible way: pack in event.buffed.amount 2 uint16 (ammount+effectIdx)
Aura const* aura = pActionInvoker->GetAura(event.buffed.spellId);
Aura const* aura = actionInvoker->GetAura(event.buffed.spellId);
if (!aura || aura->GetStackAmount() < event.buffed.amount)
return false;
//Repeat Timers
pHolder.UpdateRepeatTimer(me, event.buffed.repeatMin, event.buffed.repeatMax);
holder.UpdateRepeatTimer(me, event.buffed.repeatMin, event.buffed.repeatMax);
break;
}
default:
sLog->outErrorDb("CreatureEventAI: Creature %u using Event %u has invalid Event Type(%u), missing from ProcessEvent() Switch.", me->GetEntry(), pHolder.Event.event_id, pHolder.Event.event_type);
sLog->outErrorDb("CreatureEventAI: Creature %u using Event %u has invalid Event Type(%u), missing from ProcessEvent() Switch.", me->GetEntry(), holder.Event.event_id, holder.Event.event_type);
break;
}
//Disable non-repeatable events
if (!(pHolder.Event.event_flags & EFLAG_REPEATABLE))
pHolder.Enabled = false;
if (!(holder.Event.event_flags & EFLAG_REPEATABLE))
holder.Enabled = false;
//Store random here so that all random actions match up
uint32 rnd = rand();
//Return if chance for event is not met
if (pHolder.Event.event_chance <= rnd % 100)
if (holder.Event.event_chance <= rnd % 100)
return false;
//Process actions
for (uint8 j = 0; j < MAX_ACTIONS; ++j)
ProcessAction(pHolder.Event.action[j], rnd, pHolder.Event.event_id, pActionInvoker);
ProcessAction(holder.Event.action[j], rnd, holder.Event.event_id, actionInvoker);
return true;
}
void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32 rnd, uint32 EventId, Unit* pActionInvoker)
void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32 rnd, uint32 eventId, Unit* actionInvoker)
{
switch (action.type)
{
@@ -361,11 +361,11 @@ void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32
{
Unit* target = NULL;
if (pActionInvoker)
if (actionInvoker)
{
if (pActionInvoker->GetTypeId() == TYPEID_PLAYER)
target = pActionInvoker;
else if (Unit* owner = pActionInvoker->GetOwner())
if (actionInvoker->GetTypeId() == TYPEID_PLAYER)
target = actionInvoker;
else if (Unit* owner = actionInvoker->GetOwner())
{
if (owner->GetTypeId() == TYPEID_PLAYER)
target = owner;
@@ -442,7 +442,7 @@ void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32
}
case ACTION_T_CAST:
{
Unit* target = GetTargetByType(action.cast.target, pActionInvoker);
Unit* target = GetTargetByType(action.cast.target, actionInvoker);
Unit* caster = me;
if (!target)
@@ -496,29 +496,29 @@ void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32
}
else
sLog->outErrorDb("CreatureEventAI: event %d creature %d attempt to cast spell that doesn't exist %d", EventId, me->GetEntry(), action.cast.spellId);
sLog->outErrorDb("CreatureEventAI: event %d creature %d attempt to cast spell that doesn't exist %d", eventId, me->GetEntry(), action.cast.spellId);
}
break;
}
case ACTION_T_SUMMON:
{
Unit* target = GetTargetByType(action.summon.target, pActionInvoker);
Unit* target = GetTargetByType(action.summon.target, actionInvoker);
Creature* pCreature = NULL;
Creature* creature = NULL;
if (action.summon.duration)
pCreature = me->SummonCreature(action.summon.creatureId, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, action.summon.duration);
creature = me->SummonCreature(action.summon.creatureId, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, action.summon.duration);
else
pCreature = me->SummonCreature(action.summon.creatureId, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 0);
creature = me->SummonCreature(action.summon.creatureId, 0.0f, 0.0f, 0.0f, 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 0);
if (!pCreature)
sLog->outErrorDb("CreatureEventAI: failed to spawn creature %u. Spawn event %d is on creature %d", action.summon.creatureId, EventId, me->GetEntry());
if (!creature)
sLog->outErrorDb("CreatureEventAI: failed to spawn creature %u. Spawn event %d is on creature %d", action.summon.creatureId, eventId, me->GetEntry());
else if (action.summon.target != TARGET_T_SELF && target)
pCreature->AI()->AttackStart(target);
creature->AI()->AttackStart(target);
break;
}
case ACTION_T_THREAT_SINGLE_PCT:
if (Unit* target = GetTargetByType(action.threat_single_pct.target, pActionInvoker))
if (Unit* target = GetTargetByType(action.threat_single_pct.target, actionInvoker))
me->getThreatManager().modifyThreatPercent(target, action.threat_single_pct.percent);
break;
case ACTION_T_THREAT_ALL_PCT:
@@ -530,18 +530,18 @@ void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32
break;
}
case ACTION_T_QUEST_EVENT:
if (Unit* target = GetTargetByType(action.quest_event.target, pActionInvoker))
if (Unit* target = GetTargetByType(action.quest_event.target, actionInvoker))
if (target->GetTypeId() == TYPEID_PLAYER)
target->ToPlayer()->AreaExploredOrEventHappens(action.quest_event.questId);
break;
case ACTION_T_CAST_EVENT:
if (Unit* target = GetTargetByType(action.cast_event.target, pActionInvoker))
if (Unit* target = GetTargetByType(action.cast_event.target, actionInvoker))
if (target->GetTypeId() == TYPEID_PLAYER)
target->ToPlayer()->CastedCreatureOrGO(action.cast_event.creatureId, me->GetGUID(), action.cast_event.spellId);
break;
case ACTION_T_SET_UNIT_FIELD:
{
Unit* target = GetTargetByType(action.set_unit_field.target, pActionInvoker);
Unit* target = GetTargetByType(action.set_unit_field.target, actionInvoker);
// not allow modify important for integrity object fields
if (action.set_unit_field.field < OBJECT_END || action.set_unit_field.field >= UNIT_END)
@@ -553,11 +553,11 @@ void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32
break;
}
case ACTION_T_SET_UNIT_FLAG:
if (Unit* target = GetTargetByType(action.unit_flag.target, pActionInvoker))
if (Unit* target = GetTargetByType(action.unit_flag.target, actionInvoker))
target->SetFlag(UNIT_FIELD_FLAGS, action.unit_flag.value);
break;
case ACTION_T_REMOVE_UNIT_FLAG:
if (Unit* target = GetTargetByType(action.unit_flag.target, pActionInvoker))
if (Unit* target = GetTargetByType(action.unit_flag.target, actionInvoker))
target->RemoveFlag(UNIT_FIELD_FLAGS, action.unit_flag.value);
break;
case ACTION_T_AUTO_ATTACK:
@@ -608,12 +608,12 @@ void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32
int32 new_phase = int32(m_Phase)+action.set_inc_phase.step;
if (new_phase < 0)
{
sLog->outErrorDb("CreatureEventAI: Event %d decrease m_Phase under 0. CreatureEntry = %d", EventId, me->GetEntry());
sLog->outErrorDb("CreatureEventAI: Event %d decrease m_Phase under 0. CreatureEntry = %d", eventId, me->GetEntry());
m_Phase = 0;
}
else if (new_phase >= MAX_PHASE)
{
sLog->outErrorDb("CreatureEventAI: Event %d incremented m_Phase above %u. m_Phase mask cannot be used with phases past %u. CreatureEntry = %d", EventId, MAX_PHASE-1, MAX_PHASE-1, me->GetEntry());
sLog->outErrorDb("CreatureEventAI: Event %d incremented m_Phase above %u. m_Phase mask cannot be used with phases past %u. CreatureEntry = %d", eventId, MAX_PHASE-1, MAX_PHASE-1, me->GetEntry());
m_Phase = MAX_PHASE-1;
}
else
@@ -628,9 +628,9 @@ void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32
me->DoFleeToGetAssistance();
break;
case ACTION_T_QUEST_EVENT_ALL:
if (pActionInvoker && pActionInvoker->GetTypeId() == TYPEID_PLAYER)
if (actionInvoker && actionInvoker->GetTypeId() == TYPEID_PLAYER)
{
if (Unit* Temp = Unit::GetUnit(*me, pActionInvoker->GetGUID()))
if (Unit* Temp = Unit::GetUnit(*me, actionInvoker->GetGUID()))
if (Temp->GetTypeId() == TYPEID_PLAYER)
Temp->ToPlayer()->GroupEventHappens(action.quest_event_all.questId, me);
}
@@ -645,7 +645,7 @@ void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32
break;
}
case ACTION_T_REMOVEAURASFROMSPELL:
if (Unit* target = GetTargetByType(action.remove_aura.target, pActionInvoker))
if (Unit* target = GetTargetByType(action.remove_aura.target, actionInvoker))
target->RemoveAurasDueToSpell(action.remove_aura.spellId);
break;
case ACTION_T_RANGED_MOVEMENT:
@@ -664,80 +664,80 @@ void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32
if (action.random_phase_range.phaseMin <= action.random_phase_range.phaseMax)
m_Phase = urand(action.random_phase_range.phaseMin, action.random_phase_range.phaseMax);
else
sLog->outErrorDb("CreatureEventAI: ACTION_T_RANDOM_PHASE_RANGE cannot have Param2 < Param1. Event = %d. CreatureEntry = %d", EventId, me->GetEntry());
sLog->outErrorDb("CreatureEventAI: ACTION_T_RANDOM_PHASE_RANGE cannot have Param2 < Param1. Event = %d. CreatureEntry = %d", eventId, me->GetEntry());
break;
case ACTION_T_SUMMON_ID:
{
Unit* target = GetTargetByType(action.summon_id.target, pActionInvoker);
Unit* target = GetTargetByType(action.summon_id.target, actionInvoker);
CreatureEventAI_Summon_Map::const_iterator i = sEventAIMgr->GetCreatureEventAISummonMap().find(action.summon_id.spawnId);
if (i == sEventAIMgr->GetCreatureEventAISummonMap().end())
{
sLog->outErrorDb("CreatureEventAI: failed to spawn creature %u. Summon map index %u does not exist. EventID %d. CreatureID %d", action.summon_id.creatureId, action.summon_id.spawnId, EventId, me->GetEntry());
sLog->outErrorDb("CreatureEventAI: failed to spawn creature %u. Summon map index %u does not exist. EventID %d. CreatureID %d", action.summon_id.creatureId, action.summon_id.spawnId, eventId, me->GetEntry());
return;
}
Creature* pCreature = NULL;
Creature* creature = NULL;
if ((*i).second.SpawnTimeSecs)
pCreature = me->SummonCreature(action.summon_id.creatureId, (*i).second.position_x, (*i).second.position_y, (*i).second.position_z, (*i).second.orientation, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, (*i).second.SpawnTimeSecs);
creature = me->SummonCreature(action.summon_id.creatureId, (*i).second.position_x, (*i).second.position_y, (*i).second.position_z, (*i).second.orientation, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, (*i).second.SpawnTimeSecs);
else
pCreature = me->SummonCreature(action.summon_id.creatureId, (*i).second.position_x, (*i).second.position_y, (*i).second.position_z, (*i).second.orientation, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 0);
creature = me->SummonCreature(action.summon_id.creatureId, (*i).second.position_x, (*i).second.position_y, (*i).second.position_z, (*i).second.orientation, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 0);
if (!pCreature)
sLog->outErrorDb("CreatureEventAI: failed to spawn creature %u. EventId %d.Creature %d", action.summon_id.creatureId, EventId, me->GetEntry());
if (!creature)
sLog->outErrorDb("CreatureEventAI: failed to spawn creature %u. EventId %d.Creature %d", action.summon_id.creatureId, eventId, me->GetEntry());
else if (action.summon_id.target != TARGET_T_SELF && target)
pCreature->AI()->AttackStart(target);
creature->AI()->AttackStart(target);
break;
}
case ACTION_T_KILLED_MONSTER:
//first attempt player who tapped creature
if (Player* pPlayer = me->GetLootRecipient())
pPlayer->RewardPlayerAndGroupAtEvent(action.killed_monster.creatureId, pPlayer); // pPlayer as param is a hacky solution not to use GUID
if (Player* player = me->GetLootRecipient())
player->RewardPlayerAndGroupAtEvent(action.killed_monster.creatureId, player); // player as param is a hacky solution not to use GUID
else
{
//if not available, use pActionInvoker
if (Unit* pTarget = GetTargetByType(action.killed_monster.target, pActionInvoker))
if (Player* pPlayer2 = pTarget->GetCharmerOrOwnerPlayerOrPlayerItself())
pPlayer2->RewardPlayerAndGroupAtEvent(action.killed_monster.creatureId, pPlayer2);
//if not available, use actionInvoker
if (Unit* target = GetTargetByType(action.killed_monster.target, actionInvoker))
if (Player* player2 = target->GetCharmerOrOwnerPlayerOrPlayerItself())
player2->RewardPlayerAndGroupAtEvent(action.killed_monster.creatureId, player2);
}
break;
case ACTION_T_SET_INST_DATA:
{
InstanceScript* pInst = (InstanceScript*)me->GetInstanceScript();
if (!pInst)
InstanceScript* instance = (InstanceScript*)me->GetInstanceScript();
if (!instance)
{
sLog->outErrorDb("CreatureEventAI: Event %d attempt to set instance data without instance script. Creature %d", EventId, me->GetEntry());
sLog->outErrorDb("CreatureEventAI: Event %d attempt to set instance data without instance script. Creature %d", eventId, me->GetEntry());
return;
}
pInst->SetData(action.set_inst_data.field, action.set_inst_data.value);
instance->SetData(action.set_inst_data.field, action.set_inst_data.value);
break;
}
case ACTION_T_SET_INST_DATA64:
{
Unit* target = GetTargetByType(action.set_inst_data64.target, pActionInvoker);
Unit* target = GetTargetByType(action.set_inst_data64.target, actionInvoker);
if (!target)
{
sLog->outErrorDb("CreatureEventAI: Event %d attempt to set instance data64 but Target == NULL. Creature %d", EventId, me->GetEntry());
sLog->outErrorDb("CreatureEventAI: Event %d attempt to set instance data64 but Target == NULL. Creature %d", eventId, me->GetEntry());
return;
}
InstanceScript* pInst = (InstanceScript*)me->GetInstanceScript();
if (!pInst)
InstanceScript* instance = (InstanceScript*)me->GetInstanceScript();
if (!instance)
{
sLog->outErrorDb("CreatureEventAI: Event %d attempt to set instance data64 without instance script. Creature %d", EventId, me->GetEntry());
sLog->outErrorDb("CreatureEventAI: Event %d attempt to set instance data64 without instance script. Creature %d", eventId, me->GetEntry());
return;
}
pInst->SetData64(action.set_inst_data64.field, target->GetGUID());
instance->SetData64(action.set_inst_data64.field, target->GetGUID());
break;
}
case ACTION_T_UPDATE_TEMPLATE:
if (me->GetEntry() == action.update_template.creatureId)
{
sLog->outErrorDb("CreatureEventAI: Event %d ACTION_T_UPDATE_TEMPLATE call with param1 == current entry. Creature %d", EventId, me->GetEntry());
sLog->outErrorDb("CreatureEventAI: Event %d ACTION_T_UPDATE_TEMPLATE call with param1 == current entry. Creature %d", eventId, me->GetEntry());
return;
}
@@ -747,7 +747,7 @@ void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32
if (me->isDead())
{
sLog->outErrorDb("CreatureEventAI: Event %d ACTION_T_DIE on dead creature. Creature %d", EventId, me->GetEntry());
sLog->outErrorDb("CreatureEventAI: Event %d ACTION_T_DIE on dead creature. Creature %d", eventId, me->GetEntry());
return;
}
me->Kill(me);
@@ -792,14 +792,14 @@ void CreatureEventAI::ProcessAction(CreatureEventAI_Action const& action, uint32
break;
case ACTION_T_SUMMON_GO:
{
GameObject* pObject = NULL;
GameObject* object = NULL;
float x, y, z;
me->GetPosition(x, y, z);
pObject = me->SummonGameObject(action.raw.param1, x, y, z, 0, 0, 0, 0, 0, action.raw.param2);
if (!pObject)
object = me->SummonGameObject(action.raw.param1, x, y, z, 0, 0, 0, 0, 0, action.raw.param2);
if (!object)
{
sLog->outErrorDb("TSCR: EventAI failed to spawn object %u. Spawn event %d is on creature %d", action.raw.param1, EventId, me->GetEntry());
sLog->outErrorDb("TSCR: EventAI failed to spawn object %u. Spawn event %d is on creature %d", action.raw.param1, eventId, me->GetEntry());
}
break;
}
@@ -955,19 +955,19 @@ void CreatureEventAI::KilledUnit(Unit* victim)
}
}
void CreatureEventAI::JustSummoned(Creature* pUnit)
void CreatureEventAI::JustSummoned(Creature* unit)
{
if (m_bEmptyList || !pUnit)
if (m_bEmptyList || !unit)
return;
for (CreatureEventAIList::iterator i = m_CreatureEventAIList.begin(); i != m_CreatureEventAIList.end(); ++i)
{
if ((*i).Event.event_type == EVENT_T_SUMMONED_UNIT)
ProcessEvent(*i, pUnit);
ProcessEvent(*i, unit);
}
}
void CreatureEventAI::EnterCombat(Unit *enemy)
void CreatureEventAI::EnterCombat(Unit* enemy)
{
//Check for on combat start events
if (!m_bEmptyList)
@@ -999,7 +999,7 @@ void CreatureEventAI::EnterCombat(Unit *enemy)
m_EventDiff = 0;
}
void CreatureEventAI::AttackStart(Unit *who)
void CreatureEventAI::AttackStart(Unit* who)
{
if (!who)
return;
@@ -1047,7 +1047,7 @@ void CreatureEventAI::MoveInLineOfSight(Unit *who)
CreatureAI::MoveInLineOfSight(who);
}
void CreatureEventAI::SpellHit(Unit* pUnit, const SpellInfo* pSpell)
void CreatureEventAI::SpellHit(Unit* unit, const SpellInfo* spell)
{
if (m_bEmptyList)
@@ -1056,9 +1056,9 @@ void CreatureEventAI::SpellHit(Unit* pUnit, const SpellInfo* pSpell)
for (CreatureEventAIList::iterator i = m_CreatureEventAIList.begin(); i != m_CreatureEventAIList.end(); ++i)
if ((*i).Event.event_type == EVENT_T_SPELLHIT)
//If spell id matches (or no spell id) & if spell school matches (or no spell school)
if (!(*i).Event.spell_hit.spellId || pSpell->Id == (*i).Event.spell_hit.spellId)
if (pSpell->SchoolMask & (*i).Event.spell_hit.schoolMask)
ProcessEvent(*i, pUnit);
if (!(*i).Event.spell_hit.spellId || spell->Id == (*i).Event.spell_hit.spellId)
if (spell->SchoolMask & (*i).Event.spell_hit.schoolMask)
ProcessEvent(*i, unit);
}
void CreatureEventAI::UpdateAI(const uint32 diff)
@@ -1152,9 +1152,9 @@ inline int32 CreatureEventAI::GetRandActionParam(uint32 rnd, int32 param1, int32
return 0;
}
inline Unit* CreatureEventAI::GetTargetByType(uint32 Target, Unit* pActionInvoker)
inline Unit* CreatureEventAI::GetTargetByType(uint32 target, Unit* actionInvoker)
{
switch (Target)
switch (target)
{
case TARGET_T_SELF:
return me;
@@ -1169,23 +1169,23 @@ inline Unit* CreatureEventAI::GetTargetByType(uint32 Target, Unit* pActionInvoke
case TARGET_T_HOSTILE_RANDOM_NOT_TOP:
return SelectTarget(SELECT_TARGET_RANDOM, 1);
case TARGET_T_ACTION_INVOKER:
return pActionInvoker;
return actionInvoker;
default:
return NULL;
};
}
Unit* CreatureEventAI::DoSelectLowestHpFriendly(float range, uint32 MinHPDiff)
Unit* CreatureEventAI::DoSelectLowestHpFriendly(float range, uint32 minHPDiff)
{
CellPair p(Trinity::ComputeCellPair(me->GetPositionX(), me->GetPositionY()));
Cell cell(p);
cell.data.Part.reserved = ALL_DISTRICT;
cell.SetNoCreate();
Unit* pUnit = NULL;
Unit* unit = NULL;
Trinity::MostHPMissingInRange u_check(me, range, MinHPDiff);
Trinity::UnitLastSearcher<Trinity::MostHPMissingInRange> searcher(me, pUnit, u_check);
Trinity::MostHPMissingInRange u_check(me, range, minHPDiff);
Trinity::UnitLastSearcher<Trinity::MostHPMissingInRange> searcher(me, unit, u_check);
/*
typedef TYPELIST_4(GameObject, Creature*except pets*, DynamicObject, Corpse*Bones*) AllGridObjectTypes;
@@ -1194,7 +1194,7 @@ Unit* CreatureEventAI::DoSelectLowestHpFriendly(float range, uint32 MinHPDiff)
TypeContainerVisitor<Trinity::UnitLastSearcher<Trinity::MostHPMissingInRange>, GridTypeMapContainer > grid_unit_searcher(searcher);
cell.Visit(p, grid_unit_searcher, *me->GetMap(), *me, range);
return pUnit;
return unit;
}
void CreatureEventAI::DoFindFriendlyCC(std::list<Creature*>& _list, float range)
@@ -1230,9 +1230,9 @@ void CreatureEventAI::DoFindFriendlyMissingBuff(std::list<Creature*>& _list, flo
// *********************************
// *** Functions used globally ***
void CreatureEventAI::DoScriptText(int32 textEntry, WorldObject* pSource, Unit* target)
void CreatureEventAI::DoScriptText(int32 textEntry, WorldObject* source, Unit* target)
{
if (!pSource)
if (!source)
{
sLog->outErrorDb("CreatureEventAI: DoScriptText entry %i, invalid Source pointer.", textEntry);
return;
@@ -1240,7 +1240,7 @@ void CreatureEventAI::DoScriptText(int32 textEntry, WorldObject* pSource, Unit*
if (textEntry >= 0)
{
sLog->outErrorDb("CreatureEventAI: DoScriptText with source entry %u (TypeId=%u, guid=%u) attempts to process text entry %i, but text entry must be negative.", pSource->GetEntry(), pSource->GetTypeId(), pSource->GetGUIDLow(), textEntry);
sLog->outErrorDb("CreatureEventAI: DoScriptText with source entry %u (TypeId=%u, guid=%u) attempts to process text entry %i, but text entry must be negative.", source->GetEntry(), source->GetTypeId(), source->GetGUIDLow(), textEntry);
return;
}
@@ -1248,7 +1248,7 @@ void CreatureEventAI::DoScriptText(int32 textEntry, WorldObject* pSource, Unit*
if (i == sEventAIMgr->GetCreatureEventAITextMap().end())
{
sLog->outErrorDb("CreatureEventAI: DoScriptText with source entry %u (TypeId=%u, guid=%u) could not find text entry %i.", pSource->GetEntry(), pSource->GetTypeId(), pSource->GetGUIDLow(), textEntry);
sLog->outErrorDb("CreatureEventAI: DoScriptText with source entry %u (TypeId=%u, guid=%u) could not find text entry %i.", source->GetEntry(), source->GetTypeId(), source->GetGUIDLow(), textEntry);
return;
}
@@ -1257,75 +1257,75 @@ void CreatureEventAI::DoScriptText(int32 textEntry, WorldObject* pSource, Unit*
if ((*i).second.SoundId)
{
if (GetSoundEntriesStore()->LookupEntry((*i).second.SoundId))
pSource->PlayDirectSound((*i).second.SoundId);
source->PlayDirectSound((*i).second.SoundId);
else
sLog->outErrorDb("CreatureEventAI: DoScriptText entry %i tried to process invalid sound id %u.", textEntry, (*i).second.SoundId);
}
if ((*i).second.Emote)
{
if (pSource->GetTypeId() == TYPEID_UNIT || pSource->GetTypeId() == TYPEID_PLAYER)
if (source->GetTypeId() == TYPEID_UNIT || source->GetTypeId() == TYPEID_PLAYER)
{
((Unit*)pSource)->HandleEmoteCommand((*i).second.Emote);
((Unit*)source)->HandleEmoteCommand((*i).second.Emote);
}
else
sLog->outErrorDb("CreatureEventAI: DoScriptText entry %i tried to process emote for invalid TypeId (%u).", textEntry, pSource->GetTypeId());
sLog->outErrorDb("CreatureEventAI: DoScriptText entry %i tried to process emote for invalid TypeId (%u).", textEntry, source->GetTypeId());
}
switch((*i).second.Type)
{
case CHAT_TYPE_SAY:
pSource->MonsterSay(textEntry, (*i).second.Language, target ? target->GetGUID() : 0);
source->MonsterSay(textEntry, (*i).second.Language, target ? target->GetGUID() : 0);
break;
case CHAT_TYPE_YELL:
pSource->MonsterYell(textEntry, (*i).second.Language, target ? target->GetGUID() : 0);
source->MonsterYell(textEntry, (*i).second.Language, target ? target->GetGUID() : 0);
break;
case CHAT_TYPE_TEXT_EMOTE:
pSource->MonsterTextEmote(textEntry, target ? target->GetGUID() : 0);
source->MonsterTextEmote(textEntry, target ? target->GetGUID() : 0);
break;
case CHAT_TYPE_BOSS_EMOTE:
pSource->MonsterTextEmote(textEntry, target ? target->GetGUID() : 0, true);
source->MonsterTextEmote(textEntry, target ? target->GetGUID() : 0, true);
break;
case CHAT_TYPE_WHISPER:
{
if (target && target->GetTypeId() == TYPEID_PLAYER)
pSource->MonsterWhisper(textEntry, target->GetGUID());
source->MonsterWhisper(textEntry, target->GetGUID());
else sLog->outErrorDb("CreatureEventAI: DoScriptText entry %i cannot whisper without target unit (TYPEID_PLAYER).", textEntry);
}break;
case CHAT_TYPE_BOSS_WHISPER:
{
if (target && target->GetTypeId() == TYPEID_PLAYER)
pSource->MonsterWhisper(textEntry, target->GetGUID(), true);
source->MonsterWhisper(textEntry, target->GetGUID(), true);
else sLog->outErrorDb("CreatureEventAI: DoScriptText entry %i cannot whisper without target unit (TYPEID_PLAYER).", textEntry);
}break;
case CHAT_TYPE_ZONE_YELL:
pSource->MonsterYellToZone(textEntry, (*i).second.Language, target ? target->GetGUID() : 0);
source->MonsterYellToZone(textEntry, (*i).second.Language, target ? target->GetGUID() : 0);
break;
}
}
bool CreatureEventAI::CanCast(Unit* Target, SpellInfo const *Spell, bool Triggered)
bool CreatureEventAI::CanCast(Unit* target, SpellInfo const* spell, bool triggered)
{
//No target so we can't cast
if (!Target || !Spell)
if (!target || !spell)
return false;
//Silenced so we can't cast
if (!Triggered && me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED))
if (!triggered && me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SILENCED))
return false;
//Check for power
if (!Triggered && me->GetPower((Powers)Spell->PowerType) < Spell->CalcPowerCost(me, Spell->GetSchoolMask()))
if (!triggered && me->GetPower((Powers)spell->PowerType) < spell->CalcPowerCost(me, spell->GetSchoolMask()))
return false;
//Unit is out of range of this spell
if (!me->IsInRange(Target, Spell->GetMinRange(false), Spell->GetMaxRange(false)))
if (!me->IsInRange(target, spell->GetMinRange(false), spell->GetMaxRange(false)))
return false;
return true;
}
void CreatureEventAI::ReceiveEmote(Player* pPlayer, uint32 text_emote)
void CreatureEventAI::ReceiveEmote(Player* player, uint32 textEmote)
{
if (m_bEmptyList)
return;
@@ -1334,7 +1334,7 @@ void CreatureEventAI::ReceiveEmote(Player* pPlayer, uint32 text_emote)
{
if ((*itr).Event.event_type == EVENT_T_RECEIVE_EMOTE)
{
if ((*itr).Event.receive_emote.emoteId != text_emote)
if ((*itr).Event.receive_emote.emoteId != textEmote)
return;
Condition cond;
@@ -1342,10 +1342,10 @@ void CreatureEventAI::ReceiveEmote(Player* pPlayer, uint32 text_emote)
cond.mConditionValue1 = (*itr).Event.receive_emote.conditionValue1;
cond.mConditionValue2 = (*itr).Event.receive_emote.conditionValue2;
if (cond.Meets(pPlayer))
if (cond.Meets(player))
{
sLog->outDebug(LOG_FILTER_DATABASE_AI, "CreatureEventAI: ReceiveEmote CreatureEventAI: Condition ok, processing");
ProcessEvent(*itr, pPlayer);
ProcessEvent(*itr, player);
}
}
}

28
src/server/game/AI/EventAI/CreatureEventAI.h
View File

@@ -591,7 +591,7 @@ class CreatureEventAI : public CreatureAI
{
public:
explicit CreatureEventAI(Creature *c);
explicit CreatureEventAI(Creature* c);
~CreatureEventAI()
{
m_CreatureEventAIList.clear();
@@ -599,32 +599,32 @@ class CreatureEventAI : public CreatureAI
void JustRespawned();
void Reset();
void JustReachedHome();
void EnterCombat(Unit *enemy);
void EnterCombat(Unit* enemy);
void EnterEvadeMode();
void JustDied(Unit* /*killer*/);
void KilledUnit(Unit* victim);
void JustSummoned(Creature* pUnit);
void AttackStart(Unit *who);
void MoveInLineOfSight(Unit *who);
void SpellHit(Unit* pUnit, const SpellInfo* pSpell);
void JustSummoned(Creature* unit);
void AttackStart(Unit* who);
void MoveInLineOfSight(Unit* who);
void SpellHit(Unit* unit, const SpellInfo* spell);
void DamageTaken(Unit* done_by, uint32& damage);
void HealReceived(Unit* /*done_by*/, uint32& /*addhealth*/) {}
void UpdateAI(const uint32 diff);
void ReceiveEmote(Player* pPlayer, uint32 text_emote);
static int Permissible(const Creature *);
void ReceiveEmote(Player* player, uint32 textEmote);
static int Permissible(const Creature*);
bool ProcessEvent(CreatureEventAIHolder& pHolder, Unit* pActionInvoker = NULL);
void ProcessAction(CreatureEventAI_Action const& action, uint32 rnd, uint32 EventId, Unit* pActionInvoker);
bool ProcessEvent(CreatureEventAIHolder& holder, Unit* actionInvoker = NULL);
void ProcessAction(CreatureEventAI_Action const& action, uint32 rnd, uint32 eventId, Unit* actionInvoker);
inline uint32 GetRandActionParam(uint32 rnd, uint32 param1, uint32 param2, uint32 param3);
inline int32 GetRandActionParam(uint32 rnd, int32 param1, int32 param2, int32 param3);
inline Unit* GetTargetByType(uint32 Target, Unit* pActionInvoker);
inline Unit* GetTargetByType(uint32 target, Unit* actionInvoker);
void DoScriptText(int32 textEntry, WorldObject* pSource, Unit* target);
bool CanCast(Unit* Target, SpellInfo const *Spell, bool Triggered);
void DoScriptText(int32 textEntry, WorldObject* source, Unit* target);
bool CanCast(Unit* target, SpellInfo const* spell, bool triggered);
bool SpawnedEventConditionsCheck(CreatureEventAI_Event const& event);
Unit* DoSelectLowestHpFriendly(float range, uint32 MinHPDiff);
Unit* DoSelectLowestHpFriendly(float range, uint32 minHPDiff);
void DoFindFriendlyMissingBuff(std::list<Creature*>& _list, float range, uint32 spellid);
void DoFindFriendlyCC(std::list<Creature*>& _list, float range);

20
src/server/game/AI/EventAI/CreatureEventAIMgr.cpp
View File

@@ -124,7 +124,7 @@ void CreatureEventAIMgr::LoadCreatureEventAI_Summons()
do
{
Field *fields = result->Fetch();
Field* fields = result->Fetch();
CreatureEventAI_Summon temp;
@@ -178,7 +178,7 @@ void CreatureEventAIMgr::LoadCreatureEventAI_Scripts()
do
{
Field *fields = result->Fetch();
Field* fields = result->Fetch();
CreatureEventAI_Event temp;
temp.event_id = EventAI_Type(fields[0].GetUInt32());
@@ -250,14 +250,14 @@ void CreatureEventAIMgr::LoadCreatureEventAI_Scripts()
case EVENT_T_SPELLHIT:
if (temp.spell_hit.spellId)
{
SpellInfo const* pSpell = sSpellMgr->GetSpellInfo(temp.spell_hit.spellId);
if (!pSpell)
SpellInfo const* spell = sSpellMgr->GetSpellInfo(temp.spell_hit.spellId);
if (!spell)
{
sLog->outErrorDb("CreatureEventAI: Creature %u has non-existant SpellID(%u) defined in event %u.", temp.creature_id, temp.spell_hit.spellId, i);
continue;
}
if ((temp.spell_hit.schoolMask & pSpell->SchoolMask) != pSpell->SchoolMask)
if ((temp.spell_hit.schoolMask & spell->SchoolMask) != spell->SchoolMask)
sLog->outErrorDb("CreatureEventAI: Creature %u has param1(spellId %u) but param2 is not -1 and not equal to spell's school mask. Event %u can never trigger.", temp.creature_id, temp.spell_hit.schoolMask, i);
}
@@ -304,8 +304,8 @@ void CreatureEventAIMgr::LoadCreatureEventAI_Scripts()
break;
case EVENT_T_FRIENDLY_MISSING_BUFF:
{
SpellInfo const* pSpell = sSpellMgr->GetSpellInfo(temp.spell_hit.spellId);
if (!pSpell)
SpellInfo const* spell = sSpellMgr->GetSpellInfo(temp.spell_hit.spellId);
if (!spell)
{
sLog->outErrorDb("CreatureEventAI: Creature %u has non-existant SpellID(%u) defined in event %u.", temp.creature_id, temp.spell_hit.spellId, i);
continue;
@@ -381,8 +381,8 @@ void CreatureEventAIMgr::LoadCreatureEventAI_Scripts()
case EVENT_T_BUFFED:
case EVENT_T_TARGET_BUFFED:
{
SpellInfo const* pSpell = sSpellMgr->GetSpellInfo(temp.buffed.spellId);
if (!pSpell)
SpellInfo const* spell = sSpellMgr->GetSpellInfo(temp.buffed.spellId);
if (!spell)
{
sLog->outErrorDb("CreatureEventAI: Creature %u has non-existant SpellID(%u) defined in event %u.", temp.creature_id, temp.spell_hit.spellId, i);
continue;
@@ -501,7 +501,7 @@ void CreatureEventAIMgr::LoadCreatureEventAI_Scripts()
break;
case ACTION_T_CAST:
{
const SpellInfo *spell = sSpellMgr->GetSpellInfo(action.cast.spellId);
const SpellInfo* spell = sSpellMgr->GetSpellInfo(action.cast.spellId);
if (!spell)
sLog->outErrorDb("CreatureEventAI: Event %u Action %u uses non-existent SpellID %u.", i, j+1, action.cast.spellId);
/* FIXME: temp.raw.param3 not have event tipes with recovery time in it....

160
src/server/game/AI/ScriptedAI/ScriptedCreature.cpp
View File

@@ -16,13 +16,13 @@ struct TSpellSummary
{
uint8 Targets; // set of enum SelectTarget
uint8 Effects; // set of enum SelectEffect
} extern *SpellSummary;
} extern* SpellSummary;
void SummonList::DoZoneInCombat(uint32 entry)
{
for (iterator i = begin(); i != end();)
{
Creature *summon = Unit::GetCreature(*me, *i);
Creature* summon = Unit::GetCreature(*me, *i);
++i;
if (summon && summon->IsAIEnabled
&& (!entry || summon->GetEntry() == entry))
@@ -34,7 +34,7 @@ void SummonList::DoAction(uint32 entry, int32 info)
{
for (iterator i = begin(); i != end();)
{
Creature *summon = Unit::GetCreature(*me, *i);
Creature* summon = Unit::GetCreature(*me, *i);
++i;
if (summon && summon->IsAIEnabled
&& (!entry || summon->GetEntry() == entry))
@@ -46,7 +46,7 @@ void SummonList::DespawnEntry(uint32 entry)
{
for (iterator i = begin(); i != end();)
{
Creature *summon = Unit::GetCreature(*me, *i);
Creature* summon = Unit::GetCreature(*me, *i);
if (!summon)
erase(i++);
else if (summon->GetEntry() == entry)
@@ -64,7 +64,7 @@ void SummonList::DespawnAll()
{
while (!empty())
{
Creature *summon = Unit::GetCreature(*me, *begin());
Creature* summon = Unit::GetCreature(*me, *begin());
if (!summon)
erase(begin());
else
@@ -108,8 +108,8 @@ bool SummonList::HasEntry(uint32 entry)
return false;
}
ScriptedAI::ScriptedAI(Creature* pCreature) : CreatureAI(pCreature),
me(pCreature),
ScriptedAI::ScriptedAI(Creature* creature) : CreatureAI(creature),
me(creature),
IsFleeing(false),
_evadeCheckCooldown(2500),
_isCombatMovementAllowed(true)
@@ -118,13 +118,13 @@ ScriptedAI::ScriptedAI(Creature* pCreature) : CreatureAI(pCreature),
_difficulty = Difficulty(me->GetMap()->GetSpawnMode());
}
void ScriptedAI::AttackStartNoMove(Unit* pWho)
void ScriptedAI::AttackStartNoMove(Unit* who)
{
if (!pWho)
if (!who)
return;
if (me->Attack(pWho, false))
DoStartNoMovement(pWho);
if (me->Attack(who, false))
DoStartNoMovement(who);
}
void ScriptedAI::UpdateAI(uint32 const /*diff*/)
@@ -144,15 +144,15 @@ void ScriptedAI::UpdateAI(uint32 const /*diff*/)
}
}
void ScriptedAI::DoStartMovement(Unit* pVictim, float fDistance, float fAngle)
void ScriptedAI::DoStartMovement(Unit* victim, float distance, float angle)
{
if (pVictim)
me->GetMotionMaster()->MoveChase(pVictim, fDistance, fAngle);
if (victim)
me->GetMotionMaster()->MoveChase(victim, distance, angle);
}
void ScriptedAI::DoStartNoMovement(Unit* pVictim)
void ScriptedAI::DoStartNoMovement(Unit* victim)
{
if (!pVictim)
if (!victim)
return;
me->GetMotionMaster()->MoveIdle();
@@ -164,27 +164,27 @@ void ScriptedAI::DoStopAttack()
me->AttackStop();
}
void ScriptedAI::DoCastSpell(Unit* pTarget, SpellInfo const* pSpellInfo, bool bTriggered)
void ScriptedAI::DoCastSpell(Unit* target, SpellInfo const* spellInfo, bool triggered)
{
if (!pTarget || me->IsNonMeleeSpellCasted(false))
if (!target || me->IsNonMeleeSpellCasted(false))
return;
me->StopMoving();
me->CastSpell(pTarget, pSpellInfo, bTriggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE);
me->CastSpell(target, spellInfo, triggered ? TRIGGERED_FULL_MASK : TRIGGERED_NONE);
}
void ScriptedAI::DoPlaySoundToSet(WorldObject* pSource, uint32 uiSoundId)
void ScriptedAI::DoPlaySoundToSet(WorldObject* source, uint32 soundId)
{
if (!pSource)
if (!source)
return;
if (!GetSoundEntriesStore()->LookupEntry(uiSoundId))
if (!GetSoundEntriesStore()->LookupEntry(soundId))
{
sLog->outError("TSCR: Invalid soundId %u used in DoPlaySoundToSet (Source: TypeId %u, GUID %u)", uiSoundId, pSource->GetTypeId(), pSource->GetGUIDLow());
sLog->outError("TSCR: Invalid soundId %u used in DoPlaySoundToSet (Source: TypeId %u, GUID %u)", soundId, source->GetTypeId(), source->GetGUIDLow());
return;
}
pSource->PlayDirectSound(uiSoundId);
source->PlayDirectSound(soundId);
}
Creature* ScriptedAI::DoSpawnCreature(uint32 entry, float offsetX, float offsetY, float offsetZ, float angle, uint32 type, uint32 despawntime)
@@ -302,105 +302,107 @@ void ScriptedAI::DoResetThreat()
for (std::list<HostileReference*>::iterator itr = threatlist.begin(); itr != threatlist.end(); ++itr)
{
Unit* pUnit = Unit::GetUnit((*me), (*itr)->getUnitGuid());
Unit* unit = Unit::GetUnit((*me), (*itr)->getUnitGuid());
if (pUnit && DoGetThreat(pUnit))
DoModifyThreatPercent(pUnit, -100);
if (unit && DoGetThreat(unit))
DoModifyThreatPercent(unit, -100);
}
}
float ScriptedAI::DoGetThreat(Unit* pUnit)
float ScriptedAI::DoGetThreat(Unit* unit)
{
if (!pUnit) return 0.0f;
return me->getThreatManager().getThreat(pUnit);
if (!unit)
return 0.0f;
return me->getThreatManager().getThreat(unit);
}
void ScriptedAI::DoModifyThreatPercent(Unit* pUnit, int32 pct)
void ScriptedAI::DoModifyThreatPercent(Unit* unit, int32 pct)
{
if (!pUnit) return;
me->getThreatManager().modifyThreatPercent(pUnit, pct);
if (!unit)
return;
me->getThreatManager().modifyThreatPercent(unit, pct);
}
void ScriptedAI::DoTeleportTo(float fX, float fY, float fZ, uint32 uiTime)
void ScriptedAI::DoTeleportTo(float x, float y, float z, uint32 time)
{
me->Relocate(fX, fY, fZ);
me->SendMonsterMove(fX, fY, fZ, uiTime);
me->Relocate(x, y, z);
me->SendMonsterMove(x, y, z, time);
}
void ScriptedAI::DoTeleportTo(const float fPos[4])
void ScriptedAI::DoTeleportTo(const float position[4])
{
me->NearTeleportTo(fPos[0], fPos[1], fPos[2], fPos[3]);
me->NearTeleportTo(position[0], position[1], position[2], position[3]);
}
void ScriptedAI::DoTeleportPlayer(Unit* pUnit, float fX, float fY, float fZ, float fO)
void ScriptedAI::DoTeleportPlayer(Unit* unit, float x, float y, float z, float o)
{
if (!pUnit || pUnit->GetTypeId() != TYPEID_PLAYER)
if (!unit || unit->GetTypeId() != TYPEID_PLAYER)
{
if (pUnit)
sLog->outError("TSCR: Creature " UI64FMTD " (Entry: %u) Tried to teleport non-player unit (Type: %u GUID: " UI64FMTD ") to x: %f y:%f z: %f o: %f. Aborted.", me->GetGUID(), me->GetEntry(), pUnit->GetTypeId(), pUnit->GetGUID(), fX, fY, fZ, fO);
if (unit)
sLog->outError("TSCR: Creature " UI64FMTD " (Entry: %u) Tried to teleport non-player unit (Type: %u GUID: " UI64FMTD ") to x: %f y:%f z: %f o: %f. Aborted.", me->GetGUID(), me->GetEntry(), unit->GetTypeId(), unit->GetGUID(), x, y, z, o);
return;
}
CAST_PLR(pUnit)->TeleportTo(pUnit->GetMapId(), fX, fY, fZ, fO, TELE_TO_NOT_LEAVE_COMBAT);
CAST_PLR(unit)->TeleportTo(unit->GetMapId(), x, y, z, o, TELE_TO_NOT_LEAVE_COMBAT);
}
void ScriptedAI::DoTeleportAll(float fX, float fY, float fZ, float fO)
void ScriptedAI::DoTeleportAll(float x, float y, float z, float o)
{
Map *map = me->GetMap();
Map* map = me->GetMap();
if (!map->IsDungeon())
return;
Map::PlayerList const &PlayerList = map->GetPlayers();
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
if (Player* i_pl = i->getSource())
if (i_pl->isAlive())
i_pl->TeleportTo(me->GetMapId(), fX, fY, fZ, fO, TELE_TO_NOT_LEAVE_COMBAT);
Map::PlayerList const& PlayerList = map->GetPlayers();
for (Map::PlayerList::const_iterator itr = PlayerList.begin(); itr != PlayerList.end(); ++itr)
if (Player* player = itr->getSource())
if (player->isAlive())
player->TeleportTo(me->GetMapId(), x, y, z, o, TELE_TO_NOT_LEAVE_COMBAT);
}
Unit* ScriptedAI::DoSelectLowestHpFriendly(float fRange, uint32 uiMinHPDiff)
Unit* ScriptedAI::DoSelectLowestHpFriendly(float range, uint32 minHPDiff)
{
Unit* pUnit = NULL;
Trinity::MostHPMissingInRange u_check(me, fRange, uiMinHPDiff);
Trinity::UnitLastSearcher<Trinity::MostHPMissingInRange> searcher(me, pUnit, u_check);
me->VisitNearbyObject(fRange, searcher);
Unit* unit = NULL;
Trinity::MostHPMissingInRange u_check(me, range, minHPDiff);
Trinity::UnitLastSearcher<Trinity::MostHPMissingInRange> searcher(me, unit, u_check);
me->VisitNearbyObject(range, searcher);
return pUnit;
return unit;
}
std::list<Creature*> ScriptedAI::DoFindFriendlyCC(float fRange)
std::list<Creature*> ScriptedAI::DoFindFriendlyCC(float range)
{
std::list<Creature*> pList;
Trinity::FriendlyCCedInRange u_check(me, fRange);
Trinity::CreatureListSearcher<Trinity::FriendlyCCedInRange> searcher(me, pList, u_check);
me->VisitNearbyObject(fRange, searcher);
return pList;
std::list<Creature*> list;
Trinity::FriendlyCCedInRange u_check(me, range);
Trinity::CreatureListSearcher<Trinity::FriendlyCCedInRange> searcher(me, list, u_check);
me->VisitNearbyObject(range, searcher);
return list;
}
std::list<Creature*> ScriptedAI::DoFindFriendlyMissingBuff(float fRange, uint32 uiSpellid)
std::list<Creature*> ScriptedAI::DoFindFriendlyMissingBuff(float range, uint32 uiSpellid)
{
std::list<Creature*> pList;
Trinity::FriendlyMissingBuffInRange u_check(me, fRange, uiSpellid);
Trinity::CreatureListSearcher<Trinity::FriendlyMissingBuffInRange> searcher(me, pList, u_check);
me->VisitNearbyObject(fRange, searcher);
return pList;
std::list<Creature*> list;
Trinity::FriendlyMissingBuffInRange u_check(me, range, uiSpellid);
Trinity::CreatureListSearcher<Trinity::FriendlyMissingBuffInRange> searcher(me, list, u_check);
me->VisitNearbyObject(range, searcher);
return list;
}
Player* ScriptedAI::GetPlayerAtMinimumRange(float fMinimumRange)
Player* ScriptedAI::GetPlayerAtMinimumRange(float minimumRange)
{
Player* pPlayer = NULL;
Player* player = NULL;
CellPair pair(Trinity::ComputeCellPair(me->GetPositionX(), me->GetPositionY()));
Cell cell(pair);
cell.data.Part.reserved = ALL_DISTRICT;
cell.SetNoCreate();
Trinity::PlayerAtMinimumRangeAway check(me, fMinimumRange);
Trinity::PlayerSearcher<Trinity::PlayerAtMinimumRangeAway> searcher(me, pPlayer, check);
Trinity::PlayerAtMinimumRangeAway check(me, minimumRange);
Trinity::PlayerSearcher<Trinity::PlayerAtMinimumRangeAway> searcher(me, player, check);
TypeContainerVisitor<Trinity::PlayerSearcher<Trinity::PlayerAtMinimumRangeAway>, GridTypeMapContainer> visitor(searcher);
cell.Visit(pair, visitor, *(me->GetMap()));
return pPlayer;
return player;
}
void ScriptedAI::SetEquipmentSlots(bool loadDefault, int32 mainHand /*= EQUIP_NO_CHANGE*/, int32 offHand /*= EQUIP_NO_CHANGE*/, int32 ranged /*= EQUIP_NO_CHANGE*/)
@@ -451,14 +453,14 @@ bool ScriptedAI::EnterEvadeIfOutOfCombatArea(uint32 const diff)
if (me->IsInEvadeMode() || !me->getVictim())
return false;
float fX = me->GetPositionX();
float fY = me->GetPositionY();
float fZ = me->GetPositionZ();
float x = me->GetPositionX();
float y = me->GetPositionY();
float z = me->GetPositionZ();
switch(me->GetEntry())
{
case NPC_BROODLORD: // broodlord (not move down stairs)
if (fZ > 448.60f)
if (z > 448.60f)
return false;
break;
case NPC_VOID_REAVER: // void reaver (calculate from center of room)
@@ -466,11 +468,11 @@ bool ScriptedAI::EnterEvadeIfOutOfCombatArea(uint32 const diff)
return false;
break;
case NPC_JAN_ALAI: // jan'alai (calculate by Z)
if (fZ > 12.0f)
if (z > 12.0f)
return false;
break;
case NPC_SARTHARION: // sartharion (calculate box)
if (fX > 3218.86f && fX < 3275.69f && fY < 572.40f && fY > 484.68f)
if (x > 3218.86f && x < 3275.69f && y < 572.40f && y > 484.68f)
return false;
break;
default:

60
src/server/game/AI/ScriptedAI/ScriptedSimpleAI.cpp
View File

@@ -26,7 +26,7 @@ EndScriptData */
#include "ScriptPCH.h"
#include "ScriptedSimpleAI.h"
SimpleAI::SimpleAI(Creature *c) : ScriptedAI(c)
SimpleAI::SimpleAI(Creature* c) : ScriptedAI(c)
{
//Clear all data
Aggro_TextId[0] = 0;
@@ -63,7 +63,7 @@ void SimpleAI::Reset()
{
}
void SimpleAI::EnterCombat(Unit *who)
void SimpleAI::EnterCombat(Unit* who)
{
//Reset cast timers
if (Spell[0].First_Cast >= 0)
@@ -123,36 +123,36 @@ void SimpleAI::KilledUnit(Unit* victim)
if (!Kill_Spell)
return;
Unit *pTarget = NULL;
Unit* target = NULL;
switch (Kill_Target_Type)
{
case CAST_SELF:
pTarget = me;
target = me;
break;
case CAST_HOSTILE_TARGET:
pTarget = me->getVictim();
target = me->getVictim();
break;
case CAST_HOSTILE_SECOND_AGGRO:
pTarget = SelectTarget(SELECT_TARGET_TOPAGGRO, 1);
target = SelectTarget(SELECT_TARGET_TOPAGGRO, 1);
break;
case CAST_HOSTILE_LAST_AGGRO:
pTarget = SelectTarget(SELECT_TARGET_BOTTOMAGGRO, 0);
target = SelectTarget(SELECT_TARGET_BOTTOMAGGRO, 0);
break;
case CAST_HOSTILE_RANDOM:
pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0);
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
break;
case CAST_KILLEDUNIT_VICTIM:
pTarget = victim;
target = victim;
break;
}
//Target is ok, cast a spell on it
if (pTarget)
DoCast(pTarget, Kill_Spell);
if (target)
DoCast(target, Kill_Spell);
}
void SimpleAI::DamageTaken(Unit* killer, uint32 &damage)
void SimpleAI::DamageTaken(Unit* killer, uint32& damage)
{
//Return if damage taken won't kill us
if (me->GetHealth() > damage)
@@ -171,33 +171,33 @@ void SimpleAI::DamageTaken(Unit* killer, uint32 &damage)
if (!Death_Spell)
return;
Unit *pTarget = NULL;
Unit* target = NULL;
switch (Death_Target_Type)
{
case CAST_SELF:
pTarget = me;
target = me;
break;
case CAST_HOSTILE_TARGET:
pTarget = me->getVictim();
target = me->getVictim();
break;
case CAST_HOSTILE_SECOND_AGGRO:
pTarget = SelectTarget(SELECT_TARGET_TOPAGGRO, 1);
target = SelectTarget(SELECT_TARGET_TOPAGGRO, 1);
break;
case CAST_HOSTILE_LAST_AGGRO:
pTarget = SelectTarget(SELECT_TARGET_BOTTOMAGGRO, 0);
target = SelectTarget(SELECT_TARGET_BOTTOMAGGRO, 0);
break;
case CAST_HOSTILE_RANDOM:
pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0);
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
break;
case CAST_JUSTDIED_KILLER:
pTarget = killer;
target = killer;
break;
}
//Target is ok, cast a spell on it
if (pTarget)
DoCast(pTarget, Death_Spell);
if (target)
DoCast(target, Death_Spell);
}
void SimpleAI::UpdateAI(const uint32 diff)
@@ -222,34 +222,34 @@ void SimpleAI::UpdateAI(const uint32 diff)
//Check Current spell
if (!(Spell[i].InterruptPreviousCast && me->IsNonMeleeSpellCasted(false)))
{
Unit *pTarget = NULL;
Unit* target = NULL;
switch (Spell[i].Cast_Target_Type)
{
case CAST_SELF:
pTarget = me;
target = me;
break;
case CAST_HOSTILE_TARGET:
pTarget = me->getVictim();
target = me->getVictim();
break;
case CAST_HOSTILE_SECOND_AGGRO:
pTarget = SelectTarget(SELECT_TARGET_TOPAGGRO, 1);
target = SelectTarget(SELECT_TARGET_TOPAGGRO, 1);
break;
case CAST_HOSTILE_LAST_AGGRO:
pTarget = SelectTarget(SELECT_TARGET_BOTTOMAGGRO, 0);
target = SelectTarget(SELECT_TARGET_BOTTOMAGGRO, 0);
break;
case CAST_HOSTILE_RANDOM:
pTarget = SelectTarget(SELECT_TARGET_RANDOM, 0);
target = SelectTarget(SELECT_TARGET_RANDOM, 0);
break;
}
//Target is ok, cast a spell on it and then do our random yell
if (pTarget)
if (target)
{
if (me->IsNonMeleeSpellCasted(false))
me->InterruptNonMeleeSpells(false);
DoCast(pTarget, Spell[i].Spell_Id);
DoCast(target, Spell[i].Spell_Id);
//Yell and sound use the same number so that you can make
//the Creature yell with the correct sound effect attached
@@ -257,7 +257,7 @@ void SimpleAI::UpdateAI(const uint32 diff)
//Random yell
if (Spell[i].TextId[random_text])
DoScriptText(Spell[i].TextId[random_text], me, pTarget);
DoScriptText(Spell[i].TextId[random_text], me, target);
//Random sound
if (Spell[i].Text_Sound[random_text])

4
src/server/game/AI/ScriptedAI/ScriptedSimpleAI.h
View File

@@ -23,7 +23,7 @@ enum CastTarget
struct SimpleAI : public ScriptedAI
{
SimpleAI(Creature *c);// : ScriptedAI(c);
SimpleAI(Creature* c);// : ScriptedAI(c);
void Reset();
@@ -31,7 +31,7 @@ struct SimpleAI : public ScriptedAI
void KilledUnit(Unit* /*victim*/);
void DamageTaken(Unit* killer, uint32 &damage);
void DamageTaken(Unit* killer, uint32& damage);
void UpdateAI(const uint32 diff);

4
src/server/game/AI/SmartScripts/SmartAI.cpp
View File

@@ -787,7 +787,7 @@ void SmartAI::SetFollow(Unit* target, float dist, float angle, uint32 credit, ui
mFollowCreditType = creditType;
}
void SmartAI::SetScript9(SmartScriptHolder &e, uint32 entry, Unit* invoker)
void SmartAI::SetScript9(SmartScriptHolder& e, uint32 entry, Unit* invoker)
{
if (invoker)
GetScript()->mLastInvoker = invoker->GetGUID();
@@ -888,7 +888,7 @@ void SmartGameObjectAI::SetData(uint32 id, uint32 value)
GetScript()->ProcessEventsFor(SMART_EVENT_DATA_SET, NULL, id, value);
}
void SmartGameObjectAI::SetScript9(SmartScriptHolder &e, uint32 entry, Unit* invoker)
void SmartGameObjectAI::SetScript9(SmartScriptHolder& e, uint32 entry, Unit* invoker)
{
if (invoker)
GetScript()->mLastInvoker = invoker->GetGUID();

18
src/server/game/AI/SmartScripts/SmartAI.h
View File

@@ -48,7 +48,7 @@ class SmartAI : public CreatureAI
{
public:
~SmartAI(){};
explicit SmartAI(Creature *c);
explicit SmartAI(Creature* c);
// Start moving to the desired MovePoint
void StartPath(bool run = false, uint32 path = 0, bool repeat = false, Unit* invoker = NULL);
@@ -65,7 +65,7 @@ class SmartAI : public CreatureAI
void SetCombatMove(bool on);
void SetFollow(Unit* target, float dist = 0.0f, float angle = 0.0f, uint32 credit = 0, uint32 end = 0, uint32 creditType = 0);
void SetScript9(SmartScriptHolder &e, uint32 entry, Unit* invoker);
void SetScript9(SmartScriptHolder& e, uint32 entry, Unit* invoker);
SmartScript* GetScript() { return &mScript; }
bool IsEscortInvokerInRange();
@@ -79,7 +79,7 @@ class SmartAI : public CreatureAI
void JustReachedHome();
// Called for reaction at enter to combat if not in combat yet (enemy can be NULL)
void EnterCombat(Unit *enemy);
void EnterCombat(Unit* enemy);
// Called for reaction at stopping attack at no attackers or targets
void EnterEvadeMode();
@@ -97,7 +97,7 @@ class SmartAI : public CreatureAI
void AttackStart(Unit* who);
// Called if IsVisible(Unit *who) is true at each *who move, reaction at visibility zone enter
void MoveInLineOfSight(Unit *who);
void MoveInLineOfSight(Unit* who);
// Called when hit by a spell
void SpellHit(Unit* pUnit, const SpellInfo* pSpell);
@@ -124,13 +124,13 @@ class SmartAI : public CreatureAI
void IsSummonedBy(Unit* summoner);
// Called at any Damage to any victim (before damage apply)
void DamageDealt(Unit* done_to, uint32 & damage, DamageEffectType /*damagetype*/);
void DamageDealt(Unit* done_to, uint32& damage, DamageEffectType /*damagetype*/);
// Called when a summoned creature dissapears (UnSommoned)
void SummonedCreatureDespawn(Creature* unit);
// called when the corpse of this creature gets removed
void CorpseRemoved(uint32 & respawnDelay);
void CorpseRemoved(uint32& respawnDelay);
// Called at World update tick if creature is charmed
void UpdateAIWhileCharmed(const uint32 diff);
@@ -163,7 +163,7 @@ class SmartAI : public CreatureAI
uint64 GetGUID(int32 id = 0);
//core related
static int Permissible(const Creature *);
static int Permissible(const Creature*);
// Called at movepoint reached
void MovepointReached(uint32 id);
@@ -231,7 +231,7 @@ class SmartAI : public CreatureAI
class SmartGameObjectAI : public GameObjectAI
{
public:
SmartGameObjectAI(GameObject *g) : GameObjectAI(g), go(g) {}
SmartGameObjectAI(GameObject* g) : GameObjectAI(g), go(g) {}
~SmartGameObjectAI() {}
void UpdateAI(const uint32 diff);
@@ -248,7 +248,7 @@ public:
uint32 GetDialogStatus(Player* /*player*/);
void Destroyed(Player* player, uint32 eventId);
void SetData(uint32 id, uint32 value);
void SetScript9(SmartScriptHolder &e, uint32 entry, Unit* invoker);
void SetScript9(SmartScriptHolder& e, uint32 entry, Unit* invoker);
protected:
GameObject* const go;

2
src/server/game/AI/SmartScripts/SmartScriptMgr.cpp
View File

@@ -282,7 +282,7 @@ bool SmartAIMgr::IsTargetValid(SmartScriptHolder const& e)
return true;
}
bool SmartAIMgr::IsEventValid(SmartScriptHolder &e)
bool SmartAIMgr::IsEventValid(SmartScriptHolder& e)
{
if (e.event.type >= SMART_EVENT_END)
{

2
src/server/game/AI/SmartScripts/SmartScriptMgr.h
View File

@@ -1236,7 +1236,7 @@ class SmartAIMgr
//event stores
SmartAIEventMap mEventMap[SMART_SCRIPT_TYPE_MAX];
bool IsEventValid(SmartScriptHolder &e);
bool IsEventValid(SmartScriptHolder& e);
bool IsTargetValid(SmartScriptHolder const& e);
/*inline bool IsTargetValid(SmartScriptHolder e, int32 target)