update OnBattle

Game/AI/DefaultExecutor.cs

@@ -45,13 +45,40 @@ namespace WindBot.Game.AI
             AddExecutor(ExecutorType.Activate, _CardId.ChickenGame, DefaultChickenGame);
         }
 
+        /// <summary>
+        /// Decide which card should the attacker attack.
+        /// </summary>
+        /// <param name="attacker">Card that attack.</param>
+        /// <param name="defenders">Cards that defend.</param>
+        /// <returns>BattlePhaseAction including the target, or null (in this situation, GameAI will check the next attacker)</returns>
+        public override BattlePhaseAction OnSelectAttackTarget(ClientCard attacker, IList<ClientCard> defenders)
+        {
+            for (int i = 0; i < defenders.Count; ++i)
+            {
+                ClientCard defender = defenders[i];
+
+                attacker.RealPower = attacker.Attack;
+                defender.RealPower = defender.GetDefensePower();
+                if (!OnPreBattleBetween(attacker, defender))
+                    continue;
+
+                if (attacker.RealPower > defender.RealPower || (attacker.RealPower >= defender.RealPower && attacker.IsLastAttacker))
+                    return AI.Attack(attacker, defender);
+            }
+
+            if (attacker.CanDirectAttack)
+                return AI.Attack(attacker, null);
+
+            return null;
+        }
+
         /// <summary>
         /// Decide whether to declare attack between attacker and defender.
         /// Can be overrided to update the RealPower of attacker for cards like Honest.
         /// </summary>
         /// <param name="attacker">Card that attack.</param>
         /// <param name="defender">Card that defend.</param>
-        /// <returns>false if the attack can't be done.</returns>
+        /// <returns>false if the attack shouldn't be done.</returns>
         public override bool OnPreBattleBetween(ClientCard attacker, ClientCard defender)
         {
             if (attacker.RealPower <= 0)

Game/AI/Executor.cs

@@ -52,47 +52,26 @@ namespace WindBot.Game.AI
         /// <returns>A new BattlePhaseAction containing the action to do.</returns>
         public virtual BattlePhaseAction OnBattle(IList<ClientCard> attackers, IList<ClientCard> defenders)
         {
-            if (attackers.Count == 0)
-                return AI.ToMainPhase2();
-
-            if (defenders.Count == 0)
-            {
-                for (int i = attackers.Count - 1; i >= 0; --i)
-                {
-                    ClientCard attacker = attackers[i];
-                    if (attacker.Attack > 0)
-                        return AI.Attack(attacker, null);
-                }
-            }
-            else
-            {
-                for (int i = defenders.Count - 1; i >= 0; --i)
-                {
-                    ClientCard defender = defenders[i];
-                    for (int j = 0; j < attackers.Count; ++j)
-                    {
-                        ClientCard attacker = attackers[j];
-                        attacker.RealPower = attacker.Attack;
-                        defender.RealPower = defender.GetDefensePower();
-                        if (!OnPreBattleBetween(attacker, defender))
-                            continue;
-                        if (attacker.RealPower > defender.RealPower || (attacker.RealPower >= defender.RealPower && j == attackers.Count - 1))
-                            return AI.Attack(attacker, defender);
-                    }
-                }
-
-                for (int i = attackers.Count - 1; i >= 0; --i)
-                {
-                    ClientCard attacker = attackers[i];
-                    if (attacker.CanDirectAttack)
-                        return AI.Attack(attacker, null);
-                }
-            }
+            // For overriding
+            return null;
+        }
 
-            if (!Battle.CanMainPhaseTwo)
-                return AI.Attack(attackers[0], (defenders.Count == 0) ? null : defenders[0]);
+        /// <summary>
+        /// Called when the AI has to decide which card to attack first
+        /// </summary>
+        /// <param name="attackers">List of monsters that can attcack.</param>
+        /// <param name="defenders">List of monsters of enemy.</param>
+        /// <returns>The card to attack first.</returns>
+        public virtual ClientCard OnSelectAttacker(IList<ClientCard> attackers, IList<ClientCard> defenders)
+        {
+            // For overriding
+            return null;
+        }
 
-            return AI.ToMainPhase2();
+        public virtual BattlePhaseAction OnSelectAttackTarget(ClientCard attacker, IList<ClientCard> defenders)
+        {
+            // Overrided in DefalultExecutor
+            return null;
         }
 
         public virtual bool OnPreBattleBetween(ClientCard attacker, ClientCard defender)

Game/ClientCard.cs

@@ -36,6 +36,7 @@ namespace WindBot.Game
         public bool CanDirectAttack { get; set; }
         public bool ShouldDirectAttack { get; set; }
         public bool Attacked { get; set; }
+        public bool IsLastAttacker { get; set; }
 
         public int[] ActionIndex { get; set; }
         public IDictionary<int, int> ActionActivateIndex { get; private set; }

Game/GameAI.cs

@@ -143,13 +143,57 @@ namespace WindBot.Game
                 }
             }
 
+            // Sort the attackers and defenders, make monster with higher attack go first.
             List<ClientCard> attackers = new List<ClientCard>(battle.AttackableCards);
             attackers.Sort(AIFunctions.CompareCardAttack);
+            attackers.Reverse();
 
             List<ClientCard> defenders = new List<ClientCard>(Duel.Fields[1].GetMonsters());
             defenders.Sort(AIFunctions.CompareDefensePower);
+            defenders.Reverse();
 
-            return Executor.OnBattle(attackers, defenders);
+            // Let executor decide which card should attack first.
+            ClientCard selected = Executor.OnSelectAttacker(attackers, defenders);
+            if (selected != null && attackers.Contains(selected))
+            {
+                attackers.Remove(selected);
+                attackers.Insert(0, selected);
+            }
+
+            // Check for the executor.
+            BattlePhaseAction result = Executor.OnBattle(attackers, defenders);
+            if (result != null)
+                return result;
+
+            if (attackers.Count == 0)
+                return ToMainPhase2();
+
+            if (defenders.Count == 0)
+            {
+                // Attack with the monster with the lowest attack first
+                for (int i = attackers.Count - 1; i >= 0; --i)
+                {
+                    ClientCard attacker = attackers[i];
+                    if (attacker.Attack > 0)
+                        return Attack(attacker, null);
+                }
+            }
+            else
+            {
+                for (int k = 0; k < attackers.Count; ++k)
+                {
+                    ClientCard attacker = attackers[k];
+                    attacker.IsLastAttacker = (k == attackers.Count - 1);
+                    result = Executor.OnSelectAttackTarget(attacker, defenders);
+                    if (result != null)
+                        return result;
+                }
+            }
+
+            if (!battle.CanMainPhaseTwo)
+                return Attack(attackers[0], (defenders.Count == 0) ? null : defenders[0]);
+
+            return ToMainPhase2();
         }
 
         /// <summary>