public async Task HackathonScenario_Scenario_9_Valid_Perfect_Items_Should_Not_Deliver()
{
/*
* Scenario Number:
* 9
*
* Description:
* 9. Just in Time Delivery
*
* Changes Required (Classes, Methods etc.) :
* Modifies EndRound() in RoundEngine.cs
*
* Test Algrorithm:
* Add one character with 8 items, all with value 20
* Run 1 round to try to have deliver
* Startup Battle
* Run Auto Battle
*
* Test Conditions:
* Number of items in ItemsViewModel
*
* Validation:
* Number of items in ItemsViewModel should not change
*/
//Arrange
// Max Character Size is 1
EngineViewModel.Engine.EngineSettings.MaxNumberPartyCharacters = 1;
// Make sure all items (except Pokeball) are delivered
EngineViewModel.Engine.EngineSettings.MaxRoundCount = 1;
// Monster always miss
EngineViewModel.Engine.EngineSettings.BattleSettingsModel.MonsterHitEnum = HitStatusEnum.Miss;
// Amazon delivers
EngineViewModel.Engine.EngineSettings.BattleSettingsModel.AllowAmazonDelivery = true;
// Add Items
var FeetItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.Feet, Attribute = AttributeEnum.Attack, Value = 20
};
var NeckItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.Necklass, Attribute = AttributeEnum.Attack, Value = 20
};
var PHandItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.PrimaryHand, Attribute = AttributeEnum.Attack, Value = 20
};
var OHandItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.OffHand, Attribute = AttributeEnum.Attack, Value = 20
};
var LFingerItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.Finger, Attribute = AttributeEnum.Attack, Value = 20
};
var RFingerItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.Finger, Attribute = AttributeEnum.Attack, Value = 20
};
var PokeballItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.Pokeball, Attribute = AttributeEnum.Attack, Value = 20
};
var HeadItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.Head, Attribute = AttributeEnum.Attack, Value = 20
};
await ItemIndexViewModel.Instance.CreateAsync(FeetItem);
await ItemIndexViewModel.Instance.CreateAsync(NeckItem);
await ItemIndexViewModel.Instance.CreateAsync(PHandItem);
await ItemIndexViewModel.Instance.CreateAsync(OHandItem);
await ItemIndexViewModel.Instance.CreateAsync(LFingerItem);
await ItemIndexViewModel.Instance.CreateAsync(RFingerItem);
await ItemIndexViewModel.Instance.CreateAsync(PokeballItem);
await ItemIndexViewModel.Instance.CreateAsync(HeadItem);
ItemIndexViewModel.Instance.SetNeedsRefresh(true);
// Add Character
var CharacterPlayer = new PlayerInfoModel(new CharacterModel
{
Speed = 10,
Level = 20,
CurrentHealth = 1000,
ExperienceTotal = 4,
ExperienceRemaining = 5,
Name = "Test",
Feet = FeetItem.Id,
Necklass = NeckItem.Id,
PrimaryHand = PHandItem.Id,
OffHand = OHandItem.Id,
LeftFinger = LFingerItem.Id,
RightFinger = RFingerItem.Id,
Pokeball = PokeballItem.Id,
Head = HeadItem.Id
});
EngineViewModel.Engine.EngineSettings.CharacterList.Add(CharacterPlayer);
EngineViewModel.Engine.EngineSettings.PlayerList.Add(CharacterPlayer);
// Dice for monster drop, set to 0 so monster does not drop items
DiceHelper.EnableForcedRolls();
DiceHelper.SetForcedRollValue(1);
//Act
var OldItemsCount = ItemIndexViewModel.Instance.Dataset.Count();
await EngineViewModel.AutoBattleEngine.RunAutoBattle();
var NewItemsCount = ItemIndexViewModel.Instance.Dataset.Count();
//Reset
EngineViewModel.Engine.EngineSettings.CharacterList.Clear();
EngineViewModel.Engine.EngineSettings.PlayerList.Clear();
EngineViewModel.Engine.EngineSettings.MaxRoundCount = 100;
EngineViewModel.Engine.EngineSettings.BattleSettingsModel.MonsterHitEnum = HitStatusEnum.Default;
DiceHelper.DisableForcedRolls();
await ItemIndexViewModel.Instance.DeleteAsync(FeetItem);
await ItemIndexViewModel.Instance.DeleteAsync(NeckItem);
await ItemIndexViewModel.Instance.DeleteAsync(PHandItem);
await ItemIndexViewModel.Instance.DeleteAsync(OHandItem);
await ItemIndexViewModel.Instance.DeleteAsync(LFingerItem);
await ItemIndexViewModel.Instance.DeleteAsync(RFingerItem);
await ItemIndexViewModel.Instance.DeleteAsync(PokeballItem);
await ItemIndexViewModel.Instance.DeleteAsync(HeadItem);
EngineViewModel.Engine.EngineSettings.BattleSettingsModel.AllowAmazonDelivery = false;
//Assert
Assert.AreEqual(NewItemsCount, OldItemsCount);
}
public static void WinnerMessage(PlayerInfoModel winner)
{
Console.WriteLine();
Console.WriteLine($" {winner.PlayerName}, you win the game! You are a true captain!");
}
public static void ShowShipsNumber(PlayerInfoModel player, PlayerInfoModel opponent)
{
Console.WriteLine($" Your remaining ships: {GameLogic.RemainingShips(player)} ");
Console.WriteLine($" {opponent.PlayerName} remaining ships: {GameLogic.RemainingShips(opponent)} ");
}
/// <summary>
/// Decide which to attack
/// </summary>
public override PlayerInfoModel AttackChoice(PlayerInfoModel data)
{
return(base.AttackChoice(data));
}
/// <summary>
/// Return a stack layout with the Player information inside
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public StackLayout CreatePlayerDisplayBox(PlayerInfoModel data)
{
if (data == null)
{
data = new PlayerInfoModel();
}
// Hookup the image
var PlayerImage = new Image
{
Style = (Style)Application.Current.Resources["ImageBattleLargeStyle"],
Source = data.ImageURI
};
// Add the Level
var PlayerLevelLabel = new Label
{
Text = "Level : " + data.Level,
Style = (Style)Application.Current.Resources["ValueStyleMicro"],
HorizontalOptions = LayoutOptions.Center,
HorizontalTextAlignment = TextAlignment.Center,
Padding = 0,
LineBreakMode = LineBreakMode.TailTruncation,
CharacterSpacing = 0,
LineHeight = 1,
MaxLines = 1,
};
// Add the HP
var PlayerHPLabel = new Label
{
Text = "HP : " + data.GetCurrentHealthTotal,
Style = (Style)Application.Current.Resources["ValueStyleMicro"],
HorizontalOptions = LayoutOptions.Center,
HorizontalTextAlignment = TextAlignment.Center,
Padding = 0,
LineBreakMode = LineBreakMode.TailTruncation,
CharacterSpacing = 0,
LineHeight = 1,
MaxLines = 1,
};
// Add the Name
var PlayerNameLabel = new Label()
{
Text = data.Name,
Style = (Style)Application.Current.Resources["ValueStyle"],
HorizontalOptions = LayoutOptions.Center,
HorizontalTextAlignment = TextAlignment.Center,
Padding = 0,
CharacterSpacing = 0,
LineHeight = 1,
MaxLines = 1,
};
// Add the character job or monster type
var PlayerTypeLabel = new Label()
{
Text = (data.PlayerType == PlayerTypeEnum.Character) ? data.Job.ToMessage() : data.MonsterType.ToMessage(),
Style = (Style)Application.Current.Resources["ValueStyle"],
HorizontalOptions = LayoutOptions.Center,
HorizontalTextAlignment = TextAlignment.Center,
Padding = 0,
CharacterSpacing = 0,
LineHeight = 1,
MaxLines = 1,
};
// Put the Image Button and Text inside a layout
var PlayerStack = new StackLayout
{
Style = (Style)Application.Current.Resources["PlayerInfoBox"],
HorizontalOptions = LayoutOptions.Center,
Padding = 0,
Spacing = 0,
Margin = 5,
Children =
{
PlayerImage,
PlayerNameLabel,
PlayerTypeLabel,
PlayerLevelLabel,
PlayerHPLabel,
},
};
return(PlayerStack);
}
/// <summary>
/// Calculate Experience
/// Level up if needed
/// </summary>
public override bool CalculateExperience(PlayerInfoModel Attacker, PlayerInfoModel Target)
{
return(base.CalculateExperience(Attacker, Target));
}
/// <summary>
/// Use the Ability
/// </summary>
public override bool UseAbility(PlayerInfoModel Attacker)
{
return(base.UseAbility(Attacker));
}
/// <summary>
/// Slip as your turn decreases the attacker's current health by two points.
/// </summary>
/// <param name="Attacker"></param>
/// <returns></returns>
public virtual bool SlipAsTurn(PlayerInfoModel Attacker)
{
Attacker.CurrentHealth -= 2;
Attacker.SlippedNumTimes++;
return(true);
}
/// <summary>
/// Use the Ability
/// </summary>
/// <param name="Attacker"></param>
/// <returns></returns>
public virtual bool UseAbility(PlayerInfoModel Attacker)
{
EngineSettings.BattleMessagesModel.TurnMessage = Attacker.Name + " Uses Ability " + EngineSettings.CurrentActionAbility.ToMessage();
return(Attacker.UseAbility(EngineSettings.CurrentActionAbility));
}
// Handling clicked action on the image button for characters
public void OnImageButtonClicked(object sender, EventArgs e)
{
if (BattleEngineViewModel.Instance.Engine.EngineSettings.BattleStateEnum != BattleStateEnum.ChooseDefender)
{
return;
}
ImageButton img = sender as ImageButton;
PlayerInfoModel selected = img.BindingContext as PlayerInfoModel;
if (selected == null)
{
return;
}
BattleEngineViewModel.Instance.Engine.Round.SetCurrentDefender(selected);
var RoundCondition = ((Game.Engine.EngineGame.RoundEngine)BattleEngineViewModel.Instance.Engine.Round).RoundNextTurn(AttackTypeValue);
// Output the Message of what happened.
GameMessage();
// Show the outcome on the Board
DrawGameAttackerDefenderBoard();
if (RoundCondition == RoundEnum.NewRound)
{
BattleEngineViewModel.Instance.Engine.EngineSettings.BattleStateEnum = BattleStateEnum.NewRound;
// Pause
Task.Delay(WaitTime);
Debug.WriteLine("New Round");
Turncounter = 0;
Turn.Text = "Turn " + Turncounter.ToString();
// Show the Round Over, after that is cleared, it will show the New Round Dialog
ShowModalRoundOverPage();
return;
}
// Check for Game Over
if (RoundCondition == RoundEnum.GameOver)
{
BattleEngineViewModel.Instance.Engine.EngineSettings.BattleStateEnum = BattleStateEnum.GameOver;
// Wrap up
BattleEngineViewModel.Instance.Engine.EndBattle();
// Pause
Task.Delay(WaitTime);
Debug.WriteLine("Game Over");
GameOver();
return;
}
BattleEngineViewModel.Instance.Engine.EngineSettings.BattleStateEnum = BattleStateEnum.Battling;
HideUIElements();
ShowBattleModeUIElements();
}
/// <summary>
/// Rest as your turn increases the attacker's current health by two points.
/// </summary>
/// <param name="Attacker"></param>
/// <returns></returns>
public virtual bool RestAsTurn(PlayerInfoModel Attacker)
{
Attacker.CurrentHealth += 2;
Attacker.FiveMinuteBreaks++;
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>
/// Decide where to move
/// </summary>
/// <param name="Person"></param>
/// <returns></returns>
public int[,] MoveChoice(PlayerInfoModel Person)
{
int[,] location = new int[1, 1];
return(location);
}
/// <summary>
/// Move as a Turn
/// </summary>
/// <param name="Person"></param>
/// <returns></returns>
public bool Move(PlayerInfoModel Person)
{
var Target = MoveChoice(Person);
return(true);
}
/// <summary>
/// Apply the Damage to the Target
/// </summary>
public override int ApplyDamage(PlayerInfoModel Target)
{
return(base.ApplyDamage(Target));
}
/// <summary>
/// CharacterModel Attacks...
/// </summary>
/// <param name="Attacker"></param>
/// <returns></returns>
public virtual bool TakeTurn(PlayerInfoModel Attacker)
{
// Choose Action. Such as Move, Attack etc.
// INFO: Teams, if you have other actions they would go here.
bool result = false;
// If the action is not set, then try to set it or use Attact
if (EngineSettings.CurrentAction == ActionEnum.Unknown)
{
// Set the action if one is not set
EngineSettings.CurrentAction = DetermineActionChoice(Attacker);
// When in doubt, attack...
if (EngineSettings.CurrentAction == ActionEnum.Unknown)
{
EngineSettings.CurrentAction = ActionEnum.Attack;
}
}
// Check to see if hackathon scenarios should be enabled.
if (BattleEngineViewModel.Instance.Engine.EngineSettings.HackathonDebug && Attacker.WantsToRest)
{
var num = DiceHelper.RollDice(1, 2);
// Randomize whether character will keep its current action or rest as its move.
if (num % 2 == 0)
{
EngineSettings.CurrentAction = ActionEnum.Rest;
}
}
// Check to see if hackathon scenarios should be enabled.
if (BattleEngineViewModel.Instance.Engine.EngineSettings.HackathonDebug && BattleEngineViewModel.Instance.Engine.EngineSettings.SeattleWinter && Attacker.PlayerType == PlayerTypeEnum.Character)
{
var randomInt = DiceHelper.RollDice(1, 100);
var percentage = BattleEngineViewModel.Instance.Engine.EngineSettings.SeattleWinterLikelihood;
// Randomize whether character will keep its current action or rest as its move.
if (randomInt <= percentage)
{
EngineSettings.CurrentAction = ActionEnum.Slip;
}
}
switch (EngineSettings.CurrentAction)
{
case ActionEnum.Attack:
result = Attack(Attacker);
break;
case ActionEnum.Ability:
result = UseAbility(Attacker);
break;
case ActionEnum.Move:
result = MoveAsTurn(Attacker);
break;
case ActionEnum.Rest:
result = RestAsTurn(Attacker);
break;
case ActionEnum.Slip:
result = SlipAsTurn(Attacker);
break;
case ActionEnum.SpecialAbility:
result = UseSpecialAbility(Attacker);
break;
}
EngineSettings.BattleScore.TurnCount++;
// Save the Previous Action off
EngineSettings.PreviousAction = EngineSettings.CurrentAction;
// Reset the Action to unknown for next time
EngineSettings.CurrentAction = ActionEnum.Unknown;
return(result);
}
/// <summary>
/// Calculate the Attack, return if it hit or missed.
/// </summary>
public override HitStatusEnum CalculateAttackStatus(PlayerInfoModel Attacker, PlayerInfoModel Target)
{
return(base.CalculateAttackStatus(Attacker, Target));
}
/// <summary>
/// Critical Miss Problem
/// </summary>
/// <param name="attacker"></param>
/// <returns></returns>
public virtual bool DetermineCriticalMissProblem(PlayerInfoModel attacker)
{
return(true);
}
/// <summary>
/// If Dead process Target Died
/// </summary>
public override bool RemoveIfDead(PlayerInfoModel Target)
{
return(base.RemoveIfDead(Target));
}
private static void IdentifyWinner(PlayerInfoModel winner)
{
Console.WriteLine($"Congratulations {winner.UserName} you WIN!");
Console.WriteLine($"{winner.UserName} took {GameLogic.GetShotCount(winner)} shots.");
}
/// <summary>
/// Attack as a Turn
///
/// Pick who to go after
///
/// Determine Attack Score
/// Determine DefenseScore
///
/// Do the Attack
///
/// </summary>
public override bool Attack(PlayerInfoModel Attacker)
{
return(base.Attack(Attacker));
}
/// <summary>
/// // MonsterModel Attacks CharacterModel
/// </summary>
public override bool TurnAsAttack(PlayerInfoModel Attacker, PlayerInfoModel Target)
{
if (Attacker == null)
{
return(false);
}
if (Target == null)
{
return(false);
}
// Set Messages to empty
EngineSettings.BattleMessagesModel.ClearMessages();
// Do the Attack
CalculateAttackStatus(Attacker, Target);
// See if the Battle Settings Overrides the Roll
EngineSettings.BattleMessagesModel.HitStatus = BattleSettingsOverride(Attacker);
switch (EngineSettings.BattleMessagesModel.HitStatus)
{
case HitStatusEnum.Miss:
// It's a Miss
break;
case HitStatusEnum.CriticalMiss:
// It's a Critical Miss, so Bad things may happen
DetermineCriticalMissProblem(Attacker);
break;
case HitStatusEnum.CriticalHit:
case HitStatusEnum.Hit:
// It's a Hit
//Calculate Damage
EngineSettings.BattleMessagesModel.DamageAmount = Attacker.GetDamageRollValue();
// If critical Hit, double the damage
if (EngineSettings.BattleMessagesModel.HitStatus == HitStatusEnum.CriticalHit)
{
EngineSettings.BattleMessagesModel.DamageAmount *= 2;
}
// Apply the Damage
ApplyDamage(Target);
EngineSettings.BattleMessagesModel.TurnMessageSpecial = EngineSettings.BattleMessagesModel.GetCurrentHealthMessage();
// Check if Dead and Remove
RemoveIfDead(Target);
// If it is a character apply the experience earned
CalculateExperience(Attacker, Target);
break;
}
EngineSettings.BattleMessagesModel.TurnMessage = Attacker.Name + EngineSettings.BattleMessagesModel.AttackStatus + Target.Name + EngineSettings.BattleMessagesModel.TurnMessageSpecial + EngineSettings.BattleMessagesModel.ExperienceEarned;
Debug.WriteLine(EngineSettings.BattleMessagesModel.TurnMessage);
return(true);
}
public async Task HackathonScenario_Scenario_1_Valid_Default_Should_Pass()
{
/*
* Scenario Number:
* 1
*
* Description:
* Make a Character called Mike, who dies in the first round
*
* Changes Required (Classes, Methods etc.) List Files, Methods, and Describe Changes:
* No Code changes requied
*
* Test Algrorithm:
* Create Character named Mike
* Set speed to -1 so he is really slow
* Set Max health to 1 so he is weak
* Set Current Health to 1 so he is weak
*
* Startup Battle
* Run Auto Battle
*
* Test Conditions:
* Default condition is sufficient
*
* Validation:
* Verify Battle Returned True
* Verify Mike is not in the Player List
* Verify Round Count is 1
*
*/
//Arrange
// Set Character Conditions
EngineViewModel.Engine.EngineSettings.MaxNumberPartyCharacters = 1;
var CharacterPlayerMike = new PlayerInfoModel(
new CharacterModel
{
Speed = -1, // Will go last...
Level = 1,
CurrentHealth = 1,
ExperienceTotal = 1,
ExperienceRemaining = 1,
Name = "Mike",
});
EngineViewModel.Engine.EngineSettings.CharacterList.Add(CharacterPlayerMike);
// Set Monster Conditions
// Auto Battle will add the monsters
// Monsters always hit
EngineViewModel.Engine.EngineSettings.BattleSettingsModel.MonsterHitEnum = HitStatusEnum.Hit;
//Act
var result = await EngineViewModel.AutoBattleEngine.RunAutoBattle();
//Reset
EngineViewModel.Engine.EngineSettings.BattleSettingsModel.MonsterHitEnum = HitStatusEnum.Default;
//Assert
Assert.AreEqual(true, result);
Assert.AreEqual(null, EngineViewModel.Engine.EngineSettings.PlayerList.Find(m => m.Name.Equals("Mike")));
Assert.AreEqual(1, EngineViewModel.Engine.EngineSettings.BattleScore.RoundCount);
}
/// <summary>
/// Determine what Actions to do
/// </summary>
/// <param name="Attacker"></param>
/// <returns></returns>
public override ActionEnum DetermineActionChoice(PlayerInfoModel Attacker)
{
return(base.DetermineActionChoice(Attacker));
}
public static void PostionMessage(PlayerInfoModel player)
{
Console.WriteLine();
Console.WriteLine($" {player.PlayerName}, it's your turn to position your ships.");
Console.WriteLine();
}
/// <summary>
/// Critical Miss Problem
/// </summary>
public override bool DetermineCriticalMissProblem(PlayerInfoModel attacker)
{
return(base.DetermineCriticalMissProblem(attacker));
}
internal static void DisplayPlayerName(PlayerInfoModel player)
{
Console.WriteLine();
Console.WriteLine($" CAPTAIN {player.PlayerName.ToUpper()}");
}
/// <summary>
/// See if the Battle Settings will Override the Hit
/// Return the Override for the HitStatus
/// </summary>
public override HitStatusEnum BattleSettingsOverride(PlayerInfoModel Attacker)
{
return(base.BattleSettingsOverride(Attacker));
}
public void RoundEngine_GetNextPlayerInList_Valid_Sue_Should_Return_Monster()
{
Engine.EngineSettings.MonsterList.Clear();
// Arrange
var CharacterPlayerMike = new PlayerInfoModel(
new CharacterModel
{
Speed = 200,
Level = 1,
CurrentHealth = 1,
ExperienceTotal = 1,
Name = "Mike",
ListOrder = 1,
});
var CharacterPlayerDoug = new PlayerInfoModel(
new CharacterModel
{
Speed = 20,
Level = 1,
CurrentHealth = 1,
ExperienceTotal = 1,
Name = "Doug",
ListOrder = 2,
});
var CharacterPlayerSue = new PlayerInfoModel(
new CharacterModel
{
Speed = 2,
Level = 1,
CurrentHealth = 1,
ExperienceTotal = 1,
Name = "Sue",
ListOrder = 3,
});
var MonsterPlayer = new PlayerInfoModel(
new MonsterModel
{
Speed = 1,
Level = 1,
CurrentHealth = 1,
ExperienceTotal = 1,
Name = "Monster",
ListOrder = 4,
});
// Add each model here to warm up and load it.
Game.Helpers.DataSetsHelper.WarmUp();
Engine.EngineSettings.CharacterList.Clear();
Engine.EngineSettings.CharacterList.Add(CharacterPlayerMike);
Engine.EngineSettings.CharacterList.Add(CharacterPlayerDoug);
Engine.EngineSettings.CharacterList.Add(CharacterPlayerSue);
Engine.EngineSettings.MonsterList.Clear();
Engine.EngineSettings.MonsterList.Add(MonsterPlayer);
// Make the List
Engine.EngineSettings.PlayerList = Engine.Round.MakePlayerList();
// Set Sue as the Player
Engine.EngineSettings.CurrentAttacker = CharacterPlayerSue;
// Act
var result = Engine.Round.GetNextPlayerInList();
// Reset
// Assert
Assert.AreEqual("Monster", result.Name);
}
public async Task HackathonScenario_Scenario_9_Valid_Bad_Primary_Hand_Should_Improved()
{
/*
* Scenario Number:
* 9
*
* Description:
* 9. Just in Time Delivery
*
* Changes Required (Classes, Methods etc.) :
* Modifies EndRound() in RoundEngine.cs
*
* Test Algrorithm:
* Add one character with 8 items, all with value 20 except for Primary hand, which is 19
* Run 1 round to make sure better primary hand delivers
* Startup Battle
* Run Auto Battle
*
* Test Conditions:
* Value of Primary Hand Item the test character
*
* Validation:
* Test character should have primary hand with value 20
*/
//Arrange
// Max Character Size is 1
EngineViewModel.Engine.EngineSettings.MaxNumberPartyCharacters = 1;
// Make sure all items (except Pokeball) are delivered
EngineViewModel.Engine.EngineSettings.MaxRoundCount = 1;
// Monster always miss
EngineViewModel.Engine.EngineSettings.BattleSettingsModel.MonsterHitEnum = HitStatusEnum.Miss;
// Amazon delivers
EngineViewModel.Engine.EngineSettings.BattleSettingsModel.AllowAmazonDelivery = true;
// Add Items
var FeetItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.Feet, Attribute = AttributeEnum.Attack, Value = 20
};
var NeckItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.Necklass, Attribute = AttributeEnum.Attack, Value = 20
};
var PHandItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.PrimaryHand, Attribute = AttributeEnum.Attack, Value = 19
};
var OHandItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.OffHand, Attribute = AttributeEnum.Attack, Value = 20
};
var LFingerItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.Finger, Attribute = AttributeEnum.Attack, Value = 20
};
var RFingerItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.Finger, Attribute = AttributeEnum.Attack, Value = 20
};
var PokeballItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.Pokeball, Attribute = AttributeEnum.Attack, Value = 20
};
var HeadItem = new ItemModel {
Name = "Test", Location = ItemLocationEnum.Head, Attribute = AttributeEnum.Attack, Value = 20
};
await ItemIndexViewModel.Instance.CreateAsync(FeetItem);
await ItemIndexViewModel.Instance.CreateAsync(NeckItem);
await ItemIndexViewModel.Instance.CreateAsync(PHandItem);
await ItemIndexViewModel.Instance.CreateAsync(OHandItem);
await ItemIndexViewModel.Instance.CreateAsync(LFingerItem);
await ItemIndexViewModel.Instance.CreateAsync(RFingerItem);
await ItemIndexViewModel.Instance.CreateAsync(PokeballItem);
await ItemIndexViewModel.Instance.CreateAsync(HeadItem);
ItemIndexViewModel.Instance.SetNeedsRefresh(true);
// Add Character
var CharacterPlayer = new PlayerInfoModel(new CharacterModel
{
Speed = 10,
Level = 20,
CurrentHealth = 1000,
ExperienceTotal = 4,
ExperienceRemaining = 5,
Name = "Test",
Feet = FeetItem.Id,
Necklass = NeckItem.Id,
PrimaryHand = PHandItem.Id,
OffHand = OHandItem.Id,
LeftFinger = LFingerItem.Id,
RightFinger = RFingerItem.Id,
Pokeball = PokeballItem.Id,
Head = HeadItem.Id
});
EngineViewModel.Engine.EngineSettings.CharacterList.Add(CharacterPlayer);
EngineViewModel.Engine.EngineSettings.PlayerList.Add(CharacterPlayer);
//Act
await EngineViewModel.AutoBattleEngine.RunAutoBattle();
var NewPrimaryHandItem = EngineViewModel.Engine.EngineSettings.PlayerList.Where(m => m.Name == "Test").FirstOrDefault().DropAllItems().Where(m => m.Location == ItemLocationEnum.PrimaryHand).FirstOrDefault();
//Reset
EngineViewModel.Engine.EngineSettings.CharacterList.Clear();
EngineViewModel.Engine.EngineSettings.PlayerList.Clear();
EngineViewModel.Engine.EngineSettings.MaxRoundCount = 100;
EngineViewModel.Engine.EngineSettings.BattleSettingsModel.MonsterHitEnum = HitStatusEnum.Default;
await ItemIndexViewModel.Instance.DeleteAsync(FeetItem);
await ItemIndexViewModel.Instance.DeleteAsync(NeckItem);
await ItemIndexViewModel.Instance.DeleteAsync(PHandItem);
await ItemIndexViewModel.Instance.DeleteAsync(OHandItem);
await ItemIndexViewModel.Instance.DeleteAsync(LFingerItem);
await ItemIndexViewModel.Instance.DeleteAsync(RFingerItem);
await ItemIndexViewModel.Instance.DeleteAsync(PokeballItem);
await ItemIndexViewModel.Instance.DeleteAsync(HeadItem);
await ItemIndexViewModel.Instance.DeleteAsync(NewPrimaryHandItem);
EngineViewModel.Engine.EngineSettings.BattleSettingsModel.AllowAmazonDelivery = false;
//Assert
Assert.AreEqual(NewPrimaryHandItem.Value, 20);
}
