tiyn
/
yeschess
mirror of https://github.com/tiyn/yeschess
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

tests: added unittests

Browse Source 
Due to the official nim documentation the snake_case was now swapped
for camelCase.
Tests for nearly any move were added.
A new procedure can initialize a game with a given 8x8 board with pieces and determines if
they have been moved already.
master
TiynGER 4 years ago
parent f749f66c3c
commit 97406d4da3
3 changed files with 1318 additions and 210 deletions
Show Stats Download Patch File Download Diff File

414
chess.nim
Unescape View File

@ -12,7 +12,7 @@ type
Game* = object Game* = object
pieces*: Pieces pieces*: Pieces
moved: Moved moved: Moved
to_move*: Color toMove*: Color
## Move as object ## Move as object
Move* = object Move* = object
start: int start: int
@ -92,7 +92,28 @@ var FileChar = {
"h": 0 "h": 0
}.newTable }.newTable
proc init_board(): Pieces = proc getField*(pieces: Pieces, field: int): int =
return pieces[field]
proc setField(pieces: var Pieces, field: int, val: int): bool {.discardable.} =
if (val in PieceChar):
try:
pieces[field] = val
return true
except Exception:
return false
proc getField*(moved: Moved, field: int): bool =
return moved[field]
proc setField(moved: var Moved, field: int, val: bool): bool {.discardable.} =
try:
moved[field] = val
return true
except Exception:
return false
proc initBoard(): Pieces =
## Create and return a board with pieces in starting position. ## Create and return a board with pieces in starting position.
let board = [ let board = [
Block, Block, Block, Block, Block, Block, Block, Block, Block, Block, Block, Block, Block, Block, Block, Block, Block, Block, Block, Block,
@ -109,56 +130,73 @@ proc init_board(): Pieces =
Block, Block, Block, Block, Block, Block, Block, Block, Block, Block] Block, Block, Block, Block, Block, Block, Block, Block, Block, Block]
return board return board
proc get_move*(start: int, dest: int, prom: int, color: Color): Move = proc initBoard(pieces: array[0..63, int]): Pieces =
## Get a move object from `start` to `dest` with an eventual promition to `prom` ## Create and return a board with pieces in position of choice
var move = Move(start: start, dest: dest, prom: prom * ord(color), color: color) let board = [
if (KnightID > prom or QueenID < prom): Block, Block, Block, Block, Block, Block, Block, Block, Block, Block,
move.prom = QueenID Block, Block, Block, Block, Block, Block, Block, Block, Block, Block,
return move Block, pieces[0], pieces[1], pieces[2], pieces[3], pieces[4], pieces[5],
pieces[6], pieces[7], Block,
proc get_move*(start: int, dest: int, color: Color): Move = Block, pieces[8], pieces[9], pieces[10], pieces[11], pieces[12], pieces[13],
## Get a move object from `start` to `dest` with automatic promition to `queen` pieces[14], pieces[15], Block,
var move = Move(start: start, dest: dest, prom: QueenID * ord(color), color: color) Block, pieces[16], pieces[17], pieces[18], pieces[19], pieces[20], pieces[
return move 21], pieces[22], pieces[23], Block,
Block, pieces[24], pieces[25], pieces[26], pieces[27], pieces[28], pieces[
29], pieces[30], pieces[31], Block,
Block, pieces[32], pieces[33], pieces[34], pieces[35], pieces[36], pieces[
37], pieces[38], pieces[39], Block,
Block, pieces[40], pieces[41], pieces[42], pieces[43], pieces[44], pieces[
45], pieces[46], pieces[47], Block,
Block, pieces[48], pieces[49], pieces[50], pieces[51], pieces[52], pieces[
53], pieces[54], pieces[55], Block,
Block, pieces[56], pieces[57], pieces[58], pieces[59], pieces[60], pieces[
61], pieces[62], pieces[63], Block,
Block, Block, Block, Block, Block, Block, Block, Block, Block, Block,
Block, Block, Block, Block, Block, Block, Block, Block, Block, Block]
return board
proc init_moved(): Moved = proc initMoved(): Moved =
## Create and return a board of pieces moved. ## Create and return a board of pieces moved.
var moved: Moved var moved: Moved
return moved return moved
proc init_game*(): Game = proc initGame*(): Game =
## Create and return a Game object. ## Create and return a Game object.
let game = Game(pieces: init_board(), moved: init_moved(), let game = Game(pieces: initBoard(), moved: initMoved(),
to_move: Color.White) to_move: Color.White)
return game return game
proc get_field(pieces: Pieces, field: int): int = proc initGame*(pieces: array[0..63, int], color: Color): Game =
return pieces[field] ## Create ad return a Game object based on a position of choice.
let pieces = initBoard(pieces)
proc set_field(pieces: var Pieces, field: int, val: int): bool {.discardable.} = let compare = initBoard()
if (val in PieceChar): var moved = initMoved()
try: var same_piece: bool
pieces[field] = val for ind in pieces.low..pieces.high:
return true same_piece = (pieces[ind] != compare[ind])
except Exception: moved.setField(ind, same_piece)
return false let game = Game(pieces: pieces, moved: moved,
to_move: color)
return game
proc get_field(moved: Moved, field: int): bool = proc getMove*(start: int, dest: int, prom: int, color: Color): Move =
return moved[field] ## Get a move object from `start` to `dest` with an eventual promition to `prom`
var move = Move(start: start, dest: dest, prom: prom * ord(color), color: color)
if (KnightID > prom or QueenID < prom):
move.prom = QueenID
return move
proc set_field(moved: var Moved, field: int, val: bool): bool {.discardable.} = proc getMove*(start: int, dest: int, color: Color): Move =
try: ## Get a move object from `start` to `dest` with automatic promition to `queen`
moved[field] = val var move = Move(start: start, dest: dest, prom: QueenID * ord(color), color: color)
return true return move
except Exception:
return false
proc echo_board*(game: Game, color: Color) = proc echoBoard*(game: Game, color: Color) =
## Prints out the given `board` with its pieces as characters and line indices from perspecive of `color`. ## Prints out the given `board` with its pieces as characters and line indices from perspecive of `color`.
var line_str = "" var line_str = ""
if (color == Color.Black): if (color == Color.Black):
for i in countup(0, len(game.pieces)-1): for i in countup(0, len(game.pieces)-1):
if (game.pieces.get_field(i) == 999): if (game.pieces.getField(i) == 999):
continue continue
line_str &= PieceChar[game.pieces[i]] & " " line_str &= PieceChar[game.pieces[i]] & " "
if ((i+2) %% 10 == 0): if ((i+2) %% 10 == 0):
@ -167,7 +205,7 @@ proc echo_board*(game: Game, color: Color) =
echo "h g f e d c b a" echo "h g f e d c b a"
else: else:
for i in countdown(len(game.pieces)-1, 0): for i in countdown(len(game.pieces)-1, 0):
if (game.pieces.get_field(i) == 999): if (game.pieces.getField(i) == 999):
continue continue
line_str &= PieceChar[game.pieces[i]] & " " line_str &= PieceChar[game.pieces[i]] & " "
if ((i-1) %% 10 == 0): if ((i-1) %% 10 == 0):
@ -175,21 +213,21 @@ proc echo_board*(game: Game, color: Color) =
echo line_str echo line_str
echo "a b c d e f g h" echo "a b c d e f g h"
proc field_to_ind*(file: string, line: int): int = proc fieldToInd*(file: string, line: int): int =
## Calculate board index from `file` and `line` of a chess board. ## Calculate board index from `file` and `line` of a chess board.
try: try:
return 1+(line+1)*10+FileChar[file] return 1+(line+1)*10+FileChar[file]
except IndexDefect, ValueError: except IndexDefect, ValueError:
return -1 return -1
proc field_to_ind*(field: string): int = proc fieldToInd*(field: string): int =
## Calculate board index from `field` of a chess board. ## Calculate board index from `field` of a chess board.
try: try:
return field_to_ind($field[0], parseInt($field[1])) return fieldToInd($field[0], parseInt($field[1]))
except IndexDefect, ValueError: except IndexDefect, ValueError:
return -1 return -1
proc ind_to_field*(ind: int): string = proc indToField*(ind: int): string =
## Calculate field name from board index `ind`. ## Calculate field name from board index `ind`.
let line = (int)ind/10-1 let line = (int)ind/10-1
let file_ind = (ind)%%10-1 let file_ind = (ind)%%10-1
@ -197,7 +235,32 @@ proc ind_to_field*(ind: int): string =
if FileChar[file] == file_ind: if FileChar[file] == file_ind:
return $file & $line return $file & $line
proc gen_bishop_dests(game: Game, field: int, color: Color): seq[int] = proc notationToMove*(notation: string, color: Color): Move =
## Convert simplified algebraic chess `notation` to a move object, color of player is `color`.
try:
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 = QueenID * ord(color)
of "R":
prom = RookID * ord(color)
of "B":
prom = BishopID * ord(color)
of "N":
prom = KnightID * ord(color)
move = getMove(start, dest, prom, color)
return move
except IndexError:
var move: Move
return move
proc genBishopDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible destinations for a bishop with specific `color` located at index `field` of `game`. ## Generate possible destinations for a bishop with specific `color` located at index `field` of `game`.
## Returns a sequence of possible indices to move to. ## Returns a sequence of possible indices to move to.
try: try:
@ -206,18 +269,19 @@ proc gen_bishop_dests(game: Game, field: int, color: Color): seq[int] =
var target: int var target: int
for move in Bishop_Moves: for move in Bishop_Moves:
dest = field+move dest = field+move
target = game.pieces.get_field(dest) target = game.pieces.getField(dest)
while (target != 999 and (ord(color) * target <= 0) or target == EnPassantID): while (target != 999 and (ord(color) * target <= 0) or target ==
EnPassantID or target == -EnPassantID):
res.add(dest) res.add(dest)
if (ord(color) * target < 0 and ord(color) * target > -EnPassantID): if (ord(color) * target < 0 and ord(color) * target > -EnPassantID):
break break
dest = dest+move dest = dest+move
target = game.pieces.get_field(dest) target = game.pieces.getField(dest)
return res return res
except IndexDefect: except IndexDefect:
return @[] return @[]
proc gen_rook_dests(game: Game, field: int, color: Color): seq[int] = proc genRookDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible destinations for a rook with specific `color` located at index `field` of `game`. ## Generate possible destinations for a rook with specific `color` located at index `field` of `game`.
## Returns a sequence of possible indices to move to. ## Returns a sequence of possible indices to move to.
try: try:
@ -226,18 +290,19 @@ proc gen_rook_dests(game: Game, field: int, color: Color): seq[int] =
var target: int var target: int
for move in Rook_Moves: for move in Rook_Moves:
dest = field+move dest = field+move
target = game.pieces.get_field(dest) target = game.pieces.getField(dest)
while (target != 999 and (ord(color) * target <= 0) or target == EnPassantID): while (target != 999 and (ord(color) * target <= 0) or target ==
EnPassantID or target == -EnPassantID):
res.add(dest) res.add(dest)
if (ord(color) * target < 0 and ord(color) * target > -EnPassantID): if (ord(color) * target < 0 and ord(color) * target > -EnPassantID):
break break
dest = dest+move dest = dest+move
target = game.pieces.get_field(dest) target = game.pieces.getField(dest)
return res return res
except IndexDefect: except IndexDefect:
return @[] return @[]
proc gen_queen_dests(game: Game, field: int, color: Color): seq[int] = proc genQueenDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible destinations for a queen with specific `color` located at index `field` of `game`. ## Generate possible destinations for a queen with specific `color` located at index `field` of `game`.
## Returns a sequence of possible indices to move to. ## Returns a sequence of possible indices to move to.
try: try:
@ -246,18 +311,19 @@ proc gen_queen_dests(game: Game, field: int, color: Color): seq[int] =
var target: int var target: int
for move in Queen_Moves: for move in Queen_Moves:
dest = field+move dest = field+move
target = game.pieces.get_field(dest) target = game.pieces.getField(dest)
while (target != 999 and (ord(color) * target <= 0) or target == EnPassantID): while (target != 999 and (ord(color) * target <= 0) or target ==
EnPassantID or target == -EnPassantID):
res.add(dest) res.add(dest)
if (ord(color) * target < 0 and ord(color) * target > -EnPassantID): if (ord(color) * target < 0 and ord(color) * target > -EnPassantID):
break break
dest = dest+move dest = dest+move
target = game.pieces.get_field(dest) target = game.pieces.getField(dest)
return res return res
except IndexDefect: except IndexDefect:
return @[] return @[]
proc gen_king_castle_dest(game: Game, field: int, color: Color): seq[int] = proc genKingCastleDest(game: Game, field: int, color: Color): seq[int] =
## Generate possible castle destinations for a king with specific `color` located at index `field` of `game` ## Generate possible castle destinations for a king with specific `color` located at index `field` of `game`
## Returns a sequence of possible indices to move to. ## Returns a sequence of possible indices to move to.
try: try:
@ -268,9 +334,9 @@ proc gen_king_castle_dest(game: Game, field: int, color: Color): seq[int] =
var half_target: int var half_target: int
for castle in King_Moves_White_Castle: for castle in King_Moves_White_Castle:
dest = field + castle dest = field + castle
target = game.pieces.get_field(dest) target = game.pieces.getField(dest)
half_dest = field + (int)castle/2 half_dest = field + (int)castle/2
half_target = game.pieces.get_field(half_dest) half_target = game.pieces.getField(half_dest)
if (target == 999 or (target != 0)): if (target == 999 or (target != 0)):
continue continue
if (half_target == 999 or (half_target != 0)): if (half_target == 999 or (half_target != 0)):
@ -281,7 +347,7 @@ proc gen_king_castle_dest(game: Game, field: int, color: Color): seq[int] =
return @[] return @[]
proc gen_king_dests(game: Game, field: int, color: Color): seq[int] = proc genKingDests(game: Game, field: int, color: Color): seq[int] =
## Generate possible destinations for a king with specific `color` located at index `field` of `game`. ## Generate possible destinations for a king with specific `color` located at index `field` of `game`.
## Returns a sequence of possible indices to move to. ## Returns a sequence of possible indices to move to.
try: try:
@ -290,16 +356,16 @@ proc gen_king_dests(game: Game, field: int, color: Color): seq[int] =
var target: int var target: int
for move in King_Moves: for move in King_Moves:
dest = field + move dest = field + move
target = game.pieces.get_field(dest) target = game.pieces.getField(dest)
if (target == 999 or (ord(color) * target > 0 and ord(color) * target != EnPassantID)): if (target == 999 or (ord(color) * target > 0 and ord(color) * target != EnPassantID)):
continue continue
res.add(dest) res.add(dest)
res.add(game.gen_king_castle_dest(field, color)) res.add(game.genKingCastleDest(field, color))
return res return res
except IndexDefect: except IndexDefect:
return @[] return @[]
proc gen_knight_dests(game: Game, field: int, color: Color): seq[int] = 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`. ## Generate possible destinations for a knight with specific `color` located at index `field` of `game`.
## Returns a sequence of possible indices to move to. ## Returns a sequence of possible indices to move to.
try: try:
@ -308,7 +374,7 @@ proc gen_knight_dests(game: Game, field: int, color: Color): seq[int] =
var target: int var target: int
for move in Knight_Moves: for move in Knight_Moves:
dest = field + move dest = field + move
target = game.pieces.get_field(dest) target = game.pieces.getField(dest)
if (target == 999 or (ord(color) * target > 0 and ord(color) * target != EnPassantID)): if (target == 999 or (ord(color) * target > 0 and ord(color) * target != EnPassantID)):
continue continue
res.add(dest) res.add(dest)
@ -316,7 +382,7 @@ proc gen_knight_dests(game: Game, field: int, color: Color): seq[int] =
except IndexDefect: except IndexDefect:
return @[] return @[]
proc gen_pawn_attack_dests(game: Game, field: int, color: Color): seq[int] = 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`. ## 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. ## Returns a sequence of possible indices to move to.
try: try:
@ -324,8 +390,8 @@ proc gen_pawn_attack_dests(game: Game, field: int, color: Color): seq[int] =
var dest: int var dest: int
var target: int var target: int
for attacks in Pawn_Moves_White_Attack: for attacks in Pawn_Moves_White_Attack:
dest = field + attacks * ord(color) dest = field + (attacks * ord(color))
target = game.pieces.get_field(dest) target = game.pieces.getField(dest)
if (target == 999 or ord(color) * target >= 0): if (target == 999 or ord(color) * target >= 0):
continue continue
res.add(dest) res.add(dest)
@ -333,7 +399,7 @@ proc gen_pawn_attack_dests(game: Game, field: int, color: Color): seq[int] =
except IndexDefect: except IndexDefect:
return @[] return @[]
proc gen_pawn_double_dests(game: Game, field: int, color: Color): seq[int] = 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`. ## 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. ## Returns a sequence of possible indices to move to.
try: try:
@ -342,16 +408,16 @@ proc gen_pawn_double_dests(game: Game, field: int, color: Color): seq[int] =
var target: int var target: int
for doubles in Pawn_Moves_White_Double: for doubles in Pawn_Moves_White_Double:
dest = field + doubles * ord(color) dest = field + doubles * ord(color)
target = game.pieces.get_field(dest) target = game.pieces.getField(dest)
if (game.moved.get_field(field) or (target != 0) or ( if (game.moved.getField(field) or (target != 0) or (
game.pieces.get_field(dest+(S*ord(color))) != 0)): game.pieces.getField(dest+(S*ord(color))) != 0)):
continue continue
res.add(dest) res.add(dest)
return res return res
except IndexDefect: except IndexDefect:
return @[] return @[]
proc gen_pawn_dests(game: Game, field: int, color: Color): seq[int] = 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`. ## Generate possible destinations for a pawn with specific `color` located at index `field` of `game`.
## Returns a sequence of possible indices to move to. ## Returns a sequence of possible indices to move to.
try: try:
@ -360,189 +426,189 @@ proc gen_pawn_dests(game: Game, field: int, color: Color): seq[int] =
var target: int var target: int
for move in Pawn_Moves_White: for move in Pawn_Moves_White:
dest = field + move * ord(color) dest = field + move * ord(color)
target = game.pieces.get_field(dest) target = game.pieces.getField(dest)
if (target != 0 and target != ord(color) * EnPassantID): if (target != 0 and target != ord(color) * EnPassantID):
continue continue
res.add(dest) res.add(dest)
res.add(game.gen_pawn_attack_dests(field, color)) res.add(game.genPawnAttackDests(field, color))
res.add(game.gen_pawn_double_dests(field, color)) res.add(game.genPawnDoubleDests(field, color))
return res return res
except IndexDefect: except IndexDefect:
return @[] return @[]
proc piece_on(game: Game, color: Color, sequence: seq[int], proc pieceOn(game: Game, color: Color, sequence: seq[int],
pieceID: int): bool = pieceID: int): bool =
## Check if a piece with `pieceID` of a given `color` is in a field described in a `sequence` in a `game`. ## Check if a piece with `pieceID` of a given `color` is in a field described in a `sequence` in a `game`.
for check in sequence: for check in sequence:
if game.pieces.get_field(check) == ord(color) * -1 * pieceID: if game.pieces.getField(check) == ord(color) * -1 * pieceID:
return true return true
return false return false
proc is_attacked(game: Game, position: int, color: Color): bool = proc isAttacked(game: Game, position: int, color: Color): bool =
## Check if a field is attacked by the opposite of `color` in a `game`. ## Check if a field is attacked by the opposite of `color` in a `game`.
var attacked = false var attacked = false
attacked = attacked or game.piece_on(color, game.gen_pawn_attack_dests( attacked = attacked or game.pieceOn(color, game.genPawnAttackDests(
position, color), PawnID) position, color), PawnID)
attacked = attacked or game.piece_on(color, game.gen_queen_dests(position, attacked = attacked or game.pieceOn(color, game.genQueenDests(position,
color), QueenID) color), QueenID)
attacked = attacked or game.piece_on(color, game.gen_king_dests(position, attacked = attacked or game.pieceOn(color, game.genKingDests(position,
color), KingID) color), KingID)
attacked = attacked or game.piece_on(color, game.gen_rook_dests(position, attacked = attacked or game.pieceOn(color, game.genRookDests(position,
color), RookID) color), RookID)
attacked = attacked or game.piece_on(color, game.gen_bishop_dests(position, attacked = attacked or game.pieceOn(color, game.genBishopDests(position,
color), BishopID) color), BishopID)
attacked = attacked or game.piece_on(color, game.gen_knight_dests(position, attacked = attacked or game.pieceOn(color, game.genKnightDests(position,
color), KnightID) color), KnightID)
return attacked return attacked
proc is_in_check*(game: Game, color: Color): bool = proc isInCheck*(game: Game, color: Color): bool =
## Check if the King of a given `color` is in check in a `game`. ## Check if the King of a given `color` is in check in a `game`.
var king_pos: int var king_pos: int
for i in countup(0, game.pieces.high): for i in countup(0, game.pieces.high):
if game.pieces.get_field(i) == ord(color) * KingID: if game.pieces.getField(i) == ord(color) * KingID:
king_pos = i king_pos = i
return game.is_attacked(king_pos, color) return game.isAttacked(king_pos, color)
proc unchecked_move(game: var Game, start: int, dest: int): bool {.discardable.} = proc uncheckedMove(game: var Game, start: int, dest: int): bool {.discardable.} =
## Moves a piece if possible from `start` position to `dest` position. ## Moves a piece if possible from `start` position to `dest` position.
## Doesnt check boundaries, checks, movement. ## Doesnt check boundaries, checks, movement.
## returns true if the piece moved, else false ## returns true if the piece moved, else false
try: try:
let piece = game.pieces.get_field(start) let piece = game.pieces.getField(start)
if game.pieces.set_field(start, 0): if game.pieces.setField(start, 0):
if game.pieces.set_field(dest, piece): if game.pieces.setField(dest, piece):
game.moved.set_field(start, true) game.moved.setField(start, true)
game.moved.set_field(dest, true) game.moved.setField(dest, true)
return true return true
else: else:
game.pieces.set_field(start, piece) game.pieces.setField(start, piece)
except IndexDefect, ValueError: except IndexDefect, ValueError:
return false return false
proc move_leads_to_check(game: Game, start: int, dest: int, proc moveLeadsToCheck(game: Game, start: int, dest: int,
color: Color): bool = color: Color): bool =
## Checks in a `game` if a move from `start` to `dest` puts the `color` king in check. ## Checks in a `game` if a move from `start` to `dest` puts the `color` king in check.
var check = game var check = game
check.unchecked_move(start, dest) check.uncheckedMove(start, dest)
return check.is_in_check(color) return check.isInCheck(color)
proc remove_en_passant(pieces: var Pieces, color: Color): void = proc removeEnPassant(pieces: var Pieces, color: Color): void =
## Removes every en passant of given `color` from the `game`. ## Removes every en passant of given `color` from the `game`.
for field in pieces.low..pieces.high: for field in pieces.low..pieces.high:
if pieces.get_field(field) == ord(color) * EnPassantID: if pieces.getField(field) == ord(color) * EnPassantID:
pieces.set_field(field, 0) pieces.setField(field, 0)
proc gen_legal_knight_moves(game: Game, field: int, color: Color): seq[Move] = proc genLegalKnightMoves(game: Game, field: int, color: Color): seq[Move] =
## Generates all legal knight moves starting from `field` in a `game` for a `color`. ## Generates all legal knight moves starting from `field` in a `game` for a `color`.
if game.pieces.get_field(field) != KnightID * ord(color): if game.pieces.getField(field) != KnightID * ord(color):
return @[] return @[]
var res = newSeq[Move]() var res = newSeq[Move]()
var moves = game.gen_knight_dests(field, color) var moves = game.genKnightDests(field, color)
for dest in moves: for dest in moves:
if not game.move_leads_to_check(field, dest, color): if not game.moveLeadsToCheck(field, dest, color):
res.add(get_move(field, dest, color)) res.add(getMove(field, dest, color))
return res return res
proc gen_legal_bishop_moves(game: Game, field: int, color: Color): seq[Move] = proc genLegalBishopMoves(game: Game, field: int, color: Color): seq[Move] =
## Generates all legal bishop moves starting from `field` in a `game` for a `color`. ## Generates all legal bishop moves starting from `field` in a `game` for a `color`.
if game.pieces.get_field(field) != BishopID * ord(color): if game.pieces.getField(field) != BishopID * ord(color):
return @[] return @[]
var res = newSeq[Move]() var res = newSeq[Move]()
var moves = game.gen_bishop_dests(field, color) var moves = game.genBishopDests(field, color)
for dest in moves: for dest in moves:
if not game.move_leads_to_check(field, dest, color): if not game.moveLeadsToCheck(field, dest, color):
res.add(get_move(field, dest, color)) res.add(getMove(field, dest, color))
return res return res
proc gen_legal_rook_moves(game: Game, field: int, color: Color): seq[Move] = proc genLegalRookMoves(game: Game, field: int, color: Color): seq[Move] =
## Generates all legal rook moves starting from `field` in a `game` for a `color`. ## Generates all legal rook moves starting from `field` in a `game` for a `color`.
if game.pieces.get_field(field) != RookID * ord(color): if game.pieces.getField(field) != RookID * ord(color):
return @[] return @[]
var res = newSeq[Move]() var res = newSeq[Move]()
var moves = game.gen_rook_dests(field, color) var moves = game.genRookDests(field, color)
for dest in moves: for dest in moves:
if not game.move_leads_to_check(field, dest, color): if not game.moveLeadsToCheck(field, dest, color):
res.add(get_move(field, dest, color)) res.add(getMove(field, dest, color))
return res return res
proc gen_legal_queen_moves(game: Game, field: int, color: Color): seq[Move] = proc genLegalQueenMoves(game: Game, field: int, color: Color): seq[Move] =
## Generates all legal queen moves starting from `field` in a `game` for a `color`. ## Generates all legal queen moves starting from `field` in a `game` for a `color`.
if game.pieces.get_field(field) != QueenID * ord(color): if game.pieces.getField(field) != QueenID * ord(color):
return @[] return @[]
var res = newSeq[Move]() var res = newSeq[Move]()
var moves = game.gen_queen_dests(field, color) var moves = game.genQueenDests(field, color)
for dest in moves: for dest in moves:
if not game.move_leads_to_check(field, dest, color): if not game.moveLeadsToCheck(field, dest, color):
res.add(get_move(field, dest, color)) res.add(getMove(field, dest, color))
return res return res
proc gen_legal_king_moves(game: Game, field: int, color: Color): seq[Move] = proc genLegalKingMoves(game: Game, field: int, color: Color): seq[Move] =
## Generates all legal king moves starting from `field` in a `game` for a `color`. ## Generates all legal king moves starting from `field` in a `game` for a `color`.
if game.pieces.get_field(field) != KingID * ord(color): if game.pieces.getField(field) != KingID * ord(color):
return @[] return @[]
var res = newSeq[Move]() var res = newSeq[Move]()
var moves = game.gen_king_dests(field, color) var moves = game.genKingDests(field, color)
for dest in moves: for dest in moves:
if field - dest == W+W and game.is_attacked(dest+W, color): if field - dest == W+W and game.isAttacked(dest+W, color):
continue continue
if field - dest == E+E and game.is_attacked(dest+E, color): if field - dest == E+E and game.isAttacked(dest+E, color):
continue continue
if not game.move_leads_to_check(field, dest, color): if not game.moveLeadsToCheck(field, dest, color):
res.add(get_move(field, dest, color)) res.add(getMove(field, dest, color))
return res return res
proc gen_pawn_promotion(move: Move, color: Color): seq[Move] = proc genPawnPromotion(move: Move, color: Color): seq[Move] =
## Generate all possible promotions of a `move` by `color`. ## Generate all possible promotions of a `move` by `color`.
var promotions = newSeq[Move]() var promotions = newSeq[Move]()
let start = move.start let start = move.start
let dest = move.dest let dest = move.dest
if (90 < dest and dest < 99) or (20 < dest and dest < 29): if (90 < dest and dest < 99) or (20 < dest and dest < 29):
for piece in KnightID..QueenID: for piece in KnightID..QueenID:
promotions.add(get_move(start, dest, piece, color)) promotions.add(getMove(start, dest, piece, color))
return promotions return promotions
proc gen_legal_pawn_moves(game: Game, field: int, color: Color): seq[Move] = proc genLegalPawnMoves(game: Game, field: int, color: Color): seq[Move] =
## Generates all legal pawn moves starting from `field` in a `game` for a `color`. ## Generates all legal pawn moves starting from `field` in a `game` for a `color`.
if game.pieces.get_field(field) != PawnID * ord(color): if game.pieces.getField(field) != PawnID * ord(color):
return @[] return @[]
var res = newSeq[Move]() var res = newSeq[Move]()
var moves = game.gen_pawn_dests(field, color) var moves = game.genPawnDests(field, color)
for dest in moves: for dest in moves:
if not game.move_leads_to_check(field, dest, color): if not game.moveLeadsToCheck(field, dest, color):
var promotions = gen_pawn_promotion(get_move(field, dest, color), color) var promotions = genPawnPromotion(getMove(field, dest, color), color)
if promotions != @[]: if promotions != @[]:
res.add(promotions) res.add(promotions)
else: else:
res.add(get_move(field, dest, color)) res.add(getMove(field, dest, color))
return res return res
proc gen_legal_moves*(game: Game, field: int, color: Color): seq[Move] = proc genLegalMoves*(game: Game, field: int, color: Color): seq[Move] =
## Generates all legal moves starting from `field` in a `game` for a `color`. ## Generates all legal moves starting from `field` in a `game` for a `color`.
var legal_moves = newSeq[Move]() var legal_moves = newSeq[Move]()
var target = ord(color) * game.pieces.get_field(field) var target = ord(color) * game.pieces.getField(field)
if 0 < target and target < EnPassantID: if 0 < target and target < EnPassantID:
legal_moves = case target: legal_moves = case target:
of PawnID: of PawnID:
game.gen_legal_pawn_moves(field, color) game.genLegalPawnMoves(field, color)
of KnightID: of KnightID:
game.gen_legal_knight_moves(field, color) game.genLegalKnightMoves(field, color)
of BishopID: of BishopID:
game.gen_legal_bishop_moves(field, color) game.genLegalBishopMoves(field, color)
of RookID: of RookID:
game.gen_legal_rook_moves(field, color) game.genLegalRookMoves(field, color)
of QueenID: of QueenID:
game.gen_legal_queen_moves(field, color) game.genLegalQueenMoves(field, color)
of KingID: of KingID:
game.gen_legal_king_moves(field, color) game.genLegalKingMoves(field, color)
else: else:
@[] @[]
return legal_moves return legal_moves
proc gen_legal_moves*(game: Game, color: Color): seq[Move] = proc genLegalMoves*(game: Game, color: Color): seq[Move] =
## Generates all legal moves in a `game` for a `color`. ## Generates all legal moves in a `game` for a `color`.
var legal_moves = newSeq[Move]() var legal_moves = newSeq[Move]()
for field in game.pieces.low..game.pieces.high: for field in game.pieces.low..game.pieces.high:
legal_moves.add(game.gen_legal_moves(field, color)) legal_moves.add(game.genLegalMoves(field, color))
return legal_moves return legal_moves
proc castling(game: var Game, kstart: int, dest_kingside: bool, proc castling(game: var Game, kstart: int, dest_kingside: bool,
@ -551,7 +617,7 @@ proc castling(game: var Game, kstart: int, dest_kingside: bool,
## `dest_kingside` for kingside castling, else castling is queenside. ## `dest_kingside` for kingside castling, else castling is queenside.
## This process checks for the legality of the move and performs the switch of `game.to_move` ## This process checks for the legality of the move and performs the switch of `game.to_move`
try: try:
if game.to_move != color: if game.toMove != color:
return false return false
var kdest = kstart var kdest = kstart
var rstart: int var rstart: int
@ -564,26 +630,26 @@ proc castling(game: var Game, kstart: int, dest_kingside: bool,
rstart = kstart + (W+W+W+W) rstart = kstart + (W+W+W+W)
rdest = rstart + (E+E+E) rdest = rstart + (E+E+E)
kdest = kstart + (W+W) kdest = kstart + (W+W)
if not game.moved.get_field(kstart) and not game.moved.get_field(rstart): if not game.moved.getField(kstart) and not game.moved.getField(rstart):
var check = false var check = false
if (dest_kingside): if (dest_kingside):
check = check or game.is_attacked(kstart, color) check = check or game.isAttacked(kstart, color)
check = check or game.is_attacked(kstart+(E), color) check = check or game.isAttacked(kstart+(E), color)
check = check or game.is_attacked(kstart+(E+E), color) check = check or game.isAttacked(kstart+(E+E), color)
else: else:
check = check or game.is_attacked(kstart, color) check = check or game.isAttacked(kstart, color)
check = check or game.is_attacked(kstart+(W), color) check = check or game.isAttacked(kstart+(W), color)
check = check or game.is_attacked(kstart+(W+W), color) check = check or game.isAttacked(kstart+(W+W), color)
if check: if check:
return false return false
game.unchecked_move(kstart, kdest) game.uncheckedMove(kstart, kdest)
game.unchecked_move(rstart, rdest) game.uncheckedMove(rstart, rdest)
return true return true
return false return false
except IndexDefect, ValueError: except IndexDefect, ValueError:
return false return false
proc checked_move*(game: var Game, move: Move): bool {.discardable.} = proc checkedMove*(game: var Game, move: Move): bool {.discardable.} =
## Tries to make a move in a given `game` with the piece of a given `color` from `start` to `dest`. ## Tries to make a move in a given `game` with the piece of a given `color` from `start` to `dest`.
## This process checks for the legality of the move and performs the switch of `game.to_move` ## This process checks for the legality of the move and performs the switch of `game.to_move`
try: try:
@ -591,46 +657,46 @@ proc checked_move*(game: var Game, move: Move): bool {.discardable.} =
let dest = move.dest let dest = move.dest
let color = move.color let color = move.color
let prom = move.prom let prom = move.prom
if game.to_move != color: if game.toMove != color:
return false return false
var sequence = newSeq[Move]() var sequence = newSeq[Move]()
let piece = game.pieces.get_field(start) let piece = game.pieces.getField(start)
var create_en_passant = false var create_en_passant = false
var captured_en_passant = false var captured_en_passant = false
var move: Move var move: Move
move = get_move(start, dest, color) move = getMove(start, dest, color)
if (piece == PawnID * ord(color)): if (piece == PawnID * ord(color)):
create_en_passant = dest in game.gen_pawn_double_dests(start, color) create_en_passant = dest in game.genPawnDoubleDests(start, color)
captured_en_passant = (game.pieces.get_field(dest) == -1 * ord(color) * EnPassantID) captured_en_passant = (game.pieces.getField(dest) == -1 * ord(color) * EnPassantID)
sequence.add(game.gen_legal_moves(start, color)) sequence.add(game.genLegalMoves(start, color))
if (move in sequence): if (move in sequence):
game.pieces.remove_en_passant(color) game.pieces.removeEnPassant(color)
if (piece == KingID * ord(color) and (start - dest == (W+W))): if (piece == KingID * ord(color) and (start - dest == (W+W))):
game.castling(start, true, color) return game.castling(start, true, color)
elif (piece == KingID * ord(color) and (start - dest == (E+E))): elif (piece == KingID * ord(color) and (start - dest == (E+E))):
game.castling(start, false, color) return game.castling(start, false, color)
else: else:
game.unchecked_move(start, dest) game.uncheckedMove(start, dest)
game.to_move = Color(ord(game.to_move)*(-1)) game.toMove = Color(ord(game.toMove)*(-1))
if create_en_passant: if create_en_passant:
game.pieces.set_field(dest-(N*ord(color)), EnPassantID * ord(color)) game.pieces.setField(dest-(N*ord(color)), EnPassantID * ord(color))
if captured_en_passant: if captured_en_passant:
game.pieces.set_field(dest-(N*ord(color)), 0) game.pieces.setField(dest-(N*ord(color)), 0)
if ((90 < dest and dest < 99) or (20 < dest and dest < 29)) and if ((90 < dest and dest < 99) or (20 < dest and dest < 29)) and
game.pieces.get_field(dest) == PawnID * ord(color): game.pieces.getField(dest) == PawnID * ord(color):
game.pieces.set_field(dest, prom) game.pieces.setField(dest, prom)
return true return true
except IndexDefect, ValueError: except IndexDefect, ValueError:
return false return false
proc has_no_moves(game: Game, color: Color): bool = proc hasNoMoves(game: Game, color: Color): bool =
## Checks if a player of a given `color` has no legal moves in a `game`. ## Checks if a player of a given `color` has no legal moves in a `game`.
return (game.gen_legal_moves(color) == @[]) return (game.genLegalMoves(color) == @[])
proc is_checkmate*(game: Game, color: Color): bool = proc isCheckmate*(game: Game, color: Color): bool =
## Checks if a player of a given `color` in a `game` is checkmate. ## Checks if a player of a given `color` in a `game` is checkmate.
return game.has_no_moves(color) and game.is_in_check(color) return game.hasNoMoves(color) and game.isInCheck(color)
proc is_stalemate*(game: Game, color: Color): bool = proc isStalemate*(game: Game, color: Color): bool =
## Checks if a player of a given `color` in a `game` is stalemate. ## Checks if a player of a given `color` in a `game` is stalemate.
return game.has_no_moves(color) and not game.is_in_check(color) return game.hasNoMoves(color) and not game.isInCheck(color)

47
game.nim
Unescape View File

@ -3,44 +3,19 @@ import rdstdin
import ./chess import ./chess
proc notation_to_move(notation: string, color: Color): Move = proc runGame(): void =
## Convert simplified algebraic chess `notation` to a move object, color of player is `color`. var game = initGame()
try: game.echoBoard(game.toMove)
var move: Move while not game.isCheckmate(game.toMove):
var start = field_to_ind(notation[0..1])
var dest = field_to_ind(notation[2..3])
move = get_move(start, dest, color)
if (len(notation) > 4):
var prom_str = $notation[4]
var prom: int
case prom_str:
of "Q":
prom = QueenID * ord(color)
of "R":
prom = RookID * ord(color)
of "B":
prom = BishopID * ord(color)
of "N":
prom = KnightID * ord(color)
move = get_move(start, dest, prom, color)
return move
except IndexError:
var move: Move
return move
proc run_game(): void =
var game = init_game()
game.echo_board(game.to_move)
while not game.is_checkmate(game.to_move):
echo "Make a move" echo "Make a move"
echo game.to_move echo game.toMove
var move = readLine(stdin) var move = readLine(stdin)
while not game.checked_move(notation_to_move(move, game.to_move)): while not game.checkedMove(notationToMove(move, game.toMove)):
move = readLine(stdin) move = readLine(stdin)
game.echo_board(game.to_move) game.echoBoard(game.toMove)
if game.is_checkmate(game.to_move): if game.isCheckmate(game.toMove):
echo $game.to_move & " was checkmated" echo $game.toMove & " was checkmated"
if game.is_stalemate(game.to_move): if game.isStalemate(game.toMove):
echo "Stalemate" echo "Stalemate"
run_game() runGame()

1067
test.nim
View File

File diff suppressed because it is too large Load Diff
Write Preview
Loading…
Cancel
Save