public OldSchoolExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            AddExecutor(ExecutorType.Activate, 19613556, DefaultHeavyStorm);
            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
            AddExecutor(ExecutorType.Activate, 53129443, DefaultDarkHole);
            AddExecutor(ExecutorType.Activate, (int)CardId.Raigeki, DefaultRaigeki);
            AddExecutor(ExecutorType.Activate, 26412047, DefaultHammerShot);
            AddExecutor(ExecutorType.Activate, 66788016);
            AddExecutor(ExecutorType.Activate, 72302403, SwordsOfRevealingLight);
            AddExecutor(ExecutorType.Activate, 43422537, DoubleSummon);

            AddExecutor(ExecutorType.Summon, 83104731, DefaultTributeSummon);
            AddExecutor(ExecutorType.Summon, 6631034, DefaultTributeSummon);
            AddExecutor(ExecutorType.SummonOrSet, 43096270);
            AddExecutor(ExecutorType.SummonOrSet, 69247929);
            AddExecutor(ExecutorType.MonsterSet, 30190809);
            AddExecutor(ExecutorType.SummonOrSet, 77542832);
            AddExecutor(ExecutorType.SummonOrSet, 11091375);
            AddExecutor(ExecutorType.SummonOrSet, 35052053);
            AddExecutor(ExecutorType.SummonOrSet, 49881766);

            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);

            AddExecutor(ExecutorType.Activate, 44095762, DefaultTrap);
            AddExecutor(ExecutorType.Activate, 70342110, DefaultTrap);
        }
Beispiel #2
0
 public DuelResponseHandler(Duel card, Player targetPlayer, Player owner)
     : base(targetPlayer, owner)
 {
     this.card = card;
     this.targetPlayer = targetPlayer;
     this.owner = owner;
 }
Beispiel #3
0
 protected Executor(GameAI ai, Duel duel)
 {
     Duel = duel;
     AI = ai;
     Executors = new List<CardExecutor>();
     CurrentChain = new List<ClientCard>();
 }
Beispiel #4
0
        public HorusExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);

            AddExecutor(ExecutorType.Activate, (int)CardId.HorusTheBlackFlameDragonLv6);
            AddExecutor(ExecutorType.Activate, (int)CardId.StampingDestruction, DefaultStampingDestruction);
            AddExecutor(ExecutorType.Activate, (int)CardId.MysticalSpaceTyphoon, DefaultMysticalSpaceTyphoon);
            AddExecutor(ExecutorType.Activate, (int)CardId.FoolishBurial, FoolishBurial);
            AddExecutor(ExecutorType.Activate, (int)CardId.Mountain, DefaultField);
            AddExecutor(ExecutorType.Activate, (int)CardId.DarkHole, DefaultDarkHole);
            AddExecutor(ExecutorType.Activate, (int)CardId.Raigeki, DefaultRaigeki);
            AddExecutor(ExecutorType.Activate, (int)CardId.HammerShot, DefaultHammerShot);
            AddExecutor(ExecutorType.Activate, (int)CardId.Fissure);

            AddExecutor(ExecutorType.SpSummon, (int)CardId.CyberDragon);
            AddExecutor(ExecutorType.Activate, (int)CardId.BellowOfTheSilverDragon, BellowOfTheSilverDragon);
            AddExecutor(ExecutorType.Activate, (int)CardId.MonsterReborn, MonsterReborn);

            AddExecutor(ExecutorType.Summon, (int)CardId.WhiteNightDragon, WhiteNightDragon);
            AddExecutor(ExecutorType.Summon, (int)CardId.HorusTheBlackFlameDragonLv6, DefaultTributeSummon);
            AddExecutor(ExecutorType.Summon, (int)CardId.AlexandriteDragon);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.AxeDragonute);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.DodgerDragon);
            AddExecutor(ExecutorType.MonsterSet, (int)CardId.GolemDragon);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.LusterDragon);

            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);

            AddExecutor(ExecutorType.Activate, (int)CardId.HorusTheBlackFlameDragonLv8, HorusTheBlackFlameDragonLv8);
            AddExecutor(ExecutorType.Activate, (int)CardId.MirrorForce, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.DimensionalPrison, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.DragonsRebirth, DragonsRebirth);
        }
Beispiel #5
0
        public DragunityExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            // Set traps
            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);

            // Execute spells
            AddExecutor(ExecutorType.Activate, (int)CardId.MysticalSpaceTyphoon, MysticalSpaceTyphoon);
            AddExecutor(ExecutorType.Activate, (int)CardId.AssaultTeleport);
            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);

            // 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);
        }
        public ChaosDragonExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            // Execute spells
            AddExecutor(ExecutorType.Activate, (int)CardId.MST, MysticalSpaceTyphoon);
            AddExecutor(ExecutorType.Activate, (int)CardId.DarkHole, DarkHole);
            AddExecutor(ExecutorType.Activate, (int)CardId.Reasoning);
            AddExecutor(ExecutorType.Activate, (int)CardId.FoolishBurial, FoolishBurial);
            AddExecutor(ExecutorType.Activate, (int)CardId.Charge, ChargeoftheLightBrigade);
            AddExecutor(ExecutorType.Activate, (int)CardId.DDR, DDR);

            //Execute Traps
            AddExecutor(ExecutorType.Activate, (int)CardId.EscapeFromTheDarkDimension, EscapefromtheDarkDimension);

            // Execute monsters
            AddExecutor(ExecutorType.Activate, (int)CardId.REDMD, REDMDEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.Darkflare, DarkflareEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.CardTrooper, CardTrooperEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.ChaosSorc, ChaosSorcEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.DivineDragon, DivineDragonEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.DAD, DADEffect);

            // Special Summon
            AddExecutor(ExecutorType.SpSummon, (int)CardId.REDMD, REDMDSummon);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.DAD);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.Lightpulsar, LightpulsarSummon);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.Darkflare, ChaosSummon);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.BLSEotB, ChaosSummon);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.ChaosSorc, ChaosSummon);

            // Use draw effects if we can't do anything else
            AddExecutor(ExecutorType.Activate, (int)CardId.Allure, AllureofDarkness);

            // Normal Summon
            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);
            AddExecutor(ExecutorType.MonsterSet, (int)CardId.Ryko);
            AddExecutor(ExecutorType.Summon, (int)CardId.Calc, Calculator);
            AddExecutor(ExecutorType.Summon, (int)CardId.CardTrooper);
            AddExecutor(ExecutorType.Summon, (int)CardId.TKRO);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.DivineDragon);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.EclipseWyvern);

            // Chain traps and monsters
            AddExecutor(ExecutorType.Activate, (int)CardId.Warning, SolemnWarning);
            AddExecutor(ExecutorType.Activate, (int)CardId.Torrential, TorrentialTribute);
            AddExecutor(ExecutorType.Activate, (int)CardId.MirrorForce, MirrorForce);
            AddExecutor(ExecutorType.Activate, (int)CardId.Compulsory, CompulsoryEvac);
            AddExecutor(ExecutorType.Activate, (int)CardId.GalaxyEyesPhotonDragon, GEPDEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.BLSEotB, BLSEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.Lightpulsar, LightpulsarEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.Gorz);
            AddExecutor(ExecutorType.Activate, (int)CardId.Fader, BattleFader);
            AddExecutor(ExecutorType.Activate, (int)CardId.TKRO, SolemnWarning);

            // Set traps
            AddExecutor(ExecutorType.SpellSet, SetOurTraps);
        }
Beispiel #7
0
        internal bool Remove(Duel duel)
        {
            var comparer = new Duel.EqualityComparer();
            var index = this.Duels.FindIndex(d => comparer.Equals(d, duel));
            if (index < 0) return false;

            this.Duels.RemoveAt(index);
            return true;
        }
Beispiel #8
0
        public NekrozExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            NekrozRituelCard.Add((int)CardId.Solais);
            NekrozRituelCard.Add((int)CardId.Unicore);
            NekrozRituelCard.Add((int)CardId.ArmureInvincible);
            NekrozRituelCard.Add((int)CardId.Brionac);
            NekrozRituelCard.Add((int)CardId.Trishula);
            NekrozRituelCard.Add((int)CardId.Gungnir);
            NekrozRituelCard.Add((int)CardId.Valkyrus);

            NekrozSpellCard.Add((int)CardId.Miroir);
            NekrozSpellCard.Add((int)CardId.Kaleidoscope);
            NekrozSpellCard.Add((int)CardId.Cycle);

            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);

            AddExecutor(ExecutorType.Activate, (int)CardId.Raigeki, DefaultRaigeki);
            AddExecutor(ExecutorType.Activate, (int)CardId.RenfortDeLarmee, Renfort);
            AddExecutor(ExecutorType.Activate, (int)CardId.Transaction);
            AddExecutor(ExecutorType.Activate, (int)CardId.PreparationDesRites);
            AddExecutor(ExecutorType.Activate, (int)CardId.Miroir);
            AddExecutor(ExecutorType.Activate, (int)CardId.Kaleidoscope);
            AddExecutor(ExecutorType.Activate, (int)CardId.Cycle);
            AddExecutor(ExecutorType.Activate, (int)CardId.Typhon, DefaultMysticalSpaceTyphoon);
            AddExecutor(ExecutorType.Activate, (int)CardId.Decret);

            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.PrincesseDansanteNekroz, Princesse);
            AddExecutor(ExecutorType.MonsterSet, (int)CardId.Shurit, Shurit);
            AddExecutor(ExecutorType.Summon, (int)CardId.SenjuMilleMain, Senju);
            AddExecutor(ExecutorType.Summon, (int)CardId.ManjuMilleMain, Manju);
            AddExecutor(ExecutorType.Summon, (int)CardId.FantomeDuChaos, Fantome);

            AddExecutor(ExecutorType.Activate, (int)CardId.Unicore, Unicore);
            AddExecutor(ExecutorType.Activate, (int)CardId.ArmureInvincible, Armure);
            AddExecutor(ExecutorType.Activate, (int)CardId.Valkyrus, Valkyrus);
            AddExecutor(ExecutorType.Activate, (int)CardId.Gungnir, Gungnir);
            AddExecutor(ExecutorType.Activate, (int)CardId.Brionac, Brionac);
            AddExecutor(ExecutorType.Activate, (int)CardId.Solais, Solais);
            AddExecutor(ExecutorType.Activate, (int)CardId.Exciton, Exciton);
            AddExecutor(ExecutorType.Activate, (int)CardId.FantomeDuChaos, FantomeEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.Cancrelat);
            AddExecutor(ExecutorType.Activate, (int)CardId.SenjuMilleMain, SenjuEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.ManjuMilleMain, Brionac);
            AddExecutor(ExecutorType.Activate, (int)CardId.Herault);

            AddExecutor(ExecutorType.SpSummon, (int)CardId.Trishula);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.ArmureInvincible);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.Valkyrus);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.Gungnir);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.Brionac);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.Unicore);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.Solais);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.Exciton, Exciton);
        }
Beispiel #9
0
        public static Executor Instantiate(GameAI ai, Duel duel)
        {
            DeckInstance infos;

            string deck = ai.Game.Deck_;

            if (deck != null && _decks.ContainsKey(deck))
                infos = _decks[deck];
            else
                infos = _list[_rand.Next(_list.Count)];

            Executor executor = (Executor)Activator.CreateInstance(infos.Type, ai, duel);
            executor.Deck = infos.Deck;
            return executor;
        }
Beispiel #10
0
        public GameBehavior(GameClient game)
        {
            Game = game;
            Connection = game.Connection;

            _packets = new Dictionary<StocMessage, Action<GamePacketReader>>();
            _messages = new Dictionary<GameMessage, Action<GamePacketReader>>();
            RegisterPackets();

            _room = new Room();
            _duel = new Duel();

            _ai = new GameAI(Game, _duel);
            _ai.Executor = DecksManager.Instantiate(_ai, _duel);
            Deck = Deck.Load(_ai.Executor.Deck);
        }
