def stockFish_init(request):
stockfish = Stockfish(parameters={
"Threads": 2,
"Minimum Thinking Time": 30
})
stockfish.set_position(["e2e4", "e7e6"])
#posición de Forsyth–Edwards Notation (FEN)
stockfish.set_fen_position(
"rnbqkbnr/pppp1ppp/4p3/8/4P3/8/PPPP1PPP/RNBQKBNR w KQkq - 0 2")
#coge el mejor movimiento
stockfish.get_best_move(
) #stockfish.get_best_move_time(1000) en base al tiempo
#nivel del motor
stockfish.set_skill_level(15)
#parámetros por defecto
stockfish.get_parameters()
#coge la posición FEN
stockfish.get_fen_position()
#coge el tablero por defecto del usuario
stockfish.get_board_visual()
#evalua jugada
stockfish.get_evaluation()
p = subprocess.Popen('stockfish-x64.exe',
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
p.stdin.write("position startpos moves e2e4 e7e5\n")
p.stdin.write("go infinite\n")
p.stdin.flush()
time.sleep(1)
print(p.communicate())
class TestStockfish(unittest.TestCase):
def setUp(self):
self.stockfish = Stockfish()
def test_get_best_move(self):
best_move = self.stockfish.get_best_move()
self.assertIn(best_move, (
'e2e4',
'g1f3',
))
self.stockfish.set_position(['e2e4', 'e7e6'])
best_move = self.stockfish.get_best_move()
self.assertIn(best_move, (
'd2d4',
'g1f3',
))
# mate
self.stockfish.set_position(['f2f3', 'e7e5', 'g2g4', 'd8h4'])
self.assertFalse(self.stockfish.get_best_move())
def test_is_move_correct(self):
self.assertFalse(self.stockfish.is_move_correct('e2e1'))
self.assertTrue(self.stockfish.is_move_correct('a2a3'))
self.stockfish.set_position(['e2e4', 'e7e6'])
self.assertFalse(self.stockfish.is_move_correct('e2e1'))
self.assertTrue(self.stockfish.is_move_correct('a2a3'))
class TestStockfish(unittest.TestCase):
def setUp(self):
self.stockfish = Stockfish()
def test_get_best_move(self):
best_move = self.stockfish.get_best_move()
self.assertIn(best_move, (
'e2e4',
'g1f3',
'b1c3',
))
self.stockfish.set_position(['e2e4', 'e7e6'])
best_move = self.stockfish.get_best_move()
self.assertIn(best_move, (
'd2d4',
'g1f3',
))
# mate
self.stockfish.set_position(['f2f3', 'e7e5', 'g2g4', 'd8h4'])
self.assertFalse(self.stockfish.get_best_move())
def test_set_fen_position(self):
self.stockfish.set_fen_position(
"7r/1pr1kppb/2n1p2p/2NpP2P/5PP1/1P6/P6K/R1R2B2 w - - 1 27")
self.assertTrue(self.stockfish.is_move_correct('f4f5'))
self.assertFalse(self.stockfish.is_move_correct('a1c1'))
def test_is_move_correct(self):
self.assertFalse(self.stockfish.is_move_correct('e2e1'))
self.assertTrue(self.stockfish.is_move_correct('a2a3'))
self.stockfish.set_position(['e2e4', 'e7e6'])
self.assertFalse(self.stockfish.is_move_correct('e2e1'))
self.assertTrue(self.stockfish.is_move_correct('a2a3'))
class Computer:
def __init__(self, skill_level):
self.engine = Stockfish("./stockfish12/bin/stockfish")
self.engine.set_skill_level(skill_level)
self.move_history = []
def get_move(self, player_move):
self.move_history.append(player_move)
self.engine.set_position(self.move_history)
auto_move = self.engine.get_best_move()
self.move_history.append(auto_move)
return auto_move
def get_suggestion(self):
self.engine.set_position(self.move_history)
auto_move = self.engine.get_best_move()
return auto_move
def print_board(self):
self.engine.set_position(self.move_history)
print(self.engine.get_board_visual())
# input -- board state (changes based on the user's move)
# output -- stockfish move
def main():
#Deteremine start
random.seed(datetime.now())
white = random.randint(0, 1)
#initialize board and stockfish
board = chess.Board()
fishy = Stockfish(
'/Users/vishalaiely/Downloads/stockfish-11-mac/Mac/stockfish-11-64')
if white:
#playsound.playsound('audio/WhiteStart.mp3')
speak('Hello, you have the white pieces')
else:
#playsound.playsound('audio/BlackStart.mp3')
speak('Hello, you have the black pieces')
#Game executes and breaks when over
while not board.is_game_over():
if white:
board.push_uci(playermove(board))
fishy.set_fen_position(board.fen())
compMove = fishy.get_best_move()
board.push_uci(compMove)
speak(compMove)
else:
fishy.set_fen_position(board.fen())
compMove = fishy.get_best_move()
board.push_uci(compMove)
speak(compMove)
board.push_uci(playermove(board))
#Determines end state of game
if board.result() is '1-0':
#playsound.playsound('audio/WhiteWin.mp3')
speak('White wins')
elif board.reset() is '0-1':
#playsound.playsound('audio/BlackWin.mp3')
speak('Black wins')
elif board.is_stalemate():
speak('Stalemate')
else:
speak('Draw')
speak('Thank you for playing!')
class RandomFish():
def __init__(self):
self.stockfish = Stockfish()
self.board = chess.Board()
def get_config(self):
return 'rand0mfish.yml'
def get_name(self):
return 'rand0mfish'
def new_game(self):
self.board.reset()
def set_position(self, moves):
self.board.reset()
for m in moves:
self.board.push(chess.Move.from_uci(m))
def get_move(self):
# random move
if bool(getrandbits(1)): return choice(list(self.board.legal_moves))
# stockfish move
self.stockfish.set_fen_position(self.board.fen())
return self.stockfish.get_best_move()
class Bot():
def __init__(self):
self.stockfish = Stockfish()
def acceptable_challenge(self, chall):
if chall["variant"]["key"] != "standard":
return False
if chall["timeControl"]["limit"] > 60:
return False
if chall["timeControl"]["increment"] > 0:
return False
return True
def get_move(self, moves):
b = chess.Board()
if moves[0] == '': moves = []
for m in moves:
b.push(chess.Move.from_uci(m))
if len(list(b.legal_moves)) < 1: return None
# random move
if bool(getrandbits(1)): return choice(list(b.legal_moves))
# stockfish move
self.stockfish.set_position(moves)
return self.stockfish.get_best_move()
def test_get_best_move_wrong_position(self):
wrong_fen = "3kk3/8/8/8/8/8/8/3KK3 w - - 0 0"
s = Stockfish()
s.set_fen_position(wrong_fen)
assert s.get_best_move() in (
"d1e2",
"d1c1",
)
def bot_move(self):
stfish = Stockfish('stockfish')
stfish.set_fen_position(self.fen())
if self.board.turn:
stfish.depth = self.white_bot_power
else:
stfish.depth = self.black_bot_power
move = stfish.get_best_move()
return self.make_move(move)
def get_best_move(board):
stockfish = Stockfish()
move_list = []
for move in board.moves:
move_list.append(move.to_long_algebraic())
stockfish.set_position(move_list)
return long_algebraic_to_coordinate(stockfish.get_best_move())
def play(self):
dirname = os.path.dirname(__file__)
filename = os.path.join(dirname, 'stockfish-9-win\Windows\stockfish_9_x64')
stockfish = Stockfish(filename)
stockfish.set_skill_level(15)
if not self.chessboard.is_game_over() and not self.chessboard.is_stalemate():
board = self.chessboard.fen()
stockfish.set_fen_position(board)
ai_move = stockfish.get_best_move()
move = chess.Move.from_uci(ai_move)
print(move)
self.chessboard.push(move)
self.update()
def gen_examples(randomness: float = 0.7,
randomness_decline: float = 0.95,
max_moves: int = 80,
table: str = c.DEFAULT_TABLE) -> None:
"""
Generates training examples using Stockfish and stores them in a database in algebraic notation. Set up a MySQL
database first and set the connection in constants.py. Also make sure that Stockfish is installed correctly.
:param table: Table the data is stored in.
:param randomness: Starting Probability for proceeding with are random move instead of the best move. This is
necessary to not simulate the same game each time.
:param randomness_decline: Factor applied to the randomness with each move. Should be less than 1 to have less
randomness later in the game.
:param max_moves: Stops the simulated game early to prevent too long end games.
"""
game = Game()
stockfish = Stockfish(c.STOCKFISH_PATH)
examples = []
moves = []
for _ in range(max_moves):
stockfish.set_position(moves)
best_move = stockfish.get_best_move()
value = _value(stockfish.get_evaluation())
if best_move:
examples.append((_truncate_fen(stockfish.get_fen_position()),
(best_move[:4], value)))
if best_move and random.random() > randomness:
move_alg = best_move
move_tuple = _from_algebraic(move_alg)
else:
move_tuple = random.sample(game.game_legal_moves(), 1)[0]
move_alg = _to_algebraic(move_tuple)
if len(move_alg) == 5:
print('pawn promotion')
try:
game.make_move(move_tuple[0], move_tuple[1])
moves.append(move_alg)
except ValueError:
moves[-1] = moves[-1] + 'q'
print(examples)
randomness *= randomness_decline
if game.game_winner():
break
db = Connector()
db.insert_examples(examples, table)
class TestStockfish(unittest.TestCase):
def setUp(self):
self.stockfish = Stockfish()
def test_get_best_move(self):
best_move = self.stockfish.get_best_move()
self.assertIn(best_move, ('e2e4', 'g1f3',))
self.stockfish.set_position(['e2e4', 'e7e6'])
best_move = self.stockfish.get_best_move()
self.assertIn(best_move, ('d2d4', 'g1f3',))
# mate
self.stockfish.set_position(['f2f3', 'e7e5', 'g2g4', 'd8h4'])
self.assertFalse(self.stockfish.get_best_move())
def test_is_move_correct(self):
self.assertFalse(self.stockfish.is_move_correct('e2e1'))
self.assertTrue(self.stockfish.is_move_correct('a2a3'))
self.stockfish.set_position(['e2e4', 'e7e6'])
self.assertFalse(self.stockfish.is_move_correct('e2e1'))
self.assertTrue(self.stockfish.is_move_correct('a2a3'))
def insertFEN(self, fen):
"""Is inserting FEN into sqlite
:param fen: chess position in Forsyth-Edwards-Notation (FEN), e.g. r4rnk/1pp4p/3p4/3P1b2/1PPbpBPq/8/2QNB1KP/1R3R2 w KQkq - 0 25
"""
self.cursor.execute("select count(*) from FEN where fen = ?;", [fen])
data = self.cursor.fetchone()[0]
if data == 0:
stockfish = Stockfish('/usr/games/stockfish')
stockfish.set_fen_position(fen)
bestmove = stockfish.get_best_move()
try:
self.cursor.execute("insert into FEN(fen, bestmove) values(?,?);",
(str([fen]), bestmove))
except sqlite3.IntegrityError:
pass
class ChessGame:
def __init__(self, fen):
""" constructor taking initial FEN position"""
self.d_engine = Stockfish()
self.setFen(fen)
def setFen(self, fen):
""" set board in fen notation """
self.d_engine.set_fen(fen)
def move(self, algMove):
""" move in long algebraic notation, send to stockfish """
if self.d_engine.is_move_correct(algMove):
print("correct")
def bestMove(self):
return self.d_engine.get_best_move()
class ChessGame:
def __init__(self, fen):
""" constructor taking initial FEN position"""
self.d_engine = Stockfish()
self.setFen(fen)
def setFen(self, fen):
""" set board in fen notation """
self.d_engine.set_fen(fen)
def move(self, algMove):
""" move in long algebraic notation, send to stockfish """
if self.d_engine.is_move_correct(algMove):
print("correct")
def bestMove(self):
return self.d_engine.get_best_move()
class Brain:
def __init__(self):
self.sf = Stockfish()
self.ucim = []
self.tablero = chess.Board()
print(self.tablero)
def legal(self, mv):
mov = self.to_move(mv)
return (mov in self.tablero.legal_moves)
def mover_uci(self, mv):
self.ucim.append(mv)
self.sf.set_position(self.ucim)
self.tablero.push_uci(mv)
print(self.tablero)
def auto(self):
mv = self.sf.get_best_move()
print(mv)
return (mv)
def to_move(self, mv):
return chess.Move.from_uci(mv)
def is_over(self):
return self.tablero.is_game_over()
def capturo(self, mv):
if self.tablero.is_capture(mv):
if self.tablero.is_en_passant(mv):
return (True, True)
else:
return (True, False)
else:
return (False, False)
return
def enroque(self, mv):
if self.tablero.is_kingside_castling(mv):
return (True, True)
elif self.tablero.is_queenside_castling(mv):
return (True, False)
else:
return (False, False)
class Player:
def __init__(self, controller="random", customFunction=None):
# "random", "gp", "alphazero", "*anyother we're planning to implement"
self.controller = controller
self.customFunction = customFunction
# add any other variables as needed
self.stockfish = Stockfish(
'./stockfish-10-win/Windows/stockfish_10_x64.exe')
def choose_move(self, board, moves):
if self.controller == "random":
chosenMoveIndex = random.randint(0, len(moves) - 1)
chosenMove = moves[chosenMoveIndex]
return chosenMove
elif self.controller == "custom":
return self.customFunction(board, moves)
elif self.controller == "stockfish":
self.stockfish.set_fen_position(board.fen())
uciStr = self.stockfish.get_best_move()
move = chess.Move.from_uci(uciStr)
return move
elif self.controller == "player":
while True:
print(board)
move = input(
"Input a move, or input m for a list of possible moves: ")
if move == 'm':
for move in moves:
print(move)
continue
try:
move = chess.Move.from_uci(move)
if move in moves:
return move
else:
print("Invalid move")
except:
print("Invalid move")
continue
else:
# implement controller's movement choice
pass
class StockfishPlayer:
def __init__(self, stockfishpath):
conf = {
"Write Debug Log": "false",
"Contempt": 0,
"Min Split Depth": 0,
"Threads": 1,
"Ponder": "false",
"Hash": 16,
"MultiPV": 1,
"Skill Level": 20,
"Move Overhead": 30,
"Minimum Thinking Time": 20,
"Slow Mover": 80,
"UCI_Chess960": "false",
}
self.stockfish = Stockfish(stockfishpath, parameters=conf)
def get_best_move(self, fen):
self.stockfish.set_fen_position(fen)
return self.stockfish.get_best_move()
def calculate_suggestions(self, gui):
for _ in range(5):
stockfish = Stockfish("./src/cpu/stockfish_20090216_x64", 3)
new_chess_match = copy.deepcopy(self.__chess_match)
stockfish.set_fen_position(new_chess_match.get_fen_notation())
new_chess_match.match_moves.limpa_pilha()
rounds = 0
while rounds < 18 and (not new_chess_match.checkmate and not new_chess_match.draw):
if self.__stop_thread:
return
moviment = stockfish.get_best_move()
new_chess_match.perform_chess_move(
ChessPosition(moviment[0], int(moviment[1])),
ChessPosition(moviment[2], int(moviment[3]))
)
stockfish.set_fen_position(new_chess_match.get_fen_notation())
rounds += 1
self.__moviment_tree.add(self.get_eval(stockfish, new_chess_match), new_chess_match.match_moves)
if self.__stop_thread:
return
moviments = self.__moviment_tree.max3() if new_chess_match.current_player == 'WHITE' else self.__moviment_tree.min3()
gui.show_suggestions(moviments)
class Engine(object):
def __init__(self):
super().__init__()
self.engine = None
self.max_time = 1000 # Milliseconds
self.list_moves = []
def set_engine(self, engine_name="stockfish", skill_level=10):
if engine_name == "stockfish":
# stockfish_dir = os.path.join(Resource.get_engine_dir(), "stockfish_20090216_x64.exe")
stockfish_dir = os.path.join("E:\\Jeee\\Documents\\Projects\\Python\\Chess\\engines", "stockfish_20090216_x64.exe")
self.engine = Stockfish(stockfish_dir)
self.set_engine_skill_level(skill_level)
def set_engine_skill_level(self, level):
self.engine.set_skill_level(level)
def get_best_move(self):
move = self.engine.get_best_move()
return move
def move(self, move):
self.list_moves.append(move)
self.engine.set_position(self.list_moves)
# self.print_board_visual()
Logger.record_move(move)
def print_board_visual(self):
print(self.engine.get_board_visual())
def close_engine(self):
self.engine.__del__
class Game:
def __init__(self):
self.engine = Stockfish()
self.board = Board()
def sync_engine(self):
self.engine.set_position(self.board.move_list)
def get_best_move(self) -> str:
return self.engine.get_best_move()
def is_move_correct(self, move: str) -> bool:
return self.engine.is_move_correct(move)
def make_move(self, move) -> bool:
if self.is_move_correct(move):
self.board.make_move(move)
self.sync_engine()
return True
else:
return False
def make_best_move(self):
self.make_move(self.get_best_move())
from bs4 import BeautifulSoup
from types import SimpleNamespace
import requests, json
from stockfish import Stockfish
#Ejemplo de lo que pueden hacer los tramposos XD
stockfish = Stockfish('stockfish',
parameters={
"Threads": 4,
"Minimum Thinking Time": 30
})
stockfish.set_depth(15)
while True:
r = requests.get("https://lichess.org/KuXPWqE0bK55")
soup = BeautifulSoup(r.content, 'html.parser')
scripts = soup.select('script')
game = scripts[-1]
game = game.contents[0][41:-3]
x = json.loads(game, object_hook=lambda d: SimpleNamespace(**d))
stockfish.set_fen_position(x.data.game.fen)
print("Best move: " + stockfish.get_best_move(), end='')
next_move = input()
from stockfish import Stockfish
def debug(msg):
print(msg, file=sys.stderr)
def parser_args():
parser = argparse.ArgumentParser()
parser.add_argument('-l',
'--level',
help='Show board',
type=int,
action='store',
default=1)
args = parser.parse_args()
return args
debug("Stockfish bot starting!\n")
args = parser_args()
s = Stockfish('./bin/stockfish')
s.set_skill_level(args.level)
while True:
fen = input()
debug(fen)
s.set_fen_position(fen)
print(s.get_best_move())
""" Before running do
pip install stockfish
to get the stockfish python interface """
from stockfish import Stockfish
stockfish = Stockfish()
stockfish.set_position(['e2e4', 'e7e6'])
stockfish.depth = 20
print(stockfish.get_best_move())
print(stockfish.is_move_correct('a2a3'))
class Player(abc.ABC):
"""
An abstract class for player.
"""
QUIT_MOVE = 'a1a1'
def __init__(self, first: bool, host: str, port: int,
skill_level: Optional[int], depth: Optional[int],
stockfish: Optional[str]):
"""
Initialize a player.
Args:
first: Is the player going first.
host: The host of the game.
port: The port in the host of the game.
skill_level: Still level for stockfish.
depth: Depth to search for best move for stockfish.
stockfish: Path to the stockfish executable to use.
"""
self.player_turn = first
self.host = host
self.port = port
self.skill_level = skill_level
self.depth = depth
self.moves = []
self.socket = None
self.stockfish = Stockfish(stockfish or "./stockfish")
if self.skill_level is not None:
self.stockfish.set_skill_level(self.skill_level)
if self.depth is not None:
self.stockfish.set_depth(self.depth)
def get_turns(self) -> List[str]:
"""
Get previous turns to the game from the other player, gets the board to the desired initial state.
Returns:
The pre turns set by the other player.
"""
moves_num = struct.unpack('H', self.socket.recv(2))[0]
moves = []
for _ in range(moves_num):
moves.append(self.socket.recv(5).decode('utf-8').rstrip('\0'))
return moves
def forward_turns(self, moves: Optional[List[str]] = None):
"""
Send previous turns to the game to the other player.
Args:
moves: The pre turns set by this player.
"""
if moves is None:
moves = []
self.socket.send(struct.pack('H', len(moves)))
for move in moves:
self.socket.send(move.ljust(5, '\0').encode('utf-8'))
def set_turns(self, moves: List[str]):
"""
Set the pre turns of the game.
Args:
moves: The pre turns of the game.
"""
self.moves = moves
self.player_turn ^= len(moves) % 2
def choose_move(self):
"""
Choose a move to perform.
Chooses the move using stockfish and sends it to the other player.
"""
self.stockfish.set_position(self.moves)
move = self.stockfish.get_best_move()
if not move:
raise RuntimeError('game over')
print('Move chosen:', move)
self.socket.send(move.ljust(5, '\0').encode('utf-8'))
self.moves.append(move)
def get_move(self):
"""
Get the move done by the other player.
"""
move = self.socket.recv(5).decode('utf-8').rstrip('\0')
if move == self.QUIT_MOVE:
raise RuntimeError('game over')
self.moves.append(move)
print('Move got:', move)
def turn(self):
"""
Perform a single turn, either get the move done by the other player, or do a move.
"""
if self.player_turn:
self.choose_move()
else:
self.get_move()
self.player_turn = not self.player_turn
def print_board(self):
"""
Print the current board's state.
"""
self.stockfish.set_position(self.moves)
print(self.stockfish.get_board_visual())
def __del__(self):
"""
Destruct a player.
Disconnects the socket.
"""
self.socket and self.socket.close()
def results():
stockfish = Stockfish(
'/Users/faizaanmadhani/Desktop/PCHACKS/chessapp/stockfish-10-mac/Mac/stockfish-10-64'
)
board = chess.Board()
legalMove = board.legal_moves
# build a request object
req = request.get_json(force=True)
oldPosition = req.get('queryResult').get('parameters').get('oldPosition')
newPosition = req.get('queryResult').get('parameters').get('newPosition')
checkmate = req.get('queryResult').get('queryText')
piece = req.get('queryResult').get('parameters').get('piece')
pieceStr = str(piece)
newPositionStr = str(newPosition)
if (pieceStr == 'knight' or 'night'):
pieceStr = 'N' + newPositionStr
elif (pieceStr == 'pawn' or 'Pawn'):
pieceStr = newPositionStr
else:
pieceStr = pieceStr.charAt(0).upper() + newPositionStr
# fetch action from json
action = req.get('queryResult').get('action')
if (os.stat("fenState.txt").st_size == 0):
#If file fenState is empty, Write initial state of board to fenState
writeFile = open("fenState.txt", "w")
strBoardFen = board.fen()
writeFile.write(str(strBoardFen))
writeFile.close()
#Then, read the state of the file
readFile = open("fenState.txt", "r")
boardState = readFile.read()
board = chess.Board(boardState)
else:
#Otherwise, Read initial state of board
readFile = open("fenState.txt", "r")
boardState = readFile.read()
board = chess.Board(boardState)
if (chess.Move.from_uci(str(oldPosition) + str(newPosition))
in board.legal_moves):
board.push_san(pieceStr)
#Get Fen position
fenPosition = board.fen()
#Engine makes their move
stockfish.set_fen_position(fenPosition)
bestmove = stockfish.get_best_move()
board.push_san(bestmove)
finalReturn = "I have moved " + bestmove
#Write State to file (Debugging)
writeFile = open("state.txt", "w")
strBoard = str(board)
writeFile.write(strBoard)
writeFile.close()
#Write FenState to file (State saving between moves)
writeFile = open("fenState.txt", "w")
boardFen = board.fen()
strBoardFen = boardFen
writeFile.write(strBoardFen)
writeFile.close()
if (str(checkmate) == 'checkmate' and board.is_checkmate() == True):
finalReturn = "Checkmate!, and game over"
elif (board.is_checkmate() == False and str(checkmate) == 'checkmate'):
finalReturn = "You Can't Checkmate bro"
else:
finalReturn = "This move is wrong"
writeFile = open("move.txt", "w+")
Position = str(oldPosition + newPosition)
writeFile.write(Position)
writeFile.close()
# return a fulfillment response
return {'fulfillmentText': finalReturn}
class Ai(Player):
def __init__(self, color: str, game):
"""
une classe pour l'ordinateur
Parameters
----------
color : str
la couleur des pièces
game: Game
le jeu
"""
super().__init__()
self.name = f"ai{color}"
self.color = color
self.check = False
self.game = game
# variables propres
self.engine = Stockfish(
path="stockfish/stockfish_13_win_x64_bmi2.exe",
parameters=self.game.settings["parameters"],
)
self.steps = self.game.settings["number_of_steps"]
self.depth = self.game.settings["depth"]
def en_avant_pawn(self, board) -> np.array:
"""
clone de la méthode de la classe Board\\
ne modifie pas les valeurs étant donné qu'on ne déplace pas de pièces dans le tableau courant\\
mais dans des tableaux provisoires
"""
for i in range(8): # ligne
for j in range(8): # colonne
piece = board[i, j]
if piece is not None:
if piece.pawn_forward >= 2:
piece.pawn_forward = 0
piece.pawn_forward += piece.pawn_forward
return board
def get_move(self) -> str:
move = self.game.board.last_move
indexes = ["a", "b", "c", "d", "e", "f", "g", "h"]
y1 = str(8 - move[0][0])
y2 = str(8 - move[1][0])
x1 = indexes[move[0][1]]
x2 = indexes[move[1][1]]
return x1 + y1 + x2 + y2
def get_pos(self, move: str) -> list({tuple({int})}):
indexes = ["a", "b", "c", "d", "e", "f", "g", "h"]
x1, y1, x2, y2 = move[:4]
x1 = indexes.index(x1)
x2 = indexes.index(x2)
y1 = 8 - int(y1)
y2 = 8 - int(y2)
return [(y1, x1), (y2, x2)]
def empty(self, board, color: str) -> set({tuple({int})}):
"""
clone de la méthode de la classe Board\\
ne modifie pas les valeurs étant donné qu'on ne déplace pas de pièces dans le tableau courant\\
mais dans des tableaux provisoires
"""
res = set()
for i in range(8): # ligne
for j in range(8): # colonne
piece = board[i, j]
if piece is None or piece.color != color:
res.add((i, j))
return res
def play(self):
"""
joue le coup de l'ia
"""
# affichage
textsurface = font.render(
"modélisation...", True,
self.game.data["ai_thinking_indicator_color"])
self.game.screen.blit(textsurface, (720, 25))
pygame.display.flip()
# si l'ia ne joue pas le premier coup de la partie
if self.game.board.last_move[0][0] >= 0:
moves = self.game.all_moves # on récupère les coups précédents
# !print("last moves :", moves)
self.engine.set_position(moves)
# meilleur coup
self.engine.set_depth(self.depth)
move = self.engine.get_best_move()
self.engine.set_depth(2)
# !print("best move :", move)
# nouvelle position pour le moteur
self.engine.set_position([move])
# !print()
getpos = self.get_pos(move)
from_index = getpos[0]
to_index = getpos[1]
# affichage
pygame.draw.rect(self.game.screen, self.game.data["background_color"],
(720, 25, 100, 20))
textsurface = font.render(
"réflexion...", True,
self.game.data["ai_thinking_indicator_color"])
self.game.screen.blit(textsurface, (720, 25))
pygame.display.flip()
# préparer les coups
board = self.game.board.board
for i in range(8):
for j in range(8):
piece = board[i, j]
if piece is not None:
piece.viable = piece.accessible(
board,
(i, j)).intersection(self.empty(board, piece.color))
piece.viable = piece.accessible_with_checked(
(i, j), piece.viable, board)
# jouer le coup
piece = self.game.board.board[from_index]
if len(move) == 5:
piece.promoted = move[4]
if to_index in piece.viable:
piece.move_to(self.game, self.game.board.board, from_index,
to_index)
else:
print("error : illegal move played by ai\nsearching new move...\n")
self.play_alt()
self.game.next_player() # joueur suivant
def play_alt(self):
"""
permet à l'ordinateur de jouer son tour
"""
self.tree = Node(
self.color,
None,
self.game.board.deep_copy(self.game.board.board),
((0, 0), (0, 0)),
)
steps = self.steps
start = time.time() # durée de la réflexion totale
# on construit l'arbre des coups
pygame.draw.rect(self.game.screen, self.game.data["background_color"],
(720, 25, 100, 20))
textsurface = font.render(
"modélisation...", True,
self.game.data["ai_thinking_indicator_color"])
self.game.screen.blit(textsurface, (720, 25))
pygame.display.flip()
self.build(self.tree, steps, self.color)
# on cherche le meilleur coup
pygame.draw.rect(self.game.screen, self.game.data["background_color"],
(720, 25, 100, 20))
textsurface = font.render(
"réflexion...", True,
self.game.data["ai_thinking_indicator_color"])
self.game.screen.blit(textsurface, (720, 25))
pygame.display.flip()
self.tree.get_values(self.game.board.get_score)
# on modifie le nombre d'étape au besoin
end = time.time()
if end - start <= 0.5 and not self.check:
if self.steps + 1 <= self.settings["max_number_of_steps"]:
self.steps += self.settings["number_of_steps_increase_allowed"]
move = ()
# on joue ce coup
for child in self.tree.list_of_leaves:
if child.value == self.tree.value:
move = child.move
break
from_index = move[0]
to_index = move[1]
self.game.board.board[from_index].move_to(self.game,
self.game.board.board,
from_index, to_index)
# on passe au joueur suivant
self.game.next_player()
def build(self, current_node: Node, remaining_steps: int, color: str):
if remaining_steps == 0:
current_node.value = self.game.board.get_score(current_node.board)
return
board = current_node.board.copy()
list_of_pieces = []
# création de la liste des pièces de la bonne couleur
for i in range(8):
for j in range(8):
piece = board[i, j]
if piece is not None and piece.color == color:
list_of_pieces.append((piece, (i, j)))
# pour chaque pièce
for piece, from_index in list_of_pieces:
piece.viable = piece.accessible(board, from_index).intersection(
self.empty(board, piece.color))
piece.viable = piece.accessible_with_checked(
from_index, piece.viable, board)
# pour chaque déplacement viable
for to_index in piece.viable:
new_board = board.copy()
new_board = self.en_avant_pawn(new_board)
piece.move_to(None, new_board, from_index, to_index)
if piece.name == "pion":
if to_index[0] == 0 or to_index[0] == 7:
new_board[to_index] = Dame(piece.color)
new_node = Node(
color,
current_node,
new_board,
(from_index, to_index),
)
color = ("b", "n")[color == "b"]
current_node.__append__(new_node)
self.build(new_node, remaining_steps - 1, color)
x = np.where(np.array(color) != np.array(color2))
print(np.array(color))
print(x)
if color2.iloc[x[0][0], x[1][0]] != 'e':
x = np.array([[x[0][1], x[0][0]], [x[1][1], x[1][0]]])
position, color = update1(position, color, x)
print(board)
print(color)
print(position)
move1 = chess.Move.from_uci(pos(x, index, columns))
board.push(move1)
sf.set_fen_position(board.fen())
zz = sf.get_best_move()
move2 = chess.Move.from_uci(zz)
board.push(move2)
initial = list(zz[1::-1])
final = list(zz[3::-1])
position, color = update2(position, color, initial, final)
print(board)
print(color)
print(position)
input("Make your first move, then press Enter")
# else:
# print("I'm making my first move")
# time.sleep(10)
# chester.move_piece("d2d4")
# input("Make your move, then press Enter")
winner = False #Need to check if there's a winner after each move and if so: break the loop
while (not winner):
fen, pieces = chester.calculate_fen_position(
) #This takes a picture and analyzes it, then generates the fen position of the board and returns it as a string
print(fen)
stockfish.set_fen_position(fen)
print(stockfish.get_board_visual())
time.sleep(1)
move = str(stockfish.get_best_move())
if (move == "None"):
print("No possible move or something")
exit()
for p in pieces:
if (move[2:4] == p["square"]):
chester.move_piece(move[2:4] + 't0')
print("Moving " + move)
chester.move_piece(move)
input("Make your move, then press Enter")
# pictures = [cv.imread("Q1.jpg"), cv.imread("Q2.jpg"), cv.imread("Q3.jpg") ,cv.imread("Q4.jpg")]
# print(chester.get_img_pieces(pictures))
chester.move_to_z(chester.grab_height)
ser.close()
import time
board = chess.Board()
shallowfish = Stockfish(depth=17)
deepfish = Stockfish(depth=17)
moves = []
while True:
if board.is_game_over():
break
#raw_input("Press enter to continue...")
moves.append(shallowfish.get_best_move())
shallowfish.set_position(moves)
deepfish.set_position(moves)
board.push(chess.Move.from_uci(moves[len(moves)-1]))
print "ai 1 made move:",moves[len(moves)-1]
print board
if board.is_game_over():
break
moves.append(deepfish.get_best_move())
shallowfish.set_position(moves)
deepfish.set_position(moves)
board.push(chess.Move.from_uci(moves[len(moves)-1]))
def play_back(fen):
sf = Stockfish()
sf.set_fen_position(fen)
next_move = sf.get_best_move()
del sf
return next_move
