manzoloandClaude Opus 5.5
086e4682d4
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01GiECdCPptNRwbVzjzHbohi
546 lines
29 KiB
JavaScript
546 lines
29 KiB
JavaScript
// Il cuore dell'avventura, senza DOM: stato, comandi, coda delle azioni, dialoghi.
|
||
// La storia (scene, oggetti, dialoghi) arriva tutta dai dati: qui non c'è nessun enigma scritto a mano.
|
||
import { findPath, dist, inBox, boxDistance, nearestInside } from './geometry.js';
|
||
import * as bocce from './bocce.js';
|
||
import * as biliardo from './biliardo.js';
|
||
import * as rinquarto from './rinquarto.js';
|
||
import * as basket from './basket.js';
|
||
import * as pesca from './pesca.js';
|
||
import * as briscola from './briscola.js';
|
||
import * as tressette from './tressette.js';
|
||
import * as scopa from './scopa.js';
|
||
import * as gara from './gara.js';
|
||
|
||
// I minigiochi in primo piano: comandi opzionali per il tiro o per la scelta di una carta.
|
||
export const MINIGAMES = {
|
||
briscola: { create: (seed, level, deck) => briscola.newBriscola(seed, { level, deck }), update: briscola.update, play: briscola.play },
|
||
tressette: { create: (seed, level, deck) => tressette.newTressette(seed, { level, deck }), update: tressette.update, play: tressette.play },
|
||
scopa: { create: (seed, level, deck) => scopa.newScopa(seed, { level, deck }), update: scopa.update, play: scopa.play },
|
||
bocce: { create: (seed, level) => bocce.newBocce(seed, { level }), update: bocce.update, press: bocce.press, release: bocce.release, cancel: bocce.cancel, aim: bocce.aimScreen },
|
||
biliardo: { create: (seed, level) => biliardo.newBiliardo(seed, { level }), update: biliardo.update, press: biliardo.press, release: biliardo.release, cancel: biliardo.cancel, aim: biliardo.aimScreen },
|
||
rinquarto: { create: (seed, level) => rinquarto.newRinquarto(seed, { level }), update: rinquarto.update, press: rinquarto.press, release: rinquarto.release, cancel: rinquarto.cancel, aim: rinquarto.aimScreen },
|
||
basket: { create: (seed, level) => basket.newBasket(seed, { level }), update: basket.update, press: basket.press, release: basket.release, cancel: basket.cancel, aim: basket.aimScreen },
|
||
pesca: { create: (seed, level) => pesca.newPesca(seed, { level }), update: pesca.update, press: pesca.press, release: pesca.release, cancel: pesca.cancel, aim: pesca.aimScreen },
|
||
gara: { create: (seed, level, deck, def) => gara.newGara(seed, { level, riders: def.riders }), update: gara.update, press: gara.press, release: gara.release, cancel: gara.cancel, aim: gara.aimScreen },
|
||
};
|
||
|
||
export const VERBS = ['walk', 'look', 'take', 'use', 'talk', 'open', 'give', 'drop'];
|
||
export const VERB_LABELS = { walk: 'Vai a', look: 'Guarda', take: 'Prendi', use: 'Usa', talk: 'Parla con', open: 'Apri', give: 'Dai', drop: 'Butta' };
|
||
const DEFAULT_LINES = {
|
||
walk: null,
|
||
look: 'Niente di speciale.',
|
||
take: 'Non credo di poterlo prendere.',
|
||
use: 'Non so proprio come usarlo.',
|
||
talk: 'Non mi sembra un gran chiacchierone.',
|
||
open: 'Non si apre.',
|
||
give: 'Non credo che lo voglia.',
|
||
drop: 'Non è roba mia da buttare.',
|
||
with: 'Non funziona.',
|
||
};
|
||
const HAVE_IT = 'Ce l\'ho già.', DROPPED = 'Questo non mi serve: via.', KEEP_IT = 'Meglio tenerlo: potrebbe servirmi.';
|
||
// Le battute che il motore dice da sé (quando la storia non ne ha una): anche loro hanno la voce (make voci).
|
||
export const ENGINE_LINES = [...Object.values(DEFAULT_LINES).filter(Boolean), HAVE_IT, DROPPED, KEEP_IT];
|
||
const SPEED = 95;
|
||
// Solo profilo, come i cicli di camminata: 'up' e 'down' lasciano il verso com'è.
|
||
const FACING = { left: -1, right: 1 };
|
||
const WALK = ['walk_1', 'walk_2', 'walk_3', 'walk_4'], STEP = 15, REACH = 0.45;
|
||
// Il primo piano di un libro (story.closeups, effetto `closeup`): copertina → frontespizio → una pagina girata →
|
||
// l'ultima pagina, poi dopo una pausa il commento. Tempi in secondi.
|
||
export const PAGE_TURN = 0.7, CLOSEUP_PAUSE = 1.4;
|
||
|
||
// Condizioni: 'flag', '!flag', 'has:oggetto', '!has:oggetto', oppure un elenco (tutte vere).
|
||
export function check(cond, state) {
|
||
if (cond == null) return true;
|
||
if (Array.isArray(cond)) return cond.every(c => check(c, state));
|
||
const not = cond.startsWith('!'), key = not ? cond.slice(1) : cond;
|
||
const value = key.startsWith('has:') ? state.inventory.includes(key.slice(4)) : !!state.flags[key];
|
||
return not ? !value : value;
|
||
}
|
||
|
||
// Un oggetto è «piccolo» per il dito sotto i 24×24 pixel di scena: col tocco ha la precedenza sui vicini grandi.
|
||
const SMALL_AREA = 24 * 24;
|
||
|
||
// La miniatura di uno sfondo per la mappa (tools/miniature.py): assets/scenes/x.png -> assets/scenes/mini/x.png.
|
||
export const miniature = src => src?.replace(/([^/]+)$/, 'mini/$1') ?? null;
|
||
|
||
// Una riga dell'introduzione: un testo, oppure { rione: { id: testo } } con la riga del rione scelto.
|
||
export const introText = (line, rione) => typeof line === 'string' ? line : line.rione[rione] ?? Object.values(line.rione)[0];
|
||
|
||
// I crediti con i nomi di ogni voce in ordine casuale: nessuno viene sempre per primo.
|
||
export function shuffledCredits(credits, random = Math.random) {
|
||
return credits.map(({ role, names }) => {
|
||
const list = [...names];
|
||
for (let i = list.length - 1; i > 0; i--) {
|
||
const j = Math.floor(random() * (i + 1));
|
||
[list[i], list[j]] = [list[j], list[i]];
|
||
}
|
||
return { role, names: list };
|
||
});
|
||
}
|
||
|
||
// Le immagini del carosello dei Ringraziamenti: tutti gli sfondi del paese (uno per scena, senza doppioni) col nome
|
||
// del posto, e un ritratto dei crediti ogni quattro sfondi; i ritratti che non trovano posto chiudono la fila.
|
||
export function reelPictures(story) {
|
||
const seen = new Set(), scenes = [];
|
||
for (const s of Object.values(story.scenes)) {
|
||
if (!s.background || seen.has(s.background)) continue;
|
||
seen.add(s.background);
|
||
scenes.push({ src: s.background, name: s.name, kind: 'scene' });
|
||
}
|
||
const faces = (story.credits ?? []).flatMap(c => c.names).filter(n => n.face).map(facePicture);
|
||
let next = 0;
|
||
const placed = scenes.flatMap((p, i) => i % 4 === 3 && next < faces.length ? [p, faces[next++]] : [p]);
|
||
return [...placed, ...faces.slice(next)];
|
||
}
|
||
export const facePicture = n => ({ src: n.face, name: n.name, kind: n.face.endsWith('palio.png') ? 'palio' : 'face' });
|
||
|
||
// La ricerca della mappa: ogni parola scritta deve stare nel nome del posto, senza badare a maiuscole, accenti e
|
||
// apostrofi («camp» trova Campomigliaio, «de medici» trova Via de' Medici).
|
||
const plain = text => text.toLowerCase().normalize('NFD').replace(/[\u0300-\u036f]/g, '').replace(/[^a-z0-9]+/g, ' ').trim();
|
||
export function matchPlace(name, query) {
|
||
const words = plain(query).split(' ').filter(Boolean), hay = plain(name);
|
||
return words.every(w => hay.includes(w));
|
||
}
|
||
|
||
export const sayTime = text => Math.max(1.6, 0.9 + text.length * 0.055);
|
||
|
||
export function newState(story) {
|
||
const { scene, at } = story.start;
|
||
return { scene, x: at[0], y: at[1], facing: 1, inventory: [], flags: {}, used: {}, ended: false };
|
||
}
|
||
|
||
// Un salvataggio portato da fuori (Carica) deve tornare in tutto con la storia attuale, prima di prendere il posto di
|
||
// quello del browser: a differenza di restoreState non si aggiusta niente. Restituisce cosa non va, o null.
|
||
export function checkSave(story, data) {
|
||
if (!data || typeof data !== 'object') return 'non è una partita';
|
||
if (!Object.hasOwn(story.scenes, data.scene)) return `scena sconosciuta: ${data.scene}`;
|
||
if (!Number.isFinite(data.x) || !Number.isFinite(data.y)) return 'posizione mancante';
|
||
if (data.facing !== 1 && data.facing !== -1) return 'verso sbagliato';
|
||
if (!Array.isArray(data.inventory) || data.inventory.some(i => typeof i !== 'string' || !Object.hasOwn(story.items, i))) return 'oggetti sconosciuti';
|
||
for (const key of ['flags', 'used'])
|
||
if (!data[key] || typeof data[key] !== 'object' || Array.isArray(data[key]) || Object.values(data[key]).some(v => v !== true)) return `${key} non validi`;
|
||
if (typeof data.ended !== 'boolean') return 'fine non valida';
|
||
return null;
|
||
}
|
||
|
||
// Ripristina un salvataggio scartando tutto quello che la storia attuale non conosce più.
|
||
export function restoreState(story, data) {
|
||
const fresh = newState(story);
|
||
if (!data || typeof data !== 'object' || !story.scenes[data.scene]) return fresh;
|
||
const scene = story.scenes[data.scene];
|
||
const [x, y] = Number.isFinite(data.x) && Number.isFinite(data.y) ? nearestInside(scene.walk, [data.x, data.y]) : scene.entry ?? story.start.at;
|
||
const inventory = Array.isArray(data.inventory) ? [...new Set(data.inventory.filter(i => story.items[i]))] : [];
|
||
const pick = obj => Object.fromEntries(Object.entries(obj && typeof obj === 'object' ? obj : {}).filter(([, v]) => v === true));
|
||
return { scene: data.scene, x, y, facing: data.facing === -1 ? -1 : 1, inventory, flags: pick(data.flags), used: pick(data.used), ended: data.ended === true };
|
||
}
|
||
|
||
export class Game {
|
||
// voiceTime(who, text): secondi della voce registrata per la battuta, se c'è (il fumetto non finisce prima).
|
||
constructor(story, { state, onSave, voiceTime } = {}) {
|
||
this.story = story;
|
||
this.voiceTime = voiceTime ?? (() => undefined);
|
||
this.state = state ? restoreState(story, state) : newState(story);
|
||
this.onSave = onSave ?? (() => {});
|
||
// Ultimo stato coerente: preso solo a sequenza finita, è quello che si salva e da cui si riprende.
|
||
// Uscire a metà di una sequenza (una risposta, la porta che si apre) riporta qui, mai a un enigma risolto a metà.
|
||
this.checkpoint = state ? this.snapshot() : null;
|
||
this.dirty = false;
|
||
this.queue = [];
|
||
this.task = null;
|
||
this.path = [];
|
||
this.speech = null;
|
||
this.dialogue = null;
|
||
this.walking = false;
|
||
this.time = 0;
|
||
this.stride = 0; // strada fatta, per scegliere il passo della camminata
|
||
this.hurry = false; // doppio clic: si cammina al doppio della velocità
|
||
this.reach = 0; // secondi di braccio teso quando prende qualcosa
|
||
this.back = false; // di spalle davanti a una porta o a una bacheca
|
||
this.closeup = null; // il primo piano aperto: { id, step: 'cover' | 'title' | 'turn' | 'end', t, age }
|
||
}
|
||
|
||
get scene() { return this.story.scenes[this.state.scene]; }
|
||
// Occupato: c'è qualcosa in corso che il giocatore non può interrompere. La camminata verso un punto
|
||
// o verso un oggetto si può sempre cambiare con un altro clic: la coda che la seguiva viene scartata.
|
||
get busy() { return !!this.speech || !!this.closeup || this.reach > 0 || (this.task ? !this.task.interruptible : this.queue.length > 0); }
|
||
get idle() { return !this.busy && !this.task && !this.dialogue; }
|
||
// Fermo: nessuna battuta, nessun effetto in coda, nessuna camminata che fa parte di una sequenza.
|
||
get steady() { return !this.speech && !this.closeup && this.reach <= 0 && !this.queue.length && !(this.task && !this.task.interruptible); }
|
||
// Lo stato da salvare adesso: quello attuale se è fermo, altrimenti l'ultimo punto fermo.
|
||
savable() { return this.steady ? this.snapshot() : this.checkpoint; }
|
||
// A sequenza finita, se qualcosa è cambiato, nuovo punto fermo e salvataggio.
|
||
commit() {
|
||
if (!this.dirty || !this.steady) return false;
|
||
this.dirty = false;
|
||
this.checkpoint = this.snapshot();
|
||
this.onSave(this.checkpoint);
|
||
return true;
|
||
}
|
||
|
||
snapshot() {
|
||
const { scene, x, y, facing, inventory, flags, used, ended } = this.state;
|
||
return { scene, x: Math.round(x), y: Math.round(y), facing, inventory: [...inventory], flags: { ...flags }, used: { ...used }, ended };
|
||
}
|
||
|
||
hotspots() { return (this.scene.hotspots ?? []).filter(h => check(h.when, this.state)); }
|
||
hotspot(id) { return this.hotspots().find(h => h.id === id); }
|
||
people() { return (this.scene.people ?? []).filter(p => check(p.when, this.state)); }
|
||
// Col mouse vale il punto preciso (l'ultimo della lista sta sopra). Col dito, `reach` allarga l'area: prima gli
|
||
// oggetti piccoli (la squama sotto la panchina) entro quella distanza, anche se il dito cade sull'oggetto grande
|
||
// che li contiene; poi il punto preciso; poi l'oggetto più vicino entro `reach`.
|
||
hotspotAt(p, reach = 0) {
|
||
const list = this.hotspots();
|
||
const nearest = keep => {
|
||
let best = null, bestD = Infinity;
|
||
for (let i = list.length - 1; i >= 0; i--) {
|
||
const d = keep(list[i]) ? boxDistance(list[i].box, p) : Infinity;
|
||
if (d <= reach && d < bestD) { best = list[i]; bestD = d; }
|
||
}
|
||
return best;
|
||
};
|
||
if (reach > 0) {
|
||
const small = nearest(h => h.box[2] * h.box[3] <= SMALL_AREA);
|
||
if (small) return small;
|
||
}
|
||
for (let i = list.length - 1; i >= 0; i--) if (inBox(list[i].box, p)) return list[i];
|
||
return reach > 0 ? nearest(() => true) : null;
|
||
}
|
||
itemName(id) { return this.story.items[id]?.name ?? id; }
|
||
targetName(id) { return this.story.items[id] ? this.itemName(id) : this.hotspot(id)?.name ?? id; }
|
||
defaultVerb(target) {
|
||
if (this.story.items[target]) return 'look';
|
||
const h = this.hotspot(target);
|
||
return h?.default ?? (h?.exit ? 'walk' : 'look');
|
||
}
|
||
|
||
// Quale elenco di effetti produce "verbo + bersaglio (+ oggetto)": il punto unico della logica d'avventura.
|
||
resolve(verb, target, item = null) {
|
||
const items = this.story.items, h = items[target] ? null : this.hotspot(target);
|
||
const def = h ?? items[target];
|
||
if (!def) return [];
|
||
if (item) {
|
||
const table = verb === 'give' ? 'give' : 'with';
|
||
const found = def[table]?.[item] ?? items[item]?.with?.[target];
|
||
if (found) return found;
|
||
return [{ say: verb === 'give' ? DEFAULT_LINES.give : DEFAULT_LINES.with }];
|
||
}
|
||
if (def.actions?.[verb]) return def.actions[verb];
|
||
if (verb === 'walk') return h?.exit ? [{ go: h.exit.scene, at: h.exit.at, face: h.exit.face }] : [];
|
||
if (verb === 'take' && !h) return [{ say: HAVE_IT }];
|
||
// Si butta solo quello che non serve alla storia (`droppable`): gli oggetti indispensabili restano.
|
||
if (verb === 'drop' && !h) return def.droppable ? [{ say: DROPPED }, { drop: target }] : [{ say: KEEP_IT }];
|
||
return DEFAULT_LINES[verb] ? [{ say: DEFAULT_LINES[verb] }] : [];
|
||
}
|
||
|
||
// Comandi dal giocatore. Restituiscono false se in quel momento vanno ignorati.
|
||
walkTo(p) {
|
||
if (this.busy || this.dialogue || this.state.ended) return false;
|
||
this.queue = [];
|
||
this.task = { walk: p, interruptible: true };
|
||
this.startWalk(p);
|
||
return true;
|
||
}
|
||
|
||
act(verb, target, item = null) {
|
||
if (this.busy || this.dialogue || this.state.ended) return false;
|
||
const effects = this.resolve(verb, target, item);
|
||
const h = this.story.items[target] ? null : this.hotspot(target);
|
||
const steps = [];
|
||
if (h) {
|
||
const at = h.at ?? [h.box[0] + h.box[2] / 2, h.box[1] + h.box[3]];
|
||
steps.push({ walk: at, interruptible: true });
|
||
if (h.face) steps.push({ face: h.face });
|
||
}
|
||
this.task = null;
|
||
this.path = [];
|
||
this.walking = false;
|
||
this.queue = [...steps, ...effects];
|
||
return true;
|
||
}
|
||
|
||
skip() {
|
||
if (this.speech) { this.speech = null; return true; }
|
||
return false;
|
||
}
|
||
|
||
// Il primo piano: un tocco sfoglia (copertina → frontespizio → si gira la pagina); all'ultima pagina non fa niente.
|
||
closeupTap() {
|
||
const c = this.closeup;
|
||
if (!c || this.speech) return false;
|
||
if (this.story.closeups[c.id].type) return false; // torcia e minigiochi non si sfogliano
|
||
if (c.step === 'cover') Object.assign(c, { step: 'title', t: 0 });
|
||
else if (c.step === 'title') Object.assign(c, { step: 'turn', t: 0 });
|
||
else return false;
|
||
return true;
|
||
}
|
||
|
||
// Chiuso il libro si torna alla scena, e gli effetti che seguivano il primo piano ripartono.
|
||
outcome(def, c) { return def[c.result.winner === 'player' ? 'win' : c.result.winner === 'cpu' ? 'lose' : 'draw'] ?? []; }
|
||
// Appena il risultato di un minigioco è deciso, i suoi flag (vittoria, partita giocata) valgono e si salvano:
|
||
// anche tornando al titolo dalla schermata del risultato, senza passare dall'uscita. Una volta sola.
|
||
settle(c) {
|
||
const def = this.story.closeups?.[c.id];
|
||
if (!c.result || c.settled || !def) return false;
|
||
c.settled = true;
|
||
for (const e of this.outcome(def, c)) {
|
||
if (e.set) { this.state.flags[e.set] = true; if (this.checkpoint) this.checkpoint.flags[e.set] = true; }
|
||
if (e.unset) { delete this.state.flags[e.unset]; if (this.checkpoint) delete this.checkpoint.flags[e.unset]; }
|
||
}
|
||
if (this.checkpoint) this.onSave(this.checkpoint);
|
||
return true;
|
||
}
|
||
closeupClose() {
|
||
const c = this.closeup;
|
||
if (!c) return false;
|
||
this.closeup = null;
|
||
this.speech = null;
|
||
const def = this.story.closeups?.[c.id];
|
||
if (def?.type === 'torch') {
|
||
if (c.step === 'done') this.queue.unshift(...def.complete);
|
||
return true;
|
||
}
|
||
// I minigiochi: a partita finita (risultato deciso, anche se il conteggio si sta ancora mostrando) la battuta
|
||
// di chi ha vinto; uscendo prima, quella di chi lascia.
|
||
if (MINIGAMES[def?.type]) {
|
||
this.settle(c);
|
||
this.queue.unshift(...(c.result ? this.outcome(def, c) : def.quit ?? []));
|
||
return true;
|
||
}
|
||
// Chi è arrivato all'ultima pagina, chiudendo, la commenta (`closing`).
|
||
if (c.step === 'end') this.queue.unshift(...(this.story.closeups?.[c.id]?.closing ?? []));
|
||
return true;
|
||
}
|
||
|
||
// Bocce e biliardo: si tiene premuto per caricare la forza e si lascia per tirare (mouse, dito o spazio).
|
||
minigame() { const c = this.closeup; return c ? MINIGAMES[this.story.closeups[c.id].type] ?? null : null; }
|
||
closeupPress(pointerId) { const m = this.minigame(); return !!m && !this.speech && !!m.press?.(this.closeup, pointerId); }
|
||
closeupRelease(pointerId) { return !!this.minigame()?.release?.(this.closeup, pointerId); }
|
||
closeupCancel(pointerId) { return !!this.minigame()?.cancel?.(this.closeup, pointerId); }
|
||
closeupPlay(index) { return !this.speech && !!this.minigame()?.play?.(this.closeup, index); }
|
||
|
||
// Solo luce, nessun clic sugli oggetti dietro al primo piano. Il progresso è transitorio:
|
||
// uscire o ricaricare durante la ricerca permette di ripeterla, senza anticipare il finale.
|
||
closeupAim([x, y]) {
|
||
const c = this.closeup;
|
||
const m = this.minigame();
|
||
if (m) return !!m.aim?.(c, [x, y]);
|
||
if (!c || this.story.closeups[c.id].type !== 'torch' || !Number.isFinite(x) || !Number.isFinite(y)) return false;
|
||
c.beam = [Math.max(70, Math.min(570, x)), Math.max(65, Math.min(295, y))];
|
||
return true;
|
||
}
|
||
|
||
updateTorch(dt) {
|
||
const c = this.closeup, def = this.story.closeups[c.id];
|
||
c.t += dt;
|
||
if (c.lines?.length) { this.run(c.lines.shift()); return; }
|
||
if (c.step === 'reveal') {
|
||
if (c.t < 1.4) return;
|
||
c.found++;
|
||
c.step = c.found === def.targets.length ? 'done' : 'search';
|
||
c.t = c.dwell = 0;
|
||
return;
|
||
}
|
||
const target = def.targets[c.found];
|
||
if (c.step !== 'search' || !target) return;
|
||
c.dwell = Math.hypot(c.beam[0] - target.at[0], c.beam[1] - target.at[1]) < target.radius ? c.dwell + dt : 0;
|
||
if (c.dwell >= 0.45) {
|
||
c.step = 'reveal';
|
||
c.t = 0;
|
||
c.lines = [...(target.lines ?? [])];
|
||
}
|
||
}
|
||
|
||
options() {
|
||
if (!this.dialogue || this.busy) return [];
|
||
const node = this.story.dialogues[this.dialogue.id].nodes[this.dialogue.node];
|
||
return node.options.filter(o => check(o.when, this.state) && !(o.once && this.state.used[o.id]));
|
||
}
|
||
|
||
choose(index) {
|
||
const option = this.options()[index];
|
||
if (!option) return false;
|
||
if (option.once) { this.state.used[option.id] = true; this.dirty = true; }
|
||
const next = option.next ?? this.dialogue.node;
|
||
this.queue.push({ say: option.say ?? option.text, who: 'andrea' }, ...(option.then ?? []), next === 'end' ? { endDialogue: true } : { node: next });
|
||
return true;
|
||
}
|
||
|
||
startWalk(p) {
|
||
this.path = findPath(this.scene.walk, [this.state.x, this.state.y], p);
|
||
this.walking = this.path.length > 0;
|
||
this.back = false;
|
||
}
|
||
|
||
// Il fotogramma di Andrea in questo istante: un passo ogni STEP pixel percorsi (a grandezza piena).
|
||
pose() {
|
||
if (this.reach > 0) return 'take';
|
||
if (this.walking) return WALK[Math.floor(this.stride / STEP) % WALK.length];
|
||
if (this.speech?.who === 'andrea') return Math.floor(this.time / 0.2) % 2 ? 'talk' : 'stand';
|
||
return this.back ? 'back' : 'stand';
|
||
}
|
||
|
||
// Il fotogramma di un personaggio della scena (scene.people): quando parla alterna `talk`, o tiene la posa
|
||
// chiesta dalla battuta ({ say, who, pose }); da fermo ogni `every` secondi fa `blink` per un attimo.
|
||
personPose(p) {
|
||
const idle = p.idle ?? 'sit';
|
||
if (this.speech?.who === p.who) {
|
||
if (this.speech.pose) return this.speech.pose;
|
||
const talk = p.talk ?? ['talk'];
|
||
return talk[Math.floor(this.time / 0.3) % talk.length];
|
||
}
|
||
const every = p.every ?? 4, t = (this.time + (p.offset ?? 0)) % every;
|
||
return p.blink && t > every - 0.25 ? p.blink : idle;
|
||
}
|
||
|
||
scaleAt(y) {
|
||
const d = this.scene.depth;
|
||
if (!d) return 1;
|
||
const [[y0, s0], [y1, s1]] = d, t = Math.max(0, Math.min(1, (y - y0) / (y1 - y0)));
|
||
return s0 + (s1 - s0) * t;
|
||
}
|
||
|
||
speakerPoint(who) {
|
||
// Nel primo piano Andrea parla da sopra il libro, non dalla scena oscurata dietro.
|
||
if (this.closeup && (!who || who === 'andrea')) return [320, 34];
|
||
if (!who || who === 'andrea') return [this.state.x, this.state.y - 62 * this.scaleAt(this.state.y)];
|
||
if (this.scene.speakers?.[who]) return this.scene.speakers[who];
|
||
const h = this.hotspot(who) ?? (this.scene.hotspots ?? []).find(x => x.id === who);
|
||
if (!h) return [this.state.x, this.state.y - 62];
|
||
return h.talkAt ?? [h.box[0] + h.box[2] / 2, h.box[1] - 4];
|
||
}
|
||
|
||
update(dt) {
|
||
this.time += dt;
|
||
if (this.closeup) this.closeup.age += dt;
|
||
if (this.speech) {
|
||
this.speech.left -= dt;
|
||
if (this.speech.left > 0) return;
|
||
this.speech = null;
|
||
}
|
||
if (this.reach > 0) {
|
||
this.reach -= dt;
|
||
if (this.reach > 0) return;
|
||
}
|
||
if (this.walking) {
|
||
const scale = this.scaleAt(this.state.y);
|
||
let step = SPEED * (this.hurry ? 2 : 1) * scale * dt;
|
||
this.stride += step / scale;
|
||
while (step > 0 && this.path.length) {
|
||
const target = this.path[0], d = dist([this.state.x, this.state.y], target);
|
||
if (Math.abs(target[0] - this.state.x) > 0.5) this.state.facing = target[0] > this.state.x ? 1 : -1;
|
||
if (d <= step) {
|
||
[this.state.x, this.state.y] = target;
|
||
this.path.shift();
|
||
step -= d;
|
||
} else {
|
||
this.state.x += (target[0] - this.state.x) / d * step;
|
||
this.state.y += (target[1] - this.state.y) / d * step;
|
||
step = 0;
|
||
}
|
||
}
|
||
if (this.path.length) return;
|
||
this.walking = false;
|
||
this.task = null;
|
||
}
|
||
// Nel primo piano il tempo scorre solo per la pagina che gira e per la pausa prima del commento.
|
||
const c = this.closeup;
|
||
if (c) {
|
||
if (this.story.closeups[c.id].type === 'torch') { this.updateTorch(dt); return; }
|
||
const m = this.minigame();
|
||
if (m) {
|
||
m.update(c, dt);
|
||
this.settle(c);
|
||
// Il risultato resta leggibile finché il giocatore non esce.
|
||
return;
|
||
}
|
||
c.t += dt;
|
||
if (c.step === 'turn' && c.t >= PAGE_TURN) Object.assign(c, { step: 'end', t: 0 });
|
||
if (c.step === 'end' && !c.lines && c.t >= CLOSEUP_PAUSE) c.lines = [...(this.story.closeups?.[c.id]?.comment ?? [])];
|
||
if (c.lines?.length) this.run(c.lines.shift());
|
||
return;
|
||
}
|
||
// Esegue gli effetti istantanei di fila e si ferma al primo che richiede tempo.
|
||
while (!this.speech && !this.walking && !this.closeup && this.queue.length) this.run(this.queue.shift());
|
||
this.commit();
|
||
}
|
||
|
||
run(e) {
|
||
const s = this.state;
|
||
this.dirty = true;
|
||
if (e.say != null) {
|
||
const who = e.who ?? 'andrea', voice = this.voiceTime(who, e.say);
|
||
this.speech = { text: e.say, who, pose: e.pose, left: Math.max(sayTime(e.say), voice ? voice + 0.35 : 0) };
|
||
}
|
||
else if (e.walk) { this.task = e; this.startWalk(e.walk); }
|
||
// `go` prima di `face`: un cambio scena porta con sé il verso d'arrivo.
|
||
else if (e.go) this.go(e.go, e.at, e.face);
|
||
else if (e.face) { s.facing = FACING[e.face] ?? s.facing; this.back = e.face === 'up'; }
|
||
else if (e.give) { if (!s.inventory.includes(e.give)) s.inventory.push(e.give); this.reach = REACH; this.back = false; }
|
||
else if (e.drop) s.inventory = s.inventory.filter(i => i !== e.drop);
|
||
else if (e.set) s.flags[e.set] = true;
|
||
else if (e.unset) delete s.flags[e.unset];
|
||
else if (e.if !== undefined) this.queue.unshift(...(check(e.if, s) ? e.then ?? [] : e.else ?? []));
|
||
else if (e.dialogue) this.dialogue = { id: e.dialogue, node: 'start' };
|
||
else if (e.node) this.dialogue.node = e.node;
|
||
else if (e.endDialogue) this.dialogue = null;
|
||
else if (e.end) s.ended = true;
|
||
else if (e.closeup) {
|
||
const type = this.story.closeups[e.closeup].type;
|
||
this.closeup = type === 'torch' ? { id: e.closeup, step: 'search', t: 0, age: 0, found: 0, dwell: 0, beam: [320, 180] }
|
||
// `level`: «Alla bona», «Seria» o «A fassi male», scelto nel dialogo con l'avversario.
|
||
// `decks`: il mazzo da usare quando il suo flag è acceso (briscola: le napoletane al posto delle toscane).
|
||
: MINIGAMES[type] ? { id: e.closeup, ...MINIGAMES[type].create(Math.floor(Math.random() * 4294967296), e.level,
|
||
Object.keys(this.story.closeups[e.closeup].decks ?? {}).find(d => s.flags[this.story.closeups[e.closeup].decks[d]]), this.story.closeups[e.closeup]) }
|
||
: { id: e.closeup, step: 'cover', t: 0, age: 0 };
|
||
}
|
||
else throw new Error('Effetto sconosciuto: ' + JSON.stringify(e));
|
||
}
|
||
|
||
// La mappa: i posti già visti, con la posizione sulla pianta, e le strade che li collegano (uscite fra due posti visti).
|
||
// La fase del giorno: l'ultima di story.phases la cui condizione è vera (la prima non ne ha: è quella di partenza).
|
||
// Segue la storia, non l'orologio: il pomeriggio diventa tramonto con le impronte, e sera con la torcia.
|
||
phase() {
|
||
const phases = this.story.phases ?? [];
|
||
return [...phases].reverse().find(p => check(p.when, this.state)) ?? phases[0] ?? null;
|
||
}
|
||
// Il taccuino: le tappe fatte e quella di adesso (la prima non fatta).
|
||
notebook() {
|
||
const steps = this.story.notebook ?? [], at = steps.findIndex(s => !check(s.done, this.state));
|
||
return { done: (at < 0 ? steps : steps.slice(0, at)).map(s => s.text), now: at < 0 ? null : steps[at].text };
|
||
}
|
||
mapPlaces() {
|
||
return Object.entries(this.story.scenes)
|
||
.filter(([id, sc]) => sc.map && this.state.flags['visto:' + id])
|
||
.map(([id, sc]) => ({ id, name: sc.name, at: sc.map, here: id === this.state.scene, mini: miniature(sc.background) }));
|
||
}
|
||
mapRoads() {
|
||
const seen = new Set(this.mapPlaces().map(p => p.id)), roads = new Map();
|
||
for (const id of seen)
|
||
for (const h of this.story.scenes[id].hotspots ?? [])
|
||
if (h.exit && seen.has(h.exit.scene) && h.exit.scene !== id) roads.set([id, h.exit.scene].sort().join('|'), [id, h.exit.scene].sort());
|
||
return [...roads.values()];
|
||
}
|
||
// Viaggio dalla mappa: solo verso un posto già visto, e non mentre si parla, si cammina o si sceglie in un dialogo.
|
||
travel(scene) {
|
||
const sc = this.story.scenes[scene];
|
||
if (!sc?.map || !this.state.flags['visto:' + scene] || scene === this.state.scene) return false;
|
||
if (this.busy || this.walking || this.dialogue || this.state.ended) return false;
|
||
this.go(scene, sc.entry);
|
||
return true;
|
||
}
|
||
|
||
go(scene, at, face) {
|
||
if (!this.story.scenes[scene]) throw new Error('Scena sconosciuta: ' + scene);
|
||
this.state.scene = scene;
|
||
this.enteredAt = this.time; // per gli effetti che cominciano all'ingresso (le finestre che si accendono)
|
||
[this.state.x, this.state.y] = at ?? this.scene.entry;
|
||
this.state.facing = FACING[face] ?? this.state.facing;
|
||
this.path = [];
|
||
this.walking = false;
|
||
this.back = false;
|
||
this.state.flags['visto:' + scene] = true; // per la mappa
|
||
this.queue.unshift(...(this.scene.enter ?? []));
|
||
this.dirty = true; // si salva quando l'ingresso nella scena è finito
|
||
}
|
||
}
|