Beispiel #11
0
        public CyberDragonExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            Bot = Duel.Fields[0];

            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);

            AddExecutor(ExecutorType.SpellSet, (int)CardId.Defusion);

            AddExecutor(ExecutorType.Activate, (int)CardId.CapsuleDuneAutreDimension, Capsule);
            AddExecutor(ExecutorType.Activate, (int)CardId.Raigeki, DefaultRaigeki);
            AddExecutor(ExecutorType.Activate, (int)CardId.Polymerisation, Polymeration);
            AddExecutor(ExecutorType.Activate, (int)CardId.LienDePuissance, LienDePuissance);
            AddExecutor(ExecutorType.Activate, (int)CardId.ExplosionDevolution, ExplosionDevolution);
            AddExecutor(ExecutorType.Activate, (int)CardId.DarkHole, DefaultDarkHole);
            AddExecutor(ExecutorType.Activate, (int)CardId.UniteDeGenerationPhotonique);
            AddExecutor(ExecutorType.Activate, (int)CardId.Defusion, Defusion);

            AddExecutor(ExecutorType.Activate, (int)CardId.TrappeSansFond, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.ForceDeMirroir, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.UniteReflectiveDattaque);
            AddExecutor(ExecutorType.Activate, (int)CardId.Disfonction);
            AddExecutor(ExecutorType.Activate, (int)CardId.AppelDeLetreHante, DefaultCallOfTheHaunted);

            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.CyberDragonDrei, NoCyberDragonSpSummon);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.CyberPhoenix, NoCyberDragonSpSummon);
            AddExecutor(ExecutorType.Summon, (int)CardId.NagaCyber, NoCyberDragonSpSummon);
            AddExecutor(ExecutorType.MonsterSet, (int)CardId.CyberDragonNoyau, NoCyberDragonSpSummon);
            AddExecutor(ExecutorType.MonsterSet, (int)CardId.CyberVouivre, CyberVouivre);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.CyberDragonProto, CyberDragonProto);
            AddExecutor(ExecutorType.Summon, (int)CardId.CyberKirin, CyberKirin);

            AddExecutor(ExecutorType.SpSummon, (int)CardId.CyberDragon);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.CyberDragonUltime);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.CyberDragonJumele);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.CyberDragonLaser);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.CyberDragonBarriere);

            AddExecutor(ExecutorType.Activate, (int)CardId.CyberDragonLaser);
            AddExecutor(ExecutorType.Activate, (int)CardId.CyberDragonBarriere);
            AddExecutor(ExecutorType.Activate, (int)CardId.CyberDragonDrei);
            AddExecutor(ExecutorType.Activate, (int)CardId.CyberPhoenix);
            AddExecutor(ExecutorType.Activate, (int)CardId.CyberKirin);
            AddExecutor(ExecutorType.Activate, (int)CardId.CyberVouivre, CyberVouivreEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.NagaCyber);
        }
Beispiel #12
0
        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, DarkHole);
            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);
        }
        public BlackwingExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);

            AddExecutor(ExecutorType.Activate, (int)CardId.MysticalSpaceTyphoon, MysticalSpaceTyphoon);
            AddExecutor(ExecutorType.Activate, (int)CardId.DarkHole, DefaultDarkHole);
            AddExecutor(ExecutorType.Activate, (int)CardId.Raigeki, DefaultRaigeki);
            AddExecutor(ExecutorType.Activate, (int)CardId.TourbillonNoir, TourbillonNoir);

            AddExecutor(ExecutorType.SpSummon, (int)CardId.KrisLaFissure);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.KrisLaFissure);
            AddExecutor(ExecutorType.Summon, (int)CardId.Sirocco, Sirocco);
            AddExecutor(ExecutorType.Summon, (int)CardId.Shura, Shura);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.Shura);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.Bora);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.Bora);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.Kalut, Kalut);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.MisralLeTourbillon);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.MisralLeTourbillon);
            AddExecutor(ExecutorType.Summon, (int)CardId.Blizzard, Blizzard);
            AddExecutor(ExecutorType.MonsterSet, (int)CardId.MistralLeBouclier);

            AddExecutor(ExecutorType.SpSummon, (int)CardId.VentDargent);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.Maitre);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.Gram);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.Arsenal);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.AileSombre);

            AddExecutor(ExecutorType.Activate, (int)CardId.MirrorForce, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.DimensionalPrison, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.CorbeauxDelta, CorbeauxDelta);
            AddExecutor(ExecutorType.Activate, (int)CardId.CorbeauxDelta, DefaultUniqueTrap);

            AddExecutor(ExecutorType.Activate, (int)CardId.Blizzard);
            AddExecutor(ExecutorType.Activate, (int)CardId.Shura);
            AddExecutor(ExecutorType.Activate, (int)CardId.Kalut, KaluhSiroccoEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.Sirocco, KaluhSiroccoEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.MisralLeTourbillon, MistralLeTourbillonEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.VentDargent);
            AddExecutor(ExecutorType.Activate, (int)CardId.AileSombre);
            AddExecutor(ExecutorType.Activate, (int)CardId.Maitre);
            AddExecutor(ExecutorType.Activate, (int)CardId.Arsenal);
            AddExecutor(ExecutorType.Activate, (int)CardId.Gram);

            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);
        }
        public ProtecteursExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);

            AddExecutor(ExecutorType.Activate, (int)CardId.InvitationDesTenebres);
            AddExecutor(ExecutorType.Activate, (int)CardId.TrouNoir, DefaultDarkHole);
            AddExecutor(ExecutorType.Activate, (int)CardId.SacrificeRoyal);
            AddExecutor(ExecutorType.Activate, (int)CardId.Stelle);
            AddExecutor(ExecutorType.Activate, (int)CardId.Typhon, DefaultMysticalSpaceTyphoon);
            AddExecutor(ExecutorType.Activate, (int)CardId.LivreDeLaLune, DefaultBookOfMoon);
            AddExecutor(ExecutorType.Activate, (int)CardId.TempleCaches, TempleCaches);
            AddExecutor(ExecutorType.Activate, (int)CardId.ValleeMortuaire, ValleeMortuaire);

            AddExecutor(ExecutorType.Activate, (int)CardId.TrappeSansFond, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.MirrorForce, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.Prison, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.Rite, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.TombeImperial, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.Hommage, DefaultTorrentialTribute);

            AddExecutor(ExecutorType.Summon, (int)CardId.DevinProtecteurs);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragonPoussiereDetoileCorrompu, DragonPoussiereDetoileCorrompu);
            AddExecutor(ExecutorType.Summon, (int)CardId.Oracle);
            AddExecutor(ExecutorType.Summon, (int)CardId.Chef);
            AddExecutor(ExecutorType.Summon, (int)CardId.RaiOh);
            AddExecutor(ExecutorType.Summon, (int)CardId.Commandant, CommandantSummon);
            AddExecutor(ExecutorType.Summon, (int)CardId.Assailant);
            AddExecutor(ExecutorType.Summon, (int)CardId.Serviteur);
            AddExecutor(ExecutorType.MonsterSet, (int)CardId.Espion);
            AddExecutor(ExecutorType.MonsterSet, (int)CardId.Recruteur);

            AddExecutor(ExecutorType.Activate, (int)CardId.DevinProtecteurs);
            AddExecutor(ExecutorType.Activate, (int)CardId.Oracle);
            AddExecutor(ExecutorType.Activate, (int)CardId.Chef);
            AddExecutor(ExecutorType.Activate, (int)CardId.Commandant, Commandant);
            AddExecutor(ExecutorType.Activate, (int)CardId.Assailant, Assailant);
            AddExecutor(ExecutorType.Activate, (int)CardId.Serviteur, Serviteur);
            AddExecutor(ExecutorType.Activate, (int)CardId.Espion, EspionOuRecruteur);
            AddExecutor(ExecutorType.Activate, (int)CardId.Recruteur, EspionOuRecruteur);
        }
Beispiel #15
0
 public ExodiaExecutor(GameAI ai, Duel duel)
     : base(ai, duel)
 {
     AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
     AddExecutor(ExecutorType.Repos, (int)CardId.RoyalMagicalLibrary);
     AddExecutor(ExecutorType.Summon, (int)CardId.RoyalMagicalLibrary);
     AddExecutor(ExecutorType.Activate, (int)CardId.DoubleSummon);
     AddExecutor(ExecutorType.Activate, (int)CardId.RoyalMagicalLibrary);
     AddExecutor(ExecutorType.Activate, (int)CardId.ToonTableOfContents, ToonTableofContents);
     AddExecutor(ExecutorType.Activate, (int)CardId.BrokenBambooSword);
     AddExecutor(ExecutorType.Activate, (int)CardId.TradeIn);
     AddExecutor(ExecutorType.Activate, (int)CardId.CardsOfConsonance);
     AddExecutor(ExecutorType.Activate, (int)CardId.GoldenBambooSword);
     AddExecutor(ExecutorType.Activate, (int)CardId.OneDayofPeace);
     AddExecutor(ExecutorType.Activate, (int)CardId.UpstartGoblin);
     AddExecutor(ExecutorType.Activate, (int)CardId.SpellPowerGrasp);
     AddExecutor(ExecutorType.Activate, (int)CardId.MagicalMallet, MagicalMallet);
     AddExecutor(ExecutorType.Activate, (int)CardId.PotOfDuality, PotOfDuality);
     AddExecutor(ExecutorType.Activate, (int)CardId.ToonWorld);
 }
Beispiel #16
0
        public BlueEyesExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);

            AddExecutor(ExecutorType.Activate, (int)CardId.Decret, Decret);
            AddExecutor(ExecutorType.Activate, (int)CardId.Raigeki, DefaultRaigeki);
            AddExecutor(ExecutorType.Activate, (int)CardId.Transaction, Transaction);
            AddExecutor(ExecutorType.Activate, (int)CardId.CartesHarmonie, Harmonie);
            AddExecutor(ExecutorType.Activate, (int)CardId.TrouNoir, DefaultDarkHole);
            AddExecutor(ExecutorType.Activate, (int)CardId.UpstartGobelin);
            AddExecutor(ExecutorType.Activate, (int)CardId.MiroirDragon, MiroirDragon);
            AddExecutor(ExecutorType.Activate, (int)CardId.EpeesRevelationLumiere, DefaultSwordsOfRevealingLight);
            AddExecutor(ExecutorType.Activate, (int)CardId.DestructionDeMain, DestructionDeMain);
            AddExecutor(ExecutorType.Activate, (int)CardId.SilverCry);

            AddExecutor(ExecutorType.Summon, (int)CardId.Pierre, HasDragonSombreInHand);
            AddExecutor(ExecutorType.Summon, (int)CardId.DragonAppat, HasDragonSombreInHand);
            AddExecutor(ExecutorType.MonsterSet, (int)CardId.Pierre, Pierre);
            AddExecutor(ExecutorType.Summon, (int)CardId.Maiden);
            AddExecutor(ExecutorType.Summon, (int)CardId.Kaibaman, HasDragonInHand);
            AddExecutor(ExecutorType.MonsterSet, (int)CardId.KomodoDragon, HasDragonInHand);
            AddExecutor(ExecutorType.MonsterSet, (int)CardId.DragonAppat, Appat);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.Kaibaman, DragonEtincelant1OuMirage);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.DragonEtincelant1, DragonEtincelant1OuMirage);
            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.DragonMirage, DragonEtincelant1OuMirage);

            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragonSombreMetalique);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragonTonnerre);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragonAzur);

            AddExecutor(ExecutorType.Activate, (int)CardId.Maiden);
            AddExecutor(ExecutorType.Activate, (int)CardId.Pierre);
            AddExecutor(ExecutorType.Activate, (int)CardId.Kaibaman);
            AddExecutor(ExecutorType.Activate, (int)CardId.DragonAzur, AppatEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.DragonSombreMetalique, DragonSombre);
            AddExecutor(ExecutorType.Activate, (int)CardId.DragonTonnerre, DefaultDarkHole);
            AddExecutor(ExecutorType.Activate, (int)CardId.KomodoDragon, KomodoEffect);
            AddExecutor(ExecutorType.Activate, (int)CardId.DragonAppat, AppatEffect);
        }
Beispiel #17
0
        public CorrompuExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            CorrompuCard.Add((int)CardId.DragonArcEnCielCorrompu);
            CorrompuCard.Add((int)CardId.DragonBlancAuxYeuxBleusCorrompu);
            CorrompuCard.Add((int)CardId.DragonDeLaVeriteCorrompu);
            CorrompuCard.Add((int)CardId.DragonNoirAuxYeuxRougeCorrompu);
            CorrompuCard.Add((int)CardId.CyberDragonUltimeCorrompu);
            CorrompuCard.Add((int)CardId.DragonPoussiereDetoileCorrompu);

            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);

            AddExecutor(ExecutorType.Activate, (int)CardId.TrouNoir, DefaultDarkHole);
            AddExecutor(ExecutorType.Activate, (int)CardId.Transaction);
            AddExecutor(ExecutorType.Activate, (int)CardId.EpeesRevelationLumiere, SwordsOfRevealingLight);
            AddExecutor(ExecutorType.Activate, (int)CardId.TerraFormation, Terraforming);
            AddExecutor(ExecutorType.Activate, (int)CardId.GraalInterdit, GraalInterdit);
            AddExecutor(ExecutorType.Activate, (int)CardId.MondeCorrompu, MondeCorrompu);
            AddExecutor(ExecutorType.Activate, (int)CardId.SceauDorichalque, IsFieldEmpty);

            AddExecutor(ExecutorType.Activate, (int)CardId.TrappeSansFond, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.PrisonDimensionelle, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.ForceDeMirroir, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.AbsorptionCompetence);
            AddExecutor(ExecutorType.Activate, (int)CardId.DelugeCorrompu, DelugeCorrompu);

            AddExecutor(ExecutorType.Summon, (int)CardId.RouageDimensionelCorrompu, RouageDimensionelCorrompu);
            AddExecutor(ExecutorType.Summon, (int)CardId.Barbaros, Barbaros);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.CyberDragonUltimeCorrompu, CorrompuMonsterWithoutStardust);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragonArcEnCielCorrompu, CorrompuMonsterWithoutStardust);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragonBlancAuxYeuxBleusCorrompu, SynchroCorrompu);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragonNoirAuxYeuxRougeCorrompu, CorrompuMonsterWithoutStardust);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragonPoussiereDetoileCorrompu, DragonPoussiereDetoileCorrompu);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragonDeLaVeriteCorrompu);
            AddExecutor(ExecutorType.SpSummon, (int)CardId.DragonParadoxeCorrumpu, DragonParadoxe);

            AddExecutor(ExecutorType.Activate, (int)CardId.DragonParadoxeCorrumpu);
            AddExecutor(ExecutorType.Activate, (int)CardId.DragonDeLaVeriteCorrompu);
        }
