mioku-plugin-mc 2.1.0 → 3.0.1

package/play/missions/bundles/gather-resource.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import {
+  CATEGORY_PRIORITY,
+  type Behavior,
+} from "../../behavior/base-behavior";
+import { GatherResourceBehavior } from "../../behavior/catalog/gather";
+import type {
+  BehaviorBundle,
+  BehaviorEntry,
+  BundleBuildContext,
+} from "../registry";
+
+const paramsSchema = z.object({
+  resource: z
+    .enum(["wood", "stone", "coal", "iron", "dirt"])
+    .default("wood")
+    .describe("资源类型"),
+  count: z.number().int().min(1).max(64).default(1).describe("目标采集数量"),
+});
+
+export type GatherResourceParams = z.infer<typeof paramsSchema>;
+
+export const gatherResourceBundle: BehaviorBundle<GatherResourceParams> = {
+  id: "task.gather_resource",
+  description: "采集资源（wood/stone/coal/iron/dirt）。",
+  mode: "MISSION",
+  paramsSchema,
+  build(params: GatherResourceParams): BehaviorEntry[] {
+    const b: Behavior = new GatherResourceBehavior();
+    b.configure({ resource: params.resource, count: String(params.count) });
+    return [{ priority: CATEGORY_PRIORITY.movement, behavior: b }];
+  },
+  snapshot(internal: unknown): unknown {
+    const i = internal as { resource: string } | null;
+    return i ? { resource: i.resource } : null;
+  },
+};

package/play/missions/bundles/idle-wander.ts

@@ -0,0 +1,24 @@
+import {
+  CATEGORY_PRIORITY,
+  type Behavior,
+} from "../../behavior/base-behavior";
+import { IdleWanderBehavior } from "../../behavior/catalog/idle";
+import { z } from "zod";
+import type {
+  BehaviorBundle,
+  BehaviorEntry,
+} from "../registry";
+
+const paramsSchema = z.object({}).strict();
+
+export const idleWanderBundle: BehaviorBundle<Record<string, never>> = {
+  id: "task.idle_wander",
+  description: "原地待机：随机张望 + 偶尔短走。最低优先级。",
+  mode: "IDLE",
+  paramsSchema,
+  build(): BehaviorEntry[] {
+    const b: Behavior = new IdleWanderBehavior();
+    b.configure({});
+    return [{ priority: CATEGORY_PRIORITY.movement, behavior: b }];
+  },
+};

package/play/missions/bundles/seek-shelter.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { CATEGORY_PRIORITY, type Behavior } from "../../behavior/base-behavior";
+import { SeekShelterBehavior } from "../../behavior/catalog/seek-shelter";
+import type { BehaviorBundle, BehaviorEntry } from "../registry";
+
+const paramsSchema = z.object({}).strict();
+
+export const seekShelterBundle: BehaviorBundle<Record<string, never>> = {
+  id: "task.seek_shelter",
+  description: "寻找附近有实体屋顶的安全位置，到达后完成。",
+  mode: "MISSION",
+  paramsSchema,
+  build(): BehaviorEntry[] {
+    const behavior: Behavior = new SeekShelterBehavior();
+    behavior.configure({});
+    return [{ priority: CATEGORY_PRIORITY.movement, behavior }];
+  },
+};

package/play/missions/mission-controller.ts

