813 lines
26 KiB
JavaScript
813 lines
26 KiB
JavaScript
const {
|
||
DEFAULT_SETTINGS,
|
||
BOT_NAMES,
|
||
AREA_CLUES
|
||
} = require("../utils/constants");
|
||
const { randomCode, clone } = require("../utils/format");
|
||
|
||
const ROOMS_KEY = "zmc_rooms";
|
||
const CURRENT_ROOM_KEY = "zmc_current_room";
|
||
const USER_ID = "player-me";
|
||
const ROOM_SCHEMA_VERSION = 2;
|
||
const ROOM_STATUSES = ["waiting", "preparing", "playing", "paused", "finished", "cancelled"];
|
||
const PLAYER_ROLES = ["", "seeker", "hider"];
|
||
const PLAYER_STATUSES = ["idle", "ready", "hiding", "seeking", "caught", "spectating", "offline", "quit"];
|
||
const DEFAULT_RUNTIME = {
|
||
demoAccelerated: true,
|
||
prepareSecondsPerMinute: 1,
|
||
maxGameSeconds: 180,
|
||
demoClueIntervalSeconds: 15
|
||
};
|
||
|
||
function isRecord(value) {
|
||
return Boolean(value) && typeof value === "object" && !Array.isArray(value);
|
||
}
|
||
|
||
function asNumber(value, fallback) {
|
||
const number = Number(value);
|
||
return Number.isFinite(number) ? number : fallback;
|
||
}
|
||
|
||
function assertIntegerInRange(value, min, max, message) {
|
||
if (!Number.isInteger(value) || value < min || value > max) {
|
||
throw new Error(message);
|
||
}
|
||
}
|
||
|
||
function validateRoomPayload(payload) {
|
||
const source = isRecord(payload) ? payload : {};
|
||
const name = String(source.name || "").trim();
|
||
if (!name) throw new Error("请填写房间名称");
|
||
|
||
const settings = normalizeSettings(source);
|
||
assertIntegerInRange(settings.durationMinutes, 15, 90, "游戏时长应为 15～90 分钟");
|
||
assertIntegerInRange(settings.prepareMinutes, 1, 10, "准备时长应为 1～10 分钟");
|
||
assertIntegerInRange(settings.maxPlayers, 4, 30, "房间人数应为 4～30 人");
|
||
assertIntegerInRange(settings.seekerCount, 1, 29, "初始寻找者人数应为 1～29 人");
|
||
assertIntegerInRange(settings.clueIntervalMinutes, 3, 10, "线索间隔应为 3～10 分钟");
|
||
assertIntegerInRange(settings.radiusMeters, 200, 1500, "活动半径应为 200～1500 米");
|
||
if (settings.seekerCount >= settings.maxPlayers) {
|
||
throw new Error("初始寻找者必须少于房间人数上限");
|
||
}
|
||
|
||
return {
|
||
...settings,
|
||
name: name.slice(0, 16)
|
||
};
|
||
}
|
||
|
||
function normalizeSettings(settings) {
|
||
const source = isRecord(settings) ? settings : {};
|
||
const merged = { ...DEFAULT_SETTINGS, ...source };
|
||
return {
|
||
mode: merged.mode === "classic" ? "classic" : "infection",
|
||
durationMinutes: asNumber(merged.durationMinutes, DEFAULT_SETTINGS.durationMinutes),
|
||
prepareMinutes: asNumber(merged.prepareMinutes, DEFAULT_SETTINGS.prepareMinutes),
|
||
maxPlayers: asNumber(merged.maxPlayers, DEFAULT_SETTINGS.maxPlayers),
|
||
seekerCount: asNumber(merged.seekerCount, DEFAULT_SETTINGS.seekerCount),
|
||
clueIntervalMinutes: asNumber(merged.clueIntervalMinutes, DEFAULT_SETTINGS.clueIntervalMinutes),
|
||
radiusMeters: asNumber(merged.radiusMeters, DEFAULT_SETTINGS.radiusMeters),
|
||
skillsEnabled: merged.skillsEnabled !== false
|
||
};
|
||
}
|
||
|
||
function normalizeRuntime(runtime) {
|
||
const source = isRecord(runtime) ? runtime : {};
|
||
return {
|
||
demoAccelerated: source.demoAccelerated !== false,
|
||
prepareSecondsPerMinute: Math.max(1, asNumber(
|
||
source.prepareSecondsPerMinute,
|
||
DEFAULT_RUNTIME.prepareSecondsPerMinute
|
||
)),
|
||
maxGameSeconds: Math.max(1, asNumber(
|
||
source.maxGameSeconds,
|
||
DEFAULT_RUNTIME.maxGameSeconds
|
||
)),
|
||
demoClueIntervalSeconds: Math.max(1, asNumber(
|
||
source.demoClueIntervalSeconds,
|
||
DEFAULT_RUNTIME.demoClueIntervalSeconds
|
||
))
|
||
};
|
||
}
|
||
|
||
function getPrepareDurationSeconds(room) {
|
||
if (room.runtime.demoAccelerated) {
|
||
return room.settings.prepareMinutes * room.runtime.prepareSecondsPerMinute;
|
||
}
|
||
return room.settings.prepareMinutes * 60;
|
||
}
|
||
|
||
function getGameDurationSeconds(room) {
|
||
const configured = room.settings.durationMinutes * 60;
|
||
return room.runtime.demoAccelerated
|
||
? Math.min(configured, room.runtime.maxGameSeconds)
|
||
: configured;
|
||
}
|
||
|
||
function getClueIntervalSeconds(room) {
|
||
return room.runtime.demoAccelerated
|
||
? room.runtime.demoClueIntervalSeconds
|
||
: room.settings.clueIntervalMinutes * 60;
|
||
}
|
||
|
||
function normalizePlayer(player, index, roomCreatedAt) {
|
||
const source = isRecord(player) ? player : {};
|
||
const fallbackName = `玩家${index + 1}`;
|
||
const name = String(source.name || fallbackName).slice(0, 10);
|
||
const ready = Boolean(source.ready);
|
||
return {
|
||
...source,
|
||
id: String(source.id || `legacy-player-${index}`),
|
||
name,
|
||
avatar: String(source.avatar || name.slice(0, 1) || "?"),
|
||
isHost: Boolean(source.isHost),
|
||
isBot: Boolean(source.isBot),
|
||
ready,
|
||
role: PLAYER_ROLES.includes(source.role) ? source.role : "",
|
||
status: PLAYER_STATUSES.includes(source.status)
|
||
? source.status
|
||
: ready ? "ready" : "idle",
|
||
caughtAt: source.caughtAt || null,
|
||
caughtBy: source.caughtBy || null,
|
||
captures: Math.max(0, asNumber(source.captures, 0)),
|
||
initialRole: PLAYER_ROLES.includes(source.initialRole) ? source.initialRole : source.role || "",
|
||
skillsUsed: {
|
||
radar: Math.max(0, asNumber(source.skillsUsed && source.skillsUsed.radar, 0)),
|
||
silent: Math.max(0, asNumber(source.skillsUsed && source.skillsUsed.silent, 0))
|
||
},
|
||
silentPending: Boolean(source.silentPending),
|
||
joinedAt: asNumber(source.joinedAt, roomCreatedAt)
|
||
};
|
||
}
|
||
|
||
function normalizeEvent(event, index, roomCreatedAt) {
|
||
const source = isRecord(event) ? event : {};
|
||
return {
|
||
...source,
|
||
id: String(source.id || `legacy-event-${roomCreatedAt}-${index}`),
|
||
type: String(source.type || "system"),
|
||
message: String(source.message || "游戏状态已更新"),
|
||
createdAt: asNumber(source.createdAt, roomCreatedAt)
|
||
};
|
||
}
|
||
|
||
function normalizeRoom(room, codeHint = "") {
|
||
if (!isRecord(room)) return null;
|
||
const code = String(room.code || codeHint || "");
|
||
if (!/^\d{6}$/.test(code)) return null;
|
||
|
||
const createdAt = asNumber(room.createdAt, Date.now());
|
||
const players = Array.isArray(room.players)
|
||
? room.players.map((player, index) => normalizePlayer(player, index, createdAt))
|
||
: [];
|
||
const events = Array.isArray(room.events)
|
||
? room.events.slice(0, 20).map((event, index) => normalizeEvent(event, index, createdAt))
|
||
: [];
|
||
|
||
return {
|
||
...room,
|
||
schemaVersion: ROOM_SCHEMA_VERSION,
|
||
id: String(room.id || `room-${code}`),
|
||
code,
|
||
name: String(room.name || "未命名游戏").slice(0, 16),
|
||
hostId: String(room.hostId || (players[0] && players[0].id) || ""),
|
||
status: ROOM_STATUSES.includes(room.status) ? room.status : "waiting",
|
||
settings: normalizeSettings(room.settings),
|
||
runtime: normalizeRuntime(room.runtime),
|
||
players,
|
||
events,
|
||
captureTokensUsed: Array.isArray(room.captureTokensUsed)
|
||
? room.captureTokensUsed.slice(-50).map(String)
|
||
: [],
|
||
winner: room.winner === "hiders" || room.winner === "seekers" ? room.winner : "",
|
||
phaseStartedAt: room.phaseStartedAt || null,
|
||
phaseEndsAt: room.phaseEndsAt || null,
|
||
nextClueAt: room.nextClueAt || null,
|
||
finishedAt: room.finishedAt || null,
|
||
pausedAt: room.pausedAt || null,
|
||
pausedRemainingMs: Math.max(0, asNumber(room.pausedRemainingMs, 0)),
|
||
pausedClueRemainingMs: Math.max(0, asNumber(room.pausedClueRemainingMs, 0)),
|
||
finishReason: String(room.finishReason || ""),
|
||
resultSnapshot: isRecord(room.resultSnapshot) ? room.resultSnapshot : null,
|
||
createdAt,
|
||
updatedAt: asNumber(room.updatedAt, createdAt)
|
||
};
|
||
}
|
||
|
||
function readRooms() {
|
||
try {
|
||
const rooms = wx.getStorageSync(ROOMS_KEY);
|
||
return isRecord(rooms) ? rooms : {};
|
||
} catch (error) {
|
||
return {};
|
||
}
|
||
}
|
||
|
||
function writeRooms(rooms) {
|
||
wx.setStorageSync(ROOMS_KEY, rooms);
|
||
}
|
||
|
||
function saveRoom(room) {
|
||
const rooms = readRooms();
|
||
const normalized = normalizeRoom(room);
|
||
if (!normalized) throw new Error("房间数据无效");
|
||
normalized.updatedAt = Date.now();
|
||
rooms[normalized.code] = normalized;
|
||
writeRooms(rooms);
|
||
return clone(normalized);
|
||
}
|
||
|
||
function makePlayer(id, name, isHost = false, isBot = false) {
|
||
return {
|
||
id,
|
||
name,
|
||
avatar: name.slice(0, 1),
|
||
isHost,
|
||
isBot,
|
||
ready: isHost,
|
||
role: "",
|
||
initialRole: "",
|
||
status: "idle",
|
||
caughtAt: null,
|
||
caughtBy: null,
|
||
captures: 0,
|
||
skillsUsed: { radar: 0, silent: 0 },
|
||
silentPending: false,
|
||
joinedAt: Date.now()
|
||
};
|
||
}
|
||
|
||
function makeDemoRoom() {
|
||
const room = {
|
||
schemaVersion: ROOM_SCHEMA_VERSION,
|
||
id: "room-demo",
|
||
code: "731204",
|
||
name: "周末公园追逃局",
|
||
hostId: "demo-host",
|
||
status: "waiting",
|
||
settings: {
|
||
...DEFAULT_SETTINGS,
|
||
durationMinutes: 20,
|
||
prepareMinutes: 1
|
||
},
|
||
runtime: { ...DEFAULT_RUNTIME },
|
||
players: [
|
||
makePlayer("demo-host", "阿树", true, true),
|
||
makePlayer("demo-2", "小满", false, true),
|
||
makePlayer("demo-3", "木木", false, true)
|
||
],
|
||
events: [],
|
||
createdAt: Date.now()
|
||
};
|
||
room.players.forEach((player) => {
|
||
player.ready = true;
|
||
});
|
||
return room;
|
||
}
|
||
|
||
function ensureSeedData() {
|
||
const rooms = readRooms();
|
||
let changed = false;
|
||
Object.keys(rooms).forEach((code) => {
|
||
const normalized = normalizeRoom(rooms[code], code);
|
||
if (normalized) {
|
||
rooms[code] = normalized;
|
||
} else {
|
||
delete rooms[code];
|
||
}
|
||
changed = true;
|
||
});
|
||
if (!rooms["731204"]) {
|
||
rooms["731204"] = makeDemoRoom();
|
||
changed = true;
|
||
}
|
||
if (changed) {
|
||
writeRooms(rooms);
|
||
}
|
||
}
|
||
|
||
function createRoom(payload) {
|
||
const validated = validateRoomPayload(payload);
|
||
const rooms = readRooms();
|
||
let code = randomCode();
|
||
while (rooms[code]) code = randomCode();
|
||
const room = {
|
||
schemaVersion: ROOM_SCHEMA_VERSION,
|
||
id: `room-${Date.now()}`,
|
||
code,
|
||
name: validated.name,
|
||
hostId: USER_ID,
|
||
status: "waiting",
|
||
settings: {
|
||
...DEFAULT_SETTINGS,
|
||
...validated
|
||
},
|
||
runtime: { ...DEFAULT_RUNTIME },
|
||
players: [makePlayer(USER_ID, "我", true, false)],
|
||
events: [
|
||
{
|
||
id: `event-${Date.now()}`,
|
||
type: "system",
|
||
message: "房间已创建，邀请好友加入吧",
|
||
createdAt: Date.now()
|
||
}
|
||
],
|
||
createdAt: Date.now()
|
||
};
|
||
|
||
saveRoom(room);
|
||
wx.setStorageSync(CURRENT_ROOM_KEY, code);
|
||
return clone(room);
|
||
}
|
||
|
||
function getRoom(code) {
|
||
const room = normalizeRoom(readRooms()[code], code);
|
||
return room ? clone(room) : null;
|
||
}
|
||
|
||
function getCurrentRoom() {
|
||
let code = "";
|
||
try {
|
||
code = wx.getStorageSync(CURRENT_ROOM_KEY);
|
||
} catch (error) {
|
||
return null;
|
||
}
|
||
return code ? getRoom(code) : null;
|
||
}
|
||
|
||
function setCurrentRoom(code) {
|
||
wx.setStorageSync(CURRENT_ROOM_KEY, code);
|
||
}
|
||
|
||
function joinRoom(code, displayName = "我") {
|
||
const normalizedCode = String(code || "").trim();
|
||
if (!/^\d{6}$/.test(normalizedCode)) {
|
||
throw new Error("请输入正确的六位房间码");
|
||
}
|
||
const normalizedName = String(displayName || "").trim().slice(0, 10);
|
||
if (!normalizedName) throw new Error("请输入游戏昵称");
|
||
|
||
const rooms = readRooms();
|
||
const room = normalizeRoom(rooms[normalizedCode], normalizedCode);
|
||
if (!room) {
|
||
throw new Error("没有找到这个房间，请检查房间码");
|
||
}
|
||
if (room.status === "finished") throw new Error("这场游戏已经结束");
|
||
if (room.status === "cancelled") throw new Error("房间已被房主取消");
|
||
if (room.status !== "waiting") throw new Error("游戏已经开始，暂时无法加入");
|
||
|
||
const existing = room.players.find((player) => player.id === USER_ID);
|
||
if (!existing) {
|
||
if (room.players.length >= room.settings.maxPlayers) {
|
||
throw new Error("房间人数已满");
|
||
}
|
||
const player = makePlayer(USER_ID, normalizedName, false, false);
|
||
if (room.code === "731204") {
|
||
player.ready = true;
|
||
player.status = "ready";
|
||
}
|
||
room.players.push(player);
|
||
} else {
|
||
existing.name = normalizedName;
|
||
existing.avatar = normalizedName.slice(0, 1);
|
||
}
|
||
saveRoom(room);
|
||
setCurrentRoom(normalizedCode);
|
||
return clone(room);
|
||
}
|
||
|
||
function addDemoPlayers(code, targetCount = 6) {
|
||
const room = getRoom(code);
|
||
if (!room || room.status !== "waiting") return room;
|
||
|
||
const usedNames = room.players.map((player) => player.name);
|
||
const available = BOT_NAMES.filter((name) => !usedNames.includes(name));
|
||
while (
|
||
room.players.length < targetCount &&
|
||
room.players.length < room.settings.maxPlayers &&
|
||
available.length
|
||
) {
|
||
const name = available.shift();
|
||
const player = makePlayer(`bot-${Date.now()}-${room.players.length}`, name, false, true);
|
||
player.ready = true;
|
||
room.players.push(player);
|
||
}
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function toggleReady(code, playerId = USER_ID) {
|
||
const room = getRoom(code);
|
||
if (!room) throw new Error("房间不存在");
|
||
if (room.status !== "waiting") throw new Error("游戏已开始，不能修改准备状态");
|
||
const player = room && room.players.find((item) => item.id === playerId);
|
||
if (!player) throw new Error("你不在当前房间中");
|
||
player.ready = !player.ready;
|
||
player.status = player.ready ? "ready" : "idle";
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function startGame(code, operatorId = USER_ID) {
|
||
const room = getRoom(code);
|
||
if (!room) throw new Error("房间不存在");
|
||
if (room.status !== "waiting") throw new Error("当前房间不能重复开始");
|
||
const canControlDemo = room.code === "731204" && operatorId === USER_ID;
|
||
if (room.hostId !== operatorId && !canControlDemo) {
|
||
throw new Error("只有房主可以开始游戏");
|
||
}
|
||
if (room.players.length < 4) throw new Error("至少需要 4 名玩家");
|
||
if (room.settings.seekerCount >= room.players.length) {
|
||
throw new Error("寻找者人数必须少于当前玩家人数");
|
||
}
|
||
if (room.players.some((player) => !player.ready)) {
|
||
throw new Error("还有玩家尚未准备好");
|
||
}
|
||
|
||
const seekerCount = room.settings.seekerCount;
|
||
const sorted = [...room.players].sort((a, b) => {
|
||
if (a.id === USER_ID) return -1;
|
||
if (b.id === USER_ID) return 1;
|
||
return a.joinedAt - b.joinedAt;
|
||
});
|
||
|
||
sorted.forEach((player, index) => {
|
||
player.role = index < seekerCount ? "seeker" : "hider";
|
||
player.initialRole = player.role;
|
||
player.status = player.role === "seeker" ? "seeking" : "hiding";
|
||
player.ready = true;
|
||
player.skillsUsed = { radar: 0, silent: 0 };
|
||
player.silentPending = false;
|
||
});
|
||
|
||
room.players = sorted;
|
||
room.status = "preparing";
|
||
room.phaseStartedAt = Date.now();
|
||
room.phaseEndsAt = room.phaseStartedAt + getPrepareDurationSeconds(room) * 1000;
|
||
room.gameDurationSeconds = getGameDurationSeconds(room);
|
||
room.captureTokensUsed = [];
|
||
room.events.unshift({
|
||
id: `event-${Date.now()}`,
|
||
type: "system",
|
||
message: "身份已分配，躲藏者请立即出发",
|
||
createdAt: Date.now()
|
||
});
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function beginPlaying(code) {
|
||
const room = getRoom(code);
|
||
if (!room) throw new Error("房间不存在");
|
||
if (room.status !== "preparing") throw new Error("当前房间不能进入追逃阶段");
|
||
const scheduledStartAt = room.phaseEndsAt || Date.now();
|
||
room.status = "playing";
|
||
room.phaseStartedAt = scheduledStartAt;
|
||
room.gameDurationSeconds = room.gameDurationSeconds || getGameDurationSeconds(room);
|
||
room.phaseEndsAt = scheduledStartAt + room.gameDurationSeconds * 1000;
|
||
room.nextClueAt = scheduledStartAt + getClueIntervalSeconds(room) * 1000;
|
||
room.events.unshift({
|
||
id: `event-${Date.now()}`,
|
||
type: "system",
|
||
message: "追逃开始！请留意安全边界",
|
||
createdAt: Date.now()
|
||
});
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function addEvent(code, message, type = "system") {
|
||
const room = getRoom(code);
|
||
if (!room) return null;
|
||
room.events.unshift({
|
||
id: `event-${Date.now()}-${Math.random()}`,
|
||
type,
|
||
message,
|
||
createdAt: Date.now()
|
||
});
|
||
room.events = room.events.slice(0, 20);
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function revealClue(code) {
|
||
const room = getRoom(code);
|
||
if (!room) throw new Error("房间不存在");
|
||
if (room.status !== "playing") throw new Error("当前阶段不能广播线索");
|
||
const silentPlayers = room.players.filter(
|
||
(player) => player.role === "hider" && player.status === "hiding" && player.silentPending
|
||
);
|
||
silentPlayers.forEach((player) => {
|
||
player.silentPending = false;
|
||
});
|
||
const area = AREA_CLUES[Math.floor(Math.random() * AREA_CLUES.length)];
|
||
const message = silentPlayers.length
|
||
? `${silentPlayers.length} 名目标的静默已生效；${area}`
|
||
: area;
|
||
room.events.unshift({
|
||
id: `event-${Date.now()}-${Math.random()}`,
|
||
type: "clue",
|
||
message,
|
||
createdAt: Date.now()
|
||
});
|
||
room.events = room.events.slice(0, 20);
|
||
room.nextClueAt = Date.now() + getClueIntervalSeconds(room) * 1000;
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function useSkill(code, skill, playerId = USER_ID) {
|
||
const room = getRoom(code);
|
||
if (!room) throw new Error("房间不存在");
|
||
if (room.status !== "playing") throw new Error("当前阶段不能使用技能");
|
||
if (!room.settings.skillsEnabled) throw new Error("本局未启用角色技能");
|
||
const player = room.players.find((item) => item.id === playerId);
|
||
if (!player) throw new Error("你不在当前房间中");
|
||
const expectedSkill = player.role === "seeker" ? "radar" : "silent";
|
||
if (skill !== expectedSkill) throw new Error("当前身份不能使用这个技能");
|
||
if (player.status !== (player.role === "seeker" ? "seeking" : "hiding")) {
|
||
throw new Error("当前玩家状态不能使用技能");
|
||
}
|
||
if (player.skillsUsed[skill] >= 1) throw new Error("本局技能已经使用过");
|
||
|
||
player.skillsUsed[skill] += 1;
|
||
if (skill === "radar") {
|
||
const nearby = Math.random() > 0.45;
|
||
room.events.unshift({
|
||
id: `event-${Date.now()}-${Math.random()}`,
|
||
type: "skill",
|
||
message: nearby ? "雷达回应：附近 150 米内可能有人" : "雷达回应：附近暂未检测到目标",
|
||
createdAt: Date.now()
|
||
});
|
||
} else {
|
||
player.silentPending = true;
|
||
room.events.unshift({
|
||
id: `event-${Date.now()}-${Math.random()}`,
|
||
type: "skill",
|
||
message: "有目标已开启静默信号",
|
||
createdAt: Date.now()
|
||
});
|
||
}
|
||
room.events = room.events.slice(0, 20);
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function captureTokenKey(targetId, timeWindow) {
|
||
return `${targetId}:${timeWindow}`;
|
||
}
|
||
|
||
function hashCaptureToken(value) {
|
||
let hash = 2166136261;
|
||
for (let index = 0; index < value.length; index += 1) {
|
||
hash ^= value.charCodeAt(index);
|
||
hash = Math.imul(hash, 16777619);
|
||
}
|
||
return String(Math.abs(hash) % 10000).padStart(4, "0");
|
||
}
|
||
|
||
function getCaptureCode(code, targetId = USER_ID, now = Date.now()) {
|
||
const room = getRoom(code);
|
||
if (!room) return "";
|
||
const target = room.players.find(
|
||
(player) => player.id === targetId && player.role === "hider" && player.status === "hiding"
|
||
);
|
||
if (!target) return "";
|
||
const timeWindow = Math.floor(now / 30000);
|
||
return hashCaptureToken(`${room.code}:${target.id}:${timeWindow}`);
|
||
}
|
||
|
||
function capture(code, targetId, submittedCode, seekerId = USER_ID, now = Date.now()) {
|
||
const room = getRoom(code);
|
||
if (!room || room.status !== "playing") {
|
||
throw new Error("当前不能提交抓捕");
|
||
}
|
||
const seeker = room.players.find((player) => player.id === seekerId);
|
||
if (!seeker || seeker.role !== "seeker" || seeker.status !== "seeking") {
|
||
throw new Error("只有正在游戏的寻找者可以提交抓捕");
|
||
}
|
||
const target = room.players.find((player) => player.id === targetId);
|
||
if (!target) throw new Error("没有找到抓捕目标");
|
||
|
||
const timeWindow = Math.floor(now / 30000);
|
||
const tokenKey = captureTokenKey(target.id, timeWindow);
|
||
if (room.captureTokensUsed.includes(tokenKey)) throw new Error("口令已经使用过");
|
||
if (target.role !== "hider" || target.status !== "hiding") {
|
||
throw new Error("目标已不在躲藏状态");
|
||
}
|
||
if (String(submittedCode) !== getCaptureCode(code, target.id, now)) {
|
||
throw new Error("口令不正确或已经失效");
|
||
}
|
||
|
||
room.captureTokensUsed.push(tokenKey);
|
||
room.captureTokensUsed = room.captureTokensUsed.slice(-50);
|
||
target.caughtAt = now;
|
||
target.caughtBy = seeker.id;
|
||
seeker.captures += 1;
|
||
if (room.settings.mode === "infection") {
|
||
target.role = "seeker";
|
||
target.status = "seeking";
|
||
} else {
|
||
target.status = "caught";
|
||
}
|
||
room.events.unshift({
|
||
id: `event-${Date.now()}`,
|
||
type: "capture",
|
||
message: `${seeker.name} 抓到了 ${target.name}`,
|
||
createdAt: Date.now()
|
||
});
|
||
|
||
const survivors = room.players.filter(
|
||
(player) => player.role === "hider" && player.status === "hiding"
|
||
);
|
||
if (!survivors.length) {
|
||
finishGameObject(room, "seekers");
|
||
}
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function makeResultSnapshot(room, winner, finishedAt, reason) {
|
||
const gameStartedAt = room.phaseStartedAt || room.createdAt;
|
||
const elapsedSeconds = Math.max(0, Math.floor((finishedAt - gameStartedAt) / 1000));
|
||
const players = room.players.map((player) => {
|
||
const survivedUntil = player.caughtAt || finishedAt;
|
||
return {
|
||
id: player.id,
|
||
name: player.name,
|
||
avatar: player.avatar,
|
||
initialRole: player.initialRole || player.role,
|
||
finalRole: player.role,
|
||
finalStatus: player.status,
|
||
captures: player.captures,
|
||
caughtAt: player.caughtAt,
|
||
survivedSeconds: player.initialRole === "hider"
|
||
? Math.max(0, Math.floor((survivedUntil - gameStartedAt) / 1000))
|
||
: 0,
|
||
joinedAt: player.joinedAt
|
||
};
|
||
});
|
||
players.sort((a, b) => {
|
||
if (b.captures !== a.captures) return b.captures - a.captures;
|
||
if (b.survivedSeconds !== a.survivedSeconds) return b.survivedSeconds - a.survivedSeconds;
|
||
if (a.joinedAt !== b.joinedAt) return a.joinedAt - b.joinedAt;
|
||
return a.id.localeCompare(b.id);
|
||
});
|
||
return {
|
||
winner,
|
||
reason,
|
||
finishedAt,
|
||
elapsedSeconds,
|
||
eventCount: room.events.length,
|
||
players
|
||
};
|
||
}
|
||
|
||
function finishGameObject(room, winner, reason = "completed") {
|
||
const finishedAt = Date.now();
|
||
room.status = "finished";
|
||
room.finishedAt = finishedAt;
|
||
room.winner = winner;
|
||
room.finishReason = reason;
|
||
room.phaseEndsAt = finishedAt;
|
||
room.resultSnapshot = makeResultSnapshot(room, winner, finishedAt, reason);
|
||
}
|
||
|
||
function finishGame(code, winner, operatorId = USER_ID, reason = "manual") {
|
||
const room = getRoom(code);
|
||
if (!room) throw new Error("房间不存在");
|
||
if (!["preparing", "playing", "paused"].includes(room.status)) {
|
||
throw new Error("当前房间不能结束游戏");
|
||
}
|
||
const canControlDemo = room.code === "731204" && operatorId === USER_ID;
|
||
if (operatorId && room.hostId !== operatorId && !canControlDemo) {
|
||
throw new Error("只有房主可以提前结束游戏");
|
||
}
|
||
const survivors = room.players.filter(
|
||
(player) => player.role === "hider" && player.status === "hiding"
|
||
);
|
||
finishGameObject(room, winner || (survivors.length ? "hiders" : "seekers"), reason);
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function pauseGame(code, operatorId = USER_ID) {
|
||
const room = getRoom(code);
|
||
if (!room) throw new Error("房间不存在");
|
||
if (room.status !== "playing") throw new Error("只有追逃阶段可以暂停");
|
||
const canControlDemo = room.code === "731204" && operatorId === USER_ID;
|
||
if (room.hostId !== operatorId && !canControlDemo) throw new Error("只有房主可以暂停游戏");
|
||
const now = Date.now();
|
||
room.status = "paused";
|
||
room.pausedAt = now;
|
||
room.pausedRemainingMs = Math.max(0, room.phaseEndsAt - now);
|
||
room.pausedClueRemainingMs = room.nextClueAt
|
||
? Math.max(0, room.nextClueAt - now)
|
||
: 0;
|
||
room.events.unshift({
|
||
id: `event-${now}`,
|
||
type: "system",
|
||
message: "房主暂停了游戏，请所有玩家留在安全位置",
|
||
createdAt: now
|
||
});
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function resumeGame(code, operatorId = USER_ID) {
|
||
const room = getRoom(code);
|
||
if (!room) throw new Error("房间不存在");
|
||
if (room.status !== "paused") throw new Error("当前游戏没有暂停");
|
||
const canControlDemo = room.code === "731204" && operatorId === USER_ID;
|
||
if (room.hostId !== operatorId && !canControlDemo) throw new Error("只有房主可以继续游戏");
|
||
const now = Date.now();
|
||
room.status = "playing";
|
||
room.phaseEndsAt = now + room.pausedRemainingMs;
|
||
room.nextClueAt = room.pausedClueRemainingMs
|
||
? now + room.pausedClueRemainingMs
|
||
: now + getClueIntervalSeconds(room) * 1000;
|
||
room.pausedAt = null;
|
||
room.pausedRemainingMs = 0;
|
||
room.pausedClueRemainingMs = 0;
|
||
room.events.unshift({
|
||
id: `event-${now}`,
|
||
type: "system",
|
||
message: "房主继续了游戏",
|
||
createdAt: now
|
||
});
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function quitGame(code, playerId = USER_ID) {
|
||
const room = getRoom(code);
|
||
if (!room) throw new Error("房间不存在");
|
||
if (!["preparing", "playing", "paused"].includes(room.status)) {
|
||
throw new Error("当前不能退出游戏");
|
||
}
|
||
const player = room.players.find((item) => item.id === playerId);
|
||
if (!player) throw new Error("你不在当前房间中");
|
||
if (player.status === "quit") throw new Error("玩家已经退出游戏");
|
||
player.status = "quit";
|
||
player.ready = false;
|
||
room.events.unshift({
|
||
id: `event-${Date.now()}`,
|
||
type: "safety",
|
||
message: `${player.name} 已安全退出并前往集合点`,
|
||
createdAt: Date.now()
|
||
});
|
||
const survivors = room.players.filter(
|
||
(item) => item.role === "hider" && item.status === "hiding"
|
||
);
|
||
if (!survivors.length) finishGameObject(room, "seekers", "all_hiders_left");
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function resetRoom(code) {
|
||
const room = getRoom(code);
|
||
if (!room) return null;
|
||
room.status = "waiting";
|
||
room.winner = "";
|
||
room.finishReason = "";
|
||
room.phaseEndsAt = null;
|
||
room.phaseStartedAt = null;
|
||
room.nextClueAt = null;
|
||
room.gameDurationSeconds = null;
|
||
room.finishedAt = null;
|
||
room.pausedAt = null;
|
||
room.pausedRemainingMs = 0;
|
||
room.pausedClueRemainingMs = 0;
|
||
room.resultSnapshot = null;
|
||
room.events = [];
|
||
room.players.forEach((player) => {
|
||
player.role = "";
|
||
player.initialRole = "";
|
||
player.status = "ready";
|
||
player.ready = true;
|
||
player.caughtAt = null;
|
||
player.caughtBy = null;
|
||
player.captures = 0;
|
||
player.skillsUsed = { radar: 0, silent: 0 };
|
||
player.silentPending = false;
|
||
});
|
||
room.captureTokensUsed = [];
|
||
return saveRoom(room);
|
||
}
|
||
|
||
function clearCurrentRoom() {
|
||
wx.removeStorageSync(CURRENT_ROOM_KEY);
|
||
}
|
||
|
||
module.exports = {
|
||
USER_ID,
|
||
ensureSeedData,
|
||
createRoom,
|
||
getRoom,
|
||
getCurrentRoom,
|
||
setCurrentRoom,
|
||
joinRoom,
|
||
addDemoPlayers,
|
||
toggleReady,
|
||
startGame,
|
||
beginPlaying,
|
||
revealClue,
|
||
useSkill,
|
||
getCaptureCode,
|
||
capture,
|
||
finishGame,
|
||
pauseGame,
|
||
resumeGame,
|
||
quitGame,
|
||
resetRoom,
|
||
clearCurrentRoom
|
||
};
|