| from dataclasses import dataclass |
| import math |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| FRAMES_PER_STEP = 4 |
|
|
|
|
| @dataclass |
| class Block: |
| x: float |
| y: float |
| width: float |
|
|
|
|
| class BlockStackerEnvironment: |
| score_cap = 50 |
|
|
| 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.stacked = 0 |
| self.pressed = self.falling = self.terminal = False |
| self.angle = self.vx = self.vy = self.drift = 0.0 |
| self.current = Block(50, 25, self.random.uniform(10, 30)) |
| self.tower = [Block(50, 99, 99)] |
|
|
| @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 |
|
|
| def _advance_frame(self, tap: bool) -> int: |
| difficulty = 1 + self.stacked / 50 |
| self.angle += 0.05 * difficulty |
| previous_y = self.current.y |
| if self.falling: |
| self.current.x += self.vx * difficulty |
| self.current.y += self.vy * difficulty |
| self.vy += 0.1 |
| else: |
| swing = math.sin(self.angle) |
| self.current.x = 50 - 20 * math.sin(swing) |
| self.current.y = 5 + 20 * math.cos(swing) |
| if tap: |
| self.falling = True |
| self.vx, self.vy = -math.cos(self.angle), 0.0 |
|
|
| for block in self.tower: |
| block.x = (block.x + self.drift) % 100 |
| top = min(block.y for block in self.tower) |
| reward = 0 |
| if self.falling: |
| for block in sorted(self.tower, key=lambda block: block.y): |
| distance = abs((self.current.x - block.x + 50) % 100 - 50) |
| if previous_y <= block.y - 10 <= self.current.y and distance < (self.current.width + block.width) / 2: |
| self.current.y = block.y - 10 |
| self.tower.append(self.current) |
| self.current = Block(50, 25, self.random.uniform(10, 30)) |
| self.falling = False |
| self.stacked += 1 |
| self.drift = self.random.uniform(-1, 1) * self.stacked / 50 |
| reward = 1 |
| break |
| else: |
| self.terminal = self.current.y > 105 |
| scroll = difficulty * 0.01 + max(0, 70 - top) * 0.1 |
| for block in self.tower: |
| block.y += scroll |
| self.tower = [block for block in self.tower if block.y <= 106] |
| self.terminal |= not self.tower |
| return reward |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| for block in self.tower: |
| self._draw_block(state, block, 0, wraps=True) |
| self._draw_block(state, self.current, 2 if self.falling else 1, wraps=False) |
| if not self.falling: |
| for fraction in np.linspace(0, 1, 8): |
| x = 50 + (self.current.x - 50) * fraction |
| y = (self.current.y - 5) * fraction |
| state[int(y) // 10, int(x) // 10, 3] = True |
| if self.drift < 0: |
| state[:, :, 4] = state[:, :, 0] |
| state[9, 0, 5] = self.pressed |
| for row, value in enumerate((self.steps, self.stacked)): |
| for bit in range(9): |
| state[row, bit, 5] = bool(value & (1 << bit)) |
| state[9, 1, 5] = (self.vx < 0 if self.falling else math.cos(self.angle) > 0) |
| return state |
|
|
| @staticmethod |
| def _draw_block(state: np.ndarray, block: Block, channel: int, wraps: bool) -> None: |
| for row in range(10): |
| if row * 10 < block.y + 5 and (row + 1) * 10 > block.y - 5: |
| for column in range(10): |
| dx = column * 10 + 5 - block.x |
| distance = abs((dx + 50) % 100 - 50) if wraps else abs(dx) |
| state[row, column, channel] |= distance < block.width / 2 + 5 |
|
|