@@ -0,0 +1,296 @@
+import { randomUUID } from "node:crypto";
+import type { BehaviorMissionReporter } from "../behavior/base-behavior";
+import type { BehaviorEngine } from "../behavior/engine";
+import type { MemoryBus } from "../state/memory-bus";
+import type {
+  MissionErrorCode,
+  MissionOutcome,
+  MissionState,
+  ModeState,
+} from "../state/mode";
+import type { BehaviorBundle, TaskRegistry } from "./registry";
+
+export type BundleId = string;
+export type MissionId = string;
+
+export type SwitchResult =
+  | {
+      kind: "applied";
+      missionId: MissionId;
+      bundleId: BundleId;
+      effectiveAt: number;
+      message: string;
+    }
+  | {
+      kind: "rejected";
+      reason:
+        | "unknown_bundle"
+        | "invalid_params"
+        | "no_bot_session"
+        | "engine_busy"
+        | "rejected_by_engine";
+      detail: string;
+    };
+
+export interface MissionSpec {
+  bundle: BundleId;
+  params?: Record<string, unknown>;
+  objective?: string;
+  directiveId?: string;
+  completesDirectiveOnSuccess?: boolean;
+}
+
+export interface MissionControllerOptions {
+  registry: TaskRegistry;
+  engine: BehaviorEngine;
+  bus: MemoryBus;
+  buildContext: () => any;
+  log?: (msg: string) => void;
+  onOutcome?: (outcome: MissionOutcome) => void;
+}
+
+const EMPTY_LAST_SWITCH = {
+  from: null,
+  to: "IDLE" as const,
+  reason: "init",
+  at: 0,
+};
+
+export class MissionController {
+  private current: MissionState | null = null;
+  private currentBundle: BehaviorBundle | null = null;
+  private lastOutcome: MissionOutcome | null = null;
+  private modeState: ModeState = {
+    current: "IDLE",
+    mission: null,
+    lastSwitch: { ...EMPTY_LAST_SWITCH, at: Date.now() },
+  };
+
+  constructor(private readonly opts: MissionControllerOptions) {}
+
+  getModeState(): ModeState {
+    return this.modeState;
+  }
+
+  getCurrentMission(): MissionState | null {
+    return this.current ? { ...this.current } : null;
+  }
+
+  getLastOutcome(): MissionOutcome | null {
+    return this.lastOutcome ? { ...this.lastOutcome } : null;
+  }
+
+  startMission(spec: MissionSpec): SwitchResult {
+    const validation = this.opts.registry.validate(spec.bundle, spec.params);
+    if (!validation.ok) {
+      const reason = validation.error.startsWith("unknown_bundle")
+        ? "unknown_bundle"
+        : "invalid_params";
+      return { kind: "rejected", reason, detail: validation.error };
+    }
+
+    const bundle = this.opts.registry.get(spec.bundle);
+    if (!bundle) {
+      return {
+        kind: "rejected",
+        reason: "unknown_bundle",
+        detail: `bundle not found: ${spec.bundle}`,
+      };
+    }
+
+    const ctx = this.opts.buildContext();
+    if (!ctx?.bot) {
+      return {
+        kind: "rejected",
+        reason: "no_bot_session",
+        detail: "bot 尚未连接或上下文不可用",
+      };
+    }
+
+    const missionId = randomUUID();
+    const startedAt = Date.now();
+    const params = validation.params as Record<string, unknown>;
+    const state: MissionState = {
+      missionId,
+      bundleId: bundle.id,
+      params,
+      startedAt,
+      status: "running",
+      progress: bundle.snapshot ? bundle.snapshot(params) : params,
+      objective: spec.objective,
+      directiveId: spec.directiveId,
+      completesDirectiveOnSuccess: spec.completesDirectiveOnSuccess ?? true,
+    };
+    const reporter = this.createReporter(missionId);
+    const built = safeBuild(
+      bundle,
+      state.params,
+      { ...ctx, bus: this.opts.bus, mission: reporter },
+      this.opts.log,
+    );
+    if (!built.ok) {
+      return {
+        kind: "rejected",
+        reason: "rejected_by_engine",
+        detail: built.error,
+      };
+    }
+
+    if (this.current)
+      this.finish(
+        this.current.missionId,
+        "cancelled",
+        "cancelled",
+        "任务被新任务替换",
+      );
+    for (const entry of built.entries) entry.behavior.bindMission(reporter);
+    this.current = state;
+    this.currentBundle = bundle;
+    this.opts.engine.setMissionBehaviors(
+      missionId,
+      built.entries.map((entry) => entry.behavior),
+    );
+    this.updateBus();
+    this.recordModeSwitch(bundle.mode ?? "MISSION", `mission:${bundle.id}`);
+    this.opts.log?.(
+      `[MC/play] 任务启动: ${bundle.id} (${missionId.slice(0, 8)})`,
+    );
+
+    return {
+      kind: "applied",
+      missionId,
+      bundleId: bundle.id,
+      effectiveAt: startedAt,
+      message: `已启动 ${bundle.id}`,
+    };
+  }
+
+  tick(): void {
+    const current = this.current;
+    const bundle = this.currentBundle;
+    if (!current || typeof bundle?.isFinished !== "function") return;
+    const ctx = this.opts.buildContext();
+    if (!ctx?.bot) return;
+    try {
+      if (
+        bundle.isFinished({
+          ...ctx,
+          bus: this.opts.bus,
+          mission: this.createReporter(current.missionId),
+          startedAt: current.startedAt,
+          internal: current.progress,
+        })
+      ) {
+        this.finish(current.missionId, "succeeded", undefined, "任务完成");
+      }
+    } catch (error) {
+      this.opts.log?.(
+        `[MC/play] mission.isFinished 抛错 (${bundle.id})，强制结束: ${error}`,
+      );
+      this.finish(
+        current.missionId,
+        "failed",
+        "unknown",
+        `isFinished threw: ${String(error)}`,
+      );
+    }
+  }
+
+  stopMission(reason = "manual_stop"): SwitchResult {
+    const current = this.current;
+    if (!current) {
+      return {
+        kind: "rejected",
+        reason: "rejected_by_engine",
+        detail: "没有进行中的任务",
+      };
+    }
+    this.finish(current.missionId, "cancelled", "cancelled", reason);
+    return {
+      kind: "applied",
+      missionId: current.missionId,
+      bundleId: current.bundleId,
+      effectiveAt: Date.now(),
+      message: `已停止 ${current.bundleId}`,
+    };
+  }
+
+  private createReporter(missionId: string): BehaviorMissionReporter {
+    return {
+      progress: (value) => {
+        if (this.current?.missionId !== missionId) return;
+        this.current.progress = value;
+        this.updateBus();
+      },
+      succeed: (detail, progress) =>
+        this.finish(missionId, "succeeded", undefined, detail, progress),
+      fail: (code, detail, progress) =>
+        this.finish(missionId, "failed", code, detail, progress),
+      block: (code, detail, progress) =>
+        this.finish(missionId, "blocked", code, detail, progress),
+      isCurrent: () => this.current?.missionId === missionId,
+    };
+  }
+
+  private finish(
+    missionId: string,
+    status: MissionOutcome["status"],
+    code?: MissionErrorCode,
+    detail?: string,
+    progress?: unknown,
+  ): void {
+    const current = this.current;
+    if (!current || current.missionId !== missionId) return;
+    this.opts.engine.removeMissionBehaviors(missionId);
+    const outcome: MissionOutcome = {
+      missionId,
+      bundleId: current.bundleId,
+      status,
+      code,
+      detail,
+      progress: progress ?? current.progress,
+      startedAt: current.startedAt,
+      endedAt: Date.now(),
+      directiveId: current.directiveId,
+      completesDirectiveOnSuccess: current.completesDirectiveOnSuccess,
+    };
+    this.current = null;
+    this.currentBundle = null;
+    this.lastOutcome = outcome;
+    this.updateBus();
+    this.recordModeSwitch("IDLE", `mission_${status}`);
+    this.opts.log?.(
+      `[MC/play] 任务结束: ${outcome.bundleId} status=${status}${code ? ` code=${code}` : ""}`,
+    );
+    this.opts.onOutcome?.(outcome);
+  }
+
+  private updateBus(): void {
+    this.opts.bus.set("mission", this.current, { ttlMs: 0 });
+  }
+
+  private recordModeSwitch(to: ModeState["current"], reason: string): void {
+    const from = this.modeState.current;
+    this.modeState = {
+      current: to,
+      mission: this.current,
+      lastSwitch: { from, to, reason, at: Date.now() },
+    };
+  }
+}
+
+function safeBuild(
+  bundle: BehaviorBundle,
+  params: unknown,
+  ctx: any,
+  log?: (msg: string) => void,
+):
+  | { ok: true; entries: ReturnType<BehaviorBundle["build"]> }
+  | { ok: false; error: string } {
+  try {
+    return { ok: true, entries: (bundle.build as any)(params, ctx) };
+  } catch (error) {
+    log?.(`[MC/play] bundle.build 失败 (${bundle.id}): ${error}`);
+    return { ok: false, error: String(error) };
+  }
+}

