lilgotchi 0.0.0-stage → 3.0.2

package/dist/pets/overlay-size.js

@@ -0,0 +1,13 @@
+// Measure natural flex content, not the iframe's current viewport height.
+export function overlayContentHeight(overlay, styleFor = getComputedStyle) {
+  const style = styleFor(overlay);
+  const number = value => Number.parseFloat(value) || 0;
+  const children = [...overlay.children].filter(node => node.getClientRects().length);
+  const content = children.reduce((total, node) => {
+    const css = styleFor(node);
+    return total + node.getBoundingClientRect().height + number(css.marginTop) + number(css.marginBottom);
+  }, 0);
+  return Math.ceil(content + Math.max(0, children.length - 1) * number(style.rowGap)
+    + number(style.paddingTop) + number(style.paddingBottom)
+    + number(style.borderTopWidth) + number(style.borderBottomWidth));
+}

package/dist/pets/pixel-size.js

@@ -0,0 +1,6 @@
+// Whole device pixels keep the grid sharp at fractional browser zoom too.
+export function pixelSize(available,dpr=1) {
+  const ratio=Number.isFinite(dpr)&&dpr>0?dpr:1;
+  const scale=Math.max(1,Math.min(Math.floor(available*ratio/32),Math.round(8*ratio)));
+  return {scale,gap:Math.max(1,Math.round(ratio)),width:32*scale,height:16*scale,cssWidth:32*scale/ratio,cssHeight:16*scale/ratio};
+}

package/dist/pets/presentation.js

@@ -0,0 +1,80 @@
+import { careGrade } from './wellbeing.js';
+import { characterName } from './skins.js';
+
+export function periodAt(date) {
+  const hour=date.getHours();
+  return hour>=6&&hour<11?'morning':hour>=11&&hour<16?'afternoon':hour>=16&&hour<19?'evening':'night';
+}
+export function careAction(state) {
+  return state.poopCount>0?'clean':state.isSleeping?'wake':'sleep';
+}
+export const sceneFor=(state,period)=>!state.lightOn?'dark':state.isSleeping?'sleep':period;
+export function careHint(state) {
+  if(state.isDead)return 'Your pet has passed away. Start again when you are ready.';
+  if(state.vacationAt>0)return 'Vacation paused. Resume in Settings when you are ready.';
+  if(state.stage==='egg')return 'Your egg takes 90 seconds to hatch. Care starts after hatching.';
+  if(state.isSick)return 'Needs medicine. Open More care to help.';
+  if(state.poopCount)return 'A little cleanup will help your pet feel better.';
+  if(state.isSleeping)return 'Resting. Wake your pet before feeding or playing.';
+  if(!state.hunger)return 'Hungry. Offer a meal before playing.';
+  if(state.isMisbehaving)return 'Calling for attention with full needs. Discipline is in More care.';
+  if(!state.happiness)return 'Could use some company. Play a round together.';
+  if(state.energy<25)return 'Getting tired. A nap will restore energy.';
+  return 'Feed, play, or settle down for a nap.';
+}
+export function updatePresentation(state,now,renderer) {
+  const identity=document.getElementById('pet-identity');
+  if(!identity)return;
+  const date=new Date(now),period=periodAt(date),grade=careGrade(state);
+  const icons={morning:'☀',afternoon:'☀',evening:'◒',night:'☾'};
+  const clock=document.getElementById('pet-clock');
+  clock.textContent=`${icons[period]} ${date.toLocaleTimeString([], {hour:'numeric',minute:'2-digit'})}`;
+  clock.setAttribute('aria-label',`${period}, ${date.toLocaleTimeString([], {hour:'numeric',minute:'2-digit'})} local time`);
+  const scene=sceneFor(state,period);
+  if(document.documentElement.dataset.scene!==scene){document.documentElement.dataset.scene=scene;renderer?.updateColors();}
+  identity.textContent=`Care: ${state.vacationAt>0?'Paused':state.isDead?'Remembered':grade.label}`;
+  identity.title='Care quality reflects your pet’s recent needs.';
+  const meters=document.getElementById('care-meters');
+  meters.hidden=state.stage==='egg'||state.isDead;
+  if(!meters.hidden)meters.innerHTML=[['Food',`${state.hunger*25}%`],['Happy',`${state.happiness*25}%`],['Energy',`${Math.round(state.energy??100)}%`],['Health',`${Math.round(state.health??100)}%`]].map(([label,value])=>`<span class="need"><span>${label}</span><strong>${value}</strong></span>`).join('');
+  const needs=document.getElementById('pet-needs');
+  needs.hidden=state.stage!=='egg';
+  document.getElementById('care-hint').textContent=careHint(state);
+  const button=document.getElementById('care-btn');
+  const action=careAction(state);
+  button.querySelector('.label').textContent=action[0].toUpperCase()+action.slice(1);
+  button.querySelector('.care-symbol').textContent=action==='clean'?'✧':action==='wake'?'☀':'☾';
+  button.setAttribute('aria-label',`${action} pet`);
+}
+
+// Integer offsets preserve complete pixel cells and stay inside placement bounds.
+export function motionOffset(time,kind='idle',options={}) {
+  if(options.reducedMotion||options.eink||options.paused)return {x:0,y:0};
+  const elapsed=Math.max(0,Number.isFinite(time)?time:0);
+  if(kind==='land') {
+    // One short drop, then a quiet settle. Never loop a falling character.
+    if(elapsed>=650)return {x:0,y:0};
+    const progress=Math.min(1,elapsed/450);
+    return {x:0,y:Math.round(-2*(1-progress*progress))};
+  }
+  const bouncing=['eat','happy','play','evolve'].includes(kind);
+  return {x:kind==='idle'?Math.round(Math.sin(elapsed/1600)):0,y:bouncing?-Math.round((Math.sin(elapsed/180)+1)/2):kind==='sleep'?-Math.round((Math.sin(elapsed/1300)+1)/2):0};
+}
+
+const tiltedFrames=new WeakMap();
+export function tiltFrame(pixels,time) {
+  // Small row shear gives a pixel tilt without resampling, cropping or moving effects.
+  if(!pixels?.length||pixels[0].length>14)return pixels;
+  const wave=Math.sin(time/1900),direction=wave>.45?1:wave<-.45?-1:0;
+  if(!direction)return pixels;
+  let cached=tiltedFrames.get(pixels);
+  if(!cached){cached=new Map();tiltedFrames.set(pixels,cached);}
+  if(cached.has(direction))return cached.get(direction);
+  const width=pixels[0].length+2;
+  const result=Object.freeze(pixels.map((row,y)=>{
+    const shift=y<Math.ceil(pixels.length/2)?1+direction:1;
+    return Object.freeze([...Array(shift).fill(0),...row,...Array(width-row.length-shift).fill(0)]);
+  }));
+  cached.set(direction,result);
+  return result;
+}

