| from dataclasses import dataclass |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| MIN_SPAWN_STEPS = 4 |
| MAX_MULTIPLIER = 64 |
| PLAYER_ROW = 4 |
|
|
|
|
| @dataclass |
| class Target: |
| row: int |
| column: int |
| fire_in: int = 0 |
|
|
|
|
| @dataclass |
| class HomingShot: |
| row: int |
| column: int |
| target: Target |
| age: int = 0 |
|
|
|
|
| class AccelBEnvironment: |
| score_cap = (HORIZON // MIN_SPAWN_STEPS) * 2 * MAX_MULTIPLIER |
|
|
| def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON): |
| self.sticky_action_prob = sticky_action_prob |
| self.horizon = min(horizon, HORIZON) |
| self.seed(0) |
| self.reset() |
|
|
| def seed(self, seed: int) -> None: |
| self.random = np.random.default_rng(seed) |
|
|
| def reset(self) -> None: |
| self.steps = self.last_action = self.throttle = 0 |
| self.spawn_in = MIN_SPAWN_STEPS |
| self.multiplier = 1 |
| self.enemies: list[Target] = [] |
| self.hostile: list[Target] = [] |
| self.shots: list[HomingShot] = [] |
| self.blasts: list[tuple[int, int, int]] = [] |
| self.terminal = False |
|
|
| @property |
| def column(self) -> int: |
| return 1 + self.throttle // 2 |
|
|
| @classmethod |
| def normalize_score(cls, score: float) -> float: |
| return min(max(score, 0), cls.score_cap) / cls.score_cap |
|
|
| def act(self, action: int) -> tuple[float, bool]: |
| if self.terminal: |
| return 0.0, True |
| if self.random.random() < self.sticky_action_prob: |
| action = self.last_action |
| self.steps += 1 |
| pressed = action == 5 and self.last_action != 5 |
| self.last_action = action |
| self.throttle = min(6, self.throttle + 1) if action == 5 else max(0, self.throttle - 1) |
| if pressed and not (self.shots or self.blasts): |
| self.multiplier = 1 |
| self.shots = [HomingShot(PLAYER_ROW, self.column, target) |
| for target in (*self.enemies, *self.hostile)] |
| self._advance_targets() |
| self._advance_salvo() |
| reward = 0 |
| for targets in (self.enemies, self.hostile): |
| remaining = [] |
| for target in targets: |
| if any(abs(target.row - row) <= 1 and abs(target.column - column) <= 1 |
| for row, column, _ in self.blasts): |
| reward += self.multiplier |
| self.multiplier = min(MAX_MULTIPLIER, 2 * self.multiplier) |
| elif target.column >= 0: |
| remaining.append(target) |
| targets[:] = remaining |
| self.terminal = any((missile.row, missile.column) == (PLAYER_ROW, self.column) |
| for missile in self.hostile) or self.steps >= self.horizon |
| self.spawn_in -= 1 |
| if self.spawn_in == 0 and not self.terminal: |
| self.enemies.append(Target(int(self.random.choice((1, 2, 3, 5, 6, 7, 8))), 9, 3)) |
| self.spawn_in = max(MIN_SPAWN_STEPS, 10 - self.throttle) |
| return float(reward), self.terminal |
|
|
| def _advance_targets(self) -> None: |
| for enemy in self.enemies: |
| if self.throttle >= 3 or self.steps % 3 == 0: |
| enemy.column -= 1 |
| enemy.fire_in -= 1 |
| if enemy.fire_in == 0 and enemy.column >= 0: |
| self.hostile.append(Target(enemy.row, enemy.column)) |
| for missile in self.hostile: |
| missile.column -= 1 |
| if self.steps % 2 == 0: |
| missile.row += int(np.sign(PLAYER_ROW - missile.row)) |
|
|
| def _advance_salvo(self) -> None: |
| self.blasts = [(row, column, timer - 1) |
| for row, column, timer in self.blasts if timer > 1] |
| remaining = [] |
| for shot in self.shots: |
| shot.age += 1 |
| shot.column += 1 if shot.age == 1 else int(np.sign(shot.target.column - shot.column)) |
| if shot.age > 1: |
| shot.row += int(np.sign(shot.target.row - shot.row)) |
| distance = max(abs(shot.row - shot.target.row), abs(shot.column - shot.target.column)) |
| if distance <= 1 or shot.age >= 12: |
| self.blasts.append((shot.row, max(0, min(9, shot.column)), 3)) |
| else: |
| remaining.append(shot) |
| self.shots = remaining |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| state[PLAYER_ROW, self.column, 0] = True |
| for channel, targets in ((1, self.hostile), (2, self.enemies), (3, self.shots)): |
| for target in targets: |
| if 0 <= target.column < 10: |
| state[target.row, target.column, channel] = True |
| for row, column, _ in self.blasts: |
| state[max(0, row - 1):row + 2, max(0, column - 1):column + 2, 4] = True |
| values = (self.steps, self.throttle, self.spawn_in, self.multiplier, |
| int(self.last_action == 5), int(not (self.shots or self.blasts))) |
| for row, value in enumerate(values): |
| for bit in range(9): |
| state[row, bit, 5] = bool(value & (1 << bit)) |
| return state |
|
|
