public void PlayerHasBlockDamageEffectUnitTest()
{
Player player = new Player("test", PlayerClassType.Warrior);
EffectAmountSettings effectAmountSettings = new EffectAmountSettings {
Amount = 50,
EffectHolder = player,
Name = "block test"
};
IEffect blockEffect = new BlockDamageEffect(effectAmountSettings);
player.Effects.Add(blockEffect);
Assert.AreEqual(1, player.Effects.Count);
Assert.AreEqual(true, player.Effects[0] is BlockDamageEffect);
Assert.AreEqual(1, player.Effects[0].CurrentRound);
Assert.AreEqual(3, player.Effects[0].MaxRound);
Assert.AreEqual(false, player.Effects[0].IsHarmful);
Assert.AreEqual(blockEffect.EffectHolder, player);
}
public void ProcessBlockDamageEffectOutOfCombatRoundUnitTest()
{
OutputHelper.Display.ClearUserOutput();
Player player = new Player("test", PlayerClassType.Warrior);
EffectAmountSettings effectAmountSettings = new EffectAmountSettings {
Amount = 50,
EffectHolder = player,
Name = "block test"
};
BlockDamageEffect blockEffect = new BlockDamageEffect(effectAmountSettings);
player.Effects.Add(blockEffect);
const string blockFadeMessage = "Your block effect is fading away.";
blockEffect.ProcessRound();
Assert.AreEqual(blockFadeMessage, OutputHelper.Display.Output[0][2]);
Assert.AreEqual(effectAmountSettings.Amount, blockEffect.BlockAmount);
Assert.AreEqual(2, player.Effects[0].CurrentRound);
Assert.AreEqual(false, blockEffect.IsEffectExpired);
}
public void ProcessBlockDamageEffectInCombatRoundWhereDamageLessThanBlockAmountUnitTest()
{
OutputHelper.Display.ClearUserOutput();
Player player = new Player("test", PlayerClassType.Warrior);
EffectAmountSettings effectAmountSettings = new EffectAmountSettings {
Amount = 50,
EffectHolder = player,
Name = "block test"
};
BlockDamageEffect blockEffect = new BlockDamageEffect(effectAmountSettings);
player.Effects.Add(blockEffect);
const int incomingDamage = 30;
string blockMessage = $"Your defensive move blocked {incomingDamage} damage!";
blockEffect.ProcessChangeDamageRound(incomingDamage);
Assert.AreEqual(blockMessage, OutputHelper.Display.Output[0][2]);
Assert.AreEqual(blockEffect.BlockAmount, 50 - incomingDamage);
Assert.AreEqual(2, player.Effects[0].CurrentRound);
Assert.AreEqual(false, blockEffect.IsEffectExpired);
}
public void BlockAbilityUnitTest()
{
Player player = new Player("test", PlayerClassType.Warrior)
{
MaxRagePoints = 100,
RagePoints = 100,
InCombat = true,
MaxHitPoints = 100,
HitPoints = 100,
DodgeChance = 0,
Level = 3
};
OutputHelper.Display.ClearUserOutput();
Monster monster = new Monster(3, MonsterType.Zombie)
{
HitPoints = 100, MaxHitPoints = 100, InCombat = true
};
MonsterBuilder.BuildMonster(monster);
monster.MonsterWeapon.CritMultiplier = 1;
int abilityIndex = player.Abilities.FindIndex(
f => f.WarAbilityCategory == WarriorAbility.Block);
string[] inputInfo = new[] { "ability", "block" };
PlayerHelper.AbilityInfo(player, inputInfo);
Assert.AreEqual("Block", OutputHelper.Display.Output[0][2]);
Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]);
Assert.AreEqual("Rage Cost: 25", OutputHelper.Display.Output[2][2]);
Assert.AreEqual("Block Damage: 50", OutputHelper.Display.Output[3][2]);
const string blockInfoString =
"Block damage will prevent incoming damage from opponent until block damage is used up.";
Assert.AreEqual(blockInfoString, OutputHelper.Display.Output[4][2]);
string[] input = new[] { "use", "block" };
string abilityName = InputHelper.ParseInput(input);
Assert.AreEqual("block", abilityName);
player.UseAbility(monster, input);
int?rageCost = player.Abilities[abilityIndex].RageCost;
Assert.AreEqual(player.MaxRagePoints - rageCost, player.RagePoints);
int blockAmount = player.Abilities[abilityIndex].Defensive.BlockDamage;
string blockString = $"You start blocking your opponent's attacks! You will block {blockAmount} damage.";
Assert.AreEqual(blockString, OutputHelper.Display.Output[5][2]);
OutputHelper.Display.ClearUserOutput();
Assert.AreEqual(true, player.Effects[0] is BlockDamageEffect);
Assert.AreEqual(player.MaxHitPoints, player.HitPoints);
BlockDamageEffect blockDmgEffect = player.Effects[0] as BlockDamageEffect;
int blockAmountRemaining = blockDmgEffect.BlockAmount;
Assert.AreEqual(blockAmount, blockAmountRemaining);
int i = 0;
while (blockAmountRemaining > 0)
{
monster.MonsterWeapon.Durability = 100;
int blockAmountBefore = blockAmountRemaining;
monster.Attack(player);
blockAmountRemaining = player.Effects.Any() ? blockDmgEffect.BlockAmount : 0;
if (blockAmountRemaining > 0)
{
Assert.AreEqual(player.MaxHitPoints, player.HitPoints);
string blockRoundString = $"Your defensive move blocked {(blockAmountBefore - blockAmountRemaining)} damage!";
Assert.AreEqual(blockRoundString, OutputHelper.Display.Output[i + (i * 1)][2]);
}
else
{
GameHelper.RemovedExpiredEffectsAsync(player);
int attackAmount = monster.MonsterWeapon.Attack() - blockAmountBefore;
Assert.AreEqual(player.MaxHitPoints - attackAmount, player.HitPoints);
const string blockEndString = "You are no longer blocking damage!";
Assert.AreEqual(blockEndString, OutputHelper.Display.Output[i + 3][2]);
Thread.Sleep(1000);
Assert.AreEqual(false, player.Effects.Any());
string hitString = $"The {monster.Name} hits you for {attackAmount} physical damage.";
Assert.AreEqual(hitString, OutputHelper.Display.Output[i + 4][2]);
}
i++;
}
}
