#!/usr/bin/python

# -*- coding: utf-8 -*-

#

# This file is part of the python-chess library.

# Copyright (C) 2012-2014 Niklas Fiekas <niklas.fiekas@tu-clausthal.de>

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program. If not, see <http://www.gnu.org/licenses/>.

import sys

import random

import chess

import chess.polyglot

def print_bitboard(bitboard):

PIECE_CHARS = [

[ " ", u"\u2659", u"\u2658", u"\u2657", u"\u2656", u"\u2655", u"\u2654" ],

[ " ", u"\u265F", u"\u265e", u"\u265d", u"\u265c", u"\u265b", u"\u265a" ]

]

SEQ_DARK_SQUARE = "\033[0;30;46m"

SEQ_LIGHT_SQUARE = "\033[0;30m"

SEQ_END = "\033[0m"

for square in chess.SQUARES_180:

if chess.BB_SQUARES[square] & chess.BB_FILE_A:

for border in range(square, square + 8):

if chess.BB_SQUARES[border] & chess.BB_DARK_SQUARES:

sys.stdout.write(SEQ_DARK_SQUARE)

else:

sys.stdout.write(SEQ_LIGHT_SQUARE)

sys.stdout.write(" ")

sys.stdout.write(SEQ_END)

sys.stdout.write("\n")

if chess.BB_SQUARES[square] & chess.BB_DARK_SQUARES:

sys.stdout.write("\033[0;30;46m")

else:

sys.stdout.write("\033[0;30m")

piece = bitboard.piece_at(square)

if piece:

sys.stdout.write(" ")

sys.stdout.write(PIECE_CHARS[piece.color][piece.piece_type])

sys.stdout.write(" ")

else:

sys.stdout.write(" ")

sys.stdout.write("\033[0m")

if chess.BB_SQUARES[square] & chess.BB_FILE_H:

sys.stdout.write("\n")

sys.stdout.flush()

def minimax_value(bitboard, depth, eval_fn):

if bitboard.half_moves >= 50:

return 0

if depth == 0:

if bitboard.is_stalemate():

return 0

elif bitboard.is_checkmate():

return -1000

return (1 - bitboard.turn * 2) * eval_fn(bitboard)

best = None

for move in bitboard.generate_pseudo_legal_moves():

bitboard.push(move)

if not bitboard.was_into_check():

value = -1 * minimax_value(bitboard, depth - 1, eval_fn)

if best is None or value > best:

best = value

bitboard.pop()

if best is None:

if not bitboard.is_check():

return 0

else:

return -1000

else:

return best

def minimax(bitboard, depth, eval_fn):

best = None

for move in bitboard.generate_pseudo_legal_moves():

bitboard.push(move)

if not bitboard.was_into_check():

value = -1 * minimax_value(bitboard, depth, eval_fn)

if best is None or value > best[0]:

best = (value, move)

bitboard.pop()

return best

def alphabeta_value(bitboard, depth, alpha, beta, eval_fn):

if bitboard.half_moves >= 50:

return 0

if depth == 0:

if bitboard.is_stalemate():

return 0

elif bitboard.is_checkmate():

return -1000

return (1 - bitboard.turn * 2) * eval_fn(bitboard)

found_legal_move = False

for move in bitboard.generate_pseudo_legal_moves():

bitboard.push(move)

if not bitboard.was_into_check():

found_legal_move = True

opp_alpha = None if beta is None else -1 * beta

opp_beta = None if alpha is None else -1 * alpha

value = -1 * alphabeta_value(bitboard, depth - 1, opp_alpha, opp_beta, eval_fn)

if alpha is None or value > alpha:

alpha = value

if (alpha is not None) and (beta is not None) and alpha >= beta:

bitboard.pop()

return beta

bitboard.pop()

if not found_legal_move:

if not bitboard.is_check():

return 0

else:

return -1000

else:

return alpha

def alphabeta(bitboard, depth, eval_fn):

best = None

for move in bitboard.generate_pseudo_legal_moves():

bitboard.push(move)

if not bitboard.was_into_check():

opp_beta = None if best is None else -1 * best[0]

