1175 lines
49 KiB
JavaScript
1175 lines
49 KiB
JavaScript
(function () {
|
|
const $ = (sel, root = document) => root.querySelector(sel);
|
|
const $$ = (sel, root = document) => Array.from(root.querySelectorAll(sel));
|
|
const shuffle = (items) => items.map((value) => ({ value, sort: Math.random() })).sort((a, b) => a.sort - b.sort).map((item) => item.value);
|
|
const quips = [
|
|
"A margin note blinks, then pretends it did not.",
|
|
"Somewhere, a bookmark changes its mind.",
|
|
"The archive is pleased by unnecessary curiosity.",
|
|
"A tiny bell rings in a room you have not built yet.",
|
|
"The page remembers that you came here."
|
|
];
|
|
|
|
document.addEventListener("DOMContentLoaded", () => {
|
|
const root = $(".play-root[data-play-page]");
|
|
if (!root) return;
|
|
const page = root.dataset.playPage;
|
|
const inits = { hub, memory, constellation, poem, bookshelf, recipe, timeline, ink, terminal, study, sigil, rpg, gentleConstellarium, futureZReturnLog, subconsciousIndex };
|
|
if (inits[page]) inits[page](root);
|
|
});
|
|
|
|
function hub(root) {
|
|
const links = $$(".play-grid a", root);
|
|
const nodes = $$(".play-orbit__node", root);
|
|
const title = $("#play-hub-title", root);
|
|
const kind = $("#play-hub-kind", root);
|
|
const desc = $("#play-hub-desc", root);
|
|
const cta = $("#play-hub-link", root);
|
|
const whisper = document.createElement("p");
|
|
let active = 0;
|
|
|
|
whisper.className = "play-whisper";
|
|
whisper.setAttribute("aria-live", "polite");
|
|
$(".play-console__screen", root).appendChild(whisper);
|
|
|
|
nodes.forEach((node, index) => {
|
|
const angle = (index / nodes.length) * Math.PI * 2 - Math.PI / 2;
|
|
node.style.left = `${50 + Math.cos(angle) * 43}%`;
|
|
node.style.top = `${50 + Math.sin(angle) * 43}%`;
|
|
node.addEventListener("click", () => setActive(index));
|
|
});
|
|
|
|
function setActive(index) {
|
|
active = (index + links.length) % links.length;
|
|
const link = links[active];
|
|
links.forEach((item, i) => item.classList.toggle("is-active", i === active));
|
|
nodes.forEach((item, i) => item.classList.toggle("is-active", i === active));
|
|
title.textContent = link.querySelector("strong").textContent;
|
|
kind.textContent = link.dataset.kind;
|
|
desc.textContent = link.dataset.desc;
|
|
cta.href = link.href;
|
|
whisper.textContent = quips[active % quips.length];
|
|
}
|
|
|
|
links.forEach((link, index) => {
|
|
link.addEventListener("mouseenter", () => setActive(index));
|
|
link.addEventListener("focus", () => setActive(index));
|
|
});
|
|
$("[data-play-prev]", root).addEventListener("click", () => setActive(active - 1));
|
|
$("[data-play-next]", root).addEventListener("click", () => setActive(active + 1));
|
|
$("[data-play-random]", root).addEventListener("click", () => setActive(Math.floor(Math.random() * links.length)));
|
|
$(".play-orbit", root).addEventListener("dblclick", () => {
|
|
whisper.textContent = "You knocked twice. The cabinet knocked once back.";
|
|
root.classList.toggle("is-odd");
|
|
});
|
|
root.addEventListener("keydown", (event) => {
|
|
if (event.key === "ArrowLeft") setActive(active - 1);
|
|
if (event.key === "ArrowRight") setActive(active + 1);
|
|
});
|
|
setActive(0);
|
|
}
|
|
|
|
function memory(root) {
|
|
const symbols = ["Ink", "Lamp", "Tea", "Book", "Map", "Key"];
|
|
const board = $("[data-memory-board]", root);
|
|
const turnsEl = $("[data-memory-turns]", root);
|
|
const matchesEl = $("[data-memory-matches]", root);
|
|
const messageEl = $("[data-memory-message]", root);
|
|
let open = [];
|
|
let turns = 0;
|
|
let matches = 0;
|
|
let deck = [];
|
|
|
|
function render() {
|
|
board.innerHTML = "";
|
|
open = [];
|
|
turns = 0;
|
|
matches = 0;
|
|
deck = shuffle([...symbols, ...symbols]);
|
|
turnsEl.textContent = "0";
|
|
matchesEl.textContent = "0";
|
|
messageEl.textContent = "Cards are shuffled.";
|
|
deck.forEach((symbol, index) => {
|
|
const card = document.createElement("button");
|
|
card.type = "button";
|
|
card.className = "memory-card";
|
|
card.dataset.symbol = symbol;
|
|
card.textContent = "?";
|
|
card.style.setProperty("--tilt", `${(index % 5) - 2}deg`);
|
|
card.setAttribute("aria-label", "Hidden card");
|
|
card.addEventListener("click", () => flip(card));
|
|
board.appendChild(card);
|
|
});
|
|
}
|
|
|
|
function flip(card) {
|
|
if (card.classList.contains("is-open") || card.classList.contains("is-matched") || open.length === 2) return;
|
|
card.classList.add("is-open");
|
|
card.textContent = card.dataset.symbol;
|
|
card.setAttribute("aria-label", card.dataset.symbol);
|
|
open.push(card);
|
|
if (open.length !== 2) return;
|
|
turns += 1;
|
|
turnsEl.textContent = String(turns);
|
|
const [a, b] = open;
|
|
if (a.dataset.symbol === b.dataset.symbol) {
|
|
a.classList.add("is-matched");
|
|
b.classList.add("is-matched");
|
|
open = [];
|
|
matches += 1;
|
|
matchesEl.textContent = String(matches);
|
|
messageEl.textContent = matches === symbols.length ? `Cabinet solved in ${turns} turns.` : "A drawer clicks open.";
|
|
} else {
|
|
messageEl.textContent = "No match. The cabinet quietly re-files them.";
|
|
setTimeout(() => {
|
|
a.classList.remove("is-open");
|
|
b.classList.remove("is-open");
|
|
a.textContent = "?";
|
|
b.textContent = "?";
|
|
a.setAttribute("aria-label", "Hidden card");
|
|
b.setAttribute("aria-label", "Hidden card");
|
|
open = [];
|
|
}, 650);
|
|
}
|
|
}
|
|
|
|
$("[data-memory-reset]", root).addEventListener("click", render);
|
|
$("[data-memory-peek]", root).addEventListener("click", () => {
|
|
const hidden = $$(".memory-card:not(.is-open):not(.is-matched)", root);
|
|
hidden.forEach((card) => {
|
|
card.textContent = card.dataset.symbol;
|
|
card.classList.add("is-peeking");
|
|
});
|
|
messageEl.textContent = "A very brief lapse in scholarly discipline.";
|
|
setTimeout(() => {
|
|
hidden.forEach((card) => {
|
|
if (!card.classList.contains("is-open") && !card.classList.contains("is-matched")) card.textContent = "?";
|
|
card.classList.remove("is-peeking");
|
|
});
|
|
}, 900);
|
|
});
|
|
render();
|
|
}
|
|
|
|
function constellation(root) {
|
|
const canvas = $("[data-star-canvas]", root);
|
|
const ctx = canvas.getContext("2d");
|
|
const linesEl = $("[data-star-lines]", root);
|
|
const nameEl = document.createElement("strong");
|
|
const stars = Array.from({ length: 18 }, () => ({ x: 50 + Math.random() * 800, y: 45 + Math.random() * 430 }));
|
|
const lines = [];
|
|
let selected = null;
|
|
nameEl.className = "play-live-note";
|
|
linesEl.closest(".play-scorebar").appendChild(nameEl);
|
|
|
|
function draw() {
|
|
ctx.clearRect(0, 0, canvas.width, canvas.height);
|
|
ctx.fillStyle = "#18130f";
|
|
ctx.fillRect(0, 0, canvas.width, canvas.height);
|
|
ctx.strokeStyle = "rgba(219, 184, 104, 0.65)";
|
|
ctx.lineWidth = 2;
|
|
lines.forEach(([a, b]) => {
|
|
ctx.beginPath();
|
|
ctx.moveTo(stars[a].x, stars[a].y);
|
|
ctx.lineTo(stars[b].x, stars[b].y);
|
|
ctx.stroke();
|
|
});
|
|
stars.forEach((star, index) => {
|
|
ctx.beginPath();
|
|
ctx.fillStyle = index === selected ? "#f6d889" : "#fff8e8";
|
|
ctx.arc(star.x, star.y, index === selected ? 7 : 4, 0, Math.PI * 2);
|
|
ctx.fill();
|
|
});
|
|
linesEl.textContent = String(lines.length);
|
|
if (lines.length >= 3) nameEl.textContent = `Named: ${pick(["The Patient Spoon", "The South Window", "The Tired Comet", "The Fifth Errand"])}`;
|
|
}
|
|
|
|
canvas.addEventListener("click", (event) => {
|
|
const rect = canvas.getBoundingClientRect();
|
|
const x = ((event.clientX - rect.left) / rect.width) * canvas.width;
|
|
const y = ((event.clientY - rect.top) / rect.height) * canvas.height;
|
|
const hit = stars.findIndex((star) => Math.hypot(star.x - x, star.y - y) < 22);
|
|
if (hit < 0) return;
|
|
if (selected === null) selected = hit;
|
|
else if (selected !== hit) {
|
|
lines.push([selected, hit]);
|
|
selected = hit;
|
|
}
|
|
draw();
|
|
});
|
|
$("[data-star-reset]", root).addEventListener("click", () => {
|
|
lines.length = 0;
|
|
selected = null;
|
|
nameEl.textContent = "";
|
|
draw();
|
|
});
|
|
draw();
|
|
}
|
|
|
|
function poem(root) {
|
|
const output = $("[data-poem-output]", root);
|
|
const a = ["In the margin", "By the kettle", "Under the desk lamp", "Between two errands", "After the house quiets"];
|
|
const b = ["a careful thought", "an old joke", "a stubborn question", "a useful mistake", "a bright scrap"];
|
|
const c = ["learns to wait.", "asks for a second reading.", "finds its proper shelf.", "becomes tomorrow's note.", "keeps the page warm."];
|
|
let count = 0;
|
|
function make() {
|
|
count += 1;
|
|
output.innerHTML = `${pick(a)}<br>${pick(b)}<br>${pick(c)}`;
|
|
output.dataset.stamp = count % 5 === 0 ? "approved by the margin" : "";
|
|
}
|
|
$("[data-poem-generate]", root).addEventListener("click", make);
|
|
make();
|
|
}
|
|
|
|
function bookshelf(root) {
|
|
const titles = ["Algebra at Breakfast", "Cabinet of Weather", "Domestic Orbits", "Evening Margins", "Household Engines", "Zettels and Tea"];
|
|
const shelf = $("[data-bookshelf]", root);
|
|
const status = $("[data-bookshelf-status]", root);
|
|
let sortedOnce = false;
|
|
setupSortable(shelf, render, check);
|
|
$("[data-bookshelf-shuffle]", root).addEventListener("click", () => render(shuffle(titles)));
|
|
render(shuffle(titles));
|
|
|
|
function render(items) {
|
|
shelf.innerHTML = "";
|
|
items.forEach((title) => {
|
|
const book = document.createElement("div");
|
|
book.className = "book-spine";
|
|
book.draggable = true;
|
|
book.dataset.value = title;
|
|
book.textContent = title;
|
|
shelf.appendChild(book);
|
|
});
|
|
check();
|
|
}
|
|
function check() {
|
|
const current = $$(".book-spine", shelf).map((book) => book.dataset.value);
|
|
const sorted = current.join("|") === titles.join("|");
|
|
status.textContent = sorted ? "Shelf sorted. A secret pamphlet slides out." : "Unsorted";
|
|
if (sorted && !sortedOnce) {
|
|
sortedOnce = true;
|
|
const pamphlet = document.createElement("div");
|
|
pamphlet.className = "booklet";
|
|
pamphlet.textContent = "Pamphlet: On the Correct Order of Small Things";
|
|
shelf.appendChild(pamphlet);
|
|
}
|
|
}
|
|
}
|
|
|
|
function recipe(root) {
|
|
const wheel = $("[data-recipe-spin]", root);
|
|
const result = $("[data-recipe-result]", root);
|
|
const groups = [
|
|
["Rice", "Flatbread", "Roast potatoes", "Noodles"],
|
|
["Lemon chicken", "Spiced lentils", "Tomato eggs", "Pepper stew"],
|
|
["Cucumber salad", "Mint yoghurt", "Pickled onions", "Charred greens"],
|
|
["Serve with stories", "Eat outside", "Use the blue plates", "Make extra tea"]
|
|
];
|
|
let spin = 0;
|
|
let feast = 0;
|
|
wheel.addEventListener("click", () => {
|
|
spin += 540 + Math.floor(Math.random() * 540);
|
|
feast += 1;
|
|
wheel.style.transform = `rotate(${spin}deg)`;
|
|
result.innerHTML = groups.map((group) => `<li>${pick(group)}</li>`).join("") + (feast % 4 === 0 ? "<li>Bonus: someone gets the last crispy bit.</li>" : "");
|
|
});
|
|
wheel.click();
|
|
}
|
|
|
|
function timeline(root) {
|
|
const items = [
|
|
{ year: "2022", text: "The personal web habit begins." },
|
|
{ year: "2025", text: "Org publishing becomes the main site engine." },
|
|
{ year: "2025", text: "Weekly reviews and career notes grow into a library." },
|
|
{ year: "2026", text: "Dashboards, services, and authoring tools join the site." },
|
|
{ year: "2026", text: "The play wing opens." }
|
|
];
|
|
const list = $("[data-timeline-list]", root);
|
|
const status = $("[data-timeline-status]", root);
|
|
const paradox = document.createElement("button");
|
|
paradox.type = "button";
|
|
paradox.textContent = "Paradox";
|
|
$("[data-timeline-shuffle]", root).insertAdjacentElement("afterend", paradox);
|
|
setupSortable(list, render, check);
|
|
$("[data-timeline-shuffle]", root).addEventListener("click", () => render(shuffle(items)));
|
|
paradox.addEventListener("click", () => render([...items].reverse()));
|
|
render(shuffle(items));
|
|
|
|
function render(source) {
|
|
list.innerHTML = "";
|
|
source.forEach((item, index) => {
|
|
const card = document.createElement("div");
|
|
card.className = "timeline-card";
|
|
card.draggable = true;
|
|
card.dataset.value = String(items.indexOf(item));
|
|
card.innerHTML = `<span>${item.year}</span><strong>${item.text}</strong>`;
|
|
list.appendChild(card);
|
|
});
|
|
check();
|
|
}
|
|
function check() {
|
|
const current = $$(".timeline-card", list).map((card) => Number(card.dataset.value));
|
|
status.textContent = current.every((value, index) => value === index) ? "Timeline restored" : "Arrange the cards";
|
|
}
|
|
}
|
|
|
|
function ink(root) {
|
|
const canvas = $("[data-ink-canvas]", root);
|
|
const ctx = canvas.getContext("2d");
|
|
const drops = [];
|
|
let moon = false;
|
|
function addDrop(x, y, heavy) {
|
|
drops.push({ x, y, r: heavy ? 18 : 8, life: heavy ? 1.8 : 1, hue: 28 + Math.random() * 35 });
|
|
}
|
|
function pointer(event, heavy) {
|
|
const rect = canvas.getBoundingClientRect();
|
|
addDrop(((event.clientX - rect.left) / rect.width) * canvas.width, ((event.clientY - rect.top) / rect.height) * canvas.height, heavy);
|
|
}
|
|
canvas.addEventListener("pointermove", (event) => pointer(event, false));
|
|
canvas.addEventListener("click", (event) => pointer(event, true));
|
|
canvas.addEventListener("dblclick", () => {
|
|
moon = !moon;
|
|
});
|
|
function frame() {
|
|
ctx.fillStyle = "rgba(24, 19, 15, 0.16)";
|
|
ctx.fillRect(0, 0, canvas.width, canvas.height);
|
|
if (moon) {
|
|
ctx.beginPath();
|
|
ctx.fillStyle = "rgba(246, 216, 137, 0.72)";
|
|
ctx.arc(760, 88, 34, 0, Math.PI * 2);
|
|
ctx.fill();
|
|
}
|
|
drops.forEach((drop) => {
|
|
drop.r += 0.7;
|
|
drop.life -= 0.012;
|
|
ctx.beginPath();
|
|
ctx.strokeStyle = `hsla(${drop.hue}, 65%, 68%, ${Math.max(drop.life, 0)})`;
|
|
ctx.lineWidth = 2;
|
|
ctx.arc(drop.x, drop.y, drop.r, 0, Math.PI * 2);
|
|
ctx.stroke();
|
|
});
|
|
for (let i = drops.length - 1; i >= 0; i -= 1) if (drops[i].life <= 0) drops.splice(i, 1);
|
|
requestAnimationFrame(frame);
|
|
}
|
|
frame();
|
|
}
|
|
|
|
function terminal(root) {
|
|
const log = $("[data-terminal-log]", root);
|
|
const form = $("[data-terminal-form]", root);
|
|
const input = $("[data-terminal-input]", root);
|
|
let kindness = 0;
|
|
const responses = {
|
|
help: "Commands: help, look, map, open drawer, read note, brew tea, hum, knock, save, inventory, clear",
|
|
look: "A narrow archive room. A lamp hums. A drawer is labelled MAYBE IMPORTANT.",
|
|
map: "You are between the reading desk, the family shelf, and the door back to Play.",
|
|
"open drawer": "Inside: a brass key, a receipt, and a note folded twice.",
|
|
"read note": "The note says: keep the site useful, but leave a few doors ajar.",
|
|
"brew tea": "The room smells briefly of cardamom. Nothing else changes, which is enough.",
|
|
hum: "You hum four careful notes. Something behind the wall hums five back.",
|
|
knock: "Knock. Knock. ... A polite pause. Knock.",
|
|
save: "You save your place in the archive. The archive saves its place in you.",
|
|
inventory: "You are carrying: a brass key, a warm cup, and one unreasonable hope."
|
|
};
|
|
function write(text) {
|
|
log.textContent += `${text}\n`;
|
|
log.scrollTop = log.scrollHeight;
|
|
}
|
|
form.addEventListener("submit", (event) => {
|
|
event.preventDefault();
|
|
const cmd = input.value.trim().toLowerCase();
|
|
if (!cmd) return;
|
|
input.value = "";
|
|
if (cmd === "clear") {
|
|
log.textContent = "";
|
|
return;
|
|
}
|
|
write(`> ${cmd}`);
|
|
if (cmd === "pet book") {
|
|
kindness += 1;
|
|
write(kindness > 2 ? "The book follows you for exactly three pages." : "The book accepts this with suspicious dignity.");
|
|
} else {
|
|
write(responses[cmd] || "The archive declines to understand that command.");
|
|
}
|
|
});
|
|
write("Archive terminal ready. Type help. The cursor is listening.");
|
|
input.focus();
|
|
}
|
|
|
|
function study(root) {
|
|
const time = $("[data-study-time]", root);
|
|
const scene = $("[data-study-scene]", root);
|
|
let total = 300;
|
|
let left = total;
|
|
let timer = null;
|
|
const note = document.createElement("div");
|
|
note.className = "play-live-note";
|
|
note.textContent = "The lamp is cold.";
|
|
time.insertAdjacentElement("afterend", note);
|
|
function draw() {
|
|
const done = 1 - left / total;
|
|
scene.style.setProperty("--lamp", String(0.18 + done * 0.72));
|
|
scene.style.setProperty("--glow", `${done * 70}px`);
|
|
const m = String(Math.floor(left / 60)).padStart(2, "0");
|
|
const s = String(left % 60).padStart(2, "0");
|
|
time.textContent = `${m}:${s}`;
|
|
if (left === 0) note.textContent = "Focus complete. The desk looks proud.";
|
|
else if (done > 0.66) note.textContent = "The page has warmed through.";
|
|
else if (done > 0.33) note.textContent = "The lamp has settled into its work.";
|
|
}
|
|
function start() {
|
|
if (timer) return;
|
|
timer = setInterval(() => {
|
|
left = Math.max(0, left - 1);
|
|
draw();
|
|
if (left === 0) pause();
|
|
}, 1000);
|
|
}
|
|
function pause() {
|
|
clearInterval(timer);
|
|
timer = null;
|
|
}
|
|
$("[data-study-start]", root).addEventListener("click", start);
|
|
$("[data-study-pause]", root).addEventListener("click", pause);
|
|
$("[data-study-reset]", root).addEventListener("click", () => {
|
|
pause();
|
|
left = total;
|
|
draw();
|
|
});
|
|
draw();
|
|
}
|
|
|
|
function sigil(root) {
|
|
const canvas = $("[data-sigil-canvas]", root);
|
|
const ctx = canvas.getContext("2d");
|
|
const initials = $("[data-sigil-initials]", root);
|
|
const motto = $("[data-sigil-motto]", root);
|
|
let wax = "#9c6b2f";
|
|
const waxButton = document.createElement("button");
|
|
waxButton.type = "button";
|
|
waxButton.textContent = "New wax";
|
|
$("[data-sigil-form]", root).appendChild(waxButton);
|
|
function draw() {
|
|
const text = (initials.value || "ZXH").toUpperCase();
|
|
const phrase = motto.value || "Learn, make, remember";
|
|
ctx.clearRect(0, 0, canvas.width, canvas.height);
|
|
ctx.fillStyle = "#fbf7ec";
|
|
ctx.fillRect(0, 0, canvas.width, canvas.height);
|
|
ctx.translate(260, 260);
|
|
ctx.strokeStyle = wax;
|
|
ctx.lineWidth = 10;
|
|
ctx.beginPath();
|
|
ctx.arc(0, 0, 190, 0, Math.PI * 2);
|
|
ctx.stroke();
|
|
ctx.lineWidth = 2;
|
|
for (let i = 0; i < 12; i += 1) {
|
|
ctx.rotate(Math.PI / 6);
|
|
ctx.beginPath();
|
|
ctx.moveTo(0, -150);
|
|
ctx.lineTo(0, -185);
|
|
ctx.stroke();
|
|
}
|
|
ctx.rotate(-Math.PI * 2);
|
|
ctx.fillStyle = "#2a2118";
|
|
ctx.textAlign = "center";
|
|
ctx.textBaseline = "middle";
|
|
ctx.font = "900 94px Georgia, serif";
|
|
ctx.fillText(text.slice(0, 4), 0, -10);
|
|
ctx.font = "700 22px Georgia, serif";
|
|
ctx.fillText(phrase.slice(0, 34), 0, 88);
|
|
ctx.setTransform(1, 0, 0, 1, 0, 0);
|
|
}
|
|
waxButton.addEventListener("click", () => {
|
|
wax = pick(["#9c6b2f", "#8a3f3f", "#486b57", "#3e5f8a", "#5f4b8b"]);
|
|
draw();
|
|
});
|
|
$("[data-sigil-form]", root).addEventListener("submit", (event) => {
|
|
event.preventDefault();
|
|
draw();
|
|
});
|
|
initials.addEventListener("input", draw);
|
|
motto.addEventListener("input", draw);
|
|
draw();
|
|
}
|
|
|
|
function rpg(root) {
|
|
if (window.AshBelowLakeRpg) return window.AshBelowLakeRpg(root);
|
|
const canvas = $("[data-rpg-canvas]", root);
|
|
const ctx = canvas.getContext("2d");
|
|
const els = {
|
|
speaker: $("[data-rpg-speaker]", root),
|
|
line: $("[data-rpg-line]", root),
|
|
room: $("[data-rpg-room]", root),
|
|
route: $("[data-rpg-route]", root),
|
|
hearts: $("[data-rpg-hearts]", root),
|
|
quests: $("[data-rpg-quests]", root),
|
|
inventory: $("[data-rpg-inventory]", root),
|
|
status: $("[data-rpg-status]", root)
|
|
};
|
|
const tile = 32;
|
|
const saveSlot = "hollow-archive";
|
|
const fallbackKey = "play:rpg:hollow-archive";
|
|
const items = {
|
|
lamp: { label: "Desk Lamp", room: "entrance", x: 10, y: 8, color: "#f2c94c" },
|
|
page: { label: "Loose Page", room: "stacks", x: 18, y: 5, color: "#f7efe0" },
|
|
key: { label: "Basement Key", room: "garden", x: 4, y: 11, color: "#d59b45" }
|
|
};
|
|
const npcs = {
|
|
archivist: { name: "Archivist", room: "entrance", x: 6, y: 6, color: "#b98bff" },
|
|
shade: { name: "Shy Shade", room: "stacks", x: 17, y: 9, color: "#6ed0d4" },
|
|
gate: { name: "Iron Door", room: "garden", x: 19, y: 10, color: "#8a8f98" }
|
|
};
|
|
const rooms = {
|
|
entrance: {
|
|
name: "Entrance",
|
|
floor: "#353029",
|
|
exits: [{ x: 22, y: 7, to: "stacks", px: 1, py: 7 }],
|
|
walls: rects([[0, 0, 24, 1], [0, 15, 24, 1], [0, 0, 1, 16], [23, 0, 1, 6], [23, 9, 1, 7], [8, 3, 1, 8], [14, 7, 5, 1]])
|
|
},
|
|
stacks: {
|
|
name: "Stacks",
|
|
floor: "#242d35",
|
|
exits: [{ x: 0, y: 7, to: "entrance", px: 22, py: 7 }, { x: 23, y: 12, to: "garden", px: 1, py: 12 }],
|
|
walls: rects([[0, 0, 24, 1], [0, 15, 24, 1], [0, 0, 1, 6], [0, 9, 1, 7], [23, 0, 1, 11], [23, 14, 1, 2], [4, 3, 2, 10], [10, 2, 2, 11], [16, 3, 2, 5]])
|
|
},
|
|
garden: {
|
|
name: "Moon Garden",
|
|
floor: "#21362e",
|
|
exits: [{ x: 0, y: 12, to: "stacks", px: 22, py: 12 }],
|
|
walls: rects([[0, 0, 24, 1], [0, 15, 24, 1], [0, 0, 1, 11], [0, 14, 1, 2], [23, 0, 1, 16], [7, 4, 10, 1], [7, 10, 1, 4], [13, 10, 1, 4]])
|
|
}
|
|
};
|
|
let state = freshState();
|
|
let running = false;
|
|
|
|
function freshState() {
|
|
return {
|
|
room: "entrance",
|
|
player: { x: 3, y: 7, facing: "down" },
|
|
inventory: [],
|
|
flags: {},
|
|
route: "Undecided",
|
|
hearts: 3,
|
|
ending: null,
|
|
message: { speaker: "Archivist", line: "The archive waits. Find the lamp, help the shade, then decide what to do with the locked door." }
|
|
};
|
|
}
|
|
|
|
function rects(sources) {
|
|
const set = new Set();
|
|
sources.forEach(([x, y, w, h]) => {
|
|
for (let yy = y; yy < y + h; yy += 1) for (let xx = x; xx < x + w; xx += 1) set.add(`${xx},${yy}`);
|
|
});
|
|
return set;
|
|
}
|
|
|
|
function draw() {
|
|
const room = rooms[state.room];
|
|
ctx.fillStyle = "#14110e";
|
|
ctx.fillRect(0, 0, canvas.width, canvas.height);
|
|
for (let y = 0; y < 16; y += 1) {
|
|
for (let x = 0; x < 24; x += 1) {
|
|
ctx.fillStyle = room.walls.has(`${x},${y}`) ? "#181716" : room.floor;
|
|
ctx.fillRect(x * tile, y * tile, tile, tile);
|
|
ctx.strokeStyle = "rgba(255,255,255,0.035)";
|
|
ctx.strokeRect(x * tile, y * tile, tile, tile);
|
|
}
|
|
}
|
|
room.exits.forEach((exit) => drawGlyph(exit.x, exit.y, "#c48a41", "door"));
|
|
Object.entries(items).forEach(([id, item]) => {
|
|
if (item.room === state.room && !state.inventory.includes(id)) drawGlyph(item.x, item.y, item.color, "item");
|
|
});
|
|
Object.values(npcs).forEach((npc) => {
|
|
if (npc.room === state.room) drawGlyph(npc.x, npc.y, npc.color, npc.name === "Iron Door" ? "doorNpc" : "npc");
|
|
});
|
|
drawPlayer();
|
|
renderHud();
|
|
requestAnimationFrame(draw);
|
|
}
|
|
|
|
function drawGlyph(x, y, color, kind) {
|
|
const px = x * tile;
|
|
const py = y * tile;
|
|
ctx.fillStyle = color;
|
|
if (kind === "item") {
|
|
ctx.fillRect(px + 10, py + 10, 12, 12);
|
|
ctx.fillStyle = "rgba(255,255,255,0.45)";
|
|
ctx.fillRect(px + 13, py + 7, 6, 6);
|
|
} else if (kind === "door" || kind === "doorNpc") {
|
|
ctx.fillRect(px + 7, py + 4, 18, 25);
|
|
ctx.fillStyle = "#211812";
|
|
ctx.fillRect(px + 20, py + 16, 3, 3);
|
|
} else {
|
|
ctx.beginPath();
|
|
ctx.arc(px + 16, py + 12, 9, 0, Math.PI * 2);
|
|
ctx.fill();
|
|
ctx.fillRect(px + 8, py + 20, 16, 8);
|
|
}
|
|
}
|
|
|
|
function drawPlayer() {
|
|
const px = state.player.x * tile;
|
|
const py = state.player.y * tile;
|
|
ctx.fillStyle = "#f35f5f";
|
|
ctx.beginPath();
|
|
ctx.moveTo(px + 16, py + 7);
|
|
ctx.bezierCurveTo(px + 2, py + 2, px + 1, py + 22, px + 16, py + 28);
|
|
ctx.bezierCurveTo(px + 31, py + 22, px + 30, py + 2, px + 16, py + 7);
|
|
ctx.fill();
|
|
ctx.fillStyle = "#fff8e8";
|
|
ctx.fillRect(px + 11, py + 13, 4, 4);
|
|
ctx.fillRect(px + 18, py + 13, 4, 4);
|
|
}
|
|
|
|
function renderHud() {
|
|
els.speaker.textContent = state.message.speaker;
|
|
els.line.textContent = state.ending ? endingLine() : state.message.line;
|
|
els.room.textContent = rooms[state.room].name;
|
|
els.route.textContent = state.route;
|
|
els.hearts.textContent = String(state.hearts);
|
|
els.inventory.innerHTML = state.inventory.length
|
|
? state.inventory.map((id) => `<li>${items[id].label}</li>`).join("")
|
|
: "<li>Empty</li>";
|
|
const questRows = [
|
|
["Find a light", state.inventory.includes("lamp")],
|
|
["Return the loose page to the shade", state.flags.shadeHelped],
|
|
["Open, force, or leave the iron door", Boolean(state.ending)]
|
|
];
|
|
els.quests.innerHTML = questRows.map(([text, done]) => `<li class="${done ? "is-done" : ""}">${done ? "Done: " : ""}${text}</li>`).join("");
|
|
}
|
|
|
|
function move(dx, dy, facing) {
|
|
if (!running || state.ending) return;
|
|
state.player.facing = facing;
|
|
const nx = state.player.x + dx;
|
|
const ny = state.player.y + dy;
|
|
const room = rooms[state.room];
|
|
const exit = room.exits.find((candidate) => candidate.x === nx && candidate.y === ny);
|
|
if (exit) {
|
|
state.room = exit.to;
|
|
state.player.x = exit.px;
|
|
state.player.y = exit.py;
|
|
say("Narrator", `You enter ${rooms[state.room].name}.`);
|
|
autosave();
|
|
return;
|
|
}
|
|
if (nx < 0 || ny < 0 || nx > 23 || ny > 15 || room.walls.has(`${nx},${ny}`) || npcAt(nx, ny)) return;
|
|
state.player.x = nx;
|
|
state.player.y = ny;
|
|
const item = itemAt(nx, ny);
|
|
if (item) take(item);
|
|
}
|
|
|
|
function act() {
|
|
if (!running) return start();
|
|
if (state.ending) return;
|
|
const front = inFront();
|
|
const npc = npcAt(front.x, front.y);
|
|
if (npc) talk(npc);
|
|
else {
|
|
const here = itemAt(state.player.x, state.player.y);
|
|
if (here) take(here);
|
|
else say("Narrator", "Dust moves in the light. Nothing asks to be changed here.");
|
|
}
|
|
autosave();
|
|
}
|
|
|
|
function inFront() {
|
|
const delta = { up: [0, -1], down: [0, 1], left: [-1, 0], right: [1, 0] }[state.player.facing] || [0, 1];
|
|
return { x: state.player.x + delta[0], y: state.player.y + delta[1] };
|
|
}
|
|
|
|
function itemAt(x, y) {
|
|
return Object.keys(items).find((id) => {
|
|
const item = items[id];
|
|
return item.room === state.room && item.x === x && item.y === y && !state.inventory.includes(id);
|
|
});
|
|
}
|
|
|
|
function npcAt(x, y) {
|
|
return Object.keys(npcs).find((id) => {
|
|
const npc = npcs[id];
|
|
return npc.room === state.room && npc.x === x && npc.y === y;
|
|
});
|
|
}
|
|
|
|
function take(id) {
|
|
state.inventory.push(id);
|
|
if (id === "lamp") state.route = "Gentle";
|
|
if (id === "key" && !state.flags.shadeHelped) state.route = "Power";
|
|
say("Found", `${items[id].label} joined your inventory.`);
|
|
}
|
|
|
|
function talk(id) {
|
|
if (id === "archivist") {
|
|
if (!state.inventory.includes("lamp")) say("Archivist", "Take the lamp from the lower desk. The stacks dislike being crossed in the dark.");
|
|
else if (!state.flags.shadeHelped) say("Archivist", "A loose page has gone missing. The quiet reader in the stacks knows where it belongs.");
|
|
else say("Archivist", "You have been kind to a forgotten page. The garden door will remember that.");
|
|
}
|
|
if (id === "shade") {
|
|
if (!state.inventory.includes("page")) say("Shy Shade", "I lost the page with my name on it. It fell somewhere nearby.");
|
|
else {
|
|
state.flags.shadeHelped = true;
|
|
state.inventory = state.inventory.filter((item) => item !== "page");
|
|
state.route = "Mercy";
|
|
say("Shy Shade", "You returned my page instead of keeping it. Take the honest route through the garden.");
|
|
}
|
|
}
|
|
if (id === "gate") {
|
|
if (state.flags.shadeHelped) end("mercy");
|
|
else if (state.inventory.includes("key")) end("power");
|
|
else end("quiet");
|
|
}
|
|
}
|
|
|
|
function end(kind) {
|
|
state.ending = kind;
|
|
state.route = kind === "mercy" ? "Mercy" : kind === "power" ? "Power" : "Quiet";
|
|
say("Ending", endingLine());
|
|
save();
|
|
}
|
|
|
|
function endingLine() {
|
|
if (state.ending === "mercy") return "Mercy ending: the iron door opens without a sound, and every returned page remembers your name.";
|
|
if (state.ending === "power") return "Power ending: the key turns, but the archive grows colder around the missing page.";
|
|
if (state.ending === "quiet") return "Quiet ending: you leave the locked door alone. Some mysteries stay intact.";
|
|
return state.message.line;
|
|
}
|
|
|
|
function say(speaker, line) {
|
|
state.message = { speaker, line };
|
|
}
|
|
|
|
function start() {
|
|
running = true;
|
|
say("Archivist", "Walk the archive. Speak gently, or take what you need. The route will notice.");
|
|
els.status.textContent = "Started. Progress autosaves after room changes and actions.";
|
|
}
|
|
|
|
async function save() {
|
|
localStorage.setItem(fallbackKey, JSON.stringify(state));
|
|
try {
|
|
const response = await fetch(`/api/play/rpg/save/${saveSlot}`, {
|
|
method: "PUT",
|
|
headers: { "Content-Type": "application/json" },
|
|
body: JSON.stringify({ payload: state })
|
|
});
|
|
if (!response.ok) throw new Error(`Save failed: ${response.status}`);
|
|
els.status.textContent = "Saved to backend.";
|
|
} catch (_error) {
|
|
els.status.textContent = "Saved locally. Backend save API was not reachable.";
|
|
}
|
|
}
|
|
|
|
async function load() {
|
|
try {
|
|
const response = await fetch(`/api/play/rpg/save/${saveSlot}`);
|
|
if (response.ok) {
|
|
const data = await response.json();
|
|
state = normalizeState(data.payload);
|
|
running = true;
|
|
els.status.textContent = "Loaded from backend.";
|
|
return;
|
|
}
|
|
} catch (_error) {
|
|
/* Fall through to local save. */
|
|
}
|
|
const local = localStorage.getItem(fallbackKey);
|
|
if (local) {
|
|
state = normalizeState(JSON.parse(local));
|
|
running = true;
|
|
els.status.textContent = "Loaded local save.";
|
|
} else {
|
|
els.status.textContent = "No save found.";
|
|
}
|
|
}
|
|
|
|
function normalizeState(candidate) {
|
|
return Object.assign(freshState(), candidate || {}, {
|
|
player: Object.assign(freshState().player, (candidate && candidate.player) || {}),
|
|
inventory: Array.isArray(candidate && candidate.inventory) ? candidate.inventory.filter((id) => items[id]) : [],
|
|
flags: Object.assign({}, (candidate && candidate.flags) || {}),
|
|
message: Object.assign(freshState().message, (candidate && candidate.message) || {})
|
|
});
|
|
}
|
|
|
|
function autosave() {
|
|
save();
|
|
}
|
|
|
|
$("[data-rpg-start]", root).addEventListener("click", start);
|
|
$("[data-rpg-save]", root).addEventListener("click", save);
|
|
$("[data-rpg-load]", root).addEventListener("click", load);
|
|
$("[data-rpg-reset]", root).addEventListener("click", async () => {
|
|
state = freshState();
|
|
running = false;
|
|
localStorage.removeItem(fallbackKey);
|
|
try {
|
|
await fetch(`/api/play/rpg/save/${saveSlot}`, { method: "DELETE" });
|
|
els.status.textContent = "Reset and cleared backend save.";
|
|
} catch (_error) {
|
|
els.status.textContent = "Reset locally. Backend save API was not reachable.";
|
|
}
|
|
});
|
|
$("[data-rpg-act]", root).addEventListener("click", act);
|
|
$$("[data-rpg-move]", root).forEach((button) => {
|
|
const moves = { up: [0, -1, "up"], down: [0, 1, "down"], left: [-1, 0, "left"], right: [1, 0, "right"] };
|
|
button.addEventListener("click", () => move(...moves[button.dataset.rpgMove]));
|
|
});
|
|
window.addEventListener("keydown", (event) => {
|
|
if (!root.isConnected) return;
|
|
const tag = event.target.tagName;
|
|
if (tag === "INPUT" || tag === "TEXTAREA") return;
|
|
const keys = {
|
|
ArrowUp: [0, -1, "up"], w: [0, -1, "up"],
|
|
ArrowDown: [0, 1, "down"], s: [0, 1, "down"],
|
|
ArrowLeft: [-1, 0, "left"], a: [-1, 0, "left"],
|
|
ArrowRight: [1, 0, "right"], d: [1, 0, "right"]
|
|
};
|
|
if (keys[event.key]) {
|
|
event.preventDefault();
|
|
move(...keys[event.key]);
|
|
}
|
|
if (event.key === " " || event.key === "Enter") {
|
|
event.preventDefault();
|
|
act();
|
|
}
|
|
});
|
|
draw();
|
|
load();
|
|
}
|
|
|
|
const observatoryKey = "zxh_observatory_play_v1";
|
|
|
|
function readObservatoryState() {
|
|
try {
|
|
return JSON.parse(localStorage.getItem(observatoryKey) || "{}");
|
|
} catch (_error) {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
function writeObservatoryState(next) {
|
|
localStorage.setItem(observatoryKey, JSON.stringify(next));
|
|
}
|
|
|
|
async function loadObservatory() {
|
|
try {
|
|
const response = await fetch("/assets/content/hidden-details.json", { cache: "no-store" });
|
|
if (!response.ok) throw new Error("hidden details unavailable");
|
|
const data = await response.json();
|
|
return (data.entries || []).filter((entry) => entry.enabled !== false);
|
|
} catch (_error) {
|
|
return [];
|
|
}
|
|
}
|
|
|
|
function entryDepth(entry) {
|
|
const layer = Number(entry.familyLayer);
|
|
if (Number.isFinite(layer)) return Math.max(0, Math.min(5, layer));
|
|
if ((entry.characters || []).includes("future z")) return 4;
|
|
if ((entry.characters || []).includes("sensei chi")) return 3;
|
|
if ((entry.characters || []).includes("young z") || (entry.characters || []).includes("lima")) return 2;
|
|
return 1;
|
|
}
|
|
|
|
function characterLine(entry, fallback) {
|
|
const chars = entry.characters || [];
|
|
if (chars.includes("lima")) return "lima steadies this without making it smaller.";
|
|
if (chars.includes("aphy")) return "aphy logs the relationship, then softens the label.";
|
|
if (chars.includes("sensei chi")) return "sensei chi waits until the pattern stops trying to impress you.";
|
|
if (chars.includes("young z")) return "young z thinks this memory needs a door and a sun.";
|
|
if (chars.includes("future z")) return "future z has seen this thread from farther down the path.";
|
|
return fallback || "the observatory accepts the shape for now.";
|
|
}
|
|
|
|
function relationScore(a, b) {
|
|
const shared = (left, right) => left.filter((item) => right.includes(item)).length;
|
|
let score = 0;
|
|
score += shared(a.characters || [], b.characters || []) * 3;
|
|
score += shared(a.symbols || [], b.symbols || []) * 4;
|
|
score += shared(a.narrativeArcs || [], b.narrativeArcs || []) * 3;
|
|
score += a.emotionalTone && a.emotionalTone === b.emotionalTone ? 2 : 0;
|
|
score += Math.max(0, 3 - Math.abs(entryDepth(a) - entryDepth(b)));
|
|
["continuationLinks", "chainReferences", "echoes", "thematicLinks", "symbolicLinks", "triggerLinks", "parentLinks", "childLinks", "mirroredEntries"].forEach((key) => {
|
|
if ((a[key] || []).includes(b.id) || (b[key] || []).includes(a.id)) score += 5;
|
|
});
|
|
return score;
|
|
}
|
|
|
|
function importantEntries(entries, wantedCharacters) {
|
|
return entries
|
|
.filter((entry) => entry.title && entry.content)
|
|
.filter((entry) => !wantedCharacters || (entry.characters || []).some((name) => wantedCharacters.includes(name)))
|
|
.sort((a, b) => Number(b.resonanceScore || 0) - Number(a.resonanceScore || 0) || entryDepth(b) - entryDepth(a))
|
|
.slice(0, 18);
|
|
}
|
|
|
|
async function gentleConstellarium(root) {
|
|
const entries = importantEntries(await loadObservatory(), ["lima", "aphy", "sensei chi", "young z", "future z", "z"]);
|
|
const sky = $("[data-constellarium-sky]", root);
|
|
const status = $("[data-constellarium-status]", root);
|
|
const title = $("[data-constellarium-title]", root);
|
|
const reading = $("[data-constellarium-reading]", root);
|
|
const log = $("[data-constellarium-log]", root);
|
|
let state = readObservatoryState();
|
|
let selected = [];
|
|
let relation = "continuationLinks";
|
|
|
|
function saveThread(a, b) {
|
|
const score = relationScore(a, b);
|
|
const thread = {
|
|
id: `${a.id}:${b.id}:${relation}`,
|
|
source: a.id,
|
|
target: b.id,
|
|
relation,
|
|
score,
|
|
title: `${a.title} / ${b.title}`,
|
|
restoredAt: new Date().toISOString()
|
|
};
|
|
const restoredThreads = [...(state.restoredThreads || []).filter((item) => item.id !== thread.id), thread].slice(-24);
|
|
state = { ...state, restoredThreads, lastRestoredThread: thread, characterTrust: bumpTrust(state.characterTrust, [...(a.characters || []), ...(b.characters || [])]) };
|
|
if (score >= 8) state.crossGameFlags = { ...(state.crossGameFlags || {}), "thread:strong-restored": true };
|
|
writeObservatoryState(state);
|
|
status.textContent = score >= 8 ? "The thread holds. The sky remembers that shape." : "The thread is gentle but uncertain. Lima keeps it from falling.";
|
|
reading.textContent = score >= 8 ? characterLine(b, "two memories agree without needing to be identical.") : "aphy marks this as possible. sensei chi says possible is a real room.";
|
|
renderLog();
|
|
}
|
|
|
|
function render() {
|
|
if (!entries.length) {
|
|
sky.innerHTML = "<p class=\"play-live-note\">The observatory data is resting. Try again after the hidden details are available.</p>";
|
|
return;
|
|
}
|
|
sky.innerHTML = entries.map((entry, index) => {
|
|
const angle = (index / entries.length) * Math.PI * 2 - Math.PI / 2;
|
|
const radius = 34 + entryDepth(entry) * 8;
|
|
const active = selected.some((item) => item.id === entry.id);
|
|
return `<button type="button" class="observatory-star${active ? " is-active" : ""}" data-id="${escapeAttr(entry.id)}" style="--x:${50 + Math.cos(angle) * radius}%;--y:${50 + Math.sin(angle) * radius * 0.74}%;--size:${18 + Number(entry.resonanceScore || 3) * 2}px">
|
|
<span>${escapeHtml((entry.characters || ["z"])[0].slice(0, 1))}</span>
|
|
</button>`;
|
|
}).join("");
|
|
$$("[data-id]", sky).forEach((button) => {
|
|
button.addEventListener("click", () => choose(entries.find((entry) => entry.id === button.dataset.id)));
|
|
});
|
|
renderLog();
|
|
}
|
|
|
|
function choose(entry) {
|
|
if (!entry) return;
|
|
if (selected.length === 2) selected = [];
|
|
selected.push(entry);
|
|
title.textContent = entry.title;
|
|
reading.textContent = characterLine(entry);
|
|
if (selected.length === 2) saveThread(selected[0], selected[1]);
|
|
render();
|
|
}
|
|
|
|
function renderLog() {
|
|
const threads = state.restoredThreads || [];
|
|
log.innerHTML = threads.length
|
|
? threads.slice(-6).reverse().map((thread) => `<p><strong>${escapeHtml(thread.relation.replace("Links", ""))}</strong>: ${escapeHtml(thread.title)}</p>`).join("")
|
|
: "<p>No thread has been restored here yet.</p>";
|
|
}
|
|
|
|
$$("[data-constellarium-relation]", root).forEach((button) => {
|
|
button.addEventListener("click", () => {
|
|
relation = button.dataset.constellariumRelation;
|
|
status.textContent = `The next thread will be a ${relation.replace("Links", "").replace("Entries", "")}.`;
|
|
});
|
|
});
|
|
$("[data-constellarium-reset]", root).addEventListener("click", () => {
|
|
selected = [];
|
|
status.textContent = "The sky rests without forgetting.";
|
|
title.textContent = "Waiting for a first light";
|
|
reading.textContent = "lima keeps a hand near the thread, not pulling, just steadying.";
|
|
render();
|
|
});
|
|
render();
|
|
}
|
|
|
|
async function futureZReturnLog(root) {
|
|
const entries = importantEntries(await loadObservatory(), ["future z", "young z", "lima", "sensei chi"]).slice(0, 9);
|
|
const now = Date.now();
|
|
let state = readObservatoryState();
|
|
const visits = { ...(state.returnVisits || {}) };
|
|
const page = visits["future-z-return-log"] || { count: 0, firstSeenAt: now, lastSeenAt: 0 };
|
|
const gap = page.lastSeenAt ? now - page.lastSeenAt : 0;
|
|
visits["future-z-return-log"] = { ...page, count: page.count + 1, lastSeenAt: now };
|
|
state = { ...state, returnVisits: visits };
|
|
writeObservatoryState(state);
|
|
|
|
const stage = $("[data-return-stage]", root);
|
|
const heading = $("[data-return-heading]", root);
|
|
const message = $("[data-return-message]", root);
|
|
const context = $("[data-return-context]", root);
|
|
const status = $("[data-return-status]", root);
|
|
const list = $("[data-return-list]", root);
|
|
const restored = (state.restoredThreads || []).length;
|
|
const symbols = Object.keys(state.discoveredSymbols || {}).length;
|
|
const patient = Number(state.patientMoments || 0);
|
|
|
|
function render() {
|
|
const count = visits["future-z-return-log"].count;
|
|
const minutes = Math.floor(gap / 60000);
|
|
stage.textContent = count <= 1 ? "First opening" : count < 4 ? `${count} returns` : "familiar return";
|
|
heading.textContent = restored ? "future z found one of your restored threads." : count > 1 ? "The page recognizes your shape in time." : "The log is still warming up.";
|
|
message.textContent = restored
|
|
? "future z: I remember the thread you helped hold together. Some repairs become routes."
|
|
: count > 2
|
|
? "future z: returning is not the same as being stuck. Sometimes it is how care checks the lock."
|
|
: "future z has left the first note face down, so the ink does not smudge.";
|
|
context.textContent = minutes
|
|
? `Last gap: about ${minutes} minutes. ${symbols ? "One discovered symbol is travelling with you." : "No symbol has followed you here yet."}`
|
|
: patient ? "sensei chi notices the quiet you brought from another room." : "aphy has no elapsed-time anomaly to report yet.";
|
|
list.innerHTML = entries.map((entry, index) => {
|
|
const seen = visits[entry.id] || {};
|
|
return `<button type="button" class="return-memory" data-id="${escapeAttr(entry.id)}">
|
|
<strong>${escapeHtml(entry.title)}</strong>
|
|
<span>${seen.count ? `observed ${seen.count} time${seen.count === 1 ? "" : "s"}` : "not observed here yet"}</span>
|
|
</button>`;
|
|
}).join("");
|
|
$$("[data-id]", list).forEach((button) => button.addEventListener("click", () => observe(button.dataset.id)));
|
|
}
|
|
|
|
function observe(id) {
|
|
const entry = entries.find((item) => item.id === id);
|
|
if (!entry) return;
|
|
const seen = visits[id] || { count: 0, firstSeenAt: now };
|
|
visits[id] = { ...seen, count: seen.count + 1, lastSeenAt: Date.now() };
|
|
state = { ...readObservatoryState(), returnVisits: visits };
|
|
if ((entry.characters || []).includes("future z")) state.crossGameFlags = { ...(state.crossGameFlags || {}), "future-z:observed": true };
|
|
writeObservatoryState(state);
|
|
status.textContent = characterLine(entry, "future z folds the observation into the log.");
|
|
render();
|
|
}
|
|
|
|
$("[data-return-observe]", root).addEventListener("click", () => entries[0] && observe(entries[0].id));
|
|
$("[data-return-wait]", root).addEventListener("click", () => {
|
|
state = readObservatoryState();
|
|
state.patientMoments = Number(state.patientMoments || 0) + 1;
|
|
state.crossGameFlags = { ...(state.crossGameFlags || {}), "patience:return-log": true };
|
|
writeObservatoryState(state);
|
|
status.textContent = "sensei chi notices that you did not rush the page.";
|
|
render();
|
|
});
|
|
$("[data-return-reset]", root).addEventListener("click", () => {
|
|
state = readObservatoryState();
|
|
delete state.returnVisits;
|
|
writeObservatoryState(state);
|
|
status.textContent = "The local drift was cleared. Future z leaves the kindness, not the counter.";
|
|
});
|
|
render();
|
|
}
|
|
|
|
async function subconsciousIndex(root) {
|
|
const entries = await loadObservatory();
|
|
let state = readObservatoryState();
|
|
let selected = [];
|
|
const cloud = $("[data-symbol-cloud]", root);
|
|
const status = $("[data-subconscious-status]", root);
|
|
const sentence = $("[data-dream-sentence]", root);
|
|
const reading = $("[data-dream-reading]", root);
|
|
const routes = $("[data-subconscious-routes]", root);
|
|
const counts = new Map();
|
|
entries.forEach((entry) => (entry.symbols || []).forEach((symbol) => counts.set(symbol, (counts.get(symbol) || 0) + 1)));
|
|
[["ring", 1], ["tea", 1], ["crayon sun", 1], ["clock", 1], ["door", 1], ["mirror", 1], ["console", 1], ["kitchen light", 1]].forEach(([symbol, count]) => {
|
|
if (!counts.has(symbol)) counts.set(symbol, count);
|
|
});
|
|
const symbols = [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 16);
|
|
|
|
function render() {
|
|
cloud.innerHTML = symbols.map(([symbol, count]) => `<button type="button" class="symbol-chip${selected.includes(symbol) ? " is-active" : ""}" data-symbol="${escapeAttr(symbol)}">
|
|
<strong>${escapeHtml(symbol)}</strong><span>${count}</span>
|
|
</button>`).join("");
|
|
$$("[data-symbol]", cloud).forEach((button) => button.addEventListener("click", () => toggleSymbol(button.dataset.symbol)));
|
|
const known = state.discoveredSymbols || {};
|
|
routes.innerHTML = Object.keys(known).length
|
|
? Object.entries(known).slice(-8).map(([symbol, info]) => `<p><strong>${escapeHtml(symbol)}</strong>: ${escapeHtml(info.meaning)}</p>`).join("")
|
|
: "<p>No object has admitted its meaning yet.</p>";
|
|
}
|
|
|
|
function toggleSymbol(symbol) {
|
|
selected = selected.includes(symbol) ? selected.filter((item) => item !== symbol) : [...selected, symbol].slice(-3);
|
|
const phrase = dreamPhrase(selected);
|
|
sentence.textContent = phrase.title;
|
|
reading.textContent = phrase.reading;
|
|
if (selected.length >= 2) {
|
|
const discoveredSymbols = { ...(state.discoveredSymbols || {}) };
|
|
selected.forEach((item) => {
|
|
discoveredSymbols[item] = { meaning: phrase.meaning, discoveredAt: new Date().toISOString(), path: selected };
|
|
});
|
|
state = { ...state, discoveredSymbols, lastDreamPath: selected, crossGameFlags: { ...(state.crossGameFlags || {}), "symbol:dream-sentence": true } };
|
|
writeObservatoryState(state);
|
|
status.textContent = selected.length === 3 ? "The website answers in objects, then pretends it was only navigation." : "A symbolic route has begun to breathe.";
|
|
}
|
|
render();
|
|
}
|
|
|
|
$("[data-subconscious-clear]", root).addEventListener("click", () => {
|
|
selected = [];
|
|
sentence.textContent = "Nothing has combined yet.";
|
|
reading.textContent = "young z has drawn a door in the margin and refuses to explain why that helps.";
|
|
status.textContent = "The current dream closed without being lost.";
|
|
render();
|
|
});
|
|
render();
|
|
}
|
|
|
|
function dreamPhrase(symbols) {
|
|
const key = symbols.slice().sort().join("|");
|
|
const table = {
|
|
"clock|ring": ["A future kept warm", "future z recognizes the ring as a promise that learned to wait.", "promise and return"],
|
|
"crayon sun|door": ["Safety drawn before it was understood", "young z makes a door because a page can become a room.", "play and shelter"],
|
|
"console|tea": ["Logic learned to bow", "aphy accepts the cup from sensei chi and stops explaining for one line.", "systems softened by patience"],
|
|
"kitchen light|ring": ["Home on purpose", "lima turns the symbol back toward the ordinary room where it belongs.", "warmth and vow"],
|
|
"mirror|ring": ["The promise has a reflection", "the observatory shows the same memory from the side that was quiet.", "echo and vow"]
|
|
};
|
|
const picked = table[key] || (symbols.length
|
|
? [`${symbols.join(" / ")}`, "sensei chi says the meaning is not late. It is arriving by a slower path.", "private weather"]
|
|
: ["Nothing has combined yet.", "young z has drawn a door in the margin and refuses to explain why that helps.", "waiting"]);
|
|
return { title: picked[0], reading: picked[1], meaning: picked[2] };
|
|
}
|
|
|
|
function bumpTrust(current, characters) {
|
|
const next = { ...(current || {}) };
|
|
characters.forEach((name) => {
|
|
if (["lima", "aphy", "sensei chi", "young z", "future z"].includes(name)) next[name] = Number(next[name] || 0) + 1;
|
|
});
|
|
return next;
|
|
}
|
|
|
|
function escapeHtml(value) {
|
|
return String(value || "").replace(/[&<>"']/g, (char) => ({ "&": "&", "<": "<", ">": ">", "\"": """, "'": "'" })[char]);
|
|
}
|
|
|
|
function escapeAttr(value) {
|
|
return escapeHtml(value).replace(/`/g, "`");
|
|
}
|
|
|
|
function setupSortable(container, _render, after) {
|
|
let dragged = null;
|
|
container.addEventListener("dragstart", (event) => {
|
|
dragged = event.target.closest("[draggable='true']");
|
|
if (dragged) event.dataTransfer.effectAllowed = "move";
|
|
});
|
|
container.addEventListener("dragover", (event) => {
|
|
event.preventDefault();
|
|
const target = event.target.closest("[draggable='true']");
|
|
if (!dragged || !target || target === dragged) return;
|
|
const rect = target.getBoundingClientRect();
|
|
const before = event.clientY < rect.top + rect.height / 2 || event.clientX < rect.left + rect.width / 2;
|
|
container.insertBefore(dragged, before ? target : target.nextSibling);
|
|
after();
|
|
});
|
|
container.addEventListener("dragend", () => {
|
|
dragged = null;
|
|
after();
|
|
});
|
|
}
|
|
|
|
function pick(items) {
|
|
return items[Math.floor(Math.random() * items.length)];
|
|
}
|
|
})();
|