lilgotchi 0.0.0-stage → 3.0.2

package/dist/pets/arcade-geometry.js

@@ -0,0 +1,18 @@
+export const FIELD_WIDTH = 32;
+export const FIELD_HEIGHT = 24;
+
+export function headingPose(sprite, center, jump = 0) {
+  const width = Math.max(...sprite.map(row => row.length));
+  const left = Math.max(0, Math.min(FIELD_WIDTH - width, Math.round(center - width / 2)));
+  const top = Math.round(FIELD_HEIGHT - sprite.length - jump);
+  const occupiedRows = sprite.flatMap((row, index) => row.some(Boolean) ? [index] : []);
+  const highest = Math.min(...occupiedRows);
+  const lowest = Math.max(...occupiedRows);
+  const headLimit = highest + Math.floor((lowest - highest) / 2);
+  const head = [];
+  for (let column = 0; column < width; column++) {
+    const row = sprite.findIndex(line => !!line[column]);
+    if (row >= 0 && row <= headLimit) head.push({x:left + column, y:top + row});
+  }
+  return {left, top, width, height:sprite.length, head};
+}

package/dist/pets/arcade-opponents.js

@@ -0,0 +1,16 @@
+import { originalSprites } from './original-sprites.js';
+import { sliceSprites, slicePalette } from './slice-sprites.js';
+import { cyberpunkSprites, cyberpunkPalette } from './cyberpunk-sprites.js';
+import { lilgotchiSprites, lilgotchiPalette } from './lilgotchi-sprites.js';
+
+const opponents = [
+ {family:'pizza',name:'Slice',frames:sliceSprites.mametchi,palette:slicePalette},
+ {family:'cyberpunk',name:'Cypunk',frames:cyberpunkSprites.ginjirotchi,palette:cyberpunkPalette},
+ {family:'lilgotchi',name:'Lilgotchi',frames:lilgotchiSprites.mametchi,palette:lilgotchiPalette},
+ {family:'classic',name:'Gen 1',frames:originalSprites.mametchi,palette:[null,'#c4cfa1']},
+];
+
+export function chooseOpponent(family, random = Math.random) {
+ const choices = opponents.filter(opponent => opponent.family !== family);
+ return choices[Math.min(choices.length-1, Math.floor(random()*choices.length))];
+}

package/dist/pets/arcade-renderer.js

