Add Burn, Dragunity, Frog, Rank5 and ZexalWeapons decks

Decks/AI_Burn.ydk

+#created by ...
+#main
+102380
+102380
+102380
+2851070
+2851070
+97396380
+97396380
+26302522
+26302522
+26302522
+31305911
+31305911
+31305911
+23205979
+23205979
+23205979
+44789585
+44789585
+44789585
+19523799
+19523799
+19523799
+45311864
+45311864
+45311864
+46918794
+46918794
+46918794
+72302403
+72302403
+72302403
+98380593
+8842266
+62279055
+62279055
+62279055
+1918087
+1918087
+48276469
+98139712
+#extra
+!side

Decks/AI_Dragunity.ydk

+#created by ...
+#main
+61257789
+61257789
+61257789
+876330
+876330
+876330
+3431737
+3431737
+3431737
+28183605
+28183605
+28183605
+59755122
+59755122
+59755122
+29863101
+29863101
+39701395
+39701395
+70368879
+71490127
+73628505
+73628505
+73628505
+81439173
+5318639
+5318639
+57103969
+57103969
+60004971
+62265044
+62265044
+44095762
+58120309
+58120309
+70342110
+70342110
+80280737
+80280737
+80280737
+#extra
+99267150
+99267150
+99267150
+76774528
+76774528
+76774528
+44508094
+44508094
+44508094
+34116027
+34116027
+34116027
+21249921
+21249921
+21249921
+!side

Decks/AI_Frog.ydk

+#created by ...
+#main
+23950192
+23950192
+90311614
+90311614
+63948258
+63948258
+9126351
+9126351
+81278754
+81278754
+56052205
+56052205
+56052205
+1357146
+1357146
+46239604
+46239604
+46239604
+23408872
+23408872
+12538374
+12538374
+12580477
+73628505
+73628505
+98645731
+98645731
+86780027
+86780027
+86780027
+2084239
+2084239
+2084239
+34351849
+34351849
+34351849
+85742772
+85742772
+99188141
+99188141
+#extra
+!side

Decks/AI_Rank5.ydk

+#created by ...
+#main
+28601770
+28601770
+18842395
+18842395
+18842395
+70095155
+70095155
+70095155
+54343893
+54343893
+54343893
+14778250
+14778250
+12299841
+12299841
+12299841
+24610207
+24610207
+24610207
+26082117
+26082117
+26082117
+1845204
+1845204
+1845204
+43422537
+43422537
+43422537
+5318639
+5318639
+14087893
+13032689
+26708437
+44095762
+53582587
+56120475
+58628539
+58628539
+96457619
+96457619
+#extra
+45231177
+45231177
+45231177
+29515122
+29515122
+31386180
+31386180
+94119480
+94119480
+29669359
+29669359
+29669359
+55067058
+55067058
+55067058
+!side

Decks/AI_ZexalWeapons.ydk

+#created by ...
+#main
+70095155
+81471108
+81471108
+45082499
+45082499
+33911264
+33911264
+33911264
+65367484
+65367484
+24610207
+24610207
+24610207
+30914564
+30914564
+25259669
+25259669
+25259669
+37742478
+94656263
+94656263
+94656263
+34143852
+34143852
+34143852
+18063928
+18063928
+423585
+423585
+1845204
+1845204
+1845204
+12580477
+32807846
+5318639
+5318639
+78474168
+78474168
+78474168
+84749824
+#extra
+45231177
+45231177
+17881964
+17881964
+91949988
+60992364
+60992364
+94119480
+29669359
+71594310
+84013237
+84013237
+84013237
+25341652
+12014404
+!side

Game/AI/Decks/BurnExecutor.cs

+using WindBot.Game;
+using WindBot.Game.AI;
+
+namespace DevBot.Game.AI.Decks
+{
+    [Deck("Burn", "AI_Burn")]
+    public class BurnExecutor : DefaultExecutor
+    {
+        public enum CardId
+        {
+            LavaGolem = 102380,
+            ReflectBounder = 2851070,
+            FencingFireFerret = 97396380,
+            BlastSphere = 26302522,
+            Marshmallon = 31305911,
+            SpiritReaper = 23205979,
+            NaturiaBeans = 44789585,
+            Ookazi = 19523799,
+            GoblinThief = 45311864,
+            TremendousFire = 46918794,
+            SwordsOfRevealingLight = 72302403,
+            SupremacyBerry = 98380593,
+            PoisonOfTheOldMan = 8842266,
+            MagicCylinder = 62279055,
+            MinorGoblinOfficial = 1918087,
+            ChainBurst = 48276469,
+            SkullInvitation = 98139712
+        }
+
+        public BurnExecutor(GameAI ai, Duel duel)
+            : base(ai, duel)
+        {
+            // Set traps
+            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
+
+            // Activate Spells
+            AddExecutor(ExecutorType.Activate, (int)CardId.Ookazi);
+            AddExecutor(ExecutorType.Activate, (int)CardId.GoblinThief);
+            AddExecutor(ExecutorType.Activate, (int)CardId.TremendousFire);
+            AddExecutor(ExecutorType.Activate, (int)CardId.SwordsOfRevealingLight, SwordsOfRevealingLight);
+            AddExecutor(ExecutorType.Activate, (int)CardId.SupremacyBerry, SupremacyBerry);
+            AddExecutor(ExecutorType.Activate, (int)CardId.PoisonOfTheOldMan, PoisonOfTheOldMan);
+
+            // Set an invincible monster
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.Marshmallon, SetInvincibleMonster);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.SpiritReaper, SetInvincibleMonster);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.NaturiaBeans, SetInvincibleMonster);
+
+            // Hello, my name is Lava Golem
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.LavaGolem, LavaGolem);
+
+            // Set other monsters
+            AddExecutor(ExecutorType.Summon, (int)CardId.ReflectBounder);
+            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.FencingFireFerret);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.BlastSphere);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.NaturiaBeans);
+
+            // We're a coward
+            AddExecutor(ExecutorType.Repos, ReposEverything);
+
+            // Chain traps
+            AddExecutor(ExecutorType.Activate, (int)CardId.MagicCylinder, DefaultTrap);
+            AddExecutor(ExecutorType.Activate, (int)CardId.MinorGoblinOfficial);
+            AddExecutor(ExecutorType.Activate, (int)CardId.ChainBurst);
+            AddExecutor(ExecutorType.Activate, (int)CardId.SkullInvitation);
+        }
+
+        private bool SwordsOfRevealingLight()
+        {
+            int count = Duel.Fields[0].SpellZone.GetCardCount((int)CardId.SwordsOfRevealingLight);
+            return count == 0;
+        }
+
+        private bool SupremacyBerry()
+        {
+            return Duel.LifePoints[0] < Duel.LifePoints[1];
+        }
+
+        private bool PoisonOfTheOldMan()
+        {
+            AI.SelectOption(1);
+            return true;
+        }
+
+        private bool SetInvincibleMonster()
+        {
+            foreach (ClientCard card in Duel.Fields[0].GetMonsters())
+            {
+                if (card.Id == (int)CardId.Marshmallon ||
+                    card.Id == (int)CardId.SpiritReaper ||
+                    (card.Id == (int)CardId.NaturiaBeans && Card.Id == (int)CardId.NaturiaBeans))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        private bool LavaGolem()
+        {
+            bool found = false;
+            foreach (ClientCard card in Duel.Fields[0].GetMonsters())
+            {
+                if (card.Id == (int)CardId.Marshmallon ||
+                    card.Id == (int)CardId.SpiritReaper)
+                    found = true;
+            }
+            if (!found && Duel.LifePoints[1] > 1000)
+                return false;
+            return true;
+        }
+
+        private bool ReposEverything()
+        {
+            if (Card.Id == (int)CardId.ReflectBounder)
+                return Card.IsDefense();
+            if (Card.Id == (int)CardId.FencingFireFerret)
+                return DefaultMonsterRepos();
+            if (Card.IsAttack())
+                return true;
+            return false;
+        }
+    }
+}
\ No newline at end of file

