Datasets:
File size: 4,164 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 | from dataclasses import dataclass
import numpy as np
HORIZON = 400
GROUND = 32
UNIT = 4
SPAWN_INTERVAL = 5
MAX_BALLS = (HORIZON + SPAWN_INTERVAL - 1) // SPAWN_INTERVAL
@dataclass
class Ball:
x: int
y: int
vx: int
vy: int = 0
class BallsBombsEnvironment:
score_cap = MAX_BALLS * (MAX_BALLS + 1) // 2
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.last_action = self.scroll = 0
self.player = 2
self.next_bomb = 6
self.bomb: int | None = None
self.armed = False
self.blast: tuple[int, int] | None = None
self.multiplier = 1
self.balls: list[Ball] = []
self.terminal = False
@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:
action = self.last_action
self.last_action = action
self.steps += 1
if action == 5:
self.player += 1
self.scroll = max(0, self.player - 4)
if not self.armed and self.bomb is None and self.player >= self.next_bomb:
self.bomb = self.scroll + 9
if self.bomb == self.player:
self.armed = True
self.bomb = None
self.next_bomb = self.player + int(self.random.integers(9, 13))
if self.blast is not None:
center, radius = self.blast
self.blast = (center, radius + 1) if radius < 6 else None
if self.blast is None:
self.multiplier = 1
if self.steps % SPAWN_INTERVAL == 1:
from_left = self.random.random() < 0.1
self.balls.append(Ball(self.scroll + (0 if from_left else 9),
int(self.random.integers(5, 17)), 1 if from_left else -1))
reward = 0
survivors = []
for ball in self.balls:
ball.vy += 1
ball.y += ball.vy
if ball.y >= GROUND:
ball.y = GROUND
ball.vy = -ball.vy
if self.steps % 2 == 0:
ball.x += ball.vx
if ball.x <= self.scroll and ball.vx < 0:
ball.vx = 2
elif ball.x >= self.scroll + 9 and ball.vx > 0:
ball.vx = -1
if self._in_blast(ball.y // UNIT, ball.x):
reward += self.multiplier
self.multiplier += 1
elif ball.x == self.player and ball.y // UNIT == GROUND // UNIT:
if self.armed:
self.armed = False
self.blast = self.player, 1
else:
self.terminal = True
elif ball.x >= self.scroll - 2:
survivors.append(ball)
self.balls = survivors
self.terminal |= self.steps >= self.horizon
return float(reward), self.terminal
def _in_blast(self, row: int, x: int) -> bool:
if self.blast is None:
return False
center, radius = self.blast
distance_squared = (x - center) ** 2 + (GROUND // UNIT - row) ** 2
return (radius - 0.75) ** 2 <= distance_squared <= (radius + 0.75) ** 2
def state(self) -> np.ndarray:
state = np.zeros((10, 10, 6), dtype=bool)
state[GROUND // UNIT, self.player - self.scroll, 0] = True
for ball in self.balls:
column = ball.x - self.scroll
if 0 <= column < 10:
row = max(0, ball.y // UNIT)
state[row, column, 1] = True
state[row, column, 4] |= ball.vy < 0
if self.bomb is not None and 0 <= self.bomb - self.scroll < 10:
state[GROUND // UNIT, self.bomb - self.scroll, 2] = True
if self.blast is not None:
for row in range(9):
for column in range(10):
state[row, column, 3] = self._in_blast(row, column + self.scroll)
values = (self.steps, self.multiplier, int(self.armed), self.player,
self.next_bomb, self.last_action, 0 if self.blast is None else self.blast[1])
for row, value in enumerate(values):
for bit in range(9):
state[row, bit, 5] = bool(value & (1 << bit))
return state
|