コード例 #1
0
class GameViewCLI():
    """
    A class used to show the view in CLI
    """
    def __init__(self):
        self.gc = GameController()
        self.board_size = 9
        self.board = [[None for i in range(self.board_size)]
                      for j in range(self.board_size)]

    def start_game_2_players(self):
        """
        Start the game in 2 players mode (no AI)
        To play use these command:
        "exit" : exit the game
        action_key : input the action key stated in the command line.
        """
        state = self.gc.state
        while (not AIElements.is_over(state)):
            pprint(AIElements.get_state_dict(state))
            collected_action = AIElements.get_possible_action(state)
            print("List of Action : ")
            pprint(collected_action)
            self.gc.debug_print_board(state)
            print("Mana (White, Black) = " +
                  str(AIElements.get_players_mana(state)))
            print("Rune List:")
            print(AIElements.get_rune_information(state))
            inp = input("command : ")
            if inp in collected_action.keys():
                state = AIElements.result_function(state,
                                                   collected_action[inp])
            if inp == 'exit':
                break

    def start_game_2_experimental_(self):
        """
        Start the game in 2 players mode (no AI)
        To play use these command:
        "exit" : exit the game
        action_key : input the action key stated in the command line.
        """
        returned_params = self.gc.play_with_two_players_start()
        returned_task_controller = returned_params['task']

        while (not returned_task_controller == "END_GAME"):
            print(returned_task_controller)
            self.parse_returned_params_change_player(returned_params)
            pprint(pd.DataFrame(self.board))
            pprint(self.possible_action)
            pprint(self.rune_list)
            pprint(self.player_list)
            inp = input("command : ")
            if inp in self.possible_action_keys:
                self.gc.receive_input_action_play(inp,
                                                  self.possible_action[inp])
                returned_params = self.gc.get_whattodo_view()
                returned_task_controller = returned_params['task']
            elif inp == 'exit':
                break
            else:
                print("Wrong Input")

    def start_game_ai_experimental_(self):
        """
        Start the game in 2 players mode (no AI)
        To play use these command:
        "exit" : exit the game
        action_key : input the action key stated in the command line.
        """
        # returned_params = self.gc.play_with_two_players_start()
        returned_params = self.gc.play_with_ai_white()

        returned_task_controller = returned_params['task']

        while (not returned_task_controller == "END_GAME"):
            print(returned_task_controller)
            if returned_task_controller == 'CHANGE_PLAYER':
                self.parse_returned_params_change_player(returned_params)
                pd.options.display.max_columns = 10
                display(pd.DataFrame(self.board))
                pprint(self.possible_action)
                pprint(self.rune_list)
                pprint(self.player_list)
            elif returned_task_controller == 'AI_MOVE':
                self.parse_returned_params_ai_move(returned_params)
                if 'end' in returned_params:
                    break

                print("AI MOVE")
                pprint(returned_params['ai_action'])
                pprint(pd.DataFrame(self.board))
                print("----")
                self.parse_returned_params_change_player(returned_params)
                pprint(pd.DataFrame(self.board))
                pprint(self.possible_action)
                pprint(self.rune_list)
                pprint(self.player_list)
            inp = input("command : ")
            if inp in self.possible_action_keys:
                self.gc.receive_input_action_play(inp,
                                                  self.possible_action[inp])
                returned_params = self.gc.get_whattodo_view()
                returned_task_controller = returned_params['task']

            elif inp == 'exit':
                break
            else:
                print("Wrong Input")

    def parse_returned_params_ai_move(self, returned_params):
        self.board = [[None for i in range(self.board_size)]
                      for j in range(self.board_size)]

        # Prev state
        self.black_king = returned_params['prev_state']['black_king']
        self._pawn_write_to_board(self.black_king)
        self.white_king = returned_params['prev_state']['white_king']
        self._pawn_write_to_board(self.white_king)

        self.black_pawn_list = returned_params['prev_state']['black_pawn_list']
        for black_pawn in self.black_pawn_list:
            self._pawn_write_to_board(black_pawn)

        self.white_pawn_list = returned_params['prev_state']['white_pawn_list']
        for white_pawn in self.white_pawn_list:
            self._pawn_write_to_board(white_pawn)

        self.player_list = returned_params['prev_state']['player_list']
        self.rune_list = returned_params['prev_state']['rune_list']
        for rune in self.rune_list:
            self._rune_write_to_board(rune)

    def parse_returned_params_change_player(self, returned_params):
        self.board = [[None for i in range(self.board_size)]
                      for j in range(self.board_size)]
        self.black_king = returned_params['state']['black_king']
        self._pawn_write_to_board(self.black_king)
        self.white_king = returned_params['state']['white_king']
        self._pawn_write_to_board(self.white_king)

        self.black_pawn_list = returned_params['state']['black_pawn_list']
        for black_pawn in self.black_pawn_list:
            self._pawn_write_to_board(black_pawn)

        self.white_pawn_list = returned_params['state']['white_pawn_list']
        for white_pawn in self.white_pawn_list:
            self._pawn_write_to_board(white_pawn)

        self.player_list = returned_params['state']['player_list']
        self.rune_list = returned_params['state']['rune_list']
        for rune in self.rune_list:
            self._rune_write_to_board(rune)
        self.possible_action = returned_params['possible_action']
        self.possible_action_keys = returned_params['possible_action'].keys()

    def _rune_write_to_board(self, rune):
        self.board[rune['y']][rune['x']] = 'Runeeeeee'

    def _pawn_write_to_board(self, pawn):
        self.board[pawn['y']][pawn['x']] = pawn['pawn_type'][0:2] + 'i' \
                                                        + str(pawn['pawn_index']) \
                                                        + 'a' \
                                                        + str(pawn['atk']) \
                                                        + 'h' \
                                                        + str(pawn['hp']) \
                                                        + 'p' \
                                                        + str(pawn['step']) \
                                                        + 't' \
                                                        + str(pawn['status'])[0:2]

    def one_action(self, list_action):
        """
        Concatenate all list of actions to become one list

        ...

        Attributes
        ----------
        list_action : list
            a list of actions of Kings, Players, and Pawns

        Returns
        -------
        list
            a concatenated all list of actions.
        """
        action_list_completed = {}
        for act in list_action:
            if 'action' in act and len(act['action']) > 0:
                for key, value in act['action'].items():
                    action_list_completed[key] = value
        return action_list_completed
