Datasets:
File size: 4,455 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 | from dataclasses import dataclass
import math
import numpy as np
HORIZON = 400
FRAMES_PER_STEP = 4
PLAYER_X = 35
GROUND = 80
JUMP_DURATION = 30
@dataclass
class Enemy:
x: float
y: float
size: float
class BladeDancerEnvironment:
score_cap = 100
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.pressed = self.terminal = False
self.jump_ticks = 0.0
self.y = float(GROUND)
self.angle = math.pi / 2
self.length = 10.0
self.multiplier = 1
self.enemies: list[Enemy] = []
self.platforms = [(0.0, 200.0)]
@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
pressed = self.pressed if self.random.random() < self.sticky_action_prob else action == 5
if pressed and not self.pressed and not self.jump_ticks:
self.jump_ticks = JUMP_DURATION
self.multiplier = 1
self.pressed = pressed
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 _sword_vector(self) -> tuple[float, float]:
return self.length * math.cos(self.angle), self.length * math.sin(self.angle)
def _advance_frame(self) -> int:
if self.jump_ticks:
self.jump_ticks = max(0, self.jump_ticks - (0.5 if self.pressed else 1))
progress = self.jump_ticks / JUMP_DURATION
self.y = GROUND - math.sin(progress * math.pi) * 30
self.angle = self.angle - 0.3 if self.jump_ticks else math.pi / 2
self.length = 8 + (1 - progress) * 22 if self.jump_ticks else 10
if not self.enemies or self.random.random() < 0.04:
if len(self.enemies) == 32:
self.enemies.pop(0)
self.enemies.append(Enemy(205, self.random.uniform(30, 75), self.random.uniform(3, 6)))
reward = 0
survivors = []
sword_x, sword_y = self._sword_vector()
sword_radius = 2.5 if self.jump_ticks else 1
for enemy in self.enemies:
enemy.x -= 1
dx, dy = enemy.x - PLAYER_X, enemy.y - (self.y - 4)
fraction = min(1, max(0, (dx * sword_x + dy * sword_y) / self.length**2))
distance = math.hypot(dx - fraction * sword_x, dy - fraction * sword_y)
radius = enemy.size / 2
if distance <= radius + sword_radius:
reward += self.multiplier
self.multiplier += 1
continue
if abs(dx) < 2 + radius and abs(enemy.y - self.y) < 4 + radius:
self.terminal = True
if enemy.x >= -10:
survivors.append(enemy)
self.enemies = survivors
self.platforms = [(left - 1, right - 1) for left, right in self.platforms if right >= 1]
end = self.platforms[-1][1]
if end < 200:
gap = self.random.uniform(15, 30) if self.random.random() < 0.32 else 0
length = self.random.uniform(30, 100) if gap else self.random.uniform(50, 150)
self.platforms.append((end + gap, end + gap + length))
if not self.jump_ticks and not any(left <= PLAYER_X <= right for left, right in self.platforms):
self.terminal = True
return reward
def state(self) -> np.ndarray:
state = np.zeros((10, 10, 6), dtype=bool)
row, column = int(self.y) // 10, PLAYER_X // 20
state[row, column, 0] = True
state[row, column, 4] = self.jump_ticks > 0
sword_x, sword_y = self._sword_vector()
for fraction in np.linspace(0, 1, 12):
y = int(self.y - 4 + fraction * sword_y) // 10
x = int(PLAYER_X + fraction * sword_x) // 20
state[y, x, 1] = True
for enemy in self.enemies:
if 0 <= enemy.x < 200:
state[int(enemy.y) // 10, int(enemy.x) // 20, 2] = True
for column in range(10):
x = 20 * column + PLAYER_X % 20
state[8, column, 3] = any(left <= x <= right for left, right in self.platforms)
state[9, 0, 5] = self.pressed
for row, value in enumerate((int(self.jump_ticks * 2), self.multiplier, self.steps)):
for bit in range(9):
state[row, bit, 5] = bool(value & (1 << bit))
return state
|