Datasets:
File size: 4,291 Bytes
7248ace | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | from dataclasses import dataclass
import math
import numpy as np
HORIZON = 400
FRAMES_PER_STEP = 4
SPOKES = 6
@dataclass
class Falling:
x: float
y: float = 0
vy: float = 0
def advance(self) -> None:
self.vy += 0.02
self.y += self.vy
def near(self, x: float, y: float, radius: float) -> bool:
return math.hypot(self.x - x, self.y - y) < radius
class CatchingWheelEnvironment:
score_cap = 150
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 = 0
self.angle = 0.0
self.human_timer, self.obstacle_timer = 40.0, 99.0
self.multiplier = 1
self.pressed = self.terminal = False
self.baskets = [True] * SPOKES
self.humans: list[Falling] = []
self.obstacles: list[Falling] = []
@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 _positions(self) -> list[tuple[float, float]]:
angles = (self.angle + index * math.tau / SPOKES for index in range(SPOKES))
return [(50 + 40 * math.cos(angle), 90 + 40 * math.sin(angle)) for angle in angles]
def _change_basket(self, restore: bool) -> None:
start = int(self.random.integers(SPOKES))
for offset in range(SPOKES):
index = (start + offset) % SPOKES
if self.baskets[index] != restore:
self.baskets[index] = restore
if not restore:
self.multiplier = 1
break
def _advance_frame(self) -> int:
self.obstacle_timer -= 1
if self.obstacle_timer <= 0:
self.obstacles.append(Falling(self.random.uniform(20, 80)))
self.obstacle_timer = self.random.uniform(79.2, 118.8)
for obstacle in self.obstacles:
obstacle.advance()
self.obstacles = [obstacle for obstacle in self.obstacles if obstacle.y <= 95]
if self.pressed:
self.angle = (self.angle + 0.05) % math.tau
positions = self._positions()
for index, (x, y) in enumerate(positions):
if self.baskets[index] and any(obstacle.near(x, y, 9) for obstacle in self.obstacles):
self.baskets[index] = False
self.multiplier = 1
catchable = [point for point, live in zip(positions, self.baskets) if live]
self.human_timer -= 1
if self.human_timer <= 0:
self.humans.append(Falling(self.random.uniform(10, 90)))
self.human_timer = self.random.uniform(28, 40)
reward = 0
remaining = []
for human in self.humans:
human.advance()
if any(obstacle.near(human.x, human.y, 5) for obstacle in self.obstacles):
continue
if any(human.near(x, y, 6) for x, y in catchable):
reward += self.multiplier
self.multiplier += 1
self._change_basket(restore=True)
elif human.y > 100:
self._change_basket(restore=False)
else:
remaining.append(human)
self.humans = remaining
self.terminal = not any(self.baskets)
return reward
def state(self) -> np.ndarray:
state = np.zeros((10, 10, 6), dtype=bool)
state[9, 5, 0] = True
for live, (x, y) in zip(self.baskets, self._positions()):
if 0 <= y < 100:
state[int(y) // 10, int(x) // 10, 1 if live else 2] = True
for channel, objects in ((3, self.humans), (4, self.obstacles)):
for obj in objects:
if obj.y < 100:
state[int(obj.y) // 10, int(obj.x) // 10, channel] = True
for row, value in enumerate((self.steps, self.multiplier, round(self.angle * 80))):
for bit in range(9):
state[row, bit, 5] = bool(value & (1 << bit))
state[9, :SPOKES, 5] = self.baskets
state[9, SPOKES, 5] = self.pressed
return state
|