Beispiel #18
0
        public SuperRoboExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            AddExecutor(ExecutorType.Activate,(int)CardId.MysticalSpaceTyphoon,MysticalSpaceTyphoon);

            //Monsters
            AddExecutor(ExecutorType.Summon,(int)CardId.MechinaGearFrame, SummonGearFrame);
            AddExecutor(ExecutorType.Activate,(int)CardId.MechinaGearFrame,GearFrameEffect);

            AddExecutor(ExecutorType.SummonOrSet,(int)CardId.CardTrooper);
            AddExecutor(ExecutorType.Activate,(int)CardId.CardTrooper,CardTrooperEffect);

            AddExecutor(ExecutorType.Summon,(int)CardId.SuperRoboElephan, SummonSuperRoboElephan);
            AddExecutor(ExecutorType.Summon,(int)CardId.SuperRoboMonkei,SummonSuperRoboMonkei);
            AddExecutor(ExecutorType.Summon, (int)CardId.SuperRoboLeo, SummonSuperRoboLio);

            AddExecutor(ExecutorType.SpSummon, (int) CardId.GearspinrgSpirit, SummonGearspring);

            AddExecutor(ExecutorType.SpSummon,(int)CardId.MechinaCannon, SummonMechinaCannon);

            AddExecutor(ExecutorType.SpellSet, SetTrapsAndSpells);
        }
Beispiel #19
0
        public DamageBurnExecutor(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);
        }
        public BlueEyesMaxDragonExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            //counter
            this.AddExecutor(ExecutorType.Activate, CardId.AshBlossom, this.DefaultAshBlossomAndJoyousSpring);
            this.AddExecutor(ExecutorType.Activate, CardId.MaxxC, this.MaxxCeff);
            this.AddExecutor(ExecutorType.Activate, CardId.InfiniteImpermanence, this.DefaultInfiniteImpermanence);
            this.AddExecutor(ExecutorType.Activate, CardId.CalledByTheGrave, this.CalledByTheGraveeff);
            //first
            this.AddExecutor(ExecutorType.Activate, CardId.UpstartGoblin);
            this.AddExecutor(ExecutorType.Activate, CardId.BlueEyesAlternativeWhiteDragon, this.BlueEyesAlternativeWhiteDragoneff);
            this.AddExecutor(ExecutorType.Activate, CardId.CreatureSwap, this.CreatureSwapeff);
            this.AddExecutor(ExecutorType.Activate, CardId.TheMelodyOfAwakeningDragon, this.TheMelodyOfAwakeningDragoneff);
            //summon
            this.AddExecutor(ExecutorType.Summon, CardId.ManguOfTheTenTousandHands);
            this.AddExecutor(ExecutorType.Activate, CardId.ManguOfTheTenTousandHands, this.TenTousandHandseff);
            this.AddExecutor(ExecutorType.Activate, this.DeviritualCheck);
            //ritual summon
            this.AddExecutor(ExecutorType.Activate, CardId.AdvancedRitualArt);
            this.AddExecutor(ExecutorType.Activate, CardId.ChaosForm, this.ChaosFormeff);
            //sp summon
            this.AddExecutor(ExecutorType.SpSummon, CardId.MissusRadiant, this.MissusRadiantsp);
            this.AddExecutor(ExecutorType.Activate, CardId.MissusRadiant, this.MissusRadianteff);
            this.AddExecutor(ExecutorType.Activate, CardId.Linkuriboh, this.Linkuriboheff);
            this.AddExecutor(ExecutorType.SpSummon, CardId.Linkuriboh, this.Linkuribohsp);
            this.AddExecutor(ExecutorType.SpSummon, CardId.LinkSpider);
            this.AddExecutor(ExecutorType.SpSummon, CardId.BirrelswordDragon, this.BirrelswordDragonsp);
            this.AddExecutor(ExecutorType.Activate, CardId.BirrelswordDragon, this.BirrelswordDragoneff);
            //set
            this.AddExecutor(ExecutorType.Activate, CardId.TheMelodyOfAwakeningDragon, this.TheMelodyOfAwakeningDragoneffsecond);
            this.AddExecutor(ExecutorType.SpellSet, this.SpellSet);
            this.AddExecutor(ExecutorType.Repos, this.DefaultMonsterRepos);
            //
            this.AddExecutor(ExecutorType.Activate, CardId.RecklessGreed, this.RecklessGreedeff);

            this.AddExecutor(ExecutorType.Activate, CardId.Scapegoat, this.Scapegoateff);
        }
Beispiel #21
0
        public async Task OnReactionAddedDuelRequest(Cacheable <IUserMessage, ulong> cache,
                                                     ISocketMessageChannel channel, SocketReaction reaction)
        {
            if (!reaction.User.Value.IsBot)
            {
                var context = new ShardedCommandContext(Global.Client, (SocketUserMessage)reaction.Message);
                if (!PendingDuelProvider.UserIsPlaying(reaction.UserId))
                {
                    return;
                }
                var emote     = Emote.Parse($"{Global.ENo}");
                var user      = (SocketGuildUser)reaction.User;
                var req       = PendingDuelProvider.RequestUser(reaction.UserId);
                var requester = Global.Client.GetUser(req);
                if (reaction.Emote.Name == emote.Name)
                {
                    var game = PendingDuelProvider.games.FirstOrDefault(g => g.PlayerId == reaction.UserId);
                    PendingDuelProvider.games.Remove(game);
                    await context.Message.DeleteAsync();

                    await channel.SendMessageAsync(
                        $"**{user.Username}** has declined **{requester.Username}**'s duel request!");
                }

                if (reaction.Emote.Name == "✅")
                {
                    var game = PendingDuelProvider.games.FirstOrDefault(g => g.PlayerId == reaction.UserId);
                    PendingDuelProvider.games.Remove(game);
                    await context.Message.DeleteAsync();

                    await channel.SendMessageAsync(
                        $"**{user.Username}** has accepted **{requester.Username}**'s duel request!");

                    await Duel.StartDuel(channel, user, requester);
                }
            }
        }
Beispiel #22
0
        public ExodiaExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            ExodiaParts.Add((int)CardId.Tete);
            ExodiaParts.Add((int)CardId.BrasDroit);
            ExodiaParts.Add((int)CardId.BrasGauche);
            ExodiaParts.Add((int)CardId.JambeDroit);
            ExodiaParts.Add((int)CardId.JambeGauche);

            CounterCards.Add((int)CardId.Citadelle);
            CounterCards.Add((int)CardId.Biblio);

            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);

            AddExecutor(ExecutorType.Activate, (int)CardId.Transaction);
            AddExecutor(ExecutorType.Activate, (int)CardId.DayPiece);
            AddExecutor(ExecutorType.Activate, (int)CardId.CarteHarmonie);
            AddExecutor(ExecutorType.Activate, (int)CardId.UpstartGobelin);
            AddExecutor(ExecutorType.Activate, (int)CardId.BambouBois);
            AddExecutor(ExecutorType.Activate, (int)CardId.BambouDor);
            AddExecutor(ExecutorType.Activate, (int)CardId.MaitrisePuissanceMagique, ActivateSpell);
            AddExecutor(ExecutorType.Activate, (int)CardId.Citadelle);
            AddExecutor(ExecutorType.Activate, (int)CardId.TableMatToon, ActivateSpell);
            AddExecutor(ExecutorType.Activate, (int)CardId.MondeDesToons, ActivateSpell);
            AddExecutor(ExecutorType.Activate, (int)CardId.PotDualite, PotDualite);
            AddExecutor(ExecutorType.Activate, (int)CardId.Citadelle);

            AddExecutor(ExecutorType.Activate, (int)CardId.MailletMagique, MailletMagique);

            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.PierreBlanche);
            AddExecutor(ExecutorType.Summon, (int)CardId.Biblio);

            AddExecutor(ExecutorType.Activate, (int)CardId.PierreBlanche);
            AddExecutor(ExecutorType.Activate, (int)CardId.Biblio);

            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);
        }
Beispiel #23
0
        public DamageBurnExecutor(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);
        }
Beispiel #24
0
        public override void Resolve(Duel duel, Decision decision)
        {
            // Return a card from your mana zone to your hand.
            var controller = duel.GetPlayer(Controller);

            if (decision == null)
            {
                if (controller.ManaZone.Cards.Any())
                {
                    if (controller.ManaZone.Cards.Count > 1)
                    {
                        duel.SetAwaitingChoice(new GuidSelection(Controller, controller.ManaZone.Cards, 1, 1));
                    }
                    else
                    {
                        duel.Move(controller.ManaZone.Cards, DuelMastersModels.Zones.ZoneType.ManaZone, DuelMastersModels.Zones.ZoneType.Hand);
                    }
                }
            }
            else
            {
                duel.Move(duel.GetCard((decision as GuidDecision).Decision.Single()), DuelMastersModels.Zones.ZoneType.ManaZone, DuelMastersModels.Zones.ZoneType.Hand);
            }
        }
Beispiel #25
0
        public int RemovePkandidati(Protivkandidati g)
        {
            try
            {
                ISession s     = DataLayer.GetSession();
                ISession sa    = DataLayer.GetSession();
                Duel     mesto = sa.Load <Duel>(102);

                mesto.pkandidati.Remove(g);


                sa.SaveOrUpdate(mesto);
                s.Delete(g);
                s.Flush();
                s.Close();
                sa.Flush();
                sa.Close();
                return(1);
            }
            catch (Exception ec)
            {
                return(-1);
            }
        }
Beispiel #26
0
        public YouyouExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            //礼物云
            AddExecutor(ExecutorType.Activate, CardId.Liwuyun, WuEffect);
            //DIY
            AddExecutor(ExecutorType.Activate, CardId.LUA, LUAEffect);
            //灰流丽
            AddExecutor(ExecutorType.Activate, CardId.Huiliuli, Hand_act_eff);
            //恶意
            AddExecutor(ExecutorType.Activate, CardId.Eyi, WuEffect);
            //虚无空间
            AddExecutor(ExecutorType.Activate, CardId.Xuwukongjian, XuwukongjianEffect);
            //灵魂抽取
            AddExecutor(ExecutorType.Activate, CardId.Linghunchouqu, LinghunchouquEffect);
            //神通
            AddExecutor(ExecutorType.Activate, CardId.Shenzhitonggao, SolemnStrike_activate);
            //神宣
            AddExecutor(ExecutorType.Activate, CardId.Shenzhixuangao, SolemnJudgment_activate);
            //更衣室
            AddExecutor(ExecutorType.Activate, CardId.Gengyishi, GengyishiEffect);

            //蓝魔兽
            AddExecutor(ExecutorType.Summon, CardId.Lanlianmo);
            //真影巨兽
            AddExecutor(ExecutorType.Summon, CardId.Zhenyingjushou);
            //小庞贝
            AddExecutor(ExecutorType.Summon, CardId.Xiaopangbei);
            //蒂蒂
            AddExecutor(ExecutorType.Summon, CardId.Didi);
            //麦当劳
            AddExecutor(ExecutorType.Summon, CardId.Maidanglao);

            AddExecutor(ExecutorType.SpellSet, DefaultSpellSet);
            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);
        }
        public IActionResult ForfeitDuel(int userId)
        {
            if (!isLoggedIn)
            {
                return(RedirectToAction("LoginRegPage", "Home"));
            }

            Duel existingDuel = _context.Duels.FirstOrDefault(duel => duel.User1Id == (int)uid);
            User Challenger   = _context.Users.Include(u => u.User1Duels).ThenInclude(duel => duel.User2).FirstOrDefault(u => u.UserId == userId);
            User LoggedInUser = _context.Users.Include(u => u.User1Duels).ThenInclude(duel => duel.User2).FirstOrDefault(u => u.UserId == uid);

            if (existingDuel != null)
            {
                //add functionality to add points to challenger score
                Challenger.Score   += 100;
                LoggedInUser.Score -= 100;

                //delete duel relationship
                _context.Duels.Remove(existingDuel);
                _context.SaveChanges();
            }

            return(RedirectToAction("Leaderboard", "Duel"));
        }