value = -1 * alphabeta_value(bitboard, depth, None, opp_beta, eval_fn)

if best is None or value > best[0]:

best = value, move

bitboard.pop()

return best

def material_evaluator(bitboard):

value = 0.0

value += chess.pop_count(bitboard.pawns & bitboard.occupied_co[chess.WHITE])

value -= chess.pop_count(bitboard.pawns & bitboard.occupied_co[chess.BLACK])

value += 3.0 * chess.sparse_pop_count(bitboard.knights & bitboard.occupied_co[chess.WHITE])

value -= 3.0 * chess.sparse_pop_count(bitboard.knights & bitboard.occupied_co[chess.BLACK])

value += 3.1 * chess.sparse_pop_count(bitboard.bishops & bitboard.occupied_co[chess.WHITE])

value -= 3.1 * chess.sparse_pop_count(bitboard.bishops & bitboard.occupied_co[chess.BLACK])

value += 5.0 * chess.sparse_pop_count(bitboard.rooks & bitboard.occupied_co[chess.WHITE])

value -= 5.0 * chess.sparse_pop_count(bitboard.rooks & bitboard.occupied_co[chess.BLACK])

value += 9.0 * chess.sparse_pop_count(bitboard.queens & bitboard.occupied_co[chess.WHITE])

value -= 9.0 * chess.sparse_pop_count(bitboard.queens & bitboard.occupied_co[chess.BLACK])

return value

def mobility_evaluator(bitboard):

value = 0.0

turn = bitboard.turn

bitboard.turn = chess.WHITE

value += 0.02 * bitboard.pseudo_legal_move_count()

bitboard.turn = chess.BLACK

value -= 0.02 * bitboard.pseudo_legal_move_count()

bitboard.turn = turn

return value

if __name__ == "__main__":

sys.stdout.write("python-chess {0} by {1} <{2}>\n".format(chess.__version__, chess.__author__, chess.__email__))

log = open("log.txt", "a")

book = None

try:

book = chess.polyglot.open_reader("data/opening-books/performance.bin")

except IOError:

pass

position = chess.Bitboard()

while True:

line = sys.stdin.readline()

log.write(line)

log.flush()

line = line.strip()

if not line:

continue

if line == "uci":

# Initialize.

sys.stdout.write("id name python-chess {0}\n".format(chess.__version__))

sys.stdout.write("id author {0}\n".format(chess.__author__))

sys.stdout.write("uciok\n")

sys.stdout.flush()

elif line == "isready":

# Always ready.

sys.stdout.write("readyok\n")

sys.stdout.flush()

elif line == "ucinewgame":

# No special setup for a new game.

continue

elif line == "quit":

# Quit.

sys.exit(0)

elif line == "print":

print_bitboard(position)

print(position)

else:

parts = line.split()

command = parts.pop(0)

if command == "position":

# Setup a position.

while parts:

part = parts.pop(0)

if part == "startpos":

position.reset()

elif part == "moves":

while parts:

position.push(chess.Move.from_uci(parts.pop(0)))

break

elif len(parts) >= 6:

position.set_fen(" ".join([part, parts.pop(0), parts.pop(0), parts.pop(0), parts.pop(0), parts.pop(0)]))

else:

position.reset()

elif command == "go":

# Do not ponder.

if "ponder" in parts:

continue

best_move = None

# Consider the opening book.

if book:

choices = [ (entry.weight, entry.move()) for entry in book.get_entries_for_position(position) ]

total = sum(weight for weight, move in choices)

rand = random.randint(0, total)

upto = 0

for weight, move in choices:

if upto + weight > rand or True:

best_move = move

break

upto += weight

if not best_move:

book = None

# Search.

if not best_move:

best = alphabeta(position, 2, lambda b: material_evaluator(b) + mobility_evaluator(b) + random.uniform(-0.1, 0.1))

if best:

value, best_move = best

# Output.

if best_move:

sys.stdout.write("bestmove {0}\n".format(best_move.uci()))

sys.stdout.flush()

else:

# Unknown command.

sys.stderr.write("Unknown command: {0}\n".format(line))

sys.stderr.flush()