| from dataclasses import dataclass |
| import math |
|
|
| import numpy as np |
|
|
|
|
| HORIZON = 400 |
| FRAMES_PER_STEP = 4 |
| MIN_SPAWN_INTERVAL = 70 |
| MAX_HARVEST = 100 |
| TRACK_WIDTH = 200 |
|
|
|
|
| @dataclass |
| class Stalk: |
| x: int |
| height: float = 0 |
| speed: float = 1 |
|
|
|
|
| class BambooEnvironment: |
| score_cap = math.ceil(HORIZON * FRAMES_PER_STEP / MIN_SPAWN_INTERVAL) * MAX_HARVEST |
|
|
| 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.pressed = self.terminal = False |
| self.x = 190.0 |
| self.direction = 1 |
| self.boost = 0.0 |
| self.stalks: list[Stalk] = [] |
|
|
| @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 |
| if pressed and not self.pressed: |
| self.direction *= -1 |
| self.pressed = pressed |
| 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: |
| self.x = (self.x + self.direction * (1 + self.boost)) % TRACK_WIDTH |
| self.boost *= 0.9 |
| if self.spawn_timer == 0: |
| self.stalks.append(Stalk(int(self.random.integers(5, 195)))) |
| self.spawn_timer = int(self.random.integers(MIN_SPAWN_INTERVAL, 101)) |
| self.spawn_timer -= 1 |
|
|
| reward = 0 |
| survivors = [] |
| for stalk in self.stalks: |
| stalk.height += 0.14 * stalk.speed |
| distance = abs(self.x - stalk.x) |
| if not self.pressed and min(distance, TRACK_WIDTH - distance) <= 6: |
| if 5 <= stalk.height <= 25: |
| grade = math.ceil((stalk.height - 5) / 3) |
| reward += MAX_HARVEST if grade == 7 else grade**2 |
| continue |
| if stalk.height > 25: |
| stalk.height *= 0.7 |
| stalk.speed *= 0.6 |
| self.direction *= -1 |
| self.boost = min(5, self.boost + 1) |
| if stalk.height <= 25: |
| continue |
| if stalk.height > 50: |
| stalk.speed *= 0.997 |
| if stalk.height >= 89: |
| self.terminal = True |
| survivors.append(stalk) |
| self.stalks = survivors |
| return reward |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| column = int(self.x) // 20 |
| state[8, column, 0] = True |
| state[8, column, 1] = self.direction < 0 |
| for stalk in self.stalks: |
| column = stalk.x // 20 |
| height = max(1, math.ceil(stalk.height / 10)) |
| state[9 - height:9, column, 2] = True |
| state[9 - height, column, 3] |= 5 <= stalk.height <= 25 |
| state[9 - height, column, 4] |= 23 < stalk.height <= 25 |
| state[9, 0, 5] = self.pressed |
| for bit in range(9): |
| state[9, bit + 1, 5] = bool(self.steps & (1 << bit)) |
| return state |
|
|
