| import numpy as np |
|
|
|
|
| class AtlantisEnvironment: |
| """Three fixed defense posts protect seven installations from descending formations.""" |
|
|
| score_cap = 35_500.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.installations = [True] * 7 |
| self.shots: list[list[int | str]] = [] |
| self.wave = 0 |
| self.wave_step = 0 |
| self.steps = 0 |
| self.total_score = 0.0 |
| self.restorations_used = 0 |
| self.last_action = 0 |
| self.terminal = False |
| self.escaped = False |
| self._start_wave() |
|
|
| def _start_wave(self) -> None: |
| self.enemies = [ |
| {"row": index // 5, "column": (index * 2) % 10, "direction": 1, "bandit": index == 8} |
| for index in range(9) |
| ] |
| self.previous_enemies = [[int(enemy["row"]), int(enemy["column"])] for enemy in self.enemies] |
| self.wave_step = 0 |
|
|
| 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 |
| if action == 1: |
| self.shots.append([8, 1, -1, 1, "sentry"]) |
| elif action == 3: |
| self.shots.append([8, 8, -1, -1, "sentry"]) |
| elif action == 5 and self.installations[0]: |
| self.shots.append([8, 5, -1, 0, "command"]) |
|
|
| self.previous_enemies = [[int(enemy["row"]), int(enemy["column"])] for enemy in self.enemies] |
| self._move_enemies() |
| self._move_shots() |
| reward = self._resolve_hits() |
| self._resolve_deathrays() |
| self.wave_step += 1 |
| self.steps += 1 |
| if not any(self.installations): |
| self.escaped = True |
| self.terminal = True |
| elif not self.enemies: |
| bonus = 500.0 * sum(self.installations) |
| reward += bonus |
| self.total_score += bonus |
| self._restore_installations() |
| self.wave += 1 |
| if self.wave == 5: |
| self.terminal = True |
| else: |
| self._start_wave() |
| if self.steps >= self.horizon: |
| self.terminal = True |
| return reward, self.terminal |
|
|
| def _move_enemies(self) -> None: |
| if self.wave_step % max(1, 4 - min(self.wave, 2)) != 0: |
| return |
| for enemy in self.enemies: |
| column = int(enemy["column"]) + int(enemy["direction"]) |
| if column < 0 or column > 9: |
| enemy["direction"] = -int(enemy["direction"]) |
| enemy["row"] = int(enemy["row"]) + 1 |
| column = min(9, max(0, column)) |
| enemy["column"] = column |
|
|
| def _move_shots(self) -> None: |
| for shot in self.shots: |
| shot[0] = int(shot[0]) + int(shot[2]) |
| shot[1] = int(shot[1]) + int(shot[3]) |
| self.shots = [shot for shot in self.shots if 0 <= int(shot[0]) < 10 and 0 <= int(shot[1]) < 10] |
|
|
| def _resolve_hits(self) -> float: |
| reward = 0.0 |
| remaining_shots = [] |
| for shot in self.shots: |
| hit = next( |
| (enemy for enemy in self.enemies if [enemy["row"], enemy["column"]] == shot[:2]), |
| None, |
| ) |
| if hit is None: |
| remaining_shots.append(shot) |
| continue |
| sentry = shot[4] == "sentry" |
| if bool(hit["bandit"]): |
| reward += 2_000.0 if sentry else 1_000.0 |
| self.enemies.clear() |
| remaining_shots = [] |
| break |
| reward += 200.0 if sentry else 100.0 |
| self.enemies.remove(hit) |
| self.shots = remaining_shots |
| self.total_score += reward |
| return reward |
|
|
| def _resolve_deathrays(self) -> None: |
| attackers = [enemy for enemy in self.enemies if int(enemy["row"]) >= 8] |
| for enemy in attackers: |
| live = [index for index, intact in enumerate(self.installations) if intact] |
| if live: |
| target = 0 if self.installations[0] else live[int(self.random.randint(len(live)))] |
| self.installations[target] = False |
| self.enemies.remove(enemy) |
|
|
| def _restore_installations(self) -> None: |
| available = int(self.total_score // 10_000) - self.restorations_used |
| while available > 0 and not all(self.installations): |
| target = next(index for index, intact in enumerate(self.installations) if not intact) |
| self.installations[target] = True |
| self.restorations_used += 1 |
| available -= 1 |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| state[9, 0, 0] = True |
| state[9, 9, 0] = True |
| if self.installations[0]: |
| state[9, 5, 0] = True |
| for enemy in self.enemies: |
| row, column = int(enemy["row"]), int(enemy["column"]) |
| state[row, column, 1] = True |
| state[row, column, 2] = True |
| if bool(enemy["bandit"]): |
| state[row, column, 5] = True |
| for shot in self.shots: |
| state[int(shot[0]), int(shot[1]), 3] = True |
| for row, column in self.previous_enemies: |
| if 0 <= row < 10 and 0 <= column < 10: |
| state[row, column, 4] = True |
| for index, intact in enumerate(self.installations): |
| state[9, index + 1, 5] = intact |
| state[8, : self.wave + 1, 5] = True |
| return state |
|
|
