public void AbortingToAction_CharacterCannotAbortAgainUntilNextPhaseStarts()
        {
            //arrange
            CombatSequence      sequence = Factory.SequenceWithFastMediumAndSlowCharacters;
            HeroSystemCharacter other    = Factory.Factory.BaseCharacter;

            other.DEX.MaxValue = 9;
            sequence.AddCharacter(other);

            sequence.StartCombat();
            HeroSystemCharacter attacker = sequence.ActivePhase.Character;

            attacker.DEX.MaxValue = 20;

            HeroSystemCharacter defender = sequence.ActiveSegment.PhaseNextInDexOrder.Character;

            defender.DEX.MaxValue = 10;
            TestAbortableManuever abortableManuever = new TestAbortableManuever("Abortable Manuever", defender);



            Attack attack = attacker.Manuevers["Strike"] as Attack;

            attack?.Target(defender);


            defender.Manuevers["Abort"].Perform();
            defender.Manuevers["Abortable Manuever"].Perform();

            Assert.AreEqual(false, defender.Manuevers["Abort"].CanPerform);


            Assert.AreEqual(sequence.InterruptedPhase.Character, attacker);
        }
        public void WhenAttackInProgess_CanOnlyAbortIfCanAbortEvaluatesToTrue()
        {
            //arrange
            CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;

            sequence.StartCombat();
            HeroSystemCharacter attacker = sequence.ActivePhase.Character;
            Attack attack = attacker.Manuevers["Strike"] as Attack;
            HeroSystemCharacter   defender          = sequence.ActiveSegment.PhaseNextInDexOrder.Character;
            TestAbortableManuever abortableManuever = new TestAbortableManuever("Abortable Manuever", defender);

            //act
            attack?.Target(defender);
            defender.Manuevers["Abort"].Perform();
            //assert
            Assert.AreEqual(abortableManuever.Perform(), false);
        }
        public void UsingAbortWithNonDefensiveManuever_ManueverFails()
        {
            //arrange
            CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;

            sequence.StartCombat();
            HeroSystemCharacter attacker = sequence.ActivePhase.Character;
            Attack attack = attacker.Manuevers["Strike"] as Attack;
            HeroSystemCharacter   defender          = sequence.ActiveSegment.PhaseNextInDexOrder.Character;
            TestAbortableManuever abortableManuever = new TestAbortableManuever("Abortable Manuever", defender);

            //act
            attack?.Target(defender);
            defender.Manuevers["Abort"].Perform();

            Attack notAllowedManuever = defender.Manuevers["Strike"] as Attack;

            Assert.AreEqual(notAllowedManuever?.Perform(), false);
        }
        public void WhenAborting_OnlyDefensiveManueversAvailable()
        {
            //arrange
            CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;

            sequence.StartCombat();
            HeroSystemCharacter attacker = sequence.ActivePhase.Character;
            Attack attack = attacker.Manuevers["Strike"] as Attack;
            HeroSystemCharacter   defender          = sequence.ActiveSegment.PhaseNextInDexOrder.Character;
            TestAbortableManuever abortableManuever = new TestAbortableManuever("Abortable Manuever", defender);

            //act
            attack?.Target(defender);
            defender.Manuevers["Abort"].Perform();

            List <IManuever> notDefensiveManuevers = defender.AllowedManuevers.Values.Where
                                                         (x => x.Type != ManueverType.Defensive).ToList();

            Assert.AreEqual(0, notDefensiveManuevers.Count);
        }