// bot.mjs: npm install ws, then ARENA_TOKEN=<your token> node bot.mjs
import WebSocket from "ws";

const VERSION = "v1"; // every game is rated for this label: change it when the bot changes
const ws = new WebSocket("wss://arena.victris.ai/bot", {
  headers: { Authorization: `Bearer ${process.env.ARENA_TOKEN}` },
});
const send = (msg) => ws.send(JSON.stringify(msg));

ws.on("open", () => send({ type: "queue", version: VERSION }));
ws.on("message", (raw) => {
  const msg = JSON.parse(raw.toString());
  if (msg.type === "hello") send({ type: "ready" });
  else if (msg.type === "observation") send({ tick: msg.tick, ...decide(msg) });
  else if (msg.type === "end") send({ type: "queue", version: VERSION }); // play again
  else if (msg.type === "error") console.error(msg.code, msg.message);
});

const dist = (a, b) => Math.max(Math.abs(a[0] - b[0]), Math.abs(a[1] - b[1]));
// Is this tile hit this tick or the next? danger lists every tile a visible attack will hit.
const hit = (obs, tile) => obs.danger.some((d) => d.tile[0] === tile[0] && d.tile[1] === tile[1] && d.tick - obs.tick <= 1);

function decide(obs) {
  const me = obs.self;
  const enemy = obs.enemies[0];
  const turn = {};
  if (me.state !== "idle") return turn; // stunned, or recovering from a dash
  // Movement: step off a tile about to be hit, or close in on the enemy.
  if (hit(obs, me.pos)) {
    const safe = obs.moves.find((m) => !hit(obs, m.tile));
    if (safe) turn.move = safe.dir;
  } else if (enemy && dist(me.pos, enemy.pos) > 4) {
    const best = [...obs.moves].sort((a, b) => dist(a.tile, enemy.pos) - dist(b.tile, enemy.pos))[0];
    if (best) turn.move = best.dir;
  }
  // Attack: shoot at the enemy whenever the shot is ready.
  if (enemy && me.cooldowns.ranged === 0) turn.attack = { name: "ranged", target: enemy.pos };
  return turn;
}

# bot.py: pip install "websockets>=14", then ARENA_TOKEN=<your token> python bot.py
import asyncio, json, os
import websockets

URL = "wss://arena.victris.ai/bot"
VERSION = "v1"  # every game is rated for this label: change it when the bot changes


def dist(a, b):
    return max(abs(a[0] - b[0]), abs(a[1] - b[1]))


def hit(obs, tile):
    # Is this tile hit this tick or the next? danger lists every tile a visible attack will hit.
    return any(d["tile"] == tile and d["tick"] - obs["tick"] <= 1 for d in obs["danger"])


def decide(obs):
    me, turn = obs["self"], {}
    if me["state"] != "idle":  # stunned, or recovering from a dash
        return turn
    enemy = obs["enemies"][0] if obs["enemies"] else None
    # Movement: step off a tile about to be hit, or close in on the enemy.
    if hit(obs, me["pos"]):
        safe = [m for m in obs["moves"] if not hit(obs, m["tile"])]
        if safe:
            turn["move"] = safe[0]["dir"]
    elif enemy and dist(me["pos"], enemy["pos"]) > 4 and obs["moves"]:
        turn["move"] = min(obs["moves"], key=lambda m: dist(m["tile"], enemy["pos"]))["dir"]
    # Attack: shoot at the enemy whenever the shot is ready.
    if enemy and me["cooldowns"]["ranged"] == 0:
        turn["attack"] = {"name": "ranged", "target": enemy["pos"]}
    return turn


async def main():
    headers = {"Authorization": f"Bearer {os.environ['ARENA_TOKEN']}"}
    async with websockets.connect(URL, additional_headers=headers) as ws:
        await ws.send(json.dumps({"type": "queue", "version": VERSION}))
        async for raw in ws:
            msg = json.loads(raw)
            if msg["type"] == "hello":
                await ws.send(json.dumps({"type": "ready"}))
            elif msg["type"] == "observation":
                await ws.send(json.dumps({"tick": msg["tick"], **decide(msg)}))
            elif msg["type"] == "end":  # play again
                await ws.send(json.dumps({"type": "queue", "version": VERSION}))
            elif msg["type"] == "error":
                print(msg["code"], msg["message"])


asyncio.run(main())