Esempio n. 1
0
 public void OnAttack()
 {
     
 // This test allows us to check that Chain Mines destroyed the attacking monster
 // However it doesn't absolutely confirm that this activation was legal (we know it is but the game doesn't know for sure)
 // We likely need to create a dedicated error handler system with err_codes, signals etc.
     var deckList = new List<SetCodes>();
     deckList.Add(SetCodes.Debug500500);
     deckList.Add(SetCodes.Debug500500);
     deckList.Add(SetCodes.Debug500500);
     deckList.Add(SetCodes.DebugDestroyAttackingUnit);
     deckList.Add(SetCodes.DebugDestroyAttackingUnit);
     deckList.Add(SetCodes.DebugDestroyAttackingUnit);
     deckList.Add(SetCodes.Debug15001000);
     deckList.Add(SetCodes.Debug15001000);
     deckList.Add(SetCodes.Debug15001000);
     StartGame(deckList);
     var attacker = Player.Hand[6];
     var chainMine = Opponent.Hand[3];
     Play.Deploy(Player.Id, attacker.Id);
     Play.PassPlay(Opponent.Id);
     Play.PassPlay(Player.Id);
     Play.EndTurn(Player.Id);
     Play.SetFaceDown(Opponent.Id, chainMine.Id);
     Play.EndTurn(Opponent.Id);
     Play.AttackDirectly(Player.Id, attacker.Id);
     Play.Activate(Opponent.Id, chainMine.Id);
     Play.PassPlay(Player.Id);
     Play.PassPlay(Opponent.Id);
     
     // Link Should Resolve Here
     Assert.Contains(attacker, Player.Graveyard, attacker + "is in Player 1's Discard");
     Assert.Contains(chainMine, Opponent.Graveyard, chainMine + " is in Player 0's Discard");
 }
Esempio n. 2
0
        public void When_They_Declare_An_Attack_With_A_Unit_Not_On_Their_Field()
        {
            StartGame(DeckList);
            var unit = Player.Hand[0].Id;

            Play.AttackDirectly(Player.Id, unit);

            Assert.IsTrue(Player.IsDisqualified);
        }
Esempio n. 3
0
        public void When_They_Declare_An_Attack_With_An_Unready_Unit()
        {
            StartGame(DeckList);
            var unit = Player.Hand[0].Id;

            Play.Deploy(Player.Id, unit);
            Play.AttackDirectly(Player.Id, unit);

            Assert.IsTrue(Player.IsDisqualified);
        }
Esempio n. 4
0
        public void When_A_Player_Declares_An_Attack_During_Their_Opponents_Turn()
        {
            StartGame(DeckList);
            var unit = Player.Hand[0].Id;

            Play.Deploy(Player.Id, unit);
            // Ending twice so the unit is ready
            Play.EndTurn(Player.Id);
            Play.EndTurn(Opponent.Id);
            Play.EndTurn(Player.Id);
            Play.AttackDirectly(Player.Id, unit);

            Assert.IsTrue(Player.IsDisqualified);
        }
Esempio n. 5
0
        public void When_It_Attacks_Directly()
        {
            StartGame(DeckList);

            var debug15001000 = (Unit)Player.Hand[Player.Hand.Count - 1];

            Play.Deploy(Player.Id, debug15001000.Id);
            Play.PassPlay(Opponent.Id);
            Play.PassPlay(Player.Id);
            Play.EndTurn(Player.Id);
            Play.EndTurn(Opponent.Id);
            var expectedLife = Opponent.Health - debug15001000.Power;

            Play.AttackDirectly(Player.Id, debug15001000.Id);
            Play.PassPlay(Opponent.Id);
            Play.PassPlay(Player.Id);

            Assert.IsEqual(expectedLife, Opponent.Health, "Then the defending Player loses life equal to its attack");
        }
