Merge branch 'master' of https://github.com/IceYGO/windbot

Decks/AI_GrenMajuThunderBoarder.ydk

@@ -6,6 +6,8 @@
 71564252
 71564252
 71564252
+14558127
+14558127
 36584821
 36584821
 36584821
@@ -20,9 +22,6 @@
 35261759
 59750328
 59750328
-70368879
-70368879
-70368879
 98645731
 98645731
 98645731
@@ -30,22 +29,22 @@
 73915051
 10045474
 10045474
-10045474
 10813327
 15693423
 23924608
+47475363
+47475363
 30241314
 30241314
 58921041
 58921041
 61740673
+61936647
 69452756
 40605147
 40605147
 77538567
 77538567
-84749824
-84749824
 #extra
 86221741
 31833038
@@ -65,13 +64,11 @@
 !side
 10000080
 86937530
-14558127
 62015408
 9742784
-67441435
-72529749
-43898403
+70368879
 19508728
+10045474
 15693423
 24207889
 69452756

Game/AI/AIFunctions.cs

 using System.Collections.Generic;
+using System.Linq;
 using YGOSharp.OCGWrapper.Enums;
 namespace WindBot.Game.AI
 {
@@ -46,13 +47,7 @@ namespace WindBot.Game.AI
         /// </summary>
         public int GetTotalAttackingMonsterAttack(int player)
         {
-            int atk = 0;
-            foreach (ClientCard m in Duel.Fields[player].GetMonsters())
-            {
-                if (m.IsAttack())
-                    atk += m.Attack;
-            }
-            return atk;
+            return Duel.Fields[player].GetMonsters().Where(m => m.IsAttack()).Sum(m => (int?)m.Attack) ?? 0;
         }
         /// <summary>
         /// Get the best ATK or DEF power of the field.
@@ -61,17 +56,9 @@ namespace WindBot.Game.AI
         /// <param name="onlyATK">Only calculate attack.</param>
         public int GetBestPower(ClientField field, bool onlyATK = false)
         {
-            int bestPower = -1;
-            for (int i = 0; i < 7; ++i)
-            {
-                ClientCard card = field.MonsterZone[i];
-                if (card == null || card.Data == null) continue;
-                if (onlyATK && card.IsDefense()) continue;
-                int newPower = card.GetDefensePower();
-                if (newPower > bestPower)
-                    bestPower = newPower;
-            }
-            return bestPower;
+            return field.MonsterZone.GetMonsters()
+                .Where(card => !onlyATK || card.IsAttack())
+                .Max(card => (int?)card.GetDefensePower()) ?? -1;
         }
 
         public int GetBestAttack(ClientField field)
@@ -81,36 +68,14 @@ namespace WindBot.Game.AI
 
         public bool IsOneEnemyBetterThanValue(int value, bool onlyATK)
         {
-            int bestValue = -1;
-            bool nomonster = true;
-            for (int i = 0; i < 7; ++i)
-            {
-                ClientCard card = Enemy.MonsterZone[i];
-                if (card == null || card.Data == null) continue;
-                if (onlyATK && card.IsDefense()) continue;
-                nomonster = false;
-                int enemyValue = card.GetDefensePower();
-                if (enemyValue > bestValue)
-                    bestValue = enemyValue;
-            }
-            if (nomonster) return false;
-            return bestValue > value;
+            return Enemy.MonsterZone.GetMonsters()
+                .Any(card => card.GetDefensePower() > value && (!onlyATK || card.IsAttack()));
         }
 
         public bool IsAllEnemyBetterThanValue(int value, bool onlyATK)
         {
-            bool nomonster = true;
-            for (int i = 0; i < 7; ++i)
-            {
-                ClientCard card = Enemy.MonsterZone[i];
-                if (card == null || card.Data == null) continue;
-                if (onlyATK && card.IsDefense()) continue;
-                nomonster = false;
-                int enemyValue = card.GetDefensePower();
-                if (enemyValue <= value)
-                    return false;
-            }
-            return !nomonster;
+            return Enemy.MonsterZone.GetMonsters()
+                .All(card => card.GetDefensePower() > value && (!onlyATK || card.IsAttack()));
         }
 
         /// <summary>
@@ -146,59 +111,24 @@ namespace WindBot.Game.AI
 
         public ClientCard GetBestBotMonster(bool onlyATK = false)
         {
-            int bestPower = -1;
-            ClientCard bestMonster = null;
-            for (int i = 0; i < 7; ++i)
-            {
-                ClientCard card = Bot.MonsterZone[i];
-                if (card == null || card.Data == null) continue;
-                if (onlyATK && card.IsDefense()) continue;
-                int newPower = card.GetDefensePower();
-                if (newPower > bestPower)
-                {
-                    bestPower = newPower;
-                    bestMonster = card;
-                }
-            }
-            return bestMonster;
+            return Bot.MonsterZone.GetMonsters()
+                .Where(card => !onlyATK || card.IsAttack())
+                .OrderByDescending(card => card.GetDefensePower())
+                .FirstOrDefault();
         }
 		
         public ClientCard GetWorstBotMonster(bool onlyATK = false)
         {
-            int WorstPower = -1;
-            ClientCard WorstMonster = null;
-            for (int i = 0; i < 7; ++i)
-            {
-                ClientCard card = Bot.MonsterZone[i];
-                if (card == null || card.Data == null) continue;
-                if (onlyATK && card.IsDefense()) continue;
-                int newPower = card.GetDefensePower();
-                if (newPower < WorstPower)
-                {
-                    WorstPower = newPower;
-                    WorstMonster = card;
-                }
-            }
-            return WorstMonster;
+            return Bot.MonsterZone.GetMonsters()
+                .Where(card => !onlyATK || card.IsAttack())
+                .OrderBy(card => card.GetDefensePower())
+                .FirstOrDefault();
         }
 
         public ClientCard GetOneEnemyBetterThanValue(int value, bool onlyATK = false, bool canBeTarget = false)
         {
-            ClientCard bestCard = null;
-            int bestValue = value;
-            for (int i = 0; i < 7; ++i)
-            {
-                ClientCard card = Enemy.MonsterZone[i];
-                if (card == null || card.Data == null || (canBeTarget && card.IsShouldNotBeTarget())) continue;
-                if (onlyATK && card.IsDefense()) continue;
-                int enemyValue = card.GetDefensePower();
-                if (enemyValue >= bestValue)
-                {
-                    bestCard = card;
-                    bestValue = enemyValue;
-                }
-            }
-            return bestCard;
+            return Enemy.MonsterZone.GetMonsters()
+                .FirstOrDefault(card => card.GetDefensePower() > value && (!onlyATK || card.IsAttack()) && (!canBeTarget || !card.IsShouldNotBeTarget()));
         }
 
         public ClientCard GetOneEnemyBetterThanMyBest(bool onlyATK = false, bool canBeTarget = false)
@@ -289,21 +219,10 @@ namespace WindBot.Game.AI
 
         public ClientCard GetWorstEnemyMonster(bool onlyATK = false)
         {
-            int WorstPower = -1;
-            ClientCard WorstMonster = null;
-            for (int i = 0; i < 7; ++i)
-            {
-                ClientCard card = Enemy.MonsterZone[i];
-                if (card == null || card.Data == null) continue;
-                if (onlyATK && card.IsDefense()) continue;
-                int newPower = card.GetDefensePower();
-                if (newPower < WorstPower)
-                {
-                    WorstPower = newPower;
-                    WorstMonster = card;
-                }
-            }
-            return WorstMonster;
+            return Enemy.MonsterZone.GetMonsters()
+                .Where(card => !onlyATK || card.IsAttack())
+                .OrderBy(card => card.GetDefensePower())
+                .FirstOrDefault();
         }
 
         public ClientCard GetBestEnemySpell(bool onlyFaceup = false)
@@ -312,14 +231,11 @@ namespace WindBot.Game.AI
             if (card != null)
                 return card;
 
-            List<ClientCard> spells = Enemy.GetSpells();
+            var spells = Enemy.GetSpells();
 
-            foreach (ClientCard ecard in spells)
-            {
-                if (ecard.IsFaceup() && ecard.HasType(CardType.Continuous)||
-                    ecard.IsFaceup() && ecard.HasType(CardType.Field))
-                    return ecard;
-            }
+            card = spells.FirstOrDefault(ecard => ecard.IsFaceup() && (ecard.HasType(CardType.Continuous) || ecard.HasType(CardType.Field)));
+            if (card != null)
+                return card;
 
             if (spells.Count > 0 && !onlyFaceup)
                 return spells[0];
@@ -349,16 +265,67 @@ namespace WindBot.Game.AI
             return Duel.Turn == 1 || Duel.Phase == DuelPhase.Main2;
         }
 
-        public bool IsChainTarget(ClientCard card)
+        internal bool inListOrNull(ClientCard card, IList<ClientCard> list)
         {
-            foreach (ClientCard target in Duel.ChainTargets)
+            return card == null || list.Contains(card);
+        }
+
+        public int GetBotAvailZonesFromExtraDeck(IList<ClientCard> remove)
         {
-                if (card.Equals(target))
+            if (!Duel.IsNewRule)
+                return Zones.MainMonsterZones;
+            int result = 0;
+            
+            if (inListOrNull(Bot.MonsterZone[5], remove) && inListOrNull(Bot.MonsterZone[6], remove) &&
+                (inListOrNull(Enemy.MonsterZone[5], remove) || inListOrNull(Enemy.MonsterZone[6], remove)))
+                result |= Zones.ExtraMonsterZones;
+
+            if (inListOrNull(Bot.MonsterZone[0], remove) &&
+                (!inListOrNull(Bot.MonsterZone[1], remove) && Bot.MonsterZone[1].HasLinkMarker(CardLinkMarker.Left) ||
+                 !inListOrNull(Bot.MonsterZone[5], remove) && Bot.MonsterZone[5].HasLinkMarker(CardLinkMarker.BottomLeft) ||
+                 !inListOrNull(Enemy.MonsterZone[6], remove) && Enemy.MonsterZone[6].HasLinkMarker(CardLinkMarker.TopRight)))
+                result += Zones.z0;
+            if (inListOrNull(Bot.MonsterZone[1], remove) &&
+                (!inListOrNull(Bot.MonsterZone[0], remove) && Bot.MonsterZone[0].HasLinkMarker(CardLinkMarker.Right) ||
+                 !inListOrNull(Bot.MonsterZone[2], remove) && Bot.MonsterZone[2].HasLinkMarker(CardLinkMarker.Left) ||
+                 !inListOrNull(Bot.MonsterZone[5], remove) && Bot.MonsterZone[5].HasLinkMarker(CardLinkMarker.Bottom) ||
+                 !inListOrNull(Enemy.MonsterZone[6], remove) && Enemy.MonsterZone[6].HasLinkMarker(CardLinkMarker.Top)))
+                result += Zones.z1;
+            if (inListOrNull(Bot.MonsterZone[2], remove) &&
+                (!inListOrNull(Bot.MonsterZone[1], remove) && Bot.MonsterZone[1].HasLinkMarker(CardLinkMarker.Right) ||
+                 !inListOrNull(Bot.MonsterZone[3], remove) && Bot.MonsterZone[3].HasLinkMarker(CardLinkMarker.Left) ||
+                 !inListOrNull(Bot.MonsterZone[5], remove) && Bot.MonsterZone[5].HasLinkMarker(CardLinkMarker.BottomRight) ||
+                 !inListOrNull(Enemy.MonsterZone[6], remove) && Enemy.MonsterZone[6].HasLinkMarker(CardLinkMarker.TopLeft) ||
+                 !inListOrNull(Bot.MonsterZone[6], remove) && Bot.MonsterZone[6].HasLinkMarker(CardLinkMarker.BottomLeft) ||
+                 !inListOrNull(Enemy.MonsterZone[5], remove) && Enemy.MonsterZone[5].HasLinkMarker(CardLinkMarker.TopRight)))
+                result += Zones.z2;
+            if (inListOrNull(Bot.MonsterZone[3], remove) &&
+                (!inListOrNull(Bot.MonsterZone[2], remove) && Bot.MonsterZone[2].HasLinkMarker(CardLinkMarker.Right) ||
+                 !inListOrNull(Bot.MonsterZone[4], remove) && Bot.MonsterZone[4].HasLinkMarker(CardLinkMarker.Left) ||
+                 !inListOrNull(Bot.MonsterZone[6], remove) && Bot.MonsterZone[6].HasLinkMarker(CardLinkMarker.Bottom) ||
+                 !inListOrNull(Enemy.MonsterZone[5], remove) && Enemy.MonsterZone[5].HasLinkMarker(CardLinkMarker.Top)))
+                result += Zones.z3;
+            if (inListOrNull(Bot.MonsterZone[4], remove) &&
+                (!inListOrNull(Bot.MonsterZone[3], remove) && Bot.MonsterZone[3].HasLinkMarker(CardLinkMarker.Right) ||
+                 !inListOrNull(Bot.MonsterZone[6], remove) && Bot.MonsterZone[6].HasLinkMarker(CardLinkMarker.BottomRight) ||
+                 !inListOrNull(Enemy.MonsterZone[5], remove) && Enemy.MonsterZone[5].HasLinkMarker(CardLinkMarker.TopLeft)))
+                result += Zones.z4;
+            return result;
+        }
+
+        public int GetBotAvailZonesFromExtraDeck(ClientCard remove)
         {
-                    return true;
+            return GetBotAvailZonesFromExtraDeck(new [] { remove });
         }
+
+        public int GetBotAvailZonesFromExtraDeck()
+        {
+            return GetBotAvailZonesFromExtraDeck(new List<ClientCard>());
         }
-            return false;
+
+        public bool IsChainTarget(ClientCard card)
+        {
+            return Duel.ChainTargets.Any(card.Equals);
         }
 
         public bool IsChainTargetOnly(ClientCard card)
@@ -368,86 +335,70 @@ namespace WindBot.Game.AI
 
         public bool ChainContainsCard(int id)
         {
-            foreach (ClientCard card in Duel.CurrentChain)
-            {
-                if (card.Id == id)
-                    return true;
+            return Duel.CurrentChain.Any(card => card.Id == id);
         }
-            return false;
+
+        public bool ChainContainsCard(int[] ids)
+        {
+            return Duel.CurrentChain.Any(card => ids.Contains(card.Id));
         }
 
         public int ChainCountPlayer(int player)
         {
-            int count = 0;
-            foreach (ClientCard card in Duel.CurrentChain)
-            {
-                if (card.Controller == player)
-                    count++;
-            }
-            return count;
+            return Duel.CurrentChain.Count(card => card.Controller == player);
         }
 
         public bool ChainContainPlayer(int player)
         {
-            foreach (ClientCard card in Duel.CurrentChain)
-            {
-                if (card.Controller == player)
-                    return true;
-            }
-            return false;
+            return Duel.CurrentChain.Any(card => card.Controller == player);
         }
 
         public bool HasChainedTrap(int player)
         {
-            foreach (ClientCard card in Duel.CurrentChain)
-            {
-                if (card.Controller == player && card.HasType(CardType.Trap))
-                    return true;
-            }
-            return false;
+            return Duel.CurrentChain.Any(card => card.Controller == player && card.HasType(CardType.Trap));
         }
 
         public ClientCard GetLastChainCard()
         {
-            if (Duel.CurrentChain.Count > 0)
-                return Duel.CurrentChain[Duel.CurrentChain.Count - 1];
-            return null;
+            return Duel.CurrentChain.LastOrDefault();
         }
 
         /// <summary>
         /// Select cards listed in preferred.
         /// </summary>
-        public void SelectPreferredCards(IList<ClientCard> selected, ClientCard preferred, IList<ClientCard> cards, int min, int max)
+        public IList<ClientCard> SelectPreferredCards(ClientCard preferred, IList<ClientCard> cards, int min, int max)
         {
+            IList<ClientCard> selected = new List<ClientCard>();
             if (cards.IndexOf(preferred) > 0 && selected.Count < max)
             {
                 selected.Add(preferred);
             }
+
+            return selected;
         }
 
         /// <summary>
         /// Select cards listed in preferred.
         /// </summary>
-        public void SelectPreferredCards(IList<ClientCard> selected, int preferred, IList<ClientCard> cards, int min, int max)
+        public IList<ClientCard> SelectPreferredCards(int preferred, IList<ClientCard> cards, int min, int max)
         {
+            IList<ClientCard> selected = new List<ClientCard>();
             foreach (ClientCard card in cards)
             {
                 if (card.Id== preferred && selected.Count < max)
                     selected.Add(card);
             }
+
+            return selected;
         }
 
         /// <summary>
         /// Select cards listed in preferred.
         /// </summary>
-        public void SelectPreferredCards(IList<ClientCard> selected, IList<ClientCard> preferred, IList<ClientCard> cards, int min, int max)
-        {
-            IList<ClientCard> avail = new List<ClientCard>();
-            foreach (ClientCard card in cards)
+        public IList<ClientCard> SelectPreferredCards(IList<ClientCard> preferred, IList<ClientCard> cards, int min, int max)
         {
-                // clone
-                avail.Add(card);
-            }
+            IList<ClientCard> selected = new List<ClientCard>();
+            IList<ClientCard> avail = cards.ToList(); // clone
             while (preferred.Count > 0 && avail.IndexOf(preferred[0]) > 0 && selected.Count < max)
             {
                 ClientCard card = preferred[0];
@@ -455,30 +406,36 @@ namespace WindBot.Game.AI
                 avail.Remove(card);
                 selected.Add(card);
             }
+
+            return selected;
         }
 
         /// <summary>
         /// Select cards listed in preferred.
         /// </summary>
-        public void SelectPreferredCards(IList<ClientCard> selected, IList<int> preferred, IList<ClientCard> cards, int min, int max)
+        public IList<ClientCard> SelectPreferredCards(IList<int> preferred, IList<ClientCard> cards, int min, int max)
         {
-            for (int i = 0; i < preferred.Count; i++)
+            IList<ClientCard> selected = new List<ClientCard>();
+            foreach (int id in preferred)
             {
                 foreach (ClientCard card in cards)
                 {
-                    if (card.Id == preferred[i] && selected.Count < max && selected.IndexOf(card) <= 0)
+                    if (card.Id == id && selected.Count < max && selected.IndexOf(card) <= 0)
                         selected.Add(card);
                 }
                 if (selected.Count >= max)
                     break;
             }
+
+            return selected;
         }
 
         /// <summary>
         /// Check and fix selected to make sure it meet the count requirement.
         /// </summary>
-        public void CheckSelectCount(IList<ClientCard> selected, IList<ClientCard> cards, int min, int max)
+        public IList<ClientCard> CheckSelectCount(IList<ClientCard> _selected, IList<ClientCard> cards, int min, int max)
         {
+            var selected = _selected.ToList();
             if (selected.Count < min)
             {
                 foreach (ClientCard card in cards)
@@ -493,6 +450,8 @@ namespace WindBot.Game.AI
             {
                 selected.RemoveAt(selected.Count - 1);
             }
+
+            return selected;
         }
     }
 }
