/// <summary>
/// Have the character or monster drop all their items and returns the list of item models
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public List <ItemModel> RemoveItems(BattleEntityModel target)
{
switch (target.EntityType)
{
case (EntityTypeEnum.Character):
return(CharacterList.Where(a => a.Id == target.Id).FirstOrDefault().DropAllItems());
case (EntityTypeEnum.Monster):
default:
return(MonsterList.Where(a => a.Id == target.Id).FirstOrDefault().DropItems());
}
}
/// <summary>
/// Gets the roll of the damage value (including any stat boosts) of the character or monster
/// </summary>
/// <param name="attacker"></param>
/// <returns></returns>
public int GetDamage(BattleEntityModel attacker)
{
switch (attacker.EntityType)
{
case (EntityTypeEnum.Character):
return(CharacterList.Where(a => a.Id == attacker.Id).FirstOrDefault().RollDamageDice());
case (EntityTypeEnum.Monster):
default:
return(MonsterList.Where(a => a.Id == attacker.Id).FirstOrDefault().RollDamageDice());
}
}
/// <summary>
/// Round is restarted when all monsters are killed.
/// </summary>
/// <returns></returns>
public bool CheckRoundRestartCondtion()
{
// if all monsters are dead then round is restarted
var _aliveMonsters = MonsterList.Where(arg => arg.Alive).Count();
if (_aliveMonsters > 0)
{
// some Monsters are alive
return(false);
}
else
{
// all Monsters died
return(true);
}
}
// Get Round Turn Order
// Rember Who's Turn
// RoundNextTurn which uses PlayerCurrent as tracking which player
public RoundEnum RoundNextTurn()
{
// No characters, game is over because game ends when characters die
if (CharacterList.Count < 1)
{
// Game Over and exit do while loop from auto battle engine
RoundStateEnum = RoundEnum.GameOver;
return(RoundEnum.GameOver);
}
// Check if round is over when monsters are killed
if (MonsterList.Count < 1)
{
// If over, New Round which loops back to main auto battle engine
RoundStateEnum = RoundEnum.NewRound;
return(RoundEnum.NewRound);
}
// Player current is the next players turn which is decided by recalculating the order
// through making a list based on attributes starting with speed, level, etc
// Then parse through the list to get the next players turn
PlayerCurrent = GetNextPlayerTurn();
// Decide Who to Attack
if (PlayerCurrent.PlayerType == PlayerTypeEnum.Character)
{
// Get the player
var myPlayer = CharacterList.Where(a => a.Guid == PlayerCurrent.Guid).FirstOrDefault();
// Do the turn by going to the turn engine and either having monster or character attack
TakeTurn(myPlayer);
}
// Add Monster turn here...
else if (PlayerCurrent.PlayerType == PlayerTypeEnum.Monster)
{
// Get the player
var myPlayer = MonsterList.Where(a => a.Guid == PlayerCurrent.Guid).FirstOrDefault();
// Do the turn....
TakeTurn(myPlayer);
}
RoundStateEnum = RoundEnum.NextTurn;
return(RoundEnum.NextTurn);
}
/// <summary>
/// Process an entity's death.
/// </summary>
/// <param name="target"></param>
/// <returns></returns>
public bool TargetDied(BattleEntityModel target)
{
// Mark Status in output
BattleMessages.TurnMessageSpecial = target.Name + " has perished.";
// Remove target from Map
MapModel.RemovePlayerFromMap(target);
// Using a switch so in the future additional PlayerTypes can be added (Boss...)
switch (target.EntityType)
{
case EntityTypeEnum.Character:
DropItems(target);
var character = CharacterList.Where(a => a.Id == target.Id).FirstOrDefault();
CharacterList.Remove(character);
EntityList.Remove(EntityList.Find(m => m.Id.Equals(target.Id)));
// Add the MonsterModel to the killed list
Score.CharacterAtDeathList += character.FormatOutput() + "\n";
Debug.WriteLine(BattleMessages.TurnMessageSpecial);
return(true);
case EntityTypeEnum.Monster:
default:
DropItems(target);
var monster = MonsterList.Where(a => a.Id == target.Id).FirstOrDefault();
MonsterList.Remove(monster);
EntityList.Remove(EntityList.Find(m => m.Id.Equals(target.Id)));
// Add one to the monsters killed count...
Score.MonsterSlainNumber++;
// Add the MonsterModel to the killed list
Score.MonstersKilledList += monster.FormatOutput() + "\n";
Debug.WriteLine(BattleMessages.TurnMessageSpecial);
return(true);
}
}
// Get Round Turn Order
// Rember Who's Turn
// RoundNextTurn
public RoundEnum RoundNextTurn()
{
// No characters, game is over...
if (CharacterList.Count < 1)
{
// Game Over
RoundStateEnum = RoundEnum.GameOver;
return(RoundStateEnum);
}
// Check if round is over
if (MonsterList.Count < 1)
{
// If over, New Round
RoundStateEnum = RoundEnum.NewRound;
return(RoundEnum.NewRound);
}
// Decide Who gets next turn
// Remember who just went...
PlayerCurrent = GetNextPlayerTurn();
// Decide Who to Attack
// Do the Turn
if (PlayerCurrent.PlayerType == PlayerTypeEnum.Character)
{
// Get the player
var myPlayer = CharacterList.Where(a => a.Guid == PlayerCurrent.Guid).FirstOrDefault();
// Do the turn....
TakeTurn(myPlayer);
}
// Add Monster turn here...
else if (PlayerCurrent.PlayerType == PlayerTypeEnum.Monster)
{
// Get the player
var myPlayer = MonsterList.Where(a => a.Guid == PlayerCurrent.Guid).FirstOrDefault();
// Do the turn....
TakeTurn(myPlayer);
}
RoundStateEnum = RoundEnum.NextTurn;
return(RoundStateEnum);
}
/// <summary>
/// Pick the Monster to Attack
/// </summary>
/// <returns></returns>
public PlayerInfoModel SelectMonsterToAttack()
{
if (MonsterList == null)
{
return(null);
}
if (MonsterList.Count < 1)
{
return(null);
}
// Select first one to hit in the list for now...
// Attack the Weakness (lowest HP) MonsterModel first
var Defender = MonsterList
.Where(m => m.Alive)
.OrderBy(m => m.CurrentHealth).FirstOrDefault();
return(Defender);
}
/// <summary>
/// Pick the Monster to Attack
/// </summary>
/// <returns></returns>
public EntityInfoModel SelectMonsterToAttack()
{
if (MonsterList == null)
{
return(null);
}
if (MonsterList.Count < 1)
{
return(null);
}
// Select the one with highest attack
var Defender = MonsterList
.Where(m => m.Alive)
.OrderBy(m => m.Attack)
.LastOrDefault();
return(Defender);
}
// Get Round Turn Order
// Rember Who's Turn
// RoundNextTurn
public RoundEnum RoundNextTurn()
{
// No characters, game is over...
if (CharacterList.Count < 1)
{
// Game Over
RoundStateEnum = RoundEnum.GameOver;
return(RoundStateEnum);
}
// Check if round is over
if (MonsterList.Count < 1)
{
// If over, New Round
RoundStateEnum = RoundEnum.NewRound;
return(RoundEnum.NewRound);
}
// Decide Who gets next turn
// Remember who just went...
//if autobattle, do everything automatically
if (BattleScore.AutoBattle)
{
// Decide Who to Attack
// Do the Turn
if (PlayerCurrent.PlayerType == PlayerTypeEnum.Character)
{
// Get the player
var myPlayer = CharacterList.Where(a => a.Guid == PlayerCurrent.Guid && a.Name == PlayerCurrent.Name).FirstOrDefault();
// Do the turn....
TakeTurn(myPlayer);
}
// Add Monster turn here...
else if (PlayerCurrent.PlayerType == PlayerTypeEnum.Monster)
{
// Get the player
var myPlayer = MonsterList.Where(a => a.Guid == PlayerCurrent.Guid && a.Name == PlayerCurrent.Name).FirstOrDefault();
Debug.WriteLine("Player after selected from list: " + myPlayer.Name);
// Do the turn....
TakeTurn(myPlayer);
}
}
//if move is rest or use item, DO NOT DO ATTACK
if (TurnType == MoveEnum.Attack)
{
// Decide Who to Attack
// Do the Turn
if (PlayerCurrent.PlayerType == PlayerTypeEnum.Character)
{
// Get the player
var myPlayer = CharacterList.Where(a => a.Guid == PlayerCurrent.Guid && a.Name == PlayerCurrent.Name).FirstOrDefault();
// Do the turn....
TakeTurn(myPlayer);
}
// Add Monster turn here...
else if (PlayerCurrent.PlayerType == PlayerTypeEnum.Monster)
{
// Get the player
var myPlayer = MonsterList.Where(a => a.Guid == PlayerCurrent.Guid && a.Name == PlayerCurrent.Name).FirstOrDefault();
Debug.WriteLine("Player after selected from list: " + myPlayer.Name);
// Do the turn....
TakeTurn(myPlayer);
}
//check to see again if game is over
// No characters, game is over...
if (CharacterList.Count < 1)
{
// Game Over
RoundStateEnum = RoundEnum.GameOver;
return(RoundStateEnum);
}
// Check if round is over
if (MonsterList.Count < 1)
{
// If over, New Round
RoundStateEnum = RoundEnum.NewRound;
return(RoundEnum.NewRound);
}
PlayerCurrent = GetNextPlayerTurn();
Debug.WriteLine("\n\nPlayer current new just chosen backend for next turn: " + PlayerCurrent.Name);
RoundStateEnum = RoundEnum.NextTurn;
return(RoundStateEnum);
}
else
{
//move to next turn, but do not attack, if character
//if monster, always attack
if (PlayerCurrent.PlayerType == PlayerTypeEnum.Monster)
{
// Get the player
var myPlayer = MonsterList.Where(a => a.Guid == PlayerCurrent.Guid && a.Name == PlayerCurrent.Name).FirstOrDefault();
Debug.WriteLine("Player after selected from list: " + myPlayer.Name);
// Do the turn....
TakeTurn(myPlayer);
}
else if (PlayerCurrent.PlayerType == PlayerTypeEnum.Character)
{
//get character
var myPlayer = CharacterList.Where(a => a.Guid == PlayerCurrent.Guid && a.Name == PlayerCurrent.Name).FirstOrDefault();
//increment turn count manually since you're not calling TakeTurn anymore
BattleScore.TurnCount++;
}
//check again to see if round over
// No characters, game is over...
if (CharacterList.Count < 1)
{
// Game Over
RoundStateEnum = RoundEnum.GameOver;
return(RoundStateEnum);
}
// Check if round is over
if (MonsterList.Count < 1)
{
// If over, New Round
RoundStateEnum = RoundEnum.NewRound;
return(RoundEnum.NewRound);
}
PlayerCurrent = GetNextPlayerTurn();
Debug.WriteLine("\n\nPlayer current new just chosen backend for next turn: " + PlayerCurrent.Name);
RoundStateEnum = RoundEnum.NextTurn;
return(RoundStateEnum);
}
}
// Get Round Turn Order
// Rember Who's Turn
// Starts next turn during round
public RoundEnum RoundNextTurn()
{
// Debug statements
Debug.WriteLine("Starting RoundEngine...");
Debug.WriteLine("From Round Engine: " + RoundStateEnum);
// No charaacters, game is over...
if (CharacterList.Count < 1)
{
RoundStateEnum = RoundEnum.GameOver;
return(RoundStateEnum);
}
// Check if round is over
if (MonsterList.Count < 1)
{
// If over, New Round
RoundStateEnum = RoundEnum.NewRound;
return(RoundStateEnum);
}
// Decide Who gets next turn
PlayerCurrent = GetNextPlayerInList();
// Debug output of the next players name
Debug.WriteLine(PlayerCurrent.Name);
// Decide Who to Attack
//Do the turn as a character
if (PlayerCurrent.PlayerType == PlayerTypeEnum.Character)
{
// Get the current character for consumables
CurrentCharacter = PlayerCharacter(PlayerCurrent);
Debug.WriteLine("It's a Character!");
// Get the player
var myPlayer = CharacterList.Where(a => a.Guid == PlayerCurrent.Guid).FirstOrDefault();
// Remove player from player list if null or dead
if (myPlayer == null || !myPlayer.Alive)
{
PlayerList.Remove(PlayerCurrent);
// Restart the turn
RoundNextTurn();
}
// Do the turn...
TakeTurn(myPlayer);
}
// Monsters turn
else if (PlayerCurrent.PlayerType == PlayerTypeEnum.Monster)
{
// Get the monster
var myPlayer = MonsterList.Where(a => a.Guid == PlayerCurrent.Guid).FirstOrDefault();
// If monster is dead or null remove it from the player list and restart round
if (myPlayer == null || !myPlayer.Alive)
{
// Remove
PlayerList.Remove(PlayerCurrent);
// Restart
RoundNextTurn();
}
// Do the turn...
TakeTurn(myPlayer);
}
// Update the roundstatenum to next turn
RoundStateEnum = RoundEnum.NextTurn;
// Return the enum
return(RoundStateEnum);
}
