| import numpy as np |
|
|
|
|
| class AssaultEnvironment: |
| """Fixed-cannon wave defense with vertical/lateral fire and weapon heat.""" |
|
|
| score_cap = 75.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.player_column = 5 |
| self.facing = 1 |
| self.mothership_column = 0 |
| self.mothership_direction = 1 |
| self.aliens: list[dict[str, int | bool]] = [] |
| self.friendly_shots: list[list[int]] = [] |
| self.hostile_shots: list[list[int]] = [] |
| self.fireballs: list[list[int]] = [] |
| self.previous_aliens: list[list[int]] = [] |
| self.previous_hostiles: list[list[int]] = [] |
| self.wave = 0 |
| self.spawned = 0 |
| self.lives = 3 |
| self.heat = 0 |
| self.steps = 0 |
| self.last_action = 0 |
| self.terminal = 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 |
| fired = False |
| if action == 1: |
| self.player_column = max(0, self.player_column - 1) |
| self.facing = -1 |
| elif action == 3: |
| self.player_column = min(9, self.player_column + 1) |
| self.facing = 1 |
| elif action == 2 and self.heat < 9: |
| self.friendly_shots.append([8, self.player_column, -1, 0]) |
| fired = True |
| elif action == 5 and self.heat < 9: |
| self.friendly_shots.append([9, self.player_column, 0, self.facing]) |
| fired = True |
| self.heat = min(10, self.heat + 2) if fired else max(0, self.heat - 1) |
| if self.heat >= 10: |
| self._lose_life() |
|
|
| self._move_mothership() |
| self._spawn_alien() |
| self.previous_aliens = [[int(alien["row"]), int(alien["column"])] for alien in self.aliens] |
| self.previous_hostiles = [shot[:2] for shot in self.hostile_shots + self.fireballs] |
| self._move_aliens() |
| self._move_projectiles() |
| reward = self._resolve_friendly_hits() |
| self._resolve_hostile_hits() |
| self._launch_hostile_weapon() |
| self.steps += 1 |
| if self.spawned == 10 and not self.aliens: |
| self.wave += 1 |
| if self.wave == 5: |
| self.terminal = True |
| else: |
| self.spawned = 0 |
| if self.steps >= self.horizon: |
| self.terminal = True |
| return reward, self.terminal |
|
|
| def _move_mothership(self) -> None: |
| self.mothership_column += self.mothership_direction |
| if self.mothership_column in (0, 9): |
| self.mothership_direction *= -1 |
|
|
| def _spawn_alien(self) -> None: |
| if self.spawned >= 10 or self.steps % 4 != 0: |
| return |
| self.aliens.append({ |
| "row": 1, |
| "column": self.mothership_column, |
| "direction": self.mothership_direction, |
| "split": self.spawned % 2 == 1, |
| }) |
| self.spawned += 1 |
|
|
| def _move_aliens(self) -> None: |
| for alien in self.aliens: |
| direction = int(alien["direction"]) |
| column = int(alien["column"]) + direction |
| if column < 0 or column > 9: |
| direction *= -1 |
| column = min(9, max(0, column)) |
| alien["column"] = column |
| alien["direction"] = direction |
| if self.wave % 3 == 1 and self.steps % 3 == 0: |
| alien["row"] = min(7, int(alien["row"]) + 1) |
| elif self.wave % 3 == 2 and self.random.rand() < 0.2: |
| alien["row"] = int(self.random.randint(1, 7)) |
| alien["column"] = int(self.random.randint(10)) |
|
|
| def _move_projectiles(self) -> None: |
| for shot in self.friendly_shots: |
| shot[0] += shot[2] |
| shot[1] += shot[3] |
| self.friendly_shots = [shot for shot in self.friendly_shots if 0 <= shot[0] < 10 and 0 <= shot[1] < 10] |
| for shot in self.hostile_shots: |
| shot[0] += 1 |
| reached_base = [shot for shot in self.hostile_shots if shot[0] >= 9] |
| self.hostile_shots = [shot for shot in self.hostile_shots if shot[0] < 9] |
| for shot in reached_base: |
| direction = int(np.sign(self.player_column - shot[1])) or 1 |
| self.fireballs.append([9, shot[1], 0, direction]) |
| for fireball in self.fireballs: |
| fireball[1] += fireball[3] |
| self.fireballs = [shot for shot in self.fireballs if 0 <= shot[1] < 10] |
|
|
| def _resolve_friendly_hits(self) -> float: |
| reward = 0.0 |
| remaining_shots = [] |
| for shot in self.friendly_shots: |
| hit_fireball = next((fireball for fireball in self.fireballs if fireball[:2] == shot[:2]), None) |
| if hit_fireball is not None: |
| self.fireballs.remove(hit_fireball) |
| continue |
| hit = next((alien for alien in self.aliens if [alien["row"], alien["column"]] == shot[:2]), None) |
| if hit is None: |
| remaining_shots.append(shot) |
| continue |
| self.aliens.remove(hit) |
| if bool(hit["split"]): |
| column = int(hit["column"]) |
| row = int(hit["row"]) |
| for direction in (-1, 1): |
| self.aliens.append({"row": row, "column": column, "direction": direction, "split": False}) |
| else: |
| reward += 1.0 |
| self.friendly_shots = remaining_shots |
| return reward |
|
|
| def _resolve_hostile_hits(self) -> None: |
| if any(shot[:2] == [9, self.player_column] for shot in self.fireballs): |
| self.fireballs = [shot for shot in self.fireballs if shot[:2] != [9, self.player_column]] |
| self._lose_life() |
|
|
| def _launch_hostile_weapon(self) -> None: |
| if self.steps % 12 != 0 or not self.aliens: |
| return |
| lowest = max(self.aliens, key=lambda alien: int(alien["row"])) |
| self.hostile_shots.append([int(lowest["row"]) + 1, int(lowest["column"])]) |
|
|
| def _lose_life(self) -> None: |
| self.lives -= 1 |
| self.heat = 0 |
| self.friendly_shots.clear() |
| self.hostile_shots.clear() |
| self.fireballs.clear() |
| if self.lives <= 0: |
| self.terminal = True |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| state[9, self.player_column, 0] = True |
| state[0, self.mothership_column, 1] = True |
| for shot in self.hostile_shots + self.fireballs: |
| state[shot[0], shot[1], 1] = True |
| for alien in self.aliens: |
| state[int(alien["row"]), int(alien["column"]), 2] = True |
| for shot in self.friendly_shots: |
| state[shot[0], shot[1], 3] = True |
| for row, column in self.previous_aliens + self.previous_hostiles: |
| state[row, column, 4] = True |
| state[9, : self.heat, 5] = True |
| state[8, : self.lives, 5] = True |
| state[7, : self.wave + 1, 5] = True |
| return state |
|
|