Beispiel #28
0
        public LegionCommander(Unit9 owner, MultiSleeper abilitySleeper, Sleeper orbwalkSleeper, ControllableUnitMenu menu)
            : base(owner, abilitySleeper, orbwalkSleeper, menu)
        {
            this.ComboAbilities = new Dictionary <AbilityId, Func <ActiveAbility, UsableAbility> >
            {
                { AbilityId.legion_commander_overwhelming_odds, x => this.odds = new OverwhelmingOdds(x) },
                { AbilityId.legion_commander_press_the_attack, x => this.attack = new BuffAbility(x) },
                { AbilityId.legion_commander_duel, x => this.duel = new Duel(x) },

                { AbilityId.item_blink, x => this.blink = new LegionBlink(x) },
                { AbilityId.item_phase_boots, x => this.phase = new SpeedBuffAbility(x) },
                { AbilityId.item_blade_mail, x => this.bladeMail = new ShieldAbility(x) },
                { AbilityId.item_black_king_bar, x => this.bkb = new ShieldAbility(x) },
                { AbilityId.item_solar_crest, x => this.solar = new DebuffAbility(x) },
                { AbilityId.item_medallion_of_courage, x => this.medallion = new DebuffAbility(x) },
                { AbilityId.item_heavens_halberd, x => this.halberd = new DisableAbility(x) },
                { AbilityId.item_mjollnir, x => this.mjollnir = new ShieldAbility(x) },
                { AbilityId.item_armlet, x => this.armlet = new BuffAbility(x) },
                { AbilityId.item_abyssal_blade, x => this.abyssal = new DisableAbility(x) },
                { AbilityId.item_orchid, x => this.orchid = new DisableAbility(x) },
                { AbilityId.item_bloodthorn, x => this.bloodthorn = new Bloodthorn(x) },
                { AbilityId.item_nullifier, x => this.nullifier = new Nullifier(x) },
            };
        }
Beispiel #29
0
 public override void Resolve(Duel duel, Decision decision)
 {
     // You may choose a creature in the battle zone and put it into its owner's mana zone.
     if (decision == null)
     {
         ChooseCreatureInTheBattleZone(duel);
     }
     else if (_soulswapState == SoulswapState.FromBattleZoneToMana)
     {
         PutFromBattleZoneIntoManaZone(duel, decision);
     }
     else if (_soulswapState == SoulswapState.FromManaToBattleZone)
     {
         PutFromManaZoneToBattleZone(duel, decision);
     }
     else if (_soulswapState == SoulswapState.PermanentEnteringBattleZone)
     {
         duel.Players.Select(x => x.BattleZone).Single(x => x.PermanentEnteringBattleZone != null).Add(duel, decision);
     }
     else
     {
         throw new System.ArgumentOutOfRangeException(_soulswapState.ToString());
     }
 }
Beispiel #30
0
    /// <summary>
    /// 将卡片加入到手牌
    /// </summary>
    public static void AddCardToHand(Card card, Player player, Reason reason, bool playAnim = false)
    {
        normalDele dele = delegate
        {
            player.group_HandCard.AddCard(card);
            DuelUIManager.GetInstance().AddCardToHand(card, player.isMy);
            int i = player.group_HandCard.GroupNum;
            card.SetArea(ComVal.Area_Hand, reason);
            card.SetAreaRank(i - 1);
            if (playAnim == true)
            {
                Duel.GetInstance().FinishHandle();
            }
        };

        if (card.curArea == ComVal.Area_MainDeck && playAnim)
        {
            DuelUIManager.GetInstance().ShowDrawAnim(card.cardID, dele, player.group_HandCard.GroupNum, player.isMy);
        }
        else
        {
            dele();
        }
    }
        public LightswornExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            AddExecutor(ExecutorType.Activate, CardId.HarpiesFeatherDuster, DefaultHarpiesFeatherDusterFirst);
            AddExecutor(ExecutorType.Activate, CardId.GalaxyCyclone, DefaultGalaxyCyclone);
            AddExecutor(ExecutorType.Activate, CardId.HarpiesFeatherDuster);

            AddExecutor(ExecutorType.Activate, CardId.MetalfoesFusion);
            AddExecutor(ExecutorType.Activate, CardId.GlowUpBulb);

            AddExecutor(ExecutorType.Activate, CardId.JudgmentDragon, DefaultDarkHole);
            AddExecutor(ExecutorType.SpSummon, CardId.JudgmentDragon);

            AddExecutor(ExecutorType.Activate, CardId.ReinforcementOfTheArmy, ReinforcementOfTheArmyEffect);
            AddExecutor(ExecutorType.Activate, CardId.ChargeOfTheLightBrigade, ChargeOfTheLightBrigadeEffect);
            AddExecutor(ExecutorType.Activate, CardId.SolarRecharge, SolarRechargeEffect);

            AddExecutor(ExecutorType.Summon, CardId.Goblindbergh, GoblindberghSummon);
            AddExecutor(ExecutorType.Activate, CardId.Goblindbergh, GoblindberghEffect);

            AddExecutor(ExecutorType.SpSummon, CardId.EvilswarmExcitonKnight, DefaultEvilswarmExcitonKnightSummon);
            AddExecutor(ExecutorType.Activate, CardId.EvilswarmExcitonKnight, DefaultEvilswarmExcitonKnightEffect);
            AddExecutor(ExecutorType.SpSummon, CardId.CastelTheSkyblasterMusketeer, DefaultCastelTheSkyblasterMusketeerSummon);
            AddExecutor(ExecutorType.Activate, CardId.CastelTheSkyblasterMusketeer, DefaultCastelTheSkyblasterMusketeerEffect);
            AddExecutor(ExecutorType.SpSummon, CardId.ScarlightRedDragonArchfiend, DefaultScarlightRedDragonArchfiendSummon);
            AddExecutor(ExecutorType.Activate, CardId.ScarlightRedDragonArchfiend, DefaultScarlightRedDragonArchfiendEffect);
            AddExecutor(ExecutorType.SpSummon, CardId.Number39Utopia, DefaultNumberS39UtopiaTheLightningSummon);
            AddExecutor(ExecutorType.SpSummon, CardId.NumberS39UtopiatheLightning);
            AddExecutor(ExecutorType.Activate, CardId.NumberS39UtopiatheLightning);

            AddExecutor(ExecutorType.Activate, CardId.PerformageTrickClown, PerformageTrickClownEffect);
            AddExecutor(ExecutorType.Activate, CardId.ThousandBlades);
            AddExecutor(ExecutorType.Activate, CardId.Honest, HonestEffect);

            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);
        }
Beispiel #32
0
        public SuperRoboExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            AddExecutor(ExecutorType.Activate, (int)CardId.MysticalSpaceTyphoon, MysticalSpaceTyphoon);

            //Monsters
            AddExecutor(ExecutorType.Summon, (int)CardId.MechinaGearFrame, SummonGearFrame);
            AddExecutor(ExecutorType.Activate, (int)CardId.MechinaGearFrame, GearFrameEffect);

            AddExecutor(ExecutorType.SummonOrSet, (int)CardId.CardTrooper);
            AddExecutor(ExecutorType.Activate, (int)CardId.CardTrooper, CardTrooperEffect);

            AddExecutor(ExecutorType.Summon, (int)CardId.SuperRoboElephan, SummonSuperRoboElephan);
            AddExecutor(ExecutorType.Summon, (int)CardId.SuperRoboMonkei, SummonSuperRoboMonkei);
            AddExecutor(ExecutorType.Summon, (int)CardId.SuperRoboLeo, SummonSuperRoboLio);



            AddExecutor(ExecutorType.SpSummon, (int)CardId.GearspinrgSpirit, SummonGearspring);

            AddExecutor(ExecutorType.SpSummon, (int)CardId.MechinaCannon, SummonMechinaCannon);

            AddExecutor(ExecutorType.SpellSet, SetTrapsAndSpells);
        }
Beispiel #33
0
        public void RecordStep(string connectionId, Step step)
        {
            Player player = PlayerService.Get(connectionId);

            if (player == null)
            {
                return;
            }
            Duel duel = DuelService.GetDuelForPlayer(player.ConnectionId);

            if (duel == null || duel.IsGameOver)
            {
                return;
            }

            Player opponent = duel.GetOpponent(player.ConnectionId);

            GetContext().Clients.Client(opponent.ConnectionId).receiveStep(step);

            if (duel.IsGameOverStep(step))
            {
                TryWinDuel(duel, player);
            }
        }
        public LightswornShaddoldinosour(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            //counter

            AddExecutor(ExecutorType.Activate, CardId.GhostOgre, Hand_act_eff);
            AddExecutor(ExecutorType.Activate, CardId.AshBlossom, Hand_act_eff);
            AddExecutor(ExecutorType.Activate, CardId.MaxxC, MaxxC);
            //first do
            AddExecutor(ExecutorType.Activate, CardId.HarpiesFeatherDuster, DefaultHarpiesFeatherDusterFirst);
            AddExecutor(ExecutorType.Activate, CardId.infiniteTransience, DefaultBreakthroughSkill);
            AddExecutor(ExecutorType.Activate, CardId.ThatGrassLooksgreener);
            AddExecutor(ExecutorType.Summon, CardId.SouleatingOviraptor);
            AddExecutor(ExecutorType.Activate, CardId.SouleatingOviraptor, SouleatingOviraptoreff);
            AddExecutor(ExecutorType.Activate, CardId.AllureofDarkness, DefaultAllureofDarkness);
            AddExecutor(ExecutorType.Activate, CardId.PotOfAvarice, PotofAvariceeff);
            AddExecutor(ExecutorType.Activate, CardId.ChargeOfTheLightBrigade, ChargeOfTheLightBrigadeEffect);
            AddExecutor(ExecutorType.Activate, CardId.FoolishBurial, FoolishBurialEffect);
            AddExecutor(ExecutorType.Activate, CardId.InterruptedKaijuSlumber, DefaultInterruptedKaijuSlumber);
            AddExecutor(ExecutorType.Activate, CardId.ShaddollFusion, ShaddollFusioneff);
            //Reborn
            AddExecutor(ExecutorType.Activate, CardId.MonsterReborn, RebornEffect);
            //Normal Summon
            AddExecutor(ExecutorType.Summon, CardId.Raiden);
            AddExecutor(ExecutorType.Activate, CardId.Raiden);
            AddExecutor(ExecutorType.Summon, CardId.KeeperOfDragonicMagic);
            AddExecutor(ExecutorType.Activate, CardId.KeeperOfDragonicMagic, KeeperOfDragonicMagiceff);
            AddExecutor(ExecutorType.MonsterSet, CardId.ShaddollSquamata);
            AddExecutor(ExecutorType.MonsterSet, CardId.GlowUpBulb);
            AddExecutor(ExecutorType.MonsterSet, CardId.ShaddollHedgehog);
            AddExecutor(ExecutorType.MonsterSet, CardId.ShaddollDragon);
            AddExecutor(ExecutorType.Summon, CardId.FairyTailSnow, FairyTailSnowsummon);
            AddExecutor(ExecutorType.Activate, CardId.FairyTailSnow, FairyTailSnoweff);
            AddExecutor(ExecutorType.Summon, CardId.Lumina);
            AddExecutor(ExecutorType.Activate, CardId.Lumina);
            //activate
            AddExecutor(ExecutorType.Activate, CardId.GlowUpBulb, GlowUpBulbeff);
            //Sp Summon
            AddExecutor(ExecutorType.SpSummon, CardId.CrystronNeedlefiber, CrystronNeedlefiberesp);
            AddExecutor(ExecutorType.SpSummon, CardId.UltimateConductorTytanno, UltimateConductorTytannosp);
            AddExecutor(ExecutorType.Activate, CardId.UltimateConductorTytanno, UltimateConductorTytannoeff);
            AddExecutor(ExecutorType.Activate, CardId.DoubleEvolutionPill, DoubleEvolutionPilleff);
            AddExecutor(ExecutorType.SpSummon, CardId.MinervaTheExalte);
            AddExecutor(ExecutorType.Activate, CardId.MinervaTheExalte, MinervaTheExaltedEffect);
            AddExecutor(ExecutorType.SpSummon, CardId.GamecieltheSeaTurtleKaiju, DefaultKaijuSpsummon);

            //activate chain
            AddExecutor(ExecutorType.Activate, CardId.OvertexCoatls, OvertexCoatlseff);
            AddExecutor(ExecutorType.Activate, CardId.ShaddollBeast);
            AddExecutor(ExecutorType.Activate, CardId.ShaddollFalco, ShaddollFalcoeff);
            AddExecutor(ExecutorType.Activate, CardId.ShaddollSquamata, ShaddollSquamataeff);
            AddExecutor(ExecutorType.Activate, CardId.ShaddollDragon, ShaddollDragoneff);
            AddExecutor(ExecutorType.Activate, CardId.ShaddollHedgehog, ShaddollHedgehogeff);
            AddExecutor(ExecutorType.Activate, CardId.GiantRex);
            AddExecutor(ExecutorType.Activate, CardId.ElShaddollConstruct, ElShaddollConstructeff);
            AddExecutor(ExecutorType.Activate, CardId.ElShaddollGrysra);
            AddExecutor(ExecutorType.Activate, CardId.ElShaddollShekhinaga, ElShaddollShekhinagaeff);
            AddExecutor(ExecutorType.Activate, CardId.ElShaddollWinda);
            AddExecutor(ExecutorType.Activate, CardId.CrystronNeedlefiber, CrystronNeedlefibereff);
            AddExecutor(ExecutorType.Activate, CardId.TG_WonderMagician);
            //spellset
            AddExecutor(ExecutorType.SpellSet, CardId.MonsterReborn, spellset);
            AddExecutor(ExecutorType.SpellSet, CardId.PotOfAvarice, spellset);
            AddExecutor(ExecutorType.SpellSet, CardId.ThatGrassLooksgreener, spellset);
            //trap
            AddExecutor(ExecutorType.SpellSet, CardId.LostWind, TrapSetWhenZoneFree);
            AddExecutor(ExecutorType.SpellSet, CardId.SinisterShadowGames, TrapSetWhenZoneFree);
            AddExecutor(ExecutorType.SpellSet, CardId.ShaddollCore);
            AddExecutor(ExecutorType.SpellSet, CardId.infiniteTransience, SetIsFieldEmpty);
            //trap activate
            AddExecutor(ExecutorType.Activate, CardId.LostWind, DefaultBreakthroughSkill);
            AddExecutor(ExecutorType.Activate, CardId.SinisterShadowGames, SinisterShadowGames);
            AddExecutor(ExecutorType.Activate, CardId.ShaddollCore, ShaddollCoreeff);
            AddExecutor(ExecutorType.Repos, MonsterRepos);
        }
