mioku-plugin-mc 2.1.0 → 3.0.1

package/play/behavior/catalog/seek-shelter.ts

@@ -0,0 +1,85 @@
+import { Vec3 } from "vec3";
+import { Behavior, type BehaviorContext } from "../base-behavior";
+import { GoalNear } from "../../path-engine";
+
+export class SeekShelterBehavior extends Behavior {
+  readonly name = "seek_shelter";
+  readonly category = "movement" as const;
+  private moving = false;
+  private attempted = false;
+
+  onTick(ctx: BehaviorContext): void {
+    if (this.moving || this.attempted) return;
+    this.attempted = true;
+    const target = findShelteredPosition(ctx.bot);
+    if (!target) {
+      this.mission?.block("resource_not_found", "附近没有找到可到达的遮蔽位置");
+      return;
+    }
+    const engine = ctx.bot.pathEngine;
+    if (!engine) {
+      this.mission?.fail("path_unreachable", "寻路引擎不可用");
+      return;
+    }
+    this.moving = true;
+    engine
+      .goto(new GoalNear(target.x, target.y, target.z, 1))
+      .then(() => this.mission?.succeed("已到达遮蔽位置", target))
+      .catch((error: unknown) =>
+        this.mission?.fail("path_unreachable", String(error), target),
+      )
+      .finally(() => {
+        this.moving = false;
+      });
+  }
+
+  onStop(ctx: BehaviorContext): void {
+    try {
+      ctx.bot.pathEngine?.stop();
+    } catch {
+      // ignore
+    }
+  }
+}
+
+function findShelteredPosition(
+  bot: any,
+): { x: number; y: number; z: number } | null {
+  const position = bot.entity?.position;
+  if (!position) return null;
+  const y = Math.floor(position.y);
+  for (let radius = 0; radius <= 12; radius++) {
+    for (let dx = -radius; dx <= radius; dx++) {
+      for (let dz = -radius; dz <= radius; dz++) {
+        if (radius > 0 && Math.abs(dx) !== radius && Math.abs(dz) !== radius)
+          continue;
+        const x = Math.floor(position.x) + dx;
+        const z = Math.floor(position.z) + dz;
+        const floor = bot.blockAt(new Vec3(x, y - 1, z), false);
+        const feet = bot.blockAt(new Vec3(x, y, z), false);
+        const head = bot.blockAt(new Vec3(x, y + 1, z), false);
+        const roof = bot.blockAt(new Vec3(x, y + 2, z), false);
+        if (isSolid(floor) && isAir(feet) && isAir(head) && isSolid(roof))
+          return { x, y, z };
+      }
+    }
+  }
+  return null;
+}
+
+function isAir(block: any): boolean {
+  return (
+    !block ||
+    block.boundingBox === "empty" ||
+    block.name === "air" ||
+    block.name === "cave_air"
+  );
+}
+
+function isSolid(block: any): boolean {
+  return (
+    !!block &&
+    block.boundingBox !== "empty" &&
+    !/^(water|lava|fire)$/.test(String(block.name))
+  );
+}

package/play/behavior/engine.ts

