@mingxy/opencode-mascot 0.1.2 → 0.2.1

package/src/core/ascii-renderer.tsx

@@ -2,7 +2,7 @@
 
 import { createSignal, onCleanup } from "solid-js";
 import type { JSX } from "@opentui/solid";
-import type { MascotPack, MascotState } from "./types";
+import type { MascotPack, MascotState, EffectTimerCtx, EffectRenderCtx } from "./types";
 
 const STATE_TO_FRAME: Record<MascotState, string> = {
   idle: "default",
@@ -18,11 +18,11 @@ const DEFAULT_ANIM = {
   expressionInterval: 8000,
   idleTimeout: 120000,
   breathInterval: 3000,
-  ahogeInterval: 1500,
-  ahogeChance: 0.25,
+  walkEnabled: true,
+  walkMinDelay: 20000,
+  walkMaxDelay: 40000,
   jumpMinDelay: 20000,
   jumpMaxDelay: 40000,
-  stompThreshold: 30000,
 };
 
 const WALK_PATH = [1, 2, 3, 4, 3, 2, 1, 0, -1, -2, -3, -2, -1, 0];
@@ -45,35 +45,72 @@ function renderLines(lines: string[], fg?: string): JSX.Element {
 export function createAnimatedRenderer(pack: MascotPack): {
   element: () => JSX.Element;
   setState: (s: MascotState) => void;
+  toggleWalk: () => void;
+  setDragging: (v: boolean) => void;
+  celebrateUpdate: (newVersion: string) => void;
 } {
   const anim = { ...DEFAULT_ANIM, ...pack.animations };
   const fg = pack.colors?.defaultFg || undefined;
+  const effects = pack.effects;
 
   const [currentState, setCurrentState] = createSignal<MascotState>("idle");
   const [frameOverride, setFrameOverride] = createSignal<string | null>(null);
-  const [legsVisible, setLegsVisible] = createSignal(true);
+  const [breathPhase, setBreathPhase] = createSignal(true);
   const [walkOffset, setWalkOffset] = createSignal(0);
-  const [ahogeAlt, setAhogeAlt] = createSignal(false);
-  const [braidAlt, setBraidAlt] = createSignal(false);
-  const [waveSide, setWaveSide] = createSignal(false);
-  const [zzzPhase, setZzzPhase] = createSignal(0);
   const [jumpOffset, setJumpOffset] = createSignal(0);
-  const [stompActive, setStompActive] = createSignal(false);
-  const [stompAlt, setStompAlt] = createSignal(false);
+  const [walkEnabled, setWalkEnabled] = createSignal(anim.walkEnabled ?? true);
+  const [dragging, setDraggingSignal] = createSignal(false);
+  const [celebrate, setCelebrate] = createSignal<{ text: string; count: number } | null>(null);
+
+  let idleSleepTimeout: ReturnType<typeof setTimeout> | null = null;
+
+  const resetIdleSleep = () => {
+    if (idleSleepTimeout) clearTimeout(idleSleepTimeout);
+    idleSleepTimeout = null;
+    if (currentState() !== "idle") return;
+    idleSleepTimeout = setTimeout(() => {
+      if (currentState() === "idle") {
+        setCurrentState("sleeping");
+        stopWalk();
+      }
+    }, anim.idleTimeout);
+  };
 
-  let thinkingStartTime = 0;
+  resetIdleSleep();
 
-  // ============ 1. Blink ============
+  // ─── Extra signals from pack effects ───
+  const extraSignals = new Map<string, [() => unknown, (v: unknown) => void]>();
+  if (effects?.signals) {
+    for (const sig of effects.signals) {
+      const [get, set] = createSignal(sig.initial);
+      extraSignals.set(sig.name, [get, set]);
+    }
+  }
+
+  const getExtra = (name: string): unknown => extraSignals.get(name)?.[0]() ?? null;
+  const setExtra = (name: string, value: unknown) => extraSignals.get(name)?.[1](value);
+
+  const timerCtx: EffectTimerCtx = {
+    get: getExtra,
+    set: setExtra,
+    get state() { return currentState(); },
+    get frameOverride() { return frameOverride(); },
+    setFrameOverride: (name) => setFrameOverride(name),
+  };
+
+  // ─── Built-in timers ───
+
+  // 1. Blink
   const hasBlink = (pack.frames as Record<string, string[] | undefined>)["blink"] !== undefined;
 
   const blinkTimer = setInterval(() => {
-    if (Math.random() < anim.blinkChance && hasBlink) {
+    if (currentState() !== "sleeping" && Math.random() < anim.blinkChance && hasBlink) {
       setFrameOverride("blink");
       setTimeout(() => setFrameOverride(null), 150);
     }
   }, anim.blinkInterval);
 
-  // ============ 2. Random expression ============
+  // 2. Random expression
   const availableExpressions = Object.keys(pack.frames).filter(
     (k) => k !== "default" && k !== "blink",
   );
@@ -83,37 +120,30 @@ export function createAnimatedRenderer(pack: MascotPack): {
       const pick = availableExpressions[Math.floor(Math.random() * availableExpressions.length)];
       if (pick) {
         setFrameOverride(pick);
-        if (pick === "happy") startWave();
-        setTimeout(() => {
-          setFrameOverride(null);
-          stopWave();
-        }, 2000);
+        setTimeout(() => setFrameOverride(null), 2000);
       }
     }
   }, anim.expressionInterval);
 
-  // ============ 3. Breathing (legs tuck + braids flutter) ============
+  // 3. Breathing
   const breathTimer = setInterval(() => {
-    setLegsVisible((v) => !v);
-    setBraidAlt((v) => !v);
-  }, anim.breathInterval);
-
-  // ============ 4. Ahoge wobble (呆毛晃) ============
-  const ahogeTimer = setInterval(() => {
-    if (Math.random() < anim.ahogeChance) {
-      setAhogeAlt(true);
-      setTimeout(() => setAhogeAlt(false), 200);
+    if (currentState() === "idle") {
+      setBreathPhase((v) => !v);
     }
-  }, anim.ahogeInterval);
+  }, anim.breathInterval);
 
-  // ============ 5. Walk ============
+  // 4. Walk
   let walkStep = -1;
   let walkInterval: ReturnType<typeof setInterval> | null = null;
 
   const startWalk = () => {
-    if (walkInterval) return;
+    if (walkInterval || !walkEnabled()) return;
     walkStep = 0;
     walkInterval = setInterval(() => {
+      if (currentState() !== "idle") {
+        stopWalk();
+        return;
+      }
       if (walkStep < WALK_PATH.length) {
         setWalkOffset(WALK_PATH[walkStep]);
         walkStep++;
@@ -138,18 +168,21 @@ export function createAnimatedRenderer(pack: MascotPack): {
   let walkTimeout: ReturnType<typeof setTimeout>;
 
   function scheduleNextWalk() {
-    const delay = 5000 + Math.floor(Math.random() * 5000);
+    if (!walkEnabled()) return setTimeout(() => {}, 60000);
+    const delay = anim.walkMinDelay + Math.floor(Math.random() * (anim.walkMaxDelay - anim.walkMinDelay));
     return setTimeout(() => {
-      if (currentState() === "idle" && !frameOverride() && walkStep === -1) {
+      if (currentState() === "idle" && !frameOverride() && walkStep === -1 && walkEnabled()) {
         startWalk();
       }
-      walkTimeout = scheduleNextWalk();
+      if (currentState() !== "sleeping") {
+        walkTimeout = scheduleNextWalk();
+      }
     }, delay);
   }
 
   walkTimeout = scheduleNextWalk();
 
-  // ============ 6. Jump ============
+  // 5. Jump
   let jumpTimeout: ReturnType<typeof setTimeout>;
 
   function scheduleNextJump() {
@@ -157,77 +190,50 @@ export function createAnimatedRenderer(pack: MascotPack): {
     return setTimeout(() => {
       if (currentState() === "idle" && !frameOverride() && walkStep === -1) {
         setJumpOffset(-2);
-        setTimeout(() => setJumpOffset(0), 500);
+        setTimeout(() => setJumpOffset(-1), 1500);
+        setTimeout(() => setJumpOffset(0), 2000);
+      }
+      if (currentState() !== "sleeping") {
+        jumpTimeout = scheduleNextJump();
       }
-      jumpTimeout = scheduleNextJump();
     }, delay);
   }
 
   jumpTimeout = scheduleNextJump();
 
-  // ============ 7. Wave (挥手 — happy state) ============
-  let waveTimer: ReturnType<typeof setInterval> | null = null;
-
-  const startWave = () => {
-    if (waveTimer) return;
-    waveTimer = setInterval(() => setWaveSide((v) => !v), 300);
-  };
-
-  const stopWave = () => {
-    if (waveTimer) {
-      clearInterval(waveTimer);
-      waveTimer = null;
-    }
-    setWaveSide(false);
-  };
-
-  // ============ 8. Zzz bubbles (sleeping state) ============
-  const zzzTimer = setInterval(() => {
-    if (currentState() === "sleeping") {
-      setZzzPhase((p) => (p + 1) % 4);
-    } else {
-      setZzzPhase(0);
+  // ─── Pack-defined effect timers ───
+  const effectTimers: ReturnType<typeof setInterval>[] = [];
+  if (effects?.timers) {
+    for (const t of effects.timers) {
+      effectTimers.push(setInterval(() => t.update(timerCtx), t.interval));
     }
-  }, 1500);
-
-  // ============ 9. Stomp (跺脚 — thinking > threshold) ============
-  const stompTimer = setInterval(() => {
-    if (
-      currentState() === "thinking" &&
-      thinkingStartTime > 0 &&
-      Date.now() - thinkingStartTime > anim.stompThreshold
-    ) {
-      setStompActive(true);
-      setStompAlt((a) => !a);
-    } else {
-      setStompActive(false);
-    }
-  }, 200);
+  }
 
-  // ============ Cleanup ============
+  // ─── Cleanup ───
   onCleanup(() => {
     clearInterval(blinkTimer);
     clearInterval(expressionTimer);
     clearInterval(breathTimer);
-    clearInterval(ahogeTimer);
-    clearInterval(zzzTimer);
-    clearInterval(stompTimer);
     clearTimeout(walkTimeout);
     clearTimeout(jumpTimeout);
+    if (idleSleepTimeout) clearTimeout(idleSleepTimeout);
     if (walkInterval) clearInterval(walkInterval);
-    stopWave();
+    for (const t of effectTimers) clearInterval(t);
   });
 
-  // ============ Render ============
+  // ─── Render ───
   const element = () => {
-    legsVisible();
-    ahogeAlt();
-    braidAlt();
-    waveSide();
-    zzzPhase();
+    breathPhase();
+    walkOffset();
     jumpOffset();
-    stompActive();
-    stompAlt();
+    frameOverride();
+    currentState();
+    dragging();
+    celebrate();
+
+    for (const [, [get]] of extraSignals) {
+      get();
+    }
 
     const frameName = frameOverride() ?? STATE_TO_FRAME[currentState()] ?? "default";
     const rawLines = getFrameLines(pack, frameName);
@@ -236,85 +242,96 @@ export function createAnimatedRenderer(pack: MascotPack): {
     const width = rawLines[0]?.length ?? 10;
     const blank = " ".repeat(width);
 
-    let lines = rawLines.map((line, i) => {
-      if (!legsVisible()) {
+    let lines: string[] = rawLines.map((line, i) => {
+      if (!breathPhase()) {
         if (i === 0) return blank;
         return rawLines[i - 1];
       }
       return line;
     });
 
-    // 2. Ahoge wobble: ☆ ↔ ★
-    if (ahogeAlt()) {
-      lines = lines.map((l) => (l.includes("☆") ? l.replace("☆", "★") : l));
-    }
-
-    // 3. Braid flutter: ~ ↔ -
-    if (braidAlt()) {
-      lines = lines.map((l) => (l.includes("~") ? l.replace(/~/g, "-") : l));
-    }
-
-    // 4. Wave: braids become hands ╲ / ╱ on face row
-    if (frameName === "happy") {
-      const faceIdx = lines.findIndex((l) => l.includes("^ω^"));
-      if (faceIdx >= 0) {
-        lines[faceIdx] = waveSide()
-          ? "╲( ^ω^ )╱ "
-          : " ~( ^ω^ )~";
-      }
-    }
-
-    // 5. Stomp: legs alternate ╲ ╱ ↔ ╱ ╲
-    if (stompActive()) {
-      const legIdx = lines.length - 1;
-      if (legIdx >= 0) {
-        lines[legIdx] = stompAlt() ? "  ╲ ╱  " : "  ╱ ╲  ";
-      }
-    }
-
-    // 6. Zzz: floating Z bubbles beside face
-    const zzz = zzzPhase();
-    if (zzz > 0 && currentState() === "sleeping") {
-      for (let i = 0; i < lines.length; i++) {
-        if (lines[i].includes("-.-")) {
-          lines[i] = lines[i] + " " + "Z".repeat(zzz);
-          break;
-        }
-      }
+    if (effects?.render) {
+        const renderCtx: EffectRenderCtx = {
+          state: currentState(),
+          frameName,
+          breathPhase: breathPhase(),
+          jumpOffset: jumpOffset(),
+          dragging: dragging(),
+          get: getExtra,
+        };
+      lines = effects.render(lines, renderCtx);
     }
 
     const top = jumpOffset();
     const left = offset > 0 ? offset : 0;
+    const cel = celebrate();
 
     return (
       <box flexDirection="column" left={left} top={top}>
         {renderLines(lines, fg)}
+        {cel ? <text fg={fg}>{cel.text}</text> : null}
       </box>
     );
   };
 
-  // ============ State control ============
+  // ─── State control ───
   const setState = (s: MascotState) => {
-    const prev = currentState();
     setCurrentState(s);
+    setBreathPhase(true);
+    resetIdleSleep();
 
     if (s !== "idle") {
       stopWalk();
+    } else if (walkEnabled()) {
+      walkTimeout = scheduleNextWalk();
+      jumpTimeout = scheduleNextJump();
     }
+  };
 
-    if (s === "thinking" && prev !== "thinking") {
-      thinkingStartTime = Date.now();
-    } else if (s !== "thinking") {
-      thinkingStartTime = 0;
-      setStompActive(false);
+  const toggleWalk = () => {
+    const next = !walkEnabled();
+    setWalkEnabled(next);
+    if (!next) {
+      stopWalk();
+    } else if (currentState() === "idle") {
+      walkTimeout = scheduleNextWalk();
     }
+  };
 
-    if (s === "happy") {
-      startWave();
+  const setDragging = (v: boolean) => {
+    setDraggingSignal(v);
+    if (v) {
+      // 睡着时被拖拽 → 惊醒到 idle，切回 default 帧后手臂 ┃███┃ 才能被扇手渲染匹配
+      if (currentState() === "sleeping") {
+        setState("idle");
+      }
+      setJumpOffset(-1);
     } else {
-      stopWave();
+      setJumpOffset(0);
     }
   };
 
-  return { element, setState };
+  // 连续跳跃 + 吐火星文泡泡庆祝更新成功
+  const celebrateUpdate = (newVersion: string) => {
+    const bubbles = pack.bubbleTexts ?? ["ᵘᵖ~"];
+    if (currentState() === "sleeping") setState("idle");
+
+    let step = 0;
+    const JUMPS = 3;
+    const tick = () => {
+      if (step >= JUMPS) {
+        setJumpOffset(0);
+        setCelebrate(null);
+        return;
+      }
+      setJumpOffset(step % 2 === 0 ? -2 : 0);
+      const word = bubbles[Math.floor(Math.random() * bubbles.length)];
+      setCelebrate({ text: `${word} ᵘᵖ→ᵛ${newVersion}`, count: step });
+      step++;
+      setTimeout(tick, 600);
+    };
+    tick();
+  };
+
+  return { element, setState, toggleWalk, setDragging, celebrateUpdate };
 }

package/src/core/celebration-bus.ts

@@ -0,0 +1,16 @@
+const bus = new EventTarget();
+
+const CELEBRATE_EVENT = "mascot:celebrate";
+
+export function emitCelebrate(newVersion: string): void {
+  bus.dispatchEvent(new CustomEvent(CELEBRATE_EVENT, { detail: { newVersion } }));
+}
+
+export function onCelebrate(handler: (newVersion: string) => void): () => void {
+  const listener = (e: Event) => {
+    const detail = (e as CustomEvent).detail as { newVersion: string };
+    handler(detail.newVersion);
+  };
+  bus.addEventListener(CELEBRATE_EVENT, listener);
+  return () => bus.removeEventListener(CELEBRATE_EVENT, listener);
+}

package/src/core/mascot-loader.ts

@@ -1,18 +1,35 @@
 import type { MascotPack } from "./types"
 import { yueerPack } from "../builtins/yueer"
+import { baoziPack } from "../builtins/baozi"
 
 const BUILTINS: Record<string, MascotPack> = {
   yueer: yueerPack,
+  baozi: baoziPack,
+}
+
+const ALL_NAMES = Object.keys(BUILTINS)
+
+function randomPick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)]
+}
+
+export function loadAllMascots(): Record<string, MascotPack> {
+  return { ...BUILTINS }
+}
+
+export function getMascotNames(): string[] {
+  return [...ALL_NAMES]
+}
+
+export function getRandomMascot(): MascotPack {
+  return randomPick(Object.values(BUILTINS))
 }
 
 export async function loadMascot(options?: Record<string, unknown>): Promise<MascotPack> {
-  const mascotName = (options?.mascot as string) || "yueer"
-  
-  if (BUILTINS[mascotName]) {
-    return BUILTINS[mascotName]
-  }
-  
-  // Future: npm package loading, local file loading
-  // Fallback to yueer
-  return yueerPack
+  const mascotName = (options?.mascot as string) || "random"
+
+  if (mascotName === "random") return getRandomMascot()
+  if (BUILTINS[mascotName]) return BUILTINS[mascotName]
+
+  return getRandomMascot()
 }

package/src/core/types.ts

@@ -17,18 +17,12 @@ export interface AnimationConfig {
   blinkChance?: number;
   expressionInterval?: number;
   idleTimeout?: number;
-  /** Breathing cycle in ms (default: 3000) */
   breathInterval?: number;
-  /** Ahoge wobble check interval in ms (default: 1500) */
-  ahogeInterval?: number;
-  /** Probability of ahoge wobble per check (default: 0.25) */
-  ahogeChance?: number;
-  /** Minimum delay between jumps in ms (default: 20000) */
+  walkEnabled?: boolean;
+  walkMinDelay?: number;
+  walkMaxDelay?: number;
   jumpMinDelay?: number;
-  /** Maximum delay between jumps in ms (default: 40000) */
   jumpMaxDelay?: number;
-  /** Stomp trigger: ms in thinking state before stomping (default: 30000) */
-  stompThreshold?: number;
 }
 
 /**
@@ -39,26 +33,72 @@ export interface SidebarConfig {
   busyPhrases?: string[];
 }
 
+// ─── Effect system types ───
+
+/**
+ * A single extra signal managed by the effect system.
+ * The renderer creates a Solid signal for each and exposes get/set to timers and render.
+ */
+export interface SignalDef {
+  name: string;
+  initial: unknown;
+}
+
 /**
- * Context passed to render hooks.
+ * Timer context passed to EffectTimer.update().
  */
-export interface RenderContext {
+export interface EffectTimerCtx {
+  /** Read an extra signal by name */
+  get: (name: string) => unknown;
+  /** Write an extra signal by name */
+  set: (name: string, value: unknown) => void;
+  /** Current mascot state */
   state: MascotState;
-  frameIndex: number;
-  timestamp: number;
-  sessionData?: {
-    tokenUsage?: number;
-    tokenLimit?: number;
-    model?: string;
-  };
+  /** Current frame override (null = use state mapping) */
+  frameOverride: string | null;
+  /** Override the displayed frame */
+  setFrameOverride: (name: string | null) => void;
+}
+
+/**
+ * A recurring timer that updates extra signals.
+ */
+export interface EffectTimer {
+  /** Interval in ms */
+  interval: number;
+  /** Called on each tick */
+  update: (ctx: EffectTimerCtx) => void;
 }
 
 /**
- * Lifecycle hooks for customizing mascot behavior.
+ * Context passed to EffectRenderFn.
  */
-export interface MascotHooks {
-  beforeRender?: (context: RenderContext, frame: string[]) => string[];
-  onStateChange?: (prevState: MascotState, newState: MascotState) => void;
+export interface EffectRenderCtx {
+  state: MascotState;
+  frameName: string;
+  breathPhase: boolean;
+  jumpOffset: number;
+  dragging: boolean;
+  get: (name: string) => unknown;
+}
+
+/**
+ * Pack-defined render effect. Called after built-in rendering (breathing),
+ * before final output. Return modified lines.
+ */
+export type EffectRenderFn = (lines: string[], ctx: EffectRenderCtx) => string[];
+
+/**
+ * Effect bundle: extra signals, timers, and render function.
+ * Packs use this to define mascot-specific animations.
+ */
+export interface MascotEffects {
+  /** Extra signals (name → initial value) */
+  signals?: SignalDef[];
+  /** Recurring timers that drive signal changes */
+  timers?: EffectTimer[];
+  /** Render hook — modify lines based on signals */
+  render: EffectRenderFn;
 }
 
 /**
@@ -91,7 +131,16 @@ export interface MascotPack {
 
   animations?: AnimationConfig;
   sidebar?: SidebarConfig;
-  hooks?: MascotHooks;
+
+  /** Mascot-specific animation effects (timers + render) */
+  effects?: MascotEffects;
+
+  /** Thinking bubble phrases, shown when mascot is in busy/thinking state */
+  bubbleTexts?: string[];
+}
+
+export interface SwitchConfig {
+  onState?: Partial<Record<MascotState, string>>;
 }
 
 /**
@@ -101,4 +150,5 @@ export interface MascotConfig {
   mascot: string;
   animations: boolean;
   idleSleep: boolean;
+  switchConfig?: SwitchConfig;
 }