| import numpy as np |
|
|
|
|
| ACTIONS = { |
| 1: (0, -1), |
| 2: (-1, 0), |
| 3: (0, 1), |
| 4: (1, 0), |
| } |
|
|
|
|
| class AmidarEnvironment: |
| """Trace a rectilinear maze while avoiding deterministic patrol enemies.""" |
|
|
| score_cap = 9.0 |
|
|
| def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 600): |
| self.sticky_action_prob = sticky_action_prob |
| self.horizon = horizon |
| self.random = np.random.RandomState() |
| self.seed(0) |
| self.reset() |
|
|
| @classmethod |
| def normalize_score(cls, raw_score: float) -> float: |
| return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap |
|
|
| def seed(self, seed: int) -> None: |
| self.random.seed(seed) |
|
|
| def reset(self) -> None: |
| self.player = [9, 0] |
| self.previous_player = self.player.copy() |
| self.enemies = [[0, 0], [0, 9], [9, 9]] |
| self.previous_enemies = [position.copy() for position in self.enemies] |
| self.enemy_directions = [4, 1, 2] |
| self.painted_edges: set[tuple[tuple[int, int], tuple[int, int]]] = set() |
| self.completed_boxes: set[tuple[int, int]] = set() |
| self.shadow_timer = 0 |
| self.shadow_uses = 3 |
| self.last_action = 0 |
| self.steps = 0 |
| self.terminal = False |
|
|
| @staticmethod |
| def _on_path(position: list[int] | tuple[int, int]) -> bool: |
| row, column = position |
| return 0 <= row < 10 and 0 <= column < 10 and (row % 3 == 0 or column % 3 == 0) |
|
|
| @staticmethod |
| def _edge(first: list[int], second: list[int]) -> tuple[tuple[int, int], tuple[int, int]]: |
| return tuple(sorted((tuple(first), tuple(second)))) |
|
|
| def act(self, action: int) -> tuple[float, bool]: |
| if self.terminal: |
| return 0.0, True |
| if self.random.rand() < self.sticky_action_prob: |
| action = self.last_action |
| self.last_action = action |
| self.previous_player = self.player.copy() |
| if action == 5 and self.shadow_uses > 0 and self.shadow_timer == 0: |
| self.shadow_uses -= 1 |
| self.shadow_timer = 12 |
| elif action in ACTIONS: |
| row_delta, column_delta = ACTIONS[action] |
| target = [self.player[0] + row_delta, self.player[1] + column_delta] |
| if self._on_path(target): |
| self.player = target |
| if self.player != self.previous_player: |
| self.painted_edges.add(self._edge(self.previous_player, self.player)) |
|
|
| reward = self._complete_boxes() |
| self.previous_enemies = [position.copy() for position in self.enemies] |
| if self.shadow_timer == 0: |
| for index in range(len(self.enemies)): |
| self._move_enemy(index) |
| if self.shadow_timer == 0 and any(enemy == self.player for enemy in self.enemies): |
| self.terminal = True |
| self.shadow_timer = max(0, self.shadow_timer - 1) |
| self.steps += 1 |
| if len(self.completed_boxes) == 9 or self.steps >= self.horizon: |
| self.terminal = True |
| return reward, self.terminal |
|
|
| def _move_enemy(self, index: int) -> None: |
| direction = self.enemy_directions[index] |
| preferences = (direction, {1: 2, 2: 3, 3: 4, 4: 1}[direction], {1: 4, 2: 1, 3: 2, 4: 3}[direction]) |
| for candidate_direction in preferences: |
| row_delta, column_delta = ACTIONS[candidate_direction] |
| target = [self.enemies[index][0] + row_delta, self.enemies[index][1] + column_delta] |
| if self._on_path(target): |
| self.enemies[index] = target |
| self.enemy_directions[index] = candidate_direction |
| return |
|
|
| def _complete_boxes(self) -> float: |
| reward = 0.0 |
| for box_row in range(3): |
| for box_column in range(3): |
| box = (box_row, box_column) |
| if box in self.completed_boxes: |
| continue |
| top = box_row * 3 |
| left = box_column * 3 |
| required = set() |
| for offset in range(3): |
| required.add(self._edge([top, left + offset], [top, left + offset + 1])) |
| required.add(self._edge([top + 3, left + offset], [top + 3, left + offset + 1])) |
| required.add(self._edge([top + offset, left], [top + offset + 1, left])) |
| required.add(self._edge([top + offset, left + 3], [top + offset + 1, left + 3])) |
| if required <= self.painted_edges: |
| self.completed_boxes.add(box) |
| reward += 1.0 |
| return reward |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| state[*self.player, 0] = True |
| for enemy in self.enemies: |
| channel = 3 if self.shadow_timer > 0 else 1 |
| state[*enemy, channel] = True |
| for box_row in range(3): |
| for box_column in range(3): |
| center = (min(9, box_row * 3 + 1), min(9, box_column * 3 + 1)) |
| if (box_row, box_column) not in self.completed_boxes: |
| state[*center, 2] = True |
| for first, second in self.painted_edges: |
| state[*first, 4] = True |
| state[*second, 4] = True |
| state[9, : self.shadow_uses, 5] = True |
| if self.shadow_timer > 0: |
| state[8, : min(10, self.shadow_timer), 5] = True |
| return state |
|
|
