@linxin666/dsh-pet 0.3.19 → 0.3.21

package/src/gameplay.ts

@@ -572,6 +572,10 @@ export interface PetGameplayState {
   mode: 'work' | 'sleep' | null
   /** Epoch ms of the last lazy settle. */
   settledAt: number
+  /** Accumulated remainder ms towards the next passive income tick. */
+  incomeCarryMs?: number
+  /** Accumulated remainder ms towards the next sleep restore tick. */
+  restoreCarryMs?: number
 }
 
 /** Fresh state for one pet: stats at their initial (default max), no currency. */
@@ -624,7 +628,10 @@ export function settleGameplay(
     }
   }
   if (manifest.passiveIncome !== undefined) {
-    const ticks = Math.floor(elapsedMs / manifest.passiveIncome.intervalMs)
+    const incomeElapsed = elapsedMs + (state.incomeCarryMs ?? 0)
+    const interval = manifest.passiveIncome.intervalMs
+    const ticks = Math.floor(incomeElapsed / interval)
+    state.incomeCarryMs = incomeElapsed % interval
     if (ticks > 0) {
       const currency = manifest.passiveIncome.currency
       state.currencies[currency] = (state.currencies[currency] ?? 0) + ticks * manifest.passiveIncome.amount
@@ -632,12 +639,17 @@ export function settleGameplay(
     }
   }
   if (state.mode === 'sleep' && manifest.sleep !== undefined) {
-    const ticks = Math.floor(elapsedMs / manifest.sleep.restore.intervalMs)
+    const restoreElapsed = elapsedMs + (state.restoreCarryMs ?? 0)
+    const interval = manifest.sleep.restore.intervalMs
+    const ticks = Math.floor(restoreElapsed / interval)
+    state.restoreCarryMs = restoreElapsed % interval
     if (ticks > 0) {
       const stat = manifest.sleep.restore.stat
       state.stats[stat] = (state.stats[stat] ?? 0) + ticks * manifest.sleep.restore.amount
       changed = true
     }
+  } else {
+    state.restoreCarryMs = 0
   }
   state.settledAt = now
   clampGameplay(state, manifest)

package/src/ledger.test.ts

@@ -143,6 +143,25 @@ describe('PetLedger', () => {
     expect(ledger.takeDirty()).toBe(true)
   })
 
+  it('stores and clears the per-pet skin selection', () => {
+    const ledger = new PetLedger(emptyPersist())
+    expect(ledger.petSkin('jyn')).toBeUndefined()
+    ledger.setPetSkin('jyn', 'bingjing-gongzhu')
+    expect(ledger.petSkin('jyn')).toBe('bingjing-gongzhu')
+    expect(ledger.snapshot.skins).toEqual({ jyn: 'bingjing-gongzhu' })
+    expect(ledger.takeDirty()).toBe(true)
+    // Same value again: nothing changed, so no extra persist.
+    ledger.setPetSkin('jyn', 'bingjing-gongzhu')
+    expect(ledger.takeDirty()).toBe(false)
+    // undefined clears the entry back to the pet's default look.
+    ledger.setPetSkin('jyn', undefined)
+    expect(ledger.petSkin('jyn')).toBeUndefined()
+    expect(ledger.snapshot.skins).toEqual({})
+    expect(ledger.takeDirty()).toBe(true)
+    ledger.setPetSkin('jyn', undefined)
+    expect(ledger.takeDirty()).toBe(false)
+  })
+
   it('exposes the treat stock cap and display/pet/name setters', () => {
     const ledger = new PetLedger(emptyPersist())
     expect(ledger.treatMax).toBe(defaultTreatConfig.maxTreats)

package/src/ledger.ts

@@ -124,6 +124,30 @@ export class PetLedger {
     this.dirty = true
   }
 
+  /**
+   * Select one pet's frames2d skin; `undefined` clears the choice back to the
+   * pet's default look. Manifest validation stays a caller concern, exactly
+   * like setPetName's length check.
+   */
+  setPetSkin(petId: string, skinId: string | undefined): void {
+    const skins = this.current.skins
+    if (skinId === undefined) {
+      if (skins[petId] === undefined) return
+      const next = { ...skins }
+      delete next[petId]
+      this.current = { ...this.current, skins: next }
+    } else {
+      if (skins[petId] === skinId) return
+      this.current = { ...this.current, skins: { ...skins, [petId]: skinId } }
+    }
+    this.dirty = true
+  }
+
+  /** The persisted skin id for one pet (undefined = the pet's default look). */
+  petSkin(petId: string): string | undefined {
+    return this.current.skins[petId]
+  }
+
   /**
    * Swap the reaction pools to another pet's custom remarks (called on pet
    * selection). Slots the pet does not declare fall back to voice packs or built-ins.

package/src/persist.test.ts

@@ -49,6 +49,7 @@ describe('loadPetPersist', () => {
       const data = {
         petId: 'otter',
         names: { otter: '泡泡', 'whale-girl': '鲸鱼娘' },
+        skins: { otter: 'lanhainishang' },
         affinity: { ...emptyAffinity(), points: 42, pets: 3, feeds: 1, turns: 10 },
         treats: { ...emptyTreatLedger(), treats: 7, lastTreatGrantAt: 1234, turnsAtLastTreatGrant: 9 },
         display: { visible: false, size: 200, right: 10, bottom: 40 },
@@ -111,6 +112,18 @@ describe('loadPetPersist', () => {
     }
   })
 
+  it('sanitizes the per-pet skin map', () => {
+    const dir = tempDir()
+    try {
+      writeFileSync(join(dir, 'pet.json'), JSON.stringify({
+        skins: { otter: '  lanhainishang  ', blank: '   ', numeric: 7, '': 'x' },
+      }), 'utf8')
+      expect(loadPetPersist(dir).skins).toEqual({ otter: 'lanhainishang' })
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
   it('clamps out-of-range and non-numeric fields', () => {
     const dir = tempDir()
     try {

package/src/persist.ts

@@ -48,6 +48,12 @@ export interface PetPersist {
    * to its manifest displayName, so only user renames are stored here.
    */
   names: Record<string, string>
+  /**
+   * Per-pet selected frames2d skin id (keyed by pet id). Skin ids are manifest
+   * data, so a stale entry (skin renamed or removed, pet swapped) is ignored
+   * when the state view is built instead of pinning an unresolvable track.
+   */
+  skins: Record<string, string>
   affinity: AffinityState
   /** Treat (小鱼干) stock ledger. */
   treats: TreatLedger
@@ -63,6 +69,7 @@ export function emptyPersist(): PetPersist {
   return {
     petId: DEFAULT_PET_ID,
     names: {},
+    skins: {},
     affinity: emptyAffinity(),
     treats: emptyTreatLedger(),
     display: { ...defaultDisplayConfig },
@@ -100,6 +107,19 @@ function loadPetNames(parsed: PetPersistDocument): Record<string, string> {
   return names
 }
 
+/** Sanitize the per-pet skin selection map (string keys, non-empty trimmed values). */
+function loadPetSkins(parsed: PetPersistDocument): Record<string, string> {
+  const skins: Record<string, string> = {}
+  if (typeof parsed.skins !== 'object' || parsed.skins === null) return skins
+  for (const [id, value] of Object.entries(parsed.skins as Record<string, unknown>)) {
+    if (id === '' || typeof value !== 'string') continue
+    const skin = value.trim()
+    if (skin === '') continue
+    skins[id] = skin
+  }
+  return skins
+}
+
 /** Clamp one count/score into [0, max]. */
 function clamp(value: number, max: number): number {
   return Math.min(max, Math.max(0, value))
@@ -130,12 +150,19 @@ function loadGameplay(parsed: PetPersistDocument): Record<string, PetGameplaySta
         currencies[key] = Math.min(GAMEPLAY_LOAD_CURRENCY_CAP, Math.max(0, Math.floor(value)))
       }
     }
-    result[petId] = {
+    const item: PetGameplayState = {
       stats,
       currencies,
       mode: record.mode === 'work' || record.mode === 'sleep' ? record.mode : null,
       settledAt: clamp(finiteNum(record.settledAt, 0), Number.MAX_SAFE_INTEGER),
     }
+    if (typeof record.incomeCarryMs === 'number' && Number.isFinite(record.incomeCarryMs)) {
+      item.incomeCarryMs = Math.max(0, record.incomeCarryMs)
+    }
+    if (typeof record.restoreCarryMs === 'number' && Number.isFinite(record.restoreCarryMs)) {
+      item.restoreCarryMs = Math.max(0, record.restoreCarryMs)
+    }
+    result[petId] = item
   }
   return result
 }
@@ -185,6 +212,7 @@ export function loadPetPersist(dir: string = petHomeDir()): PetPersist {
     return {
       petId,
       names,
+      skins: loadPetSkins(parsed),
       affinity,
       treats,
       display,

package/src/routes.ts

@@ -603,6 +603,11 @@ export function makePetRoutes(deps: { service: PetService; ctx: Context; assetCa
       if (typeof name !== 'string') return Promise.reject(new Error('invalid-name'))
       return service.setName(name)
     }),
+    postRoute(ctx, PET_API_PREFIX + '/set-skin', (body) => {
+      const skin = body.skin
+      if (skin !== undefined && typeof skin !== 'string') return Promise.reject(new Error('invalid-skin'))
+      return service.setSkin(skin === undefined || skin === '' ? undefined : skin)
+    }),
     postRoute(ctx, PET_API_PREFIX + '/set-pet', (body) => {
       const petId = body.petId
       if (typeof petId !== 'string') return Promise.reject(new Error('invalid-pet'))

package/src/service.ts

@@ -13,6 +13,7 @@
  */
 
 import { Context, Service } from '@deepseek-ai/cordis'
+import type { AssistantStreamFrame } from '@deepseek-ai/dsh-agent'
 import type { Session, SessionEvent } from '@deepseek-ai/dsh-session'
 import type { AffinityConfig, PetAffinityView, PetInteraction } from './affinity.ts'
 import { announcementFresh, parseAnnouncement, type PetAnnouncement } from './announce.ts'
@@ -20,6 +21,7 @@ import type { TreatConfig } from './treats.ts'
 import {
   emptyProjectionRuntime,
   isActivityPhase,
+  projectAssistantStreamFrame,
   projectOfficialEvent,
   type ActivityStatusEventLike,
   type ProjectionRuntime,
@@ -173,6 +175,12 @@ export interface PetStateView {
   }
   /** The selected pet's display name (user rename or manifest default). */
   name: string
+  /**
+   * The selected frames2d skin id for this pet (absent = the pet's default
+   * look). Persisted host-side, so a page reload or client restart restores
+   * the user's last choice instead of falling back to the default look.
+   */
+  skin?: string
   /** Treat (小鱼干) stock snapshot. */
   treats: {
     /** Stocked treats now. */
@@ -466,6 +474,15 @@ export class PetService extends Service {
             this.rewardTurn(String(session.id), transition.completedTurn)
           }
         }),
+        this.ctx.on('agent/assistant-stream', ({ agent, frame }: { agent: { session: Session }; frame: AssistantStreamFrame }) => {
+          const session = agent.session
+          const runtime = this.activityOf(session).runtime
+          const transition = projectAssistantStreamFrame(frame, runtime)
+          if (transition === undefined) return
+          runtime.officialEventsSeen = true
+          this.officialEventSessions.add(session)
+          this.applyActivity(session, transition.input, transition.whisper)
+        }),
         this.ctx.on('session/disposed', (session: Session) => {
           this.ledger.forgetSession(String(session.id))
           this.officialEventSessions.delete(session)
@@ -709,6 +726,36 @@ export class PetService extends Service {
     return { ok: true, display: this.ledger.snapshot.display }
   }
 
+  /**
+   * The persisted skin for one entry, when the manifest still declares it: a
+   * stale id (skin removed from the manifest, pet swapped) reads as "default"
+   * rather than pinning a track the browser half cannot resolve.
+   */
+  private persistedSkin(entry: NonNullable<PetRegistry['entries'][number]>): string | undefined {
+    const stored = this.ledger.petSkin(entry.id)
+    if (stored === undefined) return undefined
+    return entry.frames2d?.skins?.some(skin => skin.id === stored) === true ? stored : undefined
+  }
+
+  /**
+   * RPC: select the current pet's frames2d skin (`undefined` restores the
+   * pet's default look). The choice is stored per pet, so every later state
+   * view (reload, client restart, pet re-selection) serves it back.
+   */
+  async setSkin(skin: string | undefined): Promise<{ ok: true; skin?: string } | { ok: false; error: string }> {
+    const entry = this.activeEntry()
+    const declared = entry.frames2d?.skins ?? []
+    if (skin === undefined) {
+      this.ledger.setPetSkin(entry.id, undefined)
+      this.flush()
+      return { ok: true }
+    }
+    if (!declared.some(candidate => candidate.id === skin)) return { ok: false, error: 'unknown-skin' }
+    this.ledger.setPetSkin(entry.id, skin)
+    this.flush()
+    return { ok: true, skin }
+  }
+
   /** RPC: update display config (size / position). Values are clamped to whole pixels. */
   async setConfig(patch: Partial<PetDisplayConfig>): Promise<{ ok: true; display: PetDisplayConfig }> {
     const next = { ...this.ledger.snapshot.display, ...patch }
@@ -839,6 +886,7 @@ export class PetService extends Service {
     const announcement = this.announcement !== undefined && announcementFresh(this.announcement, Date.now())
       ? this.announcement
       : undefined
+    const skin = this.persistedSkin(entry)
     return {
       animation: snapshot.animation,
       ...(snapshot.bubble === undefined ? {} : { bubble: snapshot.bubble }),
@@ -855,6 +903,7 @@ export class PetService extends Service {
         description: entry.description,
       },
       name: this.petName(),
+      ...(skin === undefined ? {} : { skin }),
       treats: {
         stocked: this.ledger.snapshot.treats.treats,
         max: this.ledger.treatMax,