private void CheckCardinalDirections(Board board)
{
foreach (int fileOffset in new[] { -1, 0, 1 })
{
foreach (int rankOffset in Math.Abs(fileOffset) == 1 ? new[] { 0 } : new[] { -1, 1 })
{
Square testSquare = new Square(Position, fileOffset, rankOffset);
Movement testMove = new Movement(Position, testSquare);
while (testSquare.IsValid)
{
Square enemyKingPosition = Color == Side.White ? board.BlackKing.Position : board.WhiteKing.Position;
if (board.IsOccupied(testSquare))
{
if (!board.IsOccupiedBySide(testSquare, Color) && Rules.MoveObeysRules(board, testMove, Color) && testSquare != enemyKingPosition)
{
LegalMoves.Add(new Movement(testMove));
}
break;
}
if (Rules.MoveObeysRules(board, testMove, Color) && testSquare != enemyKingPosition)
{
LegalMoves.Add(new Movement(testMove));
}
testSquare = new Square(testSquare, fileOffset, rankOffset);
testMove = new Movement(Position, testSquare);
}
}
}
}
public override void UpdateLegalMoves(Board board, Square enPassantEligibleSquare)
{
LegalMoves.Clear();
CheckSurroundingSquares(board);
CheckCastlingMoves(board);
}
public override void UpdateLegalMoves(Board board, Square enPassantEligibleSquare)
{
LegalMoves.Clear();
CheckForwardMovingSquares(board);
CheckAttackingSquares(board);
CheckEnPassantCaptures(board, enPassantEligibleSquare);
}
// make the chosen move, update board, game result and moves
internal BoardModel MakeMove(int index)
{
if (!(index >= 0 && index < LegalMoves.Count()))
{
throw Error.Argument("index out of range");
}
return(CreateMoved(this, LegalMoves[index]));
}
void Awake()
{
instance = this;
board = GetComponent <GameBoard>();
legal = GetComponent <LegalMoves>();
devUI.SetActive(inDevMode);
gameUI.SetActive(!inDevMode);
}
public bool canCastleQueenside() //returns true if the king can castle queenside (from E file to C file)
{
Piece rook = new Piece();
Coordinate pTmp = new Coordinate(Position);
pTmp.changeFile(-4); //moves from E file to A file
rook = board.board[pTmp.Rank, pTmp.File];
if (rook == null) //there is no piece where rook should be
{
return(false);
}
if (!(rook is Rook)) //the piece there is not a rook
{
return(false);
}
if (rook.hasMoved == true) //the rook there has already moved
{
return(false);
}
//figure out if the squares between the rook and king are empty MOVE TO POSSIBLE/LEGAL MOVES
pTmp.changeFile(1);
if (board.isTherePiece(pTmp) == true) //if there is a piece on B file
{
return(false);
}
pTmp.changeFile(1);
if (board.isTherePiece(pTmp) == true) //if there is a piece on C file
{
return(false);
}
if (IntoCheck(pTmp)) //if being on C file would cause check
{
return(false);
}
pTmp.changeFile(1);
if (board.isTherePiece(pTmp) == true) //if there is a piece on the D file
{
return(false);
}
if (IntoCheck(pTmp)) //if being on the D file would cause check
{
return(false);
}
if (board.inCheck(Color)) //if the king is already in check
{
return(false);
}
//if all of these are false and it has reached here, castling kingside is legal
pTmp.changeFile(-1); //moves pTmp from D file to C file
LegalMoves.Add(pTmp);
return(true);
}
public World(IPlayer p1, IPlayer p2)
{
this.player1 = p1;
this.player2 = p2;
this.board = new Board();
p1.setBoard(board);
p2.setBoard(board);
cowBox = new CowBox(board);
p1.setCowBox(cowBox);
p2.setCowBox(cowBox);
referee = new Referee(board, p1.symbol);
legalMoves = new LegalMoves(board, cowBox);
referee.currentPlayer = p1.symbol;
}
void Awake()
{
localBest = PlayerPrefs.GetInt("localbest", 0);
localBestUI.text = localBest + "";
worldBest = PlayerPrefs.GetInt("worldbest", localBest);
worldBestUI.text = worldBest + "";
board = GetComponent <GameBoard>();
puzzles = GetComponent <PuzzleManager>();
legal = GetComponent <LegalMoves>();
ai = GetComponent <AI>();
cam = Camera.main;
inGameMode = !DeveloperMode.InDevMode();
}
void Start()
{
if (DeveloperMode.InDevMode())
{
legalMoves = GetComponent <LegalMoves>();
board = GetComponent <GameBoard>();
devMode = GetComponent <DeveloperMode>();
StreamReader reader = new StreamReader("Assets/Puzzles/PGN.txt");
CustomMethods.MeasureExecutionTime(false);
pgn = reader.ReadToEnd();
CustomMethods.MeasureExecutionTime(true);
reader.Close();
ReadPGN(pgn);
}
}
// generate actual moves if not done already during condition checking
// assumes CurrentPlayer set already
internal void GenerateMoves()
{
if (!_donemovegen)
{
LegalMoves.AddRange(_game.CreateDrops(this));
LegalMoves.AddRange(_game.CreateMoves(this));
var passoption = _game.Def.GetProperty("pass turn") ?? OptionValue.False;
var allowpass = passoption.Equals(OptionValue.True) ||
(LegalMoves.Count == 0 && passoption.Equals(OptionValue.Forced));
if (allowpass)
{
LegalMoves.Insert(0, MoveModel.Create(Turn.TurnPlayer, PositionValue.None, PieceValue.None));
}
_donemovegen = true;
}
}
private void CheckAttackingSquares(Board board)
{
foreach (int fileOffset in new[] { -1, 1 })
{
int rankOffset = Color == Side.White ? 1 : -1;
Square testSquare = new Square(Position, fileOffset, rankOffset);
Movement testMove = new Movement(Position, testSquare);
Square enemyKingPosition = Color == Side.White ? board.BlackKing.Position : board.WhiteKing.Position;
if (testSquare.IsValid && board.IsOccupiedBySide(testSquare, Color.Complement()) && Rules.MoveObeysRules(board, testMove, Color) && testSquare != enemyKingPosition)
{
bool pawnAtSecondToLastRank = Position.Rank == (Color == Side.White ? 7 : 2);
Movement move = pawnAtSecondToLastRank ? new PromotionMove(Position, testSquare) : new Movement(testMove);
LegalMoves.Add(move);
}
}
}
private void CheckSurroundingSquares(Board board)
{
for (int fileOffset = -1; fileOffset <= 1; fileOffset++)
{
for (int rankOffset = -1; rankOffset <= 1; rankOffset++)
{
if (fileOffset == 0 && rankOffset == 0)
{
continue;
}
Square testSquare = new Square(Position, fileOffset, rankOffset);
Movement testMove = new Movement(Position, testSquare);
Square enemyKingPosition = Color == Side.White ? board.BlackKing.Position : board.WhiteKing.Position;
if (testSquare.IsValid && !board.IsOccupiedBySide(testSquare, Color) && Rules.MoveObeysRules(board, testMove, Color) && testSquare != enemyKingPosition)
{
LegalMoves.Add(new Movement(testMove));
}
}
}
}
private void CheckCastlingMoves(Board board)
{
if (!HasMoved && !Rules.IsPlayerInCheck(board, Color))
{
int castlingRank = Color == Side.White ? 1 : 8;
List <Square> rookSquares = new List <Square> {
new Square(1, castlingRank), new Square(8, castlingRank)
};
List <Square> inBetweenSquares = new List <Square>();
List <Movement> inBetweenMoves = new List <Movement>();
for (int rookSquareIndex = 0; rookSquareIndex < rookSquares.Count; rookSquareIndex++)
{
if (board[rookSquares[rookSquareIndex]] is Rook rook && !rook.HasMoved && rook.Color == Color)
{
bool checkingQueensideCastle = rookSquareIndex == 0;
inBetweenSquares.Add(new Square(checkingQueensideCastle ? 4 : 6, castlingRank));
inBetweenSquares.Add(new Square(checkingQueensideCastle ? 3 : 7, castlingRank));
if (checkingQueensideCastle)
{
inBetweenSquares.Add(new Square(2, castlingRank));
}
if (!board.IsOccupied(inBetweenSquares[0]) && !board.IsOccupied(inBetweenSquares[1]) && (!checkingQueensideCastle || !board.IsOccupied(inBetweenSquares[2])))
{
inBetweenMoves.Add(new Movement(Position, inBetweenSquares[0]));
inBetweenMoves.Add(new Movement(Position, inBetweenSquares[1]));
if (Rules.MoveObeysRules(board, inBetweenMoves[0], Color) && Rules.MoveObeysRules(board, inBetweenMoves[1], Color))
{
LegalMoves.Add(new CastlingMove(Position, inBetweenSquares[1], rook));
}
}
inBetweenSquares.Clear();
inBetweenMoves.Clear();
}
}
}
}
private void CheckForwardMovingSquares(Board board)
{
int advancingDirection = Color == Side.White ? 1 : -1;
Square testSquare = new Square(Position, 0, advancingDirection);
Movement testMove = new Movement(Position, testSquare);
if (!board.IsOccupied(testSquare) && Rules.MoveObeysRules(board, testMove, Color))
{
bool amOnSecondToLastRank = Position.Rank == (Color == Side.White ? 7 : 2);
LegalMoves.Add(amOnSecondToLastRank ? new PromotionMove(Position, testSquare) : new Movement(testMove));
}
if (!HasMoved)
{
testSquare = new Square(testSquare, 0, advancingDirection);
testMove = new Movement(Position, testSquare);
if (!board.IsOccupied(testSquare) && Rules.MoveObeysRules(board, testMove, Color))
{
LegalMoves.Add(new Movement(testMove));
}
}
}
// Returns all the legal moves for the given cell
public ArrayList GetLegalMoves(Cell source)
{
ArrayList LegalMoves;
LegalMoves = GetPossibleMoves(source); // Get the legal moves
ArrayList ToRemove = new ArrayList(); // contains a list of all the moves to remove
// Now check and mark all the moves which moves user under check
foreach (Cell target in LegalMoves)
{
// if the move place or leave the user under check
if (CauseCheck(new Move(source, target)))
{
ToRemove.Add(target);
}
}
// When checking the moves for the king, don't allow tower/caslting, if
// the king is under check
if (source.piece.Type == Piece.PieceType.King && IsUnderCheck(source.piece.Side.type))
{
foreach (Cell target in LegalMoves)
{
//if the move place or leave the user under check
if (Math.Abs(target.col - source.col) > 1)
{
ToRemove.Add(target);
}
}
}
// remove all the illegal moves
foreach (Cell cell in ToRemove)
{
LegalMoves.Remove(cell); // remove the illegal move
}
return(LegalMoves);
}
private void CheckKnightCircleSquares(Board board)
{
for (int fileOffset = -2; fileOffset <= 2; fileOffset++)
{
if (fileOffset == 0)
{
continue;
}
foreach (int rankOffset in Math.Abs(fileOffset) == 2 ? new[] { -1, 1 } : new[] { -2, 2 })
{
Square testSquare = new Square(Position, fileOffset, rankOffset);
Movement testMove = new Movement(Position, testSquare);
Square enemyKingPosition = Color == Side.White ? board.BlackKing.Position : board.WhiteKing.Position;
if (testSquare.IsValid && !board.IsOccupiedBySide(testSquare, Color) && Rules.MoveObeysRules(board, testMove, Color) && testSquare != enemyKingPosition)
{
LegalMoves.Add(new Movement(testMove));
}
}
}
}
private void CheckEnPassantCaptures(Board board, Square enPassantEligibleSquare)
{
if (Color == Side.White ? Position.Rank == 5 : Position.Rank == 4)
{
foreach (int fileOffset in new[] { -1, 1 })
{
Square lateralSquare = new Square(Position, fileOffset, 0);
if (lateralSquare.IsValid && board[lateralSquare] is Pawn enemyLateralPawn && enemyLateralPawn.Color != Color)
{
Square squareToCheckWithEligibleSquare = new Square(enemyLateralPawn.Position, 0, enemyLateralPawn.Color == Side.White ? -1 : 1);
if (squareToCheckWithEligibleSquare.Equals(enPassantEligibleSquare))
{
EnPassantMove testMove = new EnPassantMove(Position, enPassantEligibleSquare, enemyLateralPawn);
if (Rules.MoveObeysRules(board, testMove, Color))
{
LegalMoves.Add(new EnPassantMove(Position, enPassantEligibleSquare, enemyLateralPawn));
}
}
}
}
}
}
void Awake()
{
legalMoves = GetComponent <LegalMoves>();
manager = GetComponent <GameManager>();
drawBoard = GetComponent <DrawBoard>();
ai = GetComponent <AI>();
analysisBoard = new Square[8, 8];
board = new Piece[8, 8];
for (int ranks = 0; ranks < 8; ranks++)
{
for (int files = 0; files < 8; files++)
{
board[files, ranks] = drawBoard.GetSquare(files, ranks);
board[files, ranks].piece = Pieces.Empty;
board[files, ranks].coordinates = new Coord(files, ranks);
}
}
SetupFromFEN(startFEN);
}
// Returns all the legal moves for the given cell
public ArrayList GetLegalMoves(Cell source)
{
ArrayList LegalMoves;
LegalMoves = GetPossibleMoves(source); // Get the legal moves
ArrayList ToRemove = new ArrayList(); // contains a list of all the moves to remove
// Now check and mark all the moves which moves user under check
foreach (Cell target in LegalMoves)
{
// if the move place or leave the user under check
if (CauseCheck(new Move(source, target)))
{
ToRemove.Add(target);
}
}
// remove all the illegal moves
foreach (Cell cell in ToRemove)
{
LegalMoves.Remove(cell); // remove the illegal move
}
return(LegalMoves);
}
void Awake()
{
legalMoves = GetComponent <LegalMoves>();
board = GetComponent <GameBoard>();
}
public override void UpdateLegalMoves(Board board, Square enPassantEligibleSquare)
{
LegalMoves.Clear();
CheckCardinalDirections(board);
}
public override void UpdateLegalMoves(Board board, Square enPassantEligibleSquare)
{
LegalMoves.Clear();
CheckKnightCircleSquares(board);
}
// Write puzzle to file (position is the game position - white to move and mate, finalMove is black's previous move that resulted in this position, and difficulty is a range from 0-100)
public static string GetPuzzleFEN(Square[,] position, Coord finalMoveFrom, Coord finalMoveTo, LegalMoves legal)
{
string puzzleFEN = "";
int skipCount = 0;
Coord epSquare = new Coord();
bool isEP = false;
for (int ranks = 7; ranks >= 0; ranks--)
{
for (int files = 0; files < 8; files++)
{
if (position[files, ranks].piece == GameBoard.Pieces.Empty)
{
skipCount++;
}
else
{
if (skipCount > 0)
{
puzzleFEN += skipCount.ToString();
skipCount = 0;
}
puzzleFEN += PieceToNotation(position[files, ranks].piece, position[files, ranks].pieceColour);
if (position[files, ranks].isEnPassantSquare)
{
isEP = true;
epSquare = new Coord(files, ranks);
}
}
}
if (skipCount > 0)
{
puzzleFEN += skipCount.ToString();
skipCount = 0;
}
if (ranks != 0)
{
puzzleFEN += "/";
}
}
puzzleFEN += " w ";
if (legal.whiteCanCastleKingside)
{
puzzleFEN += "K";
}
if (legal.whiteCanCastleQueenside)
{
puzzleFEN += "Q";
}
if (legal.blackCanCastleKingside)
{
puzzleFEN += "k";
}
if (legal.blackCanCastleQueenside)
{
puzzleFEN += "q";
}
if (!legal.whiteCanCastleKingside && !legal.whiteCanCastleQueenside && !legal.blackCanCastleKingside && !legal.blackCanCastleQueenside)
{
puzzleFEN += "-";
}
if (isEP)
{
puzzleFEN += " " + "abcdefgh"[epSquare.x] + (epSquare.y + 1) + " ";
}
else
{
puzzleFEN += " - ";
}
puzzleFEN += "[" + finalMoveFrom.x + "" + finalMoveFrom.y + "" + finalMoveTo.x + "" + finalMoveTo.y + "]";
return(puzzleFEN);
}
