*Rename some script functions (no real change).

--HG--
branch : trunk

src/game/CreatureAI.cpp

@@ -71,6 +71,8 @@ void CreatureAI::OnCharmed(bool apply)
     me->IsAIEnabled = false;
 }
 
+AISpellInfoType *AISpellInfo;
+
 void CreatureAI::DoZoneInCombat(Creature* creature)
 {
     if (!creature)
@@ -151,6 +153,148 @@ void CreatureAI::EnterEvadeMode()
         me->GetMotionMaster()->MoveTargetedHome();
 }
 
+inline bool SelectTargetHelper(const Unit * me, const Unit * target, const bool &playerOnly, const float &dist, const int32 &aura)
+{
+    if(playerOnly && target->GetTypeId() != TYPEID_PLAYER)
+        return false;
+
+    if(dist && !me->IsWithinCombatRange(target, dist))
+        return false;
+
+    if(aura)
+    {
+        if(aura > 0)
+        {
+            if(!target->HasAura(aura))
+                return false;
+        }
+        else
+        {
+            if(target->HasAura(aura))
+                return false;
+        }
+    }
+
+    return true;
+}
+
+struct TargetDistanceOrder : public std::binary_function<const Unit *, const Unit *, bool>
+{
+    const Unit * me;
+    TargetDistanceOrder(const Unit* Target) : me(Target) {};
+    // functor for operator ">"
+    bool operator()(const Unit * _Left, const Unit * _Right) const
+    {
+        return (me->GetDistanceSq(_Left) < me->GetDistanceSq(_Right));
+    }
+};
+
+Unit* CreatureAI::SelectTarget(SelectAggroTarget targetType, uint32 position, float dist, bool playerOnly, int32 aura)
+{
+    if(targetType == SELECT_TARGET_NEAREST || targetType == SELECT_TARGET_FARTHEST)
+    {
+        std::list<HostilReference*> &m_threatlist = me->getThreatManager().getThreatList();
+        if(position >= m_threatlist.size())
+            return NULL;
+
+        std::list<Unit*> targetList;
+        for(std::list<HostilReference*>::iterator itr = m_threatlist.begin(); itr!= m_threatlist.end(); ++itr)
+            if(SelectTargetHelper(me, (*itr)->getTarget(), playerOnly, dist, aura))
+                targetList.push_back((*itr)->getTarget());
+
+        if(position >= targetList.size())
+            return NULL;
+
+        targetList.sort(TargetDistanceOrder(m_creature));
+
+        if(targetType == SELECT_TARGET_NEAREST)
+        {
+            std::list<Unit*>::iterator i = targetList.begin();
+            advance(i, position);
+            return *i;
+        }
+        else
+        {
+            std::list<Unit*>::reverse_iterator i = targetList.rbegin();
+            advance(i, position);
+            return *i;
+        }
+    }
+    else
+    {
+        std::list<HostilReference*> m_threatlist = me->getThreatManager().getThreatList();
+        std::list<HostilReference*>::iterator i;
+        while(position < m_threatlist.size())
+        {
+            if(targetType == SELECT_TARGET_BOTTOMAGGRO)
+            {
+                i = m_threatlist.end();
+                advance(i, - (int32)position - 1);
+            }
+            else
+            {
+                i = m_threatlist.begin();
+                if(targetType == SELECT_TARGET_TOPAGGRO)
+                    advance(i, position);
+                else // random
+                    advance(i, position + rand()%(m_threatlist.size() - position));
+            }
+
+            if(SelectTargetHelper(me, (*i)->getTarget(), playerOnly, dist, aura))
+                return (*i)->getTarget();
+            else
+                m_threatlist.erase(i);
+        }
+    }
+
+    return NULL;
+}
+
+void CreatureAI::SelectTargetList(std::list<Unit*> &targetList, uint32 num, SelectAggroTarget targetType, float dist, bool playerOnly, int32 aura)
+{
+    if(targetType == SELECT_TARGET_NEAREST || targetType == SELECT_TARGET_FARTHEST)
+    {
+        std::list<HostilReference*> &m_threatlist = m_creature->getThreatManager().getThreatList();
+        if(m_threatlist.empty())
+            return;
+
+        for(std::list<HostilReference*>::iterator itr = m_threatlist.begin(); itr!= m_threatlist.end(); ++itr)
+            if(SelectTargetHelper(me, (*itr)->getTarget(), playerOnly, dist, aura))
+                targetList.push_back((*itr)->getTarget());
+
+        targetList.sort(TargetDistanceOrder(me));
+        targetList.resize(num);
+        if(targetType == SELECT_TARGET_FARTHEST)
+            targetList.reverse();
+    }
+    else
+    {
+        std::list<HostilReference*> m_threatlist = me->getThreatManager().getThreatList();
+        std::list<HostilReference*>::iterator i;
+        while(!m_threatlist.empty() && num)
+        {
+            if(targetType == SELECT_TARGET_BOTTOMAGGRO)
+            {
+                i = m_threatlist.end();
+                --i;
+            }
+            else
+            {
+                i = m_threatlist.begin();
+                if(targetType == SELECT_TARGET_RANDOM)
+                    advance(i, rand()%m_threatlist.size());
+            }
+
+            if(SelectTargetHelper(me, (*i)->getTarget(), playerOnly, dist, aura))
+            {
+                targetList.push_back((*i)->getTarget());
+                --num;
+            }
+            m_threatlist.erase(i);
+        }
+    }
+}
+
 void SimpleCharmedAI::UpdateAI(const uint32 /*diff*/)
 {
     Creature *charmer = (Creature*)me->GetCharmer();

src/game/CreatureAI.h

@@ -37,7 +37,7 @@ struct SpellEntry;
 #define VISIBILITY_RANGE    10000
 
 //Spell targets used by SelectSpell
-enum SelectTarget
+enum SelectTargetType
 {
     SELECT_TARGET_DONTCARE = 0,                             //All target types allowed
 
@@ -77,6 +77,35 @@ enum SCEquip
     EQUIP_UNEQUIP   = 0
 };
 
+enum AITarget
+{
+    AITARGET_SELF,
+    AITARGET_VICTIM,
+    AITARGET_ENEMY,
+    AITARGET_ALLY,
+    AITARGET_BUFF,
+    AITARGET_DEBUFF,
+};
+
+enum AICondition
+{
+    AICOND_AGGRO,
+    AICOND_COMBAT,
+    AICOND_DIE,
+};
+
+#define AI_DEFAULT_COOLDOWN 5000
+
+struct AISpellInfoType
+{
+    AISpellInfoType() : target(AITARGET_SELF), condition(AICOND_COMBAT), cooldown(AI_DEFAULT_COOLDOWN) {}
+    AITarget target;
+    AICondition condition;
+    uint32 cooldown;
+};
+
+extern AISpellInfoType *AISpellInfo;
+
 class EventMap : private std::map<uint32, uint32>
 {
     private:
@@ -273,6 +302,9 @@ class TRINITY_DLL_SPEC CreatureAI : public UnitAI
 
         // Pointer to controlled by AI creature
         //Creature* const m_creature;
+
+        Unit* SelectTarget(SelectAggroTarget target, uint32 position = 0, float dist = 0, bool playerOnly = false, int32 aura = 0);
+        void SelectTargetList(std::list<Unit*> &targetList, uint32 num, SelectAggroTarget target, float dist = 0, bool playerOnly = false, int32 aura = 0);
 };
 
 struct SelectableAI : public FactoryHolder<CreatureAI>, public Permissible<Creature>

src/game/Object.cpp

@@ -1194,6 +1194,14 @@ float WorldObject::GetDistanceSq(const float &x, const float &y, const float &z)
     return dx*dx + dy*dy + dz*dz;
 }
 
