| from dataclasses import dataclass |
| import math |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| FRAMES_PER_STEP = 4 |
| BRIGADE_LEFT = 10 |
| BRIGADE_RIGHT = 40 |
| BRIDGE_TOP = 32 |
| GROUND = 37 |
|
|
|
|
| @dataclass |
| class Bridge: |
| x: float |
| length: float |
|
|
| def overlaps_brigade(self) -> bool: |
| return self.x <= BRIGADE_RIGHT and self.x + self.length >= BRIGADE_LEFT |
|
|
|
|
| class BridgeCrossEnvironment: |
| 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.score_timer = 0 |
| self.spawn_timer = 0.0 |
| self.multiplier = 1 |
| self.y, self.vy = float(GROUND), 0.0 |
| self.pressed = self.jumping = self.falling = self.on_bridge = self.terminal = False |
| self.bridges: list[Bridge] = [] |
|
|
| @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: |
| if self.spawn_timer <= 0: |
| self.bridges.append(Bridge(153, self.random.uniform(20, 40))) |
| self.spawn_timer = self.random.uniform(50, 100) |
| self.spawn_timer -= 1 |
| for bridge in self.bridges: |
| bridge.x -= 1 |
| self.bridges = [bridge for bridge in self.bridges if bridge.x + bridge.length > 0] |
| above_bridge = any(bridge.overlaps_brigade() for bridge in self.bridges) |
|
|
| if self.y < 35 and not above_bridge: |
| self.falling, self.on_bridge = True, False |
| if self.jumping or self.falling: |
| self.y += self.vy |
| self.vy += 0.1 if self.pressed else 0.2 |
| surface = BRIDGE_TOP if above_bridge else GROUND |
| if self.y > surface and self.vy > 0: |
| self.y, self.vy = float(surface), 0.0 |
| self.jumping = self.falling = False |
| self.on_bridge = above_bridge |
|
|
| if tap and not self.jumping: |
| self.jumping, self.on_bridge = True, False |
| self.vy = -2 |
| self.multiplier = math.ceil(self.multiplier / 2) |
| if not self.jumping and self.y > BRIDGE_TOP and above_bridge: |
| self.terminal = True |
|
|
| if self.on_bridge: |
| self.score_timer -= 1 |
| if self.score_timer < 0: |
| reward = self.multiplier |
| self.multiplier += 1 |
| self.score_timer = 10 |
| return reward |
| return 0 |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| row = int(self.y) // 5 |
| state[row, :3, 0] = True |
| state[row, :3, 3] = self.on_bridge |
| state[8:, :, 2] = True |
| for bridge in self.bridges: |
| for column in range(10): |
| state[7, column, 1] |= column * 15 < bridge.x + bridge.length and (column + 1) * 15 > bridge.x |
| state[0, :3, 4] = self.pressed, self.jumping, self.vy < 0 |
| for row, value in enumerate((self.steps, self.multiplier, self.score_timer)): |
| for bit in range(9): |
| state[row, bit, 5] = bool(value & (1 << bit)) |
| return state |
|
|
