manzoloandClaude Opus 5.5
538bf6cedb
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01A1dxvtsZx8NE9fwjXUNDBr
256 lines
16 KiB
JavaScript
256 lines
16 KiB
JavaScript
// Scopa in due, ai 11: regole e avversari senza DOM, come la briscola. Carte, mattoni (o denari), settebello,
|
||
// primiera e scope. Con le toscane il seme «buono» è mattoni, con le napoletane denari.
|
||
import { DECKS, cardName } from './briscola.js';
|
||
|
||
export { cardName };
|
||
export const LEVELS = ['bona', 'seria', 'male'];
|
||
export const TARGET = 11;
|
||
// I tempi delle animazioni (scopa-render.js): la carta vola dalla mano; le carte prese restano ferme un attimo e poi
|
||
// volano sul mucchietto di chi ha preso.
|
||
export const PLAY_TIME = 0.3, TAKE_HOLD = 0.75, TAKE_TIME = 1.35;
|
||
export const COIN = { toscane: 'mattoni', napoletane: 'denari' };
|
||
// Valore per le prese: Asso 1, poi i numeri, figure 8, 9 e 10. Primiera: 7 vale 21, 6 18, Asso 16, 5 15, 4 14,
|
||
// 3 13, 2 12, le figure 10.
|
||
const PRIME = [16, 12, 13, 14, 15, 18, 21, 10, 10, 10];
|
||
const build = ({ suits, ranks }) => Object.freeze(suits.flatMap((suit, s) => ranks.map((rank, r) =>
|
||
Object.freeze({ id: s * 10 + r, suit, rank, value: r + 1, prime: PRIME[r] }))));
|
||
export const DECK_CARDS = Object.fromEntries(Object.entries(DECKS).map(([name, deck]) => [name, build(deck)]));
|
||
export const other = who => who === 'player' ? 'cpu' : 'player';
|
||
const lcg = n => (Math.imul(n, 1664525) + 1013904223) >>> 0;
|
||
function rng(seed) { let n = seed >>> 0; return () => (n = lcg(n)) / 4294967296; }
|
||
function shuffle(cards, random) {
|
||
for (let i = cards.length - 1; i > 0; i--) { const j = Math.floor(random() * (i + 1)); [cards[i], cards[j]] = [cards[j], cards[i]]; }
|
||
return cards;
|
||
}
|
||
|
||
// Le prese possibili con `card`: se in tavola c'è una carta dello stesso valore si prende quella (una sola, a
|
||
// scelta se sono più d'una); altrimenti ogni gruppo di carte che somma il suo valore. Se una presa c'è, è obbligatoria.
|
||
export function captures(table, card) {
|
||
const same = table.filter(a => a.value === card.value);
|
||
if (same.length) return same.map(a => [a]);
|
||
const out = [];
|
||
for (let mask = 1; mask < 1 << table.length; mask++) {
|
||
const pick = table.filter((_, i) => mask & 1 << i);
|
||
if (pick.length > 1 && pick.reduce((n, a) => n + a.value, 0) === card.value) out.push(pick);
|
||
}
|
||
return out;
|
||
}
|
||
const isSettebello = (card, deck) => card.suit === COIN[deck] && card.value === 7;
|
||
// Primiera: la carta migliore di ogni seme; chi non ha tutti e quattro i semi non la fa.
|
||
export function primiera(cards, deck) {
|
||
const suits = DECKS[deck].suits;
|
||
if (!suits.every(s => cards.some(a => a.suit === s))) return 0;
|
||
return suits.reduce((n, s) => n + Math.max(...cards.filter(a => a.suit === s).map(a => a.prime)), 0);
|
||
}
|
||
// I punti di una smazzata: carte (più di 20), mattoni o denari (più di 5), settebello, primiera, una per scopa.
|
||
export function tally(taken, scope, deck) {
|
||
const coin = COIN[deck], rows = [], who = (a, b) => a > b ? 'player' : b > a ? 'cpu' : null;
|
||
const count = w => taken[w].length, coins = w => taken[w].filter(a => a.suit === coin).length, prime = w => primiera(taken[w], deck);
|
||
rows.push({ key: 'carte', label: 'Carte', player: count('player'), cpu: count('cpu'), winner: who(count('player'), count('cpu')) });
|
||
rows.push({ key: 'coin', label: coin === 'mattoni' ? 'Mattoni' : 'Denari', player: coins('player'), cpu: coins('cpu'), winner: who(coins('player'), coins('cpu')) });
|
||
const seven = taken.player.some(a => isSettebello(a, deck)) ? 'player' : 'cpu';
|
||
rows.push({ key: 'settebello', label: 'Settebello', player: +(seven === 'player'), cpu: +(seven === 'cpu'), winner: seven });
|
||
rows.push({ key: 'primiera', label: 'Primiera', player: prime('player'), cpu: prime('cpu'), winner: who(prime('player'), prime('cpu')) });
|
||
const points = { player: 0, cpu: 0 };
|
||
for (const r of rows) if (r.winner) points[r.winner]++;
|
||
rows.push({ key: 'scope', label: 'Scope', player: scope.player, cpu: scope.cpu, winner: null });
|
||
points.player += scope.player; points.cpu += scope.cpu;
|
||
return { rows, points };
|
||
}
|
||
|
||
function deal(c) {
|
||
// Con tre o quattro re in tavola si rimescola.
|
||
let stock;
|
||
do { c.seed = lcg(c.seed); stock = shuffle([...DECK_CARDS[c.deck]], rng(c.seed)); }
|
||
while (stock.slice(0, 4).filter(a => a.value === 10).length >= 3);
|
||
c.table = stock.splice(0, 4); c.stock = stock;
|
||
c.hands = { player: [], cpu: [] }; c.taken = { player: [], cpu: [] }; c.scope = { player: 0, cpu: 0 };
|
||
c.current = other(c.dealer); c.lastTaker = null; c.round++;
|
||
refill(c); c.events.push({ kind: 'card-shuffle' });
|
||
}
|
||
// Tre carte a testa, prima a chi gioca per primo.
|
||
function refill(c) {
|
||
for (let i = 0; i < 3; i++) for (const who of [other(c.dealer), c.dealer]) c.hands[who].push(c.stock.shift());
|
||
c.step = 'play'; c.t = 0; c.selected = 0; c.choice = null;
|
||
}
|
||
export function newScopa(seed = Date.now() >>> 0, { level = 'seria', deck = 'toscane' } = {}) {
|
||
const c = { level: LEVELS.includes(level) ? level : 'seria', deck: DECKS[deck] ? deck : 'toscane', score: { player: 0, cpu: 0 },
|
||
round: 0, seed: seed >>> 0, aiSeed: (seed ^ 0x27d4eb2f) >>> 0, age: 0, events: [], last: null, summary: null };
|
||
c.dealer = rng(seed)() < 0.5 ? 'player' : 'cpu';
|
||
deal(c); return c;
|
||
}
|
||
export const canPlay = c => c.step === 'play' && c.current === 'player';
|
||
export function select(c, index) {
|
||
if (c.step === 'choose' && Number.isInteger(index) && c.choice.options[index]) { c.choice.selected = index; return true; }
|
||
if (!canPlay(c) || !Number.isInteger(index) || !c.hands.player[index]) return false;
|
||
c.selected = index; return true;
|
||
}
|
||
export function nudge(c, direction) {
|
||
if (c.step === 'choose') { const n = c.choice.options.length; return select(c, (c.choice.selected + direction + n) % n); }
|
||
const n = c.hands.player.length;
|
||
return select(c, (c.selected + direction + n) % n);
|
||
}
|
||
// Andrea gioca una carta: se le prese possibili sono più d'una, sceglie lui quale (passo «choose»).
|
||
export function play(c, index = c.selected, who = 'player', option = null) {
|
||
if (c.step !== 'play' || c.current !== who || !Number.isInteger(index) || !c.hands[who][index]) return false;
|
||
const options = captures(c.table, c.hands[who][index]);
|
||
if (options.length > 1 && option === null) {
|
||
if (who !== 'player') return false;
|
||
c.step = 'choose'; c.choice = { index, options, selected: 0 }; return true;
|
||
}
|
||
return execute(c, who, index, options.length ? options[option ?? 0] : null);
|
||
}
|
||
export function take(c, k = c.choice?.selected) {
|
||
if (c.step !== 'choose' || !c.choice.options[k]) return false;
|
||
const { index, options } = c.choice; c.step = 'play'; c.choice = null;
|
||
return execute(c, 'player', index, options[k]);
|
||
}
|
||
export function cancel(c) { if (c.step !== 'choose') return false; c.step = 'play'; c.choice = null; return true; }
|
||
function execute(c, who, index, captured) {
|
||
if (!captured && captures(c.table, c.hands[who][index]).length) return false;
|
||
const before = [...c.table], [card] = c.hands[who].splice(index, 1);
|
||
if (captured) {
|
||
const ids = new Set(captured.map(a => a.id));
|
||
c.table = c.table.filter(a => !ids.has(a.id)); c.taken[who].push(card, ...captured); c.lastTaker = who;
|
||
} else c.table.push(card);
|
||
// L'ultima carta della smazzata non fa scopa.
|
||
const lastPlay = !c.stock.length && !c.hands.player.length && !c.hands.cpu.length;
|
||
const scopa = !!captured && !c.table.length && !lastPlay;
|
||
if (scopa) c.scope[who]++;
|
||
// `from` e `before` servono al disegno: da dove parte la carta e com'era la tavola prima della presa.
|
||
c.last = { who, card, captured: captured ?? [], scopa, from: index, before };
|
||
c.events.push({ kind: captured ? 'card-tap' : 'card-slide', who }, ...(scopa ? [{ kind: 'card-busso', who }] : []));
|
||
c.step = 'take'; c.t = 0;
|
||
if (who === 'player') c.selected = Math.min(c.selected, Math.max(0, c.hands.player.length - 1));
|
||
return true;
|
||
}
|
||
function after(c) {
|
||
c.current = other(c.last.who); c.t = 0; c.step = 'play';
|
||
if (c.hands.player.length || c.hands.cpu.length) return;
|
||
if (c.stock.length) { refill(c); return; }
|
||
// Fine smazzata: quel che resta in tavola va all'ultimo che ha preso.
|
||
if (c.lastTaker) c.taken[c.lastTaker].push(...c.table);
|
||
c.table = [];
|
||
const t = tally(c.taken, c.scope, c.deck);
|
||
c.score.player += t.points.player; c.score.cpu += t.points.cpu;
|
||
c.summary = { ...t, score: { ...c.score } }; c.t = 0;
|
||
// Il risultato è subito definitivo: uscire dal riepilogo non può cancellare una vittoria.
|
||
if (finished(c)) { c.step = 'result'; c.result = { winner: c.score.player > c.score.cpu ? 'player' : 'cpu', ...c.score }; }
|
||
else c.step = 'smazzata';
|
||
}
|
||
// Si va agli 11, contati a fine smazzata: vince chi ne ha di più; pari (o nessuno agli 11), se ne fa un'altra.
|
||
export const finished = c => Math.max(c.score.player, c.score.cpu) >= TARGET && c.score.player !== c.score.cpu;
|
||
// Dopo il riepilogo (resta finché Andrea non va avanti) si fa la smazzata dopo.
|
||
export function advance(c) {
|
||
if (c.step !== 'smazzata') return false;
|
||
c.dealer = other(c.dealer); deal(c);
|
||
return true;
|
||
}
|
||
|
||
// La sola porta d'ingresso dell'avversario: la sua mano, la tavola e le carte prese (si son viste tutte).
|
||
export function observation(c, who = 'cpu') {
|
||
return { who, deck: c.deck, hand: [...c.hands[who]], table: [...c.table], taken: { player: [...c.taken.player], cpu: [...c.taken.cpu] },
|
||
opponentCount: c.hands[other(who)].length, stock: c.stock.length, scope: { ...c.scope }, lastTaker: c.lastTaker };
|
||
}
|
||
// Le carte che non si sono viste: in mano all'altro o nel mazzo.
|
||
export function unseen(v) {
|
||
const seen = new Set([...v.hand, ...v.table, ...v.taken.player, ...v.taken.cpu].map(a => a.id));
|
||
return DECK_CARDS[v.deck].filter(a => !seen.has(a.id));
|
||
}
|
||
// Quanto vale una mossa: le carte prese (settebello, sette, mattoni, primiera, scopa) meno il rischio di lasciare
|
||
// una scopa all'altro. «Seria» il rischio lo stima a occhio; «A fassi male» conta quante carte di quel valore
|
||
// possono essere ancora in mano all'altro.
|
||
export function score(v, card, captured, counting) {
|
||
const coin = COIN[v.deck], last = !v.stock && v.hand.length === 1 && !v.opponentCount;
|
||
const left = captured ? v.table.filter(a => !captured.includes(a)) : [...v.table, card];
|
||
// La primiera vale per quanto migliora la propria: un 7 di un seme dove si ha già un 7 non aggiunge niente,
|
||
// la prima carta di un seme che manca aggiunge parecchio.
|
||
const mine = v.taken[v.who] ?? [], best = suit => Math.max(0, ...mine.filter(a => a.suit === suit).map(a => a.prime));
|
||
const prime = a => Math.max(0, a.prime - best(a.suit)) / 4 + (best(a.suit) ? 0 : 1);
|
||
const worth = a => 1 + (a.suit === coin ? 1.5 : 0) + (isSettebello(a, v.deck) ? 12 : 0) + prime(a);
|
||
let value = captured ? [card, ...captured].reduce((n, a) => n + worth(a), 0) + (!left.length && !last ? 20 : 0) : -worth(card) * 0.6;
|
||
const sum = left.reduce((n, a) => n + a.value, 0);
|
||
if (left.length && sum <= 10 && v.opponentCount) {
|
||
let p = 0.5;
|
||
if (counting) {
|
||
const pool = unseen(v), same = pool.filter(a => a.value === sum).length;
|
||
p = pool.length ? 1 - (1 - same / pool.length) ** v.opponentCount : 0;
|
||
}
|
||
value -= p * 20;
|
||
}
|
||
// Lasciare in tavola un 7 o il settebello vuol dire regalarli.
|
||
value -= left.filter(a => a.value === 7).length * (counting ? 1.5 : 0) + (left.some(a => isSettebello(a, v.deck)) ? 6 : 0);
|
||
return value;
|
||
}
|
||
export function moves(v) {
|
||
return v.hand.flatMap((card, index) => {
|
||
const opts = captures(v.table, card);
|
||
return opts.length ? opts.map((captured, option) => ({ index, option, captured })) : [{ index, option: null, captured: null }];
|
||
});
|
||
}
|
||
// «Alla bona» gioca a caso; «Seria» e «A fassi male» scelgono la mossa che vale di più.
|
||
// Taratura (tools/calibrate_scopa.mjs, 300 partite): Andrea vince 96% contro «Alla bona», 76% contro «Seria», 50% contro «A fassi male».
|
||
// A mazzo finito le carte dell'altro sono proprio quelle non viste: si calcola il finale esatto, fino al conteggio
|
||
// (carte, mattoni, settebello, primiera, scope, e la tavola all'ultimo che prende).
|
||
export function endgame(v) {
|
||
const me = v.who, them = other(me), memo = new Map();
|
||
const final = (taken, scope, table, last) => {
|
||
const all = { player: [...taken.player], cpu: [...taken.cpu] };
|
||
if (last) all[last].push(...table);
|
||
const t = tally(all, scope, v.deck);
|
||
return t.points[me] - t.points[them];
|
||
};
|
||
const solve = (hands, table, taken, scope, last, turn) => {
|
||
if (!hands.player.length && !hands.cpu.length) return final(taken, scope, table, last);
|
||
const key = `${turn}|${hands[me].map(a => a.id)}|${hands[them].map(a => a.id)}|${table.map(a => a.id).sort()}|${last}|${taken.player.length}|${scope.player}${scope.cpu}`;
|
||
if (memo.has(key)) return memo.get(key);
|
||
let best = turn === me ? -Infinity : Infinity;
|
||
for (const m of moves({ hand: hands[turn], table })) {
|
||
const r = step(hands, table, taken, scope, last, turn, m);
|
||
const value = solve(...r);
|
||
best = turn === me ? Math.max(best, value) : Math.min(best, value);
|
||
}
|
||
memo.set(key, best); return best;
|
||
};
|
||
const step = (hands, table, taken, scope, last, turn, m) => {
|
||
const card = hands[turn][m.index], rest = { ...hands, [turn]: hands[turn].filter((_, i) => i !== m.index) };
|
||
if (!m.captured) return [rest, [...table, card], taken, scope, last, other(turn)];
|
||
const ids = new Set(m.captured.map(a => a.id)), left = table.filter(a => !ids.has(a.id));
|
||
const end = !rest.player.length && !rest.cpu.length;
|
||
return [rest, left, { ...taken, [turn]: [...taken[turn], card, ...m.captured] },
|
||
!left.length && !end ? { ...scope, [turn]: scope[turn] + 1 } : scope, turn, other(turn)];
|
||
};
|
||
const hands = { [me]: v.hand, [them]: unseen(v) };
|
||
const start = [hands, v.table, v.taken, v.scope ?? { player: 0, cpu: 0 }, v.lastTaker ?? null, me];
|
||
return moves(v).map(m => ({ m, value: solve(...step(...start, m)) })).reduce((a, b) => b.value > a.value ? b : a).m;
|
||
}
|
||
export function choose(v, level = 'seria', seed = 1) {
|
||
const all = moves(v);
|
||
if (level === 'bona') return all[Math.floor(rng(seed)() * all.length)];
|
||
const counting = level === 'male';
|
||
if (counting && !v.stock && unseen(v).length === v.opponentCount) return endgame(v);
|
||
return all.reduce((a, b) => score(v, v.hand[b.index], b.captured, counting) > score(v, v.hand[a.index], a.captured, counting) ? b : a);
|
||
}
|
||
export function update(c, dt) {
|
||
if (!Number.isFinite(dt) || dt < 0 || c.step === 'result') return;
|
||
c.t += dt;
|
||
if (c.step === 'take' && c.t >= (c.last.captured.length ? TAKE_TIME : PLAY_TIME * 2)) after(c);
|
||
else if (c.step === 'play' && c.current === 'cpu' && c.t >= 0.75) {
|
||
c.aiSeed = lcg(c.aiSeed);
|
||
const m = choose(observation(c, 'cpu'), c.level, c.aiSeed);
|
||
play(c, m.index, 'cpu', m.option);
|
||
}
|
||
}
|
||
export function status(c, names = { player: 'Andrea', cpu: 'Il giocatore' }) {
|
||
if (c.step === 'result') return `${c.result.winner === 'player' ? 'Hai vinto' : `Vince ${names.cpu}`}, ${c.score.player} a ${c.score.cpu}!`;
|
||
if (c.step === 'smazzata') return `Smazzata finita: siamo ${c.score.player} a ${c.score.cpu}. Invio per continuare.`;
|
||
if (c.step === 'choose') return 'Più prese possibili: scegli quale (frecce o tocca una carta in tavola), Invio prende.';
|
||
if (c.step === 'take') {
|
||
const l = c.last;
|
||
return l.scopa ? `Scopa di ${names[l.who]}!` : l.captured.length ? `${names[l.who]} prende con ${cardName(l.card)}.` : `${names[l.who]} posa ${cardName(l.card)}.`;
|
||
}
|
||
// A parole anche la tavola, per chi non vede il disegno.
|
||
const table = `In tavola: ${c.table.map(cardName).join(', ') || 'niente'}.`;
|
||
return c.current === 'player' ? `${table} Tocca una carta per giocarla. Frecce o 1–2–3 scelgono, Invio gioca.` : `${table} ${names.cpu} pensa…`;
|
||
}
|