+float WorldObject::GetDistanceSq(const WorldObject *obj) const
+{
+    float dx = GetPositionX() - obj->GetPositionX();
+    float dy = GetPositionY() - obj->GetPositionY();
+    float dz = GetPositionZ() - obj->GetPositionZ();
+    return dx*dx + dy*dy + dz*dz;
+}
+
 float WorldObject::GetDistance2d(const WorldObject* obj) const
 {
     float dx = GetPositionX() - obj->GetPositionX();

src/game/Object.h

@@ -463,6 +463,7 @@ class TRINITY_DLL_SPEC WorldObject : public Object
         float GetDistance( const WorldObject* obj ) const;
         float GetDistance(const float x, const float y, const float z) const;
         float GetDistanceSq(const float &x, const float &y, const float &z) const;
+        float GetDistanceSq(const WorldObject *obj) const;
         float GetDistance2d(const WorldObject* obj) const;
         float GetDistance2d(const float x, const float y) const;
         float GetExactDistance2d(const float x, const float y) const;

src/game/Unit.cpp

@@ -413,7 +413,7 @@ void Unit::resetAttackTimer(WeaponAttackType type)
     m_attackTimer[type] = uint32(GetAttackTime(type) * m_modAttackSpeedPct[type]);
 }
 
-bool Unit::IsWithinCombatRange(Unit *obj, float dist2compare) const
+bool Unit::IsWithinCombatRange(const Unit *obj, float dist2compare) const
 {
     if (!obj || !IsInMap(obj)) return false;
 
@@ -428,7 +428,7 @@ bool Unit::IsWithinCombatRange(Unit *obj, float dist2compare) const
     return distsq < maxdist * maxdist;
 }
 
-bool Unit::IsWithinMeleeRange(Unit *obj, float dist) const
+bool Unit::IsWithinMeleeRange(const Unit *obj, float dist) const
 {
     if (!obj || !IsInMap(obj)) return false;
 

src/game/Unit.h

@@ -940,8 +940,8 @@ class TRINITY_DLL_SPEC Unit : public WorldObject
         void SetCanDualWield(bool value) { m_canDualWield = value; }
         float GetCombatReach() const { return m_floatValues[UNIT_FIELD_COMBATREACH]; }
         float GetMeleeReach() const { float reach = m_floatValues[UNIT_FIELD_COMBATREACH]; return reach > MIN_MELEE_REACH ? reach : MIN_MELEE_REACH; }
-        bool IsWithinCombatRange(Unit *obj, float dist2compare) const;
-        bool IsWithinMeleeRange(Unit *obj, float dist = MELEE_RANGE) const;
+        bool IsWithinCombatRange(const Unit *obj, float dist2compare) const;
+        bool IsWithinMeleeRange(const Unit *obj, float dist = MELEE_RANGE) const;
         void GetRandomContactPoint( const Unit* target, float &x, float &y, float &z, float distance2dMin, float distance2dMax ) const;
         uint32 m_extraAttacks;
         bool m_canDualWield;