Game/AI/Decks/DragunityExecutor.cs

+using OCGWrapper.Enums;
+using System.Collections.Generic;
+using WindBot.Game;
+using WindBot.Game.AI;
+
+namespace DevBot.Game.AI.Decks
+{
+    [Deck("Dragunity", "AI_Dragunity")]
+    public class DragunityExecutor : DefaultExecutor
+    {
+        public enum CardId
+        {
+            StardustDragonAssaultMode = 61257789,
+            DragunityArmaMysletainn = 876330,
+            AssaultBeast = 3431737,
+            DragunityDux = 28183605,
+            DragunityPhalanx = 59755122,
+            AssaultTeleport = 29863101,
+            CardsOfConsonance = 39701395,
+            UpstartGoblin = 70368879,
+            DragonsMirror = 71490127,
+            Terraforming = 73628505,
+            FoolishBurial = 81439173,
+            MonsterReborn = 83764718,
+            MysticalSpaceTyphoon = 5318639,
+            FireFormationTenki = 57103969,
+            DragunitySpearOfDestiny = 60004971,
+            DragonRavine = 62265044,
+            MirrorForce = 44095762,
+            StarlightRoad = 58120309,
+            DimensionalPrison = 70342110,
+            AssaultModeActivate = 80280737,
+            FiveHeadedDragon = 99267150,
+            ScrapDragon = 76774528,
+            StardustDragon = 44508094,
+            DragunityKnightGaeDearg = 34116027,
+            DragunityKnightVajrayana = 21249921
+        }
+
+        public DragunityExecutor(GameAI ai, Duel duel)
+            : base(ai, duel)
+        {
+            // Set traps
+            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
+
+            // Execute spells
+            AddExecutor(ExecutorType.Activate, (int)CardId.MysticalSpaceTyphoon, DefaultMysticalSpaceTyphoon);
+            AddExecutor(ExecutorType.Activate, (int)CardId.AssaultTeleport);
+            AddExecutor(ExecutorType.Activate, (int)CardId.UpstartGoblin);
+            AddExecutor(ExecutorType.Activate, (int)CardId.DragonRavine, DragonRavineField);
+            AddExecutor(ExecutorType.Activate, (int)CardId.Terraforming, Terraforming);
+            AddExecutor(ExecutorType.Activate, (int)CardId.FoolishBurial, FoolishBurial);
+            AddExecutor(ExecutorType.Activate, (int)CardId.MonsterReborn, MonsterReborn);
+
+            // Execute monsters
+            AddExecutor(ExecutorType.Activate, (int)CardId.ScrapDragon, ScrapDragonEffect);
+            AddExecutor(ExecutorType.Activate, (int)CardId.DragunityPhalanx);
+            AddExecutor(ExecutorType.Activate, (int)CardId.DragunityKnightVajrayana);
+            AddExecutor(ExecutorType.Activate, (int)CardId.DragunityArmaMysletainn);
+            AddExecutor(ExecutorType.Activate, (int)CardId.DragunityDux);
+
+            // Summon
+            AddExecutor(ExecutorType.Activate, (int)CardId.DragonsMirror, DragonsMirror);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.ScrapDragon, ScrapDragonSummon);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.StardustDragon);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragunityKnightVajrayana);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragunityKnightGaeDearg);
+            AddExecutor(ExecutorType.Summon, (int)CardId.DragunityPhalanx, DragunityPhalanxSummon);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragunityArmaMysletainn, DragunityArmaMysletainn);
+            AddExecutor(ExecutorType.Summon, (int)CardId.DragunityArmaMysletainn, DragunityArmaMysletainnTribute);
+
+            // Use draw effects if we can't do anything else
+            AddExecutor(ExecutorType.Activate, (int)CardId.CardsOfConsonance);
+            AddExecutor(ExecutorType.Activate, (int)CardId.DragonRavine, DragonRavineEffect);
+            AddExecutor(ExecutorType.Activate, (int)CardId.FireFormationTenki, FireFormationTenki);
+            AddExecutor(ExecutorType.Activate, (int)CardId.DragunitySpearOfDestiny);
+
+            // Summon
+            AddExecutor(ExecutorType.Summon, (int)CardId.DragunityDux, DragunityDux);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.DragunityPhalanx, DragunityPhalanxSet);
+            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.AssaultBeast);
+
+            // Draw assault mode if we don't have one
+            AddExecutor(ExecutorType.Activate, (int)CardId.AssaultBeast, AssaultBeast);
+
+            // Set useless cards
+            AddExecutor(ExecutorType.SpellSet, (int)CardId.DragonsMirror, SetUselessCards);
+            AddExecutor(ExecutorType.SpellSet, (int)CardId.Terraforming, SetUselessCards);
+            AddExecutor(ExecutorType.SpellSet, (int)CardId.AssaultTeleport, SetUselessCards);
+            AddExecutor(ExecutorType.SpellSet, (int)CardId.CardsOfConsonance, SetUselessCards);
+
+            // Chain traps and monsters
+            AddExecutor(ExecutorType.Activate, (int)CardId.StardustDragonAssaultMode, StardustDragon);
+            AddExecutor(ExecutorType.Activate, (int)CardId.StardustDragon, StardustDragon);
+            AddExecutor(ExecutorType.Activate, (int)CardId.StarlightRoad, DefaultTrap);
+            AddExecutor(ExecutorType.Activate, (int)CardId.MirrorForce, DefaultTrap);
+            AddExecutor(ExecutorType.Activate, (int)CardId.DimensionalPrison, DefaultTrap);
+            AddExecutor(ExecutorType.Activate, (int)CardId.AssaultModeActivate);
+        }
+
+        private bool DragonRavineField()
+        {
+            if (Card.Location == CardLocation.Hand)
+                return DefaultField();
+            return false;
+        }
+
+        private bool DragonRavineEffect()
+        {
+            if (Card.Location != CardLocation.SpellZone)
+                return false;
+
+            ClientField field = Duel.Fields[0];
+
+            int tributeId = -1;
+            if (field.HasInHand((int)CardId.DragunityPhalanx))
+                tributeId = (int)CardId.DragunityPhalanx;
+            else if (field.HasInHand((int)CardId.FireFormationTenki))
+                tributeId = (int)CardId.FireFormationTenki;
+            else if (field.HasInHand((int)CardId.Terraforming))
+                tributeId = (int)CardId.Terraforming;
+            else if (field.HasInHand((int)CardId.DragonRavine))
+                tributeId = (int)CardId.DragonRavine;
+            else if (field.HasInHand((int)CardId.AssaultTeleport))
+                tributeId = (int)CardId.AssaultTeleport;
+            else if (field.HasInHand((int)CardId.AssaultBeast))
+                tributeId = (int)CardId.AssaultBeast;
+            else if (field.HasInHand((int) CardId.DragunityArmaMysletainn))
+                tributeId = (int)CardId.DragunityArmaMysletainn;
+            else
+            {
+                int count = 0;
+                foreach (ClientCard card in Duel.Fields[0].Hand)
+                {
+                    if (card.Id == (int)CardId.DragunityDux)
+                        ++count;
+                }
+                if (count >= 2)
+                    tributeId = (int)CardId.DragunityDux;
+            }
+            if (tributeId == -1 && field.HasInHand((int)CardId.StardustDragonAssaultMode))
+                tributeId = (int)CardId.StardustDragonAssaultMode;
+            if (tributeId == -1 && field.HasInHand((int)CardId.DragunitySpearOfDestiny))
+                tributeId = (int)CardId.StardustDragonAssaultMode;
+            if (tributeId == -1 && field.HasInHand((int)CardId.DragonsMirror)
+                && Duel.Fields[0].GetMonsterCount() == 0)
+                tributeId = (int)CardId.StardustDragonAssaultMode;
+
+            if (tributeId == -1)
+                return false;
+
+            int needId = -1;
+            if (!field.HasInMonstersZone((int)CardId.DragunityPhalanx) &&
+                !field.HasInGraveyard((int)CardId.DragunityPhalanx))
+                needId = (int)CardId.DragunityPhalanx;
+            else if (field.GetMonsterCount() == 0)
+                needId = (int)CardId.DragunityDux;
+            else
+            {
+                bool hasRealMonster = false;
+                foreach (ClientCard card in field.GetMonsters())
+                {
+                    if (card.Id != (int)CardId.AssaultBeast)
+                    {
+                        hasRealMonster = true;
+                        break;
+                    }
+                }
+                if (!hasRealMonster || GetProblematicCard() != null)
+                    needId = (int)CardId.DragunityDux;
+            }
+
+            if (needId == -1)
+                return false;
+
+            int option;
+
+            if (tributeId == (int)CardId.DragunityPhalanx)
+                needId = (int)CardId.DragunityDux;
+
+            int remaining = 3;
+            foreach (ClientCard card in Duel.Fields[0].Hand)
+                if (card.Id == needId)
+                    remaining--;
+            foreach (ClientCard card in Duel.Fields[0].Graveyard)
+                if (card.Id == needId)
+                    remaining--;
+            foreach (ClientCard card in Duel.Fields[0].Banished)
+                if (card.Id == needId)
+                    remaining--;
+            if (remaining <= 0)
+                return false;
+
+            if (needId == (int)CardId.DragunityPhalanx)
+                option = 2;
+            else
+                option = 1;
+
+            if (ActivateDescription != (int)CardId.DragonRavine*16 + option)
+                return false;
+
+            AI.SelectCard(tributeId);
+            AI.SelectNextCard(needId);
+
+            return true;
+        }
+
+        private bool Terraforming()
+        {
+            if (Duel.Fields[0].HasInHand((int)CardId.DragonRavine))
+                return false;
+            if (Duel.Fields[0].SpellZone[5] != null)
+                return false;
+            return true;
+        }
+
+        private bool SetUselessCards()
+        {
+            ClientField field = Duel.Fields[0];
+
+            if (field.HasInSpellZone((int)CardId.FireFormationTenki))
+                return false;
+            if (field.HasInSpellZone((int)CardId.AssaultTeleport))
+                return false;
+            if (field.HasInSpellZone((int)CardId.CardsOfConsonance))
+                return false;
+            if (field.HasInSpellZone((int)CardId.DragonsMirror))
+                return false;
+
+            return Duel.Fields[0].GetSpellCountWithoutField() < 4;
+        }
+
+        private bool FireFormationTenki()
+        {
+            if (Card.Location == CardLocation.Hand)
+                return Duel.Fields[0].GetSpellCountWithoutField() < 4;
+            return true;
+        }
+
+        private bool FoolishBurial()
+        {
+            if (Duel.Fields[0].HasInGraveyard((int)CardId.DragunityPhalanx))
+                return false;
+            if (Duel.Fields[0].HasInHand((int)CardId.DragunityPhalanx))
+                return false;
+            int remaining = 3;
+            foreach (ClientCard card in Duel.Fields[0].Banished)
+                if (card.Id == (int)CardId.DragunityPhalanx)
+                    remaining--;
+            if (remaining > 0)
+            {
+                AI.SelectCard((int)CardId.DragunityPhalanx);
+                return true;
+            }
+            return false;
+        }
+
+        private bool MonsterReborn()
+        {
+            List<ClientCard> cards = new List<ClientCard>(Duel.Fields[0].Graveyard);
+            cards.Sort(AIFunctions.CompareCardAttack);
+            ClientCard selectedCard = null;
+            for (int i = cards.Count - 1; i >= 0; --i)
+            {
+                ClientCard card = cards[i];
+                if (card.Attack < 2000)
+                    break;
+                if (card.Id == (int) CardId.StardustDragonAssaultMode ||
+                    card.Id == (int) CardId.FiveHeadedDragon)
+                    continue;
+                if (card.IsMonster())
+                {
+                    selectedCard = card;
+                    break;
+                }
+            }
+            cards = new List<ClientCard>(Duel.Fields[1].Graveyard);
+            cards.Sort(AIFunctions.CompareCardAttack);
+            for (int i = cards.Count - 1; i >= 0; --i)
+            {
+                ClientCard card = cards[i];
+                if (card.Attack < 2000)
+                    break;
+                if (card.IsMonster() && card.HasType(CardType.Normal) && (selectedCard == null || card.Attack > selectedCard.Attack))
+                {
+                    selectedCard = card;
+                    break;
+                }
+            }
+            if (selectedCard != null)
+            {
+                AI.SelectCard(selectedCard);
+                return true;
+            }
+            return false;
+        }
+
+        private bool DragonsMirror()
+        {
+            IList<ClientCard> tributes = new List<ClientCard>();
+            int phalanxCount = 0;
+            foreach (ClientCard card in Duel.Fields[0].Graveyard)
+            {
+                if (card.Id == (int) CardId.DragunityPhalanx)
+                {
+                    phalanxCount++;
+                    break;
+                }
+                if (card.Race == (int) CardRace.Dragon)
+                    tributes.Add(card);
+                if (tributes.Count == 5)
+                    break;
+            }
+
+            // We can tribute one or two phalanx if needed, but only
+            // if we have more than one in the graveyard.
+            if (tributes.Count < 5 && phalanxCount > 1)
+            {
+                foreach (ClientCard card in Duel.Fields[0].Graveyard)
+                {
+                    if (card.Id == (int) CardId.DragunityPhalanx)
+                    {
+                        phalanxCount--;
+                        tributes.Add(card);
+                        if (phalanxCount <= 1)
+                            break;
+                    }
+                }
+            }
+
+            if (tributes.Count < 5)
+                return false;
+
+            AI.SelectCard((int)CardId.FiveHeadedDragon);
+            AI.SelectNextCard(tributes);
+            return true;
+        }
+
+        private bool ScrapDragonSummon()
+        {
+            if (AI.Utils.IsOneEnnemyBetterThanValue(2500, true))
+                return true;
+            ClientCard invincible = GetProblematicCard();
+            return invincible != null;
+        }
+
+        private bool ScrapDragonEffect()
+        {
+            ClientCard invincible = GetProblematicCard();
+            if (invincible == null && !AI.Utils.IsOneEnnemyBetterThanValue(2800 - 1, false))
+                return false;
+
+            ClientField field = Duel.Fields[0];
+
+            int tributeId = -1;
+            if (field.HasInSpellZone((int)CardId.FireFormationTenki))
+                tributeId = (int)CardId.FireFormationTenki;
+            else if (field.HasInSpellZone((int)CardId.Terraforming))
+                tributeId = (int)CardId.Terraforming;
+            else if (field.HasInSpellZone((int)CardId.DragonsMirror))
+                tributeId = (int)CardId.DragonsMirror;
+            else if (field.HasInSpellZone((int)CardId.CardsOfConsonance))
+                tributeId = (int)CardId.CardsOfConsonance;
+            else if (field.HasInSpellZone((int)CardId.AssaultTeleport))
+                tributeId = (int)CardId.AssaultTeleport;
+            else if (field.HasInSpellZone((int)CardId.AssaultModeActivate))
+                tributeId = (int)CardId.AssaultModeActivate;
+            else if (field.HasInSpellZone((int)CardId.DragonRavine))
+                tributeId = (int)CardId.DragonRavine;
+
+            List<ClientCard> monsters = Duel.Fields[1].GetMonsters();
+            monsters.Sort(AIFunctions.CompareCardAttack);
+
+            ClientCard destroyCard = invincible;
+            if (destroyCard == null)
+            {
+                for (int i = monsters.Count - 1; i >= 0; --i)
+                {
+                    if (monsters[i].IsAttack())
+                    {
+                        destroyCard = monsters[i];
+                        break;
+                    }
+                }
+            }
+
+            if (destroyCard == null)
+                return false;
+
+            if (tributeId != -1)
+                AI.SelectCard(tributeId);
+
+            AI.SelectNextCard(destroyCard);
+
+            return true;
+        }
+
+        private bool DragunityPhalanxSummon()
+        {
+            return Duel.Fields[0].HasInHand((int)CardId.DragunityArmaMysletainn);
+        }
+
+        private bool DragunityArmaMysletainn()
+        {
+            if (Duel.Fields[0].HasInMonstersZone((int)CardId.DragunityPhalanx))
+            {
+                AI.SelectCard((int)CardId.DragunityPhalanx);
+                return true;
+            }
+            if (Duel.Fields[0].HasInMonstersZone((int)CardId.DragunityDux))
+            {
+                AI.SelectCard((int)CardId.DragunityDux);
+                return true;
+            }
+            return false;
+        }
+
+        private bool DragunityArmaMysletainnTribute()
+        {
+            if ((Duel.Fields[0].HasInMonstersZone((int)CardId.AssaultBeast)
+                && Duel.Fields[0].HasInGraveyard((int)CardId.DragunityPhalanx))
+                || Duel.Fields[0].HasInMonstersZone((int)CardId.DragunityPhalanx)
+                || Duel.Fields[0].HasInHand((int)CardId.DragunitySpearOfDestiny))
+                return true;
+            return false;
+        }
+
+        private bool DragunityDux()
+        {
+            return Duel.Fields[0].HasInGraveyard((int)CardId.DragunityPhalanx) ||
+                (Duel.Fields[0].GetMonsterCount() == 0 && Duel.Fields[0].HasInHand((int)CardId.DragunityArmaMysletainn) ||
+                Duel.Fields[0].HasInHand((int)CardId.DragunitySpearOfDestiny));
+        }
+
+        private bool DragunityPhalanxSet()
+        {
+            return Duel.Fields[0].GetMonsterCount() == 0 || !Duel.Fields[0].HasInGraveyard((int)CardId.DragunityPhalanx);
+        }
+
+        private bool AssaultBeast()
+        {
+            if (!Duel.Fields[0].HasInSpellZone((int)CardId.AssaultModeActivate))
+                return true;
+            return false;
+        }
+
+        private bool StardustDragon()
+        {
+            if (Card.Location == CardLocation.Grave)
+                return true;
+            return LastChainPlayer == 1;
+        }
+
+        private ClientCard GetProblematicCard()
+        {
+            ClientCard card = Duel.Fields[1].MonsterZone.GetInvincibleMonster();
+            return card ?? Duel.Fields[1].SpellZone.GetNegateAttackSpell();
+        }
+    }
+}
\ No newline at end of file

