fraq-plugin-doudizhu 0.1.0

package/README.md

@@ -0,0 +1,7 @@
+# fraq-plugin-template
+
+用于开发 Fraq 插件的模板仓库。包含了：
+
+- TypeScript 配置（`tsconfig.json`）
+- Biome 配置（`biome.json`），用于代码格式化和 linting
+- 简单的测试脚本，可以通过 `npx tsx test/smoke.ts` 运行

package/dist/index.d.mts

@@ -0,0 +1,143 @@
+//#region src/cards.d.ts
+type Suit = 'Club' | 'Diamond' | 'Heart' | 'Spade' | 'Joker';
+type Rank = '3' | '4' | '5' | '6' | '7' | '8' | '9' | '10' | 'J' | 'Q' | 'K' | 'A' | '2' | 'SJ' | 'BJ';
+interface Card {
+  readonly id: string;
+  readonly suit: Suit;
+  readonly rank: Rank;
+  readonly value: number;
+  readonly label: string;
+  readonly imageName: string;
+}
+//#endregion
+//#region src/rules.d.ts
+type PlayKind = 'single' | 'pair' | 'triple' | 'triple-single' | 'triple-pair' | 'straight' | 'pair-straight' | 'airplane' | 'airplane-single' | 'airplane-pair' | 'bomb' | 'rocket';
+interface Play {
+  readonly cards: Card[];
+  readonly kind: PlayKind;
+  readonly mainValue: number;
+  readonly length: number;
+}
+//#endregion
+//#region src/game.d.ts
+type GamePhase = 'bidding' | 'doubling' | 'playing' | 'finished';
+type PlayerKind = 'human' | 'bot';
+interface Player {
+  readonly id: string;
+  readonly kind: PlayerKind;
+  readonly name: string;
+  hand: Card[];
+  bid: number;
+  bidChoice?: 0 | 1 | 2 | 3;
+  multiplier: number;
+  doubleChoice?: 0 | 1 | 2;
+}
+interface GameSnapshot {
+  readonly phase: GamePhase;
+  readonly currentPlayer: number;
+  readonly landlordIndex?: number;
+  readonly highestBid: number;
+  readonly multiplier: number;
+  readonly players: readonly Player[];
+  readonly bottom: readonly Card[];
+  readonly previousPlay?: Play;
+  readonly lastPlayer?: number;
+}
+type GameAction = {
+  type: 'bid';
+  level: 0 | 1 | 2 | 3;
+} | {
+  type: 'double';
+  level: 0 | 1 | 2;
+} | {
+  type: 'play';
+  cards: string;
+} | {
+  type: 'pass';
+};
+type GameEvent = {
+  type: 'message';
+  text: string;
+} | {
+  type: 'hand';
+  playerId: string;
+  cards: Card[];
+  text: string;
+} | {
+  type: 'played';
+  playerId: string;
+  cards: Card[];
+  text: string;
+} | {
+  type: 'turn';
+  playerId: string;
+  text: string;
+} | {
+  type: 'finished';
+  winnerId: string;
+  text: string;
+} | {
+  type: 'expired';
+  text: string;
+};
+interface GameOptions {
+  readonly timeoutMs: number;
+  readonly random?: () => number;
+  readonly onExpired?: () => void | Promise<void>;
+}
+declare class DoudizhuGame {
+  readonly players: [Player, Player, Player];
+  readonly bottom: Card[];
+  phase: GamePhase;
+  currentPlayer: number;
+  landlordIndex?: number;
+  highestBid: number;
+  multiplier: number;
+  previousPlay?: Play;
+  lastPlayer?: number;
+  private passCount;
+  private bidRound;
+  private timeoutHandle?;
+  private readonly options;
+  constructor(humanId: string, humanName: string, options: GameOptions);
+  get snapshot(): GameSnapshot;
+  dispose(): void;
+  begin(): Promise<GameEvent[]>;
+  act(playerId: string, action: GameAction): Promise<GameEvent[]>;
+  private applyBid;
+  private finishBidding;
+  private applyDouble;
+  private applyPass;
+  private applyPlay;
+  private advanceBots;
+  private resetTimeout;
+  private clearTimeout;
+}
+interface Room {
+  readonly id: number;
+  readonly humanId: string;
+  readonly game: DoudizhuGame;
+}
+declare class RoomManager {
+  private readonly maxRooms;
+  private readonly gameOptions;
+  private readonly onExpired?;
+  private readonly rooms;
+  private nextId;
+  constructor(maxRooms: number, gameOptions: GameOptions, onExpired?: ((room: Room) => void | Promise<void>) | undefined);
+  create(humanId: string, humanName: string): Room;
+  getByHuman(humanId: string): Room | undefined;
+  get(roomId: number): Room | undefined;
+  remove(roomId: number): void;
+  list(): readonly Room[];
+}
+//#endregion
+//#region src/index.d.ts
+interface DoudizhuOptions {
+  readonly maxRooms?: number;
+  readonly turnTimeoutMs?: number;
+  readonly imageDirectory?: string;
+}
+declare const _default: import("@fraqjs/fraq").PluginDefinition<[options?: DoudizhuOptions | undefined]>;
+//#endregion
+export { DoudizhuOptions, RoomManager, _default as default };

