1
0
mirror of https://github.com/tiyn/yeschess.git synced 2026-02-22 10:34:47 +01:00

Compare commits

...

2 Commits

Author SHA1 Message Date
TiynGER
0a0accb3d0 chess: Moved replaced with CastleRights
Moved was a 10x12 1-d array, that stored bools.
It was only used for checking if a pawn moved (especially important for
the double move of the pawns) and if the other pieces moved (important
for checking if the player can castle or not).
The pawn moves are now checked by the starting position (pawns on the
second rank cant be already moved).
The castle rights of a game are expressed as CastleRights, a tuple with 4 bools.
This saves basically 116 boolean values.
2020-12-18 01:01:58 +01:00
TiynGER
c91bf64047 chess restructuring: changed order of functions 2020-12-18 00:25:22 +01:00
3 changed files with 258 additions and 238 deletions

View File

@@ -8,8 +8,6 @@ type
White = 1
Board* = array[0..119, int] ## \
## `Board` saves the position of the chess pieces.
Moved* = array[0..119, bool] ## \
## `Moved` saves the position of squares a piece moved on or from.
CastleRights = tuple
## `CastleRights` contains the rights to castling for each player.
wk: bool # `wk` describes White kingside castle
@@ -19,11 +17,11 @@ type
Game* = object
## `Game` stores all important information of a chess game.
board*: Board
moved: Moved
toMove*: Color
previousBoard: seq[Board]
previousCastleRights: seq[CastleRights]
fiftyMoveCounter: int
castleRights: CastleRights
Move* = object
## `Move` stores all important information for a move.
start: int
@@ -109,8 +107,7 @@ const
(0, 1, 0, 0, 0), # bishop only
(0, 2, 0, 0, 0) # 2 knights
] ## `InsufficientMaterial` describes the pieces where no checkmate can be
## forced.
## forced
let
PieceChar = {
@@ -144,47 +141,65 @@ let
# `FileChar` maps the files of the chessboard to numbers for better
# conversion.
proc checkInsufficientMaterial(board: Board): bool =
## Checks for combinations of pieces on a `board`, where no checkmate can be
## forced.
## Returns true if no player can force a checkmate to the other.
var wp = 0
var wn = 0
var wb = 0
var wr = 0
var wq = 0
var bp = 0
var bn = 0
var bb = 0
var br = 0
var bq = 0
for field in board.low..board.high:
case board[field]:
of WPawn:
wp = wp + 1
of BPawn:
bp = bp + 1
of WKnight:
wn = wn + 1
of BKnight:
bn = bn + 1
of WBishop:
wb = wb + 1
of BBishop:
bb = bb + 1
of WRook:
wr = wr + 1
of BRook:
br = br + 1
of WQueen:
wq = wq + 1
of BQueen:
bq = bq + 1
else:
continue
let wpieces: PieceAmount = (wp, wn, wb, wr, wq)
let bpieces: PieceAmount = (bp, bn, bb, br, bq)
return (wpieces in InsufficientMaterial) and (bpieces in InsufficientMaterial)
proc fieldToInd*(file: string, line: int): int =
## Calculate and return board index from `file` and `line` of a chess board.
## Returns -1 if the `field` was not input correct.
try:
return 1+(line+1)*10+FileChar[file]
except IndexDefect, ValueError:
return -1
proc fieldToInd*(field: string): int =
## Calculate and return board index from `field` of a chess board.
## Returns -1 if the `field` was not input correct.
try:
return fieldToInd($field[0], parseInt($field[1]))
except IndexDefect, ValueError:
return -1
proc indToField*(ind: int): string =
## Calculate and returns field name from board index `ind`.
let line = (int)ind/10-1
let file_ind = (ind)%%10-1
for file, i in FileChar:
if FileChar[file] == file_ind:
return $file & $line
proc getMove*(start: int, dest: int, prom: int, color: Color): Move =
## Get a move object of the `color` player from `start` to `dest` with an
## eventual promition to `prom`.
var move = Move(start: start, dest: dest, prom: prom * ord(color), color: color)
if (WKnight > prom or WQueen < prom):
move.prom = WQueen
return move
proc getMove*(start: int, dest: int, color: Color): Move =
## Get a move object of the `color` player from `start` to `dest` with
## automatic promition to queen.
var move = Move(start: start, dest: dest, prom: WQueen * ord(color), color: color)
return move
proc notationToMove*(notation: string, color: Color): Move =
## Convert and return simplified algebraic chess `notation` to a move object,
## color of player is `color`.
var move: Move
var start = fieldToInd(notation[0..1])
var dest = fieldToInd(notation[2..3])
move = getMove(start, dest, color)
if (len(notation) > 4):
var promStr = $notation[4]
var prom: int
case promStr:
of "Q":
prom = WQueen * ord(color)
of "R":
prom = WRook * ord(color)
of "B":
prom = WBishop * ord(color)
of "N":
prom = WKnight * ord(color)
move = getMove(start, dest, prom, color)
return move
proc initBoard(): Board =
## Create and return a board with pieces in starting position.
@@ -229,16 +244,11 @@ proc initBoard(board: array[0..63, int]): Board =
Block, Block, Block, Block, Block, Block, Block, Block, Block, Block]
return board
proc initMoved(): Moved =
## Create and return a board of pieces moved.
var moved: Moved
return moved
proc initGame*(): Game =
## Create and return a Game object.
let game = Game(board: initBoard(), moved: initMoved(),
let game = Game(board: initBoard(),
to_move: Color.White, previousBoard: @[], previousCastleRights: @[],
fiftyMoveCounter: 0)
fiftyMoveCounter: 0, castleRights: (true, true, true, true))
return game
proc initGame*(board: array[0..63, int], color: Color): Game =
@@ -246,30 +256,28 @@ proc initGame*(board: array[0..63, int], color: Color): Game =
## `board` describes the pieces, `color` the color that is about to move.
let board = initBoard(board)
let compare = initBoard()
var moved = initMoved()
var same_piece: bool
var wk = false
var wq = false
var bk = false
var bq = false
if (board[fieldToInd("e1")] == compare[fieldToInd("e1")]):
if (board[fieldToInd("a1")] == compare[fieldToInd("a1")]):
wq = true
if (board[fieldToInd("h1")] == compare[fieldToInd("h1")]):
wk = true
if (board[fieldToInd("e8")] == compare[fieldToInd("e8")]):
if (board[fieldToInd("a8")] == compare[fieldToInd("a8")]):
bq = true
if (board[fieldToInd("h8")] == compare[fieldToInd("h8")]):
bk = true
for ind in board.low..board.high:
same_piece = (board[ind] != compare[ind])
moved[ind] = same_piece
let game = Game(board: board, moved: moved,
let game = Game(board: board,
to_move: color, previousBoard: @[], previousCastleRights: @[],
fiftyMoveCounter: 0)
fiftyMoveCounter: 0, castleRights: (wk, wq, bk, bq))
return game
proc getMove*(start: int, dest: int, prom: int, color: Color): Move =
## Get a move object of the `color` player from `start` to `dest` with an
## eventual promition to `prom`.
var move = Move(start: start, dest: dest, prom: prom * ord(color), color: color)
if (WKnight > prom or WQueen < prom):
move.prom = WQueen
return move
proc getMove*(start: int, dest: int, color: Color): Move =
## Get a move object of the `color` player from `start` to `dest` with
## automatic promition to queen.
var move = Move(start: start, dest: dest, prom: WQueen * ord(color), color: color)
return move
proc echoBoard*(game: Game, color: Color) =
## Prints out the given `board` with its pieces as characters and line
## indices from perspecive of `color`.
@@ -293,59 +301,88 @@ proc echoBoard*(game: Game, color: Color) =
echo line_str
echo "a b c d e f g h"
proc fieldToInd*(file: string, line: int): int =
## Calculate and return board index from `file` and `line` of a chess board.
## Returns -1 if the `field` was not input correct.
try:
return 1+(line+1)*10+FileChar[file]
except IndexDefect, ValueError:
return -1
proc genPawnAttackDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible attack destinations for a pawn with specific `color`
## located at index `field` of `game`.
## Returns a sequence of possible indices to move to.
if (not field in game.board.low..game.board.high):
return @[]
var res = newSeq[int]()
var dest: int
var target: int
for attacks in Pawn_Moves_White_Attack:
dest = field + (attacks * ord(color))
if (not dest in game.board.low..game.board.high):
continue
target = game.board[dest]
if (target == 999 or ord(color) * target >= 0):
continue
res.add(dest)
return res
proc fieldToInd*(field: string): int =
## Calculate and return board index from `field` of a chess board.
## Returns -1 if the `field` was not input correct.
try:
return fieldToInd($field[0], parseInt($field[1]))
except IndexDefect, ValueError:
return -1
proc genPawnDoubleDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible double destinations for a pawn with specific `color`
## located at index `field` of `game`.
## Returns a sequence of possible indices to move to.
if (not field in game.board.low..game.board.high):
return @[]
var res = newSeq[int]()
var dest: int
var target: int
for doubles in Pawn_Moves_White_Double:
dest = field + doubles * ord(color)
if (not dest in game.board.low..game.board.high):
continue
target = game.board[dest]
if ((target != 0) or (
game.board[dest+(S*ord(color))] != 0)):
continue
if (color == Color.White and not (field in fieldToInd("h2")..fieldToInd("a2"))):
continue
if (color == Color.Black and not (field in fieldToInd("h7")..fieldToInd("a7"))):
continue
res.add(dest)
return res
proc indToField*(ind: int): string =
## Calculate and returns field name from board index `ind`.
let line = (int)ind/10-1
let file_ind = (ind)%%10-1
for file, i in FileChar:
if FileChar[file] == file_ind:
return $file & $line
proc genPawnDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible destinations for a pawn with specific `color` located at
## index `field` of `game`.
## Returns a sequence of possible indices to move to.
if (not field in game.board.low..game.board.high):
return @[]
var res = newSeq[int]()
var dest: int
var target: int
for move in Pawn_Moves_White:
dest = field + move * ord(color)
if (not dest in game.board.low..game.board.high):
continue
target = game.board[dest]
if (target != 0 and target != ord(color) * WEnPassant):
continue
res.add(dest)
res.add(game.genPawnAttackDests(field, color))
res.add(game.genPawnDoubleDests(field, color))
return res
proc genCastleRights(moved: Moved): CastleRights =
## Generate and return rights to castle from given `moved`
let wk = not moved[fieldToInd("e1")] and not moved[fieldToInd("h1")]
let wq = not moved[fieldToInd("e1")] and not moved[fieldToInd("a1")]
let bk = not moved[fieldToInd("e8")] and not moved[fieldToInd("h8")]
let bq = not moved[fieldToInd("e8")] and not moved[fieldToInd("a8")]
return (wk, wq, bk, bq)
proc notationToMove*(notation: string, color: Color): Move =
## Convert and return simplified algebraic chess `notation` to a move object,
## color of player is `color`.
var move: Move
var start = fieldToInd(notation[0..1])
var dest = fieldToInd(notation[2..3])
move = getMove(start, dest, color)
if (len(notation) > 4):
var promStr = $notation[4]
var prom: int
case promStr:
of "Q":
prom = WQueen * ord(color)
of "R":
prom = WRook * ord(color)
of "B":
prom = WBishop * ord(color)
of "N":
prom = WKnight * ord(color)
move = getMove(start, dest, prom, color)
return move
proc genKnightDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible destinations for a knight with specific `color` located
## at index `field` of `game`.
## Returns a sequence of possible indices to move to.
if (not field in game.board.low..game.board.high):
return @[]
var res = newSeq[int]()
var dest: int
var target: int
for move in Knight_Moves:
dest = field + move
if (not dest in game.board.low..game.board.high):
continue
target = game.board[dest]
if (target == 999 or (ord(color) * target > 0 and ord(color) * target != WEnPassant)):
continue
res.add(dest)
return res
proc genBishopDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible destinations for a bishop with specific `color` located
@@ -461,85 +498,6 @@ proc genKingDests(game: Game, field: int, color: Color): seq[int] =
res.add(game.genKingCastleDest(field, color))
return res
proc genKnightDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible destinations for a knight with specific `color` located
## at index `field` of `game`.
## Returns a sequence of possible indices to move to.
if (not field in game.board.low..game.board.high):
return @[]
var res = newSeq[int]()
var dest: int
var target: int
for move in Knight_Moves:
dest = field + move
if (not dest in game.board.low..game.board.high):
continue
target = game.board[dest]
if (target == 999 or (ord(color) * target > 0 and ord(color) * target != WEnPassant)):
continue
res.add(dest)
return res
proc genPawnAttackDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible attack destinations for a pawn with specific `color`
## located at index `field` of `game`.
## Returns a sequence of possible indices to move to.
if (not field in game.board.low..game.board.high):
return @[]
var res = newSeq[int]()
var dest: int
var target: int
for attacks in Pawn_Moves_White_Attack:
dest = field + (attacks * ord(color))
if (not dest in game.board.low..game.board.high):
continue
target = game.board[dest]
if (target == 999 or ord(color) * target >= 0):
continue
res.add(dest)
return res
proc genPawnDoubleDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible double destinations for a pawn with specific `color`
## located at index `field` of `game`.
## Returns a sequence of possible indices to move to.
if (not field in game.board.low..game.board.high):
return @[]
var res = newSeq[int]()
var dest: int
var target: int
for doubles in Pawn_Moves_White_Double:
dest = field + doubles * ord(color)
if (not dest in game.board.low..game.board.high):
continue
target = game.board[dest]
if (game.moved[field] or (target != 0) or (
game.board[dest+(S*ord(color))] != 0)):
continue
res.add(dest)
return res
proc genPawnDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible destinations for a pawn with specific `color` located at
## index `field` of `game`.
## Returns a sequence of possible indices to move to.
if (not field in game.board.low..game.board.high):
return @[]
var res = newSeq[int]()
var dest: int
var target: int
for move in Pawn_Moves_White:
dest = field + move * ord(color)
if (not dest in game.board.low..game.board.high):
continue
target = game.board[dest]
if (target != 0 and target != ord(color) * WEnPassant):
continue
res.add(dest)
res.add(game.genPawnAttackDests(field, color))
res.add(game.genPawnDoubleDests(field, color))
return res
proc pieceOn(game: Game, color: Color, sequence: seq[int],
pieceID: int): bool =
## Returns true if the `PieceID` of a given `color` is in `sequence` else
@@ -581,8 +539,22 @@ proc uncheckedMove(game: var Game, start: int, dest: int): bool {.discardable.}
let piece = game.board[start]
game.board[start] = 0
game.board[dest] = piece
game.moved[start] = true
game.moved[dest] = true
if (start == fieldToInd("e1") or start == fieldToInd("a1")):
game.castleRights.wq = false
if (start == fieldToInd("e1") or start == fieldToInd("h1")):
game.castleRights.wk = false
if (start == fieldToInd("e8") or start == fieldToInd("a8")):
game.castleRights.bq = false
if (start == fieldToInd("e8") or start == fieldToInd("h8")):
game.castleRights.bk = false
if (dest == fieldToInd("e1") or dest == fieldToInd("a1")):
game.castleRights.wq = false
if (dest == fieldToInd("e1") or dest == fieldToInd("h1")):
game.castleRights.wk = false
if (dest == fieldToInd("e8") or dest == fieldToInd("a8")):
game.castleRights.bq = false
if (dest == fieldToInd("e8") or dest == fieldToInd("h8")):
game.castleRights.bk = false
return true
proc moveLeadsToCheck(game: Game, start: int, dest: int,
@@ -593,11 +565,31 @@ proc moveLeadsToCheck(game: Game, start: int, dest: int,
check.uncheckedMove(start, dest)
return check.isInCheck(color)
proc removeEnPassant(board: var Board, color: Color): void =
## Removes every en passant of given `color` from the `board`.
for field in board.low..board.high:
if board[field] == ord(color) * WEnPassant:
board[field] = 0
proc genPawnPromotion(move: Move, color: Color): seq[Move] =
## Generate all possible promotions of a `move` by `color`.
var promotions = newSeq[Move]()
let start = move.start
let dest = move.dest
if (90 < dest and dest < 99) or (20 < dest and dest < 29):
for piece in WKnight..WQueen:
promotions.add(getMove(start, dest, piece, color))
return promotions
proc genLegalPawnMoves(game: Game, field: int, color: Color): seq[Move] =
## Generates all legal pawn moves in a `game` starting from `field` for a
## `color`.
if game.board[field] != WPawn * ord(color):
return @[]
var res = newSeq[Move]()
var moves = game.genPawnDests(field, color)
for dest in moves:
if not game.moveLeadsToCheck(field, dest, color):
var promotions = genPawnPromotion(getMove(field, dest, color), color)
if promotions != @[]:
res.add(promotions)
else:
res.add(getMove(field, dest, color))
return res
proc genLegalKnightMoves(game: Game, field: int, color: Color): seq[Move] =
## Generates all legal knight moves in a `game` starting from `field` for a
@@ -663,32 +655,6 @@ proc genLegalKingMoves(game: Game, field: int, color: Color): seq[Move] =
res.add(getMove(field, dest, color))
return res
proc genPawnPromotion(move: Move, color: Color): seq[Move] =
## Generate all possible promotions of a `move` by `color`.
var promotions = newSeq[Move]()
let start = move.start
let dest = move.dest
if (90 < dest and dest < 99) or (20 < dest and dest < 29):
for piece in WKnight..WQueen:
promotions.add(getMove(start, dest, piece, color))
return promotions
proc genLegalPawnMoves(game: Game, field: int, color: Color): seq[Move] =
## Generates all legal pawn moves in a `game` starting from `field` for a
## `color`.
if game.board[field] != WPawn * ord(color):
return @[]
var res = newSeq[Move]()
var moves = game.genPawnDests(field, color)
for dest in moves:
if not game.moveLeadsToCheck(field, dest, color):
var promotions = genPawnPromotion(getMove(field, dest, color), color)
if promotions != @[]:
res.add(promotions)
else:
res.add(getMove(field, dest, color))
return res
proc genLegalMoves*(game: Game, field: int, color: Color): seq[Move] =
## Generates all legal moves in a `game` starting from `field` for a `color`.
var legal_moves = newSeq[Move]()
@@ -730,15 +696,24 @@ proc castling(game: var Game, kstart: int, dest_kingside: bool,
var kdest = kstart
var rstart: int
var rdest: int
var rights = false
if (dest_kingside):
kdest = kstart + (E+E)
rstart = kstart + (E+E+E)
rdest = rstart + (W+W)
if (color == Color.White):
rights = game.castleRights.wk
else:
rights = game.castleRights.bk
else:
rstart = kstart + (W+W+W+W)
rdest = rstart + (E+E+E)
kdest = kstart + (W+W)
if not game.moved[kstart] and not game.moved[rstart]:
if (color == Color.White):
rights = game.castleRights.bq
else:
rights = game.castleRights.bq
if (rights):
var check = false
if (dest_kingside):
check = check or game.isAttacked(kstart, color)
@@ -756,6 +731,12 @@ proc castling(game: var Game, kstart: int, dest_kingside: bool,
return true
return false
proc removeEnPassant(board: var Board, color: Color): void =
## Removes every en passant of given `color` from the `board`.
for field in board.low..board.high:
if board[field] == ord(color) * WEnPassant:
board[field] = 0
proc checkedMove*(game: var Game, move: Move): bool {.discardable.} =
## Tries to make a `move` in a given `game``.
## This process checks for the legality of the move and performs the switch
@@ -799,7 +780,7 @@ proc checkedMove*(game: var Game, move: Move): bool {.discardable.} =
var prevBoard = game.previousBoard
var prevCastle = game.previousCastleRights
game.previousBoard.add(game.board)
game.previousCastleRights.add(game.moved.genCastleRights())
game.previousCastleRights.add(game.castleRights)
game.fiftyMoveCounter = game.fiftyMoveCounter + 1
if fiftyMoveRuleReset:
game.fiftyMoveCounter = 0
@@ -833,6 +814,48 @@ proc isDrawClaimable*(game: Game): bool =
## Returns true if a draw is claimable by either player.
return game.threeMoveRep() or game.fiftyMoveRule()
proc checkInsufficientMaterial(board: Board): bool =
## Checks for combinations of pieces on a `board`, where no checkmate can be
## forced.
## Returns true if no player can force a checkmate to the other.
var wp = 0
var wn = 0
var wb = 0
var wr = 0
var wq = 0
var bp = 0
var bn = 0
var bb = 0
var br = 0
var bq = 0
for field in board.low..board.high:
case board[field]:
of WPawn:
wp = wp + 1
of BPawn:
bp = bp + 1
of WKnight:
wn = wn + 1
of BKnight:
bn = bn + 1
of WBishop:
wb = wb + 1
of BBishop:
bb = bb + 1
of WRook:
wr = wr + 1
of BRook:
br = br + 1
of WQueen:
wq = wq + 1
of BQueen:
bq = bq + 1
else:
continue
let wpieces: PieceAmount = (wp, wn, wb, wr, wq)
let bpieces: PieceAmount = (bp, bn, bb, br, bq)
return (wpieces in InsufficientMaterial) and (bpieces in InsufficientMaterial)
proc isStalemate*(game: Game, color: Color): bool =
## Returns true if the `color` player is stalemate in a `game`.
return (game.hasNoMoves(color) and not game.isInCheck(color)) or

View File

@@ -1,6 +1,3 @@
from strutils import parseInt
import rdstdin
import ./chess
proc runGame*(): void =