Game/AI/Decks/FrogExecutor.cs

+using OCGWrapper.Enums;
+using System.Collections.Generic;
+using WindBot.Game;
+using WindBot.Game.AI;
+
+namespace DevBot.Game.AI.Decks
+{
+    [Deck("Frog", "AI_Frog")]
+    public class FrogExecutor : DefaultExecutor
+    {
+        public enum CardId
+        {
+            CryomancerOfTheIceBarrier = 23950192,
+            DewdarkOfTheIceBarrier = 90311614,
+            SubmarineFrog = 63948258,
+            SwapFrog = 9126351,
+            FlipFlopFrog = 81278754,
+            Unifrog = 56052205,
+            Ronintoadin = 1357146,
+            DupeFrog = 46239604,
+            Tradetoad = 23408872,
+            TreebornFrog = 12538374,
+            DarkHole = 53129443,
+            Raigeki = 12580477,
+            Terraforming = 73628505,
+            PotOfDuality = 98645731,
+            Solidarity = 86780027,
+            Wetlands = 2084239,
+            FroggyForcefield = 34351849,
+            GravityBind = 85742772,
+            TheHugeRevolutionIsOver = 99188141
+        }
+
+        public FrogExecutor(GameAI ai, Duel duel)
+            : base(ai, duel)
+        {
+            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
+
+            AddExecutor(ExecutorType.Activate, (int)CardId.Solidarity, Solidarity);
+            AddExecutor(ExecutorType.Activate, (int)CardId.Terraforming, Terraforming);
+            AddExecutor(ExecutorType.Activate, (int)CardId.Wetlands, DefaultField);
+            AddExecutor(ExecutorType.Activate, (int)CardId.DarkHole, DefaultDarkHole);
+            AddExecutor(ExecutorType.Activate, (int)CardId.Raigeki, DefaultRaigeki);
+            AddExecutor(ExecutorType.Activate, (int)CardId.PotOfDuality, PotOfDuality);
+
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.SwapFrog, SwapFrogSummon);
+            AddExecutor(ExecutorType.Activate, (int)CardId.SwapFrog, SwapFrogActivate);
+            AddExecutor(ExecutorType.Activate, (int)CardId.DupeFrog, DupeFrog);
+            AddExecutor(ExecutorType.Activate, (int)CardId.FlipFlopFrog, FlipFlopFrog);
+            AddExecutor(ExecutorType.Activate, (int)CardId.Ronintoadin, Ronintoadin);
+            AddExecutor(ExecutorType.Activate, (int)CardId.TreebornFrog);
+            AddExecutor(ExecutorType.Activate, (int)CardId.Unifrog);
+
+            AddExecutor(ExecutorType.Summon, (int)CardId.CryomancerOfTheIceBarrier, SummonFrog);
+            AddExecutor(ExecutorType.Summon, (int)CardId.DewdarkOfTheIceBarrier, SummonFrog);
+            AddExecutor(ExecutorType.Summon, (int)CardId.SubmarineFrog, SummonFrog);
+            AddExecutor(ExecutorType.Summon, (int)CardId.SwapFrog, SummonFrog);
+            AddExecutor(ExecutorType.Summon, (int)CardId.Unifrog, SummonFrog);
+            AddExecutor(ExecutorType.Summon, (int)CardId.Ronintoadin, SummonFrog);
+            AddExecutor(ExecutorType.Summon, (int)CardId.DupeFrog, SummonFrog);
+            AddExecutor(ExecutorType.Summon, (int)CardId.Tradetoad, SummonFrog);
+            AddExecutor(ExecutorType.Summon, (int)CardId.TreebornFrog, SummonFrog);
+            AddExecutor(ExecutorType.Summon, (int)CardId.FlipFlopFrog, SummonFrog);
+
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.FlipFlopFrog);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.DupeFrog);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.Tradetoad);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.Ronintoadin);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.TreebornFrog);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.Unifrog);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.SwapFrog);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.SubmarineFrog);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.DewdarkOfTheIceBarrier);
+            AddExecutor(ExecutorType.MonsterSet, (int)CardId.CryomancerOfTheIceBarrier);
+
+            AddExecutor(ExecutorType.Repos, FrogMonsterRepos);
+
+            AddExecutor(ExecutorType.Activate, (int)CardId.FroggyForcefield, DefaultTrap);
+            AddExecutor(ExecutorType.Activate, (int)CardId.TheHugeRevolutionIsOver, DefaultTrap);
+            AddExecutor(ExecutorType.Activate, (int)CardId.GravityBind, GravityBind);
+        }
+
+        private int m_swapFrogSummoned;
+        private int m_flipFlopFrogSummoned;
+
+        public override bool OnPreBattleBetween(ClientCard attacker, ClientCard defender)
+        {
+            if (attacker.Id == (int)CardId.Unifrog || attacker.Id == (int)CardId.DewdarkOfTheIceBarrier)
+                return true;
+            if (defender.IsMonsterInvincible() && !defender.IsMonsterDangerous() && attacker.Id == (int)CardId.SubmarineFrog)
+                return true;
+            return base.OnPreBattleBetween(attacker, defender);
+        }
+
+        private bool SwapFrogSummon()
+        {
+            int atk = Card.Attack + GetSpellBonus();
+            if (AI.Utils.IsAllEnnemyBetterThanValue(atk, true))
+                return false;
+
+            AI.SelectCard((int)CardId.Ronintoadin);
+            m_swapFrogSummoned = Duel.Turn;
+            return true;
+        }
+
+        private bool SwapFrogActivate()
+        {
+            if (m_swapFrogSummoned != Duel.Turn)
+                return false;
+            m_swapFrogSummoned = -1;
+
+            if (Duel.Fields[0].GetRemainingCount((int)CardId.Ronintoadin, 2) == 0)
+                return false;
+
+            AI.SelectCard((int)CardId.Ronintoadin);
+            return true;
+        }
+
+        private bool DupeFrog()
+        {
+            AI.SelectCard(CardLocation.Deck);
+            return true;
+        }
+
+        private bool FlipFlopFrog()
+        {
+            if (Card.IsDefense() || m_flipFlopFrogSummoned == Duel.Turn || Duel.Phase == DuelPhase.Main2)
+            {
+                m_flipFlopFrogSummoned = -1;
+                List<ClientCard> monsters = Duel.Fields[1].GetMonsters();
+                monsters.Sort(AIFunctions.CompareCardAttack);
+                monsters.Reverse();
+                AI.SelectCard(monsters);
+                return true;
+            }
+            return false;
+        }
+
+        private bool Ronintoadin()
+        {
+            List<ClientCard> monsters = Duel.Fields[0].GetGraveyardMonsters();
+            if (monsters.Count > 2)
+            {
+                if (GetSpellBonus() == 0)
+                    AI.SelectPosition(CardPosition.FaceUpDefence);
+                return true;
+            }
+            return false;
+        }
+
+        private bool SummonFrog()
+        {
+            int atk = Card.Attack + GetSpellBonus();
+
+            if (AI.Utils.IsOneEnnemyBetterThanValue(atk, true))
+                return false;
+
+            if (Card.Id == (int)CardId.SwapFrog)
+                m_swapFrogSummoned = Duel.Turn;
+            return true;
+        }
+
+        private bool PotOfDuality()
+        {
+            List<int> cards = new List<int>();
+            
+            if (AI.Utils.IsEnnemyBetter(false, false))
+            {
+                cards.Add((int)CardId.FlipFlopFrog);
+            }
+
+            if (Duel.Fields[0].SpellZone[5] == null)
+            {
+                cards.Add((int)CardId.Terraforming);
+                cards.Add((int)CardId.Wetlands);
+            }
+
+            cards.Add((int)CardId.DarkHole);
+            cards.Add((int)CardId.SwapFrog);
+            cards.Add((int)CardId.GravityBind);
+
+            if (cards.Count > 0)
+            {
+                AI.SelectCard(cards);
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool DarkHole()
+        {
+            return AI.Utils.IsEnnemyBetter(false, false);
+        }
+
+        private bool Terraforming()
+        {
+            if (Duel.Fields[0].HasInHand((int)CardId.Wetlands))
+                return false;
+            if (Duel.Fields[0].SpellZone[5] != null)
+                return false;
+            return true;
+        }
+
+        private bool Solidarity()
+        {
+            List<ClientCard> monsters = Duel.Fields[0].GetGraveyardMonsters();
+            return monsters.Count != 0;
+        }
+
+        private bool GravityBind()
+        {
+            List<ClientCard> spells = Duel.Fields[0].GetSpells();
+            foreach (ClientCard spell in spells)
+            {
+                if (spell.Id == (int)CardId.GravityBind && !spell.IsFacedown())
+                    return false;
+            }
+            return true;
+        }
+
+        private bool FrogMonsterRepos()
+        {
+            if (Card.Id == (int)CardId.Unifrog)
+                return Card.IsDefense();
+            if (Card.Id == (int)CardId.DewdarkOfTheIceBarrier)
+                return Card.IsDefense();
+
+            bool ennemyBetter = AI.Utils.IsOneEnnemyBetterThanValue(Card.Attack + (Card.IsFacedown() ? GetSpellBonus() : 0), true);
+            if (Card.Attack < 800)
+                ennemyBetter = true;
+            bool result = false;
+            if (Card.IsAttack() && ennemyBetter)
+                result =  true;
+            if (Card.IsDefense() && !ennemyBetter)
+                result = true;
+
+            if (!result && Card.Id == (int)CardId.FlipFlopFrog && Duel.Fields[1].GetMonsterCount() > 0 && Card.IsFacedown())
+                result = true;
+
+            if (Card.Id == (int)CardId.FlipFlopFrog && Card.IsFacedown() && result)
+                m_flipFlopFrogSummoned = Duel.Turn;
+
+            return result;
+        }
+
+        private int GetSpellBonus()
+        {
+            int atk = 0;
+            if (Duel.Fields[0].SpellZone[5] != null)
+                atk += 1200;
+
+            List<ClientCard> monsters = Duel.Fields[0].GetGraveyardMonsters();
+            if (monsters.Count != 0)
+            {
+                foreach (ClientCard card in Duel.Fields[0].GetSpells())
+                {
+                    if (card.Id == (int)CardId.Solidarity)
+                        atk += 800;
+                }
+            }
+
+            return atk;
+        }
+    }
+}

