public static IEnumerable<Piece> GetNeighbors(this Piece tile, CreeperBoard board)
{
List<CardinalDirection> neighborlyDirections = new List<CardinalDirection> { CardinalDirection.North, CardinalDirection.South, CardinalDirection.East, CardinalDirection.West };
return neighborlyDirections
.Where(x => board.Tiles.Any(y => y.Position == tile.Position.AtDirection(x)))
.Select(x => board.Tiles.At(tile.Position.AtDirection(x)));
}
public AICreeperBoard(CreeperBoard board)
{
_tileRows = CreeperBoard.TileRows;
_pegRows = CreeperBoard.PegRows;
BlackTileCount = 0;
WhiteTileCount = 0;
BlackPegs = new HashSet<AIBoardNode>();
WhitePegs = new HashSet<AIBoardNode>();
TileHistory = new Stack<CreeperColor>();
MoveHistory = new Stack<Move>();
GameStateHistory = new Stack<CreeperGameState>();
TileBoard = new AIBoardNode[_tileRows, _tileRows];
PegBoard = new AIBoardNode[_pegRows, _pegRows];
RowHeadBlack = new AIBoardNode[_tileRows];
RowHeadWhite = new AIBoardNode[_tileRows];
ColumnHeadBlack = new AIBoardNode[_tileRows];
ColumnHeadWhite = new AIBoardNode[_tileRows];
foreach (Piece tile in board.Tiles)
{
TileBoard[tile.Position.Row, tile.Position.Column] = new AIBoardNode(tile.Position.Row, tile.Position.Column, tile.Color);
}
foreach (Piece peg in board.Pegs)
{
PegBoard[peg.Position.Row, peg.Position.Column] = new AIBoardNode(peg.Position.Row, peg.Position.Column, peg.Color);
if (peg.Color == CreeperColor.Ice)
{
BlackPegs.Add(PegBoard[peg.Position.Row, peg.Position.Column]);
}
else if (peg.Color == CreeperColor.Fire)
{
WhitePegs.Add(PegBoard[peg.Position.Row, peg.Position.Column]);
}
}
for (int row = 0; row < _tileRows; row++)
{
for (int column = 0; column < _tileRows; column++)
{
if (TileBoard[row, column].Color == CreeperColor.Ice || TileBoard[row, column].Color == CreeperColor.Fire)
{
UpdateListHeads(row, column, TileBoard[row, column].Color);
AddTileToTeam(TileBoard[row, column]);
}
}
}
//Hash = new AIHash(this);
}
public static IEnumerable<Move> PossibleMoves(this Piece peg, CreeperBoard board)
{
List<Piece> pegs = new List<Piece>(board.Pegs);
if (peg.Color == CreeperColor.Empty || peg.Color == CreeperColor.Invalid)
{
yield break;
}
List<CardinalDirection> neighborlyDirections = new List<CardinalDirection>
{
CardinalDirection.North,
CardinalDirection.Northeast,
CardinalDirection.Northwest,
CardinalDirection.South,
CardinalDirection.Southeast,
CardinalDirection.Southwest,
CardinalDirection.East,
CardinalDirection.West
};
foreach (CardinalDirection direction in neighborlyDirections)
{
Position destinationPosition = peg.Position.AtDirection(direction);
if (CreeperBoard.IsValidPosition(destinationPosition, PieceType.Peg)
&& pegs.At(destinationPosition).Color == CreeperColor.Empty)
{
yield return new Move(peg.Position, destinationPosition, peg.Color);
}
if (
(direction == CardinalDirection.North
|| direction == CardinalDirection.South
|| direction == CardinalDirection.East
|| direction == CardinalDirection.West
)
&& (CreeperBoard.IsValidPosition(destinationPosition, PieceType.Peg))
&& (pegs.At(destinationPosition).Color == ((peg.Color == CreeperColor.Fire) ? CreeperColor.Ice : CreeperColor.Fire))
)
{
destinationPosition = destinationPosition.AtDirection(direction);
if (CreeperBoard.IsValidPosition(destinationPosition, PieceType.Peg)
&& pegs.At(destinationPosition).Color == CreeperColor.Empty)
{
yield return new Move(peg.Position, destinationPosition, peg.Color);
}
}
}
yield break;
}
public static void AIGame(CreeperBoard board)
{
CreeperAI.CreeperAI creeperAI = new CreeperAI.CreeperAI(2, 10, .01, 11, 1000);
bool pauseAfterPrint = false;
bool gameOver = false;
CreeperColor turn = CreeperColor.Ice;
while (!board.IsFinished(turn)
&& board.Pegs.Any(x => x.Color == CreeperColor.Fire)
&& board.Pegs.Any(x => x.Color == CreeperColor.Ice))
{
turn = (turn == CreeperColor.Fire) ? CreeperColor.Ice : CreeperColor.Fire;
board.Move(creeperAI.GetMove(board, turn));
board.PrintToConsole(pauseAfterPrint);
}
Console.WriteLine(String.Format("{0} won.", turn.ToString()));
}
public static void WhiteWin(CreeperBoard board)
{
Position startPosition;
Position endPosition;
Move move;
bool pausePrint = false;
for (int i = 0; i < 4; i++)
{
startPosition = new Position(i, i + 1);
endPosition = new Position(i + 1, i + 2);
move = new Move(startPosition, endPosition, CreeperColor.Fire);
board.Move(move);
board.PrintToConsole(pausePrint);
}
for (int i = 0; i < 3; i++)
{
startPosition = new Position(i, i + 2);
endPosition = new Position(i + 1, i + 3);
move = new Move(startPosition, endPosition, CreeperColor.Fire);
board.Move(move);
board.PrintToConsole(pausePrint);
}
startPosition = new Position(4, 6);
endPosition = new Position(5, 5);
move = new Move(startPosition, endPosition, CreeperColor.Fire);
board.Move(move);
board.PrintToConsole(pausePrint);
startPosition = new Position(4, 5);
endPosition = new Position(5, 4);
move = new Move(startPosition, endPosition, CreeperColor.Fire);
board.Move(move);
board.PrintToConsole(pausePrint);
if(board.GetGameState(CreeperColor.Fire) == CreeperGameState.Complete)
{
Console.WriteLine("White wins!");
}
}
public static void JumpTest(CreeperBoard board)
{
// test's a non jumping of flipping move
/* if (board.IsValidMove(new Move(new Position(1, 2), new Position(2, 3), CreeperColor.White)))
{
Console.WriteLine("SideMove Test passed!");
}
else
{
Console.WriteLine("SideMove Test failed");
}*/
board.Move(new Move(new Position(4,0),new Position(3,0),CreeperColor.Ice));
//board.Move(new Move(new Position(2, 0), new Position(4, 0), CreeperColor.White));
if (board.IsValidMove(new Move(new Position(2,0), new Position(4,0), CreeperColor.Fire)))
{
Console.WriteLine("Jump Test works!");
}
else
{
Console.WriteLine("Jump Test Failed");
}
}
static void PrintAICreeperBoard(CreeperBoard board)
{
board.ReadFromFile("TestBoard.txt");
AICreeperBoard AIBoard = new AICreeperBoard(board);
AIBoard.PrintToConsole();
}
static void Main(string[] args)
{
CreeperBoard board = new CreeperBoard();
//PrintAICreeperBoard(board);
//board.ReadFromFile("TestBoard.txt");
//board.PrintToConsole();
//WhiteWin(board);
AIGame(board);
//Testfunction(board);
//using (XNAControlGame.Game1 game = new XNAControlGame.Game1())
//{
// game.Run();
//}
}
public CreeperBoard(CreeperBoard board)
{
Pegs = board.Pegs.Select(x => new Piece(x.Color, x.Position)).ToList();
Tiles = board.Tiles.Select(x => new Piece(x.Color, x.Position)).ToList();
}
public bool Defeats(Gene opponent)
{
try
{
int moveCount = 0;
CreeperColor turn = CreeperColor.Ice;
CreeperBoard board = new CreeperBoard();
CreeperAI.AI thisAI = new CreeperAI.AI(_weights);
CreeperAI.AI opponentAI = new CreeperAI.AI(opponent._weights);
while (!board.IsFinished(turn))
{
moveCount++;
if (moveCount > 70)
{
Console.WriteLine("Move Loop");
return false;
}
turn = turn.Opposite();
if (turn == CreeperColor.Fire)
{
board.Move(thisAI.GetMove(board, turn));
}
else
{
board.Move(opponentAI.GetMove(board, turn));
}
}
return turn == CreeperColor.Fire && board.GetGameState(turn) == CreeperGameState.Complete;
}
catch (Exception)
{
Console.WriteLine("Exception");
return false;
}
}
public CreeperBoard GetBoard()
{
return _board = _board ?? new CreeperBoard();
}
