Datasets:
File size: 5,249 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 | import numpy as np
class AtlantisEnvironment:
"""Three fixed defense posts protect seven installations from descending formations."""
score_cap = 35_500.0
def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 1_500):
self.sticky_action_prob = sticky_action_prob
self.horizon = horizon
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.installations = [True] * 7
self.shots: list[list[int | str]] = []
self.wave = 0
self.wave_step = 0
self.steps = 0
self.total_score = 0.0
self.restorations_used = 0
self.last_action = 0
self.terminal = False
self.escaped = False
self._start_wave()
def _start_wave(self) -> None:
self.enemies = [
{"row": index // 5, "column": (index * 2) % 10, "direction": 1, "bandit": index == 8}
for index in range(9)
]
self.previous_enemies = [[int(enemy["row"]), int(enemy["column"])] for enemy in self.enemies]
self.wave_step = 0
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
if action == 1:
self.shots.append([8, 1, -1, 1, "sentry"])
elif action == 3:
self.shots.append([8, 8, -1, -1, "sentry"])
elif action == 5 and self.installations[0]:
self.shots.append([8, 5, -1, 0, "command"])
self.previous_enemies = [[int(enemy["row"]), int(enemy["column"])] for enemy in self.enemies]
self._move_enemies()
self._move_shots()
reward = self._resolve_hits()
self._resolve_deathrays()
self.wave_step += 1
self.steps += 1
if not any(self.installations):
self.escaped = True
self.terminal = True
elif not self.enemies:
bonus = 500.0 * sum(self.installations)
reward += bonus
self.total_score += bonus
self._restore_installations()
self.wave += 1
if self.wave == 5:
self.terminal = True
else:
self._start_wave()
if self.steps >= self.horizon:
self.terminal = True
return reward, self.terminal
def _move_enemies(self) -> None:
if self.wave_step % max(1, 4 - min(self.wave, 2)) != 0:
return
for enemy in self.enemies:
column = int(enemy["column"]) + int(enemy["direction"])
if column < 0 or column > 9:
enemy["direction"] = -int(enemy["direction"])
enemy["row"] = int(enemy["row"]) + 1
column = min(9, max(0, column))
enemy["column"] = column
def _move_shots(self) -> None:
for shot in self.shots:
shot[0] = int(shot[0]) + int(shot[2])
shot[1] = int(shot[1]) + int(shot[3])
self.shots = [shot for shot in self.shots if 0 <= int(shot[0]) < 10 and 0 <= int(shot[1]) < 10]
def _resolve_hits(self) -> float:
reward = 0.0
remaining_shots = []
for shot in self.shots:
hit = next(
(enemy for enemy in self.enemies if [enemy["row"], enemy["column"]] == shot[:2]),
None,
)
if hit is None:
remaining_shots.append(shot)
continue
sentry = shot[4] == "sentry"
if bool(hit["bandit"]):
reward += 2_000.0 if sentry else 1_000.0
self.enemies.clear()
remaining_shots = []
break
reward += 200.0 if sentry else 100.0
self.enemies.remove(hit)
self.shots = remaining_shots
self.total_score += reward
return reward
def _resolve_deathrays(self) -> None:
attackers = [enemy for enemy in self.enemies if int(enemy["row"]) >= 8]
for enemy in attackers:
live = [index for index, intact in enumerate(self.installations) if intact]
if live:
target = 0 if self.installations[0] else live[int(self.random.randint(len(live)))]
self.installations[target] = False
self.enemies.remove(enemy)
def _restore_installations(self) -> None:
available = int(self.total_score // 10_000) - self.restorations_used
while available > 0 and not all(self.installations):
target = next(index for index, intact in enumerate(self.installations) if not intact)
self.installations[target] = True
self.restorations_used += 1
available -= 1
def state(self) -> np.ndarray:
state = np.zeros((10, 10, 6), dtype=bool)
state[9, 0, 0] = True
state[9, 9, 0] = True
if self.installations[0]:
state[9, 5, 0] = True
for enemy in self.enemies:
row, column = int(enemy["row"]), int(enemy["column"])
state[row, column, 1] = True
state[row, column, 2] = True
if bool(enemy["bandit"]):
state[row, column, 5] = True
for shot in self.shots:
state[int(shot[0]), int(shot[1]), 3] = True
for row, column in self.previous_enemies:
if 0 <= row < 10 and 0 <= column < 10:
state[row, column, 4] = True
for index, intact in enumerate(self.installations):
state[9, index + 1, 5] = intact
state[8, : self.wave + 1, 5] = True
return state
|