@@ -0,0 +1,243 @@
+import type { Behavior, BehaviorContext } from "./base-behavior";
+import type { MovementInit } from "../types";
+import { createBehavior } from "./catalog/factory";
+import type { BehaviorMode, ModeState } from "../state/mode";
+
+export interface BehaviorEngineOptions {
+  ctxBuilder: () => BehaviorContext | null;
+  tickInterval: number;
+  survival: Behavior[];
+  overlays: Behavior[];
+  initialMovement?: MovementInit;
+}
+
+export interface BehaviorStateInfo {
+  name: string;
+  category: string;
+  priority: number;
+  enabled: boolean;
+  active: boolean;
+}
+
+export class BehaviorEngine {
+  private readonly survival: Behavior[];
+  private readonly overlays: Behavior[];
+  private movement: Behavior | null = null;
+  private missionId: string | null = null;
+  private missionBehaviors: Behavior[] = [];
+  private timer?: NodeJS.Timeout;
+  private current: Behavior | null = null;
+  private lastMode: BehaviorMode = "IDLE";
+  private readonly lastSwitch: ModeState["lastSwitch"] = {
+    from: null,
+    to: "IDLE",
+    reason: "init",
+    at: Date.now(),
+  };
+  private readonly ctxBuilder: () => BehaviorContext | null;
+  private readonly tickInterval: number;
+
+  constructor(opts: BehaviorEngineOptions) {
+    this.ctxBuilder = opts.ctxBuilder;
+    this.tickInterval = opts.tickInterval;
+    this.survival = opts.survival;
+    this.overlays = opts.overlays;
+    if (opts.initialMovement) {
+      this.movement = createBehavior(opts.initialMovement);
+      this.movement.enabled = true;
+    }
+  }
+
+  start(): void {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.tick(), this.tickInterval);
+  }
+
+  stop(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+    const ctx = this.ctxBuilder();
+    if (this.current && ctx) {
+      try {
+        this.current.onStop(ctx);
+      } catch {
+        // ignore
+      }
+    }
+    this.current = null;
+  }
+
+  setMissionBehaviors(missionId: string, behaviors: Behavior[]): void {
+    this.missionId = missionId;
+    for (const b of behaviors) b.enabled = true;
+    this.missionBehaviors = behaviors;
+  }
+
+  removeMissionBehaviors(missionId: string): void {
+    if (this.missionId === missionId) {
+      this.missionBehaviors = [];
+      this.missionId = null;
+    }
+  }
+
+  toggleOverlay(name: string, enabled: boolean, params?: Record<string, string>): boolean {
+    const b = this.overlays.find((o) => o.name === name);
+    if (!b) return false;
+    if (params) b.configure(params);
+    b.enabled = enabled;
+    return true;
+  }
+
+  isOverlayEnabled(name: string): boolean {
+    const b = this.overlays.find((o) => o.name === name);
+    return b?.enabled ?? false;
+  }
+
+  clear(): void {
+    for (const o of this.overlays) o.enabled = false;
+    this.movement = createBehavior({ name: "idle", params: {} });
+    this.movement.enabled = true;
+    this.missionBehaviors = [];
+    this.missionId = null;
+  }
+
+  stopMission(): void {
+    this.movement = createBehavior({ name: "idle", params: {} });
+    this.movement.enabled = true;
+    this.missionBehaviors = [];
+    this.missionId = null;
+  }
+
+  currentLabel(): string | null {
+    return this.current?.name ?? null;
+  }
+
+  getStates(ctx: BehaviorContext): BehaviorStateInfo[] {
+    const all = this.getAllBehaviors();
+    return all.map((b) => ({
+      name: b.name,
+      category: b.category,
+      priority: b.priority,
+      enabled: b.effectivelyEnabled,
+      active: b.effectivelyEnabled && this.safeActive(b, ctx),
+    }));
+  }
+
+  getAllBehaviors(): Behavior[] {
+    const list: Behavior[] = [];
+    list.push(...this.survival);
+    list.push(...this.overlays);
+    for (const b of this.missionBehaviors) list.push(b);
+    if (this.movement) list.push(this.movement);
+    return list;
+  }
+
+  modeState(): ModeState {
+    const next = this.computeMode();
+    if (next !== this.lastMode) {
+      this.lastSwitch.from = this.lastMode;
+      this.lastSwitch.to = next;
+      this.lastSwitch.reason = next === "EMERGENCY" ? "emergency_engaged" : "emergency_cleared";
+      this.lastSwitch.at = Date.now();
+      this.lastMode = next;
+    }
+    return {
+      current: this.lastMode,
+      mission: null,
+      lastSwitch: { ...this.lastSwitch },
+    };
+  }
+
+  private tick(): void {
+    const ctx = this.ctxBuilder();
+    if (!ctx) return;
+
+    const candidates: Behavior[] = [];
+    for (const b of this.survival) candidates.push(b);
+    for (const b of this.overlays) candidates.push(b);
+    for (const b of this.missionBehaviors) candidates.push(b);
+    if (!this.missionHasActive(ctx) && this.movement) candidates.push(this.movement);
+
+    let winner: Behavior | null = null;
+    for (const b of candidates) {
+      if (!b.effectivelyEnabled) continue;
+      if (!this.safeActive(b, ctx)) continue;
+      if (!winner || b.priority > winner.priority) winner = b;
+    }
+
+    if (this.current !== winner) {
+      if (this.current) {
+        try {
+          this.current.onStop(ctx);
+        } catch (e) {
+          ctx.log(`行为 onStop 失败(${this.current.name}): ${e}`);
+        }
+      }
+      this.current = winner;
+      if (this.current) {
+        try {
+          this.current.onStart(ctx);
+        } catch (e) {
+          ctx.log(`行为 onStart 失败(${this.current.name}): ${e}`);
+        }
+      }
+    }
+
+    if (this.current) {
+      try {
+        this.current.onTick(ctx);
+      } catch (e) {
+        ctx.log(`行为 onTick 失败(${this.current.name}): ${e}`);
+      }
+      if (this.current.isFinished()) {
+        try {
+          this.current.onStop(ctx);
+        } catch {
+          // ignore
+        }
+        this.current = null;
+      }
+    }
+  }
+
+  private safeActive(b: Behavior, ctx: BehaviorContext): boolean {
+    try {
+      return b.isActive(ctx);
+    } catch {
+      return false;
+    }
+  }
+
+  private missionHasActive(ctx: BehaviorContext): boolean {
+    for (const b of this.missionBehaviors) {
+      if (!b.effectivelyEnabled) continue;
+      if (this.safeActive(b, ctx)) return true;
+    }
+    return false;
+  }
+
+  private computeMode(): BehaviorMode {
+    const ctx = this.ctxBuilder();
+    if (!ctx) return this.lastMode;
+    const all = [...this.survival, ...this.overlays, ...this.missionBehaviors];
+    if (!this.missionHasActive(ctx) && this.movement) all.push(this.movement);
+    let emergency = false;
+    let mission = false;
+    for (const b of all) {
+      if (!b.effectivelyEnabled) continue;
+      if (!this.safeActive(b, ctx)) continue;
+      if (b.category === "survival") {
+        emergency = true;
+        break;
+      }
+      if (b.category === "movement" || b.category === "combat") {
+        mission = true;
+      }
+    }
+    if (emergency) return "EMERGENCY";
+    if (mission) return "MISSION";
+    return "IDLE";
+  }
+}

