mioku-plugin-mc 2.1.0 → 3.0.1

package/play/types.ts

@@ -0,0 +1,284 @@
+export interface PlayServerConfig {
+  id: string;
+  name: string;
+  host: string;
+  version?: string;
+  username: string;
+  auth?: "offline" | "microsoft";
+  password?: string;
+  maxPlayMs: number;
+  joinCommands: string[];
+  allowedCommands: string[];
+}
+
+export interface GroupBinding {
+  groupId: number;
+  botSelfId: number;
+  allowedServerIds: string[];
+}
+
+export type PlayToolPermission = "owner" | "admin" | "member";
+
+export interface WorkStatus {
+  running: boolean;
+  goal: string | null;
+  summary: string;
+  progress?: { current: number; target: number; unit: string };
+  updatedAt: number;
+}
+
+export interface PlayConfig {
+  servers: PlayServerConfig[];
+  groups: GroupBinding[];
+  mainChatDebounceMs: number;
+  mainConversationFocusMs: number;
+  chatScanIntervalMs: number;
+  workSubroutineMaxMs: number;
+  workSubroutineMaxIterations: number;
+  toolPermission: PlayToolPermission;
+  behaviorTickIntervalMs: number;
+  goodbyeTimeoutMs: number;
+  qqSendPerMinute: number;
+  gameChatMinIntervalMs: number;
+  debug: { enabled: boolean };
+}
+
+export const DEFAULT_PLAY_CONFIG: PlayConfig = {
+  servers: [],
+  groups: [],
+  mainChatDebounceMs: 1_000,
+  mainConversationFocusMs: 30_000,
+  chatScanIntervalMs: 4 * 60_000,
+  workSubroutineMaxMs: 5 * 60_000,
+  workSubroutineMaxIterations: 25,
+  toolPermission: "admin",
+  behaviorTickIntervalMs: 200,
+  goodbyeTimeoutMs: 8_000,
+  qqSendPerMinute: 3,
+  gameChatMinIntervalMs: 1_500,
+  debug: { enabled: false },
+};
+
+export interface MovementInit {
+  name: string;
+  params?: Record<string, string>;
+}
+
+export type MainLoopTrigger =
+  | "direct_game_chat"
+  | "direct_qq_chat"
+  | "chat_scan_due"
+  | "work_completed";
+
+export interface PlaySessionStatus {
+  serverId: string;
+  serverName: string;
+  groupId: number;
+  botSelfId: number;
+  startedAt: number;
+  connected: boolean;
+  currentBehavior: string | null;
+  lastAction: string | null;
+  workStatus?: WorkStatus | null;
+}
+
+export type PlayEventType =
+  | "game_chat"
+  | "qq_chat"
+  | "damage"
+  | "vitals_threshold"
+  | "day_phase"
+  | "death"
+  | "respawn"
+  | "inventory_change"
+  | "equipment_change"
+  | "mission_outcome"
+  | "action_outcome"
+  | "path_error"
+  | "chat_scan_due"
+  | "work_completed";
+
+export interface PlayEvent<T = unknown> {
+  seq: number;
+  at: number;
+  type: PlayEventType;
+  data: T;
+}
+
+export interface EventBatch {
+  events: PlayEvent[];
+  cursor: number;
+}
+
+export class PlayEventJournal {
+  private seq = 0;
+  private events: PlayEvent[] = [];
+  private listeners = new Set<(event: PlayEvent) => void>();
+
+  constructor(private readonly maxEntries = 300) {}
+
+  append<T>(type: PlayEventType, data: T): PlayEvent<T> {
+    const event: PlayEvent<T> = {
+      seq: ++this.seq,
+      at: Date.now(),
+      type,
+      data,
+    };
+    this.events.push(event);
+    if (this.events.length > this.maxEntries) {
+      this.events.splice(0, this.events.length - this.maxEntries);
+    }
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+        // Journal consumers must not affect the game loop.
+      }
+    }
+    return event;
+  }
+
+  readAfter(
+    cursor: number,
+    filter?: (event: PlayEvent) => boolean,
+    limit?: number,
+  ): EventBatch {
+    const matched = this.events.filter(
+      (event) => event.seq > cursor && (!filter || filter(event)),
+    );
+    return {
+      events: limit && matched.length > limit ? matched.slice(-limit) : matched,
+      cursor: matched.at(-1)?.seq ?? cursor,
+    };
+  }
+
+  subscribe(listener: (event: PlayEvent) => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  latestCursor(): number {
+    return this.seq;
+  }
+
+  clear(): void {
+    this.events = [];
+    this.listeners.clear();
+  }
+}
+
+function asStringList(value: unknown): string[] {
+  if (Array.isArray(value)) {
+    return value
+      .map((v) => String(v ?? "").trim())
+      .filter((v) => v.length > 0);
+  }
+  if (typeof value === "string") {
+    return value
+      .split(/[\n,]+/)
+      .map((v) => v.trim())
+      .filter((v) => v.length > 0);
+  }
+  return [];
+}
+
+function asNumber(value: unknown, fallback: number): number {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+function asPositiveNumber(value: unknown, fallback: number): number {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+function normalizeServer(raw: any): PlayServerConfig {
+  const auth = raw?.auth === "microsoft" ? "microsoft" : "offline";
+  return {
+    id: String(raw?.id ?? "").trim(),
+    name: String(raw?.name ?? raw?.id ?? "").trim(),
+    host: String(raw?.host ?? "").trim(),
+    version: raw?.version ? String(raw.version).trim() : undefined,
+    username: String(raw?.username ?? "").trim(),
+    auth,
+    password: raw?.password ? String(raw.password) : undefined,
+    maxPlayMs: asPositiveNumber(raw?.maxPlayMs, 30 * 60_000),
+    joinCommands: asStringList(raw?.joinCommands),
+    allowedCommands: asStringList(raw?.allowedCommands).map((command) =>
+      command.startsWith("/") ? command : `/${command}`,
+    ),
+  };
+}
+
+function normalizeBinding(raw: any): GroupBinding {
+  return {
+    groupId: asNumber(raw?.groupId ?? raw?.group_id, 0),
+    botSelfId: asNumber(raw?.botSelfId ?? raw?.bot_self_id, 0),
+    allowedServerIds: asStringList(raw?.allowedServerIds ?? raw?.allowed_server_ids),
+  };
+}
+
+export function normalizePlayConfig(raw: any): PlayConfig {
+  const servers = Array.isArray(raw?.servers)
+    ? raw.servers.map(normalizeServer).filter((s: PlayServerConfig) => s.id && s.host)
+    : [];
+  const groups = Array.isArray(raw?.groups)
+    ? raw?.groups
+        .map(normalizeBinding)
+        .filter((g: GroupBinding) => g.groupId > 0 && g.botSelfId > 0)
+    : [];
+  const perm: PlayToolPermission =
+    raw?.toolPermission === "owner" ||
+    raw?.toolPermission === "admin" ||
+    raw?.toolPermission === "member"
+      ? raw.toolPermission
+      : DEFAULT_PLAY_CONFIG.toolPermission;
+
+  return {
+    servers,
+    groups,
+    mainChatDebounceMs: asPositiveNumber(
+      raw?.mainChatDebounceMs,
+      DEFAULT_PLAY_CONFIG.mainChatDebounceMs,
+    ),
+    mainConversationFocusMs: asPositiveNumber(
+      raw?.mainConversationFocusMs,
+      DEFAULT_PLAY_CONFIG.mainConversationFocusMs,
+    ),
+    chatScanIntervalMs: asPositiveNumber(
+      raw?.chatScanIntervalMs,
+      DEFAULT_PLAY_CONFIG.chatScanIntervalMs,
+    ),
+    workSubroutineMaxMs: asPositiveNumber(
+      raw?.workSubroutineMaxMs,
+      DEFAULT_PLAY_CONFIG.workSubroutineMaxMs,
+    ),
+    workSubroutineMaxIterations: asPositiveNumber(
+      raw?.workSubroutineMaxIterations,
+      DEFAULT_PLAY_CONFIG.workSubroutineMaxIterations,
+    ),
+    toolPermission: perm,
+    behaviorTickIntervalMs: asPositiveNumber(
+      raw?.behaviorTickIntervalMs,
+      DEFAULT_PLAY_CONFIG.behaviorTickIntervalMs,
+    ),
+    goodbyeTimeoutMs: asPositiveNumber(
+      raw?.goodbyeTimeoutMs,
+      DEFAULT_PLAY_CONFIG.goodbyeTimeoutMs,
+    ),
+    qqSendPerMinute: asPositiveNumber(
+      raw?.qqSendPerMinute,
+      DEFAULT_PLAY_CONFIG.qqSendPerMinute,
+    ),
+    gameChatMinIntervalMs: asPositiveNumber(
+      raw?.gameChatMinIntervalMs,
+      DEFAULT_PLAY_CONFIG.gameChatMinIntervalMs,
+    ),
+    debug: {
+      enabled:
+        raw?.debug && typeof raw.debug === "object"
+          ? Boolean(raw.debug.enabled)
+          : DEFAULT_PLAY_CONFIG.debug.enabled,
+    },
+  };
+}

package/play/util/async.ts

@@ -0,0 +1,11 @@
+export async function withTimeoutMs<T>(promise: Promise<T>, ms: number): Promise<T> {
+  let timer: NodeJS.Timeout | undefined;
+  const timeout = new Promise<never>((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`timeout after ${ms}ms`)), ms);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}

package/play/util/endpoint.ts

@@ -0,0 +1,38 @@
+import { promises as dns } from "dns";
+
+const DEFAULT_PORT = 25565;
+
+function parseHostPort(input: string): { host: string; port?: number } {
+  const host = input.trim();
+  const lastColon = host.lastIndexOf(":");
+  if (lastColon > 0 && lastColon < host.length - 1) {
+    const suffix = host.slice(lastColon + 1);
+    const n = Number(suffix);
+    if (Number.isInteger(n) && n > 0 && n <= 65535) {
+      return { host: host.slice(0, lastColon), port: n };
+    }
+  }
+  return { host };
+}
+
+export async function resolveMinecraftEndpoint(
+  input: string,
+  defaultPort: number = DEFAULT_PORT,
+): Promise<{ host: string; port: number }> {
+  const { host: rawHost, port: explicitPort } = parseHostPort(input);
+  if (explicitPort !== undefined) {
+    return { host: rawHost, port: explicitPort };
+  }
+  const srvName = rawHost.startsWith("_minecraft._tcp.")
+    ? rawHost
+    : `_minecraft._tcp.${rawHost}`;
+  try {
+    const records = await dns.resolveSrv(srvName);
+    if (records && records.length > 0) {
+      return { host: records[0].name, port: records[0].port };
+    }
+  } catch {
+    // no SRV record; fall back to direct connection
+  }
+  return { host: rawHost, port: defaultPort };
+}

package/play/util/entities.ts

@@ -0,0 +1,135 @@
+const HOSTILE_MOBS = new Set([
+  "zombie", "husk", "drowned", "skeleton", "stray", "creeper", "spider", "cave_spider",
+  "enderman", "witch", "blaze", "ghast", "magma_cube", "slime", "phantom", "pillager",
+  "vindicator", "evoker", "ravager", "hoglin", "zoglin", "warden", "wither",
+  "ender_dragon", "shulker", "silverfish", "guardian", "elder_guardian", "piglin_brute",
+  "piglin", "zombified_piglin",
+]);
+
+export function entityName(entity: any): string {
+  if (!entity) return "unknown";
+  const raw = entity.name || entity.entityType || entity.kind || "unknown";
+  return String(raw).toLowerCase().replace(/^minecraft:/, "");
+}
+
+export function isHostileEntity(entity: any): boolean {
+  return HOSTILE_MOBS.has(entityName(entity));
+}
+
+export function isPassiveMob(entity: any): boolean {
+  const name = entityName(entity);
+  const passive = [
+    "cow", "pig", "sheep", "chicken", "rabbit", "horse", "donkey", "mule",
+    "villager", "iron_golem", "snow_golem", "cat", "ocelot", "wolf", "parrot",
+    "fox", "bee", "turtle", "panda", "llama", "trader_llama", "wandering_trader",
+    "mooshroom", "goat", "axolotl", "allay", "frog", "tadpole", "sniffer",
+  ];
+  return passive.includes(name);
+}
+
+export function entityDistance(a: any, b: any): number {
+  if (!a?.position || !b?.position) return Infinity;
+  return Math.hypot(
+    a.position.x - b.position.x,
+    a.position.y - b.position.y,
+    a.position.z - b.position.z,
+  );
+}
+
+export function listNearbyHostiles(bot: any, radius = 16): string[] {
+  const out: string[] = [];
+  const pos = bot?.entity?.position;
+  if (!pos) return out;
+  for (const id in bot.entities) {
+    const e = bot.entities[id];
+    if (e === bot.entity) continue;
+    if (!isHostileEntity(e)) continue;
+    const d = entityDistance({ position: pos }, e);
+    if (d <= radius) out.push(`${entityName(e)}@${d.toFixed(0)}`);
+  }
+  return out.slice(0, 8);
+}
+
+export function listNearbyPlayers(bot: any, radius = 16): string[] {
+  const out: string[] = [];
+  const pos = bot?.entity?.position;
+  if (!pos) return out;
+  for (const name in bot.players) {
+    const p = bot.players[name];
+    if (!p || name === bot.username) continue;
+    const d = entityDistance({ position: pos }, p.entity);
+    if (d <= radius) out.push(`${name}@${d.toFixed(0)}`);
+  }
+  return out.slice(0, 8);
+}
+
+export function nearestHostile(bot: any, radius = 16): any | null {
+  let best: any = null;
+  let bestDist = Infinity;
+  const pos = bot?.entity?.position;
+  if (!pos) return null;
+  for (const id in bot.entities) {
+    const e = bot.entities[id];
+    if (e === bot.entity || !isHostileEntity(e)) continue;
+    const d = entityDistance({ position: pos }, e);
+    if (d <= radius && d < bestDist) {
+      best = e;
+      bestDist = d;
+    }
+  }
+  return best;
+}
+
+export function nearestPassiveMob(bot: any, radius = 20): any | null {
+  let best: any = null;
+  let bestDist = Infinity;
+  const pos = bot?.entity?.position;
+  if (!pos) return null;
+  for (const id in bot.entities) {
+    const e = bot.entities[id];
+    if (e === bot.entity || !isPassiveMob(e)) continue;
+    if (e.name === "player") continue;
+    const d = entityDistance({ position: pos }, e);
+    if (d <= radius && d < bestDist) {
+      best = e;
+      bestDist = d;
+    }
+  }
+  return best;
+}
+
+export function nearestCreeper(bot: any, radius = 6): any | null {
+  let best: any = null;
+  let bestDist = Infinity;
+  const pos = bot?.entity?.position;
+  if (!pos) return null;
+  for (const id in bot.entities) {
+    const e = bot.entities[id];
+    if (entityName(e) !== "creeper") continue;
+    const d = entityDistance({ position: pos }, e);
+    if (d <= radius && d < bestDist) {
+      best = e;
+      bestDist = d;
+    }
+  }
+  return best;
+}
+
+export function nearestPlayer(bot: any, radius = 16): any | null {
+  let best: any = null;
+  let bestDist = Infinity;
+  const pos = bot?.entity?.position;
+  if (!pos) return null;
+  const players: any = bot.players ?? {};
+  for (const name in players) {
+    if (name === bot.username) continue;
+    const entity = players[name]?.entity;
+    if (!entity?.position) continue;
+    const d = entityDistance({ position: pos }, entity);
+    if (d <= radius && d < bestDist) {
+      best = entity;
+      bestDist = d;
+    }
+  }
+  return best;
+}

package/play/util/inventory.ts

@@ -0,0 +1,75 @@
+import type { Bot } from "mineflayer";
+
+const FOOD_NAMES = new Set([
+  "bread", "apple", "golden_apple", "enchanted_golden_apple", "cooked_beef", "beef",
+  "cooked_porkchop", "porkchop", "cooked_chicken", "chicken", "cooked_mutton", "mutton",
+  "cooked_cod", "cod", "cooked_salmon", "salmon", "cooked_rabbit", "rabbit",
+  "baked_potato", "potato", "carrot", "beetroot", "beetroot_soup", "mushroom_stew",
+  "cookie", "melon_slice", "sweet_berries", "glow_berries", "dried_kelp",
+  "pumpkin_pie", "honey_bottle", "chorus_fruit",
+]);
+
+export function isFood(name: string): boolean {
+  return FOOD_NAMES.has(name);
+}
+
+export function findFood(bot: Bot): any | null {
+  const items = bot.inventory?.items?.() ?? [];
+  return items.find((i: any) => isFood(i.name)) ?? null;
+}
+
+export async function equipSword(bot: Bot): Promise<void> {
+  const items = bot.inventory?.items?.() ?? [];
+  const sword = items.find((i: any) => /sword$/.test(i.name));
+  if (sword) {
+    try {
+      await bot.equip(sword as any, "hand");
+    } catch {
+      // ignore
+    }
+  }
+}
+
+export async function equipToolFor(bot: Bot, resource: string): Promise<boolean> {
+  const items = bot.inventory?.items?.() ?? [];
+  let tool: any;
+  if (resource === "wood") {
+    tool = items.find((i: any) => /_axe$/.test(i.name) && !/pickaxe/.test(i.name));
+  } else {
+    tool = items.find((i: any) => /_pickaxe$/.test(i.name));
+  }
+  if (tool) {
+    try {
+      await bot.equip(tool, "hand");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+export async function eatFood(bot: Bot): Promise<boolean> {
+  const food = findFood(bot);
+  if (!food) return false;
+  try {
+    await bot.equip(food, "hand");
+    await bot.consume();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function hasShield(bot: Bot): boolean {
+  try {
+    const anyBot = bot as any;
+    if (anyBot.supportFeature?.("doesntHaveOffHandSlot")) return false;
+    const dest = anyBot.getEquipmentDestSlot?.("off-hand");
+    if (dest == null) return false;
+    const slot = bot.inventory?.slots?.[dest];
+    return !!slot && /shield/.test(String(slot.name));
+  } catch {
+    return false;
+  }
+}

package/skills/mc.ts

@@ -0,0 +1,58 @@
+import type { AISkill } from "mioku";
+import type { PlayManager } from "../play";
+
+export function createMcSkill(playManager: PlayManager): AISkill {
+  return {
+    name: "mc",
+    description:
+      "让机器人进入或离开 Minecraft 服务器，让它可以与玩家一起游玩。进入后机器人将自主行动（探索、跟随、战斗、收集），直到决定离开或时间耗尽。",
+    permission: "admin",
+    tools: [
+      {
+        name: "control_bot",
+        description:
+          "进入或退出 Minecraft 服务器。action='enter' + serverId 加入服务器；action='exit' 退出。机器人进入后会自主决定行为。仅在群管理员要求或继续游戏有意义时调用。",
+        parameters: {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              enum: ["enter", "exit"],
+              description: "'enter' 加入服务器，'exit' 退出当前服务器",
+            },
+            serverId: {
+              type: "string",
+              description: "要进入的服务器 ID。enter 时需要，exit 时忽略。",
+            },
+          },
+          required: ["action"],
+        },
+        handler: async (args: any, runtimeCtx?: any) => {
+          const event = runtimeCtx?.event || runtimeCtx?.rawEvent;
+          const groupId = Number(event?.group_id);
+          if (!Number.isFinite(groupId) || groupId <= 0) {
+            return { error: "无法识别当前群，请在群聊中调用" };
+          }
+
+          const action = String(args?.action ?? "").toLowerCase();
+          if (action === "exit") {
+            const r = await playManager.exit(groupId);
+            return { success: r.success, message: r.message };
+          }
+
+          if (action !== "enter") {
+            return { error: `未知 action: ${action}` };
+          }
+
+          const serverId = String(args?.serverId ?? "").trim();
+          if (!serverId) return { error: "缺少 serverId" };
+
+          const r = await playManager.enter(groupId, serverId);
+          return r.success
+            ? { success: true, serverId: r.serverId, message: r.message }
+            : { error: r.message };
+        },
+      },
+    ],
+  };
+}