\ No newline at end of file

Game/AI/CardContainer.cs

 using System.Collections.Generic;
 using YGOSharp.OCGWrapper.Enums;
+using System;
 using System.Linq;
 
 namespace WindBot.Game.AI
@@ -8,185 +9,90 @@ namespace WindBot.Game.AI
     {
         public static ClientCard GetHighestAttackMonster(this IEnumerable<ClientCard> cards, bool canBeTarget = false)
         {
-            int highestAtk = 0;
-            ClientCard selected = null;
-            foreach (ClientCard card in cards)
-            {
-                if (card == null || card.Data == null || card.IsFacedown() || (canBeTarget && card.IsShouldNotBeTarget())) continue;
-                if (card.HasType(CardType.Monster) && card.Attack > highestAtk)
-                {
-                    highestAtk = card.Attack;
-                    selected = card;
-                }
-            }
-            return selected;
+            return cards
+                .Where(card => card?.Data != null && card.HasType(CardType.Monster) && card.IsFaceup() && !(canBeTarget && card.IsShouldNotBeTarget()))
+                .OrderBy(card => card.Attack).FirstOrDefault();
         }
 
         public static ClientCard GetHighestDefenseMonster(this IEnumerable<ClientCard> cards, bool canBeTarget = false)
         {
-            int highestDef = 0;
-            ClientCard selected = null;
-            foreach (ClientCard card in cards)
-            {
-                if (card == null || card.Data == null || card.IsFacedown() || (canBeTarget && card.IsShouldNotBeTarget())) continue;
-                if (card.HasType(CardType.Monster) && card.Defense > highestDef)
-                {
-                    highestDef = card.Defense;
-                    selected = card;
-                }
-            }
-            return selected;
+            return cards
+                .Where(card => card?.Data != null && card.HasType(CardType.Monster) && card.IsFaceup() && !(canBeTarget && card.IsShouldNotBeTarget()))
+                .OrderBy(card => card.Defense).FirstOrDefault();
         }
 
         public static ClientCard GetLowestAttackMonster(this IEnumerable<ClientCard> cards, bool canBeTarget = false)
         {
-            int lowestAtk = 0;
-            ClientCard selected = null;
-            foreach (ClientCard card in cards)
-            {
-                if (card == null || card.Data == null || card.IsFacedown() || (canBeTarget && card.IsShouldNotBeTarget())) continue;
-                if (lowestAtk == 0 && card.HasType(CardType.Monster) ||
-                    card.HasType(CardType.Monster) && card.Attack < lowestAtk)
-                {
-                    lowestAtk = card.Attack;
-                    selected = card;
-                }
-            }
-            return selected;
+            return cards
+                .Where(card => card?.Data != null && card.HasType(CardType.Monster) && card.IsFaceup() && !(canBeTarget && card.IsShouldNotBeTarget()))
+                .OrderByDescending(card => card.Attack).FirstOrDefault();
         }
 
         public static ClientCard GetLowestDefenseMonster(this IEnumerable<ClientCard> cards, bool canBeTarget = false)
         {
-            int lowestDef = 0;
-            ClientCard selected = null;
-            foreach (ClientCard card in cards)
-            {
-                if (card == null || card.Data == null || card.IsFacedown() || (canBeTarget && card.IsShouldNotBeTarget())) continue;
-                if (lowestDef == 0 && card.HasType(CardType.Monster) ||
-                    card.HasType(CardType.Monster) && card.Defense < lowestDef)
-                {
-                    lowestDef = card.Defense;
-                    selected = card;
-                }
-            }
-            return selected;
+            return cards
+                .Where(card => card?.Data != null && card.HasType(CardType.Monster) && card.IsFaceup() && !(canBeTarget && card.IsShouldNotBeTarget()))
+                .OrderByDescending(card => card.Defense).FirstOrDefault();
         }
 
         public static bool ContainsMonsterWithLevel(this IEnumerable<ClientCard> cards, int level)
         {
-            foreach (ClientCard card in cards)
-            {
-                if (card == null)
-                    continue;
-                if (!card.HasType(CardType.Xyz) && card.Level == level)
-                    return true;
-            }
-            return false;
+            return cards.Where(card => card?.Data != null).Any(card => !card.HasType(CardType.Xyz) && card.Level == level);
         }
 
         public static bool ContainsMonsterWithRank(this IEnumerable<ClientCard> cards, int rank)
         {
-            foreach (ClientCard card in cards)
-            {
-                if (card == null)
-                    continue;
-                if (card.HasType(CardType.Xyz) && card.Rank == rank)
-                    return true;
-            }
-            return false;
+            return cards.Where(card => card?.Data != null).Any(card => card.HasType(CardType.Xyz) && card.Rank == rank);
         }
 
         public static bool ContainsCardWithId(this IEnumerable<ClientCard> cards, int id)
         {
-            foreach (ClientCard card in cards)
-            {
-                if (card == null)
-                    continue;
-                if (card.Id == id)
-                    return true;
-            }
-            return false;
+            return cards.Where(card => card?.Data != null).Any(card => card.Id == id);
         }
 
         public static int GetCardCount(this IEnumerable<ClientCard> cards, int id)
         {
-            int count = 0;
-            foreach (ClientCard card in cards)
-            {
-                if (card == null)
-                    continue;
-                if (card.Id == id)
-                    count++;
-            }
-            return count;
+            return cards.Where(card => card?.Data != null).Count(card => card.Id == id);
         }
 
         public static List<ClientCard> GetMonsters(this IEnumerable<ClientCard> cards)
         {
-            List<ClientCard> cardlist = new List<ClientCard>();
-
-            foreach (ClientCard card in cards)
-            {
-                if (card == null)
-                    continue;
-                if (card.HasType(CardType.Monster))
-                    cardlist.Add(card);
-            }
-            return cardlist;
+            return cards.Where(card => card?.Data != null && card.HasType(CardType.Monster)).ToList();
         }
 
         public static List<ClientCard> GetFaceupPendulumMonsters(this IEnumerable<ClientCard> cards)
         {
-            List<ClientCard> cardlist = new List<ClientCard>();
-
-            foreach (ClientCard card in cards)
-            {
-                if (card == null)
-                    continue;
-                if (card.HasType(CardType.Monster) && card.IsFaceup() && card.HasType(CardType.Pendulum))
-                    cardlist.Add(card);
-            }
-            return cardlist;
+            return cards.Where(card => card?.Data != null && card.HasType(CardType.Monster) && card.IsFaceup() && card.HasType(CardType.Pendulum)).ToList();
         }
 
         public static ClientCard GetInvincibleMonster(this IEnumerable<ClientCard> cards, bool canBeTarget = false)
         {
-            foreach (ClientCard card in cards)
-            {
-                if (card != null && card.IsMonsterInvincible() && card.IsFaceup() && (!canBeTarget || !card.IsShouldNotBeTarget()))
-                    return card;
-            }
-            return null;
+            return cards.FirstOrDefault(card => card?.Data != null && card.IsMonsterInvincible() && card.IsFaceup() && (!canBeTarget || !card.IsShouldNotBeTarget()));
         }
 
         public static ClientCard GetDangerousMonster(this IEnumerable<ClientCard> cards, bool canBeTarget = false)
         {
-            foreach (ClientCard card in cards)
-            {
-                if (card != null && card.IsMonsterDangerous() && card.IsFaceup() && (!canBeTarget || !card.IsShouldNotBeTarget()))
-                    return card;
-            }
-            return null;
+            return cards.FirstOrDefault(card => card?.Data != null && card.IsMonsterDangerous() && card.IsFaceup() && (!canBeTarget || !card.IsShouldNotBeTarget()));
         }
 
         public static ClientCard GetFloodgate(this IEnumerable<ClientCard> cards, bool canBeTarget = false)
         {
-            foreach (ClientCard card in cards)
-            {
-                if (card != null && card.IsFloodgate() && card.IsFaceup() && (!canBeTarget || !card.IsShouldNotBeTarget()))
-                    return card;
-            }
-            return null;
+            return cards.FirstOrDefault(card => card?.Data != null && card.IsFloodgate() && card.IsFaceup() && (!canBeTarget || !card.IsShouldNotBeTarget()));
         }
 
-        public static ClientCard GetShouldBeDisabledBeforeItUseEffectMonster(this IEnumerable<ClientCard> cards)
+        public static ClientCard GetFirstMatchingCard(this IEnumerable<ClientCard> cards, Func<ClientCard, bool> filter)
         {
-            foreach (ClientCard card in cards)
+            return cards.FirstOrDefault(card => card?.Data != null && filter.Invoke(card));
+        }
+
+        public static ClientCard GetFirstMatchingFaceupCard(this IEnumerable<ClientCard> cards, Func<ClientCard, bool> filter)
         {
-                if (card != null && card.IsMonsterShouldBeDisabledBeforeItUseEffect() && card.IsFaceup())
-                    return card;
+            return cards.FirstOrDefault(card => card?.Data != null && card.IsFaceup() && filter.Invoke(card));
         }
-            return null;
+
+        public static ClientCard GetShouldBeDisabledBeforeItUseEffectMonster(this IEnumerable<ClientCard> cards, bool canBeTarget = true)
+        {
+            return cards.FirstOrDefault(card => card?.Data != null && card.IsMonsterShouldBeDisabledBeforeItUseEffect() && card.IsFaceup() && (!canBeTarget || !card.IsShouldNotBeTarget()));
         }
 
         public static IEnumerable<IEnumerable<T>> GetCombinations<T>(this IEnumerable<T> elements, int k)

Game/AI/Decks/AltergeistExecutor.cs

@@ -461,7 +461,8 @@ namespace WindBot.Game.AI.Decks
                 return card;
 
             card = Enemy.MonsterZone.GetDangerousMonster(canBeTarget);
-            if (card != null)
+            if (card != null
+                && (Duel.Player == 0 || (Duel.Phase > DuelPhase.Main1 && Duel.Phase < DuelPhase.Main2)))
                 return card;
 
             card = Enemy.MonsterZone.GetInvincibleMonster(canBeTarget);
@@ -1136,7 +1137,7 @@ namespace WindBot.Game.AI.Decks
                 if (!AI.Utils.IsTurn1OrMain2())
                 {
                     ClientCard self_best = AI.Utils.GetBestBotMonster();
-                    ClientCard enemy_best = AI.Utils.GetProblematicEnemyCard(self_best.Attack + 1, true);
+                    ClientCard enemy_best = AI.Utils.GetProblematicEnemyCard(self_best.Attack, true);
                     ClientCard enemy_target = GetProblematicEnemyCard_Alter(true,false);
 
                     if ((enemy_best != null || enemy_target != null)
@@ -1548,7 +1549,7 @@ namespace WindBot.Game.AI.Decks
                     ClientCard enemy_card = GetBestEnemyCard_random();
                     if (enemy_card != null)
                     {
-                        Logger.DebugWriteLine("Silquitousdecide:" + bounce_self?.Name);
+                        Logger.DebugWriteLine("Silquitous decide:" + bounce_self?.Name);
                         AI.SelectCard(bounce_self);
                         AI.SelectNextCard(enemy_card);
                         return true;
@@ -1908,6 +1909,11 @@ namespace WindBot.Game.AI.Decks
             }
             else
             {
+                ClientCard self_best = AI.Utils.GetBestBotMonster();
+                int best_atk = self_best == null ? 0 : self_best.Attack;
+                ClientCard enemy_best = AI.Utils.GetProblematicEnemyCard(best_atk, true);
+                ClientCard enemy_target = GetProblematicEnemyCard_Alter(true, false);
+
                 if (!Multifaker_ssfromhand && Multifaker_candeckss() && can_ss_Multifaker)
                 {
                     Spoofing_select(new[]
@@ -1928,6 +1934,45 @@ namespace WindBot.Game.AI.Decks
                         CardId.Silquitous
                     });
                 }
+                else if (!summoned && !Bot.HasInGraveyard(CardId.Meluseek) && Bot.GetRemainingCount(CardId.Meluseek,3) > 0 && !Bot.HasInHand(CardId.Meluseek)
+                    && (enemy_best != null || enemy_target != null) )
+                {
+                    if (Bot.HasInHand(CardId.Silquitous))
+                    {
+                        foreach (ClientCard card in Bot.Hand)
+                        {
+                            if (card.Id == CardId.Silquitous)
+                            {
+                                AI.SelectCard(card);
+                                AI.SelectNextCard(new[]{
+                                    CardId.Meluseek,
+                                    CardId.Marionetter
+                                });
+                                return true;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        Spoofing_select(new[]
+                        {
+                            CardId.Silquitous,
+                            CardId.Manifestation,
+                            CardId.Kunquery,
+                            CardId.Multifaker,
+                            CardId.Protocol,
+                            CardId.Meluseek,
+                            CardId.Marionetter,
+                        });
+                        AI.SelectNextCard(new[]{
+                            CardId.Meluseek,
+                            CardId.Marionetter,
+                            CardId.Multifaker,
+                            CardId.Kunquery
+                        });
+                        return true;
+                    }
+                }
                 else if (!summoned && !Bot.HasInHand(CardId.Marionetter) && Bot.GetRemainingCount(CardId.Marionetter,3) > 0)
                 {
                     if (Bot.HasInHand(CardId.Silquitous))
@@ -1944,7 +1989,8 @@ namespace WindBot.Game.AI.Decks
                                 return true;
                             }
                         }
-                    } else
+                    }
+                    else
                     {
                         Spoofing_select(new[]
                         {
@@ -1966,6 +2012,7 @@ namespace WindBot.Game.AI.Decks
                     }
                 }
             }
+            // target protect
             bool go = false;
             foreach(ClientCard card in Bot.GetSpells())
             {
@@ -2052,6 +2099,7 @@ namespace WindBot.Game.AI.Decks
         {
             if (EvenlyMatched_ready()) return false;
             bool can_summon = false;
+            if (Enemy.GetMonsterCount() == 0 && Enemy.LifePoints <= 800) return true;
             foreach (ClientCard card in Bot.Hand)
             {
                 if (isAltergeist(card.Id) && card.IsTrap())
@@ -2089,6 +2137,7 @@ namespace WindBot.Game.AI.Decks
         public bool Multifaker_summon()
         {
             if (EvenlyMatched_ready()) return false;
+            if (Enemy.GetMonsterCount() == 0 && Enemy.LifePoints <= 1200) return true;
             if (Bot.HasInMonstersZone(CardId.Silquitous) || Bot.HasInHandOrInSpellZone(CardId.Spoofing))
             {
                 summoned = true;
@@ -2112,7 +2161,7 @@ namespace WindBot.Game.AI.Decks
             if (Duel.Phase != DuelPhase.Main2) return false;
             ClientCard card_ex_left = Enemy.MonsterZone[6];
             ClientCard card_ex_right = Enemy.MonsterZone[5];
-            if (card_ex_left != null && card_ex_left.HasLinkMarker((int)LinkMarker.Top))
+            if (card_ex_left != null && card_ex_left.HasLinkMarker((int)CardLinkMarker.Top))
             {
                 ClientCard self_card_1 = Bot.MonsterZone[1];
                 if (self_card_1 == null)
@@ -2129,7 +2178,7 @@ namespace WindBot.Game.AI.Decks
                     return true;
                 }
             }
-            if (card_ex_right != null && card_ex_right.HasLinkMarker((int)LinkMarker.Top))
+            if (card_ex_right != null && card_ex_right.HasLinkMarker((int)CardLinkMarker.Top))
             {
                 ClientCard self_card_2 = Bot.MonsterZone[3];
                 if (self_card_2 == null)
@@ -2210,11 +2259,23 @@ namespace WindBot.Game.AI.Decks
             if (AI.Utils.ChainContainsCard(CardId.Linkuriboh)) return false;
             if (AI.Utils.ChainContainsCard(CardId.Multifaker)) return false;
             if (Duel.Player == 1)
+            {
+                if (Card.Location == CardLocation.Grave)
                 {
                     AI.SelectCard(new[] { CardId.Meluseek });
                     ss_other_monster = true;
                     return true;
                 } else
+                {
+                    if (Card.IsDisabled() && !Enemy.HasInSpellZone(82732705, true)) return false;
+                    ClientCard enemy_card = Enemy.BattlingMonster;
+                    if (enemy_card == null) return false;
+                    ClientCard self_card = Bot.BattlingMonster;
+                    if (self_card == null) return (enemy_card.Id != CardId.Hayate);
+                    return (enemy_card.Attack > self_card.GetDefensePower());
+                }
+            }
+            else
             {
                 if (!summoned && !Bot.HasInHand(CardId.Marionetter) && !Meluseek_searched && (Duel.Phase == DuelPhase.Main1 || Duel.Phase == DuelPhase.Main2))
                 {
@@ -2509,7 +2570,7 @@ namespace WindBot.Game.AI.Decks
                 Logger.DebugWriteLine("Tuner: enemy: " + enemy_power.ToString() + ", bot: " + self_power.ToString());
                 if (enemy_power < self_power || enemy_power == 0) return false;
                 int real_count = (Bot.HasInExtra(CardId.Needlefiber)) ? Bot.GetMonsterCount() + 2 : Bot.GetMonsterCount() + 1;
-                if ((real_count < 3 && enemy_power >= 2400)
+                if ((real_count <= 3 && enemy_power >= 2400)
                     || !(Bot.HasInExtra(CardId.TripleBurstDragon) || Bot.HasInExtra(CardId.Borrelsword)) ) return false;
             }
             if (Multifaker_ssfromdeck) return false;
@@ -2707,6 +2768,15 @@ namespace WindBot.Game.AI.Decks
             return null;
         }
 
+        public override CardPosition OnSelectPosition(int cardId, IList<CardPosition> positions)
+        {
+            if (AI.Utils.IsTurn1OrMain2())
+            {
+                return CardPosition.FaceUpDefence;
+            }
+            return 0;
+        }
+
         public override int OnSelectPlace(int cardId, int player, int location, int available)
         {
             if (player == 0)

Game/AI/Decks/BlueEyesExecutor.cs

 using YGOSharp.OCGWrapper.Enums;
 using System.Collections.Generic;
+using System.Linq;
 using WindBot;
 using WindBot.Game;
 using WindBot.Game.AI;
@@ -138,27 +139,11 @@ namespace WindBot.Game.AI.Decks
             if (max == 2 && cards[0].Location == CardLocation.Deck)
             {
                 Logger.DebugWriteLine("OnSelectCard MelodyOfAwakeningDragon");
-                IList<ClientCard> result = new List<ClientCard>();
+                List<ClientCard> result = new List<ClientCard>();
                 if (!Bot.HasInHand(CardId.WhiteDragon))
-                {
-                    foreach (ClientCard card in cards)
-                    {
-                        if (card.Id == CardId.WhiteDragon)
-                        {
-                            result.Add(card);
-                            break;
-                        }
-                    }
-                }
-                foreach (ClientCard card in cards)
-                {
-                    if (card.Id == CardId.AlternativeWhiteDragon && result.Count < max)
-                    {
-                        result.Add(card);
-                    }
-                }
-                AI.Utils.CheckSelectCount(result, cards, min, max);
-                return result;
+                    result.AddRange(cards.Where(card => card.Id == CardId.WhiteDragon).Take(1));
+                result.AddRange(cards.Where(card => card.Id == CardId.AlternativeWhiteDragon));
+                return AI.Utils.CheckSelectCount(result, cards, min, max);
             }
             Logger.DebugWriteLine("Use default.");
             return null;
@@ -167,10 +152,8 @@ namespace WindBot.Game.AI.Decks
         public override IList<ClientCard> OnSelectXyzMaterial(IList<ClientCard> cards, int min, int max)
         {
             Logger.DebugWriteLine("OnSelectXyzMaterial " + cards.Count + " " + min + " " + max);
-            IList<ClientCard> result = new List<ClientCard>();
-            AI.Utils.SelectPreferredCards(result, UsedAlternativeWhiteDragon, cards, min, max);
-            AI.Utils.CheckSelectCount(result, cards, min, max);
-            return result;
+            IList<ClientCard> result = AI.Utils.SelectPreferredCards(UsedAlternativeWhiteDragon, cards, min, max);
+            return AI.Utils.CheckSelectCount(result, cards, min, max);
         }
 
         public override IList<ClientCard> OnSelectSynchroMaterial(IList<ClientCard> cards, int sum, int min, int max)

Game/AI/Decks/BlueEyesMaxDragonExecutor.cs

@@ -128,28 +128,29 @@ namespace WindBot.Game.AI.Decks
         {
             if(Duel.LastChainPlayer==1)
             {
-                if(AI.Utils.GetLastChainCard().Id==CardId.MaxxC)
+                ClientCard lastCard = AI.Utils.GetLastChainCard();
+                if (lastCard.Id==CardId.MaxxC)
                 {
                     AI.SelectCard(CardId.MaxxC);
                     if(AI.Utils.ChainContainsCard(CardId.TheMelodyOfAwakeningDragon))
                         AI.SelectNextCard(new[] { CardId.BlueEyesChaosMaxDragon, CardId.BlueEyesChaosMaxDragon, CardId.BlueEyesAlternativeWhiteDragon });
                     return UniqueFaceupSpell();
                 }
-                if (AI.Utils.GetLastChainCard().Id == CardId.LockBird)
+                if (lastCard.Id == CardId.LockBird)
                 {
                     AI.SelectCard(CardId.LockBird);
                     if (AI.Utils.ChainContainsCard(CardId.TheMelodyOfAwakeningDragon))
                         AI.SelectNextCard(new[] { CardId.BlueEyesChaosMaxDragon, CardId.BlueEyesChaosMaxDragon, CardId.BlueEyesAlternativeWhiteDragon });
                     return UniqueFaceupSpell();
                 }
-                if (AI.Utils.GetLastChainCard().Id == CardId.Ghost)
+                if (lastCard.Id == CardId.Ghost)
                 {
                     AI.SelectCard(CardId.Ghost);
                     if (AI.Utils.ChainContainsCard(CardId.TheMelodyOfAwakeningDragon))
                         AI.SelectNextCard(new[] { CardId.BlueEyesChaosMaxDragon, CardId.BlueEyesChaosMaxDragon, CardId.BlueEyesAlternativeWhiteDragon });
                     return UniqueFaceupSpell();
                 }
-                if (AI.Utils.GetLastChainCard().Id == CardId.AshBlossom)
+                if (lastCard.Id == CardId.AshBlossom)
                 {
                     AI.SelectCard(CardId.AshBlossom);
                     if (AI.Utils.ChainContainsCard(CardId.TheMelodyOfAwakeningDragon))

Game/AI/Decks/GrenMajuThunderBoarderExecutor.cs

@@ -13,6 +13,7 @@ namespace WindBot.Game.AI.Decks
         {
             public const int InspectBoarder = 15397015;
             public const int ThunderKingRaiOh = 71564252;
+            public const int AshBlossomAndJoyousSpring =14558127;
             public const int GhostReaperAndWinterCherries = 62015408;
             public const int GrenMajuDaEizo = 36584821;
             public const int MaxxC = 23434538;
@@ -29,9 +30,11 @@ namespace WindBot.Game.AI.Decks
             public const int WakingTheDragon = 10813327;
             public const int EvenlyMatched = 15693423;
             public const int HeavyStormDuster = 23924608;
+            public const int DrowningMirrorForce = 47475363;
             public const int MacroCosmos = 30241314;
             public const int AntiSpellFragrance = 58921041;
             public const int ImperialOrder = 61740673;
+            public const int PhatomKnightsSword = 61936647;
             public const int UnendingNightmare= 69452756;
             public const int SolemnWarning = 84749824;
             public const int SolemStrike= 40605147;
@@ -42,7 +45,7 @@ namespace WindBot.Game.AI.Decks
             public const int BorreloadDragon = 31833038;
             public const int BirrelswordDragon = 85289965;
             public const int FirewallDragon = 5043010;
-            public const int BingirsuTheWorldChaliceWarrior = 30194529;
+            public const int NingirsuTheWorldChaliceWarrior = 30194529;
             public const int TopologicTrisbaena = 72529749;
             public const int KnightmareUnicorn = 38342335;
             public const int KnightmarePhoenix = 2857636;
@@ -53,27 +56,32 @@ namespace WindBot.Game.AI.Decks
             public const int BrandishMaidenKagari= 63288573;
             public const int LinkSpider = 98978921;
             public const int Linkuriboh = 41999284;
+
+            public const int KnightmareGryphon = 65330383;
         }
 
         public GrenMajuThunderBoarderExecutor(GameAI ai, Duel duel)
             : base(ai, duel)
         {
-            AddExecutor(ExecutorType.GoToBattlePhase, EvenlyMatchedToBP);
+            AddExecutor(ExecutorType.GoToBattlePhase, GoToBattlePhase);
             AddExecutor(ExecutorType.Activate, CardId.EvenlyMatched, EvenlyMatchedeff);
             //Sticker
             AddExecutor(ExecutorType.Activate, CardId.MacroCosmos, MacroCosmoseff);
             AddExecutor(ExecutorType.Activate, CardId.AntiSpellFragrance, AntiSpellFragranceeff);
             //counter
-            AddExecutor(ExecutorType.Activate, CardId.MaxxC, MaxxCeff);            
-            AddExecutor(ExecutorType.Activate, CardId.InfiniteImpermanence, InfiniteImpermanenceeff);
+            AddExecutor(ExecutorType.Activate, CardId.AshBlossomAndJoyousSpring, DefaultAshBlossomAndJoyousSpring);
+            AddExecutor(ExecutorType.Activate, CardId.MaxxC, DefaultMaxxC);            
+            AddExecutor(ExecutorType.Activate, CardId.InfiniteImpermanence, DefaultInfiniteImpermanence);
             AddExecutor(ExecutorType.Activate, CardId.SolemnWarning, DefaultSolemnWarning);
             AddExecutor(ExecutorType.Activate, CardId.SolemStrike, DefaultSolemnStrike);
+            AddExecutor(ExecutorType.Activate, CardId.ImperialOrder, ImperialOrderfirst);
             AddExecutor(ExecutorType.Activate, CardId.HeavyStormDuster, HeavyStormDustereff);
             AddExecutor(ExecutorType.Activate, CardId.UnendingNightmare, UnendingNightmareeff);
-            AddExecutor(ExecutorType.Activate, CardId.DarkBribe);
+            AddExecutor(ExecutorType.Activate, CardId.DarkBribe, DarkBribeeff);
             AddExecutor(ExecutorType.Activate, CardId.ImperialOrder, ImperialOrdereff);
             AddExecutor(ExecutorType.Activate, CardId.ThunderKingRaiOh, ThunderKingRaiOheff);
             AddExecutor(ExecutorType.Activate, CardId.SolemnJudgment, DefaultSolemnJudgment);
+            AddExecutor(ExecutorType.Activate, CardId.DrowningMirrorForce, DrowningMirrorForceeff);
             //first do
             AddExecutor(ExecutorType.Activate, CardId.UpstartGoblin, UpstartGoblineff);
             AddExecutor(ExecutorType.Activate, CardId.HarpieFeatherDuster, DefaultHarpiesFeatherDusterFirst);
@@ -81,23 +89,25 @@ namespace WindBot.Game.AI.Decks
             AddExecutor(ExecutorType.Activate, CardId.PotOfDesires, PotOfDesireseff);
             AddExecutor(ExecutorType.Activate, CardId.CardOfDemise, CardOfDemiseeff);
             //sp
-            AddExecutor(ExecutorType.SpSummon, CardId.BorreloadDragon, BorreloadDragonsp);
-            AddExecutor(ExecutorType.Activate, CardId.BorreloadDragon, BorreloadDragoneff);            
-            AddExecutor(ExecutorType.Activate, CardId.EaterOfMillions, EaterOfMillionseff);
-            AddExecutor(ExecutorType.Activate, CardId.WakingTheDragon, WakingTheDragoneff);
             AddExecutor(ExecutorType.SpSummon, CardId.MissusRadiant, MissusRadiantsp);
             AddExecutor(ExecutorType.Activate, CardId.MissusRadiant, MissusRadianteff);
             AddExecutor(ExecutorType.Activate, CardId.Linkuriboh, Linkuriboheff);
             AddExecutor(ExecutorType.SpSummon, CardId.Linkuriboh, Linkuribohsp);
             AddExecutor(ExecutorType.SpSummon, CardId.LinkSpider);
+            AddExecutor(ExecutorType.SpSummon, CardId.BorreloadDragon, BorreloadDragonsp);
+            AddExecutor(ExecutorType.Activate, CardId.BorreloadDragon, BorreloadDragoneff);            
+            AddExecutor(ExecutorType.Activate, CardId.EaterOfMillions, EaterOfMillionseff);
+            AddExecutor(ExecutorType.Activate, CardId.WakingTheDragon, WakingTheDragoneff);
             // normal summon
             AddExecutor(ExecutorType.Summon, CardId.InspectBoarder, InspectBoardersummon);
             AddExecutor(ExecutorType.Summon, CardId.GrenMajuDaEizo, GrenMajuDaEizosummon);
             AddExecutor(ExecutorType.Summon, CardId.ThunderKingRaiOh, ThunderKingRaiOhsummon);
+            AddExecutor(ExecutorType.SpSummon, CardId.BorreloadDragon, BorreloadDragonspsecond);
             AddExecutor(ExecutorType.SpSummon, CardId.EaterOfMillions, EaterOfMillionssp);
             //spell          
             AddExecutor(ExecutorType.Activate, CardId.MoonMirrorShield, MoonMirrorShieldeff);
-            AddExecutor(ExecutorType.Activate, CardId.Scapegoat, Scapegoateff);
+            AddExecutor(ExecutorType.Activate, CardId.Scapegoat, DefaultScapegoat);
+            AddExecutor(ExecutorType.Activate, CardId.PhatomKnightsSword, PhatomKnightsSwordeff);
             AddExecutor(ExecutorType.Repos, MonsterRepos);
             //set
             AddExecutor(ExecutorType.SpellSet, SpellSet);
@@ -135,20 +145,9 @@ namespace WindBot.Game.AI.Decks
             base.OnNewPhase();
         }
 
-        private bool SpellWillBeNegated()
-        {
-            ClientCard card = null;
-            foreach (ClientCard check in Bot.GetSpells())
+        private bool GoToBattlePhase()
         {
-                if(check.Id==CardId.ImperialOrder && !check.IsDisabled())
-                    card = check;
-            }
-                
-            if (card!=null && card.IsFaceup())
-                return true;
-            if (Enemy.HasInSpellZone(CardId.ImperialOrder, true))
-                return true;
-            return false;
+            return Bot.HasInHand(CardId.EvenlyMatched) && Duel.Turn >= 2 && Enemy.GetFieldCount() >= 2 && Bot.GetFieldCount() == 0;
         }
  
         private bool MacroCosmoseff()
@@ -170,46 +169,9 @@ namespace WindBot.Game.AI.Decks
             return Duel.Player == 1 && UniqueFaceupSpell();
         }
  
-        private bool MaxxCeff()
-        {           
-            return Duel.Player == 1;
-        }
-
-        private bool EvenlyMatchedToBP()
-        {
-            return Bot.HasInHand(CardId.EvenlyMatched) && Bot.GetFieldCount() <= 1 && Duel.Turn >= 2 && Enemy.GetFieldCount() - Bot.GetFieldCount() >= 2;
-        }
-
         private bool EvenlyMatchedeff()
         {
-            return true;
-        }
-        private bool InfiniteImpermanenceeff()
-        {
-            AI.SelectPlace(Zones.z2);
-            ClientCard target = Enemy.MonsterZone.GetShouldBeDisabledBeforeItUseEffectMonster();
-            if(target!=null)
-            {
-                AI.SelectCard(target);
-                return true;
-            }
-            if(Duel.LastChainPlayer==1)
-            {
-                foreach (ClientCard check in Enemy.GetMonsters())
-                {
-                    if(AI.Utils.GetLastChainCard()==check)
-                    {
-                        target = check;
-                        break;
-                    }
-                }
-                if(target!=null)
-                {
-                    AI.SelectCard(target);
-                    return true;
-                }
-            }
-            return false;
+            return Enemy.GetFieldCount()-Bot.GetFieldCount() > 1;
         }
  
         private bool HeavyStormDustereff()
@@ -219,6 +181,16 @@ namespace WindBot.Game.AI.Decks
             {
                 if (check.HasType(CardType.Continuous) || check.HasType(CardType.Field))
                     targets.Add(check);
+                
+            }
+            if (AI.Utils.GetPZone(1, 0) != null && AI.Utils.GetPZone(1, 0).Type == 16777218)
+            {
+                targets.Add(AI.Utils.GetPZone(1, 0));
+                
+            }
+            if (AI.Utils.GetPZone(1, 1) != null && AI.Utils.GetPZone(1, 1).Type == 16777218)
+            {
+                targets.Add(AI.Utils.GetPZone(1, 1));               
             }
             foreach (ClientCard check in Enemy.GetSpells())
             {
@@ -230,9 +202,15 @@ namespace WindBot.Game.AI.Decks
                 AI.SelectCard(targets);
                 return true;
             }
+            int count = 0;
+            foreach(ClientCard check in Enemy.GetSpells())
+            {
+                if (check.Type == 16777218)
+                    count++;
+            }
             if(AI.Utils.GetLastChainCard()!=null && 
                 (AI.Utils.GetLastChainCard().HasType(CardType.Continuous)||
-                AI.Utils.GetLastChainCard().HasType(CardType.Field)) &&
+                AI.Utils.GetLastChainCard().HasType(CardType.Field) || count==2) &&
                 Duel.LastChainPlayer==1)               
                 {
                 AI.SelectCard(targets);
@@ -242,7 +220,6 @@ namespace WindBot.Game.AI.Decks
         }
         private bool UnendingNightmareeff()
         {
-          
             ClientCard card = null;
             foreach(ClientCard check in Enemy.GetSpells())
             {
@@ -250,7 +227,21 @@ namespace WindBot.Game.AI.Decks
                     card = check;
                 break;
             }
-            if(card!=null && Bot.LifePoints>1000)
+            int count = 0;
+            foreach (ClientCard check in Enemy.GetSpells())
+            {
+                if (check.Type == 16777218)
+                    count++;
+            }
+            if(count==2)
+            {
+                if (AI.Utils.GetPZone(1, 1) != null && AI.Utils.GetPZone(1, 1).Type == 16777218)
+                {
+                    card=AI.Utils.GetPZone(1, 1);
+                }
+            }
+                
+            if (card!=null && Bot.LifePoints>1000)
             {
                 AI.SelectCard(card);
                 return true;
@@ -258,12 +249,27 @@ namespace WindBot.Game.AI.Decks
             return false;
         }
 
-        private bool ImperialOrdereff()
+        private bool DarkBribeeff()
+        {
+            if (AI.Utils.GetLastChainCard()!=null && AI.Utils.GetLastChainCard().Id == CardId.UpstartGoblin)
+                return false;
+            return true;
+
+        }
+        private bool ImperialOrderfirst()
         {
+            if (AI.Utils.GetLastChainCard() != null && AI.Utils.GetLastChainCard().Id == CardId.UpstartGoblin)
+                return false;
+            return DefaultOnBecomeTarget() && AI.Utils.GetLastChainCard().HasType(CardType.Spell);
+        }
 
+        private bool ImperialOrdereff()
+        {
+            if (AI.Utils.GetLastChainCard() != null && AI.Utils.GetLastChainCard().Id == CardId.UpstartGoblin)
+                return false;
             if (Duel.LastChainPlayer == 1)
             {
-                foreach(ClientCard check in Enemy.SpellZone)
+                foreach(ClientCard check in Enemy.GetSpells())
                 {
                     if (AI.Utils.GetLastChainCard() == check)
                         return true;
@@ -271,15 +277,27 @@ namespace WindBot.Game.AI.Decks
             }
             return false;
         }
-
+        private bool DrowningMirrorForceeff()
+        {
+            if(Enemy.GetMonsterCount() ==1)
+            {
+                if(Enemy.BattlingMonster.Attack-Bot.LifePoints>=1000)
+                    return DefaultUniqueTrap();
+            }
+            if (AI.Utils.GetTotalAttackingMonsterAttack(1) >= Bot.LifePoints)
+                return DefaultUniqueTrap();
+            if (Enemy.GetMonsterCount() >= 2)
+                return DefaultUniqueTrap();
+            return false;
+        }
         private bool UpstartGoblineff()
         {         
-            return !SpellWillBeNegated();
+            return !DefaultSpellWillBeNegated();
         }
 
         private bool PotOfDualityeff()
         {
-            if (SpellWillBeNegated())
+            if (DefaultSpellWillBeNegated())
                 return false;          
             int count = 0;
             if (Bot.GetMonsterCount() > 0)
@@ -289,6 +307,20 @@ namespace WindBot.Game.AI.Decks
                 if (card.HasType(CardType.Monster))
                     count++;
             }
+            if(AI.Utils.GetBestEnemyMonster()!=null && AI.Utils.GetBestEnemyMonster().Attack>=1900)
+                AI.SelectCard(new[]
+                   {
+                     CardId.EaterOfMillions,
+                    CardId.PotOfDesires,
+                    CardId.GrenMajuDaEizo,
+                    CardId.InspectBoarder,
+                    CardId.ThunderKingRaiOh,                  
+                    CardId.Scapegoat,
+                    CardId.SolemnJudgment,
+                    CardId.SolemnWarning,
+                    CardId.SolemStrike,
+                    CardId.InfiniteImpermanence,
+                });
             if (count == 0)
                 AI.SelectCard(new[]
                 {
@@ -297,6 +329,7 @@ namespace WindBot.Game.AI.Decks
                     CardId.ThunderKingRaiOh,
                     CardId.EaterOfMillions,
                     CardId.GrenMajuDaEizo,
+                    CardId.Scapegoat,
                 });
             else
             {
@@ -308,6 +341,7 @@ namespace WindBot.Game.AI.Decks
                     CardId.SolemnWarning,
                     CardId.SolemStrike,
                     CardId.InfiniteImpermanence,
+                    CardId.Scapegoat,
                 });
             }
             return true;
@@ -315,12 +349,13 @@ namespace WindBot.Game.AI.Decks
 
         private bool PotOfDesireseff()
         {
-            return Bot.Deck.Count > 14 && !SpellWillBeNegated();
+            if (CardOfDemiseeff_used) return false;          
+            return Bot.Deck.Count > 14 && !DefaultSpellWillBeNegated();
         }
 
         private bool CardOfDemiseeff()
         {          
-            if(Bot.Hand.Count == 1 && Bot.GetSpellCountWithoutField() <= 3 && !SpellWillBeNegated())
+            if (Bot.Hand.Count == 1 && Bot.GetSpellCountWithoutField() <= 3 && !DefaultSpellWillBeNegated())
             {
                 CardOfDemiseeff_used = true;
                 return true;
@@ -333,7 +368,7 @@ namespace WindBot.Game.AI.Decks
             if(Card.Location==CardLocation.Hand)
             {
                 if (Bot.GetMonsterCount() == 0) return false;
-                return !SpellWillBeNegated();
+                return !DefaultSpellWillBeNegated();
             }
             if(Card.Location==CardLocation.Grave)
             {
@@ -342,59 +377,67 @@ namespace WindBot.Game.AI.Decks
             return false;
         }
 
-        private bool Scapegoateff()
+        private bool PhatomKnightsSwordeff()
         {
-            if (SpellWillBeNegated()) return false;
-            if (Duel.Player == 0) return false;
-            if (Duel.Phase == DuelPhase.End) return true;
-            if (Duel.LastChainPlayer == 1 && (AI.Utils.IsChainTarget(Card) || (DefaultOnBecomeTarget() && !Bot.HasInSpellZone(CardId.WakingTheDragon)))) return true;
-            if (Duel.Phase > DuelPhase.Main1 && Duel.Phase < DuelPhase.Main2)
+            if (Card.IsFaceup())
+                return true;
+            if(Duel.Phase==DuelPhase.BattleStart && Bot.BattlingMonster!=null && Enemy.BattlingMonster!=null)
             {                
-                int total_atk = 0;
-                List<ClientCard> enemy_monster = Enemy.GetMonsters();
-                foreach (ClientCard m in enemy_monster)
+                if (Bot.BattlingMonster.Attack + 800 >= Enemy.BattlingMonster.GetDefensePower())
                 {
-                    if (m.IsAttack() && !m.Attacked) total_atk += m.Attack;
+                    AI.SelectCard(Bot.BattlingMonster);
+                    return DefaultUniqueTrap();
                 }                
-                if (total_atk >= Bot.LifePoints) return true;
             }
             return false;
         }
-
         private bool InspectBoardersummon()
         {           
-            AI.SelectPlace(Zones.z4 | Zones.z0);
+            if (Bot.MonsterZone[0] == null)
+                AI.SelectPlace(Zones.z0);
+            else
+                AI.SelectPlace(Zones.z4);
             return true;
         }
         private bool GrenMajuDaEizosummon()
         {
             if (Duel.Turn == 1) return false;           
-            AI.SelectPlace(Zones.z4 | Zones.z0);
+            if (Bot.MonsterZone[0] == null)
+                AI.SelectPlace(Zones.z0);
+            else
+                AI.SelectPlace(Zones.z4);
             return Bot.Banished.Count >= 6;
         }
 
         private bool ThunderKingRaiOhsummon()
         { 
-            AI.SelectPlace(Zones.z4 | Zones.z0);
+            if (Bot.MonsterZone[0] == null)
+                AI.SelectPlace(Zones.z0);
+            else
+                AI.SelectPlace(Zones.z4);
             return true;
         }
 
         private bool ThunderKingRaiOheff()
         {
-            foreach (ClientCard card in Duel.SummoningCards)
+           if(Duel.SummoningCards.Count > 0)
            {
-                if (card.Attack >= 1900)
+                foreach(ClientCard m in Duel.SummoningCards)
+                {
+                    if (m.Attack >= 1900)
                         return true;
                 }
+           }            
             return false;
         }
 
         private bool BorreloadDragonsp()
         {
+            if (!Bot.HasInMonstersZone(CardId.MissusRadiant)) return false;
             IList<ClientCard> material_list = new List<ClientCard>();
             foreach (ClientCard monster in Bot.GetMonsters())
             {
-                if (monster.Id != CardId.EaterOfMillions)
+                if (monster.Id ==CardId.MissusRadiant || monster.Id==CardId.LinkSpider || monster.Id==CardId.Linkuriboh)
                     material_list.Add(monster);
                 if (material_list.Count == 3) break;
             }
@@ -405,10 +448,29 @@ namespace WindBot.Game.AI.Decks
             }
             return false;
         }
-
+        private bool BorreloadDragonspsecond()
+        {
+            if (!Bot.HasInMonstersZone(CardId.MissusRadiant)) return false;
+            IList<ClientCard> material_list = new List<ClientCard>();
+            foreach (ClientCard monster in Bot.GetMonsters())
+            {
+                if ((monster.Id == CardId.MissusRadiant || 
+                    monster.Id == CardId.LinkSpider || 
+                    monster.Id == CardId.Linkuriboh )&&
+                    monster.Id!=CardId.EaterOfMillions)
+                    material_list.Add(monster);
+                if (material_list.Count == 3) break;
+            }
+            if (material_list.Count >= 3)
+            {
+                AI.SelectMaterials(material_list);
+                return true;
+            }
+            return false;
+        }
         public bool BorreloadDragoneff()
         {
-            if (ActivateDescription == -1)
+            if (ActivateDescription == -1 && (Duel.Phase==DuelPhase.BattleStart||Duel.Phase==DuelPhase.End))
             {
                 ClientCard enemy_monster = Enemy.BattlingMonster;
                 if (enemy_monster != null && enemy_monster.HasPosition(CardPosition.Attack))
@@ -431,6 +493,11 @@ namespace WindBot.Game.AI.Decks
 
         private bool EaterOfMillionssp()
         {
+            if (Bot.MonsterZone[0] == null)
+                AI.SelectPlace(Zones.z0);
+            else
+                AI.SelectPlace(Zones.z4);
+            if (Enemy.HasInMonstersZone(CardId.KnightmareGryphon, true)) return false;
             if (Bot.HasInMonstersZone(CardId.InspectBoarder) && !eater_eff) return false;           
             if (AI.Utils.GetProblematicEnemyMonster() == null && Bot.ExtraDeck.Count < 5) return false;
             if (Bot.GetMonstersInMainZone().Count >= 5) return false;
@@ -456,6 +523,7 @@ namespace WindBot.Game.AI.Decks
                         CardId.BirrelswordDragon,
                         CardId.RaidraptorUltimateFalcon,
                     });*/
+                   
                     AI.SelectPlace(Zones.z4 | Zones.z0);
                     return true;
                 }
@@ -475,7 +543,8 @@ namespace WindBot.Game.AI.Decks
 
         private bool EaterOfMillionseff()
         {
-            //if (Enemy.BattlingMonster.HasPosition(CardPosition.Attack) && (Bot.BattlingMonster.Attack - Enemy.BattlingMonster.GetDefensePower() >= Enemy.LifePoints)) return false;
+            if (Enemy.BattlingMonster.HasPosition(CardPosition.Attack) && (Bot.BattlingMonster.Attack - Enemy.BattlingMonster.GetDefensePower() >= Enemy.LifePoints)) return false;
+            
             return true;
         }
 
@@ -497,7 +566,10 @@ namespace WindBot.Game.AI.Decks
             if (material_list.Count < 2) return false;
             if (Bot.HasInMonstersZone(CardId.MissusRadiant)) return false;
             AI.SelectMaterials(material_list);
-            AI.SelectPlace(Zones.z5 | Zones.z6);
+            if (Bot.MonsterZone[0] == null && Bot.MonsterZone[2] == null && Bot.MonsterZone[5] == null)
+                AI.SelectPlace(Zones.z5);
+            else
+                AI.SelectPlace(Zones.z6);
             return true;
         }
 
@@ -513,12 +585,11 @@ namespace WindBot.Game.AI.Decks
 
         private bool Linkuribohsp()
         {            
-            
             foreach (ClientCard c in Bot.GetMonsters())
             {
-                if (c.Id != CardId.EaterOfMillions && c.Level == 1 && c.Id != CardId.Linkuriboh && c.Id != CardId.LinkSpider)
+                if (c.Id != CardId.EaterOfMillions  && c.Id != CardId.Linkuriboh && c.Level==1 )
                 {
-                    AI.SelectCard(c);
+                    AI.SelectMaterials(c);
                     return true;
                 }
             }
@@ -549,10 +620,11 @@ namespace WindBot.Game.AI.Decks
             if (Card.Id == CardId.MacroCosmos && Bot.HasInSpellZone(CardId.MacroCosmos)) return false;
             if (Card.Id == CardId.AntiSpellFragrance && Bot.HasInSpellZone(CardId.AntiSpellFragrance)) return false;
             if (CardOfDemiseeff_used)return true;            
-            //if (Duel.Turn > 1 && Duel.Phase != DuelPhase.Main2) return false;
             if (Card.Id == CardId.EvenlyMatched && (Enemy.GetFieldCount() - Bot.GetFieldCount()) < 0) return false;
             if (Card.Id == CardId.AntiSpellFragrance && Bot.HasInSpellZone(CardId.AntiSpellFragrance)) return false;
             if (Card.Id == CardId.MacroCosmos && Bot.HasInSpellZone(CardId.MacroCosmos)) return false;
+            if (Duel.Turn > 1 && Duel.Phase == DuelPhase.Main1 && Bot.HasAttackingMonster())
+                return false;
             if (Card.Id == CardId.InfiniteImpermanence)
                 return Bot.GetFieldCount() > 0 && Bot.GetSpellCountWithoutField() < 4;
             if (Card.Id == CardId.Scapegoat)
@@ -570,13 +642,12 @@ namespace WindBot.Game.AI.Decks
         }
         public override bool OnPreBattleBetween(ClientCard attacker, ClientCard defender)
         {
-            
-            if (attacker.Id==CardId.EaterOfMillions && (Bot.HasInMonstersZone(CardId.InspectBoarder) && eater_eff))
+            if (attacker.Id == _CardId.EaterOfMillions && (Bot.HasInMonstersZone(CardId.InspectBoarder) && eater_eff) && !attacker.IsDisabled())
             {
                 attacker.RealPower = 9999;
                 return true;
             }
-            if (attacker.Id == CardId.EaterOfMillions && !Bot.HasInMonstersZone(CardId.InspectBoarder))
+            if (attacker.Id == _CardId.EaterOfMillions && !Bot.HasInMonstersZone(CardId.InspectBoarder) && !attacker.IsDisabled())
             {
                 attacker.RealPower = 9999;
                 return true;

Game/AI/Decks/LightswornExecutor.cs

@@ -91,6 +91,7 @@ namespace WindBot.Game.AI.Decks
         public override void OnNewTurn()
         {
             ClownUsed = false;
+            base.OnNewTurn();
         }
 
         public override bool OnPreBattleBetween(ClientCard attacker, ClientCard defender)
@@ -114,8 +115,8 @@ namespace WindBot.Game.AI.Decks
                 if (result.Count >= max)
                     break;
             }
-            AI.Utils.CheckSelectCount(result, cards, min, max);
-            return result;
+            
+            return AI.Utils.CheckSelectCount(result, cards, min, max);
         }
 
         private bool ReinforcementOfTheArmyEffect()

Game/AI/Decks/LightswornShaddoldinosourExecutor.cs

@@ -1098,6 +1098,7 @@ namespace WindBot.Game.AI.Decks
                 if (targets.Count == 0)
                     return false;
 
+                AI.SelectCard(0);
                 AI.SelectNextCard(targets);
                 return true;
             }
@@ -1260,7 +1261,7 @@ namespace WindBot.Game.AI.Decks
 
         private bool RedWyverneff()
         {
-            IList<ClientCard> check = Enemy.MonsterZone;
+            IList<ClientCard> check = Enemy.GetMonsters();
             ClientCard best = null;
             foreach (ClientCard monster in check)
             {

Game/AI/Decks/RainbowExecutor.cs

@@ -172,8 +172,8 @@ namespace WindBot.Game.AI.Decks
                 if (result.Count > 0)
                     break;
             }
-            AI.Utils.CheckSelectCount(result, cards, min, max);
-            return result;
+            
+            return AI.Utils.CheckSelectCount(result, cards, min, max);
         }
 
         private bool UnexpectedDaiEffect()

Game/AI/Decks/Rank5Executor.cs

@@ -120,15 +120,13 @@ namespace WindBot.Game.AI.Decks
 
         public override IList<ClientCard> OnSelectXyzMaterial(IList<ClientCard> cards, int min, int max)
         {
-            IList<ClientCard> result = new List<ClientCard>();
-            AI.Utils.SelectPreferredCards(result, new[] {
+            IList<ClientCard> result = AI.Utils.SelectPreferredCards(new[] {
                 CardId.MistArchfiend,
                 CardId.PanzerDragon,
                 CardId.SolarWindJammer,
                 CardId.StarDrawing
             }, cards, min, max);
-            AI.Utils.CheckSelectCount(result, cards, min, max);
-            return result;
+            return AI.Utils.CheckSelectCount(result, cards, min, max);
         }
 
         private bool NormalSummon()

Game/AI/Decks/YosenjuExecutor.cs

@@ -181,10 +181,8 @@ namespace WindBot.Game.AI.Decks
 
         public override IList<ClientCard> OnSelectXyzMaterial(IList<ClientCard> cards, int min, int max)
         {
-            IList<ClientCard> result = new List<ClientCard>();
-            AI.Utils.SelectPreferredCards(result, CardId.YosenjuTsujik, cards, min, max);
-            AI.Utils.CheckSelectCount(result, cards, min, max);
-            return result;
+            IList<ClientCard> result = AI.Utils.SelectPreferredCards(CardId.YosenjuTsujik, cards, min, max);
+            return AI.Utils.CheckSelectCount(result, cards, min, max);
         }
 
         private bool PotOfDualityEffect()

Game/AI/Decks/ZexalWeaponsExecutor.cs

-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using WindBot;
 using WindBot.Game;
 using WindBot.Game.AI;
@@ -103,7 +104,7 @@ namespace WindBot.Game.AI.Decks
             // Summons: Effects
             AddExecutor(ExecutorType.Activate, CardId.Goblindbergh, GoblindberghEffect);
             AddExecutor(ExecutorType.Activate, CardId.TinGoldfish, GoblindberghEffect);
-            AddExecutor(ExecutorType.Activate, CardId.Kagetokage);
+            AddExecutor(ExecutorType.Activate, CardId.Kagetokage, KagetokageEffect);
             AddExecutor(ExecutorType.Activate, CardId.SummonerMonk, SummonerMonkEffect);
             AddExecutor(ExecutorType.Activate, CardId.Honest, DefaultHonestEffect);
 
@@ -138,14 +139,12 @@ namespace WindBot.Game.AI.Decks
 
         public override IList<ClientCard> OnSelectXyzMaterial(IList<ClientCard> cards, int min, int max)
         {
-            IList<ClientCard> result = new List<ClientCard>();
-            AI.Utils.SelectPreferredCards(result, new[] {
+            IList<ClientCard> result = AI.Utils.SelectPreferredCards(new[] {
                 CardId.StarDrawing,
                 CardId.SolarWindJammer,
                 CardId.Goblindbergh
             }, cards, min, max);
-            AI.Utils.CheckSelectCount(result, cards, min, max);
-            return result;
+            return AI.Utils.CheckSelectCount(result, cards, min, max);
         }
 
         private bool Number39Utopia()
@@ -235,6 +234,13 @@ namespace WindBot.Game.AI.Decks
             return true;
         }
 
+        private bool KagetokageEffect()
+        {
+            var lastChainCard = AI.Utils.GetLastChainCard();
+            if (lastChainCard == null) return true;
+            return lastChainCard.Id != CardId.Goblindbergh && lastChainCard.Id != CardId.TinGoldfish;
+        }
+
         private bool SummonerMonkEffect()
         {
             IList<int> costs = new[]

Game/AI/DefaultExecutor.cs

 using System;
 using System.Collections.Generic;
+using System.Linq;
 using YGOSharp.OCGWrapper.Enums;
 using WindBot;
 using WindBot.Game;
@@ -21,10 +22,15 @@ namespace WindBot.Game.AI
             public const int SuperAntiKaijuWarMachineMechaDogoran = 84769941;
 
             public const int UltimateConductorTytanno = 18940556;
+            public const int ElShaddollConstruct = 20366274;
+            public const int AllyOfJusticeCatastor = 26593852;
 
             public const int DupeFrog = 46239604;
             public const int MaraudingCaptain = 2460565;
 
+            public const int BlackRoseDragon = 73580471;
+            public const int JudgmentDragon = 57774843;
+            public const int TopologicTrisbaena = 72529749;
             public const int EvilswarmExcitonKnight = 46772449;
             public const int HarpiesFeatherDuster = 18144506;
             public const int DarkMagicAttack = 2314238;
@@ -38,7 +44,8 @@ namespace WindBot.Game.AI
             public const int Number39Utopia = 84013237;
             public const int UltimayaTzolkin = 1686814;
 
-            public const int VampireFräulein = 6039967;
+            public const int MoonMirrorShield = 19508728;
+            public const int VampireFraeulein = 6039967;
             public const int InjectionFairyLily = 79575620;
 
             public const int BlueEyesChaosMAXDragon = 55410871;
@@ -54,9 +61,23 @@ namespace WindBot.Game.AI
             public const int GalaxySoldier = 46659709;
             public const int MacroCosmos = 30241314;
             public const int UpstartGoblin = 70368879;
+            public const int CyberEmergency = 60600126;
+
             public const int EaterOfMillions = 63845230;
+
+            public const int InvokedPurgatrio = 12307878;
+            public const int ChaosAncientGearGiant = 51788412;
+            public const int UltimateAncientGearGolem = 12652643;
+
+            public const int RedDragonArchfiend = 70902743;
+
+            public const int ImperialOrder = 61740673;
+            public const int NaturiaBeast = 33198837;
+            public const int AntiSpellFragrance = 58921041;
         }
 
+        int HonestEffectCount = 0;
+
         protected DefaultExecutor(GameAI ai, Duel duel)
             : base(ai, duel)
         {
@@ -71,10 +92,8 @@ namespace WindBot.Game.AI
         /// <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)
+            foreach (ClientCard defender in defenders)
             {
-                ClientCard defender = defenders[i];
-
                 attacker.RealPower = attacker.Attack;
                 defender.RealPower = defender.GetDefensePower();
                 if (!OnPreBattleBetween(attacker, defender))
@@ -109,30 +128,53 @@ namespace WindBot.Game.AI
 
                 if (defender.IsMonsterDangerous())
                 {
-                    bool canignoreit = false;
-                    if (attacker.Id == _CardId.UltimateConductorTytanno && !attacker.IsDisabled() && defender.IsDefense())
-                        canignoreit = true;
-                    if (!canignoreit)
+                    bool canIgnoreIt = !attacker.IsDisabled() && (
+                        attacker.Id == _CardId.UltimateConductorTytanno && defender.IsDefense() || 
+                        attacker.Id == _CardId.ElShaddollConstruct && defender.IsSpecialSummoned ||
+                        attacker.Id == _CardId.AllyOfJusticeCatastor && !defender.HasAttribute(CardAttribute.Dark));
+                    if (!canIgnoreIt)
                         return false;
                 }
 
-                if (defender.Id == _CardId.CrystalWingSynchroDragon && defender.IsAttack() && !defender.IsDisabled() && attacker.Level >= 5)
+                foreach (ClientCard equip in defender.EquipCards)
+                {
+                    if (equip.Id == _CardId.MoonMirrorShield && !equip.IsDisabled())
+                    {
+                        return false;
+                    }
+                }
+
+                if (!defender.IsDisabled())
+                {
+                    if (defender.Id == _CardId.CrystalWingSynchroDragon && defender.IsAttack() && attacker.Level >= 5)
+                        return false;
+
+                    if (defender.Id == _CardId.AllyOfJusticeCatastor && !attacker.HasAttribute(CardAttribute.Dark))
                         return false;
 
-                if (defender.Id == _CardId.NumberS39UtopiaTheLightning && defender.IsAttack() && !defender.IsDisabled() && defender.HasXyzMaterial(2, _CardId.Number39Utopia))
+                    if (defender.Id == _CardId.NumberS39UtopiaTheLightning && defender.IsAttack() && defender.HasXyzMaterial(2, _CardId.Number39Utopia))
                         defender.RealPower = 5000;
 
-                if (defender.Id == _CardId.VampireFräulein && !defender.IsDisabled())
+                    if (defender.Id == _CardId.VampireFraeulein)
                         defender.RealPower += (Enemy.LifePoints > 3000) ? 3000 : (Enemy.LifePoints - 100);
 
-                if (defender.Id == _CardId.InjectionFairyLily && !defender.IsDisabled() && Enemy.LifePoints > 2000)
+                    if (defender.Id == _CardId.InjectionFairyLily && Enemy.LifePoints > 2000)
                         defender.RealPower += 3000;
                 }
+            }
 
             if (!defender.IsMonsterHasPreventActivationEffectInBattle())
             {
                 if (attacker.Id == _CardId.NumberS39UtopiaTheLightning && !attacker.IsDisabled() && attacker.HasXyzMaterial(2, _CardId.Number39Utopia))
                     attacker.RealPower = 5000;
+
+                foreach (ClientCard equip in attacker.EquipCards)
+                {
+                    if (equip.Id == _CardId.MoonMirrorShield && !equip.IsDisabled())
+                    {
+                        attacker.RealPower = defender.RealPower + 100;
+                    }
+                }
             }
 
             if (Enemy.HasInMonstersZone(_CardId.DupeFrog, true) && defender.Id != _CardId.DupeFrog)
@@ -141,15 +183,8 @@ namespace WindBot.Game.AI
             if (Enemy.HasInMonstersZone(_CardId.MaraudingCaptain, true) && defender.Id != _CardId.MaraudingCaptain && defender.Race == (int)CardRace.Warrior)
                 return false;
 
-            if (defender.Id == _CardId.UltimayaTzolkin && !defender.IsDisabled())
-            {
-                List<ClientCard> monsters = Enemy.GetMonsters();
-                foreach (ClientCard monster in monsters)
-                {
-                    if (monster.HasType(CardType.Synchro))
+            if (defender.Id == _CardId.UltimayaTzolkin && !defender.IsDisabled() && Enemy.GetMonsters().Any(monster => !monster.Equals(defender) && monster.HasType(CardType.Synchro)))
                 return false;
-                }
-            }
 
             return true;
         }
@@ -186,14 +221,20 @@ namespace WindBot.Game.AI
             return false;
         }
 
+        public override void OnNewTurn()
+        {
+            HonestEffectCount = 0;
+        }
+
         /// <summary>
         /// Destroy face-down cards first, in our turn.
         /// </summary>
         protected bool DefaultMysticalSpaceTyphoon()
         {
-            foreach (ClientCard card in Duel.CurrentChain)
-                if (card.Id == _CardId.MysticalSpaceTyphoon)
+            if (Duel.CurrentChain.Any(card => card.Id == _CardId.MysticalSpaceTyphoon))
+            {
                 return false;
+            }
 
             List<ClientCard> spells = Enemy.GetSpells();
             if (spells.Count == 0)
@@ -203,14 +244,10 @@ namespace WindBot.Game.AI
 
             if (selected == null)
             {
-                foreach (ClientCard card in spells)
-                {
-                    if (Duel.Player == 1 && !card.HasType(CardType.Continuous))
-                        continue;
-                    selected = card;
-                    if (Duel.Player == 0 && card.IsFacedown())
-                        break;
-                }
+                if (Duel.Player == 0)
+                    selected = spells.FirstOrDefault(card => card.IsFacedown());
+                if (Duel.Player == 1)
+                    selected = spells.FirstOrDefault(card => card.HasType(CardType.Continuous) || card.HasType(CardType.Equip));
             }
 
             if (selected == null)
@@ -247,14 +284,7 @@ namespace WindBot.Game.AI
             }
             else
             {
-                foreach (ClientCard card in spells)
-                {
-                    if (card.IsFacedown())
-                    {
-                        selected = card;
-                        break;
-                    }
-                }
+                selected = spells.FirstOrDefault(card => card.IsFacedown());
             }
 
             if (selected == null)
@@ -271,7 +301,7 @@ namespace WindBot.Game.AI
         {
             if (AI.Utils.IsAllEnemyBetter(true))
             {
-                ClientCard monster = Enemy.GetMonsters().GetHighestAttackMonster();
+                ClientCard monster = Enemy.GetMonsters().GetHighestAttackMonster(true);
                 if (monster != null && monster.HasType(CardType.Effect) && !monster.HasType(CardType.Link) && (monster.HasType(CardType.Xyz) || monster.Level > 4))
                 {
                     AI.SelectCard(monster);
@@ -286,7 +316,7 @@ namespace WindBot.Game.AI
         /// </summary>
         protected bool DefaultCompulsoryEvacuationDevice()
         {
-            ClientCard target = AI.Utils.GetProblematicEnemyMonster();
+            ClientCard target = AI.Utils.GetProblematicEnemyMonster(0, true);
             if (target != null)
             {
                 AI.SelectCard(target);
@@ -294,7 +324,7 @@ namespace WindBot.Game.AI
             }
             if (AI.Utils.IsChainTarget(Card))
             {
-                ClientCard monster = AI.Utils.GetBestEnemyMonster();
+                ClientCard monster = AI.Utils.GetBestEnemyMonster(false, true);
                 if (monster != null)
                 {
                     AI.SelectCard(monster);
@@ -311,20 +341,34 @@ namespace WindBot.Game.AI
         {
             if (!AI.Utils.IsAllEnemyBetter(true))
                 return false;
-            ClientCard selected = null;
-            int BestAtk = 0;
-            foreach (ClientCard card in Bot.Graveyard)
-            {
-                if (card.Attack > BestAtk)
-                {
-                    BestAtk = card.Attack;
-                    selected = card;
-                }
-            }
+            ClientCard selected = Bot.Graveyard.OrderByDescending(card => card.Attack).FirstOrDefault();
             AI.SelectCard(selected);
             return true;
         }
 
+        /// <summary>
+        /// Default Scapegoat effect
+        /// </summary>
+        protected bool DefaultScapegoat()
+        {
+            if (DefaultSpellWillBeNegated()) return false;
+            if (Duel.Player == 0) return false;
+            if (Duel.Phase == DuelPhase.End) return true;
+            if (DefaultOnBecomeTarget()) return true;
+            if (Duel.Phase > DuelPhase.Main1 && Duel.Phase < DuelPhase.Main2)
+            {
+                if (Enemy.HasInMonstersZone(new []
+                {
+                    _CardId.UltimateConductorTytanno,
+                    _CardId.InvokedPurgatrio,
+                    _CardId.ChaosAncientGearGiant,
+                    _CardId.UltimateAncientGearGolem,
+                    _CardId.RedDragonArchfiend
+                }, true)) return false;
+                if (AI.Utils.GetTotalAttackingMonsterAttack(1) >= Bot.LifePoints) return true;
+            }
+            return false;
+        }
         /// <summary>
         /// Always active in opponent's turn.
         /// </summary>
@@ -337,9 +381,12 @@ namespace WindBot.Game.AI
         /// </summary>
         protected bool DefaultAshBlossomAndJoyousSpring()
         {
-            if (AI.Utils.GetLastChainCard().Id == _CardId.MacroCosmos)
-                return false;
-            if (AI.Utils.GetLastChainCard().Id == _CardId.UpstartGoblin)
+            int[] ignoreList = {
+                _CardId.MacroCosmos,
+                _CardId.UpstartGoblin,
+                _CardId.CyberEmergency
+            };
+            if (ignoreList.Contains(AI.Utils.GetLastChainCard().Id))
                 return false;
             return Duel.LastChainPlayer == 1;
         }
@@ -374,32 +421,23 @@ namespace WindBot.Game.AI
         /// </summary>
         protected bool DefaultCalledByTheGrave()
         {
-            if (Duel.LastChainPlayer == 1)
-            {
-                if (AI.Utils.GetLastChainCard().Id == _CardId.MaxxC)
+            int[] targetList =
             {
-                    AI.SelectCard(_CardId.MaxxC);
-                    return UniqueFaceupSpell();
-                }
-                if (AI.Utils.GetLastChainCard().Id == _CardId.LockBird)
+                _CardId.MaxxC,
+                _CardId.LockBird,
+                _CardId.GhostOgreAndSnowRabbit,
+                _CardId.AshBlossom,
+                _CardId.GhostBelle
+            };
+            if (Duel.LastChainPlayer == 1)
             {
-                    AI.SelectCard(_CardId.LockBird);
-                    return UniqueFaceupSpell();
-                }
-                if (AI.Utils.GetLastChainCard().Id == _CardId.GhostOgreAndSnowRabbit)
+                foreach (int id in targetList)
                 {
-                    AI.SelectCard(_CardId.GhostOgreAndSnowRabbit);
-                    return UniqueFaceupSpell();
-                }
-                if (AI.Utils.GetLastChainCard().Id == _CardId.AshBlossom)
+                    if (AI.Utils.GetLastChainCard().Id == id)
                     {
-                    AI.SelectCard(_CardId.AshBlossom);
+                        AI.SelectCard(id);
                         return UniqueFaceupSpell();
                     }
-                if (AI.Utils.GetLastChainCard().Id == _CardId.GhostBelle)
-                {
-                    AI.SelectCard(_CardId.GhostBelle);
-                    return UniqueFaceupSpell();
                 }
             }
             return false;
@@ -408,6 +446,19 @@ namespace WindBot.Game.AI
         /// Default InfiniteImpermanence effect
         /// </summary>
         protected bool DefaultInfiniteImpermanence()
+        {            
+            // TODO: disable s & t
+            return DefaultBreakthroughSkill();
+        }
+        /// <summary>
+        /// Chain the enemy monster, or disable monster like Rescue Rabbit.
+        /// </summary>
+        protected bool DefaultBreakthroughSkill()
+        {
+            if (!DefaultUniqueTrap())
+                return false;
+
+            if (Duel.Player == 1)
             {
                 ClientCard target = Enemy.MonsterZone.GetShouldBeDisabledBeforeItUseEffectMonster();
                 if (target != null)
@@ -415,68 +466,34 @@ namespace WindBot.Game.AI
                     AI.SelectCard(target);
                     return true;
                 }
-            if (Duel.LastChainPlayer == 1)
-            {
-                foreach (ClientCard check in Enemy.GetMonsters())
-                {
-                    if (AI.Utils.GetLastChainCard() == check)
-                    {
-                        target = check;
-                        break;
-                    }
             }
-                if (target != null && !target.IsDisabled())
+
+            ClientCard LastChainCard = AI.Utils.GetLastChainCard();
+
+            if (LastChainCard != null && LastChainCard.Controller == 1 && LastChainCard.Location == CardLocation.MonsterZone &&
+                !LastChainCard.IsDisabled() && !LastChainCard.IsShouldNotBeTarget() && !LastChainCard.IsShouldNotBeSpellTrapTarget())
             {
-                    AI.SelectCard(target);
+                AI.SelectCard(LastChainCard);
                 return true;
             }
-            }
+
             if (Bot.BattlingMonster != null && Enemy.BattlingMonster != null)
             {
-                if (Enemy.BattlingMonster.IsDisabled()) return false;
-                if (Enemy.BattlingMonster.Id == _CardId.EaterOfMillions)
+                if (!Enemy.BattlingMonster.IsDisabled() && Enemy.BattlingMonster.Id == _CardId.EaterOfMillions)
                 {
                     AI.SelectCard(Enemy.BattlingMonster);
                     return true;
                 }
             }
+
             if (Duel.Phase == DuelPhase.BattleStart && Duel.Player == 1 &&
                 Enemy.HasInMonstersZone(_CardId.NumberS39UtopiaTheLightning, true))
             {
                 AI.SelectCard(_CardId.NumberS39UtopiaTheLightning);
-                return UniqueFaceupSpell();
-            }
-            return false;
-        }
-        /// <summary>
-        /// Chain the enemy monster, or disable monster like Rescue Rabbit.
-        /// </summary>
-        protected bool DefaultBreakthroughSkill()
-        {
-            if (!DefaultUniqueTrap())
-                return false;
-
-            if (Duel.Player == 1)
-            {
-                foreach (ClientCard target in Enemy.GetMonsters())
-                {
-                    if (target.IsMonsterShouldBeDisabledBeforeItUseEffect())
-                    {
-                        AI.SelectCard(target);
                 return true;
             }
-                }
-            }
-
-            ClientCard LastChainCard = AI.Utils.GetLastChainCard();
 
-            if (LastChainCard == null)
             return false;
-            if (LastChainCard.Controller != 1 || LastChainCard.Location != CardLocation.MonsterZone
-                || LastChainCard.IsDisabled() || LastChainCard.IsShouldNotBeTarget() || LastChainCard.IsShouldNotBeSpellTrapTarget())
-                return false;
-            AI.SelectCard(LastChainCard);
-            return true;
         }
 
         /// <summary>
@@ -608,31 +625,70 @@ namespace WindBot.Game.AI
         {
             if (Card.IsFaceup() && Card.IsDefense() && Card.Attack == 0)
                 return false;
-            if (Enemy.HasInMonstersZone(_CardId.BlueEyesChaosMAXDragon) &&
-                Card.IsAttack() && (4000-Card.Defense)*2>(4000 - Card.Attack))
+
+            if (Enemy.HasInMonstersZone(_CardId.BlueEyesChaosMAXDragon, true) &&
+                Card.IsAttack() && (4000 - Card.Defense) * 2 > (4000 - Card.Attack))
                 return false;
-            if (Enemy.HasInMonstersZone(_CardId.BlueEyesChaosMAXDragon) &&
+            if (Enemy.HasInMonstersZone(_CardId.BlueEyesChaosMAXDragon, true) &&
                 Card.IsDefense() && Card.IsFaceup() &&
                 (4000 - Card.Defense) * 2 > (4000 - Card.Attack))
                 return true;
-            bool enemyBetter = AI.Utils.IsAllEnemyBetter(true);
 
+            bool enemyBetter = AI.Utils.IsAllEnemyBetter(true);
             if (Card.IsAttack() && enemyBetter)
                 return true;
             if (Card.IsDefense() && !enemyBetter && Card.Attack >= Card.Defense)
                 return true;
+
             return false;
         }
 
+        /// <summary>
+        /// If spell will be negated
+        /// </summary>
+        protected bool DefaultSpellWillBeNegated()
+        {
+            return Bot.HasInSpellZone(_CardId.ImperialOrder, true, true) || Enemy.HasInSpellZone(_CardId.ImperialOrder, true) || Enemy.HasInMonstersZone(_CardId.NaturiaBeast, true);
+        }
+
+        /// <summary>
+        /// If spell must set first to activate
+        /// </summary>
+        protected bool DefaultSpellMustSetFirst()
+        {
+            ClientCard card = null;
+            foreach (ClientCard check in Bot.GetSpells())
+            {
+                if (check.Id == _CardId.AntiSpellFragrance && !check.IsDisabled())
+                    card = check;
+            }
+            if (card != null && card.IsFaceup())
+                return true;
+            return Bot.HasInSpellZone(_CardId.AntiSpellFragrance, true, true) ||  Enemy.HasInSpellZone(_CardId.AntiSpellFragrance, true);
+        }
+
         /// <summary>
         /// if spell/trap is the target or enermy activate HarpiesFeatherDuster
         /// </summary>
         protected bool DefaultOnBecomeTarget()
         {
             if (AI.Utils.IsChainTarget(Card)) return true;
-            if (AI.Utils.ChainContainsCard(_CardId.EvilswarmExcitonKnight)) return true;
-            if (Enemy.HasInSpellZone(_CardId.HarpiesFeatherDuster, true)) return true;
-            if (Enemy.HasInSpellZone(_CardId.DarkMagicAttack, true)) return true;
+            int[] destroyAllList =
+            {
+                _CardId.EvilswarmExcitonKnight,
+                _CardId.BlackRoseDragon,
+                _CardId.JudgmentDragon,
+                _CardId.TopologicTrisbaena
+            };
+            int[] destroyAllOpponentList =
+            {
+                _CardId.HarpiesFeatherDuster,
+                _CardId.DarkMagicAttack
+            };
+
+            if (AI.Utils.ChainContainsCard(destroyAllList)) return true;
+            if (Enemy.HasInSpellZone(destroyAllOpponentList, true)) return true;
+            // TODO: ChainContainsCard(id, player)
             return false;
         }
         /// <summary>
@@ -659,12 +715,7 @@ namespace WindBot.Game.AI
         /// </summary>
         protected bool UniqueFaceupSpell()
         {
-            foreach (ClientCard card in Bot.GetSpells())
-            {
-                if (card.Id == Card.Id && card.IsFaceup())
-                    return false;
-            }
-            return true;
+            return !Bot.GetSpells().Any(card => card.Id == Card.Id && card.IsFaceup());
         }
 
         /// <summary>
@@ -672,12 +723,7 @@ namespace WindBot.Game.AI
         /// </summary>
         protected bool UniqueFaceupMonster()
         {
-            foreach (ClientCard card in Bot.GetMonsters())
-            {
-                if (card.Id == Card.Id && card.IsFaceup())
-                    return false;
-            }
-            return true;
+            return !Bot.GetMonsters().Any(card => card.Id == Card.Id && card.IsFaceup());
         }
 
         /// <summary>
@@ -685,11 +731,8 @@ namespace WindBot.Game.AI
         /// </summary>
         protected bool DefaultDontChainMyself()
         {
-            foreach (CardExecutor exec in Executors)
-            {
-                if (exec.Type == Type && exec.CardId == Card.Id)
+            if (Executors.Any(exec => exec.Type == Type && exec.CardId == Card.Id))
                 return false;
-            }
             return Duel.LastChainPlayer != 0;
         }
 
@@ -698,13 +741,9 @@ namespace WindBot.Game.AI
         /// </summary>
         protected bool DefaultChickenGame()
         {
-            int count = 0;
-            foreach (CardExecutor exec in Executors)
-            {
-                if (exec.Type == Type && exec.CardId == Card.Id)
-                    count++;
-            }
-            if (count > 1 || Bot.LifePoints <= 1000)
+            if (Executors.Count(exec => exec.Type == Type && exec.CardId == Card.Id) > 1)
+                return false;
+            if (Bot.LifePoints <= 1000)
                 return false;
             if (Bot.LifePoints <= Enemy.LifePoints && ActivateDescription == AI.Utils.GetStringId(_CardId.ChickenGame, 0))
                 return true;
@@ -718,22 +757,8 @@ namespace WindBot.Game.AI
         /// </summary>
         protected bool DefaultAllureofDarkness()
         {
-            IList<ClientCard> condition = Bot.Hand;
-            IList<ClientCard> check = new List<ClientCard>();
-            ClientCard con = null;
-            foreach (ClientCard card in condition)
-            {
-                if (card.HasAttribute(CardAttribute.Dark))
-                {
-                    con = card;
-                    break;
-                }
-            }
-            if (con != null)
-            {
-                return true;
-            }
-            return false;
+            ClientCard target = Bot.Hand.FirstOrDefault(card => card.HasAttribute(CardAttribute.Dark));
+            return target != null;
         }
 
         /// <summary>
@@ -756,14 +781,17 @@ namespace WindBot.Game.AI
                 {
                     if (monster.HasType(CardType.Tuner))
                         tuner = true;
-                    else if (!monster.HasType(CardType.Xyz))
+                    else if (!monster.HasType(CardType.Xyz) && !monster.HasType(CardType.Link))
+                    {
                         nontuner = true;
+                        levels[monster.Level] = levels[monster.Level] + 1;
+                    }
+
                     if (monster.IsOneForXyz())
                     {
                         AI.SelectOption(XYZ);
                         return true;
                     }
-                    levels[monster.Level] = levels[monster.Level] + 1;
                 }
                 if (tuner && nontuner)
                 {
@@ -842,6 +870,9 @@ namespace WindBot.Game.AI
                 });
                 return true;
             }
+
+            if (DefaultDarkHole())
+            {
                 AI.SelectCard(new[]
                 {
                     _CardId.JizukirutheStarDestroyingKaiju,
@@ -863,7 +894,10 @@ namespace WindBot.Game.AI
                     _CardId.ThunderKingtheLightningstrikeKaiju,
 
                 });
-            return DefaultDarkHole();
+                return true;
+            }
+
+            return false;
         }
 
         /// <summary>
@@ -945,19 +979,8 @@ namespace WindBot.Game.AI
             if (selfCount < oppoCount)
                 return true;
 
-            int selfAttack = 0;
-            List<ClientCard> monsters = Bot.GetMonsters();
-            foreach (ClientCard monster in monsters)
-            {
-                selfAttack += monster.GetDefensePower();
-            }
-
-            int oppoAttack = 0;
-            monsters = Enemy.GetMonsters();
-            foreach (ClientCard monster in monsters)
-            {
-                oppoAttack += monster.GetDefensePower();
-            }
+            int selfAttack = Bot.GetMonsters().Sum(monster => (int?)monster.GetDefensePower()) ?? 0;
+            int oppoAttack = Enemy.GetMonsters().Sum(monster => (int?)monster.GetDefensePower()) ?? 0;
 
             return selfAttack < oppoAttack;
         }
@@ -1020,23 +1043,9 @@ namespace WindBot.Game.AI
         /// </summary>
         protected bool DefaultScarlightRedDragonArchfiendEffect()
         {
-            int selfCount = 0;
-            List<ClientCard> monsters = Bot.GetMonsters();
-            foreach (ClientCard monster in monsters)
-            {
-                if (!monster.Equals(Card) && monster.IsSpecialSummoned && monster.HasType(CardType.Effect) && monster.Attack <= Card.Attack)
-                    selfCount++;
-            }
-
-            int oppoCount = 0;
-            monsters = Enemy.GetMonsters();
-            foreach (ClientCard monster in monsters)
-            {
-                if (monster.IsSpecialSummoned && monster.HasType(CardType.Effect) && monster.Attack <= Card.Attack)
-                    oppoCount++;
-            }
-
-            return (oppoCount > 0 && selfCount <= oppoCount) || oppoCount >= 3;
+            int selfCount = Bot.GetMonsters().Count(monster => !monster.Equals(Card) && monster.IsSpecialSummoned && monster.HasType(CardType.Effect) && monster.Attack <= Card.Attack);
+            int oppoCount = Enemy.GetMonsters().Count(monster => monster.IsSpecialSummoned && monster.HasType(CardType.Effect) && monster.Attack <= Card.Attack);
+            return selfCount <= oppoCount || oppoCount >= 3;
         }
 
         /// <summary>
@@ -1050,9 +1059,14 @@ namespace WindBot.Game.AI
                     (((Bot.BattlingMonster.Attack < Enemy.BattlingMonster.Attack) || Bot.BattlingMonster.Attack >= Enemy.LifePoints)
                     || ((Bot.BattlingMonster.Attack < Enemy.BattlingMonster.Defense) && (Bot.BattlingMonster.Attack + Enemy.BattlingMonster.Attack > Enemy.BattlingMonster.Defense)));
             }
-            else return AI.Utils.IsTurn1OrMain2();
-        }
 
+            if (AI.Utils.IsTurn1OrMain2() && HonestEffectCount <= 5)
+            {
+                HonestEffectCount++;
+                return true;
+            }
 
+            return false;
+        }
     }
 }

Game/AI/Dialogs.cs

@@ -127,7 +127,7 @@ namespace WindBot.Game.AI
 
         public void SendOnDirectAttack(string attacker)
         {
-            if (attacker == "" || attacker == null)
+            if (string.IsNullOrEmpty(attacker))
             {
                 attacker = _facedownmonstername;
             }

Game/AI/Enums/Floodgate.cs

@@ -77,6 +77,7 @@
         LairOfDarkness = 59160188,
         SuperboltThunderDragon = 15291624,
         ThunderDragonLord = 41685633,
-        CyberDragonInfinity = 10443957
+        CyberDragonInfinity = 10443957,
+        ImperialCustom = 9995766
     }
 }

Game/AI/Executor.cs

 using System;
 using System.Collections.Generic;
+using System.Linq;
 using YGOSharp.OCGWrapper.Enums;
 using WindBot;
 using WindBot.Game;
@@ -82,12 +83,12 @@ namespace WindBot.Game.AI
 
         public virtual void OnChaining(int player, ClientCard card)
         {
-            
+            // For overriding
         }
 
         public virtual void OnChainEnd()
         {
-            
+            // For overriding
         }
         public virtual void OnNewPhase()
         {
@@ -239,12 +240,7 @@ namespace WindBot.Game.AI
 
         private bool DefaultNoExecutor()
         {
-            foreach (CardExecutor exec in Executors)
-            {
-                if (exec.Type == Type && exec.CardId == Card.Id)
-                    return false;
-            }
-            return true;
+            return Executors.All(exec => exec.Type != Type || exec.CardId != Card.Id);
         }
     }
 }
\ No newline at end of file

Game/ClientCard.cs

@@ -12,6 +12,7 @@ namespace WindBot.Game
         public string Name { get; private set; }
 
         public int Position { get; set; }
+        public int Sequence { get; set; }
         public CardLocation Location { get; set; }
         public int Alias { get; private set; }
         public int Level { get; private set; }
@@ -35,6 +36,10 @@ namespace WindBot.Game
         public int SelectSeq { get; set; }
         public int OpParam1 { get; set; }
         public int OpParam2 { get; set; }
+
+        public List<ClientCard> EquipCards { get; set; }
+        public ClientCard EquipTarget;
+
         public bool CanDirectAttack { get; set; }
         public bool ShouldDirectAttack { get; set; }
         public bool Attacked { get; set; }
@@ -44,16 +49,18 @@ namespace WindBot.Game
         public int[] ActionIndex { get; set; }
         public IDictionary<int, int> ActionActivateIndex { get; private set; }
 
-        public ClientCard(int id, CardLocation loc)
-            : this(id, loc, 0)
+        public ClientCard(int id, CardLocation loc, int sequence)
+            : this(id, loc, -1 , 0)
         {
         }
 
-        public ClientCard(int id, CardLocation loc, int position)
+        public ClientCard(int id, CardLocation loc, int sequence, int position)
         {
             SetId(id);
+            Sequence = sequence;
             Position = position;
             Overlays = new List<int>();
+            EquipCards = new List<ClientCard>();
             ActionIndex = new int[16];
             ActionActivateIndex = new Dictionary<int, int>();
             Location = loc;
@@ -144,27 +151,77 @@ namespace WindBot.Game
 
         public bool HasLinkMarker(int dir)
         {
-            return ((LinkMarker & dir) != 0);
+            return (LinkMarker & dir) != 0;
+        }
+
+        public bool HasLinkMarker(CardLinkMarker dir)
+        {
+            return (LinkMarker & (int)dir) != 0;
         }
 
-        public bool HasLinkMarker(LinkMarker dir)
+        public int GetLinkedZones()
         {
-            return ((LinkMarker & (int)dir) != 0);
+            if (!HasType(CardType.Link) || Location != CardLocation.MonsterZone)
+                return 0;
+            int zones = 0;
+            if (Sequence > 0 && Sequence <= 4 && HasLinkMarker(CardLinkMarker.Left))
+                zones |= 1 << (Sequence - 1);
+            if (Sequence <= 3 && HasLinkMarker(CardLinkMarker.Right))
+                zones |= 1 << (Sequence + 1);
+            if (Sequence == 0 && HasLinkMarker(CardLinkMarker.TopRight)
+                || Sequence == 1 && HasLinkMarker(CardLinkMarker.Top)
+                || Sequence == 2 && HasLinkMarker(CardLinkMarker.TopLeft))
+                zones |= (1 << 5) | (1 << (16 + 6));
+            if (Sequence == 2 && HasLinkMarker(CardLinkMarker.TopRight)
+                || Sequence == 3 && HasLinkMarker(CardLinkMarker.Top)
+                || Sequence == 4 && HasLinkMarker(CardLinkMarker.TopLeft))
+                zones |= (1 << 6) | (1 << (16 + 5));
+            if (Sequence == 5)
+            {
+                if (HasLinkMarker(CardLinkMarker.BottomLeft))
+                    zones |= 1 << 0;
+                if (HasLinkMarker(CardLinkMarker.Bottom))
+                    zones |= 1 << 1;
+                if (HasLinkMarker(CardLinkMarker.BottomRight))
+                    zones |= 1 << 2;
+                if (HasLinkMarker(CardLinkMarker.TopLeft))
+                    zones |= 1 << (16 + 4);
+                if (HasLinkMarker(CardLinkMarker.Top))
+                    zones |= 1 << (16 + 3);
+                if (HasLinkMarker(CardLinkMarker.TopRight))
+                    zones |= 1 << (16 + 2);
+            }
+            if (Sequence == 6)
+            {
+                if (HasLinkMarker(CardLinkMarker.BottomLeft))
+                    zones |= 1 << 2;
+                if (HasLinkMarker(CardLinkMarker.Bottom))
+                    zones |= 1 << 3;
+                if (HasLinkMarker(CardLinkMarker.BottomRight))
+                    zones |= 1 << 4;
+                if (HasLinkMarker(CardLinkMarker.TopLeft))
+                    zones |= 1 << (16 + 2);
+                if (HasLinkMarker(CardLinkMarker.Top))
+                    zones |= 1 << (16 + 1);
+                if (HasLinkMarker(CardLinkMarker.TopRight))
+                    zones |= 1 << (16 + 0);
+            }
+            return zones;
         }
 
         public bool HasType(CardType type)
         {
-            return ((Type & (int)type) != 0);
+            return (Type & (int)type) != 0;
         }
 
         public bool HasPosition(CardPosition position)
         {
-            return ((Position & (int)position) != 0);
+            return (Position & (int)position) != 0;
         }
 
         public bool HasAttribute(CardAttribute attribute)
         {
-            return ((Attribute & (int)attribute) != 0);
+            return (Attribute & (int)attribute) != 0;
         }
 
         public bool IsMonster()
@@ -189,7 +246,7 @@ namespace WindBot.Game
 
         public bool IsExtraCard()
         {
-            return (HasType(CardType.Fusion) || HasType(CardType.Synchro) || HasType(CardType.Xyz));
+            return HasType(CardType.Fusion) || HasType(CardType.Synchro) || HasType(CardType.Xyz) || HasType(CardType.Link);
         }
 
         public bool IsFaceup()
@@ -214,7 +271,7 @@ namespace WindBot.Game
 
         public bool IsDisabled()
         {
-            return (Disabled != 0);
+            return Disabled != 0;
         }
 
         public bool HasXyzMaterial()

Game/ClientField.cs

 using System.Collections.Generic;
+using System.Linq;
+using WindBot.Game.AI;
 using YGOSharp.OCGWrapper.Enums;
 
 namespace WindBot.Game
@@ -31,9 +33,9 @@ namespace WindBot.Game
             ExtraDeck = new List<ClientCard>();
 
             for (int i = 0; i < deck; ++i)
-                Deck.Add(new ClientCard(0, CardLocation.Deck));
+                Deck.Add(new ClientCard(0, CardLocation.Deck, -1));
             for (int i = 0; i < extra; ++i)
-                ExtraDeck.Add(new ClientCard(0, CardLocation.Extra));
+                ExtraDeck.Add(new ClientCard(0, CardLocation.Extra, -1));
         }
 
         public int GetMonstersExtraZoneCount()
@@ -95,30 +97,36 @@ namespace WindBot.Game
             return count;
         }
 
-
         public int GetFieldCount()
         {
             return GetSpellCount() + GetMonsterCount();
         }
 
-
         public int GetFieldHandCount()
         {
             return GetSpellCount() + GetMonsterCount() + GetHandCount();
         }
 
-
         public bool IsFieldEmpty()
         {
             return GetMonsters().Count == 0 && GetSpells().Count == 0;
         }
 
+        public int GetLinkedZones()
+        {
+            int zones = 0;
+            for (int i = 0; i < 7; i++)
+            {
+                zones |= MonsterZone[i]?.GetLinkedZones() ?? 0;
+            }
+            return zones;
+        }
+
         public List<ClientCard> GetMonsters()
         {
             return GetCards(MonsterZone);
         }
 
-
         public List<ClientCard> GetGraveyardMonsters()
         {
             return GetCards(Graveyard, CardType.Monster);
@@ -141,23 +149,12 @@ namespace WindBot.Game
 
         public List<ClientCard> GetMonstersInExtraZone()
         {
-            List<ClientCard> cards = new List<ClientCard>();
-            if (MonsterZone[5] != null)
-                cards.Add(MonsterZone[5]);
-            if (MonsterZone[6] != null)
-                cards.Add(MonsterZone[6]);
-            return cards;
+            return GetMonsters().Where((card, i) => i >= 5).ToList();
         }
 
         public List<ClientCard> GetMonstersInMainZone()
         {
-            List<ClientCard> cards = new List<ClientCard>();
-            for (int i = 0; i < 5; i++)
-            {
-                if (MonsterZone[i] != null)
-                    cards.Add(MonsterZone[i]);
-            }
-            return cards;
+            return GetMonsters().Where((card, i) => i < 5).ToList();
         }
 
         public bool HasInHand(int cardId)
@@ -202,44 +199,32 @@ namespace WindBot.Game
 
         public bool HasAttackingMonster()
         {
-            IList<ClientCard> monsters = GetMonsters();
-            foreach (ClientCard card in monsters)
-            {
-                if (card.IsAttack())
-                    return true;
-            }
-            return false;
+            return GetMonsters().Any(card => card.IsAttack());
         }
 
         public bool HasDefendingMonster()
         {
-            IList<ClientCard> monsters = GetMonsters();
-            foreach (ClientCard card in monsters)
-            {
-                if (card.IsDefense())
-                    return true;
-            }
-            return false;
+            return GetMonsters().Any(card => card.IsDefense());
         }
 
-        public bool HasInMonstersZone(int cardId, bool notDisabled = false, bool hasXyzMaterial = false)
+        public bool HasInMonstersZone(int cardId, bool notDisabled = false, bool hasXyzMaterial = false, bool faceUp = false)
         {
-            return HasInCards(MonsterZone, cardId, notDisabled, hasXyzMaterial);
+            return HasInCards(MonsterZone, cardId, notDisabled, hasXyzMaterial, faceUp);
         }
 
-        public bool HasInMonstersZone(IList<int> cardId, bool notDisabled = false, bool hasXyzMaterial = false)
+        public bool HasInMonstersZone(IList<int> cardId, bool notDisabled = false, bool hasXyzMaterial = false, bool faceUp = false)
         {
-            return HasInCards(MonsterZone, cardId, notDisabled, hasXyzMaterial);
+            return HasInCards(MonsterZone, cardId, notDisabled, hasXyzMaterial, faceUp);
         }
 
-        public bool HasInSpellZone(int cardId, bool notDisabled = false)
+        public bool HasInSpellZone(int cardId, bool notDisabled = false, bool faceUp = false)
         {
-            return HasInCards(SpellZone, cardId, notDisabled);
+            return HasInCards(SpellZone, cardId, notDisabled, false, faceUp);
         }
 
-        public bool HasInSpellZone(IList<int> cardId, bool notDisabled = false)
+        public bool HasInSpellZone(IList<int> cardId, bool notDisabled = false, bool faceUp = false)
         {
-            return HasInCards(SpellZone, cardId, notDisabled);
+            return HasInCards(SpellZone, cardId, notDisabled, false, faceUp);
         }
 
         public bool HasInHandOrInSpellZone(int cardId)
@@ -315,94 +300,46 @@ namespace WindBot.Game
         public int GetRemainingCount(int cardId, int initialCount)
         {
             int remaining = initialCount;
-            foreach (ClientCard card in Hand)
-                if (card != null && card.Id == cardId)
-                    remaining--;
-            foreach (ClientCard card in SpellZone)
-                if (card != null && card.Id == cardId)
-                    remaining--;
-            foreach (ClientCard card in Graveyard)
-                if (card != null && card.Id == cardId)
-                    remaining--;
-            foreach (ClientCard card in Banished)
-                if (card != null && card.Id == cardId)
-                    remaining--;
+            remaining = remaining - Hand.Count(card => card != null && card.Id == cardId);
+            remaining = remaining - SpellZone.Count(card => card != null && card.Id == cardId);
+            remaining = remaining - Graveyard.Count(card => card != null && card.Id == cardId);
+            remaining = remaining - Banished.Count(card => card != null && card.Id == cardId);
             return (remaining < 0) ? 0 : remaining;
         }
 
         private static int GetCount(IEnumerable<ClientCard> cards)
         {
-            int count = 0;
-            foreach (ClientCard card in cards)
-            {
-                if (card != null)
-                    count++;
-            }
-            return count;
+            return cards.Count(card => card != null);
         }
 
         public int GetCountCardInZone(IEnumerable<ClientCard> cards, int cardId)
         {
-            int count = 0;
-            foreach (ClientCard card in cards)
-            {
-                if (card != null && card.Id == cardId)
-                    count++;
-            }
-            return count;
+            return cards.Count(card => card != null && card.Id == cardId);
         }
 
         public int GetCountCardInZone(IEnumerable<ClientCard> cards, List<int> cardId)
         {
-            int count = 0;
-            foreach (ClientCard card in cards)
-            {
-                if (card != null && cardId.Contains(card.Id))
-                    count++;
-            }
-            return count;
+            return cards.Count(card => card != null && cardId.Contains(card.Id));
         }
 
         private static List<ClientCard> GetCards(IEnumerable<ClientCard> cards, CardType type)
         {
-            List<ClientCard> nCards = new List<ClientCard>();
-            foreach (ClientCard card in cards)
-            {
-                if (card != null && card.HasType(type))
-                    nCards.Add(card);
-            }
-            return nCards;
+            return cards.Where(card => card != null && card.HasType(type)).ToList();
         }
 
         private static List<ClientCard> GetCards(IEnumerable<ClientCard> cards)
         {
-            List<ClientCard> nCards = new List<ClientCard>();
-            foreach (ClientCard card in cards)
-            {
-                if (card != null)
-                    nCards.Add(card);
-            }
-            return nCards;
+            return cards.Where(card => card != null).ToList();
         }
 
-        private static bool HasInCards(IEnumerable<ClientCard> cards, int cardId, bool notDisabled = false, bool hasXyzMaterial = false)
-        {
-            foreach (ClientCard card in cards)
+        private static bool HasInCards(IEnumerable<ClientCard> cards, int cardId, bool notDisabled = false, bool hasXyzMaterial = false, bool faceUp = false)
         {
-                if (card != null && card.Id == cardId && !(notDisabled && card.IsDisabled()) && !(hasXyzMaterial && !card.HasXyzMaterial()))
-                    return true;
-            }
-            return false;
+            return cards.Any(card => card != null && card.Id == cardId && !(notDisabled && card.IsDisabled()) && !(hasXyzMaterial && !card.HasXyzMaterial()) && !(faceUp && card.IsFacedown()));
         }
 
-        private static bool HasInCards(IEnumerable<ClientCard> cards, IList<int> cardId, bool notDisabled = false, bool hasXyzMaterial = false)
+        private static bool HasInCards(IEnumerable<ClientCard> cards, IList<int> cardId, bool notDisabled = false, bool hasXyzMaterial = false, bool faceUp = false)
         {
-            foreach (ClientCard card in cards)
-            {
-                if (card != null && cardId.Contains(card.Id) && !(notDisabled && card.IsDisabled()) && !(hasXyzMaterial && !card.HasXyzMaterial()))
-                    return true;
-            }
-            return false;
+            return cards.Any(card => card != null && cardId.Contains(card.Id) && !(notDisabled && card.IsDisabled()) && !(hasXyzMaterial && !card.HasXyzMaterial()) && !(faceUp && card.IsFacedown()));
         }
     }
 }
\ No newline at end of file

Game/Deck.cs

@@ -83,8 +83,7 @@ namespace WindBot.Game
             }
             catch (Exception)
             {
-                if (reader != null)
-                    reader.Close();
+                reader?.Close();
                 return null;
             }
         }

Game/Duel.cs

@@ -38,12 +38,12 @@ namespace WindBot.Game
             LastSummonedCards = new List<ClientCard>();
         }
 
-        public ClientCard GetCard(int player, CardLocation loc, int index)
+        public ClientCard GetCard(int player, CardLocation loc, int seq)
         {
-            return GetCard(player, (int)loc, index, 0);
+            return GetCard(player, (int)loc, seq, 0);
         }
 
-        public ClientCard GetCard(int player, int loc, int index, int subindex)
+        public ClientCard GetCard(int player, int loc, int seq, int subSeq)
         {
             if (player < 0 || player > 1)
                 return null;
@@ -79,51 +79,52 @@ namespace WindBot.Game
             if (cards == null)
                 return null;
 
-            if (index >= cards.Count)
+            if (seq >= cards.Count)
                 return null;
 
             if (isXyz)
             {
-                ClientCard card = cards[index];
-                if (card == null || subindex >= card.Overlays.Count)
+                ClientCard card = cards[seq];
+                if (card == null || subSeq >= card.Overlays.Count)
                     return null;
-                return null; // TODO card.Overlays[subindex]
+                return null; // TODO card.Overlays[subSeq]
             }
 
-            return cards[index];
+            return cards[seq];
         }
 
-        public void AddCard(CardLocation loc, int cardId, int player, int zone, int pos)
+        public void AddCard(CardLocation loc, int cardId, int player, int seq, int pos)
         {
             switch (loc)
             {
                 case CardLocation.Hand:
-                    Fields[player].Hand.Add(new ClientCard(cardId, loc, pos));
+                    Fields[player].Hand.Add(new ClientCard(cardId, loc, -1, pos));
                     break;
                 case CardLocation.Grave:
-                    Fields[player].Graveyard.Add(new ClientCard(cardId, loc, pos));
+                    Fields[player].Graveyard.Add(new ClientCard(cardId, loc,-1, pos));
                     break;
                 case CardLocation.Removed:
-                    Fields[player].Banished.Add(new ClientCard(cardId, loc, pos));
+                    Fields[player].Banished.Add(new ClientCard(cardId, loc, -1, pos));
                     break;
                 case CardLocation.MonsterZone:
-                    Fields[player].MonsterZone[zone] = new ClientCard(cardId, loc, pos);
+                    Fields[player].MonsterZone[seq] = new ClientCard(cardId, loc, seq, pos);
                     break;
                 case CardLocation.SpellZone:
-                    Fields[player].SpellZone[zone] = new ClientCard(cardId, loc, pos);
+                    Fields[player].SpellZone[seq] = new ClientCard(cardId, loc, seq, pos);
                     break;
                 case CardLocation.Deck:
-                    Fields[player].Deck.Add(new ClientCard(cardId, loc, pos));
+                    Fields[player].Deck.Add(new ClientCard(cardId, loc, -1, pos));
                     break;
                 case CardLocation.Extra:
-                    Fields[player].ExtraDeck.Add(new ClientCard(cardId, loc, pos));
+                    Fields[player].ExtraDeck.Add(new ClientCard(cardId, loc, -1, pos));
                     break;
             }
         }
 
-        public void AddCard(CardLocation loc, ClientCard card, int player, int zone, int pos, int id)
+        public void AddCard(CardLocation loc, ClientCard card, int player, int seq, int pos, int id)
         {
             card.Location = loc;
+            card.Sequence = seq;
             card.Position = pos;
             card.SetId(id);
             switch (loc)
@@ -138,10 +139,10 @@ namespace WindBot.Game
                     Fields[player].Banished.Add(card);
                     break;
                 case CardLocation.MonsterZone:
-                    Fields[player].MonsterZone[zone] = card;
+                    Fields[player].MonsterZone[seq] = card;
                     break;
                 case CardLocation.SpellZone:
-                    Fields[player].SpellZone[zone] = card;
+                    Fields[player].SpellZone[seq] = card;
                     break;
                 case CardLocation.Deck:
                     Fields[player].Deck.Add(card);
@@ -152,7 +153,7 @@ namespace WindBot.Game
             }
         }
 
-        public void RemoveCard(CardLocation loc, ClientCard card, int player, int zone)
+        public void RemoveCard(CardLocation loc, ClientCard card, int player, int seq)
         {
             switch (loc)
             {
@@ -166,10 +167,10 @@ namespace WindBot.Game
                     Fields[player].Banished.Remove(card);
                     break;
                 case CardLocation.MonsterZone:
-                    Fields[player].MonsterZone[zone] = null;
+                    Fields[player].MonsterZone[seq] = null;
                     break;
                 case CardLocation.SpellZone:
-                    Fields[player].SpellZone[zone] = null;
+                    Fields[player].SpellZone[seq] = null;
                     break;
                 case CardLocation.Deck:
                     Fields[player].Deck.Remove(card);

Game/GameAI.cs

@@ -92,11 +92,12 @@ namespace WindBot.Game
         public void OnNewPhase()
         {
             m_selector.Clear();
+            m_position.Clear();
             m_selector_pointer = -1;
             m_materialSelector = null;
             m_option = -1;
             m_yesno = -1;
-            m_position = CardPosition.FaceUpAttack;
+           
             m_place = 0;
             if (Duel.Player == 0 && Duel.Phase == DuelPhase.Draw)
             {
@@ -359,10 +360,7 @@ namespace WindBot.Game
                 return result;
             result = new List<ClientCard>();
             // TODO: use selector
-            for (int i = 0; i < cards.Count; i++)
-            {
-                result.Add(cards[i]);
-            }
+            result = cards.ToList();
             return result;
         }
 
@@ -508,8 +506,7 @@ namespace WindBot.Game
         /// <returns>Selected position.</returns>
         public CardPosition OnSelectPosition(int cardId, IList<CardPosition> positions)
         {
-            CardPosition selector_selected = m_position;
-            m_position = CardPosition.FaceUpAttack;
+            CardPosition selector_selected = GetSelectedPosition();
 
             CardPosition executor_selected = Executor.OnSelectPosition(cardId, positions);
 
@@ -550,10 +547,15 @@ namespace WindBot.Game
                 }
                 else
                 {
-                    if (hint == HINTMSG_SMATERIAL)
+                    switch (hint)
+                    {
+                        case HINTMSG_SMATERIAL:
                             selected = Executor.OnSelectSynchroMaterial(cards, sum, min, max);
-                    if (hint == HINTMSG_RELEASE)
+                            break;
+                        case HINTMSG_RELEASE:
                             selected = Executor.OnSelectRitualTribute(cards, sum, min, max);
+                            break;
+                    }
                 }
                 if (selected != null)
                 {
@@ -747,7 +749,6 @@ namespace WindBot.Game
 
         
         private CardSelector m_materialSelector;
-        private CardPosition m_position = CardPosition.FaceUpAttack;
         private int m_place;
         private int m_option;
         private int m_number;
@@ -755,6 +756,7 @@ namespace WindBot.Game
         private int m_yesno;
         private IList<CardAttribute> m_attributes = new List<CardAttribute>();
         private IList<CardSelector> m_selector = new List<CardSelector>();
+        private IList<CardPosition> m_position = new List<CardPosition>();
         private int m_selector_pointer = -1;
         private IList<CardRace> m_races = new List<CardRace>();
 
@@ -929,9 +931,20 @@ namespace WindBot.Game
             return selected;
         }
 
+        public CardPosition GetSelectedPosition()
+        {
+            CardPosition selected = CardPosition.FaceUpAttack;
+            if (m_position.Count > 0)
+            {
+                selected = m_position[0];
+                m_position.RemoveAt(0);
+            }
+            return selected;
+        }
+
         public void SelectPosition(CardPosition pos)
         {
-            m_position = pos;
+            m_position.Add(pos);
         }
 
         public void SelectPlace(int zones)
@@ -1006,12 +1019,7 @@ namespace WindBot.Game
         /// <returns>A list of the selected attributes.</returns>
         public virtual IList<CardAttribute> OnAnnounceAttrib(int count, IList<CardAttribute> attributes)
         {
-            IList<CardAttribute> foundAttributes = new List<CardAttribute>();
-            foreach (CardAttribute attribute in m_attributes)
-            {
-                if(attributes.Contains(attribute))
-                    foundAttributes.Add(attribute);
-            }
+            IList<CardAttribute> foundAttributes = m_attributes.Where(attributes.Contains).ToList();
             if (foundAttributes.Count > 0)
                 return foundAttributes;
 
@@ -1026,12 +1034,7 @@ namespace WindBot.Game
         /// <returns>A list of the selected races.</returns>
         public virtual IList<CardRace> OnAnnounceRace(int count, IList<CardRace> races)
         {
-            IList<CardRace> foundRaces = new List<CardRace>();
-            foreach (CardRace race in m_races)
-            {
-                if (races.Contains(race))
-                    foundRaces.Add(race);
-            }
+            IList<CardRace> foundRaces = m_races.Where(races.Contains).ToList();
             if (foundRaces.Count > 0)
                 return foundRaces;
 
@@ -1069,12 +1072,10 @@ namespace WindBot.Game
         private bool ShouldExecute(CardExecutor exec, ClientCard card, ExecutorType type, int desc = -1)
         {
             Executor.SetCard(type, card, desc);
-            if (card != null &&
+            return card != null &&
                    exec.Type == type &&
                    (exec.CardId == -1 || exec.CardId == card.Id) &&
-                (exec.Func == null || exec.Func()))
-                return true;
-            return false;
+                   (exec.Func == null || exec.Func());
         }
     }
 }

Game/GameBehavior.cs

@@ -101,6 +101,7 @@ namespace WindBot.Game
             _messages.Add(GameMessage.Recover, OnRecover);
             _messages.Add(GameMessage.LpUpdate, OnLpUpdate);
             _messages.Add(GameMessage.Move, OnMove);
+            _messages.Add(GameMessage.Swap, OnSwap);
             _messages.Add(GameMessage.Attack, OnAttack);
             _messages.Add(GameMessage.PosChange, OnPosChange);
             _messages.Add(GameMessage.Chaining, OnChaining);
@@ -130,7 +131,8 @@ namespace WindBot.Game
             _messages.Add(GameMessage.AnnounceRace, OnAnnounceRace);
             _messages.Add(GameMessage.AnnounceCardFilter, OnAnnounceCard);
             _messages.Add(GameMessage.RockPaperScissors, OnRockPaperScissors);
-
+            _messages.Add(GameMessage.Equip, OnEquip);
+            _messages.Add(GameMessage.Unequip, OnUnEquip);
             _messages.Add(GameMessage.Summoning, OnSummoning);
             _messages.Add(GameMessage.Summoned, OnSummoned);
             _messages.Add(GameMessage.SpSummoning, OnSpSummoning);
@@ -373,7 +375,7 @@ namespace WindBot.Game
             for (int i = 0; i < count; ++i)
             {
                 _duel.Fields[player].Deck.RemoveAt(_duel.Fields[player].Deck.Count - 1);
-                _duel.Fields[player].Hand.Add(new ClientCard(0, CardLocation.Hand));
+                _duel.Fields[player].Hand.Add(new ClientCard(0, CardLocation.Hand, -1));
             }
             _ai.OnDraw(player);
         }
@@ -444,19 +446,19 @@ namespace WindBot.Game
             _duel.Fields[player].Deck.Clear();
             for (int i = 0; i < mcount; ++i)
             {
-                _duel.Fields[player].Deck.Add(new ClientCard(0, CardLocation.Deck));
+                _duel.Fields[player].Deck.Add(new ClientCard(0, CardLocation.Deck, -1));
             }
             _duel.Fields[player].ExtraDeck.Clear();
             for (int i = 0; i < ecount; ++i)
             {
                 int code = packet.ReadInt32() & 0x7fffffff;
-                _duel.Fields[player].ExtraDeck.Add(new ClientCard(code, CardLocation.Extra));
+                _duel.Fields[player].ExtraDeck.Add(new ClientCard(code, CardLocation.Extra, -1));
             }
             _duel.Fields[player].Hand.Clear();
             for (int i = 0; i < hcount; ++i)
             {
                 int code = packet.ReadInt32();
-                _duel.Fields[player].Hand.Add(new ClientCard(code, CardLocation.Hand));
+                _duel.Fields[player].Hand.Add(new ClientCard(code, CardLocation.Hand,-1));
             }
         }
 
@@ -583,6 +585,27 @@ namespace WindBot.Game
             }
         }
 
+        private void OnSwap(BinaryReader packet)
+        {
+            int cardId1 = packet.ReadInt32();
+            int controler1 = GetLocalPlayer(packet.ReadByte());
+            int location1 = packet.ReadByte();
+            int sequence1 = packet.ReadByte();
+            packet.ReadByte();
+            int cardId2 = packet.ReadInt32();
+            int controler2 = GetLocalPlayer(packet.ReadByte());
+            int location2 = packet.ReadByte();
+            int sequence2 = packet.ReadByte();
+            packet.ReadByte();
+            ClientCard card1 = _duel.GetCard(controler1, (CardLocation)location1, sequence1);
+            ClientCard card2 = _duel.GetCard(controler2, (CardLocation)location2, sequence2);
+            if (card1 == null || card2 == null) return;
+            _duel.RemoveCard((CardLocation)location1, card1, controler1, sequence1);
+            _duel.RemoveCard((CardLocation)location2, card2, controler2, sequence2);
+            _duel.AddCard((CardLocation)location2, card1, controler2, sequence2, card1.Position, cardId1);
+            _duel.AddCard((CardLocation)location1, card2, controler1, sequence1, card2.Position, cardId2);
+        }
+
         private void OnAttack(BinaryReader packet)
         {
             int ca = GetLocalPlayer(packet.ReadByte());
@@ -604,7 +627,7 @@ namespace WindBot.Game
             _duel.Fields[attackcard.Controller].BattlingMonster = attackcard;
             _duel.Fields[1 - attackcard.Controller].BattlingMonster = defendcard;
 
-            if (ld == 0 && (attackcard != null) && (ca != 0))
+            if (ld == 0 && ca != 0)
             {
                 _ai.OnDirectAttack(attackcard);
             }
@@ -670,7 +693,7 @@ namespace WindBot.Game
                 int seq = packet.ReadByte();
                 ClientCard card;
                 if (((int)loc & (int)CardLocation.Overlay) != 0)
-                    card = new ClientCard(id, CardLocation.Overlay);
+                    card = new ClientCard(id, CardLocation.Overlay, -1);
                 else
                     card = _duel.GetCard(controler, loc, seq);
                 if (card == null) continue;
@@ -717,9 +740,8 @@ namespace WindBot.Game
             packet.ReadInt32(); // ???
 
             ClientCard card = _duel.GetCard(player, (CardLocation)loc, seq);
-            if (card == null) return;
 
-            card.Update(packet, _duel);
+            card?.Update(packet, _duel);
         }
 
         private void OnUpdateData(BinaryReader packet)
@@ -858,7 +880,7 @@ namespace WindBot.Game
                 packet.ReadByte(); // pos
                 ClientCard card;
                 if (((int)loc & (int)CardLocation.Overlay) != 0)
-                    card = new ClientCard(id, CardLocation.Overlay);
+                    card = new ClientCard(id, CardLocation.Overlay, -1);
                 else
                     card = _duel.GetCard(player, loc, seq);
                 if (card == null) continue;
@@ -917,7 +939,7 @@ namespace WindBot.Game
                 packet.ReadByte(); // pos
                 ClientCard card;
                 if (((int)loc & (int)CardLocation.Overlay) != 0)
-                    card = new ClientCard(id, CardLocation.Overlay);
+                    card = new ClientCard(id, CardLocation.Overlay, -1);
                 else
                     card = _duel.GetCard(player, loc, seq);
                 if (card == null) continue;
@@ -1420,6 +1442,39 @@ namespace WindBot.Game
             Connection.Send(CtosMessage.Response, result);
         }
 
