@yyyu-star/arcade-kit 0.10.2 → 0.11.1

package/src/fun-logic.ts

@@ -0,0 +1,351 @@
+/**
+ * 牌桌互动的规则（0.11.0）：冷却、护盾、连击、回敬、电脑怎么反应、菜单放哪。纯函数和小类，不碰 DOM，时间和随机数由调用方给，
+ * 页面（table-fun.ts）和房间（电脑在服务器上回应时）都能用，测试在 workerd 里直接跑。
+ *
+ * 座位用游戏自己的编号（页面上一般是"我 = 0"的画面座位，房间里是真实座位），这里不关心是哪种，只要同一个对象里一致。
+ * 所有数字的出处是仓库根 docs/table-fun.md 第 2–4 节；都能经参数改，默认值就是规范。
+ */
+import { PROPS, STICKERS, type PropId, type StickerId } from './fun-art.js';
+
+export { PROPS, STICKERS, type PropId, type StickerId };
+
+// ---------- 节奏 ----------
+
+export const FUN_TIMING = {
+  /** 自己扔道具的冷却 */
+  propCooldownMs: 1500,
+  /** 表情、短语的冷却 */
+  talkCooldownMs: 1000,
+  /** 同一个人 shieldWindowMs 里最多被扔 shieldMax 次，多的亮护盾、不播 */
+  shieldMax: 6,
+  shieldWindowMs: 10_000,
+  /** 连击、回敬都按这个算 */
+  comboMs: 3000,
+  /** 长按多久算"连扔上次那个" */
+  longPressMs: 400,
+  /** 污渍留多久再淡出 */
+  stainMs: 3000,
+  /** 首次提示留多久 */
+  hintMs: 3000,
+  /** 好友房的电脑从房间立刻发出来（房间只有一个闹钟），页面晚这么久再播，像人反应了一下、也等道具落地 */
+  botLagMs: 900,
+} as const;
+
+export type FunKind = 'prop' | 'talk';
+
+/** 自己发东西的冷却：道具一个计时，表情和短语共用一个 */
+export class FunCooldown {
+  private last: Record<FunKind, number> = { prop: -Infinity, talk: -Infinity };
+  constructor(private readonly ms: Record<FunKind, number> = { prop: FUN_TIMING.propCooldownMs, talk: FUN_TIMING.talkCooldownMs }) {}
+
+  /** 还要等多久（毫秒，0 = 能发） */
+  left(kind: FunKind, now: number): number {
+    return Math.max(0, this.last[kind] + this.ms[kind] - now);
+  }
+
+  /** 能发就记下并返回 true；冷却中返回 false，不记 */
+  take(kind: FunKind, now: number): boolean {
+    if (this.left(kind, now) > 0) return false;
+    this.last[kind] = now;
+    return true;
+  }
+
+  total(kind: FunKind): number {
+    return this.ms[kind];
+  }
+}
+
+// ---------- 护盾、连击、回敬 ----------
+
+export interface HitResult {
+  /** 被扔太多了：这一下不播，头像上亮护盾 */
+  shield: boolean;
+  /** 同一个人连着扔同一个人的第几下（1 = 不算连击） */
+  combo: number;
+  /** 被 to 扔过以后 comboMs 内扔回去 */
+  revenge: boolean;
+}
+
+/** 每一下扔中都过这里；真人、电脑、好友房转发来的一视同仁 */
+export class FunTally {
+  private readonly hits = new Map<number, number[]>();
+  /** 每个人最近一次扔的是谁、第几下：换了目标就断（"连续扔同一个人"） */
+  private readonly chain = new Map<number, { to: number; t: number; n: number }>();
+  /** 谁最近扔过这个人 */
+  private readonly lastBy = new Map<number, { from: number; t: number }>();
+
+  constructor(private readonly t: { shieldMax: number; shieldWindowMs: number; comboMs: number } = FUN_TIMING) {}
+
+  hit(from: number, to: number, now: number): HitResult {
+    const recent = (this.hits.get(to) ?? []).filter((x) => now - x < this.t.shieldWindowMs);
+    if (recent.length >= this.t.shieldMax) {
+      this.hits.set(to, recent);
+      return { shield: true, combo: 1, revenge: false };
+    }
+    recent.push(now);
+    this.hits.set(to, recent);
+    const prev = this.chain.get(from);
+    const combo = prev && prev.to === to && now - prev.t <= this.t.comboMs ? prev.n + 1 : 1;
+    this.chain.set(from, { to, t: now, n: combo });
+    const by = this.lastBy.get(from);
+    const revenge = !!by && by.from === to && now - by.t <= this.t.comboMs;
+    this.lastBy.set(to, { from, t: now });
+    return { shield: false, combo, revenge };
+  }
+}
+
+// ---------- 电脑怎么反应 ----------
+
+/** 互动性格：爱闹 / 普通 / 高冷（每个电脑人物一个，写在游戏的人物表里） */
+export type FunTemper = 'rowdy' | 'normal' | 'cool';
+export const TEMPER_MULT: Record<FunTemper, number> = { rowdy: 1.5, normal: 1, cool: 0.3 };
+
+/** 反应的情绪：决定冒哪个表情、气泡说哪类话（话由游戏给，kit 有一套不提任何游戏的默认） */
+export type FunMood = 'angry' | 'sweat' | 'love' | 'smug' | 'shock' | 'cry';
+
+/** 名场面：游戏把自己的公开事件映射成这几类，没有的不报 */
+export type MomentKind =
+  | 'big-win'
+  | 'comeback'
+  | 'bluff-caught'
+  | 'bomb'
+  | 'first-out'
+  | 'double-down'
+  | 'kong'
+  | 'self-draw'
+  | (string & {});
+
+/** 发给 botReact 的事 */
+export type FunEvent =
+  /** 有人冲这个电脑扔了道具（prop）或点名短语（没有 prop） */
+  | { kind: 'hit'; from: number; to: number; prop?: PropId }
+  /** 名场面：赢的、输的各是谁；hand 区分"这一手"（每手电脑主动互动有上限） */
+  | { kind: 'moment'; moment: MomentKind; winners: readonly number[]; losers: readonly number[]; hand: string | number };
+
+export interface FunBot {
+  seat: number;
+  temper: FunTemper;
+}
+
+/** 电脑这一下要做什么：一定有表情和一句话的情绪（看得见），回敬时再带一个道具飞过去 */
+export interface BotAction {
+  from: number;
+  /** 道具、点名的对象 */
+  to?: number;
+  /** 过多久做（像人一样反应一下） */
+  delay: number;
+  sticker: StickerId;
+  mood: FunMood;
+  prop?: PropId;
+}
+
+export interface BotReactConfig {
+  /** 被扔后回应的概率（再乘性格） */
+  respond: number;
+  /** 回应里直接回敬道具的比例 */
+  counterShare: number;
+  /** 同一个电脑 counterWindowMs 里最多回敬几次 */
+  counterMax: number;
+  counterWindowMs: number;
+  /** 同一个电脑两次反应至少隔多久（不能比扔道具的冷却长，否则连扔时回应被吞） */
+  minGapMs: number;
+  /** 反应延迟区间 */
+  delay: readonly [number, number];
+  /** 名场面：输的一方冲赢家、赢的一方得意 */
+  momentLose: number;
+  momentWin: number;
+  /** 每一手电脑主动互动最多几次 */
+  perHand: number;
+}
+
+export const BOT_REACT: BotReactConfig = {
+  respond: 0.6,
+  counterShare: 0.25,
+  counterMax: 2,
+  counterWindowMs: 20_000,
+  minGapMs: 1000,
+  delay: [800, 2000],
+  momentLose: 0.4,
+  momentWin: 0.3,
+  perHand: 2,
+};
+
+/** 电脑反应的账：调用方存着（页面一局一份；房间放内存） */
+export interface BotState {
+  lastOut: Record<number, number>;
+  counters: Record<number, number[]>;
+  hand: string | number | null;
+  /** 这一手已经主动互动了几次 */
+  n: number;
+}
+
+export function newBotState(): BotState {
+  return { lastOut: {}, counters: {}, hand: null, n: 0 };
+}
+
+const DIRTY: readonly PropId[] = ['tomato', 'egg', 'stinkyEgg', 'slipper', 'bomb'];
+
+/** 同类回敬：番茄还番茄，鸡蛋还拖鞋（一个比一个狠一点），善意的还善意的 */
+export const COUNTER: Record<PropId, PropId> = {
+  tomato: 'tomato',
+  egg: 'slipper',
+  stinkyEgg: 'stinkyEgg',
+  slipper: 'slipper',
+  bomb: 'bomb',
+  rose: 'rose',
+  like: 'like',
+  cheers: 'cheers',
+};
+
+const MOOD_STICKER: Record<FunMood, readonly StickerId[]> = {
+  angry: ['angry'],
+  sweat: ['sweat'],
+  love: ['love'],
+  smug: ['smug', 'cool', 'lol'],
+  shock: ['shock'],
+  cry: ['cry'],
+};
+
+const pick = <T>(xs: readonly T[], rand: () => number): T => xs[Math.floor(rand() * xs.length) % xs.length]!;
+
+/**
+ * 一个电脑对一件事的反应，没有就是 null。被扔：bot 是被扔的那个；名场面：调用方把每个电脑都问一遍（每手有上限，按问的顺序先到先得）。
+ * 被扔时的回应不占"每手主动互动"的次数，只守 minGapMs 和回敬上限。
+ */
+export function botReact(ev: FunEvent, bot: FunBot, st: BotState, now: number, rand: () => number, cfg: BotReactConfig = BOT_REACT): BotAction | null {
+  const mult = TEMPER_MULT[bot.temper];
+  const p = (x: number): number => Math.min(0.95, x * mult);
+  if (now - (st.lastOut[bot.seat] ?? -Infinity) < cfg.minGapMs) return null;
+  const delay = Math.round(cfg.delay[0] + rand() * (cfg.delay[1] - cfg.delay[0]));
+  const out = (a: Omit<BotAction, 'from' | 'delay'>): BotAction => {
+    st.lastOut[bot.seat] = now;
+    return { from: bot.seat, delay, ...a };
+  };
+
+  if (ev.kind === 'hit') {
+    if (ev.to !== bot.seat || ev.from === bot.seat) return null;
+    if (rand() >= p(cfg.respond)) return null;
+    const nice = ev.prop !== undefined && !DIRTY.includes(ev.prop);
+    const recent = (st.counters[bot.seat] ?? []).filter((t) => now - t < cfg.counterWindowMs);
+    st.counters[bot.seat] = recent;
+    if (rand() < cfg.counterShare && recent.length < cfg.counterMax) {
+      recent.push(now);
+      const prop = ev.prop ? COUNTER[ev.prop] : 'tomato';
+      return out({ to: ev.from, prop, mood: nice ? 'love' : 'angry', sticker: nice ? 'love' : 'angry' });
+    }
+    const mood: FunMood = nice ? 'love' : pick(['angry', 'sweat'] as const, rand);
+    return out({ to: ev.from, mood, sticker: pick(MOOD_STICKER[mood], rand) });
+  }
+
+  // 名场面：新的一手从头计数
+  if (st.hand !== ev.hand) {
+    st.hand = ev.hand;
+    st.n = 0;
+  }
+  if (st.n >= cfg.perHand) return null;
+  const lost = ev.losers.includes(bot.seat);
+  const won = ev.winners.includes(bot.seat);
+  if (lost && ev.winners.length) {
+    if (rand() >= p(cfg.momentLose)) return null;
+    st.n++;
+    const to = ev.winners[Math.floor(rand() * ev.winners.length) % ev.winners.length]!;
+    // 一半扔个不太狠的道具，一半冒表情加一句
+    if (rand() < 0.5) return out({ to, prop: pick(['tomato', 'egg', 'slipper'] as const, rand), mood: 'angry', sticker: 'angry' });
+    const mood: FunMood = pick(['shock', 'cry', 'angry', 'sweat'] as const, rand);
+    return out({ to, mood, sticker: pick(MOOD_STICKER[mood], rand) });
+  }
+  if (won) {
+    if (rand() >= p(cfg.momentWin)) return null;
+    st.n++;
+    return out({ mood: 'smug', sticker: pick(MOOD_STICKER.smug, rand) });
+  }
+  return null;
+}
+
+// ---------- 菜单放哪 ----------
+
+export interface Box {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+}
+
+const overlap = (a: Box, b: Box): number =>
+  Math.max(0, Math.min(a.left + a.width, b.left + b.width) - Math.max(a.left, b.left)) * Math.max(0, Math.min(a.top + a.height, b.top + b.height) - Math.max(a.top, b.top));
+
+/**
+ * 菜单（w×h）贴着头像（anchor）放：先试朝屏幕中心那一侧，再试另外三侧；夹在可见区里（留 margin），
+ * 和"禁区"（手牌、操作按钮）以及头像本身压得最少的那个位置胜出，一样少时按试的顺序。
+ */
+export function placeMenu(anchor: Box, w: number, h: number, view: { width: number; height: number }, avoid: readonly Box[] = [], margin = 8, gap = 10): { left: number; top: number } {
+  const cx = anchor.left + anchor.width / 2;
+  const cy = anchor.top + anchor.height / 2;
+  const right = { left: anchor.left + anchor.width + gap, top: cy - h / 2 };
+  const left = { left: anchor.left - gap - w, top: cy - h / 2 };
+  const below = { left: cx - w / 2, top: anchor.top + anchor.height + gap };
+  const above = { left: cx - w / 2, top: anchor.top - gap - h };
+  // 朝中心：水平离中心远就先左右，否则先上下
+  const dx = view.width / 2 - cx;
+  const dy = view.height / 2 - cy;
+  const order = Math.abs(dx) / view.width >= Math.abs(dy) / view.height ? (dx >= 0 ? [right, below, above, left] : [left, below, above, right]) : dy >= 0 ? [below, right, left, above] : [above, right, left, below];
+  const clamp = (p: { left: number; top: number }): Box => ({
+    left: Math.max(margin, Math.min(view.width - margin - w, p.left)),
+    top: Math.max(margin, Math.min(view.height - margin - h, p.top)),
+    width: w,
+    height: h,
+  });
+  let best: Box | null = null;
+  let bestCost = Infinity;
+  for (const c of order.map(clamp)) {
+    const cost = [anchor, ...avoid].reduce((s, b) => s + overlap(c, b), 0);
+    if (cost < bestCost) {
+      best = c;
+      bestCost = cost;
+      if (cost === 0) break;
+    }
+  }
+  return { left: best!.left, top: best!.top };
+}
+
+// ---------- 编号 ----------
+
+/**
+ * 编号怎么排（和房间转发的 emote id 一致）：短语 0..P-1，表情 P..P+11，道具 P+12..P+19。P 是游戏短语表的长度。
+ * 游戏的 RoomGame.emotes 写 funIdCount(P)。
+ */
+export function funIdCount(phrases: number): number {
+  return phrases + 12 + 8;
+}
+
+export type FunItem = { kind: 'phrase'; index: number } | { kind: 'sticker'; index: number } | { kind: 'prop'; index: number };
+
+export function funItem(id: number, phrases: number): FunItem | null {
+  if (!Number.isInteger(id) || id < 0 || id >= funIdCount(phrases)) return null;
+  if (id < phrases) return { kind: 'phrase', index: id };
+  if (id < phrases + 12) return { kind: 'sticker', index: id - phrases };
+  return { kind: 'prop', index: id - phrases - 12 };
+}
+
+export const stickerId = (phrases: number, index: number): number => phrases + index;
+export const propId = (phrases: number, index: number): number => phrases + 12 + index;
+
+/** 电脑的表情对应的情绪（页面收到电脑的表情时配一句话用）；不是情绪表情的回 null */
+export function stickerMood(s: StickerId): FunMood | null {
+  for (const [mood, list] of Object.entries(MOOD_STICKER) as [FunMood, readonly StickerId[]][]) if (list.includes(s)) return mood;
+  return null;
+}
+
+/** 房间用：真人发来的编号换成给 botReact 的"被扔"（冲人来的道具、点名短语才算，表情、不点名的短语不算） */
+export function hitEvent(id: number, phrases: number, from: number, to?: number): Extract<FunEvent, { kind: 'hit' }> | null {
+  const it = funItem(id, phrases);
+  if (!it || to === undefined || to === from || it.kind === 'sticker') return null;
+  return it.kind === 'prop' ? { kind: 'hit', from, to, prop: PROPS[it.index]! } : { kind: 'hit', from, to };
+}
+
+/** 房间用：电脑的反应换成要经 botEmote 发的编号。先表情（页面会配上一句话），回扔时再加道具 */
+export function botEmoteIds(a: BotAction, phrases: number): { id: number; to?: number }[] {
+  const out: { id: number; to?: number }[] = [{ id: stickerId(phrases, STICKERS.indexOf(a.sticker)) }];
+  if (a.prop && a.to !== undefined) out.push({ id: propId(phrases, PROPS.indexOf(a.prop)), to: a.to });
+  return out;
+}

