@wanghaopeng1148/deskpet 2.0.0

package/shared/animation-engine.ts

@@ -0,0 +1,422 @@
+/**
+ * 动画引擎 — 5 状态动画调度、优先级管理、算法微动
+ *
+ * 从旧版 Python animation_engine.py 1:1 移植。
+ *
+ * 状态优先级: 点击(4) > 忙碌(3) > 悬浮(2) > 待机(1) > 休眠(0)
+ * 过渡: 0.15s 线性插值
+ * 点击动画: 跳跃 / 压扁回弹 / 左右抖动 轮流触发
+ */
+import { ClickAnimationType, PetState } from './types.ts'
+
+export interface StateParams {
+  fps: number
+  /** 上下浮动幅度(px) */
+  floatAmplitudePx: number
+  /** 浮动周期(s) */
+  floatPeriodS: number
+  /** 基础缩放 */
+  scaleBase: number
+  /** 缩放变化幅度 */
+  scaleAmplitude: number
+  /** 旋转微动幅度(度) */
+  rotationAmplitude: number
+  /** 循环周期(s) */
+  cycleDurationS: number
+  /** 淡入淡出时长(s) */
+  fadeDurationS: number
+}
+
+const STATE_PARAMS: Record<PetState, StateParams> = {
+  [PetState.SLEEP]: {
+    fps: 10,
+    floatAmplitudePx: 1.0,
+    floatPeriodS: 5.0,
+    scaleBase: 1.0,
+    scaleAmplitude: 0.01,
+    rotationAmplitude: 0.0,
+    cycleDurationS: 5.0,
+    fadeDurationS: 0.15
+  },
+  [PetState.IDLE]: {
+    fps: 20,
+    floatAmplitudePx: 0.0,
+    floatPeriodS: 2.5,
+    scaleBase: 1.0,
+    scaleAmplitude: 0.0,
+    rotationAmplitude: 0.0,
+    cycleDurationS: 2.5,
+    fadeDurationS: 0.15
+  },
+  [PetState.HOVER]: {
+    fps: 30,
+    floatAmplitudePx: 2.0,
+    floatPeriodS: 1.5,
+    scaleBase: 1.05,
+    scaleAmplitude: 0.01,
+    rotationAmplitude: 2.0,
+    cycleDurationS: 1.5,
+    fadeDurationS: 0.15
+  },
+  [PetState.BUSY]: {
+    fps: 30,
+    floatAmplitudePx: 4.0,
+    floatPeriodS: 1.2,
+    scaleBase: 1.0,
+    scaleAmplitude: 0.03,
+    rotationAmplitude: 3.0,
+    cycleDurationS: 1.2,
+    fadeDurationS: 0.15
+  },
+  [PetState.CLICK]: {
+    fps: 30,
+    floatAmplitudePx: 0.0,
+    floatPeriodS: 0.4,
+    scaleBase: 1.0,
+    scaleAmplitude: 0.0,
+    rotationAmplitude: 0.0,
+    cycleDurationS: 0.4,
+    fadeDurationS: 0.15
+  }
+}
+
+/** 点击动画时长（按类型） */
+const CLICK_DURATIONS: Record<ClickAnimationType, number> = {
+  [ClickAnimationType.JUMP]: 0.6,
+  [ClickAnimationType.SQUASH]: 0.5,
+  [ClickAnimationType.SHAKE]: 0.5
+}
+
+/** 单帧变换参数（渲染层直接消费） */
+export interface AnimationFrame {
+  offsetX: number
+  offsetY: number
+  scale: number
+  rotation: number
+  opacity: number
+  state: PetState
+}
+
+export type StateChangeCallback = (oldState: PetState, newState: PetState) => void
+
+export class AnimationEngine {
+  private currentState: PetState = PetState.IDLE
+  private targetState: PetState = PetState.IDLE
+  private previousState: PetState = PetState.IDLE
+
+  private stateStartTime: number
+  private lastInteractionTime: number
+  private idleTimeoutS: number
+
+  private clickAnimating = false
+  private clickStartTime = 0
+  private clickDuration = STATE_PARAMS[PetState.CLICK].cycleDurationS
+  private clickAnimType: ClickAnimationType = ClickAnimationType.SQUASH
+  private clickAnimCycle: ClickAnimationType[] = [
+    ClickAnimationType.JUMP,
+    ClickAnimationType.SQUASH,
+    ClickAnimationType.SHAKE
+  ]
+  private clickAnimIndex = 0
+
+  private inTransition = false
+  private transitionStart = 0
+  private transitionDuration = 0.15
+
+  private enabled = true
+  private speedMultiplier = 1.0
+  private amplitudeMultiplier = 1.0
+
+  private stateChangeCallbacks: StateChangeCallback[] = []
+
+  constructor(idleTimeoutS = 180.0) {
+    this.stateStartTime = now()
+    this.lastInteractionTime = now()
+    this.idleTimeoutS = idleTimeoutS
+  }
+
+  /** 当前对外状态（过渡期间返回目标状态） */
+  get state(): PetState {
+    return this.inTransition ? this.targetState : this.currentState
+  }
+
+  get isSleeping(): boolean {
+    return this.currentState === PetState.SLEEP
+  }
+
+  get isEnabled(): boolean {
+    return this.enabled
+  }
+
+  setEnabled(value: boolean): void {
+    this.enabled = value
+  }
+
+  get speed(): number {
+    return this.speedMultiplier
+  }
+
+  setSpeed(value: number): void {
+    this.speedMultiplier = clamp(value, 0.1, 5.0)
+  }
+
+  get amplitude(): number {
+    return this.amplitudeMultiplier
+  }
+
+  setAmplitude(value: number): void {
+    this.amplitudeMultiplier = clamp(value, 0.1, 5.0)
+  }
+
+  /** 当前状态已持续毫秒数（渲染层用于推进精灵帧） */
+  get stateElapsedMs(): number {
+    return (now() - this.stateStartTime) * 1000
+  }
+
+  /** 请求切换到指定状态（遵循优先级规则） */
+  requestState(state: PetState, force = false): boolean {
+    if (!this.enabled && state !== PetState.SLEEP) return false
+
+    // 点击动画播放中，仅更高优先级可打断
+    if (this.clickAnimating) {
+      if (state > PetState.CLICK) {
+        this.clickAnimating = false
+      } else {
+        return false
+      }
+    }
+
+    const effectiveState = this.inTransition ? this.targetState : this.currentState
+
+    // 优先级检查（SLEEP 总是允许）
+    if (!force && state < effectiveState && state !== PetState.SLEEP) return false
+
+    // 同状态不重复切换（CLICK 总是响应）
+    if (state === effectiveState && state !== PetState.CLICK) {
+      this.lastInteractionTime = now()
+      return true
+    }
+
+    // ── CLICK 单次动画 ──────────────────────────────
+    if (state === PetState.CLICK) {
+      this.clickAnimating = true
+      this.clickStartTime = now()
+      this.clickAnimType = this.clickAnimCycle[this.clickAnimIndex]
+      this.clickAnimIndex = (this.clickAnimIndex + 1) % this.clickAnimCycle.length
+      this.clickDuration = CLICK_DURATIONS[this.clickAnimType] ?? 0.4
+      // 点击动画即时响应，跳过过渡
+      this.previousState = this.currentState
+      this.currentState = state
+      this.inTransition = false
+      this.stateStartTime = now()
+      this.lastInteractionTime = now()
+      this.emitStateChange(this.previousState, state)
+      return true
+    }
+
+    this.previousState = this.currentState
+    this.targetState = state
+    this.startTransition()
+    this.lastInteractionTime = now()
+    this.emitStateChange(this.previousState, this.targetState)
+    return true
+  }
+
+  /** 通知有用户交互（重置闲置计时器） */
+  notifyInteraction(): void {
+    this.lastInteractionTime = now()
+  }
+
+  /**
+   * 计算当前帧变换参数（每帧调用一次，渲染层 rAF 驱动）
+   */
+  computeFrame(): AnimationFrame {
+    const t = now()
+
+    // ── 状态过渡 ────────────────────────────────────
+    if (this.inTransition) {
+      const progress = (t - this.transitionStart) / this.transitionDuration
+      if (progress >= 1.0) {
+        this.finishTransition()
+      } else {
+        const prev = this.computeStateFrame(this.previousState, t)
+        const target = this.computeStateFrame(this.targetState, t)
+        const p = clamp(progress, 0, 1)
+        return {
+          offsetX: lerp(prev.offsetX, target.offsetX, p),
+          offsetY: lerp(prev.offsetY, target.offsetY, p),
+          scale: lerp(prev.scale, target.scale, p),
+          rotation: lerp(prev.rotation, target.rotation, p),
+          opacity: lerp(prev.opacity, target.opacity, p),
+          state: this.targetState
+        }
+      }
+    }
+
+    // ── 点击动画单次处理 ────────────────────────────
+    if (this.clickAnimating) {
+      const elapsed = t - this.clickStartTime
+      if (elapsed >= this.clickDuration) {
+        this.clickAnimating = false
+        this.previousState = this.currentState
+        this.targetState = PetState.IDLE
+        this.startTransition()
+        return this.computeFrame() // 递归一次获取过渡帧
+      }
+      return this.computeClickFrame(elapsed)
+    }
+
+    // ── 闲置检测（超时进入休眠） ────────────────────
+    if (
+      this.idleTimeoutS > 0 &&
+      this.currentState !== PetState.SLEEP &&
+      this.currentState !== PetState.CLICK
+    ) {
+      const idle = t - this.lastInteractionTime
+      if (idle >= this.idleTimeoutS) {
+        this.requestState(PetState.SLEEP)
+      }
+    }
+
+    return this.computeStateFrame(this.currentState, t)
+  }
+
+  private computeStateFrame(state: PetState, t: number): AnimationFrame {
+    const params = STATE_PARAMS[state]
+    const elapsed = t - this.stateStartTime
+
+    const period = params.cycleDurationS / Math.max(this.speedMultiplier, 0.01)
+    const phase = (elapsed % period) / period
+    const wave = easeInOutSine(phase)
+
+    const frame: AnimationFrame = {
+      offsetX: 0,
+      offsetY: wave * params.floatAmplitudePx * this.amplitudeMultiplier,
+      scale: params.scaleBase + wave * params.scaleAmplitude * this.amplitudeMultiplier,
+      rotation: wave * params.rotationAmplitude * this.amplitudeMultiplier,
+      opacity: 1.0,
+      state
+    }
+
+    if (state === PetState.SLEEP) {
+      frame.opacity = 0.95 + wave * 0.05
+    }
+
+    return frame
+  }
+
+  private computeClickFrame(elapsed: number): AnimationFrame {
+    const total = this.clickDuration
+    const progress = Math.min(elapsed / total, 1.0)
+    switch (this.clickAnimType) {
+      case ClickAnimationType.JUMP:
+        return this.computeJumpFrame(progress)
+      case ClickAnimationType.SQUASH:
+        return this.computeSquashFrame(progress)
+      default:
+        return this.computeShakeFrame(progress)
+    }
+  }
+
+  /** 跳跃: 上升 → 下落 → 落地压扁 → 回弹恢复 (0.6s) */
+  private computeJumpFrame(progress: number): AnimationFrame {
+    const jumpHeight = 35.0
+    let offsetY = 0
+    let scale = 1.0
+
+    if (progress < 0.35) {
+      const t = progress / 0.35
+      offsetY = -jumpHeight * (2 * t - t * t)
+    } else if (progress < 0.65) {
+      const t = (progress - 0.35) / 0.3
+      offsetY = -jumpHeight * (1 - t * t)
+    } else if (progress < 0.8) {
+      const t = (progress - 0.65) / 0.15
+      scale = 1.0 - 0.1 * t
+    } else {
+      const t = (progress - 0.8) / 0.2
+      scale = 0.9 + 0.1 * t
+    }
+
+    return { offsetX: 0, offsetY, scale, rotation: 0, opacity: 1, state: PetState.CLICK }
+  }
+
+  /** 压扁回弹: 压扁 100→82% → 拉伸 82→112% → 回弹 (0.5s) */
+  private computeSquashFrame(progress: number): AnimationFrame {
+    let scale: number
+    if (progress < 0.35) {
+      const t = progress / 0.35
+      scale = 1.0 - 0.18 * t
+    } else if (progress < 0.65) {
+      const t = (progress - 0.35) / 0.3
+      scale = 0.82 + 0.3 * t
+    } else {
+      const t = (progress - 0.65) / 0.35
+      scale = 1.12 - 0.12 * t
+    }
+    return { offsetX: 0, offsetY: 0, scale, rotation: 0, opacity: 1, state: PetState.CLICK }
+  }
+
+  /** 左右抖动: 高频正弦摆动，幅度衰减 (0.5s) */
+  private computeShakeFrame(progress: number): AnimationFrame {
+    const maxOffset = 10.0
+    const decay = 1.0 - progress * 0.7
+    const shake = Math.sin(progress * Math.PI * 6) * maxOffset * decay
+    return { offsetX: shake, offsetY: 0, scale: 1, rotation: 0, opacity: 1, state: PetState.CLICK }
+  }
+
+  private startTransition(): void {
+    this.inTransition = true
+    this.transitionStart = now()
+  }
+
+  private finishTransition(): void {
+    this.inTransition = false
+    this.currentState = this.targetState
+    this.stateStartTime = now()
+  }
+
+  /** 注册状态变更回调 */
+  onStateChange(cb: StateChangeCallback): () => void {
+    this.stateChangeCallbacks.push(cb)
+    return () => {
+      const i = this.stateChangeCallbacks.indexOf(cb)
+      if (i >= 0) this.stateChangeCallbacks.splice(i, 1)
+    }
+  }
+
+  private emitStateChange(oldState: PetState, newState: PetState): void {
+    for (const cb of this.stateChangeCallbacks) {
+      try {
+        cb(oldState, newState)
+      } catch {
+        // 回调异常不阻断引擎
+      }
+    }
+  }
+
+  /** 批量配置动画参数 */
+  configure(enabled: boolean, speed: number, amplitude: number): void {
+    this.enabled = enabled
+    this.speedMultiplier = speed
+    this.amplitudeMultiplier = amplitude
+  }
+}
+
+// ── 工具函数 ────────────────────────────────────────────────
+
+function now(): number {
+  return performance.now() / 1000
+}
+
+function clamp(v: number, min: number, max: number): number {
+  return Math.max(min, Math.min(v, max))
+}
+
+function lerp(a: number, b: number, t: number): number {
+  return a + (b - a) * clamp(t, 0, 1)
+}
+
+function easeInOutSine(t: number): number {
+  return Math.sin(t * Math.PI * 2)
+}

