329 lines
12 KiB
JavaScript
329 lines
12 KiB
JavaScript
import { IsNull, LessThan, MoreThan } from "typeorm";
|
|
import { redisClient } from "../../db/redis.js";
|
|
import { genId } from "../../misc/gen-id.js";
|
|
import { ReversiGames, Users } from "../../models/index.js";
|
|
import { deserializeLogs, restoreGame, serializeLogs, standardMap, ReversiEngine } from "./engine.js";
|
|
import { publishReversiGameStream, publishReversiStream } from "../stream.js";
|
|
const INVITATION_TIMEOUT_MS = 1000 * 20;
|
|
const TIME_LIMIT_MIN = 5;
|
|
const TIME_LIMIT_MAX = 300;
|
|
const updateKeys = [
|
|
"map",
|
|
"bw",
|
|
"isLlotheo",
|
|
"canPutEverywhere",
|
|
"loopedBoard",
|
|
"timeLimitForEachTurn"
|
|
];
|
|
async function getGame(id) {
|
|
return await ReversiGames.findOne({
|
|
where: {
|
|
id
|
|
},
|
|
relations: {
|
|
user1: true,
|
|
user2: true
|
|
}
|
|
});
|
|
}
|
|
async function publishGame(id, type, body) {
|
|
publishReversiGameStream(id, type, body);
|
|
}
|
|
async function endGame(game, winnerId, reason) {
|
|
await ReversiGames.update(game.id, {
|
|
isEnded: true,
|
|
endedAt: new Date(),
|
|
winnerId,
|
|
surrenderedUserId: reason === "surrender" ? winnerId === game.user1Id ? game.user2Id : game.user1Id : null,
|
|
timeoutUserId: reason === "timeout" ? winnerId === game.user1Id ? game.user2Id : game.user1Id : null
|
|
});
|
|
const fresh = await getGame(game.id);
|
|
if (fresh) {
|
|
await publishGame(game.id, "ended", {
|
|
winnerId,
|
|
game: await ReversiGames.packDetail(fresh)
|
|
});
|
|
}
|
|
}
|
|
export function isValidUpdateKey(key) {
|
|
return typeof key === "string" && updateKeys.includes(key);
|
|
}
|
|
export function isValidUpdateValue(key, value) {
|
|
switch(key){
|
|
case "map":
|
|
return Array.isArray(value) && value.length > 0 && value.every((row)=>typeof row === "string" && row.length <= 64);
|
|
case "bw":
|
|
return value === "random" || value === "1" || value === "2";
|
|
case "isLlotheo":
|
|
case "canPutEverywhere":
|
|
case "loopedBoard":
|
|
return typeof value === "boolean";
|
|
case "timeLimitForEachTurn":
|
|
return typeof value === "number" && value >= TIME_LIMIT_MIN && value <= TIME_LIMIT_MAX;
|
|
}
|
|
}
|
|
export async function matchSpecificUser(me, target, multiple = false) {
|
|
if (!multiple) {
|
|
const since = genId(new Date(Date.now() - 1000 * 60 * 3));
|
|
const games = await ReversiGames.find({
|
|
where: [
|
|
{
|
|
id: MoreThan(since),
|
|
user1Id: me.id,
|
|
user2Id: target.id,
|
|
isStarted: false
|
|
},
|
|
{
|
|
id: MoreThan(since),
|
|
user1Id: target.id,
|
|
user2Id: me.id,
|
|
isStarted: false
|
|
}
|
|
],
|
|
relations: {
|
|
user1: true,
|
|
user2: true
|
|
},
|
|
order: {
|
|
id: "DESC"
|
|
}
|
|
});
|
|
if (games.length > 0) return games[0];
|
|
}
|
|
const invitations = await redisClient.zrangebyscore(`reversi:matchSpecific:${me.id}`, Date.now() - INVITATION_TIMEOUT_MS, "+inf");
|
|
if (invitations.includes(target.id)) {
|
|
await redisClient.zrem(`reversi:matchSpecific:${me.id}`, target.id);
|
|
return await matched(target.id, me.id, {
|
|
noIrregularRules: false
|
|
});
|
|
}
|
|
const pipeline = redisClient.pipeline();
|
|
pipeline.zadd(`reversi:matchSpecific:${target.id}`, Date.now(), me.id);
|
|
pipeline.expire(`reversi:matchSpecific:${target.id}`, 120);
|
|
await pipeline.exec();
|
|
publishReversiStream(target.id, "invited", {
|
|
user: await Users.pack(me.id, target, {
|
|
detail: false
|
|
})
|
|
});
|
|
return null;
|
|
}
|
|
export async function matchAnyUser(me, options, multiple = false) {
|
|
if (!multiple) {
|
|
const since = genId(new Date(Date.now() - 1000 * 60 * 3));
|
|
const games = await ReversiGames.find({
|
|
where: [
|
|
{
|
|
id: MoreThan(since),
|
|
user1Id: me.id,
|
|
isStarted: false
|
|
},
|
|
{
|
|
id: MoreThan(since),
|
|
user2Id: me.id,
|
|
isStarted: false
|
|
}
|
|
],
|
|
relations: {
|
|
user1: true,
|
|
user2: true
|
|
},
|
|
order: {
|
|
id: "DESC"
|
|
}
|
|
});
|
|
if (games.length > 0) return games[0];
|
|
}
|
|
const invitations = await redisClient.zrangebyscore(`reversi:matchSpecific:${me.id}`, Date.now() - INVITATION_TIMEOUT_MS, "+inf");
|
|
if (invitations.length > 0) {
|
|
const inviterId = invitations[Math.floor(Math.random() * invitations.length)];
|
|
await redisClient.zrem(`reversi:matchSpecific:${me.id}`, inviterId);
|
|
return await matched(inviterId, me.id, {
|
|
noIrregularRules: false
|
|
});
|
|
}
|
|
const matchings = await redisClient.zrevrange("reversi:matchAny", 0, 2);
|
|
const items = matchings.filter((id)=>!id.startsWith(me.id));
|
|
if (items.length > 0) {
|
|
const [matchedUserId, option] = items[0].split(":");
|
|
await redisClient.zrem("reversi:matchAny", me.id, matchedUserId, `${me.id}:noIrregularRules`, `${matchedUserId}:noIrregularRules`);
|
|
return await matched(matchedUserId, me.id, {
|
|
noIrregularRules: options.noIrregularRules || option === "noIrregularRules"
|
|
});
|
|
}
|
|
const pipeline = redisClient.pipeline();
|
|
pipeline.zadd("reversi:matchAny", Date.now(), options.noIrregularRules ? `${me.id}:noIrregularRules` : me.id);
|
|
pipeline.expire("reversi:matchAny", 15);
|
|
await pipeline.exec();
|
|
return null;
|
|
}
|
|
async function matched(parentId, childId, options) {
|
|
const game = await ReversiGames.insert({
|
|
id: genId(),
|
|
startedAt: null,
|
|
endedAt: null,
|
|
user1Id: parentId,
|
|
user2Id: childId,
|
|
user1Ready: false,
|
|
user2Ready: false,
|
|
black: null,
|
|
isStarted: false,
|
|
isEnded: false,
|
|
winnerId: null,
|
|
surrenderedUserId: null,
|
|
timeoutUserId: null,
|
|
timeLimitForEachTurn: 90,
|
|
logs: [],
|
|
map: standardMap,
|
|
bw: "random",
|
|
noIrregularRules: options.noIrregularRules,
|
|
isLlotheo: false,
|
|
canPutEverywhere: false,
|
|
loopedBoard: false,
|
|
form1: null,
|
|
form2: null,
|
|
crc32: null
|
|
}).then((x)=>getGame(x.identifiers[0].id));
|
|
if (!game) throw new Error("failed to create reversi game");
|
|
publishReversiStream(parentId, "matched", {
|
|
game: await ReversiGames.packDetail(game)
|
|
});
|
|
return game;
|
|
}
|
|
export async function cancelMatch(user, userId) {
|
|
if (userId) await redisClient.zrem(`reversi:matchSpecific:${userId}`, user.id);
|
|
await redisClient.zrem("reversi:matchAny", user.id, `${user.id}:noIrregularRules`);
|
|
}
|
|
export async function getInvitations(user) {
|
|
return await redisClient.zrangebyscore(`reversi:matchSpecific:${user.id}`, Date.now() - INVITATION_TIMEOUT_MS, "+inf");
|
|
}
|
|
export async function gameReady(gameId, user, ready) {
|
|
const game = await getGame(gameId);
|
|
if (!game || game.isStarted) return;
|
|
if (game.user1Id !== user.id && game.user2Id !== user.id) return;
|
|
const patch = game.user1Id === user.id ? {
|
|
user1Ready: ready
|
|
} : {
|
|
user2Ready: ready
|
|
};
|
|
await ReversiGames.update(game.id, patch);
|
|
const fresh = await getGame(game.id);
|
|
if (!fresh) return;
|
|
await publishGame(game.id, "changeReadyStates", {
|
|
user1: fresh.user1Ready,
|
|
user2: fresh.user2Ready
|
|
});
|
|
if (fresh.user1Ready && fresh.user2Ready) setTimeout(()=>startGame(fresh.id), 3000);
|
|
}
|
|
export async function updateSettings(gameId, user, key, value) {
|
|
const game = await getGame(gameId);
|
|
if (!game || game.isStarted) return;
|
|
if (game.user1Id !== user.id && game.user2Id !== user.id) return;
|
|
if (game.user1Id === user.id && game.user1Ready) return;
|
|
if (game.user2Id === user.id && game.user2Ready) return;
|
|
if (game.noIrregularRules && (key === "isLlotheo" || key === "canPutEverywhere" || key === "loopedBoard")) return;
|
|
await ReversiGames.update(game.id, {
|
|
[key]: value
|
|
});
|
|
await publishGame(game.id, "updateSettings", {
|
|
userId: user.id,
|
|
key,
|
|
value
|
|
});
|
|
}
|
|
async function startGame(gameId) {
|
|
const game = await getGame(gameId);
|
|
if (!game || game.isStarted || game.isEnded || !game.user1Ready || !game.user2Ready) return;
|
|
const black = game.bw === "random" ? Math.random() > 0.5 ? 1 : 2 : parseInt(game.bw, 10);
|
|
const engine = new ReversiEngine(game.map, game);
|
|
await ReversiGames.update(game.id, {
|
|
startedAt: new Date(),
|
|
isStarted: true,
|
|
black,
|
|
crc32: engine.calcCrc32()
|
|
});
|
|
const fresh = await getGame(game.id);
|
|
if (!fresh) return;
|
|
if (engine.isEnded) {
|
|
const winnerId = engine.winner === true ? black === 1 ? game.user1Id : game.user2Id : engine.winner === false ? black === 1 ? game.user2Id : game.user1Id : null;
|
|
await endGame(fresh, winnerId, null);
|
|
return;
|
|
}
|
|
await redisClient.setex(`reversi:game:turnTimer:${game.id}:1`, fresh.timeLimitForEachTurn, "");
|
|
await publishGame(game.id, "started", {
|
|
game: await ReversiGames.packDetail(fresh)
|
|
});
|
|
}
|
|
export async function putStone(gameId, user, pos, id) {
|
|
const game = await getGame(gameId);
|
|
if (!game || !game.isStarted || game.isEnded) return;
|
|
if (game.user1Id !== user.id && game.user2Id !== user.id) return;
|
|
const myColor = game.user1Id === user.id && game.black === 1 || game.user2Id === user.id && game.black === 2;
|
|
const engine = restoreGame(game);
|
|
if (engine.turn !== myColor || !engine.canPut(myColor, pos)) return;
|
|
engine.putStone(pos);
|
|
const logs = deserializeLogs(game.logs);
|
|
const log = {
|
|
time: Date.now(),
|
|
player: myColor,
|
|
operation: "put",
|
|
pos
|
|
};
|
|
logs.push(log);
|
|
const serialized = serializeLogs(logs);
|
|
await ReversiGames.update(game.id, {
|
|
logs: serialized,
|
|
crc32: engine.calcCrc32()
|
|
});
|
|
await publishGame(game.id, "log", {
|
|
...log,
|
|
id: id ?? null
|
|
});
|
|
const fresh = await getGame(game.id);
|
|
if (!fresh) return;
|
|
if (engine.isEnded) {
|
|
const winnerId = engine.winner === true ? game.black === 1 ? game.user1Id : game.user2Id : engine.winner === false ? game.black === 1 ? game.user2Id : game.user1Id : null;
|
|
await endGame(fresh, winnerId, null);
|
|
} else if (engine.turn != null) {
|
|
await redisClient.setex(`reversi:game:turnTimer:${game.id}:${engine.turn ? "1" : "0"}`, fresh.timeLimitForEachTurn, "");
|
|
}
|
|
}
|
|
export async function surrender(gameId, user) {
|
|
const game = await getGame(gameId);
|
|
if (!game || game.isEnded) return;
|
|
if (game.user1Id !== user.id && game.user2Id !== user.id) return;
|
|
await endGame(game, game.user1Id === user.id ? game.user2Id : game.user1Id, "surrender");
|
|
}
|
|
export async function cancelGame(gameId, user) {
|
|
const game = await getGame(gameId);
|
|
if (!game || game.isStarted) return;
|
|
if (game.user1Id !== user.id && game.user2Id !== user.id) return;
|
|
await ReversiGames.delete(game.id);
|
|
await publishGame(game.id, "canceled", {
|
|
userId: user.id
|
|
});
|
|
}
|
|
export async function checkTimeout(gameId) {
|
|
const game = await getGame(gameId);
|
|
if (!game || game.isEnded) return;
|
|
const engine = restoreGame(game);
|
|
if (engine.turn == null) return;
|
|
const timer = await redisClient.exists(`reversi:game:turnTimer:${game.id}:${engine.turn ? "1" : "0"}`);
|
|
if (timer === 0) {
|
|
const winnerId = engine.turn ? game.black === 1 ? game.user2Id : game.user1Id : game.black === 1 ? game.user1Id : game.user2Id;
|
|
await endGame(game, winnerId, "timeout");
|
|
}
|
|
}
|
|
export async function checkCrc(gameId, crc32) {
|
|
const game = await getGame(gameId);
|
|
if (!game) return null;
|
|
return crc32.toString() !== game.crc32 ? game : null;
|
|
}
|
|
export async function cleanupOpenGames() {
|
|
await ReversiGames.delete({
|
|
id: LessThan(genId(new Date(Date.now() - 1000 * 60 * 10))),
|
|
isStarted: false,
|
|
startedAt: IsNull()
|
|
});
|
|
}
|