package/dist/pets/renderer.js

@@ -0,0 +1,100 @@
+import { C } from './constants.js';
+import { PF } from './font.js';
+import { SP, palette } from './skins.js';
+import { petType } from './storage.js';
+import { frameInfo } from './layout.js';
+import { pixelSize } from './pixel-size.js';
+
+export class Renderer {
+  constructor(canvas){
+    this.canvas=canvas;
+    this.ctx=canvas.getContext('2d');
+    this.w=C.W; this.h=C.H;
+    this.buf=Array.from({length:this.h},()=>new Uint8Array(this.w));
+    this.updateColors();
+    canvas.width=this.w*C.SCALE;
+    canvas.height=this.h*C.SCALE;
+    if(canvas.parentElement && typeof ResizeObserver!=='undefined') {
+      const resize=()=>{
+        const parent=canvas.parentElement;
+        const style=getComputedStyle(parent);
+        const available=parent.clientWidth-parseFloat(style.paddingLeft||0)-parseFloat(style.paddingRight||0);
+        const size=pixelSize(available,globalThis.devicePixelRatio||1);
+        this.pixelScale=size.scale;this.pixelGap=Math.min(size.scale-1,size.gap);
+        canvas.width=size.width;canvas.height=size.height;
+        canvas.style.width=`${size.cssWidth}px`;canvas.style.height=`${size.cssHeight}px`;
+        this.render(this.inverted||false);
+      };
+      this.resizeObserver=new ResizeObserver(resize);this.resizeObserver.observe(canvas.parentElement);
+      window.addEventListener('resize',resize);resize();
+    }
+  }
+  updateColors(){
+    const s=getComputedStyle(document.documentElement);
+    this.bg=s.getPropertyValue('--lcd-bg').trim()||'#c4cfa1';
+    this.fg=s.getPropertyValue('--lcd-fg').trim()||'#0f380f';
+  }
+  clear(){ for(let y=0;y<this.h;y++) this.buf[y].fill(0); this.rejectedPixels=[]; this.lastComposition=[]; }
+  setPixel(x,y,v=1){
+    if(Number.isInteger(x)&&Number.isInteger(y)&&x>=0&&x<this.w&&y>=0&&y<this.h) this.buf[y][x]=v;
+    else if(v) {
+      const rejected={family:petType,frame:this.drawingContext||'unlabeled',x,y,value:v};
+      (this.rejectedPixels??=[]).push(rejected);
+      if(this.strictBounds) throw new Error(`Clipped sprite pixel: ${JSON.stringify(rejected)}`);
+    }
+  }
+  drawSprite(sp,px,py){
+    for(let y=0;y<sp.length;y++)
+      for(let x=0;x<sp[y].length;x++)
+        if(sp[y][x]) this.setPixel(px+x,py+y,sp[y][x]);
+  }
+  drawText(txt,px,py){
+    let cx=px;
+    for(const ch of txt.toUpperCase()){
+      const g=PF[ch];
+      if(g){ this.drawSprite(g,cx,py); cx+=g[0].length+1; }
+      else cx+=3;
+    }
+  }
+  drawHearts(count,max,px,py){
+    for(let i=0;i<max;i++) this.drawSprite(i<count?SP.heart:SP.heartEmpty,px+i*6,py);
+  }
+  // Progress bar: x,y, width, fraction 0-1
+  drawBar(px,py,w,frac){
+    for(let x=0;x<w;x++) this.setPixel(px+x,py);
+    for(let x=0;x<w;x++) this.setPixel(px+x,py+2);
+    this.setPixel(px,py+1); this.setPixel(px+w-1,py+1);
+    const fill=Math.floor((w-2)*Math.min(1,frac));
+    for(let x=0;x<fill;x++) this.setPixel(px+1+x,py+1);
+  }
+  render(invert=false){
+    this.inverted=invert;
+    const s=this.pixelScale||C.SCALE,gap=this.pixelGap??1;
+    this.ctx.fillStyle=invert?(petType==='classic'?this.fg:'#030504'):this.bg;
+    this.ctx.fillRect(0,0,this.w*s,this.h*s);
+    this.ctx.fillStyle=invert?this.bg:this.fg;
+    for(let y=0;y<this.h;y++)
+      for(let x=0;x<this.w;x++)
+        if(this.buf[y][x]) {
+          this.ctx.fillStyle = invert ? (petType==='classic'?this.bg:'#334038') : (palette[this.buf[y][x]] || this.fg);
+          this.ctx.fillRect(x*s+gap,y*s+gap,s-gap,s-gap);
+        }
+  }
+  renderToCanvas(canvas,sp,scale=4,{field=false}={}){
+    frameInfo(sp);
+    const ctx=canvas.getContext('2d');
+    if(!Number.isSafeInteger(scale)||scale<1)throw new RangeError("Sprite scale must be a positive integer");
+    const s=scale;
+    canvas.width=(field?32:sp[0].length)*s;
+    canvas.height=(field?24:sp.length)*s;
+    const offsetX=field?Math.floor((32-sp[0].length)/2)*s:0;
+    const offsetY=field?Math.floor((24-sp.length)/2)*s:0;
+    ctx.fillStyle=this.bg;
+    ctx.fillRect(0,0,canvas.width,canvas.height);
+    ctx.fillStyle=this.fg;
+    for(let y=0;y<sp.length;y++)
+      for(let x=0;x<sp[y].length;x++)
+        if(sp[y][x]) { ctx.fillStyle=palette[sp[y][x]] || this.fg; ctx.fillRect(offsetX+x*s,offsetY+y*s,s,s); }
+  }
+}
+

