manzolo/leggenda-del-regolo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

La pista col gesso: le macchinine sul parcheggio di Cardetole contro il Chiaru (consenso del 29 ottobre, sprite di Codex dalla foto), un giro a spinte con le penalità alla francese (fuori, tagliè, cappottè, accompagnè: si torna dov'eri); Bertovo diventa Trappizzio Berti; Fabrizio Berti e il suo libro nei Ringraziamenti (Andrea)

Browse Source 
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GiECd9KMfjthRUnujCGSzZ
This commit is contained in:
manzolo
2026-10-29 08:47:03 +01:00
co-authored by Claude Opus 5.5
parent 1918c8d9c7
commit 08ab9ba069
57 changed files with 1082 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/micro.browser.mjs
+88
View File
@@ -0,0 +1,88 @@
// La pista col gesso nel browser vero, su desktop e touch: la scena di Cardetole col Chiaru, la mira, la spinta
// tenendo premuto e i comandi del pannello. npm run browser:micro — schermate in /tmp/regolo-micro.
import { chromium } from 'playwright';
import { mkdirSync } from 'node:fs';
import assert from 'node:assert/strict';
import { staticServer } from './helpers.mjs';
const out = process.env.OUT ?? '/tmp/regolo-micro';
mkdirSync(out, { recursive: true });
const server = await staticServer();
let browser;
const errors = [];
try {
browser = await chromium.launch({ args: ['--autoplay-policy=no-user-gesture-required', '--use-gl=angle', '--use-angle=swiftshader', '--enable-unsafe-swiftshader'] });
for (const [name, mobile, viewport] of [
['desktop', false, { width: 1280, height: 860 }],
['touch', true, { width: 844, height: 390 }],
['portrait', true, { width: 390, height: 844 }],
]) {
const page = await browser.newPage({ viewport, hasTouch: mobile, isMobile: mobile });
page.on('pageerror', e => errors.push(e.message));
await page.goto(`http://127.0.0.1:${server.port}/`);
await page.click('#splash');
await page.click('#new-game');
await page.click('#rione [data-rione="campomigliaio"]');
await page.click('#skip-intro');
await page.evaluate(async () => {
const { settle } = await import('/tests/helpers.mjs');
settle(game); game.go('cardetole'); settle(game);
});
await page.waitForTimeout(1200);
if (name === 'desktop') await page.screenshot({ path: `${out}/${name}-cardetole.png` });
await page.evaluate(async () => {
const { settle } = await import('/tests/helpers.mjs');
game.act('talk', 'chiaru'); settle(game);
game.choose(game.options().findIndex(o => o.text === 'Si corre?')); settle(game);
game.choose(game.options().findIndex(o => o.text === 'Alla bona.')); settle(game);
});
await page.waitForSelector('#bocce-controls:not([hidden])');
await page.waitForFunction(async () => {
const { hasBackground } = await import('/src/engine/render.js');
return hasBackground('assets/closeups/micro-parcheggio.png') && hasBackground('assets/closeups/micro/rossa.png');
});
assert.equal(await page.locator('#bocce-throw').textContent(), 'Spingi');
assert.ok(await page.locator('#micro-help').isVisible(), 'il «Come si gioca» delle macchinine');
const exit = await page.locator('#closeup-close').boundingBox(), canvas = await page.locator('#scene').boundingBox();
assert.ok(exit.y >= canvas.y + canvas.height, 'l\'uscita sta fuori dalla pista');
await page.waitForTimeout(1600);
const state = () => page.evaluate(() => ({ angle: game.closeup.angle, power: game.closeup.power, step: game.closeup.step, x: game.closeup.cars.player.x }));
// Un punto della pista davanti alla macchinina di Andrea, in pixel della pagina.
const ahead = await page.evaluate(() => { const c = game.closeup, i = (c.cars.player.idx + 50) % c.track.n; return c.track.pts[i]; });
const target = { x: canvas.x + ahead[0] / 640 * canvas.width, y: canvas.y + ahead[1] / 360 * canvas.height };
if (!mobile) {
const before = (await state()).angle;
await page.mouse.move(target.x, target.y + 30, { steps: 4 });
assert.notEqual((await state()).angle, before, 'senza clic la mira segue il mouse');
await page.mouse.click(target.x, target.y);
} else await page.touchscreen.tap(target.x, target.y);
const aimed = await state();
assert.equal(aimed.step, 'aim', 'un tocco mira senza spingere');
await page.screenshot({ path: `${out}/${name}-mira.png` });
// Si spinge: col mouse tenendo premuto, col dito dal pulsante dopo aver scelto la forza.
if (!mobile) {
// Si lascia appena la carica arriva: restando troppo alla carica piena sarebbe un accompagnè.
await page.mouse.move(target.x, target.y); await page.mouse.down();
await page.waitForFunction(() => game.closeup.charging && game.closeup.power >= 0.75);
await page.mouse.up();
} else {
await page.locator('#bocce-power').fill('70');
await page.locator('#bocce-throw').tap();
}
await page.waitForTimeout(250);
const rolling = await state();
assert.equal(rolling.step, 'rolling', 'la macchinina parte');
await page.screenshot({ path: `${out}/${name}-corsa.png` });
// Poi spinge il Chiaru, e si torna a mirare.
await page.waitForFunction(() => game.closeup.current === 'player' && game.closeup.step === 'aim', null, { timeout: 15000 });
assert.notEqual((await state()).x, aimed.x, 'la macchinina di Andrea si è mossa');
await page.screenshot({ path: `${out}/${name}-dopo.png` });
await page.close();
}
assert.deepEqual(errors, []);
console.log(`ok: schermate in ${out}`);
} finally {
await browser?.close();
server.kill();
}
tests/micro.test.mjs
+183
View File
@@ -0,0 +1,183 @@
import test from 'node:test';
import assert from 'node:assert/strict';
import * as m from '../src/engine/micro.js';
import { drawMicro } from '../src/engine/micro-render.js';
import { Game, MINIGAMES } from '../src/engine/game.js';
import { story } from '../src/story/story.js';
import { settle } from './helpers.mjs';
// Fa andare la spinta in corso (e quella del Chiaru, se tocca a lui) finché non si torna a mirare o è finita.
function run(c, limit = 20000) {
for (let i = 0; i < limit && !(m.canThrow(c) || c.step === 'result'); i++) m.update(c, 1 / 60);
}
// Andrea «prudente»: mira a un punto della linea di mezzo `ahead` pixel più avanti, con la forza giusta per arrivarci.
function flick(c, ahead = 60) {
const car = c.cars.player, i = (car.idx + Math.round(ahead / c.track.step)) % c.track.n, [x, y] = c.track.pts[i];
c.angle = Math.atan2(y - car.y, x - car.x); c.power = m.powerFor(Math.hypot(x - car.x, y - car.y));
assert.ok(m.shoot(c));
}
// Andrea alla bona: la spinta più lunga che la guida dà in pista, puntando avanti lungo la linea di mezzo.
function guided(c) {
for (let ahead = 190; ahead >= 20; ahead -= 10) {
flickAim(c, ahead);
if (!m.guide(c).out) break;
}
assert.ok(m.shoot(c));
}
function flickAim(c, ahead) {
const car = c.cars.player, i = (car.idx + Math.round(ahead / c.track.step)) % c.track.n, [x, y] = c.track.pts[i];
c.angle = Math.atan2(y - car.y, x - car.x); c.power = m.powerFor(Math.hypot(x - car.x, y - car.y));
}
test('la pista: chiusa, larga uguale, e le macchinine partono in pista poco prima del traguardo', () => {
const t = m.TRACK;
assert.ok(t.length > 1500 && t.length < 2500);
for (let i = 0; i < t.n; i++) {
const [x, y] = t.pts[i];
assert.ok(x - m.HALF > 0 && x + m.HALF < 640 && y - m.HALF > 22 && y + m.HALF < 360, `la pista sta nel quadro (${x}, ${y})`);
}
// I tratti lontani lungo la pista non si toccano: fra i due gessi c'è sempre asfalto.
for (let i = 0; i < t.n; i += 3) for (let j = i + 3; j < t.n; j += 3) {
const along = Math.min(j - i, t.n - j + i) * t.step;
if (along < 120) continue;
const d = Math.hypot(t.pts[i][0] - t.pts[j][0], t.pts[i][1] - t.pts[j][1]);
assert.ok(d > 2 * m.HALF + 2 * m.CAR.r, `tratti troppo vicini: ${i} e ${j} (${d.toFixed(1)} px)`);
}
const c = m.newMicro(1);
for (const car of Object.values(c.cars)) {
assert.ok(!m.isOut(m.project(t, car.x, car.y).d));
assert.ok(car.progress < 0 && car.progress > -30, 'prima del traguardo');
}
});
test('stesso seme: stessa partita; la spinta va lontano quanto dice la guida', () => {
const a = m.newMicro(4, { level: 'male' }), b = m.newMicro(4, { level: 'male' });
for (const c of [a, b]) { flick(c); run(c); }
assert.deepEqual(a.cars, b.cars);
const c = m.newMicro(2, { level: 'bona' }), start = { ...c.cars.player };
c.power = 0.6; const g = m.guide(c);
assert.ok(m.shoot(c)); run(c);
// Il Chiaru ha già spinto: la macchinina di Andrea sta dove diceva la guida (se lui non l'ha urtata).
assert.ok(Math.hypot(c.cars.player.x - g.x, c.cars.player.y - g.y) < 3, 'arriva dove diceva la guida');
assert.ok(Math.abs(Math.hypot(g.x - start.x, g.y - start.y) - m.reach(m.speedFor(0.6))) < 0.01);
});
test('tutta fuori: si torna dove si era prima della spinta, e la guida lo diceva', () => {
const c = m.newMicro(3, { level: 'bona' }), start = { x: c.cars.player.x, y: c.cars.player.y };
c.angle = -Math.PI / 2; c.power = 1; // dritto verso l'erba in alto
assert.equal(m.guide(c).out, true);
assert.ok(m.shoot(c));
for (let i = 0; i < 2000 && c.step !== 'settle'; i++) m.update(c, 1 / 60);
assert.equal(c.cars.player.fault, 'fuori');
for (let i = 0; i < 200 && c.current === 'player'; i++) m.update(c, 1 / 60);
assert.deepEqual([c.cars.player.x, c.cars.player.y], [start.x, start.y]);
assert.match(c.line, /^Fuori! Andrea torna/);
assert.equal(c.returns.length, 1);
// Nel tornante non si salta dall'altra parte: si esce lo stesso.
assert.ok(c.events.some(e => e.kind === 'micro-fuori'));
});
test('le penalità alla francese: tagliè, cappottè, accompagnè; per tutte si torna indietro', () => {
// Tagliè: dal tratto di mezzo della esse, dritti in su attraverso l'erba verso il tratto di sopra.
const t = m.newMicro(1, { level: 'bona' }), [sx, sy] = t.track.pts[Math.round(t.track.n * 0.48)];
const p = m.project(t.track, sx, sy); Object.assign(t.cars.player, { x: sx, y: sy, idx: p.i, s: p.s, progress: p.s });
t.angle = -Math.PI / 2; t.power = 0.6; assert.ok(m.shoot(t));
for (let i = 0; i < 2000 && t.step !== 'settle'; i++) m.update(t, 1 / 60);
for (let i = 0; i < 200 && t.current === 'player'; i++) m.update(t, 1 / 60);
assert.match(t.line, /^Tagliè! Andrea torna dov'era\./);
assert.deepEqual([t.cars.player.x, t.cars.player.y], [sx, sy]);
// Cappottè: Andrea a tutta forza contro il Chiaru fermo davanti.
const k = m.newMicro(2, { level: 'bona' }), me = k.cars.player, him = k.cars.cpu, before = { x: him.x, y: him.y };
k.angle = Math.atan2(him.y - me.y, him.x - me.x); k.power = 1; assert.ok(m.shoot(k));
for (let i = 0; i < 2000 && k.step !== 'settle'; i++) m.update(k, 1 / 60);
assert.equal(him.fault, 'cappotte');
for (let i = 0; i < 200 && k.current === 'player'; i++) m.update(k, 1 / 60);
assert.match(k.line, /Cappottè! Il Chiaru torna dov'era\./);
// Torna al suo posto; se lì c'è ora Andrea, si scosta appena quanto basta.
assert.ok(Math.hypot(him.x - before.x, him.y - before.y) <= 2 * m.CAR.r + 1e-9);
// Accompagnè: tenuto premuto ben oltre la carica piena.
const a = m.newMicro(3), start = { x: a.cars.player.x, y: a.cars.player.y };
assert.ok(m.press(a));
for (let i = 0; i < 120; i++) m.update(a, 1 / 60);
assert.ok(m.overHeld(a));
assert.ok(m.release(a));
for (let i = 0; i < 2000 && a.current === 'player'; i++) m.update(a, 1 / 60);
assert.match(a.line, /^Accompagnè! Andrea torna dov'era\./);
assert.deepEqual([a.cars.player.x, a.cars.player.y], [start.x, start.y]);
// Lasciando in tempo, la spinta piena vale.
const ok = m.newMicro(3); m.press(ok);
for (let i = 0; i < Math.round((m.SWING + 0.2) * 60); i++) m.update(ok, 1 / 60);
m.release(ok); assert.equal(ok.cars.player.fault, null);
});
test('una partita intera: stesse spinte per tutti e due, un vincitore, e il Chiaru alla bona perde contro chi usa la guida', () => {
const wins = { player: 0, cpu: 0, draw: 0 };
for (const seed of [1, 2, 3]) {
const c = m.newMicro(seed, { level: 'bona' });
for (let n = 0; n < 80 && c.step !== 'result'; n++) { if (m.canThrow(c)) guided(c); run(c); }
assert.equal(c.step, 'result');
assert.equal(c.result.flicks.player, c.result.flicks.cpu);
assert.ok(m.finished(c, c.cars.player) || m.finished(c, c.cars.cpu));
wins[c.result.winner]++;
}
assert.ok(wins.player >= 2, `alla bona Andrea, con la guida, deve vincere quasi sempre (${JSON.stringify(wins)})`);
// A fassi male il Chiaru fa il giro con meno spinte che alla bona.
const flicks = level => {
const c = m.newMicro(7, { level });
for (let n = 0; n < 80 && c.step !== 'result'; n++) { if (m.canThrow(c)) { c.angle = c.cars.player.heading; c.power = 0; m.shoot(c); } run(c); }
return c.flicks.cpu;
};
assert.ok(flicks('male') < flicks('bona'));
});
test('i comandi: un tocco mira soltanto, tenere premuto carica, lasciare spinge; la mira si gira con le frecce', () => {
const c = m.newMicro(5);
assert.ok(m.press(c, 1)); m.update(c, 0.05); assert.ok(m.release(c, 1) === true && c.step === 'aim', 'il tocco breve non spinge');
assert.ok(m.press(c, 1)); for (let i = 0; i < 60; i++) m.update(c, 1 / 60); assert.ok(c.charging);
const before = c.cars.player.x;
assert.ok(m.release(c, 1)); assert.equal(c.step, 'rolling');
m.update(c, 0.2); assert.notEqual(c.cars.player.x, before);
assert.equal(m.press(c, 2), false, 'mentre corre non si spinge');
const d = m.newMicro(5), a0 = d.angle;
m.key(d, 'ArrowRight', true); m.update(d, 0.5); m.key(d, 'ArrowRight', false);
assert.ok(d.angle > a0);
assert.ok(m.aimScreen(d, [320, 200])); assert.equal(m.aimScreen(d, [320, 10]), false, 'il tabellone non si mira');
assert.ok(m.setPower(d, 0.25)); assert.equal(d.power, 0.25);
});
test('il Chiaru pensa a pezzi: nessun fotogramma lo ferma troppo', () => {
const c = m.newMicro(6, { level: 'male' });
flick(c);
let worst = 0;
for (let i = 0; i < 600 && !m.canThrow(c); i++) { const t = performance.now(); m.update(c, 1 / 60); worst = Math.max(worst, performance.now() - t); }
assert.ok(worst < 40, `fotogramma da ${worst.toFixed(1)} ms`);
});
test('il disegno: gesso, macchinine, guida e risultato; lo stato non cambia', () => {
const calls = [], ctx = new Proxy({}, { get: (o, k) => k in o ? o[k] : (...args) => calls.push([k, ...args]) });
const c = m.newMicro(8, { level: 'bona' }), bg = {}, cars = { [story.closeups.micro.cars.player]: { car: 'player' } };
const draw = () => { const before = structuredClone(c); drawMicro(ctx, c, story.closeups.micro, bg, src => cars[src]); assert.deepEqual(c, before); };
draw();
assert.ok(calls.some(([op, img]) => op === 'drawImage' && img === bg));
assert.ok(calls.filter(([op, img]) => op === 'drawImage' && img?.car === 'player').length >= 2, 'la macchinina e il suo fantasma');
assert.ok(calls.some(([op, t]) => op === 'fillText' && t === 'Chiaru'));
c.step = 'result'; c.result = { winner: 'cpu', flicks: { player: 12, cpu: 12 } }; calls.length = 0; draw();
assert.ok(calls.some(([op, t]) => op === 'fillText' && t === 'HA VINTO IL CHIARU'));
});
test('il Chiaru al parcheggio di Cardetole: si chiacchiera, si sceglie il livello e si corre', () => {
assert.ok(MINIGAMES.micro);
const g = new Game(story); g.go('cardetole'); settle(g);
g.act('talk', 'chiaru'); settle(g);
assert.ok(!g.options().some(o => o.text === 'Seria.'), 'il livello non si sceglie subito');
g.choose(g.options().findIndex(o => o.text === 'Si corre?')); settle(g);
g.choose(g.options().findIndex(o => o.text === 'No, aspetta.')); settle(g);
assert.equal(g.closeup, null);
g.choose(g.options().findIndex(o => o.text === 'Si corre?')); settle(g);
g.choose(g.options().findIndex(o => o.text === 'A fassi male.')); settle(g);
assert.equal(g.closeup?.id, 'micro'); assert.equal(g.closeup.level, 'male');
g.closeup.step = 'result'; g.closeup.result = { winner: 'player', flicks: { player: 11, cpu: 11 } };
g.closeupClose(); settle(g);
assert.ok(g.state.flags.micro_vinto);
});
tests/rinquarto.test.mjs
+9 -9
View File
@@ -7,7 +7,7 @@ import { Game, MINIGAMES } from '../src/engine/game.js';
import { story } from '../src/story/story.js';
import { settle } from './helpers.mjs';
// Tira (Andrea col tiro dato, o Bertovo da sé) e aspetta l'esito.
// Tira (Andrea col tiro dato, o Trappizzio Berti da sé) e aspetta l'esito.
function roll(c) {
for (let i = 0; i < 20000 && c.step !== 'review' && c.step !== 'result'; i++) r.update(c, 1 / 60);
assert.ok(['review', 'result'].includes(c.step), 'il tiro si deve fermare');
@@ -55,7 +55,7 @@ test('la diretta tocca il disturbo; meno sponde del richiesto non valgono', () =
assert.equal(r.tryShot({ ...bona, skill: r.LEVELS.male }, bona.solution.angle).point, one.cushions >= 3);
});
test('a turno: prima Andrea, poi il tavolo torna com\'era e tira Bertovo; l\'esito resta finché non si va avanti', () => {
test('a turno: prima Andrea, poi il tavolo torna com\'era e tira Trappizzio Berti; l\'esito resta finché non si va avanti', () => {
const c = r.newRinquarto(8, { level: 'bona' });
assert.equal(r.shooter(c), 'andrea'); assert.ok(r.canThrow(c)); assert.equal(r.button(c), 'Tira');
const mine = andrea(c);
@@ -68,7 +68,7 @@ test('a turno: prima Andrea, poi il tavolo torna com\'era e tira Bertovo; l\'esi
assert.equal(r.shooter(c), 'bertovo'); assert.equal(c.step, 'think');
assert.ok(samePlace(c, c.start), 'il tavolo è tornato com\'era');
assert.equal(r.canThrow(c), false, 'mentre tira lui i comandi sono fermi'); assert.equal(r.shoot(c), false);
assert.match(r.status(c), /Tira Bertovo/);
assert.match(r.status(c), /Tira Trappizzio Berti/);
roll(c);
assert.equal(c.history.at(-1).who, 'bertovo'); assert.equal(c.score.bertovo, Number(c.history.at(-1).point));
r.advance(c);
@@ -81,18 +81,18 @@ test('alla fine vince chi ha più punti; può finire pari', () => {
assert.equal(c.step, 'result');
assert.equal(c.score.andrea, 0);
assert.equal(c.result.winner, c.score.bertovo > 0 ? 'cpu' : 'draw');
assert.match(r.status(c), c.score.bertovo > 0 ? /Ha vinto Bertovo/ : /Pari/);
assert.match(r.status(c), c.score.bertovo > 0 ? /Ha vinto Trappizzio Berti/ : /Pari/);
for (const [a, b, w] of [[3, 2, 'player'], [2, 3, 'cpu'], [2, 2, 'draw']]) {
const d = { ...c, step: 'review', last: true, round: 1, position: c.skill.positions, score: { andrea: a, bertovo: b } };
r.advance(d); assert.equal(d.result.winner, w);
}
});
test('l\'allenamento: tira prima Bertovo, sempre giusto, poi Andrea; niente punti, finisce pari', () => {
test('l\'allenamento: tira prima Trappizzio Berti, sempre giusto, poi Andrea; niente punti, finisce pari', () => {
const c = r.newRinquarto(2, { level: 'allenamento' });
assert.equal(r.shooter(c), 'bertovo'); assert.equal(c.step, 'think');
for (let p = 0; p < c.skill.positions; p++) {
roll(c); assert.ok(c.history.at(-1).point, 'Bertovo fa vedere il rinquarto');
roll(c); assert.ok(c.history.at(-1).point, 'Trappizzio Berti fa vedere il rinquarto');
r.advance(c); assert.equal(r.shooter(c), 'andrea');
andrea(c); r.advance(c);
}
@@ -100,7 +100,7 @@ test('l\'allenamento: tira prima Bertovo, sempre giusto, poi Andrea; niente punt
assert.equal(c.result.winner, 'draw'); assert.ok(c.result.training);
});
test('Bertovo è più preciso salendo di livello', () => {
test('Trappizzio Berti è più preciso salendo di livello', () => {
const spread = level => {
const c = r.newRinquarto(4, { level: 'bona' }); c.skill = r.LEVELS[level];
const errors = Array.from({ length: 400 }, () => r.bertovoPlan(c).angle - c.solution.angle);
@@ -131,7 +131,7 @@ test('i comandi: un tocco mira e basta, tenendo premuto si tira; il secondo dito
assert.equal(r.setPower(d, 0.2), false); assert.equal(d.power, 1);
});
test('dialogo di Bertovo: si chiacchiera, la sfida o l\'allenamento; lui sta al tavolo di mezzo del Circolo', () => {
test('dialogo di Trappizzio Berti: si chiacchiera, la sfida o l\'allenamento; lui sta al tavolo di mezzo del Circolo', () => {
assert.ok(MINIGAMES.rinquarto);
assert.equal(story.characters.bertovo.sprite, 'assets/characters/bertovo.json');
const where = Object.entries(story.scenes).filter(([, sc]) => JSON.stringify(sc).includes('bertovo')).map(([id]) => id);
@@ -169,7 +169,7 @@ test('il disegno: traiettoria con le sponde numerate, riepilogo, e lo stato non
assert.ok(calls.some(([op, t]) => op === 'fillText' && t === '1'), 'la prima sponda è numerata');
assert.ok(calls.some(([op, t]) => op === 'fillText' && /punto!/.test(t)));
c.step = 'result'; c.result = { winner: 'cpu', points: { andrea: 1, bertovo: 3 } }; calls.length = 0; draw();
assert.ok(calls.some(([op, t]) => op === 'fillText' && t === 'HA VINTO BERTOVO'));
assert.ok(calls.some(([op, t]) => op === 'fillText' && t === 'HA VINTO TRAPPIZZIO BERTI'));
} finally {
if (previous === undefined) delete globalThis.document; else globalThis.document = previous;
}