@zhin.js/plugin-blackjack 0.0.0

package/src/index.ts

@@ -0,0 +1,36 @@
+import { Cron, formatCompact, usePlugin, type DatabaseFeature } from 'zhin.js';
+import { registerModels } from './models.js';
+import {
+  createServices,
+  resolveGameDatabase,
+  type SessionService,
+} from './session-service.js';
+import { registerCommands, registerInteractive, registerTextFallback } from './commands.js';
+import { registerBjHub } from './hub-register.js';
+
+const plugin = usePlugin();
+const { logger, useContext, addCron } = plugin;
+
+registerModels(plugin);
+
+let services: SessionService | null = null;
+
+useContext('database', (dbFeature: DatabaseFeature) => {
+  services = createServices(resolveGameDatabase(dbFeature));
+  logger.info(formatCompact({ 模块: '21点', 数据模型: '已就绪' }));
+});
+
+registerBjHub(() => services);
+registerCommands(plugin, () => services);
+registerInteractive(plugin, () => services);
+registerTextFallback(plugin, () => services);
+
+addCron(
+  new Cron('0 */15 * * * *', async () => {
+    if (!services) return;
+    const n = await services.abortStale(30 * 60 * 1000);
+    if (n > 0) logger.debug(formatCompact({ '21点': '清理超时局', count: n }));
+  }),
+);
+
+logger.info(formatCompact({ 模块: '21点', 状态: '已加载' }));

package/src/models.ts

@@ -0,0 +1,47 @@
+import type { Models, Plugin } from 'zhin.js';
+
+export type BjSessionStatus = 'active' | 'won' | 'lost' | 'draw' | 'aborted';
+
+declare module 'zhin.js' {
+  interface Models {
+    bj_sessions: {
+      id: string;
+      adapter: string;
+      endpoint: string;
+      channel_type: string;
+      channel_id: string;
+      channel_key: string;
+      player_id: string;
+      player_name: string;
+      deck_json: string;
+      player_cards_json: string;
+      dealer_cards_json: string;
+      board_message_id: string;
+      status: BjSessionStatus;
+      updated_at: number;
+      created_at: number;
+    };
+  }
+}
+
+export type BjSessionRow = Models['bj_sessions'];
+
+export function registerModels(plugin: Plugin): void {
+  plugin.defineModel('bj_sessions', {
+    id: { type: 'text', primary: true },
+    adapter: { type: 'text', nullable: false },
+    endpoint: { type: 'text', nullable: false },
+    channel_type: { type: 'text', nullable: false },
+    channel_id: { type: 'text', nullable: false },
+    channel_key: { type: 'text', nullable: false },
+    player_id: { type: 'text', nullable: false },
+    player_name: { type: 'text', default: '' },
+    deck_json: { type: 'text', default: '[]' },
+    player_cards_json: { type: 'text', default: '[]' },
+    dealer_cards_json: { type: 'text', default: '[]' },
+    board_message_id: { type: 'text', default: '' },
+    status: { type: 'text', default: 'active' },
+    updated_at: { type: 'integer', default: 0 },
+    created_at: { type: 'integer', default: 0 },
+  });
+}

package/src/session-service.ts

