Ejemplo n.º 1
0
class ChessWindow(QMainWindow):
    def __init__(self, windowsize):
        super().__init__()
        self.windowsize = windowsize
        self.figure_size = int(board_dimension/8)
        self.chessboard = QSvgWidget('images/Chess_Board.svg')
        self.text = QLabel()
        self.pc_enemy_text = QLabel()
        self.win_text = QLabel()
        self.figures = [[0]*8 for i in range(8)]
        self.initUI()
        self.timer = QTimer()
        self.timer.timeout.connect(self.recursive_enemy)
        self.timer.start(1000)

    def initUI(self):
        self.setFixedSize(self.windowsize)
        self.setWindowFlags(Qt.CustomizeWindowHint | Qt.FramelessWindowHint)

        widget = QWidget()
        self.setCentralWidget(widget)

        if current_player == 1:
            self.text.setText('Current player: White')
        else:
            self.text.setText('Current player: Red')


        self.text.setFont(QFont('SansSerif', 25))
        self.text.setGeometry(QRect(board_dimension + offset_x + 50, offset_y, 500, 100))
        self.text.setParent(widget)

        self.win_text.setFont(QFont('SansSerif', 25))
        self.win_text.setGeometry(QRect(board_dimension + offset_x + 50, offset_y + 100, 500, 100))
        self.win_text.setParent(widget)

        if recursive_enemy:
            self.pc_enemy_text.setText('PC Enemy: ON')
            self.pc_enemy_text.setFont(QFont('SansSerif', 25))
            self.pc_enemy_text.setGeometry(QRect(board_dimension + offset_x + 50, offset_y + 50, 500, 100))

        self.pc_enemy_text.setParent(widget)

        self.chessboard.setGeometry(offset_x, offset_y, board_dimension, board_dimension)
        self.chessboard.setParent(widget)

        for x in range(0, 8):
            for y in range(0, 8):
                red_color = QGraphicsColorizeEffect()
                red_color.setColor(QColor(255, 0, 0))
                found = False
                # pawns
                if abs(Game.get_board()[x][y]) == 1:
                    new_figure = DragFigure('images/Chess_plt45.svg')
                    found = True
                # towers
                elif abs(Game.get_board()[x][y]) == 2:
                    new_figure = DragFigure('images/Chess_rlt45.svg')
                    found = True
                # rooks
                elif abs(Game.get_board()[x][y]) == 3:
                    new_figure = DragFigure('images/Chess_nlt45.svg')
                    found = True
                # bishops
                elif abs(Game.get_board()[x][y]) == 4:
                    new_figure = DragFigure('images/Chess_blt45.svg')
                    found = True
                # kings
                elif abs(Game.get_board()[x][y]) == 5:
                    new_figure = DragFigure('images/Chess_klt45.svg')
                    found = True
                # queens
                elif abs(Game.get_board()[x][y]) == 6:
                    new_figure = DragFigure('images/Chess_qlt45.svg')
                    found = True

                if found:
                    if Game.get_board()[x][y] < 0:
                        new_figure.setGraphicsEffect(red_color)
                    self.figures[x][y] = new_figure
                    new_figure.setGeometry(x * self.figure_size + offset_x, y * self.figure_size + offset_y, self.figure_size, self.figure_size)
                    new_figure.setParent(widget)

    def recursive_enemy(self):
        if current_player == -1:
            if recursive_enemy:
                print('Enemy turn')
                if not Game.finished(Game.get_board(), current_player):
                    print('Evaluating best move')
                    best_move = recursive_evaluation(Game.get_board(), current_player, current_player)
                    print('Best move found')
                    print(best_move)
                    self.move_figure(best_move)
                else:
                    reward_ai = Game.reward(Game.get_board(), current_player)
                    reward_human = Game.reward(Game.get_board(), -current_player)
                    self.pc_enemy_text.setText('Game finished!')
                    if reward_ai == 0 and reward_human == 0:
                        self.win_text.setText('Winner: Draw')
                    elif reward_ai == -1:
                        self.win_text.setText('Gratulation, Sieg!')
                    else:
                        self.win_text.setText('Schade, verloren.')
                    print('Game finished!')
            elif random_enemy:
                if not Game.finished(Game.get_board(), current_player):
                    print('Random move search')
                    move = random_move(Game.get_board(), current_player, current_player)
                    print('Random move found')
                    print(move)
                    self.move_figure(move)
                else:
                    reward_ai = Game.reward(Game.get_board(), current_player)
                    reward_human = Game.reward(Game.get_board(), -current_player)
                    self.pc_enemy_text.setText('Game finished!')
                    if reward_ai == 0 and reward_human == 0:
                        self.win_text.setText('Winner: Draw')
                    elif reward_ai == -1:
                        self.win_text.setText('Winner: Human')
                    else:
                        self.win_text.setText('Winner: AI')
                    self.pc_enemy_text.setText('Game finished!')


    def move_figure(self, move):
        global current_player
        global Game

        if -1 < move.x < 8 and -1 < move.y < 8 and -1 < move.x_new < 8 and -1 < move.y_new < 8:
            valid_moves = Game.get_valid_actions(Game.get_board(), current_player)

            new_board = deepcopy(Game.get_board())
            pawn_to_queen = False
            if current_player == 1 and move.y_new == 7 and new_board[move.x][move.y] == 1:
                new_board[move.x_new][move.y_new] = 6
                pawn_to_queen = True
            elif current_player == -1 and move.y_new == 0 and new_board[move.x][move.y] == -1:
                new_board[move.x_new][move.y_new] = -6
                pawn_to_queen = True
            else:
                new_board[move.x_new][move.y_new] = new_board[move.x][move.y]
            new_board[move.x][move.y] = 0

            valid_move = False
            for action in valid_moves:
                if action == new_board:
                    print('Valid Move!')
                    valid_move = True

            if valid_move:
                goal_value = Game.get_board()[move.x_new][move.y_new]
                goal_position = QPoint(move.x_new * self.figure_size + offset_x, move.y_new * self.figure_size + offset_y)
                if np.sign(goal_value) != current_player and goal_value != 0:
                    self.figures[move.x_new][move.y_new].move(-10000, -1000)
                    #self.parent().childAt(goal_position).move(-10000, -1000)

                move.execute_move()

                if pawn_to_queen:
                    self.figures[move.x][move.y].load('images/Chess_qlt45.svg')

                self.figures[move.x][move.y].setGeometry(goal_position.x(), goal_position.y(), self.figure_size, self.figure_size)

                self.figures[move.x_new][move.y_new] = self.figures[move.x][move.y]
                self.figures[move.x][move.y] = 0

                if current_player == 1:
                    self.centralWidget().childAt(QPoint(board_dimension + offset_x + 50, offset_y)).setText('Current player: White')
                else:
                    self.centralWidget().childAt(QPoint(board_dimension + offset_x + 50, offset_y)).setText('Current player: Red')
        else:
            print('Invalid move!')