Beispiel #35
0
 public static Executor GetExecutor(GameAI ai, Duel duel)
 {
     if (m_executors == null)
     {
         List<Type> decks = GetDecks();
         List<Type> enabledDecks = new List<Type>();
         foreach (Type deck in decks)
         {
             GameDeck conDeck = Program.Config.GetDeck(deck.Name);
             if (conDeck == null || conDeck.Enabled)
                 enabledDecks.Add(deck);
         }
         m_executors = enabledDecks.ToArray();
         m_rand = new Random();
     }
     return (Executor)Activator.CreateInstance(m_executors[m_rand.Next(0, m_executors.Length)], ai, duel);
 }
Beispiel #36
0
        public DragunExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            // counter
            this.AddExecutor(ExecutorType.Activate, CardId.AshBlossomJoyousSpring, this.DefaultAshBlossomAndJoyousSpring);
            this.AddExecutor(ExecutorType.Activate, CardId.CalledbyTheGrave, this.DefaultCalledByTheGrave);
            this.AddExecutor(ExecutorType.Activate, CardId.InfiniteImpermanence, this.DefaultInfiniteImpermanence);
            this.AddExecutor(ExecutorType.Activate, CardId.SolemnStrike, this.DefaultSolemnStrike);
            this.AddExecutor(ExecutorType.Activate, CardId.DragunofRedEyes, this.DragunofRedEyesCounter);

            this.AddExecutor(ExecutorType.Activate, CardId.MaxxC, this.DefaultMaxxC);
            this.AddExecutor(ExecutorType.Activate, CardId.HarpiesFeatherDuster);

            this.AddExecutor(ExecutorType.Activate, CardId.DragunofRedEyes, this.DragunofRedEyesDestroy);
            this.AddExecutor(ExecutorType.Activate, CardId.ThousandEyesRestrict, this.ThousandEyesRestrictEffect);

            this.AddExecutor(ExecutorType.Activate, CardId.RedEyesInsight, this.RedEyesInsightEffect);

            this.AddExecutor(ExecutorType.Activate, CardId.RedEyesFusion, this.RedEyesFusionEffect);

            this.AddExecutor(ExecutorType.Repos, this.MonsterRepos);

            this.AddExecutor(ExecutorType.Summon, CardId.TourGuideFromTheUnderworld, this.TourGuideFromTheUnderworldSummon);
            this.AddExecutor(ExecutorType.Activate, CardId.TourGuideFromTheUnderworld, this.TourGuideFromTheUnderworldEffect);
            this.AddExecutor(ExecutorType.Summon, CardId.Sangan, this.SanganSummon);
            this.AddExecutor(ExecutorType.Activate, CardId.Sangan, this.SanganEffect);

            this.AddExecutor(ExecutorType.Summon, CardId.MechaPhantomBeastOLion);
            this.AddExecutor(ExecutorType.Activate, CardId.MechaPhantomBeastOLion, this.MechaPhantomBeastOLionEffect);

            this.AddExecutor(ExecutorType.SpSummon, CardId.SalamangreatAlmiraj, this.SalamangreatAlmirajSummon);
            this.AddExecutor(ExecutorType.SpSummon, CardId.ImdukTheWorldChaliceDragon, this.ImdukTheWorldChaliceDragonSummon);
            this.AddExecutor(ExecutorType.SpSummon, CardId.LinkSpider, this.LinkSpiderSummon);

            this.AddExecutor(ExecutorType.SpSummon, CardId.CrusadiaArboria);

            this.AddExecutor(ExecutorType.Activate, CardId.InstantFusion, this.InstantFusionEffect);

            this.AddExecutor(ExecutorType.Summon, CardId.RedEyesWyvern);
            this.AddExecutor(ExecutorType.Summon, CardId.CrusadiaArboria, this.SummonForMaterial);
            this.AddExecutor(ExecutorType.Summon, CardId.AshBlossomJoyousSpring, this.SummonForMaterial);
            this.AddExecutor(ExecutorType.Summon, CardId.MaxxC, this.SummonForMaterial);

            this.AddExecutor(ExecutorType.Activate, CardId.FoolishBurial, this.FoolishBurialEffect);
            this.AddExecutor(ExecutorType.Activate, CardId.MonsterReborn, this.MonsterRebornEffect);

            this.AddExecutor(ExecutorType.Activate, CardId.MagiciansSouls, this.MagiciansSoulsEffect);
            this.AddExecutor(ExecutorType.Summon, CardId.MagiciansSouls, this.SummonForMaterial);

            this.AddExecutor(ExecutorType.SpSummon, CardId.CrystronHalqifibrax, this.CrystronNeedlefiberSummon);
            this.AddExecutor(ExecutorType.Activate, CardId.CrystronHalqifibrax, this.CrystronNeedlefiberEffect);

            this.AddExecutor(ExecutorType.SpSummon, CardId.PredaplantVerteAnaconda, this.PredaplantVerteAnacondaSummon);

            this.AddExecutor(ExecutorType.Activate, CardId.MagicalizedFusion, this.MagicalizedFusionEffect);

            this.AddExecutor(ExecutorType.Activate, CardId.PredaplantVerteAnaconda, this.PredaplantVerteAnacondaEffect);

            this.AddExecutor(ExecutorType.SpellSet, CardId.InfiniteImpermanence, this.TrapSet);
            this.AddExecutor(ExecutorType.SpellSet, CardId.SolemnStrike, this.TrapSet);

            this.AddExecutor(ExecutorType.MonsterSet, CardId.Sangan);
        }
        private List<Duel> GenerateDuels()
        {
            var duel1 = new Duel
            {
                Winner = storage.Characters[0],
                Characters = new List<Character>
                {
                    storage.Characters[0],
                    storage.Characters[1],
                    storage.Characters[4]
                },
                Id = 1
            };

            var duel2 = new Duel
            {
                Winner = storage.Characters[6],
                Characters = new List<Character>
                {
                    storage.Characters[5],
                    storage.Characters[6]
                },
                Id = 2
            };

            var duel3 = new Duel
            {
                Winner = storage.Characters[3],
                Characters = new List<Character>
                {
                    storage.Characters[2],
                    storage.Characters[3],
                    storage.Characters[5]
                },
                Id = 3
            };

            var duel4 = new Duel
            {
                Winner = storage.Characters[2],
                Characters = new List<Character>
                {
                    storage.Characters[2],
                    storage.Characters[1],
                },
                Id = 4
            };

            var duel5 = new Duel
            {
                Winner = storage.Characters[5],
                Characters = new List<Character>
                {
                    storage.Characters[2],
                    storage.Characters[4],
                    storage.Characters[5]
                },
                Id = 5
            };

            var duel6 = new Duel
            {
                Winner = storage.Characters[2],
                Characters = new List<Character>
                {
                    storage.Characters[1],
                    storage.Characters[3],
                    storage.Characters[2]
                },
                Id = 6
            };

            return new List<Duel> {duel1, duel2, duel3, duel4, duel5, duel6};
        }
        public async Task <ActionResult> SaveMatchData(int?winner, string playerDataString, float duration,
                                                       int lastWave, string duelDataString)
        {
            if (!winner.HasValue || string.IsNullOrEmpty(playerDataString))
            {
                return(Json(new MissingArgumentFailure()));
            }

            //Creating Match
            Match match = await CreateMatch(winner.Value, duration, lastWave);

            //Adding Duels
            if (!string.IsNullOrEmpty(duelDataString))
            {
                Dictionary <int, Dictionary <String, float> > duelData = null;
                try
                {
                    duelData = JsonConvert.DeserializeObject <Dictionary <int, Dictionary <String, float> > >(duelDataString);
                }
                catch (Exception)
                {
                    try
                    {
                        var data = JsonConvert.DeserializeObject <List <Dictionary <String, float> > >(duelDataString);
                        for (int i = 0; i < data.Count; i++)
                        {
                            duelData[i + 1] = data[i];
                        }
                    }
                    catch (Exception) { }
                }
                if (duelData != null)
                {
                    foreach (var pair in duelData)
                    {
                        var  order = pair.Key;
                        var  data  = pair.Value;
                        Duel duel  = await CreateDuel(match, order, (int)data["winner"], data["time"]);
                    }
                }
            }

            //Adding player Data
            var playerData =
                JsonConvert.DeserializeObject <Dictionary <long, Dictionary <string, string> > >(playerDataString);
            List <Player>          players          = new List <Player>();
            List <PlayerMatchData> playerMatchDatas = new List <PlayerMatchData>();

            foreach (var pair in playerData)
            {
                long steamId = pair.Key;
                Dictionary <string, string> decodedData = pair.Value;
                Player player = await GetOrCreatePlayer(steamId);

                PlayerMatchData playerMatchData = await CreatePlayerMatchData(player,
                                                                              match,
                                                                              decodedData["fraction"],
                                                                              int.Parse(decodedData["team"]),
                                                                              bool.Parse(decodedData["abandoned"]),
                                                                              int.Parse(decodedData["earned_tangos"]),
                                                                              int.Parse(decodedData["earned_gold"]));

                List <PlayerUnitRelation> playerUnitRelations =
                    await CreatePlayerUnitRelations(playerMatchData, decodedData);

                players.Add(player);
                playerMatchDatas.Add(playerMatchData);
            }
            await DecideIsTraining(match);
            await ModifyRatings(playerMatchDatas, match);

            await _steamApi.UpdatePlayerInformation(players.Select(p => p.SteamId));

            return(Json(new { Success = true }));
        }
 private static bool UserWasTakingPartInDuel(Duel duel, User u1)
 {
     return duel.Characters.Any(c => u1.Characters.Contains(c));
 }
Beispiel #40
0
 private void AssertScheduleContainsDuel(Duel duel)
 {
     if (!this.Schedule.ContainsDuel(duel))
     {
         throw new Exception("This duel is not part of this session.");
     }
 }
Beispiel #41
0
 public override void Initialize()
 {
     gameState = new GameState();
     gameAI = new AI(gameState.PlayerTwo);
     duelScreen = new Duel(this, gameState);
 }
 protected DefaultExecutor(GameAI ai, Duel duel)
     : base(ai, duel)
 {
 }