@@ -0,0 +1,118 @@
+import type { Database, DatabaseFeature, Message, Models, RelatedModel } from 'zhin.js';
+import { channelKey, generateSessionId } from '@zhin.js/game-shared';
+import type { BjSessionRow } from './models.js';
+import { freshDeck } from './engine.js';
+
+export type BjDatabase = Database<unknown, Models, string>;
+
+function getModel(db: BjDatabase): RelatedModel<unknown, Models, 'bj_sessions'> {
+  const model = db.models.get('bj_sessions');
+  if (!model) throw new Error('bj_sessions not registered');
+  return model as RelatedModel<unknown, Models, 'bj_sessions'>;
+}
+
+export function resolveGameDatabase(feature: DatabaseFeature): BjDatabase {
+  return feature.db;
+}
+
+export class SessionService {
+  constructor(private readonly db: BjDatabase) {}
+
+  async createSession(message: Message<any>): Promise<BjSessionRow> {
+    const deck = freshDeck();
+    const playerCards = [deck.pop()!, deck.pop()!];
+    const dealerCards = [deck.pop()!, deck.pop()!];
+    const now = Date.now();
+    const row: BjSessionRow = {
+      id: generateSessionId(),
+      adapter: String(message.$adapter),
+      endpoint: message.$endpoint,
+      channel_type: message.$channel.type,
+      channel_id: message.$channel.id,
+      channel_key: channelKey(message),
+      player_id: message.$sender.id,
+      player_name: String(message.$sender.name ?? message.$sender.id),
+      deck_json: JSON.stringify(deck),
+      player_cards_json: JSON.stringify(playerCards),
+      dealer_cards_json: JSON.stringify(dealerCards),
+      board_message_id: '',
+      status: 'active',
+      updated_at: now,
+      created_at: now,
+    };
+    await getModel(this.db).create(row);
+    return row;
+  }
+
+  async getById(id: string): Promise<BjSessionRow | null> {
+    return getModel(this.db).findOne({ id });
+  }
+
+  async getActiveForUser(channelKeyValue: string, userId: string): Promise<BjSessionRow | null> {
+    const rows = await getModel(this.db).findAll({
+      channel_key: channelKeyValue,
+      player_id: userId,
+      status: 'active',
+    });
+    return rows[0] ?? null;
+  }
+
+  async getActiveByChannel(channelKeyValue: string): Promise<BjSessionRow | null> {
+    const rows = await getModel(this.db).findAll({
+      channel_key: channelKeyValue,
+      status: 'active',
+    });
+    return rows[0] ?? null;
+  }
+
+  async getActiveByBoardMessageId(messageId: string): Promise<BjSessionRow | null> {
+    const rows = await getModel(this.db).findAll({
+      board_message_id: messageId,
+      status: 'active',
+    });
+    return rows[0] ?? null;
+  }
+
+  async updateSession(id: string, patch: Partial<BjSessionRow>): Promise<void> {
+    await getModel(this.db).updateWhere({ id }, { ...patch, updated_at: Date.now() });
+  }
+
+  async abortStale(maxAgeMs: number): Promise<number> {
+    const cutoff = Date.now() - maxAgeMs;
+    const model = getModel(this.db);
+    const rows = await model.findAll({ status: 'active' });
+    let n = 0;
+    for (const row of rows) {
+      if (row.updated_at < cutoff) {
+        await model.updateWhere({ id: row.id }, { status: 'aborted', updated_at: Date.now() });
+        n++;
+      }
+    }
+    return n;
+  }
+}
+
+export function createServices(db: BjDatabase): SessionService {
+  return new SessionService(db);
+}
+
+function parseJsonStringArray(value: string | string[] | unknown): string[] {
+  if (Array.isArray(value)) return value.filter((x): x is string => typeof x === 'string');
+  if (typeof value !== 'string' || !value) return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed)
+      ? parsed.filter((x): x is string => typeof x === 'string')
+      : [];
+  } catch {
+    return [];
+  }
+}
+
+export function parseCards(json: string | string[]): string[] {
+  return parseJsonStringArray(json);
+}
+
+export function parseDeck(json: string | string[]): string[] {
+  return parseJsonStringArray(json);
+}

package/src/view.ts

@@ -0,0 +1,70 @@
+import { buildChoiceKeyboard } from '@zhin.js/game-shared';
+import type { SendContent } from 'zhin.js';
+import { BJ_PREFIX, formatHand, handValue, isBlackjack, TARGET } from './engine.js';
+import type { BjSessionRow } from './models.js';
+import { parseCards } from './session-service.js';
+
+export function buildBjView(
+  session: BjSessionRow,
+  terminal = false,
+  revealDealer = false,
+  channelType?: string,
+): SendContent {
+  const player = parseCards(session.player_cards_json);
+  const dealer = parseCards(session.dealer_cards_json);
+  const lines = [
+    '🃏 **21 点**',
+    '',
+    `你的牌：${formatHand(player)}`,
+    `庄家：${revealDealer || terminal ? formatHand(dealer) : formatHand(dealer, true)}`,
+    '',
+  ];
+
+  if (terminal) {
+    if (session.status === 'won') lines.push('🎉 **你赢了！**');
+    else if (session.status === 'lost') lines.push('💀 **你输了**');
+    else lines.push('🤝 **平局**');
+    lines.push('', '点击「再来一局」或发送 `/21点 开始`');
+  } else {
+    lines.push(`目标：尽量接近 ${TARGET} 且不超过。`);
+  }
+
+  const choices = terminal
+    ? [{ id: 'restart', label: '🔄 再来一局', style: 'primary' as const, keepEnabledWhenTerminal: true }]
+    : [
+        { id: 'hit', label: '➕ 要牌', style: 'primary' as const },
+        { id: 'stand', label: '✋ 停牌', style: 'secondary' as const },
+      ];
+
+  return buildChoiceKeyboard({
+    gamePrefix: BJ_PREFIX,
+    sessionId: session.id,
+    narrative: lines.join('\n'),
+    choices,
+    terminal,
+    fallbackHint: terminal ? '回复 1 再来一局' : '1 要牌 · 2 停牌',
+    interactionProfile: terminal ? 'terminal' : 'gameplay',
+    channelType,
+  });
+}
+
+export function checkNaturalBlackjack(session: BjSessionRow): boolean {
+  const player = parseCards(session.player_cards_json);
+  const dealer = parseCards(session.dealer_cards_json);
+  return isBlackjack(player) || isBlackjack(dealer);
+}
+
+export function naturalOutcome(session: BjSessionRow): 'won' | 'lost' | 'draw' | null {
+  const player = parseCards(session.player_cards_json);
+  const dealer = parseCards(session.dealer_cards_json);
+  const pbj = isBlackjack(player);
+  const dbj = isBlackjack(dealer);
+  if (!pbj && !dbj) return null;
+  if (pbj && dbj) return 'draw';
+  if (pbj) return 'won';
+  return 'lost';
+}
+
+export function playerBust(session: BjSessionRow): boolean {
+  return handValue(parseCards(session.player_cards_json)) > TARGET;
+}