public void BattleMessageModel_Get_Default_Should_Pass()
{
// Arrange
// Act
var result = new BattleMessagesModel();
// Reset
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(EntityTypeEnum.Unknown, result.PlayerType);
Assert.AreEqual(HitStatusEnum.Unknown, result.HitStatus);
Assert.AreEqual(string.Empty, result.AttackerName);
Assert.AreEqual(string.Empty, result.TargetName);
Assert.AreEqual(string.Empty, result.AttackStatus);
Assert.AreEqual(string.Empty, result.TurnMessage);
Assert.AreEqual(string.Empty, result.TurnMessageSpecial);
Assert.AreEqual(string.Empty, result.LevelUpMessage);
Assert.AreEqual(0, result.DamageAmount);
Assert.AreEqual(0, result.CurrentHealth);
Assert.AreEqual(@"<html><body bgcolor=""#E8D0B6""><p>", result.htmlHead);
Assert.AreEqual(@"</p></body></html>", result.htmlTail);
}
public void BattleMessageModel_ClearMessage_Should_Pass()
{
// Arrange
var result = new BattleMessagesModel
{
PlayerType = PlayerTypeEnum.Character,
HitStatus = HitStatusEnum.Hit,
AttackerName = "CaptainSU"
};
// Act
result.ClearMessages();
// Reset
// Assert
Assert.AreEqual(PlayerTypeEnum.Unknown, result.PlayerType);
Assert.AreEqual(HitStatusEnum.Unknown, result.HitStatus);
Assert.AreEqual(string.Empty, result.AttackerName);
Assert.AreEqual(string.Empty, result.TargetName);
Assert.AreEqual(string.Empty, result.AttackStatus);
Assert.AreEqual(string.Empty, result.TurnMessage);
Assert.AreEqual(string.Empty, result.TurnMessageSpecial);
Assert.AreEqual(string.Empty, result.LevelUpMessage);
Assert.AreEqual(0, result.DamageAmount);
Assert.AreEqual(0, result.CurrentHealth);
Assert.AreEqual(@"<html><body bgcolor=""#E8D0B6""><p>", result.htmlHead);
Assert.AreEqual(@"</p></body></html>", result.htmlTail);
}
public void BattleMessageModel_Constructor_Default_Should_Pass()
{
// Arrange
// Act
var result = new BattleMessagesModel();
// Reset
// Assert
Assert.IsNotNull(result);
}
public void BattleMessageModel_GetTurnMessage_Default_Should_Pass()
{
// Arrange
var message = new BattleMessagesModel();
// Act
var result = message.GetTurnMessage();
// Reset
// Assert
Assert.IsNotNull(result);
}
public void BattleMessageModel_GetDamageMessage_Default_Should_Pass()
{
// Arrange
var message = new BattleMessagesModel();
// Act
var result = message.GetDamageMessage();
// Reset
// Assert
Assert.AreEqual(" for 0 damage ", result);
}
/// <summary>
/// // MonsterModel Attacks CharacterModel
/// </summary>
/// <param name="Attacker"></param>
/// <param name="AttackScore"></param>
/// <param name="Target"></param>
/// <param name="DefenseScore"></param>
/// <returns></returns>
public bool TurnAsAttack(PlayerInfoModel Attacker, PlayerInfoModel Target)
{
if (Attacker == null)
{
return(false);
}
if (Target == null)
{
return(false);
}
// Set Messages to empty
ClearBattleMessages();
// Do the Attack
CalculateAttackStatus(Attacker, Target);
switch (BattleMessagesModel.HitStatus)
{
case HitStatusEnum.Miss:
// It's a Miss
break;
case HitStatusEnum.Hit:
// It's a Hit
//Calculate Damage
BattleMessagesModel.DamageAmount = Attacker.GetDamageRollValue();
// Apply the Damage
Target.TakeDamage(BattleMessagesModel.DamageAmount);
BattleMessagesModel.CurrentHealth = Target.CurrentHealth;
BattleMessagesModel.TurnMessageSpecial = BattleMessagesModel.GetCurrentHealthMessage();
// Check if Dead and Remove
RemoveIfDead(Target);
// If it is a character apply the experience earned
CalculateExperience(Attacker, Target);
break;
}
BattleMessagesModel.TurnMessage = Attacker.Name + BattleMessagesModel.AttackStatus + Target.Name + BattleMessagesModel.TurnMessageSpecial + BattleMessagesModel.ExperienceEarned;
Debug.WriteLine(BattleMessagesModel.TurnMessage);
return(true);
}
public void BattleMessageModel_GetHTMLFormattedTurnMessage_HitStatus_CriticalMiss_Should_Pass()
{
// Arrange
var message = new BattleMessagesModel();
message.HitStatus = HitStatusEnum.CriticalMiss;
// Act
var result = message.GetHTMLFormattedTurnMessage();
// Reset
// Assert
Assert.IsNotNull(result);
}
public void BattleMessageModel_GetHTMLFormattedTurnMessage_Character_Default_Should_Pass()
{
// Arrange
var message = new BattleMessagesModel();
message.PlayerType = EntityTypeEnum.Character;
// Act
var result = message.GetHTMLFormattedTurnMessage();
// Reset
// Assert
Assert.IsNotNull(result);
}
public void BattleMessageModel_ClearMessages_HitStatus_CriticalMiss_Should_Pass()
{
// Arrange
var message = new BattleMessagesModel();
message.HitStatus = HitStatusEnum.CriticalMiss;
message.PlayerType = PlayerTypeEnum.Monster;
message.AttackerName = "Minnie";
message.TargetName = "Target";
message.AttackStatus = "Attacking";
message.TurnMessage = "turn message";
message.TurnMessageSpecial = "turn message special";
message.ExperienceEarned = "experience";
message.LevelUpMessage = "level up";
message.BadCriticalMissMessage = "bad critical message";
message.DamageAmount = 10;
message.CurrentHealth = 45;
// Act
var result = message.ClearMessages();
// Reset
// Assert
Assert.IsTrue(result);
Assert.AreEqual(HitStatusEnum.Unknown, message.HitStatus);
Assert.AreEqual(PlayerTypeEnum.Unknown, message.PlayerType);
Assert.AreEqual(string.Empty, message.AttackerName);
Assert.AreEqual(string.Empty, message.TargetName);
Assert.AreEqual(string.Empty, message.AttackerName);
Assert.AreEqual(string.Empty, message.AttackStatus);
Assert.AreEqual(string.Empty, message.TurnMessage);
Assert.AreEqual(string.Empty, message.TurnMessageSpecial);
Assert.AreEqual(string.Empty, message.ExperienceEarned);
Assert.AreEqual(string.Empty, message.ExperienceEarned);
Assert.AreEqual(string.Empty, message.LevelUpMessage);
Assert.AreEqual(string.Empty, message.BadCriticalMissMessage);
Assert.AreEqual(0, message.DamageAmount);
Assert.AreEqual(0, message.CurrentHealth);
}
/// <summary>
/// // MonsterModel Attacks CharacterModel
/// </summary>
/// <param name="Attacker"></param>
/// <param name="AttackScore"></param>
/// <param name="Target"></param>
/// <param name="DefenseScore"></param>
/// <returns></returns>
public bool TurnAsAttack(PlayerInfoModel Attacker, PlayerInfoModel Target)
{
if (Attacker == null)
{
return(false);
}
if (Target == null)
{
return(false);
}
// Set Messages to empty
BattleMessagesModel.ClearMessages();
// Do the Attack
CalculateAttackStatus(Attacker, Target);
if (Attacker.PlayerType == PlayerTypeEnum.Character && Attacker.AttributesPrime())
{
BattleMessagesModel.HitStatus = HitStatusEnum.Hit;
}
// Hackathon
// Hackathon Scenario 2, Bob alwasys misses
if (Attacker.Name.Equals("Bob"))
{
BattleMessagesModel.HitStatus = HitStatusEnum.Miss;
BattleMessagesModel.TurnMessage = "Bob always Misses";
Debug.WriteLine(BattleMessagesModel.TurnMessage);
return(true);
}
switch (BattleMessagesModel.HitStatus)
{
case HitStatusEnum.Miss:
// It's a Miss
RemoveIfDead(Attacker);
break;
case HitStatusEnum.Hit:
// It's a Hit
//Calculate Damage
BattleMessagesModel.DamageAmount = Attacker.GetDamageRollValue();
if (Attacker.PlayerType == PlayerTypeEnum.Character && Attacker.AttributesPrime())
{
BattleMessagesModel.DamageAmount += Attacker.GetDamageLevelBonus;
var myItem = ItemIndexViewModel.Instance.GetItem(Attacker.PrimaryHand);
if (myItem != null)
{
// Dice of the weapon. So sword of Damage 10 is d10
BattleMessagesModel.DamageAmount += myItem.Damage;
}
Debug.WriteLine("Prime Damage Done Boyyyy");
}
if (Attacker.PlayerType == PlayerTypeEnum.Character)
{
if (Helpers.StrengthWeaknessHelper.characterStrongAgainst(Attacker.CharEnum.ToString(), Target.MonstEnum.ToString()))
{
BattleMessagesModel.DamageAmount *= 2;
}
}
else
{
if (Helpers.StrengthWeaknessHelper.monsterStrength(Target.CharEnum.ToString(), Attacker.MonstEnum.ToString()))
{
BattleMessagesModel.DamageAmount *= 2;
}
}
// Apply the Damage
ApplyDamage(Target);
BattleMessagesModel.TurnMessageSpecial = BattleMessagesModel.GetCurrentHealthMessage();
// Check if Dead and Remove
RemoveIfDead(Target);
RemoveIfDead(Attacker);
// If it is a character apply the experience earned
CalculateExperience(Attacker, Target);
break;
}
BattleMessagesModel.TurnMessage = Attacker.Name + BattleMessagesModel.AttackStatus + Target.Name + BattleMessagesModel.TurnMessageSpecial + BattleMessagesModel.ExperienceEarned;
Debug.WriteLine(BattleMessagesModel.TurnMessage);
return(true);
}
/// <summary>
/// // MonsterModel Attacks CharacterModel
/// </summary>
/// <param name="Attacker"></param>
/// <param name="AttackScore"></param>
/// <param name="Target"></param>
/// <param name="DefenseScore"></param>
/// <returns></returns>
public bool TurnAsAttack(PlayerInfoModel Attacker, PlayerInfoModel Target)
{
if (Attacker == null)
{
return(false);
}
if (Target == null)
{
return(false);
}
// Set Messages to empty
BattleMessagesModel.ClearMessages();
// Do the Attack
CalculateAttackStatus(Attacker, Target);
// Hackathon
// Hackathon Scenario 2, Bob alwasys misses
if (Attacker.Name.Equals("Bob"))
{
BattleMessagesModel.HitStatus = HitStatusEnum.Miss;
BattleMessagesModel.TurnMessage = "Bob always Misses";
Debug.WriteLine(BattleMessagesModel.TurnMessage);
return(true);
}
// See if the Battle Settings Overrides the Roll
BattleMessagesModel.HitStatus = BattleSettingsOverride(Attacker);
switch (BattleMessagesModel.HitStatus)
{
case HitStatusEnum.Miss:
// It's a Miss
break;
case HitStatusEnum.Hit:
// It's a Hit
//Calculate Damage
BattleMessagesModel.DamageAmount = Attacker.GetDamageRollValue();
// Apply the Damage
ApplyDamage(Target);
BattleMessagesModel.TurnMessageSpecial = BattleMessagesModel.GetCurrentHealthMessage();
// Check if Dead and Remove
RemoveIfDead(Target);
// If it is a character apply the experience earned
CalculateExperience(Attacker, Target);
break;
}
BattleMessagesModel.TurnMessage = Attacker.Name + BattleMessagesModel.AttackStatus + Target.Name + BattleMessagesModel.TurnMessageSpecial + BattleMessagesModel.ExperienceEarned;
Debug.WriteLine(BattleMessagesModel.TurnMessage);
return(true);
}
/// <summary>
/// Run Auto Battle
/// </summary>
/// <returns></returns>
public async Task <bool> RunAutoBattle()
{
RoundEnum RoundCondition;
Debug.WriteLine("Auto Battle Starting");
// Auto Battle, does all the steps that a human would do.
// Prepare for Battle
bool Ifeelgood = false;
var d20 = DiceHelper.RollDice(1, 20);
if (d20 < 10)
{
//Do not Use Special Ability
Ifeelgood = false;
}
CreateCharacterParty(Ifeelgood);
// Start Battle in AutoBattle mode
StartBattle(true);
// Fight Loop. Continue until Game is Over...
do
{
// Check for excessive duration.
if (DetectInfinateLoop())
{
Debug.WriteLine("Aborting, More than Max Rounds");
EndBattle();
return(false);
}
Debug.WriteLine("Next Turn");
// Do the turn...
// If the round is over start a new one...
RoundCondition = RoundNextTurn();
if (RoundCondition == RoundEnum.NewRound)
{
NewRound();
Debug.WriteLine("New Round");
//if round is 2 reincarnate any character
if (BattleScore.RoundCount == 2)
{
if (BattleScore.CharacterModelDeathList.Count > 0)
{
BattleScore.CharacterModelDeathList[0].Alive = true;
CharacterList.Add(BattleScore.CharacterModelDeathList[0]);
BattleMessagesModel.ReincarnatedCharName = BattleScore.CharacterModelDeathList[0].Name;
Debug.WriteLine(BattleMessagesModel.GetReincarnatedPlayerMessage());
WasReincarnated = true;
}
}
}
} while (RoundCondition != RoundEnum.GameOver);
Debug.WriteLine("Game Over");
// Wrap up
EndBattle();
return(true);
}
/// <summary>
/// Attack the Target this Turn
/// </summary>
/// <param name="Attacker"></param>
/// <param name="AttackScore"></param>
/// <param name="Target"></param>
/// <param name="DefenseScore"></param>
/// <returns></returns>
public bool TurnAsAttack(PlayerInfoModel Attacker, PlayerInfoModel Target)
{
if (Attacker == null)
{
return(false);
}
if (Target == null)
{
return(false);
}
BattleMessagesModel.TurnMessage = string.Empty;
BattleMessagesModel.TurnMessageSpecial = string.Empty;
BattleMessagesModel.AttackStatus = string.Empty;
BattleMessagesModel.PlayerType = PersonTypeEnum.Monster;
var AttackScore = Attacker.Level + Attacker.CurrentStrength;
var DefenseScore = Target.CurrentThiccness + Target.Level;
// Choose who to attack
BattleMessagesModel.TargetName = Target.Name;
BattleMessagesModel.AttackerName = Attacker.Name;
// Hack #47: Character Attribute equal Prime should deal Max damage
if (isTotalPrime(Attacker) == true)
{
BattleMessagesModel.HitStatus = HitStatusEnum.Hit;
}
else
{
BattleMessagesModel.HitStatus = RollToHitTarget(AttackScore, DefenseScore);
}
// Hackathon #2: Characters named Bob should miss
if (Attacker.Name.Contains("Bob"))
{
BattleMessagesModel.HitStatus = HitStatusEnum.Miss;
}
Debug.WriteLine(BattleMessagesModel.GetTurnMessage());
// It's a Miss
if (BattleMessagesModel.HitStatus == HitStatusEnum.Miss)
{
return(true);
}
// It's a Hit
if (BattleMessagesModel.HitStatus == HitStatusEnum.Hit)
{
int Damage = Attacker.CurrentStrength;
//Calculate Damage
if (Attacker.Head != null)
{
Damage = CalculateDamage(Attacker);
// Hack 47: Continued
Damage = isPrime(Attacker, Damage);
// Hackathon 43: Go SU RedHawks
//if (ItemIndexViewModel.Instance.GetItem(Attacker.ItemOne).Description == "Go SU RedHawks")
//{
// // Inflict 2x damage
// Damage = Attacker.CurrentStrength + (2 * (ItemIndexViewModel.Instance.GetItem(Attacker.ItemOne).Value));
// Debug.WriteLine("Go SU!");
//}
//else
//{
// Damage = Attacker.CurrentStrength + ItemIndexViewModel.Instance.GetItem(Attacker.ItemOne).Value;
//}
}
BattleMessagesModel.DamageAmount = Damage;
Target.TakeDamage(BattleMessagesModel.DamageAmount);
// Hackathon 25: Rebound Damage
float chance = DiceHelper.RollDice(1, 100) / 100f;
if (SettingsHelper.ReboundEnabled && chance <= SettingsHelper.REBOUND_CHANCE)
{
int ReboundDamage = (int)(Damage / 2);
// Don't allow the player to die from rebound damage, leave them with at least 1 hit point
if (Attacker.CurrentHitPoints - ReboundDamage <= 0)
{
ReboundDamage = Attacker.CurrentHitPoints - 1;
}
Debug.WriteLine("The attack rebounded! Took " + ReboundDamage + " damage!");
Attacker.TakeDamage(ReboundDamage);
}
// Hackathon 24: Rental Insurance (Break Item)
chance = DiceHelper.RollDice(1, 100) / 100f;
if (SettingsHelper.RentalInsuranceEnabled && chance <= SettingsHelper.RENTAL_INSURANCE_TEST)
{
Debug.WriteLine(Attacker.Name + "'s " + ItemIndexViewModel.Instance.GetItem(Attacker.Head).Name + " broke!");
Attacker.Head = null;
}
}
BattleMessagesModel.CurrentHealth = Target.CurrentHitPoints;
BattleMessagesModel.TurnMessageSpecial = BattleMessagesModel.GetCurrentHealthMessage();
//Check if Target is dead
RemoveIfDead(Target);
BattleMessagesModel.TurnMessage = Attacker.Name + BattleMessagesModel.AttackStatus + Target.Name + BattleMessagesModel.TurnMessageSpecial;
Debug.WriteLine(BattleMessagesModel.TurnMessage);
return(true);
}
/// <summary>
/// // MonsterModel Attacks CharacterModel
/// </summary>
/// <param name="Attacker"></param>
/// <param name="AttackScore"></param>
/// <param name="Target"></param>
/// <param name="DefenseScore"></param>
/// <returns></returns>
public bool TurnAsAttack(PlayerInfoModel Attacker, PlayerInfoModel Target, bool UseSpecialAbility)
{
if (Attacker == null)
{
return(false);
}
if (Target == null)
{
return(false);
}
BattleMessagesModel.ClearMessages();
//TODO
BattleMessagesModel.PlayerType = PlayerTypeEnum.Monster;
var AttackScore = 0;
// Choose who to attack
BattleMessagesModel.TargetName = Target.Name;
BattleMessagesModel.AttackerName = Attacker.Name;
CurrentAttacker = Attacker;
CurrentDefender = Target;
if (Attacker.PlayerType == PlayerTypeEnum.Character)
{
// bool UseSpecialAbility = RollToUseSpecialAbilityOnTarget();
if (UseSpecialAbility)
{
if (Attacker.ISSpecialAbilityNotUsed == true)
{
Debug.WriteLine(BattleMessagesModel.GetSpecialAbilityMessage());
AttackScore = Attacker.Level + Attacker.GetAttack(UseSpecialAbility);
}
}
UseSpecialAbility = false;
}
if (Attacker.PlayerType == PlayerTypeEnum.Monster)
{
AttackScore = Attacker.Level + Attacker.GetAttack();
}
// Hack #43
if (Attacker.AttackWithGoSUItem)
{
BattleMessagesModel.SpecialMessage = "Go SU!";
Debug.WriteLine(BattleMessagesModel.SpecialMessage);
}
// Hack #27
if (Attacker.BrokenItems.Count > 0)
{
BattleMessagesModel.ItemsBroken = string.Empty;
foreach (ItemModel BrokenItem in Attacker.BrokenItems)
{
BattleMessagesModel.ItemsBroken += "Item " + BrokenItem.Name + " broke" + "\n";
}
Debug.WriteLine(BattleMessagesModel.ItemsBroken);
// reset
Attacker.BrokenItems = new List <ItemModel>();
}
var DefenseScore = Target.GetDefense() + Target.Level;
// Hackathon
// Hackathon Scenario 2, Bob alwasys misses
if (Attacker.Name.Equals("Bob"))
{
BattleMessagesModel.HitStatus = HitStatusEnum.Miss;
BattleMessagesModel.TurnMessage = "Bob always Misses";
Debug.WriteLine(BattleMessagesModel.TurnMessage);
return(true);
}
// Hack #47
var AttributeSumPrimeCheck = CheckIfAttributesSumtoPrime(Attacker);
BattleMessagesModel.HitStatus = HitStatusEnum.Hit;
if (!AttributeSumPrimeCheck)
{
BattleMessagesModel.HitStatus = RollToHitTarget(AttackScore, DefenseScore);
// Player has died due to Hack #48, i.e., player roll was same as secret
if (BattleMessagesModel.HitStatus == HitStatusEnum.Unknown)
{
RemoveIfDead(Attacker);
BattleMessagesModel.SpecialMessage = "The CIA regrets to inform you that your character died.";
Debug.WriteLine(BattleMessagesModel.SpecialMessage);
return(true);
}
}
Debug.WriteLine(BattleMessagesModel.GetTurnMessage());
// It's a Miss
if (BattleMessagesModel.HitStatus == HitStatusEnum.Miss)
{
BattleMessagesModel.TurnMessage = Attacker.Name + BattleMessagesModel.AttackStatus + Target.Name + BattleMessagesModel.TurnMessageSpecial.Replace("\n", Environment.NewLine);
Debug.WriteLine(BattleMessagesModel.TurnMessage);
return(true);
}
// It's a Hit
if (BattleMessagesModel.HitStatus == HitStatusEnum.Hit)
{
//Calculate Damage
BattleMessagesModel.DamageAmount = Attacker.GetDamageRollValue(AttributeSumPrimeCheck);
//Hack #31, When Round Count exceeds 100, Monster Damage power becomes 10x
if (BattleScore.RoundCount > 100 && Attacker.PlayerType == PlayerTypeEnum.Monster)
{
BattleMessagesModel.DamageAmount *= 10;
}
Target.TakeDamage(BattleMessagesModel.DamageAmount);
}
BattleMessagesModel.CurrentHealth = Target.CurrentHealth;
BattleMessagesModel.TurnMessageSpecial = BattleMessagesModel.GetCurrentHealthMessage();
//Hack #33, Character in the turn Loose its current health when it is Round 13.
if (BattleScore.RoundCount == 13)
{
if (Attacker.PlayerType == PlayerTypeEnum.Character)
{
Attacker.CurrentHealth = 0;
}
if (Target.PlayerType == PlayerTypeEnum.Character)
{
Target.CurrentHealth = 0;
}
Debug.WriteLine("Its Lucky 13 round, so Character Loose its Health");
}
RemoveIfDead(Target);
// If it is a character apply the experience earned
CalculateExperience(Attacker, Target);
BattleMessagesModel.TurnMessage = Attacker.Name + BattleMessagesModel.AttackStatus + Target.Name + BattleMessagesModel.TurnMessageSpecial.Replace("\n", Environment.NewLine);
Debug.WriteLine(BattleMessagesModel.TurnMessage);
return(true);
}
