| from dataclasses import dataclass |
| import math |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| FRAMES_PER_STEP = 4 |
| BLAST_RADIUS = 25 |
|
|
|
|
| @dataclass |
| class Submarine: |
| x: float |
| y: float |
| vx: float |
| fire_timer: int |
|
|
|
|
| @dataclass |
| class Bullet: |
| x: float |
| y: float |
| vx: float |
|
|
|
|
| class BlastBuoyEnvironment: |
| 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.spawn_timer = self.combo_timer = self.shield = self.freeze = 0 |
| self.combo = 1 |
| self.pressed = self.terminal = False |
| self.x, self.y = 30.0, 40.0 |
| self.vx = self.vy = 0.0 |
| self.submarines: list[Submarine] = [] |
| self.bullets: list[Bullet] = [] |
|
|
| @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 |
| self.vy = min(1.1, max(-1.1, self.vy + (0.06 if self.pressed else -0.05))) |
| self.vx *= 0.95 |
| self.x = min(95, max(5, self.x + self.vx)) |
| self.y = min(87, max(13, self.y + self.vy)) |
| if self.y in (13, 87): |
| self.vy = 0 |
|
|
| self.shield = max(0, self.shield - 1) |
| if self.combo_timer: |
| self.combo_timer -= 1 |
| else: |
| self.combo = 1 |
|
|
| if not self.spawn_timer: |
| direction = int(self.random.choice((-1, 1))) |
| self.submarines.append(Submarine( |
| -8 if direction > 0 else 108, |
| self.random.uniform(13, 87), |
| direction * self.random.uniform(0.2, 0.45), |
| int(self.random.integers(60, 121)), |
| )) |
| self.spawn_timer = int(self.random.integers(50, 91)) |
| self.spawn_timer -= 1 |
|
|
| contact = None |
| for sub in self.submarines: |
| sub.x += sub.vx |
| sub.fire_timer -= 1 |
| if sub.fire_timer < 0 and 0 < sub.x < 100 and abs(sub.y - self.y) < 10: |
| if math.hypot(sub.x - self.x, sub.y - self.y) > 36: |
| direction = 1 if self.x > sub.x else -1 |
| self.bullets.append(Bullet(sub.x + direction * 6, sub.y, direction * 0.95)) |
| sub.fire_timer = int(self.random.integers(90, 151)) |
| if contact is None and not self.shield and abs(sub.x - self.x) < 7.5 and abs(sub.y - self.y) < 5: |
| contact = sub |
|
|
| self.submarines = [sub for sub in self.submarines if -12 <= sub.x <= 112] |
| reward = self._blast(contact) if contact is not None else 0 |
|
|
| survivors = [] |
| for bullet in self.bullets: |
| bullet.x += bullet.vx |
| if abs(bullet.x - self.x) < 5.5 and abs(bullet.y - self.y) < 4: |
| self.terminal |= not self.shield |
| elif -5 <= bullet.x <= 105: |
| survivors.append(bullet) |
| self.bullets = survivors |
| return reward |
|
|
| def _blast(self, center: Submarine) -> int: |
| self.submarines.remove(center) |
| remaining = [ |
| sub for sub in self.submarines |
| if math.hypot(sub.x - center.x, sub.y - center.y) >= BLAST_RADIUS |
| ] |
| extras = len(self.submarines) - len(remaining) |
| self.submarines = remaining |
| self.bullets = [ |
| bullet for bullet in self.bullets |
| if math.hypot(bullet.x - center.x, bullet.y - center.y) >= BLAST_RADIUS |
| ] |
| reward = (5 + 8 * extras) * self.combo |
| self.combo += 1 |
| self.combo_timer = 120 |
| angle = math.atan2(self.y - center.y, self.x - center.x) |
| self.vx, self.vy = 2.2 * math.cos(angle), 2.2 * math.sin(angle) |
| self.shield = 40 |
| self.freeze = min(8, 3 + extras) |
| 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.shield > 0 |
| for sub in self.submarines: |
| if 0 <= sub.x < 100: |
| state[int(sub.y) // 10, int(sub.x) // 10, 1 if sub.vx > 0 else 2] = True |
| for bullet in self.bullets: |
| if 0 <= bullet.x < 100: |
| state[int(bullet.y) // 10, int(bullet.x) // 10, 3] = True |
| for row, value in enumerate((self.steps, self.combo, self.combo_timer, self.shield, self.freeze)): |
| for bit in range(9): |
| state[row, bit, 5] = bool(value & (1 << bit)) |
| state[9, :2, 5] = self.pressed, self.vy > 0 |
| return state |
|
|