@@ -0,0 +1,116 @@
+import { classicSprites } from './classic-sprites.js';
+import { FIELD_WIDTH, FIELD_HEIGHT, headingPose } from './arcade-geometry.js';
+
+const arrowPixels = {
+ left:[[2,0],[1,1],[0,2],[1,3],[2,4],[1,2],[2,2],[3,2],[4,2]],
+ right:[[2,0],[3,1],[4,2],[3,3],[2,4],[0,2],[1,2],[2,2],[3,2]],
+ up:[[2,0],[1,1],[3,1],[0,2],[4,2],[2,1],[2,2],[2,3],[2,4]],
+};
+
+export function drawArcade(q, s, sprite, palette = [], options = {}) {
+ const reducedMotion = options.reducedMotion ?? globalThis.matchMedia?.('(prefers-reduced-motion: reduce)').matches ?? false;
+ const frames = options.frames || {idle1:sprite};
+ const idle = frames.idle1 || sprite;
+ const opponent = options.opponent;
+ const rivalFrames = opponent?.frames || classicSprites.mametchi;
+ const foreground = options.foreground || '#0f380f';
+ const background = options.background || '#c4cfa1';
+ const field = q('.arcade-field');
+ field.width = FIELD_WIDTH; field.height = FIELD_HEIGHT;
+ const ctx = field.getContext('2d');
+ ctx.fillStyle = background; ctx.fillRect(0,0,FIELD_WIDTH,FIELD_HEIGHT);
+ const rect = (x,y,w,h,color=foreground) => {ctx.fillStyle=color;ctx.fillRect(Math.round(x),Math.round(y),w,h);};
+ const pose = direction => frames[{left:'lookLeft',right:'lookRight',up:'lookUp'}[direction]] || idle;
+ const pet = (frame, x, bottom, {rival=false,fallen=false}={}) => {
+  const width = fallen ? frame.length : Math.max(...frame.map(row=>row.length));
+  const height = fallen ? Math.max(...frame.map(row=>row.length)) : frame.length;
+  const left=Math.max(0,Math.min(FIELD_WIDTH-width,Math.round(x)));
+  const top=Math.max(0,Math.min(FIELD_HEIGHT-height,Math.round(bottom-height)));
+  for(let row=0;row<frame.length;row++)for(let col=0;col<frame[row].length;col++){
+   const pixel=frame[row][col];if(!pixel)continue;
+   rect(left+(fallen?frame.length-1-row:col),top+(fallen?col:row),1,1,rival?(opponent?.palette[pixel]||foreground):palette[pixel]||foreground);
+  }
+ };
+ const centered = (frame,bottom=24) => pet(frame,(FIELD_WIDTH-frame[0].length)/2,bottom);
+ const arrow = (direction,x,y,color=foreground) => {for(const [dx,dy] of arrowPixels[direction]||[])rect(x+dx,y+dy,1,1,color);};
+ const reaction = (x,y,good) => {
+  if(good){rect(x+1,y,1,1);rect(x,y+1,3,1);rect(x+1,y+2,1,1);}
+  else {rect(x+1,y,1,2);rect(x+1,y+3,1,1);}
+ };
+
+ if(s.id==='get'){
+  const frame=s.reaction==='happy'?frames.happy||idle:s.reaction==='startled'?frames.sad||idle:idle;
+  pet(frame,s.lane*10+5-frame[0].length/2,24);
+  if(s.object){
+   const occupiedTop=idle.findIndex(row=>row.some(Boolean));
+   const catchY=FIELD_HEIGHT-idle.length+Math.max(0,occupiedTop)-2;
+   const x=s.object.lane*10+4,y=s.object.y/10*catchY;
+   if(s.object.kind==='note'){rect(x+2,y,1,3);rect(x,y+2,3,1);}
+   else {rect(x+1,y,1,1,'#825b41');rect(x,y+1,3,2,'#825b41');}
+  }
+ }
+ if(s.id==='heading'){
+  const geometry=headingPose(idle,s.x,s.jump);
+  pet(idle,geometry.left,geometry.top+idle.length);
+  rect(s.ball.x,s.ball.y,2,2);
+ }
+ if(s.id==='bump'){
+  const reveal=s.phase==='reveal',time=s.phaseTime||0;
+  const contact=reveal&&time>=250&&time<1000;
+  const fallen=contact&&!reducedMotion&&time>=400;
+  const playerLoses=s.boutWon===false;
+  const player=frames.lookRight||idle;
+  pet(player,contact&&!playerLoses?5:1,24,{fallen:fallen&&playerLoses});
+  pet(rivalFrames.lookLeft||rivalFrames.idle1,contact&&playerLoses?17:21,24,{rival:true,fallen:fallen&&!playerLoses});
+  if(reveal)reaction(playerLoses?6:25,5,false);
+ }
+ if(s.id==='memory'){
+  const direction=s.phase==='watch'?s.cue:s.lastInput;
+  centered(pose(direction));
+  if(direction)arrow(direction,14,3);
+  if(s.result)reaction(14,3,s.result==='win');
+ }
+ if(s.id==='flag'){
+  centered(pose(s.response));
+  const flag=(left,raised)=>{
+   const x=left?6:25,y=raised?10:18;
+   rect(x,y,1,5);rect(left?x-3:x+1,y,3,2,left?'#365f54':'#934d42');
+  };
+  flag(true,s.response==='left'||s.response==='both');
+  flag(false,s.response==='right'||s.response==='both');
+  if(s.phase==='cue'){
+   if(s.cue==='fake'){
+    for(let i=0;i<5;i++){rect(14+i,2+i,1,1);rect(18-i,2+i,1,1);}
+   }else if(s.cue==='both'){arrow('left',8,2);arrow('right',19,2);}
+   else arrow(s.cue,14,2);
+  }
+  if(s.phase==='rest')reaction(14,3,s.correct);
+ }
+ q('.arcade-meter').hidden=!['bump','hoops'].includes(s.id);
+ if(['bump','hoops'].includes(s.id)){
+  const target=s.id==='bump'?s.target:[s.target.min*100,s.target.max*100];
+  q('.arcade-meter span').style.cssText=`left:${target[0]}%;width:${target[1]-target[0]}%`;
+  q('.arcade-meter i').style.left=`${s.id==='bump'?s.meter:s.marker*100}%`;
+ }
+ if(s.id==='sprint'){
+  for(let y=0;y<FIELD_HEIGHT;y++)rect(31,y,1,1,y%2?background:foreground);
+  const player=frames.lookRight||idle;
+  const end=30-player[0].length;
+  pet(player,Math.min(end,s.progress/s.finish*end),12);
+  const rival=rivalFrames.lookRight||rivalFrames.idle1;
+  pet(rival,Math.min(30-rival[0].length,s.opponent/s.finish*(30-rival[0].length)),24,{rival:true});
+  if(s.phase==='countdown'||(s.phase==='race'&&s.elapsed<1000)){
+   const active=s.phase==='race'?2:s.countdown>1500?0:1;
+   rect(23,1,5,11,'#17282e');
+   for(let i=0;i<3;i++)rect(24,2+i*3,3,2,i===active?['#ef7971','#f5d56e','#83da9c'][i]:'#455459');
+  }
+ }
+ if(s.id==='hoops'){
+  const frame=s.phase==='arc'?frames.eat||idle:frames.lookRight||idle;
+  pet(frame,0,24);
+  rect(30,3,1,20);rect(29,3,1,4);rect(27,23,5,1);
+  rect(24,9,7,1,'#ad5a35');
+  rect(25,10,1,2);rect(29,10,1,2);rect(26,12,1,2);rect(28,12,1,2);rect(26,13,3,1);
+  if(s.ball){rect(s.ball.x,s.ball.y,2,2,'#f6a64b');rect(s.ball.x,s.ball.y+1,1,1,'#8a4726');}
+ }
+}