package/dist/pets/scenery.css

@@ -0,0 +1,24 @@
+/* Separate landscape strip. The original 32 by 16 canvas stays unobstructed. */
+.scene-window { height:24px; width:100%; position:relative; overflow:hidden; margin:0 0 7px; border-radius:10px 10px 2px 2px; background:linear-gradient(var(--sky-top,#95b9ba),var(--sky-bottom,#d7d3a4)); isolation:isolate; pointer-events:none; }
+.scene-orb { position:absolute; width:10px; height:10px; border-radius:50%; top:4px; right:23%; background:var(--sky-orb,#f5df9f); }
+.scene-land { position:absolute; inset:8px 0 0; background:var(--sky-land,#748761); clip-path:polygon(0 70%,12% 50%,24% 65%,40% 12%,57% 52%,74% 25%,90% 63%,100% 46%,100% 100%,0 100%); }
+:root[data-scene="morning"] { --sky-top:#9faeac; --sky-bottom:#e5c796; --sky-orb:#ffe3a6; --sky-land:#77835c; }
+:root[data-scene="afternoon"] { --sky-top:#86b5b9; --sky-bottom:#bbd7c7; --sky-orb:#fff0b1; --sky-land:#617f62; }
+:root[data-scene="evening"] { --sky-top:#8c7b9a; --sky-bottom:#d69c7b; --sky-orb:#f0ba85; --sky-land:#666078; }
+:root[data-scene="night"] { --sky-top:#1d2c42; --sky-bottom:#3b4b64; --sky-orb:#d1dace; --sky-land:#253842; }
+:root[data-scene="night"] .scene-orb { background:transparent; box-shadow:-3px 1px 0 0 var(--sky-orb); }
+:root[data-scene="night"] .scene-window { background:radial-gradient(circle at 22% 22%,#d2d8c7 0 1px,transparent 1.5px),radial-gradient(circle at 65% 30%,#d2d8c7 0 1px,transparent 1.5px),linear-gradient(var(--sky-top),var(--sky-bottom)); }
+:root[data-pet="pizza"] .scene-land { background:var(--sky-land); clip-path:polygon(0 80%,18% 30%,32% 70%,50% 10%,65% 68%,83% 33%,100% 80%,100% 100%,0 100%); }
+:root[data-pet="cyberpunk"] .scene-land { clip-path:polygon(0 60%,8% 60%,8% 20%,17% 20%,17% 45%,30% 45%,30% 0,41% 0,41% 65%,52% 65%,52% 30%,66% 30%,66% 55%,78% 55%,78% 10%,88% 10%,88% 65%,100% 65%,100% 100%,0 100%); }
+:root[data-pet="cyberpunk"] .scene-window { box-shadow:inset 0 -1px #8cebdc55; }
+:root[data-scene="sleep"],:root[data-scene="dark"] { --sky-top:#0d151b; --sky-bottom:#182128; --sky-land:#202b30; }
+:root[data-scene="sleep"] .scene-orb,:root[data-scene="dark"] .scene-orb { display:none; }
+:root.eink .scene-window { background:#eee; box-shadow:none; }
+:root.eink .scene-land { background:#777; }
+:root.eink .scene-orb { background:#333; box-shadow:none; }
+.growth-card { margin:10px 0; padding:10px 12px; border:1px solid #66755e; border-radius:12px; background:#26302a; color:#edf1e8; display:flex; align-items:center; gap:10px; font:12px/1.5 system-ui,sans-serif; }
+.growth-card[hidden] { display:none; }
+.growth-message { margin:0; flex:1; }
+.growth-card button { flex-shrink:0; min-height:44px; padding:8px; font:inherit; color:inherit; background:#354438; border:1px solid #778774; border-radius:9px; cursor:pointer; }
+.growth-card button:focus-visible { outline:2px solid #e5d6a3; outline-offset:3px; }
+@media(prefers-reduced-motion:no-preference) { :root:not(.eink) .growth-card { animation:growth-arrive .25s ease-out; } @keyframes growth-arrive { from{opacity:.5;transform:translateY(3px)} to{opacity:1;transform:none} } }

package/dist/pets/simulation.js

@@ -0,0 +1,185 @@
+import { now as clockNow, setSimulationTime } from './clock.js';
+import { C } from './constants.js';
+import { Evo } from './evolution.js';
+import { elderFor } from './original-roster.js';
+import { advanceWellbeing, sleepDecision } from './wellbeing.js';
+import { limitAbsence } from './away.js';
+
+export class PetSimulation {
+  processMissedTime(){
+    const end=clockNow(), st=this.state;
+    if(st.vacationAt>0)return;
+    if(st.isDead) { this.showDeath(); return; }
+    const previous={...st};
+    const skipped=limitAbsence(st,end);
+    const start=st.lastProcessed;
+    if(end<=start) return;
+    if(st.wellbeingUpdatedAt<start)st.wellbeingUpdatedAt=start;
+    const sound=this.sound;
+    this.sound=new Proxy({}, {get:()=>()=>{}});
+    this.catchingUp=true;
+    try {
+      for(let time=Math.min(start+60000,end);;time=Math.min(time+60000,end)) {
+        setSimulationTime(time);
+        this.tick();
+        if(Math.floor(time/600000)>Math.floor((time-60000)/600000)) this.maybeMisbehave();
+        if(time===end || st.isDead) break;
+      }
+    } finally {
+      setSimulationTime(null);
+      this.sound=sound;
+      this.catchingUp=false;
+      this.animState=null;
+    }
+    this.state.lastProcessed=end;
+    this.state.save();
+    this.growth?.observe(previous,st);
+    if(st.isDead) this.showDeath();
+    this.updateButtons();
+    if(skipped>0)this.toast('Welcome back. Only eight hours passed for your pet.');
+  }
+
+  // -- GAME TICK --
+  tick(){
+    const st=this.state, now=clockNow();
+    if(st.vacationAt>0)return;
+    advanceWellbeing(st,now);
+    st.lastProcessed=now;
+    if(st.isDead) return;
+
+    if(st.stage==='egg'){
+      if(Evo.shouldEvolve(st)) this.doEvolve();
+      return;
+    }
+
+    if(now-st.lastAgeInc>=86400000){ st.age++; st.lastAgeInc+=86400000; }
+    this.checkSleep();
+    if(st.isSleeping) return;
+
+    const hRate=C.HUNGER_DECAY[st.stage]||3600000;
+    if(now-st.lastHungerDecay>=hRate){
+      if(st.hunger>0) st.hunger--;
+      st.lastHungerDecay=now;
+    }
+    const hpRate=C.HAPPY_DECAY[st.stage]||3600000;
+    if(now-st.lastHappyDecay>=hpRate){
+      if(st.happiness>0) st.happiness--;
+      st.lastHappyDecay=now;
+    }
+    const pRate=C.POOP_RATE[st.stage]||10800000;
+    if(now-st.lastPoopTime>=pRate&&st.poopCount<C.MAX_POOP){
+      st.poopCount++; st.lastPoopTime=now;
+    }
+    if(st.poopCount>=3&&!st.isSick&&Math.random()<(this.catchingUp ? 1-Math.pow(.99,60) : .01)) this.makeSick();
+
+    this.checkAttention();
+
+    if(st.attentionCallTime&&now-st.attentionCallTime>=C.CARE_WINDOW){
+      st.careMistakes++;
+      st.attentionCallTime=null; st.attentionReason=null;
+    }
+
+    if(Evo.shouldEvolve(st)&&!st.isSick) this.doEvolve();
+
+    if(st.stage==='adult'){
+      if(st.careMistakes>=C.ADULT_MAX_MISTAKES||st.age>=C.MAX_AGE){
+        st.isDead=true; st.stage='dead';
+        this.cancelGame();
+        st.save();
+        this.sound.death(); this.showDeath();
+      }
+      if(!st.isDead&&['maskutchi','zuccitchi'].includes(st.character)&&st.discipline>=100&&st.age>=10&&Math.random()<.05){
+        const elder=elderFor(st);
+        if(!elder)return;
+        const previous={...st};
+        st.character=elder;
+        this.sound.hatch();
+        this.animState='evolve'; this.animTimer=clockNow();
+        if(!this.catchingUp){this.growth?.observe(previous,st);this.landingAt=clockNow()+2000;}
+      }
+    }
+
+    if(this.catchingUp) return;
+    const bar=document.getElementById('attention-bar');
+    bar.classList.toggle('active',st.attentionCallTime!=null);
+
+    if(st.attentionCallTime&&now%4000<1000) this.sound.attention();
+
+    this.updateButtons();
+  }
+
+  checkSleep(){
+    const st=this.state, h=new Date(clockNow()).getHours();
+    const sch=C.SLEEP[st.stage];
+    if(!sch) return;
+    const shouldSleep=sleepDecision(st,(h>=sch.s||h<sch.w),clockNow());
+    if(shouldSleep&&!st.isSleeping){
+      st.isSleeping=true;
+    }
+    if(!shouldSleep&&st.isSleeping){
+      st.isSleeping=false; st.lightOn=true;
+      st.lastHungerDecay=clockNow(); st.lastHappyDecay=clockNow(); st.lastPoopTime=clockNow();
+    }
+  }
+
+  checkAttention(){
+    const st=this.state;
+    if(st.isSick&&!st.attentionCallTime){
+      st.attentionCallTime=clockNow(); st.attentionReason='sick'; return;
+    }
+    if(st.hunger===0&&!st.attentionCallTime&&!st.isMisbehaving){
+      st.attentionCallTime=clockNow(); st.attentionReason='hungry';
+      return;
+    }
+    if(st.happiness===0&&!st.attentionCallTime&&!st.isMisbehaving){
+      st.attentionCallTime=clockNow(); st.attentionReason='sad';
+      return;
+    }
+    if(!st.attentionCallTime&&st.isMisbehaving){
+      st.attentionCallTime=clockNow(); st.attentionReason='misbehave';
+    }
+    if(st.attentionCallTime&&!st.isSick&&st.hunger>0&&st.happiness>0&&!st.isMisbehaving){
+      st.attentionCallTime=null; st.attentionReason=null;
+    }
+  }
+
+  makeSick(){
+    const st=this.state;
+    st.isSick=true;
+    st.medDoses=1+Math.floor(Math.random()*3);
+    st.sickCount++;
+  }
+
+  doEvolve(){
+    const st=this.state;
+    const r=Evo.evolve(st);
+    if(!r) return;
+    const previous={...st};
+    const oldStage=st.stage;
+    st.stage=r.stage; st.character=r.character; st.weight=r.weight;
+    st.stageStartTime=clockNow();
+    if(oldStage==='egg'){
+      st.hunger=0; st.happiness=0;
+      this.checkAttention();
+    }
+    if(r.stage==='teen') st.prevTeen=r.character;
+    this.sound.hatch();
+    this.animState='evolve'; this.animTimer=clockNow();
+    if(!this.catchingUp){this.growth?.observe(previous,st);this.landingAt=clockNow()+2000;}
+    const name=this.evolutionName?.(r.character)||r.character;
+    this.toast(`Evolved into ${name}!`);
+    if(!this.catchingUp) this.state.save();
+    this.updateButtons();
+  }
+
+  maybeMisbehave(){
+    const st=this.state;
+    if(st.vacationAt>0)return;
+    if(st.isDead||st.isSleeping||st.stage==='egg'||st.stage==='baby') return;
+    if(Math.random()<.05&&!st.isMisbehaving&&st.hunger>0&&st.happiness>0){
+      st.isMisbehaving=true;
+      this.updateButtons();
+    }
+  }
+
+}

package/dist/pets/skins.js

@@ -0,0 +1,14 @@
+import { lilgotchiSprites, lilgotchiPalette, lilgotchiNames } from './lilgotchi-sprites.js';
+import { sliceSprites, slicePalette, sliceNames } from './slice-sprites.js';
+import { cyberpunkSprites, cyberpunkPalette, cyberpunkNames } from './cyberpunk-sprites.js';
+import { classicSprites } from './classic-sprites.js';
+import { originalSprites } from './original-sprites.js';
+import { petType } from './storage.js';
+
+export const SP = structuredClone(classicSprites);
+if (petType === 'classic') Object.assign(SP, originalSprites);
+export const palette = petType === 'pizza' ? slicePalette : petType === 'cyberpunk' ? cyberpunkPalette : petType === 'lilgotchi' ? lilgotchiPalette : [];
+if (petType === 'pizza') Object.assign(SP, sliceSprites);
+if (petType === 'cyberpunk') Object.assign(SP, cyberpunkSprites);
+if (petType === 'lilgotchi') Object.assign(SP, lilgotchiSprites);
+export const characterName = name => petType === 'pizza' ? sliceNames[name] : petType === 'cyberpunk' ? cyberpunkNames[name] : petType === 'lilgotchi' ? lilgotchiNames[name] : name.charAt(0).toUpperCase()+name.slice(1);

package/dist/pets/slice-sprites.js

@@ -0,0 +1,38 @@
+const palette=['','#fff0c2','#b96b32','#ffd15a','#cf432f','#38271f','#5f9c58','#dfb889','#ffe66a','#92acb8','#b975c5','#713c24','#9e3028'];
+const drawings=[
+ ['egg','Dough','egg',[4,6],['000000000000','000000000000','000055550000','000511115000','005111111500','005111111500','000511115000','000055550000']],
+ ['babytchi','Dough Drop','baby',[4,6],['000005500000','000051150000','000511115000','005111111500','005111111500','005111111500','000511115000','000051150000','000055055000']],
+ ['marutchi','Pizza Puff','child',[4,6],['000055550000','000522225000','005233332500','052443344250','052333333250','523333333325','523333333325','052333333250','005222222500','000550055000']],
+ ['tamatchi','Little Slice','teen',[4,5],['005555555500','052222222250','005333333500','005333333500','000533335000','000533335000','000053350000','000053350000','000005500000','000055055000']],
+ ['kuchitamatchi','Folded Slice','teen',[4,5],['000055555000','000522222500','005333332500','053333332500','053333332500','005333325000','000533325000','000053325000','000005335000','000055005500']],
+ ['mametchi','Margherita','adult',[4,5],['055555555550','522222222225','053114461350','053114461350','005333113500','005333333500','000533335000','000534435000','000056150000','000005500000','000055055000']],
+ ['ginjirotchi','Pepperoni','adult',[4,5],['055555555550','522222222225','053443344350','053443344350','005333333500','005333333500','000533335000','000534435000','000054450000','000005500000','000055055000']],
+ ['maskutchi','BBQ Chicken','adult',[4,5],['005555555500','052222222250','05377BAA7350','053BB7A7B350','005A33733500','005333333500','0053333B3500','0005377A5000','00005BB50000','000053350000','000005500000','000055055000']],
+ ['kuchipatchi','Meat Lovers','adult',[4,6],['005555555500','052222222250','5244BB3BB425','5234BB3BB325','52C333333C25','52C333333C25','523333333325','5244C3BB4325','052222222250','005555555500','000550055000']],
+ ['nyorotchi','Anchovy','adult',[4,5],['000555555000','005222222500','005393339500','005339993500','005393339500','005333333500','000533335000','000539935000','000053950000','000053350000','000005500000','000055055000']],
+ ['tarakotchi','Pineapple','adult',[4,5],['005555555500','052222222250','05188C188150','05188C188150','005133133500','005333333500','0053333C1500','000531885000','00005C850000','000053150000','000005500000','000055055000']],
+ ['oyajitchi','Spoiled Slice','adult',[4,5],['005555555500','052222222250','051166111150','005166611500','005111111500','005111111500','000511115000','000516615000','000051150000','000051150000','000005155000','000055055000']],
+];
+const faces={idle1:['505','000','050'],idle2:['505','000','555'],happy:['050','505','555'],sad:['000','505','050'],eat:['505','050','555'],sleep:['000','505','000'],lookLeft:['550','500','050'],lookRight:['055','005','050'],lookUp:['505','000','050']};
+function canvas(rows){
+ if(rows.length>12||rows.some(row=>row.length>12))throw new Error('Slice proposal exceeds its display');
+ return [...Array(12-rows.length).fill(''),...rows].map(row=>[...row.padEnd(12,'0')].map(value=>parseInt(value,16)));
+}
+function pose(rows,face,expression){
+ const pixels=canvas(rows);
+ if(expression)faces[expression].forEach((row,dy)=>[...row].forEach((value,dx)=>{if(value!=='0')pixels[face[1]+dy-(expression==='lookUp'?1:0)][face[0]+dx]=Number(value);}));
+ if(expression==='idle2'){
+  const foot=pixels[11].findIndex(value=>value===5);
+  if(foot>0){pixels[11][foot]=0;pixels[11][foot-1]=5;}
+ }
+ return pixels;
+}
+const artwork={type:'Slice',palette,pets:drawings.map(([id,name,stage,face,rows])=>({
+ id,name,stage,
+ frames:id==='egg'?{idle1:pose(rows,face),idle2:pose(rows.map(row=>'0'+row.slice(0,-1)),face)}:Object.fromEntries(Object.keys(faces).map(expression=>[expression,pose(rows,face,expression)]))
+}))};
+
+const freezeFrame=frame=>Object.freeze(frame.map(row=>Object.freeze([...row])));
+export const slicePalette=Object.freeze(artwork.palette);
+export const sliceNames=Object.freeze(Object.fromEntries(artwork.pets.map(pet=>[pet.id,pet.name])));
+export const sliceSprites=Object.freeze(Object.fromEntries(artwork.pets.map(pet=>[pet.id,Object.freeze(Object.fromEntries(Object.entries(pet.frames).map(([key,frame])=>[key,freezeFrame(pet.id==='egg'?frame.slice(2):frame)])))])));

package/dist/pets/sound.js

@@ -0,0 +1,33 @@
+export class SoundManager {
+  constructor(){ this.ctx=null; this.muted=true; }
+  init(){
+    try {
+      if(!this.ctx) this.ctx=new (window.AudioContext||window.webkitAudioContext)();
+      if(this.ctx.state==='suspended') this.ctx.resume().catch(()=>{});
+    }catch(e){}
+  }
+  beep(freq,dur,vol=.15){
+    if(this.muted||this.suspended||!this.ctx) return;
+    try{
+      const o=this.ctx.createOscillator(),g=this.ctx.createGain();
+      o.type='square'; o.frequency.value=freq; g.gain.value=vol;
+      o.connect(g); g.connect(this.ctx.destination);
+      o.start(); o.stop(this.ctx.currentTime+dur/1000);
+    }catch(e){}
+  }
+  btnPress(){ this.beep(800,50); }
+  attention(){ this.beep(1000,100); setTimeout(()=>this.beep(1200,100),150); }
+  happy(){ this.beep(600,80); setTimeout(()=>this.beep(900,120),100); }
+  sad(){ this.beep(300,200); }
+  gameWin(){ [0,100,200].forEach((d,i)=>setTimeout(()=>this.beep(600+i*200,100),d)); }
+  gameLose(){ this.beep(400,100); setTimeout(()=>this.beep(200,200),120); }
+  death(){ this.beep(200,500,.1); }
+  hatch(){ [0,150,300,450].forEach((d,i)=>setTimeout(()=>this.beep(500+i*100,80),d)); }
+  eat(){ this.beep(500,60); setTimeout(()=>this.beep(600,60),80); }
+  clean(){ this.beep(700,50); setTimeout(()=>this.beep(900,50),60); setTimeout(()=>this.beep(1100,50),120); }
+  medicine(){ this.beep(400,80); setTimeout(()=>this.beep(600,80),100); setTimeout(()=>this.beep(800,80),200); }
+  discipline(){ this.beep(200,100); setTimeout(()=>this.beep(400,100),120); }
+  denied(){ this.beep(200,150,.1); }
+  toggleMute(){ this.muted=!this.muted; }
+}
+

package/dist/pets/status.js

@@ -0,0 +1,28 @@
+import { C } from './constants.js';
+import { now } from './clock.js';
+import { petType } from './storage.js';
+import { characterName } from './skins.js';
+import { isP2 } from './original-roster.js';
+
+export function updateStatus(state) {
+  const status = document.getElementById('pet-status');
+  if (!status) return;
+  let text;
+  if (state.stage === 'egg') {
+    const seconds = Math.max(0, Math.ceil((C.EGG_MS - ((state.vacationAt || now()) - state.stageStartTime)) / 1000));
+    text = `hatching in ${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, '0')}. your egg takes 90 seconds.`;
+  } else if (state.isDead) text = `lived for ${state.age} days. start again when you’re ready.`;
+  else text = `${state.stage} · ${state.age} days · food ${state.hunger}/4 · happy ${state.happiness}/4${state.isSleeping ? ' · sleeping' : ''}${state.isSick ? ' · needs medicine' : ''}${state.isMisbehaving ? ' · needs discipline' : ''}`;
+  if(state.vacationAt>0)text = `Vacation paused. ${text}`;
+  status.textContent = ((petType === 'pizza' || petType === 'cyberpunk' || petType === 'lilgotchi') && state.stage !== 'egg' && !state.isDead ? characterName(state.character)+' · ' : '') + text.replace(/ · food \d\/4 · happy \d\/4/,'');
+  status.hidden=state.stage==='egg';
+  const needs=document.getElementById('pet-needs');
+  if(needs) {
+    const hearts=count=>'♥'.repeat(count)+'♡'.repeat(4-count);
+    needs.textContent=state.stage==='egg'?`${characterName('egg').toUpperCase()} · ${text.split('.')[0]}`:state.isDead?'Rest in peace':`Food ${hearts(state.hunger)} ${state.hunger}/4 · Happy ${hearts(state.happiness)} ${state.happiness}/4`;
+  }
+  const familyName={classic:isP2(state)?'Gen 2':'Gen 1',pizza:'Slice',cyberpunk:'Cypunk',lilgotchi:'Lilgotchi'}[petType]||petType;
+  document.getElementById('lcd').setAttribute('aria-label', `${familyName} pet. ${text}`);
+}
+
+

package/dist/pets/storage.js

@@ -0,0 +1,49 @@
+import { frameCharacter } from './catalog.js';
+export const selectedCharacter=frameCharacter(new URLSearchParams(globalThis.location?.search || ''));
+export const petTypes = ['classic', 'pizza', 'cyberpunk', 'lilgotchi'];
+export const petType = selectedCharacter.skin;
+export const saveKey = ['default','slice','cyberpunk'].includes(selectedCharacter.id) ? `taylor-pocket-pets-p1-v1-${petType}` : `lilgotchi:standalone:${selectedCharacter.id}`;
+import { validState } from './valid-state.js';
+export { validState } from './valid-state.js';
+let bridge = null;
+export function configureStorage(adapter) { bridge = adapter; }
+
+function status(text) {
+  const element = globalThis.document?.getElementById('save-status');
+  if (element) element.textContent = text;
+}
+
+export function saveState(state) {
+  if (bridge) { bridge.save(JSON.parse(JSON.stringify(state))); return true; }
+  try {
+    localStorage.setItem(saveKey, JSON.stringify(state));
+    status('saved in this browser');
+    return true;
+  } catch {
+    status('saving unavailable. progress lasts for this visit.');
+    return false;
+  }
+}
+
+export function loadState(state) {
+  if (bridge) {
+    const data = bridge.load();
+    if (!validState(data)) return false;
+    for (const key of Object.keys(state)) if (Object.hasOwn(data,key)) state[key]=data[key];
+    return true;
+  }
+  try {
+    const raw = localStorage.getItem(saveKey);
+    if (!raw) return false;
+    const data = JSON.parse(raw);
+    if (!validState(data)) return false;
+    // Only copy known state fields, not arbitrary properties from saved JSON.
+    for (const key of Object.keys(state)) if (Object.hasOwn(data, key)) state[key] = data[key];
+    return true;
+  } catch { return false; }
+}
+
+export function clearState() {
+  if (bridge) return;
+  try { localStorage.removeItem(saveKey); } catch {}
+}

package/dist/pets/valid-state.js

@@ -0,0 +1,26 @@
+import { p1Stages, p2Stages } from './original-roster.js';
+export const characters = [...new Set([...Object.values(p1Stages).flat(),...Object.values(p2Stages).flat()])];
+const stages = ['egg','baby','child','teen','adult','dead'];
+
+export function validState(data) {
+  if (!data || !stages.includes(data.stage) || !characters.includes(data.character)) return false;
+  for (const key of ['age','weight','hunger','happiness','discipline','careMistakes','poopCount','bornAt','stageStartTime','lastHungerDecay','lastHappyDecay','lastPoopTime','lastAgeInc','lastProcessed','snacksInWindow','snackWindowStart','medDoses','sickCount']) {
+    if (!Number.isFinite(data[key]) || data[key] < 0) return false;
+  }
+  if (data.hunger > 4 || data.happiness > 4 || data.discipline > 100 || data.poopCount > 4) return false;
+  if (![data.hunger,data.happiness,data.discipline,data.poopCount].every(Number.isInteger)) return false;
+  // Older saves omit these fields. Present fields must still be safe to import.
+  for (const key of ['energy','health']) if (key in data && (!Number.isFinite(data[key]) || data[key]<0 || data[key]>100)) return false;
+  for (const key of ['wellbeingUpdatedAt','careTotal','careDuration','sleepOverrideUntil']) if (key in data && (!Number.isFinite(data[key]) || data[key]<0)) return false;
+  if ('sleepOverride' in data && !['auto','sleep','wake'].includes(data.sleepOverride)) return false;
+  if (data.careTotal > data.careDuration * 100 + 1) return false;
+  if (('careTotal' in data) !== ('careDuration' in data)) return false;
+  if (('sleepOverride' in data) !== ('sleepOverrideUntil' in data)) return false;
+  if (data.wellbeingUpdatedAt > data.lastProcessed + 300000) return false;
+  if ('vacationAt' in data && (!Number.isFinite(data.vacationAt) || data.vacationAt<0 || data.vacationAt>data.lastProcessed+300000)) return false;
+  if (data.vacationAt>0 && data.vacationAt<data.lastProcessed) return false;
+  if (data.sleepOverride !== undefined && data.sleepOverride !== 'auto' && (!Number.isFinite(data.wellbeingUpdatedAt) || data.sleepOverrideUntil > data.wellbeingUpdatedAt + 7500000)) return false;
+  for (const key of ['isSick','isSleeping','lightOn','isDead','isMisbehaving']) if (typeof data[key] !== 'boolean') return false;
+  return data.attentionCallTime === null || Number.isFinite(data.attentionCallTime);
+}
+