| import numpy as np |
|
|
|
|
| DIRECTIONS = ( |
| (-1, 0), |
| (-1, 1), |
| (0, 1), |
| (1, 1), |
| (1, 0), |
| (1, -1), |
| (0, -1), |
| (-1, -1), |
| ) |
| POINTS = {3: 20.0, 2: 50.0, 1: 100.0} |
|
|
|
|
| class AsteroidsEnvironment: |
| """Momentum, wraparound, fragmentation, and risky hyperspace on a torus.""" |
|
|
| score_cap = 6_240.0 |
|
|
| def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 1_500): |
| 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.ship = [5, 5] |
| self.previous_ship = self.ship.copy() |
| self.velocity = [0, 0] |
| self.direction = 0 |
| self.shots: list[list[int]] = [] |
| self.wave = 0 |
| self.lives = 4 |
| self.steps = 0 |
| self.last_action = 0 |
| self.terminal = False |
| self._start_wave() |
|
|
| def _start_wave(self) -> None: |
| starts = ((0, 0, 1, 1), (0, 9, 1, -1), (9, 0, -1, 1), (9, 9, -1, -1)) |
| self.asteroids = [ |
| {"row": row, "column": column, "dr": dr, "dc": dc, "size": 3} |
| for row, column, dr, dc in starts |
| ] |
| self.previous_asteroids = [[int(asteroid["row"]), int(asteroid["column"])] for asteroid in self.asteroids] |
|
|
| 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_ship = self.ship.copy() |
| if action == 1: |
| self.direction = (self.direction - 1) % 8 |
| elif action == 3: |
| self.direction = (self.direction + 1) % 8 |
| elif action == 2: |
| thrust = DIRECTIONS[self.direction] |
| self.velocity[0] = int(np.clip(self.velocity[0] + thrust[0], -1, 1)) |
| self.velocity[1] = int(np.clip(self.velocity[1] + thrust[1], -1, 1)) |
| elif action == 4: |
| self.ship = [int(self.random.randint(10)), int(self.random.randint(10))] |
| self.velocity = [0, 0] |
| elif action == 5: |
| dr, dc = DIRECTIONS[self.direction] |
| self.shots.append([self.ship[0], self.ship[1], dr, dc, 12]) |
|
|
| if action != 4: |
| self.ship[0] = (self.ship[0] + self.velocity[0]) % 10 |
| self.ship[1] = (self.ship[1] + self.velocity[1]) % 10 |
| self.previous_asteroids = [[int(asteroid["row"]), int(asteroid["column"])] for asteroid in self.asteroids] |
| self._move_asteroids() |
| self._move_shots() |
| reward = self._resolve_shots() |
| if any([asteroid["row"], asteroid["column"]] == self.ship for asteroid in self.asteroids): |
| self._lose_ship() |
| self.steps += 1 |
| if not self.asteroids: |
| self.wave += 1 |
| if self.wave == 3: |
| self.terminal = True |
| else: |
| self._start_wave() |
| if self.steps >= self.horizon: |
| self.terminal = True |
| return reward, self.terminal |
|
|
| def _move_asteroids(self) -> None: |
| for asteroid in self.asteroids: |
| asteroid["row"] = (int(asteroid["row"]) + int(asteroid["dr"])) % 10 |
| asteroid["column"] = (int(asteroid["column"]) + int(asteroid["dc"])) % 10 |
|
|
| def _move_shots(self) -> None: |
| for shot in self.shots: |
| shot[0] = (shot[0] + shot[2]) % 10 |
| shot[1] = (shot[1] + shot[3]) % 10 |
| shot[4] -= 1 |
| self.shots = [shot for shot in self.shots if shot[4] > 0] |
|
|
| def _resolve_shots(self) -> float: |
| reward = 0.0 |
| remaining_shots = [] |
| for shot in self.shots: |
| hit = next( |
| (asteroid for asteroid in self.asteroids if [asteroid["row"], asteroid["column"]] == shot[:2]), |
| None, |
| ) |
| if hit is None: |
| remaining_shots.append(shot) |
| continue |
| self.asteroids.remove(hit) |
| size = int(hit["size"]) |
| reward += POINTS[size] |
| if size > 1: |
| for turn in (-1, 1): |
| direction = DIRECTIONS.index((int(hit["dr"]), int(hit["dc"]))) |
| dr, dc = DIRECTIONS[(direction + turn) % 8] |
| self.asteroids.append({ |
| "row": int(hit["row"]), |
| "column": int(hit["column"]), |
| "dr": dr, |
| "dc": dc, |
| "size": size - 1, |
| }) |
| self.shots = remaining_shots |
| return reward |
|
|
| def _lose_ship(self) -> None: |
| self.lives -= 1 |
| self.ship = [5, 5] |
| self.previous_ship = self.ship.copy() |
| self.velocity = [0, 0] |
| self.shots.clear() |
| if self.lives <= 0: |
| self.terminal = True |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| state[*self.ship, 0] = True |
| for asteroid in self.asteroids: |
| row, column = int(asteroid["row"]), int(asteroid["column"]) |
| state[row, column, 1] = True |
| state[row, column, 2] = True |
| size = int(asteroid["size"]) |
| state[row, (column + size - 1) % 10, 5] = True |
| for shot in self.shots: |
| state[shot[0], shot[1], 3] = True |
| for row, column in self.previous_asteroids: |
| state[row, column, 4] = True |
| state[*self.previous_ship, 4] = True |
| state[9, : self.lives, 5] = True |
| state[8, : self.wave + 1, 5] = True |
| velocity_marker = (self.velocity[0] + 1) * 3 + self.velocity[1] + 1 |
| state[7, velocity_marker, 5] = True |
| state[6, self.direction, 5] = True |
| return state |
|
|
