| from dataclasses import dataclass |
| import math |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| FRAMES_PER_STEP = 4 |
| SPOKES = 6 |
|
|
|
|
| @dataclass |
| class Falling: |
| x: float |
| y: float = 0 |
| vy: float = 0 |
|
|
| def advance(self) -> None: |
| self.vy += 0.02 |
| self.y += self.vy |
|
|
| def near(self, x: float, y: float, radius: float) -> bool: |
| return math.hypot(self.x - x, self.y - y) < radius |
|
|
|
|
| class CatchingWheelEnvironment: |
| score_cap = 150 |
|
|
| 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.steps = 0 |
| self.angle = 0.0 |
| self.human_timer, self.obstacle_timer = 40.0, 99.0 |
| self.multiplier = 1 |
| self.pressed = self.terminal = False |
| self.baskets = [True] * SPOKES |
| self.humans: list[Falling] = [] |
| self.obstacles: list[Falling] = [] |
|
|
| @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: |
| self.pressed = action == 5 |
| self.steps += 1 |
| reward = 0 |
| for _ in range(FRAMES_PER_STEP): |
| reward += self._advance_frame() |
| if self.terminal: |
| break |
| self.terminal |= self.steps >= self.horizon |
| return float(reward), self.terminal |
|
|
| def _positions(self) -> list[tuple[float, float]]: |
| angles = (self.angle + index * math.tau / SPOKES for index in range(SPOKES)) |
| return [(50 + 40 * math.cos(angle), 90 + 40 * math.sin(angle)) for angle in angles] |
|
|
| def _change_basket(self, restore: bool) -> None: |
| start = int(self.random.integers(SPOKES)) |
| for offset in range(SPOKES): |
| index = (start + offset) % SPOKES |
| if self.baskets[index] != restore: |
| self.baskets[index] = restore |
| if not restore: |
| self.multiplier = 1 |
| break |
|
|
| def _advance_frame(self) -> int: |
| self.obstacle_timer -= 1 |
| if self.obstacle_timer <= 0: |
| self.obstacles.append(Falling(self.random.uniform(20, 80))) |
| self.obstacle_timer = self.random.uniform(79.2, 118.8) |
| for obstacle in self.obstacles: |
| obstacle.advance() |
| self.obstacles = [obstacle for obstacle in self.obstacles if obstacle.y <= 95] |
|
|
| if self.pressed: |
| self.angle = (self.angle + 0.05) % math.tau |
| positions = self._positions() |
| for index, (x, y) in enumerate(positions): |
| if self.baskets[index] and any(obstacle.near(x, y, 9) for obstacle in self.obstacles): |
| self.baskets[index] = False |
| self.multiplier = 1 |
| catchable = [point for point, live in zip(positions, self.baskets) if live] |
|
|
| self.human_timer -= 1 |
| if self.human_timer <= 0: |
| self.humans.append(Falling(self.random.uniform(10, 90))) |
| self.human_timer = self.random.uniform(28, 40) |
| reward = 0 |
| remaining = [] |
| for human in self.humans: |
| human.advance() |
| if any(obstacle.near(human.x, human.y, 5) for obstacle in self.obstacles): |
| continue |
| if any(human.near(x, y, 6) for x, y in catchable): |
| reward += self.multiplier |
| self.multiplier += 1 |
| self._change_basket(restore=True) |
| elif human.y > 100: |
| self._change_basket(restore=False) |
| else: |
| remaining.append(human) |
| self.humans = remaining |
| self.terminal = not any(self.baskets) |
| return reward |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| state[9, 5, 0] = True |
| for live, (x, y) in zip(self.baskets, self._positions()): |
| if 0 <= y < 100: |
| state[int(y) // 10, int(x) // 10, 1 if live else 2] = True |
| for channel, objects in ((3, self.humans), (4, self.obstacles)): |
| for obj in objects: |
| if obj.y < 100: |
| state[int(obj.y) // 10, int(obj.x) // 10, channel] = True |
| for row, value in enumerate((self.steps, self.multiplier, round(self.angle * 80))): |
| for bit in range(9): |
| state[row, bit, 5] = bool(value & (1 << bit)) |
| state[9, :SPOKES, 5] = self.baskets |
| state[9, SPOKES, 5] = self.pressed |
| return state |
|
|