package/play/behavior/survival/auto-eat.ts

@@ -0,0 +1,46 @@
+import { Behavior, type BehaviorContext } from "../base-behavior";
+import { nearestHostile } from "../../util/entities";
+import { eatFood, findFood } from "../../util/inventory";
+
+const HUNGER_THRESHOLD = 10;
+const COMBAT_BLOCK_RADIUS = 5;
+
+export class AutoEatBehavior extends Behavior {
+  readonly name = "auto_eat";
+  readonly category = "maintenance" as const;
+  private eating = false;
+
+  isActive(ctx: BehaviorContext): boolean {
+    const bot = ctx.bot;
+    if ((bot.food ?? 20) > HUNGER_THRESHOLD) return false;
+    if (!findFood(bot)) return false;
+    return nearestHostile(bot, COMBAT_BLOCK_RADIUS) === null;
+  }
+
+  async onTick(ctx: BehaviorContext): Promise<void> {
+    if (this.eating) return;
+    this.eating = true;
+    try {
+      ctx.bot.clearControlStates();
+    } catch {
+      // ignore
+    }
+    try {
+      await eatFood(ctx.bot);
+    } finally {
+      this.eating = false;
+    }
+  }
+
+  onStop(): void {
+    this.eating = false;
+  }
+
+  contributesState(ctx: BehaviorContext): Record<string, unknown> {
+    return {
+      eating: this.eating,
+      food: ctx.bot.food ?? 0,
+      foodLow: (ctx.bot.food ?? 20) <= HUNGER_THRESHOLD,
+    };
+  }
+}