Game/AI/Decks/Rank5Executor.cs

+using OCGWrapper.Enums;
+using System.Collections.Generic;
+using WindBot.Game;
+using WindBot.Game.AI;
+
+namespace DevBot.Game.AI.Decks
+{
+    [Deck("Rank V", "AI_Rank5")]
+    public class Rank5Executor : DefaultExecutor
+    {
+        public enum CardId
+        {
+            MistArchfiend = 28601770,
+            PowerInvader = 18842395,
+            CyberDragon = 70095155,
+            ViceDragon = 54343893,
+            TheTricky = 14778250,
+            WindUpSoldier = 12299841,
+            StarDrawing = 24610207,
+            GagagaMagician = 26082117,
+            InstantFusion = 1845204,
+            DoubleSummon = 43422537,
+            MysticalSpaceTyphoon = 5318639,
+            BookOfMoon = 14087893,
+            XyzUnit = 13032689,
+            XyzReborn = 26708437,
+            MirrorForce = 44095762,
+            TorrentialTribute = 53582587,
+            SakuretsuArmor = 56120475,
+            XyzEffect = 58628539,
+            XyzVeil = 96457619,
+
+            FlameSwordsman = 45231177,
+            DigvorzhakKingOfHeavyIndustry = 29515122,
+            TirasKeeperOfGenesis = 31386180,
+            AdreusKeeperOfArmageddon = 94119480,
+            Number61Volcasaurus = 29669359,
+            Number19Freezerdon = 55067058
+        }
+
+        public Rank5Executor(GameAI ai, Duel duel)
+            : base(ai, duel)
+        {
+            // Quick spells
+            AddExecutor(ExecutorType.Activate, (int)CardId.BookOfMoon, DefaultBookOfMoon);
+            AddExecutor(ExecutorType.Activate, (int)CardId.MysticalSpaceTyphoon, DefaultMysticalSpaceTyphoon);
+
+            // XYZ Monsters: Effect
+            AddExecutor(ExecutorType.Activate, (int)CardId.DigvorzhakKingOfHeavyIndustry);
+            AddExecutor(ExecutorType.Activate, (int)CardId.TirasKeeperOfGenesis);
+            AddExecutor(ExecutorType.Activate, (int)CardId.AdreusKeeperOfArmageddon);
+            AddExecutor(ExecutorType.Activate, (int)CardId.Number61Volcasaurus);
+            AddExecutor(ExecutorType.Activate, (int)CardId.Number19Freezerdon);
+
+            // Summon LV.5 Monsters
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.CyberDragon);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.ViceDragon);
+            AddExecutor(ExecutorType.Summon, (int)CardId.PowerInvader, PowerInvader);
+            AddExecutor(ExecutorType.Summon, (int)CardId.WindUpSoldier);
+            AddExecutor(ExecutorType.Summon, (int)CardId.StarDrawing);
+            AddExecutor(ExecutorType.Summon, (int)CardId.GagagaMagician);
+
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.TheTricky, TheTricky);
+
+            AddExecutor(ExecutorType.Summon, (int)CardId.MistArchfiend, MistArchfiend);
+            AddExecutor(ExecutorType.Activate, (int)CardId.InstantFusion, IsAnotherRank5Available);
+
+            AddExecutor(ExecutorType.Activate, (int)CardId.GagagaMagician, GagagaMagicianEffect);
+            AddExecutor(ExecutorType.Activate, (int)CardId.WindUpSoldier, WindUpSoldierEffect);
+
+            // Useful spells
+            AddExecutor(ExecutorType.Activate, (int)CardId.DoubleSummon, DoubleSummon);
+            AddExecutor(ExecutorType.Activate, (int)CardId.XyzUnit, XyzUnit);
+
+            // XYZ Monsters: Summon
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.DigvorzhakKingOfHeavyIndustry, SummonXYZ);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.TirasKeeperOfGenesis, SummonXYZ);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.AdreusKeeperOfArmageddon, SummonXYZ);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.Number61Volcasaurus, SummonXYZ);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.Number19Freezerdon, SummonXYZ);
+
+            // Xyz Reborn
+            AddExecutor(ExecutorType.Activate, (int)CardId.XyzReborn);
+
+            // Reposition
+            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);
+
+            // Set and activate traps
+            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
+
+            AddExecutor(ExecutorType.Activate, (int)CardId.XyzVeil, XyzVeil);
+            AddExecutor(ExecutorType.Activate, (int)CardId.XyzEffect, XyzEffect);
+            AddExecutor(ExecutorType.Activate, (int)CardId.TorrentialTribute, DefaultTorrentialTribute);
+            AddExecutor(ExecutorType.Activate, (int)CardId.MirrorForce, DefaultTrap);
+            AddExecutor(ExecutorType.Activate, (int)CardId.SakuretsuArmor, DefaultTrap);
+        }
+
+        public override bool OnSelectHand()
+        {
+            return false;
+        }
+
+        private bool SummonXYZ()
+        {
+            List<ClientCard> monsters = Duel.Fields[0].GetMonsters();
+            foreach (ClientCard monster in monsters)
+                if (monster.Id == Card.Id)
+                    return false;
+            return true;
+        }
+
+        private bool PowerInvader()
+        {
+            if (Duel.Fields[1].GetMonsterCount() >= 2)
+            {
+                AI.SelectOption(1);
+                return true;
+            }
+            return false;
+        }
+
+        private bool TheTricky()
+        {
+            IList<ClientCard> hand = Duel.Fields[0].Hand;
+            foreach (ClientCard card in hand)
+            {
+                if (card.Id == (int)CardId.TheTricky && card != Card)
+                {
+                    AI.SelectCard(card);
+                    return true;
+                }
+            }
+            if (Duel.Fields[0].HasInHand((int)CardId.PowerInvader))
+            {
+                AI.SelectCard((int)CardId.PowerInvader);
+                return true;
+            }
+            if (Duel.Fields[0].HasInHand((int)CardId.CyberDragon))
+            {
+                AI.SelectCard((int)CardId.CyberDragon);
+                return true;
+            }
+            if (Duel.Fields[0].HasInHand((int)CardId.ViceDragon))
+            {
+                AI.SelectCard((int)CardId.ViceDragon);
+                return true;
+            }
+            if (Duel.Fields[0].HasInHand((int)CardId.XyzVeil))
+            {
+                AI.SelectCard((int)CardId.XyzVeil);
+                return true;
+            }
+            if (Duel.Fields[0].HasInHand((int)CardId.XyzEffect))
+            {
+                AI.SelectCard((int)CardId.XyzEffect);
+                return true;
+            }
+            if (Duel.Fields[0].HasInHand((int)CardId.MysticalSpaceTyphoon))
+            {
+                AI.SelectCard((int)CardId.MysticalSpaceTyphoon);
+                return true;
+            }
+            return false;
+        }
+
+        private bool MistArchfiend()
+        {
+            if (!IsAnotherRank5Available())
+                return false;
+            AI.SelectOption(1);
+            return true;
+        }
+
+        private bool IsAnotherRank5Available()
+        {
+            List<ClientCard> monsters = Duel.Fields[0].GetMonsters();
+            foreach (ClientCard monster in monsters)
+            {
+                if (monster.HasType(CardType.Monster) &&
+                    !monster.HasType(CardType.Xyz) &&
+                    (monster.Level == 5 ||
+                        monster.Id == (int)CardId.WindUpSoldier) ||
+                        monster.Id == (int)CardId.StarDrawing ||
+                        monster.Id == (int)CardId.GagagaMagician)
+                    return true;
+            }
+            int mistCount = 0;
+            IList<ClientCard> hand = Duel.Fields[0].Hand;
+            foreach (ClientCard card in hand)
+            {
+                if (card.Id == (int)CardId.InstantFusion && Card.Id != card.Id)
+                    return true;
+                if (card.Id == (int)CardId.MistArchfiend && Card.Id != card.Id)
+                    return true;
+                if (card.Id == (int)CardId.MistArchfiend)
+                    ++mistCount;
+            }
+            if (mistCount >= 2)
+                return true;
+            return false;
+        }
+
+        private bool WindUpSoldierEffect()
+        {
+            List<ClientCard> monsters = Duel.Fields[0].GetMonsters();
+            foreach (ClientCard monster in monsters)
+            {
+                if (monster.HasType(CardType.Monster) &&
+                    !monster.HasType(CardType.Xyz) &&
+                    (monster.Level == 5 ||
+                        monster.Id == (int)CardId.StarDrawing) ||
+                        monster.Id == (int)CardId.GagagaMagician)
+                    return true;
+            }
+            return false;
+        }
+
+        private bool GagagaMagicianEffect()
+        {
+            AI.SelectNumber(5);
+            return true;
+        }
+
+        private bool DoubleSummon()
+        {
+            IList<ClientCard> hand = Duel.Fields[0].Hand;
+            foreach (ClientCard card in hand)
+            {
+                if (card.Id == (int)CardId.PowerInvader && Duel.Fields[1].GetMonsterCount() >= 2)
+                    return true;
+                if (card.Id == (int)CardId.WindUpSoldier ||
+                    card.Id == (int)CardId.StarDrawing ||
+                    card.Id == (int)CardId.GagagaMagician)
+                    return true;
+            }
+            return false;
+        }
+
+        private bool XyzUnit()
+        {
+            List<ClientCard> monsters = Duel.Fields[0].GetMonsters();
+            foreach (ClientCard monster in monsters)
+            {
+                if (monster.HasType(CardType.Xyz))
+                {
+                    AI.SelectCard(monster);
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        private bool XyzVeil()
+        {
+            List<ClientCard> spells = Duel.Fields[0].GetSpells();
+            foreach (ClientCard spell in spells)
+            {
+                if (spell.Id == (int)CardId.XyzVeil && spell != Card)
+                    return false;
+            }
+            List<ClientCard> monsters = Duel.Fields[0].GetMonsters();
+            foreach (ClientCard monster in monsters)
+            {
+                if (monster.HasType(CardType.Xyz))
+                    return true;
+            }
+            return true;
+        }
+
+        private bool XyzEffect()
+        {
+            ClientCard card = GetBestEnnemyCard();
+            if (card != null)
+            {
+                AI.SelectCard(card);
+                return true;
+            }
+            return false;
+        }
+
+        private ClientCard GetProblematicCard()
+        {
+            ClientCard card = Duel.Fields[1].MonsterZone.GetInvincibleMonster();
+            if (card != null)
+                return card;
+            card = Duel.Fields[1].SpellZone.GetNegateAttackSpell();
+            if (card != null)
+                return card;
+            return null;
+        }
+
+        private ClientCard GetBestEnnemyCard()
+        {
+            ClientCard card = GetProblematicCard();
+            if (card != null)
+                return card;
+            card = Duel.Fields[1].MonsterZone.GetHighestAttackMonster();
+            if (card != null)
+                return card;
+            List<ClientCard> spells = Duel.Fields[1].GetSpells();
+            if (spells.Count > 0)
+                return spells[0];
+            return null;
+        }
+    }
+}

Game/AI/Decks/ZexalWeaponsExecutor.cs

+using OCGWrapper.Enums;
+using System.Collections.Generic;
+using WindBot.Game;
+using WindBot.Game.AI;
+
+namespace DevBot.Game.AI.Decks
+{
+    [Deck("Zexal Weapons", "AI_ZexalWeapons")]
+    class ZexalWeaponsExecutor : DefaultExecutor
+    {
+        public enum CardId
+        {
+            CyberDragon = 70095155,
+            ZwTornadoBringer = 81471108,
+            ZwLightningBlade = 45082499,
+            SolarWindJammer = 33911264,
+            PhotonTrasher = 65367484,
+            StarDrawing = 24610207,
+            SacredCrane = 30914564,
+            Goblindbergh = 25259669,
+            Honest = 37742478,
+            Kagetokage = 94656263,
+            HeroicChallengerExtraSword = 34143852,
+            TinGoldfish = 18063928,
+            SummonerMonk = 423585,
+            InstantFusion = 1845204,
+            Raigeki = 12580477,
+            ReinforcementOfTheArmy = 32807846,
+            DarkHole = 53129443,
+            MysticalSpaceTyphoon = 5318639,
+            BreakthroughSkill = 78474168,
+            SolemnWarning = 84749824,
+
+            FlameSwordsman = 45231177,
+            DarkfireDragon = 17881964,
+            GaiaDragonTheThunderCharger = 91949988,
+            ZwLionArms = 60992364,
+            AdreusKeeperOfArmageddon = 94119480,
+            Number61Volcasaurus = 29669359,
+            GemKnightPearl = 71594310,
+            Number39Utopia = 84013237,
+            MaestrokeTheSymphonyDjinn = 25341652,
+            GagagaCowboy = 12014404
+        }
+
+        public ZexalWeaponsExecutor(GameAI ai, Duel duel)
+            : base(ai, duel)
+        {
+            // Quick spells
+            AddExecutor(ExecutorType.Activate, (int)CardId.MysticalSpaceTyphoon, DefaultMysticalSpaceTyphoon);
+
+            // XYZ summons
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.Number39Utopia);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.ZwLionArms);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.AdreusKeeperOfArmageddon);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.Number61Volcasaurus);
+
+            // XYZ effects
+            AddExecutor(ExecutorType.Activate, (int)CardId.Number39Utopia, Number39Utopia);
+            AddExecutor(ExecutorType.Activate, (int)CardId.ZwLionArms, ZwLionArms);
+            AddExecutor(ExecutorType.Activate, (int)CardId.AdreusKeeperOfArmageddon);
+            AddExecutor(ExecutorType.Activate, (int)CardId.Number61Volcasaurus);
+
+            // Weapons
+            AddExecutor(ExecutorType.Activate, (int)CardId.ZwTornadoBringer);
+            AddExecutor(ExecutorType.Activate, (int)CardId.ZwLightningBlade);
+
+            // Spell cards
+            AddExecutor(ExecutorType.Activate, (int)CardId.DarkHole, DefaultDarkHole);
+            AddExecutor(ExecutorType.Activate, (int)CardId.Raigeki, DefaultRaigeki);
+            AddExecutor(ExecutorType.Activate, (int)CardId.ReinforcementOfTheArmy, ReinforcementOfTheArmy);
+
+            // Special summons
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.PhotonTrasher);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.CyberDragon);
+            AddExecutor(ExecutorType.SpSummon, (int)CardId.SolarWindJammer, SolarWindJammer);
+
+            AddExecutor(ExecutorType.Activate, (int)CardId.InstantFusion, InstantFusion);
+
+            // Normal summons
+            AddExecutor(ExecutorType.Summon, (int)CardId.Goblindbergh, GoblindberghFirst);
+            AddExecutor(ExecutorType.Summon, (int)CardId.TinGoldfish, GoblindberghFirst);
+            AddExecutor(ExecutorType.Summon, (int)CardId.StarDrawing);
+            AddExecutor(ExecutorType.Summon, (int)CardId.SacredCrane);
+            AddExecutor(ExecutorType.Summon, (int)CardId.HeroicChallengerExtraSword);
+            AddExecutor(ExecutorType.Summon, (int)CardId.Goblindbergh);
+            AddExecutor(ExecutorType.Summon, (int)CardId.TinGoldfish);
+            AddExecutor(ExecutorType.Summon, (int)CardId.SummonerMonk);
+
+            // Summons: Effects
+            AddExecutor(ExecutorType.Activate, (int)CardId.Goblindbergh, GoblindberghEffect);
+            AddExecutor(ExecutorType.Activate, (int)CardId.TinGoldfish, GoblindberghEffect);
+            AddExecutor(ExecutorType.Activate, (int)CardId.Kagetokage);
+            AddExecutor(ExecutorType.Activate, (int)CardId.SummonerMonk, SummonerMonkEffect);
+
+            // Reposition
+            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);
+
+            // Set and activate traps
+            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
+
+            AddExecutor(ExecutorType.Activate, (int)CardId.BreakthroughSkill, BreakthroughSkill);
+            AddExecutor(ExecutorType.Activate, (int)CardId.SolemnWarning, DefaultTrap);
+        }
+
+        public override bool OnSelectHand()
+        {
+            return false;
+        }
+
+        private bool Number39Utopia()
+        {
+            if (!HasChainedTrap(0) && Duel.Player == 1 && Duel.Phase == DuelPhase.BattleStart && Card.Overlays.Count > 1)
+                return true;
+            return false;
+        }
+
+        private bool ZwLionArms()
+        {
+            if (ActivateDescription == (int)CardId.ZwLionArms * 16 + 0 ||
+                ActivateDescription == (int)CardId.ZwLionArms * 16 + 1)
+                return true;
+            return false;
+        }
+
+        private bool ReinforcementOfTheArmy()
+        {
+            AI.SelectCard(new[]
+                {
+                    (int)CardId.Goblindbergh,
+                    (int)CardId.TinGoldfish,
+                    (int)CardId.StarDrawing,
+                    (int)CardId.Kagetokage,
+                    (int)CardId.SacredCrane
+                });
+            return true;
+        }
+
+        private bool InstantFusion()
+        {
+            List<ClientCard> monsters = Duel.Fields[0].GetMonsters();
+            int count = 0;
+            foreach (ClientCard card in monsters)
+            {
+                if (card.Level == 5)
+                    ++count;
+            }
+            if (count == 1)
+                AI.SelectCard((int)CardId.FlameSwordsman);
+            else
+                AI.SelectCard((int)CardId.DarkfireDragon);
+            return true;
+        }
+
+        private bool GoblindberghFirst()
+        {
+            IList<ClientCard> hand = Duel.Fields[0].Hand;
+            foreach (ClientCard card in hand)
+            {
+                if (card != Card && card.IsMonster() && card.Level == 4)
+                    return true;
+            }
+            return false;
+        }
+
+        private bool GoblindberghEffect()
+        {
+            AI.SelectCard(new[]
+                {
+                    (int)CardId.SacredCrane,
+                    (int)CardId.HeroicChallengerExtraSword,
+                    (int)CardId.StarDrawing,
+                    (int)CardId.SummonerMonk
+                });
+            return true;
+        }
+
+        private bool SummonerMonkEffect()
+        {
+            if (Duel.Fields[0].HasInHand((int)CardId.InstantFusion) ||
+                Duel.Fields[0].HasInHand((int)CardId.MysticalSpaceTyphoon))
+            {
+                AI.SelectCard(new[]
+                    {
+                        (int)CardId.InstantFusion,
+                        (int)CardId.MysticalSpaceTyphoon
+                    });
+                return true;
+            }
+            AI.SelectNextCard(new[]
+                {
+                    (int)CardId.Goblindbergh,
+                    (int)CardId.TinGoldfish,
+                    (int)CardId.StarDrawing,
+                    (int)CardId.Kagetokage,
+                    (int)CardId.SacredCrane
+                });
+            return false;
+        }
+
+        private bool SolarWindJammer()
+        {
+            AI.SelectPosition(CardPosition.FaceUpDefence);
+            return true;
+        }
+
+        private bool BreakthroughSkill()
+        {
+            return (CurrentChain.Count > 0 && DefaultTrap());
+        }
+    }
+}