package/src/fun.ts

@@ -10,6 +10,7 @@
  * - 被扔的头像抖一下由游戏做（头像在游戏的画布或 DOM 里，kit 碰不到）：命中时调 opts.onHit(prop)。
  * 这个文件引用 DOM，但只在调用时才碰：在 workerd、Node 里 import 不会出错（测试只测纯函数和素材）。
  */
+import { FUN_TIMING } from './fun-logic.js';
 import { BURST, DRIP, PETAL, PROPS, SHELL, SMOKE, SOOT, SPARK, SPLAT_TOMATO, STAR, STICKERS, STINK, dot, propSvg, splatEgg, stickerSvg, type PropId, type StickerId } from './fun-art.js';
 
 export { PROPS, STICKERS, propSvg, stickerSvg, type PropId, type StickerId };
@@ -226,7 +227,7 @@ const SPIN: Record<PropId, number> = { tomato: 540, egg: 600, stinkyEgg: 600, sl
 const FLY_MS = 700;
 
 /**
- * 从 from（发的人头像的屏幕矩形）扔到 to（对象头像），命中后按道具播效果，污渍留 1.5–2 秒再淡出。
+ * 从 from（发的人头像的屏幕矩形）扔到 to（对象头像），命中后按道具播效果，脏东西的污渍留 3 秒（FUN_TIMING.stainMs）再淡出，玫瑰停 1.6 秒。
  * 名额满了直接返回 false；播完（不含污渍的停留）返回 true。
  */
 export async function throwAt(layer: FunLayer, from: RectLike, to: RectLike, prop: PropId, opts: ThrowOptions = {}): Promise<boolean> {
@@ -312,7 +313,7 @@ async function splat(h: Hit, svg: string, scale: number, extra?: (g: HTMLElement
   const sz = h.s * scale;
   const d = sprite(g, svg, sz, h.c, `rotate(${rnd(-20, 20).toFixed(0)}deg)`);
   extra?.(g);
-  stain(h.el, h.key, g, 1700);
+  stain(h.el, h.key, g, FUN_TIMING.stainMs);
   await play(d, [{ transform: pos(h.c, sz, 'scale(.25)') }, { transform: pos(h.c, sz, 'scale(1.18)'), offset: 0.6 }, { transform: pos(h.c, sz, 'scale(1)') }], 180, { easing: 'ease-out' });
   return g;
 }

package/src/room.ts

@@ -117,6 +117,8 @@ export const DEFAULT_LIMITS: RoomLimits = {
 
 /** 闹钟里出错时，过这么久再醒来重试（不用"马上"，免得每次都出错时连着计费）。 */
 const ALARM_RETRY_MS = 60_000;
+/** 每个座位记住最近几个做成的 moveId（0.11.1）：客户端断线时攒着没确认的操作，重连后原样补发 */
+const RECENT_MOVES = 8;
 
 /** 计量说的门槛在内存里记多久（不进新人时用；报数、还名额时顺便更新）。 */
 const LEVEL_TTL_MS = 30_000;
@@ -148,6 +150,11 @@ interface SeatState {
   auto: boolean;
   /** 这个座位最后一次做成的操作的 moveId（重发去重） */
   lastMoveId: string | null;
+  /**
+   * 最近做成的几个 moveId，新的在后（0.11.1，最多 RECENT_MOVES 个；旧房间的状态里没有，读到时当空的）。
+   * 只记最后一个不够：连发 A、B，A 的 ack 丢了，重连后补发 A，lastMoveId 已经是 B，不轮流的操作（free）就会被做第二遍
+   */
+  recentMoves?: string[];
 }
 
 interface Persist<S> {
@@ -389,13 +396,14 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
       this.alarmAt = null;
       await this.entry(() => this.onAlarm());
       // 出错时状态可能没走到"重设闹钟"那一步：房间还在、又没有闹钟，就过一会儿再醒来，不然房间永远没人关
-      if (this.lastStepFailed && this.alarmAt === null && this.load()) {
+      // setAlarm 本身失败时 alarmAt 是 undefined（不知道），以存储里读到的为准（0.11.1）
+      if (this.lastStepFailed && this.load() && (this.alarmAt === undefined ? await this.ctx.storage.getAlarm() : this.alarmAt) === null) {
         this.alarmAt = Date.now() + ALARM_RETRY_MS;
         this.lastStepWrites++;
         this.totalWrites++;
         this.unmetered++;
         this.maxStepWrites = Math.max(this.maxStepWrites, this.lastStepWrites);
-        await this.ctx.storage.setAlarm(this.alarmAt);
+        await this.setAlarmSafely(this.alarmAt);
       }
     } catch (e) {
       console.error('room alarm failed', e instanceof Error ? e.message : e);
@@ -430,11 +438,26 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
     this.totalWrites += this.writes;
     this.unmetered += this.writes;
     this.maxStepWrites = Math.max(this.maxStepWrites, this.writes);
-    if (at !== null) await this.ctx.storage.setAlarm(at);
+    if (at !== null && !(await this.setAlarmSafely(at))) this.lastStepFailed = true;
     await this.afterStep();
     return out;
   }
 
+  /**
+   * 设闹钟；失败了不往外抛（0.11.1）。planAlarm 已经把 alarmAt 改成了新时间，失败时它就是错的：
+   * 留着的话以后 planAlarm 看"已经设了更早的"一直不重设，房间就没人收场。改回"不知道"，下一个入口按 getAlarm() 重新读、照常重排
+   */
+  private async setAlarmSafely(at: number): Promise<boolean> {
+    try {
+      await this.ctx.storage.setAlarm(at);
+      return true;
+    } catch (e) {
+      console.error('room setAlarm failed', e instanceof Error ? e.message : e);
+      this.alarmAt = undefined;
+      return false;
+    }
+  }
+
   // ---------- 计量（0.2.0） ----------
 
   /**
@@ -809,7 +832,7 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
     if (seat === null) return this.reject(ws, 'not_seated', moveId);
     const s = st.seats[seat]!;
     // 重发的同一个操作：不再做一遍，只回 ack 和当前状态
-    if (s.lastMoveId === moveId) {
+    if (s.lastMoveId === moveId || s.recentMoves?.includes(moveId)) {
       const bound = this.boundOf(attachmentOf(ws)!.userId);
       return this.send(ws, this.stateMsg(seat, bound, [{ state: st.game, delay: 0 }], moveId));
     }
@@ -828,6 +851,7 @@ export abstract class GameRoom<S, A, V, Env = unknown, O = unknown, E extends Ro
     const out = this.step(seat, action, now, free);
     if (out) return this.reject(ws, out, moveId);
     s.lastMoveId = moveId;
+    s.recentMoves = [...(s.recentMoves ?? []), moveId].slice(-RECENT_MOVES);
     const auto = this.runAuto(now);
     if (seen !== null && auto.length === 0 && this.othersSee(seat) === seen) return this.commitQuiet(ws, seat, moveId);
     this.commit({ frames: [{ state: st.game, delay: 0 }, ...auto], ack: { ws, moveId } });