Esempio n. 6
0
        public void OnAttack()
        {
            var deckList = new List <SetCodes>();

            deckList.Add(SetCodes.Debug500500);
            deckList.Add(SetCodes.Debug500500);
            deckList.Add(SetCodes.Debug500500);
            deckList.Add(SetCodes.DebugDestroyAttackingUnit);
            deckList.Add(SetCodes.DebugDestroyAttackingUnit);
            deckList.Add(SetCodes.DebugDestroyAttackingUnit);
            deckList.Add(SetCodes.Debug15001000);
            deckList.Add(SetCodes.Debug15001000);
            deckList.Add(SetCodes.Debug15001000);
            StartGame(deckList);

            // LINK SUMMARY
            // ACTION TAKEN (NON CHAIN)
            // PLAYER WHO TOOK ACTION MAY CHAIN
            // OPPONENT MAY CHAIN
            // RESOLVE

            // UPDATE
            // Player A May Take Action From IDLE
            // Player A May Respond To Own Action (Repeat This Until Pass) From ACTIVE
            // Player B May Respond (From ACTIVE)
            // Player A May Respond (From ACTIVE)
            var attacker   = Player.Hand[6];
            var chainMines = (Support)Opponent.Hand[3];



            // Whitebox Checking
            Assert.IsTrue(Player.State == States.Idle, "Player 1 is IDLE");
            Assert.IsTrue(Opponent.State == States.Passive, "Player 0 is PASSIVE");

            Play.Deploy(Player.Id, attacker.Id);

            // Whitebox Checking
            // Player 1 took an action from IDLE that doesn't start a chain so they should
            // be active (rather than acting?) Maybe acting != activating?

            Assert.Contains(attacker, Player.Field, "Attacker Has been Deployed");

            Assert.IsTrue(Player.State == States.Acting, "Player 1 is ACTING");
            Assert.IsTrue(Opponent.State == States.Active, "Player 0 is ACTIVE");

            Play.PassPlay(Opponent.Id);

            // Whitebox Check
            Assert.IsTrue(Opponent.State == States.Passing, "Player 0 is PASSING");
            Assert.IsTrue(Player.State == States.Active, "Player 1 is ACTIVE");

            Play.PassPlay(Player.Id);

            Assert.IsTrue(Player.State == States.Idle, "Player 1 is IDLE");
            Assert.IsTrue(Opponent.State == States.Passive, "Player 0 is PASSIVE");

            Play.EndTurn(Player.Id);

            Assert.IsTrue(Player.State == States.Passive, "Player 1 is PASSIVE");
            Assert.IsTrue(Opponent.State == States.Idle, "Player 0 is IDLE");

            Play.SetFaceDown(Opponent.Id, chainMines.Id);
            Assert.Contains(chainMines, Opponent.Support, "Chain Mines Has been set");
            Play.EndTurn(Opponent.Id);

            Assert.IsTrue(Player.State == States.Idle, "Player 1 is IDLE");
            Assert.IsTrue(Opponent.State == States.Passive, "Player 0 is PASSIVE");
            Play.AttackDirectly(Player.Id, attacker.Id);

            Assert.IsTrue(Player.State == States.Acting, "Player 1 is ACTING");
            Assert.IsTrue(Opponent.State == States.Active, "Player 0 is ACTIVE");

            Assert.IsTrue(chainMines.IsReady, "ChainMines Is Ready");
            Assert.IsTrue(chainMines.State == Card.States.CanBeActivated, "ChainMine can be activated");
            Play.Activate(Opponent.Id, chainMines.Id);

            Assert.IsTrue(Opponent.State == States.Acting, "Player 0 is ACTING");
            Assert.IsTrue(Player.State == States.Active, "Player 1 is ACTIVE");

            Play.PassPlay(Player.Id);

            Assert.IsTrue(Player.State == States.Passing, "Player 1 is PASSING");
            Assert.IsTrue(Opponent.State == States.Active, "Player 0 is ACTIVE");

            Play.PassPlay(Opponent.Id);

            Assert.IsTrue(Player.State == States.Idle, "Player 1 is IDLE");
            Assert.IsTrue(Opponent.State == States.Passive, "Player 0 is PASSIVE");



            Assert.Contains(attacker, Player.Graveyard, attacker + "Unit %s is in Player 1's discard");

            Assert.Contains(chainMines, Opponent.Graveyard, chainMines + "Support %s is in Player 0's Discard");
        }