manzoloandClaude Opus 5.5
7e1e6f6144
Esito che vale e si salva appena deciso, per tutti i minigiochi (anche tornando al titolo dalla schermata del risultato); briscola: uscire durante il conteggio non perde più la vittoria; tressette: si esce ai 21 col primo evento che ci porta, accusa compresa (prima vinceva sempre Andrea se ci arrivavano tutte e due), il carico che fa vincere si dà anche se è il 2, accuse che non escono dal tavolo, convenzioni scritte nell'aiuto; scopa: primiera valutata per quel che migliora, finale esatto a mazzo finito, presa sulla tavola al rilascio con scelta e conferma, frecce e Invio sempre sulla presa scelta. Tastiera: Invio e Spazio giocano sempre la carta scelta. Tavola descritta a parole. Classi CSS comuni ai tre giochi. Video: player nel gioco (pulsante «Guarda il video» nel «Come si gioca», compare quando il video esiste), video/narra.py per la voce del narratore, pezzi comuni dei copioni e il copione della briscola; scaletta in video/SCALETTA-CARTE.md Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01A1dxvtsZx8NE9fwjXUNDBr
175 lines
12 KiB
JavaScript
175 lines
12 KiB
JavaScript
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { DECK_CARDS, newTressette, accuse, accuseName, legal, best, signalOk, reason, setSignal, play, collect, advance, update, observation, choose, knowledge, canPlay, finished, team, status, TARGET } from '../src/engine/tressette.js';
|
|
import { simulate, calibrate } from '../tools/calibrate_tressette.mjs';
|
|
|
|
const card = (suit, rank, deck = 'toscane') => DECK_CARDS[deck].find(a => a.suit === suit && a.rank === rank);
|
|
const hand = list => list.map(([s, r]) => card(s, r));
|
|
|
|
test('mazzo: 40 carte, 32 terzi di punti, ordine 3 > 2 > Asso > figure > 7 … 4', () => {
|
|
for (const cards of Object.values(DECK_CARDS)) {
|
|
assert.equal(cards.length, 40); assert.equal(cards.reduce((n, a) => n + a.thirds, 0), 32);
|
|
}
|
|
const order = ['3', '2', 'Asso', 'Regio', 'Donna', 'Gobbo', '7', '6', '5', '4'];
|
|
for (let i = 1; i < order.length; i++) assert.ok(card('cuori', order[i - 1]).power > card('cuori', order[i]).power, order[i]);
|
|
assert.equal(card('picche', 'Asso').thirds, 3); assert.equal(card('picche', 'Regio').thirds, 1); assert.equal(card('picche', '7').thirds, 0);
|
|
});
|
|
|
|
test('si risponde al seme; chi non ce l\'ha gioca quel che vuole; prende la più alta del seme di uscita', () => {
|
|
const h = hand([['cuori', '4'], ['fiori', '3'], ['cuori', 'Regio']]);
|
|
assert.deepEqual(legal(h, []), [0, 1, 2]);
|
|
assert.deepEqual(legal(h, [{ who: 1, card: card('cuori', '7') }]), [0, 2]);
|
|
assert.deepEqual(legal(h, [{ who: 1, card: card('picche', '7') }]), [0, 1, 2]);
|
|
const table = [{ who: 1, card: card('cuori', '4') }, { who: 2, card: card('fiori', '3') }, { who: 3, card: card('cuori', '2') }, { who: 0, card: card('cuori', 'Asso') }];
|
|
assert.equal(best(table).who, 3, 'il 3 di fiori non risponde: prende il 2 di cuori');
|
|
});
|
|
|
|
test('accuse: napoletana 3 punti, tre o quattro Assi, 2 o 3 per 3 o 4 punti, anche insieme', () => {
|
|
const h = hand([['cuori', 'Asso'], ['cuori', '2'], ['cuori', '3'], ['picche', '3'], ['fiori', '3'], ['mattoni', '7']]);
|
|
const a = accuse(h);
|
|
assert.deepEqual(a.map(x => [x.kind, x.points]), [['napoletana', 3], ['buongioco', 3]]);
|
|
assert.equal(accuse(hand([['cuori', '2'], ['picche', '2'], ['fiori', '2'], ['mattoni', '2']]))[0].points, 4);
|
|
assert.deepEqual(accuse(hand([['cuori', 'Asso'], ['cuori', '2'], ['picche', '3']])), []);
|
|
// Del tris si dice il seme che manca, così Andrea sa quello che sa l'avversario.
|
|
const tris = accuse(hand([['picche', '3'], ['fiori', '3'], ['mattoni', '3']]), ['cuori', 'mattoni', 'fiori', 'picche'])[0];
|
|
assert.equal(tris.missing, 'cuori'); assert.equal(accuseName(tris), 'tre 3, manca cuori');
|
|
});
|
|
|
|
test('segni: volo con l\'ultima, striscio se ne resta un\'altra, busso sempre; solo chi esce', () => {
|
|
const h = hand([['cuori', '4'], ['cuori', '5'], ['fiori', '7']]);
|
|
assert.ok(signalOk(h, 2, [], 'volo')); assert.ok(!signalOk(h, 0, [], 'volo'));
|
|
assert.ok(signalOk(h, 0, [], 'striscio')); assert.ok(!signalOk(h, 2, [], 'striscio'));
|
|
assert.ok(signalOk(h, 0, [], 'busso')); assert.ok(signalOk(h, 2, [], 'busso'));
|
|
assert.ok(!signalOk(h, 0, [{ who: 1, card: card('cuori', '7') }], 'busso'));
|
|
const c = newTressette(5); c.current = 0; c.table = []; c.hands[0] = [...h]; c.pending[0] = [];
|
|
assert.ok(setSignal(c, 'volo')); assert.equal(play(c, 0), false); assert.match(c.refused, /Volo solo/);
|
|
assert.equal(c.hands[0].length, 3, 'la carta resta in mano');
|
|
assert.equal(play(c, 0, 0, 'xyz'), false); assert.equal(c.refused, 'Segno non riconosciuto.');
|
|
assert.ok(play(c, 2)); assert.equal(c.table[0].signal, 'volo'); assert.equal(c.signal, null);
|
|
assert.ok(c.events.some(e => e.kind === 'card-volo'));
|
|
});
|
|
|
|
test('la carta che non risponde al seme si rifiuta con la ragione', () => {
|
|
const c = newTressette(9); c.current = 0; c.hands[0] = hand([['cuori', '4'], ['fiori', '3']]);
|
|
c.table = [{ who: 3, card: card('cuori', '7') }];
|
|
assert.equal(play(c, 1), false); assert.equal(reason(c, 1), 'Devi rispondere a cuori.');
|
|
assert.ok(canPlay(c)); assert.ok(play(c, 0));
|
|
});
|
|
|
|
test('una smazzata: accuse dette al proprio turno, 10 prese, sempre 11 punti fra terzi e ultima presa', () => {
|
|
const c = newTressette(1234, { level: 'seria' });
|
|
assert.deepEqual(c.score, [0, 0]); assert.deepEqual(c.accuse, [], 'prima di giocare nessuno ha accusato');
|
|
const owed = c.pending.flat();
|
|
assert.equal(c.current, (c.dealer + 1) % 4, 'esce chi sta a destra del mazziere');
|
|
assert.ok(c.hands.every(h => h.length === 10));
|
|
const firstDealer = c.dealer;
|
|
while (!['smazzata', 'result'].includes(c.step)) {
|
|
if (canPlay(c)) { const m = choose(observation(c, 0), 'seria'); assert.ok(play(c, m.index, 0, m.signal)); }
|
|
update(c, 20);
|
|
if (c.tricks.length === 1) assert.equal(c.accuse.length, owed.length, 'dopo la prima presa hanno accusato tutti');
|
|
}
|
|
if (c.step === 'smazzata') {
|
|
assert.equal(c.tricks.length, 10);
|
|
assert.equal(c.summary.thirds[0] + c.summary.thirds[1], 35);
|
|
assert.equal(c.summary.points[0] + c.summary.points[1], 11, 'i terzi avanzati sommano sempre a due');
|
|
assert.deepEqual(c.score, [0, 1].map(t => c.summary.accused[t] + c.summary.points[t]));
|
|
assert.ok(advance(c)); assert.equal(c.dealer, (firstDealer + 1) % 4); assert.equal(c.step, 'play');
|
|
}
|
|
});
|
|
|
|
test('si va ai 21: chi ci arriva per primo è fuori, anche a metà smazzata, e la vittoria non si perde', () => {
|
|
const c = newTressette(3); c.pending = [[], [], [], []];
|
|
c.base = [20, 19]; c.score = [20, 19]; c.thirds = [2, 0];
|
|
// Una presa da un terzo porta noi a 21 (3 terzi = 1 punto): fuori subito.
|
|
c.table = [{ who: 0, card: card('cuori', '3') }, { who: 1, card: card('cuori', '4') }, { who: 2, card: card('cuori', '5') }, { who: 3, card: card('cuori', '6') }];
|
|
c.step = 'trick'; c.last = { winner: 0, cards: c.table.map(p => p.card) };
|
|
assert.ok(collect(c)); assert.equal(c.step, 'result'); assert.equal(c.result.winner, 'player'); assert.deepEqual(c.score, [21, 19]);
|
|
assert.ok(finished(c)); assert.equal(advance(c), false);
|
|
assert.match(status(c), /Avete vinto voi, 21 a 19/);
|
|
// Anche le accuse bastano: dette giocando, contano alla fine di quella presa.
|
|
const d = newTressette(3); d.base = [0, 19]; d.score = [0, 19]; d.current = 1; d.table = []; d.tricks = [];
|
|
d.pending = [[], [{ who: 1, kind: 'napoletana', suit: 'fiori', points: 3, cards: [] }], [], []];
|
|
d.hands[1] = [card('fiori', '7'), ...d.hands[1].slice(1)];
|
|
assert.ok(play(d, 0, 1)); assert.equal(d.score[1], 22);
|
|
assert.equal(d.step, 'result', 'l\'accusa fa uscire subito'); assert.equal(d.result.winner, 'cpu');
|
|
// Tutte e due a un passo, tutte e due con un'accusa: esce chi accusa per primo, chiunque sia (Codex, seme 28).
|
|
const e = newTressette(28); e.base = [18, 18]; e.score = [18, 18]; e.current = 1; e.table = []; e.tricks = [];
|
|
e.pending = [[{ who: 0, kind: 'buongioco', rank: '3', points: 3, cards: [] }], [{ who: 1, kind: 'buongioco', rank: '2', points: 3, cards: [] }], [], []];
|
|
assert.ok(play(e, 0, 1)); assert.equal(e.result.winner, 'cpu'); assert.deepEqual(e.score, [18, 21]);
|
|
assert.equal(play(e, 0, 2), false, 'a partita finita non si gioca più');
|
|
});
|
|
|
|
test('partite intere deterministiche col seme; i due mazzi danno le stesse carte', () => {
|
|
const a = simulate(77, 'male'), b = simulate(77, 'male');
|
|
assert.deepEqual(a.score, b.score); assert.ok(Math.max(...a.score) >= TARGET);
|
|
const t = newTressette(42), n = newTressette(42, { deck: 'napoletane' });
|
|
assert.deepEqual(t.hands.map(h => h.map(a => a.id)), n.hands.map(h => h.map(a => a.id)));
|
|
assert.equal(n.hands[0][0].suit === 'denari' || ['coppe', 'spade', 'bastoni'].includes(n.hands[0][0].suit), true);
|
|
});
|
|
|
|
test('gli altri non vedono le carte altrui: l\'osservazione ha solo la propria mano e il tavolo', () => {
|
|
const c = newTressette(11), v = observation(c, 1);
|
|
assert.deepEqual(v.hand.map(a => a.id), c.hands[1].map(a => a.id));
|
|
assert.equal(v.hands, undefined); assert.equal(v.seed, undefined);
|
|
const k = knowledge(v, true);
|
|
assert.equal(k.out.length, 30, 'fuori ci sono le 30 carte degli altri tre');
|
|
assert.ok(!k.could(1, k.out[0]), 'non può pensare di averle lui');
|
|
// Cambiare le mani degli altri non cambia la scelta.
|
|
const other = structuredClone(c); other.hands[0].reverse(); other.hands[2].reverse();
|
|
c.current = other.current = 1;
|
|
assert.deepEqual(choose(observation(c, 1), 'male', 5), choose(observation(other, 1), 'male', 5));
|
|
});
|
|
|
|
test('«A fassi male» conta: sa che il 3 è uscito, e col 2 si fa la presa sicura', () => {
|
|
const c = newTressette(8); c.current = 1; c.table = [];
|
|
c.hands[1] = hand([['cuori', '2'], ['fiori', '4']]);
|
|
c.tricks = [{ leader: 0, winner: 0, cards: [{ who: 0, card: card('cuori', '3') }, { who: 1, card: card('fiori', '5') }, { who: 2, card: card('cuori', '4') }, { who: 3, card: card('cuori', '5') }] }];
|
|
assert.equal(choose(observation(c, 1), 'male').index, 0, 'esce col 2, ormai il più alto');
|
|
const foes = [0, 2];
|
|
assert.equal(knowledge(observation(c, 1), false).beatable(card('cuori', '2'), foes), true, 'chi non conta ha paura del 3');
|
|
assert.equal(knowledge(observation(c, 1), true).beatable(card('cuori', '2'), foes), false);
|
|
});
|
|
|
|
test('il socio ritorna il seme a chi ha bussato', () => {
|
|
const c = newTressette(8); c.current = 2; c.table = [];
|
|
c.hands[2] = hand([['cuori', '4'], ['fiori', '2'], ['cuori', '7']]);
|
|
c.tricks = [{ leader: 0, winner: 2, cards: [{ who: 0, card: card('cuori', '5'), signal: 'busso' }, { who: 1, card: card('cuori', '6') }, { who: 2, card: card('cuori', '3') }, { who: 3, card: card('picche', '4') }] }];
|
|
const m = choose(observation(c, 2), 'male');
|
|
assert.equal(c.hands[2][m.index].suit, 'cuori'); assert.equal(c.hands[2][m.index].rank, '4');
|
|
});
|
|
|
|
test('chi riceve il busso prende con la migliore; il socio non spreca il 3 su una presa già sua', () => {
|
|
const c = newTressette(8); c.pending = [[], [], [], []]; c.current = 2;
|
|
c.table = [{ who: 0, card: card('cuori', '4'), signal: 'busso' }, { who: 1, card: card('cuori', '5') }];
|
|
c.hands[2] = hand([['cuori', '2'], ['cuori', '6'], ['fiori', '7']]);
|
|
assert.equal(c.hands[2][choose(observation(c, 2), 'male').index].rank, '2', 'al busso risponde col 2');
|
|
const d = newTressette(8); d.pending = [[], [], [], []]; d.current = 3;
|
|
d.table = [{ who: 0, card: card('fiori', '6') }, { who: 1, card: card('fiori', '2') }, { who: 2, card: card('fiori', '4') }];
|
|
d.hands[3] = hand([['fiori', '3'], ['fiori', '5'], ['cuori', '7']]);
|
|
// L'avversario del posto 3: il suo socio (1) prende col 2 e lui è l'ultimo; tiene il 3 e dà il 5.
|
|
assert.equal(d.hands[3][choose(observation(d, 3), 'male').index].rank, '5');
|
|
});
|
|
|
|
test('se un carico al socio basta per i 21, si dà anche il 2', () => {
|
|
const c = newTressette(8); c.pending = [[], [], [], []]; c.current = 3;
|
|
c.base = [0, 20]; c.score = [0, 20]; c.thirds = [0, 1];
|
|
c.table = [{ who: 0, card: card('cuori', '4') }, { who: 1, card: card('cuori', '3') }, { who: 2, card: card('cuori', '5') }];
|
|
c.hands[3] = hand([['fiori', '2'], ['picche', '4']]);
|
|
assert.equal(c.hands[3][choose(observation(c, 3), 'seria').index].rank, '2');
|
|
assert.equal(c.hands[3][choose(observation(c, 3), 'male').index].rank, '2');
|
|
});
|
|
|
|
test('chi vola ha finito il seme: per «A fassi male» non può più avere il 3', () => {
|
|
const c = newTressette(8); c.pending = [[], [], [], []]; c.current = 1;
|
|
c.tricks = [{ leader: 2, winner: 0, cards: [{ who: 2, card: card('cuori', '4'), signal: 'volo' }, { who: 3, card: card('cuori', '5') }, { who: 0, card: card('cuori', '6') }, { who: 1, card: card('cuori', '7') }] }];
|
|
c.hands[1] = hand([['cuori', '2'], ['fiori', '4']]); c.table = [];
|
|
const k = knowledge(observation(c, 1), true);
|
|
assert.equal(k.could(2, card('cuori', '3')), false);
|
|
});
|
|
|
|
test('taratura: Alla bona < Seria < A fassi male, contro Andrea e il socio che giocano attenti', () => {
|
|
const runs = calibrate(60);
|
|
assert.ok(runs[0].playerPercent > runs[1].playerPercent, JSON.stringify(runs));
|
|
assert.ok(runs[1].playerPercent >= runs[2].playerPercent, JSON.stringify(runs));
|
|
});
|