@zhin.js/plugin-roulette 0.0.0-stage → 0.1.2

package/lib/session-service.js

@@ -0,0 +1,167 @@
+import { VersionedSessionService, channelKey, generateCompactId, secureRandomInt, } from '@zhin.js/game-kit';
+import { cancelGame, createLobby, currentPlayer, decodeRouletteState, expireLobby, expireTurn, isOpen, joinLobby, leaveGame, pullTrigger, startRound, } from './engine.js';
+export class RouletteSessionService extends VersionedSessionService {
+    #chooseBulletChamber;
+    constructor(database, options = {}) {
+        super(database, {
+            gameId: 'roulette',
+            table: 'roulette_sessions',
+            userFields: ['host_id'],
+            projectOutcomes: projectRouletteOutcomes,
+        });
+        this.#chooseBulletChamber = options.chooseBulletChamber ?? secureRandomInt;
+    }
+    async createLobby(message, endpoint, config) {
+        const now = Date.now();
+        const host = playerFromMessage(message);
+        const state = createLobby(host, tableRules(config));
+        return this.createRow({
+            id: generateCompactId('rlt_'),
+            adapter: String(message.$adapter),
+            endpoint: message.$endpoint,
+            channel_type: message.$channel.type,
+            channel_id: message.$channel.id,
+            channel_key: channelKey(message),
+            endpoint_adapter: endpoint.adapter,
+            endpoint_id: endpoint.id,
+            host_id: host.id,
+            state_json: JSON.stringify(state),
+            phase: state.phase,
+            turn: '',
+            revision: 0,
+            processed_actions: '[]',
+            deadline_at: now + config.lobbyTimeoutSeconds * 1000,
+            status: 'active',
+            updated_at: now,
+            created_at: now,
+        });
+    }
+    /** Every seated player counts as busy, not just the host. */
+    async getActiveForUser(channelKeyValue, userId) {
+        const rows = await this.model.findAll({ channel_key: channelKeyValue, status: 'active' });
+        const seated = rows.find((row) => decodeRouletteState(row.state_json).players.some((player) => player.id === userId));
+        return seated ?? null;
+    }
+    async applyAction(session, actorId, action, config) {
+        if (action.type === 'join') {
+            await this.assertPlayersAvailable(session.channel_key, [action.player.id]);
+        }
+        const result = await this.mutateSession(session.id, {
+            actionId: `${session.id}:${session.revision}:${actorId}:${action.type}`,
+            expectedRevision: session.revision,
+            apply: (current) => {
+                const before = decodeRouletteState(current.state_json);
+                const after = this.#transition(before, actorId, action, config);
+                return rowPatch(after, config, Date.now());
+            },
+        });
+        return {
+            session: result.session,
+            state: decodeRouletteState(result.session.state_json),
+            applied: result.kind === 'applied',
+        };
+    }
+    /** Open sessions whose lobby or turn deadline has passed. */
+    async listOverdue(now) {
+        const rows = await this.model.findAll({ status: 'active' });
+        return rows.filter((row) => row.deadline_at > 0 && row.deadline_at <= now);
+    }
+    #transition(state, actorId, action, config) {
+        switch (action.type) {
+            case 'join':
+                return joinLobby(state, action.player, tableRules(config));
+            case 'start':
+                return startRound(state, actorId, this.#chooseBulletChamber(state.chamberCount));
+            case 'fire':
+                return pullTrigger(state, actorId).state;
+            case 'leave':
+                return leaveGame(state, actorId);
+            case 'cancel':
+                return cancelGame(state);
+            case 'expire':
+                return state.phase === 'lobby' ? expireLobby(state) : expireTurn(state);
+        }
+    }
+}
+/** Per-group switches. The mute penalty is off until a group turns it on. */
+export class RouletteGroupSettings {
+    #model;
+    constructor(database) {
+        const model = database.models.get('roulette_group_settings');
+        if (!model)
+            throw new Error('roulette_group_settings not registered');
+        this.#model = model;
+    }
+    async isMutePenaltyEnabled(channelKeyValue) {
+        const row = await this.#model.findOne({ id: channelKeyValue });
+        return row?.mute_penalty === 1;
+    }
+    async setMutePenalty(channelKeyValue, enabled, actorId) {
+        const patch = {
+            mute_penalty: enabled ? 1 : 0,
+            updated_by: actorId,
+            updated_at: Date.now(),
+        };
+        const existing = await this.#model.findOne({ id: channelKeyValue });
+        if (existing) {
+            await this.#model.updateWhere({ id: channelKeyValue }, patch);
+            return;
+        }
+        await this.#model.create({ id: channelKeyValue, ...patch });
+    }
+}
+export function createServices(database, options = {}) {
+    return {
+        sessions: new RouletteSessionService(database, options),
+        settings: new RouletteGroupSettings(database),
+    };
+}
+export function stateOf(session) {
+    return decodeRouletteState(session.state_json);
+}
+export function playerFromMessage(message) {
+    const name = message.$sender.name?.trim() || message.$sender.id;
+    return { id: message.$sender.id, name };
+}
+function tableRules(config) {
+    return { chamberCount: config.chambers, maxPlayers: config.maxPlayers };
+}
+function rowPatch(state, config, now) {
+    return {
+        state_json: JSON.stringify(state),
+        phase: state.phase,
+        turn: currentPlayer(state)?.id ?? '',
+        host_id: state.hostId,
+        deadline_at: deadlineFor(state, config, now),
+        status: statusFor(state),
+    };
+}
+function deadlineFor(state, config, now) {
+    if (state.phase === 'playing')
+        return now + config.turnTimeoutSeconds * 1000;
+    if (state.phase === 'lobby')
+        return now + config.lobbyTimeoutSeconds * 1000;
+    return 0;
+}
+function statusFor(state) {
+    if (isOpen(state))
+        return 'active';
+    if (state.phase === 'finished')
+        return 'finished';
+    return 'aborted';
+}
+/** Survivors win one point each; the loser records a loss. Aborted games record nothing. */
+function projectRouletteOutcomes(session) {
+    if (session.status !== 'finished')
+        return [];
+    const state = decodeRouletteState(session.state_json);
+    return state.players.map((player) => {
+        const lost = player.id === state.loserId;
+        return {
+            userId: player.id,
+            userName: player.name,
+            result: lost ? 'lost' : 'won',
+            score: lost ? 0 : 1,
+        };
+    });
+}

