dsh-piggy 0.25.0

package/packages/pet-core/src/core/settlement.js

@@ -0,0 +1,308 @@
+// @ts-check
+/**
+ * 时间推进：衰减、疾病、结算、死亡。
+ *
+ * 纯函数领域逻辑：时间由 nowMs 传入，不读写文件、不碰 DOM（见 docs/CONVENTIONS.md）。
+ * @module dsh-piggy/core/settlement
+ */
+
+import { CERTIFICATE_AFTER, DEFAULT_TIME_SCALE, ILLNESS_ONSET, GRADUATION_GROWTH, GRADUATION_LESSONS, SICK_AWAY_MULTIPLIER, SICK_PAY_MULTIPLIER, STUDY_GROWTH_PER_LESSON, TRAITS, illnessStageMs, interestByKey, jobByKey, rarityByKey, schoolStageByKey, stageForNextLesson, subjectByKey, traitBonus, tripByKey } from '../data.js'
+import { AWAY_DECAY_MULTIPLIER, AWAY_FLOOR, CLEANLINESS_DECAY_PER_MIN, HAPPINESS_DECAY_PER_MIN, SATIETY_DECAY_PER_MIN, SETTLE_STEP_MS } from './constants.js'
+import { announce, clamp100, remember } from './effects.js'
+import { growWithTime, grow, outingGrowth } from './growth.js'
+import { describeDrops, graduationDrops, studyDrops, workDrops } from './drops.js'
+import { advanceIllness, noteOuting, restAtHome, rollForIllness } from './illness.js'
+import { say } from './lines.js'
+import { rollerFor } from './random.js'
+import { noteToday } from './diary.js'
+
+export { currentIllness, die } from './illness.js'
+
+// ---------------------------------------------------------------------------
+// The clock: decay, activity settlement, illness progression
+// ---------------------------------------------------------------------------
+
+/**
+ * Bring the pig up to `nowMs`, resolving everything that happened in between.
+ *
+ * The gap is cut into at most two stretches — away until the activity ends,
+ * then home — and each stretch is walked in steps of SETTLE_STEP_MS. That is
+ * what lets a long absence play out the way it would have live: a job that
+ * ended at 18:56 is paid (and stamped) at 18:56, the evening after it is time
+ * at home, and a bar that crosses a threshold at 3 a.m. starts its sickness
+ * risk at 3 a.m. rather than at whatever moment the panel was next opened.
+ *
+ * Randomness comes from the pig's own seed (see random.js); pass `roll` to pin
+ * the outcome, as the tests and dev mode do.
+ *
+ * @param {object} state
+ * @param {number} nowMs
+ * @param {{roll?: import('./random.js').Roll}} [options]
+ */
+export function decay(state, nowMs, options = {}) {
+  const fromMs = state.lastSeenAt ?? nowMs
+  state.lastSeenAt = nowMs
+  // An unopened box is not a pet yet: it never gets hungry, dirty, sick or
+  // older, and it cannot die while it waits to be poked open (#2).
+  if (state.hatched !== true) return state
+  if (!(nowMs > fromMs) || state.dead === true) return state
+  const next = options.roll ?? rollerFor(state)
+  if (typeof state.ageMs !== 'number' || !Number.isFinite(state.ageMs)) {
+    // First tick after loading an old save: seed pig time from the birthday.
+    state.ageMs = typeof state.bornAt === 'number' ? Math.max(0, fromMs - state.bornAt) : 0
+  }
+
+  let cursor = fromMs
+  const activity = state.activity
+  if (activity !== null && activity !== undefined) {
+    const untilMs = Math.min(nowMs, Math.max(cursor, activity.endsAt))
+    passTime(state, { fromMs: cursor, toMs: untilMs, away: true }, next)
+    cursor = untilMs
+    // Settle at the moment it ended, not at the moment someone looked.
+    if (state.dead !== true && state.activity === activity && untilMs >= activity.endsAt) {
+      finishActivity(state, untilMs, next)
+    }
+  }
+  if (state.dead !== true) passTime(state, { fromMs: cursor, toMs: nowMs, away: false }, next)
+  return state
+}
+
+/**
+ * Walk one stretch, all of it either away or at home, in bounded steps.
+ * @param {object} state
+ * @param {{fromMs: number, toMs: number, away: boolean}} stretch
+ * @param {import('./random.js').Roll} next
+ */
+function passTime(state, stretch, next) {
+  let cursor = stretch.fromMs
+  while (cursor < stretch.toMs && state.dead !== true) {
+    const stepEnd = Math.min(stretch.toMs, cursor + SETTLE_STEP_MS)
+    step(state, { elapsedMs: stepEnd - cursor, atMs: stepEnd, away: stretch.away }, next)
+    cursor = stepEnd
+  }
+}
+
+/**
+ * One step of pig time: bars, sickness risk, illness, age.
+ * @param {object} state
+ * @param {{elapsedMs: number, atMs: number, away: boolean}} tick
+ * @param {import('./random.js').Roll} next
+ */
+function step(state, tick, next) {
+  const { elapsedMs, atMs, away } = tick
+  drainBars(state, elapsedMs / 60000, away)
+  trackSicknessRisk(state, elapsedMs / 60000, away, atMs, next)
+  progressIllness(state, elapsedMs, { away, atMs }, next)
+  if (state.dead !== true) growOlder(state, elapsedMs, atMs)
+}
+
+/**
+ * Time passing, with one floor: an activity may not empty a bar on its own.
+ * A pig back from a day trip should be ravenous and filthy — a welcome-home
+ * meal and bath — not sitting at zero before you can even react to it.
+ * Going away never *raises* a bar either.
+ */
+function drainBars(state, minutes, away) {
+  const speed = away ? AWAY_DECAY_MULTIPLIER : 1
+  const drain = (value, perMinute) => {
+    const lowered = value - minutes * perMinute * speed
+    return away ? Math.max(lowered, Math.min(value, AWAY_FLOOR)) : lowered
+  }
+  state.satiety = clamp100(drain(state.satiety, SATIETY_DECAY_PER_MIN))
+  state.happiness = clamp100(drain(state.happiness, HAPPINESS_DECAY_PER_MIN))
+  state.cleanliness = clamp100(drain(state.cleanliness, CLEANLINESS_DECAY_PER_MIN))
+}
+
+/**
+ * Illness only comes from being left at home. A pig that was out living its
+ * life has not been neglected, and coming back sick every trip is not a game.
+ * At home each condition adds its own hourly chance (see illness.js).
+ */
+function trackSicknessRisk(state, minutes, away, atMs, next) {
+  if (away) return
+  restAtHome(state, minutes)
+  rollForIllness(state, { minutes, atMs }, next)
+}
+
+/**
+ * Illness advances on accumulated *effective* time, not wall clock: being out
+ * and about while ill runs it at SICK_AWAY_MULTIPLIER, so a day of work costs
+ * two days of illness and staying home is the cheap way to wait it out.
+ */
+function progressIllness(state, elapsedMs, where, next) {
+  if (state.illness === null || state.illness === undefined) return
+  const rate = where.away ? SICK_AWAY_MULTIPLIER : 1
+  state.illness.progressMs = (state.illness.progressMs ?? 0) + elapsedMs * rate
+  let guard = 0
+  while (state.illness !== null && guard < 16) {
+    // Each stage has its own length, so it has to be re-read after every step.
+    const stageMs = illnessStageMs(state.illness.stage)
+    if (state.illness.progressMs < stageMs) break
+    // Carry the excess into the next stage rather than dropping it.
+    const carried = state.illness.progressMs - stageMs
+    advanceIllness(state, where.atMs, next)
+    if (state.illness !== null) state.illness.progressMs = carried
+    guard += 1
+  }
+}
+
+/**
+ * Pig time is elapsed real time times the scale. Age only counts days now —
+ * the body follows the level — and the same pig time drives passive growth.
+ */
+function growOlder(state, elapsedMs, atMs) {
+  const scale = Number.isFinite(state.timeScale) && state.timeScale > 0
+    ? state.timeScale
+    : DEFAULT_TIME_SCALE
+  const pigMs = elapsedMs * scale
+  state.ageMs += pigMs
+  if (state.hatched === true) growWithTime(state, pigMs, atMs)
+}
+
+/**
+ * @param {object} state
+ * @param {number} nowMs
+ * @param {import('./random.js').Roll} [next] - for drops; defaults to the pig's own seed.
+ */
+export function finishActivity(state, nowMs, next = rollerFor(state)) {
+  const activity = state.activity
+  state.activity = null
+  if (activity === null) return
+  state.lastActiveAt = nowMs
+  if (activity.kind === 'work') finishWork(state, activity, nowMs, next)
+  else if (activity.kind === 'study') finishStudy(state, activity, nowMs, next)
+  else if (activity.kind === 'interest') finishInterest(state, activity, nowMs)
+  else if (activity.kind === 'trip') finishTrip(state, activity, nowMs)
+}
+
+export function finishInterest(state, activity, nowMs) {
+  const interest = interestByKey(activity.key)
+  if (interest === null) return
+  // Straight into the same three traits the school ladder feeds.
+  state.traits = { ...(state.traits ?? {}) }
+  state.traits[interest.trait] = (state.traits[interest.trait] ?? 0) + interest.gain
+  state.interests = { ...(state.interests ?? {}) }
+  state.interests[interest.key] = (state.interests[interest.key] ?? 0) + 1
+  const certified = state.interests[interest.key] === CERTIFICATE_AFTER
+  state.satiety = clamp100(state.satiety - 4)
+  state.happiness = clamp100(state.happiness + 3)
+  state.stats.interests = (state.stats.interests ?? 0) + 1
+  noteOuting(state)
+  grow(state, STUDY_GROWTH_PER_LESSON, nowMs)
+  remember(state, `${interest.emoji} 学完${interest.label}，${TRAITS[interest.trait].label} +${interest.gain}`, nowMs)
+  announce(state, 'study', `${state.name} 学会了${interest.label}，${TRAITS[interest.trait].label} +${interest.gain} ${interest.emoji}`, nowMs)
+  noteToday(state, 'study')
+  if (certified) {
+    remember(state, `📜 拿到了${interest.certificate}`, nowMs)
+    announce(state, 'certificate', `${state.name} 拿到了${interest.certificate} 📜`, nowMs)
+  }
+}
+
+export function finishWork(state, activity, nowMs, next = rollerFor(state)) {
+  const job = jobByKey(activity.key)
+  // A shift started under an older job table is paid what it promised then
+  // (the v11 upgrade stamps `legacyCoins` on it), even if the job is gone.
+  if (job === null && !Number.isFinite(activity.legacyCoins)) return
+  const base = job === null ? activity.legacyCoins : job.coins
+  const trait = job === null ? null : job.trait
+  // A sick pig still goes to work — that is the way out of the sick-and-broke
+  // deadlock — but at half pay, so being ill costs money rather than being a wall.
+  const sick = state.illness !== null
+  const points = trait === null ? 0 : (state.traits?.[trait] ?? 0)
+  const withTrait = trait === null ? base : base * traitBonus(trait, points).pay
+  const coins = sick ? Math.max(1, Math.round(withTrait * SICK_PAY_MULTIPLIER)) : Math.round(withTrait)
+  state.coins += coins
+  if (job !== null) {
+    state.satiety = clamp100(state.satiety + job.satiety)
+    state.cleanliness = clamp100(state.cleanliness + job.cleanliness)
+  }
+  state.stats.jobs += 1
+  state.stats.coinsEarned += coins
+  noteToday(state, 'work')
+  noteToday(state, 'coinsEarned', coins)
+  noteOuting(state)
+  grow(state, outingGrowth(job === null ? activity.minutes ?? 0 : job.minutes), nowMs)
+  const brought = workDrops(state, coins, next)
+  const label = job === null ? activity.label : job.label
+  const emoji = job === null ? activity.emoji : job.emoji
+  const tag = sick ? '（带病上工，只有一半）' : (points > 0 && trait !== null ? `（${TRAITS[trait].label} ${points}）` : '')
+  const extra = brought.length > 0 ? `，还带回了${describeDrops(brought)}` : ''
+  remember(state, `${emoji} ${label}回来，赚了 ${coins} 金币${tag}${extra}`, nowMs)
+  announce(state, 'work', sick
+    ? `${state.name} 带病打工回来了，只赚到 ${coins} 金币 🤒${extra}`
+    : `${state.name} 打工回来了！赚到 ${coins} 金币 💰${extra}`, nowMs)
+  say(state, (state.outingStreak ?? 0) >= ILLNESS_ONSET.overworkStreak ? 'tired' : 'workDone', nowMs)
+}
+
+/**
+ * A lesson is over: one more on this subject's count. Crossing 9 / 20 / 40 / 95
+ * is a graduation — three gifts, extra growth, and 「我没有留级」.
+ */
+export function finishStudy(state, activity, nowMs, next = rollerFor(state)) {
+  const subject = subjectByKey(activity.key)
+  if (subject === null) return
+  const taken = state.lessons?.[subject.key] ?? 0
+  // The stage is the one the lesson was booked at, so a table change mid-lesson
+  // cannot change what it pays.
+  const stage = schoolStageByKey(activity.stage) ?? stageForNextLesson(taken)
+  state.lessons = { ...(state.lessons ?? {}), [subject.key]: taken + 1 }
+  state.traits = { ...(state.traits ?? {}) }
+  state.traits[subject.trait] = (state.traits[subject.trait] ?? 0) + stage.gain
+  if (subject.secondary !== null && stage.secondaryGain > 0) {
+    state.traits[subject.secondary] = (state.traits[subject.secondary] ?? 0) + stage.secondaryGain
+  }
+  state.satiety = clamp100(state.satiety + stage.satiety)
+  state.happiness = clamp100(state.happiness + stage.happiness)
+  state.stats.courses += 1
+  state.stats.lessons += 1
+  noteOuting(state)
+  grow(state, STUDY_GROWTH_PER_LESSON, nowMs)
+  const gains = `${TRAITS[subject.trait].label} +${stage.gain}`
+    + (subject.secondary !== null && stage.secondaryGain > 0 ? `、${TRAITS[subject.secondary].label} +${stage.secondaryGain}` : '')
+  if (GRADUATION_LESSONS.includes(taken + 1)) {
+    const gifts = graduationDrops(state, next)
+    grow(state, GRADUATION_GROWTH, nowMs)
+    state.stats.graduations = (state.stats.graduations ?? 0) + 1
+    remember(state, `🎓 ${subject.label}${stage.label}毕业（第 ${taken + 1} 节）`, nowMs)
+    announce(state, 'graduate', `${state.name} ${subject.label}${stage.label}毕业啦 🎓 ${gains}，带回${describeDrops(gifts)}`, nowMs)
+    noteToday(state, 'graduate')
+    say(state, 'graduate', nowMs)
+    return
+  }
+  const brought = studyDrops(state, next)
+  const extra = brought.length > 0 ? `，还带回了${describeDrops(brought)}` : ''
+  remember(state, `${subject.emoji} 上完${subject.label}第 ${taken + 1} 节，${gains}`, nowMs)
+  announce(state, 'study', `${state.name} 上完${subject.label}第 ${taken + 1} 节，${gains} 📚${extra}`, nowMs)
+  noteToday(state, 'study')
+  say(state, (state.outingStreak ?? 0) >= ILLNESS_ONSET.overworkStreak ? 'tired' : 'study', nowMs)
+}
+
+export function finishTrip(state, activity, nowMs) {
+  const trip = tripByKey(activity.key)
+  if (trip === null) return
+  // Deterministic souvenir rotation keeps the mechanic testable without RNG —
+  // and the rarity is a property of the souvenir, so "far trips are worth more"
+  // is a fact about the table rather than a dice roll.
+  const pick = trip.souvenirs[state.stats.trips % trip.souvenirs.length]
+  const tier = rarityByKey(pick.rarity)
+  state.souvenirs = [...(state.souvenirs ?? []), {
+    key: pick.key, emoji: pick.emoji, label: pick.label,
+    rarity: pick.rarity, story: pick.story,
+    from: trip.key, fromLabel: trip.label,
+  }]
+  state.happiness = clamp100(state.happiness + trip.happiness)
+  state.satiety = clamp100(state.satiety + trip.satiety)
+  state.stats.trips += 1
+  grow(state, outingGrowth(trip.minutes), nowMs)
+  remember(state, `${trip.emoji} ${trip.label}回来，带回「${pick.label}」${tier.emoji}`, nowMs)
+  announce(state, 'trip', `${state.name} 从${trip.label}回来了，带回「${pick.label}」${tier.emoji}🧳`, nowMs)
+  noteToday(state, 'trip')
+  noteToday(state, 'souvenirs')
+  say(state, 'tripBack', nowMs)
+}
+
+export { advanceIllness, catchIllness } from './illness.js'
+
+// ---------------------------------------------------------------------------
+// Effects and level crossings
+// ---------------------------------------------------------------------------