package/play/missions/registry.ts

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import type { Behavior, BehaviorMissionReporter } from "../behavior/base-behavior";
+import type { BehaviorMode } from "../state/mode";
+
+export interface BehaviorEntry {
+  priority: number;
+  behavior: Behavior;
+}
+
+export interface BundleBuildContext {
+  bot: any;
+  movements: any;
+  log: (msg: string) => void;
+  bus: any;
+  mission: BehaviorMissionReporter;
+}
+
+export interface MissionContext extends BundleBuildContext {
+  startedAt: number;
+  internal: unknown;
+}
+
+export interface BehaviorBundle<P = Record<string, unknown>> {
+  readonly id: string;
+  readonly description: string;
+  readonly paramsSchema: z.ZodType<P, any, any>;
+  readonly mode: BehaviorMode | null;
+  build(params: P, ctx: BundleBuildContext): BehaviorEntry[];
+  isFinished?(ctx: MissionContext): boolean;
+  snapshot?(internal: unknown): unknown;
+  serialize?(): unknown;
+  deserialize?(data: unknown): void;
+}
+
+export type BundleId = string;
+
+export type ValidateResult =
+  | { ok: true; params: unknown }
+  | { ok: false; error: string };
+
+export interface BundleListEntry {
+  id: string;
+  description: string;
+  mode: BehaviorMode | null;
+}
+
+export class TaskRegistry {
+  private bundles = new Map<BundleId, BehaviorBundle>();
+
+  register<P>(bundle: BehaviorBundle<P>): void {
+    this.bundles.set(bundle.id, bundle as unknown as BehaviorBundle);
+  }
+
+  get(id: string): BehaviorBundle | undefined {
+    return this.bundles.get(id);
+  }
+
+  list(): BundleListEntry[] {
+    return [...this.bundles.values()].map((b) => ({
+      id: b.id,
+      description: b.description,
+      mode: b.mode,
+    }));
+  }
+
+  describe(): Array<BundleListEntry & { params: unknown }> {
+    return [...this.bundles.values()]
+      .map((bundle) => ({
+        id: bundle.id,
+        description: bundle.description,
+        mode: bundle.mode,
+        params: describeSchema(bundle.paramsSchema),
+      }))
+      .sort((a, b) => a.id.localeCompare(b.id));
+  }
+
+  validate(id: string, params: unknown): ValidateResult {
+    const bundle = this.bundles.get(id);
+    if (!bundle) {
+      return {
+        ok: false,
+        error: `unknown_bundle: ${id} (available: ${this.list().map((b) => b.id).join(", ") || "none"})`,
+      };
+    }
+    const result = bundle.paramsSchema.safeParse(params ?? {});
+    if (!result.success) {
+      return {
+        ok: false,
+        error: `invalid_params: ${result.error.issues
+          .map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`)
+          .join("; ")}`,
+      };
+    }
+    return { ok: true, params: result.data };
+  }
+}
+
+function describeSchema(schema: z.ZodTypeAny): unknown {
+  const definition = (schema as any)?._def;
+  if (definition?.typeName !== z.ZodFirstPartyTypeKind.ZodObject) return {};
+  const shape = definition.shape();
+  const out: Record<string, string> = {};
+  for (const key of Object.keys(shape).sort()) {
+    out[key] = String(shape[key]?._def?.description ?? shape[key]?._def?.typeName ?? "unknown");
+  }
+  return out;
+}