lilgotchi 0.0.0-stage → 3.0.2

package/dist/pets/lilgotchi-sprites.js

@@ -0,0 +1,62 @@
+const palette=['','#fff0cc','#e7c88d','#435345','#c7dfcf','#dac9a5','#735443','#638b82','#fffbea'];
+const expressions=['idle1','idle2','happy','sad','eat','sleep','lookLeft','lookRight','lookUp'];
+const designs=[
+  {id:'egg',name:'Little Egg',stage:'egg',widths:[2,4,6,6,4],fill:1,edge:2},
+  {id:'babytchi',name:'Peep Egg',stage:'baby',widths:[2,4,6,8,8,6,4],fill:1,edge:2,face:8},
+  {id:'marutchi',name:'Growing Egg',stage:'child',widths:[2,4,6,8,8,10,10,8,6],fill:1,edge:2,face:6},
+  {id:'tamatchi',name:'Smooth Egg',stage:'teen',widths:[2,4,6,8,8,10,10,10,8,6],fill:1,edge:2,face:6,marks:[[4,3,8],[3,5,8]]},
+  {id:'kuchitamatchi',name:'Speckled Egg',stage:'teen',widths:[2,4,6,8,8,10,10,10,8,6],fill:5,edge:2,face:6,marks:[[5,3,6],[3,5,6],[8,5,6],[3,8,6],[7,10,6]]},
+  {id:'mametchi',name:'Duck Egg',stage:'adult',widths:[2,4,6,8,8,10,10,10,10,8,6],fill:4,edge:2,face:6,marks:[[4,3,8],[3,5,8],[8,9,1]]},
+  {id:'ginjirotchi',name:'Quail Egg',stage:'adult',widths:[2,4,6,8,8,8,6,4],fill:5,edge:6,face:7,marks:[[5,5,6],[3,7,6],[8,7,6],[4,9,6],[7,10,6]]},
+  {id:'maskutchi',name:'Goose Egg',stage:'adult',widths:[2,4,6,6,8,8,8,10,10,10,8,6],fill:8,edge:2,face:6,marks:[[4,3,1],[3,7,1],[8,9,1]]},
+  {id:'kuchipatchi',name:'Jumbo Egg',stage:'adult',widths:[4,6,8,10,10,12,12,12,12,12,10,8],fill:1,edge:2,face:6,marks:[[3,3,8],[2,5,8],[2,6,8],[9,9,2]]},
+  {id:'nyorotchi',name:'Golden Egg',stage:'adult',widths:[2,4,6,8,8,10,10,10,8,6],fill:2,edge:6,face:6,ink:6,marks:[[5,3,8],[4,4,8],[3,5,8],[3,6,1],[8,9,1]]},
+  {id:'tarakotchi',name:'Century Egg',stage:'adult',widths:[2,4,6,8,10,10,10,10,8,6],fill:7,edge:6,face:6,ink:8,marks:[[5,3,4],[4,4,4],[3,5,4],[8,9,3]]},
+  {id:'oyajitchi',name:'Cracked Elder',stage:'adult',widths:[2,4,6,6,8,8,8,10,10,10,8,6],fill:8,edge:2,face:6,marks:[[5,1,3],[6,2,3],[5,3,3],[6,4,3],[4,3,1],[3,7,1]]},
+];
+function draw(design,expression){
+  const frame=Array.from({length:12},()=>Array(12).fill(0));
+  const top=12-design.widths.length;
+  design.widths.forEach((width,row)=>{
+    const left=(12-width)/2;
+    for(let x=left;x<left+width;x++)frame[top+row][x]=row===design.widths.length-1||x===left||x===left+width-1?design.edge:design.fill;
+  });
+  for(const [x,y,color] of design.marks||[])if(frame[y][x])frame[y][x]=color;
+  if(design.stage==='egg'){
+    if(expression==='idle2'){frame[8][5]=8;frame[8][6]=8;}
+    return frame;
+  }
+  const y=design.face-(expression==='lookUp'?1:0),ink=design.ink||3;
+  const pixel=(x,dy,color=ink)=>{if(frame[y+dy]?.[x])frame[y+dy][x]=color;};
+  if(expression==='lookLeft'||expression==='lookRight'){
+    const left=expression==='lookLeft';
+    pixel(left?3:6,0);pixel(left?5:8,0);
+    pixel(left?2:9,1);pixel(left?3:8,2);
+  }else if(expression==='happy'){
+    pixel(4,0);pixel(3,1);pixel(5,1);pixel(7,0);pixel(6,1);pixel(8,1);pixel(5,2);pixel(6,2);
+  }else if(expression==='sleep'){
+    pixel(3,1);pixel(4,1);pixel(7,1);pixel(8,1);
+  }else if(expression==='sad'){
+    pixel(4,0);pixel(7,0);pixel(5,1);pixel(6,1);pixel(4,2);pixel(7,2);
+  }else{
+    pixel(4,0);pixel(7,0);
+    if(expression==='eat'){pixel(5,1);pixel(6,1);pixel(5,2);pixel(6,2);}
+    else if(expression==='idle2'){pixel(5,2);pixel(6,2);}
+    else pixel(5,2);
+  }
+  if(design.id==='oyajitchi'){
+    // A missing side shard opens into a long jagged crack beside the face.
+    for(const [x,y] of [[8,2],[8,3],[7,3],[8,4],[9,4],[8,5]])frame[y][x]=0;
+    for(const [x,y] of [[7,4],[7,5],[8,6],[9,7],[8,8],[9,9],[8,10]])frame[y][x]=3;
+  }
+  return frame;
+}
+const artwork={
+  type:'Lilgotchi',palette,
+  pets:designs.map(design=>({id:design.id,name:design.name,stage:design.stage,frames:Object.fromEntries((design.stage==='egg'?['idle1','idle2']:expressions).map(expression=>[expression,draw(design,expression)]))})),
+};
+
+const freezeFrame=frame=>Object.freeze(frame.map(row=>Object.freeze([...row])));
+export const lilgotchiPalette=Object.freeze(artwork.palette);
+export const lilgotchiNames=Object.freeze(Object.fromEntries(artwork.pets.map(pet=>[pet.id,pet.name])));
+export const lilgotchiSprites=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/minigames/bump.js

