public void CharacterHoldsActionGenerically_HeGoesAfterOtherCharactersPhaseIfHeLosesDexRoll()
        {
            //arrange
            CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;

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

            HoldActionManuever held = holder.Manuevers["Hold Action"] as HoldActionManuever;

            HeroSystemCharacter attacker = sequence.NextCombatPhase.Character;
            Attack ranged = new Attack("Basic Ranged", attacker, DamageType.Normal, 5, DefenseType.PD, true);

            HeroSystemCharacter defender = sequence.NextCombatPhase.Character;

            Dice.RandomnessState = RandomnessState.average;


            //act

            held.Perform();

            ranged.Target(defender);

            holder.DEX.CurrentValue = 5;
            held.Interrupt(InterruptionWith.Generic);

            Assert.AreNotEqual(holder, sequence.ActivePhase.Character);
            Assert.AreEqual(attacker, sequence.ActivePhase.Character);

            sequence.CompleteActivePhase();
            Assert.AreEqual(holder, sequence.ActivePhase.Character);
        }
        public void MoreThanOneCharacterTriesToUseHeldActionAtSameTime_CharacterWhoWinsDexRollGoesFirst()
        {
            //arrange
            CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;

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


            HeroSystemCharacter holder2 = sequence.ActiveSegment.PhaseNextInDexOrder.Character;

            HoldActionManuever held1 = holder1.Manuevers["Hold Action"] as HoldActionManuever;

            held1.DexWaitingFor = 10;

            HoldActionManuever held2 = holder2.Manuevers["Hold Action"] as HoldActionManuever;

            held2.DexWaitingFor = 10;


            held1.Perform();
            holder1.DEX.CurrentValue = 30;

            held2.Perform();

            Dice.RandomnessState = RandomnessState.average;

            Assert.AreEqual(holder1, sequence.ActivePhase.Character);
            sequence.CompleteActivePhase();

            Assert.AreEqual(holder2, sequence.ActivePhase.Character);
        }
        public void CharacterHoldsActionUntilLowerDexAndTheCompletesHeldAction_InterruptedPhaseActsNext()
        {
            //arrange
            CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;

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


            HoldActionManuever holdManuever = (HoldActionManuever)character.Manuevers["Hold Action"];

            holdManuever.DexWaitingFor = 15;

            character.Manuevers["Hold Action"].Perform();

            sequence.CompleteActivePhase();
            //act

            //execute the held action
            sequence.CompleteActivePhase();

            //assert
            Assert.AreEqual(sequence.ActiveSegment.CombatPhases[2], sequence.ActivePhase);
            Assert.AreEqual(character.HeldManuever, null);
            Assert.AreEqual(sequence.HeldManuevers.Count, 0);
        }
        public void CharacterHoldsActionGenerically_HeCanInteruptOtherCharactersPhaseOnlyIfHeWinsDexRoll()
        {
            //arrange
            CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;

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

            HoldActionManuever held = holder.Manuevers["Hold Action"] as HoldActionManuever;

            HeroSystemCharacter attacker = sequence.NextCombatPhase.Character;
            Attack ranged = new Attack("Basic Ranged", attacker, DamageType.Normal, 5, DefenseType.PD, true);

            HeroSystemCharacter defender = sequence.NextCombatPhase.Character;

            Dice.RandomnessState = RandomnessState.average;


            //act

            held.Perform();
            ranged.Target(defender);
            held.Interrupt(InterruptionWith.Generic);

            //assert
            Assert.AreEqual(holder, sequence.ActivePhase.Character);
            Assert.AreEqual(sequence.ActivePhase, held.HeldPhase);
            Assert.AreEqual(sequence.InterruptedPhase.Character, attacker);
            Assert.AreEqual(sequence.InterruptedPhase.PhaseLeft, 1);
        }
        private Phase InterruptNextPhaseWithHeldPhaseIfWaitingForDexBeforeNextPhase(Phase nextPhase)
        {
            HoldActionManuever held = HeldPhaseWaitingForDexOrSegmentAvailableBeforeNextPhase(nextPhase);

            if (held != null)
            {
                held.Initialize();
                Sequence.InterruptedPhase = nextPhase;

                nextPhase = held.HeldPhase;
            }
            return(nextPhase);
        }
        public void CharacterHoldsActionUntilCharactersNextPhase_CharacterLosesHeldAction()
        {
            //arrange
            CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;

            sequence.StartCombat();
            HeroSystemCharacter character    = sequence.ActivePhase.Character;
            HoldActionManuever  holdManuever = (HoldActionManuever)character.Manuevers["Hold Action"];

            //act
            holdManuever.DexWaitingFor     = 10;
            holdManuever.SegmentWaitingFor = 2;
            character.Manuevers["Hold Action"].Perform();
            sequence.CompleteActivePhase();
            sequence.CompleteActivePhase();

            Assert.AreEqual(character.HeldManuever, null);
            Assert.AreEqual(0, sequence.HeldManuevers.Count);
        }
        public void CharacterHoldsActionAfterHalfPhaseAction_OnlyHalfPhaseActionsAreAvailable()
        {
            //arrange
            CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;

            sequence.StartCombat();
            HeroSystemCharacter character    = sequence.ActivePhase.Character;
            TestManuever        testManuever = new TestManuever("Sample Half 1", character);

            //act
            character.Manuevers["Sample Half 1"].Perform();

            HoldActionManuever holdManuever = (HoldActionManuever)character.Manuevers["Hold Action"];

            holdManuever.DexWaitingFor = 15;
            character.Manuevers["Hold Action"].Perform();

            sequence.CompleteActivePhase();

            //assert
            Assert.AreEqual(.5, sequence.ActivePhase.PhaseLeft);
        }
        public void CharacterHoldsActionUntilDifferentSegment_PhaseExecutesAtSegmentSpecified()
        {
            //arrange
            CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;

            sequence.StartCombat();

            HeroSystemCharacter character = sequence.ActivePhase.Character;

            //act
            HoldActionManuever holdManuever = (HoldActionManuever)character.Manuevers["Hold Action"];

            holdManuever.DexWaitingFor     = 15;
            holdManuever.SegmentWaitingFor = 1;

            character.Manuevers["Hold Action"].Perform();

            sequence.CompleteActivePhase();
            sequence.CompleteActivePhase();

            Assert.AreEqual(sequence.ActiveSegment.Number, holdManuever.SegmentWaitingFor);
        }
        public void CharacterUsingHeldDefensiveAction_AlwaysGoesBeforeOtherHeldOrInterruptedActions()
        {
            //arrange
            CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;

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


            HeroSystemCharacter attacker = sequence.ActiveSegment.PhaseNextInDexOrder.Character;

            HoldActionManuever held1 = holder1.Manuevers["Hold Action"] as HoldActionManuever;

            held1.Perform();

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

            attack?.Target(holder1);

            holder1.DEX.CurrentValue = 10;
            held1.Interrupt(InterruptionWith.Defensive);

            Assert.AreEqual(holder1, sequence.ActivePhase.Character);
        }
        public void CharacterHoldsActionUntilLowerDex_PhaseExecutesAtLowerDexSpecified()
        {
            //arrange
            CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;

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

            //act
            HoldActionManuever holdManuever = (HoldActionManuever)character.Manuevers["Hold Action"];

            holdManuever.DexWaitingFor = 15;

            character.Manuevers["Hold Action"].Perform();

            //assert
            Assert.AreEqual(character.ActivePhase, null);
            Assert.AreEqual(character.HeldManuever, character.Manuevers["Hold Action"]);
            Assert.AreEqual(character.HeldManuever, sequence.HeldManuevers[0]);
            Assert.AreEqual(sequence.ActivePhase.Character.DEX.CurrentValue, 20);

            sequence.CompleteActivePhase();
            Assert.AreEqual(character, sequence.ActivePhase.Character);
        }