+        private void OnEquip(BinaryReader packet)
+        {
+            int equipCardControler = GetLocalPlayer(packet.ReadByte());
+            int equipCardLocation = packet.ReadByte();
+            int equipCardSequence = packet.ReadSByte();
+            packet.ReadByte();
+            int targetCardControler = GetLocalPlayer(packet.ReadByte());
+            int targetCardLocation = packet.ReadByte();
+            int targetCardSequence = packet.ReadSByte();
+            packet.ReadByte();
+            ClientCard equipCard = _duel.GetCard(equipCardControler, (CardLocation)equipCardLocation, equipCardSequence);
+            ClientCard targetCard = _duel.GetCard(targetCardControler, (CardLocation)targetCardLocation, targetCardSequence);
+            if (equipCard == null || targetCard == null) return;
+            equipCard.EquipTarget?.EquipCards.Remove(equipCard);
+            equipCard.EquipTarget = targetCard;
+            targetCard.EquipCards.Add(equipCard);
+        }
+
+        private void OnUnEquip(BinaryReader packet)
+        {
+            int equipCardControler = GetLocalPlayer(packet.ReadByte());
+            int equipCardLocation = packet.ReadByte();
+            int equipCardSequence = packet.ReadSByte();
+            packet.ReadByte();
+            ClientCard equipCard = _duel.GetCard(equipCardControler, (CardLocation)equipCardLocation, equipCardSequence);
+            if (equipCard == null) return;
+            if (equipCard.EquipTarget != null)
+            {
+                equipCard.EquipTarget.EquipCards.Remove(equipCard);
+                equipCard.EquipTarget = null;
+            }
+        }
+
         private void OnSummoning(BinaryReader packet)
         {
             _duel.LastSummonedCards.Clear();