package/lib/view.d.ts

@@ -0,0 +1,10 @@
+import type { RouletteConfig } from './config.js';
+import { type RoulettePlayer, type RouletteState } from './engine.js';
+export declare const ROULETTE_TITLE = "\uD83D\uDD2B \u4FC4\u7F57\u65AF\u8F6E\u76D8";
+export declare function describeLobby(state: RouletteState, config: RouletteConfig): string;
+export declare function describeRoundStart(state: RouletteState, config: RouletteConfig): string;
+export declare function describeTurn(state: RouletteState, config: RouletteConfig): string;
+export declare function describeClick(shooter: RoulettePlayer, state: RouletteState, config: RouletteConfig): string;
+export declare function describeEnding(state: RouletteState): string;
+export declare function describeAbort(state: RouletteState): string;
+export declare function describeStatus(state: RouletteState, config: RouletteConfig): string;

package/lib/view.js

@@ -0,0 +1,73 @@
+import { MIN_ROULETTE_PLAYERS, currentPlayer, loserOf, remainingChambers, survivorsOf, } from './engine.js';
+export const ROULETTE_TITLE = '🔫 俄罗斯轮盘';
+export function describeLobby(state, config) {
+    const host = state.players.find((player) => player.id === state.hostId);
+    const lines = [
+        `${ROULETTE_TITLE} · 等待玩家（${state.players.length}/${config.maxPlayers}）`,
+        `玩家：${listNames(state.players)}`,
+        `发送「轮盘 加入」上桌；${host?.name ?? '房主'} 发送「轮盘 开始」开局（至少 ${MIN_ROULETTE_PLAYERS} 人）。`,
+        `${config.lobbyTimeoutSeconds} 秒内没有开始会自动解散。`,
+    ];
+    return lines.join('\n');
+}
+export function describeRoundStart(state, config) {
+    const order = state.players.map((player, index) => `${index + 1}. ${player.name}`);
+    const lines = [
+        `${ROULETTE_TITLE} · 开局！${state.chamberCount} 个弹巢里装了 1 发子弹，已转好弹巢。`,
+        '开枪顺序：',
+        ...order,
+        describeTurn(state, config),
+    ];
+    return lines.join('\n');
+}
+export function describeTurn(state, config) {
+    const shooter = currentPlayer(state);
+    if (!shooter)
+        return '';
+    return `👉 轮到 ${shooter.name}：发送「开枪」，${config.turnTimeoutSeconds} 秒内不开枪判负。`
+        + `（剩余 ${remainingChambers(state)} 个弹巢）`;
+}
+export function describeClick(shooter, state, config) {
+    return [`咔哒……${shooter.name} 的这一枪是空膛。`, describeTurn(state, config)].join('\n');
+}
+export function describeEnding(state) {
+    const loser = loserOf(state);
+    if (!loser)
+        return describeAbort(state);
+    const headline = endingHeadline(state, loser);
+    const survivors = survivorsOf(state);
+    return [
+        headline,
+        `🏆 幸存：${listNames(survivors)}（各 +1 胜）`,
+        '发送「排行 轮盘」查看本群排行。',
+    ].join('\n');
+}
+export function describeAbort(state) {
+    if (state.endReason === 'lobby-expired')
+        return `${ROULETTE_TITLE} 长时间没有开始，已自动解散。`;
+    if (state.endReason === 'lobby-empty')
+        return `${ROULETTE_TITLE} 所有人都离开了，已解散。`;
+    return `${ROULETTE_TITLE} 已取消，本局不计分。`;
+}
+export function describeStatus(state, config) {
+    if (state.phase === 'lobby')
+        return describeLobby(state, config);
+    const lines = [
+        `${ROULETTE_TITLE} · 进行中，已开 ${state.pullsMade} 枪`,
+        `玩家：${listNames(state.players)}`,
+        describeTurn(state, config),
+    ];
+    return lines.join('\n');
+}
+function endingHeadline(state, loser) {
+    if (state.endReason === 'turn-timeout')
+        return `⌛ ${loser.name} 超时没有开枪，判负！`;
+    if (state.endReason === 'forfeit')
+        return `🏳️ ${loser.name} 中途离场，判负！`;
+    return `💥 砰！${loser.name} 中弹出局（第 ${state.pullsMade} 枪）。`;
+}
+function listNames(players) {
+    if (players.length === 0)
+        return '无';
+    return players.map((player) => player.name).join('、');
+}

