def test_start_moves():
board = ChessBoard("rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")
assert board.possible_moves("a2") == ["a3", "a4"]
assert board.possible_moves("a7") == ["a6", "a5"]
assert board.possible_moves("a1") == []
assert board.possible_moves("b1") == ["a3", "c3"]
assert board.possible_moves("c1") == []
assert board.possible_moves("d1") == []
class ChessGame:
STATUS_WHITE_MOVE = "white_move"
STATUS_BLACK_MOVE = "black_move"
STATUS_WHITE_VICTORY = "white_victory"
STATUS_BLACK_VICTORY = "black_victory"
def __init__(self, renderer: InputRender = None):
self._finished = False
self._board = ChessBoard()
self._renderer = renderer
self._status = ChessGame.STATUS_WHITE_MOVE
def run(self):
self._renderer.render(self.get_game_state())
while not self._finished:
command = self._parse_command()
if command is None and self._renderer is not None:
self._renderer.print_line("Invalid command, please re-enter.")
continue
if not self._try_move(command):
self._renderer.print_line("Invalid command, please re-enter.")
continue
self._board.execute_move(command)
if self._status == ChessGame.STATUS_WHITE_MOVE:
self._status = ChessGame.STATUS_BLACK_MOVE
elif self._status == ChessGame.STATUS_BLACK_MOVE:
self._status = ChessGame.STATUS_WHITE_MOVE
self._renderer.render(self.get_game_state())
def _try_move(self, command: MoveCommand):
board_copy = deepcopy(self._board)
src_piece = board_copy.get_piece(command.src)
if src_piece is None:
return False
if (self._status == ChessGame.STATUS_WHITE_MOVE and src_piece.color == Piece.BLACK) or \
(self._status == ChessGame.STATUS_BLACK_MOVE and src_piece.color == Piece.WHITE):
return False
if command.dst not in src_piece.get_moveable_positions(board_copy) and \
command.dst not in src_piece.get_threatened_positions(board_copy):
return False
board_copy.execute_move(command)
for piece in board_copy.pieces:
if self._status == ChessGame.STATUS_WHITE_MOVE and \
board_copy.white_king_position in piece.get_threatened_positions(board_copy):
return False
elif self._status == ChessGame.STATUS_BLACK_MOVE and \
board_copy.black_king_position in piece.get_threatened_positions(board_copy):
return False
return True
def _parse_command(self):
input_ = input()
return MoveCommand.from_string(input_)
def get_game_state(self):
return ChessGameState(self._board.pieces, self._board.size)
def test_all_possible_moves():
board = ChessBoard("8/7R/6R1/8/8/4K3/7k/8 w - - 0 1")
assert board.all_moves("b") == {}
board = ChessBoard("8/7R/8/8/8/4K1R1/7k/8 w - - 0 1")
assert board.all_moves("b") == {"h2": ["g3"]}
board = ChessBoard("8/7R/8/3K4/8/1p4R1/2b4k/8 w - - 0 1")
assert board.all_moves("b") == {"c2": ["h7"], "h2": ["g3"]}
def __init__(
self,
ai_depth=3,
starting_pos="rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1",
):
"""
input: ai_depth is amount of moves to search into the future.
in the future, we can try to add different parameter constrains
# such as time limit, cpu compute speed.
"""
ChessBoard.__init__(self, starting_pos=starting_pos)
self.depth = ai_depth
def __init__(self):
pygame.init()
pygame.display.set_caption('Шахматы')
pygame.display.set_icon(pygame.image.load('images/icon.jpg'))
self.screen = pygame.display.set_mode((860, 565))
self.clock = pygame.time.Clock()
self.board = ChessBoard()
self.main_menu = pygame.image.load('images/main_menu.jpg')
self.main_menu = pygame.transform.scale(self.main_menu, (860, 565))
self.board_img = pygame.image.load('images/board.png')
self.win_background = pygame.Surface((860, 565))
self.poss_target = pygame.Surface(
(self.board.cell_size, self.board.cell_size))
self.target_image = pygame.Surface(
(self.board.cell_size, self.board.cell_size))
self.target_enemy_image = pygame.Surface(
(self.board.cell_size, self.board.cell_size))
self.move_history = pygame.Surface((270, 310))
self.win_background.set_alpha(150)
self.poss_target.set_alpha(125)
self.target_image.set_alpha(125)
self.target_enemy_image.set_alpha(125)
pygame.draw.rect(self.win_background, (255, 255, 255),
self.win_background.get_rect())
pygame.draw.rect(self.poss_target, (173, 255, 182),
self.poss_target.get_rect())
pygame.draw.rect(self.target_image, (173, 255, 255),
self.target_image.get_rect())
pygame.draw.rect(self.target_enemy_image, (255, 173, 173),
self.target_enemy_image.get_rect())
self.w_figures_captured_images = []
self.b_figures_captured_images = []
self.new_game = False
self.pause = True
self.winner = None
self.target = None
self.target_poss_moves = ()
self.all_poss_moves = self.get_all_poss_moves()
self.main_loop()
def launchSingleplayerGame(self):
# board client handles logic of chess board moves and attacks
self.boardClient = ChessBoard()
# view client handles drawing everything
self.viewClient = AppWindow(self.root, self.boardClient)
self.viewClient.pack()
self.bindGameEvents()
def min_max_search(board: ChessBoard, ai_num: int, control_bar, depth: int = 6):
"""
Min-max search to find the best place of setting chess
:param control_bar: class Bar from main.py
:param ai_num: The player number which ai is
:param board: chessboard
:param depth: depth of calculation NOTE: GREAT NUMBER OF DEPTH MAY SPEND A LONG TIME
:return: the coordinate of best position
"""
# If the board is empty
for x in board.board:
for y in x:
if y != 0:
break
else:
continue
break
else:
control_bar.exit()
return 7, 7
max_v = -99999999
points = points_gen(board, ai_num)
candidates = []
# Show progress bar
for point in points:
control_bar.step_in()
board.board[point[0]][point[1]] = ai_num
cur_v = search_point(
board, ai_num, 1 if ai_num == 2 else 2, depth, -9999999999, 9999999999
)
if cur_v == max_v:
candidates.append(point)
elif cur_v > max_v:
max_v = cur_v
candidates = [point]
board.board[point[0]][point[1]] = 0
result = sample(candidates, 1)[0]
control_bar.exit()
return result
def launchMultiplayerGame(self):
# connection handler makes chess playable in multiplayer
self.multiplayerClient = ConnectionHandler()
# board client handles logic of chess board moves and attacks
self.boardClient = ChessBoard()
# view client handles drawing everything
self.viewClient = AppWindow(self.root, self.boardClient)
self.viewClient.pack()
self.bindGameEvents()
def search_point(
board: ChessBoard, ai_num: int, player: int, depth: int, alpha: int, beta: int
):
"""
This function use alpha-beta pruning to calculate best-fit point
:param board: chessboard
:param ai_num: The player number which ai is
:param player: current player number
:param depth: maximum depth of calculation
:param alpha: max value when calculate
:param beta: min value when calculate
:return: the maximum score of the position
"""
# Computer - Human
split_board = list(board.split_board())
v = board.evaluate(ai_num, split_board) - board.evaluate(
1 if ai_num == 2 else 2, split_board
)
if depth <= 0 or board.win_determine() in [WHITE_WIN, BLACK_WIN, TIE]:
return v
points = points_gen(board, player)
if player == ai_num:
# Computer turn, max level
for point in points:
board.board[point[0]][point[1]] = player
cur_v = search_point(
board, ai_num, 1 if player == 2 else 2, depth - 1, alpha, beta
)
board.board[point[0]][point[1]] = 0
alpha = max(alpha, cur_v)
# Prune
if beta < alpha:
# print("Pruned {} nodes".format(len(points) - points.index(point) - 1))
break
return alpha
else:
# Human turn, min level
for point in points:
board.board[point[0]][point[1]] = player
cur_v = search_point(
board, ai_num, 1 if player == 2 else 2, depth - 1, alpha, beta
)
board.board[point[0]][point[1]] = 0
beta = min(beta, cur_v)
# Prune
if beta < alpha:
print("Pruned {} nodes".format(len(points) - points.index(point) - 1))
break
return beta
def __init__(self, w_figs, b_figs, board):
chess_board = ChessBoard()
ok = 1
passed = -1
if w_figs == [] and b_figs == [] and board == None:
w_figures, b_figures = self.generate_figures(chess_board)
else:
w_figures, b_figures, chess_board = w_figs, b_figs, board
chess_board.change_board(w_figures, b_figures)
alive_figures = []
for x in w_figures:
alive_figures.append([x.curr_pos_ltr, x.curr_pos_num, x.player])
for x in b_figures:
alive_figures.append([x.curr_pos_ltr, x.curr_pos_num, x.player])
w_player = Player("white", w_figures)
b_player = Player("black", b_figures)
self.chess_board = chess_board
self.w_player = w_player
self.b_player = b_player
self.command_counter = None
self.is_moved = None
self.curr_player = None
self.opponent = None
self.alive_figures = alive_figures
self.ok = ok
self.passed = passed
self.w_check = 0
self.b_check = 0
self.w_checkmate = 0
self.b_checkmate = 0
self.draw = 0
self.ended = 0
def game_setup():
chess_board = ChessBoard()
chess_board.create_board()
# print(chess_board.get_board())
move = PawnMovementLogic(chess_board.get_board(), 1, 2, 3, 2,
ChessBoard.PLAYER_ONE_INDICATOR, True)
move.move_pawn()
move = PawnMovementLogic(chess_board.get_board(), 6, 3, 5, 3,
ChessBoard.PLAYER_TWO_INDICATOR, True)
move.move_pawn()
move = PawnMovementLogic(chess_board.get_board(), 3, 2, 4, 2,
ChessBoard.PLAYER_ONE_INDICATOR, False)
move.move_pawn()
print("here_1")
move = PawnMovementLogic(chess_board.get_board(), 5, 3, 4, 2,
ChessBoard.PLAYER_TWO_INDICATOR, False)
move.capture_piece()
def __init__(self):
self.root = Tk()
#board client handles logic of chess board moves and attacks
self.boardClient = ChessBoard()
#view client handles drawing everything
self.viewClient = AppWindow(self.root, self.boardClient)
self.viewClient.pack()
# connection handler makes chess playable in multiplayer
self.multiplayerClient = ConnectionHandler()
#event handler handles event performed on windows
self.eventsClient = EventHandler(self.boardClient, self.viewClient,
self.multiplayerClient)
self.root.mainloop()
def run_game():
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
settings = Settings()
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("Chess")
board = ChessBoard(settings, screen)
board.set_initial_board()
while True:
gf.check_events(board)
gf.update_board(board)
screen.fill(settings.bg_color)
board.draw()
pygame.display.flip()
def __init__(self, exe_path, turn_limit_s, thread):
"""
BRIEF Set up the UI
"""
super().__init__()
self.board = ChessBoard(self)
if os.path.isfile(exe_path):
self.player_b = AiPlayer(exe_path, turn_limit_s, Player.BLACK,
thread, self.board)
self.player_w = AiPlayer(exe_path, turn_limit_s, Player.WHITE,
thread, self.board)
else:
self.player_b = Player(Player.BLACK, thread, self.board)
self.player_w = Player(Player.WHITE, thread, self.board)
player_options_b = PlayerOptions(self.player_b, self)
board_controls = BoardControls(self.board)
player_options_w = PlayerOptions(self.player_w, self)
v_layout = QVBoxLayout()
v_layout.addStretch()
v_layout.addWidget(player_options_b)
v_layout.addStretch()
v_layout.addWidget(board_controls)
v_layout.addStretch()
v_layout.addWidget(player_options_w)
v_layout.addStretch()
h_layout = QHBoxLayout()
h_layout.addWidget(self.board)
h_layout.addLayout(v_layout)
h_layout.addSpacing(50)
self.setLayout(h_layout)
class MainView(QMainWindow):
def __init__(self):
super().__init__()
self.board = ChessBoard(self)
self.init()
def init(self):
self.create_menu()
self.layout()
self.setWindowTitle("NChess")
self.setWindowIcon(QIcon("rsc/icon.png"))
self.resize(1160, 900)
self.center()
self.show()
self.board.startpos()
def layout(self):
layout = BorderLayout()
layout.addWidget(self.board, BorderLayout.Center)
vbox = QVBoxLayout()
show_best_move = QCheckBox("Show Best Move")
show_best_move.setChecked(True)
show_best_move.stateChanged.connect(self.board.show_best_move_changed)
vbox.addWidget(show_best_move)
engine_selector = QComboBox()
engine_selector.addItem("Stockfish")
engine_selector.addItem("Leela")
engine_selector.addItem("Komodo")
engine_selector.addItem("NCE")
engine_selector.currentIndexChanged.connect(
lambda: self.board.change_engine(engine_selector.currentText()))
vbox.addWidget(engine_selector)
self.game_score = QLabel()
self.game_score.setText("Score: 0")
self.game_score.setWordWrap(True)
self.game_score.setMaximumWidth(200)
self.game_score.setMinimumWidth(200)
vbox.addWidget(self.game_score)
next_btn = QPushButton()
next_btn.setText("Next")
next_btn.clicked.connect(lambda: self.board.next_move())
vbox.addWidget(next_btn)
undo_btn = QPushButton()
undo_btn.setText("Back")
undo_btn.clicked.connect(lambda: self.board.back_move())
vbox.addWidget(undo_btn)
reset_btn = QPushButton()
reset_btn.setText("Reset")
reset_btn.clicked.connect(lambda: self.board.startpos())
vbox.addWidget(reset_btn)
self.fen_field = QLineEdit()
self.fen_field.setText(STARTING_FEN)
self.fen_field.setMinimumWidth(200)
self.fen_field.setMaximumWidth(200)
vbox.addWidget(self.fen_field)
set_fen_btn = QPushButton()
set_fen_btn.setText("Set fen")
set_fen_btn.clicked.connect(
lambda: self.board.loadfen(self.fen_field.text()))
vbox.addWidget(set_fen_btn)
self.engine_thoughts = QLabel()
self.engine_thoughts.setText("...")
self.engine_thoughts.setWordWrap(True)
self.engine_thoughts.setMaximumWidth(200)
self.engine_thoughts.setMinimumWidth(200)
vbox.addWidget(self.engine_thoughts)
vbox.addStretch(1)
east_widget = QWidget()
east_widget.setLayout(vbox)
layout.addWidget(east_widget, BorderLayout.East)
central_widget = QWidget()
central_widget.setLayout(layout)
self.setCentralWidget(central_widget)
def create_menu(self):
menubar = self.menuBar()
file = menubar.addMenu("File")
exit_action = QAction(QIcon("rsc/exit.png"), "Exit", self)
exit_action.setShortcut("Ctrl+Q")
exit_action.triggered.connect(self.close)
file.addAction(exit_action)
def center(self):
qr = self.frameGeometry()
cp = QDesktopWidget().availableGeometry().center()
qr.moveCenter(cp)
self.move(qr.topLeft())
def mousePressEvent(self, event):
self.board.mouse_press(event)
def mouseReleaseEvent(self, event):
self.board.mouse_release(event)
def closeEvent(self, event):
self.board.engine_handler.stockfish.quit()
self.board.engine_handler.leela.quit()
self.board.engine_handler.komodo.quit()
self.board.engine_handler.nce.quit()
Mohammad Kebbi; 1496572
Sheetal Gour; 1547017
Main Functon that initializes the User Interface class to run the chess
Game on pygame
"""
import pygame
from board import ChessBoard
from userInterface import UserInterface
if __name__ == "__main__":
pygame.init() # initialize pygame
# set window size for create pygame window for chess program
surface = pygame.display.set_mode(
[600, 600], 0, 0
) # (Re adjust the coordinate if you want to change size of game's window
# sets the title of the window
pygame.display.set_caption('pyChess')
# Initialize chessBoard class. Used for our interface
Board = ChessBoard()
# create and initialize User interface object to run pygame chess program
UI = UserInterface(surface, Board)
UI.playGame() # call play game function to start the game
pygame.quit() # Close program
class Game:
def __init__(self):
pygame.init()
pygame.display.set_caption('Шахматы')
pygame.display.set_icon(pygame.image.load('images/icon.jpg'))
self.screen = pygame.display.set_mode((860, 565))
self.clock = pygame.time.Clock()
self.board = ChessBoard()
self.main_menu = pygame.image.load('images/main_menu.jpg')
self.main_menu = pygame.transform.scale(self.main_menu, (860, 565))
self.board_img = pygame.image.load('images/board.png')
self.win_background = pygame.Surface((860, 565))
self.poss_target = pygame.Surface(
(self.board.cell_size, self.board.cell_size))
self.target_image = pygame.Surface(
(self.board.cell_size, self.board.cell_size))
self.target_enemy_image = pygame.Surface(
(self.board.cell_size, self.board.cell_size))
self.move_history = pygame.Surface((270, 310))
self.win_background.set_alpha(150)
self.poss_target.set_alpha(125)
self.target_image.set_alpha(125)
self.target_enemy_image.set_alpha(125)
pygame.draw.rect(self.win_background, (255, 255, 255),
self.win_background.get_rect())
pygame.draw.rect(self.poss_target, (173, 255, 182),
self.poss_target.get_rect())
pygame.draw.rect(self.target_image, (173, 255, 255),
self.target_image.get_rect())
pygame.draw.rect(self.target_enemy_image, (255, 173, 173),
self.target_enemy_image.get_rect())
self.w_figures_captured_images = []
self.b_figures_captured_images = []
self.new_game = False
self.pause = True
self.winner = None
self.target = None
self.target_poss_moves = ()
self.all_poss_moves = self.get_all_poss_moves()
self.main_loop()
def main_loop(self):
running = True
while running:
self.draw_window()
for event in pygame.event.get():
if event.type == QUIT:
running = False
if event.type == MOUSEBUTTONUP and event.button == 1:
self.get_click()
self.clock.tick(60)
def draw_window(self):
if not self.new_game:
# Вывод главного меню
self.draw_main_menu()
else:
# Вывод доски
self.draw_board()
if self.winner:
# Вывод победного меню
self.draw_win_menu()
pygame.display.update()
def reset(self):
# Обнуление игры
self.screen.fill((250, 232, 167))
self.new_game = False
self.pause = True
self.winner = None
self.figure_untarget()
self.all_poss_moves = self.get_all_poss_moves()
self.board.reset()
self.draw_window()
def draw_main_menu(self):
# Главное меню
new_game = pygame.Surface((400, 85))
exit = pygame.Surface((250, 85))
new_game.set_alpha(150)
exit.set_alpha(150)
# Фон для кнопок
pygame.draw.rect(new_game, (105, 105, 105), new_game.get_rect())
pygame.draw.rect(exit, (105, 105, 105), exit.get_rect())
self.screen.blit(self.main_menu, (0, 0))
self.screen.blit(new_game, (225, 210))
self.screen.blit(exit, (305, 310))
self.message_display('Новая игра', (425, 250),
font_color=(255, 255, 255))
self.message_display('Выход', (425, 350), font_color=(255, 255, 255))
pygame.display.update()
def draw_board(self):
# Отрисовка всего на доске
self.screen.fill((250, 232, 167))
self.screen.blit(self.board_img, (0, 0))
# Выделение фигуры
if not self.pause:
if self.target:
self.screen.blit(self.target_image,
self.get_coords(self.target.pos))
# Выделение доступных для хода клеток
if self.target_poss_moves:
for move in self.target_poss_moves:
# Если пустая
if self.board.field[move[0]][move[1]]:
self.screen.blit(self.target_enemy_image,
self.get_coords(move))
# Если вражеская фигура
else:
self.screen.blit(self.target_image,
self.get_coords(move))
else:
# Фигуры текущего игрока, которые могут ходить
for cell in self.all_poss_moves.keys():
if self.all_poss_moves[cell]:
self.screen.blit(self.poss_target,
self.get_coords(cell))
# Отрисовка координатного поля на доске
for i in range(8, 0, -1):
x, y = self.get_coords((0, i - 1))
self.message_display('%s' % i,
(int(x - self.board.edge * 0.5),
int(y + self.board.cell_size * 0.5)), 24)
x, y = self.get_coords((i - 1, 7))
self.message_display('%s' % self.get_cell_name((i - 1, 7)),
(int(x + self.board.edge),
int(y + self.board.cell_size * 1.25)), 24)
# Отрисовка фигур
for figure in self.board.alive_figures():
figure_pos = self.get_coords(figure.pos)
figure_img = pygame.image.load(figure.image)
figure_img = pygame.transform.scale(figure_img, (50, 50))
self.screen.blit(figure_img,
(figure_pos[0] + 7, figure_pos[1] + 7))
# Отрисовка бокового меню
self.draw_side_menu()
def draw_side_menu(self):
# Боковое меню
player = 'белых' if self.board.curr_player == 'w' else 'черных'
history_list = self.board.move_history
hist_y = 3
b_x, b_y = 570, 5
w_x, w_y = 570, 505
self.move_history.fill((250, 232, 167))
self.message_display('Ход: %s' % player, (710, 120), 38)
# Отображение истории ходов
for move in history_list if len(
history_list) < 12 else history_list[-12:]:
move = str(history_list.index(move) + 1) + '. ' + move
self.message_display(move, (15, hist_y), 23, align_left=1)
hist_y += 25
# Вставка таблицы на основной экран
self.screen.blit(self.move_history, (577, 160))
pygame.draw.rect(self.screen, (0, 0, 0), (577, 160, 270, 310), 3)
# Отображение побеждённых чёрных фигур
i = 0
for b_fig in self.b_figures_captured_images:
# Если фигур становится больше 8, то отрисовка идёт в 2 ряда
if i == 9:
b_x = 570
b_y += 30
b_fig = pygame.image.load(b_fig)
b_fig = pygame.transform.scale(b_fig, (25, 25))
self.screen.blit(b_fig, (b_x, b_y))
b_x += 30
i += 1
# Отображение побеждённых белых фигур
i = 0
for w_fig in self.w_figures_captured_images:
# Если фигур становится больше 8, то отрисовка идёт в 2 ряда
if i == 9:
w_x = 570
w_y += 30
w_fig = pygame.image.load(w_fig)
w_fig = pygame.transform.scale(w_fig, (25, 25))
self.screen.blit(w_fig, (w_x, w_y))
w_x += 30
i += 1
def draw_win_menu(self):
# Победное меню
yes = pygame.Surface((90, 75))
no = pygame.Surface((90, 75))
yes.set_alpha(100)
no.set_alpha(100)
# Фон под кнопки
pygame.draw.rect(yes, (100, 100, 100), yes.get_rect())
pygame.draw.rect(no, (100, 100, 100), no.get_rect())
# Отрисовка фона
self.screen.blit(self.win_background, (0, 0))
self.screen.blit(yes, (255, 365))
self.screen.blit(no, (455, 365))
self.message_display('Шах и Мат!', (425, 130))
self.message_display('%s победили!' % self.winner, (425, 230))
self.message_display('Вернутся в главное меню?', (425, 330), 56)
self.message_display('Да', (300, 400), 48)
self.message_display('Нет', (500, 400), 48)
pygame.display.update()
def get_coords(self, cell):
# Клетка в координаты
return cell[0] * self.board.cell_size + self.board.edge,\
cell[1] * self.board.cell_size + self.board.edge
def get_cell(self, coords):
# Координаты в клетку
x, y = (coords[0] - self.board.edge) // self.board.cell_size, \
(coords[1] - self.board.edge) // self.board.cell_size
if 0 <= x <= 7 and 0 <= y <= 7:
return x, y
def get_cell_name(self, cell, for_history=0):
# Возвращает название клетки в виде ЦИФРАБУКВА (пример: (1,3) => 'B3')
conversions = {
0: 'A',
1: 'B',
2: 'C',
3: 'D',
4: 'E',
5: 'F',
6: 'G',
7: 'H'
}
if for_history:
return str(conversions[cell[0]]) + str(cell[1] + 1)
return str(conversions[cell[0]])
def get_click(self):
x, y = pygame.mouse.get_pos()
# Обработка клика мыши
# Получение клетки из координат
cell = self.get_cell((x, y))
# Если не пауза
if not self.pause:
if cell:
# Фигура на клетке. Нужна для смены фокуса на другую союзную фигуру без повторного клика по текущей.
cell_figure = self.board.figure_at(cell)
# Если фигура не выбрана:
if not self.target:
# Фокус на данную клетку
if self.is_curr_player_figure_at(cell):
self.figure_target(cell)
# Если фигура уже выбрана:
else:
# Убирает фокус при повторном нажатии
if cell == self.target.pos:
self.figure_untarget()
# Меняет фокус на другую союзную фигуру
elif cell_figure and cell_figure.color == self.board.curr_player:
self.figure_target(cell)
# Если клетка находится в доступных шагах:
elif cell in self.target_poss_moves:
# Является ли фигура королём
if self.target.name == 'King' and cell in self.board.castle_moves_for_player(
):
# Castle that king
self.add_move(self.target.pos, cell)
self.board.castle_king(self.target, cell)
else:
# Движение фигуры
self.add_move(self.target.pos, cell)
self.move_figure(self.target, cell)
# Повышение пешки
if self.target.name == 'Pawn' and (cell[1] == 0 or
cell[1] == 7):
self.board.field[cell[0]][cell[1]] = None
self.board.field[cell[0]][cell[1]] = Queen(
self.board.curr_player, cell)
# Снятие фокуса
self.figure_untarget()
# Смена игрока
self.change_player()
# Проверка на шах и мат, и обновление списка со всеми возможными ходами
self.all_poss_moves = self.get_all_poss_moves()
checkmate = True
for figures_pos in self.all_poss_moves:
if len(self.all_poss_moves[figures_pos]) != 0:
checkmate = False
# Если шах и мат:
if checkmate:
# Определение победителя
self.winner = 'Белые' if self.board.curr_player == 'b' else 'Чёрные'
self.pause = True
self.draw_board()
self.draw_win_menu()
# Иначе переключение на победное/главное меню
else:
# Если есть победитель, то переключение на победное меню
if self.winner:
if 365 <= y <= 440:
# Если "да", то происходит сброс и возврат в гланое меню
if 255 <= x <= 345:
self.reset()
# Если "нет", то выход из игры
elif 455 <= x <= 545:
quit()
else:
pass
# Иначе главное меню
else:
# Если "Новая игра"
if 225 <= x <= 625 and 210 <= y <= 295:
self.new_game = True
self.pause = False
# Если "Выход"
elif 305 <= x <= 555 and 310 <= y <= 395:
quit()
def get_target_poss_moves(self):
# Получить возможные ходы
return self.all_poss_moves[self.target.pos]
def get_all_poss_moves(self):
# Получить все возожные ходы для игрока
moves = {}
figures = self.board.curr_player_figures()
for figure in figures:
f_moves = self.board.possible_moves_for(figure)
moves[figure.pos] = self.board.is_player_in_check(figure, f_moves)
return moves
def figure_target(self, cell):
# Фокус на фигуру
self.target = self.board.figure_at(cell)
self.target_poss_moves = self.get_target_poss_moves()
def figure_untarget(self):
# Снятие фокуса
self.target = None
self.target_poss_moves = None
def is_curr_player_figure_at(self, cell):
# Является ли фигура фигруой текущего игрока
for figure in self.board.curr_player_figures():
if cell == figure.pos:
return True
def change_player(self):
# Смена игрока
self.board.curr_player = 'w' if self.board.curr_player == 'b' else 'b'
def move_figure(self, figure, cell):
# Движение фигуры и захват срезанной фигуры, если есть
figure_captured = self.board.move_figure(figure, cell)
if figure_captured:
self.figure_was_captured(figure_captured)
def add_move(self, pos_1, pos_2):
# Добавление хода в историю
name = 'Б: ' if self.board.curr_player == 'w' else 'Ч: '
move = name + self.get_cell_name(
pos_1, for_history=1) + ' => ' + self.get_cell_name(pos_2,
for_history=1)
self.board.move_history.append(move)
def figure_was_captured(self, figure):
# Получегие изображения захваченной фигуры
if figure.color == 'w':
self.w_figures_captured_images.append(figure.image)
else:
self.b_figures_captured_images.append(figure.image)
def message_display(self,
text,
coords,
font_size=68,
font_color=(0, 0, 0),
align_left=0):
# Отображение сообщения
font_dir = pygame.font.match_font('verdana')
text_font = pygame.font.Font(font_dir, font_size)
text_surface = text_font.render(text, True, font_color)
if not align_left:
text_rect = text_surface.get_rect()
text_rect.center = (coords)
self.screen.blit(text_surface, text_rect)
else:
self.move_history.blit(text_surface, coords)
self.__translateBoardCoords(i, j),
image=self.piecesImages[tilePiece.name + "Black"])
def addBinding(self, eventName, function):
self.piecesCanvas.bind(eventName, function)
def __translateBoardCoords(self, boardPositionX, boardPositionY):
"""translates integer position on the chess board to pixel position in canvas"""
return (boardPositionX * 64 + 32,
(64 * 8) - (boardPositionY * 64) - 32)
############################################################################
###############################DEBUG########################################
if __name__ == "__main__":
from board import ChessBoard
x = ChessBoard()
root = Tk()
app = BoardWindow(root)
app.drawBoard(x)
input("w")
p = x.getPiece(0, 1)
x.movePiece(p, 0, 2)
app.drawBoard(x)
root.mainloop()
############################################################################
############################################################################
def test_taking_figures(self):
chess_board = ChessBoard()
b_R1 = Figure("R1", chess_board.board, 'A', 8, "black")
b_H1 = Figure("H1", chess_board.board, 'B', 8, "black")
b_B1 = Figure("B1", chess_board.board, 'C', 8, "black")
b_Q1 = Figure("Q1", chess_board.board, 'D', 8, "black")
b_K1 = Figure("K1", chess_board.board, 'E', 8, "black")
b_B2 = Figure("B2", chess_board.board, 'F', 8, "black")
b_H2 = Figure("H2", chess_board.board, 'G', 8, "black")
b_R2 = Figure("R2", chess_board.board, 'H', 8, "black")
b_P1 = Figure("P1", chess_board.board, 'A', 7, "black")
b_P2 = Figure("P2", chess_board.board, 'B', 7, "black")
b_P3 = Figure("P3", chess_board.board, 'C', 7, "black")
b_P4 = Figure("P4", chess_board.board, 'D', 7, "black")
b_P5 = Figure("P5", chess_board.board, 'E', 7, "black")
b_P6 = Figure("P6", chess_board.board, 'F', 7, "black")
b_P7 = Figure("P7", chess_board.board, 'G', 7, "black")
b_P8 = Figure("P8", chess_board.board, 'H', 7, "black")
w_R1 = Figure("R1", chess_board.board, 'A', 1, "white")
w_H1 = Figure("H1", chess_board.board, 'B', 1, "white")
w_B1 = Figure("B1", chess_board.board, 'C', 1, "white")
w_Q1 = Figure("Q1", chess_board.board, 'D', 1, "white")
w_K1 = Figure("K1", chess_board.board, 'E', 1, "white")
w_B2 = Figure("B2", chess_board.board, 'F', 1, "white")
w_H2 = Figure("H2", chess_board.board, 'G', 1, "white")
w_R2 = Figure("R2", chess_board.board, 'H', 1, "white")
w_P1 = Figure("P1", chess_board.board, 'A', 2, "white")
w_P2 = Figure("P2", chess_board.board, 'B', 2, "white")
w_P3 = Figure("P3", chess_board.board, 'C', 2, "white")
w_P4 = Figure("P4", chess_board.board, 'D', 2, "white")
w_P5 = Figure("P5", chess_board.board, 'E', 2, "white")
w_P6 = Figure("P6", chess_board.board, 'F', 2, "white")
w_P7 = Figure("P7", chess_board.board, 'G', 2, "white")
w_P8 = Figure("P8", chess_board.board, 'H', 2, "white")
w_figs = [
w_R1, w_H1, w_B1, w_Q1, w_K1, w_B2, w_H2, w_R2, w_P1, w_P2, w_P3,
w_P4, w_P5, w_P6, w_P7, w_P8
]
b_figs = [
b_R1, b_H1, b_B1, b_Q1, b_K1, b_B2, b_H2, b_R2, b_P1, b_P2, b_P3,
b_P4, b_P5, b_P6, b_P7, b_P8
]
moves = [
"A2-A4",
"B7-B5",
"C2-C4",
"D7-D5",
"E2-E4",
"F7-F5", # moving the pawns
"G2-G4",
"H7-H5",
"A4-B5",
"D5-C4",
"E4-F5",
"H5-G4", # out of the way
"A1-A7",
"A8-A7",
"F1-C4",
"E8-F7",
"C4-E6",
"F7-E6",
"B1-A3",
"D8-D2",
"C1-D2",
"G8-H6",
"E1-E2",
"H6-F5",
"exit"
]
board = [{
"A": None,
"B": b_H1,
"C": b_B1,
"D": None,
"E": None,
"F": b_B2,
"G": None,
"H": b_R2
}, {
"A": b_R1,
"B": None,
"C": b_P3,
"D": None,
"E": b_P5,
"F": None,
"G": b_P7,
"H": None
}, {
"A": None,
"B": None,
"C": None,
"D": None,
"E": b_K1,
"F": None,
"G": None,
"H": None
}, {
"A": None,
"B": w_P1,
"C": None,
"D": None,
"E": None,
"F": b_H2,
"G": None,
"H": None
}, {
"A": None,
"B": None,
"C": None,
"D": None,
"E": None,
"F": None,
"G": b_P8,
"H": None
}, {
"A": w_H1,
"B": None,
"C": None,
"D": None,
"E": None,
"F": None,
"G": None,
"H": None
}, {
"A": None,
"B": w_P2,
"C": None,
"D": w_B1,
"E": w_K1,
"F": w_P6,
"G": None,
"H": w_P8
}, {
"A": None,
"B": None,
"C": None,
"D": w_Q1,
"E": None,
"F": None,
"G": w_H2,
"H": w_R2
}]
board = reverse_board(board)
game = Game(w_figs, b_figs, chess_board)
game.run(moves)
self.assertEqual(game.chess_board.board, board)
self.assertEqual(game.w_player.won_figures,
[b_P2, b_P6, b_P1, b_P4, b_Q1])
self.assertEqual(game.b_player.won_figures,
[w_P3, w_P7, w_R1, w_B2, w_P4, w_P5])
def main():
chess_board = ChessBoard()
chess_board.start()
def main():
board = ChessBoard('./images/tests/2.png')
for column in board.get_board():
print(column)
def __init__(self, pack_label: bool = False):
self.chessBoard = ChessBoard("p", "p")
self.root = Tk()
self.root.resizable(width=FALSE, height=FALSE)
self.root.title("GoBang")
self.button_freeze = False
# Total chessboard
self.boardFrame = Frame(self.root)
# Menu
self._init_menu()
# Create canvas
self.gap = 25
self.mainBoard = Canvas(self.boardFrame,
width=self.gap * 16,
height=self.gap * 16) # size: 400 * 400
self._draw_lines()
# Bind mouse action
self.mainBoard.bind("<Button-1>", self.mouse_click)
# Generate all positions
self.all_positions = {(x, y)
for x in range(self.gap, self.gap * 16, self.gap)
for y in range(self.gap, self.gap * 16, self.gap)
}
self.operate = []
# print(self.all_positions)
# Create control frame
self.controlFrame = Labelframe(self.root, text="Control Panel")
self.turn = Label(self.controlFrame, text="Next player: black")
self.turn.pack(pady=10)
# Evaluate part
self.score1 = Label(self.controlFrame, text="Black: 0")
self.score2 = Label(self.controlFrame, text="White: 0")
self.evaluateButton = Button(self.controlFrame,
text="Evaluate",
command=self.button_evaluate)
# AI part
self.aiCalculateButton = Button(self.controlFrame,
text="AI Calculate (beta)",
command=self.ai_calculate)
self.score1.pack()
self.score2.pack()
# self.evaluateButton.pack()
self.aiCalculateButton.pack(pady=10)
# Create Label frames
self.horLabel = Frame(self.boardFrame)
self.verLabel = Frame(self.boardFrame)
self._draw_label()
# Pack Widgets
if pack_label:
self.horLabel.grid(row=0, column=1, pady=0)
self.verLabel.grid(row=1, column=0, padx=0)
self.mainBoard.grid(row=1, column=1, padx=0, pady=0)
self.boardFrame.grid()
# Some bugs here, cannot click canvas after click button....
self.controlFrame.grid(row=0, column=1, padx=5)
class ChessBoardInterface:
def __init__(self, pack_label: bool = False):
self.chessBoard = ChessBoard("p", "p")
self.root = Tk()
self.root.resizable(width=FALSE, height=FALSE)
self.root.title("GoBang")
self.button_freeze = False
# Total chessboard
self.boardFrame = Frame(self.root)
# Menu
self._init_menu()
# Create canvas
self.gap = 25
self.mainBoard = Canvas(self.boardFrame,
width=self.gap * 16,
height=self.gap * 16) # size: 400 * 400
self._draw_lines()
# Bind mouse action
self.mainBoard.bind("<Button-1>", self.mouse_click)
# Generate all positions
self.all_positions = {(x, y)
for x in range(self.gap, self.gap * 16, self.gap)
for y in range(self.gap, self.gap * 16, self.gap)
}
self.operate = []
# print(self.all_positions)
# Create control frame
self.controlFrame = Labelframe(self.root, text="Control Panel")
self.turn = Label(self.controlFrame, text="Next player: black")
self.turn.pack(pady=10)
# Evaluate part
self.score1 = Label(self.controlFrame, text="Black: 0")
self.score2 = Label(self.controlFrame, text="White: 0")
self.evaluateButton = Button(self.controlFrame,
text="Evaluate",
command=self.button_evaluate)
# AI part
self.aiCalculateButton = Button(self.controlFrame,
text="AI Calculate (beta)",
command=self.ai_calculate)
self.score1.pack()
self.score2.pack()
# self.evaluateButton.pack()
self.aiCalculateButton.pack(pady=10)
# Create Label frames
self.horLabel = Frame(self.boardFrame)
self.verLabel = Frame(self.boardFrame)
self._draw_label()
# Pack Widgets
if pack_label:
self.horLabel.grid(row=0, column=1, pady=0)
self.verLabel.grid(row=1, column=0, padx=0)
self.mainBoard.grid(row=1, column=1, padx=0, pady=0)
self.boardFrame.grid()
# Some bugs here, cannot click canvas after click button....
self.controlFrame.grid(row=0, column=1, padx=5)
def ai_calculate(self):
"""
Call min_max search in ai.py to find the best place to set chess
"""
if self.button_freeze:
return
print("Perform AI Evaluate!", end=" ")
start_time = time.time()
self.chessBoard.freeze = True
self.button_freeze = True
bar = Bar(len(points_gen(self.chessBoard, self.chessBoard.next_turn)))
position = min_max_search(self.chessBoard,
self.chessBoard.next_turn,
bar,
depth=2)
print(position)
position = self.convert_coordinate(position[0], position[1])
temp_coo = namedtuple("Coordinate", ["x", "y"])
print("Used time: {}".format(round(time.time() - start_time, 3)))
self.chessBoard.freeze = False
self.button_freeze = False
self.mouse_click(temp_coo(position[0], position[1]))
def button_evaluate(self):
"""
Evaluate and score the situation on chessboard for both players
"""
if self.button_freeze:
return
print("Perform evaluate_point!")
split = list(self.chessBoard.split_board())
self.score1["text"] = "Black: {}".format(
self.chessBoard.evaluate(1, split))
self.score2["text"] = "White: {}".format(
self.chessBoard.evaluate(2, split))
self.root.update()
def mouse_click(self, click):
x, y = self._nearest_position(click)
converted_coo = self.convert_coordinate(x, y)
# Calculate is the place already has a chess
if self.chessBoard.board[converted_coo[0]][converted_coo[1]] != 0:
return
# If the board is frozen...
if self.chessBoard.freeze:
return
# Draw chess
chess_size = self.gap * 2 // 5
if self.chessBoard.next_turn == 1:
color = "Black"
else:
color = "White"
new_position = self.convert_coordinate(x, y)
print("{} chess at position({}, {})".format(color, new_position[0],
new_position[1]))
self.operate.append(
self.mainBoard.create_oval(
x - chess_size,
y - chess_size,
x + chess_size,
y + chess_size,
fill=color,
tag="{} {}".format(x, y),
))
self.mainBoard.update()
# Update Chessboard
result = self.chessBoard.set_chess(converted_coo[0], converted_coo[1])
# If the game is ended
if result == TIE:
print("Tie!")
self.chessBoard.freeze = True
ok_window = OkWindow(TIE)
self.root.wait_window(ok_window.root)
print("Restart: {}".format(ok_window.final_restart))
# Restart game
if ok_window.final_restart:
self.restart_game()
elif result != CONTINUE:
if result == BLACK_WIN:
winner = "Black"
else:
winner = "White"
print("{} won!".format(winner))
self.chessBoard.freeze = True
ok_window = OkWindow(winner)
self.root.wait_window(ok_window.root)
print("Restart: {}".format(ok_window.final_restart))
# Restart game
if ok_window.final_restart:
self.restart_game()
# Update gui
self.turn["text"] = "Next player: {}".format(
"black" if self.chessBoard.next_turn == 1 else "white")
self.button_evaluate()
# print(self.chessBoard)
def _nearest_position(self, click) -> Tuple[int, int]:
x, y = click.x, click.y
return (
sorted(
range(self.gap, self.gap * 16, self.gap),
key=lambda temp_x: abs(temp_x - x),
)[0],
sorted(
range(self.gap, self.gap * 16, self.gap),
key=lambda temp_y: abs(temp_y - y),
)[0],
)
@staticmethod
def convert_coordinate(x: int, y: int) -> Tuple[int, int]:
if x > 16 or y > 16:
return x // 25 - 1, y // 25 - 1
else:
return (x + 1) * 25, (y + 1) * 25
def _init_menu(self):
menu = Menu(self.root, tearoff=0)
self.root.config(menu=menu)
game_menu = Menu(menu)
game_menu.add_command(label="New game", command=self.restart_game)
# game_menu.add_command(label="Evaluate", command=self.button_evaluate)
game_menu.add_command(label="Withdraw", command=self.withdraw)
game_menu.add_command(label="Exit", command=self.root.destroy)
menu.add_cascade(label="Game", menu=game_menu)
def _draw_label(self):
for x in range(15):
Label(self.horLabel, text=format_number(x)).pack(side=LEFT,
padx=3,
pady=0)
for y in range(15):
Label(self.verLabel, text=format_number(y)).pack(side=TOP,
pady=2,
padx=0)
def _draw_lines(self):
# horizontal
for index in range(1, 16):
self.mainBoard.create_line(self.gap * index, self.gap,
self.gap * index, 25 * 15)
self.mainBoard.create_line(self.gap, self.gap * index, 25 * 15,
self.gap * index)
def restart_game(self):
global user_info, bd
del bd
print("\n----------Restart Game!----------")
self.root.destroy()
bd = ChessBoardInterface(pack_label=user_info["pack_label"])
bd.root.mainloop()
def withdraw(self):
# Check if the chessboard is frozen
if self.chessBoard.freeze or self.button_freeze:
return
withdraw_gen = self.chessBoard.withdraw()
last_chess = next(withdraw_gen)
player, position = last_chess
print("Withdraw {} chess at ({}, {})".format(
"Black" if player == 1 else "White", position[0], position[1]))
# Change next player
self.chessBoard.next_turn = 1 if self.chessBoard.next_turn == 2 else 2
# Delete picture
self.mainBoard.delete(self.operate.pop())
self.button_evaluate()
def __init__(self):
super().__init__()
self.board = ChessBoard(self)
self.init()
def test_basic_movement(self):
chess_board = ChessBoard()
b_R1 = Figure("R1", chess_board.board, 'A', 8, "black")
b_H1 = Figure("H1", chess_board.board, 'B', 8, "black")
b_B1 = Figure("B1", chess_board.board, 'C', 8, "black")
b_Q1 = Figure("Q1", chess_board.board, 'D', 8, "black")
b_K1 = Figure("K1", chess_board.board, 'E', 8, "black")
b_B2 = Figure("B2", chess_board.board, 'F', 8, "black")
b_H2 = Figure("H2", chess_board.board, 'G', 8, "black")
b_R2 = Figure("R2", chess_board.board, 'H', 8, "black")
b_P1 = Figure("P1", chess_board.board, 'A', 7, "black")
b_P2 = Figure("P2", chess_board.board, 'B', 7, "black")
b_P3 = Figure("P3", chess_board.board, 'C', 7, "black")
b_P4 = Figure("P4", chess_board.board, 'D', 7, "black")
b_P5 = Figure("P5", chess_board.board, 'E', 7, "black")
b_P6 = Figure("P6", chess_board.board, 'F', 7, "black")
b_P7 = Figure("P7", chess_board.board, 'G', 7, "black")
b_P8 = Figure("P8", chess_board.board, 'H', 7, "black")
w_R1 = Figure("R1", chess_board.board, 'A', 1, "white")
w_H1 = Figure("H1", chess_board.board, 'B', 1, "white")
w_B1 = Figure("B1", chess_board.board, 'C', 1, "white")
w_Q1 = Figure("Q1", chess_board.board, 'D', 1, "white")
w_K1 = Figure("K1", chess_board.board, 'E', 1, "white")
w_B2 = Figure("B2", chess_board.board, 'F', 1, "white")
w_H2 = Figure("H2", chess_board.board, 'G', 1, "white")
w_R2 = Figure("R2", chess_board.board, 'H', 1, "white")
w_P1 = Figure("P1", chess_board.board, 'A', 2, "white")
w_P2 = Figure("P2", chess_board.board, 'B', 2, "white")
w_P3 = Figure("P3", chess_board.board, 'C', 2, "white")
w_P4 = Figure("P4", chess_board.board, 'D', 2, "white")
w_P5 = Figure("P5", chess_board.board, 'E', 2, "white")
w_P6 = Figure("P6", chess_board.board, 'F', 2, "white")
w_P7 = Figure("P7", chess_board.board, 'G', 2, "white")
w_P8 = Figure("P8", chess_board.board, 'H', 2, "white")
w_figs = [
w_R1, w_H1, w_B1, w_Q1, w_K1, w_B2, w_H2, w_R2, w_P1, w_P2, w_P3,
w_P4, w_P5, w_P6, w_P7, w_P8
]
b_figs = [
b_R1, b_H1, b_B1, b_Q1, b_K1, b_B2, b_H2, b_R2, b_P1, b_P2, b_P3,
b_P4, b_P5, b_P6, b_P7, b_P8
]
moves = [
"A2-A4",
"B7-B5",
"C2-C4",
"D7-D5",
"E2-E4",
"F7-F5", # moving the pawns
"G2-G4",
"H7-H5",
"A4-B5",
"D5-C4",
"E4-F5",
"H5-G4", # out of the way
"A1-C1",
"A1-A10",
"A1-B3",
"A1-C3",
"A1-A5", # rook movement
"G8-G7",
"G8-G5",
"G8-H7",
"G8-F5",
"G8-H6", # horse movement
"A5-D5",
"C1-B2",
"C1-A3",
"C1-D2",
"C1-F4",
"C1-C3", # bishop movement
"D1-D2",
"D1-D4",
"D1-H5",
"D1-B3", # queen movement
"E8-E7",
"E8-E5",
"E8-F8",
"E8-F7", # king movement
"F1-D3",
"exit" # last bishop move
]
board = [{
"A": b_R1,
"B": b_H1,
"C": b_B1,
"D": b_Q1,
"E": None,
"F": b_B2,
"G": None,
"H": b_R2
}, {
"A": b_P1,
"B": None,
"C": b_P3,
"D": None,
"E": b_P5,
"F": b_K1,
"G": b_P7,
"H": None
}, {
"A": None,
"B": None,
"C": None,
"D": None,
"E": None,
"F": None,
"G": None,
"H": b_H2
}, {
"A": w_R1,
"B": w_P1,
"C": None,
"D": None,
"E": None,
"F": w_P5,
"G": None,
"H": None
}, {
"A": None,
"B": None,
"C": b_P4,
"D": None,
"E": None,
"F": None,
"G": b_P8,
"H": None
}, {
"A": None,
"B": w_Q1,
"C": None,
"D": w_B2,
"E": None,
"F": None,
"G": None,
"H": None
}, {
"A": None,
"B": w_P2,
"C": None,
"D": w_P4,
"E": None,
"F": w_P6,
"G": None,
"H": w_P8
}, {
"A": None,
"B": w_H1,
"C": w_B1,
"D": None,
"E": w_K1,
"F": None,
"G": w_H2,
"H": w_R2
}]
board = reverse_board(board)
game = Game(w_figs, b_figs, chess_board)
game.run(moves)
self.assertEqual(game.chess_board.board, board)
def has_neighbor(board: ChessBoard, point: Tuple[int, int], depth: int) -> bool:
"""
Determine whether a point has neighbor which is filled
:param depth: depth of calculation
:param board: chessboard
:param point: point wants to calculate
:return: whether a point has neighbor which is filled
"""
x, y = point
all_points = [
board.board[cx][cy]
# (cx, cy)
for cx in range(
x - depth if x - depth >= 0 else 0, x + depth + 1 if x + depth <= 14 else 15
)
for cy in range(
y - depth if y - depth >= 0 else 0, y + depth + 1 if y + depth <= 14 else 15
)
]
if any((1 in all_points, 2 in all_points)):
return True
return False
if __name__ == "__main__":
a = ChessBoard("p", "p")
a.set_chess(4, 6)
print(has_neighbor(a, (3, 4), depth=2))
print(points_gen(a, 1))
def test_end(self):
chess_board = ChessBoard()
b_R1 = Figure("R1", chess_board.board, 'A', 8, "black")
b_H1 = Figure("H1", chess_board.board, 'B', 8, "black")
b_B1 = Figure("B1", chess_board.board, 'C', 8, "black")
b_Q1 = Figure("Q1", chess_board.board, 'D', 8, "black")
b_K1 = Figure("K1", chess_board.board, 'E', 8, "black")
b_B2 = Figure("B2", chess_board.board, 'F', 8, "black")
b_H2 = Figure("H2", chess_board.board, 'G', 8, "black")
b_R2 = Figure("R2", chess_board.board, 'H', 8, "black")
b_P1 = Figure("P1", chess_board.board, 'A', 7, "black")
b_P2 = Figure("P2", chess_board.board, 'B', 7, "black")
b_P3 = Figure("P3", chess_board.board, 'C', 7, "black")
b_P4 = Figure("P4", chess_board.board, 'D', 7, "black")
b_P5 = Figure("P5", chess_board.board, 'E', 7, "black")
b_P6 = Figure("P6", chess_board.board, 'F', 7, "black")
b_P7 = Figure("P7", chess_board.board, 'G', 7, "black")
b_P8 = Figure("P8", chess_board.board, 'H', 7, "black")
w_R1 = Figure("R1", chess_board.board, 'A', 1, "white")
w_H1 = Figure("H1", chess_board.board, 'B', 1, "white")
w_B1 = Figure("B1", chess_board.board, 'C', 1, "white")
w_Q1 = Figure("Q1", chess_board.board, 'D', 1, "white")
w_K1 = Figure("K1", chess_board.board, 'E', 1, "white")
w_B2 = Figure("B2", chess_board.board, 'F', 1, "white")
w_H2 = Figure("H2", chess_board.board, 'G', 1, "white")
w_R2 = Figure("R2", chess_board.board, 'H', 1, "white")
w_P1 = Figure("P1", chess_board.board, 'A', 2, "white")
w_P2 = Figure("P2", chess_board.board, 'B', 2, "white")
w_P3 = Figure("P3", chess_board.board, 'C', 2, "white")
w_P4 = Figure("P4", chess_board.board, 'D', 2, "white")
w_P5 = Figure("P5", chess_board.board, 'E', 2, "white")
w_P6 = Figure("P6", chess_board.board, 'F', 2, "white")
w_P7 = Figure("P7", chess_board.board, 'G', 2, "white")
w_P8 = Figure("P8", chess_board.board, 'H', 2, "white")
w_figs = [
w_R1, w_H1, w_B1, w_Q1, w_K1, w_B2, w_H2, w_R2, w_P1, w_P2, w_P3,
w_P4, w_P5, w_P6, w_P7, w_P8
]
b_figs = [
b_R1, b_H1, b_B1, b_Q1, b_K1, b_B2, b_H2, b_R2, b_P1, b_P2, b_P3,
b_P4, b_P5, b_P6, b_P7, b_P8
]
moves = ["E2-E4", "F7-F6", "D2-D4", "G7-G5", "D1-H5", "exit"]
board = [{
"A": b_R1,
"B": b_H1,
"C": b_B1,
"D": b_Q1,
"E": b_K1,
"F": b_B2,
"G": b_H2,
"H": b_R2
}, {
"A": b_P1,
"B": b_P2,
"C": b_P3,
"D": b_P4,
"E": b_P5,
"F": None,
"G": None,
"H": b_P8
}, {
"A": None,
"B": None,
"C": None,
"D": None,
"E": None,
"F": b_P6,
"G": None,
"H": None
}, {
"A": None,
"B": None,
"C": None,
"D": None,
"E": None,
"F": None,
"G": b_P7,
"H": w_Q1
}, {
"A": None,
"B": None,
"C": None,
"D": w_P4,
"E": w_P5,
"F": None,
"G": None,
"H": None
}, {
"A": None,
"B": None,
"C": None,
"D": None,
"E": None,
"F": None,
"G": None,
"H": None
}, {
"A": w_P1,
"B": w_P2,
"C": w_P3,
"D": None,
"E": None,
"F": w_P6,
"G": w_P7,
"H": w_P8
}, {
"A": w_R1,
"B": w_H1,
"C": w_B1,
"D": None,
"E": w_K1,
"F": w_B2,
"G": w_H2,
"H": w_R2
}]
board = reverse_board(board)
game = Game(w_figs, b_figs, chess_board)
game.run(moves)
self.assertEqual(game.b_checkmate, 1)
def show_board():
game = ChessBoard()
game.show()
# image = pygame.image.load(r'C:\Users\user\Pictures\geek.jpg')
# screen.blit(image, (x,y))
# pygame.transform.scale(img, (1280, 720))
# rect = picture.get_rect()
SCREEN_WIDTH = 680
SCREEN_HEIGHT = 680
screen = pygame.display.set_mode((SCREEN_WIDTH,SCREEN_HEIGHT))
COLORS = {"green":(0,255,0),"blue":(0,0,255),"red":(255,0,0),"black":(0,0,0),"white":(255,255,255),
"golden":(255,215,0)}
KEYS = {"UP":pygame.K_UP,"DOWN":pygame.K_DOWN,"LEFT":pygame.K_LEFT,"RIGHT":pygame.K_RIGHT}
my_chess_board = ChessBoard(screen,SCREEN_WIDTH)
blacks_team = blacks.BlackTeam(surface=screen,board=my_chess_board)
blacks_team.DrawAllPlayers()
whites_team = whites.WhiteTeam(surface=screen,board=my_chess_board)
whites_team.DrawAllPlayers()
blacks_team.opponent = whites_team
whites_team.opponent = blacks_team
def GamePlay():
running = True
while running:
for event in pygame.event.get():
if event.type==QUIT:
[-6, 0, 0, -6, 0, -2, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 2, 6, 0, 0, 0], [0, 0, 2, 0, 0, 0, 0, 0],
[6, 6, 6, 0, 3, 6, 6, 6], [1, 0, 3, 5, 4, 0, 0, 1]]
board4 = [[0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1],
[0, 0, 0, 0, 0, -5, 0, -4], [0, 0, 0, 5, 0, 0, 2, 0],
[0, 0, 0, -6, 0, 0, 0, 0], [6, 6, 0, 0, 0, -6, 6, 6],
[0, 0, 0, 0, 0, -2, 0, 4], [0, 0, 0, 0, -1, 0, 0, 0]]
board5 = [[0, 0, 0, -5, -2, -1, -4, 0], [0, 0, 0, -1, -3, -6, -6, -6],
[-6, -6, -2, -6, -6, 0, 0, 0], [0, 0, 0, 0, 0, 0, 2, 0],
[0, 0, 6, 0, 2, 5, 0, 0], [0, 6, 0, 0, 0, 0, 6, 0],
[6, 3, 0, 0, 6, 6, 4, 6], [0, 0, 1, 1, 0, 0, 0, 0]]
print('test1')
board = ChessBoard('./images/tests/1.png')
npt.assert_equal(board1, board.get_board())
print('test2')
board = ChessBoard('./images/tests/2.png')
npt.assert_equal(board2, board.get_board())
print('test3')
board = ChessBoard('./images/tests/3.png')
npt.assert_equal(board3, board.get_board())
print('test4')
board = ChessBoard('./images/tests/4.png')
npt.assert_equal(board4, board.get_board())
print('test5')
