| from dataclasses import dataclass |
| import math |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| FRAMES_PER_STEP = 4 |
| DIAGONAL = math.sqrt(0.5) |
|
|
|
|
| @dataclass |
| class Bar: |
| x: float |
| y: float |
| width: float |
| passed: bool = False |
|
|
|
|
| class CatapultEnvironment: |
| score_cap = 500 |
|
|
| 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 = self.passed_count = 0 |
| self.pressed = self.terminal = False |
| self.x, self.y, self.vx, self.vy = 200.0, 60.0, 0.0, 0.0 |
| self.bar_position, self.base_score, self.next_bar = -10.0, 1.0, 50.0 |
| self.support: Bar | None = Bar(200, 60, 20, passed=True) |
| self.bars = [self.support] |
|
|
| @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 |
| pressed = self.pressed if self.random.random() < self.sticky_action_prob else action == 5 |
| tap = pressed and not self.pressed |
| self.pressed = pressed |
| self.steps += 1 |
| reward = 0 |
| for frame in range(FRAMES_PER_STEP): |
| reward += self._advance_frame(tap and frame == 0) |
| if self.terminal: |
| break |
| self.terminal |= self.steps >= self.horizon |
| return float(reward), self.terminal |
|
|
| def _advance_frame(self, tap: bool) -> int: |
| scroll = 0.05 + max(0, self.x - 30) * 0.1 |
| slope = 1 if self.pressed else -1 |
| self.x -= scroll |
| if self.support is not None: |
| self.bar_position -= slope * 0.2 |
| self.base_score = max(1, self.base_score - 0.5) |
| self.x = self.support.x + slope * (4 - self.bar_position) * DIAGONAL |
| self.y = self.support.y - (4 + self.bar_position) * DIAGONAL |
| if abs(self.bar_position) > self.support.width * 0.65: |
| self.support = None |
| self.vx = self.vy = 0.0 |
| elif tap and self.bar_position > 0: |
| self.vx = math.sqrt(self.bar_position) * DIAGONAL |
| self.vy = -self.vx |
| self.x += self.vx |
| self.y += self.vy |
| self.support = None |
| self.passed_count = 0 |
| else: |
| self.x += self.vx |
| self.y += self.vy |
| self.vy += 0.1 |
| self.base_score += self.vx * 0.1 |
|
|
| if self.y > 99 or self.x < 0: |
| self.terminal = True |
| return 0 |
|
|
| reward = 0 |
| for bar in self.bars: |
| bar.x -= scroll |
| dx, dy = self.x - bar.x, self.y - bar.y |
| if self.support is None and abs(dy - slope * dx) * DIAGONAL < 4 and abs(dx + slope * dy) * DIAGONAL < bar.width / 2 + 2: |
| self.support = bar |
| offset = math.hypot(dx - slope * 4 * DIAGONAL, dy + 4 * DIAGONAL) |
| self.bar_position = max(-bar.width * 0.4, min(bar.width * 0.4, offset if dx <= slope * 4 * DIAGONAL else -offset)) |
| reward += math.ceil(self.base_score) |
| bar.passed = True |
| if not bar.passed and bar.x + bar.width / 2 < self.x: |
| bar.passed = True |
| self.passed_count += 1 |
| bonus = 10 * self.passed_count |
| reward += bonus |
| self.base_score += bonus |
| self.bars = [bar for bar in self.bars if bar.x >= -bar.width / 2] |
|
|
| self.next_bar -= scroll |
| if self.next_bar < 0: |
| width = self.random.uniform(20, 30) |
| self.bars.append(Bar(200 + width / 2, self.random.uniform(50, 90), width)) |
| self.next_bar += width / 2 + self.random.uniform(30, 50) |
| return reward |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| row = min(9, max(0, int(self.y) // 10)) |
| column = min(9, max(0, int(self.x) // 20)) |
| state[row, column, 0] = True |
| state[row, column, 3] = self.support is not None |
| slope = 1 if self.pressed else -1 |
| for bar in self.bars: |
| for distance in np.linspace(-bar.width / 2, bar.width / 2, 9): |
| x = bar.x + distance * DIAGONAL |
| y = bar.y + slope * distance * DIAGONAL |
| if 0 <= x < 200 and 0 <= y < 100: |
| state[int(y) // 10, int(x) // 20, 1 if bar.passed else 2] = True |
| for row, value in enumerate((self.steps, round((self.bar_position + 32) * 4), math.ceil(self.base_score), self.passed_count)): |
| for bit in range(9): |
| state[row, bit, 5] = bool(value & (1 << bit)) |
| state[9, :3, 4] = self.pressed, self.vy < 0, self.bar_position > 0 |
| return state |
|
|
