| from dataclasses import dataclass |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| FRAMES_PER_STEP = 4 |
|
|
|
|
| @dataclass |
| class Spike: |
| x: float |
| y: float |
|
|
|
|
| class BottopEnvironment: |
| score_cap = HORIZON * FRAMES_PER_STEP / 10 |
|
|
| 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.spawn_distance = self.height = self.velocity = 0.0 |
| self.jumping = self.pressed = self.terminal = False |
| self.spikes: list[Spike] = [] |
|
|
| @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 |
| frames = 0 |
| for _ in range(FRAMES_PER_STEP): |
| self._advance_frame() |
| frames += 1 |
| if self.terminal: |
| break |
| self.terminal |= self.steps >= self.horizon |
| return frames / 10, self.terminal |
|
|
| def _advance_frame(self) -> None: |
| self.spawn_distance -= 1 |
| if self.spawn_distance < 0: |
| if self.random.random() < 0.33: |
| y = float(self.random.choice((8, 92))) |
| else: |
| y = self.random.uniform(8, 92) |
| self.spikes.append(Spike(103, y)) |
| self.spawn_distance += self.random.uniform(30, 60) |
| for spike in self.spikes: |
| spike.x -= 1 |
| self.spikes = [spike for spike in self.spikes if spike.x > -3] |
|
|
| if not self.jumping and self.pressed: |
| self.jumping = True |
| self.velocity = 3 |
| if self.jumping: |
| self.velocity -= 0.1 if self.pressed else 0.3 |
| self.height += self.velocity |
| if self.height < 0: |
| self.height = self.velocity = 0 |
| self.jumping = False |
| top, bottom = 8 + self.height, 92 - self.height |
| self.terminal = any( |
| abs(spike.x - 9) < 6 and min(abs(spike.y - top), abs(spike.y - bottom)) < 6 |
| for spike in self.spikes |
| ) |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| state[int(8 + self.height) // 10, 0, 0] = True |
| state[int(92 - self.height) // 10, 0, 1] = True |
| for spike in self.spikes: |
| if 0 <= spike.x < 100: |
| state[int(spike.y) // 10, int(spike.x) // 10, 2] = True |
| state[(0, 9), :, 3] = True |
| state[0, :3, 4] = self.pressed, self.jumping, self.velocity > 0 |
| for bit in range(9): |
| state[9, bit, 5] = bool(self.steps & (1 << bit)) |
| return state |
|
|
