| from dataclasses import dataclass |
| import math |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| FRAMES_PER_STEP = 4 |
| PLAYER_X = 35 |
| SCROLL = 0.6 |
|
|
|
|
| @dataclass |
| class Rock: |
| x: float |
| y: float |
| width: float |
| height: float |
| bore: int = 0 |
|
|
| @property |
| def threshold(self) -> int: |
| return round(math.sqrt(self.width * self.height) / (SCROLL / 0.5)) |
|
|
| def contains(self, y: float) -> bool: |
| return abs(self.x - PLAYER_X) < self.width / 2 + 2 and abs(self.y - y) < self.height / 2 + 2 |
|
|
|
|
| @dataclass |
| class Enemy: |
| x: float |
| y: float |
| vx: float |
|
|
|
|
| class BoreCometEnvironment: |
| 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.freeze = 0 |
| self.pressed = self.terminal = self.was_in_rock = False |
| self.y, self.vy = 30.0, 0.0 |
| self.next_rock, self.next_enemy = 20.0, 60 |
| self.rocks: list[Rock] = [] |
| self.enemies: list[Enemy] = [] |
|
|
| @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 _advance_frame(self) -> int: |
| if self.freeze: |
| self.freeze -= 1 |
| return 0 |
| rock = next((rock for rock in reversed(self.rocks) if rock.contains(self.y)), None) |
| if rock is not None and not self.pressed: |
| self.terminal = True |
| return 0 |
|
|
| reward = 0 |
| if self.pressed: |
| self.vy -= 0.06 if rock is not None else 0.11 |
| if rock is not None: |
| rock.bore += 1 |
| reward += 1 |
| if rock.bore >= rock.threshold: |
| reward += rock.threshold + self._blast(15 + (rock.width + rock.height) / 4, 3) |
| self.rocks.remove(rock) |
| rock = None |
| self.vy = min(1.8, max(-1.5, self.vy + 0.05)) |
| self.y += self.vy * (0.45 if rock is not None else 1) |
| if self.y < 10: |
| self.y, self.vy = 10, 0 |
| if self.was_in_rock and rock is None and self.pressed: |
| reward += self._blast(22, 2) |
| self.was_in_rock = rock is not None |
|
|
| self._spawn() |
| for obstacle in self.rocks: |
| obstacle.x -= SCROLL |
| self.rocks = [obstacle for obstacle in self.rocks if obstacle.x >= -20] |
| for enemy in self.enemies: |
| enemy.x += enemy.vx |
| if rock is None and math.hypot(enemy.x - PLAYER_X, enemy.y - self.y) < 5: |
| self.terminal = True |
| self.enemies = [enemy for enemy in self.enemies if enemy.x >= -8] |
| self.terminal |= self.y > 91 |
| return reward |
|
|
| def _blast(self, radius: float, freeze: int) -> int: |
| survivors = [enemy for enemy in self.enemies if math.hypot(enemy.x - PLAYER_X, enemy.y - self.y) >= radius] |
| kills = len(self.enemies) - len(survivors) |
| self.enemies = survivors |
| if kills or freeze == 3: |
| self.freeze = max(self.freeze, min(8, freeze + kills)) |
| return 3 * kills**2 |
|
|
| def _spawn(self) -> None: |
| self.next_rock -= SCROLL |
| if self.next_rock < 0: |
| self.rocks.append(Rock(112, self.random.uniform(25, 75), self.random.uniform(14, 30), self.random.uniform(10, 22))) |
| self.next_rock = self.random.uniform(30, 55) |
| self.next_enemy -= 1 |
| if self.next_enemy < 0: |
| self.enemies.append(Enemy(105, self.random.uniform(8, 84), -SCROLL - self.random.uniform(0.2, 0.5))) |
| self.next_enemy = int(self.random.integers(50, 91)) |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| row = int(self.y) // 10 |
| state[row, 3, 0] = True |
| state[row, 3, 4] = self.pressed |
| state[9, :, 3] = True |
| for rock in self.rocks: |
| for row in range(10): |
| if abs(row * 10 + 5 - rock.y) < rock.height / 2 + 5: |
| for column in range(10): |
| state[row, column, 1] |= abs(column * 10 + 5 - rock.x) < rock.width / 2 + 5 |
| for enemy in self.enemies: |
| if 0 <= enemy.x < 100: |
| state[int(enemy.y) // 10, int(enemy.x) // 10, 2] = True |
| active_rock = next((rock for rock in reversed(self.rocks) if rock.contains(self.y)), None) |
| for row, value in enumerate((self.steps, self.freeze, active_rock.bore if active_rock else 0)): |
| for bit in range(9): |
| state[row, bit, 5] = bool(value & (1 << bit)) |
| state[9, :2, 5] = self.vy < 0, self.was_in_rock |
| return state |
|
|