@@ -0,0 +1,52 @@
+import { model } from "./model.js";
+export function createBump({ slow = false } = {}) {
+  const period = slow ? 3200 : 1600;
+  const s = {
+    id: "bump",
+    phase: "countdown",
+    result: null,
+    paused: false,
+    bout: 1,
+    wins: 0,
+    meter: 0,
+    target: [60, 85],
+    phaseTime: 0,
+    boutWon: null,
+  };
+  const settle = (win) => {
+    s.boutWon = win;
+    if (win) s.wins++;
+    s.phase = "reveal";
+    s.phaseTime = 0;
+  };
+  return model(
+    s,
+    (dt) => {
+      s.phaseTime += dt;
+      if (s.phase === "countdown" && s.phaseTime >= 1500) {
+        s.phase = "meter";
+        s.phaseTime = 0;
+      } else if (s.phase === "meter") {
+        const t = s.phaseTime % period;
+        s.meter = t <= period / 2 ? (t / period) * 200 : ((period - t) / period) * 200;
+        if (s.phaseTime >= 6000) settle(false);
+      } else if (s.phase === "reveal" && s.phaseTime >= 1200) {
+        if (s.bout === 3) {
+          s.result = s.wins >= 2 ? "win" : "loss";
+          s.phase = "done";
+        } else {
+          s.bout++;
+          s.target = [60 + (s.bout - 1) * 3, 85 - (s.bout - 1) * 3];
+          s.phase = "countdown";
+          s.phaseTime = 0;
+          s.meter = 0;
+          s.boutWon = null;
+        }
+      }
+    },
+    (action) => {
+      if (action === "bump" && s.phase === "meter")
+        settle(s.meter >= s.target[0] && s.meter <= s.target[1]);
+    },
+  );
+}

package/dist/pets/minigames/flag.js

