| import numpy as np |
|
|
|
|
| PIN_POSITIONS = ((4, 6), (3, 7), (5, 7), (2, 8), (4, 8), (6, 8), (1, 9), (3, 9), (5, 9), (7, 9)) |
|
|
|
|
| class BowlingEnvironment: |
| """Ten-frame steerable bowling with standard strike, spare, and tenth-frame scoring.""" |
|
|
| score_cap = 300.0 |
|
|
| def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 500): |
| self.sticky_action_prob = sticky_action_prob |
| self.horizon = horizon |
| self.random = np.random.RandomState() |
| self.seed(0) |
| self.reset() |
|
|
| @classmethod |
| def normalize_score(cls, raw_score: float) -> float: |
| return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap |
|
|
| def seed(self, seed: int) -> None: |
| self.random.seed(seed) |
|
|
| def reset(self) -> None: |
| self.bowler_row = 4 |
| self.ball: list[int] | None = None |
| self.previous_ball: list[int] | None = None |
| self.hook = 0 |
| self.standing = set(range(10)) |
| self.frames: list[list[int]] = [[] for _ in range(10)] |
| self.frame = 0 |
| self.confirmed_score = 0 |
| self.steps = 0 |
| self.last_action = 0 |
| self.terminal = False |
|
|
| def act(self, action: int) -> tuple[float, bool]: |
| if self.terminal: |
| return 0.0, True |
| if self.random.rand() < self.sticky_action_prob: |
| action = self.last_action |
| self.last_action = action |
| if self.ball is None: |
| if action == 2: |
| self.bowler_row = max(1, self.bowler_row - 1) |
| elif action == 4: |
| self.bowler_row = min(7, self.bowler_row + 1) |
| elif action == 5: |
| self.ball = [self.bowler_row, 0] |
| self.previous_ball = self.ball.copy() |
| self.hook = 0 |
| else: |
| self.previous_ball = self.ball.copy() |
| if action == 2: |
| self.ball[0] = max(1, self.ball[0] - 1) |
| self.hook = max(-1, self.hook - 1) |
| elif action == 4: |
| self.ball[0] = min(7, self.ball[0] + 1) |
| self.hook = min(1, self.hook + 1) |
| self.ball[1] += 1 |
| if self.ball[1] >= 9: |
| previous_score = self.confirmed_score |
| self._finish_roll() |
| self.confirmed_score = self._score_available() |
| reward = float(self.confirmed_score - previous_score) |
| self.steps += 1 |
| return reward, self.terminal |
| self.steps += 1 |
| if self.steps >= self.horizon: |
| self.terminal = True |
| return 0.0, self.terminal |
|
|
| def _finish_roll(self) -> None: |
| knocked = self._knocked_pins() |
| self.standing -= knocked |
| pinfall = len(knocked) |
| frame_rolls = self.frames[self.frame] |
| frame_rolls.append(pinfall) |
| self.ball = None |
| self.previous_ball = None |
| self.hook = 0 |
| if self.frame < 9: |
| if pinfall == 10 or len(frame_rolls) == 2: |
| self.frame += 1 |
| self.standing = set(range(10)) |
| return |
| if len(frame_rolls) == 1: |
| if pinfall == 10: |
| self.standing = set(range(10)) |
| elif len(frame_rolls) == 2: |
| if frame_rolls[0] == 10: |
| if pinfall == 10: |
| self.standing = set(range(10)) |
| elif sum(frame_rolls) == 10: |
| self.standing = set(range(10)) |
| else: |
| self.terminal = True |
| else: |
| self.terminal = True |
|
|
| def _knocked_pins(self) -> set[int]: |
| if not self.standing or self.ball is None: |
| return set() |
| entry_row = self.ball[0] |
| if self.standing == set(range(10)) and entry_row == 4 and self.hook != 0: |
| return self.standing.copy() |
| knocked = { |
| index |
| for index in self.standing |
| if abs(PIN_POSITIONS[index][0] - entry_row) <= 1 |
| } |
| if self.hook < 0: |
| knocked |= {index for index in self.standing if PIN_POSITIONS[index][0] < entry_row and abs(PIN_POSITIONS[index][0] - entry_row) <= 2} |
| elif self.hook > 0: |
| knocked |= {index for index in self.standing if PIN_POSITIONS[index][0] > entry_row and abs(PIN_POSITIONS[index][0] - entry_row) <= 2} |
| return knocked |
|
|
| def _score_available(self) -> int: |
| flattened = [roll for frame in self.frames for roll in frame] |
| score = 0 |
| cursor = 0 |
| for frame_index in range(9): |
| frame = self.frames[frame_index] |
| if not frame: |
| break |
| if frame[0] == 10: |
| if cursor + 2 >= len(flattened): |
| break |
| score += 10 + flattened[cursor + 1] + flattened[cursor + 2] |
| cursor += 1 |
| elif len(frame) == 2 and sum(frame) == 10: |
| if cursor + 2 >= len(flattened): |
| break |
| score += 10 + flattened[cursor + 2] |
| cursor += 2 |
| elif len(frame) == 2: |
| score += sum(frame) |
| cursor += 2 |
| else: |
| break |
| tenth = self.frames[9] |
| if self.frame == 9 or self.terminal: |
| score += sum(tenth) |
| return score |
|
|
| def state(self) -> np.ndarray: |
| state = np.zeros((10, 10, 6), dtype=bool) |
| state[self.bowler_row, 0, 0] = True |
| state[0, :, 1] = True |
| state[9, :, 1] = True |
| for index in self.standing: |
| state[*PIN_POSITIONS[index], 2] = True |
| if self.ball is not None: |
| state[*self.ball, 3] = True |
| if self.previous_ball is not None: |
| state[*self.previous_ball, 4] = True |
| state[9, : self.frame + 1, 5] = True |
| state[8, : min(10, len(self.frames[self.frame]) + 1), 5] = True |
| score_bucket = min(9, self.confirmed_score // 30) |
| state[7, : score_bucket + 1, 5] = True |
| state[6, self.hook + 1, 5] = True |
| return state |
|
|