Beispiel #43
0
 public AIFunctions(Duel duel)
 {
     Duel = duel;
 }
 // 3 points for each non-winning character of given class that fought in duel
 // 7 points for winner of the duel when there were 2 characters fighting
 // 10 points for winner of the duel when there were 3 or more characters fighting
 private int GetPointsForDuel(string className, Duel duel)
 {
     var points = 0;
     foreach (var character in duel.Characters)
     {
         if (character.Class.Name != className) continue;
         if (duel.Winner.Equals(character))
         {
             if (duel.Characters.Count >= 3) points += 10;
             else points += 7;
         }
         else
         {
             points += 3;
         }
     }
     return points;
 }
Beispiel #45
0
 public override bool Applies(Card card, Duel duel)
 {
     return(duel.GetOpponent(duel.GetPlayer(Owner)).BattleZone.GetChoosableCreatures(duel).Select(x => x.Id).Contains(card.Id));
 }
Beispiel #46
0
 protected DefaultExecutor(GameAI ai, Duel duel)
     : base(ai, duel)
 {
     AddExecutor(ExecutorType.Activate, _CardId.ChickenGame, DefaultChickenGame);
 }
Beispiel #47
0
 protected DefaultExecutor(GameAI ai, Duel duel)
     : base(ai, duel)
 {
 }
 private static bool UserHasDuelWinner(User u, Duel d)
 {
     return u.Characters.Contains(d.Winner);
 }
Beispiel #49
0
        public DragunityExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            // Set traps
            this.AddExecutor(ExecutorType.SpellSet, this.DefaultSpellSet);

            // Execute spells
            this.AddExecutor(ExecutorType.Activate, CardId.MysticalSpaceTyphoon, this.DefaultMysticalSpaceTyphoon);
            this.AddExecutor(ExecutorType.Activate, CardId.AssaultTeleport);
            this.AddExecutor(ExecutorType.Activate, CardId.UpstartGoblin);
            this.AddExecutor(ExecutorType.Activate, CardId.DragonRavine, this.DragonRavineField);
            this.AddExecutor(ExecutorType.Activate, CardId.Terraforming, this.Terraforming);
            this.AddExecutor(ExecutorType.Activate, CardId.FoolishBurial, this.FoolishBurial);
            this.AddExecutor(ExecutorType.Activate, CardId.MonsterReborn, this.MonsterReborn);

            // Execute monsters
            this.AddExecutor(ExecutorType.Activate, CardId.ScrapDragon, this.ScrapDragonEffect);
            this.AddExecutor(ExecutorType.Activate, CardId.CrystalWingSynchroDragon, this.CrystalWingSynchroDragonEffect);
            this.AddExecutor(ExecutorType.Activate, CardId.DragunityPhalanx);
            this.AddExecutor(ExecutorType.Activate, CardId.DragunityKnightVajrayana);
            this.AddExecutor(ExecutorType.Activate, CardId.DragunityArmaMysletainn, this.DragunityArmaMysletainnEffect);
            this.AddExecutor(ExecutorType.Activate, CardId.DragunityDux);

            // Summon
            this.AddExecutor(ExecutorType.Activate, CardId.DragonsMirror, this.DragonsMirror);
            this.AddExecutor(ExecutorType.SpSummon, CardId.ScrapDragon, this.ScrapDragonSummon);
            this.AddExecutor(ExecutorType.SpSummon, CardId.CrystalWingSynchroDragon, this.CrystalWingSynchroDragonSummon);
            this.AddExecutor(ExecutorType.SpSummon, CardId.StardustDragon);
            this.AddExecutor(ExecutorType.SpSummon, CardId.DragunityKnightVajrayana);
            this.AddExecutor(ExecutorType.SpSummon, CardId.DragunityKnightGaeDearg);
            this.AddExecutor(ExecutorType.Summon, CardId.DragunityPhalanx, this.DragunityPhalanxSummon);
            this.AddExecutor(ExecutorType.SpSummon, CardId.DragunityArmaMysletainn, this.DragunityArmaMysletainn);
            this.AddExecutor(ExecutorType.Summon, CardId.DragunityArmaMysletainn, this.DragunityArmaMysletainnTribute);

            // Use draw effects if we can't do anything else
            this.AddExecutor(ExecutorType.Activate, CardId.CardsOfConsonance);
            this.AddExecutor(ExecutorType.Activate, CardId.DragonRavine, this.DragonRavineEffect);
            this.AddExecutor(ExecutorType.Activate, CardId.FireFormationTenki, this.FireFormationTenki);
            this.AddExecutor(ExecutorType.Activate, CardId.DragunitySpearOfDestiny);

            // Summon
            this.AddExecutor(ExecutorType.Summon, CardId.DragunityDux, this.DragunityDux);
            this.AddExecutor(ExecutorType.MonsterSet, CardId.DragunityPhalanx, this.DragunityPhalanxSet);
            this.AddExecutor(ExecutorType.SummonOrSet, CardId.AssaultBeast);

            // Draw assault mode if we don't have one
            this.AddExecutor(ExecutorType.Activate, CardId.AssaultBeast, this.AssaultBeast);

            // Set useless cards
            this.AddExecutor(ExecutorType.SpellSet, CardId.DragonsMirror, this.SetUselessCards);
            this.AddExecutor(ExecutorType.SpellSet, CardId.Terraforming, this.SetUselessCards);
            this.AddExecutor(ExecutorType.SpellSet, CardId.AssaultTeleport, this.SetUselessCards);
            this.AddExecutor(ExecutorType.SpellSet, CardId.CardsOfConsonance, this.SetUselessCards);

            // Chain traps and monsters
            this.AddExecutor(ExecutorType.Activate, CardId.StardustDragonAssaultMode, this.DefaultStardustDragonEffect);
            this.AddExecutor(ExecutorType.Activate, CardId.StardustDragon, this.DefaultStardustDragonEffect);
            this.AddExecutor(ExecutorType.Activate, CardId.StarlightRoad, this.DefaultTrap);
            this.AddExecutor(ExecutorType.Activate, CardId.MirrorForce, this.DefaultTrap);
            this.AddExecutor(ExecutorType.Activate, CardId.DimensionalPrison, this.DefaultTrap);
            this.AddExecutor(ExecutorType.Activate, CardId.AssaultModeActivate, this.AssaultModeActivate);

            this.AddExecutor(ExecutorType.Repos, this.DefaultMonsterRepos);
        }
Beispiel #50
0
 public override void PerformTurnBasedAction(Duel duel, Decision decision)
 {
     duel.Battle(AttackingCreature, TargetCreature);
 }
Beispiel #51
0
        public AHDXSExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            // Add Executors to all normal monsters

            //  Add Executors to all special summonable effect monsters
            //  Add Executors to all pure special summonable effect monsters
            AddExecutor(ExecutorType.Activate, CardId.DXSJN);
            AddExecutor(ExecutorType.Repos, CardId.hei1an4da4dai4xie2ye2shen2zuo3ke4nei4luo4fa3_900000098, hei1an4da4dai4xie2ye2shen2zuo3ke4nei4luo4fa3_900000098Repos);
            AddExecutor(ExecutorType.SpSummon, CardId.hei1an4da4dai4xie2ye2shen2zuo3ke4nei4luo4fa3_900000098, hei1an4da4dai4xie2ye2shen2zuo3ke4nei4luo4fa3_900000098SpSummon);
            AddExecutor(ExecutorType.Activate, CardId.hei1an4da4dai4xie2ye2shen2zuo3ke4nei4luo4fa3_900000098, hei1an4da4dai4xie2ye2shen2zuo3ke4nei4luo4fa3_900000098Activate);
            AddExecutor(ExecutorType.MonsterSet, CardId.shen1yuan1de5di4di2an4sha1zhe3_16226786, shen1yuan1de5di4di2an4sha1zhe3_16226786MonsterSet);
            AddExecutor(ExecutorType.Repos, CardId.shen1yuan1de5di4di2an4sha1zhe3_16226786, shen1yuan1de5di4di2an4sha1zhe3_16226786Repos);
            AddExecutor(ExecutorType.Activate, CardId.shen1yuan1de5di4di2an4sha1zhe3_16226786, shen1yuan1de5di4di2an4sha1zhe3_16226786Activate);
            AddExecutor(ExecutorType.MonsterSet, CardId.laomoshushi);
            AddExecutor(ExecutorType.Repos, CardId.laomoshushi);
            AddExecutor(ExecutorType.Activate, CardId.laomoshushi, shen1yuan1de5di4di2an4sha1zhe3_16226786Activate);
            AddExecutor(ExecutorType.MonsterSet, CardId.an4zhi1jia3jia4mian4_28933734, an4zhi1jia3jia4mian4_28933734MonsterSet);
            AddExecutor(ExecutorType.Repos, CardId.an4zhi1jia3jia4mian4_28933734, an4zhi1jia3jia4mian4_28933734Repos);
            AddExecutor(ExecutorType.Activate, CardId.an4zhi1jia3jia4mian4_28933734, an4zhi1jia3jia4mian4_28933734Activate);
            AddExecutor(ExecutorType.MonsterSet, CardId.muchankanshouzhe);
            AddExecutor(ExecutorType.SummonOrSet, CardId.ju4xing2bing4du2_95178994, ju4xing2bing4du2_95178994NormalSummon);
            AddExecutor(ExecutorType.Repos, CardId.ju4xing2bing4du2_95178994, ju4xing2bing4du2_95178994Repos);
            AddExecutor(ExecutorType.Activate, CardId.ju4xing2bing4du2_95178994, ju4xing2bing4du2_95178994Activate);
            AddExecutor(ExecutorType.SummonOrSet, CardId.san1yan3guai4_26202165, san1yan3guai4_26202165NormalSummon);
            AddExecutor(ExecutorType.Repos, CardId.san1yan3guai4_26202165, san1yan3guai4_26202165Repos);
            AddExecutor(ExecutorType.Activate, CardId.san1yan3guai4_26202165, san1yan3guai4_26202165Activate);
            AddExecutor(ExecutorType.MonsterSet, CardId.jing1shen2ji4sheng1ti3ben4ti1_4266839, jing1shen2ji4sheng1ti3ben4ti1_4266839MonsterSet);
            AddExecutor(ExecutorType.Activate, CardId.jing1shen2ji4sheng1ti3ben4ti1_4266839, jing1shen2ji4sheng1ti3ben4ti1_4266839Activate);
            AddExecutor(ExecutorType.Summon, CardId.hun4hun2hun3dun4zhuan4si3ling2shi1_1434352, hun4hun2hun3dun4zhuan4si3ling2shi1_1434352NormalSummon);
            AddExecutor(ExecutorType.Repos, CardId.hun4hun2hun3dun4zhuan4si3ling2shi1_1434352, hun4hun2hun3dun4zhuan4si3ling2shi1_1434352Repos);
            AddExecutor(ExecutorType.Activate, CardId.hun4hun2hun3dun4zhuan4si3ling2shi1_1434352, hun4hun2hun3dun4zhuan4si3ling2shi1_1434352Activate);
            AddExecutor(ExecutorType.Activate, CardId.li4zi5zi3zi2qiu2_40640058, li4zi5zi3zi2qiu2_40640058Activate);
            AddExecutor(ExecutorType.Activate, CardId.qiuxinliziqiu, QXLZQActivate);
            AddExecutor(ExecutorType.Activate, CardId.caozhongsiling, CZSLactivate);
            AddExecutor(ExecutorType.Summon, CardId.caozhongsiling);
            AddExecutor(ExecutorType.Activate, CardId.anheirenou, shen1yuan1de5di4di2an4sha1zhe3_16226786Activate);
            AddExecutor(ExecutorType.SpSummon, CardId.anheirenou);
            AddExecutor(ExecutorType.SpellSet, CardId.xuan2xuan4feng1_5318639, xuan2xuan4feng1_5318639SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.xuan2xuan4feng1_5318639, DefaultMysticalSpaceTyphoon);
            AddExecutor(ExecutorType.SpellSet, CardId.guang1zhi1hu4feng1jian4_72302403, guang1zhi1hu4feng1jian4_72302403SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.guang1zhi1hu4feng1jian4_72302403, guang1zhi1hu4feng1jian4_72302403Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.anheizhifei);
            AddExecutor(ExecutorType.Activate, CardId.anheizhifei);
            AddExecutor(ExecutorType.SpellSet, CardId.yibinbinduhiechen);
            AddExecutor(ExecutorType.Activate, CardId.yibinbinduhiechen, shen1yuan1de5di4di2an4sha1zhe3_16226786Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.yingmujingbi);
            AddExecutor(ExecutorType.Activate, CardId.yingmujingbi, YMJBactivate);
            AddExecutor(ExecutorType.SpellSet, CardId.si3zhi1ka3qia3zu3po4huai4pi1pei1bing4du2_57728570, si3zhi1ka3qia3zu3po4huai4pi1pei1bing4du2_57728570SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.si3zhi1ka3qia3zu3po4huai4pi1pei1bing4du2_57728570, si3zhi1ka3qia3zu3po4huai4pi1pei1bing4du2_57728570Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.jiliuzhan);
            AddExecutor(ExecutorType.Activate, CardId.jiliuzhan, DefaultDarkHole);
            AddExecutor(ExecutorType.SpellSet, CardId.diaoding);
            AddExecutor(ExecutorType.Activate, CardId.diaoding);
            AddExecutor(ExecutorType.SpellSet, CardId.gong1ji1wu2mo2li4hua4hua1_14315573, gong1ji1wu2mo2li4hua4hua1_14315573SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.gong1ji1wu2mo2li4hua4hua1_14315573, gong1ji1wu2mo2li4hua4hua1_14315573Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.chouhenzhadan);
            AddExecutor(ExecutorType.Activate, CardId.chouhenzhadan, CHZAeffect);
            AddExecutor(ExecutorType.SpellSet, CardId.mo2fa3tong3_62279055, mo2fa3tong3_62279055SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.mo2fa3tong3_62279055, mo2fa3tong3_62279055Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.shen2sheng4fang2hu4zhao4fan3she4shi2ye4jing4li4_44095762, shen2sheng4fang2hu4zhao4fan3she4shi2ye4jing4li4_44095762SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.shen2sheng4fang2hu4zhao4fan3she4shi2ye4jing4li4_44095762, DefaultDarkHole);
            AddExecutor(ExecutorType.SpellSet, CardId.di2ren2cao1cao4zong4qi4_98045062, di2ren2cao1cao4zong4qi4_98045062SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.di2ren2cao1cao4zong4qi4_98045062, di2ren2cao1cao4zong4qi4_98045062Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.si3zhe3su1sheng1_83764718, si3zhe3su1sheng1_83764718SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.si3zhe3su1sheng1_83764718, si3zhe3su1sheng1_83764718Activate);
            AddExecutor(ExecutorType.Activate, CardId.GXjimu);
            AddExecutor(ExecutorType.Activate, CardId.GXxizhan, GXxizhaneffect);
            AddExecutor(ExecutorType.Activate, CardId.GXtianping, GXTPeffect);
            AddExecutor(ExecutorType.Activate, CardId.GXyaoshi, ysoshieffect);
            AddExecutor(ExecutorType.Activate, CardId.GXzhihuilun, DefaultTrap);
            AddExecutor(ExecutorType.Activate, CardId.GXMofang, GXMFeffect);
            AddExecutor(ExecutorType.Activate, CardId.DXSJN);


            //unuesing


            AddExecutor(ExecutorType.SpellSet, CardId.feng1yin4zhi1huang2jin1ju3gui4_75500286, feng1yin4zhi1huang2jin1ju3gui4_75500286SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.feng1yin4zhi1huang2jin1ju3gui4_75500286, feng1yin4zhi1huang2jin1ju3gui4_75500286Activate);
            AddExecutor(ExecutorType.MonsterSet, CardId.bu3nao3mo2_40267580, bu3nao3mo2_40267580MonsterSet);
            AddExecutor(ExecutorType.Repos, CardId.bu3nao3mo2_40267580, bu3nao3mo2_40267580Repos);
            AddExecutor(ExecutorType.Activate, CardId.bu3nao3mo2_40267580, bu3nao3mo2_40267580Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.hepingshizhe);
            AddExecutor(ExecutorType.Activate, CardId.hepingshizhe, GWXactivate);
            AddExecutor(ExecutorType.SpellSet, CardId.guaishouxian);
            AddExecutor(ExecutorType.Activate, CardId.guaishouxian, GWXactivate);
            AddExecutor(ExecutorType.SpellSet, CardId.zhukeling);
            AddExecutor(ExecutorType.Activate, CardId.zhukeling);
            AddExecutor(ExecutorType.SpellSet, CardId.jinshufansheshilaimu);
            AddExecutor(ExecutorType.Activate, CardId.jinshufansheshilaimu);
            AddExecutor(ExecutorType.SpellSet, CardId.shou1suo1su4_55713623, shou1suo1su4_55713623SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.shou1suo1su4_55713623, shou1suo1su4_55713623Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.dalongjuan);
            AddExecutor(ExecutorType.Activate, CardId.dalongjuan);
            AddExecutor(ExecutorType.SpellSet, CardId.baodaosuo);
            AddExecutor(ExecutorType.Activate, CardId.baodaosuo);
            AddExecutor(ExecutorType.SpellSet, CardId.tian1shi3shi4de5di4di2tou2shai3zi5zi3zi2_74137509, tian1shi3shi4de5di4di2tou2shai3zi5zi3zi2_74137509SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.tian1shi3shi4de5di4di2tou2shai3zi5zi3zi2_74137509, tian1shi3shi4de5di4di2tou2shai3zi5zi3zi2_74137509Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.e4e3wu4wu1mo2de5di4di2tou2shai3zi5zi3zi2_126218, e4e3wu4wu1mo2de5di4di2tou2shai3zi5zi3zi2_126218SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.e4e3wu4wu1mo2de5di4di2tou2shai3zi5zi3zi2_126218, e4e3wu4wu1mo2de5di4di2tou2shai3zi5zi3zi2_126218Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.mo2shu4zhu2li3mao4_81210420, mo2shu4zhu2li3mao4_81210420SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.mo2shu4zhu2li3mao4_81210420, mo2shu4zhu2li3mao4_81210420Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.liu4lu4mang2wang2xing1zhi1zhou4fu4_18807108, liu4lu4mang2wang2xing1zhi1zhou4fu4_18807108SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.liu4lu4mang2wang2xing1zhi1zhou4fu4_18807108, liu4lu4mang2wang2xing1zhi1zhou4fu4_18807108Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.sha1sha4chen2zhi1da4dai4long2juan3juan4quan2_60082869, sha1sha4chen2zhi1da4dai4long2juan3juan4quan2_60082869SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.sha1sha4chen2zhi1da4dai4long2juan3juan4quan2_60082869, sha1sha4chen2zhi1da4dai4long2juan3juan4quan2_60082869Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.ti4zui4yang2_73915051, ti4zui4yang2_73915051SpellSet);
            AddExecutor(ExecutorType.Activate, CardId.ti4zui4yang2_73915051, ti4zui4yang2_73915051Activate);
            AddExecutor(ExecutorType.SpellSet, CardId.sizhimoshuxian);
            AddExecutor(ExecutorType.Activate, CardId.sizhimoshuxian);

            //Default

            AddExecutor(ExecutorType.Repos, DefaultSFMonsterRepos);
        }