@@ -0,0 +1,87 @@
+// Flag cues are settled once, including fake cues where waiting is the answer.
+export function createFlag({ random = Math.random, slow = false } = {}) {
+  const types = ["left", "right", "both", "fake"];
+  const duration = slow ? 4000 : 2400;
+  let phase = "prepare",
+    result = null,
+    paused = false,
+    remaining = 900;
+  let round = 1,
+    score = 0,
+    response = null,
+    correct = null;
+  let cue = types[Math.min(3, Math.max(0, Math.floor(random() * 4)))];
+  function settle() {
+    correct = cue === "fake" ? response === null : response === cue;
+    if (correct) score++;
+    phase = "rest";
+    remaining = 900;
+  }
+  return {
+    input(action) {
+      if (
+        result ||
+        paused ||
+        phase !== "cue" ||
+        response !== null ||
+        !["left", "right", "both"].includes(action)
+      )
+        return false;
+      response = action;
+      return true;
+    },
+    advance(ms) {
+      if (!Number.isFinite(ms) || ms <= 0 || result || paused) return;
+      while (ms > 0 && !result) {
+        const step = Math.min(ms, remaining);
+        ms -= step;
+        remaining -= step;
+        if (remaining > 0) break;
+        if (phase === "prepare") {
+          phase = "cue";
+          remaining = duration;
+        } else if (phase === "cue") settle();
+        else if (round === 15) {
+          phase = "done";
+          result = score >= 12 ? "win" : "loss";
+        } else {
+          round++;
+          phase = "cue";
+          remaining = duration;
+          response = null;
+          correct = null;
+          cue = types[Math.min(3, Math.max(0, Math.floor(random() * 4)))];
+        }
+      }
+    },
+    pause() {
+      if (!result) paused = true;
+    },
+    resume() {
+      paused = false;
+    },
+    quit() {
+      if (!result) {
+        result = "quit";
+        phase = "done";
+      }
+    },
+    snapshot() {
+      return {
+        id: "flag",
+        phase,
+        result,
+        paused,
+        cue,
+        response,
+        correct,
+        round,
+        rounds: 15,
+        score,
+        target: 12,
+        remaining,
+        duration,
+      };
+    },
+  };
+}

package/dist/pets/minigames/get.js

@@ -0,0 +1,59 @@
+import { model, randomIndex, clamp } from "./model.js";
+export function createGet({ random = Math.random } = {}) {
+  const s = {
+    id: "get",
+    phase: "playing",
+    result: null,
+    paused: false,
+    elapsed: 0,
+    remaining: 30000,
+    score: 0,
+    lives: 3,
+    lane: 1,
+    object: null,
+    reaction: null,
+  };
+  let wait = 300,
+    moveTime = -150;
+  return model(
+    s,
+    (dt) => {
+      s.elapsed += dt;
+      s.remaining = Math.max(0, 30000 - s.elapsed);
+      if (s.object) {
+        s.object.y +=
+          dt * (s.elapsed < 10000 ? 0.009 : s.elapsed < 20000 ? 0.011 : 0.013);
+        if (s.object.y >= 10) {
+          if (s.object.lane === s.lane) {
+            if (s.object.kind === "note") {
+              s.score++;
+              s.reaction = "happy";
+            } else {
+              s.lives--;
+              s.reaction = "startled";
+            }
+          }
+          s.object = null;
+          wait = 200;
+        }
+      } else if ((wait -= dt) <= 0) {
+        s.object = {
+          lane: randomIndex(random, 3),
+          kind: random() < 0.8 ? "note" : "poop",
+          y: 0,
+        };
+        s.reaction = null;
+      }
+      if (!s.lives || !s.remaining) {
+        s.result = s.lives > 0 && s.score >= 12 ? "win" : "loss";
+        s.phase = "done";
+      }
+    },
+    (action) => {
+      if (["left", "right"].includes(action) && s.elapsed - moveTime >= 150) {
+        s.lane = clamp(s.lane + (action === "left" ? -1 : 1), 0, 2);
+        moveTime = s.elapsed;
+      }
+    },
+  );
+}

package/dist/pets/minigames/heading.js

