Datasets:
File size: 5,514 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 | import numpy as np
DELTAS = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}
class BoxingEnvironment:
"""Two-minute top-down bout with guarded jabs, power punches, and counter windows."""
score_cap = 100.0
def __init__(self, sticky_action_prob: float = 0.1, round_steps: int = 120):
self.sticky_action_prob = sticky_action_prob
self.round_steps = round_steps
self.random = np.random.RandomState()
self.seed(0)
self.reset()
@classmethod
def normalize_score(cls, raw_score: float) -> float:
return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap
def seed(self, seed: int) -> None:
self.random.seed(seed)
def reset(self) -> None:
self.player = [5, 2]
self.opponent = [5, 7]
self.previous_player = self.player.copy()
self.previous_opponent = self.opponent.copy()
self.player_score = 0
self.opponent_score = 0
self.player_recovery = 0
self.opponent_recovery = 0
self.player_punch: list[int] | None = None
self.opponent_punch: list[int] | None = None
self.steps = 0
self.last_action = 0
self.terminal = False
def act(self, action: int) -> tuple[float, bool]:
if self.terminal:
return 0.0, True
if self.random.rand() < self.sticky_action_prob:
action = self.last_action
self.last_action = action
self.previous_player = self.player.copy()
self.previous_opponent = self.opponent.copy()
self.player_punch = None
self.opponent_punch = None
reward = 0.0
if action in DELTAS:
self._move(self.player, self.opponent, action)
elif action == 5 and self.player_recovery == 0:
scored = self._punch(self.player, self.opponent, defender_is_player=False)
reward = float(min(scored, 100 - self.player_score))
self.player_score += int(reward)
self.player_recovery = 2
if self.player_score >= 100:
self.player_score = 100
self.terminal = True
return reward, True
if self.steps < 60 or self.steps % 2 == 0:
self._opponent_action()
self.player_recovery = max(0, self.player_recovery - 1)
self.opponent_recovery = max(0, self.opponent_recovery - 1)
self.steps += 1
if self.opponent_score >= 100 or self.steps >= self.round_steps:
self.opponent_score = min(100, self.opponent_score)
self.terminal = True
return reward, self.terminal
@staticmethod
def _move(boxer: list[int], other: list[int], action: int) -> None:
row_delta, column_delta = DELTAS[action]
target = [boxer[0] + row_delta, boxer[1] + column_delta]
if 1 <= target[0] <= 8 and 1 <= target[1] <= 8 and target != other:
boxer[:] = target
def _punch(self, attacker: list[int], defender: list[int], defender_is_player: bool) -> int:
row_distance = abs(attacker[0] - defender[0])
column_distance = abs(attacker[1] - defender[1])
distance = max(row_distance, column_distance)
if distance > 2:
return 0
recovery = self.player_recovery if defender_is_player else self.opponent_recovery
angled = row_distance > 0 and column_distance > 0
if not angled and recovery == 0:
return 0
points = 2 if distance == 1 else 1
punch_cell = [
attacker[0] + int(np.sign(defender[0] - attacker[0])),
attacker[1] + int(np.sign(defender[1] - attacker[1])),
]
if defender_is_player:
self.opponent_punch = punch_cell
else:
self.player_punch = punch_cell
self._push(attacker, defender)
return points
@staticmethod
def _push(attacker: list[int], defender: list[int]) -> None:
row_delta = int(np.sign(defender[0] - attacker[0]))
column_delta = int(np.sign(defender[1] - attacker[1]))
target = [
int(np.clip(defender[0] + row_delta, 1, 8)),
int(np.clip(defender[1] + column_delta, 1, 8)),
]
if target != attacker:
defender[:] = target
def _opponent_action(self) -> None:
row_distance = abs(self.opponent[0] - self.player[0])
column_distance = abs(self.opponent[1] - self.player[1])
if max(row_distance, column_distance) <= 2 and self.opponent_recovery == 0:
self.opponent_score += self._punch(self.opponent, self.player, defender_is_player=True)
self.opponent_recovery = 2
return
candidates = []
for action in DELTAS:
row_delta, column_delta = DELTAS[action]
target = [self.opponent[0] + row_delta, self.opponent[1] + column_delta]
if not (1 <= target[0] <= 8 and 1 <= target[1] <= 8) or target == self.player:
continue
distance = max(abs(target[0] - self.player[0]), abs(target[1] - self.player[1]))
angled_bonus = -1 if target[0] != self.player[0] and target[1] != self.player[1] else 0
candidates.append((distance + angled_bonus, self.random.rand(), action))
if candidates:
self._move(self.opponent, self.player, min(candidates)[2])
def state(self) -> np.ndarray:
state = np.zeros((10, 10, 6), dtype=bool)
state[*self.player, 0] = True
state[*self.opponent, 1] = True
state[*self.opponent, 2] = True
if self.player_punch is not None:
state[*self.player_punch, 3] = True
state[*self.previous_player, 4] = True
state[*self.previous_opponent, 4] = True
state[9, : min(10, (self.player_score + 9) // 10), 5] = True
state[8, : min(10, (self.opponent_score + 9) // 10), 5] = True
remaining = max(0, self.round_steps - self.steps)
state[7, : min(10, (remaining + 11) // 12), 5] = True
state[6, : self.player_recovery, 5] = True
return state
|