package/shared/chain-condition.ts

@@ -0,0 +1,60 @@
+/**
+ * 任务链条件判定（方案 §3.3.B：条件分支——退出码/输出匹配）
+ *
+ * 语法:
+ *   （空）/ always / 成功   → 仅成功时继续
+ *   failed / 失败           → 仅失败时继续
+ *   exit==0 / exit!=0 / exit>=N ...  → 按脚本退出码
+ *   output contains xxx     → stdout 包含子串
+ */
+import type { ActionResult } from './types.ts'
+
+export interface ChainContext {
+  success: boolean
+  exitCode: number | null
+  stdout: string
+}
+
+export function evalChainCondition(
+  cond: string | null | undefined,
+  ctx: ChainContext
+): boolean {
+  const c = (cond ?? '').trim().toLowerCase()
+  if (!c || c === 'always' || c === 'success' || c === '成功') return ctx.success
+  if (c === 'failed' || c === '失败') return !ctx.success
+
+  const m = /^exit\s*(==|!=|>=|<=|>|<)\s*(-?\d+)$/.exec(c)
+  if (m) {
+    const code = ctx.exitCode ?? (ctx.success ? 0 : -1)
+    const target = parseInt(m[2], 10)
+    switch (m[1]) {
+      case '==':
+        return code === target
+      case '!=':
+        return code !== target
+      case '>=':
+        return code >= target
+      case '<=':
+        return code <= target
+      case '>':
+        return code > target
+      case '<':
+        return code < target
+    }
+  }
+
+  const om = /^output\s+contains\s+(.+)$/.exec(c)
+  if (om) return ctx.stdout.toLowerCase().includes(om[1].trim().toLowerCase())
+
+  // 未知条件按成功处理
+  return ctx.success
+}
+
+/** 便捷：从 ActionResult 构造判定上下文 */
+export function chainContextOf(result: ActionResult): ChainContext {
+  return {
+    success: result.success,
+    exitCode: result.exitCode ?? null,
+    stdout: result.stdout ?? ''
+  }
+}