@@ -0,0 +1,117 @@
+import { model, clamp } from "./model.js";
+import { headingPose, FIELD_HEIGHT, FIELD_WIDTH } from "../arcade-geometry.js";
+
+const defaultSprite = Array.from({ length: 12 }, () => Array(12).fill(1));
+
+// Compare ball and head movement together so a rising jump cannot skip contact.
+export function touchesHead(beforeBall, ball, beforeHead, head) {
+  return head.some((pixel, index) => {
+    const previous = beforeHead[index];
+    return (
+      ball.x + 2 > pixel.x && ball.x < pixel.x + 1 &&
+      beforeBall.y + 2 <= previous.y && ball.y + 2 >= pixel.y
+    );
+  });
+}
+export function createHeading({
+  random = Math.random,
+  slow = false,
+  sprite = defaultSprite,
+} = {}) {
+  const halfWidth = Math.max(...sprite.map(row => row.length)) / 2;
+  const duration = slow ? 75000 : 45000;
+  const speed = slow ? 0.6 : 1;
+  const s = {
+    id: "heading",
+    phase: "countdown",
+    result: null,
+    paused: false,
+    elapsed: 0,
+    remaining: duration,
+    score: 0,
+    misses: 0,
+    x: 16,
+    jump: 0,
+    ball: { x: 16, y: 1 },
+    phaseTime: 0,
+  };
+  let jumpTime = -1,
+    velocity = 0,
+    moveTime = -100,
+    vx = 0.003;
+  const serve = () => {
+    s.ball = { x: clamp(s.x + (random() < 0.5 ? -3 : 3), 2, 29), y: 1 };
+    vx = random() < 0.5 ? -0.003 : 0.003;
+    velocity = 0.006 + Math.floor(s.score / 3) * 0.001;
+    s.phase = "playing";
+  };
+  return model(
+    s,
+    (dt) => {
+      const previousHead = headingPose(sprite, s.x, s.jump).head;
+      s.elapsed += dt;
+      s.remaining = Math.max(0, duration - s.elapsed);
+      dt *= speed;
+      s.phaseTime += dt;
+      if (jumpTime >= 0) {
+        jumpTime += dt;
+        s.jump = 3 * Math.sin(Math.PI * Math.min(1, jumpTime / 700));
+        if (jumpTime >= 700) {
+          jumpTime = -1;
+          s.jump = 0;
+        }
+      }
+      if (s.phase === "countdown" && s.phaseTime >= 1000) serve();
+      if (s.phase === "playing") {
+        const previous = { ...s.ball };
+        s.ball.y += velocity * dt;
+        s.ball.x += vx * dt;
+        if (s.ball.x < 1 || s.ball.x > 29) {
+          s.ball.x = clamp(s.ball.x, 1, 29);
+          vx = -vx;
+        }
+        velocity += dt * 0.000012;
+        if (s.ball.y < 1) {
+          s.ball.y = 1;
+          velocity = Math.abs(velocity);
+        }
+        const head = headingPose(sprite, s.x, s.jump).head;
+        if (
+          velocity > 0 && jumpTime >= 0 &&
+          touchesHead(previous, s.ball, previousHead, head)
+        ) {
+          s.score++;
+          const contact = head.filter(pixel =>
+            s.ball.x + 2 > pixel.x && s.ball.x < pixel.x + 1);
+          s.ball.y = Math.min(...contact.map(pixel => pixel.y)) - 2;
+          velocity = -0.016 - Math.floor(s.score / 3) * 0.001;
+          if (s.score >= 10) {
+            s.result = "win";
+            s.phase = "done";
+          }
+        } else if (s.ball.y >= FIELD_HEIGHT - 2) {
+          s.misses++;
+          s.phase = "countdown";
+          s.phaseTime = 0;
+          s.ball.y = FIELD_HEIGHT - 2;
+        }
+      }
+      if (!s.result && (s.misses >= 3 || !s.remaining)) {
+        s.result = "loss";
+        s.phase = "done";
+      }
+    },
+    (action) => {
+      if (["left", "right"].includes(action) && s.elapsed - moveTime >= 100) {
+        s.x = clamp(
+          s.x + (action === "left" ? -2 : 2),
+          halfWidth,
+          FIELD_WIDTH - halfWidth,
+        );
+        moveTime = s.elapsed;
+      }
+      if (action === "jump" && s.phase === "playing" && jumpTime < 0)
+        jumpTime = 0;
+    },
+  );
+}

package/dist/pets/minigames/hoops.js