Beispiel #52
0
 private void AssertDecisionIsNotRegisteredYet(Duel duel)
 {
     var comparer = new Duel.EqualityComparer();;
     if (this.Outcomes.Any(o => comparer.Equals(o.Decision.Duel, duel)))
     {
         throw new Exception("A decision for this duel has already been registered.");
     }
 }
Beispiel #53
0
        public ST1732Executor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            AddExecutor(ExecutorType.Activate, CardId.CosmicCyclone, DefaultCosmicCyclone);
            AddExecutor(ExecutorType.Activate, CardId.MysticalSpaceTyphoon, DefaultMysticalSpaceTyphoon);
            AddExecutor(ExecutorType.Activate, CardId.DarkHole, DefaultDarkHole);
            AddExecutor(ExecutorType.Activate, CardId.BookOfMoon, DefaultBookOfMoon);

            AddExecutor(ExecutorType.Activate, CardId.CynetUniverse, CynetUniverseEffect);

            AddExecutor(ExecutorType.SpSummon, CardId.Linkslayer);
            AddExecutor(ExecutorType.Activate, CardId.Linkslayer, LinkslayerEffect);

            AddExecutor(ExecutorType.SpSummon, CardId.LinkSpider);
            AddExecutor(ExecutorType.Activate, CardId.LinkSpider);

            AddExecutor(ExecutorType.Activate, CardId.MindControl, MindControlEffect);
            AddExecutor(ExecutorType.SpSummon, CardId.Backlinker);
            AddExecutor(ExecutorType.Activate, CardId.Backlinker, BacklinkerEffect);

            AddExecutor(ExecutorType.Activate, CardId.BootStagguard, BootStagguardEffect);

            AddExecutor(ExecutorType.Activate, CardId.MonsterReborn, MonsterRebornEffect);
            AddExecutor(ExecutorType.Activate, CardId.MoonMirrorShield, MoonMirrorShieldEffect);

            AddExecutor(ExecutorType.Activate, CardId.CynetBackdoor, CynetBackdoorEffect);
            AddExecutor(ExecutorType.Activate, CardId.RecodedAlive);

            AddExecutor(ExecutorType.Summon, CardId.BalancerLord, BalancerLordSummon);

            AddExecutor(ExecutorType.Summon, CardId.ROMCloudia, ROMCloudiaSummon);
            AddExecutor(ExecutorType.Activate, CardId.ROMCloudia, ROMCloudiaEffect);

            AddExecutor(ExecutorType.Summon, CardId.Draconnet, DraconnetSummon);
            AddExecutor(ExecutorType.Activate, CardId.Draconnet, DraconnetEffect);

            AddExecutor(ExecutorType.Summon, CardId.Kleinant);
            AddExecutor(ExecutorType.Activate, CardId.Kleinant, KleinantEffect);

            AddExecutor(ExecutorType.Summon, CardId.RAMClouder);
            AddExecutor(ExecutorType.Activate, CardId.RAMClouder, RAMClouderEffect);

            AddExecutor(ExecutorType.SummonOrSet, CardId.DotScaper);
            AddExecutor(ExecutorType.Activate, CardId.DotScaper, DotScaperEffect);

            AddExecutor(ExecutorType.Summon, CardId.BalancerLord);
            AddExecutor(ExecutorType.Summon, CardId.ROMCloudia);
            AddExecutor(ExecutorType.Summon, CardId.Draconnet);
            AddExecutor(ExecutorType.SummonOrSet, CardId.Backlinker);
            AddExecutor(ExecutorType.SummonOrSet, CardId.Digitron);
            AddExecutor(ExecutorType.SummonOrSet, CardId.Bitron);

            AddExecutor(ExecutorType.Activate, CardId.BalancerLord, BalancerLordEffect);

            AddExecutor(ExecutorType.SpSummon, CardId.DecodeTalker, LinkSummon);
            AddExecutor(ExecutorType.Activate, CardId.DecodeTalker);

            AddExecutor(ExecutorType.SpSummon, CardId.TriGateWizard, LinkSummon);
            AddExecutor(ExecutorType.Activate, CardId.TriGateWizard);

            AddExecutor(ExecutorType.SpSummon, CardId.EncodeTalker, LinkSummon);
            AddExecutor(ExecutorType.Activate, CardId.EncodeTalker);

            AddExecutor(ExecutorType.SpSummon, CardId.Honeybot, LinkSummon);
            AddExecutor(ExecutorType.SpSummon, CardId.BinarySorceress, LinkSummon);
            AddExecutor(ExecutorType.Activate, CardId.BinarySorceress);

            AddExecutor(ExecutorType.SpellSet, CardId.CynetBackdoor, DefaultSpellSet);
            AddExecutor(ExecutorType.SpellSet, CardId.RecodedAlive, DefaultSpellSet);

            AddExecutor(ExecutorType.SpellSet, CardId.SolemnStrike, DefaultSpellSet);
            AddExecutor(ExecutorType.SpellSet, CardId.CompulsoryEvacuationDevice, DefaultSpellSet);
            AddExecutor(ExecutorType.SpellSet, CardId.DimensionalBarrier, DefaultSpellSet);
            AddExecutor(ExecutorType.SpellSet, CardId.TorrentialTribute, DefaultSpellSet);
            AddExecutor(ExecutorType.SpellSet, CardId.MirrorForce, DefaultSpellSet);
            AddExecutor(ExecutorType.SpellSet, CardId.BottomlessTrapHole, DefaultSpellSet);
            AddExecutor(ExecutorType.SpellSet, CardId.BookOfMoon, DefaultSpellSet);
            AddExecutor(ExecutorType.SpellSet, CardId.CosmicCyclone, DefaultSpellSet);
            AddExecutor(ExecutorType.SpellSet, CardId.MysticalSpaceTyphoon, DefaultSpellSet);

            AddExecutor(ExecutorType.Activate, CardId.SolemnStrike, DefaultSolemnStrike);
            AddExecutor(ExecutorType.Activate, CardId.CompulsoryEvacuationDevice, DefaultCompulsoryEvacuationDevice);
            AddExecutor(ExecutorType.Activate, CardId.DimensionalBarrier, DefaultDimensionalBarrier);
            AddExecutor(ExecutorType.Activate, CardId.TorrentialTribute, DefaultTorrentialTribute);
            AddExecutor(ExecutorType.Activate, CardId.MirrorForce, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, CardId.BottomlessTrapHole, DefaultUniqueTrap);

            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);
        }
