added matches

ender_match/ender.ini

@@ -0,0 +1,34 @@
+[DEFAULT]
+Games=50
+Output=komodo_white.pgn
+Openings=/home/dkappe/work/chess/Arena/Engines/LeelaZero/192/openings/noomen3.pgn
+Enemy=Komodo 12
+Enemy Command=/home/dkappe/work/chess/Arena/Engines/Komodo/komodo-12-linux-BMI2
+Leela=ID11258 lc0 0.19.1-rc1
+Leela Command=/home/dkappe/deep1/chess/bin/lc0.19.1-rc1
+Ender=Franken-Ender-83
+Ender Command=/home/dkappe/deep1/chess/bin/lc0.19.1-rc1
+Movetime=2500
+Color=White
+Leela Ratio=0.75
+EGTB Path=/home/dkappe/deep1/chess/egtb
+[Leela Options]
+Threads=2
+SyzygyPath=/home/dkappe/deep1/chess/egtb
+WeightsFile=/home/dkappe/work/chess/Arena/Engines/LeelaZero/192/weights_11258.txt.gz
+CPuct=2.5
+DirichletNoise=true
+[Ender Options]
+Threads=2
+SyzygyPath=/home/dkappe/deep1/chess/egtb
+WeightsFile=/home/dkappe/deep1/chess/ender-test/ender128-83.pb
+CPuct=3.5
+DirichletNoise=false
+SmartPruningFactor=0
+FpuReduction=1.02
+PolicyTemperature=1.7
+[Enemy Options]
+Threads=4
+Hash=1024
+Ponder=false
+SyzygyPath=/home/dkappe/deep1/chess/egtb

ender_match/ender_match.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

ender_match/ender_match.py

