| """Les 8 bots de l'arène. |
| |
| Deux bots suivent une règle écrite à la main (Dot, Locus) et servent de référence. |
| Les six autres partent d'un cerveau aux poids tirés au hasard et apprennent seuls, |
| chacun avec sa propre méthode et sa propre famille de fonctions. |
| """ |
| from __future__ import annotations |
|
|
| import os |
| from dataclasses import dataclass, field |
|
|
| import numpy as np |
|
|
| from . import config as C |
| from . import sensors, vocab as V |
| from .nets import MLP |
| from .world import World |
|
|
| CKPT_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "checkpoints") |
|
|
|
|
| @dataclass |
| class Shot: |
| g: object |
| z: object |
| text: str |
| ztext: str |
| target: int |
| params: dict = field(default_factory=dict) |
|
|
|
|
| def line_blocked(world: World, shooter: int, target: int) -> float: |
| """Part du segment tireur → cible qui traverse un obstacle (sert aux choix de cible simples).""" |
| s, t = world.soldiers[shooter], world.soldiers[target] |
| k = np.linspace(0, 1, 60) |
| return float(np.mean([not world.is_free(s.x + (t.x - s.x) * a, s.y + (t.y - s.y) * a) for a in k])) |
|
|
|
|
| def clearest_target(world: World, shooter: int) -> int: |
| s = world.soldiers[shooter] |
| enemies = world.alive(1 - s.team) |
| return min(enemies, key=lambda j: (round(line_blocked(world, shooter, j), 2), |
| np.hypot(world.soldiers[j].x - s.x, world.soldiers[j].y - s.y))) |
|
|
|
|
| class Bot: |
| key = "?" |
| name = "?" |
| color = (0, 0, 0) |
| method = "" |
| blurb = "" |
| vocab: V.Vocab = V.Line() |
| learns = False |
|
|
| def choose_target(self, world: World, shooter: int) -> int: |
| return clearest_target(world, shooter) |
|
|
| def act(self, world: World, shooter: int, target: int | None = None) -> Shot: ... |
|
|
|
|
| |
|
|
| class DotBot(Bot): |
| key, name, color = "dot", "Dot", (90, 90, 100) |
| method = "règle fixe" |
| blurb = "Tire tout droit sur la cible la plus dégagée. Aucun apprentissage : c'est l'étalon." |
|
|
| def act(self, world, shooter, target=None): |
| target = self.choose_target(world, shooter) if target is None else target |
| s, t = world.soldiers[shooter], world.soldiers[target] |
| ut = max((t.x - s.x) * s.dir, 1e-3) |
| p = {"a": (t.y - s.y) / ut} |
| return Shot(self.vocab.g(p), None, self.vocab.text(p), "", target, p) |
|
|
|
|
| class LocusBot(Bot): |
| """Cherche un chemin libre colonne par colonne (programmation dynamique), |
| puis l'écrit comme une ligne brisée avec des valeurs absolues.""" |
| key, name, color = "locus", "Locus", (40, 120, 120) |
| method = "planificateur" |
| blurb = "Calcule le lieu des points libres et trace une ligne brisée qui l'emprunte. Aucun apprentissage." |
| vocab = V.PiecewiseAbs() |
| DU, DY, MAXJ, MARGIN = 1.0, 0.5, 6, 1.25 |
|
|
| def _plan(self, world, shooter, target): |
| s, t = world.soldiers[shooter], world.soldiers[target] |
| d = s.dir |
| ut = (t.x - s.x) * d |
| ncol = int(ut // self.DU) |
| if ncol < 2: |
| return None |
| ys = np.arange(-C.BOARD_H + 0.75, C.BOARD_H - 0.74, self.DY) |
| us = np.arange(ncol + 1) * self.DU |
| us[-1] = ut |
| X = s.x + d * us[:, None] |
| Y = np.broadcast_to(ys, (len(us), len(ys))) |
| o = world.obstacles |
| dd = np.hypot(X[..., None] - o[:, 0], Y[..., None] - o[:, 1]) - o[:, 2] |
| blocked = (dd < self.MARGIN).any(-1) |
| if len(world.craters): |
| c = world.craters |
| in_hole = (np.hypot(X[..., None] - c[:, 0], Y[..., None] - c[:, 1]) < c[:, 2] - 0.5).any(-1) |
| blocked &= ~in_hole |
| for i, so in enumerate(world.soldiers): |
| if i in (shooter, target) or not so.alive: |
| continue |
| blocked |= np.hypot(X - so.x, Y - so.y) < 1.8 |
| j0 = int(np.argmin(np.abs(ys - s.y))) |
| j1 = int(np.argmin(np.abs(ys - t.y))) |
| blocked[0, j0] = False |
| blocked[-1, j1] = False |
| INF = 1e18 |
| cost = np.full(len(ys), INF); cost[j0] = 0 |
| back = np.zeros((len(us), len(ys)), dtype=np.int64) |
| jj = np.arange(len(ys)) |
| for c_ in range(1, len(us)): |
| best = np.full(len(ys), INF); arg = np.zeros(len(ys), dtype=np.int64) |
| for dj in range(-self.MAXJ, self.MAXJ + 1): |
| src = jj - dj |
| ok = (src >= 0) & (src < len(ys)) |
| cand = np.full(len(ys), INF) |
| cand[ok] = cost[src[ok]] + (dj * self.DY) ** 2 + 0.02 |
| upd = cand < best |
| best[upd], arg[upd] = cand[upd], src[upd] |
| best[blocked[c_]] = INF |
| cost, back[c_] = best, arg |
| if cost[j1] >= INF: |
| return None |
| path = [j1] |
| for c_ in range(len(us) - 1, 0, -1): |
| path.append(back[c_, path[-1]]) |
| path = path[::-1] |
| pts = np.column_stack([us, ys[path]]) |
| pts[0, 1], pts[-1, 1] = s.y, t.y |
| return _simplify(pts, 0.35) |
|
|
| def act(self, world, shooter, target=None): |
| s = world.soldiers[shooter] |
| order = [target] if target is not None else sorted( |
| world.alive(1 - s.team), key=lambda j: abs(world.soldiers[j].x - s.x)) |
| for tgt in order: |
| pts = self._plan(world, shooter, tgt) |
| if pts is not None: |
| slopes = np.diff(pts[:, 1]) / np.maximum(np.diff(pts[:, 0]), 1e-6) |
| cs = (slopes[1:] - slopes[:-1]) / 2 |
| p = {"A": float(slopes[0] + cs.sum()), "c": cs.tolist(), "u": pts[1:-1, 0].tolist()} |
| return Shot(self.vocab.g(p), None, self.vocab.text(p), "", tgt, p) |
| return DotBot().act(world, shooter, order[0]) |
|
|
|
|
| def _simplify(pts, eps): |
| """Ramer-Douglas-Peucker : garde seulement les coins utiles de la ligne brisée.""" |
| if len(pts) < 3: |
| return pts |
| a, b = pts[0], pts[-1] |
| ab = b - a |
| n = np.hypot(*ab) or 1.0 |
| d = np.abs(ab[0] * (pts[:, 1] - a[1]) - ab[1] * (pts[:, 0] - a[0])) / n |
| k = int(np.argmax(d)) |
| if d[k] > eps: |
| left, right = _simplify(pts[:k + 1], eps), _simplify(pts[k:], eps) |
| return np.vstack([left[:-1], right]) |
| return np.vstack([a, b]) |
|
|
|
|
| |
|
|
| class LearnedBot(Bot): |
| learns = True |
| channels = ("couloir",) |
| hidden = (32,) |
| learner = "ga" |
| ally_penalty = 1.0 |
|
|
| def __init__(self, path: str | None = None, seed: int = 0): |
| n_in = sensors.obs_size(self.channels) |
| out_act = "linear" if self.learner == "ppo" else "tanh" |
| self.policy = MLP([n_in, *self.hidden, self.vocab.n_out], out_act, rng=np.random.default_rng(seed)) |
| self.value = None |
| self.trained_iters = 0 |
| path = path or os.path.join(CKPT_DIR, f"{self.key}.npz") |
| if os.path.exists(path): |
| self.load(path) |
|
|
| |
| def brain_out(self, obs): |
| o = self.policy(obs) |
| return np.tanh(o) if self.policy.out_act == "linear" else o |
|
|
| def obs(self, world, shooter, target): |
| return sensors.normalize(sensors.observe(world, shooter, target, self.channels), self.channels) |
|
|
| def choose_target(self, world, shooter): |
| enemies = world.alive(1 - world.soldiers[shooter].team) |
| if self.value is not None and len(enemies) > 1: |
| scores = [float(self.value(self.obs(world, shooter, j))[0]) for j in enemies] |
| return enemies[int(np.argmax(scores))] |
| return clearest_target(world, shooter) |
|
|
| def act(self, world, shooter, target=None): |
| target = self.choose_target(world, shooter) if target is None else target |
| out = self.brain_out(self.obs(world, shooter, target)) |
| return self.shot_from(out, V.ctx_of(world, shooter, target), target) |
|
|
| def shot_from(self, out, ctx, target): |
| p = self.vocab.decode(out, ctx) |
| return Shot(self.vocab.g(p), self.vocab.z(p), self.vocab.text(p), self.vocab.ztext(p), target, p) |
|
|
| |
| def save(self, path=None, **extra): |
| path = path or os.path.join(CKPT_DIR, f"{self.key}.npz") |
| os.makedirs(os.path.dirname(path), exist_ok=True) |
| d = self.policy.to_dict("pi_") |
| if self.value is not None: |
| d.update(self.value.to_dict("v_")) |
| d["iters"] = np.array(self.trained_iters) |
| for k, v in extra.items(): |
| d[k] = np.asarray(v) |
| np.savez(path, **d) |
|
|
| def load(self, path): |
| d = np.load(path, allow_pickle=False) |
| self.policy = MLP.from_dict(d, "pi_") |
| self.value = MLP.from_dict(d, "v_") if "v_flat" in d else None |
| self.trained_iters = int(d["iters"]) if "iters" in d else 0 |
|
|
|
|
| class EvolutionBot(LearnedBot): |
| key, name, color = "evolution", "Evolution", (200, 60, 50) |
| method = "algorithme génétique" |
| blurb = ("Une population de 48 cerveaux. À chaque génération les meilleurs se reproduisent, " |
| "leurs enfants sont mutés, les nuls disparaissent. Les champions gardent la moyenne de tous leurs scores.") |
| vocab, channels, hidden, learner = V.Gauss(), ("couloir",), (8,), "ga" |
|
|
|
|
| class PoleZeroBot(LearnedBot): |
| key, name, color = "polezero", "Pole-Zero", (120, 70, 170) |
| method = "stratégies d'évolution (ES)" |
| blurb = ("Un seul cerveau qu'on secoue dans 48 directions au hasard ; on le pousse vers " |
| "les secousses qui ont le mieux visé. Écrit des fractions à pôles complexes.") |
| vocab, channels, hidden, learner = V.PoleZero(), ("couloir", "allies"), (16,), "es" |
|
|
|
|
| class FlyBot(LearnedBot): |
| key, name, color = "fly", "Fly", (30, 140, 200) |
| method = "entropie croisée (CEM)" |
| blurb = ("Tire 64 cerveaux autour d'une moyenne, garde les 16 meilleurs et recentre la moyenne " |
| "dessus. Écrit des ondes : il vole.") |
| vocab, channels, hidden, learner = V.Wave(), ("couloir",), (8,), "cem" |
|
|
|
|
| class IrrationalBot(LearnedBot): |
| key, name, color = "irrational", "Irrational", (220, 140, 30) |
| method = "apprentissage par renforcement (PPO)" |
| blurb = ("Apprend par essais et erreurs avec PPO, comme un agent de jeu vidéo. " |
| "Écrit des racines et des valeurs absolues.") |
| vocab, channels, hidden, learner = V.Irrational(), ("couloir", "allies"), (64, 64), "ppo" |
|
|
|
|
| class PeaceBot(LearnedBot): |
| key, name, color = "peace", "Peace", (70, 160, 80) |
| method = "PPO + punition des tirs fratricides" |
| blurb = ("Même méthode que Irrational, mais tuer un coéquipier lui coûte trois fois une victoire. " |
| "Il voit ses alliés et préfère rater que trahir.") |
| vocab, channels, hidden, learner, ally_penalty = V.Steps(), ("couloir", "allies", "enemies"), (64, 64), "ppo", 3.0 |
|
|
|
|
| class ThreeDBot(LearnedBot): |
| key, name, color = "3d", "3D", (230, 60, 140) |
| method = "PPO en 3 dimensions" |
| blurb = ("Ajoute z(x) à son tir : il peut sauter par-dessus les obstacles bas. " |
| "Il voit la hauteur de chaque obstacle.") |
| vocab, channels, hidden, learner = V.Lob3D(), ("couloir", "hauteur", "allies"), (64, 64), "ppo" |
|
|
|
|
| ALL = [DotBot, LocusBot, EvolutionBot, PoleZeroBot, FlyBot, IrrationalBot, PeaceBot, ThreeDBot] |
| BY_KEY = {b.key: b for b in ALL} |
| LEARNERS = [b.key for b in ALL if b.learns] |
|
|
|
|
| def make(key: str, **kw) -> Bot: |
| cls = BY_KEY[key.lower()] |
| return cls(**kw) if cls.learns else cls() |
|
|
