internal ContinueAttackResponse DecideToMakeNewAttack(ContinueAttackRequest continueAttackRequest)
{
ContinueAttackResponse response = new ContinueAttackResponse();
response.ContinueAttacking = false;
return(response);
}
internal ContinueAttackResponse DecideToMakeNewAttack(ContinueAttackRequest continueAttackRequest)
{
ContinueAttackResponse response = new ContinueAttackResponse();
var myTerritories = GetMyTerritories(continueAttackRequest.Board);
var rand = new Random();
foreach (var territory in myTerritories)
{
var territoryNeighbors = GetNeighbors(territory, continueAttackRequest.Board);
foreach (var neighbor in territoryNeighbors)
{
if (neighbor.Armies == 0 && territory.Armies > 3)
{
response.ContinueAttacking = true;
return(response);
}
if (territory.Armies > neighbor.Armies * 2)
{
if (rand.Next(10) != 1)
{
break;
}
response.ContinueAttacking = true;
return(response);
}
}
}
response.ContinueAttacking = false;
return(response);
}
public ContinueAttackResponse WhenToContinueAttack(ContinueAttackRequest continueAttackRequest)
{
ContinueAttackResponse attackResponse = new ContinueAttackResponse();
attackResponse.ContinueAttacking = (continueAttackRequest.AttackingTerritorry.Armies > continueAttackRequest.DefendingTerritorry.Armies);
return(attackResponse);
}
public ContinueAttackResponse ContinueAttack([FromBody] ContinueAttackRequest continueAttackRequest)
{
ContinueAttackResponse response = new ContinueAttackResponse();
response.ContinueAttacking = true;
return(response);
}
public ContinueAttackResponse WhenToContinueAttack(ContinueAttackRequest continueAttackRequest)
{
ContinueAttackResponse continueAttackResponse = new ContinueAttackResponse();
if (continueAttackRequest.AttackingTerritorry.Armies > continueAttackRequest.DefendingTerritorry.Armies + 1)
{
continueAttackResponse.ContinueAttacking = true;
return(continueAttackResponse);
}
continueAttackResponse.ContinueAttacking = false;
return(continueAttackResponse);
}
private ContinueAttackResponse createContinueAttackResponse(ContinueAttackRequest continueAttackRequest)
{
Random rnd = new Random();
ContinueAttackResponse response = new ContinueAttackResponse();
if (rnd.Next(1, 3) == 1)
{
response.ContinueAttacking = false;
}
else
{
response.ContinueAttacking = true;
}
return(response);
}
internal ContinueAttackResponse DecideToMakeNewAttack(ContinueAttackRequest continueAttackRequest)
{
ContinueAttackResponse response = new ContinueAttackResponse();
IEnumerable <BoardTerritory> myTerritories = GetMyTerritories(continueAttackRequest.Board);
BoardTerritory topDog = new BoardTerritory();
topDog.Armies = 0;
foreach (BoardTerritory territory in myTerritories)
{
if (territory.Armies > topDog.Armies)
{
if (GetNumBadTerritories(territory, continueAttackRequest.Board) > 0)
{
topDog = territory;
}
}
}
IEnumerable <BoardTerritory> tDogNeighbors = GetNeighbors(topDog, continueAttackRequest.Board);
BoardTerritory smallPup = new BoardTerritory();
smallPup.Armies = 99999;
foreach (BoardTerritory t in tDogNeighbors)
{
if (!myTerritories.Contains(t) && t.Armies < smallPup.Armies)
{
smallPup = t;
}
}
if (topDog.Armies > (2 * smallPup.Armies))
{
response.ContinueAttacking = true;
}
else
{
response.ContinueAttacking = false;
}
return(response);
}
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.");
}
}
