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

Decks/AI_Mathmech.ydk

+#created by ...
+#main
+8567955
+8567955
+8567955
+89743495
+89743495
+27182739
+27182739
+27182739
+53577438
+53577438
+53577438
+16360142
+16360142
+16360142
+80965043
+80965043
+80965043
+52354896
+52354896
+12580477
+14025912
+14532163
+14532163
+35261759
+35261759
+35261759
+57160136
+57160136
+57160136
+70368879
+70368879
+70368879
+81439173
+93104632
+93104632
+8267140
+41410651
+36361633
+36361633
+36361633
+#extra
+42632209
+42632209
+42632209
+15248594
+15248594
+15248594
+61399402
+61399402
+61399402
+85692042
+85692042
+85692042
+88021907
+88021907
+88021907
+!side

Decks/AI_PureWinds.ydk

+#created by ...
+#main
+71007216
+71007216
+71007216
+81275020
+71175527
+71175527
+71175527
+43722862
+43722862
+43722862
+53932291
+53932291
+65277087
+65277087
+65277087
+54455435
+54455435
+54455435
+91662792
+91662792
+91662792
+16725505
+70117860
+70117860
+70117860
+12580477
+27980138
+27980138
+58577036
+83764718
+8267140
+25789292
+67723438
+67723438
+8608979
+8608979
+8608979
+24590232
+40605147
+84749824
+#extra
+27315304
+50954680
+50954680
+50954680
+82044279
+82044279
+14577226
+29552709
+29552709
+64880894
+84766279
+42110604
+70913714
+30674956
+90512490
+!side
+19420830
+19420830
+19420830
+94145021
+94145021
+94145021
+25789292
+25789292
+43711255
+43711255
+43711255
+58921041
+58921041
+23002292
+23002292

Decks/AI_Timethief.ydk

+#created by ...
+#main
+65367484
+65367484
+65367484
+56308388
+56308388
+56308388
+67696066
+82496097
+82496097
+82496097
+74578720
+74578720
+74578720
+19891131
+19891131
+19891131
+70368879
+70368879
+70368879
+81439173
+10877309
+10877309
+10877309
+81670445
+81670445
+81670445
+18678554
+18678554
+18678554
+26708437
+26708437
+26708437
+57319935
+57319935
+98827725
+98827725
+98827725
+76587747
+76587747
+76587747
+#extra
+56832966
+56832966
+56832966
+86532744
+86532744
+86532744
+84013237
+84013237
+84013237
+55285840
+55285840
+55285840
+59208943
+59208943
+59208943
+!side

Game/AI/Decks/MathMechExecutor.cs