package/play/behavior/survival/escape-lava.ts

@@ -0,0 +1,44 @@
+import { Behavior, type BehaviorContext } from "../base-behavior";
+
+export class EscapeLavaBehavior extends Behavior {
+  readonly name = "escape_lava";
+  readonly category = "survival" as const;
+
+  isActive(ctx: BehaviorContext): boolean {
+    const bot = ctx.bot;
+    const pos = bot.entity?.position;
+    if (!pos) return false;
+    const feet = bot.blockAt(pos);
+    const below = bot.blockAt(pos.offset(0, -1, 0));
+    const isDanger = (b: any) => {
+      const n = String(b?.name ?? "").toLowerCase();
+      return n === "lava" || n === "fire" || n === "flowing_lava";
+    };
+    return isDanger(feet) || isDanger(below);
+  }
+
+  onStart(ctx: BehaviorContext): void {
+    try { ctx.bot.pathEngine?.setGoal(null); } catch { /* ignore */ }
+  }
+
+  onTick(ctx: BehaviorContext): void {
+    ctx.bot.setControlState("jump", true);
+    ctx.bot.setControlState("sprint", true);
+    ctx.bot.setControlState("forward", true);
+  }
+
+  onStop(ctx: BehaviorContext): void {
+    try {
+      ctx.bot.clearControlStates();
+    } catch {
+      // ignore
+    }
+  }
+
+  contributesState(): Record<string, unknown> {
+    return {
+      active: true,
+      hazard: "lava_or_fire",
+    };
+  }
+}

package/play/behavior/survival/escape-water.ts

@@ -0,0 +1,35 @@
+import { Behavior, type BehaviorContext } from "../base-behavior";
+
+export class EscapeWaterBehavior extends Behavior {
+  readonly name = "escape_water";
+  readonly category = "survival" as const;
+
+  isActive(ctx: BehaviorContext): boolean {
+    return (ctx.bot.oxygenLevel ?? 20) <= 0;
+  }
+
+  onStart(ctx: BehaviorContext): void {
+    try { ctx.bot.pathEngine?.setGoal(null); } catch { /* ignore */ }
+  }
+
+  onTick(ctx: BehaviorContext): void {
+    ctx.bot.setControlState("jump", true);
+    ctx.bot.setControlState("forward", true);
+  }
+
+  onStop(ctx: BehaviorContext): void {
+    try {
+      ctx.bot.clearControlStates();
+    } catch {
+      // ignore
+    }
+  }
+
+  contributesState(ctx: BehaviorContext): Record<string, unknown> {
+    return {
+      active: true,
+      oxygen: ctx.bot.oxygenLevel ?? 0,
+      drowning: true,
+    };
+  }
+}

package/play/behavior/survival/flee-creeper.ts