コード例 #2
0
class ViewGUI(QWidget):
    # TODO Add AI handle
    def __init__(self):
        self.counter_debug = 0
        super().__init__()
        self.gc = GameController()
        self.initUI()
        self.activate_coor = []  # tuple x,y
        self.move_coor = []
        self.atk_coor = []
        self.INACTIVE_PAWN_CSS = "background-color: #9AAC41;"
        self.ACTIVE_PAWN_CSS = "background-color: #E1FE57"
        self.ACTIVATE_PAWN_CSS = "background-color: green; color: white; font-weight: 500;"
        self.TILE_MOVE_CSS = "background-color: #53F399;"
        self.TILE_ATK_CSS = "background-color: #FF3500;"
        self.PROMOTE_PAWN_CSS = "background-color: #2e00ff; color: white;"

    def button_two_players_clicked(self):
        sender = self.sender()
        returned_params = self.gc.play_with_two_players_start()
        returned_task_controller = returned_params['task']
        if returned_task_controller == "END_GAME":
            self.task = "END GAME"
        else:
            self.clear_all_button_board()
            self.reset_board_two_players(returned_params)
            self.parse_possible_action()

    def button_ai_white_vs_players_clicked(self):
        sender = self.sender()
        returned_params = self.gc.play_with_ai_white()
        returned_task_controller = returned_params['task']
        if returned_task_controller == "END_GAME":
            self.task = "END GAME"
        else:
            self.clear_all_button_board()
            self.reset_board_two_players(returned_params)
            self.parse_possible_action()

    def decide_status_board_css(self, y, x):
        return self.ACTIVE_PAWN_CSS if self.list_btn_board[y][
            x].active_status_pawn else self.INACTIVE_PAWN_CSS

    def parse_possible_action(self):

        self.counter_debug += 1
        self.activate_coor = []
        self.promote_coor = []
        self.move_coor = []
        self.atk_coor = []
        # pprint(self.possible_action)
        for key, value in self.possible_action.items():
            if value['action'] == 'activate':
                self.btn_activate.setEnabled(True)
                self.list_btn_board[value['pawn_y']][
                    value['pawn_x']].set_activate_key(key)
                self.btn_activate.clicked.connect(
                    lambda: self.enable_activate_possible_action_button())
                self.activate_coor.append((value['pawn_x'], value['pawn_y']))
            if value['action'] == 'move':
                self.move_coor.append({"pawn_x" : value['pawn_x'],\
                                        "pawn_y" : value['pawn_y'],\
                                        "end_x" : value['x_end'],\
                                        "end_y" : value['y_end'],
                                        "move_key" : key})
                pawn_x = value['pawn_x']
                pawn_y = value['pawn_y']
                end_x = value['x_end']
                end_y = value['y_end']
                move_key = key
                self.list_btn_board[pawn_y][pawn_x].setEnabled(True)
                self.list_btn_board[pawn_y][pawn_x].add_move_list(
                    end_y, end_x, key)
                self.list_btn_board[pawn_y][pawn_x].clicked.connect(
                    lambda: self.enable_move())
            if value['action'] == 'attack':
                pawn_x = value['pawn_x']
                pawn_y = value['pawn_y']
                end_x = value['x_end']
                end_y = value['y_end']
                move_key = key
                self.list_btn_board[pawn_y][pawn_x].setEnabled(True)
                self.atk_coor.append({"pawn_x" : pawn_x,\
                                        "pawn_y" : pawn_y,\
                                        "end_x" : end_x,\
                                        "end_y" : end_y,\
                                        "move_key" : key})
                self.list_btn_board[pawn_y][pawn_x].add_attack_list(
                    end_y, end_x, key)
                # print(self.list_btn_board[pawn_y][pawn_x].attack_list)
                self.list_btn_board[pawn_y][pawn_x].clicked.connect(
                    lambda: self.enable_attack())

            if value['action'] == 'promote':
                pawn_x = value['pawn_x']
                pawn_y = value['pawn_y']
                move_key = key
                choice = value['promoted_choice']
                self.list_btn_board[pawn_y][pawn_x].add_promote_list(
                    move_key, choice)
                self.promote_coor.append((pawn_x, pawn_y))
                self.btn_evolve.clicked.connect(
                    lambda: self.enable_promote_possible_action_button())
                self.btn_evolve.setEnabled(True)

            if value['action'] == 'skip':
                self.gc.receive_input_action_play("skip",
                                                  self.possible_action["skip"])
                returned_params = self.gc.get_whattodo_view()
                self.returned_params = returned_params
                returned_task_controller = returned_params['task']
                self.clear_all_button_board()
                self.reset_board_two_players(returned_params)
                self.btn_activate.setEnabled(False)
                self.btn_evolve.setEnabled(False)

                self.parse_possible_action()

    def enable_promote_possible_action_button(self):
        if len(self.promote_coor) > 0:
            self.btn_activate.setEnabled(False)
            self.disable_all_pawn_button()
            for coor in self.promote_coor:
                try:
                    self.list_btn_board[coor[1]][coor[0]].clicked.disconnect()
                except Exception:
                    pass
                self.list_btn_board[coor[1]][coor[0]].setEnabled(True)
                self.list_btn_board[coor[1]][coor[0]].setStyleSheet(
                    self.PROMOTE_PAWN_CSS)
                self.list_btn_board[coor[1]][coor[0]].clicked.connect(
                    self.button_promote_pawn)
            self.btn_evolve.setText("Cancel Evolve")
            try:
                self.btn_evolve.clicked.disconnect()
            except Exception:
                pass
            self.btn_evolve.clicked.connect(
                lambda: self.disable_promote_possible_action_button())

    def disable_promote_possible_action_button(self):
        for coor in self.promote_coor:
            self.list_btn_board[coor[1]][coor[0]].setEnabled(False)
            self.list_btn_board[coor[1]][coor[0]].setStyleSheet(
                self.decide_status_board_css(coor[1], coor[0]))
            try:
                self.list_btn_board[coor[1]][coor[0]].clicked.disconnect()
            except Exception:
                pass
        self.btn_evolve.setText("Evolve")
        self.parse_possible_action()

    def button_promote_pawn(self):
        # print(self.sender().promote_dict.keys())
        items = self.sender().promote_dict.keys()
        item, okPressed = QInputDialog.getItem(self, "Select Promote",
                                               "Promote To:", items, 0, False)
        if item and okPressed:
            choice = self.sender().promote_dict[item]
            self.gc.receive_input_action_play(choice,
                                              self.possible_action[choice])
            returned_params = self.gc.get_whattodo_view()
            self.returned_params = returned_params
            returned_task_controller = returned_params['task']
            self.clear_all_button_board()
            self.reset_board_two_players(returned_params)
            self.btn_activate.setEnabled(False)
            self.btn_evolve.setEnabled(False)

            self.parse_possible_action()

    def enable_attack(self):
        sender = self.sender()

        self.disable_all_pawn_button()
        sender.setEnabled(True)
        self.btn_activate.setEnabled(False)
        self.btn_evolve.setEnabled(False)

        for tuple_range in sender.attack_list:
            self.list_btn_board[tuple_range[1]][tuple_range[0]].setEnabled(
                True)
            self.list_btn_board[tuple_range[1]][tuple_range[0]].setStyleSheet(
                self.TILE_ATK_CSS)
            self.list_btn_board[tuple_range[1]][tuple_range[0]].set_attack_key(
                tuple_range[2])
            self.list_btn_board[tuple_range[1]][tuple_range[
                0]].clicked.connect(lambda: self.button_attack_pawn())
        sender.clicked.connect(lambda: self.disable_attack())

    def disable_attack(self):
        sender = self.sender()
        for tuple_range in sender.attack_list:
            try:
                self.list_btn_board[tuple_range[1]][
                    tuple_range[0]].disconnect()
            except Exception:
                pass
            self.list_btn_board[tuple_range[1]][tuple_range[0]].setEnabled(
                False)
        try:
            sender.clicked.disconnect()
        except Exception:
            pass
        for tuple_range in sender.attack_list:
            self.list_btn_board[tuple_range[1]][tuple_range[0]].setStyleSheet(
                "")
        sender.clear_attack_list()
        for tuple_range in sender.move_list:
            try:
                self.list_btn_board[tuple_range[1]][
                    tuple_range[0]].disconnect()
            except Exception:
                pass
            self.list_btn_board[tuple_range[1]][tuple_range[0]].setEnabled(
                False)
        try:
            sender.clicked.disconnect()
        except Exception:
            pass
        for tuple_range in sender.move_list:
            self.list_btn_board[tuple_range[1]][tuple_range[0]].setStyleSheet(
                "")
        sender.clear_move_list()
        self.parse_possible_action()

    def button_attack_pawn(self):
        sender = self.sender()
        self.gc.receive_input_action_play(
            sender.attack_key, self.possible_action[sender.attack_key])
        returned_params = self.gc.get_whattodo_view()
        self.returned_params = returned_params
        returned_task_controller = returned_params['task']
        self.clear_all_button_board()
        self.reset_board_two_players(returned_params)
        self.btn_activate.setEnabled(False)
        self.btn_evolve.setEnabled(False)
        self.parse_possible_action()

    def disable_all_pawn_button(self):
        for move in self.move_coor:
            self.list_btn_board[move['pawn_y']][move['pawn_x']].setEnabled(
                False)
        for move in self.atk_coor:
            self.list_btn_board[move['pawn_y']][move['pawn_x']].setEnabled(
                False)

    def enable_move(self):
        sender = self.sender()
        # try: sender.clicked.disconnect()
        # except Exception: pass
        self.disable_all_pawn_button()
        sender.setEnabled(True)
        self.btn_activate.setEnabled(False)
        self.btn_evolve.setEnabled(False)

        for tuple_range in sender.move_list:
            self.list_btn_board[tuple_range[1]][tuple_range[0]].setEnabled(
                True)
            self.list_btn_board[tuple_range[1]][tuple_range[0]].setStyleSheet(
                self.TILE_MOVE_CSS)
            self.list_btn_board[tuple_range[1]][tuple_range[0]].set_move_key(
                tuple_range[2])
            self.list_btn_board[tuple_range[1]][tuple_range[
                0]].clicked.connect(lambda: self.button_move_pawn())
        sender.clicked.connect(lambda: self.disable_attack())

    def button_move_pawn(self):
        sender = self.sender()
        self.gc.receive_input_action_play(
            sender.move_key, self.possible_action[sender.move_key])
        returned_params = self.gc.get_whattodo_view()
        print(type(returned_params))

        self.returned_params = returned_params
        returned_task_controller = returned_params['task']
        self.clear_all_button_board()
        self.reset_board_two_players(returned_params)
        self.btn_activate.setEnabled(False)
        self.btn_evolve.setEnabled(False)
        self.parse_possible_action()

    def disable_move(self):
        sender = self.sender()
        for tuple_range in sender.move_list:
            try:
                self.list_btn_board[tuple_range[1]][
                    tuple_range[0]].disconnect()
            except Exception:
                pass
            self.list_btn_board[tuple_range[1]][tuple_range[0]].setEnabled(
                False)
        try:
            sender.clicked.disconnect()
        except Exception:
            pass
        for tuple_range in sender.move_list:
            self.list_btn_board[tuple_range[1]][tuple_range[0]].setStyleSheet(
                "")
        sender.clear_move_list()
        self.parse_possible_action()

    def enable_activate_possible_action_button(self):
        self.btn_evolve.setEnabled(False)

        if len(self.activate_coor) > 0:
            for coor in self.activate_coor:
                self.list_btn_board[coor[1]][coor[0]].setEnabled(True)
                self.list_btn_board[coor[1]][coor[0]].setStyleSheet(
                    self.ACTIVATE_PAWN_CSS)
                self.list_btn_board[coor[1]][coor[0]].clicked.connect(
                    self.button_activate_pawn)
            self.btn_activate.setText("Cancel Activate")
            self.disable_all_pawn_button()
            try:
                self.btn_activate.clicked.disconnect()
            except Exception:
                pass
            self.btn_activate.clicked.connect(
                lambda: self.disable_activate_possible_action_button())

    def disable_activate_possible_action_button(self):
        for coor in self.activate_coor:
            self.list_btn_board[coor[1]][coor[0]].setEnabled(False)
            self.list_btn_board[coor[1]][coor[0]].setStyleSheet(
                self.decide_status_board_css(coor[1], coor[0]))
            try:
                self.list_btn_board[coor[1]][coor[0]].clicked.disconnect()
            except Exception:
                pass
        self.btn_activate.setText("Activate")
        self.parse_possible_action()

    def button_activate_pawn(self):
        for coor in self.activate_coor:
            try:
                self.list_btn_board[coor[1]][coor[0]].clicked.disconnect()
            except Exception:
                pass
        key_action = self.sender().activate_key
        self.gc.receive_input_action_play(key_action,
                                          self.possible_action[key_action])
        returned_params = self.gc.get_whattodo_view()
        self.returned_params = returned_params
        returned_task_controller = returned_params['task']
        self.reset_board_two_players(returned_params)
        self.btn_activate.setEnabled(False)
        self.btn_evolve.setEnabled(False)
        self.parse_possible_action()

    def clear_all_button_board(self):
        self.btn_activate.setText("Activate")
        self.btn_evolve.setText("Evolve")
        for board_rows in self.list_btn_board:
            for board in board_rows:
                try:
                    board.clicked.disconnect()
                except Exception:
                    pass
                board.clear_move_list()
                board.clear_attack_list()
                board.clear_promote_list()
                board.setEnabled(False)
                board.move_key = None
                board.setText("")
                board.setStyleSheet("")

    def color_check_mana(self, mana, label):
        if mana == 10:
            label.setStyleSheet("background-color: #fe0081;")
        elif mana > 4:
            label.setStyleSheet("background-color: #07fe00;")
        elif mana > 2:
            label.setStyleSheet("background-color: #e0e728;")
        else:
            label.setStyleSheet("")

    def check_task(self, returned_params):
        pass

    def reset_board_two_players(self, returned_params):
        self.clear_all_button_board()
        # pprint(returned_params)

        # TODO put to check task function
        if returned_params['task'] == 'END_GAME':
            QMessageBox.about(self, "Title", "Game has ended")
            sys.exit()

        self.mana_0 = returned_params['state']['player_list'][0]['mana']
        self.mana_1 = returned_params['state']['player_list'][1]['mana']
        self.mn0.setText(str(self.mana_0))
        self.mn1.setText(str(self.mana_1))
        self.color_check_mana(self.mana_0, self.mn0)
        self.color_check_mana(self.mana_1, self.mn1)

        self.black_king = returned_params['state']['black_king']
        if not self.black_king['dead']:
            self._pawn_write_to_board(self.black_king)
        self.white_king = returned_params['state']['white_king']
        if not self.white_king['dead']:
            self._pawn_write_to_board(self.white_king)

        self.black_pawn_list = returned_params['state']['black_pawn_list']
        for black_pawn in self.black_pawn_list:
            if not black_pawn['dead']:
                self._pawn_write_to_board(black_pawn)

        self.white_pawn_list = returned_params['state']['white_pawn_list']
        for white_pawn in self.white_pawn_list:
            if not white_pawn['dead']:
                self._pawn_write_to_board(white_pawn)

        self.player_list = returned_params['state']['player_list']
        self.rune_list = returned_params['state']['rune_list']
        for rune in self.rune_list:
            self._rune_write_to_board(rune)
        self.possible_action = returned_params['possible_action']
        self.possible_action_keys = returned_params['possible_action'].keys()

    def _rune_write_to_board(self, rune):
        self.list_btn_board[rune['y']][rune['x']].set_text_with_params(
            rune, "rune")

    def _pawn_write_to_board(self, pawn):
        self.list_btn_board[pawn['y']][pawn['x']].set_text_with_params(
            pawn, "pawn")
        self.list_btn_board[pawn['y']][pawn['x']].set_active_status_pawn(
            pawn['status'])
        self.list_btn_board[pawn['y']][pawn['x']].setStyleSheet(
            self.decide_status_board_css(pawn['y'], pawn['x']))

    def initUI(self):
        main_layout = QHBoxLayout()
        board_layout = self.ui_board()
        mana_info = self.ui_info_mana()
        special_ui_button = self.ui_button_special()
        info_game = self.ui_info_static()
        info_layout = QVBoxLayout()
        info_layout.addLayout(mana_info)
        info_layout.addLayout(special_ui_button)
        info_layout.addLayout(info_game)

        self.button_two_players = QPushButton("Play Two Players")
        self.button_two_players.clicked.connect(
            self.button_two_players_clicked)
        self.button_ai_white_player = QPushButton("AI White vs Human")
        self.button_ai_white_player.clicked.connect(
            self.button_ai_white_vs_players_clicked)

        main_layout.addWidget(self.button_two_players)
        main_layout.addWidget(self.button_ai_white_player)

        main_layout.addLayout(board_layout)
        main_layout.addLayout(info_layout)

        self.setLayout(main_layout)
        self.move(50, 50)
        self.show()

    def ui_info_mana(self):
        lbl1 = QLabel('Player White', self)
        lbl2 = QLabel('Player Black', self)
        self.mn0 = QLabel('5', self)
        self.mn1 = QLabel('5', self)
        self.label_task = QLabel("STATUS", self)
        self.task = QLabel('WAIT', self)
        grid = QGridLayout()
        grid.addWidget(lbl1, 0, 0)
        grid.addWidget(lbl2, 0, 1)
        grid.addWidget(self.mn0, 1, 0)
        grid.addWidget(self.mn1, 1, 1)
        grid.addWidget(self.label_task, 2, 0)
        grid.addWidget(self.task, 2, 1)
        return grid

    def ui_button_special(self):
        hbox = QVBoxLayout()
        self.btn_evolve = QPushButton("Evolve")
        self.btn_evolve.setEnabled(False)
        self.btn_activate = QPushButton("Activate")
        self.btn_activate.setEnabled(False)

        hbox.addWidget(self.btn_evolve)
        hbox.addWidget(self.btn_activate)
        return hbox

    def ui_info_static(self):
        grid = QVBoxLayout()
        lbl1 = QLabel('3 = Activate', self)
        lbl2 = QLabel('5 = Promote 2nd tier', self)
        lbl3 = QLabel('10 = Promote to Queen', self)
        grid.addWidget(QLabel("Information"))
        grid.addWidget(lbl1)
        grid.addWidget(lbl2)
        grid.addWidget(lbl3)
        return grid

    def ui_board(self, size=9):
        grid = QGridLayout()
        grid.setHorizontalSpacing(0)
        grid.setVerticalSpacing(0)

        i, j = 0, 0
        self.list_btn_board = [[None for i in range(9)] for j in range(9)]
        for k in range(size):
            for l in range(size):
                btn_board = BoardButton()
                btn_board.setEnabled(False)
                btn_board.setFixedSize(100, 90)
                self.list_btn_board[k][l] = btn_board
                grid.addWidget(btn_board, k, l)
        return grid