package/dist/pets/arcade-sprites.js

@@ -0,0 +1,64 @@
+// Compact playfield portraits are drawn separately from the care screen art.
+// Each is eight pixels wide and six tall, leaving room for notes and balls.
+const rows={
+ classic:{
+  babytchi:['00111100','01000010','10100101','10011001','01111110','00011000'],
+  marutchi:['00111100','01111110','11011011','11111111','11000011','01111110'],
+  tamatchi:['00011000','00111100','01011010','01111110','00100100','01000010'],
+  kuchitamatchi:['00111100','01000010','10100101','01111110','00111100','01000010'],
+  mametchi:['01000100','10111010','10000010','01010100','01111100','01000100'],
+  ginjirotchi:['00111100','01111110','10111011','11000011','01111110','01000010'],
+  maskutchi:['00111100','01000010','11011011','10100101','01111110','01000010'],
+  kuchipatchi:['00111100','01000010','10100101','10000111','01111110','01000010'],
+  nyorotchi:['01111000','10000100','10101100','10010100','01111000','00111110'],
+  tarakotchi:['01000010','00111100','01000010','10100101','10111101','01000010'],
+  oyajitchi:['00011000','00111100','01011010','11111111','01011010','00100100'],
+ },
+ pizza:{
+  babytchi:['00055000','00511500','05111150','05155150','00511500','00055000'],
+  marutchi:['00555500','05244250','52333325','52355325','05222250','00500500'],
+  tamatchi:['05555550','52222225','05355350','00533500','00055000','00500500'],
+  kuchitamatchi:['00555500','05222250','53355350','05333250','00533250','00055000'],
+  mametchi:['05555550','52222225','05155150','00546500','00035000','00500500'],
+  ginjirotchi:['05555550','52222225','05455450','00533500','00045000','00500500'],
+  maskutchi:['05555550','52222225','05755750','005AB500','000B5000','00500500'],
+  kuchipatchi:['05555550','52222225','53455435','53BB3B35','05222250','00500500'],
+  nyorotchi:['05555550','52222225','05355350','00599500','00035000','00500500'],
+  tarakotchi:['05555550','52222225','05855850','005C8500','000C5000','00500500'],
+  oyajitchi:['05555550','52222225','05155150','00566500','00065000','00500500'],
+ },
+ cyberpunk:{
+  babytchi:['00333300','03222300','03121300','03222300','00333300','00303000'],
+  marutchi:['00040000','00333300','03222330','03121230','00333300','00303000'],
+  tamatchi:['00333300','03222330','03333330','03121330','00344300','03000300'],
+  kuchitamatchi:['00400300','00333300','03121340','03222300','00344300','03000300'],
+  mametchi:['00700700','00333330','03122130','33377333','03222300','03303300'],
+  ginjirotchi:['00300300','00333330','03322330','33314333','03442300','03303300'],
+  maskutchi:['00600600','00666660','06122160','66611666','06216300','06606600'],
+  kuchipatchi:['04400000','00333330','03122130','34344343','03222300','03303300'],
+  nyorotchi:['03300400','03233330','04312133','03344330','00322330','03300303'],
+  tarakotchi:['05555550','59999995','59199195','59911995','05555550','00333000'],
+  oyajitchi:['00400300','00333340','43121330','00344300','04322304','03300330'],
+ },
+ lilgotchi:{
+  babytchi:['00000000','00022000','00211200','02133120','00211200','00022000'],
+  marutchi:['00022000','00211200','02111120','02133120','02111120','00222200'],
+  tamatchi:['00022000','00281200','02111120','02133120','02111120','00222200'],
+  kuchitamatchi:['00022000','00265200','02555520','02533520','02655620','00222200'],
+  mametchi:['00022000','00284200','02444420','02433420','02444120','00222200'],
+  ginjirotchi:['00066000','00656600','06555560','06533560','00665600','00066000'],
+  maskutchi:['00022000','00288200','02888820','02833820','02888820','00222200'],
+  kuchipatchi:['00222200','02111120','21111112','21133112','21111112','02222220'],
+  nyorotchi:['00066000','00682600','06222260','06266260','06222260','00666600'],
+  tarakotchi:['00066000','00647600','06777760','06788760','06777360','00666600'],
+  oyajitchi:['00022000','00288000','02883000','02833820','02888320','00222200'],
+ },
+};
+export const arcadeSprites=Object.freeze(Object.fromEntries(Object.entries(rows).map(([family,pets])=>[
+ family,Object.freeze(Object.fromEntries(Object.entries(pets).map(([id,drawing])=>[
+  id,Object.freeze(drawing.map(row=>Object.freeze([...row].map(pixel=>parseInt(pixel,16)))))
+ ])))
+])));
+export function arcadeSprite(family,identity){
+ return arcadeSprites[family]?.[identity]||arcadeSprites.classic[identity]||arcadeSprites.classic.babytchi;
+}

