410 lines
11 KiB
TypeScript
410 lines
11 KiB
TypeScript
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,
|
||
};
|
||
}
|