| from dataclasses import dataclass |
| import math |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| FRAMES_PER_STEP = 4 |
|
|
|
|
| @dataclass |
| class Board: |
| x: float |
| y: float |
| slope: int |
|
|
|
|
| @dataclass |
| class Passenger: |
| x: float |
| y: float |
| kind: int |
| vx: float = 0 |
| vy: float = 0 |
| bounces: int = 0 |
|
|
|
|
| class BoardingEnvironment: |
| 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.cooldown = 0 |
| self.pressed = self.ready = self.terminal = False |
| self.x, self.direction, self.kind = 50.0, -1, -1 |
| self.gate = self.gate_target = 91.0 |
| self.board_credit = 0 |
| self.boards: list[Board] = [] |
| self.passengers: list[Passenger] = [] |
| for y in range(47, 88, 2): |
| self._add_board(y) |
|
|
| def _add_board(self, y: float) -> None: |
| x = self.random.uniform(9, 90) |
| if all(math.hypot(board.x - x, board.y - y) >= 16 for board in self.boards): |
| self.boards.append(Board(x, y, int(self.random.choice((-1, 1))))) |
|
|
| @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 |
| released = self.pressed and not pressed |
| self.pressed = pressed |
| self.steps += 1 |
| reward = 0 |
| for frame in range(FRAMES_PER_STEP): |
| reward += self._advance_frame(released and frame == 0) |
| if self.terminal: |
| break |
| self.terminal |= self.steps >= self.horizon |
| return float(reward), self.terminal |
|
|
| def _advance_frame(self, released: bool) -> int: |
| for board in self.boards: |
| board.y -= 0.1 |
| self.boards = [board for board in self.boards if 15 < board.y < self.gate] |
| self.gate_target = max(11, self.gate_target - 0.1) |
| self.gate += (self.gate_target - self.gate) * 0.1 |
| if self.gate <= 12: |
| self.terminal = True |
| return 0 |
| if self.board_credit >= 2: |
| self._add_board(self.gate - 3) |
| self.board_credit -= 2 |
|
|
| self.cooldown = max(0, self.cooldown - 1) |
| boarding = self.pressed and self.ready |
| if boarding and not self.cooldown: |
| self.passengers.append(Passenger(self.x, 9, self.kind)) |
| self.cooldown = 10 |
| self.x += self.direction * (0.1 if boarding else 1) |
| if self.x < 10 or self.x > 90: |
| self.direction = 1 if self.x < 10 else -1 |
| if released: |
| if self.ready: |
| self.kind *= -1 |
| self.ready = True |
|
|
| reward = 0 |
| survivors = [] |
| for passenger in self.passengers: |
| self._move_passenger(passenger) |
| if passenger.y <= self.gate: |
| survivors.append(passenger) |
| elif (passenger.x - 50) * passenger.kind > 0: |
| reward += passenger.bounces |
| self.gate_target = min(91, self.gate_target + 2 * passenger.bounces) |
| self.board_credit += passenger.bounces |
| else: |
| reward -= 1 + passenger.bounces |
| self.gate_target -= min(20, math.sqrt(1 + passenger.bounces)) |
| self.passengers = survivors |
| return reward |
|
|
| def _move_passenger(self, passenger: Passenger) -> None: |
| old_x, old_y = passenger.x, passenger.y |
| passenger.vx *= 0.9 |
| passenger.vy = (passenger.vy + 0.2) * 0.9 |
| passenger.x += passenger.vx |
| passenger.y += passenger.vy |
| for board in self.boards: |
| previous = old_y - board.y - board.slope * (old_x - board.x) |
| current = passenger.y - board.y - board.slope * (passenger.x - board.x) |
| if previous > 0 or current < 0 or current == previous: |
| continue |
| crossing_x = old_x + (passenger.x - old_x) * (-previous / (current - previous)) |
| if abs(crossing_x - board.x) <= 4: |
| impulse = math.hypot(passenger.vx, passenger.vy) * math.sqrt(2) |
| passenger.vx += board.slope * impulse |
| passenger.vy += impulse |
| passenger.x += 2 * passenger.vx |
| passenger.y += 2 * passenger.vy |
| passenger.bounces += 1 |
| break |
| if passenger.x < 0 or passenger.x > 99: |
| passenger.x = min(99, max(0, passenger.x)) |
| passenger.vx *= -1 |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| state[0, int(self.x) // 10, 0] = True |
| state[int(self.gate) // 10, :, 1] = True |
| for board in self.boards: |
| state[int(board.y) // 10, int(board.x) // 10, 2 if board.slope < 0 else 3] = True |
| for passenger in self.passengers: |
| state[int(passenger.y) // 10, int(passenger.x) // 10, 4 if passenger.kind < 0 else 5] = True |
| state[0, :4, 1] = self.kind > 0, self.direction > 0, self.ready, self.pressed |
| return state |
|
|
