@yyyu-star/arcade-kit 0.19.1 → 0.20.1

package/dist/room.js

@@ -45,6 +45,7 @@ export const DEFAULT_LIMITS = {
     chatPerMin: 10,
     meterBatch: 200,
     closingMs: 60 * 60_000,
+    matchJoinMs: 20_000,
 };
 /** 闹钟里出错时，过这么久再醒来重试（不用"马上"，免得每次都出错时连着计费）。 */
 const ALARM_RETRY_MS = 60_000;
@@ -164,7 +165,10 @@ export class GameRoom extends DurableObject {
     lastStepFailed = false;
     /** 写了还没报给计量的行数 */
     unmetered = 0;
-    /** 这一步做完以后要还房主的名额（打完、关房），entry 最后去找计量 */
+    /**
+     * 这一步做完以后要还的名额（打完、关房；房主一个人，匹配桌是排进来的每个人），entry 最后去找计量。
+     * refund：匹配桌开打时没来的人（0.20.0），连当天的开房次数一起退给他（全站开房数不退，桌子开成了）
+     */
     release = null;
     /** 计量最近一次说的门槛（内存；被驱逐就重新问） */
     level = null;
@@ -221,6 +225,49 @@ export class GameRoom extends DurableObject {
             await meter.kitRelease(host.userId, code, 0, true).catch(() => console.error('meter release failed', code));
         return { r: out instanceof Response ? 'error' : out };
     }
+    /**
+     * 快速匹配开桌（0.20.0，只有 match.ts 的排队对象经 RPC 调）：players 按排队先后，每人占一个开房名额（计量一次占齐，占不齐一个都不占），
+     * 建房时把他们按 matchSeats 坐好。和 kitCreate 一样：码撞了回 exists、什么都不写；占到了却没建成就退回去。
+     */
+    async kitCreateMatch(code, players, rawOpts) {
+        const fixed = this.checkOpts(rawOpts);
+        if (fixed === undefined || (rawOpts !== undefined && !this.game.options))
+            return { r: 'bad_options' };
+        if (!validPlayers(code, players, fixed.count))
+            return { r: 'bad' };
+        const meter = this.meter();
+        const users = players.map((p) => p.userId);
+        let reserved = false;
+        if (meter && !this.load()) {
+            try {
+                const r = await meter.kitReserveMany(users, code, Date.now() + this.limits.maxLifeMs);
+                if (!r.ok) {
+                    if (r.error === 'has_room')
+                        return { r: 'refused', userId: r.userId, why: 'has_room', code: r.code };
+                    return r.error === 'daily_limit' ? { r: 'refused', userId: r.userId, why: 'daily_limit' } : { r: 'refused', userId: null, why: 'busy' };
+                }
+                reserved = true;
+            }
+            catch (e) {
+                console.error('meter unreachable, refusing match room', e instanceof Error ? e.message : e);
+                return { r: 'unavailable' };
+            }
+        }
+        const before = this.maxStepWrites;
+        const out = await this.entry(() => this.createMatch(code, players, fixed));
+        if (out === 'created')
+            this.maxStepWrites = before;
+        else if (reserved && meter)
+            await meter.kitReleaseMany(users, code, 0, true).catch(() => console.error('meter release failed', code));
+        return { r: out instanceof Response ? 'error' : out };
+    }
+    /**
+     * 快速匹配时 n 个人坐哪几个座位（0.20.0，可选覆盖）：count 是这一局用几个座位，返回 n 个不重复的座位号（排队先后的顺序）。
+     * 默认随机（crypto，不在规则核心里）；比如两个真人要坐对家，游戏在这里给。给的不合格（重复、越界、个数不对）就按默认的随机
+     */
+    matchSeats(n, count) {
+        return randomSeats(n, count);
+    }
     /** 进房：只认 kit 自己拼的内部地址（worker.ts 的 acceptJoin），身份在 x-kit-user 头里。 */
     async fetch(request) {
         const url = new URL(request.url);
@@ -391,7 +438,9 @@ export class GameRoom extends DurableObject {
             this.release = null;
             this.unmetered = 0;
             try {
-                const level = release ? await meter.kitRelease(release.host, release.code, n) : await meter.kitReport(n);
+                const level = release
+                    ? await meter.kitReleaseMany(release.users, release.code, n, release.refund === true, false)
+                    : await meter.kitReport(n);
                 this.level = { value: level, at: Date.now() };
                 this.meterRetryAt = 0;
             }
@@ -428,7 +477,7 @@ export class GameRoom extends DurableObject {
     async newcomerGate(userId) {
         const meter = this.meter();
         const st = this.load();
-        if (!meter || !st || st.host === userId || this.seatOf(userId) !== null || this.boundOf(userId) !== null)
+        if (!meter || !st || st.host === userId || this.seatOf(userId) !== null || this.boundOf(userId) !== null || st.match?.users.includes(userId))
             return null;
         if (this.sockets().some((o) => attachmentOf(o)?.userId === userId))
             return null;
@@ -473,6 +522,34 @@ export class GameRoom extends DurableObject {
         this.save();
         return 'created';
     }
+    /** 匹配桌（0.20.0）：和 create 一样建表、存一行、设闹钟，只是排进来的人都先坐好（算掉线，连上就"回来"），记下最晚开打的时间。 */
+    createMatch(code, players, fixed) {
+        if (this.load())
+            return 'exists';
+        this.writes += this.ctx.storage.sql.exec(`CREATE TABLE IF NOT EXISTS ${TABLE} (k INTEGER PRIMARY KEY, v TEXT NOT NULL)`).rowsWritten;
+        const now = Date.now();
+        const seats = Array.from({ length: this.game.seats }, () => emptySeat());
+        let order;
+        try {
+            order = this.matchSeats(players.length, fixed.count);
+        }
+        catch (e) {
+            console.error('matchSeats threw', e instanceof Error ? e.message : e);
+            order = [];
+        }
+        if (!validSeats(order, players.length, fixed.count))
+            order = randomSeats(players.length, fixed.count);
+        players.forEach((p, i) => (seats[order[i]] = humanSeat(p.userId, p.name, now)));
+        this.st = {
+            sv: 1, code, host: players[0].userId, createdAt: now, status: 'waiting', seq: 0, gameSeq: 0, turnSeq: 0, seats, game: null, rulesVersion: null,
+            turnSince: null, aiAt: null, noHumanSince: now, inbound: 0, inboundBy: {}, joins: {}, owners: seats.map(() => null),
+            ...(fixed.opts !== undefined ? { opts: fixed.opts } : {}),
+            match: { users: players.map((p) => p.userId), joinBy: now + this.limits.matchJoinMs },
+        };
+        this.planAlarm();
+        this.save();
+        return 'created';
+    }
     /** 进房（含重连）：接受、记座位、发快照，中间没有 await（4.5 续局的写法）。 */
     join(me, rawCv, chat = false) {
         const pair = new WebSocketPair();
@@ -494,6 +571,11 @@ export class GameRoom extends DurableObject {
             server.close(CLOSE.tooOld, 'client too old');
             return done();
         }
+        // 匹配桌只认排进来的人（0.20.0）：房间码不给页面看，别人拿到码也进不来、看不了，回的和"没有这个房间"一样
+        if (st.match && !st.match.users.includes(me.userId)) {
+            server.close(CLOSE.noRoom, 'no room');
+            return done();
+        }
         const seat = this.seatOf(me.userId);
         const others = this.sockets().filter((o) => o !== server && attachmentOf(o));
         const mine = others.filter((o) => attachmentOf(o).userId === me.userId);
@@ -550,9 +632,11 @@ export class GameRoom extends DurableObject {
             st.joins[me.userId] = used + 1;
             st.noHumanSince = null;
         }
+        // 匹配桌的人到齐了：不等，和这次进房同一步开打（还是只写这一行和闹钟）
+        const frames = changed && this.matchReady(st) ? this.beginPlay(st, Date.now()) : [{ state: st.game, delay: 0 }];
         // 状态没变（没入座的人进来、在线时又从别的设备连一次）不写库、不广播
         if (changed)
-            this.commit({ frames: [{ state: st.game, delay: 0 }] }, server);
+            this.commit({ frames }, server);
         this.send(server, this.welcome(seat, this.boundOf(me.userId)));
         return done();
     }
@@ -699,6 +783,9 @@ export class GameRoom extends DurableObject {
         const target = st.seats[raw];
         if (st.status === 'over')
             return this.reject(ws, 'room_over');
+        // 匹配桌等人时座位是排好的，不换（开打以后离座、回座照常）
+        if (st.match && st.status === 'waiting')
+            return this.reject(ws, 'seat_taken');
         if (st.status === 'waiting') {
             // 开房时定了选项的（0.4.0）：这一局用不到的座位现在就不让坐，免得房主开打时才被 seat_closed 拒
             if (st.opts !== undefined && raw >= this.countOf(st.opts))
@@ -741,7 +828,7 @@ export class GameRoom extends DurableObject {
     }
     leave(seat) {
         const st = this.st;
-        if (seat === null)
+        if (seat === null || (st.match && st.status === 'waiting'))
             return;
         // 等人时空出来；开打后由电脑接手（不判负），轮到它就接着出。座位还绑着他，留下昵称给牌桌显示"电脑代某某打"
         st.seats[seat] = st.status === 'playing' ? { ...aiSeat(), name: st.seats[seat].name } : emptySeat();
@@ -756,8 +843,8 @@ export class GameRoom extends DurableObject {
     }
     start(ws, me, seat, rawOpts) {
         const st = this.st;
-        // 房主选择开打（9.1）
-        if (me.userId !== st.host)
+        // 房主选择开打（9.1）；匹配桌没有房主，到齐或到点自动开（0.20.0）
+        if (me.userId !== st.host || st.match)
             return this.reject(ws, 'not_host');
         if (st.status !== 'waiting')
             return this.reject(ws, 'already_started');
@@ -769,22 +856,44 @@ export class GameRoom extends DurableObject {
         const checked = fixed ?? this.checkOpts(rawOpts);
         if (!checked)
             return this.reject(ws, 'bad_options');
-        const { opts, count } = checked;
-        if (st.seats.some((s, i) => i >= count && s.kind === 'human'))
+        if (st.seats.some((s, i) => i >= checked.count && s.kind === 'human'))
             return this.reject(ws, 'seat_closed');
-        // 空座位由电脑补满；入座的人从这一刻起绑在自己的座位上
+        this.commit({ frames: this.beginPlay(st, Date.now(), checked) });
+    }
+    /**
+     * 开打：空座位由电脑补满，入座的人从这一刻起绑在自己的座位上，返回要广播的帧。
+     * 匹配桌（0.20.0）到点还没连上的人：座位照样绑给他，电脑先代打（auto），他连上就交还
+     */
+    beginPlay(st, now, checked) {
+        const { opts, count } = checked ?? { opts: st.opts, count: this.countOf(st.opts) };
         st.seats = st.seats.map((s, i) => (s.kind === 'empty' && i < count ? aiSeat() : s));
+        if (st.match) {
+            const absent = [];
+            for (const s of st.seats) {
+                if (s.kind !== 'human' || s.awaySince === null)
+                    continue;
+                s.auto = true;
+                absent.push(s.userId);
+            }
+            // 没来的人（关了页面、网断了）：他的开房名额和当天次数退给他，不然白扣一个、还被 has_room 卡到这桌打完。
+            // 他后来回来照样能接着打这个座位（座位还绑着他）
+            if (absent.length)
+                this.release = { users: absent, code: st.code, refund: true };
+        }
         st.owners = st.seats.map((s) => (s.kind === 'human' ? s.userId : null));
         st.rulesVersion = this.game.rulesVersion;
         st.game = this.begin(st.code, { opts, seats: st.seats.map((s) => s.kind) });
         st.gameSeq = st.seq + 1;
         st.turnSeq = st.gameSeq;
         st.status = 'playing';
-        const now = Date.now();
         st.turnSince = now;
         if (!this.game.over(st.game))
             this.stalled(this.actorsOf(st.game));
-        this.commit({ frames: [{ state: st.game, delay: 0 }, ...this.runAuto(now)] });
+        return [{ state: st.game, delay: 0 }, ...this.runAuto(now)];
+    }
+    /** 匹配桌在等人，排进来的人都连上了 */
+    matchReady(st) {
+        return !!st.match && st.status === 'waiting' && st.seats.every((s) => s.kind !== 'human' || s.awaySince === null);
     }
     /**
      * 开局拿随机：写了 begin 的给 256 位熵（只在这里用一次，房间不存；游戏要接着发牌就把它放进自己的状态，那只在服务端）。
@@ -904,6 +1013,9 @@ export class GameRoom extends DurableObject {
             return this.closeRoom();
         const frames = [];
         let changed = false;
+        // 匹配桌等够了（0.20.0）：没来的由电脑代打，照样开
+        if (st.match && st.status === 'waiting' && now >= st.match.joinBy)
+            return this.commit({ frames: this.beginPlay(st, now) });
         // 掉线超过宽限：电脑托管（只在开打以后有意义，等人时不管）
         for (const s of st.status === 'playing' ? st.seats : []) {
             if (s.kind === 'human' && s.awaySince !== null && !s.auto && now >= s.awaySince + this.limits.graceMs) {
@@ -967,6 +1079,8 @@ export class GameRoom extends DurableObject {
             ds.push(st.effectsAt);
         if (st.noHumanSince !== null)
             ds.push(st.noHumanSince + this.limits.noHumanMs);
+        if (st.match && st.status === 'waiting')
+            ds.push(st.match.joinBy);
         if (st.status === 'playing') {
             for (const s of st.seats)
                 if (s.kind === 'human' && s.awaySince !== null && !s.auto)
@@ -1027,7 +1141,7 @@ export class GameRoom extends DurableObject {
         if (over) {
             st.status = 'over';
             st.turnSince = null;
-            this.release = { host: st.host, code: st.code };
+            this.release = releaseOf(st);
             return;
         }
         const after = this.turnOf(next);
@@ -1080,7 +1194,7 @@ export class GameRoom extends DurableObject {
         console.error('game has nobody to act but is not over', st.code);
         st.status = 'over';
         st.turnSince = null;
-        this.release = { host: st.host, code: st.code };
+        this.release = releaseOf(st);
         return true;
     }
     /** 超时代出：先用 timeout，被规则拒了再用 ai 试一次。都不行返回 false（记日志）。 */
@@ -1474,7 +1588,7 @@ export class GameRoom extends DurableObject {
                 st.ending = { reason, at: Date.now() };
                 st.effectsAt = null;
                 st.effectTries = 0;
-                this.release = { host: st.host, code: st.code };
+                this.release = releaseOf(st);
                 this.closing = false;
                 this.planAlarm();
                 this.save();
@@ -1490,7 +1604,7 @@ export class GameRoom extends DurableObject {
             ws.close(CLOSE.roomClosed, reason);
         }
         if (this.st)
-            this.release = { host: this.st.host, code: this.st.code };
+            this.release = releaseOf(this.st);
         this.st = null;
         this.alarmToSet = null;
         this.alarmAt = null;
@@ -1554,12 +1668,13 @@ export class GameRoom extends DurableObject {
             turn,
             ...(st.opts !== undefined ? { opts: st.opts } : {}),
             ...(until !== null ? { pause: { until } } : {}),
+            ...(st.match ? { match: true } : {}),
         };
     }
     /** 这个房间的自己人：房主、坐着的、开打后绑过座位的。猜码超限时只放他们进（0.14.0） */
     insider(userId) {
         const st = this.load();
-        return !!st && (st.host === userId || this.seatOf(userId) !== null || this.boundOf(userId) !== null);
+        return !!st && (st.host === userId || this.seatOf(userId) !== null || this.boundOf(userId) !== null || !!st.match?.users.includes(userId));
     }
     /** 房主，或者开打后绑过座位的人：旁观名额不算他们（0.14.0） */
     ownsRoom(st, userId) {
@@ -1666,6 +1781,31 @@ function sameGroup(before, seat, after) {
 function validHost(code, host) {
     return ROOM_CODE_RE.test(code) && !!host && typeof host.userId === 'string' && !!host.userId && typeof host.name === 'string';
 }
+/** 打完、关房时要还谁的名额：匹配桌是排进来的每个人，好友房是房主 */
+function releaseOf(st) {
+    return { users: st.match ? [...st.match.users] : [st.host], code: st.code };
+}
+/** 匹配桌的人：1 到 count 个、userId 不重复、各自像个身份 */
+function validPlayers(code, players, count) {
+    if (!Array.isArray(players) || players.length < 1 || players.length > count)
+        return false;
+    if (!players.every((p) => validHost(code, p)))
+        return false;
+    return new Set(players.map((p) => p.userId)).size === players.length;
+}
+function validSeats(order, n, count) {
+    return Array.isArray(order) && order.length === n && new Set(order).size === n && order.every((x) => Number.isInteger(x) && x >= 0 && x < count);
+}
+/** 从 0..count-1 里随机挑 n 个座位（crypto；房间里的随机，不是规则核心） */
+function randomSeats(n, count) {
+    const all = Array.from({ length: count }, (_, i) => i);
+    const r = crypto.getRandomValues(new Uint32Array(count));
+    for (let i = count - 1; i > 0; i--) {
+        const j = r[i] % (i + 1);
+        [all[i], all[j]] = [all[j], all[i]];
+    }
+    return all.slice(0, n);
+}
 function emptySeat() {
     return { kind: 'empty', userId: null, name: null, awaySince: null, auto: false, lastMoveId: null };
 }