public float takeFireDamage(float delta, ObjectInteractable source)//Damage subtracts. deltas should be positive.
{
if (!dead && takesFireDamage)
{
if (delta >= 0.5f)
{
foreach (var observer in fireHitObservers)
{
observer.trigger(source.gameObject);
}
foreach (var observer in fireDamageObservers)
{
delta = observer.trigger(delta);
}
}
BurningEffect burning = GetComponent <BurningEffect>();
if (burning != null)
{
burning.addDuration(delta / 100);
}
return(takeRawDamage(applyArmor(fireArmor, delta), source));
}
else
{
return(0);
}
}
public void FireballSpellUnitTest()
{
Player player = new Player("test", PlayerClassType.Mage)
{
MaxManaPoints = 100, ManaPoints = 100, InCombat = true
};
GearHelper.EquipInitialGear(player);
OutputHelper.Display.ClearUserOutput();
Monster monster = new Monster(3, MonsterType.Demon)
{
HitPoints = 50, MaxHitPoints = 100, FireResistance = 0
};
MonsterBuilder.BuildMonster(monster);
player.PlayerWeapon.CritMultiplier = 1; // Remove crit chance to remove "noise" in test
string[] inputInfo = new[] { "spell", "fireball" };
int spellIndex = player.Spellbook.FindIndex(
f => f.SpellCategory == SpellType.Fireball);
PlayerHelper.SpellInfo(player, inputInfo);
Assert.AreEqual("Fireball", OutputHelper.Display.Output[0][2]);
Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]);
Assert.AreEqual("Mana Cost: 35", OutputHelper.Display.Output[2][2]);
Assert.AreEqual("Instant Damage: 25", OutputHelper.Display.Output[3][2]);
Assert.AreEqual("Damage Over Time: 5", OutputHelper.Display.Output[4][2]);
Assert.AreEqual("Fire damage over time will burn for 3 rounds.",
OutputHelper.Display.Output[5][2]);
OutputHelper.Display.ClearUserOutput();
string[] input = new[] { "cast", "fireball" };
string spellName = InputHelper.ParseInput(input);
Assert.AreEqual("fireball", spellName);
player.CastSpell(monster, spellName);
Assert.AreEqual(player.MaxManaPoints - player.Spellbook[spellIndex].ManaCost, player.ManaPoints);
Assert.AreEqual(25, monster.HitPoints);
Assert.AreEqual(3, monster.Effects[0].MaxRound);
Assert.AreEqual($"You hit the {monster.Name} for {player.Spellbook[spellIndex].Offensive.Amount} fire damage.",
OutputHelper.Display.Output[0][2]);
Assert.AreEqual($"The {monster.Name} bursts into flame!",
OutputHelper.Display.Output[1][2]);
BurningEffect burnEffect = monster.Effects[0] as BurningEffect;
for (int i = 2; i < 5; i++)
{
burnEffect.ProcessRound();
Assert.AreEqual(
$"The {monster.Name} burns for {burnEffect.FireDamageOverTime} fire damage.",
OutputHelper.Display.Output[i][2]);
Assert.AreEqual(i, monster.Effects[0].CurrentRound);
GameHelper.RemovedExpiredEffectsAsync(monster);
Thread.Sleep(1000);
}
Assert.AreEqual(false, monster.Effects.Any());
Assert.AreEqual(10, monster.HitPoints);
}
public void FirebreathSpellUnitTest()
{
Player player = new Player("test", PlayerClassType.Mage)
{
HitPoints = 200, MaxHitPoints = 200, FireResistance = 0
};
OutputHelper.Display.ClearUserOutput();
Monster monster = new Monster(3, MonsterType.Dragon);
MonsterBuilder.BuildMonster(monster);
int spellIndex = monster.Spellbook.FindIndex(
f => f.SpellCategory == SpellType.Fireball);
foreach (IItem item in monster.MonsterItems.Where(item => item is IEquipment eItem && eItem.Equipped))
{
IEquipment eItem = item as IEquipment;
eItem.Equipped = false;
}
monster.MonsterWeapon.CritMultiplier = 1; // Remove crit chance to remove "noise" in test
monster.Spellbook[spellIndex].CastFireOffense(monster, player, spellIndex);
int spellCost = monster.Spellbook[spellIndex].EnergyCost;
Assert.AreEqual(monster.MaxEnergyPoints - spellCost, monster.EnergyPoints);
int spellDamage = monster.Spellbook[spellIndex].Offensive.Amount;
Assert.AreEqual(player.MaxHitPoints - spellDamage, player.HitPoints);
int spellMaxRounds = monster.Spellbook[spellIndex].Offensive.AmountMaxRounds;
Assert.AreEqual(spellMaxRounds, player.Effects[0].MaxRound);
string attackString = $"The {monster.Name} breathes a pillar of fire at you!";
Assert.AreEqual(attackString, OutputHelper.Display.Output[0][2]);
string attackSuccessString = $"The {monster.Name} hits you for {spellDamage} fire damage.";
Assert.AreEqual(attackSuccessString, OutputHelper.Display.Output[1][2]);
const string onFireString = "You burst into flame!";
Assert.AreEqual(onFireString, OutputHelper.Display.Output[2][2]);
Assert.AreEqual(true, player.Effects[0] is BurningEffect);
int burnDamage = monster.Spellbook[spellIndex].Offensive.AmountOverTime;
BurningEffect burnEffect = player.Effects[0] as BurningEffect;
for (int i = 2; i < 5; i++)
{
burnEffect.ProcessRound();
string burnString = $"You burn for {burnDamage} fire damage.";
Assert.AreEqual(burnString, OutputHelper.Display.Output[i + 1][2]);
Assert.AreEqual(i, player.Effects[0].CurrentRound);
GameHelper.RemovedExpiredEffectsAsync(player);
Thread.Sleep(1000);
}
Assert.AreEqual(false, player.Effects.Any());
Assert.AreEqual(player.MaxHitPoints - spellDamage - (burnDamage * 3), player.HitPoints);
}
public void beginChilled(ObjectActor subject, ObjectInteractable source)
{
BurningEffect burning = subject.getBurningEffect();
if (burning != null)
{
subject.endBurning();
return;
}
beginCondition <ChilledEffect>(subject, source);
}
virtual public void ReceiveFireDamage(float tickLength, float damageAmount, float totalDuration)
{
Debug.Log("Starting burn for " + damageAmount + " damage per tick");
Debug.Log("Duration is " + totalDuration);
//StartCoroutine(TakeFireDamageOverTime(tickLength, damageAmount, totalDuration));
if (currBurn == null)
{
currBurn = Instantiate(burningeffectPrefab, transform);
currBurn.initialize(tickLength, damageAmount, totalDuration);
}
else
{
currBurn.addBurning(totalDuration);
}
}
public void PlayerHasBurningEffectUnitTest()
{
Player player = new Player("test", PlayerClassType.Mage);
EffectOverTimeSettings effectOverTimeSettings = new EffectOverTimeSettings {
AmountOverTime = 20,
EffectHolder = player,
MaxRound = 3,
Name = "burning test"
};
BurningEffect burningEffect = new BurningEffect(effectOverTimeSettings);
player.Effects.Add(burningEffect);
Assert.AreEqual(1, player.Effects.Count);
Assert.AreEqual(effectOverTimeSettings.Name, burningEffect.Name);
Assert.AreEqual(true, player.Effects[0] is BurningEffect);
}
IEnumerator SlowEnemyRoutine(float slowDuration)
{
BurningEffect burn = GetComponentInChildren <BurningEffect>();
if (burn != null)
{
burn.DestroyBurn();
}
coldActive = true;
chilled = 0.5f;
StartCoroutine(flashColor(Color.cyan, slowDuration));
backupColdTimer = slowDuration;
yield return(new WaitForSeconds(slowDuration));
Debug.Log("ending slow");
coldActive = false;
chilled = 1f;
}
public void Update()
{
player.Update();
player.CheckLavaCollision(lava);
if (player.IntersectingLava)
{
BurningEffect lavaEffect = new BurningEffect(20, 2, player);
}
if (Keyboard.GetState().IsKeyDown(Keys.Enter))
{
obstacles.Clear();
InitiateLevel();
}
if (perlin.Seed != Game1.seed)
{
InitiateLevel();
}
}
public void PlayerBurningEffectDoesNotExpireWhenCurrentRoundEqualsMaxRoundUnitTest()
{
Player player = new Player("test", PlayerClassType.Mage);
EffectOverTimeSettings effectOverTimeSettings = new EffectOverTimeSettings {
AmountOverTime = 20,
EffectHolder = player,
MaxRound = 3,
Name = "burning test"
};
BurningEffect burningEffect = new BurningEffect(effectOverTimeSettings);
player.Effects.Add(burningEffect);
for (int i = 0; i < effectOverTimeSettings.MaxRound - 1; i++)
{
burningEffect.ProcessRound();
}
Assert.AreEqual(3, burningEffect.CurrentRound);
Assert.AreEqual(false, burningEffect.IsEffectExpired);
}
public void MonsterBurningEffectExpiresWhenCurrentRoundGreaterThanMaxRoundUnitTest()
{
Monster monster = new Monster(5, MonsterType.Skeleton);
EffectOverTimeSettings effectOverTimeSettings = new EffectOverTimeSettings {
AmountOverTime = 20,
EffectHolder = monster,
MaxRound = 3,
Name = "burning test"
};
BurningEffect burningEffect = new BurningEffect(effectOverTimeSettings);
monster.Effects.Add(burningEffect);
for (int i = 0; i < effectOverTimeSettings.MaxRound; i++)
{
burningEffect.ProcessRound();
}
Assert.AreEqual(4, burningEffect.CurrentRound);
Assert.AreEqual(true, burningEffect.IsEffectExpired);
}
public void ProcessBurningEffectRoundMonsterUnitTest()
{
OutputHelper.Display.ClearUserOutput();
Monster monster = new Monster(5, MonsterType.Skeleton);
EffectOverTimeSettings effectOverTimeSettings = new EffectOverTimeSettings {
AmountOverTime = 20,
EffectHolder = monster,
MaxRound = 3,
Name = "burning test"
};
BurningEffect burningEffect = new BurningEffect(effectOverTimeSettings);
monster.Effects.Add(burningEffect);
string burningMessage = $"The {monster.Name} burns for {effectOverTimeSettings.AmountOverTime} fire damage.";
burningEffect.ProcessRound();
Assert.AreEqual(monster.MaxHitPoints - effectOverTimeSettings.AmountOverTime, monster.HitPoints);
Assert.AreEqual(burningMessage, OutputHelper.Display.Output[0][2]);
Assert.AreEqual(2, burningEffect.CurrentRound);
Assert.AreEqual(false, burningEffect.IsEffectExpired);
}
public void ProcessBurningEffectRoundPlayerUnitTest()
{
OutputHelper.Display.ClearUserOutput();
Player player = new Player("test", PlayerClassType.Mage);
EffectOverTimeSettings effectOverTimeSettings = new EffectOverTimeSettings {
AmountOverTime = 20,
EffectHolder = player,
MaxRound = 3,
Name = "burning test"
};
BurningEffect burningEffect = new BurningEffect(effectOverTimeSettings);
player.Effects.Add(burningEffect);
string burningMessage = $"You burn for {effectOverTimeSettings.AmountOverTime} fire damage.";
burningEffect.ProcessRound();
Assert.AreEqual(player.MaxHitPoints - effectOverTimeSettings.AmountOverTime, player.HitPoints);
Assert.AreEqual(burningMessage, OutputHelper.Display.Output[0][2]);
Assert.AreEqual(2, burningEffect.CurrentRound);
Assert.AreEqual(false, burningEffect.IsEffectExpired);
}
// Start is called before the first frame update
void Start()
{
burningeffect = GetComponent <BurningEffect>();
fireSprite = transform.GetChild(0).gameObject;
numFires = 1;
}
public void ImmolatingArrowAbilityUnitTest()
{
Player player = new Player("test", PlayerClassType.Archer)
{
MaxComboPoints = 100,
ComboPoints = 100,
MaxHitPoints = 100,
HitPoints = 10,
InCombat = true
};
GearHelper.EquipInitialGear(player);
OutputHelper.Display.ClearUserOutput();
Monster monster = new Monster(3, MonsterType.Demon)
{
HitPoints = 100, MaxHitPoints = 100, InCombat = true, FireResistance = 0
};
MonsterBuilder.BuildMonster(monster);
player.PlayerWeapon.CritMultiplier = 1; // Remove crit chance to remove "noise" in test
player.Abilities.Add(new PlayerAbility(
"immolating arrow", 35, 1, ArcherAbility.ImmolatingArrow, 8));
string[] input = new[] { "use", "immolating", "arrow" };
PlayerHelper.AbilityInfo(player, input);
Assert.AreEqual("Immolating Arrow", OutputHelper.Display.Output[0][2]);
Assert.AreEqual("Rank: 1", OutputHelper.Display.Output[1][2]);
Assert.AreEqual("Combo Cost: 35", OutputHelper.Display.Output[2][2]);
Assert.AreEqual("Instant Damage: 25", OutputHelper.Display.Output[3][2]);
Assert.AreEqual("Damage Over Time: 5", OutputHelper.Display.Output[4][2]);
Assert.AreEqual("Fire damage over time for 3 rounds.", OutputHelper.Display.Output[5][2]);
int arrowCount = player.PlayerQuiver.Quantity;
player.UseAbility(monster, input);
Assert.AreEqual(arrowCount - 1, player.PlayerQuiver.Quantity);
int index = player.Abilities.FindIndex(
f => f.ArcAbilityCategory == ArcherAbility.ImmolatingArrow);
Assert.AreEqual(player.ComboPoints, player.MaxComboPoints - player.Abilities[index].ComboCost);
string attackString = $"Your immolating arrow hit the {monster.Name} for 25 physical damage.";
Assert.AreEqual(attackString, OutputHelper.Display.Output[6][2]);
Assert.AreEqual(monster.HitPoints,
monster.MaxHitPoints - player.Abilities[index].Offensive.Amount);
OutputHelper.Display.ClearUserOutput();
Assert.AreEqual(true, monster.Effects[0] is BurningEffect);
Assert.AreEqual(3, monster.Effects[0].MaxRound);
BurningEffect burnEffect = monster.Effects[0] as BurningEffect;
for (int i = 0; i < 3; i++)
{
int baseHitPoints = monster.HitPoints;
burnEffect.ProcessRound();
Assert.AreEqual(i + 2, monster.Effects[0].CurrentRound);
Assert.AreEqual(monster.HitPoints, baseHitPoints - burnEffect.FireDamageOverTime);
string burnString = $"The {monster.Name} burns for {burnEffect.FireDamageOverTime} fire damage.";
Assert.AreEqual(burnString, OutputHelper.Display.Output[i][2]);
GameHelper.RemovedExpiredEffectsAsync(monster);
Thread.Sleep(1000);
}
Assert.AreEqual(false, monster.Effects.Any());
}
public override object Clone()
{
BurningEffect instance = (BurningEffect)base.Clone();
return(instance);
}