package/packages/pet-core/src/core/state.js

@@ -0,0 +1,210 @@
+// @ts-check
+/**
+ * 状态迁移（重置/继承/领养/改名/复活）。
+ *
+ * 纯函数领域逻辑：时间由 nowMs 传入，不读写文件、不碰 DOM（见 docs/CONVENTIONS.md）。
+ * @module dsh-piggy/core/state
+ */
+
+import { DEFAULT_TIME_SCALE, MAX, MAX_LEVEL, REVIVE_ITEM, xpForLevel } from '../data.js'
+import { lifeStageFor } from './clock.js'
+import { MEMORY_LIMIT } from './constants.js'
+import { announce, clamp, remember } from './effects.js'
+import { layEgg } from './egg.js'
+import { say } from './lines.js'
+import { sanitizeIllness, sanitizeInventory, sanitizeTraits } from './migrate.js'
+import { decay, die } from './settlement.js'
+
+/**
+ * Wipe the pig and start from a fresh box, whatever state it was in.
+ *
+ * `adopt` only works once a pig has died, which meant there was no way to start
+ * over with a living one short of deleting the save file by hand — and the
+ * running host holds the state in memory, so editing the file does not even
+ * work while it is up.
+ */
+export function reset(nowMs) {
+  return layEgg(nowMs)
+}
+
+/**
+ * What a new pig inherits from the old one.
+ *
+ * Schooling, traits and souvenirs carry over. Growth does not: since B2 the
+ * level *is* the body, and a new piglet that inherited Lv40 would hatch fully
+ * grown. Losing a pig is only ever an accident now (there is no old age), and
+ * the revive item is the way to keep the one you have.
+ */
+export const INHERITED = ['traits', 'lessons', 'interests', 'souvenirs']
+
+export function inherit(oldState, fresh, nowMs) {
+  if (oldState === null) return fresh
+  for (const key of INHERITED) {
+    if (oldState[key] !== undefined) fresh[key] = structuredCloneish(oldState[key])
+  }
+  if (Array.isArray(oldState.memories)) fresh.memories = oldState.memories.slice(-MEMORY_LIMIT)
+  remember(fresh, '🐖 新的小猪来了，本事和收藏都留下了', nowMs)
+  return fresh
+}
+
+/** JSON round-trip; every inherited field is plain data. */
+export function structuredCloneish(value) {
+  try { return JSON.parse(JSON.stringify(value)) } catch (error) { return value }
+}
+
+/** Change how fast pig time runs. Only affects the future, never the past. */
+export function setTimeScale(state, scale, nowMs) {
+  if (state === null) return state
+  const value = Number.isFinite(scale) && scale > 0 ? Math.min(365, scale) : DEFAULT_TIME_SCALE
+  state.timeScale = value
+  remember(state, `⏱ 时间倍率改成 ×${value}`, nowMs)
+  return state
+}
+
+/** Put the pig's clock back to now, so its age counts real time again. */
+export function ageFromNow(state, nowMs) {
+  if (state === null) return state
+  state.bornAt = nowMs
+  state.ageMs = 0
+  state.ageForced = false
+  state.stage = lifeStageFor(state, nowMs).key
+  state.lastSeenAt = nowMs
+  remember(state, '🔧 年龄归零，从现在开始按真实时间算', nowMs)
+  return state
+}
+
+/**
+ * ---------------------------------------------------------------------------
+ * Developer mode
+ *
+ * Applies an arbitrary patch to the pig so the panel can be driven into any
+ * state without waiting days for it. Everything is clamped through the same
+ * bounds the game uses, so dev mode can produce a *valid* state but never a
+ * corrupt one — no negative coins, no health of 99, no dangling illness.
+ * ---------------------------------------------------------------------------
+ */
+
+/** Numeric fields dev mode may set, with their legal range. */
+export const DEV_NUMBERS = Object.freeze({
+  satiety: [0, 100],
+  happiness: [0, 100],
+  cleanliness: [0, 100],
+  health: [0, MAX.health],
+  coins: [0, 1_000_000],
+  xp: [0, 10_000_000],
+  weightG: [400, 500_000],
+})
+
+export function applyDevPatch(state, patch, nowMs) {
+  if (state === null || typeof patch !== 'object' || patch === null) return state
+  const before = { dead: state.dead, hatched: state.hatched, stage: state.stage }
+
+  for (const [key, [lo, hi]] of Object.entries(DEV_NUMBERS)) {
+    const value = patch[key]
+    if (typeof value === 'number' && Number.isFinite(value)) {
+      state[key] = clamp(Math.round(value), lo, hi)
+    }
+  }
+
+  if (patch.traits !== null && typeof patch.traits === 'object') {
+    state.traits = sanitizeTraits({ ...state.traits, ...patch.traits })
+  }
+
+  if (patch.illness === null) state.illness = null
+  else if (typeof patch.illness === 'object' && patch.illness !== null) {
+    state.illness = sanitizeIllness({ ...patch.illness, since: nowMs, progressMs: 0 }, nowMs)
+  }
+
+  if (patch.inventory !== null && typeof patch.inventory === 'object') {
+    state.inventory = sanitizeInventory({ ...state.inventory, ...patch.inventory })
+  }
+
+  // Fast-forward: decay the pig as if `__advanceMs` had really passed. This is
+  // the whole point of dev mode — the interesting states take days to reach.
+  if (typeof patch.__advanceMs === 'number' && Number.isFinite(patch.__advanceMs) && patch.__advanceMs > 0) {
+    state.lastSeenAt = nowMs - Math.min(patch.__advanceMs, 60 * 86_400_000)
+    decay(state, nowMs)
+  }
+
+  // Level is what takes months to see now (B2): jump straight to one.
+  if (typeof patch.level === 'number' && Number.isFinite(patch.level)) {
+    state.xp = xpForLevel(clamp(Math.round(patch.level), 1, MAX_LEVEL))
+  }
+
+  // Age only counts days on the panel now; still jumpable for testing.
+  if (typeof patch.ageDays === 'number' && Number.isFinite(patch.ageDays)) {
+    // Age is accumulated pig time, so both have to move or the stage will not.
+    const days = Math.max(0, patch.ageDays)
+    state.bornAt = nowMs - days * 86_400_000
+    state.ageMs = days * 86_400_000
+    // Mark it, so a forced age is never mistaken for the pig simply growing up.
+    state.ageForced = true
+  }
+
+  // Health 0 is death, whether or not the panel also ticked "dead": leaving a
+  // 0-health pig walking around showed a corpse with no grave or announcement.
+  if (state.dead !== true && state.health <= 0) {
+    die(state, nowMs, '被开发者按死了')
+  }
+
+  if (patch.dead === true) {
+    die(state, nowMs, '被开发者按死了')
+  } else if (patch.dead === false && state.dead === true) {
+    revive(state, nowMs)
+  }
+
+  if (patch.hatched === true && state.hatched !== true) state.hatched = true
+  if (patch.hatched === false) {
+    state.hatched = false
+    state.dead = false
+    state.diedAt = null
+    state.stage = 'box'
+  }
+
+  if (patch.activity === null) state.activity = null
+  if (patch.outingStreak === 0) state.outingStreak = 0
+
+  state.stage = lifeStageFor(state, nowMs).key
+  state.lastSeenAt = nowMs
+  remember(state, `🔧 开发者改了状态（${before.stage} → ${state.stage}）`, nowMs)
+  return state
+}
+
+/** Start over with a fresh box. The old pig's story stays in `memories`. */
+export function adopt(state, nowMs) {
+  const fresh = inherit(state, layEgg(nowMs), nowMs)
+  remember(fresh, '又领养了一只，纸盒里传来窸窸窣窣的声音 📦', nowMs)
+  return Object.assign(state ?? {}, fresh)
+}
+
+// ---------------------------------------------------------------------------
+// Creation and migration
+// ---------------------------------------------------------------------------
+
+export function revive(state, nowMs) {
+  state.dead = false
+  state.diedAt = null
+  state.health = MAX.health
+  state.satiety = Math.max(state.satiety, 60)
+  state.cleanliness = Math.max(state.cleanliness, 60)
+  state.happiness = Math.max(state.happiness, 50)
+  state.illness = null
+  state.activity = null
+  state.outingStreak = 0
+  state.stats.revives = (state.stats.revives ?? 0) + 1
+  remember(state, `被 ${REVIVE_ITEM.label} 救了回来 ✨`, nowMs)
+  announce(state, 'revived', `${state.name} 回来了 ✨`, nowMs)
+  say(state, 'revive', nowMs)
+}
+
+// ---------------------------------------------------------------------------
+// Naming and mood
+// ---------------------------------------------------------------------------
+
+export function rename(state, rawName, nowMs) {
+  const cleaned = String(rawName ?? '').replace(/\s+/g, ' ').trim()
+  if (cleaned === '' || [...cleaned].length > 16) return null
+  state.name = cleaned
+  remember(state, `改名叫「${cleaned}」`, nowMs)
+  return cleaned
+}

