@pikehub/warpass-bot 0.0.0-stage → 62.0.1

package/index.js

@@ -0,0 +1,483 @@
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const require = createRequire(import.meta.url);
+const here = dirname(fileURLToPath(import.meta.url));
+
+function triple() {
+  const abi = process.platform === "linux" ? "-gnu" : process.platform === "win32" ? "-msvc" : "";
+  return `${process.platform}-${process.arch}${abi}`;
+}
+
+function loadNative() {
+  const local = join(here, `warpass-bot.${triple()}.node`);
+  if (existsSync(local)) return require(local);
+  return require(`@pikehub/warpass-bot-${triple()}`);
+}
+
+const native = loadNative();
+
+export const ENGINE_VERSION = native.ENGINE_VERSION;
+export const DEFAULT_URL = "https://warpass.pike.com.br";
+export const TILE = 256;
+export const TICKS_PER_SECOND = 20;
+
+const parse = (text) => (text === null || text === undefined ? null : JSON.parse(text));
+
+export class WarpassError extends Error {
+  constructor(raw) {
+    let info = null;
+    try {
+      info = JSON.parse(raw);
+    } catch {
+      info = null;
+    }
+    super(info && info.kind ? describe(info) : String(raw));
+    this.name = "WarpassError";
+    this.kind = info?.kind ?? "error";
+    Object.assign(this, info || {});
+  }
+}
+
+function describe(e) {
+  switch (e.kind) {
+    case "outdatedEngine":
+      return `This SDK runs engine ${e.have} but the server runs engine ${e.need}. Install @pikehub/warpass-bot@${e.need}.`;
+    case "unauthenticated":
+      return "The bot key was refused.";
+    case "refused":
+      return `${e.about} refused (${e.reason}): ${e.message}`;
+    case "cancelled":
+      return `The match offer was cancelled (${e.reason}).`;
+    default:
+      return e.message || e.reason || e.kind;
+  }
+}
+
+function attempt(call) {
+  try {
+    return call();
+  } catch (err) {
+    throw new WarpassError(err && err.message ? err.message : err);
+  }
+}
+
+async function guard(promise) {
+  try {
+    return await promise;
+  } catch (err) {
+    throw new WarpassError(err && err.message ? err.message : err);
+  }
+}
+
+function units(list) {
+  return (Array.isArray(list) ? list : [list]).map((u) => (typeof u === "number" ? u : u.eid));
+}
+
+function point(p) {
+  return Array.isArray(p) ? p : [p.x, p.y];
+}
+
+export class Orders {
+  constructor() {
+    this.list = [];
+  }
+
+  push(order, args) {
+    this.list.push(attempt(() => native.encode(order, args)));
+    return this;
+  }
+
+  move(who, x, y, { queued = false } = {}) {
+    return this.push("move", { units: units(who), x, y, queued });
+  }
+
+  attackMove(who, x, y, { queued = false } = {}) {
+    return this.push("attackMove", { units: units(who), x, y, queued });
+  }
+
+  formMove(who, x, y, { face = [0, 256], queued = false, attack = false } = {}) {
+    return this.push("formMove", { units: units(who), x, y, face, queued, attack });
+  }
+
+  target(who, target, { queued = false } = {}) {
+    return this.push("target", { units: units(who), target, queued });
+  }
+
+  attack(who, target, { queued = false } = {}) {
+    return this.push("attack", { units: units(who), target, queued });
+  }
+
+  repair(who, target, { queued = false } = {}) {
+    return this.push("repair", { units: units(who), target, queued });
+  }
+
+  gather(who, tile, { queued = false } = {}) {
+    return this.push("gather", { units: units(who), tile: point(tile), queued });
+  }
+
+  build(who, building, at, { queued = false } = {}) {
+    return this.push("build", { units: units(who), building, at: point(at), queued });
+  }
+
+  buildLine(who, building, from, to, { queued = false } = {}) {
+    return this.push("buildLine", { units: units(who), building, from: point(from), to: point(to), queued });
+  }
+
+  train(building, unit, count = 1) {
+    return this.push("train", { building, unit, count });
+  }
+
+  research(building, upgrade) {
+    return this.push("research", { building, upgrade });
+  }
+
+  cancel(building, index) {
+    return this.push("cancel", { building, index });
+  }
+
+  rally(buildings, x, y) {
+    return this.push("rally", { buildings: units(buildings), x, y });
+  }
+
+  stop(who) {
+    return this.push("stop", { units: units(who) });
+  }
+
+  hold(who) {
+    return this.push("hold", { units: units(who) });
+  }
+
+  formUp(who) {
+    return this.push("formUp", { units: units(who) });
+  }
+
+  remove(who) {
+    return this.push("remove", { units: units(who) });
+  }
+
+  spawnToggle(buildings, on) {
+    return this.push("spawnToggle", { buildings: units(buildings), on });
+  }
+
+  surrender() {
+    return this.push("surrender", {});
+  }
+}
+
+function queries(call) {
+  const refusal = (q, args) => call(q, args);
+  return {
+    canAfford: (id) => call("canAfford", { id }),
+    cost: (id) => call("cost", { id }),
+    trainRefusal: (building, unit) => refusal("trainRefusal", { building, unit }),
+    canTrain: (building, unit) => refusal("trainRefusal", { building, unit }) === null,
+    researchRefusal: (building, upgrade) => refusal("researchRefusal", { building, upgrade }),
+    canResearch: (building, upgrade) => refusal("researchRefusal", { building, upgrade }) === null,
+    placeRefusal: (building, at) => refusal("placeRefusal", { building, at: point(at) }),
+    canPlace: (building, at) => refusal("placeRefusal", { building, at: point(at) }) === null,
+    findPlacement: (building, near, radius = 16) => call("findPlacement", { building, near: point(near), radius }),
+    nearestResource: (from, resource, radius = 40) => call("nearestResource", { from: point(from), resource, radius }),
+    reachable: (from, to) => call("reachable", { from: point(from), to: point(to) }),
+    front: (toward) => call("front", toward ? { toward: point(toward) } : {}),
+    tile: (at) => call("tile", { at: point(at) }),
+    map: () => call("map", {}),
+    view: () => call("view", {}),
+  };
+}
+
+async function runThink(think, req, game) {
+  const act = new Orders();
+  await think({ view: req.view, events: req.events, tick: req.tick, slot: req.slot, game, act });
+  return act.list;
+}
+
+export class Warpass {
+  constructor(session, url, token, hello) {
+    this.session = session;
+    this.url = url;
+    this.token = token;
+    this.name = hello.name;
+    this.engineVersion = hello.engineVersion;
+  }
+
+  static async connect({ token, url = DEFAULT_URL } = {}) {
+    if (!token) throw new WarpassError(JSON.stringify({ kind: "unauthenticated" }));
+    const session = new native.OnlineSession();
+    const hello = parse(await guard(session.connect(url, token)));
+    return new Warpass(session, url, token, hello);
+  }
+
+  async queue({ race, avoidBots = false } = {}) {
+    const offer = parse(await guard(this.session.queue(race, avoidBots)));
+    return new Offer(this.session, offer);
+  }
+
+  async lobby({ code, race, everyTicks = 10 } = {}) {
+    const info = parse(await guard(this.session.lobby(String(code ?? ""), race, everyTicks)));
+    return new OnlineMatch(this.session, info);
+  }
+
+  static async join({ token, url = DEFAULT_URL, matchId, everyTicks = 10 } = {}) {
+    const session = new native.OnlineSession();
+    const info = parse(await guard(session.join(url, token, matchId, everyTicks)));
+    return new OnlineMatch(session, info);
+  }
+}
+
+export class Offer {
+  constructor(session, offer) {
+    this.session = session;
+    this.offerId = offer.offerId;
+    this.opponent = offer.opponent;
+  }
+
+  async accept({ everyTicks = 10 } = {}) {
+    const info = parse(await guard(this.session.accept(everyTicks)));
+    return new OnlineMatch(this.session, info);
+  }
+
+  async decline() {
+    await guard(this.session.decline());
+  }
+}
+
+export class OnlineMatch {
+  constructor(session, info) {
+    this.session = session;
+    this.id = info.matchId;
+    this.slot = info.slot;
+    this.loop = null;
+    this.game = queries((q, args) => session.query(q, args));
+  }
+
+  onThink(think, { everyTicks } = {}) {
+    if (everyTicks) this.session.setEvery(everyTicks);
+    this.loop = (async () => {
+      for (;;) {
+        const req = parse(await guard(this.session.nextThink()));
+        if (!req) return;
+        let orders = [];
+        try {
+          orders = await runThink(think, req, this.game);
+        } finally {
+          this.session.submit(orders);
+        }
+      }
+    })();
+    return this;
+  }
+
+  async ended() {
+    if (!this.loop) this.onThink(() => {});
+    await this.loop;
+    return { reason: this.session.endReason() };
+  }
+
+  async result({ timeoutMs = 120000 } = {}) {
+    await this.ended();
+    return parse(await guard(this.session.result(timeoutMs)));
+  }
+}
+
+export function Bot({ race, think, everyTicks = 10, name = "" }) {
+  return { kind: "bot", race, everyTicks, name, think };
+}
+
+export function Ai({ race, level = 5 }) {
+  return { kind: "ai", race, level };
+}
+
+export function Idle({ race }) {
+  return { kind: "idle", race };
+}
+
+export class Match {
+  constructor({ seed, players, mapSize = null, maxTicks = null }) {
+    this.seed = seed;
+    this.players = players;
+    this.mapSize = mapSize;
+    this.maxTicks = maxTicks;
+  }
+
+  toNative() {
+    return {
+      seed: this.seed,
+      mapSize: this.mapSize ?? undefined,
+      maxTicks: this.maxTicks ?? undefined,
+      players: this.players.map(({ think, ...p }) => p),
+    };
+  }
+}
+
+export class Replay {
+  constructor(data) {
+    this.data = data;
+  }
+
+  static load(pathOrText) {
+    const text = existsSync(pathOrText) ? readFileSync(pathOrText, "utf8") : pathOrText;
+    return new Replay(JSON.parse(text));
+  }
+
+  save(path) {
+    writeFileSync(path, JSON.stringify(this.data));
+    return path;
+  }
+
+  verify() {
+    return attempt(() => native.verifyReplay(JSON.stringify(this.data)));
+  }
+
+  analyse() {
+    return this.verify().analysis;
+  }
+}
+
+export class GameResult {
+  constructor(r) {
+    Object.assign(this, r);
+    this.replay = new Replay(r.replay);
+  }
+
+  won(slot) {
+    return this.finished && this.winnerSlot === slot;
+  }
+}
+
+export async function play(match) {
+  const m = match instanceof Match ? match : new Match(match);
+  const session = attempt(() => new native.LocalSession(m.toNative()));
+  for (let req = session.nextThink(); req; req = session.nextThink()) {
+    const player = m.players[req.slot];
+    let orders = [];
+    if (player && player.think) {
+      const game = queries((q, args) => session.query(req.slot, q, args));
+      orders = await runThink(player.think, req, game);
+    }
+    session.submit(req.slot, orders);
+  }
+  return new GameResult(session.result());
+}
+
+export async function playMany(matches, { concurrency = 4 } = {}) {
+  const list = matches.map((m) => (m instanceof Match ? m : new Match(m)));
+  if (list.every((m) => m.players.every((p) => p.kind !== "bot"))) {
+    const raw = parse(await guard(native.playMany(list.map((m) => m.toNative()))));
+    return raw.map((r) => new GameResult(r));
+  }
+  const out = new Array(list.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < list.length) {
+      const k = next++;
+      out[k] = await play(list[k]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, list.length) }, worker));
+  return out;
+}
+
+export class CustomGame {
+  constructor({ seed = 1, races = [], mapType = null, aiLevel = 0 } = {}) {
+    this.native = new native.CustomSession(seed, races, mapType, aiLevel);
+    this.game = (slot) => queries((q, args) => this.native.query(slot, q, args));
+  }
+
+  setup(op) {
+    return attempt(() => this.native.setup(op));
+  }
+
+  spawn(owner, unit, x, y) {
+    return this.setup({ op: "spawn", owner, unit, x, y });
+  }
+
+  building(owner, building, tx, ty) {
+    return this.setup({ op: "building", owner, building, tx, ty });
+  }
+
+  terrain(tx, ty, terrain) {
+    const id = typeof terrain === "number" ? terrain : rules().terrains[terrain];
+    return this.setup({ op: "terrain", tile: ty * this.map().width + tx, terrain: id });
+  }
+
+  flattenArea(w, h) {
+    return attempt(() => this.native.flattenArea(w, h));
+  }
+
+  research(owner, upgrade) {
+    return this.setup({ op: "research", owner, upgrade });
+  }
+
+  resources(owner, { food = 0, wood = 0, stone = 0, gold = 0 } = {}) {
+    return this.setup({ op: "resources", owner, food, wood, stone, gold });
+  }
+
+  weather(key, duration, ramp = 0) {
+    return this.setup({ op: "weather", key, duration, ramp });
+  }
+
+  reveal(owner, eid = -1) {
+    return this.setup({ op: "reveal", owner, eid });
+  }
+
+  remove(eid) {
+    return this.setup({ op: "remove", eid });
+  }
+
+  order(slot, build) {
+    const act = new Orders();
+    build(act);
+    this.native.order(slot, act.list);
+  }
+
+  step(n = 1) {
+    return this.native.step(n);
+  }
+
+  until(maxTicks, done) {
+    for (let k = 0; k < maxTicks; k++) {
+      this.native.step(1);
+      if (done(this.observer(), this.tick)) return k + 1;
+    }
+    return -1;
+  }
+
+  view(slot) {
+    return this.native.view(slot);
+  }
+
+  observer() {
+    return this.native.view(null);
+  }
+
+  map() {
+    return this.native.query(0, "map", {});
+  }
+
+  replay() {
+    return new Replay(this.native.replay());
+  }
+
+  get tick() {
+    return this.native.tick;
+  }
+
+  get winner() {
+    return this.native.winner;
+  }
+}
+
+export function rules(race) {
+  return native.rules(race ?? null);
+}
+
+export function docs(page) {
+  return native.docs(page ?? null);
+}
+
+export function docsIndex() {
+  return native.docsIndex();
+}