+using System;
+using YGOSharp.OCGWrapper.Enums;
+using System.Collections.Generic;
+using System.Diagnostics;
+using WindBot;
+using WindBot.Game;
+using WindBot.Game.AI;
+using System.Linq;
+
+namespace WindBot.Game.AI.Decks
+{
+    [Deck("MathMech", "AI_Mathmech")]
+    public class MathmechExecutor : DefaultExecutor
+    {
+        public class CardID
+        {
+            public const int MathmechNebla = 53577438;
+            public const int MathmechSigma = 27182739;
+            public const int MathmechDivision = 89743495;
+            public const int MathmechAddition = 80965043;
+            public const int MathmechSubtra = 16360142;
+            public const int Mathmechdouble = 52354896;
+            public const int MathmechFinalSigma = 42632209;
+            public const int Mathmechalem = 85692042;
+            public const int MathmechMagma = 15248594;
+            public const int BalancerLord = 08567955;
+            public const int LightDragon = 61399402;
+
+            // spells
+            public const int upstartGoblin = 70368879;
+            public const int raigeki = 12580477;
+            public const int cynetmining = 57160136;
+            public const int  PotOfDesires= 35261759;
+            public const int lightningStorm =  14532163;
+            public const int cosmicCyclone = 08267140;
+            public const int foolishBurial = 81439173;
+            public const int OneTimePasscode = 93104632;
+            public const int mathmechEquation = 14025912;
+            //traps
+            public const int threanteningRoar = 36361633;
+            //tokens
+            public const int securitytoken = 93104633;
+
+        }
+        public MathmechExecutor(GameAI ai, Duel duel)
+            : base(ai, duel)
+        {
+            AddExecutor(ExecutorType.Activate, CardID.raigeki ,when_raigeki);
+            AddExecutor(ExecutorType.Activate, CardID.upstartGoblin);
+            AddExecutor(ExecutorType.Activate, CardID.OneTimePasscode);
+            AddExecutor(ExecutorType.SpellSet, CardID.threanteningRoar);
+            AddExecutor(ExecutorType.Activate,CardID.cosmicCyclone , when_cosmic);
+            AddExecutor(ExecutorType.Activate,CardID.lightningStorm ,lightstorm_target);
+            AddExecutor(ExecutorType.Activate,CardID.foolishBurial,foolish_burial_target);
+            AddExecutor(ExecutorType.Activate,CardID.mathmechEquation,mathmech_equation_target);
+            AddExecutor(ExecutorType.Activate,CardID.PotOfDesires);
+
+
+            AddExecutor(ExecutorType.Summon, CardID.MathmechNebla);
+            AddExecutor(ExecutorType.Summon,CardID.BalancerLord );
+            AddExecutor(ExecutorType.Summon, CardID.Mathmechdouble);
+            AddExecutor(ExecutorType.Summon, CardID.MathmechSubtra);
+            AddExecutor(ExecutorType.Summon, CardID.MathmechAddition);
+            AddExecutor(ExecutorType.Summon, CardID.MathmechDivision);
+            AddExecutor(ExecutorType.Summon, CardID.MathmechDivision);
+            AddExecutor(ExecutorType.Activate, CardID.MathmechSigma);
+            AddExecutor(ExecutorType.Activate,CardID.threanteningRoar);
+
+            //xyz summons
+            AddExecutor(ExecutorType.SpSummon, CardID.Mathmechalem, when_Mathmechalem);
+            //xyz effects
+            AddExecutor(ExecutorType.Activate, CardID.Mathmechalem, mathchalenEffect);
+            //Synchro
+            AddExecutor(ExecutorType.SpSummon, CardID.MathmechFinalSigma , FinalSigmaSummon);
+            
+            AddExecutor(ExecutorType.Activate, CardID.Mathmechdouble, doubleEffect);
+
+            //normal effects
+            AddExecutor(ExecutorType.Activate, CardID.MathmechNebla, NeblaEffect);
+            AddExecutor(ExecutorType.Activate,CardID.MathmechDivision , divisionEffect);
+            AddExecutor(ExecutorType.Activate,CardID.BalancerLord , active_balancer);
+            AddExecutor(ExecutorType.Activate, CardID.MathmechSubtra , whom_subtra);
+            AddExecutor(ExecutorType.Activate, CardID.MathmechAddition , whom_addition);
+            //spell effects
+            AddExecutor(ExecutorType.Activate, CardID.cynetmining , how_to_cynet_mine);
+            AddExecutor(ExecutorType.SpSummon, CardID.MathmechMagma, MagmaSummon);
+            AddExecutor(ExecutorType.Activate,CardID.MathmechFinalSigma);
+            AddExecutor(ExecutorType.Activate,CardID.MathmechMagma);
+            
+
+            //function
+            
+        }
+
+        public override bool OnSelectHand()
+        {
+            return false;
+        }
+        private bool when_cosmic()
+        {
+            
+            if (Enemy.GetSpellCount() > 1)
+            {
+                AI.SelectCard(Util.GetBestEnemySpell());
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        private bool divisionEffect()
+        {
+            if (Enemy.GetMonsterCount() > 0)
+            {
+                AI.SelectCard(Util.GetBestEnemyMonster(canBeTarget:true,onlyFaceup:true));
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        private bool when_raigeki()
+        {
+            if (Enemy.GetMonsterCount() > 3)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        private bool whom_addition()
+        {
+            AI.SelectCard(Util.GetBestBotMonster(onlyATK:true));
+            return true;
+        }
+
+        private bool whom_subtra()
+        {
+            try
+            {
+                AI.SelectCard(Util.GetBestEnemyMonster(onlyFaceup: true, canBeTarget: true));
+                return true;
+            }
+            catch (Exception e)
+            {
+                return true;
+            }
+        }
+
+        private bool active_balancer()
+        {
+            if (Bot.HasInHand(CardID.MathmechNebla))
+            {
+                AI.SelectCard(CardID.MathmechNebla);
+                return true;
+            }
+            else
+            {
+                return true;
+            }
+        }
+        private bool lightstorm_target()
+        {
+            if ((Enemy.MonsterZone.ToList().Count > Enemy.SpellZone.ToList().Count ) && Enemy.MonsterZone.ToList().Count>3)
+            {
+                AI.SelectPlace(Zones.MonsterZones);
+                return true;
+            }
+            else
+            {
+                AI.SelectPlace(Zones.SpellZones);
+                return true;
+            }
+
+        }
+
+        private bool mathmech_equation_target()
+        {
+            if (Bot.HasInGraveyard(CardID.MathmechNebla))
+            {
+                AI.SelectCard(CardID.MathmechNebla);
+                return true;
+            }
+            else
+            {
+                AI.SelectCard((Util.GetBestBotMonster(onlyATK: true)));
+                return true;
+            }
+        }
+
+        private bool foolish_burial_target()
+        {
+            AI.SelectCard(CardID.MathmechNebla);
+            return true;
+        }
+        private bool how_to_cynet_mine()
+        {
+            AI.SelectCard(Util.GetWorstBotMonster());
+            if (!Bot.HasInHandOrInMonstersZoneOrInGraveyard(CardID.MathmechSigma))
+            {
+                AI.SelectNextCard(CardID.MathmechSigma);
+                return true;
+            }
+            return true;
+        }
+        private bool when_Mathmechalem()
+        {
+            if (Bot.HasInMonstersZone(CardID.MathmechNebla)){
+                return false;
+            }
+            else if(Bot.HasInMonstersZone(CardID.MathmechSigma) && Bot.HasInMonstersZone(CardID.Mathmechdouble))
+            {
+                return false;
+            }
+            else if (Bot.HasInMonstersZone(CardID.Mathmechalem))
+            {
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+        }
+        private bool FinalSigmaSummon()
+        {
+            if (Duel.Turn < 1)
+            {
+                return false;
+            }
+            if ((Bot.HasInMonstersZone(CardID.Mathmechdouble) && (( Bot.HasInMonstersZone(CardID.MathmechSigma)) || Bot.HasInMonstersZone(CardID.MathmechNebla))))
+            {
+                AI.SelectPosition(CardPosition.Attack);
+                try { AI.SelectPlace(Zones.ExtraMonsterZones);  }
+                catch { }
+                
+                return true;
+            }
+            else
+            {
+                return true;
+            }
+
+        }
+        private bool NeblaEffect()
+        {
+            bool a = Bot.HasInMonstersZone(CardID.MathmechSubtra) || Bot.HasInMonstersZone(CardID.securitytoken) || Bot.HasInMonstersZone(CardID.MathmechSigma) || Bot.HasInMonstersZone(CardID.MathmechAddition) || Bot.HasInMonstersZone(CardID.Mathmechalem) || Bot.HasInMonstersZone(CardID.MathmechDivision);
+            if (a)
+            {
+                List<int> cards = new List<int>();
+                cards.Add(CardID.MathmechSigma);
+                cards.Add(CardID.MathmechSubtra);
+                cards.Add(CardID.MathmechAddition);
+                cards.Add(item:CardID.MathmechDivision);
+                cards.Add(item:CardID.Mathmechalem);
+                cards.Add(CardID.securitytoken);
+                int u = 0;
+                List<ClientCard> monsters = Bot.GetMonstersInMainZone();
+                for (int i = 0; i < monsters.Count; i++)
+                {
+                    if (cards.Contains(monsters[i].Id))
+                    {
+                        u = monsters[i].Id;
+                        break;
+                    }
+                    else
+                    {
+                        u = CardID.securitytoken;
+                    }
+                }
+                AI.SelectCard(CardID.securitytoken);
+                AI.SelectNextCard(CardID.Mathmechdouble);
+                return true;
+
+
+            }
+            if (Card.Location == CardLocation.Grave)
+            {
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        private bool doubleEffect()
+        {
+            if (Bot.HasInMonstersZone(CardID.MathmechNebla) || Bot.HasInMonstersZone(CardID.MathmechSigma))
+            {
+                return true;
+            };
+            if (Card.Location == CardLocation.Grave )
+                {
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+        
+        private bool mathchalenEffect()
+
+        {
+            if (Duel.Turn < 1)
+            {
+                return false;
+            }
+            if ( (Bot.HasInHandOrInGraveyard(CardID.MathmechNebla) &&  !Bot.HasInMonstersZone(CardID.MathmechNebla)) && (Card.Location == CardLocation.FieldZone && Card.HasXyzMaterial(0)) )
+            {
+                AI.SelectCard(CardID.Mathmechalem);
+                AI.SelectNextCard(CardID.MathmechNebla);
+                return true;
+            }
+
+            if (Bot.HasInHandOrInGraveyard(CardID.Mathmechdouble) &&
+                (Bot.HasInMonstersZone(CardID.MathmechNebla) || Bot.HasInMonstersZone(CardID.MathmechSigma)) &&
+                Card.Location == CardLocation.FieldZone && Card.HasXyzMaterial(0))
+            {
+                AI.SelectCard(CardID.Mathmechalem);
+                AI.SelectNextCard(CardID.Mathmechdouble);
+                return true;
+            }
+            if (!Bot.HasInHandOrInGraveyard(CardID.MathmechNebla) && Card.HasXyzMaterial(2))
+            {
+                AI.SelectCard(CardID.MathmechNebla);
+                AI.SelectThirdCard(CardID.MathmechNebla);
+                return true;
+            }
+
+            if (!Bot.HasInHandOrInGraveyard(CardID.MathmechSigma) && Card.HasXyzMaterial(2))
+            {
+                AI.SelectCard(CardID.MathmechSigma);
+                AI.SelectThirdCard(CardID.MathmechSigma);
+                return true;
+            }
+            else
+            {
+                return false;
+            };
+            
+            
+        }
+
+        private bool MagmaSummon()
+        {
+            if (Bot.HasInMonstersZone(CardID.MathmechNebla))
+            {
+                return false;
+            }
+
+            if (Bot.HasInMonstersZone(CardID.MathmechSigma) && Bot.HasInMonstersZone(CardID.Mathmechdouble))
+            {
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+    }
+
+}
\ No newline at end of file

Game/AI/Decks/PureWindsExecutor.cs

+using YGOSharp.OCGWrapper.Enums;
+using System.Collections.Generic;
+using WindBot;
+using WindBot.Game;
+using WindBot.Game.AI;
+using System.Linq;
+
+namespace WindBot.Game.AI.Decks
+{
+    [Deck("PureWinds", "AI_PureWinds")]
+    // Made by Pluani (AniHelp) and Szefo
+    class PureWindsExecutor : DefaultExecutor
+    {
+        public class CardId
+        {
+            public const int SpeedroidTerrortop = 81275020;
+            public const int WindwitchIceBell = 43722862;
+            public const int PilicaDescendantOfGusto = 71175527;
+            public const int SpeedroidTaketomborg = 53932291;
+            public const int WindaPriestessOfGusto = 54455435;
+            public const int WindwitchGlassBell = 71007216;
+
+            public const int GustoGulldo = 65277087;
+            public const int GustoEgul = 91662792;
+            public const int WindwitchSnowBell = 70117860;
+            public const int SpeedroidRedEyedDice = 16725505;
+            public const int Raigeki = 12580477;
+            public const int MonsterReborn = 83764719;
+            public const int Reasoning = 58577036;
+            public const int ElShaddollWinda = 94977269;
+
+            public const int QuillPenOfGulldos = 27980138;
+            public const int CosmicCyclone = 8267140;
+            public const int EmergencyTeleport = 67723438;
+
+            public const int ForbiddenChalice = 25789292;
+            public const int SuperTeamBuddyForceUnite = 8608979;
+            public const int KingsConsonance = 24590232;
+            public const int GozenMatch = 53334471;
+            public const int SolemnStrike = 40605147;
+            public const int SolemnWarning = 84749824;
+
+            public const int MistWurm = 27315304;
+            public const int CrystalWingSynchroDragon = 50954680;
+            public const int ClearWingSynchroDragon = 82044279;
+            public const int WindwitchWinterBell = 14577226;
+
+            public const int StardustChargeWarrior = 64880894;
+            public const int DaigustoSphreez = 29552709;
+            public const int DaigustoGulldos = 84766279;
+
+            public const int HiSpeedroidChanbara = 42110604;
+            public const int OldEntityHastorr = 70913714;
+            public const int WynnTheWindCharmerVerdant = 30674956;
+            public const int GreatFly = 90512490;
+            public const int KnightmareIblee = 10158145;
+            public const int ChaosMax = 55410871;
+            public const int SkillDrain = 82732705;
+            public const int SoulDrain = 73599290;
+            public const int Rivalry = 90846359;
+            public const int OnlyOne = 24207889;
+        }
+
+        List<int> ReposTargets = new List<int>
+        { CardId.GustoGulldo,
+            CardId.WindaPriestessOfGusto,
+            CardId.GustoEgul,
+            CardId.PilicaDescendantOfGusto,
+            CardId.DaigustoGulldos
+        };
+
+        List<int> taketomborgSpList = new List<int>
+        {   CardId.WindwitchGlassBell,
+            CardId.GustoGulldo,
+            CardId.GustoEgul,
+            CardId.SpeedroidRedEyedDice,
+            CardId.WindwitchSnowBell,
+            CardId.SpeedroidTerrortop
+        };
+
+        List<int> level1 = new List<int>
+        { CardId.GustoEgul,
+            CardId.SpeedroidRedEyedDice,
+            CardId.WindwitchSnowBell
+        };
+
+        List<int> Pilica = new List<int>
+        { 
+            CardId.ClearWingSynchroDragon,
+            CardId.WindwitchWinterBell,
+            CardId.StardustChargeWarrior
+        };
+
+        List<int> level3 = new List<int>
+        { CardId.PilicaDescendantOfGusto,
+            CardId.WindwitchIceBell,
+            CardId.SpeedroidTaketomborg
+        };
+        List<int> KeepSynchro = new List<int>
+        { CardId.DaigustoSphreez,
+            CardId.CrystalWingSynchroDragon,
+            CardId.ClearWingSynchroDragon,
+            CardId.WindwitchWinterBell,
+            CardId.GreatFly,
+            CardId.WynnTheWindCharmerVerdant
+        };
+        List<int> KeepSynchro2 = new List<int>
+        { 
+            CardId.CrystalWingSynchroDragon,
+            CardId.DaigustoSphreez,
+            CardId.ClearWingSynchroDragon,
+            CardId.WindwitchWinterBell
+        };
+        List<int> reborn = new List<int>
+        { CardId.ClearWingSynchroDragon,
+            CardId.DaigustoSphreez,
+            CardId.WindwitchWinterBell,
+            CardId.PilicaDescendantOfGusto,
+            CardId.OldEntityHastorr,
+            CardId.HiSpeedroidChanbara,
+            CardId.DaigustoGulldos
+        };
+        List<int> Gulldosulist = new List<int>
+        { CardId.CrystalWingSynchroDragon,
+            CardId.MistWurm,
+            CardId.ClearWingSynchroDragon,
+            CardId.WindwitchWinterBell,
+            CardId.ClearWingSynchroDragon,
+            CardId.StardustChargeWarrior
+        };
+        List<int> Gulldosulist2 = new List<int>
+        {
+            CardId.SpeedroidTerrortop,
+            CardId.PilicaDescendantOfGusto,
+            CardId.WindaPriestessOfGusto,
+            CardId.WindwitchIceBell,
+            CardId.SpeedroidTaketomborg,
+            CardId.OldEntityHastorr,
+            CardId.HiSpeedroidChanbara,
+            CardId.DaigustoGulldos,
+            CardId.DaigustoSphreez
+        };
+        List<int> EgulsuList = new List<int>
+        {
+            CardId.SpeedroidTerrortop,
+            CardId.PilicaDescendantOfGusto,
+            CardId.WindaPriestessOfGusto,
+            CardId.WindwitchIceBell,
+            CardId.SpeedroidTaketomborg,
+            CardId.OldEntityHastorr,
+            CardId.HiSpeedroidChanbara,
+            CardId.DaigustoGulldos,
+            CardId.DaigustoSphreez,
+            CardId.StardustChargeWarrior,
+            CardId.WindwitchWinterBell,
+            CardId.ClearWingSynchroDragon
+        };
+        List<int> SynchroList = new List<int>
+        {
+            CardId.SpeedroidTerrortop,
+            CardId.PilicaDescendantOfGusto,
+            CardId.WindwitchIceBell,
+            CardId.SpeedroidTaketomborg,
+            CardId.OldEntityHastorr,
+            CardId.HiSpeedroidChanbara,
+            CardId.DaigustoGulldos,
+            CardId.DaigustoSphreez,
+            CardId.StardustChargeWarrior,
+            CardId.WindwitchWinterBell,
+            CardId.ClearWingSynchroDragon,
+            CardId.CrystalWingSynchroDragon,
+            CardId.MistWurm
+        };
+        List<int> SynchroFull = new List<int>
+        {
+            CardId.OldEntityHastorr,
+            CardId.HiSpeedroidChanbara,
+            CardId.DaigustoGulldos,
+            CardId.DaigustoSphreez,
+            CardId.StardustChargeWarrior,
+            CardId.WindwitchWinterBell,
+            CardId.ClearWingSynchroDragon,
+            CardId.CrystalWingSynchroDragon,
+            CardId.MistWurm
+        };
+        List<int> LinkList = new List<int>
+        {
+            CardId.WynnTheWindCharmerVerdant,
+            CardId.GreatFly
+        };
+        List<int> tuner = new List<int>
+        {
+            CardId.GustoGulldo,
+            CardId.GustoEgul,
+            CardId.SpeedroidRedEyedDice,
+            CardId.WindwitchGlassBell,
+            CardId.WindwitchSnowBell
+        };
+        List<int> gusto = new List<int>
+        {
+            CardId.GustoGulldo,
+            CardId.GustoEgul,
+            CardId.WindaPriestessOfGusto,
+            CardId.PilicaDescendantOfGusto,
+            CardId.DaigustoGulldos,
+            CardId.DaigustoSphreez
+        };
+        List<int> ET = new List<int>
+        {
+            CardId.ClearWingSynchroDragon,
+            CardId.WindwitchWinterBell
+        };
+
+        private bool WindwitchGlassBelleff_used;
+        private bool Summon_used;
+        private bool Pilica_eff;
+        private bool plan_A;
+        //TODO: reset the flags when they should reset ( public override void OnNewTurn() )
+        public PureWindsExecutor(GameAI ai, Duel duel)
+            : base(ai, duel)
+        {
+            //counter
+            AddExecutor(ExecutorType.Activate, CardId.SolemnStrike, base.DefaultSolemnStrike);
+            AddExecutor(ExecutorType.Activate, CardId.SolemnWarning, base.DefaultSolemnWarning);
+            AddExecutor(ExecutorType.Activate, CardId.ForbiddenChalice, ForbiddenChaliceeff);
+            AddExecutor(ExecutorType.Activate, CardId.CrystalWingSynchroDragon, CrystalWingSynchroDragoneff);
+            AddExecutor(ExecutorType.Activate, CardId.GustoGulldo, GustoGulldoeff);
+            AddExecutor(ExecutorType.Activate, CardId.GustoEgul, GustoEguleff);
+            AddExecutor(ExecutorType.Activate, CardId.WindaPriestessOfGusto, WindaPriestessOfGustoeff);
+            AddExecutor(ExecutorType.Activate, CardId.PilicaDescendantOfGusto, PilicaDescendantOfGustoeff);
+            AddExecutor(ExecutorType.Activate, CardId.OldEntityHastorr, OldEntityHastorreff);
+            AddExecutor(ExecutorType.Activate, CardId.WynnTheWindCharmerVerdant, WynnTheWindCharmerVerdanteff);
+            AddExecutor(ExecutorType.Activate, CardId.GreatFly, GreatFlyeff);
+            AddExecutor(ExecutorType.Activate, CardId.QuillPenOfGulldos, QuillPenOfGulldoseff);
+            AddExecutor(ExecutorType.Activate, CardId.CosmicCyclone, CosmicCycloneeff);
+            AddExecutor(ExecutorType.Activate, CardId.MonsterReborn, Reborneff);
+            //plan A             
+            AddExecutor(ExecutorType.Activate, CardId.WindwitchIceBell, WindwitchIceBelleff);
+            AddExecutor(ExecutorType.Activate, CardId.WindwitchGlassBell, WindwitchGlassBelleff);
+            AddExecutor(ExecutorType.Activate, CardId.WindwitchSnowBell, WindwitchSnowBellsp);
+            AddExecutor(ExecutorType.Activate, CardId.StardustChargeWarrior);
+            AddExecutor(ExecutorType.Activate, CardId.WindwitchWinterBell, WindwitchWinterBelleff);
+            AddExecutor(ExecutorType.Activate, CardId.ClearWingSynchroDragon, ClearWingSynchroDragoneff);
+            AddExecutor(ExecutorType.Activate, CardId.DaigustoSphreez, DaigustoSphreezeff);
+            AddExecutor(ExecutorType.Activate, CardId.SpeedroidTerrortop, SpeedroidTerrortopeff);
+            AddExecutor(ExecutorType.Activate, CardId.SpeedroidTaketomborg, SpeedroidTaketomborgeff);
+            AddExecutor(ExecutorType.Activate, CardId.SpeedroidRedEyedDice, SpeedroidRedEyedDiceeff);
+            AddExecutor(ExecutorType.Activate, CardId.MistWurm, MistWurmeff);
+            AddExecutor(ExecutorType.Activate, CardId.DaigustoGulldos, DaigustoGulldoseff);
+            AddExecutor(ExecutorType.SpSummon, CardId.WindwitchWinterBell, WindwitchWinterBellsp);
+
+            AddExecutor(ExecutorType.SpSummon, CardId.CrystalWingSynchroDragon, CrystalWingSynchroDragonsp);
+            // if fail
+            AddExecutor(ExecutorType.SpSummon, CardId.ClearWingSynchroDragon, ClearWingSynchroDragonsp);
+            // if fail
+            AddExecutor(ExecutorType.SpSummon, CardId.DaigustoSphreez, DaigustoSphreezsp);
+            // plan B
+            AddExecutor(ExecutorType.SpSummon, CardId.SpeedroidTerrortop);
+            AddExecutor(ExecutorType.SpSummon, CardId.SpeedroidTaketomborg, SpeedroidTaketomborgsp);
+            //summon
+            AddExecutor(ExecutorType.Summon, CardId.PilicaDescendantOfGusto, PilicaDescendantOfGustosu);
+            AddExecutor(ExecutorType.Summon, CardId.GustoGulldo, GustoGulldosu);
+            AddExecutor(ExecutorType.Summon, CardId.GustoEgul, GustoEgulsu);
+            AddExecutor(ExecutorType.Summon, CardId.WindaPriestessOfGusto, WindaPriestessOfGustosu);
+            AddExecutor(ExecutorType.Summon, CardId.SpeedroidRedEyedDice, SpeedroidRedEyedDicesu);
+            //other thing
+            AddExecutor(ExecutorType.SpSummon, CardId.MistWurm);
+            AddExecutor(ExecutorType.SpSummon, CardId.DaigustoGulldos);
+            AddExecutor(ExecutorType.SpSummon, CardId.HiSpeedroidChanbara);
+            AddExecutor(ExecutorType.SpSummon, CardId.StardustChargeWarrior);
+            AddExecutor(ExecutorType.SpSummon, CardId.OldEntityHastorr);
+            AddExecutor(ExecutorType.SpSummon, CardId.GreatFly, GreatFlysp);
+            AddExecutor(ExecutorType.SpSummon, CardId.WynnTheWindCharmerVerdant, WynnTheWindCharmerVerdantsp);
+            AddExecutor(ExecutorType.Activate, CardId.Raigeki);
+            AddExecutor(ExecutorType.Activate, CardId.GozenMatch);
+            AddExecutor(ExecutorType.Activate, CardId.KingsConsonance, KingsConsonanceeff);
+            //trap set
+            AddExecutor(ExecutorType.SpellSet, CardId.KingsConsonance);
+            AddExecutor(ExecutorType.SpellSet, CardId.SolemnStrike);
+            AddExecutor(ExecutorType.SpellSet, CardId.SolemnWarning);
+            AddExecutor(ExecutorType.SpellSet, CardId.ForbiddenChalice);
+            AddExecutor(ExecutorType.SpellSet, CardId.SuperTeamBuddyForceUnite);
+            AddExecutor(ExecutorType.SpellSet, CardId.GozenMatch);
+            AddExecutor(ExecutorType.MonsterSet, CardId.GustoGulldo, gulldoset);
+            AddExecutor(ExecutorType.MonsterSet, CardId.GustoEgul, egulset);
+            AddExecutor(ExecutorType.MonsterSet, CardId.WindaPriestessOfGusto, windaset);
+            AddExecutor(ExecutorType.Summon, CardId.WindwitchGlassBell, WindwitchGlassBellsummonfirst);
+            AddExecutor(ExecutorType.Summon, CardId.WindwitchGlassBell, WindwitchGlassBellsummon);
+            AddExecutor(ExecutorType.MonsterSet, CardId.SpeedroidRedEyedDice, SpeedroidRedEyedDiceset);
+            AddExecutor(ExecutorType.MonsterSet, CardId.WindwitchSnowBell, WindwitchSnowBellset);
+            AddExecutor(ExecutorType.Activate, CardId.EmergencyTeleport, EmergencyTeleporteff);
+            AddExecutor(ExecutorType.Activate, CardId.Reasoning, Reasoningeff);
+            AddExecutor(ExecutorType.Activate, CardId.SuperTeamBuddyForceUnite, SuperTeamBuddyForceUniteeff);
+
+            AddExecutor(ExecutorType.Repos, MonsterRepos);
+        }
+        private bool windaset()
+        {
+            if (Enemy.HasInMonstersZoneOrInGraveyard(CardId.ChaosMax))
+                return false;
+            return true;
+        }
+        private bool egulset()
+        {
+            if (Enemy.HasInMonstersZoneOrInGraveyard(CardId.ChaosMax))
+                return false;
+            return true;
+        }
+        private bool gulldoset()
+        {
+            if (Enemy.HasInMonstersZoneOrInGraveyard(CardId.ChaosMax))
+                return false;
+            return true;
+        }
+
+        private bool Reasoningeff()
+        {
+            if ((Bot.HasInMonstersZone(CardId.CrystalWingSynchroDragon) ||
+                Bot.HasInMonstersZone(CardId.MistWurm)) &&
+                (Util.GetBotAvailZonesFromExtraDeck() == 0))
+                return false;
+            if (Bot.HasInMonstersZone(level3) &&
+                Bot.HasInMonstersZone(CardId.WindwitchGlassBell) &&
+                Bot.HasInHand(CardId.WindwitchSnowBell))
+                return false;
+            AI.SelectPosition(CardPosition.FaceUpDefence);
+            return true;
+        }
+        private bool KingsConsonanceeff()
+        {
+            AI.SelectCard(CardId.CrystalWingSynchroDragon,
+                CardId.DaigustoSphreez,
+                CardId.ClearWingSynchroDragon,
+                CardId.HiSpeedroidChanbara,
+                CardId.OldEntityHastorr);
+            return true;
+        }
+        private bool Reborneff()
+        {
+            if (Bot.HasInGraveyard(KeepSynchro2))
+            {
+                AI.SelectCard(KeepSynchro2);
+                return true;
+            }
+            if (!Util.IsOneEnemyBetter(true)) return false;
+            if (!Bot.HasInGraveyard(reborn))
+            {
+                return false;
+            }
+            AI.SelectCard(reborn);
+            return true;
+        }
+
+        private bool SpeedroidRedEyedDiceset()
+        {
+            if (Enemy.HasInMonstersZone(CardId.ChaosMax))
+                return false;
+            if ((Bot.GetMonstersInMainZone().Count + Bot.GetMonstersInExtraZone().Count) == 0)
+                return true;
+            return false;
+        }
+
+        private bool WindwitchSnowBellset()
+        {
+            if (Enemy.HasInMonstersZone(CardId.ChaosMax))
+                return false;
+            if ((Bot.GetMonstersInMainZone().Count + Bot.GetMonstersInExtraZone().Count) == 0)
+                return true;
+            return false;
+        }
+
+        private bool GreatFlysp()
+        {
+            if (Bot.HasInMonstersZone(KeepSynchro))
+                return false;
+            if (Bot.HasInMonstersZone(CardId.HiSpeedroidChanbara))
+                return false;
+            if (Bot.HasInMonstersZone(CardId.WynnTheWindCharmerVerdant))
+                return false;
+            return true;
+        }
+        private bool WynnTheWindCharmerVerdantsp()
+        { 
+            if (Bot.HasInMonstersZone(KeepSynchro))
+                return false;
+            if (Bot.HasInMonstersZone(CardId.HiSpeedroidChanbara))
+                return false;
+            if (Bot.HasInMonstersZone(CardId.GreatFly))
+                return false;
+            return true;
+        }
+        private bool MistWurmeff()
+        {
+            AI.SelectCard(Util.GetBestEnemyCard(false, true));
+            if (Util.GetBestEnemyCard(false, true) != null)
+                Logger.DebugWriteLine("*************SelectCard= " + Util.GetBestEnemyCard(false, true).Id);
+            AI.SelectNextCard(Util.GetBestEnemyCard(false, true));
+            if (Util.GetBestEnemyCard(false, true) != null)
+                Logger.DebugWriteLine("*************SelectCard= " + Util.GetBestEnemyCard(false, true).Id);
+            AI.SelectThirdCard(Util.GetBestEnemyCard(false, true));
+            if (Util.GetBestEnemyCard(false, true) != null)
+                Logger.DebugWriteLine("*************SelectCard= " + Util.GetBestEnemyCard(false, true).Id);
+            return true;
+        }
+        private bool GustoGulldosu()
+        {
+            if (Bot.HasInMonstersZone(Gulldosulist) &&
+                (Util.GetBotAvailZonesFromExtraDeck() == 0))
+            {
+                return false;
+            }
+            else if (Bot.HasInMonstersZone(CardId.DaigustoSphreez) ||
+                Bot.HasInHand(CardId.EmergencyTeleport))
+            {
+                Summon_used = true;
+                return true;
+            }
+            else if (Bot.HasInMonstersZone(Gulldosulist2) || Bot.HasInHand(CardId.SpeedroidTaketomborg))
+            {
+                Summon_used = true;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        private bool GustoEgulsu()
+        {
+            if (Bot.HasInMonstersZone(CardId.DaigustoSphreez) &&
+                !Bot.HasInHand(CardId.GustoGulldo))
+            {
+                Summon_used = true;
+                return true;
+            }
+            else if ((Bot.HasInMonstersZone(CardId.CrystalWingSynchroDragon) ||
+                Bot.HasInMonstersZone(CardId.MistWurm)) &&
+                (Util.GetBotAvailZonesFromExtraDeck() == 0))
+                return false;
+            else if (Bot.HasInMonstersZone(EgulsuList) || Bot.HasInHand(CardId.SpeedroidTaketomborg))
+            {
+                Summon_used = true;
+                return true;
+            }
+            return false;
+        }
+        private bool WindaPriestessOfGustosu()
+        {
+            if (Bot.HasInMonstersZone(CardId.DaigustoSphreez) &&
+                !Bot.HasInHand(CardId.GustoGulldo) &&
+                !Bot.HasInHand(CardId.GustoEgul))
+            {
+                Summon_used = true;
+                return true;
+            }
+            else if (Bot.HasInMonstersZone(CardId.GustoGulldo) ||
+                Bot.HasInMonstersZone(CardId.WindwitchGlassBell) ||
+                ((Bot.HasInMonstersZone(level3) || Bot.HasInMonstersZone(CardId.WindaPriestessOfGusto)) &&
+                Bot.HasInMonstersZone(tuner)) ||
+                (Bot.HasInMonstersZone(CardId.OldEntityHastorr) && Bot.HasInMonstersZone(level1)) &&
+                (Util.GetBotAvailZonesFromExtraDeck() >= 1))
+            {
+                Summon_used = true;
+                return true;
+            }
+            return false;
+        }
+        private bool SpeedroidRedEyedDicesu()
+        {
+            if ((Bot.HasInMonstersZone(CardId.CrystalWingSynchroDragon) ||
+                Bot.HasInMonstersZone(CardId.MistWurm) ||
+                Bot.HasInMonstersZone(CardId.DaigustoSphreez)) &&
+                (Util.GetBotAvailZonesFromExtraDeck() == 0))
+                return false;
+            else if (Bot.HasInMonstersZone(EgulsuList))
+            {
+                Summon_used = true;
+                return true;
+            }
+            return false;
+        }
+        private bool PilicaDescendantOfGustosu()
+        {
+            if ((Bot.HasInMonstersZone(CardId.CrystalWingSynchroDragon) ||
+                Bot.HasInMonstersZone(CardId.MistWurm)) &&
+                (Util.GetBotAvailZonesFromExtraDeck() == 0))
+                return false;
+            else if (Bot.HasInMonstersZone(Pilica) &&
+                !Bot.HasInGraveyard(level1) &&
+                (Util.GetBotAvailZonesFromExtraDeck() == 0))
+                return false;
+            else if (!Bot.HasInMonstersZoneOrInGraveyard(tuner))
+                return false;
+            else {
+                Summon_used = true;
+                return true;
+            }
+        }
+        private bool EmergencyTeleporteff()
+        {
+            if ((Bot.HasInMonstersZone(CardId.CrystalWingSynchroDragon) ||
+                Bot.HasInMonstersZone(CardId.MistWurm)) &&
+                (Util.GetBotAvailZonesFromExtraDeck() == 0))
+                return false;
+            else if (Bot.HasInMonstersZone(level3) &&
+                Bot.HasInMonstersZone(CardId.WindwitchGlassBell) &&
+                Bot.HasInHand(CardId.WindwitchSnowBell))
+                return false;
+            else if (Bot.HasInMonstersZone(tuner) && Bot.HasInMonstersZone(level3))
+                return false;
+            else if (!Bot.HasInHandOrInMonstersZoneOrInGraveyard(tuner))
+                return false;
+            else if (!Bot.HasInHandOrInMonstersZoneOrInGraveyard(level1) && Bot.HasInMonstersZone(ET))
+                return false;
+            if (Pilica_eff == true)
+                return false;
+            AI.SelectCard(CardId.PilicaDescendantOfGusto);
+            AI.SelectPosition(CardPosition.FaceUpDefence);
+            return true;
+        }
+        private bool SpeedroidRedEyedDiceeff()
+        {
+            if (Bot.HasInMonstersZone(CardId.SpeedroidTerrortop))
+            {
+                AI.SelectCard(CardId.SpeedroidTerrortop);
+                AI.SelectNumber(6);
+                return true;
+            }
+            else if (Bot.HasInMonstersZone(CardId.SpeedroidTaketomborg))
+            {
+                AI.SelectCard(CardId.SpeedroidTaketomborg);
+                AI.SelectNumber(6);
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        private bool DaigustoGulldoseff()
+        {
+            AI.SelectCard();
+            AI.SelectNextCard(Util.GetBestEnemyMonster());
+            return true;
+        }
+        private bool SpeedroidTaketomborgeff()
+        {
+            if ((Bot.GetRemainingCount(CardId.SpeedroidRedEyedDice, 1) >= 1) &&
+                Bot.HasInMonstersZone(CardId.SpeedroidTerrortop))
+            {
+                AI.SelectCard(CardId.SpeedroidRedEyedDice);
+                return true;
+            }
+            return false;
+        }
+
+        private bool QuillPenOfGulldoseff()
+        {
+            var gyTargets = Bot.Graveyard.Where(x => x.Attribute == (int)CardAttribute.Wind).Select(x => x.Id).ToArray();
+            if (gyTargets.Count() >= 2)
+            {
+                AI.SelectCard(gyTargets);
+                if (Bot.HasInSpellZone(CardId.OldEntityHastorr))
+                {
+                    AI.SelectNextCard(CardId.OldEntityHastorr);
+                }
+                else if (Util.GetProblematicEnemyCard() != null)
+                {
+
+                    AI.SelectNextCard(Util.GetProblematicEnemyCard());
+                }
+                else
+                {
+                    return false;
+                }
+                return true;
+            }
+            return false;
+        }
+
+        private bool WindwitchIceBelleff()
+        {
+            if (Enemy.HasInMonstersZone(CardId.ElShaddollWinda)) return false;
+            if (WindwitchGlassBelleff_used && !Bot.HasInHand(CardId.WindwitchSnowBell)) return false;
+            //AI.SelectPlace(Zones.z2, 1);
+            if (Bot.GetRemainingCount(CardId.WindwitchGlassBell, 3) >= 1)
+            {
+                AI.SelectCard(CardId.WindwitchGlassBell);
+            }
+            else if (Bot.HasInHand(CardId.WindwitchGlassBell))
+            {
+                AI.SelectCard(CardId.WindwitchSnowBell);
+            }
+            AI.GetSelectedPosition();
+            if (Card.Location == CardLocation.Hand)
+            {
+                AI.SelectPosition(CardPosition.FaceUpDefence);
+                AI.SelectPosition(CardPosition.FaceUpDefence);
+            }
+            return true;
+        }
+        private bool SpeedroidTaketomborgsp()
+        {
+            if (Util.GetBotAvailZonesFromExtraDeck() == 0)
+                return false;
+            if (Bot.HasInMonstersZone(CardId.DaigustoSphreez))
+                return false;
+            if (Bot.HasInMonstersZone(taketomborgSpList))
+            {
+                AI.SelectPosition(CardPosition.FaceUpDefence);
+                return true;
+            }
+            return false;
+
+        }
+        private bool WindwitchGlassBelleff()
+        {
+            if ((Bot.HasInHandOrHasInMonstersZone(CardId.WindwitchIceBell) ||
+                Bot.HasInHandOrHasInMonstersZone(CardId.SpeedroidTaketomborg) ||
+                Bot.HasInMonstersZone(CardId.PilicaDescendantOfGusto)) &&
+                !Bot.HasInHand(CardId.WindwitchSnowBell))
+            {
+                AI.SelectCard(CardId.WindwitchSnowBell);
+                WindwitchGlassBelleff_used = true;
+                return true;
+            }
+            AI.SelectCard(CardId.WindwitchIceBell);
+            WindwitchGlassBelleff_used = true;
+            return true;
+        }
+
+        private bool OldEntityHastorreff()
+        {
+            AI.SelectCard(Util.GetBestEnemyMonster());
+            return true;
+        }
+
+        private bool WynnTheWindCharmerVerdanteff()
+        {
+            AI.SelectCard(CardId.PilicaDescendantOfGusto, CardId.WindwitchIceBell, CardId.SpeedroidTerrortop, CardId.GustoGulldo, CardId.GustoEgul, CardId.WindaPriestessOfGusto);
+            return true;
+        }
+        private bool SpeedroidTerrortopeff()
+        {
+            AI.SelectCard(CardId.SpeedroidTaketomborg, CardId.SpeedroidRedEyedDice);
+            return true;
+        }
+        private bool GreatFlyeff()
+        {
+            AI.SelectCard(CardId.PilicaDescendantOfGusto, CardId.WindwitchIceBell, CardId.SpeedroidTerrortop, CardId.GustoGulldo, CardId.GustoEgul, CardId.WindaPriestessOfGusto);
+            return true;
+        }
+
+        private bool PilicaDescendantOfGustoeff()
+        {
+            AI.SelectCard(CardId.GustoGulldo, CardId.WindwitchGlassBell, CardId.WindwitchSnowBell, CardId.GustoEgul, CardId.SpeedroidRedEyedDice);
+            Pilica_eff = true;
+            return true;
+        }
+
+        private bool SuperTeamBuddyForceUniteeff()
+        {
+            foreach (ClientCard card in Duel.CurrentChain)
+                if (card.IsCode(CardId.SuperTeamBuddyForceUnite))
+                    return false;
+            if (Bot.HasInGraveyard(CardId.PilicaDescendantOfGusto) && Bot.HasInMonstersZone(CardId.DaigustoSphreez))
+            {
+                AI.SelectCard(CardId.SuperTeamBuddyForceUnite, CardId.DaigustoSphreez, CardId.PilicaDescendantOfGusto);
+                AI.SelectPosition(CardPosition.Attack);
+                return true;
+            }
+
+            if (Bot.HasInGraveyard(CardId.WindaPriestessOfGusto) && Bot.HasInMonstersZone(CardId.DaigustoSphreez))
+            {
+                AI.SelectCard(CardId.SuperTeamBuddyForceUnite, CardId.DaigustoSphreez, CardId.WindaPriestessOfGusto);
+                AI.SelectPosition(CardPosition.Attack);
+                return true;
+            }
+
+            if (Bot.HasInGraveyard(CardId.DaigustoSphreez) && Bot.HasInMonstersZone(CardId.PilicaDescendantOfGusto))
+            {
+                AI.SelectCard(CardId.SuperTeamBuddyForceUnite, CardId.PilicaDescendantOfGusto, CardId.DaigustoSphreez);
+                AI.SelectPosition(CardPosition.Attack);
+                return true;
+            }
+
+            if (Bot.HasInGraveyard(CardId.DaigustoSphreez) && Bot.HasInMonstersZone(CardId.WindaPriestessOfGusto))
+            {
+                AI.SelectCard(CardId.SuperTeamBuddyForceUnite, CardId.WindaPriestessOfGusto, CardId.DaigustoSphreez);
+                AI.SelectPosition(CardPosition.Attack);
+                return true;
+            }
+            if (Bot.HasInGraveyard(CardId.DaigustoGulldos) && Bot.HasInMonstersZone(CardId.WindaPriestessOfGusto))
+            {
+                AI.SelectCard(CardId.SuperTeamBuddyForceUnite, CardId.WindaPriestessOfGusto, CardId.DaigustoGulldos);
+                AI.SelectPosition(CardPosition.Attack);
+                return true;
+            }
+            if (Bot.HasInGraveyard(CardId.DaigustoGulldos) && Bot.HasInMonstersZone(CardId.PilicaDescendantOfGusto))
+            {
+                AI.SelectCard(CardId.SuperTeamBuddyForceUnite, CardId.DaigustoGulldos, CardId.PilicaDescendantOfGusto);
+                AI.SelectPosition(CardPosition.Attack);
+                return true;
+            }
+            if (Bot.HasInGraveyard(CardId.DaigustoSphreez) && Bot.HasInMonstersZone(CardId.DaigustoGulldos))
+            {
+                AI.SelectCard(CardId.DaigustoGulldos, CardId.DaigustoSphreez);
+                AI.SelectPosition(CardPosition.Attack);
+                return true;
+            }
+            if (Bot.HasInGraveyard(CardId.CrystalWingSynchroDragon))
+            {
+                AI.SelectCard(CardId.CrystalWingSynchroDragon);
+                AI.SelectPosition(CardPosition.Attack);
+                return true;
+            }
+            if (Bot.HasInGraveyard(CardId.CrystalWingSynchroDragon))
+            {
+                AI.SelectCard(CardId.ClearWingSynchroDragon);
+                AI.SelectPosition(CardPosition.Attack);
+                return true;
+            }
+            if (Bot.HasInGraveyard(SynchroList))
+            {
+                AI.SelectCard(SynchroList);
+                AI.SelectPosition(CardPosition.Attack);
+                return true;
+            }
+            if (Bot.HasInGraveyard(CardId.PilicaDescendantOfGusto) && Bot.HasInMonstersZone(CardId.WindaPriestessOfGusto))
+            {
+                AI.SelectCard(CardId.WindaPriestessOfGusto, CardId.PilicaDescendantOfGusto);
+                AI.SelectPosition(CardPosition.FaceUpDefence);
+                return true;
+            }
+            if (Util.GetBotAvailZonesFromExtraDeck() >= 1)
+            {
+                if ((Bot.HasInMonstersZone(CardId.SpeedroidTerrortop) ||
+                Bot.HasInMonstersZone(CardId.SpeedroidRedEyedDice) ||
+                Bot.HasInMonstersZone(CardId.HiSpeedroidChanbara)) &&
+                !Bot.HasInHand(CardId.SpeedroidTaketomborg))
+                {
+                    AI.SelectCard(CardId.SpeedroidRedEyedDice, CardId.SpeedroidTerrortop, CardId.SpeedroidTaketomborg);
+                    return true;
+                }
+                if ((Bot.HasInMonstersZone(CardId.SpeedroidTerrortop) ||
+                    Bot.HasInMonstersZone(CardId.SpeedroidRedEyedDice) ||
+                    Bot.HasInMonstersZone(CardId.HiSpeedroidChanbara)) &&
+                    Bot.HasInHand(CardId.SpeedroidTaketomborg))
+                    return false;
+            }
+            if (Bot.HasInGraveyard(CardId.SuperTeamBuddyForceUnite))
+            {
+                AI.SelectCard(CardId.SuperTeamBuddyForceUnite);
+                return true;
+            }
+            return false;
+        }
+
+        private bool WindwitchSnowBellsp()
+        {
+            if ((Bot.HasInMonstersZone(CardId.CrystalWingSynchroDragon) ||
+                Bot.HasInMonstersZone(CardId.DaigustoSphreez) ||
+                Bot.HasInMonstersZone(CardId.MistWurm)) &&
+                (Util.GetBotAvailZonesFromExtraDeck() == 0))
+                return false;
+            if (Bot.HasInMonstersZone(level3) &&
+                Bot.HasInMonstersZone(CardId.WindwitchGlassBell) &&
+                Bot.HasInMonstersZone(level1))
+                return false;
+            if ((Bot.HasInMonstersZone(CardId.ClearWingSynchroDragon) ||
+                Bot.HasInMonstersZone(CardId.WindwitchWinterBell)) &&
+                Bot.HasInMonstersZone(CardId.WindwitchSnowBell) &&
+                (Util.GetBotAvailZonesFromExtraDeck() == 0))
+                return false;
+                AI.SelectPosition(CardPosition.FaceUpDefence);
+            return true;
+        }
+        private bool DaigustoSphreezsp()
+        {
+            //AI.SelectPlace(Zones.z5, Zones.ExtraMonsterZones);
+            AI.SelectCard(CardId.WindwitchSnowBell, CardId.PilicaDescendantOfGusto, CardId.WindaPriestessOfGusto);
+            AI.SelectCard(CardId.SpeedroidRedEyedDice, CardId.PilicaDescendantOfGusto, CardId.WindaPriestessOfGusto);
+            AI.SelectCard(CardId.GustoGulldo, CardId.PilicaDescendantOfGusto);
+            AI.SelectCard(CardId.WindwitchSnowBell, CardId.DaigustoGulldos);
+            AI.SelectCard(CardId.SpeedroidRedEyedDice, CardId.DaigustoGulldos);
+            AI.SelectPosition(CardPosition.Attack);
+            return true;
+        }
+        private bool DaigustoSphreezeff()
+        {
+            if (Summon_used == true)
+            {
+                AI.SelectCard(CardId.PilicaDescendantOfGusto, CardId.GustoGulldo, CardId.GustoEgul, CardId.WindaPriestessOfGusto);
+                return true;
+            }
+            AI.SelectCard(CardId.GustoGulldo, CardId.PilicaDescendantOfGusto, CardId.GustoEgul, CardId.WindaPriestessOfGusto);
+            return true;
+        }
+        private bool WindwitchWinterBelleff()
+        {
+            AI.SelectCard(CardId.WindwitchGlassBell);
+            return true;
+        }
+
+        private bool WindwitchWinterBellsp()
+        {
+            if (Bot.HasInHandOrInSpellZone(CardId.SuperTeamBuddyForceUnite) || 
+                Bot.HasInHandOrInSpellZone(CardId.MonsterReborn))
+                return false;
+            if (Bot.HasInMonstersZone(CardId.WindwitchIceBell) &&
+                 Bot.HasInMonstersZone(CardId.WindwitchGlassBell) &&
+                 Bot.HasInMonstersZone(CardId.WindwitchSnowBell))
+            {
+                //AI.SelectPlace(Zones.z5, Zones.ExtraMonsterZones);
+                AI.GetSelectedPosition();
+                AI.SelectPosition(CardPosition.FaceUpAttack);
+                AI.SelectCard(CardId.WindwitchIceBell, CardId.WindwitchGlassBell);
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool ClearWingSynchroDragonsp()
+        {
+            if (Bot.HasInMonstersZone(CardId.DaigustoSphreez))
+                return false;
+            AI.SelectPosition(CardPosition.Attack);
+            return true;
+        }
+
+        private bool ClearWingSynchroDragoneff()
+        {
+            if (Duel.LastChainPlayer == 1)
+            {
+                return true;
+            }
+            return false;
+        }
+        private bool CrystalWingSynchroDragonsp()
+        {
+            if (Bot.HasInMonstersZone(CardId.WindwitchSnowBell) && Bot.HasInMonstersZone(CardId.WindwitchWinterBell))
+            {
+                //AI.SelectPlace(Zones.z5, Zones.ExtraMonsterZones);
+                plan_A = true;
+            }
+            else if (Bot.HasInMonstersZone(CardId.WindwitchSnowBell) && Bot.HasInMonstersZone(CardId.ClearWingSynchroDragon))
+            {
+                //AI.SelectPlace(Zones.z5, Zones.ExtraMonsterZones);
+                plan_A = true;
+            }
+            return true;
+        }
+        private bool ForbiddenChaliceeff()
+        {
+            if (Duel.LastChainPlayer == 1)
+            {
+                var target = Util.GetProblematicEnemyMonster(0, true);
+                if (target != null && !target.IsShouldNotBeSpellTrapTarget() && Duel.CurrentChain.Contains(target))
+                {
+                    AI.SelectCard(target);
+                    return true;
+                }
+            }
+            return false;
+        }
+        private bool CosmicCycloneeff()
+        {
+            foreach (ClientCard card in Duel.CurrentChain)
+                if (card.IsCode(_CardId.CosmicCyclone))
+                    return false;
+            if ((Enemy.HasInSpellZone(CardId.SkillDrain) ||
+                Enemy.HasInSpellZone(CardId.Rivalry) ||
+                Enemy.HasInSpellZone(CardId.OnlyOne)) &&
+                (Bot.LifePoints > 1000))
+            {
+                AI.SelectCard(CardId.SkillDrain, CardId.SoulDrain, CardId.Rivalry, CardId.OnlyOne);
+                return true;
+            }
+            if (Bot.HasInSpellZone(CardId.OldEntityHastorr) && (Bot.LifePoints > 1000))
+            {
+                AI.SelectCard(CardId.OldEntityHastorr);
+                return true;
+            }
+            return (Bot.LifePoints > 1000) && DefaultMysticalSpaceTyphoon();
+        }
+        private bool CrystalWingSynchroDragoneff()
+        {
+            if (Duel.LastChainPlayer == 1)
+            {
+                return true;
+            }
+            return false;
+        }
+        private bool GustoGulldoeff()
+        {
+            if (Bot.HasInMonstersZone(CardId.DaigustoSphreez))
+            {
+                AI.SelectCard(CardId.GustoEgul, CardId.WindaPriestessOfGusto);
+                AI.SelectPosition(CardPosition.Attack);
+                return true;
+            }
+            AI.SelectCard(CardId.GustoEgul, CardId.WindaPriestessOfGusto);
+            AI.SelectPosition(CardPosition.FaceUpDefence);
+            return true;
+        }
+        private bool GustoEguleff()
+        {
+            if (Bot.HasInMonstersZone(CardId.DaigustoSphreez))
+            {
+                AI.SelectCard(CardId.WindaPriestessOfGusto, CardId.PilicaDescendantOfGusto);
+                AI.SelectPosition(CardPosition.Attack);
+                return true;
+            }
+            AI.SelectCard(CardId.WindaPriestessOfGusto, CardId.PilicaDescendantOfGusto);
+            AI.SelectPosition(CardPosition.FaceUpDefence);
+            return true;
+        }
+        private bool WindaPriestessOfGustoeff()
+        {
+            if (Bot.HasInMonstersZone(CardId.DaigustoSphreez))
+            {
+                AI.SelectCard(CardId.GustoGulldo, CardId.GustoEgul);
+                AI.SelectPosition(CardPosition.Attack);
+            }
+            AI.SelectCard(CardId.GustoGulldo, CardId.GustoEgul);
+            AI.SelectPosition(CardPosition.FaceUpDefence);
+            return true;
+        }
+        private bool WindwitchGlassBellsummonfirst()
+        {
+            if (Bot.HasInHand(CardId.PilicaDescendantOfGusto) &&
+                (Bot.HasInGraveyard(CardId.GustoGulldo) ||
+                Bot.HasInGraveyard(CardId.GustoEgul) ||
+                Bot.HasInGraveyard(CardId.WindwitchGlassBell) ||
+                Bot.HasInGraveyard(CardId.SpeedroidRedEyedDice)))
+            {
+                return false;
+            }
+            if (Bot.HasInMonstersZone(CardId.DaigustoSphreez))
+                return false;
+            else if (!Bot.HasInHand(CardId.WindwitchIceBell))
+            {
+                Summon_used = true;
+                return true;
+            }
+            return false;
+        }
+        private bool WindwitchGlassBellsummon()
+        {
+            if (!plan_A && (Bot.HasInGraveyard(CardId.WindwitchGlassBell) || Bot.HasInMonstersZone(CardId.WindwitchGlassBell)))
+                return false;
+            //AI.SelectPlace(Zones.z2, 1);
+            if (Bot.HasInMonstersZone(CardId.WindwitchIceBell) &&
+                !Bot.HasInMonstersZone(CardId.WindwitchGlassBell))
+            {
+                Summon_used = true;
+                return true;
+            }
+            if (WindwitchGlassBelleff_used) return false;
+            return false;
+        }
+
+        public bool MonsterRepos()
+        {
+            if (Card.IsCode(CardId.CrystalWingSynchroDragon) || Card.IsCode(CardId.DaigustoSphreez))
+                return (!Card.HasPosition(CardPosition.Attack));
+            if (Card.IsCode(SynchroFull))
+            {
+                if (Card.IsFacedown() || Card.IsDefense())
+                   return true;
+            }     
+            if (Bot.HasInMonstersZone(CardId.DaigustoSphreez))
+            {
+                if (Card.IsCode(gusto))
+                {
+                    if (Card.IsFacedown() || Card.IsDefense())
+                    {
+                        return true;
+                    }
+                    else
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            if ((Util.GetBotAvailZonesFromExtraDeck() >= 1) &&
+                ((Bot.GetMonsterCount() - Bot.GetMonstersInExtraZone().Count) >= 2))
+            {
+                if (Bot.HasInMonstersZone(tuner) &&
+                    (Bot.HasInMonstersZone(level3) ||
+                    Bot.HasInMonstersZone(CardId.WindwitchGlassBell)))
+                {
+                    if (Card.IsFacedown())
+                        return true;
+                }
+                if (Bot.HasInMonstersZone(CardId.WindaPriestessOfGusto) &&
+                    (Bot.HasInMonstersZone(CardId.GustoGulldo) ||
+                    Bot.HasInMonstersZone(CardId.WindwitchGlassBell)))
+                {
+                    if (Card.IsFacedown())
+                        return true;
+                }
+                if (((Bot.GetMonsterCount() - Bot.GetMonstersInExtraZone().Count) >= 3) &&
+                    Bot.HasInMonstersZone(level1) &&
+                    (Bot.HasInMonstersZone(CardId.WindaPriestessOfGusto) ||
+                    Bot.HasInMonstersZone(level3)))
+                {
+                    if (Card.IsFacedown())
+                        return true;
+                }
+                if (((Bot.GetMonsterCount() - Bot.GetMonstersInExtraZone().Count) >= 2) &&
+                    (Bot.HasInMonstersZone(CardId.GustoGulldo) || Bot.HasInMonstersZone(CardId.WindwitchGlassBell)) &&
+                    Bot.HasInMonstersZone(CardId.WindaPriestessOfGusto))
+                {
+                    if (Card.IsFacedown())
+                        return true;
+                }
+            }
+            
+            if (Card.IsFacedown())
+                return false;
+            return base.DefaultMonsterRepos();
+        }
+        public override bool OnSelectHand()
+        {
+            // go first
+            return true;
+        }
+        public override bool OnPreBattleBetween(ClientCard attacker, ClientCard defender)
+        {
+            if (attacker.IsCode(CardId.CrystalWingSynchroDragon))
+            {
+                if (defender.Level >= 5)
+                    attacker.RealPower = attacker.Attack + defender.Attack;
+                return true;
+            }
+            else if (attacker.IsCode(CardId.DaigustoSphreez))
+            {
+                attacker.RealPower = attacker.Attack + defender.Attack + defender.Defense;
+                return true;
+            }
+            else if (Bot.HasInMonstersZone(CardId.DaigustoSphreez) &&
+                attacker.IsCode(CardId.DaigustoSphreez, CardId.GustoGulldo, CardId.GustoEgul, CardId.WindaPriestessOfGusto, CardId.PilicaDescendantOfGusto, CardId.DaigustoGulldos))
+            {
+                attacker.RealPower = attacker.Attack + defender.Attack + defender.Defense;
+                return true;
+            }
+            return base.OnPreBattleBetween(attacker, defender);
+        }
+
+    }
+}
\ No newline at end of file

Game/AI/Decks/SkyStrikerExecutor.cs

@@ -58,8 +58,8 @@ namespace WindBot.Game.AI.Decks
         public SkyStrikerExecutor(GameAI ai, Duel duel)
             : base(ai, duel)
         {
-            AddExecutor(ExecutorType.Activate, CardId.AshBlossom, DefaultTrap);
-            AddExecutor(ExecutorType.Activate, CardId.GhostRabbit, DefaultTrap);
+            AddExecutor(ExecutorType.Activate, CardId.AshBlossom, DefaultAshBlossomAndJoyousSpring);
+            AddExecutor(ExecutorType.Activate, CardId.GhostRabbit, DefaultGhostOgreAndSnowRabbit);
             AddExecutor(ExecutorType.Activate, CardId.EffectVeiler, DefaultBreakthroughSkill);
             AddExecutor(ExecutorType.Activate, CardId.SolemnWarning, DefaultSolemnWarning);
             AddExecutor(ExecutorType.Activate, CardId.SolemnJudgment, DefaultSolemnJudgment);

Game/AI/Decks/TimeThiefExecutor.cs

+using System;
+using YGOSharp.OCGWrapper.Enums;
+using System.Collections.Generic;
+using System.Diagnostics;
+using WindBot;
+using WindBot.Game;
+using WindBot.Game.AI;
+using System.Linq;
+using System.Reflection;
+
+namespace WindBot.Game.AI.Decks
+{
+    [Deck("TimeThief", "AI_Timethief")]
+    public class TimeThiefExecutor : DefaultExecutor
+    {
+        public class Monsters
+        {
+            //monsters
+            public const int TimeThiefWinder = 56308388;
+            public const int TimeThiefBezelShip = 82496079;
+            public const int TimeThiefCronocorder = 74578720;
+            public const int TimeThiefRegulator = 19891131;
+            public const int PhotonTrasher = 65367484;
+            public const int PerformTrickClown = 67696066;
+        }
+        
+        public class Spells
+        {
+            // spells
+            public const int UpstartGoblin = 70368879;
+            public const int Raigeki = 12580477;
+            public const int FoolishBurial = 81439173;
+            public const int TimeThiefStartup = 10877309;
+            public const int TimeThiefHack = 81670445;
+        }
+        public class Traps
+        {
+            //traps
+            public const int XyzReborn = 26708437;
+            public const int XyzExtreme = 57319935;
+            public const int TimeThiefRetrograte = 76587747;
+            public const int PhantomKnightsShade = 98827725;
+            public const int TimeThiefFlyBack = 18678554;
+        }
+        public class XYZs
+        {
+            //xyz
+            public const int TimeThiefRedoer = 55285840;
+            public const int TimeThiefPerpetua = 59208943;
+            public const int CrazyBox = 42421606;
+        }
+        
+
+        
+        public TimeThiefExecutor(GameAI ai, Duel duel)
+            : base(ai, duel)
+        {
+            // executors
+            //Spell activate
+            AddExecutor(ExecutorType.Activate,Spells.UpstartGoblin);
+            AddExecutor(ExecutorType.Activate,Spells.FoolishBurial,FoolishBurialTarget);
+            AddExecutor(ExecutorType.Activate,Spells.TimeThiefStartup,TimeThiefStartupEffect);
+            AddExecutor(ExecutorType.Activate,Spells.TimeThiefHack);  
+            
+            // trap executors set
+            AddExecutor(ExecutorType.SpellSet,Traps.XyzExtreme);
+            AddExecutor(ExecutorType.SpellSet,Traps.XyzReborn);
+            AddExecutor(ExecutorType.SpellSet,Traps.PhantomKnightsShade);
+            AddExecutor(ExecutorType.SpellSet,Traps.TimeThiefRetrograte);
+            AddExecutor(ExecutorType.SpellSet,Traps.TimeThiefFlyBack);
+            
+            //special summons
+            AddExecutor(ExecutorType.SpSummon,Monsters.PhotonTrasher ,SummonToDef);
+            AddExecutor(ExecutorType.SpSummon,Monsters.TimeThiefRegulator, SummonToDef);
+            AddExecutor(ExecutorType.SpSummon,Monsters.TimeThiefWinder, SummonToDef);
+            AddExecutor(ExecutorType.SpSummon,Monsters.PerformTrickClown, SummonToDef);
+            AddExecutor(ExecutorType.SpSummon,Monsters.TimeThiefCronocorder, SummonToDef);
+            AddExecutor(ExecutorType.SpSummon,Monsters.TimeThiefBezelShip, SummonToDef);
+            
+            //normal summons
+            AddExecutor(ExecutorType.Summon,Monsters.TimeThiefRegulator  );
+            AddExecutor(ExecutorType.Summon,Monsters.TimeThiefWinder );
+            AddExecutor(ExecutorType.Summon,Monsters.TimeThiefBezelShip );
+            AddExecutor(ExecutorType.Summon,Monsters.PerformTrickClown );
+            AddExecutor(ExecutorType.Summon,Monsters.TimeThiefCronocorder );
+            //xyz summons
+            AddExecutor(ExecutorType.SpSummon,XYZs.TimeThiefRedoer);
+            AddExecutor(ExecutorType.SpSummon,XYZs.TimeThiefPerpetua);
+            // activate trap
+            AddExecutor(ExecutorType.Activate,Traps.PhantomKnightsShade);
+            AddExecutor(ExecutorType.Activate,Traps.XyzExtreme , XyzExtremeEffect);
+            AddExecutor(ExecutorType.Activate,Traps.XyzReborn , XyzRebornEffect);
+            AddExecutor(ExecutorType.Activate,Traps.TimeThiefRetrograte , RetrograteEffect);
+            AddExecutor(ExecutorType.Activate,Traps.TimeThiefFlyBack );
+            
+            //xyz effects
+            AddExecutor(ExecutorType.Activate,XYZs.TimeThiefRedoer,RedoerEffect);
+            AddExecutor(ExecutorType.Activate,XYZs.TimeThiefPerpetua , PerpertuaEffect);
+            
+            //monster effects
+            AddExecutor(ExecutorType.Activate,Monsters.TimeThiefRegulator , RegulatorEffect);
+            AddExecutor(ExecutorType.Activate,Monsters.TimeThiefWinder);
+            AddExecutor(ExecutorType.Activate,Monsters.PhotonTrasher);
+            AddExecutor(ExecutorType.Activate,Monsters.TimeThiefCronocorder);
+            AddExecutor(ExecutorType.Activate,Monsters.PerformTrickClown);
+            AddExecutor(ExecutorType.Activate,Monsters.TimeThiefBezelShip);
+                  
+            
+        }
+
+        private bool SummonToDef()
+        {
+            AI.SelectPosition(CardPosition.Defence);
+            return true;
+        }
+        
+
+        private bool RegulatorEffect()
+        {
+            if (Card.Location == CardLocation.MonsterZone)
+            {
+                AI.SelectCard(Monsters.TimeThiefCronocorder);
+                AI.SelectCard(Monsters.TimeThiefWinder);
+                return true;
+            }
+
+            if (Card.Location == CardLocation.Grave)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        private bool PerpertuaEffect()
+        {
+            if (Bot.HasInGraveyard(XYZs.TimeThiefRedoer))
+            {
+                AI.SelectCard(XYZs.TimeThiefRedoer);
+                return true;
+            }
+
+            if (Bot.HasInMonstersZone(XYZs.TimeThiefRedoer))
+            {
+                AI.SelectCard(Monsters.TimeThiefBezelShip);
+                AI.SelectNextCard(XYZs.TimeThiefRedoer);
+                return true;
+            }
+
+            return false;
+        }
+
+        private int _totalAttack;
+        private int _totalBotAttack;
+        private bool RedoerEffect()
+        {
+
+            List<ClientCard> enemy = Enemy.GetMonstersInMainZone();
+            List<int> units = Card.Overlays;
+            if (Duel.Phase == DuelPhase.Standby && (AI.Executor.Util.GetStringId(XYZs.TimeThiefRedoer,0) ==
+                                                    ActivateDescription))
+            {
+                
+                return true;
+            }
+
+            try
+            {
+                if (Bot.HasInSpellZone(Traps.XyzReborn))
+                {
+                    return false;
+                }
+
+                if (Bot.HasInSpellZone(Traps.XyzExtreme))
+                {
+                    return false;
+                }
+
+                for (int i = 0; i < enemy.Count; i++)
+                {
+                    _totalAttack += enemy[i].Attack;
+                }
+
+                foreach (var t in Bot.GetMonsters())
+                {
+                    _totalBotAttack += t.Attack;
+                }
+
+                if (_totalAttack > Bot.LifePoints + _totalBotAttack)
+                {
+                    return false;
+                }
+                
+            
+
+                foreach (var t in enemy)
+                {
+                    if (t.Attack < 2400 || !t.IsAttack()) continue;
+                    try
+                    {
+                        AI.SelectCard(t.Id);
+                        AI.SelectCard(t.Id);
+                    }
+                    catch{}
+
+                    return true;
+                }
+            }
+            catch{}
+
+            if (Bot.UnderAttack)
+            {
+                //AI.SelectCard(Util.GetBestEnemyMonster());
+                return true;
+            }
+
+            return false;
+            
+        }
+
+        private bool RetrograteEffect()
+        {
+            if (Card.Owner== 1)
+            {
+                return true;
+            }
+            return false;
+            
+        }
+
+        private bool XyzRebornEffect()
+        {
+            if (Bot.HasInGraveyard(XYZs.TimeThiefRedoer))
+            {
+                AI.SelectCard(XYZs.TimeThiefRedoer);
+                return true;
+            }
+            return true;
+            
+        }
+        //function
+        private bool XyzExtremeEffect()
+        {
+            AI.SelectCard(XYZs.CrazyBox);
+            return true;
+        }
+        private bool TimeThiefStartupEffect()
+        {
+            if (Card.Location == CardLocation.Hand)
+            {
+                if (Bot.HasInHand(Monsters.TimeThiefRegulator) && !(Bot.GetMonsterCount() > 0))
+                {
+                    AI.SelectCard(Monsters.TimeThiefRegulator);
+                    return true;
+                }
+                if(Bot.HasInHand(Monsters.TimeThiefWinder) && Bot.GetMonsterCount()>1)
+                {
+                    AI.SelectCard(Monsters.TimeThiefWinder);
+                    return true;
+                }
+                return true;
+                
+            }
+            if (Card.Location == CardLocation.Grave)
+            {
+                AI.SelectCard(Monsters.TimeThiefCronocorder);
+                AI.SelectCard(Spells.TimeThiefHack);
+                AI.SelectCard(Traps.TimeThiefFlyBack);
+                return true;
+            }
+ 
+                return false;
+            
+        }
+        private bool FoolishBurialTarget()
+        {
+            AI.SelectCard(Monsters.PerformTrickClown);
+            return true;
+        }
+        
+
+        
+    }
+
+}

Game/AI/DefaultExecutor.cs

@@ -38,12 +38,15 @@ namespace WindBot.Game.AI
             public const int CosmicCyclone = 8267140;
             public const int ChickenGame = 67616300;
 
+            public const int SantaClaws = 46565218;
+
             public const int CastelTheSkyblasterMusketeer = 82633039;
             public const int CrystalWingSynchroDragon = 50954680;
             public const int NumberS39UtopiaTheLightning = 56832966;
             public const int Number39Utopia = 84013237;
             public const int UltimayaTzolkin = 1686814;
             public const int MekkKnightCrusadiaAstram = 21887175;
+            public const int HamonLordofStrikingThunder = 32491822;
 
             public const int MoonMirrorShield = 19508728;
             public const int PhantomKnightsFogBlade = 25542642;
@@ -87,6 +90,7 @@ namespace WindBot.Game.AI
             : base(ai, duel)
         {
             AddExecutor(ExecutorType.Activate, _CardId.ChickenGame, DefaultChickenGame);
+            AddExecutor(ExecutorType.Activate, _CardId.SantaClaws);
         }
 
         /// <summary>
@@ -197,6 +201,9 @@ namespace WindBot.Game.AI
             if (defender.IsCode(_CardId.UltimayaTzolkin) && !defender.IsDisabled() && Enemy.GetMonsters().Any(monster => !monster.Equals(defender) && monster.HasType(CardType.Synchro)))
                 return false;
 
+            if (Enemy.GetMonsters().Any(monster => !monster.Equals(defender) && monster.IsCode(_CardId.HamonLordofStrikingThunder) && !monster.IsDisabled() && monster.IsDefense()))
+                return false;
+
             if (defender.OwnTargets.Any(card => card.IsCode(_CardId.PhantomKnightsFogBlade) && !card.IsDisabled()))
                 return false;
 

Game/AI/Enums/DangerousMonster.cs

@@ -23,5 +23,6 @@
         ElShaddollConstruct = 20366274,
         ZushintheSleepingGiant = 67547370,
         Heart_eartHDragon = 97403510,
+        DaigustoSphreeze = 29552709,
     }
 }

Game/AI/Enums/Floodgate.cs

@@ -82,6 +82,24 @@
         InspectorBoarder = 15397015,
         Mashoudou = 76375976,
         EternalSoul = 48680970,
-        MarincessBattleOcean = 91027843
+        MarincessBattleOcean = 91027843,
+        TopologicZeroboros = 66403530,
+        GladiatorBeastDomitianus = 33652635,
+        SerzielWatcheroftheEvilEye = 82466274,
+        ZerrzielRuleroftheEvilEyed = 17739335,
+        GorgonEmpressoftheEvilEyed = 29357687,
+        UnchainedSoulofRage = 67680512,
+        DracoBerserkeroftheTenyi = 5041348,
+        NidhoggGeneraiderBossofIce = 49275969,
+        UtgardaGeneraiderBossofDelusion = 744887,
+        FrodiGeneraiderBossofSwords = 40998517,
+        HoarrGeneraiderBossofRumbling = 68199168,
+        GodPhoenixGearfried = 22091647,
+        BrotherhoodoftheFireFistEland = 61472381,
+        PredaplantVerteAnaconda = 70369116,
+        RedSupernovaDragon = 99585850,
+        NumberF0UtopicFutureDragon = 26973555,
+        InvokedAugoeides = 97300502,
+        DragonmaidStrahl = 24799107
     }
 }

Game/AI/Enums/InvincibleMonster.cs

@@ -64,6 +64,8 @@
         NumberF0UtopicFutureFutureSlash = 43490025,
         NumberF0UtopicFuture = 65305468,
         GoukiTheGiantOgre = 47946130,
-        BorrelswordDragon = 85289965
+        BorrelswordDragon = 85289965,
+        NumberF0UtopicFutureDragon = 26973555,
+        BorrelendDragon = 98630720
     }
 }

Game/AI/Enums/ShouldBeDisabledBeforeItUseEffectMonster.cs

@@ -44,6 +44,12 @@
         PaladinofDarkDragon = 71408082,
         PaladinofPhotonDragon = 85346853,
         TwinPhotonLizard = 29455728,
+        TimeThiefRegulator = 19891131,
+        MathmechNabla = 53577438,
+        NidhoggGeneraiderBossofIce = 49275969,
+        HoarrGeneraiderBossofRumbling = 68199168,
+        RedFamiliar = 8372133,
+        AccesscodeTalker = 86066372,
 
         CosmoBrain = 85679527,
         ShiranuiSolitaire = 94801854,

Game/AI/Enums/ShouldNotBeMonsterTarget.cs

@@ -13,6 +13,7 @@
         CXyzSimontheGreatMoralLeader = 41147577,
         PaleozoicAnomalocaris = 61307542,
         PaleozoicOpabinia = 37649320,
-        BorreloadDragon = 31833038
+        BorreloadDragon = 31833038,
+        BorrelendDragon = 98630720
     }
 }

Game/AI/Enums/ShouldNotBeTarget.cs

@@ -49,5 +49,6 @@
         Blackwing_FullArmoredWing = 54082269,
         DragunofRedEyes = 37818794,
         RedEyesBDragon = 74677422, // sometimes the name of DragunofRedEyes will be changed to RedEyesBDragon
+        TheArrivalCyberseIgnister = 11738489
     }
 }

Game/GameBehavior.cs

@@ -683,12 +683,14 @@ namespace WindBot.Game
 
         private void OnChaining(BinaryReader packet)
         {
-            packet.ReadInt32(); // card id
+            int cardId = packet.ReadInt32();
             int pcc = GetLocalPlayer(packet.ReadByte());
             int pcl = packet.ReadByte();
             int pcs = packet.ReadSByte();
             int subs = packet.ReadSByte();
             ClientCard card = _duel.GetCard(pcc, pcl, pcs, subs);
+            if (card.Id == 0)
+                card.SetId(cardId);
             int cc = GetLocalPlayer(packet.ReadByte());
             if (_debug)
                 if (card != null) Logger.WriteLine("(" + cc.ToString() + " 's " + (card.Name ?? "UnKnowCard") + " activate effect)");

WindBot.csproj

@@ -68,6 +68,8 @@
     <Compile Include="Game\AI\DecksManager.cs" />
     <Compile Include="Game\AI\Decks\AltergeistExecutor.cs" />
     <Compile Include="Game\AI\Decks\BlackwingExecutor.cs" />
+    <Compile Include="Game\AI\Decks\MathMechExecutor.cs" />
+    <Compile Include="Game\AI\Decks\PureWindsExecutor.cs" />
     <Compile Include="Game\AI\Decks\DragunExecutor.cs" />
     <Compile Include="Game\AI\Decks\Level8Executor.cs" />
     <Compile Include="Game\AI\Decks\SalamangreatExecutor.cs" />
@@ -77,6 +79,7 @@
     <Compile Include="Game\AI\Decks\SkyStrikerExecutor.cs" />
     <Compile Include="Game\AI\Decks\MokeyMokeyKingExecutor.cs" />
     <Compile Include="Game\AI\Decks\MokeyMokeyExecutor.cs" />
+    <Compile Include="Game\AI\Decks\TimeThiefExecutor.cs" />
     <Compile Include="Game\AI\Decks\ToadallyAwesomeExecutor.cs" />
     <Compile Include="Game\AI\Decks\NekrozExecutor.cs" />
     <Compile Include="Game\AI\Decks\GravekeeperExecutor.cs" />