package/shared/cron-weekly.ts

@@ -0,0 +1,131 @@
+/**
+ * 每周定时（cron）的友好表达 —— 对齐旧版「指定时间（每天/每周）」的交互
+ *
+ * 旧版 pet（src/ui/task_panel.py）是「HH:MM 输入框 + 周一~周日复选框」，
+ * 保存为 `分 时 * * 周几`。这里把这套搬到 Web 端，并加上 cron 描述文本。
+ *
+ * ⚠️ 周几编号采用**标准 cron 语义**：0=周日, 1=周一, ... 6=周六
+ *    （与 node-schedule / crontab 一致，调度器直接用 schedule.scheduleJob(cron)）。
+ *    旧版把「周一」映射成 0，与标准相反（属旧版 bug），此处**不沿用**——
+ *    否则周一的任务会在周日跑。
+ */
+
+/** 显示顺序（中文习惯从周一开始） */
+export const WEEKDAY_ORDER = [1, 2, 3, 4, 5, 6, 0] as const
+
+/** cron 值 → 中文名 */
+export const WEEKDAY_NAMES: Record<number, string> = {
+  1: '周一',
+  2: '周二',
+  3: '周三',
+  4: '周四',
+  5: '周五',
+  6: '周六',
+  0: '周日'
+}
+
+/** 全部 7 天（cron 值） */
+export const ALL_WEEKDAYS = [0, 1, 2, 3, 4, 5, 6]
+
+export interface WeeklyCron {
+  hour: number
+  minute: number
+  /** cron 周几值（0=周日） */
+  weekdays: number[]
+}
+
+function norm(v: number, max: number): number {
+  if (!Number.isFinite(v)) return 0
+  const n = Math.round(v)
+  return Math.max(0, Math.min(max, n))
+}
+
+function mod7(v: number): number {
+  return ((v % 7) + 7) % 7
+}
+
+/**
+ * 解析「分 时 * * 周几」形式的 cron
+ * @returns 解析成功返回 {hour, minute, weekdays}；
+ *          无法表示为「每周定时」（如带步进写法、指定了日/月、跨周区间）时返回 null，
+ *          调用方应回退到「手动编辑 cron 表达式」，避免把用户的表达式改坏。
+ */
+export function parseWeeklyCron(cron: string | null | undefined): WeeklyCron | null {
+  const s = (cron ?? '').trim()
+  if (!s) return null
+  const parts = s.split(/\s+/)
+  if (parts.length !== 5) return null
+  const [mi, ho, dom, mon, dow] = parts
+
+  // 只支持「每周」形态：日、月字段必须为 *
+  if (dom !== '*' || mon !== '*') return null
+  if (!/^\d{1,2}$/.test(mi) || !/^\d{1,2}$/.test(ho)) return null
+
+  const minute = Number(mi)
+  const hour = Number(ho)
+  if (minute > 59 || hour > 23) return null
+
+  const weekdays = parseDowField(dow)
+  if (!weekdays) return null
+  return { hour, minute, weekdays }
+}
+
+function parseDowField(field: string): number[] | null {
+  const f = field.trim()
+  if (f === '*' || f === '?') return [...ALL_WEEKDAYS]
+  const set = new Set<number>()
+  for (const raw of f.split(',')) {
+    const token = raw.trim()
+    if (!token) return null
+    // 步进（*/2、1-5/2）不在友好 UI 的表达范围内 → 交给手动编辑
+    if (token.includes('/')) return null
+    const m = /^(\d)(?:-(\d))?$/.exec(token)
+    if (!m) return null
+    const a = Number(m[1])
+    const b = m[2] === undefined ? a : Number(m[2])
+    if (a > 7 || b > 7) return null
+    if (a > b) return null // 跨周环绕（如 6-1）不支持
+    for (let i = a; i <= b; i++) set.add(mod7(i))
+  }
+  return set.size > 0 ? [...set].sort((x, y) => x - y) : null
+}
+
+/**
+ * 由「时间 + 周几」生成 cron
+ * - 7 天全选（或全不选）→ 周几字段用 `*`（每天）
+ */
+export function buildWeeklyCron(minute: number, hour: number, weekdays: number[]): string {
+  const m = norm(minute, 59)
+  const h = norm(hour, 23)
+  const set = [...new Set((weekdays ?? []).map(mod7))].sort((a, b) => a - b)
+  const dow = set.length === 0 || set.length === 7 ? '*' : set.join(',')
+  return `${m} ${h} * * ${dow}`
+}
+
+/** 生成中文说明（任务列表展示用），如「每周一、三、五 17:55」「每天 09:00」 */
+export function formatWeeklyCron(cron: string | null | undefined): string | null {
+  const p = parseWeeklyCron(cron)
+  if (!p) return null
+  const time = `${String(p.hour).padStart(2, '0')}:${String(p.minute).padStart(2, '0')}`
+  if (p.weekdays.length === 7) return `每天 ${time}`
+  // 按中文习惯顺序（周一 → 周日）展示；后续项省略「周」字 → 「每周一、三、五」
+  const labels = WEEKDAY_ORDER.filter((w) => p.weekdays.includes(w)).map(
+    (w) => WEEKDAY_NAMES[w] ?? String(w)
+  )
+  const joined = labels.map((n, i) => (i === 0 ? n : n.replace(/^周/, ''))).join('、')
+  return `每${joined} ${time}`
+}
+
+/** 快速选择预设 */
+export const WEEKDAY_PRESETS: Array<{ label: string; weekdays: number[] }> = [
+  { label: '每天', weekdays: [...ALL_WEEKDAYS] },
+  { label: '工作日', weekdays: [1, 2, 3, 4, 5] },
+  { label: '周末', weekdays: [6, 0] }
+]
+
+/** 判断两个周几数组是否等价（忽略顺序与重复） */
+export function sameWeekdays(a: number[], b: number[]): boolean {
+  const sa = [...new Set(a.map(mod7))].sort((x, y) => x - y).join(',')
+  const sb = [...new Set(b.map(mod7))].sort((x, y) => x - y).join(',')
+  return sa === sb
+}