@@ -0,0 +1,96 @@
+export function createHoops({ slow = false } = {}) {
+  const period = slow ? 4000 : 2400;
+  let phase = "ready",
+    result = null,
+    paused = false,
+    shot = 1,
+    score = 0;
+  let elapsed = 0,
+    arcElapsed = 0,
+    made = null,
+    marker = 0;
+  const target = () => ({
+    min: 0.5 - Math.max(0.08, 0.18 - score * 0.02),
+    max: 0.5 + Math.max(0.08, 0.18 - score * 0.02),
+  });
+  return {
+    input(action) {
+      if (paused || result) return false;
+      if (phase === "ready" && ["ready", "shoot"].includes(action)) {
+        phase = "aim";
+        elapsed = 0;
+        marker = 0;
+        return true;
+      }
+      if (phase !== "aim" || action !== "shoot") return false;
+      const bounds = target();
+      made =
+        marker + Number.EPSILON >= bounds.min &&
+        marker - Number.EPSILON <= bounds.max;
+      phase = "arc";
+      arcElapsed = 0;
+      return true;
+    },
+    advance(ms) {
+      if (!Number.isFinite(ms) || ms <= 0 || result || paused) return;
+      if (phase === "aim") {
+        elapsed += ms;
+        const cycle = (elapsed % period) / period;
+        marker = cycle <= 0.5 ? cycle * 2 : (1 - cycle) * 2;
+      } else if (phase === "arc") {
+        arcElapsed = Math.min(900, arcElapsed + ms);
+        if (arcElapsed === 900) {
+          if (made) score++;
+          if (shot === 5) {
+            phase = "done";
+            result = score >= 3 ? "win" : "loss";
+          } else {
+            shot++;
+            phase = "ready";
+          }
+        }
+      }
+    },
+    pause() {
+      if (!result) paused = true;
+    },
+    resume() {
+      paused = false;
+    },
+    quit() {
+      if (!result) {
+        result = "quit";
+        phase = "done";
+      }
+    },
+    snapshot() {
+      const t = ["arc", "done"].includes(phase) ? arcElapsed / 900 : 0;
+      // A made shot reaches the rim on its way down, then drops through the net.
+      const rimTime = 0.72;
+      const flight = Math.min(1, t / rimTime);
+      const endX = made ? 26 : marker < 0.5 ? 21 : 29;
+      const ball = t <= rimTime
+        ? {
+            x: 10 + (endX - 10) * flight,
+            y: 16 - 8 * flight - 9 * Math.sin(Math.PI * flight),
+          }
+        : { x: endX, y: 8 + 7 * ((t - rimTime) / (1 - rimTime)) };
+      return {
+        id: "hoops",
+        phase,
+        result,
+        paused,
+        shot,
+        shots: 5,
+        score,
+        targetScore: 3,
+        marker,
+        target: target(),
+        made,
+        arcProgress: t,
+        hoop: { centerX: 27, rimY: 9, left: 24, right: 30 },
+        ball: { x: Math.round(ball.x), y: Math.round(ball.y) },
+      };
+    },
+  };
+}

package/dist/pets/minigames/memory.js

@@ -0,0 +1,81 @@
+import { model, randomIndex } from "./model.js";
+export function createMemory({ random = Math.random, slow = false } = {}) {
+  const sequence = Array.from(
+    { length: 6 },
+    () => ["left", "up", "right"][randomIndex(random, 3)],
+  );
+  const s = {
+    id: "memory",
+    phase: "watch",
+    result: null,
+    paused: false,
+    round: 1,
+    length: 2,
+    cue: sequence[0],
+    cueIndex: 0,
+    entered: 0,
+    lastInput: null,
+    inputRemaining: 0,
+    phaseTime: 0,
+  };
+  const duration = slow ? 1000 : 600,
+    gap = slow ? 350 : 200;
+  const restart = () => {
+    s.phase = "watch";
+    s.phaseTime = 0;
+    s.cueIndex = 0;
+    s.cue = sequence[0];
+    s.entered = 0;
+  };
+  return model(
+    s,
+    (dt) => {
+      s.inputRemaining = Math.max(0, s.inputRemaining - dt);
+      if (!s.inputRemaining) s.lastInput = null;
+      if (s.phase === "answer") return;
+      s.phaseTime += dt;
+      if (s.phase === "between" && s.phaseTime >= 450) {
+        restart();
+        return;
+      }
+      if (s.phase === "watch" && s.phaseTime >= duration) {
+        s.cue = null;
+        s.phase = "gap";
+        s.phaseTime = 0;
+      } else if (s.phase === "gap" && s.phaseTime >= gap) {
+        s.phaseTime = 0;
+        s.cueIndex++;
+        if (s.cueIndex >= s.length) s.phase = "answer";
+        else {
+          s.phase = "watch";
+          s.cue = sequence[s.cueIndex];
+        }
+      }
+    },
+    (action) => {
+      if (s.phase !== "answer" || !["left", "up", "right"].includes(action))
+        return;
+      s.lastInput = action;
+      s.inputRemaining = 450;
+      if (action !== sequence[s.entered]) {
+        s.result = "loss";
+        s.phase = "done";
+        return;
+      }
+      if (++s.entered === s.length) {
+        if (s.round === 5) {
+          s.result = "win";
+          s.phase = "done";
+        } else {
+          s.round++;
+          s.length++;
+          s.phase = "between";
+          s.phaseTime = 0;
+        }
+      }
+    },
+    () => {
+      if (s.phase === "watch" || s.phase === "gap") restart();
+    },
+  );
+}

