抓大鹅F3实现

src/services/match3d-runtime/index.ts

@@ -0,0 +1,8 @@
+export {
+  buildLocalMatch3DOptimisticRun,
+  confirmLocalMatch3DClick,
+  MATCH3D_VISUAL_SEEDS,
+  resolveLocalMatch3DTimer,
+  startLocalMatch3DRun,
+  stopLocalMatch3DRun,
+} from './match3dLocalRuntime';

src/services/match3d-runtime/match3dLocalRuntime.ts

@@ -0,0 +1,409 @@
+import type {
+  Match3DClickItemRequest,
+  Match3DClickItemResult,
+  Match3DItemSnapshot,
+  Match3DRunSnapshot,
+  Match3DTraySlot,
+} from '../../../packages/shared/src/contracts/match3dRuntime';
+
+const MATCH3D_TRAY_SLOT_COUNT = 7;
+const MATCH3D_LOCAL_DURATION_MS = 600_000;
+
+type Match3DVisualSeed = {
+  itemTypeId: string;
+  visualKey: string;
+  colorClassName: string;
+  label: string;
+};
+
+export const MATCH3D_VISUAL_SEEDS: Match3DVisualSeed[] = [
+  {
+    itemTypeId: 'apple',
+    visualKey: 'apple-red',
+    colorClassName: 'from-rose-400 to-red-600',
+    label: '苹',
+  },
+  {
+    itemTypeId: 'banana',
+    visualKey: 'banana-yellow',
+    colorClassName: 'from-yellow-300 to-amber-500',
+    label: '蕉',
+  },
+  {
+    itemTypeId: 'grape',
+    visualKey: 'grape-purple',
+    colorClassName: 'from-violet-400 to-purple-700',
+    label: '萄',
+  },
+  {
+    itemTypeId: 'melon',
+    visualKey: 'melon-green',
+    colorClassName: 'from-emerald-300 to-green-600',
+    label: '瓜',
+  },
+  {
+    itemTypeId: 'berry',
+    visualKey: 'berry-blue',
+    colorClassName: 'from-sky-300 to-blue-600',
+    label: '莓',
+  },
+  {
+    itemTypeId: 'peach',
+    visualKey: 'peach-pink',
+    colorClassName: 'from-pink-300 to-orange-400',
+    label: '桃',
+  },
+  {
+    itemTypeId: 'plum',
+    visualKey: 'plum-indigo',
+    colorClassName: 'from-indigo-300 to-indigo-700',
+    label: '李',
+  },
+  {
+    itemTypeId: 'lime',
+    visualKey: 'lime-lime',
+    colorClassName: 'from-lime-300 to-lime-600',
+    label: '柠',
+  },
+  {
+    itemTypeId: 'orange',
+    visualKey: 'orange-orange',
+    colorClassName: 'from-orange-300 to-orange-600',
+    label: '橙',
+  },
+  {
+    itemTypeId: 'candy',
+    visualKey: 'candy-cyan',
+    colorClassName: 'from-cyan-300 to-teal-600',
+    label: '糖',
+  },
+];
+
+function createEmptyTray(): Match3DTraySlot[] {
+  return Array.from({ length: MATCH3D_TRAY_SLOT_COUNT }, (_, slotIndex) => ({
+    slotIndex,
+  }));
+}
+
+function normalizeRemainingMs(run: Match3DRunSnapshot, nowMs = Date.now()) {
+  if (run.status !== 'Running') {
+    return run;
+  }
+  const elapsedMs = Math.max(0, nowMs - run.startedAtMs);
+  const remainingMs = Math.max(0, run.durationLimitMs - elapsedMs);
+  if (remainingMs > 0) {
+    return {
+      ...run,
+      serverNowMs: nowMs,
+      remainingMs,
+    };
+  }
+  return {
+    ...run,
+    status: 'Failed' as const,
+    serverNowMs: nowMs,
+    remainingMs: 0,
+    failureReason: 'TimeUp' as const,
+    snapshotVersion: run.snapshotVersion + 1,
+  };
+}
+
+function buildItem(
+  seed: Match3DVisualSeed,
+  index: number,
+  copyIndex: number,
+): Match3DItemSnapshot {
+  const ring = Math.floor(index / 6);
+  const angle = index * 0.86 + copyIndex * 0.22;
+  const spread = 0.16 + (ring % 4) * 0.085;
+  const x = 0.5 + Math.cos(angle) * spread + ((index % 3) - 1) * 0.026;
+  const y = 0.5 + Math.sin(angle * 1.13) * spread + ((copyIndex % 3) - 1) * 0.02;
+  const radius = 0.072 - Math.min(0.018, ring * 0.004) + (copyIndex % 2) * 0.004;
+  return {
+    itemInstanceId: `${seed.itemTypeId}-${copyIndex + 1}`,
+    itemTypeId: seed.itemTypeId,
+    visualKey: seed.visualKey,
+    x: Math.max(0.18, Math.min(0.82, x)),
+    y: Math.max(0.18, Math.min(0.82, y)),
+    radius,
+    layer: index + 1,
+    state: 'InBoard',
+    clickable: true,
+  };
+}
+
+function recomputeClickable(items: Match3DItemSnapshot[]) {
+  const boardItems = items.filter((item) => item.state === 'InBoard');
+  return items.map((item) => {
+    if (item.state !== 'InBoard') {
+      return {
+        ...item,
+        clickable: false,
+      };
+    }
+    const coveredByHigherLayer = boardItems.some((other) => {
+      if (other.itemInstanceId === item.itemInstanceId || other.layer <= item.layer) {
+        return false;
+      }
+      const distance = Math.hypot(other.x - item.x, other.y - item.y);
+      return distance < Math.min(item.radius, other.radius) * 0.78;
+    });
+    return {
+      ...item,
+      clickable: !coveredByHigherLayer,
+    };
+  });
+}
+
+function findNextTrayIndex(traySlots: Match3DTraySlot[]) {
+  return traySlots.find((slot) => !slot.itemInstanceId)?.slotIndex ?? -1;
+}
+
+function countClearedItems(items: Match3DItemSnapshot[]) {
+  return items.filter((item) => item.state === 'Cleared').length;
+}
+
+function resolveRunStatus(run: Match3DRunSnapshot): Match3DRunSnapshot {
+  const clearedItemCount = countClearedItems(run.items);
+  if (clearedItemCount >= run.totalItemCount) {
+    return {
+      ...run,
+      status: 'Won',
+      clearedItemCount,
+      remainingMs: Math.max(0, run.remainingMs),
+    };
+  }
+  const trayIsFull = run.traySlots.every((slot) => Boolean(slot.itemInstanceId));
+  if (trayIsFull) {
+    return {
+      ...run,
+      status: 'Failed',
+      clearedItemCount,
+      failureReason: 'TrayFull',
+    };
+  }
+  return {
+    ...run,
+    status: 'Running',
+    failureReason: undefined,
+    clearedItemCount,
+  };
+}
+
+function settleMatchedTrayItems(run: Match3DRunSnapshot) {
+  const slotsByType = new Map<string, Match3DTraySlot[]>();
+  for (const slot of run.traySlots) {
+    if (!slot.itemTypeId || !slot.itemInstanceId) {
+      continue;
+    }
+    slotsByType.set(slot.itemTypeId, [
+      ...(slotsByType.get(slot.itemTypeId) ?? []),
+      slot,
+    ]);
+  }
+
+  const matchedSlots = [...slotsByType.values()].find((slots) => slots.length >= 3);
+  if (!matchedSlots) {
+    return {
+      run,
+      clearedItemInstanceIds: [] as string[],
+    };
+  }
+
+  const clearedItemInstanceIds = matchedSlots
+    .slice(0, 3)
+    .map((slot) => slot.itemInstanceId)
+    .filter((itemInstanceId): itemInstanceId is string => Boolean(itemInstanceId));
+  const clearedSet = new Set(clearedItemInstanceIds);
+  const nextRun = {
+    ...run,
+    traySlots: run.traySlots.map((slot) =>
+      slot.itemInstanceId && clearedSet.has(slot.itemInstanceId)
+        ? { slotIndex: slot.slotIndex }
+        : slot,
+    ),
+    items: run.items.map((item) =>
+      clearedSet.has(item.itemInstanceId)
+        ? {
+            ...item,
+            state: 'Cleared' as const,
+            clickable: false,
+          }
+        : item,
+    ),
+  };
+
+  return {
+    run: nextRun,
+    clearedItemInstanceIds,
+  };
+}
+
+export function startLocalMatch3DRun(clearCount = 12): Match3DRunSnapshot {
+  const normalizedClearCount = Math.max(1, Math.round(clearCount));
+  const typeCount = Math.min(MATCH3D_VISUAL_SEEDS.length, normalizedClearCount);
+  const items = Array.from({ length: normalizedClearCount }, (_, clearIndex) =>
+    Array.from({ length: 3 }, (_, copyOffset) => {
+      const seed = MATCH3D_VISUAL_SEEDS[clearIndex % typeCount] ?? MATCH3D_VISUAL_SEEDS[0]!;
+      return buildItem(seed, clearIndex * 3 + copyOffset, clearIndex * 3 + copyOffset);
+    }),
+  ).flat();
+  const nowMs = Date.now();
+  return {
+    runId: `local-match3d-run-${nowMs}`,
+    profileId: 'local-match3d-profile',
+    status: 'Running',
+    snapshotVersion: 1,
+    startedAtMs: nowMs,
+    durationLimitMs: MATCH3D_LOCAL_DURATION_MS,
+    serverNowMs: nowMs,
+    remainingMs: MATCH3D_LOCAL_DURATION_MS,
+    clearCount: normalizedClearCount,
+    totalItemCount: items.length,
+    clearedItemCount: 0,
+    traySlots: createEmptyTray(),
+    items: recomputeClickable(items),
+  };
+}
+
+export function resolveLocalMatch3DTimer(run: Match3DRunSnapshot) {
+  return normalizeRemainingMs(run);
+}
+
+export function buildLocalMatch3DOptimisticRun(
+  run: Match3DRunSnapshot,
+  itemInstanceId: string,
+): Match3DRunSnapshot {
+  const targetItem = run.items.find((item) => item.itemInstanceId === itemInstanceId);
+  const nextTrayIndex = findNextTrayIndex(run.traySlots);
+  if (!targetItem || targetItem.state !== 'InBoard' || nextTrayIndex < 0) {
+    return run;
+  }
+  return {
+    ...run,
+    items: run.items.map((item) =>
+      item.itemInstanceId === itemInstanceId
+        ? {
+            ...item,
+            state: 'Flying' as const,
+            clickable: false,
+          }
+        : item,
+    ),
+    traySlots: run.traySlots.map((slot) =>
+      slot.slotIndex === nextTrayIndex
+        ? {
+            slotIndex: slot.slotIndex,
+            itemInstanceId: targetItem.itemInstanceId,
+            itemTypeId: targetItem.itemTypeId,
+            visualKey: targetItem.visualKey,
+          }
+        : slot,
+    ),
+  };
+}
+
+export async function confirmLocalMatch3DClick(
+  run: Match3DRunSnapshot,
+  request: Match3DClickItemRequest,
+): Promise<Match3DClickItemResult> {
+  // 中文注释：F3 阶段用本地函数模拟后端权威确认，真实接口接入后保留同一结果语义。
+  await new Promise((resolve) => window.setTimeout(resolve, 180));
+  const timedRun = normalizeRemainingMs(run);
+  if (timedRun.status !== 'Running') {
+    return {
+      status: 'RunFinished',
+      run: timedRun,
+      clearedItemInstanceIds: [],
+      failureReason: timedRun.failureReason,
+    };
+  }
+  if (request.clientSnapshotVersion !== run.snapshotVersion) {
+    return {
+      status: 'VersionConflict',
+      run: timedRun,
+      clearedItemInstanceIds: [],
+    };
+  }
+
+  const targetItem = run.items.find(
+    (item) => item.itemInstanceId === request.itemInstanceId,
+  );
+  if (!targetItem || targetItem.state !== 'InBoard') {
+    return {
+      status: 'RejectedAlreadyMoved',
+      run: timedRun,
+      clearedItemInstanceIds: [],
+    };
+  }
+  if (!targetItem.clickable) {
+    return {
+      status: 'RejectedNotClickable',
+      run: timedRun,
+      clearedItemInstanceIds: [],
+    };
+  }
+  const nextTrayIndex = findNextTrayIndex(run.traySlots);
+  if (nextTrayIndex < 0) {
+    const failedRun = {
+      ...timedRun,
+      status: 'Failed' as const,
+      failureReason: 'TrayFull' as const,
+      snapshotVersion: run.snapshotVersion + 1,
+    };
+    return {
+      status: 'RejectedTrayFull',
+      run: failedRun,
+      clearedItemInstanceIds: [],
+      failureReason: 'TrayFull',
+    };
+  }
+
+  const movedRun: Match3DRunSnapshot = {
+    ...timedRun,
+    snapshotVersion: run.snapshotVersion + 1,
+    items: timedRun.items.map((item) =>
+      item.itemInstanceId === targetItem.itemInstanceId
+        ? {
+            ...item,
+            state: 'InTray' as const,
+            clickable: false,
+          }
+        : item,
+    ),
+    traySlots: timedRun.traySlots.map((slot) =>
+      slot.slotIndex === nextTrayIndex
+        ? {
+            slotIndex: slot.slotIndex,
+            itemInstanceId: targetItem.itemInstanceId,
+            itemTypeId: targetItem.itemTypeId,
+            visualKey: targetItem.visualKey,
+          }
+        : slot,
+    ),
+  };
+  const settled = settleMatchedTrayItems(movedRun);
+  const nextRun = resolveRunStatus({
+    ...settled.run,
+    items: recomputeClickable(settled.run.items),
+  });
+
+  return {
+    status: 'Accepted',
+    run: nextRun,
+    acceptedItemInstanceId: targetItem.itemInstanceId,
+    clearedItemInstanceIds: settled.clearedItemInstanceIds,
+    failureReason: nextRun.failureReason,
+  };
+}
+
+export function stopLocalMatch3DRun(run: Match3DRunSnapshot): Match3DRunSnapshot {
+  if (run.status !== 'Running') {
+    return run;
+  }
+  return {
+    ...run,
+    status: 'Stopped',
+    snapshotVersion: run.snapshotVersion + 1,
+  };
+}