package/middlewares/roulette-alias/index.js

@@ -0,0 +1,10 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { defineGameCommandAliasMiddleware } from '@zhin.js/game-kit';
+import { runRouletteCommand } from "../../lib/roulette-command.js";
+/** `轮盘 加入` / `/轮盘赌 开枪` / `roulette start` route to the same logic as the command. */
+export default defineGameCommandAliasMiddleware({
+    aliases: ['轮盘', '轮盘赌', 'roulette'],
+    async run(action, input, context) {
+        return runRouletteCommand(context, input, action);
+    },
+});

package/middlewares/roulette-fire/index.js

@@ -0,0 +1,30 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { channelKey, messageFromCommandInput } from '@zhin.js/game-kit';
+import { defineMiddleware } from 'zhin.js/middleware';
+import { runRouletteCommand } from "../../lib/roulette-command.js";
+import { rouletteServicesToken } from "../../lib/runtime.js";
+const FIRE_WORDS = ['开枪', '扣动扳机'];
+/**
+ * A bare 「开枪」 fires only for the player whose turn it is in this group,
+ * so the word stays ordinary chat everywhere else.
+ */
+export default defineMiddleware({
+    target: 'inbound',
+    async handle(context, next) {
+        const text = context.input.content?.trim() ?? '';
+        if (!FIRE_WORDS.includes(text)) {
+            await next();
+            return;
+        }
+        const message = messageFromCommandInput(context.input);
+        const services = context.use(rouletteServicesToken);
+        const session = await services.sessions.getActiveByChannel(channelKey(message));
+        if (!session || session.turn !== message.$sender.id) {
+            await next();
+            return;
+        }
+        const reply = await runRouletteCommand(context, context.input, 'fire');
+        if (reply)
+            await context.input.$reply(reply);
+    },
+});

package/package.json

