| import numpy as np |
|
|
|
|
| DELTAS = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)} |
| OPENINGS = {(0, 5), (9, 5), (5, 0), (5, 9)} |
| BASE_INTERIOR = {(2, 2), (2, 3), (2, 4), (4, 7), (5, 7), (6, 7), (7, 2), (7, 3)} |
| SPAWN_CANDIDATES = ((1, 1), (1, 8), (4, 4), (7, 7), (8, 1), (3, 8), (6, 2)) |
|
|
|
|
| def room_walls(room: int) -> set[tuple[int, int]]: |
| boundary = { |
| (row, column) |
| for row in range(10) |
| for column in range(10) |
| if row in (0, 9) or column in (0, 9) |
| } - OPENINGS |
| interior = BASE_INTERIOR |
| for _ in range(room): |
| interior = {(column, 9 - row) for row, column in interior} |
| return boundary | interior |
|
|
|
|
| class BerzerkEnvironment: |
| """Four electrified mazes with robot crossfire and invincible Evil Otto pressure.""" |
|
|
| score_cap = 1_200.0 |
|
|
| def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 1_000): |
| 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.room = 0 |
| self.lives = 3 |
| self.steps = 0 |
| self.last_action = 0 |
| self.death_this_step = False |
| self.terminal = False |
| self._start_room([9, 5]) |
|
|
| def _start_room(self, entry: list[int]) -> None: |
| self.walls = room_walls(self.room) |
| self.player = entry.copy() |
| self.previous_player = self.player.copy() |
| self.aim = 2 |
| available = [position for position in SPAWN_CANDIDATES if position not in self.walls and list(position) != self.player] |
| self.robots = [list(position) for position in available[:5]] |
| self.previous_robots = [robot.copy() for robot in self.robots] |
| self.player_shot: list[int] | None = None |
| self.robot_shots: list[list[int]] = [] |
| self.otto: list[int] | None = None |
| self.room_steps = 0 |
| self.clear_bonus_awarded = False |
|
|
| 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.death_this_step = False |
| self.previous_player = self.player.copy() |
| if action in DELTAS: |
| self.aim = action |
| if self._move_player(action): |
| self.steps += 1 |
| return 0.0, self.terminal |
| elif action == 5 and self.player_shot is None: |
| row_delta, column_delta = DELTAS[self.aim] |
| self.player_shot = [self.player[0], self.player[1], row_delta, column_delta, 8] |
|
|
| self.previous_robots = [robot.copy() for robot in self.robots] |
| reward = self._move_robots() |
| self._move_shots() |
| reward += self._resolve_player_shot() |
| reward += self._resolve_robot_shots() |
| self._spawn_and_move_otto() |
| reward += self._resolve_otto() |
| if not self.robots and not self.clear_bonus_awarded: |
| reward += 50.0 |
| self.clear_bonus_awarded = True |
| self.room_steps += 1 |
| self.steps += 1 |
| if self.steps >= self.horizon: |
| self.terminal = True |
| return reward, self.terminal |
|
|
| def _move_player(self, action: int) -> bool: |
| row_delta, column_delta = DELTAS[action] |
| target = [self.player[0] + row_delta, self.player[1] + column_delta] |
| if not (0 <= target[0] < 10 and 0 <= target[1] < 10): |
| if tuple(self.player) in OPENINGS: |
| self.room += 1 |
| if self.room == 4: |
| self.terminal = True |
| else: |
| opposite = {1: [5, 9], 2: [9, 5], 3: [5, 0], 4: [0, 5]}[action] |
| self._start_room(opposite) |
| return True |
| return False |
| if tuple(target) in self.walls: |
| self._lose_life() |
| elif target in self.robots or target == self.otto: |
| self._lose_life() |
| else: |
| self.player = target |
| return False |
|
|
| def _move_robots(self) -> float: |
| if self.room_steps % 2 != 0: |
| return 0.0 |
| reward = 0.0 |
| for robot in self.robots.copy(): |
| row_delta = int(np.sign(self.player[0] - robot[0])) |
| column_delta = int(np.sign(self.player[1] - robot[1])) |
| target = [robot[0] + row_delta, robot[1] + column_delta] |
| if tuple(target) in self.walls: |
| if robot in self.robots: |
| self.robots.remove(robot) |
| reward += 50.0 |
| elif target in self.robots: |
| if robot in self.robots: |
| self.robots.remove(robot) |
| reward += 50.0 |
| if target in self.robots: |
| self.robots.remove(target) |
| reward += 50.0 |
| elif target == self.player: |
| self._lose_life() |
| elif robot in self.robots: |
| robot[:] = target |
| if self.room_steps % 8 == 0: |
| for robot in self.robots: |
| row_delta = int(np.sign(self.player[0] - robot[0])) |
| column_delta = int(np.sign(self.player[1] - robot[1])) |
| self.robot_shots.append([robot[0], robot[1], row_delta, column_delta, 8]) |
| return reward |
|
|
| def _move_shots(self) -> None: |
| if self.player_shot is not None: |
| self.player_shot[0] += self.player_shot[2] |
| self.player_shot[1] += self.player_shot[3] |
| self.player_shot[4] -= 1 |
| if ( |
| self.player_shot[4] <= 0 |
| or not (0 <= self.player_shot[0] < 10 and 0 <= self.player_shot[1] < 10) |
| or tuple(self.player_shot[:2]) in self.walls |
| ): |
| self.player_shot = None |
| remaining = [] |
| for shot in self.robot_shots: |
| shot[0] += shot[2] |
| shot[1] += shot[3] |
| shot[4] -= 1 |
| if shot[4] > 0 and 0 <= shot[0] < 10 and 0 <= shot[1] < 10 and tuple(shot[:2]) not in self.walls: |
| remaining.append(shot) |
| self.robot_shots = remaining |
|
|
| def _resolve_player_shot(self) -> float: |
| if self.player_shot is None: |
| return 0.0 |
| hit = next((robot for robot in self.robots if robot == self.player_shot[:2]), None) |
| if hit is None: |
| return 0.0 |
| self.robots.remove(hit) |
| self.player_shot = None |
| return 50.0 |
|
|
| def _resolve_robot_shots(self) -> float: |
| reward = 0.0 |
| remaining = [] |
| for shot in self.robot_shots: |
| hit = next((robot for robot in self.robots if robot == shot[:2]), None) |
| if hit is not None: |
| self.robots.remove(hit) |
| reward += 50.0 |
| elif shot[:2] == self.player: |
| self._lose_life() |
| else: |
| remaining.append(shot) |
| self.robot_shots = remaining |
| return reward |
|
|
| def _spawn_and_move_otto(self) -> None: |
| if self.otto is None and self.room_steps >= 40: |
| self.otto = [9, 5] |
| if self.otto is None or self.room_steps % 2 != 0: |
| return |
| self.otto[0] += int(np.sign(self.player[0] - self.otto[0])) |
| self.otto[1] += int(np.sign(self.player[1] - self.otto[1])) |
|
|
| def _resolve_otto(self) -> float: |
| if self.otto is None: |
| return 0.0 |
| reward = 0.0 |
| hit = next((robot for robot in self.robots if robot == self.otto), None) |
| if hit is not None: |
| self.robots.remove(hit) |
| reward += 50.0 |
| if self.otto == self.player: |
| self._lose_life() |
| return reward |
|
|
| def _lose_life(self) -> None: |
| if self.death_this_step: |
| return |
| self.death_this_step = True |
| self.lives -= 1 |
| self.player = [9, 5] |
| self.previous_player = self.player.copy() |
| self.player_shot = None |
| self.robot_shots.clear() |
| if self.lives <= 0: |
| self.terminal = True |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| state[*self.player, 0] = True |
| for robot in self.robots: |
| state[*robot, 1] = True |
| state[*robot, 2] = True |
| for shot in self.robot_shots: |
| state[shot[0], shot[1], 1] = True |
| if self.otto is not None: |
| state[*self.otto, 1] = True |
| if self.player_shot is not None: |
| state[self.player_shot[0], self.player_shot[1], 3] = True |
| state[*self.previous_player, 4] = True |
| for robot in self.previous_robots: |
| state[*robot, 4] = True |
| for wall in self.walls: |
| state[*wall, 5] = True |
| state[9, : self.lives, 5] = True |
| state[8, : self.room + 1, 5] = True |
| state[7, self.aim, 5] = True |
| return state |
|
|