package/dist/index.mjs

@@ -0,0 +1,844 @@
+import { definePlugin, param, seg } from "@fraqjs/fraq";
+import sharp from "sharp";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+//#region src/card-image.ts
+const CARD_WIDTH = 120;
+const CARD_HEIGHT = Math.round(1044 / 750 * CARD_WIDTH);
+const CARD_OVERLAP = 50;
+var CardImageRenderer = class {
+	cache = /* @__PURE__ */ new Map();
+	imageDirectory;
+	constructor(options = {}) {
+		this.imageDirectory = path.resolve(options.imageDirectory ?? path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../image"));
+	}
+	async render(cards) {
+		if (cards.length === 0) throw new Error("不能拼接空牌面。");
+		const key = cards.map((card) => card.id).join("|");
+		const cached = this.cache.get(key);
+		if (cached) return cached;
+		const width = CARD_WIDTH + (cards.length - 1) * CARD_OVERLAP + 16;
+		const height = 183;
+		const composites = await Promise.all(cards.map(async (card, index) => ({
+			input: await sharp(path.join(this.imageDirectory, card.imageName)).resize(CARD_WIDTH, CARD_HEIGHT, { fit: "fill" }).png().toBuffer(),
+			left: 8 + index * CARD_OVERLAP,
+			top: 8
+		})));
+		const uri = `base64://${(await sharp({ create: {
+			width,
+			height,
+			channels: 4,
+			background: {
+				r: 0,
+				g: 0,
+				b: 0,
+				alpha: 0
+			}
+		} }).composite(composites).png().toBuffer()).toString("base64")}`;
+		this.cache.set(key, uri);
+		return uri;
+	}
+};
+//#endregion
+//#region src/cards.ts
+const SUITS = [
+	"Club",
+	"Diamond",
+	"Heart",
+	"Spade"
+];
+const RANKS = [
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"8",
+	"9",
+	"10",
+	"J",
+	"Q",
+	"K",
+	"A",
+	"2"
+];
+const RANK_VALUES = {
+	"3": 3,
+	"4": 4,
+	"5": 5,
+	"6": 6,
+	"7": 7,
+	"8": 8,
+	"9": 9,
+	"10": 10,
+	J: 11,
+	Q: 12,
+	K: 13,
+	A: 14,
+	"2": 15,
+	SJ: 16,
+	BJ: 17
+};
+function createDeck() {
+	const cards = [];
+	for (const suit of SUITS) for (const rank of RANKS) cards.push({
+		id: `${suit}-${rank}`,
+		suit,
+		rank,
+		value: RANK_VALUES[rank],
+		label: rank,
+		imageName: `${suit}${rank}.png`
+	});
+	cards.push({
+		id: "Joker-SJ",
+		suit: "Joker",
+		rank: "SJ",
+		value: RANK_VALUES.SJ,
+		label: "小王",
+		imageName: "JOKER-A.png"
+	}, {
+		id: "Joker-BJ",
+		suit: "Joker",
+		rank: "BJ",
+		value: RANK_VALUES.BJ,
+		label: "大王",
+		imageName: "JOKER-B.png"
+	});
+	return cards;
+}
+function sortCards(cards) {
+	return [...cards].sort((left, right) => left.value - right.value || left.id.localeCompare(right.id));
+}
+function shuffle(items, random = Math.random) {
+	const result = [...items];
+	for (let index = result.length - 1; index > 0; index -= 1) {
+		const swapIndex = Math.floor(random() * (index + 1));
+		[result[index], result[swapIndex]] = [result[swapIndex], result[index]];
+	}
+	return result;
+}
+function dealDeck(random = Math.random) {
+	const deck = shuffle(createDeck(), random);
+	return {
+		hands: [
+			sortCards(deck.slice(0, 17)),
+			sortCards(deck.slice(17, 34)),
+			sortCards(deck.slice(34, 51))
+		],
+		bottom: sortCards(deck.slice(51))
+	};
+}
+const TOKEN_ALIASES = {
+	"小王": "SJ",
+	SJ: "SJ",
+	"大王": "BJ",
+	BJ: "BJ",
+	3: "3",
+	4: "4",
+	5: "5",
+	6: "6",
+	7: "7",
+	8: "8",
+	9: "9",
+	10: "10",
+	J: "J",
+	j: "J",
+	Q: "Q",
+	q: "Q",
+	K: "K",
+	k: "K",
+	A: "A",
+	a: "A",
+	2: "2"
+};
+function tokenizeCards(input) {
+	return input.replace(/[，,、]+/g, " ").trim().split(/\s+/u).filter(Boolean);
+}
+function takeCardsFromHand(hand, input) {
+	const selected = [];
+	const remaining = [...hand];
+	for (const token of tokenizeCards(input)) {
+		const rank = TOKEN_ALIASES[token];
+		if (!rank) throw new Error(`无法识别牌面「${token}」，请使用 3-10、J、Q、K、A、2、小王或大王。`);
+		const index = remaining.findIndex((card) => card.rank === rank);
+		if (index === -1) throw new Error(`你的手牌中没有可出的「${token}」。`);
+		const [card] = remaining.splice(index, 1);
+		selected.push(card);
+	}
+	if (selected.length === 0) throw new Error("请在「出牌」后填写至少一张牌。");
+	return selected;
+}
+//#endregion
+//#region src/rules.ts
+function groups(cards) {
+	const map = /* @__PURE__ */ new Map();
+	for (const card of cards) {
+		const group = map.get(card.value) ?? [];
+		group.push(card);
+		map.set(card.value, group);
+	}
+	return [...map.entries()].sort(([left], [right]) => left - right).map(([value, groupedCards]) => ({
+		value,
+		cards: groupedCards
+	}));
+}
+function isConsecutive(values, minimumLength) {
+	return values.length >= minimumLength && values.every((value, index) => index === 0 || value === values[index - 1] + 1 && value < 15);
+}
+function findTripleSequence(grouped) {
+	const triples = grouped.filter((group) => group.cards.length >= 3 && group.value < 15).map((group) => group.value);
+	if (triples.length < 2 || !isConsecutive(triples, 2)) return;
+	return triples;
+}
+function analyzePlay(cards) {
+	if (cards.length === 0) return void 0;
+	const sorted = sortCards(cards);
+	const grouped = groups(sorted);
+	const counts = grouped.map((group) => group.cards.length).sort((left, right) => left - right);
+	const values = grouped.map((group) => group.value);
+	if (sorted.length === 2 && values[0] === 16 && values[1] === 17) return {
+		cards: sorted,
+		kind: "rocket",
+		mainValue: 17,
+		length: 1
+	};
+	if (sorted.length === 4 && counts.length === 1) return {
+		cards: sorted,
+		kind: "bomb",
+		mainValue: grouped[0].value,
+		length: 1
+	};
+	if (sorted.length === 1) return {
+		cards: sorted,
+		kind: "single",
+		mainValue: sorted[0].value,
+		length: 1
+	};
+	if (sorted.length === 2 && counts.length === 1) return {
+		cards: sorted,
+		kind: "pair",
+		mainValue: grouped[0].value,
+		length: 1
+	};
+	if (sorted.length === 3 && counts.length === 1) return {
+		cards: sorted,
+		kind: "triple",
+		mainValue: grouped[0].value,
+		length: 1
+	};
+	if (sorted.length === 4 && counts.length === 2 && counts[1] === 3) return {
+		cards: sorted,
+		kind: "triple-single",
+		mainValue: grouped.find((group) => group.cards.length === 3).value,
+		length: 1
+	};
+	if (sorted.length === 5 && counts.length === 2 && counts[0] === 2 && counts[1] === 3) return {
+		cards: sorted,
+		kind: "triple-pair",
+		mainValue: grouped.find((group) => group.cards.length === 3).value,
+		length: 1
+	};
+	if (counts.every((count) => count === 1) && isConsecutive(values, 5)) return {
+		cards: sorted,
+		kind: "straight",
+		mainValue: values.at(-1),
+		length: values.length
+	};
+	if (counts.every((count) => count === 2) && isConsecutive(values, 3)) return {
+		cards: sorted,
+		kind: "pair-straight",
+		mainValue: values.at(-1),
+		length: values.length
+	};
+	const tripleSequence = findTripleSequence(grouped);
+	if (tripleSequence && tripleSequence.length * 3 === sorted.length) return {
+		cards: sorted,
+		kind: "airplane",
+		mainValue: tripleSequence.at(-1),
+		length: tripleSequence.length
+	};
+	if (tripleSequence && tripleSequence.length * 4 === sorted.length) {
+		if (grouped.filter((group) => !tripleSequence.includes(group.value)).every((group) => group.cards.length === 1)) return {
+			cards: sorted,
+			kind: "airplane-single",
+			mainValue: tripleSequence.at(-1),
+			length: tripleSequence.length
+		};
+	}
+	if (tripleSequence && tripleSequence.length * 5 === sorted.length) {
+		if (grouped.filter((group) => !tripleSequence.includes(group.value)).every((group) => group.cards.length === 2)) return {
+			cards: sorted,
+			kind: "airplane-pair",
+			mainValue: tripleSequence.at(-1),
+			length: tripleSequence.length
+		};
+	}
+}
+function canBeat(candidate, previous) {
+	if (!previous) return true;
+	if (candidate.kind === "rocket") return true;
+	if (previous.kind === "rocket") return false;
+	if (candidate.kind === "bomb") return previous.kind !== "bomb" || candidate.mainValue > previous.mainValue;
+	if (previous.kind === "bomb") return false;
+	return candidate.kind === previous.kind && candidate.length === previous.length && candidate.mainValue > previous.mainValue;
+}
+function chooseCards(groupsByCount, count, value) {
+	return groupsByCount.find((group) => group.value === value).cards.slice(0, count);
+}
+function generateBasicPlays(hand) {
+	const grouped = groups(hand);
+	const plays = [];
+	for (const group of grouped) {
+		plays.push({
+			cards: chooseCards(grouped, 1, group.value),
+			kind: "single",
+			mainValue: group.value,
+			length: 1
+		});
+		if (group.cards.length >= 2) plays.push({
+			cards: chooseCards(grouped, 2, group.value),
+			kind: "pair",
+			mainValue: group.value,
+			length: 1
+		});
+		if (group.cards.length >= 3) plays.push({
+			cards: chooseCards(grouped, 3, group.value),
+			kind: "triple",
+			mainValue: group.value,
+			length: 1
+		});
+		if (group.cards.length === 4) plays.push({
+			cards: group.cards,
+			kind: "bomb",
+			mainValue: group.value,
+			length: 1
+		});
+	}
+	const values = grouped.filter((group) => group.value < 15 && group.cards.length >= 1).map((group) => group.value);
+	for (let start = 0; start < values.length; start += 1) for (let end = start + 5; end <= values.length; end += 1) {
+		const window = values.slice(start, end);
+		if (!isConsecutive(window, 5)) break;
+		plays.push({
+			cards: window.flatMap((value) => chooseCards(grouped, 1, value)),
+			kind: "straight",
+			mainValue: window.at(-1),
+			length: window.length
+		});
+	}
+	const pairValues = grouped.filter((group) => group.value < 15 && group.cards.length >= 2).map((group) => group.value);
+	for (let start = 0; start < pairValues.length; start += 1) for (let end = start + 3; end <= pairValues.length; end += 1) {
+		const window = pairValues.slice(start, end);
+		if (!isConsecutive(window, 3)) break;
+		plays.push({
+			cards: window.flatMap((value) => chooseCards(grouped, 2, value)),
+			kind: "pair-straight",
+			mainValue: window.at(-1),
+			length: window.length
+		});
+	}
+	if (grouped.some((group) => group.value === 16 && group.cards.length > 0) && grouped.some((group) => group.value === 17 && group.cards.length > 0)) plays.push({
+		cards: [...chooseCards(grouped, 1, 16), ...chooseCards(grouped, 1, 17)],
+		kind: "rocket",
+		mainValue: 17,
+		length: 1
+	});
+	return plays;
+}
+function findAiPlay(hand, previous) {
+	const candidates = generateBasicPlays(hand).filter((candidate) => canBeat(candidate, previous)).sort((left, right) => left.cards.length - right.cards.length || left.mainValue - right.mainValue);
+	if (candidates.length > 0) return candidates[0];
+	if (previous) return void 0;
+	return candidates[0];
+}
+//#endregion
+//#region src/game.ts
+const BOT_NAMES = ["机器人甲", "机器人乙"];
+function nextPlayer(index) {
+	return (index + 1) % 3;
+}
+function playerLabel(player) {
+	return player.kind === "human" ? "你" : player.name;
+}
+function bidLabel(level) {
+	return level === 0 ? "不叫" : `${level}分`;
+}
+function doubleLabel(level) {
+	return level === 0 ? "不加倍" : level === 1 ? "加倍" : "超级加倍";
+}
+function botBid(player) {
+	const highCards = player.hand.filter((card) => card.value >= 14).length;
+	if (highCards >= 4) return 3;
+	if (highCards >= 2) return 2;
+	if (highCards >= 1) return 1;
+	return 0;
+}
+function botDouble(player) {
+	const highCards = player.hand.filter((card) => card.value >= 14).length;
+	if (highCards >= 4) return 2;
+	if (highCards >= 2) return 1;
+	return 0;
+}
+var DoudizhuGame = class {
+	players;
+	bottom;
+	phase = "bidding";
+	currentPlayer = 0;
+	landlordIndex;
+	highestBid = 0;
+	multiplier = 1;
+	previousPlay;
+	lastPlayer;
+	passCount = 0;
+	bidRound = 1;
+	timeoutHandle;
+	options;
+	constructor(humanId, humanName, options) {
+		this.options = options;
+		const dealt = dealDeck(options.random);
+		this.bottom = dealt.bottom;
+		this.players = [
+			{
+				id: humanId,
+				kind: "human",
+				name: humanName || humanId,
+				hand: dealt.hands[0],
+				bid: 0,
+				multiplier: 1
+			},
+			{
+				id: "bot-1",
+				kind: "bot",
+				name: BOT_NAMES[0],
+				hand: dealt.hands[1],
+				bid: 0,
+				multiplier: 1
+			},
+			{
+				id: "bot-2",
+				kind: "bot",
+				name: BOT_NAMES[1],
+				hand: dealt.hands[2],
+				bid: 0,
+				multiplier: 1
+			}
+		];
+		this.resetTimeout();
+	}
+	get snapshot() {
+		return {
+			phase: this.phase,
+			currentPlayer: this.currentPlayer,
+			landlordIndex: this.landlordIndex,
+			highestBid: this.highestBid,
+			multiplier: this.multiplier,
+			players: this.players,
+			bottom: this.bottom,
+			previousPlay: this.previousPlay,
+			lastPlayer: this.lastPlayer
+		};
+	}
+	dispose() {
+		if (this.timeoutHandle) clearTimeout(this.timeoutHandle);
+		this.timeoutHandle = void 0;
+		this.phase = "finished";
+	}
+	async begin() {
+		const events = [{
+			type: "message",
+			text: "斗地主房间已开始，底牌已发完。你可以发送「明牌」查看手牌。"
+		}, {
+			type: "hand",
+			playerId: this.players[0].id,
+			cards: this.players[0].hand,
+			text: "你的手牌"
+		}];
+		return this.advanceBots(events);
+	}
+	async act(playerId, action) {
+		if (this.phase === "finished") return [{
+			type: "message",
+			text: "这局已经结束。"
+		}];
+		const playerIndex = this.players.findIndex((player) => player.id === playerId);
+		if (playerIndex !== this.currentPlayer) return [{
+			type: "message",
+			text: `现在轮到${playerLabel(this.players[this.currentPlayer])}操作。`
+		}];
+		if (this.players[playerIndex]?.kind !== "human") return [{
+			type: "message",
+			text: "人机正在操作，请稍候。"
+		}];
+		const events = [];
+		if (this.phase === "bidding" && action.type === "bid") this.applyBid(playerIndex, action.level, events);
+		else if (this.phase === "doubling" && action.type === "double") this.applyDouble(playerIndex, action.level, events);
+		else if (this.phase === "playing" && action.type === "pass") this.applyPass(playerIndex, events);
+		else if (this.phase === "playing" && action.type === "play") this.applyPlay(playerIndex, action.cards, events);
+		else return [{
+			type: "message",
+			text: "当前阶段不能使用这个指令。"
+		}];
+		this.resetTimeout();
+		return this.advanceBots(events);
+	}
+	applyBid(playerIndex, level, events) {
+		if (level !== 0 && level <= this.highestBid) throw new Error(`叫地主的分数必须高于当前最高分 ${this.highestBid}。`);
+		const player = this.players[playerIndex];
+		player.bid = level;
+		player.bidChoice = level;
+		this.highestBid = Math.max(this.highestBid, level);
+		events.push({
+			type: "message",
+			text: `${playerLabel(player)}${bidLabel(level)}。`
+		});
+		if (level === 3) {
+			this.landlordIndex = playerIndex;
+			this.finishBidding(events);
+			return;
+		}
+		if (this.players.every((item) => item.bidChoice !== void 0)) {
+			const bidder = this.players.reduce((best, item, index) => item.bid > this.players[best].bid ? index : best, 0);
+			if (this.highestBid === 0) {
+				this.bidRound += 1;
+				this.highestBid = 0;
+				this.players.forEach((item) => {
+					item.bid = 0;
+					item.bidChoice = void 0;
+				});
+				if (this.bidRound > 3) {
+					const random = this.options.random ?? Math.random;
+					this.landlordIndex = Math.floor(random() * this.players.length);
+					events.push({
+						type: "message",
+						text: "连续三轮无人叫地主，系统已随机选择地主。"
+					});
+					this.finishBidding(events);
+					return;
+				}
+				this.currentPlayer = 0;
+				events.push({
+					type: "message",
+					text: `第 ${this.bidRound} 轮叫地主开始。`
+				});
+				return;
+			}
+			this.landlordIndex = bidder;
+			this.finishBidding(events);
+			return;
+		}
+		this.currentPlayer = nextPlayer(playerIndex);
+	}
+	finishBidding(events) {
+		const landlord = this.players[this.landlordIndex];
+		landlord.hand = sortCards([...landlord.hand, ...this.bottom]);
+		this.phase = "doubling";
+		this.currentPlayer = 0;
+		events.push({
+			type: "message",
+			text: `${playerLabel(landlord)}成为地主，底牌已加入手牌。请依次选择加倍方式。`
+		});
+		events.push({
+			type: "hand",
+			playerId: this.players[0].id,
+			cards: this.players[0].hand,
+			text: "你的地主手牌"
+		});
+	}
+	applyDouble(playerIndex, level, events) {
+		const player = this.players[playerIndex];
+		player.doubleChoice = level;
+		player.multiplier = level === 0 ? 1 : level === 1 ? 2 : 4;
+		this.multiplier *= level === 0 ? 1 : level === 1 ? 2 : 4;
+		events.push({
+			type: "message",
+			text: `${playerLabel(player)}${doubleLabel(level)}。`
+		});
+		if (this.players.every((item) => item.doubleChoice !== void 0)) {
+			this.phase = "playing";
+			this.currentPlayer = this.landlordIndex;
+			this.previousPlay = void 0;
+			this.lastPlayer = void 0;
+			this.passCount = 0;
+			events.push({
+				type: "message",
+				text: `加倍阶段结束，${playerLabel(this.players[this.currentPlayer])}先出牌。`
+			});
+			events.push({
+				type: "turn",
+				playerId: this.players[this.currentPlayer].id,
+				text: "轮到你出牌。"
+			});
+			return;
+		}
+		this.currentPlayer = nextPlayer(playerIndex);
+	}
+	applyPass(playerIndex, events) {
+		if (!this.previousPlay) throw new Error("当前没有可不要的牌，请先出牌。");
+		const player = this.players[playerIndex];
+		this.passCount += 1;
+		events.push({
+			type: "message",
+			text: `${playerLabel(player)}要不起。`
+		});
+		if (this.passCount >= 2) {
+			this.currentPlayer = this.lastPlayer;
+			this.previousPlay = void 0;
+			this.passCount = 0;
+			events.push({
+				type: "message",
+				text: `两家都不要，${playerLabel(this.players[this.currentPlayer])}重新取得出牌权。`
+			});
+			return;
+		}
+		this.currentPlayer = nextPlayer(playerIndex);
+	}
+	applyPlay(playerIndex, input, events) {
+		const player = this.players[playerIndex];
+		const cards = takeCardsFromHand(player.hand, input);
+		const play = analyzePlay(cards);
+		if (!play) throw new Error("这组牌不符合斗地主牌型。");
+		if (!canBeat(play, this.previousPlay)) throw new Error("这组牌压不过上一手牌。");
+		const playedIds = new Set(cards.map((card) => card.id));
+		player.hand = player.hand.filter((card) => !playedIds.has(card.id));
+		this.previousPlay = play;
+		this.lastPlayer = playerIndex;
+		this.passCount = 0;
+		events.push({
+			type: "played",
+			playerId: player.id,
+			cards: play.cards,
+			text: `${playerLabel(player)}出了 ${play.cards.length} 张牌。`
+		});
+		if (player.hand.length === 0) {
+			this.phase = "finished";
+			this.clearTimeout();
+			events.push({
+				type: "finished",
+				winnerId: player.id,
+				text: `${playerLabel(player)}获胜！本局倍率 ${this.multiplier}。`
+			});
+			return;
+		}
+		this.currentPlayer = nextPlayer(playerIndex);
+	}
+	async advanceBots(events) {
+		while (this.phase !== "finished" && this.players[this.currentPlayer].kind === "bot") {
+			const playerIndex = this.currentPlayer;
+			const player = this.players[playerIndex];
+			if (this.phase === "bidding") {
+				const bid = botBid(player);
+				this.applyBid(playerIndex, bid !== 0 && bid <= this.highestBid ? 0 : bid, events);
+			} else if (this.phase === "doubling") this.applyDouble(playerIndex, botDouble(player), events);
+			else if (this.phase === "playing") {
+				const play = findAiPlay(player.hand, this.previousPlay);
+				if (play) this.applyPlay(playerIndex, play.cards.map((card) => card.label).join(" "), events);
+				else this.applyPass(playerIndex, events);
+			}
+			this.resetTimeout();
+		}
+		if (this.phase !== "finished") events.push({
+			type: "turn",
+			playerId: this.players[this.currentPlayer].id,
+			text: `轮到${playerLabel(this.players[this.currentPlayer])}操作。`
+		});
+		return events;
+	}
+	resetTimeout() {
+		this.clearTimeout();
+		if (this.phase === "finished") return;
+		this.timeoutHandle = setTimeout(() => {
+			if (this.phase === "finished") return;
+			this.phase = "finished";
+			this.options.onExpired?.();
+		}, this.options.timeoutMs);
+	}
+	clearTimeout() {
+		if (this.timeoutHandle) clearTimeout(this.timeoutHandle);
+		this.timeoutHandle = void 0;
+	}
+};
+var RoomManager = class {
+	maxRooms;
+	gameOptions;
+	onExpired;
+	rooms = /* @__PURE__ */ new Map();
+	nextId = 1;
+	constructor(maxRooms, gameOptions, onExpired) {
+		this.maxRooms = maxRooms;
+		this.gameOptions = gameOptions;
+		this.onExpired = onExpired;
+	}
+	create(humanId, humanName) {
+		if ([...this.rooms.values()].some((room) => room.humanId === humanId)) throw new Error("你已经在这个群的斗地主房间中。");
+		if (this.rooms.size >= this.maxRooms) throw new Error(`当前群的 ${this.maxRooms} 个房间都在进行中。`);
+		const roomId = this.nextId++;
+		let room;
+		room = {
+			id: roomId,
+			humanId,
+			game: new DoudizhuGame(humanId, humanName, {
+				...this.gameOptions,
+				onExpired: async () => {
+					this.remove(roomId);
+					await this.onExpired?.(room);
+				}
+			})
+		};
+		this.rooms.set(room.id, room);
+		return room;
+	}
+	getByHuman(humanId) {
+		return [...this.rooms.values()].find((room) => room.humanId === humanId);
+	}
+	get(roomId) {
+		return this.rooms.get(roomId);
+	}
+	remove(roomId) {
+		const room = this.rooms.get(roomId);
+		if (!room) return;
+		room.game.dispose();
+		this.rooms.delete(roomId);
+	}
+	list() {
+		return [...this.rooms.values()];
+	}
+};
+//#endregion
+//#region src/index.ts
+function positiveInteger(value, fallback) {
+	return Number.isInteger(value) && value > 0 ? value : fallback;
+}
+var src_default = definePlugin({
+	name: "doudizhu",
+	apply(ctx, options = {}) {
+		const maxRooms = positiveInteger(options.maxRooms, 2);
+		const turnTimeoutMs = positiveInteger(options.turnTimeoutMs, 6e4);
+		const renderer = new CardImageRenderer({ imageDirectory: options.imageDirectory });
+		const registeredUsers = /* @__PURE__ */ new Set();
+		const managers = /* @__PURE__ */ new Map();
+		const roomSessions = /* @__PURE__ */ new Map();
+		function getManager(groupId) {
+			let manager = managers.get(groupId);
+			if (manager) return manager;
+			manager = new RoomManager(maxRooms, { timeoutMs: turnTimeoutMs }, async (room) => {
+				const session = roomSessions.get(room.id);
+				roomSessions.delete(room.id);
+				if (session) await session.reply("本局因操作超时已结束，房间已释放。");
+			});
+			managers.set(groupId, manager);
+			return manager;
+		}
+		function groupIdOf(session) {
+			return session.raw.message_scene === "group" ? session.raw.peer_id : void 0;
+		}
+		function requireRoom(session) {
+			const groupId = groupIdOf(session);
+			if (groupId === void 0) return void 0;
+			const manager = getManager(groupId);
+			const room = manager.getByHuman(String(session.raw.sender_id));
+			if (!room) {
+				session.reply("你当前没有斗地主房间，请先发送“开始斗地主”。");
+				return;
+			}
+			return {
+				manager,
+				room
+			};
+		}
+		async function replyEvents(session, events) {
+			for (const event of events) if (event.type === "hand") {
+				const image = await renderer.render(event.cards);
+				await session.reply([textSegment(event.text), seg.image(image, { summary: event.text })]);
+			} else if (event.type === "played") {
+				const image = await renderer.render(event.cards);
+				await session.reply([textSegment(event.text), seg.image(image, { summary: "本轮出牌" })]);
+			} else await session.reply(event.text);
+		}
+		async function act(session, action) {
+			const target = requireRoom(session);
+			if (!target) return;
+			try {
+				await replyEvents(session, await target.room.game.act(String(session.raw.sender_id), action));
+				if (target.room.game.phase === "finished") {
+					target.manager.remove(target.room.id);
+					roomSessions.delete(target.room.id);
+				}
+			} catch (error) {
+				await session.reply(error instanceof Error ? error.message : "操作失败，请稍后再试。");
+			}
+		}
+		const router = ctx.router.filter((session) => session.raw.message_scene === "group");
+		router.command("注册").describe("注册斗地主玩家").execute(async (session) => {
+			registeredUsers.add(session.raw.sender_id);
+			await session.reply("斗地主注册成功。发送“开始斗地主”即可开局。");
+		});
+		router.command("开始斗地主").describe("创建一局斗地主人机对局").execute(async (session) => {
+			const userId = session.raw.sender_id;
+			if (!registeredUsers.has(userId)) {
+				await session.reply("请先发送“注册”完成斗地主注册。");
+				return;
+			}
+			const manager = getManager(groupIdOf(session));
+			try {
+				const senderName = session.raw.message_scene === "group" ? session.raw.group_member.card || session.raw.group_member.nickname : String(userId);
+				const room = manager.create(String(userId), senderName);
+				roomSessions.set(room.id, session);
+				await replyEvents(session, await room.game.begin());
+			} catch (error) {
+				await session.reply(error instanceof Error ? error.message : "创建房间失败，请稍后再试。");
+			}
+		});
+		router.command("明牌").describe("查看自己的合成手牌").execute(async (session) => {
+			const target = requireRoom(session);
+			if (!target) return;
+			const player = target.room.game.snapshot.players.find((item) => item.id === String(session.raw.sender_id));
+			if (!player) return;
+			const image = await renderer.render(player.hand);
+			await session.reply([textSegment(`你的手牌（${player.hand.length} 张）`), seg.image(image, { summary: "斗地主手牌" })]);
+		});
+		router.command("叫地主").execute((session) => act(session, {
+			type: "bid",
+			level: 3
+		}));
+		router.command("叫地主").arg("level", param.num().refine((value) => value >= 0 && value <= 3 && Number.isInteger(value))).execute((session, { level }) => act(session, {
+			type: "bid",
+			level
+		}));
+		router.command("抢地主").execute((session) => {
+			const target = requireRoom(session);
+			if (!target) return;
+			return act(session, {
+				type: "bid",
+				level: Math.min(3, target.room.game.snapshot.highestBid + 1)
+			});
+		});
+		router.command("不叫").execute((session) => act(session, {
+			type: "bid",
+			level: 0
+		}));
+		router.command("加倍").execute((session) => act(session, {
+			type: "double",
+			level: 1
+		}));
+		router.command("超级加倍").execute((session) => act(session, {
+			type: "double",
+			level: 2
+		}));
+		router.command("不加倍").execute((session) => act(session, {
+			type: "double",
+			level: 0
+		}));
+		router.command("出牌").arg("cards", param.greedy()).execute((session, { cards }) => act(session, {
+			type: "play",
+			cards
+		}));
+		router.command("要不起").execute((session) => act(session, { type: "pass" }));
+	}
+});
+function textSegment(text) {
+	return {
+		type: "text",
+		data: { text }
+	};
+}
+//#endregion
+export { RoomManager, src_default as default };

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "fraq-plugin-doudizhu",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "群聊斗地主人机对局插件",
+  "files": [
+    "dist",
+    "image"
+  ],
+  "main": "dist/index.mjs",
+  "typings": "dist/index.d.mts",
+  "keywords": [],
+  "author": "fraq-plugin-doudizhu",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fraqjs/fraq-plugin-doudizhu.git"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.9",
+    "@fraqjs/plugin-mock": "^1.1.0",
+    "@types/node": "^24.13.3",
+    "tsdown": "^0.22.14",
+    "tsx": "^4.23.12",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "sharp": "^0.34.3"
+  },
+  "peerDependencies": {
+    "@fraqjs/fraq": "^1.1.0"
+  },
+  "fraq": {
+    "category": "entertainment"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "tsx --test test/*.test.ts",
+    "check": "tsc --noEmit"
+  }
+}