Changeset 48

Timestamp:

09/30/09 21:44:28 (3 years ago)

Author:

valroft

Message:

- Some work on bringing spell cast AI support to GenericAI.
- Removed unnecessary code.

Location:

trunk/src/hearthstone-world

Files:

• CritterAI.h (modified) (1 diff)
• GenericAI.cpp (modified) (4 diffs)
• GenericAI.h (modified) (3 diffs)
• GuardianAI.h (modified) (2 diffs)

trunk/src/hearthstone-world/CritterAI.h

@@ -31 +31 @@
 
         virtual void OnDamageTaken(Unit * pAttacker, uint32 damage);
-        virtual void OnDeath(Unit* pKiller) { BaseAI::OnDeath(pKiller); }
-        virtual void OnSpawn() { BaseAI::OnSpawn(); }
-        virtual void Update() { BaseAI::Update(); }
-
-        virtual bool NeedsToResetThreat() { return false; }
-        virtual bool NeedToReturnHome() { return false; }
-        virtual bool CanMoveToNextWaypoint() { return false; }
-
-        virtual void OnRemoveInRangeUnit(Unit* u) { BaseAI::OnRemoveInRangeUnit(u); }
         virtual uint32 GetAIFlags() { return 0; }
 };

trunk/src/hearthstone-world/GenericAI.cpp

@@ -24 +24 @@
         m_lastUpdateTime = 0;
         m_lastAttackTime = 0;
+        m_forceSpell = NULL;
 
         ai->GetMoveGenerator()->SetThreatReference(&m_threat);
@@ -142 +143 @@
 
         return true;
+}
+
+AI_Spell* GenericAI::GetNextSpell()
+{
+        uint32 msTime = getMSTime();
+        AISpellStorage::iterator itr = m_unit->GetAIInterface()->GetAvailableSpellsBegin();
+        for(; itr != m_unit->GetAIInterface()->GetAvailableSpellsEnd(); ++itr)
+        {
+                AI_Spell* sp = (*itr);
+                if( sp->cooldowntime > msTime ) // We're still on cooldown.
+                        continue;
+
+                if( sp->procChance < 100 && !Rand(sp->procChance) ) // It just ain't proccing.
+                        continue; 
+
+                // not enough mana?
+                if( sp->spell->manaCost && m_unit->GetUInt32Value(UNIT_FIELD_POWER1+POWER_TYPE_MANA) < sp->spell->manaCost )
+                        continue;
+
+                // not enough mana?
+                if( sp->spell->ManaCostPercentage && m_unit->GetManaPct() < sp->spell->ManaCostPercentage )
+                        continue;
+
+                ++sp->procCount;
+                sp->cooldowntime = msTime + sp->cooldown;
+
+                return sp;
+        }
+
+        return NULL;
 }
 
@@ -172 +203 @@
 
         // Attack our current target, if we have one.
-        if( m_threat.GetAttackTarget() && IsInAttackRange(m_threat.GetAttackTarget()) )
+        if( m_threat.GetAttackTarget() && CanMeleeAttack(m_threat.GetAttackTarget()) )
         {
                 // just because we're in range doesn't mean we are good to go.
@@ -199 +230 @@
 }
 
-bool GenericAI::IsInAttackRange(Unit *u)
-{
-        return m_unit->GetAIInterface()->IsInAttackRange(u);
+bool GenericAI::CanMeleeAttack(Unit *u)
+{
+        return m_unit->GetAIInterface()->IsInAttackRange(u) && !m_unit->GetCurrentSpell();
 }
 

trunk/src/hearthstone-world/GenericAI.h

@@ -39 +39 @@
         virtual bool NeedToReturnHome();
         virtual bool MeetsAttackCriteria(Unit* u);
-        virtual bool IsInAttackRange(Unit* u);
+        virtual bool CanMeleeAttack(Unit* u);
         virtual uint32 GetAttackTime();
 
@@ -47 +47 @@
         virtual bool CanMoveToNextWaypoint();
 
+        AI_Spell* GetNextSpell();
+
 private:
         ThreatTable m_threat;
@@ -52 +54 @@
         uint32 m_lastUpdateTime;
         uint32 m_lastAttackTime;
+        AI_Spell* m_forceSpell;
 };
 

trunk/src/hearthstone-world/GuardianAI.h

@@ -33 +33 @@
                 pUnit->GetAIInterface()->GetMoveGenerator()->SetBehavior(MOVEMENT_GENERATOR_FOLLOW);
         }
-
-        virtual void OnDamageTaken(Unit * pAttacker, uint32 damage) { GenericAI::OnDamageTaken(pAttacker, damage); }
-        virtual void OnDeath(Unit* pKiller) { GenericAI::OnDeath(pKiller); }
         virtual void OnSpawn() { GenericAI::OnSpawn(); }
         virtual void Update()
@@ -46 +43 @@
                 GenericAI::Update();
         }
-
-        virtual bool IsAttackOrMoveEligible() { return GenericAI::IsAttackOrMoveEligible(); }
         virtual bool NeedsToResetThreat() { return false; }
         virtual bool NeedToReturnHome() { return false; }
-        virtual bool MeetsAttackCriteria(Unit* u) { return GenericAI::MeetsAttackCriteria(u); }
-        virtual bool IsInAttackRange(Unit* u) { return GenericAI::IsInAttackRange(u); }
-        virtual uint32 GetAttackTime() { return GenericAI::GetAttackTime(); }
         virtual bool CanMoveToNextWaypoint() { return false; }
 
-        virtual void OnRemoveInRangeUnit(Unit* u) { GenericAI::OnRemoveInRangeUnit(u); }
         virtual uint32 GetAIFlags() { return AI_FLAG_GENERIC_AI | AI_FLAG_GUARDIAN_AI; }
-        virtual ThreatTable* GetThreat() { return GenericAI::GetThreat(); }
 
         virtual void SetOwner(Unit* u) { m_owner = u; m_unit->GetAIInterface()->GetMoveGenerator()->SetFollowTarget(m_owner); }