| from dataclasses import dataclass |
| import math |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| FRAMES_PER_STEP = 4 |
|
|
|
|
| @dataclass |
| class Bubble: |
| x: float |
| y: float |
| size: float |
|
|
|
|
| class BlazeThrustEnvironment: |
| score_cap = 250 |
|
|
| 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.hold_time = 0 |
| self.pressed = self.terminal = False |
| self.x, self.y = 50.0, 90.0 |
| self.vx = self.vy = 0.0 |
| self.size = 9.0 |
| self.multiplier = 1 |
| self.next_bubble = self.random.uniform(10, 40) |
| self.winds = [(0.0, self.random.uniform(20, 40))] |
| self.bubbles: list[Bubble] = [] |
|
|
| @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 _wind_left(self, y: float) -> bool: |
| return any(top <= y <= bottom for top, bottom in self.winds) |
|
|
| def _advance_frame(self) -> int: |
| self.vy += -0.1 if self.pressed else 0.1 |
| self.hold_time = self.hold_time + 1 if self.pressed else max(0, self.hold_time - 3) |
| scroll = max(0, (60 - self.y) * 0.1) |
| self.x += self.vx |
| self.y += self.vy + scroll |
| self.vx *= 0.95 |
| self.vy *= 0.95 |
| if self.x < 5: |
| self.x, self.vx = 10, abs(self.vx) * 0.5 |
| elif self.x > 95: |
| self.x, self.vx = 90, -abs(self.vx) * 0.5 |
| if self.y > 95: |
| self.y, self.vy = 90, -abs(self.vy) * 0.3 |
|
|
| if scroll: |
| self.winds = [(top + scroll, bottom + scroll) for top, bottom in self.winds if top + scroll < 120] |
| top = self.winds[0][0] |
| if top >= 0: |
| bottom = top - self.random.uniform(20, 40) |
| self.winds.insert(0, (bottom - self.random.uniform(20, 40), bottom)) |
| self.vx += self.size * (-0.02 if self._wind_left(self.y) else 0.02) |
| self.size *= 1 - 0.0016 * (1 + self.hold_time * 0.01) |
| if self.size <= 2: |
| self.terminal = True |
| return 0 |
|
|
| reward = self._advance_bubbles(scroll) |
| if scroll and len(self.bubbles) < 15: |
| self.next_bubble -= scroll |
| if self.next_bubble <= 0: |
| size = self.random.uniform(3, 9) |
| self.bubbles.append(Bubble(self.random.uniform(10, 90), -size, size)) |
| self.next_bubble = self.random.uniform(5, 55) |
| return reward |
|
|
| def _advance_bubbles(self, scroll: float) -> int: |
| reward = 0 |
| remaining = [] |
| for bubble in self.bubbles: |
| bubble.y += scroll + 0.3 - (bubble.size - 3) * 0.015 |
| bubble.x += bubble.size * (-0.02 if self._wind_left(bubble.y) else 0.02) |
| bubble.x = min(95, max(5, bubble.x)) |
| if math.hypot(bubble.x - self.x, bubble.y - self.y) <= bubble.size + self.size: |
| reward += self.multiplier |
| self.multiplier = min(16, self.multiplier + 1) |
| self.size = min(25, self.size + bubble.size * 0.2) |
| elif bubble.y > 120: |
| self.multiplier = 1 |
| else: |
| remaining.append(bubble) |
| self.bubbles = remaining |
| return reward |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| row, column = int(self.y) // 10, int(self.x) // 10 |
| state[row, column, 0] = True |
| state[row, column, 4] = self.vy < 0 |
| for row in range(10): |
| state[row, :, 1 if self._wind_left(10 * row + 5) else 2] = True |
| for bubble in self.bubbles: |
| if 0 <= bubble.y < 100: |
| state[int(bubble.y) // 10, int(bubble.x) // 10, 3] = True |
| for row, value in enumerate((round(self.size * 10), self.multiplier, self.hold_time, self.steps)): |
| for bit in range(10): |
| state[row, bit, 5] = bool(value & (1 << bit)) |
| state[row + 4, 0, 5] = bool(value & 1024) |
| state[9, 0, 5] = self.pressed |
| return state |
|
|
