@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/kit/hopBot.js

@@ -0,0 +1,142 @@
+class d {
+  constructor(s, t) {
+    this.sim = s, this.scan = t.scan, this.origin = t.origin, this.meterShown = t.meter, this.traced = t.traced ?? [72, 75, 77, 80, 16, 18];
+  }
+  sim;
+  log = [];
+  scan;
+  origin;
+  meterShown;
+  traced;
+  snapshot() {
+    return { sim: this.sim.snapshot(), log: this.log.length };
+  }
+  restore(s) {
+    this.sim.restore(s.sim), this.log.length = s.log;
+  }
+  /** The hero's position in level pixels (left/top of its bottom block). */
+  get px() {
+    const s = this.sim.pos;
+    return { x: (s.x - this.origin) * 20 + s.sx, y: (s.y - this.origin) * 20 + s.sy };
+  }
+  /** Its block (level coordinates), rounded to the nearest. */
+  get at() {
+    const s = this.px;
+    return { x: Math.round(s.x / 20), y: Math.round(s.y / 20) };
+  }
+  say(s) {
+    const t = this.px;
+    this.log.push(`[${this.sim.scene}] ${s} @${(t.x / 20).toFixed(2)},${(t.y / 20).toFixed(2)} t${this.sim.ticks} hp ${this.sim.ci.hitpts}`);
+  }
+  async tick() {
+    const s = this.sim.ci.hitpts, t = await this.sim.tick() ?? void 0;
+    if (process.env.BOT_HURT && this.sim.ci.hitpts < s) {
+      const e = this.sim.w, h = e.mi.map((r, o) => ({ mi: r, n: e.mm[o].monnum })).filter(({ mi: r, n: o }) => o < 64 && Math.abs(r.curx[0] - this.sim.pos.x) <= 1 && Math.abs(r.cury[0] - this.sim.pos.y) <= 1), i = this.meterShown;
+      this.say(
+        `  hurt ${s - this.sim.ci.hitpts}: monsters ${h.map((r) => r.n).join(",")} block ${this.sim.blockAt(this.sim.pos.x + 1, this.sim.pos.y)} ${i.name} ${this.sim.meter(i.n) - 1}`
+      );
+    }
+    return process.env.BOT_TRACE && this.say(`  keys ${this.traced.filter((e) => this.sim.isHeld(e)).join(",")} gy ${this.sim.ci.gravy}${t ? " " + t : ""}`), t;
+  }
+  async wait(s) {
+    for (let t = 0; t < s; t++) {
+      const e = await this.tick();
+      if (e) return e;
+    }
+  }
+  /** Waits until the hero stops moving up or down (standing, or holding on to something). */
+  async land(s = 80) {
+    let t = this.px.y, e = 0;
+    for (let h = 0; h < s; h++) {
+      const i = await this.tick();
+      if (i) return i;
+      const r = this.px.y;
+      if (e = r === t ? e + 1 : 0, t = r, e >= 3) return;
+    }
+    return "never landed";
+  }
+  /** Before each step of a walk: a game's chance to stop for something (keys still held). */
+  async beforeStep(s) {
+  }
+  /** Before a hop (and before a walk hops what blocks it, `dir` still held): a game's chance to wait. */
+  async beforeHop(s) {
+  }
+  /** Walks to level column `bx` (its left edge at bx * 20 px), hopping over whatever stops it. */
+  async walk(s, t = "", e = 900) {
+    const h = this.scan, i = s * 20, r = i > this.px.x ? "right" : "left", o = () => r === "right" ? this.px.x >= i : this.px.x <= i;
+    this.sim.press(h[r]);
+    let n = 0, a = this.px.x;
+    for (let l = 0; l < e && !o(); l++) {
+      const p = await this.beforeStep(r);
+      if (p) return this.sim.releaseAll(), p;
+      const m = await this.tick();
+      if (m) return this.sim.releaseAll(), m;
+      if (n = this.px.x === a ? n + 1 : 0, a = this.px.x, n >= 3) {
+        const x = await this.beforeHop(r);
+        if (x) return this.sim.releaseAll(), x;
+        this.sim.press(h.up);
+        const f = await this.wait(10);
+        if (this.sim.release(h.up), f) return this.sim.releaseAll(), f;
+        n = -12;
+      }
+    }
+    this.sim.release(h[r]);
+    const c = await this.land();
+    if (c) return c;
+    if (Math.abs(this.px.x - i) > 3) {
+      const l = this.px.x > i ? "left" : "right";
+      this.sim.press(h[l]);
+      for (let p = 0; p < 10 && Math.abs(this.px.x - i) > 2; p++) {
+        const m = await this.tick();
+        if (m) return this.sim.releaseAll(), m;
+      }
+      this.sim.release(h[l]);
+    }
+    return Math.abs(this.px.x - i) > 6 ? `walk to ${s} ${t} stopped at ${(this.px.x / 20).toFixed(2)}` : (t && this.say(`at ${t}`), this.land());
+  }
+  /**
+   * A hop: Up (or Q/E sideways) held `hold` ticks; then `steer` held while it falls, until it
+   * lands or has gone `steerTo` columns (level block x).
+   */
+  async hop(s, t = 12, e, h) {
+    const i = this.scan, r = s === "up" ? i.up : s === "left" ? i.q : i.e, o = await this.beforeHop();
+    if (o) return o;
+    this.sim.press(r);
+    let n = await this.wait(t);
+    if (this.sim.release(r), n) return this.sim.releaseAll(), n;
+    if (e) {
+      this.sim.press(i[e]);
+      const a = h !== void 0 ? h * 20 : void 0;
+      for (let c = 0; c < 60 && !(a !== void 0 && (e === "right" ? this.px.x >= a : this.px.x <= a)); c++)
+        if (n = await this.tick(), n) return this.sim.releaseAll(), n;
+      this.sim.release(i[e]);
+    }
+    return n = await this.land(), this.say(`hopped ${s}${e ? " then " + e : ""}`), n;
+  }
+  /** Holds a key for `ticks` (Down to climb down, Up to climb up, Space for the game's action). */
+  async hold(s, t) {
+    const e = this.scan[s];
+    this.sim.press(e);
+    const h = await this.wait(t);
+    return this.sim.release(e), h;
+  }
+  /** Climbs (or walks) along one axis until the hero reaches level column/row `to`. */
+  async dig(s, t, e = "", h = 400) {
+    const i = t * 20, r = () => s === "left" ? this.px.x <= i : s === "right" ? this.px.x >= i : s === "up" ? this.px.y <= i : this.px.y >= i;
+    return this.until(s, r, e || `dug ${s} to ${t}`, h);
+  }
+  /** Holds `key` until `check` says so (or `max` ticks: then it fails). */
+  async until(s, t, e, h = 300) {
+    const i = s === void 0 ? void 0 : this.scan[s];
+    i !== void 0 && this.sim.press(i);
+    for (let r = 0; r < h && !t(); r++) {
+      const o = await this.tick();
+      if (o) return this.sim.releaseAll(), o;
+    }
+    if (i !== void 0 && this.sim.release(i), !t()) return `never ${e}`;
+    this.say(e);
+  }
+}
+export {
+  d as HopBot
+};