Datasets:
File size: 5,256 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 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 | from dataclasses import dataclass
import math
import numpy as np
HORIZON = 400
FRAMES_PER_STEP = 4
DIRECTIONS = ((0, -1), (-1, 0), (1, 0), (0, 1))
@dataclass(eq=False)
class Node:
x: float
y: float
vx: float = 0
vy: float = 0
anchored: bool = True
tethered: bool = False
@dataclass
class Link:
a: Node
b: Node
length: float
def near(self, x: float, y: float) -> bool:
dx, dy = self.b.x - self.a.x, self.b.y - self.a.y
px, py = x - self.a.x, y - self.a.y
squared = dx * dx + dy * dy
fraction = min(1, max(0, (px * dx + py * dy) / squared)) if squared else 0
return math.hypot(px - fraction * dx, py - fraction * dy) <= 5
class CNodesEnvironment:
score_cap = 500
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 = 0
self.multiplier = 1
self.next_node = self.boost = 0.0
self.cursor = (3, 5)
self.terminal = False
self.nodes: list[Node] = []
self.links: list[Link] = []
@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
if 1 <= action <= 4:
dy, dx = DIRECTIONS[action - 1]
row, col = self.cursor
self.cursor = min(9, max(2, row + dy)), min(9, max(0, col + dx))
if action == 5 and self.last_action != 5:
row, col = self.cursor
self.links = [link for link in self.links if not link.near(col * 10 + 5, row * 10 + 5)]
self.multiplier = 1
self.boost = 1
self.last_action = action
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:
lowest = max((node.y for node in self.nodes), default=0)
scroll = 0.03 + self.boost + max(0, 29 - lowest) * 0.1
self.boost *= 0.7
self.next_node -= scroll
if self.next_node < 0:
new = Node(self.random.uniform(10, 90), 0)
for node in self.nodes:
if node.anchored and abs(new.x - node.x) / 2 + abs(node.y) < 30 and self.random.random() < 0.7:
self.links.append(Link(new, node, math.hypot(new.x - node.x, node.y)))
self.nodes.append(new)
self.next_node = 4
for link in self.links:
dx, dy = link.b.x - link.a.x, link.b.y - link.a.y
distance = math.hypot(dx, dy)
if distance:
force = (distance - link.length) * 0.02 / distance
link.a.vx += force * dx
link.a.vy += force * dy
link.b.vx -= force * dx
link.b.vy -= force * dy
for node in self.nodes:
node.y += scroll
node.anchored &= node.y <= 20
if node.anchored:
node.vx = node.vy = 0
else:
node.x += node.vx
node.y += node.vy
node.vx *= 0.95
node.vy = (node.vy + 0.03) * 0.95
self.links = [link for link in self.links if min(link.a.y, link.b.y) <= 100]
self._update_tethers()
reward = 0
survivors = []
for node in self.nodes:
if node.tethered and node.y > 100:
self.terminal = True
if node.y > 140:
reward += self.multiplier
self.multiplier = min(64, self.multiplier * 2)
else:
survivors.append(node)
self.nodes = survivors
alive = set(survivors)
self.links = [link for link in self.links if link.a in alive and link.b in alive]
return reward
def _update_tethers(self) -> None:
connected = {node: [] for node in self.nodes}
for link in self.links:
connected[link.a].append(link.b)
connected[link.b].append(link.a)
pending = [node for node in self.nodes if node.anchored]
reached = set(pending)
while pending:
for neighbor in connected[pending.pop()]:
if neighbor not in reached:
reached.add(neighbor)
pending.append(neighbor)
for node in self.nodes:
node.tethered = node in reached and not node.anchored
def state(self) -> np.ndarray:
state = np.zeros((10, 10, 6), dtype=bool)
for node in self.nodes:
if 0 <= node.x < 100 and 0 <= node.y < 100:
channel = 0 if node.anchored else 1 if node.tethered else 2
state[int(node.y) // 10, int(node.x) // 10, channel] = True
for link in self.links:
for fraction in np.linspace(0, 1, 12):
x = link.a.x + (link.b.x - link.a.x) * fraction
y = link.a.y + (link.b.y - link.a.y) * fraction
if 0 <= x < 100 and 0 <= y < 100:
state[int(y) // 10, int(x) // 10, 3] = True
row, col = self.cursor
state[row, col, 4] = True
for row, value in enumerate((self.steps, self.multiplier, self.last_action)):
for bit in range(9):
state[row, bit, 5] = bool(value & (1 << bit))
return state
|