tiyn/yeschess
1
0
Fork 0
mirror of https://github.com/tiyn/yeschess.git synced 2025-04-01 14:47:44 +02:00
Code Issues Projects Releases Wiki Activity

refactoring: absolute path for db, general refactoring

Browse Source 
Due to the path for the db being relative it came
to problems when importing the openingBook.nim file
in other modules (especially in ).
To change this i added a variable, that needs to point to the
root directory of the project.
Additionally i set some coding guidelines and enforced them
into the current codebase.
This commit is contained in:
TiynGER 2021-05-16 03:15:40 +02:00
parent 80772462da
commit e306de0573
5 changed files with 121 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
README.md
View File

@ -52,3 +52,32 @@ The engine uses a simple implementation of the
For the evaluation function each piece has a corresponding value.
Additionally [piece-square tables](https://www.chessprogramming.org/Piece-Square_Tables)
are used.
## Contributing
### Setup
To setup the project for development you need to create the file
`src/secret.nim`.
It should contain values for the following variables:
```nim
let projectdir* = "<absolute path to root dir of ychess>"
let api_token* = "<lichess api token for bot>"
```
### Code Style Guide
Basic arithmetic operations should be surrounded by spaces for example: `1 + 3`.
This however is not true for negation of a single value (`-1`) or if the
arithmetic operation is done inside array brackets or in iterators (`a+1..3`,
`a[c+3]`).
Determining the length of a string, array, etc should not be done via a function
(`len(array)`) but by appending it like `array.len`.
If statements should not contain outer brackets.
In some cases (especially concatenations of `and` and `or`) inner brackets are
useful to increase readability in complexer logic formulas.
When assigning booleans with logical formulas outer brackets are expected.

96
src/chess.nim
View File

@ -153,7 +153,7 @@ proc fieldToInd(field: string): int =
proc indToField(ind: int): string =
## Calculate and returns field name from board index `ind`.
let line = int(ind / 10 - 1)
let file_ind = 7 - ((ind) %% 10 - 1)
let file_ind = 7 - (ind %% 10 - 1)
for file, i in FileChar:
if FileChar[file] == file_ind:
return $file & $line
@ -162,7 +162,7 @@ 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 (prom < WKnight or prom > WQueen):
if prom < WKnight or prom > WQueen:
move.prom = WQueen
return move
@ -181,7 +181,7 @@ proc notationToMove*(notation: string, color: Color): Move =
var start = fieldToInd(notation[0..1])
var dest = fieldToInd(notation[2..3])
move = getMove(start, dest, color)
if (len(notation) > 4):
if notation.len > 4:
var promStr = $notation[4]
let prom = case promStr:
of "R":
@ -351,22 +351,22 @@ proc echoBoard*(chess: Chess, color: Color) =
## Prints out the given `board` with its pieces as characters and line
## indices from perspecive of `color`.
var line_str: string
if (color == Color.Black):
for i in 0..len(chess.board)-1:
if (chess.board[i] == Block):
if color == Color.Black:
for i in 0..chess.board.len-1:
if chess.board[i] == Block:
continue
line_str &= PieceChar[chess.board[i]] & " "
if ((i + 2) %% 10 == 0):
line_str &= $(int((i / 10) - 1)) & "\n"
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(chess.board) - 1, 0):
if (chess.board[i] == Block):
if chess.board[i] == Block:
continue
line_str &= PieceChar[chess.board[i]] & " "
if ((i - 1) %% 10 == 0):
line_str &= $(int((i / 10) - 1)) & "\n"
if (i - 1) %% 10 == 0:
line_str &= $int((i / 10) - 1) & "\n"
echo line_str
echo "a b c d e f g h"
@ -374,7 +374,7 @@ proc genPawnAttackDests(chess: Chess, field: int, color: Color): seq[int] =
## Generate possible attack destinations for a pawn with specific `color`
## located at index `field` of `chess`.
## Returns a sequence of possible indices to move to.
if (not field in chess.board.low..chess.board.high):
if field < chess.board.low or field > chess.board.high:
return @[]
var res = newSeq[int]()
var dest: int
@ -395,7 +395,7 @@ proc genPawnDoubleDests(chess: Chess, field: int, color: Color): seq[int] =
## Generate possible double destinations for a pawn with specific `color`
## located at index `field` of `chess`.
## Returns a sequence of possible indices to move to.
if (not field in chess.board.low..chess.board.high):
if field < chess.board.low or field > chess.board.high:
return @[]
var res = newSeq[int]()
var dest: int
@ -403,12 +403,12 @@ proc genPawnDoubleDests(chess: Chess, field: int, color: Color): seq[int] =
for doubles in Pawn_Moves_White_Double:
dest = field + doubles * ord(color)
target = chess.board[dest]
if ((target != 0) or (
chess.board[dest + (S * ord(color))] != 0)):
if target != 0 or
chess.board[dest + (S * ord(color))] != 0:
continue
if (color == Color.White and not (field in fieldToInd("h2")..fieldToInd("a2"))):
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"))):
if color == Color.Black and not (field in fieldToInd("h7")..fieldToInd("a7")):
continue
res.add(dest)
return res
@ -417,17 +417,17 @@ proc genPawnDests(chess: Chess, field: int, color: Color): seq[int] =
## Generate possible destinations for a pawn with specific `color` located at
## index `field` of `chess`.
## Returns a sequence of possible indices to move to.
if (not field in chess.board.low..chess.board.high):
if field < chess.board.low or field > chess.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 chess.board.low..chess.board.high):
if not dest in chess.board.low..chess.board.high:
continue
target = chess.board[dest]
if (target != 0 and dest != chess.enPassantSquare):
if target != 0 and dest != chess.enPassantSquare:
continue
res.add(dest)
res.add(chess.genPawnAttackDests(field, color))
@ -438,17 +438,17 @@ proc genKnightDests(chess: Chess, field: int, color: Color): seq[int] =
## Generate possible destinations for a knight with specific `color` located
## at index `field` of `chess`.
## Returns a sequence of possible indices to move to.
if (not field in chess.board.low..chess.board.high):
if field < chess.board.low or field > chess.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 chess.board.low..chess.board.high):
if not dest in chess.board.low..chess.board.high:
continue
target = chess.board[dest]
if (target == Block or (ord(color) * target > 0)):
if target == Block or ord(color) * target > 0:
continue
res.add(dest)
return res
@ -458,19 +458,19 @@ proc genSlidePieceDests(chess: Chess, field: int, color: Color, moves: seq[
## Generate possible destinations for a piece with `moves` and specific `color`
## located at index `field` of `chess`.
## Returns a sequence of possible indices to move to.
if (not field in chess.board.low..chess.board.high):
if field < chess.board.low or field > chess.board.high:
return @[]
var res = newSeq[int]()
var dest: int
var target: int
for move in moves:
dest = field + move
if (not dest in chess.board.low..chess.board.high):
if not dest in chess.board.low..chess.board.high:
continue
target = chess.board[dest]
while (target != Block and (ord(color) * target <= 0)):
while target != Block and ord(color) * target <= 0:
res.add(dest)
if (ord(color) * target < 0):
if ord(color) * target < 0:
break
dest = dest + move
target = chess.board[dest]
@ -498,7 +498,7 @@ proc genKingCastleDest(chess: Chess, field: int, color: Color): seq[int] =
## Generate possible castle destinations for a king with specific `color`
## located at index `field` of `chess`
## Returns a sequence of possible indices to move to.
if (not field in chess.board.low..chess.board.high):
if field < chess.board.low or field > chess.board.high:
return @[]
var res = newSeq[int]()
var dest: int
@ -507,14 +507,14 @@ proc genKingCastleDest(chess: Chess, field: int, color: Color): seq[int] =
var half_target: int
for castle in King_Moves_White_Castle:
dest = field + castle
if (not dest in chess.board.low..chess.board.high):
if not dest in chess.board.low..chess.board.high:
continue
target = chess.board[dest]
half_dest = field + int(castle / 2)
half_target = chess.board[half_dest]
if (target == Block or (target != 0)):
if target == Block or target != 0:
continue
if (half_target == Block or (half_target != 0)):
if half_target == Block or half_target != 0:
continue
res.add(dest)
return res
@ -523,17 +523,17 @@ proc genKingDests(chess: Chess, field: int, color: Color): seq[int] =
## Generate possible destinations for a king with specific `color`
## located at index `field` of `chess`.
## Returns a sequence of possible indices to move to.
if (not field in chess.board.low..chess.board.high):
if field < chess.board.low or field > chess.board.high:
return @[]
var res = newSeq[int]()
var dest: int
var target: int
for move in King_Moves:
dest = field + move
if (not dest in chess.board.low..chess.board.high):
if not dest in chess.board.low..chess.board.high:
continue
target = chess.board[dest]
if (target == Block or (ord(color) * target > 0)):
if target == Block or ord(color) * target > 0:
continue
res.add(dest)
res.add(chess.genKingCastleDest(field, color))
@ -717,11 +717,11 @@ proc castling(chess: var Chess, kstart: int, dest_kingside: bool,
var rstart: int
var rdest: int
var rights: bool
if (dest_kingside):
if dest_kingside:
kdest = kstart + E + E
rstart = kstart + E + E + E
rdest = rstart + W + W
if (color == Color.White):
if color == Color.White:
rights = chess.castleRights.wk
else:
rights = chess.castleRights.bk
@ -729,12 +729,12 @@ proc castling(chess: var Chess, kstart: int, dest_kingside: bool,
kdest = kstart + W + W
rstart = kstart + W + W + W + W
rdest = rstart + E + E + E
if (color == Color.White):
if color == Color.White:
rights = chess.castleRights.wq
else:
rights = chess.castleRights.bq
if (rights):
if (dest_kingside):
if rights:
if dest_kingside:
if chess.isAttacked(kstart, color) or chess.isAttacked(kstart+E, color) or
chess.isAttacked(kstart+E+E, color) or chess.board[kstart+E] != 0 or
chess.board[kstart+E+E] != 0:
@ -760,7 +760,7 @@ proc checkedMove*(chess: var Chess, move: Move): bool {.discardable.} =
let dest = move.dest
let color = move.color
let prom = move.prom
if (chess.toMove != color or start == -1 or dest == -1):
if chess.toMove != color or start == -1 or dest == -1:
return false
let piece = chess.board[start]
var createEnPassant: bool
@ -768,17 +768,17 @@ proc checkedMove*(chess: var Chess, move: Move): bool {.discardable.} =
var fiftyMoveRuleReset: bool
var move: Move
move = getMove(start, dest, color)
if (piece == WKing * ord(color) and (start - dest == (W+W))):
if piece == WKing * ord(color) and start - dest == (W+W):
return chess.castling(start, true, color)
elif (piece == WKing * ord(color) and (start - dest == (E+E))):
elif piece == WKing * ord(color) and start - dest == (E+E):
return chess.castling(start, false, color)
if (piece == WPawn * ord(color)):
if piece == WPawn * ord(color):
createEnPassant = dest in chess.genPawnDoubleDests(start, color)
capturedEnPassant = (dest == chess.enPassantSquare)
fiftyMoveRuleReset = true
if (chess.board[move.dest] != 0):
if chess.board[move.dest] != 0:
fiftyMoveRuleReset = true
if (move in chess.genLegalMoves(start, color)):
if move in chess.genLegalMoves(start, color):
chess.enPassantSquare = -1
chess.uncheckedMove(start, dest)
chess.toMove = Color(ord(chess.toMove)*(-1))
@ -812,8 +812,8 @@ proc threeMoveRep(chess: Chess): bool =
return false
var lastState = chess.previousBoard[chess.previousBoard.high]
var reps: int
for stateInd in (chess.previousBoard.low)..(chess.previousBoard.high):
if (chess.previousBoard[stateInd] == lastState):
for stateInd in chess.previousBoard.low..chess.previousBoard.high:
if chess.previousBoard[stateInd] == lastState:
reps = reps + 1
return reps >= 3
@ -839,7 +839,7 @@ proc checkInsufficientMaterial(board: Board): bool =
pieces[4])
let bpieces: PieceAmount = (pieces[5], pieces[6], pieces[7], pieces[8],
pieces[9])
return (wpieces in InsufficientMaterial) and (bpieces in InsufficientMaterial)
return wpieces in InsufficientMaterial and bpieces in InsufficientMaterial
proc isStalemate*(chess: Chess, color: Color): bool =
## Returns true if the `color` player is stalemate in a `chess`.

2
src/engine/lichessBridge.nim
View File

@ -2,7 +2,7 @@ import nimpy
import asyncnet, asyncdispatch
import chess
import engine/secret
import secret
import engine/engine
let berserk = pyImport("berserk")

42
src/engine/posMoveDB.nim → src/engine/openingBook.nim
View File

@ -3,18 +3,31 @@ import sequtils
import strutils
import sugar
import tables
import os
include chess
let dbConn = "openings.db"
import secret
type
BookMove* = object
## `PossibleMove` capsulates a possible moves in a position with additional
## statistics.
fen*: string # `fen` is the fen string of a position.
move*: string # `move` describes a move in pure coordinate notation.
white*: int # `white` is the number of game white won from this position.
black*: int # `black` is the number of game black won from this position.
draw*: int # `draw` is the number of game drawn from this position.
rating*: int # `rating` is the average rating of the player to move.
let dbConn = projectdir & "src/engine/openings.db"
let dbUser = ""
let dbPasswd = ""
let dbName = ""
let tableName = "posmoves"
proc initDB*(): void =
proc initDB(): void =
## Initialize the database with a table if it doesnt currently exist.
let db = open(dbConn, dbUser, dbPasswd, dbName)
db.exec(sql"""CREATE TABLE IF NOT EXISTS ? (
@ -29,7 +42,7 @@ proc initDB*(): void =
db.close()
echo("Database initialization done.")
proc storeMove*(fen: string, move: string, white: bool, black: bool, draw: bool,
proc storeMove(fen: string, move: string, white: bool, black: bool, draw: bool,
rating: int): void =
## Store a possible `move` done by a player with `rating` (0 for unknown)
## in a position described by `fen`.
@ -54,7 +67,9 @@ proc storeMove*(fen: string, move: string, white: bool, black: bool, draw: bool,
echo("inserted (", join([fen, move, $white, $black, $draw, $rating], ", "),
") into ", tableName)
proc loadMove*(fen: string): seq[Row] =
proc loadMove*(fen: string): seq[BookMove] =
## Load all possible moves possible in a given position described by `fen`
## from the database. Format moves as a BookMove object.
let db = open(dbConn, dbUser, dbPasswd, dbName)
let res = db.getAllRows(sql """SELECT move, white, black, draw, rating
FROM ?
@ -62,7 +77,17 @@ proc loadMove*(fen: string): seq[Row] =
ORDER BY rating DESC
""", tableName, fen)
db.close()
return res
var fRes: seq[BookMove]
for entry in res:
var bookMv: BookMove
bookMv.fen = fen
bookMv.move = entry[0]
bookMv.white = parseInt(entry[1])
bookMv.black = parseInt(entry[2])
bookMv.draw = parseInt(entry[3])
bookMv.rating = parseInt(entry[4])
fRes.add(bookMv)
return fRes
proc sanToPcn(sanMoves: string): string =
## Convert a list of `sanMoves` to pure coordinate notation (assuming the game
@ -224,5 +249,6 @@ proc iterMultiPGN(fileP: string): void =
else:
sanMoves &= line
initDB()
when isMainModule:
initDB()
#iterMultiPGN("file.pgn")

18
src/game.nim
View File

@ -15,10 +15,10 @@ proc runGameHotseat*(): void =
while not chess.checkedMove(notationToMove(move, chess.toMove)):
move = readLine(stdin)
chess.echoBoard(chess.toMove)
if (chess.isDrawClaimable()):
if chess.isDrawClaimable():
echo "Do you want to claim a draw? (y/N)"
draw = readLine(stdin)
if (draw == "y"):
if draw == "y":
echo "Draw claimed"
break
if chess.isCheckmate(chess.toMove):
@ -33,17 +33,17 @@ proc runGameSolo*(color: Color, difficulty: int): void =
var chess = initChess()
var draw: string
while not chess.isCheckmate(chess.toMove) and not chess.isStalemate(chess.toMove):
if (chess.toMove == color):
if chess.toMove == color:
chess.echoBoard(color)
echo "Make a move"
var hMove = readLine(stdin)
while not chess.checkedMove(notationToMove(hMove, chess.toMove)):
hMove = readLine(stdin)
chess.echoBoard(color)
if (chess.isDrawClaimable):
if chess.isDrawClaimable():
echo "Do you want to claim a draw? (y/N)"
draw = readLine(stdin)
if (draw == "y"):
if draw == "y":
echo "Draw claimed"
break
else:
@ -63,7 +63,7 @@ proc menu(): void =
echo("How many players? (1/2)")
input = readLine(stdin)
discard parseInt(input, playerCount, 0)
if (playerCount == 1 or playerCount == 2):
if playerCount == 1 or playerCount == 2:
break
if playerCount == 1:
var color: string
@ -72,16 +72,16 @@ proc menu(): void =
echo("Choose the difficulty for the engine (1-10)")
input = readLine(stdin)
discard parseInt(input, difficulty, 0)
if (difficulty >= 1 and difficulty <= 10):
if difficulty >= 1 and difficulty <= 10:
break
while true:
echo("Do you want to play Black or White? (B/W)")
color = readLine(stdin)
if (color == "B"):
if color == "B":
echo("\n\n\n")
runGameSolo(Color.Black, difficulty)
break
elif (color == "W"):
elif color == "W":
echo("\n\n\n")
runGameSolo(Color.White, difficulty)
break