public Tuple <VirtualPiece, Vector2Int> DoEverythingBecauseNothingWorks()
{
int maxUtils = 1500;
VirtualPiece bestMovePiece = null;
Vector2Int bestMovePosition = new Vector2Int(0, 0);
foreach (VirtualPiece piece in playerPiecesDict[playerTurn])
{
List <Vector2Int> possileCells = piece.CheckPathing();
Vector2Int currentPosition = piece.cCurrentPosition;
bool isDead = piece.cIsDead;
foreach (Vector2Int movement in possileCells)
{
VirtualBoard newVirtualBoard = CloneVirtualBoard();
VirtualPiece newPiece = newVirtualBoard.FindPiece(piece.cCurrentPosition, piece.cPieceName, isDead, piece.cPlayerInt);
newPiece.MovePiece(movement.x, movement.y);
newVirtualBoard.player1Utils = newVirtualBoard.EvaluateVirtualBoard();
if (newVirtualBoard.aiPlayerWinning)
{
maxUtils = newVirtualBoard.player1Utils;
bestMovePiece = piece;
bestMovePosition = movement;
return(new Tuple <VirtualPiece, Vector2Int>(bestMovePiece, bestMovePosition));
}
int maxUtils2 = -1500;
VirtualPiece bestMovePiece2 = null;
Vector2Int bestMovePosition2 = new Vector2Int(0, 0);
foreach (VirtualPiece piece2 in newVirtualBoard.playerPiecesDict[newVirtualBoard.playerTurn])
{
List <Vector2Int> possileCells2 = piece2.CheckPathing();
Vector2Int currentPosition2 = piece2.cCurrentPosition;
bool isDead2 = piece2.cIsDead;
foreach (Vector2Int movement2 in possileCells2)
{
VirtualBoard newVirtualBoard2 = newVirtualBoard.CloneVirtualBoard();
VirtualPiece newPiece2 = newVirtualBoard2.FindPiece(piece2.cCurrentPosition, piece2.cPieceName, isDead2, piece2.cPlayerInt);
newPiece2.MovePiece(movement2.x, movement2.y);
newVirtualBoard2.player1Utils = newVirtualBoard2.EvaluateVirtualBoard();
if (newVirtualBoard2.player1Utils > maxUtils2)
{
maxUtils2 = newVirtualBoard2.player1Utils;
newVirtualBoard.player1Utils = newVirtualBoard2.player1Utils;
bestMovePiece2 = newPiece2;
bestMovePosition2 = movement2;
}
}
}
if (newVirtualBoard.player1Utils < maxUtils)
{
maxUtils = newVirtualBoard.player1Utils;
bestMovePiece = piece;
bestMovePosition = movement;
}
}
}
return(new Tuple <VirtualPiece, Vector2Int>(bestMovePiece, bestMovePosition));
}
public VirtualBoard CloneVirtualBoard()
{
VirtualBoard newVirtualBoard = new VirtualBoard();
for (int x = 0; x < mAllCells.GetLength(0); x++)
{
for (int y = 0; y < mAllCells.GetLength(1); y++)
{
if (mAllCells[x, y] != null)
{
VirtualPiece newPiece = mAllCells[x, y].ClonePiece(newVirtualBoard);
newVirtualBoard.mAllCells[x, y] = newPiece;
newVirtualBoard.playerPiecesDict[newPiece.cPlayerInt].Add(newPiece);
}
}
}
foreach (KeyValuePair <int, List <VirtualPiece> > kvp in sideBoardDict)
{
for (int x = 0; x < kvp.Value.Count; x++)
{
VirtualPiece newPiece = kvp.Value[x].ClonePiece(newVirtualBoard);
newVirtualBoard.sideBoardDict[kvp.Key].Add(newPiece);
}
}
newVirtualBoard.playerTurn = SwitchPlayerTurn();
return(newVirtualBoard);
}
public Tuple <VirtualPiece, Vector2Int> GetBestMove2()
{
virtualBoard = new VirtualBoard();
virtualBoard.SetVirtualBoard(gameBoard);
virtualBoard.CreateRecursiveBoardDict();
foreach (KeyValuePair <Tuple <VirtualPiece, Vector2Int>, VirtualBoard> kvp in virtualBoard.recursiveBoardDict)
{
kvp.Value.CreateRecursiveBoardDict();
foreach (KeyValuePair <Tuple <VirtualPiece, Vector2Int>, VirtualBoard> kvp2 in kvp.Value.recursiveBoardDict)
{
kvp2.Value.CreateRecursiveBoardDict();
foreach (KeyValuePair <Tuple <VirtualPiece, Vector2Int>, VirtualBoard> kvp3 in kvp2.Value.recursiveBoardDict)
{
kvp3.Value.CreateRecursiveBoardDict();
foreach (KeyValuePair <Tuple <VirtualPiece, Vector2Int>, VirtualBoard> kvp4 in kvp3.Value.recursiveBoardDict)
{
kvp4.Value.CreateRecursiveBoardDict();
}
kvp3.Value.GetBestMove();
}
kvp2.Value.GetBestMove();
}
kvp.Value.GetBestMove();
}
virtualBoard.GetBestMove();
return(virtualBoard.bestMove);
}
public VirtualPiece ClonePiece(VirtualBoard newVirtualBoard)
{
VirtualPiece newPiece = new VirtualPiece();
newPiece.SetVirtualPiece(cPieceName, cPlayerInt, cPossibleMovement, cIsDead, cCurrentPosition, newVirtualBoard);
return(newPiece);
}
//***Let your strategic brain go nutz here!! All of this below is just **Example** code
// Example Function - Returns a random safe *ChessMove*
private ChessMove GetSafeMoves(List <ChessMove> lsMoves)
{
List <ChessMove> SafeMoves = new List <ChessMove>();
// Find the Safe moves
foreach (ChessMove move in lsMoves)
{
// Look in the future
ChessMove mve = VirtualBoard.MovePiece(move); // capture possible return of additional information into the move (This MUST be done)
bool isPieceSafe = VirtualBoard.IsSafe(mve.PieceMoved.Location, Me);
VirtualBoard.UndoMovePiece(mve);
if (isPieceSafe)
{
SafeMoves.Add(mve);
}
}
if (SafeMoves.Count > 0)
{
return(SafeMoves[_rando.Next(0, SafeMoves.Count)]); // Return a random safe move
}
else // No safe moves
{
return(lsMoves[_rando.Next(0, lsMoves.Count)]); // Return a random move
}
}
public void SetVirtualPiece(string pieceName, int playerInt, List <Vector2Int> possibleMovement, bool isDead, Vector2Int currentPosition, VirtualBoard virtualBoard)
{
cPieceName = pieceName;
cPlayerInt = playerInt;
cPossibleMovement = possibleMovement;
cIsDead = isDead;
cCurrentPosition = currentPosition;
cVirtualBoard = virtualBoard;
}
//=======================================================================================
//
// Your Bot Brain Goes Here *Example Code provided
//
//=======================================================================================
public List <ChessMove> GetAllMoves() // Returns a List of All legal *ChessMove* for your *GamePiece*'s
{
List <ChessMove> lsOfMoves = new List <ChessMove>();
// Iterate through all your gamepieces
foreach (GamePiece piece in Me.MyPieces.FindAll(p => p.isAlive)) // Usefull, no point in moving a DEAD GamePiece
{
List <ChessMove> moves = VirtualBoard.PossibleMoves(piece);
lsOfMoves.AddRange(moves);
}
return(lsOfMoves);
}
// Example Function - Returns a single *ChessMove*
private ChessMove GetTheSafest(List <ChessMove> lsMoves)
{
List <ChessMove> betterMoves = lsMoves.FindAll(m => m.MoveType == Condition.Attack); // Lambda's for searching Lists are a powerful tool.
List <ChessMove> bestMoves = new List <ChessMove>();
if (betterMoves.Count > 0)
{
foreach (ChessMove move in betterMoves)
{
// Look in the future
ChessMove mve = VirtualBoard.MovePiece(move); // capture possible return of additional information into the move (This MUST be done if pawn)
bool isPieceSafe = VirtualBoard.IsSafe(mve.PieceMoved.Location, Me);
VirtualBoard.UndoMovePiece(mve);
if (isPieceSafe)
{
bestMoves.Add(move);
}
}
}
if (bestMoves.Count < 0)
{
foreach (ChessMove move in lsMoves)
{
// Look in the future
ChessMove mve = VirtualBoard.MovePiece(move); // capture possible return of additional information into the move (This MUST be done if pawn)
bool isPieceSafe = VirtualBoard.IsSafe(mve.PieceMoved.Location, Me);
VirtualBoard.UndoMovePiece(mve);
if (isPieceSafe)
{
bestMoves.Add(mve);
}
}
}
if (bestMoves.Count > 0)
{
return(bestMoves[_rando.Next(0, bestMoves.Count)]);
}
else
{
return(lsMoves[_rando.Next(0, lsMoves.Count)]);
}
}
public void ResetNewBoard()
{
virtualBoard = new VirtualBoard();
virtualBoard.SetVirtualBoard(gameBoard);
virtualBoard.CreateRecursiveBoardDict();
foreach (KeyValuePair <Tuple <VirtualPiece, Vector2Int>, VirtualBoard> kvp in virtualBoard.recursiveBoardDict)
{
kvp.Value.CreateRecursiveBoardDict();
foreach (KeyValuePair <Tuple <VirtualPiece, Vector2Int>, VirtualBoard> kvp2 in kvp.Value.recursiveBoardDict)
{
kvp2.Value.CreateRecursiveBoardDict();
}
}
foreach (KeyValuePair <Tuple <VirtualPiece, Vector2Int>, VirtualBoard> kvp in virtualBoard.recursiveBoardDict)
{
foreach (KeyValuePair <Tuple <VirtualPiece, Vector2Int>, VirtualBoard> kvp2 in kvp.Value.recursiveBoardDict)
{
kvp2.Value.GetUtilsFromFutureMove();
}
kvp.Value.GetUtilsFromFutureMove();
}
}
public void CreateRecursiveBoardDict()
{
foreach (VirtualPiece piece in playerPiecesDict[playerTurn])
{
List <Vector2Int> possileCells = piece.CheckPathing();
Vector2Int currentPosition = piece.cCurrentPosition;
bool isDead = piece.cIsDead;
foreach (Vector2Int movement in possileCells)
{
VirtualBoard newVirtualBoard = CloneVirtualBoard();
VirtualPiece newPiece = newVirtualBoard.FindPiece(piece.cCurrentPosition, piece.cPieceName, isDead, piece.cPlayerInt);
newPiece.MovePiece(movement.x, movement.y);
newVirtualBoard.player1Utils = newVirtualBoard.EvaluateVirtualBoard();
recursiveBoardDict.Add(new Tuple <VirtualPiece, Vector2Int>(piece, movement), newVirtualBoard);
}
}
// foreach (VirtualPiece piece in playerPiecesDict[playerTurn])
//{
// if (piece.cPlayerInt == playerTurn)
// {
// List<Vector2Int> possileCells = piece.CheckPathing();
// Vector2Int currentPosition = piece.cCurrentPosition;
// bool isDead = piece.cIsDead;
// foreach (Vector2Int movement in possileCells)
// {
// VirtualBoard newVirtualBoard = CloneVirtualBoard();
// VirtualPiece newPiece = newVirtualBoard.FindPiece(piece.cCurrentPosition, piece.cPieceName, isDead, piece.cPlayerInt);
// newPiece.MovePiece(movement.x, movement.y);
// newVirtualBoard.player1Utils = newVirtualBoard.EvaluateVirtualBoard();
// recursiveBoardDict.Add(new Tuple<VirtualPiece, Vector2Int>(piece, movement), newVirtualBoard);
// }
// }
//}
}
public Tuple <VirtualPiece, Vector2Int> GetBestMove()
{
virtualBoard = new VirtualBoard();
virtualBoard.SetVirtualBoard(gameBoard);
return(virtualBoard.DoEverythingBecauseNothingWorks());
}