package/dist/pets/minigames/model.js

@@ -0,0 +1,40 @@
+export function model(state, step, input, onResume = () => {}) {
+  let remainder = 0;
+  const active = () => !state.result && !state.paused;
+  return {
+    input(action) {
+      if (active()) input(action);
+    },
+    advance(ms) {
+      if (!Number.isFinite(ms) || ms < 0)
+        throw new RangeError("Elapsed time must be finite and positive");
+      if (!active()) return;
+      remainder += ms;
+      while (remainder >= 10 && active()) {
+        remainder -= 10;
+        step(10);
+      }
+    },
+    snapshot() {
+      return structuredClone(state);
+    },
+    pause() {
+      if (!state.result) state.paused = true;
+    },
+    resume() {
+      if (state.paused && !state.result) {
+        state.paused = false;
+        onResume();
+      }
+    },
+    quit() {
+      if (!state.result) {
+        state.result = "quit";
+        state.phase = "done";
+      }
+    },
+  };
+}
+export const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+export const randomIndex = (random, length) =>
+  clamp(Math.floor(random() * length), 0, length - 1);

package/dist/pets/minigames/sprint.js

@@ -0,0 +1,103 @@
+// Both input modes advance at most once each half second.
+export function createSprint({ hold = false, slow = false } = {}) {
+  const finish = 30,
+    tapInterval = 500,
+    opponentDuration = slow ? 20000 : 18000;
+  let phase = "countdown",
+    result = null,
+    paused = false,
+    countdown = 3000;
+  let elapsed = 0,
+    progress = 0,
+    lastTap = -tapInterval,
+    holding = false,
+    nextHold = 0,
+    queuedTap = false;
+  function settle() {
+    if (progress >= finish) {
+      progress = finish;
+      phase = "done";
+      result = "win";
+    } else if (elapsed >= opponentDuration) {
+      phase = "done";
+      result = "loss";
+    }
+  }
+  return {
+    input(action) {
+      if (paused || result || phase !== "race") return false;
+      if (hold && ["hold", "start-hold", "stop-hold"].includes(action)) {
+        holding = action === "hold" ? !holding : action === "start-hold";
+        nextHold = Math.max(elapsed, lastTap + tapInterval);
+        return true;
+      }
+      if (!hold && action === "run" && elapsed - lastTap >= tapInterval) {
+        lastTap = elapsed;
+        queuedTap = false;
+        progress++;
+        settle();
+        return true;
+      }
+      // Keep one early tap for the next step, never a burst of queued steps.
+      if (!hold && action === "run") queuedTap = true;
+      return false;
+    },
+    advance(ms) {
+      if (!Number.isFinite(ms) || ms <= 0 || result || paused) return;
+      if (phase === "countdown") {
+        const step = Math.min(countdown, ms);
+        countdown -= step;
+        ms -= step;
+        if (countdown === 0) phase = "race";
+      }
+      if (phase !== "race") return;
+      const end = Math.min(opponentDuration, elapsed + ms);
+      if (!hold && queuedTap && lastTap + tapInterval <= end) {
+        elapsed = lastTap + tapInterval;
+        lastTap = elapsed;
+        queuedTap = false;
+        progress++;
+        settle();
+      }
+      while (hold && holding && nextHold <= end && !result) {
+        elapsed = nextHold;
+        progress++;
+        lastTap = elapsed;
+        nextHold += tapInterval;
+        settle();
+      }
+      if (!result) {
+        elapsed = end;
+        settle();
+      }
+    },
+    pause() {
+      if (!result) paused = true;
+    },
+    resume() {
+      paused = false;
+    },
+    quit() {
+      if (!result) {
+        result = "quit";
+        phase = "done";
+      }
+    },
+    snapshot() {
+      return {
+        id: "sprint",
+        phase,
+        result,
+        paused,
+        countdown,
+        elapsed,
+        progress,
+        finish,
+        opponent: Math.min(finish, (elapsed / opponentDuration) * finish),
+        holding,
+        hold,
+        opponentDuration,
+      };
+    },
+  };
+}