| import numpy as np |
|
|
|
|
| DIRECTIONS = ( |
| (-1, 0), |
| (-1, 1), |
| (0, 1), |
| (1, 1), |
| (1, 0), |
| (1, -1), |
| (0, -1), |
| (-1, -1), |
| ) |
| POINTS = {"tank": 1_000.0, "fighter": 2_000.0, "supertank": 3_000.0, "saucer": 5_000.0} |
| WAVES = ( |
| ("tank", "tank", "tank", "fighter", "saucer"), |
| ("tank", "tank", "fighter", "fighter", "saucer"), |
| ("tank", "tank", "fighter", "supertank", "saucer"), |
| ("tank", "fighter", "fighter", "supertank", "saucer"), |
| ("tank", "fighter", "supertank", "supertank", "saucer"), |
| ) |
| OBSTACLES = {(2, 2), (2, 7), (5, 1), (5, 8), (7, 3), (7, 6)} |
| SPAWNS = ((0, 1), (0, 5), (0, 9), (4, 0), (4, 9)) |
|
|
|
|
| class BattleZoneEnvironment: |
| """Radar combat with oriented movement, cover, shell dodging, and four target classes.""" |
|
|
| score_cap = 60_000.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 = [9, 5] |
| self.previous_player = self.player.copy() |
| self.direction = 0 |
| self.lives = 5 |
| self.wave = 0 |
| self.steps = 0 |
| self.total_score = 0.0 |
| self.bonus_awarded = False |
| self.player_shell: list[int] | None = None |
| self.enemy_shells: list[list[int]] = [] |
| self.last_action = 0 |
| self.terminal = False |
| self._start_wave() |
|
|
| def _start_wave(self) -> None: |
| self.enemies = [ |
| {"kind": kind, "position": [*SPAWNS[index]], "previous": [*SPAWNS[index]]} |
| for index, kind in enumerate(WAVES[self.wave]) |
| ] |
|
|
| 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_player = self.player.copy() |
| if action == 1: |
| self.direction = (self.direction - 1) % 8 |
| elif action == 3: |
| self.direction = (self.direction + 1) % 8 |
| elif action in (2, 4): |
| multiplier = 1 if action == 2 else -1 |
| row_delta, column_delta = DIRECTIONS[self.direction] |
| target = [self.player[0] + multiplier * row_delta, self.player[1] + multiplier * column_delta] |
| if self._open(target): |
| self.player = target |
| elif action == 5 and self.player_shell is None: |
| row_delta, column_delta = DIRECTIONS[self.direction] |
| self.player_shell = [self.player[0], self.player[1], row_delta, column_delta, 9] |
|
|
| self._move_enemies() |
| self._move_shells() |
| reward = self._resolve_player_shell() |
| self._resolve_enemy_shells() |
| self._enemy_fire() |
| self.steps += 1 |
| if self.total_score >= 50_000 and not self.bonus_awarded: |
| self.lives += 1 |
| self.bonus_awarded = True |
| if not self.enemies: |
| self.wave += 1 |
| if self.wave == len(WAVES): |
| self.terminal = True |
| else: |
| self._start_wave() |
| if self.steps >= self.horizon: |
| self.terminal = True |
| return reward, self.terminal |
|
|
| @staticmethod |
| def _open(position: list[int]) -> bool: |
| return 0 <= position[0] < 10 and 0 <= position[1] < 10 and tuple(position) not in OBSTACLES |
|
|
| def _move_enemies(self) -> None: |
| for enemy in self.enemies: |
| enemy["previous"] = list(enemy["position"]) |
| kind = str(enemy["kind"]) |
| if kind == "saucer": |
| enemy["position"][1] = (enemy["position"][1] + 1) % 10 |
| continue |
| interval = {"tank": 3, "fighter": 2, "supertank": 1}[kind] |
| if self.steps % interval != 0: |
| continue |
| position = list(enemy["position"]) |
| row_delta = int(np.sign(self.player[0] - position[0])) |
| column_delta = int(np.sign(self.player[1] - position[1])) |
| if kind == "fighter" and self.steps % 4 < 2: |
| column_delta = -column_delta or 1 |
| candidates = ([position[0] + row_delta, position[1] + column_delta], [position[0] + row_delta, position[1]]) |
| for target in candidates: |
| if self._open(target) and target != self.player: |
| enemy["position"] = target |
| break |
|
|
| def _move_shells(self) -> None: |
| if self.player_shell is not None: |
| self.player_shell[0] += self.player_shell[2] |
| self.player_shell[1] += self.player_shell[3] |
| self.player_shell[4] -= 1 |
| if not self._open(self.player_shell[:2]) or self.player_shell[4] <= 0: |
| self.player_shell = None |
| remaining = [] |
| for shell in self.enemy_shells: |
| shell[0] += shell[2] |
| shell[1] += shell[3] |
| shell[4] -= 1 |
| if self._open(shell[:2]) and shell[4] > 0: |
| remaining.append(shell) |
| self.enemy_shells = remaining |
|
|
| def _resolve_player_shell(self) -> float: |
| if self.player_shell is None: |
| return 0.0 |
| hit = next((enemy for enemy in self.enemies if enemy["position"] == self.player_shell[:2]), None) |
| if hit is None: |
| return 0.0 |
| self.enemies.remove(hit) |
| self.player_shell = None |
| reward = POINTS[str(hit["kind"])] |
| self.total_score += reward |
| return reward |
|
|
| def _resolve_enemy_shells(self) -> None: |
| remaining = [] |
| for shell in self.enemy_shells: |
| friendly_hit = next((enemy for enemy in self.enemies if enemy["position"] == shell[:2]), None) |
| if friendly_hit is not None: |
| self.enemies.remove(friendly_hit) |
| elif shell[:2] == self.player: |
| self._lose_tank() |
| else: |
| remaining.append(shell) |
| self.enemy_shells = remaining |
|
|
| def _enemy_fire(self) -> None: |
| for enemy in self.enemies: |
| kind = str(enemy["kind"]) |
| if kind == "saucer": |
| continue |
| interval = {"tank": 12, "fighter": 9, "supertank": 7}[kind] |
| if self.steps % interval != 0: |
| continue |
| position = list(enemy["position"]) |
| row_delta = int(np.sign(self.player[0] - position[0])) |
| column_delta = int(np.sign(self.player[1] - position[1])) |
| self.enemy_shells.append([position[0], position[1], row_delta, column_delta, 10]) |
|
|
| def _lose_tank(self) -> None: |
| self.lives -= 1 |
| self.player = [9, 5] |
| self.previous_player = self.player.copy() |
| self.direction = 0 |
| self.player_shell = None |
| self.enemy_shells.clear() |
| if self.lives <= 0: |
| self.terminal = True |
|
|
| def _in_view(self, position: list[int]) -> bool: |
| row_delta = int(np.sign(position[0] - self.player[0])) |
| column_delta = int(np.sign(position[1] - self.player[1])) |
| if (row_delta, column_delta) == (0, 0): |
| return True |
| target_direction = DIRECTIONS.index((row_delta, column_delta)) |
| return min((target_direction - self.direction) % 8, (self.direction - target_direction) % 8) <= 1 |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| state[*self.player, 0] = True |
| for enemy in self.enemies: |
| position = list(enemy["position"]) |
| state[*position, 1] = True |
| if self._in_view(position): |
| state[*position, 2] = True |
| type_marker = {"tank": 0, "fighter": 1, "supertank": 2, "saucer": 3}[str(enemy["kind"])] |
| state[position[0], type_marker, 5] = True |
| state[*list(enemy["previous"]), 4] = True |
| for shell in self.enemy_shells: |
| state[shell[0], shell[1], 1] = True |
| if self.player_shell is not None: |
| state[self.player_shell[0], self.player_shell[1], 3] = True |
| state[*self.previous_player, 4] = True |
| for obstacle in OBSTACLES: |
| state[*obstacle, 5] = True |
| state[9, : min(10, self.lives), 5] = True |
| state[8, : self.wave + 1, 5] = True |
| state[7, self.direction, 5] = True |
| return state |
|
|