package/dist/pets/arcade.js

@@ -0,0 +1,393 @@
+import { chooseOpponent } from './arcade-opponents.js';
+import { drawArcade } from "./arcade-renderer.js";
+import { games } from "./arcade-catalog.js";
+import { arcadeSprite } from "./arcade-sprites.js";
+import { petType } from "./storage.js";
+import { SP, palette } from "./skins.js";
+import { applyWellbeingAction } from "./wellbeing.js";
+import { now } from "./clock.js";
+export class Arcade {
+  constructor(app) {
+    this.app = app;
+    this.model = null;
+    this.selection = null;
+    this.settled = false;
+    this.last = 0;
+    this.held = null;
+    this.repeatAt = 0;
+    this.root = document.createElement("div");
+    this.root.className = "overlay";
+    this.root.id = "arcade-overlay";
+    this.root.tabIndex = -1;
+    this.root.setAttribute("role", "dialog");
+    this.root.setAttribute("aria-modal", "true");
+    this.root.setAttribute("aria-labelledby", "arcade-title");
+    this.root.innerHTML =
+      '<h2 class="overlay-title" id="arcade-title">Play</h2><div class="arcade-picker"></div><p class="arcade-instruction"></p><label class="arcade-options"><input type="checkbox"><span> Slower cues</span></label><canvas class="arcade-pet" aria-label="Your pet"></canvas><div class="arcade-cue" aria-live="polite"></div><canvas class="arcade-field" width="32" height="24" aria-label="Game field"></canvas><div class="arcade-meter"><span></span><i></i></div><p class="arcade-score" aria-live="off"></p><span class="arcade-announcement" style="position:absolute;width:1px;height:1px;overflow:hidden;clip-path:inset(50%)" role="status" aria-atomic="true"></span><button class="overlay-btn arcade-start">Start</button><div class="arcade-actions"></div><button class="overlay-btn arcade-pause">Pause</button><button class="overlay-close arcade-exit">Back to games</button>';
+    document.body.append(this.root);
+    this.q = (selector) => this.root.querySelector(selector);
+    this.q(".arcade-start").onclick = () => this.start();
+    this.q(".arcade-pause").onclick = () => this.togglePause();
+    this.q(".arcade-exit").onclick = () => {
+      if (this.selection) this.open();
+      else app.closeOverlay("arcade-overlay");
+    };
+    document.addEventListener("keydown", (event) => {
+      if (
+        !this.root.classList.contains("show") ||
+        event.repeat ||
+        !this.model ||
+        ["INPUT", "SELECT", "TEXTAREA"].includes(event.target.tagName) ||
+        (event.target.tagName === "BUTTON" &&
+          [" ", "Enter"].includes(event.key))
+      )
+        return;
+      const action = {
+        ArrowLeft: "left",
+        ArrowRight: "right",
+        ArrowUp: this.selection === "heading" ? "jump" : "up",
+        " ":
+          games[this.selection].actions.length === 1
+            ? games[this.selection].actions[0]
+            : this.selection === "flag"
+              ? "both"
+              : "jump",
+      }[event.key];
+      if (action) {
+        event.preventDefault();
+        if (
+          ["get", "heading"].includes(this.selection) &&
+          ["left", "right"].includes(action)
+        ) {
+          this.held = action;
+          this.repeatAt = 0;
+        }
+        this.input(action);
+      }
+    });
+    document.addEventListener("keyup", (event) => {
+      if (["ArrowLeft", "ArrowRight"].includes(event.key)) this.held = null;
+    });
+    window.addEventListener("blur", () => {
+      this.held = null;
+      this.pause();
+    });
+    const loop = (time) => {
+      if (this.model) {
+        if(this.petChanged()){this.last=time;requestAnimationFrame(loop);return;}
+        if (app.state.isDead || app.state.vacationAt > 0) {
+          this.cancel();
+          this.last = time;
+          requestAnimationFrame(loop);
+          return;
+        }
+        if (document.hidden || app.panelVisible === false) this.pause();
+        else if (!this.model.snapshot().paused) {
+          if (this.last) this.model.advance(time - this.last);
+          if (this.held && time >= this.repeatAt) {
+            this.input(this.held);
+            this.repeatAt = time + 150;
+          }
+          this.paint();
+        }
+      }
+      this.last = time;
+      requestAnimationFrame(loop);
+    };
+    requestAnimationFrame(loop);
+  }
+  open() {
+    this.cancel();
+    this.q(".arcade-announcement").textContent = "";
+    this.announcementKey=null;
+    this.selection = null;
+    this.app.openOverlay("arcade-overlay");
+    this.q(".overlay-title").textContent = "Choose a game";
+    this.q(".arcade-picker").replaceChildren();
+    for (const [id, name] of [
+      ["guess", "Left and right"],
+      ...Object.entries(games).map(([id, g]) => [id, g.name]),
+    ]) {
+      const b = document.createElement("button");
+      b.className = "overlay-btn";
+      b.textContent = name;
+      b.onclick = () => {
+        if (id === "guess") {
+          const reason=this.unavailable();
+          if(reason){this.q(".arcade-instruction").textContent=reason;this.q(".arcade-announcement").textContent=reason;return;}
+          this.app.closeOverlay("arcade-overlay");
+          this.app.startGame();
+        } else this.select(id);
+      };
+      this.q(".arcade-picker").append(b);
+    }
+    this.showRun(false);
+    this.q(".arcade-instruction").hidden = false;
+    this.q(".arcade-instruction").textContent = this.unavailable() || "Pick something to play.";
+    this.q(".arcade-exit").textContent = "Close";
+    this.q(".arcade-picker button")?.focus();
+  }
+  showRun(selected) {
+    for (const selector of [
+      ".arcade-options",
+      ".arcade-start",
+      ".arcade-pet",
+      ".arcade-cue",
+      ".arcade-field",
+      ".arcade-score",
+      ".arcade-meter",
+      ".arcade-actions",
+      ".arcade-pause",
+    ])
+      this.q(selector).hidden = !selected;
+    this.q(".arcade-picker").hidden = selected;
+  }
+  select(id) {
+    this.selection = id;
+    this.q(".arcade-announcement").textContent = "";
+    this.announcementKey=null;
+    this.q(".arcade-options span").textContent =
+      id === "sprint" ? " Steady running" : ["bump","heading"].includes(id) ? " Slower pace" : " Slower cues";
+    this.showRun(true);
+    this.q(".overlay-title").textContent = games[id].name;
+    this.q(".arcade-instruction").hidden = false;
+    this.q(".arcade-instruction").textContent = games[id].instruction + (id === "sprint" ? " You: upper lane. Opponent: lower lane." : "");
+    this.q(".arcade-start").textContent = "Start";
+    this.q(".arcade-start").disabled = !!this.unavailable();
+    this.q(".arcade-start").hidden = false;
+    this.q(".arcade-options").hidden = ![
+      "memory",
+      "bump",
+      "heading",
+      "flag",
+      "sprint",
+      "hoops",
+    ].includes(id);
+    this.q(".arcade-field").hidden = true;
+    this.q(".arcade-meter").hidden = true;
+    this.q(".arcade-pause").hidden = true;
+    this.q(".arcade-cue").textContent = "";
+    this.q(".arcade-score").textContent = "";
+    this.q(".arcade-actions").replaceChildren();
+    this.q(".arcade-exit").textContent = "Back to games";
+    this.drawPet();
+    if (this.unavailable()) this.q(".arcade-instruction").textContent = this.unavailable();
+    this.q(this.unavailable()?".arcade-exit":".arcade-start").focus();
+  }
+  unavailable() {
+    const st=this.app.state;
+    if(st.isDead)return "Start a new pet before playing.";
+    if(st.vacationAt>0)return "Turn Vacation off before playing.";
+    if(st.stage==="egg")return "Your pet can play after hatching.";
+    if(st.isSleeping)return "Wake your pet before playing.";
+    if(st.isSick)return "Your pet needs medicine before playing.";
+    if(st.hunger===0)return "Feed your pet before playing.";
+    return "";
+  }
+  start() {
+    const st = this.app.state;
+    if ((this.model && !this.model.snapshot().result) || !this.selection) return;
+    const reason=this.unavailable();
+    if(reason){
+      this.q(".arcade-instruction").textContent=reason;
+      this.q(".arcade-announcement").textContent=reason;
+      return;
+    }
+    this.cueSoundKey=null;
+    this.announcementKey=null;
+    this.runCharacter = st.character;
+    this.opponent = ['bump','sprint'].includes(this.selection) ? chooseOpponent(petType) : null;
+    this.model = games[this.selection].create({
+      sprite: SP[st.character]?.idle1,
+      slow: this.q("input").checked,
+      hold: this.q("input").checked,
+    });
+    this.settled = false;
+    this.last = 0;
+    applyWellbeingAction(st, "play", now());
+    st.save();
+    this.q(".arcade-start").hidden = true;
+    this.q(".arcade-instruction").hidden = true;
+    this.q(".arcade-options").hidden = true;
+    this.q(".arcade-field").hidden = false;
+    this.q(".arcade-pet").hidden = true;
+    this.q(".arcade-pause").hidden = false;
+    this.q(".arcade-actions").hidden = false;
+    this.q(".arcade-actions").replaceChildren();
+    for (const action of games[this.selection].actions) {
+      const b = document.createElement("button");
+      b.className = "overlay-btn";
+      b.textContent =
+        action === "run" && this.q("input").checked
+          ? "Run steadily"
+          : action[0].toUpperCase() + action.slice(1);
+      b.onclick = () => this.input(action);
+      if (
+        ["get", "heading"].includes(this.selection) &&
+        ["left", "right"].includes(action)
+      ) {
+        b.onpointerdown = () => {
+          this.held = action;
+          this.repeatAt = 0;
+        };
+        for (const type of ["pointerup", "pointercancel", "pointerleave"])
+          b.addEventListener(type, () => (this.held = null));
+      }
+      this.q(".arcade-actions").append(b);
+    }
+    this.paint();
+    this.root.focus();
+  }
+  input(action) {
+    if(this.petChanged())return;
+    if (this.app.state.isDead || this.app.state.vacationAt > 0) {
+      this.cancel();
+      return;
+    }
+    if (!this.model) return;
+    if(document.hidden || this.app.panelVisible===false){this.pause();return;}
+    const s = this.model.snapshot();
+    if(s.paused || s.result)return;
+    if (this.selection === "sprint" && s.hold && action === "run")
+      action = "hold";
+    this.model.input(action);
+    this.paint();
+  }
+  pause() {
+    this.held = null;
+    this.cueSoundKey=null;
+    if (this.model && !this.model.snapshot().result) {
+      this.model.pause();
+      this.q(".arcade-pause").textContent = "Resume";
+      this.q(".arcade-cue").textContent = "Paused";
+    }
+  }
+  togglePause() {
+    if (!this.model) return;
+    if(this.app.state.isDead || this.app.state.vacationAt>0){this.cancel();return;}
+    if(document.hidden || this.app.panelVisible===false)return;
+    if (this.model.snapshot().paused) {
+      this.model.resume();
+      this.last = 0;
+      this.q(".arcade-pause").textContent = "Pause";
+      this.paint();
+    } else this.pause();
+  }
+  petChanged() {
+    if(!this.model||!this.runCharacter||this.runCharacter===this.app.state.character)return false;
+    this.open();
+    this.q(".arcade-instruction").textContent="Your pet grew! Pick a game for your new look.";
+    return true;
+  }
+  cancel() {
+    this.runCharacter = null;
+    this.held = null;
+    this.model?.quit();
+    this.model = null;
+    this.last = 0;
+  }
+  drawPet() {
+    const sp = SP[this.app.state.character];
+    if (sp) this.app.renderer.renderToCanvas(this.q(".arcade-pet"), sp.idle1);
+  }
+  paint() {
+    if(this.petChanged())return;
+    const s = this.model.snapshot();
+    if(s.id === "sprint" && s.hold){
+      const run=this.q(".arcade-actions").children[0];
+      if(run){run.textContent=s.holding?"Stop running":"Run steadily";run.setAttribute("aria-pressed",String(s.holding));}
+    }
+    this.drawPet();
+    const accepting=!s.paused&&!s.result&&(s.id!=="memory"||s.phase==="answer")&&(s.id!=="flag"||(s.phase==="cue"&&s.response===null))&&(s.id!=="hoops"||["ready","aim"].includes(s.phase))&&(s.id!=="bump"||s.phase==="meter")&&(s.id!=="sprint"||s.phase==="race");
+    for(const button of this.q(".arcade-actions").children)button.disabled=!accepting;
+    this.q(".arcade-pause").textContent = s.paused ? "Resume" : "Pause";
+    const score = s.result
+      ? s.result === "win"
+        ? "You won! +1 Happy"
+        : "Round finished. Try again."
+      : s.id === "get"
+        ? `${s.score}/12 notes · ${s.lives} lives · ${Math.ceil(s.remaining / 1000)}s`
+        : s.id === "bump"
+          ? `Bout ${s.bout}/3 · ${s.wins} wins · Target ${s.target.join(" to ")}`
+          : s.id === "heading"
+            ? `${s.score}/10 headers · ${s.misses}/3 misses · ${Math.ceil(s.remaining / 1000)}s`
+            : s.id === "memory"
+              ? `Round ${s.round}/5 · ${s.entered}/${s.length}`
+              : s.id === "flag"
+                ? `Round ${s.round}/15 · ${s.score} correct`
+                : s.id === "sprint"
+                  ? `Race to ${s.finish} steps`
+                  : `Shot ${s.shot}/5 · ${s.score} baskets`;
+    if (this.q(".arcade-score").textContent !== score)
+      this.q(".arcade-score").textContent = score;
+    const cue = arcadeCue(s);
+    if (this.q(".arcade-cue").textContent !== cue)
+      this.q(".arcade-cue").textContent = cue;
+    // Announce outcomes and care changes, not the clock on every second.
+    const announcementKey=JSON.stringify([s.result,s.score,s.lives,s.misses,s.round,s.bout,s.shot]);
+    if(announcementKey!==this.announcementKey){
+      this.announcementKey=announcementKey;
+      this.q(".arcade-announcement").textContent=s.id==="get"&&!s.result
+        ? `${s.score} notes. ${s.lives} lives.`
+        : s.id==="heading"&&!s.result
+          ? `${s.score} headers. ${s.misses} misses.` : score;
+    }
+    if(s.id==="memory" && s.phase==="watch" && s.cue && !s.paused){
+      const key=`${s.round}:${s.cueIndex}`;
+      if(this.cueSoundKey!==key){
+        this.cueSoundKey=key;
+        this.app.sound.beep?.({left:440,up:660,right:880}[s.cue],100);
+      }
+    }
+    drawArcade(
+      this.q,
+      s,
+      arcadeSprite(petType, this.app.state.character),
+      palette,
+      {opponent:this.opponent, reducedMotion:!!this.app.motionDisabled?.(), frames:SP[this.app.state.character], foreground:this.app.renderer.fg, background:this.app.renderer.bg},
+    );
+    if(s.result)this.q(".arcade-meter").hidden = true;
+    if (
+      s.result &&
+      !this.settled &&
+      !this.app.state.isDead &&
+      !(this.app.state.vacationAt > 0)
+    ) {
+      this.settled = true;
+      if (s.result === "win") {
+        this.app.state.happiness = Math.min(4, this.app.state.happiness + 1);
+        this.app.sound.gameWin();
+      } else this.app.sound.gameLose();
+      this.app.state.save();
+      this.app.updateButtons();
+      this.q(".arcade-pause").hidden = true;
+      this.held = null;
+      this.q(".arcade-actions").hidden = true;
+      this.q(".arcade-meter").hidden = true;
+      this.q(".arcade-start").textContent = "Play again";
+      this.q(".arcade-start").hidden = false;
+      this.q(".arcade-start").disabled = !!this.unavailable();
+      this.q(".arcade-start").focus();
+      for (const b of this.q(".arcade-actions").children) b.disabled = true;
+    }
+  }
+}
+
+export function arcadeCue(s) {
+  if(s.paused)return "Paused";
+  if(s.result)return s.result==="win"?"Nice work!":"Try another round";
+  if(s.id==="memory"&&s.phase==="between")return "Nice! Next round…";
+  if(s.id==="memory")return s.cue?`Watch: ${{left:"← Left",up:"↑ Up",right:"→ Right"}[s.cue]}`:s.phase==="answer"?"Your turn":"Watch";
+  if(s.id==="flag"){
+    if(s.phase==="prepare")return "Get ready for the next flag";
+    if(s.phase==="rest")return s.correct?"Correct!":"Missed that one";
+    return `Round ${s.round}: ${s.cue==="fake"?"Fake! Wait":s.cue?.toUpperCase()||"Wait"}`;
+  }
+  if(s.phase==="countdown")return s.id==="sprint"?"Wait for green":"Ready…";
+  if(s.id==="bump")return s.phase==="meter"?"Stop in the target":s.boutWon?"You won the bout!":"Opponent wins this bout";
+  if(s.id==="hoops")return s.phase==="ready"?"Press Shoot when ready":s.phase==="aim"?"Stop in the target":s.arcProgress<0.72?"In the air…":s.made?"Basket!":"Missed the basket";
+  if(s.id==="get")return "Catch notes. Dodge poop.";
+  if(s.id==="heading")return "Jump to meet the ball";
+  if(s.id==="sprint")return s.hold?(s.holding?"Running steadily":"Press Run steadily to go"):"Keep running!";
+  return "";
+}

