mirror of https://github.com/tiyn/yeschess
The most important movements and even en passant and castling are implemented. A cli game is not done for now. An engine is the goal of the project, but will be focussed at the end of the basic development.master
TiynGER
4 years ago
parent
3747b1ae49
commit
b30aa89dc0
@ -1,2 +1,5 @@
|
||||
# ychess
|
||||
|
||||
**Attention**: This code is under construction and not finished yet.
|
||||
|
||||
ychess is a chess implementation written in nim.
|
||||
|
||||
@ -0,0 +1,511 @@
|
||||
import tables
|
||||
from strutils import parseInt
|
||||
|
||||
type
|
||||
Color* = enum
|
||||
Black = -1, White = 1
|
||||
## Board that saves the pieces
|
||||
Pieces* = array[0..119, int]
|
||||
## Board that checks if pieces moved
|
||||
Moved* = array[0..119, bool]
|
||||
## Game as object of different values
|
||||
Game* = object
|
||||
pieces: Pieces
|
||||
moved: Moved
|
||||
to_move: Color
|
||||
|
||||
const
|
||||
# IDs for piece
|
||||
BlockID* = 999
|
||||
PawnID* = 1
|
||||
KnightID* = 2
|
||||
BishopID* = 3
|
||||
RookID* = 4
|
||||
QueenID* = 5
|
||||
KingID* = 6
|
||||
EnPassantID* = 7
|
||||
# IDs that are saved in the array
|
||||
Block* = BlockID
|
||||
WPawn* = PawnID
|
||||
WKnight* = KnightID
|
||||
WBishop* = BishopID
|
||||
WRook* = RookID
|
||||
WQueen* = QueenID
|
||||
WKing* = KingID
|
||||
WEnPassant* = EnPassantID
|
||||
BPawn* = -PawnID
|
||||
BKnight* = -KnightID
|
||||
BBishop* = -BishopID
|
||||
BRook* = -RookID
|
||||
BQueen* = -QueenID
|
||||
BKing* = -KingID
|
||||
BEnPassant* = EnPassantID
|
||||
# Directions of movement
|
||||
N = 10
|
||||
S = -N
|
||||
W = 1
|
||||
E = -W
|
||||
# Movement options for pieces (Bishop/Rook/Queen can repeat in the same direction)
|
||||
Knight_Moves = [N+N+E, N+N+W, E+E+N, E+E+S, S+S+E, S+S+W, W+W+N, W+W+S]
|
||||
Bishop_Moves = [N+E, N+W, S+E, S+W]
|
||||
Rook_Moves = [N, E, S, W]
|
||||
Queen_Moves = [N, E, S, W, N+E, N+W, S+E, S+W]
|
||||
King_Moves = [N, E, S, W, N+E, N+W, S+E, S+W]
|
||||
Pawn_Moves_White = [N]
|
||||
Pawn_Moves_White_Double = [N+N]
|
||||
Pawn_Moves_White_Attack = [N+E, N+W]
|
||||
|
||||
var PieceChar = {
|
||||
0: " ",
|
||||
1: "P",
|
||||
2: "N",
|
||||
3: "B",
|
||||
4: "R",
|
||||
5: "Q",
|
||||
6: "K",
|
||||
7: " ",
|
||||
-1: "p",
|
||||
-2: "n",
|
||||
-3: "b",
|
||||
-4: "r",
|
||||
-5: "q",
|
||||
-6: "k",
|
||||
-7: " ",
|
||||
999: "-"
|
||||
}.newTable
|
||||
|
||||
var FileChar = {
|
||||
"a": 7,
|
||||
"b": 6,
|
||||
"c": 5,
|
||||
"d": 4,
|
||||
"e": 3,
|
||||
"f": 2,
|
||||
"g": 1,
|
||||
"h": 0
|
||||
}.newTable
|
||||
|
||||
proc init_board(): Pieces =
|
||||
## Create and return a board with pieces in starting position.
|
||||
let board = [
|
||||
Block, Block, Block, Block, Block, Block, Block, Block, Block, Block,
|
||||
Block, Block, Block, Block, Block, Block, Block, Block, Block, Block,
|
||||
Block, WRook, WKnight, WBishop, WKing, WQueen, WBishop, WKnight, WRook, Block,
|
||||
Block, WPawn, WPawn, WPawn, WPawn, WPawn, WPawn, WPawn, WPawn, Block,
|
||||
Block, 0, 0, 0, 0, 0, 0, 0, 0, Block,
|
||||
Block, 0, 0, 0, 0, 0, 0, 0, 0, Block,
|
||||
Block, 0, 0, 0, 0, 0, 0, 0, 0, Block,
|
||||
Block, 0, 0, 0, 0, 0, 0, 0, 0, Block,
|
||||
Block, BPawn, BPawn, BPawn, BPawn, BPawn, BPawn, BPawn, BPawn, Block,
|
||||
Block, BRook, BKnight, BBishop, BKing, BQueen, BBishop, BKnight, BRook, 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 =
|
||||
## Create and return a board of pieces moved.
|
||||
var moved: Moved
|
||||
return moved
|
||||
|
||||
proc init_game*(): Game =
|
||||
## Create and return a Game object.
|
||||
let game = Game(pieces: init_board(), moved: init_moved(),
|
||||
to_move: Color.White)
|
||||
return game
|
||||
|
||||
proc get_field*(pieces: Pieces, field: int): int =
|
||||
return pieces[field]
|
||||
|
||||
proc set_field(pieces: var Pieces, field: int, val: int): bool {.discardable.} =
|
||||
if (val in PieceChar):
|
||||
try:
|
||||
pieces[field] = val
|
||||
return true
|
||||
except Exception:
|
||||
return false
|
||||
|
||||
proc get_field*(moved: Moved, field: int): bool =
|
||||
return moved[field]
|
||||
|
||||
proc set_field(moved: var Moved, field: int, val: bool): bool {.discardable.} =
|
||||
try:
|
||||
moved[field] = val
|
||||
return true
|
||||
except Exception:
|
||||
return false
|
||||
|
||||
proc echo_board*(game: Game, color: Color) =
|
||||
## Prints out the given `board` with its pieces as characters and line indices from perspecive of `color`.
|
||||
var line_str = ""
|
||||
if (color == Color.Black):
|
||||
for i in countup(0, len(game.pieces)-1):
|
||||
if (game.pieces.get_field(i) == 999):
|
||||
continue
|
||||
line_str &= PieceChar[game.pieces[i]] & " "
|
||||
if ((i+2) %% 10 == 0):
|
||||
line_str &= $((int)((i)/10)-1) & "\n"
|
||||
echo line_str
|
||||
echo "h g f e d c b a"
|
||||
else:
|
||||
for i in countdown(len(game.pieces)-1, 0):
|
||||
if (game.pieces.get_field(i) == 999):
|
||||
continue
|
||||
line_str &= PieceChar[game.pieces[i]] & " "
|
||||
if ((i-1) %% 10 == 0):
|
||||
line_str &= $((int)((i)/10)-1) & "\n"
|
||||
echo line_str
|
||||
echo "a b c d e f g h"
|
||||
|
||||
proc field_to_ind*(file: string, line: int): int =
|
||||
## Calculate board index from `file` and `line` of a chess board.
|
||||
try:
|
||||
return 1+(line+1)*10+FileChar[file]
|
||||
except IndexDefect, ValueError:
|
||||
return -1
|
||||
|
||||
proc field_to_ind*(field: string): int =
|
||||
## Calculate board index from `field` of a chess board.
|
||||
try:
|
||||
return field_to_ind($field[0], parseInt($field[1]))
|
||||
except IndexDefect, ValueError:
|
||||
return -1
|
||||
|
||||
proc ind_to_field*(ind: int): string =
|
||||
## Calculate 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 gen_bishop_moves(game: Game, field: int, color: Color): seq[int] =
|
||||
## Generate possible moves for a bishop with specific `color` located at index `field` of `board`.
|
||||
## Returns a sequence of possible indices to move to.
|
||||
try:
|
||||
var res = newSeq[int]()
|
||||
var dest: int
|
||||
var target: int
|
||||
for move in Bishop_Moves:
|
||||
dest = field+move
|
||||
target = game.pieces.get_field(dest)
|
||||
while (target != 999 and (ord(color) * target <= 0) or target == EnPassantID):
|
||||
res.add(dest)
|
||||
if (ord(color) * target < 0 and ord(color) * target > -EnPassantID):
|
||||
break
|
||||
dest = dest+move
|
||||
target = game.pieces.get_field(dest)
|
||||
return res
|
||||
except IndexDefect:
|
||||
return @[]
|
||||
|
||||
proc gen_rook_moves(game: Game, field: int, color: Color): seq[int] =
|
||||
## Generate possible moves for a rook with specific `color` located at index `field` of `board`.
|
||||
## Returns a sequence of possible indices to move to.
|
||||
try:
|
||||
var res = newSeq[int]()
|
||||
var dest: int
|
||||
var target: int
|
||||
for move in Rook_Moves:
|
||||
dest = field+move
|
||||
target = game.pieces.get_field(dest)
|
||||
while (target != 999 and (ord(color) * target <= 0) or target == EnPassantID):
|
||||
res.add(dest)
|
||||
if (ord(color) * target < 0 and ord(color) * target > -EnPassantID):
|
||||
break
|
||||
dest = dest+move
|
||||
target = game.pieces.get_field(dest)
|
||||
return res
|
||||
except IndexDefect:
|
||||
return @[]
|
||||
|
||||
proc gen_queen_moves(game: Game, field: int, color: Color): seq[int] =
|
||||
## Generate possible moves for a queen with specific `color` located at index `field` of `board`.
|
||||
## Returns a sequence of possible indices to move to.
|
||||
try:
|
||||
var res = newSeq[int]()
|
||||
var dest: int
|
||||
var target: int
|
||||
for move in Queen_Moves:
|
||||
dest = field+move
|
||||
target = game.pieces.get_field(dest)
|
||||
while (target != 999 and (ord(color) * target <= 0) or target == EnPassantID):
|
||||
res.add(dest)
|
||||
if (ord(color) * target < 0 and ord(color) * target > -EnPassantID):
|
||||
break
|
||||
dest = dest+move
|
||||
target = game.pieces.get_field(dest)
|
||||
return res
|
||||
except IndexDefect:
|
||||
return @[]
|
||||
|
||||
proc gen_king_moves(game: Game, field: int, color: Color): seq[int] =
|
||||
## Generate possible moves for a king with specific `color` located at index `field` of `board`.
|
||||
## Returns a sequence of possible indices to move to.
|
||||
try:
|
||||
var res = newSeq[int]()
|
||||
var dest: int
|
||||
var target: int
|
||||
for move in King_Moves:
|
||||
dest = field + move
|
||||
target = game.pieces.get_field(dest)
|
||||
if (target == 999 or (ord(color) * target > 0 and ord(color) * target != EnPassantID)):
|
||||
continue
|
||||
res.add(dest)
|
||||
return res
|
||||
except IndexDefect:
|
||||
return @[]
|
||||
|
||||
proc gen_knight_moves(game: Game, field: int, color: Color): seq[int] =
|
||||
## Generate possible moves for a knight with specific `color` located at index `field` of `board`.
|
||||
## Returns a sequence of possible indices to move to.
|
||||
try:
|
||||
var res = newSeq[int]()
|
||||
var dest: int
|
||||
var target: int
|
||||
for move in Knight_Moves:
|
||||
dest = field + move
|
||||
target = game.pieces.get_field(dest)
|
||||
if (target == 999 or (ord(color) * target > 0 and ord(color) * target != EnPassantID)):
|
||||
continue
|
||||
res.add(dest)
|
||||
return res
|
||||
except IndexDefect:
|
||||
return @[]
|
||||
|
||||
proc gen_pawn_attacks(game: Game, field: int, color: Color): seq[int] =
|
||||
## Generate possible attacks for a pawn with specific `color` located at index `field` of `board`.
|
||||
## Returns a sequence of possible indices to move to.
|
||||
try:
|
||||
var res = newSeq[int]()
|
||||
var dest: int
|
||||
var target: int
|
||||
for attacks in Pawn_Moves_White_Attack:
|
||||
dest = field + attacks * ord(color)
|
||||
target = game.pieces.get_field(dest)
|
||||
if (target == 999 or ord(color) * target >= 0):
|
||||
continue
|
||||
res.add(dest)
|
||||
return res
|
||||
except IndexDefect:
|
||||
return @[]
|
||||
|
||||
proc gen_pawn_doubles(game: Game, field: int, color: Color): seq[int] =
|
||||
## Generate possible double moves for a pawn with specific `color` located at index `field` of `board`.
|
||||
## Returns a sequence of possible indices to move to.
|
||||
try:
|
||||
var res = newSeq[int]()
|
||||
var dest: int
|
||||
var target: int
|
||||
for doubles in Pawn_Moves_White_Double:
|
||||
dest = field + doubles * ord(color)
|
||||
target = game.pieces.get_field(dest)
|
||||
if (game.moved.get_field(field) or (target != 0) or (game.pieces.get_field(dest+(S*ord(color))) != 0)):
|
||||
continue
|
||||
res.add(dest)
|
||||
return res
|
||||
except IndexDefect:
|
||||
return @[]
|
||||
|
||||
proc gen_pawn_moves(game: Game, field: int, color: Color): seq[int] =
|
||||
## Generate possible moves for a pawn with specific `color` located at index `field` of `board`.
|
||||
## Returns a sequence of possible indices to move to.
|
||||
try:
|
||||
var res = newSeq[int]()
|
||||
var dest: int
|
||||
var target: int
|
||||
for move in Pawn_Moves_White:
|
||||
dest = field + move * ord(color)
|
||||
target = game.pieces.get_field(dest)
|
||||
if (target != 0 and target != ord(color) * EnPassantID):
|
||||
continue
|
||||
res.add(dest)
|
||||
res.add(game.gen_pawn_attacks(field, color))
|
||||
res.add(game.gen_pawn_doubles(field, color))
|
||||
return res
|
||||
except IndexDefect:
|
||||
return @[]
|
||||
|
||||
proc piece_on(game: Game, color: Color, sequence: seq[int],
|
||||
pieceID: int): bool =
|
||||
## 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:
|
||||
if game.pieces.get_field(check) == ord(color) * -1 * pieceID:
|
||||
return true
|
||||
return false
|
||||
|
||||
proc is_attacked(game: Game, position: int, color: Color): bool =
|
||||
## Check if a field is attacked by the opposite of `color` in a `game`.
|
||||
var attacked = false
|
||||
attacked = attacked or game.piece_on(color, game.gen_pawn_attacks(position,
|
||||
color), PawnID)
|
||||
attacked = attacked or game.piece_on(color, game.gen_queen_moves(position,
|
||||
color), QueenID)
|
||||
attacked = attacked or game.piece_on(color, game.gen_king_moves(position,
|
||||
color), KingID)
|
||||
attacked = attacked or game.piece_on(color, game.gen_rook_moves(position,
|
||||
color), RookID)
|
||||
attacked = attacked or game.piece_on(color, game.gen_bishop_moves(position,
|
||||
color), BishopID)
|
||||
attacked = attacked or game.piece_on(color, game.gen_knight_moves(position,
|
||||
color), KnightID)
|
||||
return attacked
|
||||
|
||||
proc is_in_check(game: Game, color: Color): bool =
|
||||
## Check if the King of a given `color` is in check in a `game`.
|
||||
var king_pos: int
|
||||
for i in countup(0, game.pieces.high):
|
||||
if game.pieces.get_field(i) == ord(color) * KingID:
|
||||
king_pos = i
|
||||
return game.is_attacked(king_pos, color)
|
||||
|
||||
proc simple_move(game: var Game, start: int, dest: int): bool {.discardable.} =
|
||||
## Moves a piece if possible from `start` position to `dest` position.
|
||||
## Doesnt check boundaries, checks, movement.
|
||||
## returns true if the piece moved, else false
|
||||
try:
|
||||
let piece = game.pieces.get_field(start)
|
||||
if game.pieces.set_field(start, 0):
|
||||
if game.pieces.set_field(dest, piece):
|
||||
game.moved.set_field(start, true)
|
||||
game.moved.set_field(dest, true)
|
||||
return true
|
||||
else:
|
||||
game.pieces.set_field(start, piece)
|
||||
except IndexDefect, ValueError:
|
||||
return false
|
||||
|
||||
proc move_leads_to_check(game: Game, start: int, dest: int,
|
||||
color: Color): bool =
|
||||
## Checks in a game if a move from `start` to `dest` puts the `color` king in check.
|
||||
var check = game
|
||||
check.simple_move(start, dest)
|
||||
return check.is_in_check(color)
|
||||
|
||||
proc remove_en_passant(pieces: var Pieces, color: Color): void =
|
||||
## Removes every en passant of given `color` from the `game`.
|
||||
for field in pieces.low..pieces.high:
|
||||
if pieces.get_field(field) == ord(color) * EnPassantID:
|
||||
pieces.set_field(field,0)
|
||||
|
||||
proc checked_move*(game: var Game, start: int, dest: int, color: Color): bool {.discardable.} =
|
||||
## 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`
|
||||
try:
|
||||
if game.to_move != color:
|
||||
return false
|
||||
var sequence = newSeq[int]()
|
||||
let piece = game.pieces.get_field(start)
|
||||
var create_en_passant = false
|
||||
var captured_en_passant = false
|
||||
if (piece == PawnID * ord(color)):
|
||||
sequence.add(game.gen_pawn_moves(start, color))
|
||||
create_en_passant = dest in game.gen_pawn_doubles(start,color)
|
||||
captured_en_passant = (game.pieces.get_field(dest) == -1 * ord(color) * EnPassantID)
|
||||
if (piece == KnightID * ord(color)):
|
||||
sequence.add(game.gen_knight_moves(start, color))
|
||||
if (piece == BishopID * ord(color)):
|
||||
sequence.add(game.gen_bishop_moves(start, color))
|
||||
if (piece == RookID * ord(color)):
|
||||
sequence.add(game.gen_rook_moves(start, color))
|
||||
if (piece == QueenID * ord(color)):
|
||||
sequence.add(game.gen_queen_moves(start, color))
|
||||
if (piece == KingID * ord(color)):
|
||||
sequence.add(game.gen_king_moves(start, color))
|
||||
if (dest in sequence) and not game.move_leads_to_check(start, dest, color):
|
||||
game.pieces.remove_en_passant(color)
|
||||
game.simple_move(start, dest)
|
||||
game.to_move = Color(ord(game.to_move)*(-1))
|
||||
if create_en_passant:
|
||||
game.pieces.set_field(dest-(N*ord(color)),EnPassantID * ord(color))
|
||||
if captured_en_passant:
|
||||
game.pieces.set_field(dest-(N*ord(color)),0)
|
||||
return true
|
||||
except IndexDefect, ValueError:
|
||||
return false
|
||||
|
||||
proc checked_promotion*(game: var Game, start: int, dest: int, color: Color,
|
||||
prom: int): bool {.discardable.} =
|
||||
## Tries to make a promotion to `prom` 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`
|
||||
try:
|
||||
if game.pieces.get_field(start) != PawnID * ord(color) or (1 > prom or
|
||||
prom > 5):
|
||||
return false
|
||||
if (90 < dest and dest < 99) or (20 < dest and dest < 29):
|
||||
if (game.checked_move(start, dest, color)):
|
||||
game.pieces.set_field(dest, prom)
|
||||
return false
|
||||
except IndexDefect, ValueError:
|
||||
return false
|
||||
|
||||
proc castling*(game: var Game, kstart: int, dest_kingside: bool,
|
||||
color: Color): bool {.discardable.} =
|
||||
## Tries to castle in a given `game` with the king of a given `color` from `start`.
|
||||
## `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`
|
||||
try:
|
||||
if game.to_move != color:
|
||||
return false
|
||||
var kdest = kstart
|
||||
var rstart: int
|
||||
var rdest: int
|
||||
if (dest_kingside):
|
||||
kdest = kstart + (E+E) * ord(color)
|
||||
rstart = kstart + (E+E+E) * ord(color)
|
||||
rdest = rstart + (W+W) * ord(color)
|
||||
else:
|
||||
rstart = kstart + (W+W+W+W) * ord(color)
|
||||
rdest = rstart + (E+E+E) * ord(color)
|
||||
kdest = kstart + (W+W) * ord(color)
|
||||
if not game.moved.get_field(kstart) and not game.moved.get_field(rstart):
|
||||
var check = false
|
||||
if (dest_kingside):
|
||||
check = check or game.is_attacked(kstart, color)
|
||||
check = check or game.is_attacked(kstart+(E)*ord(color), color)
|
||||
check = check or game.is_attacked(kstart+(E+E)*ord(color), color)
|
||||
else:
|
||||
check = check or game.is_attacked(kstart, color)
|
||||
check = check or game.is_attacked(kstart+(W)*ord(color), color)
|
||||
check = check or game.is_attacked(kstart+(W+W)*ord(color), color)
|
||||
if check:
|
||||
return false
|
||||
game.simple_move(kstart, kdest)
|
||||
game.simple_move(rstart, rdest)
|
||||
return false
|
||||
except IndexDefect, ValueError:
|
||||
return false
|
||||
|
||||
proc has_no_moves(game: Game, color: Color): bool =
|
||||
## Checks if a player of a given `color` has no legal moves in a `game`.
|
||||
var sequence = newSeq[(int,int)]()
|
||||
for field_ind in game.pieces.low..game.pieces.high:
|
||||
var target = ord(color) * game.pieces.get_field(field_ind)
|
||||
if 0 < target and target < EnPassantID:
|
||||
var possibilities = newSeq[int]()
|
||||
case target:
|
||||
of PawnID:
|
||||
possibilities = game.gen_pawn_moves(field_ind, color)
|
||||
of KnightID:
|
||||
possibilities = game.gen_knight_moves(field_ind, color)
|
||||
of BishopID:
|
||||
possibilities = game.gen_bishop_moves(field_ind, color)
|
||||
of RookID:
|
||||
possibilities = game.gen_rook_moves(field_ind, color)
|
||||
of QueenID:
|
||||
possibilities = game.gen_queen_moves(field_ind, color)
|
||||
of KingID:
|
||||
possibilities = game.gen_king_moves(field_ind, color)
|
||||
else:
|
||||
continue
|
||||
for dest in possibilities:
|
||||
if (not game.move_leads_to_check(field_ind,dest,color)):
|
||||
return false
|
||||
return true
|
||||
|
||||
proc is_checkmate*(game: Game, color: Color): bool =
|
||||
## 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)
|
||||
|
||||
proc is_stalemate*(game: Game, color: Color): bool =
|
||||
## 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)
|
||||
@ -0,0 +1,12 @@
|
||||
import ./chess
|
||||
|
||||
# Testing
|
||||
|
||||
var game = chess.init_game()
|
||||
game.checked_move(field_to_ind("e2"),field_to_ind("e4"),Color.White)
|
||||
game.checked_move(field_to_ind("e7"),field_to_ind("e6"),Color.Black)
|
||||
game.checked_move(field_to_ind("g2"),field_to_ind("g4"),Color.White)
|
||||
game.checked_move(field_to_ind("d8"),field_to_ind("h4"),Color.Black)
|
||||
game.echo_board(Color.White)
|
||||
echo game.is_checkmate(Color.White)
|
||||
echo game.is_stalemate(Color.White)
|
||||
Loading…
Reference in new issue