@@ -0,0 +1,240 @@
+import time
+import chess
+import chess.pgn
+import chess.uci
+import chess.syzygy
+import sys
+import configparser
+from random import randrange
+
+
+config = configparser.ConfigParser()
+config.read(sys.argv[1])
+
+ENDER_PIECE_COUNT = int(config['DEFAULT']['Piece Count'])
+
+class Engine:
+    def __init__(self, name=None, cmd=None, options=None):
+        super().__init__()
+        self.name = name
+        self.engine = chess.uci.popen_engine(cmd)
+        self.engine.setoption(options)
+        self.engine.uci()
+        self.engine.isready()
+
+
+
+class Openings:
+    def __init__(self, pgnfile=None):
+        super().__init__()
+        self.openings = []
+        if pgnfile != None:
+            while True:
+                game = chess.pgn.read_game(pgnfile)
+                if game == None:
+                    break
+                else:
+                    self.openings.append(game)
+
+    def opening_count(self):
+        return len(self.openings)
+
+    def get_opening(self):
+        random_index = randrange(len(self.openings))
+        return self.openings[random_index]
+
+class MatchGame:
+    def __init__(self, white=None, black=None, egtb_path=None, tbadj=6):
+        super().__init__()
+        self.white = white
+        self.black = black
+        self.tb = chess.syzygy.open_tablebases(egtb_path)
+        self.tbadj = tbadj
+        self.board = chess.Board()
+
+    def adjudicate(self):
+        if self.board.is_game_over(claim_draw=True):
+            return False, None, None
+        elif len(self.board.piece_map()) <= self.tbadj:
+            result = self.tb.get_wdl(self.board)
+            if result == None:
+                return False, None, None
+            side_to_move = self.board.turn
+            if side_to_move: # white
+                if result == 2:
+                    return True, "1-0", "TB win for White."
+                elif result == -2:
+                    return True, "0-1", "TB win for Black"
+                else:
+                    return True, "1/2-1/2", "TB draw"
+            else: # black
+                if result == 2:
+                    return True, "0-1", "TB win for Black."
+                elif result == -2:
+                    return True, "1-0", "TB win for White"
+                else:
+                    return True, "1/2-1/2", "TB draw"
+        else:
+            return False, None, None
+
+    def game_over(self):
+        if self.board.is_game_over(claim_draw=True):
+            game = chess.pgn.Game.from_board(self.board)
+            game.headers['Result'] = self.board.result(claim_draw=True)
+            return True, game
+        else:
+            adjudicated, result, comment = self.adjudicate()
+            if adjudicated:
+                game = chess.pgn.Game.from_board(self.board)
+                game.headers['Result'] = result
+                node = game.end()
+                node.comment = comment
+                return True, game
+            else:
+                return False, None
+
+    def populate_headers(self, game):
+        game.headers['Event'] = 'Event'
+        game.headers['Site'] = 'Site'
+        game.headers['Date'] = '??'
+        game.headers['White'] = self.white.name
+        game.headers['Black'] = self.black.name
+        game.headers['Round'] = 1
+
+    def play(self, movetime=1000, opening=None):
+        self.white.engine.ucinewgame()
+        self.black.engine.ucinewgame()
+
+        if opening != None:
+            moves = opening.main_line()
+            for m in moves:
+                self.board.push(m)
+
+        while True:
+            over, game = self.game_over()
+            if over:
+                self.populate_headers(game)
+                return game
+            if self.board.turn: #white
+                self.white.engine.position(self.board)
+                best, ponder = self.white.engine.go(movetime=movetime)
+                self.board.push(best)
+            else:
+                self.black.engine.position(self.board)
+                best, ponder = self.black.engine.go(movetime=movetime)
+                self.board.push(best)
+            print(best)
+
+def doctor_game(game, side, piece_count):
+    moves = game.main_line()
+    board = chess.Board()
+    for m in moves:
+        board.push(m)
+        if len(board.piece_map()) <= piece_count and board.turn == side:
+            break
+    if board.is_game_over(claim_draw=True):
+        return None
+    if len(board.piece_map()) > piece_count or board.turn != side:
+        return None
+    opening = chess.pgn.Game.from_board(board)
+    return opening
+
+def getMatchGame(color, us=None, them=None):
+    if color: # white
+        match_game = MatchGame(white=us, black=them, egtb_path=config['DEFAULT']['EGTB Path'])
+    else:
+        match_game = MatchGame(white=them, black=us, egtb_path=config['DEFAULT']['EGTB Path'])
+    return match_game
+
+with open(config['DEFAULT']['Output'], 'a+') as pgn, open(config['DEFAULT']['Openings'], 'r') as openings:
+    movetime = int(config['DEFAULT']['Movetime'])
+    count = int(config['DEFAULT']['Games'])
+    if config['DEFAULT']['Color'] == 'White':
+        color = chess.WHITE
+    else:
+        color = chess.BLACK
+
+    book = Openings(openings)
+    print(book.opening_count())
+    enemy_name = config['DEFAULT']['Enemy']
+    enemy_cmd = config['DEFAULT']['Enemy Command']
+    enemy_options = config['Enemy Options']
+    enemy = Engine(name=enemy_name, cmd=enemy_cmd, options=enemy_options)
+    print(enemy.engine.name)
+
+    leela_name = config['DEFAULT']['Leela']
+    leela_cmd = config['DEFAULT']['Leela Command']
+    leela_options = config['Leela Options']
+    leela = Engine(name=leela_name, cmd=leela_cmd, options=leela_options)
+    print(leela.engine.name)
+
+    ender_name = config['DEFAULT']['Ender']
+    ender_cmd = config['DEFAULT']['Ender Command']
+    ender_options = config['Ender Options']
+    ender = Engine(name=ender_name, cmd=ender_cmd, options=ender_options)
+    print(ender.engine.name)
+
+    for i in range(count):
+        sys.stdout.flush()
+
+        print("\n")
+        print("Leela")
+
+
+
+        match_game = getMatchGame(color, us=leela, them=enemy)
+
+        op = book.get_opening()
+        game = match_game.play(movetime=movetime, opening=op)
+        game.headers['LeelaRatio'] = config['DEFAULT']['Leela Ratio']
+        game.headers['TimeControl'] = "move/{}s".format(movetime/1000)
+
+
+        next_opening = doctor_game(game, color, ENDER_PIECE_COUNT)
+
+        if next_opening == None:
+            # one more time
+            match_game = getMatchGame(color, us=leela, them=enemy)
+
+            game = match_game.play(movetime=movetime, opening=op)
+            game.headers['LeelaRatio'] = config['DEFAULT']['Leela Ratio']
+            game.headers['TimeControl'] = "move/{}s".format(movetime/1000)
+
+            next_opening = doctor_game(game, color, ENDER_PIECE_COUNT)
+
+        print("")
+
+        if next_opening == None:
+            print("Unsuitable game.\n")
+            print(game)
+        else:
+            time.sleep(60)
+
+            print("\n")
+            print("Ender")
+
+            match_game2 = getMatchGame(color, us=ender, them=enemy)
+
+            game2 = match_game2.play(movetime=movetime, opening=next_opening)
+            game2.headers['LeelaRatio'] = config['DEFAULT']['Leela Ratio']
+            game2.headers['TimeControl'] = "move/{}s".format(movetime/1000)
+
+            pgn.write("{}\n".format(game))
+            pgn.write("\n")
+            pgn.write("{}\n".format(game2))
+            pgn.write("\n")
+            pgn.flush()
+
+            print(game.headers['Result'])
+            print(game2.headers['Result'])
+
+    enemy.engine.quit()
+    leela.engine.quit()
+    ender.engine.quit()
+
+    pgn.flush()
+    pgn.close()
+
+
+
+