@@ -0,0 +1,76 @@
+import { Behavior, type BehaviorContext } from "../base-behavior";
+import { GoalXZ } from "../../path-engine";
+import { nearestCreeper } from "../../util/entities";
+import { hasShield } from "../../util/inventory";
+
+const CREEPER_FLEE_RADIUS = 6;
+const FLEE_DISTANCE = 10;
+const FLEE_TIMEOUT_MS = 5_000;
+
+export class FleeCreeperBehavior extends Behavior {
+  readonly name = "flee_creeper";
+  readonly category = "survival" as const;
+  private fleeing = false;
+
+  isActive(ctx: BehaviorContext): boolean {
+    if (hasShield(ctx.bot)) return false;
+    return nearestCreeper(ctx.bot, CREEPER_FLEE_RADIUS) !== null;
+  }
+
+  onTick(ctx: BehaviorContext): void {
+    if (this.fleeing) return;
+    const bot = ctx.bot;
+    const engine = bot.pathEngine;
+    if (!engine) return;
+    const creeper = nearestCreeper(bot, CREEPER_FLEE_RADIUS + 2);
+    if (!creeper) return;
+    const pos = bot.entity?.position;
+    const cp = creeper.position;
+    if (!pos || !cp) return;
+    const dx = pos.x - cp.x;
+    const dz = pos.z - cp.z;
+    const len = Math.hypot(dx, dz) || 1;
+    const tx = Math.floor(pos.x + (dx / len) * FLEE_DISTANCE);
+    const tz = Math.floor(pos.z + (dz / len) * FLEE_DISTANCE);
+    this.fleeing = true;
+    ctx.log(`flee_creeper -> (${tx},${tz})`);
+    const timer = setTimeout(() => {
+      try {
+        engine.stop();
+      } catch {
+        // ignore
+      }
+    }, FLEE_TIMEOUT_MS);
+    engine
+      .goto(new GoalXZ(tx, tz))
+      .catch(() => {
+        // ignore
+      })
+      .finally(() => {
+        clearTimeout(timer);
+        try {
+          engine.setGoal(null);
+        } catch {
+          // ignore
+        }
+        this.fleeing = false;
+      });
+  }
+
+  onStop(ctx: BehaviorContext): void {
+    try {
+      ctx.bot.pathEngine?.stop();
+    } catch {
+      // ignore
+    }
+    this.fleeing = false;
+  }
+
+  contributesState(): Record<string, unknown> {
+    return {
+      active: true,
+      hazard: "creeper",
+      fleeing: this.fleeing,
+    };
+  }
+}

package/play/behavior/survival/mlg-fall.ts

@@ -0,0 +1,56 @@
+import { Behavior, type BehaviorContext } from "../base-behavior";
+
+const FALL_VELOCITY_THRESHOLD = -0.7;
+
+export class MlgFallBehavior extends Behavior {
+  readonly name = "mlg_fall";
+  readonly category = "survival" as const;
+  private placed = false;
+
+  isActive(ctx: BehaviorContext): boolean {
+    const bot = ctx.bot;
+    const vy = bot.entity?.velocity?.y;
+    if (vy === undefined || vy >= FALL_VELOCITY_THRESHOLD) return false;
+    const head = bot.entity?.position;
+    if (!head) return false;
+    const below = bot.blockAt(head.offset(0, -2, 0));
+    const n = String(below?.name ?? "").toLowerCase();
+    return n !== "water" && n !== "lava";
+  }
+
+  onStart(ctx: BehaviorContext): void {
+    this.placed = false;
+    try { ctx.bot.pathEngine?.setGoal(null); } catch { /* ignore */ }
+  }
+
+  onTick(ctx: BehaviorContext): void {
+    if (this.placed) return;
+    const bot = ctx.bot;
+    const bucket = bot.inventory?.items?.().find((i: any) => i.name === "water_bucket");
+    if (!bucket) return;
+    this.placed = true;
+    void (async () => {
+      try {
+        await bot.equip(bucket, "hand");
+        bot.look(0, Math.PI / 2, true);
+        bot.activateItem();
+        setTimeout(() => {
+          try {
+            bot.activateItem();
+          } catch {
+            // ignore
+          }
+        }, 400);
+      } catch {
+        this.placed = false;
+      }
+    })();
+  }
+
+  contributesState(): Record<string, unknown> {
+    return {
+      active: true,
+      waterBucketPlaced: this.placed,
+    };
+  }
+}