package/dist/pets/away.js

@@ -0,0 +1,20 @@
+// Pause every relative game clock together so a holiday cannot age a pet.
+const clocks=['stageStartTime','lastProcessed','lastHungerDecay','lastHappyDecay','lastPoopTime','lastAgeInc','snackWindowStart','attentionCallTime','wellbeingUpdatedAt'];
+export const MAX_CATCHUP=8*60*60*1000;
+export function shiftClocks(state,elapsed) {
+  if(!Number.isFinite(elapsed)||elapsed===0)return;
+  for(const key of clocks)if(Number.isFinite(state[key]))state[key]=Math.max(0,state[key]+elapsed);
+  if(state.sleepOverrideUntil>0)state.sleepOverrideUntil=Math.max(0,state.sleepOverrideUntil+elapsed);
+}
+export function resumeVacation(state,now) {
+  if(!Number.isFinite(state.vacationAt)||state.vacationAt<=0||!Number.isFinite(now)||now<0)return false;
+  // Rebase together even after a system clock correction, retaining elapsed phases.
+  shiftClocks(state,now-state.vacationAt);
+  state.vacationAt=0;
+  return true;
+}
+export function limitAbsence(state,now) {
+  const skipped=Math.max(0,now-state.lastProcessed-MAX_CATCHUP);
+  shiftClocks(state,skipped);
+  return skipped;
+}