/// <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); }