| from dataclasses import dataclass |
| import math |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| FRAMES_PER_STEP = 4 |
|
|
|
|
| @dataclass |
| class Body: |
| x: float |
| y: float |
| vx: float = 0 |
| vy: float = 0 |
|
|
|
|
| @dataclass |
| class Blast: |
| x: float |
| y: float |
| age: int = 0 |
|
|
| @property |
| def radius(self) -> float: |
| return 25 * math.sin(self.age * 0.15) |
|
|
| def hits(self, x: float, y: float, tolerance: float) -> bool: |
| return abs(math.hypot(x - self.x, y - self.y) - self.radius) <= tolerance |
|
|
|
|
| class BombUpEnvironment: |
| 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.spawn_timer = 0 |
| self.multiplier = 1 |
| self.pressed = self.terminal = False |
| self.player = Body(50, 50) |
| self.spawner = Body(80, 0) |
| self.bomb: Body | None = None |
| self.blast: Blast | None = None |
| self.rocks: list[Body] = [] |
|
|
| @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 |
|
|
| @staticmethod |
| def _bounce(body: Body) -> None: |
| if (body.x < 7 and body.vx < 0) or (body.x > 93 and body.vx > 0): |
| body.x = min(93, max(7, body.x)) |
| body.vx *= -0.7 |
|
|
| def _tap(self) -> None: |
| player = self.player |
| if self.bomb is None: |
| direction = -1 if player.vx < 0 else 1 |
| self.bomb = Body(player.x + 2 * direction, player.y, player.vx + 0.5 * direction, player.vy) |
| self.multiplier = 1 |
| return |
| self.blast = Blast(self.bomb.x, self.bomb.y) |
| dx, dy = player.x - self.bomb.x, player.y - self.bomb.y |
| distance_squared = max(1, dx * dx + dy * dy) |
| player.vx += 20 * dx / distance_squared |
| player.vy += 20 * dy / distance_squared |
| self.bomb = None |
|
|
| def _advance_frame(self, tap: bool) -> int: |
| player = self.player |
| scroll = (40 - player.y) * 0.3 if player.y < 40 else min(0, (60 - player.y) * 0.2) |
| self._bounce(player) |
| player.vx *= 0.99 |
| player.vy = (player.vy + 0.02) * 0.99 |
| player.x += player.vx |
| player.y += player.vy + scroll |
| if tap: |
| self._tap() |
| if self.bomb is not None: |
| bomb = self.bomb |
| self._bounce(bomb) |
| bomb.vx *= 0.98 |
| bomb.vy = (bomb.vy + 0.15) * 0.98 |
| bomb.x += bomb.vx |
| bomb.y += bomb.vy + scroll |
| if bomb.y > 103: |
| self.bomb = None |
| if self.blast is not None: |
| self.blast.age += 1 |
| if self.blast.radius < 0: |
| self.blast = None |
|
|
| self.spawner.vx = (self.spawner.vx + self.random.uniform(-0.1, 0.1)) * 0.99 |
| self.spawner.x += self.spawner.vx |
| self._bounce(self.spawner) |
| if self.spawn_timer == 0: |
| bottom = self.random.random() > (0.05 if player.y > 30 else 0.9) |
| y = 103 if bottom else -3 |
| vy = -self.random.uniform(0.5, 1) if bottom else player.vy / 2 |
| self.rocks.append(Body(self.spawner.x, y, vy=vy)) |
| self.spawn_timer = int(self.random.integers(8, 11)) |
| self.spawn_timer -= 1 |
|
|
| reward = 0 |
| remaining = [] |
| for rock in self.rocks: |
| rock.y += rock.vy |
| rock.vy = (rock.vy + 0.01) * 0.99 |
| rock.y += rock.vy + scroll |
| if self.blast is not None and self.blast.hits(rock.x, rock.y, 3.5): |
| reward += self.multiplier |
| self.multiplier += 1 |
| continue |
| if abs(rock.x - player.x) < 5.5 and abs(rock.y - player.y) < 5.5: |
| self.terminal = True |
| if -50 <= rock.y <= 150: |
| remaining.append(rock) |
| self.rocks = remaining |
| return reward |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| row = min(9, max(0, int(self.player.y) // 10)) |
| column = min(9, max(0, int(self.player.x) // 10)) |
| state[row, column, 0] = True |
| state[row, column, 4] = self.player.vy < 0 |
| if self.bomb is not None and 0 <= self.bomb.x < 100 and 0 <= self.bomb.y < 100: |
| state[int(self.bomb.y) // 10, int(self.bomb.x) // 10, 1] = True |
| for rock in self.rocks: |
| if 0 <= rock.y < 100: |
| state[int(rock.y) // 10, int(rock.x) // 10, 2] = True |
| if self.blast is not None: |
| for y in range(10): |
| for x in range(10): |
| state[y, x, 3] = self.blast.hits(x * 10 + 5, y * 10 + 5, 7) |
| for row, value in enumerate((self.steps, self.multiplier)): |
| for bit in range(9): |
| state[row, bit, 5] = bool(value & (1 << bit)) |
| state[9, :3, 5] = self.pressed, self.bomb is not None, self.player.vx < 0 |
| return state |
|
|