@@ -1,6 +1,103 @@
 {
   "name": "@zhin.js/plugin-roulette",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.2",
+  "description": "Zhin.js 俄罗斯轮盘 — 多人轮流开枪，可按群开启禁言惩罚 (Plugin Runtime)",
+  "type": "module",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "plugin.js",
+    "schema.json",
+    "commands/**/*.js",
+    "middlewares/**/*.js",
+    "schedules/**/*.js",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "zhin",
+    "zhin.js",
+    "game",
+    "roulette"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@zhin.js/core": "1.1.48",
+    "@zhin.js/game-kit": "1.1.13"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10",
+    "@zhin.js/schedule-feature": "1.1.7",
+    "@zhin.js/testing": "1.0.5",
+    "zhin.js": "1.1.13"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zhinjs/zhin.git",
+    "directory": "plugins/games/roulette"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "zhin": {
+    "protocol": 1,
+    "type": "plugin",
+    "entry": "./plugin.js",
+    "engine": "^1.0.0",
+    "runtime": "trusted",
+    "features": [
+      {
+        "package": "@zhin.js/command",
+        "api": "^1.0.0"
+      },
+      {
+        "package": "@zhin.js/middleware",
+        "api": "^1.0.0"
+      },
+      {
+        "package": "@zhin.js/game-kit",
+        "api": "^1.0.0"
+      },
+      {
+        "package": "@zhin.js/schedule-feature",
+        "api": "^1.0.0"
+      }
+    ],
+    "plugins": []
+  },
+  "peerDependencies": {
+    "@zhin.js/command": "^1.1.9",
+    "@zhin.js/middleware": "^1.1.8",
+    "zhin.js": "^1.1.13",
+    "@zhin.js/schedule-feature": "^1.1.7"
+  },
+  "peerDependenciesMeta": {
+    "@zhin.js/command": {
+      "optional": true
+    },
+    "@zhin.js/middleware": {
+      "optional": true
+    },
+    "@zhin.js/schedule-feature": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf lib",
+    "test": "NODE_OPTIONS=--experimental-strip-types vitest run --root ../../.. plugins/games/roulette/tests"
+  }
 }

package/plugin.js

@@ -0,0 +1,39 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { defineGamePlugin } from '@zhin.js/game-kit';
+import { ROULETTE_TABLES, defineHostTables } from "./lib/models.js";
+import { rouletteServicesToken } from "./lib/runtime.js";
+import { createServices, } from "./lib/session-service.js";
+/**
+ * Plugin Runtime wiring:
+ * - `commands/roulette` and the `轮盘` alias middleware share one action runner.
+ * - `middlewares/roulette-fire` lets the player on turn just say 「开枪」.
+ * - Sessions use the host database when installed, otherwise memory.
+ * - `schedules/deadlines` enforces turn and lobby timeouts and posts the result.
+ * - Results feed game-hub records, so 「战绩」 and 「排行 轮盘」 work.
+ */
+export default defineGamePlugin({
+    name: 'roulette',
+    metadata: {
+        displayName: 'Russian Roulette',
+    },
+    game: {
+        id: 'roulette',
+        title: '俄罗斯轮盘',
+        icon: '🔫',
+        description: '多人轮流开枪，中弹者输；可按群开启禁言惩罚',
+        commandPrefix: '/轮盘',
+        quickStart: '开局',
+        aliases: ['轮盘赌', 'roulette'],
+        menus: [
+            { id: 'open', label: '🎮 开局' },
+            { id: 'join', label: '🙋 加入' },
+            { id: 'help', label: '📖 玩法说明' },
+        ],
+    },
+    tables: ROULETTE_TABLES,
+    servicesToken: rouletteServicesToken,
+    defineHostTables,
+    createServices: (database) => createServices(database),
+    session: (services) => services.sessions,
+    stale: false,
+});

package/schedules/deadlines/index.js

@@ -0,0 +1,8 @@
+// Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { defineSchedule } from '@zhin.js/schedule-feature';
+import { DEADLINE_CRON, runDeadlineSweep } from "../../lib/deadline-job.js";
+export default defineSchedule({
+    cron: DEADLINE_CRON,
+    description: '结束超时未开枪的回合和无人开始的房间',
+    execute: (context) => runDeadlineSweep(context, Date.now()),
+});

package/schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "chambers": {
+      "type": "integer",
+      "minimum": 2,
+      "maximum": 12,
+      "default": 6,
+      "description": "弹巢数量，其中一发是实弹"
+    },
+    "maxPlayers": {
+      "type": "integer",
+      "minimum": 2,
+      "maximum": 10,
+      "default": 6,
+      "description": "单局最多玩家数"
+    },
+    "turnTimeoutSeconds": {
+      "type": "integer",
+      "minimum": 10,
+      "maximum": 600,
+      "default": 60,
+      "description": "轮到的玩家超过这个秒数不开枪，判负"
+    },
+    "lobbyTimeoutSeconds": {
+      "type": "integer",
+      "minimum": 30,
+      "maximum": 3600,
+      "default": 300,
+      "description": "开局后超过这个秒数仍未开始，自动解散"
+    },
+    "muteSeconds": {
+      "type": "integer",
+      "minimum": 10,
+      "maximum": 3600,
+      "default": 60,
+      "description": "开启禁言惩罚的群里，输家被禁言的秒数（每个群默认关闭）"
+    }
+  }
+}