private async Task doBattle()
{
game.StartTime = DateTime.Now;
while (game.Players.Count() > 1 && game.GameState == GameState.Attacking && game.Players.Any(p => game.PlayerCanAttack(p)))
{
var consecutivePacifistTurns = 0;
for (int i = 0; i < game.Players.Count() && game.Players.Count() > 1; i++)
{
var currentPlayer = game.Players.Skip(i).First() as ApiPlayer;
if (game.PlayerCanAttack(currentPlayer))
{
var failedTries = 0;
TryAttackResult attackResult = new TryAttackResult {
AttackInvalid = false
};
Territory attackingTerritory = null;
Territory defendingTerritory = null;
logger.LogInformation($"Asking {currentPlayer.Name} what action they want to perform...");
var actionResponse = await askForActionAsync(currentPlayer, ActionStatus.PreviousActionRequestFailed);
if (actionResponse.userAction == UserAction.Attack)
{
consecutivePacifistTurns = 0;
do
{
logger.LogInformation($"Asking {currentPlayer.Name} where they want to attack...");
var beginAttackResponse = await askForAttackLocationAsync(currentPlayer, BeginAttackStatus.PreviousAttackRequestFailed);
try
{
attackingTerritory = game.Board.GetTerritory(beginAttackResponse.From);
defendingTerritory = game.Board.GetTerritory(beginAttackResponse.To);
logger.LogInformation($"{currentPlayer.Name} wants to attack from {attackingTerritory} to {defendingTerritory}");
attackResult = game.TryAttack(currentPlayer.Token, attackingTerritory, defendingTerritory);
}
catch (Exception ex)
{
attackResult = new TryAttackResult {
AttackInvalid = true, Message = ex.Message
};
}
if (attackResult.AttackInvalid)
{
logger.LogError($"Invalid attack request! {currentPlayer.Name} from {attackingTerritory} to {defendingTerritory} ");
failedTries++;
if (failedTries == MaxFailedTries)
{
BootPlayerFromGame(currentPlayer);
i--;
break;
}
}
} while (attackResult.AttackInvalid);
while (attackResult.CanContinue)
{
var continueResponse = await askContinueAttackingAsync(currentPlayer, attackingTerritory, defendingTerritory);
if (continueResponse.ContinueAttacking)
{
logger.LogInformation("Keep attacking!");
attackResult = game.TryAttack(currentPlayer.Token, attackingTerritory, defendingTerritory);
}
else
{
logger.LogInformation("run away!");
break;
}
}
}
else if (actionResponse.userAction == UserAction.Pacifism)
{
consecutivePacifistTurns++;
if (consecutivePacifistTurns == game.Players.Count())
{
logger.LogInformation("Game Over");
game.SetGameOver();
return;
}
}
}
else
{
logger.LogWarning($"{currentPlayer.Name} cannot attack.");
}
}
}
logger.LogInformation("Game Over");
game.SetGameOver();
}
public async Task AttackRequest(Location from, Location to)
{
responsetime.Stop();
Stopwatch processingtime = new Stopwatch();
processingtime.Start();
Log.Information("Attack request received from player " + currentPlayer.Name);
Log.Information("Attack request by " + currentPlayer + " from location: " + from.Row + "," + from.Column);
Log.Information("Attack request by " + currentPlayer + " to location: " + to.Row + "," + to.Column);
if (game.GameState == GameState.GameOver)
{
return;
}
if (Context.ConnectionId == currentPlayer.Token)
{
game.OutstandingAttackRequestCount--;
if (currentPlayer.Strikes >= MaxFailedTries)
{
if (game.Players.Count() == 1)
{
await sendGameOverAsync();
return;
}
Log.Information("Player " + currentPlayer.Name + " kicked out for too many bad attack responses.");
await Clients.Client(Context.ConnectionId).SendMessage("Server", $"Too many bad requests. No risk for you");
game.RemovePlayerByToken(currentPlayer.Token);
game.RemovePlayerFromBoard(currentPlayer.Token);
await tellNextPlayerToAttack();
return;
}
if (game.Players.Count() > 1 && game.GameState == GameState.Attacking && game.Players.Any(p => game.PlayerCanAttack(p)))
{
if (game.PlayerCanAttack(currentPlayer))
{
TryAttackResult attackResult = new TryAttackResult {
AttackInvalid = false
};
Territory attackingTerritory = null;
Territory defendingTerritory = null;
try
{
attackingTerritory = game.Board.GetTerritory(from);
defendingTerritory = game.Board.GetTerritory(to);
logger.LogInformation($"{currentPlayer.Name} wants to attack from {attackingTerritory} to {defendingTerritory}");
attackResult = game.TryAttack(currentPlayer.Token, attackingTerritory, defendingTerritory);
await Clients.All.SendStatus(getStatus());
}
catch (Exception ex)
{
Log.Error("Attack exception caused by " + currentPlayer.Name + ": " + ex.Message);
attackResult = new TryAttackResult {
AttackInvalid = true, Message = ex.Message
};
}
if (attackResult.AttackInvalid)
{
currentPlayer.Strikes++;
logger.LogError($"Invalid attack request! {currentPlayer.Name} from {attackingTerritory} to {defendingTerritory}. You now have {currentPlayer.Strikes} strike(s)!");
await Clients.Client(currentPlayer.Token).SendMessage("Server", $"Invalid attack request: {attackResult.Message} :( You now have {currentPlayer.Strikes} strike(s)!");
await Clients.Client(currentPlayer.Token).YourTurnToAttack(game.Board.SerializableTerritories);
}
else
{
await Clients.Client(Context.ConnectionId).SendMessage("Server", $"Successfully Attacked From ({from.Row}, {from.Column}) To ({to.Row}, {to.Column})");
if (game.GameState == GameState.Attacking)
{
if (game.PlayerCanAttack(currentPlayer))
{
await Clients.Client(currentPlayer.Token).YourTurnToAttack(game.Board.SerializableTerritories);
}
else
{
await tellNextPlayerToAttack();
}
}
else
{
await sendGameOverAsync();
}
}
}
else
{
await Clients.Client(currentPlayer.Token).SendMessage("Server", "You are unable to attack. Moving to next player.");
logger.LogInformation("Player {currentPlayer} cannot attack.", currentPlayer.Name);
await tellNextPlayerToAttack();
}
}
else
{
await sendGameOverAsync();
}
}
else
{
var badPlayer = game.Players.Single(p => p.Token == Context.ConnectionId) as Player;
badPlayer.Strikes++;
logger.LogInformation("Player {currentPlayer} tried to play when it's not their turn. You now have {strikes} strikes!", badPlayer.Name, badPlayer.Strikes);
processingtime.Stop();
Log.Information("Processing attack request by " + currentPlayer.Name + " took: " + processingtime.Elapsed);
await Clients.Client(badPlayer.Token).SendMessage("Server", "It's not your turn");
}
}
public async Task DoPlayerBattle(ApiPlayer player)
{
if (game.PlayerCanAttack(player))
{
var failedTries = 0;
bool hasCard = false;
ContinueAttackResponse anotherAttackResponse = new ContinueAttackResponse {
ContinueAttacking = false
};
do
{
TryAttackResult attackResult = new TryAttackResult {
AttackInvalid = false
};
Territory attackingTerritory = null;
Territory defendingTerritory = null;
do
{
logger.LogInformation($"Asking {player.Name} where they want to attack...");
var beginAttackResponse = await askForAttackLocationAsync(player, BeginAttackStatus.PreviousAttackRequestFailed);
try
{
attackingTerritory = game.Board.GetTerritory(beginAttackResponse.From);
defendingTerritory = game.Board.GetTerritory(beginAttackResponse.To);
logger.LogInformation($"{player.Name} wants to attack from {attackingTerritory} to {defendingTerritory}");
attackResult = game.TryAttack(player.Token, attackingTerritory, defendingTerritory);
if (attackResult.BattleWasWon && !hasCard)
{
player.PlayerCards.Add(new Card());
hasCard = true;
}
}
catch (Exception ex)
{
attackResult = new TryAttackResult {
AttackInvalid = true, Message = ex.Message
};
}
if (attackResult.AttackInvalid)
{
logger.LogError($"Invalid attack request! {player.Name} from {attackingTerritory} to {defendingTerritory} ");
failedTries++;
if (failedTries == MaxFailedTries)
{
BootPlayerFromGame(player);
logger.LogError($"Player {player.Name} Booted! Due to attack error");
return;
}
}
} while (attackResult.AttackInvalid);
while (attackResult.CanContinue)
{
var continueResponse = await askContinueAttackingAsync(player, attackingTerritory, defendingTerritory);
if (continueResponse.ContinueAttacking)
{
logger.LogInformation("Keep attacking!");
attackResult = game.TryAttack(player.Token, attackingTerritory, defendingTerritory);
if (attackResult.BattleWasWon && !hasCard)
{
player.PlayerCards.Add(new Card());
hasCard = true;
}
}
else
{
logger.LogInformation("run away!");
break;
}
}
if (game.PlayerCanAttack(player))
{
anotherAttackResponse = await AskMakeAnotherAttackAsync(player, attackingTerritory, defendingTerritory);
}
else
{
anotherAttackResponse.ContinueAttacking = false;
}
} while (anotherAttackResponse.ContinueAttacking);
}
else
{
logger.LogWarning($"{player.Name} cannot attack.");
}
}
public async Task AttackRequest(Location from, Location to)
{
if (game.GameState == GameState.GameOver)
{
return;
}
logger.LogDebug($"Received Attack Request from {Context.ConnectionId}");
Log.Logger.Debug($"Received Attack Request from {Context.ConnectionId}");
if (Context.ConnectionId == currentPlayer.Token)
{
logger.LogDebug($"{Context.ConnectionId} belongs to {currentPlayer.Name}");
Log.Logger.Debug($"{Context.ConnectionId} belongs to {currentPlayer.Name}");
game.OutstandingAttackRequestCount--;
if (currentPlayer.Strikes >= MaxFailedTries)
{
if (game.Players.Count() == 1)
{
await sendGameOverAsync();
return;
}
logger.LogInformation("Attacking Phase: {0} has too many strikes. Booting from game.", currentPlayer.Name);
Log.Logger.Information($"Attacking Phase: {currentPlayer.Name} has too many strikes. {currentPlayer.Name } will be booted from the game.");
await Clients.Client(Context.ConnectionId).SendMessage("Server", $"Too many bad requests. No risk for you");
game.RemovePlayerByToken(currentPlayer.Token);
game.RemovePlayerFromBoard(currentPlayer.Token);
await tellNextPlayerToAttack();
return;
}
if (game.Players.Count() > 1 && game.GameState == GameState.Attacking && game.Players.Any(p => game.PlayerCanAttack(p)))
{
if (game.PlayerCanAttack(currentPlayer))
{
TryAttackResult attackResult = new TryAttackResult {
AttackInvalid = false
};
Territory attackingTerritory = null;
Territory defendingTerritory = null;
try
{
attackingTerritory = game.Board.GetTerritory(from);
defendingTerritory = game.Board.GetTerritory(to);
logger.LogDebug($"{currentPlayer.Name} wants to attack from {attackingTerritory.Location} to {defendingTerritory.Location}");
Log.Logger.Debug($"{currentPlayer.Name} wants to attack from {attackingTerritory.Location} to {defendingTerritory.Location}");
attackResult = game.TryAttack(currentPlayer.Token, attackingTerritory, defendingTerritory);
await Clients.All.SendStatus(getStatus());
}
catch (Exception ex)
{
attackResult = new TryAttackResult {
AttackInvalid = true, Message = ex.Message
};
}
if (attackResult.AttackInvalid)
{
currentPlayer.Strikes++;
logger.LogWarning($"Invalid attack request! from ({attackingTerritory.Location.Row}, {attackingTerritory.Location.Column}) to ({defendingTerritory.Location.Row}, {defendingTerritory.Location.Column}). {currentPlayer.Name} now has {currentPlayer.Strikes} and will be kicked after {MaxFailedTries - currentPlayer.Strikes} more strikes!");
Log.Logger.Warning($"Invalid attack request! from ({attackingTerritory.Location.Row}, {attackingTerritory.Location.Column}) to ({defendingTerritory.Location.Row}, {defendingTerritory.Location.Column}). {currentPlayer.Name} now has {currentPlayer.Strikes} and will be kicked after {MaxFailedTries - currentPlayer.Strikes} more strikes!");
await Clients.Client(currentPlayer.Token).SendMessage("Server", $"Invalid attack request: {attackResult.Message} :( You now have {currentPlayer.Strikes} strike(s)!");
await Clients.Client(currentPlayer.Token).YourTurnToAttack(game.Board.SerializableTerritories);
}
else
{
logger.LogDebug($"{currentPlayer.Name} attacked from ({from.Row}, {from.Column}) to ({to.Row}, {to.Column})");
Log.Logger.Debug($"{currentPlayer.Name} attacked from ({from.Row}, {from.Column}) to ({to.Row}, {to.Column})");
await Clients.Client(Context.ConnectionId).SendMessage("Server", $"Successfully Attacked From ({from.Row}, {from.Column}) To ({to.Row}, {to.Column})");
if (game.GameState == GameState.Attacking)
{
if (game.PlayerCanAttack(currentPlayer))
{
await Clients.Client(currentPlayer.Token).YourTurnToAttack(game.Board.SerializableTerritories);
}
else
{
await tellNextPlayerToAttack();
}
}
else
{
await sendGameOverAsync();
}
}
}
else
{
try
{
await Clients.Client(currentPlayer.Token).SendMessage("Server", "You are unable to attack. Moving to next player.");
logger.LogInformation("Player {currentPlayer} cannot attack. anymore passing turn to next player", currentPlayer.Name);
await tellNextPlayerToAttack();
}
catch (Exception ex)
{
logger.LogError($"An exception occurred while {currentPlayer.Name} was passing their turn to the next player: {ex.Message}");
Log.Logger.Error($"An exception occurred while {currentPlayer.Name} was passing their turn to the next playier; {ex.Message}");
}
}
}
else
{
await sendGameOverAsync();
}
}
else
{
var badPlayer = game.Players.Single(p => p.Token == Context.ConnectionId) as Player;
badPlayer.Strikes++;
logger.LogWarning("Player {currentPlayer} tried to play when it's not their turn. You now have {strikes} strikes!", badPlayer.Name, badPlayer.Strikes);
Log.Logger.Warning($"{badPlayer.Name} tried to play when it's not their turn. {badPlayer.Name} now has {badPlayer.Strikes} strikes! {MaxFailedTries - badPlayer.Strikes} more and you will be booted from the game!");
await Clients.Client(badPlayer.Token).SendMessage("Server", "It's not your turn");
}
}
