Datasets:
File size: 4,250 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 | from dataclasses import dataclass
import math
import numpy as np
HORIZON = 400
FRAMES_PER_STEP = 4
@dataclass
class Bubble:
x: float
y: float
size: float
class BlazeThrustEnvironment:
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.hold_time = 0
self.pressed = self.terminal = False
self.x, self.y = 50.0, 90.0
self.vx = self.vy = 0.0
self.size = 9.0
self.multiplier = 1
self.next_bubble = self.random.uniform(10, 40)
self.winds = [(0.0, self.random.uniform(20, 40))]
self.bubbles: list[Bubble] = []
@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 _wind_left(self, y: float) -> bool:
return any(top <= y <= bottom for top, bottom in self.winds)
def _advance_frame(self) -> int:
self.vy += -0.1 if self.pressed else 0.1
self.hold_time = self.hold_time + 1 if self.pressed else max(0, self.hold_time - 3)
scroll = max(0, (60 - self.y) * 0.1)
self.x += self.vx
self.y += self.vy + scroll
self.vx *= 0.95
self.vy *= 0.95
if self.x < 5:
self.x, self.vx = 10, abs(self.vx) * 0.5
elif self.x > 95:
self.x, self.vx = 90, -abs(self.vx) * 0.5
if self.y > 95:
self.y, self.vy = 90, -abs(self.vy) * 0.3
if scroll:
self.winds = [(top + scroll, bottom + scroll) for top, bottom in self.winds if top + scroll < 120]
top = self.winds[0][0]
if top >= 0:
bottom = top - self.random.uniform(20, 40)
self.winds.insert(0, (bottom - self.random.uniform(20, 40), bottom))
self.vx += self.size * (-0.02 if self._wind_left(self.y) else 0.02)
self.size *= 1 - 0.0016 * (1 + self.hold_time * 0.01)
if self.size <= 2:
self.terminal = True
return 0
reward = self._advance_bubbles(scroll)
if scroll and len(self.bubbles) < 15:
self.next_bubble -= scroll
if self.next_bubble <= 0:
size = self.random.uniform(3, 9)
self.bubbles.append(Bubble(self.random.uniform(10, 90), -size, size))
self.next_bubble = self.random.uniform(5, 55)
return reward
def _advance_bubbles(self, scroll: float) -> int:
reward = 0
remaining = []
for bubble in self.bubbles:
bubble.y += scroll + 0.3 - (bubble.size - 3) * 0.015
bubble.x += bubble.size * (-0.02 if self._wind_left(bubble.y) else 0.02)
bubble.x = min(95, max(5, bubble.x))
if math.hypot(bubble.x - self.x, bubble.y - self.y) <= bubble.size + self.size:
reward += self.multiplier
self.multiplier = min(16, self.multiplier + 1)
self.size = min(25, self.size + bubble.size * 0.2)
elif bubble.y > 120:
self.multiplier = 1
else:
remaining.append(bubble)
self.bubbles = remaining
return reward
def state(self) -> np.ndarray:
state = np.zeros((10, 10, 6), dtype=bool)
row, column = int(self.y) // 10, int(self.x) // 10
state[row, column, 0] = True
state[row, column, 4] = self.vy < 0
for row in range(10):
state[row, :, 1 if self._wind_left(10 * row + 5) else 2] = True
for bubble in self.bubbles:
if 0 <= bubble.y < 100:
state[int(bubble.y) // 10, int(bubble.x) // 10, 3] = True
for row, value in enumerate((round(self.size * 10), self.multiplier, self.hold_time, self.steps)):
for bit in range(10):
state[row, bit, 5] = bool(value & (1 << bit))
state[row + 4, 0, 5] = bool(value & 1024)
state[9, 0, 5] = self.pressed
return state
|