package/packages/pet-core/src/core/travel.js

@@ -0,0 +1,58 @@
+// @ts-check
+/**
+ * 旅行与纪念品。
+ *
+ * 纯函数领域逻辑：时间由 nowMs 传入，不读写文件、不碰 DOM（见 docs/CONVENTIONS.md）。
+ * @module dsh-piggy/core/travel
+ */
+
+import { rarityByKey, tripByKey } from '../data.js'
+import { begin } from './activity.js'
+import { TOO_WEAK_HEALTH } from './constants.js'
+import { remember } from './effects.js'
+
+/**
+ * Sell one souvenir from the collection.
+ *
+ * Souvenirs used to be strings with no way out of the list; now each one has a
+ * rarity and a price, so the collection is a wallet as well as a shelf.
+ *
+ * @returns `{ok: true, sold, coins}` or `{ok: false, reason}`.
+ */
+export function sellSouvenir(state, souvenirKey, nowMs) {
+  if (state === null || state === undefined) return { ok: false, reason: 'absent' }
+  if (state.dead === true) return { ok: false, reason: 'dead' }
+  const list = Array.isArray(state.souvenirs) ? state.souvenirs : []
+  const index = list.findIndex(entry => entry !== null && typeof entry === 'object' && entry.key === souvenirKey)
+  if (index < 0) return { ok: false, reason: 'not-owned' }
+  const entry = list[index]
+  const tier = rarityByKey(entry.rarity)
+  state.souvenirs = [...list.slice(0, index), ...list.slice(index + 1)]
+  state.coins += tier.price
+  state.stats.sales = (state.stats.sales ?? 0) + 1
+  remember(state, `把「${entry.label}」卖了 ${tier.price} 金币`, nowMs)
+  return { ok: true, sold: entry.key, coins: tier.price, rarity: tier.key }
+}
+
+export function startTrip(state, tripKey, nowMs) {
+  if (state.hatched !== true) return { ok: false, reason: 'box' }
+  const trip = tripByKey(tripKey)
+  if (trip === null) return { ok: false, reason: 'unknown' }
+  if (state.dead) return { ok: false, reason: 'dead' }
+  if (state.activity !== null) return { ok: false, reason: 'away' }
+  if (state.health <= TOO_WEAK_HEALTH) return { ok: false, reason: 'weak' }
+  if (state.coins < trip.cost) return { ok: false, reason: 'poor', price: trip.cost }
+  if (state.satiety < 15) return { ok: false, reason: 'hungry' }
+
+  state.coins -= trip.cost
+  const result = begin(state, {
+    kind: 'trip', key: trip.key, label: trip.label, emoji: trip.emoji,
+    minutes: trip.minutes, cost: trip.cost,
+  }, nowMs)
+  if (!result.ok) {
+    state.coins += trip.cost
+    return result
+  }
+  remember(state, `${trip.emoji} 出发去${trip.label}（花了 ${trip.cost} 金币）`, nowMs)
+  return result
+}