WindBot.csproj

@@ -53,8 +53,13 @@
     <Compile Include="Game\AI\CardSelector.cs" />
     <Compile Include="Game\AI\DeckAttribute.cs" />
     <Compile Include="Game\AI\DecksManager.cs" />
+    <Compile Include="Game\AI\Decks\BurnExecutor.cs" />
+    <Compile Include="Game\AI\Decks\DragunityExecutor.cs" />
+    <Compile Include="Game\AI\Decks\FrogExecutor.cs" />
     <Compile Include="Game\AI\Decks\HorusExecutor.cs" />
     <Compile Include="Game\AI\Decks\OldSchoolExecutor.cs" />
+    <Compile Include="Game\AI\Decks\Rank5Executor.cs" />
+    <Compile Include="Game\AI\Decks\ZexalWeaponsExecutor.cs" />
     <Compile Include="Game\AI\DefaultExecutor.cs" />
     <Compile Include="Game\AI\Dialogs.cs" />
     <Compile Include="Game\AI\Enums\DangerousMonster.cs" />
@@ -84,6 +89,15 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />
+    <None Include="Decks\AI_Burn.ydk">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="Decks\AI_Dragunity.ydk">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="Decks\AI_Frog.ydk">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="Decks\AI_Horus.ydk">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
@@ -92,6 +106,12 @@
     </None>
   </ItemGroup>
   <ItemGroup>
+    <None Include="Decks\AI_Rank5.ydk">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="Decks\AI_ZexalWeapons.ydk">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="sqlite3.dll">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>