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 CharacterMovement(HeroSystemCharacter character)
{
Character = character;
Run = new Movement(character, "Run", 6, false);
Swim = new Movement(character, "Swim", 2, false);
Leap = new Movement(character, "Leap", 2, false);
}
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 PerceptiveCharacterAndTargetCharacterThatsIsFarAway()
{
Map = MapFactory.ActiveGameMap;
Viewer = Factory.BaseCharacter;
Target = Factory.BaseCharacter;
Target.Hex = new GameHex(1, 1, 22);
}
public void AttackWithKnockback_DamagesCharacter()
{
HeroSystemCharacter attacker = new HeroSystemCharacter();
Attack cm = new Attack("Basic", attacker, DamageType.Normal, 5,
DefenseType.PD);
DamageAmount attackDamage = new DamageAmount();
attackDamage.Type = DamageType.Normal;
attackDamage.BOD = 13;
attackDamage.WorksAgainstDefense = DefenseType.PD;
HeroSystemCharacter defender = new HeroSystemCharacter();
KnockbackResult actualKnockback = cm.KnockBackCharacter(defender, attackDamage);
KnockbackResultType actualResult = actualKnockback.Result;
KnockbackResultType expectedResult = KnockbackResultType.KnockBacked;
Assert.AreEqual(actualResult, expectedResult);
bool isProne = defender.State.ContainsKey(CharacterStateType.Prone);
Assert.AreEqual(isProne, true);
}
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 override void ApplyModifierTo(HeroSystemCharacter character)
{
int deltaMod = ModiferAmount - CumulativeModifierApplied;
character.Characteristics[Charasteristic].Modifier += deltaMod;
if (MultiplierApplied == 0 && Multiplier != 0)
{
MultiplierApplied = Multiplier;
if (character.Characteristics[Charasteristic].Multiplier == 0)
{
character.Characteristics[Charasteristic].Multiplier = Multiplier;
}
else
{
character.Characteristics[Charasteristic].Multiplier *= Multiplier;
}
}
if (SetToZero == true)
{
character.Characteristics[Charasteristic].ToZero = true;
}
CumulativeModifierApplied += deltaMod;
}
public void TestGiven()
{
Defender = HeroSystemCharacterRepository.GetInstance().Characters["Default Character"];
Attacker = HeroSystemCharacterRepository.GetInstance().LoadBaseCharacter();
Attacker.STR.MaxValue = 15;
Dice.Dice.RandomnessState = RandomnessState.average;
}
public override void RemoveModifierFrom(HeroSystemCharacter character)
{
character.DamageClassModifier -= CumulativeModifierApplied;
CumulativeModifierApplied = 0;
character.DamageMultiplier = 0;
// character.DamageModifierAppliesTo = HealthType.ALL;
}
public Brace(HeroSystemCharacter character)
: base(ManueverType.CombatManuever, "Brace", character, false)
{
PhaseActionTakes = PhaseLength.Zero;
Modifier.RangedModifer.ModiferAmount = +2;
Modifier.DCV.Multiplier = .5;
}
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);
}
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 Phase AddCharacter(HeroSystemCharacter character)
{
Phase phase = new Phase(character, this);
_combatPhases[character.Name] = phase;
character.SPD.Phases[Number] = phase;
return(phase);
}
public void HandKillingAttackHits_StrengthModAddedToDamgeDice()
{
HeroSystemCharacter attacker = characterFactory.BaseCharacterWithOneHandKillingAttackCombatManuever;
HandKillingAttack attack = attacker.Manuevers["Hand Killing PerformAttack"] as HandKillingAttack;
Assert.AreEqual(attack.DamageDiceNumber, 6);
}
public void CharacterWithStandardSensesAndAttackerWithSenseAffectingPower()
{
Target = Factory.BaseCharacter;
CharacterSenses = Target.CharacterSenses;
Attacker = Factory.BaseCharacter;
BlindingPower = new SenseAffectingPower(Attacker, 10, true);
SuperSight = CharacterSenses.SightGroup.CreateSenseWithNameForGroup("Super Sight");
SightGroup = CharacterSenses.SenseGroups["Sight"];
}
public void Given()
{
Sequence = new CombatSequence();
Sequence.StartCombat();
Character = Factory.BaseCharacter;
Character.SPD.MaxValue = 6;
Sequence.AddCharacter(Character);
Sequence.StartCombat();
}
public int RequiredRollToBlockAttacker(HeroSystemCharacter attacker)
{
int roll = 0;
if (Character?.OCV?.CurrentValue != null && attacker?.OCV?.CurrentValue != null)
{
roll = Character.OCV.CurrentValue - attacker.OCV.CurrentValue + 11;
}
return(roll);
}
public Manuever(ManueverType type, String name, HeroSystemCharacter character, bool isAbortable = false)
{
IsAbortable = isAbortable;
Name = name;
Character = character;
Type = type;
Character.AddManuever(this);
PhaseActionTakes = PhaseLength.Half;
Modifier = new ManueverModifier();
}
public override void RemoveModifierFrom(HeroSystemCharacter character)
{
character.Characteristics[Charasteristic].Modifier -= CumulativeModifierApplied;
if (character.Characteristics[Charasteristic].Multiplier != 0 && MultiplierApplied != 0)
{
character.Characteristics[Charasteristic].Multiplier /= MultiplierApplied;
}
CumulativeModifierApplied = 0;
MultiplierApplied = 0;
}
private void addCharacterPhaseToSegments(HeroSystemCharacter character)
{
character.CombatSequence = this;
Characters.Add(character);
foreach (var phaseNumber in ((SPD)character.SPD).SegmentNumbersCharacterHasPhases)
{
Segment segment = Segments[phaseNumber];
Phase phase = segment.AddCharacter(character);
character.SPD.Phases[segment.Number] = phase;
}
}
public ConcealmentAmount BlockingCoverProvidedAgainstOtherCharacter(HeroSystemCharacter viewingCharacter, ITargetable coveredCharacter)
{
if (coveredCharacter?.Name == "attacker")
{
return(ConcealmentAmount);
}
else
{
return(ConcealmentAmount.None);
}
}
public Movement(HeroSystemCharacter character, string name, int inches, bool turningModeRequired)
{
this.Character = character;
this.Name = name;
this.Inches = inches;
this.TurningModeRequired = turningModeRequired;
Facing = new HexFacing();
MovementManuever manuever = new MovementManuever(this.Character, this);
NonCombatCVModifier = new ManueverModifier();
}
public void AdddingCharacterToCombatSequence_CharacterIsOrderedByPhasesAndDex()
{
CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharacters;
sequence.StartCombat();
//segment 12
Segment currentSegment = sequence.ActiveSegment;
List <Phase> phases = currentSegment.CombatPhases;
HeroSystemCharacter currentCharacter = phases.First().Character;
Assert.AreEqual("Fast Character", currentCharacter.Name);
currentCharacter = phases.ElementAt(1).Character;
Assert.AreEqual("Medium Character", currentCharacter.Name);
currentCharacter = phases.ElementAt(2).Character;
Assert.AreEqual("Slow Character", currentCharacter.Name);
//segment 2
currentSegment = sequence.SegmentAfter(currentSegment);
currentSegment = sequence.SegmentAfter(currentSegment);
phases = currentSegment.CombatPhases;
currentCharacter = phases.ElementAt(0).Character;
Assert.AreEqual("Fast Character", currentCharacter.Name);
//segment 3
currentSegment = sequence.SegmentAfter(currentSegment);
phases = currentSegment.CombatPhases;
currentCharacter = phases.ElementAt(0).Character;
Assert.AreEqual("Medium Character", currentCharacter.Name);
//segment 4
currentSegment = sequence.SegmentAfter(currentSegment);
phases = currentSegment.CombatPhases;
currentCharacter = phases.First().Character;
Assert.AreEqual("Fast Character", currentCharacter.Name);
//segment 6
currentSegment = sequence.SegmentAfter(currentSegment);
currentSegment = sequence.SegmentAfter(currentSegment);
phases = currentSegment.CombatPhases;
currentCharacter = phases.First().Character;
Assert.AreEqual("Fast Character", currentCharacter.Name);
currentCharacter = phases.ElementAt(1).Character;
Assert.AreEqual("Medium Character", currentCharacter.Name);
currentCharacter = phases.ElementAt(2).Character;
Assert.AreEqual("Slow Character", currentCharacter.Name);
}
public void AffectSense(HeroSystemCharacter defender)
{
if (AffectsGroup != null)
{
SenseGroup affected = defender.CharacterSenses.SenseGroupList.Where(x => x.Type == AffectsGroup).ToList().FirstOrDefault();
affected.IsDisabled = true;
}
else if (AffectsPower != null)
{
List <Sense> powerSenses = defender.CharacterSenses.Senses.Where(x => x.Power == AffectsPower).ToList();
powerSenses.ForEach((Sense sense) => { sense.IsDisabled = true; });
}
}
public void CharacterWithSightAndOtherCharacterTarget()
{
Character = Factory.BaseCharacter;
Character.OCV.MaxValue = 4;
Character.DCV.MaxValue = 4;
Target = Factory.BaseCharacter;
Sight = Character.CharacterSenses.Sight;
Hearing = Character.CharacterSenses.Hearing;
Touch = Character.CharacterSenses.Touch;
CharacterSenses = Character.CharacterSenses;
Strike = Character.Manuevers["Strike"] as Strike;
Ranged = Factory.AddRangedAttackToCharacter(Character);
CharacterSenses.Target = Target;
}
public void WhenSegmentTwelveFinished_PostSegmentTwelveRecoveryRunOnAllCharcters()
{
CombatSequence sequence = Factory.SequenceWithFastMediumAndSlowCharactersWithMocRecManeuver;
sequence.StartCombat();
HeroSystemCharacter character = sequence.Characters.FirstOrDefault();
sequence.CompleteActivePhase();
sequence.CompleteActivePhase();
sequence.CompleteActivePhase();
Mock.Get(character?.Manuevers["Recover"])
.Verify(foo => foo.Perform(), Times.Exactly(3));
}
public void TestActivatingAttack_AttackIsUsedCalculatesChanceToHitOnDefender()
{
HeroSystemCharacter character = characterFactory.BaseCharacterWithOneCombatManuever;
HeroSystemCharacter defender = characterFactory.BaseCharacter;
character.OCV.CurrentValue = 5;
defender.DCV.CurrentValue = 3;
var cm = character.Manuevers["Basic"] as Attack;
int tohit = cm.RollRequiredToHitWithoutModifiers(defender);
Assert.AreEqual(13, tohit);
}
public void CharacterPerformsHalfPhaseAction_OnlyHalfPhaseIsleft()
{
//arrange
CombatSequence sequence = Factory.SequenceWithCharacterWithMixOfFullAndHalfPhaseManuevers;
sequence.StartCombat();
Phase phase = sequence.ActivePhase;
HeroSystemCharacter character = phase.Character;
IManuever halfPhaseManuever = character.Manuevers["Sample Half 1"];
//act
halfPhaseManuever.Perform();
//arrange
Assert.AreEqual(.5, phase.PhaseLeft);
}
public void TestTakeDamage_EffectsCharacterStateBasedOnAmount()
{
DamageAmount attackDamage = new DamageAmount();
attackDamage.STUN = 35;
attackDamage.BOD = 5;
attackDamage.WorksAgainstDefense = DefenseType.PD;
HeroSystemCharacter defender = new HeroSystemCharacter();
defender.PD.CurrentValue = 5;
defender.STUN.CurrentValue = 50;
defender.BOD.CurrentValue = 10;
defender.BOD.MaxValue = 10;
defender.CON.CurrentValue = 29;
defender.TakeDamage(attackDamage);
bool actualStunned = defender.State.ContainsKey(CharacterStateType.Stunned);
bool expectedStunned = true;
Assert.AreEqual(actualStunned, expectedStunned);
attackDamage = new DamageAmount();
attackDamage.STUN = 35;
attackDamage.BOD = 10;
attackDamage.WorksAgainstDefense = DefenseType.PD;
defender.TakeDamage(attackDamage);
bool actualUnconsious = defender.State.ContainsKey(CharacterStateType.Unconsious);
bool expectedUnconsious = true;
Assert.AreEqual(actualUnconsious, expectedUnconsious);
attackDamage.BOD = 11;
defender.TakeDamage(attackDamage);
bool actualDying = defender.State.ContainsKey(CharacterStateType.Dying);
bool expectedDying = true;
Assert.AreEqual(actualDying, expectedDying);
attackDamage.BOD = 14;
defender.TakeDamage(attackDamage);
bool actualDead = defender.State.ContainsKey(CharacterStateType.Dying);
bool expectedDead = true;
Assert.AreEqual(actualDead, expectedDead);
}
public void WhenNoDefendersWithinOneHex_HTHAttackAbilityIsDisabled()
{
//arrange
HeroSystemCharacter character = characterFactory.BaseCharacterWithOneCombatManuever;
HeroSystemCharacter defender = characterFactory.BaseCharacter;
MapFactory.ActiveGameMap.HexBesideOtherHex = false;
//act
character.Hex = new GameHex(1, 1, 1);
defender.Hex = new GameHex(1, 1, 3);
//assert
var strike = character.Manuevers["Basic"];
Assert.AreEqual(strike.CanPerform, false);
}
