| from dataclasses import dataclass |
| from math import cos, pi, sin |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| ANGLES = 32 |
|
|
|
|
| @dataclass |
| class EscapeBar: |
| angle: int |
| inner: int |
| outer: int |
| speed: int = 2 |
|
|
|
|
| class AntLionEnvironment: |
| score_cap = HORIZON * (HORIZON + 1) |
|
|
| 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.angle, self.radius = 8, 32 |
| self.steps = self.last_action = self.velocity = self.multiplier = 0 |
| self.spawn_in = 1 |
| self.bars: list[EscapeBar] = [] |
| self.attached: EscapeBar | None = None |
| self.offset = 0 |
| self.terminal = False |
|
|
| @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.last_action = action |
| self.steps += 1 |
| if self.attached is None: |
| self.velocity = max(-2, min(2, self.velocity + (1 if action == 5 else -1))) |
| self.angle = (self.angle + self.velocity) % ANGLES |
| self.radius -= 2 if self.radius > 40 else 1 |
| if self.radius <= 3: |
| self.terminal = True |
| return 0.0, True |
| self.spawn_in -= 1 |
| if not self.spawn_in: |
| self.bars.append(EscapeBar(int(self.random.integers(ANGLES)), 42, |
| 42 + int(self.random.integers(8, 17)))) |
| self.spawn_in = max(8, int(self.random.integers(14, 20)) - self.steps // 80) |
| remaining = [] |
| for bar in self.bars: |
| if self.steps % 4 == 0: |
| bar.angle = (bar.angle - 1) % ANGLES |
| movement = bar.speed + int(bar.inner > 40) |
| bar.inner = max(0, bar.inner - movement) |
| bar.outer -= movement |
| if bar.outer >= 0: |
| remaining.append(bar) |
| else: |
| self.multiplier = max(1, self.multiplier - 1) if self.multiplier else 0 |
| if self.attached is bar: |
| self.attached = None |
| self.bars = remaining |
| if self.attached is not None: |
| bar = self.attached |
| self.offset += 3 |
| if self.steps % 5 == 0: |
| bar.speed = min(3, bar.speed + 1) |
| self.angle, self.radius = bar.angle, bar.inner + self.offset |
| if self.radius > bar.outer + 3: |
| self.attached = None |
| reward = 0 |
| if self.attached is None and self.radius > 3: |
| for bar in self.bars: |
| separation = (self.angle - bar.angle) % ANGLES |
| if min(separation, ANGLES - separation) <= 1 and bar.inner <= self.radius <= bar.outer: |
| self.attached = bar |
| self.offset = self.radius - bar.inner |
| self.multiplier += 2 |
| reward = self.multiplier |
| break |
| self.terminal = self.radius <= 3 or self.steps >= self.horizon |
| return float(reward), self.terminal |
|
|
| @staticmethod |
| def _cell(angle: int, radius: int) -> tuple[int, int]: |
| radians = angle * 2 * pi / ANGLES |
| return round(4.5 + sin(radians) * radius / 9), round(4.5 + cos(radians) * radius / 9) |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| row, column = self._cell(self.angle, self.radius) |
| state[max(0, min(9, row)), max(0, min(9, column)), 0] = True |
| state[4:6, 4:6, 1] = True |
| for bar in self.bars: |
| for radius in range(bar.inner, bar.outer + 1): |
| row, column = self._cell(bar.angle, radius) |
| if 0 <= row < 10 and 0 <= column < 10: |
| state[row, column, 3 if bar is self.attached else 2] = True |
| values = (self.angle, self.radius, self.velocity + 2, self.offset, |
| self.multiplier, self.steps, self.spawn_in, self.last_action) |
| for row, value in enumerate(values): |
| for bit in range(10): |
| state[row, bit, 5] = bool(value & (1 << bit)) |
| return state |
|
|
