private bool IsPrime(EntityInfoModel Attacker)
{
int number = Attacker.GetAttackTotal + Attacker.GetDefenseTotal + Attacker.GetMaxHealthTotal + Attacker.GetSpeedTotal;
if (number <= 1)
{
return(false);
}
if (number == 2)
{
return(true);
}
if (number % 2 == 0)
{
return(false);
}
var boundary = (int)Math.Floor(Math.Sqrt(number));
for (int i = 3; i <= boundary; i += 2)
{
if (number % i == 0)
{
return(false);
}
}
return(true);
}
public int CharacterDropItem(EntityInfoModel Target)
{
var DroppedMessage = "\nItems Dropped : \n";
// Drop Items to ItemModel Pool
var myItemList = Target.DropAllItems();
// Add to ScoreModel
foreach (var ItemModel in myItemList)
{
BattleScore.ItemsDroppedList += ItemModel.FormatOutput() + "\n";
DroppedMessage += ItemModel.Name + "\n";
}
ItemPool.AddRange(myItemList);
if (myItemList.Count == 0)
{
DroppedMessage = " Nothing dropped. ";
}
BattleMessageModel.DroppedMessage = DroppedMessage;
BattleScore.ItemModelDropList.AddRange(myItemList);
return(myItemList.Count());
}
//Sleeping Turn for Hackthon Scenario 7
public bool FallAsleep(EntityInfoModel Attacker)
{
Debug.WriteLine(string.Format(Attacker.Name, " is sleeping"));
BattleMessageModel.ClearMessages();
BattleMessageModel.TurnMessage = Attacker.Name + " is sleeping";
return(true);
}
/// <summary>
/// Use the Ability
/// </summary>
/// <param name="Attacker"></param>
/// <returns></returns>
public bool UseAbility(EntityInfoModel Attacker)
{
BattleMessageModel.ClearMessages();
BattleMessageModel.TurnMessageSpecial = " Used Ability";
BattleMessageModel.TurnMessage = Attacker.Name + BattleMessageModel.TurnMessageSpecial;
Debug.WriteLine(BattleMessageModel.TurnMessage);
return(true);
}
/// <summary>
/// If Dead process Target Died
/// </summary>
/// <param name="Target"></param>
public bool RemoveIfDead(EntityInfoModel Target)
{
//Check if dead
if (Target.Alive == false)
{
TargetDied(Target);
return(true);
}
return(false);
}
/// <summary>
/// Decide which to attack
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public EntityInfoModel AttackChoice(EntityInfoModel data)
{
switch (data.PlayerType)
{
case PlayerTypeEnum.Monster:
return(SelectCharacterToAttack());
case PlayerTypeEnum.Character:
default:
return(SelectMonsterToAttack());
}
}
/// <summary>
/// Update defender info on the page
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void UpdateDefender(EntityInfoModel player)
{
if (player == null)
{
DefenderImage.Source = "question_mark.png";
DefenderLabel.Text = "";
return;
}
var defender = EngineViewModel.Engine.CurrentDefender;
DefenderImage.Source = defender.ImageURI;
DefenderLabel.Text = defender.GetCurrentHealthTotal.ToString() + " / " + defender.GetMaxHealthTotal.ToString();
}
/// <summary>
/// Update attacker info on the page
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public void UpdateAttacker(EntityInfoModel player)
{
if (player == null)
{
AttackerImage.Source = "question_mark.png";
AttackerLabel.Text = "";
return;
}
var attacker = EngineViewModel.Engine.CurrentAttacker;
AttackerImage.Source = attacker.ImageURI;
AttackerLabel.Text = attacker.GetCurrentHealthTotal.ToString() + " / " + attacker.GetMaxHealthTotal.ToString();
}
public async Task AutoBattleEngine_RunAutoBattle_Character_Level_Up_Should_Pass()
{
/*
* Test to force leveling up of a character during the battle
*
* 1 Character, Experience set at next level mark
*
* 6 Monsters
*
* Character Should Level UP 1 level
*
*/
//Arrange
// Add Characters
Engine.MaxNumberPartyCharacters = 1;
CharacterIndexViewModel.Instance.Dataset.Clear();
// To See Level UP happening, a character needs to be close to the next level
var Character = new CharacterModel
{
Experience = 300, // Enough for next level
Name = "Mike Level Example",
Speed = 100, // Go first
};
// Remember Start Level
var StartLevel = Character.Level;
var CharacterPlayer = new EntityInfoModel(Character);
Engine.CharacterList.Add(CharacterPlayer);
// Add Monsters
//Act
var result = await Engine.RunAutoBattle();
//Reset
//Assert
Assert.AreEqual(true, result);
Assert.AreEqual(true, Engine.BattleScore.CharacterAtDeathList.Contains("Mike Level Example"));
// Assert.AreEqual(StartLevel+1, Engine.BattleScore.CharacterModelDeathList.Where(m=>m.Guid.Equals(Character.Guid)).First().Level);
}
/// <summary>
/// Roll dice to determine if the unique Item Drop
/// </summary>
/// <param name="round"></param>
/// <returns></returns>
public bool IsUniqueDrop(EntityInfoModel Target)
{
if (Target.PlayerType == PlayerTypeEnum.Character)
{
return(false);
}
int rate = (int)(10 * Target.DropRate);
int dice = DiceHelper.RollDice(1, 10);
if (dice > rate)
{
return(false);
}
return(true);
}
/// <summary>
/// Pickup Items Dropped
/// </summary>
/// <param name="character"></param>
public bool PickupItemsFromPool(EntityInfoModel character)
{
{
// Have the character, walk the items in the pool, and decide if any are better than current one.
GetItemFromPoolIfBetter(character, ItemLocationEnum.Head);
GetItemFromPoolIfBetter(character, ItemLocationEnum.Necklass);
GetItemFromPoolIfBetter(character, ItemLocationEnum.PrimaryHand);
GetItemFromPoolIfBetter(character, ItemLocationEnum.OffHand);
GetItemFromPoolIfBetter(character, ItemLocationEnum.RightFinger);
GetItemFromPoolIfBetter(character, ItemLocationEnum.LeftFinger);
GetItemFromPoolIfBetter(character, ItemLocationEnum.Feet);
}
return(true);
}
/// <summary>
/// Drop Item
/// </summary>
/// <param name="Target"></param>
/// <returns></returns>
public int DropItems(EntityInfoModel Target)
{
// Depends on Target Player Type,
// It will generate different Drop Methods
var result = 0;
if (Target.PlayerType == PlayerTypeEnum.Character)
{
result = CharacterDropItem(Target);
}
if (Target.PlayerType == PlayerTypeEnum.Monster)
{
result = MonsterDropItem(Target);
}
return(result);
}
/// <summary>
/// Update PlayerList after Character was attacked. Because it didn't update the Character stored in PlayerList
/// </summary>
/// <param name="Target"></param>
private void UpdatePlayerList(EntityInfoModel Target)
{
for (int i = 0; i < PlayerList.Count; i++)
{
if (PlayerList[i].PlayerType == PlayerTypeEnum.Character)
{
if (PlayerList[i].Guid == Target.Guid)
{
PlayerList[i].CurrentHealth = Target.CurrentHealth;
if (PlayerList[i].Level != Target.Level)
{
PlayerList[i].LevelUpToValue(Target.Level);
}
}
}
}
}
/// </summary>
/// <param name="Attacker"></param>
/// <returns></returns>
public bool Attack(EntityInfoModel Attacker)
{
if (BattleScore.AutoBattle)
{
// For attack, choose who
CurrentDefender = AttackChoice(Attacker);
if (CurrentDefender == null)
{
return(false);
}
}
TurnAsAttack(Attacker, CurrentDefender);
return(true);
}
/// <summary>
/// Target Died
///
/// Process for death...
///
/// Returns the count of items dropped at death
/// </summary>
/// <param name="Target"></param>
public bool TargetDied(EntityInfoModel Target)
{
bool found;
// Mark Status in output
BattleMessageModel.TurnMessageSpecial = " and causes death. ";
// Removing the
MapModel.RemovePlayerFromMap(Target);
// INFO: Teams, Hookup your Boss if you have one...
// Using a switch so in the future additional PlayerTypes can be added (Boss...)
switch (Target.PlayerType)
{
case PlayerTypeEnum.Character:
// Add the Character to the killed list
BattleScore.CharacterAtDeathList += Target.FormatOutput() + "\n";
BattleScore.CharacterModelDeathList.Add(Target);
DropItems(Target);
found = CharacterList.Remove(CharacterList.Find(m => m.Guid.Equals(Target.Guid)));
found = PlayerList.Remove(PlayerList.Find(m => m.Guid.Equals(Target.Guid)));
return(true);
case PlayerTypeEnum.Monster:
default:
// Add one to the monsters killed count...
BattleScore.MonsterSlainNumber++;
// Add the MonsterModel to the killed list
BattleScore.MonstersKilledList += Target.FormatOutput() + "\n";
BattleScore.MonsterModelDeathList.Add(Target);
DropItems(Target);
found = MonsterList.Remove(MonsterList.Find(m => m.Guid.Equals(Target.Guid)));
found = PlayerList.Remove(PlayerList.Find(m => m.Guid.Equals(Target.Guid)));
return(true);
}
}
public async Task AutoBattleEngine_RunAutoBattle_GameOver_Round_1_Should_Pass()
{
/*
*
* 1 Character, Speed slowest, only 1 HP
*
* 6 Monsters
*
* Should end in the first round
*
*/
//Arrange
// Add Characters
Engine.MaxNumberPartyCharacters = 1;
var CharacterPlayer = new EntityInfoModel(
new CharacterModel
{
Speed = -1, // Will go last...
Level = 10,
CurrentHealth = 1,
Experience = 1,
ExperienceRemaining = 1,
ListOrder = 1,
});
Engine.CharacterList.Add(CharacterPlayer);
// Add Monsters
Engine.MaxNumberPartyMonsters = 6;
//Act
var result = await Engine.RunAutoBattle();
//Reset
//Assert
Assert.AreEqual(true, result);
}
/// <summary>
/// Monster Drop Item
/// </summary>
/// <param name="Target"></param>
/// <returns></returns>
public int MonsterDropItem(EntityInfoModel Target)
{
// Monster will only drop unique Item
// The unique item will drop based on droprate
var DroppedMessage = "\nItems Dropped : \n";
if (string.IsNullOrEmpty(Target.UniqueItemId))
{
var data = GetRandomMonsterItemDrops();
BattleScore.ItemsDroppedList += data.FormatOutput() + "\n";
DroppedMessage += data.Name + "\n";
ItemPool.Add(data);
BattleMessageModel.DroppedMessage = DroppedMessage;
BattleScore.ItemModelDropList.Add(data);
return(1);
}
if (!IsUniqueDrop(Target))
{
DroppedMessage = " Nothing dropped. ";
BattleMessageModel.DroppedMessage = DroppedMessage;
return(0);
}
var ItemModel = ItemIndexViewModel.Instance.GetItem(Target.UniqueItemId);
BattleScore.ItemsDroppedList += ItemModel.FormatOutput() + "\n";
DroppedMessage += ItemModel.Name + "\n";
ItemPool.Add(ItemModel);
BattleMessageModel.DroppedMessage = DroppedMessage;
BattleScore.ItemModelDropList.Add(ItemModel);
return(1);
}
/// <summary>
/// Return a stack layout for the Characters
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public StackLayout CreateCharacterDisplayBox(EntityInfoModel data)
{
if (data == null)
{
data = new EntityInfoModel();
}
// Hookup the image
var PlayerImage = new Image
{
Style = (Style)Application.Current.Resources["ImageBattleMediumStyle"],
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 = 1,
LineHeight = 1,
MaxLines = 1,
};
// Put the Image Button and Text inside a layout
var PlayerStack = new StackLayout
{
Style = (Style)Application.Current.Resources["ScoreCharacterInfoBox"],
HorizontalOptions = LayoutOptions.Center,
Padding = 0,
Spacing = 0,
Children =
{
PlayerImage,
PlayerLevelLabel,
},
};
return(PlayerStack);
}
/// <summary>
/// Calculate Experience
/// Level up if needed
/// </summary>
/// <param name="Attacker"></param>
/// <param name="Target"></param>
public bool CalculateExperience(EntityInfoModel Attacker, EntityInfoModel Target)
{
if (Attacker.PlayerType == PlayerTypeEnum.Character)
{
var experienceEarned = Target.CalculateExperienceEarned(BattleMessageModel.DamageAmount);
BattleMessageModel.ExperienceEarned = " Earned " + experienceEarned + " points";
var levelup = Attacker.AddExperience(experienceEarned);
if (levelup)
{
BattleMessageModel.LevelUpMessage = Attacker.Name + " is now Level " + Attacker.Level + " With Health Max of " + Attacker.GetMaxHealthTotal;
Debug.WriteLine(BattleMessageModel.LevelUpMessage);
}
// Add Experinece to the Score
BattleScore.ExperienceGainedTotal += experienceEarned;
}
return(true);
}
/// <summary>
/// Swap the Item the character has for one from the pool
///
/// Drop the current item back into the Pool
///
/// </summary>
/// <param name="character"></param>
/// <param name="setLocation"></param>
/// <param name="PoolItem"></param>
/// <returns></returns>
private ItemModel SwapCharacterItem(EntityInfoModel character, ItemLocationEnum setLocation, ItemModel PoolItem)
{
// Put on the new ItemModel, which drops the one back to the pool
var droppedItem = character.AddItem(setLocation, PoolItem.Id);
// Add the PoolItem to the list of selected items
BattleScore.ItemModelSelectList.Add(PoolItem);
// Remove the ItemModel just put on from the pool
ItemPool.Remove(PoolItem);
if (droppedItem != null)
{
// Add the dropped ItemModel to the pool
ItemPool.Add(droppedItem);
}
return(droppedItem);
}
public ActionResult GetEntityInfo(string place, string type, string name)
{
var vModel = new EntityInfoModel();
IEntity entity = null;
switch (type.ToLower())
{
case "thing":
entity = _dataCache.GetByName <IThing>(name);
break;
case "persona":
entity = _dataCache.GetByName <IPersona>(name);
break;
case "place":
entity = _dataCache.GetByName <IPlace>(name);
break;
}
if (entity == null)
{
vModel.Errors = "Invalid parameters.";
}
else
{
vModel.Entity = entity;
if (type.Equals("place", StringComparison.InvariantCultureIgnoreCase))
{
var thisPlace = (IPlace)entity;
vModel.Things = thisPlace.GetThings().Select(thing => thing.Name);
vModel.Personas = thisPlace.GetPersonas().Select(thing => thing.Name);
}
vModel.Actions = entity.FullContext.Where(ctx => ctx.GetType() == typeof(Verb)).Select(ctx => ctx.Name);
vModel.Adjectives = entity.FullContext.Where(ctx => ctx.GetType() == typeof(Descriptor)).Select(ctx => ctx.Name);
}
return(View(@"~/Views/Existence/EntityInfo.cshtml", vModel));
}
/// <summary>
/// Calculate the Attack, return if it hit or missed.
/// </summary>
/// <param name="Attacker"></param>
/// <param name="Target"></param>
/// <returns></returns>
public HitStatusEnum CalculateAttackStatus(EntityInfoModel Attacker, EntityInfoModel Target)
{
// Remember Current Player
BattleMessageModel.PlayerType = PlayerTypeEnum.Monster;
BattleMessageModel.TargetName = Target.Name;
BattleMessageModel.AttackerName = Attacker.Name;
//if(Attacker.PlayerType == PlayerTypeEnum.Monster)
//{
// BattleMessageModel.HitStatus = HitStatusEnum.Hit;
// BattleMessageModel.AttackStatus = " Hit hit ";
// return BattleMessageModel.HitStatus;
//}
//Set Attack and Defense
var AttackScore = Attacker.Level + Attacker.GetAttackTotal;
var DefenseScore = Target.Level + Target.GetDefenseTotal;
BattleMessageModel.HitStatus = RollToHitTarget(AttackScore, DefenseScore);
//BattleMessageModel.HitStatus = HitStatusEnum.Miss;
//BattleMessageModel.AttackStatus = "Miss";
return(BattleMessageModel.HitStatus);
}
public async Task AutoBattleEngine_RunAutoBattle_Monsters_1_Should_Pass()
{
//Arrange
// Add Characters
Engine.MaxNumberPartyCharacters = 1;
var CharacterPlayerMike = new EntityInfoModel(
new CharacterModel
{
Speed = -1,
Level = 10,
CurrentHealth = 11,
Experience = 1,
ExperienceRemaining = 1,
Name = "Mike",
ListOrder = 1,
});
Engine.CharacterList.Add(CharacterPlayerMike);
// Add Monsters
// Need to set the Monster count to 1, so the battle goes to Next Round Faster
Engine.MaxNumberPartyMonsters = 1;
//Act
var result = await Engine.RunAutoBattle();
//Reset
//Assert
Assert.AreEqual(true, result);
}
/// <summary>
/// Apply the Damage to the Target
/// </summary>
/// <param name="Target"></param>
private void ApplyDamage(EntityInfoModel Target)
{
Target.TakeDamage(BattleMessageModel.DamageAmount);
BattleMessageModel.CurrentHealth = Target.GetCurrentHealthTotal;
}
/// <summary>
/// Swap out the item if it is better
///
/// Uses Value to determine
/// </summary>
/// <param name="character"></param>
/// <param name="setLocation"></param>
public bool GetItemFromPoolIfBetter(EntityInfoModel character, ItemLocationEnum setLocation)
{
// We planning to assign item depending on CharacterClass
// We have four Class, Each Class has their outstanding attributes
// So item attribute will be considered
var myList = ItemPool.Where(a => a.Location == setLocation)
.OrderByDescending(a => a.Value)
.ToList();
// This will be complete later, after we complete Character Class
//if(setLocation != ItemLocationEnum.OffHand || setLocation != ItemLocationEnum.PrimaryHand)
//{
// var Attribute = AttributeEnum.Unknown;
// switch (character.CharacterClass)
// {
// case (CharacterClassEnum.Fighter):
// Attribute = AttributeEnum.Attack;
// break;
// case (CharacterClassEnum.Cleric):
// Attribute = AttributeEnum.Defense;
// break;
// case (CharacterClassEnum.Unknown):
// default:
// break;
// }
// if (Attribute == AttributeEnum.Unknown)
// {
// return false;
// }
// myList = ItemPool.Where(a => a.Location == setLocation && a.Attribute == Attribute)
// .OrderByDescending(a => a.Value)
// .ToList();
//}
// If no items in the list, return...
if (!myList.Any())
{
return(false);
}
var CharacterItem = character.GetItemByLocation(setLocation);
if (CharacterItem == null)
{
SwapCharacterItem(character, setLocation, myList.FirstOrDefault());
return(true);
}
foreach (var PoolItem in myList)
{
if (PoolItem.Value > CharacterItem.Value)
{
SwapCharacterItem(character, setLocation, PoolItem);
return(true);
}
}
return(true);
}
public void HackathonScenario_Scenario_14_If_Confusion_Turn_Character_Should_Skip()
{
/*
* Scenario Number:
* 14
*
* Description:
* Confusion, have % chance to occuring each round.
* If happens, then confusion occurs for each monster and character for that round
* Each party member rolls a chance of being confused.
*
* Changes Required (Classes, Methods etc.) List Files, Methods, and Describe Changes:
* Change to Turn Engine, Take Turn method, added switch check and dice roll
* Changed BaseEngine, added boolean switch for enabling confusion, and is confusion turn or not.
* Check for Experience gained is 0
*
* Test Algrorithm:
* Create Character named Bob
* Create Monster
* Call TakeTurn
*
* Test Conditions:
* Test with Character of Named ConfusionCharacter
*
* Validation:
* Verify Experience gained is 0
*
*/
//Arrange
DiceHelper.EnableForcedRolls();
DiceHelper.SetForcedRollValue(0);
// Set Character Conditions
BattleEngine.MaxNumberPartyCharacters = 1;
var TestSword = ItemViewModel.Dataset.Where(a => a.Location == ItemLocationEnum.PrimaryHand).FirstOrDefault();
var CharacterPlayer = new EntityInfoModel(
new CharacterModel
{
Level = 10,
CurrentHealth = 200,
MaxHealth = 200,
//TestDamage = 123,
Experience = 100,
Name = "Confused Character",
});
CharacterPlayer.Attack = 25;
CharacterPlayer.Speed = 20;
CharacterPlayer.Defense = 25;
CharacterPlayer.AddItem(ItemLocationEnum.PrimaryHand, TestSword.Id);
BattleEngine.CharacterList.Add(CharacterPlayer);
// Set Monster Conditions
// Add a monster to attack
BattleEngine.MaxNumberPartyCharacters = 1;
var MonsterPlayer = new EntityInfoModel(
new MonsterModel
{
Speed = 10,
Level = 10,
CurrentHealth = 100,
Experience = 100,
Name = "Monster",
});
BattleEngine.CharacterList.Add(MonsterPlayer);
// Have dice roll to 20
DiceHelper.EnableForcedRolls();
DiceHelper.SetForcedRollValue(20);
// EnableConfusionRounds
BattleEngine.EnableConfusionRound = true;
BattleEngine.NewRound();
//Act
var result = BattleEngine.TakeTurn(CharacterPlayer);
//Reset
DiceHelper.DisableForcedRolls();
BattleEngine.EnableConfusionRound = false;
//Assert
Assert.AreEqual(true, result);
Assert.AreEqual(AutoBattleEngine.BattleScore.ExperienceGainedTotal, 0);
}
public void HackathonScenario_Scenario_7_If_Sleep_Monster_Should_Sleep()
{
/*
* Scenario Number:
* 7
*
* Description:
* The n Character can sleep monsters at (n-1)*2 + 1 Round
*
* Changes Required (Classes, Methods etc.) List Files, Methods, and Describe Changes:
* Change to Turn Engine, Take Turn method, added switch check
* Changed BaseEngine, added boolean switch for enabling Sleep, Added Awake to check if Monster is asleep
*
* Test Algrorithm:
* Create Character
* Call TakeTurn
*
* Test Conditions:
* Test with Character Sleep Character
*
* Validation:
* Verify Awake is false
*
*/
//Arrange
DiceHelper.EnableForcedRolls();
DiceHelper.SetForcedRollValue(0);
// Set Character Conditions
BattleEngine.MaxNumberPartyCharacters = 1;
var TestSword = ItemViewModel.Dataset.Where(a => a.Location == ItemLocationEnum.PrimaryHand).FirstOrDefault();
var CharacterPlayer = new EntityInfoModel(
new CharacterModel
{
Level = 10,
CurrentHealth = 200,
MaxHealth = 200,
//TestDamage = 123,
Experience = 100,
Name = "Sleep Character",
});
BattleEngine.CharacterList.Add(CharacterPlayer);
// Set Monster Conditions
// Add a monster to attack
BattleEngine.MaxNumberPartyCharacters = 1;
var MonsterPlayer = new EntityInfoModel(
new MonsterModel
{
Speed = 1,
Level = 10,
CurrentHealth = 100,
Experience = 100,
Name = "Monster",
});
BattleEngine.MonsterList.Add(MonsterPlayer);
BattleEngine.SLEEPINGTEST = true;
// Have dice roll to 20
DiceHelper.EnableForcedRolls();
DiceHelper.SetForcedRollValue(20);
// EnableConfusionRounds
BattleEngine.EnableConfusionRound = false;
//BattleEngine.NewRound();
//Act
var sleep = BattleEngine.TakeTurn(CharacterPlayer);
//var result = BattleEngine.TakeTurn(MonsterPlayer);
//Reset
DiceHelper.DisableForcedRolls();
//Assert
Assert.AreEqual(true, sleep);
//Assert.IsTrue(BattleEngine.EnableConfusionRound);
Assert.IsFalse(BattleEngine.Awake);
}
/// <summary>
/// Find a Desired Target
/// Move close to them
/// Get to move the number of Speed
/// </summary>
/// <param name="Attacker"></param>
/// <returns></returns>
public bool MoveAsTurn(EntityInfoModel Attacker, MapModelLocation targetLocation = null)
{
/*
* TODO: TEAMS Work out your own move logic if you are implementing move
*
* Mike's Logic
* The monster or charcter will move to a different square if one is open
* Find the Desired Target
* Jump to the closest space near the target that is open
*
* If no open spaces, return false
*
*/
if (Attacker.PlayerType == PlayerTypeEnum.Monster)
{
// For Attack, Choose Who
CurrentDefender = AttackChoice(Attacker);
if (CurrentDefender == null)
{
return(false);
}
// Get X, Y for Defender
var locationDefender = MapModel.GetLocationForPlayer(CurrentDefender);
if (locationDefender == null)
{
return(false);
}
var locationAttacker = MapModel.GetLocationForPlayer(Attacker);
if (locationAttacker == null)
{
return(false);
}
// Find Location Nearest to Defender that is Open.
// Get the Open Locations
var openSquare = MapModel.ReturnClosestEmptyLocation(locationDefender);
Debug.WriteLine(string.Format("{0} moves from {1},{2} to {3},{4}", locationAttacker.Player.Name, locationAttacker.Column, locationAttacker.Row, openSquare.Column, openSquare.Row));
BattleMessageModel.TurnMessage = Attacker.Name + " moves closer to " + CurrentDefender.Name;
return(MapModel.MovePlayerOnMap(locationAttacker, openSquare));
}
else if (Attacker.PlayerType == PlayerTypeEnum.Character)
{
var locationAttacker = MapModel.GetLocationForPlayer(Attacker);
if (locationAttacker == null)
{
return(false);
}
var openSquare = TargetLocation;
Debug.WriteLine(string.Format("{0} moves from {1},{2} to {3},{4}", locationAttacker.Player.Name, locationAttacker.Column, locationAttacker.Row, openSquare.Column, openSquare.Row));
BattleMessageModel.TurnMessage = Attacker.Name + " moves to row: " + openSquare.Row + 1 + " column: " + openSquare.Column;
return(MapModel.MovePlayerOnMap(locationAttacker, openSquare));
}
return(true);
}
/// <summary>
/// Attack Action Deatil
/// </summary>
/// <param name="Attacker"></param>
/// <param name="Target"></param>
/// <returns></returns>
public bool TurnAsAttack(EntityInfoModel Attacker, EntityInfoModel Target)
{
if (Attacker == null)
{
return(false);
}
if (Target == null)
{
return(false);
}
BattleMessageModel.ClearMessages();
CalculateAttackStatus(Attacker, Target);
// Hackathon
// Hackathon Scenario 2, Bob alwasys misses
if (Attacker.Name.Equals("Bob"))
{
BattleMessageModel.HitStatus = HitStatusEnum.Miss;
BattleMessageModel.TurnMessage = "Bob always Misses";
Debug.WriteLine(BattleMessageModel.TurnMessage);
return(true);
}
if (PrimeNumber)
{
if (Attacker.PlayerType == PlayerTypeEnum.Character && IsPrime(Attacker))
{
BattleMessageModel.HitStatus = HitStatusEnum.Hit;
BattleMessageModel.TurnMessage = "Prime always Hit";
//Debug.WriteLine(Attacker.TestDamage);
BattleMessageModel.DamageAmount = Attacker.GetDamageTotal;
Debug.WriteLine(BattleMessageModel.TurnMessage);
return(true);
}
}
switch (BattleMessageModel.HitStatus)
{
case HitStatusEnum.Miss:
// It's a Miss
break;
case HitStatusEnum.Hit:
// It's a Hit
BattleMessageModel.DamageAmount = Attacker.GetDamageRollValue();
ApplyDamage(Target);
BattleMessageModel.TurnMessageSpecial = BattleMessageModel.GetCurrentHealthMessage();
// Check if the target dead. If dead, remove it
RemoveIfDead(Target);
// If Attacker is a Character, it should gain experience from Monster
CalculateExperience(Attacker, Target);
break;
}
BattleMessageModel.TurnMessage = Attacker.Name + BattleMessageModel.AttackStatus + Target.Name + BattleMessageModel.TurnMessageSpecial + BattleMessageModel.ExperienceEarned;
Debug.WriteLine(BattleMessageModel.TurnMessage);
if (Target.PlayerType == PlayerTypeEnum.Character)
{
UpdatePlayerList(Target);
}
return(true);
}
// Attack or Move
// Roll To Hit
// Decide Hit or Miss
// Decide Damage
// Death
// Drop Items
// Turn Over
#endregion Algrorithm
/// <summary>
/// CharacterModel Attacks...
/// </summary>
/// <param name="Attacker"></param>
/// <returns></returns>
public bool TakeTurn(EntityInfoModel Attacker)
{
// Choose Action. Such as Move, Attack etc.
// INFO: Teams, if you have other actions they would go here.
bool result = false;
// Check for confusion round or not, if it is confusion round and rolled confusion, skip turn
if (EnableConfusionRound && IsConfusionRound && DiceHelper.RollDice(1, 20) - Attacker.Level > 0)
{
BattleMessageModel.TurnMessage = Attacker.Name + " is confused.";
Debug.WriteLine(BattleMessageModel.TurnMessage);
return(true);
}
if (Attacker.PlayerType == PlayerTypeEnum.Monster)
{
if (BattleScore.TurnCount >= PlayerList.Count)
{
Awake = true;
}
/*
* Order of Priority
* If can attack Then Attack
* Next use Ability or Move
*/
// Assume Move if nothing else happens
CurrentAction = ActionEnum.Move;
Debug.WriteLine(BattleScore.TurnCount);
if (!Awake)
{
CurrentAction = ActionEnum.Sleep;
}
// See if Desired Target is within Range, and if so attack away
else if (MapModel.IsTargetInRange(Attacker, AttackChoice(Attacker)))
{
CurrentAction = ActionEnum.Attack;
}
}
else
{
if (SLEEPINGTEST)
{
int listNo = Attacker.ListOrder;
if ((listNo * 2 + 1) == BattleScore.RoundCount)
{
foreach (var player in PlayerList)
{
if (player.PlayerType == PlayerTypeEnum.Monster)
{
player.FallAsleep();
}
}
Awake = false;
}
}
if (false)
{
if (BattleScore.AutoBattle)
{
/*
* Order of Priority
* If can attack Then Attack
* Next use Ability or Move
*/
// Assume Move if nothing else happens
CurrentAction = ActionEnum.Move;
// See if Desired Target is within Range, and if so attack away
if (MapModel.IsTargetInRange(Attacker, AttackChoice(Attacker)))
{
CurrentAction = ActionEnum.Attack;
}
// Simple Logic is Roll to Try Ability. 50% says try
else if (DiceHelper.RollDice(1, 10) > 5)
{
CurrentAction = ActionEnum.Ability;
}
}
}
}
switch (CurrentAction)
{
case ActionEnum.Unknown:
case ActionEnum.Attack:
result = Attack(Attacker);
break;
case ActionEnum.Ability:
result = UseAbility(Attacker);
break;
case ActionEnum.Sleep:
result = FallAsleep(Attacker);
break;
case ActionEnum.Move:
result = MoveAsTurn(Attacker, TargetLocation);
break;
}
BattleScore.TurnCount++;
return(result);
//return result;
}