Beispiel #54
0
 public override string ToString(Duel duel)
 {
     return($"{Player} cast {Spell}.");
 }
 public override string ToString(Duel duel)
 {
     return($"{Player} put {Card} from the top of their deck into their shield zone.");
 }
 public override string ToString(Duel duel)
 {
     return($"{Player} put {Card} from their {Source} into their {Destination}.");
 }
Beispiel #57
0
        public ToadallyAwesomeExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            AddExecutor(ExecutorType.Activate, CardId.HarpiesFeatherDuster, DefaultHarpiesFeatherDusterFirst);
            AddExecutor(ExecutorType.Activate, CardId.GalaxyCyclone, DefaultGalaxyCyclone);
            AddExecutor(ExecutorType.Activate, CardId.HarpiesFeatherDuster);
            AddExecutor(ExecutorType.Activate, CardId.DarkHole, DefaultDarkHole);

            AddExecutor(ExecutorType.Activate, CardId.AquariumStage, AquariumStageEffect);
            AddExecutor(ExecutorType.Activate, CardId.MedallionOfTheIceBarrier, MedallionOfTheIceBarrierEffect);
            AddExecutor(ExecutorType.Activate, CardId.FoolishBurial, FoolishBurialEffect);

            AddExecutor(ExecutorType.SpSummon, CardId.PriorOfTheIceBarrier);
            AddExecutor(ExecutorType.Summon, CardId.GraydleSlimeJr, GraydleSlimeJrSummon);
            AddExecutor(ExecutorType.SpSummon, CardId.SwapFrog, SwapFrogSpsummon);

            AddExecutor(ExecutorType.Activate, CardId.SwapFrog, SwapFrogEffect);
            AddExecutor(ExecutorType.Activate, CardId.GraydleSlimeJr, GraydleSlimeJrEffect);
            AddExecutor(ExecutorType.Activate, CardId.Ronintoadin, RonintoadinEffect);
            AddExecutor(ExecutorType.Activate, CardId.PriorOfTheIceBarrier);
            AddExecutor(ExecutorType.Activate, CardId.DupeFrog);

            AddExecutor(ExecutorType.Activate, CardId.Surface, SurfaceEffect);
            AddExecutor(ExecutorType.Activate, CardId.MonsterReborn, SurfaceEffect);
            AddExecutor(ExecutorType.Activate, CardId.Salvage, SalvageEffect);

            AddExecutor(ExecutorType.Summon, CardId.SwapFrog);
            AddExecutor(ExecutorType.Summon, CardId.DewdarkOfTheIceBarrier, IceBarrierSummon);
            AddExecutor(ExecutorType.Summon, CardId.CryomancerOfTheIceBarrier, IceBarrierSummon);

            AddExecutor(ExecutorType.Activate, CardId.CardDestruction);

            AddExecutor(ExecutorType.Summon, CardId.GraydleSlimeJr, NormalSummon);
            AddExecutor(ExecutorType.Summon, CardId.PriorOfTheIceBarrier, NormalSummon);
            AddExecutor(ExecutorType.Summon, CardId.Ronintoadin, NormalSummon);
            AddExecutor(ExecutorType.Summon, CardId.DupeFrog, NormalSummon);
            AddExecutor(ExecutorType.Summon, CardId.PriorOfTheIceBarrier, PriorOfTheIceBarrierSummon);

            AddExecutor(ExecutorType.SpSummon, CardId.CatShark, CatSharkSummon);
            AddExecutor(ExecutorType.Activate, CardId.CatShark, CatSharkEffect);
            AddExecutor(ExecutorType.SpSummon, CardId.SkyCavalryCentaurea, SkyCavalryCentaureaSummon);
            AddExecutor(ExecutorType.Activate, CardId.SkyCavalryCentaurea);
            AddExecutor(ExecutorType.SpSummon, CardId.DaigustoPhoenix, DaigustoPhoenixSummon);
            AddExecutor(ExecutorType.Activate, CardId.DaigustoPhoenix);
            AddExecutor(ExecutorType.SpSummon, CardId.ToadallyAwesome);
            AddExecutor(ExecutorType.Activate, CardId.ToadallyAwesome, ToadallyAwesomeEffect);
            AddExecutor(ExecutorType.SpSummon, CardId.HeraldOfTheArcLight, HeraldOfTheArcLightSummon);
            AddExecutor(ExecutorType.Activate, CardId.HeraldOfTheArcLight);

            AddExecutor(ExecutorType.MonsterSet, CardId.GraydleSlimeJr);
            AddExecutor(ExecutorType.MonsterSet, CardId.DupeFrog);
            AddExecutor(ExecutorType.MonsterSet, CardId.Ronintoadin);

            AddExecutor(ExecutorType.Repos, Repos);

            // cards got by Toadally Awesome
            AddExecutor(ExecutorType.Activate, CardId.MysticalSpaceTyphoon, DefaultMysticalSpaceTyphoon);
            AddExecutor(ExecutorType.Activate, CardId.BookOfMoon, DefaultBookOfMoon);
            AddExecutor(ExecutorType.Activate, CardId.CallOfTheHaunted, SurfaceEffect);
            AddExecutor(ExecutorType.Activate, CardId.TorrentialTribute, DefaultTorrentialTribute);
            AddExecutor(ExecutorType.Activate, OtherSpellEffect);
            AddExecutor(ExecutorType.Activate, OtherTrapEffect);
            AddExecutor(ExecutorType.Activate, OtherMonsterEffect);
        }
Beispiel #58
0
 public void Update(GamePacketReader packet, Duel duel)
 {
     int flag = packet.ReadInt32();
     if ((flag & (int)Query.Code) != 0)
         SetId(packet.ReadInt32());
     if ((flag & (int)Query.Position) != 0)
     {
         Controller = duel.GetLocalPlayer(packet.ReadByte());
         packet.ReadByte();
         packet.ReadByte();
         Position = packet.ReadByte();
     }
     if ((flag & (int)Query.Alias) != 0)
         Alias = packet.ReadInt32();
     if ((flag & (int)Query.Type) != 0)
         Type = packet.ReadInt32();
     if ((flag & (int)Query.Level) != 0)
         Level = packet.ReadInt32();
     if ((flag & (int)Query.Rank) != 0)
         Rank = packet.ReadInt32();
     if ((flag & (int)Query.Attribute) != 0)
         Attribute = packet.ReadInt32();
     if ((flag & (int)Query.Race) != 0)
         Race = packet.ReadInt32();
     if ((flag & (int)Query.Attack) != 0)
         Attack = packet.ReadInt32();
     if ((flag & (int)Query.Defence) != 0)
         Defense = packet.ReadInt32();
     if ((flag & (int)Query.BaseAttack) != 0)
         BaseAttack = packet.ReadInt32();
     if ((flag & (int)Query.BaseDefence) != 0)
         BaseDefense = packet.ReadInt32();
     if ((flag & (int)Query.Reason) != 0)
         packet.ReadInt32();
     if ((flag & (int)Query.ReasonCard) != 0)
         packet.ReadInt32(); // Int8 * 4
     if ((flag & (int)Query.EquipCard) != 0)
         packet.ReadInt32(); // Int8 * 4
     if ((flag & (int)Query.TargetCard) != 0)
     {
         int count = packet.ReadInt32();
         for (int i = 0; i < count; ++i)
             packet.ReadInt32(); // Int8 * 4
     }
     if ((flag & (int)Query.OverlayCard) != 0)
     {
         Overlays.Clear();
         int count = packet.ReadInt32();
         for (int i = 0; i < count; ++i)
             Overlays.Add(packet.ReadInt32());
     }
     if ((flag & (int)Query.Counters) != 0)
     {
         int count = packet.ReadInt32();
         for (int i = 0; i < count; ++i)
             packet.ReadInt32(); // Int16 * 2
     }
     if ((flag & (int)Query.Owner) != 0)
         Owner = duel.GetLocalPlayer(packet.ReadInt32());
     if ((flag & (int)Query.IsDisabled) != 0)
         packet.ReadInt32();
     if ((flag & (int)Query.IsPublic) != 0)
         packet.ReadInt32();
     if ((flag & (int)Query.LScale) != 0)
         packet.ReadInt32();
     if ((flag & (int)Query.RScale) != 0)
         packet.ReadInt32();
 }
Beispiel #59
0
        public QliphortExecutor(GameAI ai, Duel duel)
            : base(ai, duel)
        {
            AddExecutor(ExecutorType.Activate, (int)CardId.黑洞, DefaultDarkHole);
            AddExecutor(ExecutorType.Activate, (int)CardId.召唤师的技艺);

            AddExecutor(ExecutorType.Activate, (int)CardId.机壳工具丑恶, 机壳工具丑恶发动);
            AddExecutor(ExecutorType.Activate, (int)CardId.机壳工具丑恶, 机壳工具丑恶效果);

            AddExecutor(ExecutorType.Activate, (int)CardId.机壳别名愚钝, 设置刻度);
            AddExecutor(ExecutorType.Activate, (int)CardId.机壳壳层拒绝, 设置刻度);
            AddExecutor(ExecutorType.Activate, (int)CardId.机壳基因组贪欲, 设置刻度);
            AddExecutor(ExecutorType.Activate, (int)CardId.机壳档案色欲, 设置刻度);

            AddExecutor(ExecutorType.Summon, 通常召唤);
            AddExecutor(ExecutorType.SpSummon);

            AddExecutor(ExecutorType.Activate, (int)CardId.机壳的牲祭, 机壳的牲祭);

            AddExecutor(ExecutorType.Activate, (int)CardId.机壳别名愚钝, 机壳别名愚钝效果);
            AddExecutor(ExecutorType.Activate, (int)CardId.机壳基因组贪欲, 机壳基因组贪欲效果);
            AddExecutor(ExecutorType.Activate, (int)CardId.机壳档案色欲, 机壳档案色欲效果);

            // 盖坑
            AddExecutor(ExecutorType.SpellSet, (int)CardId.技能抽取, 优先盖不重复的坑);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.虚无空间, 优先盖不重复的坑);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.次元障壁, 优先盖不重复的坑);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.激流葬, 优先盖不重复的坑);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.神之通告, 优先盖不重复的坑);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.神圣防护罩反射镜力, 优先盖不重复的坑);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.强制脱出装置, 优先盖不重复的坑);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.反大革命, 优先盖不重复的坑);

            AddExecutor(ExecutorType.SpellSet, (int)CardId.机壳的牲祭, 魔陷区有空余格子);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.技能抽取, 魔陷区有空余格子);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.虚无空间, 魔陷区有空余格子);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.次元障壁, 魔陷区有空余格子);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.激流葬, 魔陷区有空余格子);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.神之通告, 魔陷区有空余格子);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.神圣防护罩反射镜力, 魔陷区有空余格子);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.强制脱出装置, 魔陷区有空余格子);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.反大革命, 魔陷区有空余格子);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.黑洞, 魔陷区有空余格子);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.召唤师的技艺, 魔陷区有空余格子);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.强欲而谦虚之壶, 魔陷区有空余格子);

            // 开完削命继续盖坑
            AddExecutor(ExecutorType.Activate, (int)CardId.强欲而谦虚之壶, 强欲而谦虚之壶);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.削命的宝札);
            AddExecutor(ExecutorType.Activate, (int)CardId.削命的宝札, 削命的宝札);

            AddExecutor(ExecutorType.SpellSet, (int)CardId.机壳的牲祭, 已发动过削命);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.技能抽取, 已发动过削命);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.虚无空间, 已发动过削命);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.次元障壁, 已发动过削命);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.激流葬, 已发动过削命);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.神之通告, 已发动过削命);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.神圣防护罩反射镜力, 已发动过削命);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.强制脱出装置, 已发动过削命);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.反大革命, 已发动过削命);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.黑洞, 已发动过削命);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.召唤师的技艺, 已发动过削命);
            AddExecutor(ExecutorType.SpellSet, (int)CardId.强欲而谦虚之壶, 已发动过削命);

            // 坑人
            AddExecutor(ExecutorType.Activate, (int)CardId.反大革命, DefaultTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.神之通告, 神之通告);
            AddExecutor(ExecutorType.Activate, (int)CardId.技能抽取, 技能抽取);
            AddExecutor(ExecutorType.Activate, (int)CardId.虚无空间, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.强制脱出装置, DefaultCompulsoryEvacuationDevice);
            AddExecutor(ExecutorType.Activate, (int)CardId.次元障壁, DefaultDimensionalBarrier);
            AddExecutor(ExecutorType.Activate, (int)CardId.神圣防护罩反射镜力, DefaultUniqueTrap);
            AddExecutor(ExecutorType.Activate, (int)CardId.激流葬, DefaultTorrentialTribute);

            AddExecutor(ExecutorType.Repos, DefaultMonsterRepos);
        }
 public override string ToString(Duel duel)
 {
     return($"{Turn} ends for {duel.GetPlayer(Turn.ActivePlayer).Name}.");
 }