def captured(board, move, player): opponent_pieces = SeegaRules._get_opponent_neighbours( board, move, player) captured_pieces = list() if opponent_pieces: for piece in opponent_pieces: if piece != (board.board_shape[0] // 2, board.board_shape[1] // 2): if piece[0] == move[0]: if piece[1] < move[1] and 0 <= piece[1] - 1 < board.board_shape[0] and \ board.get_cell_color((piece[0], piece[1] - 1)) == Color(player): captured_pieces.append(piece) if piece[1] > move[1] and 0 <= piece[1] + 1 < board.board_shape[0] and \ board.get_cell_color((piece[0], piece[1] + 1)) == Color(player): captured_pieces.append(piece) if piece[1] == move[1]: if piece[0] < move[0] and 0 <= piece[0] - 1 < board.board_shape[0] and \ board.get_cell_color((piece[0] - 1, piece[1])) == Color(player): captured_pieces.append(piece) if piece[0] > move[0] and 0 <= piece[0] + 1 < board.board_shape[0] and \ board.get_cell_color((piece[0] + 1, piece[1])) == Color(player): captured_pieces.append(piece) return captured_pieces
def __init__(self, node, parent, attrs): self.content = '' self.node = node # note: circular reference self.parent = parent self._attrs = {} for key, value in attrs.items(): if key in ('x', 'xpadding', 'y', 'ypadding'): value = int(value) elif key == 'width' and not value.endswith('%'): x1 = int(attrs.get('x', 0)) x2 = int(attrs.get('x', 0)) + int(value) value = x2 - x1 elif key == 'height' and not value.endswith('%'): y1 = int(attrs.get('y', 0)) y2 = int(attrs.get('y', 0)) + int(value) value = y2 - y1 elif key in ('radius', 'size', 'spacing'): value = int(value) elif key.find('color') != -1: value = Color(value) elif key.find('font') != -1: value = Font(value) value.size = int(value.size) self._attrs[str(key).replace('-', '_')] = value self._children = []
def get_player_actions(state, player, reward_move=False): """Provide for a player and at a state all of his possible actions. Args: state (YoteState): A state object from the yote game. player (int): The number of the player making the move. reward_move (bool, optional): True if the move is a stealing move. Defaults to False. Returns: List[YoteAction]: Contains all possible actions for a player at the given state. """ actions = [] board = state.get_board() empty_cells = board.get_all_empty_cells() opponent_pieces = board.get_player_pieces_on_board(Color(player * -1)) if reward_move: for piece in opponent_pieces: actions.append(YoteAction(action_type=YoteActionType.STEAL_FROM_BOARD, at=piece)) if state.in_hand[player * -1] > 0: actions.append(YoteAction(action_type=YoteActionType.STEAL_FROM_HAND)) return actions else: if empty_cells and state.in_hand[player] > 0: for cell in empty_cells: actions.append(YoteAction(action_type=YoteActionType.ADD, to=cell)) player_pieces = board.get_player_pieces_on_board(Color(player)) for piece in player_pieces: moves = YoteRules.get_effective_cell_moves(state, piece, player) if moves: for move in moves: actions.append(YoteAction(action_type=YoteActionType.MOVE, at=piece, to=move)) return actions
def make_move(state, action, player): # they are in the state object """Transform the action of the player to a move. The move is made and the reward computed. Args: state (YoteState): A state object from the yote game. action (Action): An action object containing the move. player (int): The number of the player making the move. rewarding_move (bool, optional): True if the move is a stealing move. Defaults to False. Returns: (next_state, done, next_is_reward): Gives the next state of the game along with the game status and the type of the next step. """ board = state.get_board() json_action = action.get_json_action() action = action.get_action_as_dict() phase = state.phase reward = 0 if phase == 1 and action['action_type'] == SeegaActionType.ADD: state.in_hand[player] -= 1 board.fill_cell(action['action']['to'], Color(player)) elif phase == 2 and action['action_type'] == SeegaActionType.MOVE: at = action['action']['at'] to = action['action']['to'] captured_pieces = SeegaRules.captured(board, to, player) state.captured = captured_pieces board.empty_cell(at) board.fill_cell(to, Color(player)) if captured_pieces: reward = len(captured_pieces) state.boring_moves = 0 for piece in captured_pieces: board.empty_cell(piece) else: state.boring_moves += 1 state.set_board(board) state.score[player] += reward state.set_latest_player(player) state.set_latest_move(json_action) if phase == 1: if state.in_hand[player] == 0 and state.in_hand[player * -1] == 0: state.set_next_player(player) state.phase = 2 elif state.in_hand[player] != 0 and state.in_hand[player] % 2 != 0: state.set_next_player(player) elif state.in_hand[player] % 2 == 0: state.set_next_player(player * -1) elif phase == 2: if SeegaRules.is_player_stuck(state, player * -1): state.set_next_player(player) else: state.set_next_player(player * -1) done = SeegaRules.is_end_game(state) return state, done
def steal(self, state): board = state.get_board() empty_cells = board.get_all_empty_cells() me = board.get_player_pieces_on_board(Color(self.position)) opponents = board.get_player_pieces_on_board(Color(-self.position)) latest_move = state.get_latest_move() prior_cell = latest_move["action"]["to"] if len(opponents) > 0: # Protect just moved piece if (prior_cell[0] - 1, prior_cell[1]) in opponents: if (prior_cell[0] + 1, prior_cell[1]) in empty_cells: return YoteAction( action_type=YoteActionType.STEAL_FROM_BOARD, at=(prior_cell[0] - 1, prior_cell[1]), ) if (prior_cell[0] + 1, prior_cell[1]) in opponents: if (prior_cell[0] - 1, prior_cell[1]) in empty_cells: return YoteAction( action_type=YoteActionType.STEAL_FROM_BOARD, at=(prior_cell[0] + 1, prior_cell[1]), ) if (prior_cell[0], prior_cell[1] - 1) in opponents: if (prior_cell[0], prior_cell[1] + 1) in empty_cells: return YoteAction( action_type=YoteActionType.STEAL_FROM_BOARD, at=(prior_cell[0], prior_cell[1] - 1), ) if (prior_cell[0], prior_cell[1] + 1) in opponents: if (prior_cell[0], prior_cell[1] - 1) in empty_cells: return YoteAction( action_type=YoteActionType.STEAL_FROM_BOARD, at=(prior_cell[0], prior_cell[1] + 1), ) for cell in opponents: # Protect the other pieces if (((cell[0] - 1, cell[1]) in me and (cell[0] - 2, cell[1]) in empty_cells) or ((cell[0] + 1, cell[1]) in me and (cell[0] + 2, cell[1]) in empty_cells) or ((cell[0], cell[1] - 1) in me and (cell[0], cell[1] - 2) in empty_cells) or ((cell[0], cell[1] + 1) in me and (cell[0], cell[1] + 2) in empty_cells)): return YoteAction( action_type=YoteActionType.STEAL_FROM_BOARD, at=cell) return YoteAction(action_type=YoteActionType.STEAL_FROM_BOARD, at=opponents[0]) else: return YoteAction(action_type=YoteActionType.STEAL_FROM_HAND)
def get_player_actions(state, player): """Provide for a player and at a state all of his possible actions. Args: state (YoteState): A state object from the yote game. player (int, optional): True if the move is a stealing move. Defaults to False. Returns: List[YoteAction]: Contains all possible actions for a player at the given state. """ actions = [] phase = state.phase board = state.get_board() if phase == 1: empty_cells = board.get_all_empty_cells_without_center() if empty_cells and state.in_hand[player]: for cell in empty_cells: actions.append( SeegaAction(action_type=SeegaActionType.ADD, to=cell)) return actions elif phase == 2: player_pieces = board.get_player_pieces_on_board(Color(player)) for piece in player_pieces: moves = SeegaRules.get_effective_cell_moves(state, piece) if moves: for move in moves: actions.append( SeegaAction(action_type=SeegaActionType.MOVE, at=piece, to=move)) return actions
def __init__(self, color): super(AI, self).__init__(color) self.ME = color.value self.ME_color = color self.OTHER = -color.value self.OTHER_color = Color(-color.value) self.max_time = None self.remaining_time = None self.typical_time = None self.move_nb = 0 self.exploring_depth_limit = 1 self.absolute_max_depth = 1000 self.playing_barrier = False self.reached_win = False self.last_action = None self.explored_nodes = 0 self.state_evaluations = dict( ) # {state: (static_eval, dynamic_eval, dynamic_eval_depth) self.current_eval = 0 self.board_preferences = np.array([[60, 50, 99, 50, 60], [50, 31, 1, 33, 50], [99, 1, -1, 1, 99], [50, 11, 1, 13, 50], [60, 50, 99, 50, 60]])[::-1] self.highest_values_indices = [ np.unravel_index(i, self.board_preferences.shape) for i in np.argsort(self.board_preferences, axis=None) ][::-1]
def generate_bars(self, sizes): """ creates the bars if they aren't already, else updates them :param sizes: sizes of bars :return: """ bar_width = self.surface.get_rect().size[0] / self.size for i, y in enumerate(sizes): try: bar = self.bars[y] bar.position = Vector2D.custom(self.surface, i * bar_width, y - 1, inverty=True) continue except KeyError: bar = Rectangle(Vector2D.custom(self.surface, i * bar_width, y - 1, inverty=True), Vector2D(bar_width, y), color=Color.lerp(y / self.max, colors.RED, colors.GREEN, colors.BLUE) if self.color is None else self.color) self.bars[y] = bar
def is_legal_move(state, action, player): phase = state.phase action = action.get_action_as_dict() if state.get_next_player() == player: if phase == 1: if action[ 'action_type'] == SeegaActionType.ADD and state.in_hand[ player]: empty_cells = state.get_board().get_all_empty_cells() if empty_cells and action['action']['to'] in empty_cells \ and not state.get_board().is_center(action['action']['to']): return True elif phase == 2: if SeegaRules.is_player_stuck(state, player * -1): if action['action'][ 'at'] in SeegaRules.get_unstucked_piece( state, player * -1): return True return False if state.get_next_player() == player: if action['action_type'] == SeegaActionType.MOVE: if state.get_board().get_cell_color( action['action']['at']) == Color(player): effective_moves = SeegaRules.get_effective_cell_moves( state, action['action']['at']) if effective_moves and action['action'][ 'to'] in effective_moves: return True return False return False return False
def get_effective_cell_moves(state, cell, player): """Give the effective(Only the possible ones) moves a player can make regarding a piece on the board. Args: state (YoteState): The current game state. cell ((int, int)): The coordinates of the piece on the board. player (int): The number of the player making the move. Returns: List: A list containing all the coordinates where the piece can go. """ board = state.get_board() if board.is_cell_on_board(cell): possibles_moves = YoteRules._get_rules_possibles_moves(cell, board.board_shape) effective_moves = [] i, j = cell for move in possibles_moves: if board.is_empty_cell(move): effective_moves.append(move) elif board.get_cell_color(move) == Color(player * -1): k, l = move if i == k and j < l and board.is_empty_cell((i, j + 2)): effective_moves.append((i, j + 2)) elif i == k and l < j and board.is_empty_cell((i, j - 2)): effective_moves.append((i, j - 2)) elif j == l and i < k and board.is_empty_cell((i + 2, j)): effective_moves.append((i + 2, j)) elif j == l and k < i and board.is_empty_cell((i - 2, j)): effective_moves.append((i - 2, j)) return effective_moves
def _get_opponent_neighbours(board, cell, player): possibles_neighbours = SeegaRules._get_rules_possibles_moves(cell, board.board_shape) enemies = list() for neighbour in possibles_neighbours: if board.get_cell_color(neighbour) == Color(player * -1): enemies.append(neighbour) return enemies
def get_unstucked_piece(state, player): board = state.get_board() player_pieces = board.get_player_pieces_on_board(Color(player)) piece_to_move = set() for piece in player_pieces: opponent_pieces = SeegaRules._get_opponent_neighbours(board, piece, player) if len(opponent_pieces) > 0: for opp_piece in opponent_pieces: if len(SeegaRules.get_effective_cell_moves(state, opp_piece)) > 0: piece_to_move.add(opp_piece) return list(piece_to_move)
def is_legal_move(state, action, player, rewarding_move=False): # TODO: Update this function to an more # optimized one. """Check if an action is a legal move. Args: state (YoteState): A state object from the yote game. action (Action): An action object containing the move. player (int): The number of the player making the move. rewarding_move (bool, optional): True if the move is a stealing move. Defaults to False. Returns: bool: True is the move is a legal one and False if else. """ action = action.get_action_as_dict() if rewarding_move: if player == state.get_next_player() == state.get_latest_player(): if action['action_type'] == YoteActionType.STEAL_FROM_HAND and state.in_hand[player * -1] > 0: return True elif action['action_type'] == YoteActionType.STEAL_FROM_BOARD: opponent_piece = state.get_board().get_player_pieces_on_board(Color(player * -1)) if opponent_piece and action['action']['at'] in opponent_piece: return True return False else: if state.get_next_player() == player: if action['action_type'] == YoteActionType.ADD and state.in_hand[player] > 0: empty_cells = state.get_board().get_all_empty_cells() if empty_cells and action['action']['to'] in empty_cells: return True elif action['action_type'] == YoteActionType.MOVE: if state.get_board().get_cell_color(action['action']['at']) == Color(player): effective_moves = YoteRules.get_effective_cell_moves(state, action['action']['at'], player) if effective_moves and action['action']['to'] in effective_moves: return True return False return False
def bytesToBitmap(self, palette_b: bytes, icon_b: bytes) -> Image.Image: palette: list[Color] = Color.BGR555ToColors(palette_b) icon_data: list[int] = BytesHelper.bytesToBit4(icon_b) target: Image.Image = Image.new('RGB', (32, 32)) pixels = target.load() pixel_i: int = 0 for pixel_y in range(4): for pixel_x in range(4): for chunk_y in range(8): for chunk_x in range(8): pixels[chunk_x + pixel_x * 8, chunk_y + pixel_y * 8] = palette[ icon_data[pixel_i]].toTupleNoAlpha() pixel_i += 1 return target
# change this as necessary to change sorting algorithm # sorta = CocktailSort(bars.sizes[:]) # sorta = InsertionSort(bars.sizes[:]) # sorta = CycleSort(bars.sizes[:]) # sorta = QuickSort(bars.sizes[:], 0, len(bars.sizes) - 1) sorta = algorithms.MergeSort(bars.sizes[:]) # limit queue size to be safe ac = AlgorithmController(sorta, maxsize=10000) ac.start() # button to control algorithm flow flip_button = Button(Text('', color=colors.WHITE), size=Vector2D(70, 25), color=Color(0, 0, 0, 0), onclick=lambda _: should_sort.flip()) flip_button.position = Vector2D( Vector2D.center(screen.get_rect(), screen.get_rect().size).x - (flip_button.size.x / 2), 0) flip_button.onhover = Hover(BLACK_TEXT_WHITE_BACKGROUND, WHITE_TEXT_TRANSPARENT_BACKGROUND) def fbflip(val): flip_button.text.text = 'RUNNING' if val else 'STOPPED' fbflip(should_sort.get()) should_sort.on_flip = fbflip manager = WidgetManager([flip_button])
def provide(self, state): board = state.get_board() empty_cells = board.get_all_empty_cells() me = board.get_player_pieces_on_board(Color(self.position)) opponents = board.get_player_pieces_on_board(Color(-self.position)) available_moves = YoteRules.get_player_actions(state, self.position) def is_dangerous_cell(cell): if ((cell[0] - 1, cell[1]) in opponents and (cell[0] + 1, cell[1]) in empty_cells or (cell[0] + 1, cell[1]) in opponents and (cell[0] - 1, cell[1]) in empty_cells or (cell[0], cell[1] - 1) in opponents and (cell[0], cell[1] + 1) in empty_cells or (cell[0], cell[1] + 1) in opponents and (cell[0], cell[1] - 1) in empty_cells): return True else: return False if state.get_latest_player() == self.position: return self.steal(state) for cell in me: # Just take the opponents piece if (cell[0] - 1, cell[1]) in opponents: if (cell[0] - 2, cell[1]) in empty_cells: return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0] - 2, cell[1]), ) if (cell[0] + 1, cell[1]) in opponents: if (cell[0] + 2, cell[1]) in empty_cells: return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0] + 2, cell[1]), ) if (cell[0], cell[1] - 1) in opponents: if (cell[0], cell[1] - 2) in empty_cells: return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0], cell[1] - 2), ) if (cell[0], cell[1] + 1) in opponents: if (cell[0], cell[1] + 2) in empty_cells: return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0], cell[1] + 2), ) for cell in me: # just run away if (cell[0], cell[1] - 1) in opponents: if ((cell[0], cell[1] + 1) in empty_cells and (cell[0], cell[1] + 2) not in opponents and not ( (cell[0] - 1, cell[1] + 1) in opponents and cell[0] + 1, cell[1] + 1, ) in empty_cells or (cell[0] + 1, cell[1] + 1) in opponents and (cell[0] - 1, cell[1] + 1) in empty_cells): return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0], cell[1] + 1), ) if (cell[0] - 1, cell[1]) in opponents: if ((cell[0] + 1, cell[1]) in empty_cells and (cell[0] + 2, cell[1]) not in opponents and not ( (cell[0] + 1, cell[1] - 1) in opponents and cell[0] + 1, cell[1] + 1, ) in empty_cells or (cell[0] + 1, cell[1] + 1) in opponents and (cell[0] + 1, cell[1] - 1) in empty_cells): return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0] + 1, cell[1]), ) if (cell[0] + 1, cell[1]) in opponents: if ((cell[0] - 1, cell[1]) in empty_cells and (cell[0] - 2, cell[1]) not in opponents and not ( (cell[0] - 1, cell[1] - 1) in opponents and cell[0] - 1, cell[1] + 1, ) in empty_cells or (cell[0] - 1, cell[1] + 1) in opponents and (cell[0] - 1, cell[1] - 1) in empty_cells): return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0] - 1, cell[1]), ) if (cell[0], cell[1] + 1) in opponents: if ((cell[0], cell[1] - 1) in empty_cells and (cell[0], cell[1] - 2) not in opponents and not ( (cell[0] - 1, cell[1] - 1) in opponents and cell[0] + 1, cell[1] - 1, ) in empty_cells or (cell[0] + 1, cell[1] - 1) in opponents and (cell[0] - 1, cell[1] - 1) in empty_cells): return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0], cell[1] - 1), ) for cell in me: if (cell[0], cell[1] - 1) in empty_cells and ( cell[0], cell[1] - 2, ) not in opponents: if ((cell[0] + 1, cell[1] - 1) in opponents and (cell[0] - 1, cell[1] - 1) not in empty_cells or (cell[0] - 1, cell[1] - 1) in opponents and (cell[0] + 1, cell[1] - 1) not in empty_cells): return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0], cell[1] - 1), ) if (cell[0], cell[1] + 1) in empty_cells and ( cell[0], cell[1] + 2, ) not in opponents: if ((cell[0] + 1, cell[1] + 1) in opponents and (cell[0] - 1, cell[1] + 1) not in opponents or (cell[0] - 1, cell[1] + 1) in opponents and (cell[0] + 1, cell[1] + 1) not in opponents): return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0], cell[1] + 1), ) if (cell[0] - 1, cell[1]) in empty_cells and ( cell[0] - 2, cell[1], ) not in opponents: if ((cell[0] - 1, cell[1] - 1) in opponents and (cell[0] - 1, cell[1] - 1) not in opponents or (cell[0] - 1, cell[1] + 1) in opponents and (cell[0] - 1, cell[1] - 1) not in opponents): return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0] - 1, cell[1]), ) if (cell[0] + 1, cell[1]) in empty_cells and ( cell[0] + 2, cell[1], ) not in opponents: if ((cell[0] + 1, cell[1] - 1) in opponents and (cell[0] + 1, cell[1] + 1) not in opponents or (cell[0] + 1, cell[1] + 1) in opponents and (cell[0] + 1, cell[1] - 1) not in opponents): return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0] + 1, cell[1]), ) for cell in me: if (cell[0], cell[1] - 1) in empty_cells and ( cell[0], cell[1] - 2, ) not in opponents: if ((cell[0], cell[1] - 3) in opponents and (cell[0], cell[1] - 2) not in opponents or (cell[0] + 2, cell[1] - 1) in opponents and (cell[0] + 1, cell[1] - 1) not in opponents or (cell[0] - 2, cell[1] - 1) in opponents and (cell[0] - 1, cell[1] - 1) not in opponents): return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0], cell[1] - 1), ) if (cell[0], cell[1] + 1) in empty_cells and ( cell[0], cell[1] + 2, ) not in opponents: if ((cell[0], cell[1] + 3) in opponents and (cell[0], cell[1] + 2) not in opponents or (cell[0] + 2, cell[1] + 1) in opponents and (cell[0] + 1, cell[1] + 1) not in opponents or (cell[0] - 2, cell[1] + 1) in opponents and (cell[0] - 1, cell[1] + 1) not in opponents): return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0], cell[1] + 1), ) if (cell[0] - 1, cell[1]) in empty_cells and ( cell[0] - 2, cell[1], ) not in opponents: if ((cell[0] - 3, cell[1]) in opponents and (cell[0] - 2, cell[1]) not in opponents or (cell[0] - 1, cell[1] - 2) in opponents and (cell[0] - 1, cell[1] - 1) not in opponents or (cell[0] - 1, cell[1] + 2) in opponents and (cell[0] - 1, cell[1] + 1) not in opponents): return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0] - 1, cell[1]), ) if (cell[0] + 1, cell[1]) in empty_cells and ( cell[0] + 2, cell[1], ) not in opponents: if ((cell[0] + 3, cell[1]) in opponents and (cell[0] + 2, cell[1]) not in opponents or (cell[0] + 1, cell[1] - 2) in opponents and (cell[0] + 1, cell[1] - 1) not in opponents or (cell[0] + 1, cell[1] + 2) in opponents and (cell[0] + 1, cell[1] + 1) not in opponents): return YoteAction( action_type=YoteActionType.MOVE, at=cell, to=(cell[0] + 1, cell[1]), ) if state.get_player_info(self.position)["in_hand"] > 0: return self.add(board) else: return available_moves[0]
def add(self, board): empty_cells = board.get_all_empty_cells() me = board.get_player_pieces_on_board(Color(self.position)) opponents = board.get_player_pieces_on_board(Color(-self.position)) for cell in opponents: # on board_imit if cell[1] - 1 == 0 and (cell[0], cell[1] - 1) in empty_cells: return YoteAction(action_type=YoteActionType.ADD, to=(cell[0], cell[1] - 1)) elif cell[0] - 1 == 0 and (cell[0] - 1, cell[1]) in empty_cells: return YoteAction(action_type=YoteActionType.ADD, to=(cell[0] - 1, cell[1])) elif (cell[0] + 1 == board.board_shape[0] and (cell[0] + 1, cell[1]) in empty_cells): return YoteAction(action_type=YoteActionType.ADD, to=(cell[0] + 1, cell[1])) elif (cell[1] + 1 == board.board_shape[1] and (cell[0], cell[1] + 1) in empty_cells): return YoteAction(action_type=YoteActionType.ADD, to=(cell[0], cell[1] + 1)) for cell in opponents: # consecutives if (cell[0], cell[1] - 2) in me and (cell[0], cell[1] - 1) in empty_cells: return YoteAction(action_type=YoteActionType.ADD, to=(cell[0], cell[1] - 1)) if (cell[0] - 2, cell[1]) in me and (cell[0] - 1, cell[1]) in empty_cells: return YoteAction(action_type=YoteActionType.ADD, to=(cell[0] - 1, cell[1])) if (cell[0] + 2, cell[1]) in me and (cell[0] + 1, cell[1]) in empty_cells: return YoteAction(action_type=YoteActionType.ADD, to=(cell[0] + 1, cell[1])) if (cell[0], cell[1] + 2) in me and (cell[0], cell[1] + 1) in empty_cells: return YoteAction(action_type=YoteActionType.ADD, to=(cell[0], cell[1] + 1)) for cell in opponents: # block if ((cell[0], cell[1] - 2) in empty_cells and (cell[0], cell[1] - 1) in empty_cells and not ((cell[0], cell[1] - 3) in opponents)): if (cell[0], cell[1] - 2) in empty_cells: return YoteAction(action_type=YoteActionType.ADD, to=(cell[0], cell[1] - 2)) if ((cell[0] - 2, cell[1]) in empty_cells and (cell[0] - 1, cell[1]) in empty_cells and not ((cell[0] - 3, cell[1]) not in opponents)): if (cell[0] - 2, cell[1]) in empty_cells: return YoteAction(action_type=YoteActionType.ADD, to=(cell[0] - 2, cell[1])) if ((cell[0] + 2, cell[1]) in empty_cells and (cell[0] + 1, cell[1]) in empty_cells and not ((cell[0] + 3, cell[1]) not in opponents)): if (cell[0] + 2, cell[1]) in empty_cells: return YoteAction(action_type=YoteActionType.ADD, to=(cell[0] + 2, cell[1])) if ((cell[0], cell[1] + 2) in empty_cells and (cell[0], cell[1] + 1) in empty_cells and not ((cell[0], cell[1] + 3) not in opponents)): if (cell[0], cell[1] + 2) in empty_cells: return YoteAction(action_type=YoteActionType.ADD, to=(cell[0], cell[1] + 2)) return YoteAction(action_type=YoteActionType.ADD, to=empty_cells[0])
def make_move(state, action, player, rewarding_move=False): # TODO : done and next_is_reward can be removed as # they are in the state object """Transform the action of the player to a move. The move is made and the reward computed. Args: state (YoteState): A state object from the yote game. action (Action): An action object containing the move. player (int): The number of the player making the move. rewarding_move (bool, optional): True if the move is a stealing move. Defaults to False. Returns: (next_state, done, next_is_reward): Gives the next state of the game along with the game status and the type of the next step. """ board = state.get_board() json_action = action.get_json_action() action = action.get_action_as_dict() captured = None reward = 0 next_is_reward = False previous_is_reward = False if rewarding_move: state.boring_moves = 0 previous_is_reward = True if action['action_type'] == YoteActionType.STEAL_FROM_HAND: reward += 1 state.in_hand[player * -1] -= 1 elif action['action_type'] == YoteActionType.STEAL_FROM_BOARD: board.empty_cell(action['action']['at']) reward += 1 else: if action['action_type'] == YoteActionType.ADD: state.boring_moves += 1 state.in_hand[player] -= 1 board.fill_cell(action['action']['to'], Color(player)) elif action['action_type'] == YoteActionType.MOVE: at = action['action']['at'] to = action['action']['to'] def distance(cell_1, cell_2): import math return math.sqrt((cell_1[0] - cell_2[0]) ** 2 + (cell_1[1] - cell_2[1]) ** 2) board.empty_cell(at) board.fill_cell(to, Color(player)) if int(distance(at, to)) == 1: state.boring_moves += 1 elif int(distance(at, to)) > 1: state.boring_moves = 0 next_is_reward = True board.fill_cell(to, Color(player)) if at[0] == to[0] and at[1] < to[1]: board.empty_cell((at[0], at[1] + 1)) captured = (at[0], at[1] + 1) elif at[0] == to[0] and at[1] > to[1]: board.empty_cell((at[0], at[1] - 1)) captured = (at[0], at[1] - 1) elif at[1] == to[1] and at[0] < to[0]: board.empty_cell((at[0] + 1, at[1])) captured = (at[0] + 1, at[1]) elif at[1] == to[1] and at[0] > to[0]: board.empty_cell((at[0] - 1, at[1])) captured = (at[0] - 1, at[1]) reward += 1 state.set_board(board) state.score[player] += reward state.captured = captured state.rewarding_move = next_is_reward state.previous_is_reward = previous_is_reward state.set_latest_player(player) state.set_latest_move(json_action) if next_is_reward: state.set_next_player(player) else: state.set_next_player(player * -1) done = YoteRules.is_end_game(state) return state, done, next_is_reward
def move_piece(self, at, to, player): x, y = to[0], to[1] self.squares[x][y].set_piece(Piece(player, Color(player).name)) x, y = at[0], at[1] self.squares[x][y].remove_piece()
def BLACK_TEXT_WHITE_BACKGROUND(button): button.mutate_color(Color(255, 255, 255, 255)) button.text.color = colors.BLACK
player_type[i] = player_type[i][:-3] agents = {} # load the agents k = -1 for i in range(2): if player_type[i] != 'human': j = player_type[i].rfind('/') # extract the dir from the agent dir = player_type[i][:j] # add the dir to the system path sys.path.append(dir) # extract the agent filename file = player_type[i][j + 1:] # create the agent instance agents[k] = getattr(__import__(file), 'AI')(Color(k)) k *= -1 if None in agents: raise Exception('Problems in AI players instances. \n' 'Usage:\n' '-t allowed time for each ai \n' '\t total number of seconds credited to each player \n' '-ai0 ai0_file.py \n' '\t path to the ai that will play as player 0 \n' '-ai1 ai1_file.py\n' '\t path to the ai that will play as player 1 \n' '-s sleep time \n' '\t time(in second) to show the board(or move)') game = YoteGUI(app, (5, 6), agents, sleep_time=sleep_time,
def add_piece(self, cell, player): x, y = cell[0], cell[1] self.squares[x][y].set_piece(Piece(player, Color(player).name))