public void Test_FighterCanChargeUpToThreeTimesButNotMore()
{
FighterStatsClass stats = new FighterStatsClass();
int normalAttackValue = stats.GetCurrentAttackDamage(false);
stats.UseChargeForDamageBoost(true);
int firstBoostValue = stats.GetCurrentAttackDamage(false);
stats.UseChargeForDamageBoost(true);
int secondBoostValue = stats.GetCurrentAttackDamage(false);
stats.UseChargeForDamageBoost(true);
int thirdBoostValue = stats.GetCurrentAttackDamage(false);
stats.UseChargeForDamageBoost(true);
int forthBoostValue = stats.GetCurrentAttackDamage(false);
// TODO: Rechnung irgendwie hier rausziehen?
int expectedDamage = Mathf.FloorToInt(stats.GetDefaultAttackDamage() * (1 + stats.GetMaxAmountOfChargings() * stats.GetChargeDamageBoost()));
Assert.Less(normalAttackValue, firstBoostValue, "First charge for damage boost didn't increase damage!");
Assert.Less(firstBoostValue, secondBoostValue, "Second charge for damage boost didn't increase damage!");
Assert.Less(secondBoostValue, thirdBoostValue, "Third charge for damage boost didn't increase damage!");
Assert.AreEqual(thirdBoostValue, forthBoostValue, "Forth charge for damage boost increased damage, but three boosts is the maximum!");
Assert.AreEqual(expectedDamage, thirdBoostValue, "Fighter didn't deal 3x boost damage after trying to boost 4 times");
}
public void Test_FighterSubclassesMustDeclareOwnReactToDodgeFunction()
{
FighterStatsClass stats = new FighterStatsClass();
stats.ShowDodge();
LogAssert.Expect(LogType.Error, "ShowDodge() must be implemented inside the sub-class!");
}
public void Test_FighterDiesIfHealthDropsToZero()
{
FighterStatsClass stats = new FighterStatsClass();
int killDamage = stats.GetCurrentHealth();
stats.ReceiveDamage(killDamage);
Assert.AreEqual(FighterState.dead, stats.GetCurrentFighterState(), "Fighter didn't die after health dropped to zero!");
}
public void Test_FighterCannotAttackNullPointer()
{
FighterStatsClass stats1 = new FighterStatsClass();
FighterStatsClass stats2 = null;
stats1.AttackOpponent(stats2, false, true);
LogAssert.Expect(LogType.Warning, "Fighter tried to attack an opponent that's a nnullpointer. Can't attack non-existant opponents!");
}
public void Test_FighterHealthCannotDropUnderZero()
{
const int heavyDamage = 200;
FighterStatsClass stats = new FighterStatsClass();
stats.ReceiveDamage(heavyDamage);
Assert.Zero(stats.GetCurrentHealth(), "Fighter health is not 0 after receiving massive damage!");
}
public void Test_FighterIsOnLastBreathWhileHealthBelowThreshhold()
{
FighterStatsClass stats = new FighterStatsClass();
int lastBreathDamage = Mathf.FloorToInt(stats.GetMaxHealth() - (stats.GetLastBreathThreshold() * stats.GetMaxHealth()));
stats.ReceiveDamage(lastBreathDamage);
Assert.AreEqual(FighterState.lastBreath, stats.GetCurrentFighterState(), "Fighter didn't get to last breath after his health dropped below the threshold!");
}
public void Test_FighterCanDealAttackDamage()
{
FighterStatsClass stats = new FighterStatsClass();
int dummyEnemyLife = 100;
dummyEnemyLife -= stats.GetCurrentAttackDamage();
Assert.Less(dummyEnemyLife, 100, "Enemy didn't receive any damage from fighter, no attack damage dealt!");
}
public void Test_FighterHealthCannotExceedMaxHealth()
{
FighterStatsClass stats = new FighterStatsClass();
const int heal = 20;
stats.GetHealedBy(heal);
Assert.AreEqual(stats.GetMaxHealth(), stats.GetCurrentHealth(), "Fighter health changed after healing with full health!");
Assert.LessOrEqual(stats.GetCurrentHealth(), stats.GetMaxHealth(), "Fighter health exceeds full health after healing!");
}
public void Test_FighterCannotReceiveNegativeDamage()
{
FighterStatsClass stats = new FighterStatsClass();
const int wrongDamage = -30;
stats.ReceiveDamage(wrongDamage);
LogAssert.Expect(LogType.Warning, "Fighter cannot receive negative damage. Health will not be modified.");
Assert.AreEqual(stats.GetMaxHealth(), stats.GetCurrentHealth(), "Fighter health was modified by negative damage!");
}
public void Test_FighterBeginsWithMaximumHealth()
{
// Arrange
FighterStatsClass stats = new FighterStatsClass();
// Act
// Assert
Assert.AreEqual(stats.GetMaxHealth(), stats.GetCurrentHealth(), "Fighter didn't start with maximum health!");
}
public void Test_FighterCannotDieTwice()
{
FighterStatsClass stats = new FighterStatsClass();
int killDamage = stats.GetCurrentHealth();
stats.ReceiveDamage(killDamage);
stats.ReceiveDamage(killDamage);
LogAssert.Expect(LogType.Warning, "Fighter is already dead and can no longer receive any damage!");
}
public void Test_FighterCannotAttackWithoutWaitingTurnTime()
{
FighterStatsClass stats = new FighterStatsClass();
FighterStatsClass enemy = new FighterStatsClass();
Assert.IsFalse(stats.CanAct(), "Fighter was able to attack without having to wait their turn time!");
stats.AttackOpponent(enemy, false);
LogAssert.Expect(LogType.Warning, "Tried to attack an opponent when not allowed to do that!");
}
public void Test_FighterCanBeDamaged()
{
FighterStatsClass stats = new FighterStatsClass();
const int damage = 10;
int expectedHealth = stats.GetMaxHealth() - damage;
stats.ReceiveDamage(damage);
Assert.AreNotEqual(stats.GetMaxHealth(), stats.GetCurrentHealth(), "Fighter health didn't change after being damaged!");
Assert.Less(stats.GetCurrentHealth(), stats.GetMaxHealth(), "Fighter health somehow increased after being damaged!");
Assert.AreEqual(expectedHealth, stats.GetCurrentHealth(), "Fighter health is not at the expected value after being damaged!");
}
public void Test_FighterCanRevoverFromLastBreath()
{
FighterStatsClass stats = new FighterStatsClass();
int lastBreathDamage = Mathf.FloorToInt(stats.GetMaxHealth() - (stats.GetLastBreathThreshold() * stats.GetMaxHealth()));
const int heal = 10;
stats.ReceiveDamage(lastBreathDamage);
Assert.AreEqual(FighterState.lastBreath, stats.GetCurrentFighterState(), "Fighter didn't get to last breath after his health dropped below the threshold!");
stats.GetHealedBy(heal);
Assert.AreEqual(FighterState.alive, stats.GetCurrentFighterState(), "Fighter didn't recover from last breath after his health exceeded the threshold!");
}
public void Test_AttackingAnOpponentReturnsTrueAfterLandingAHit()
{
FighterStatsClass stats1 = new FighterStatsClass();
FighterStatsClass stats2 = new FighterStatsClass();
int fullHealth = stats2.GetCurrentHealth();
bool landedHit = stats1.AttackOpponent(stats2, false, true);
int damagedHealth = stats2.GetCurrentHealth();
Assert.Less(damagedHealth, fullHealth, "Fighter wasn't able to attack another fighter and damage them!");
Assert.IsTrue(landedHit, "AttackOpponent() did not return true after landing a hit!");
}
public override bool AttackOpponent(FighterStatsClass opponent, bool CanBeDodged = true, bool ignoreTurnTime = false)
{
if (GameCtr != null)
{
if (!GameCtr.TakesPartInCurrentBattle(this))
{
Debug.LogError("Enemy that is not part of the current battle tried to attack the player!");
}
}
return(base.AttackOpponent(opponent, CanBeDodged, ignoreTurnTime));
}
public void Use(FighterStatsClass user, IGameController gameCtr = null)
{
if (usesLeft == 0)
{
Debug.LogWarning("Tried to use item when it had 0 uses left. No effect!");
return;
}
if (user == null)
{
Debug.LogWarning("Tried to use item without a user. No effect!");
return;
}
switch (type)
{
case ItemType.AttackBoost:
user.AddLastingDamageBoost("Boost Item", 1.2f);
if (gameCtr != null)
{
SoundEffectControl sfx = gameCtr.GetSFXControl();
if (sfx != null)
{
sfx.Boost();
}
}
break;
case ItemType.Healing:
user.GetHealedBy(80);
if (gameCtr != null)
{
SoundEffectControl sfx = gameCtr.GetSFXControl();
if (sfx != null)
{
sfx.Heal();
}
}
break;
case ItemType.DealDamage:
if (gameCtr != null)
{
gameCtr.PlayerThrowBomb();
}
break;
default:
Debug.LogWarning("There was no behavior specified for item of type " + type.ToString());
break;
}
usesLeft--;
}
public void Test_FighterCannotReceiveNegativeHealing()
{
FighterStatsClass stats = new FighterStatsClass();
const int damage = 30;
const int wrongHeal = -20;
int expectedHealth = stats.GetMaxHealth() - damage;
stats.ReceiveDamage(damage);
stats.GetHealedBy(wrongHeal);
LogAssert.Expect(LogType.Warning, "Fighter cannot be healed by a negative amount. Health will not be modified.");
Assert.AreEqual(expectedHealth, stats.GetCurrentHealth(), "Fighter health was modified by negative healing!");
}
public void Test_FighterCanAttackAnotherFighter()
{
FighterStatsClass stats1 = new FighterStatsClass();
FighterStatsClass stats2 = new FighterStatsClass();
int fullHealth = stats2.GetCurrentHealth();
stats1.AttackOpponent(stats2, false, true);
int damagedHealth = stats2.GetCurrentHealth();
Assert.Less(damagedHealth, fullHealth,
"Fighter wasn't able to attack another fighter and damage them!");
}
public void Test_FighterCanChargeForHeavyDamage()
{
FighterStatsClass stats = new FighterStatsClass();
int dummyEnemyLifeNormalDamage = 100;
int dummyEnemyLifeHeavyDamage = 100;
dummyEnemyLifeNormalDamage -= stats.GetCurrentAttackDamage();
stats.UseChargeForDamageBoost(true);
dummyEnemyLifeHeavyDamage -= stats.GetCurrentAttackDamage();
Assert.AreNotEqual(dummyEnemyLifeHeavyDamage, dummyEnemyLifeNormalDamage, "Heavy damage and normal attack damage are equal!");
Assert.Less(dummyEnemyLifeHeavyDamage, dummyEnemyLifeNormalDamage, "Heavy damage wasn't more that normal attack damage!");
}
public void Test_FighterGetCurrentAttackDamageCanBeDisplayedWithoutReset()
{
FighterStatsClass stats = new FighterStatsClass();
stats.UseChargeForDamageBoost(true);
int chargedValueDisplayed = stats.GetCurrentAttackDamage(false);
int chargedValueForAttack = stats.GetCurrentAttackDamage();
int resettedValue = stats.GetCurrentAttackDamage(false);
Assert.AreEqual(chargedValueDisplayed, chargedValueForAttack, "Displaying the attack damage resetted heavy damage even if it shouldn't have done that!");
Assert.Less(resettedValue, chargedValueForAttack, "Heavy damage wasn't reset after one attack!");
}
public void Test_FighterCanBeHealed()
{
FighterStatsClass stats = new FighterStatsClass();
const int damage = 30;
const int heal = 20;
int damagedHealth = stats.GetMaxHealth() - damage;
int expectedHealth = damagedHealth + heal;
stats.ReceiveDamage(damage);
stats.GetHealedBy(heal);
Assert.AreEqual(expectedHealth, stats.GetCurrentHealth(), "Fighter health is not at the expected value after healing!");
Assert.AreNotEqual(damagedHealth, stats.GetCurrentHealth(), "Fighter health didn't change after healing!");
}
public void Test_FighterCanReceiveLastingDamageBoost()
{
FighterStatsClass stats = new FighterStatsClass();
int oldDamage = stats.GetCurrentAttackDamage();
string source = "Weapon X";
float boost = 0.2f;
stats.AddLastingDamageBoost(source, boost);
int newDamage = stats.GetCurrentAttackDamage();
Assert.Less(oldDamage, newDamage, "Lasting damage boost didn't increase attack damage!");
}
public void Test_FighterCannotDodgeUnavoidableAttack()
{
FighterStatsClass stats1 = new FighterStatsClass();
FighterStatsClass stats2 = new FighterStatsClass();
stats2.DodgePropability = 1f;
int fullHealth = stats2.GetCurrentHealth();
stats1.AttackOpponent(stats2, false, true);
int afterAttack = stats2.GetCurrentHealth();
Assert.Less(afterAttack, fullHealth, "Fighter was able to dodge unavoidable attack!");
}
public void Test_FighterChargeHeavyDamageIsRemovedAfterAttack()
{
FighterStatsClass stats = new FighterStatsClass();
int dummyEnemyLifeNormalDamage1 = 100;
int dummyEnemyLifeHeavyDamage = 100;
int dummyEnemyLifeNormalDamage2 = 100;
dummyEnemyLifeNormalDamage1 -= stats.GetCurrentAttackDamage();
stats.UseChargeForDamageBoost(true);
dummyEnemyLifeHeavyDamage -= stats.GetCurrentAttackDamage();
dummyEnemyLifeNormalDamage2 -= stats.GetCurrentAttackDamage();
Assert.Less(dummyEnemyLifeHeavyDamage, dummyEnemyLifeNormalDamage2, "Heavy damage wasn't more that normal attack damage!");
Assert.AreEqual(dummyEnemyLifeNormalDamage1, dummyEnemyLifeNormalDamage2, "Heavy damage wasn't reset after one attack!");
}
public void Test_FighterCanDodgeIncomingAttack()
{
FighterStatsClass stats1 = new FighterStatsClass();
FighterStatsClass stats2 = new FighterStatsClass();
stats2.DodgePropability = 1f;
int fullHealth = stats2.GetCurrentHealth();
stats1.AttackOpponent(stats2, true, true);
int afterAttack = stats2.GetCurrentHealth();
Assert.AreEqual(fullHealth, afterAttack, "Fighter wasn't able to dodge incoming attack!");
LogAssert.Expect(LogType.Error, "ShowDodge() must be implemented inside the sub-class!");
}
public void Test_AttackingAnOpponentReturnsFalseAfterOpponentDodged()
{
FighterStatsClass stats1 = new FighterStatsClass();
FighterStatsClass stats2 = new FighterStatsClass();
stats2.DodgePropability = 1;
int fullHealth = stats2.GetCurrentHealth();
bool landedHit = stats1.AttackOpponent(stats2, true, true);
int damagedHealth = stats2.GetCurrentHealth();
LogAssert.Expect(LogType.Error, "ShowDodge() must be implemented inside the sub-class!");
Assert.AreEqual(damagedHealth, fullHealth, "Attacked opponent did not dodge as expected!");
Assert.IsFalse(landedHit, "AttackOpponent() did not return false after the opponent dodged!");
}
public void Test_FighterCanRemoveLastingDamageBoost()
{
FighterStatsClass stats = new FighterStatsClass();
int normalDamage = stats.GetCurrentAttackDamage();
string sourceA = "Item A";
float boostA = 0.2f;
stats.AddLastingDamageBoost(sourceA, boostA);
stats.RemoveLastingDamageBoost(sourceA);
int damageAfterRemoval = stats.GetCurrentAttackDamage();
Assert.IsEmpty(stats.lastingDamageBoosts.Keys, "Lasting damage boosts still contain a boost after it was removed!");
Assert.AreEqual(normalDamage, damageAfterRemoval, "Lasting damage boost couldn't be removed!");
}
public void Test_FighterCannotRemoveNonexistantLastingDamageBoost()
{
FighterStatsClass stats = new FighterStatsClass();
string sourceA = "Item A";
float boostA = 0.2f;
stats.AddLastingDamageBoost(sourceA, boostA);
int boostedDamage = stats.GetCurrentAttackDamage();
stats.RemoveLastingDamageBoost("wrongSource");
int damageAfterAttemptedRemoval = stats.GetCurrentAttackDamage();
Assert.AreEqual(boostedDamage, damageAfterAttemptedRemoval, "Attack damage was modified after trying to remove a non-existant lasting damage boost!");
Assert.IsNotEmpty(stats.lastingDamageBoosts.Keys, "Lasting damage boost of different source was removed when trying to remove one of a non-existant source!");
LogAssert.Expect(LogType.Warning, "Fighter cannot remove lasting damage boost of a source that never gave him a boost. Attacke damage will not be modified.");
}
public virtual bool AttackOpponent(FighterStatsClass opponent, bool CanBeDodged = true, bool ignoreTurnTime = false)
{
if (!CanAct() && !ignoreTurnTime)
{
Debug.LogWarning("Tried to attack an opponent when not allowed to do that!");
return(false);
}
if (!ignoreTurnTime)
{
currentTurnTime = 0;
}
if (opponent == null)
{
Debug.LogWarning("Fighter tried to attack an opponent that's a nnullpointer. Can't attack non-existant opponents!");
}
else if (opponent.GetCurrentFighterState() == FighterState.dead)
{
Debug.LogWarning("Fighter tried to attack an opponent that already died. Can't attack dead opponents!");
}
else
{
if (CanBeDodged)
{
float dodgeRand = 1;
dodgeRand = Random.value;
if (dodgeRand >= opponent.GetDodgePropability())
{
opponent.ReceiveDamage(GetCurrentAttackDamage());
return(true);
}
else
{
opponent.ShowDodge();
return(false);
}
}
else
{
opponent.ReceiveDamage(GetCurrentAttackDamage());
return(true);
}
}
return(false);
}
