| from math import atan2, cos, hypot, pi, sin, sqrt |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| SECTORS = 24 |
| MAX_CHARGE = 12 |
| SPAWN_INTERVAL = 6 |
| CENTER = (5, 5) |
| MAX_ENEMIES = (HORIZON + SPAWN_INTERVAL - 1) // SPAWN_INTERVAL |
|
|
|
|
| class ArcfireEnvironment: |
| score_cap = MAX_ENEMIES * (MAX_ENEMIES + 1) // 2 |
|
|
| 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.player = CENTER |
| self.steps = self.last_action = self.aim = self.charge = self.arc_start = 0 |
| self.multiplier = 1 |
| self.spawn_index = int(self.random.integers(36)) |
| self.enemies: list[tuple[int, int]] = [] |
| self.shot: tuple[int, int, int, int] | None = None |
| self.terminal = False |
|
|
| @classmethod |
| def normalize_score(cls, score: float) -> float: |
| return min(max(score, 0), cls.score_cap) / cls.score_cap |
|
|
| @staticmethod |
| def _range(width: int) -> int: |
| return max(3, round(9 / sqrt(width))) |
|
|
| def _in_arc(self, cell: tuple[int, int], start: int, width: int, radius: int) -> bool: |
| dy, dx = cell[0] - self.player[0], cell[1] - self.player[1] |
| direction = atan2(dy, dx) * SECTORS / (2 * pi) |
| return (direction - start) % SECTORS <= width and abs(hypot(dx, dy) - radius) <= 0.75 |
|
|
| 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 |
| self.aim = (self.aim + 1) % SECTORS |
| if action == 5 and self.last_action != 5: |
| self.charge, self.arc_start, self.multiplier = 1, self.aim, 1 |
| elif action == 5 and self.charge: |
| self.charge += 1 |
| if self.charge > MAX_CHARGE: |
| self.charge = 0 |
| elif self.charge: |
| width = self.charge |
| reach = self._range(width) |
| if self.shot is None: |
| self.shot = (self.arc_start, width, reach, 1) |
| angle = (self.arc_start + width / 2) * 2 * pi / SECTORS |
| stride = reach / 2 |
| row, column = self.player |
| self.player = (max(1, min(8, row + round(stride * sin(angle)))), |
| max(1, min(8, column + round(stride * cos(angle))))) |
| self.charge = 0 |
| self.last_action = action |
|
|
| if self.steps % SPAWN_INTERVAL == 1: |
| if self.random.random() < 0.1: |
| self.spawn_index = int(self.random.integers(36)) |
| else: |
| self.spawn_index = (self.spawn_index + int(self.random.integers(-1, 2))) % 36 |
| side, offset = divmod(self.spawn_index, 9) |
| self.enemies.append(((0, offset), (offset, 9), (9, 9 - offset), (9 - offset, 0))[side]) |
| if self.steps % 3 == 0: |
| self.enemies = [(row + int(np.sign(CENTER[0] - row)), column + int(np.sign(CENTER[1] - column))) |
| for row, column in self.enemies] |
|
|
| reward = 0 |
| if self.shot is not None: |
| start, width, reach, radius = self.shot |
| survivors = [] |
| for cell in self.enemies: |
| if self._in_arc(cell, start, width, radius): |
| reward += self.multiplier |
| self.multiplier += 1 |
| else: |
| survivors.append(cell) |
| self.enemies = survivors |
| self.shot = (start, width, reach, radius + 1) if radius < reach else None |
| self.terminal = any(cell in (CENTER, self.player) for cell in self.enemies) |
| self.terminal |= self.steps >= self.horizon |
| return float(reward), self.terminal |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| state[*self.player, 0] = True |
| for cell in self.enemies: |
| state[*cell, 1] = True |
| state[*CENTER, 2] = True |
| for row in range(10): |
| for column in range(10): |
| cell = row, column |
| if self.shot is not None: |
| start, width, _, radius = self.shot |
| state[row, column, 3] = self._in_arc(cell, start, width, radius) |
| if self.charge: |
| state[row, column, 4] = self._in_arc(cell, self.arc_start, self.charge, self._range(self.charge)) |
| values = (self.steps, self.aim, self.charge, self.arc_start, self.multiplier, |
| self.spawn_index, int(self.last_action == 5), *(self.shot or (0, 0, 0, 0))) |
| offset = 0 |
| for value, width in zip(values, (9, 5, 4, 5, 7, 6, 1, 5, 4, 4, 4), strict=True): |
| for bit in range(width): |
| state[offset // 10, offset % 10, 5] = bool(value & (1 << bit)) |
| offset += 1 |
| return state |
|
|
