public AIBoardNode(CreeperColor color)
{
Color = color;
Row = -1;
Column = -1;
}
private void UpdateListHeads(int row, int column, CreeperColor type)
{
if (row > 5) throw new ArgumentOutOfRangeException(row.ToString());
if (column > 5) throw new ArgumentOutOfRangeException(column.ToString());
// This gives us direct access to the first node added to a given row, column, and color.
// Also, we now remove the tile from the opposite team's head array, when appropriate.
if (type == CreeperColor.Ice)
{
if (RowHeadWhite[row] == TileBoard[row, column])
{
RowHeadWhite[row] = (RowHeadWhite[row] == RowHeadWhite[row].TeamNorth) ? null : RowHeadWhite[row].TeamNorth;
}
if (ColumnHeadWhite[column] == TileBoard[row, column])
{
ColumnHeadWhite[column] = (ColumnHeadWhite[column] == ColumnHeadWhite[column].TeamEast) ? null : ColumnHeadWhite[column].TeamEast;
}
if (TileBoard[row, column].Color != CreeperColor.Empty)
{
RowHeadBlack[row] = RowHeadBlack[row] ?? TileBoard[row, column];
ColumnHeadBlack[column] = ColumnHeadBlack[column] ?? TileBoard[row, column];
}
}
else if (type == CreeperColor.Fire)
{
if (RowHeadBlack[row] == TileBoard[row, column])
{
RowHeadBlack[row] = (RowHeadBlack[row] == RowHeadBlack[row].TeamNorth) ? null : RowHeadBlack[row].TeamNorth;
}
if (ColumnHeadBlack[column] == TileBoard[row, column])
{
ColumnHeadBlack[column] = (ColumnHeadBlack[column] == ColumnHeadBlack[column].TeamEast) ? null : ColumnHeadBlack[column].TeamEast;
}
if (TileBoard[row, column].Color != CreeperColor.Empty)
{
RowHeadWhite[row] = RowHeadWhite[row] ?? TileBoard[row, column];
ColumnHeadWhite[column] = ColumnHeadWhite[column] ?? TileBoard[row, column];
}
}
else
{
// We don't want this method called with anything but tiles.
throw new ArgumentOutOfRangeException(type.ToString());
}
}
public AIBoardNode(int row, int column, CreeperColor color)
{
Color = color;
Row = row;
Column = column;
}
public IEnumerable<AIBoardNode> GetNeighbors(AIBoardNode node, CreeperColor color)
{
foreach (Position neighborPosition in new[]{
new Position(node.Row - 1, node.Column),
new Position(node.Row + 1, node.Column),
new Position(node.Row, node.Column - 1),
new Position(node.Row, node.Column + 1),
})
{
if (IsValidPosition(neighborPosition.Row, neighborPosition.Column, PieceType.Tile)
&& TileBoard[neighborPosition.Row, neighborPosition.Column].Color == color)
{
yield return TileBoard[neighborPosition.Row, neighborPosition.Column];
}
}
}
public int TeamCount(CreeperColor turn, PieceType type)
{
if (turn == CreeperColor.Invalid || turn == CreeperColor.Empty)
throw new ArgumentOutOfRangeException(turn.ToString());
return ((turn == CreeperColor.Ice) ? ((type == PieceType.Peg) ? BlackPegs.Count : BlackTileCount) : ((type == PieceType.Peg) ? WhitePegs.Count : WhiteTileCount));
}
public bool CouldBeFinished(CreeperColor turnColor)
{
if (BlackPegs.Count == 0 || WhitePegs.Count == 0)
{
return true;
}
if (TeamCount(turnColor, PieceType.Tile) < _MinimumToWin)
{
return false;
}
AIBoardNode[] rowHeadArray = (turnColor == CreeperColor.Fire)? RowHeadWhite : RowHeadBlack;
AIBoardNode[] columnHeadArray = (turnColor == CreeperColor.Fire)? ColumnHeadWhite : ColumnHeadBlack;
if (rowHeadArray.Count(x => x != null) < _tileRows - 2
|| columnHeadArray.Count(x => x != null) < _tileRows - 2)
{
return false;
}
return true;
}
public CreeperGameState GetGameState(CreeperColor playerTurn)
{
if (TeamCount(playerTurn, PieceType.Peg) == 0 || TeamCount(playerTurn.Opposite(), PieceType.Peg) == 0)
{
return CreeperGameState.Draw;
}
bool gameOver = false;
bool stackEmpty = false;
Stack<AIBoardNode> stack = new Stack<AIBoardNode>();
HashSet<AIBoardNode> foundTiles = new HashSet<AIBoardNode>();
HashSet<AIBoardNode> endTiles = new HashSet<AIBoardNode>();
Position start = (playerTurn == CreeperColor.Fire) ? _WhiteStart : _BlackStart;
Position end = (playerTurn == CreeperColor.Fire) ? _WhiteEnd : _BlackEnd;
AIBoardNode winTile1 = TileBoard[end.Row - 1, end.Column];
AIBoardNode winTile2 = TileBoard[end.Row, IsValidPosition(end.Row, end.Column - 1, PieceType.Tile)? end.Column - 1: end.Column + 1];
if (winTile1.Color == playerTurn) endTiles.Add(winTile1);
if (winTile2.Color == playerTurn) endTiles.Add(winTile2);
if (!endTiles.Any())
{
return CreeperGameState.Unfinished;
}
AIBoardNode currentTile = TileBoard[start.Row, start.Column];
IEnumerable<AIBoardNode> neighbors = GetNeighbors(currentTile, playerTurn);
while (!stackEmpty && !(currentTile.Row == end.Row && currentTile.Column == end.Column))
{
foreach (AIBoardNode neighbor in neighbors)
{
if (!foundTiles.Contains(neighbor))
{
stack.Push(neighbor);
}
}
foundTiles.UnionWith(neighbors);
if (foundTiles.Intersect(endTiles).Any())
{
gameOver = true;
break;
}
if (stack.Any())
{
currentTile = stack.Pop();
}
else
{
stackEmpty = true;
}
neighbors = GetNeighbors(currentTile, playerTurn);
}
return gameOver ? CreeperGameState.Complete : CreeperGameState.Unfinished;
}
public Move(Position startPosition, Position endPosition, CreeperColor playerColor)
{
StartPosition = startPosition;
EndPosition = endPosition;
PlayerColor = playerColor;
}
public Move[] AllPossibleMoves(CreeperColor color)
{
if (color == CreeperColor.Invalid || color == CreeperColor.Empty) throw new ArgumentOutOfRangeException(color.ToString());
Position startPosition = new Position();
Move[] possibleMoves = new Move[100];
int index = 0;
foreach (AIBoardNode peg in (color == CreeperColor.Ice) ? BlackPegs : WhitePegs)
{
startPosition = new Position(peg.Row, peg.Column);
Move[] movesForPeg = new Move[]
{
new Move(startPosition, new Position(peg.Row + 1, peg.Column), color),
new Move(startPosition, new Position(peg.Row - 1, peg.Column), color),
new Move(startPosition, new Position(peg.Row, peg.Column + 1), color),
new Move(startPosition, new Position(peg.Row, peg.Column - 1), color),
new Move(startPosition, new Position(peg.Row + 1, peg.Column + 1), color),
new Move(startPosition, new Position(peg.Row + 1, peg.Column - 1), color),
new Move(startPosition, new Position(peg.Row - 1, peg.Column + 1), color),
new Move(startPosition, new Position(peg.Row - 1, peg.Column - 1), color),
new Move(startPosition, new Position(peg.Row + 2, peg.Column), color),
new Move(startPosition, new Position(peg.Row - 2, peg.Column), color),
new Move(startPosition, new Position(peg.Row, peg.Column + 2), color),
new Move(startPosition, new Position(peg.Row, peg.Column - 2), color),
};
for (int i = 0; i < movesForPeg.Length; i++)
{
if (IsValidMove(movesForPeg[i]))
{
possibleMoves[index++] = movesForPeg[i];
}
}
}
Array.Resize(ref possibleMoves, index);
return possibleMoves;
}
public IEnumerable<Piece> WhereTeam(CreeperColor color, PieceType pieceType)
{
IEnumerable<Piece> pieces = (pieceType == PieceType.Peg) ? Pegs : Tiles;
return pieces.Where(x => x.Color == color);
}
public Piece(CreeperColor color, Position position)
{
Color = color;
Position = position;
}
public bool IsFinished(CreeperColor playerTurn)
{
return GetGameState(playerTurn) != CreeperGameState.Unfinished;
}
public CreeperGameState GetGameState(CreeperColor playerTurn)
{
IEnumerable<Piece> currentTeam = WhereTeam(playerTurn, PieceType.Peg);
IEnumerable<Piece> opponentTeam = WhereTeam(playerTurn.Opposite(), PieceType.Peg);
if (!currentTeam.Any()
|| !currentTeam.SelectMany(x => CreeperUtility.PossibleMoves(x, this)).Any()
|| !opponentTeam.Any()
|| !opponentTeam.SelectMany(x => CreeperUtility.PossibleMoves(x, this)).Any())
{
return CreeperGameState.Draw;
}
bool gameOver = false;
bool stackEmpty = false;
Stack<Piece> stack = new Stack<Piece>();
HashSet<Piece> foundTiles = new HashSet<Piece>();
HashSet<Piece> endTiles = new HashSet<Piece>();
Position start = (playerTurn == CreeperColor.Fire) ? _WhiteStart : _BlackStart;
Position end = (playerTurn == CreeperColor.Fire) ? _WhiteEnd : _BlackEnd;
endTiles.UnionWith(Tiles.At(end).GetNeighbors(this).Where(x => x.Color == playerTurn));
if (!endTiles.Any())
{
return CreeperGameState.Unfinished;
}
Piece currentTile = Tiles.At(start);
IEnumerable<Piece> neighbors = currentTile.GetNeighbors(this).Where(x => x.Color == playerTurn);
while (!stackEmpty && !currentTile.Position.Equals(end))
{
foreach (Piece neighbor in neighbors)
{
if (!foundTiles.Contains(neighbor))
{
stack.Push(neighbor);
}
}
foundTiles.UnionWith(neighbors);
if (foundTiles.Intersect(endTiles).Any())
{
gameOver = true;
break;
}
if (stack.Any())
{
currentTile = stack.Pop();
}
else
{
stackEmpty = true;
}
neighbors = currentTile.GetNeighbors(this).Where(x => x.Color == playerTurn);
}
return gameOver ? CreeperGameState.Complete : CreeperGameState.Unfinished;
}
private void StartLocalHardAIGame(CreeperColor playerColor)
{
AppModel.AI.Difficulty = AIDifficulty.Hard;
AppModel.EventAggregator.Publish(new InitializeGameMessage()
{
Settings = new GameSettings()
{
AI = AppModel.AI,
Board = new CreeperBoard(),
Player1Type = playerColor.IsFire() ? PlayerType.Human : PlayerType.AI,
Player2Type = playerColor.IsFire() ? PlayerType.AI : PlayerType.Human,
StartingColor = CreeperColor.Fire,
}
});
}
public Player(PlayerType playerType, CreeperColor creeperColor)
{
Type = playerType;
Color = creeperColor;
}
public GameOverViewModel(CreeperColor? winner)
{
_winner = winner;
}
