feat(SCOPONE-0009): complete iteration 0 dealer AI
This commit is contained in:
Giancarmine Salucci
343
src/game/ai.ts
343
src/game/ai.ts
@@ -1,5 +1,5 @@
|
||||
import { Card, GameState, PlayerIndex, Difficulty, PRIMIERA_VALUES, Suit, SUITS } from './types';
|
||||
import { findCaptures, canCapture, teamOf, applyMove, buildDeck, cloneState } from './engine';
|
||||
import { Card, GameState, PlayerIndex, Difficulty, PRIMIERA_VALUES, Suit, SUITS, DealerRelativeRole } from './types';
|
||||
import { findCaptures, canCapture, teamOf, applyMove, buildDeck, cloneState, getDealerRelativeRole } from './engine';
|
||||
import { CardTracker } from './card-tracker';
|
||||
|
||||
export interface AIMove {
|
||||
@@ -22,10 +22,59 @@ interface SearchProfile {
|
||||
batchSize: number;
|
||||
}
|
||||
|
||||
interface DealerRoleContext {
|
||||
role: DealerRelativeRole;
|
||||
onDealerSide: boolean;
|
||||
defendingDealerAdvantage: boolean;
|
||||
attackingDealerAdvantage: boolean;
|
||||
aggressionBias: number;
|
||||
controlBias: number;
|
||||
pairPreservingBias: number;
|
||||
parityBreakingBias: number;
|
||||
tablePressureBias: number;
|
||||
}
|
||||
|
||||
interface ParitySnapshot {
|
||||
unseenCounts: number[];
|
||||
oddResidue: boolean[];
|
||||
evenResidue: boolean[];
|
||||
}
|
||||
|
||||
const DEALER_ROLE_WEIGHTS: Record<DealerRelativeRole, Omit<DealerRoleContext, 'role' | 'onDealerSide' | 'defendingDealerAdvantage' | 'attackingDealerAdvantage'>> = {
|
||||
'first-hand': {
|
||||
aggressionBias: 1.28,
|
||||
controlBias: 0.9,
|
||||
pairPreservingBias: 0.88,
|
||||
parityBreakingBias: 1.26,
|
||||
tablePressureBias: 1.3,
|
||||
},
|
||||
'second-hand': {
|
||||
aggressionBias: 1,
|
||||
controlBias: 1.08,
|
||||
pairPreservingBias: 1.12,
|
||||
parityBreakingBias: 0.96,
|
||||
tablePressureBias: 1,
|
||||
},
|
||||
'third-hand': {
|
||||
aggressionBias: 1.16,
|
||||
controlBias: 0.94,
|
||||
pairPreservingBias: 0.94,
|
||||
parityBreakingBias: 1.16,
|
||||
tablePressureBias: 1.12,
|
||||
},
|
||||
dealer: {
|
||||
aggressionBias: 0.84,
|
||||
controlBias: 1.32,
|
||||
pairPreservingBias: 1.34,
|
||||
parityBreakingBias: 0.82,
|
||||
tablePressureBias: 0.78,
|
||||
},
|
||||
};
|
||||
|
||||
const SEARCH_PROFILES: Record<Difficulty, SearchProfile> = {
|
||||
beginner: { timeBudgetMs: 120, sampleCount: 0, maxDepth: 0, batchSize: 0 },
|
||||
advanced: { timeBudgetMs: 650, sampleCount: 0, maxDepth: 0, batchSize: 0 },
|
||||
master: { timeBudgetMs: 9800, sampleCount: 12, maxDepth: 6, batchSize: 2 },
|
||||
master: { timeBudgetMs: 4600, sampleCount: 10, maxDepth: 6, batchSize: 2 },
|
||||
};
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -72,18 +121,192 @@ function countValueInHand(hand: Card[], value: number): number {
|
||||
return n;
|
||||
}
|
||||
|
||||
function getDealerRoleContext(state: GameState, playerIdx: PlayerIndex): DealerRoleContext {
|
||||
const role = getDealerRelativeRole(state.dealer, playerIdx);
|
||||
const onDealerSide = role === 'dealer' || role === 'second-hand';
|
||||
return {
|
||||
role,
|
||||
onDealerSide,
|
||||
defendingDealerAdvantage: onDealerSide,
|
||||
attackingDealerAdvantage: !onDealerSide,
|
||||
...DEALER_ROLE_WEIGHTS[role],
|
||||
};
|
||||
}
|
||||
|
||||
function getParitySnapshot(
|
||||
tracker: CardTracker | undefined,
|
||||
myHand: Card[],
|
||||
table: Card[],
|
||||
): ParitySnapshot | null {
|
||||
if (!tracker) return null;
|
||||
|
||||
const unseenCounts = Array.from({ length: 11 }, () => 0);
|
||||
const oddResidue = Array.from({ length: 11 }, () => false);
|
||||
const evenResidue = Array.from({ length: 11 }, () => false);
|
||||
const summary = tracker.getValueParityResidueSummary(myHand, table);
|
||||
|
||||
for (const residue of summary) {
|
||||
unseenCounts[residue.value] = residue.unseenCount;
|
||||
oddResidue[residue.value] = residue.hasOddUnseenResidue;
|
||||
evenResidue[residue.value] = residue.hasEvenUnseenResidue;
|
||||
}
|
||||
|
||||
return { unseenCounts, oddResidue, evenResidue };
|
||||
}
|
||||
|
||||
function countParityValuesOnTable(afterTable: Card[], parity: ParitySnapshot | null): { oddValues: number; evenValues: number } {
|
||||
if (!parity || afterTable.length === 0) {
|
||||
return { oddValues: 0, evenValues: 0 };
|
||||
}
|
||||
|
||||
let oddValues = 0;
|
||||
let evenValues = 0;
|
||||
const seenValues = new Set<number>();
|
||||
|
||||
for (const card of afterTable) {
|
||||
if (seenValues.has(card.value)) continue;
|
||||
seenValues.add(card.value);
|
||||
if (parity.oddResidue[card.value]) oddValues++;
|
||||
else if (parity.evenResidue[card.value]) evenValues++;
|
||||
}
|
||||
|
||||
return { oddValues, evenValues };
|
||||
}
|
||||
|
||||
function scoreRoleTablePlan(
|
||||
afterTable: Card[],
|
||||
roleContext: DealerRoleContext,
|
||||
nextIsOpp: boolean,
|
||||
): number {
|
||||
if (afterTable.length === 0) return 0;
|
||||
|
||||
const tableSum = afterTable.reduce((sum, card) => sum + card.value, 0);
|
||||
let score = 0;
|
||||
|
||||
if (roleContext.role === 'first-hand') {
|
||||
if (afterTable.length >= 2) score += 22 * roleContext.tablePressureBias;
|
||||
if (tableSum >= 8 && tableSum <= 15) score += 18 * roleContext.aggressionBias;
|
||||
}
|
||||
|
||||
if (roleContext.role === 'third-hand') {
|
||||
if (afterTable.length >= 2) score += 14 * roleContext.tablePressureBias;
|
||||
if (tableSum >= 10) score += 10 * roleContext.aggressionBias;
|
||||
}
|
||||
|
||||
if (roleContext.role === 'second-hand') {
|
||||
if (nextIsOpp && tableSum >= 11) score += 16 * roleContext.controlBias;
|
||||
if (!nextIsOpp && tableSum <= 10) score += 10 * roleContext.tablePressureBias;
|
||||
}
|
||||
|
||||
if (roleContext.role === 'dealer') {
|
||||
if (tableSum >= 11) score += 28 * roleContext.controlBias;
|
||||
if (tableSum <= 10 && nextIsOpp) score -= 24 * roleContext.controlBias;
|
||||
if (afterTable.length === 1 && nextIsOpp) score -= 16 * roleContext.controlBias;
|
||||
}
|
||||
|
||||
return Math.round(score);
|
||||
}
|
||||
|
||||
function scoreParityTableState(
|
||||
afterTable: Card[],
|
||||
parity: ParitySnapshot | null,
|
||||
roleContext: DealerRoleContext,
|
||||
nextIsOpp: boolean,
|
||||
): number {
|
||||
const { oddValues, evenValues } = countParityValuesOnTable(afterTable, parity);
|
||||
if (oddValues === 0 && evenValues === 0) return 0;
|
||||
|
||||
let score = 0;
|
||||
if (roleContext.defendingDealerAdvantage) {
|
||||
score += evenValues * 18 * roleContext.controlBias;
|
||||
score -= oddValues * 22 * roleContext.controlBias;
|
||||
if (nextIsOpp) score += evenValues * 8 - oddValues * 10;
|
||||
} else {
|
||||
score += oddValues * 20 * roleContext.tablePressureBias;
|
||||
score -= evenValues * 10;
|
||||
if (nextIsOpp) score += oddValues * 12;
|
||||
}
|
||||
|
||||
return Math.round(score);
|
||||
}
|
||||
|
||||
function scoreCaptureParityPlan(
|
||||
played: Card,
|
||||
captured: Card[],
|
||||
afterTable: Card[],
|
||||
parity: ParitySnapshot | null,
|
||||
roleContext: DealerRoleContext,
|
||||
nextIsOpp: boolean,
|
||||
): number {
|
||||
if (!parity || captured.length === 0) return 0;
|
||||
|
||||
let score = 0;
|
||||
const directCapture = captured.length === 1 && captured[0].value === played.value;
|
||||
|
||||
if (directCapture) {
|
||||
const unseenCount = parity.unseenCounts[played.value] ?? 0;
|
||||
const base = parity.oddResidue[played.value] ? 58 : 30;
|
||||
score += base * roleContext.pairPreservingBias;
|
||||
if (roleContext.defendingDealerAdvantage && unseenCount > 0) score += 18 * roleContext.controlBias;
|
||||
} else {
|
||||
let parityBreaks = 0;
|
||||
let oddTargets = 0;
|
||||
const seenValues = new Set<number>();
|
||||
|
||||
for (const card of captured) {
|
||||
if (seenValues.has(card.value)) continue;
|
||||
seenValues.add(card.value);
|
||||
if ((parity.unseenCounts[card.value] ?? 0) > 0) parityBreaks++;
|
||||
if (parity.oddResidue[card.value]) oddTargets++;
|
||||
}
|
||||
|
||||
const disruption = parityBreaks * 20 + oddTargets * 18 + Math.max(0, captured.length - 1) * 12;
|
||||
score += disruption * roleContext.parityBreakingBias;
|
||||
if (roleContext.defendingDealerAdvantage) score -= 18 * roleContext.controlBias;
|
||||
}
|
||||
|
||||
score += scoreParityTableState(afterTable, parity, roleContext, nextIsOpp);
|
||||
return Math.round(score);
|
||||
}
|
||||
|
||||
function scoreDumpParityPlan(
|
||||
card: Card,
|
||||
afterTable: Card[],
|
||||
parity: ParitySnapshot | null,
|
||||
roleContext: DealerRoleContext,
|
||||
nextIsOpp: boolean,
|
||||
): number {
|
||||
if (!parity) return 0;
|
||||
|
||||
let score = scoreParityTableState(afterTable, parity, roleContext, nextIsOpp);
|
||||
if (parity.oddResidue[card.value]) {
|
||||
score += roleContext.attackingDealerAdvantage ? 18 * roleContext.tablePressureBias : -20 * roleContext.controlBias;
|
||||
}
|
||||
if (parity.evenResidue[card.value]) {
|
||||
score += roleContext.defendingDealerAdvantage ? 14 * roleContext.pairPreservingBias : 6;
|
||||
}
|
||||
|
||||
return Math.round(score);
|
||||
}
|
||||
|
||||
function getSearchProfile(state: GameState, difficulty: Difficulty): SearchProfile {
|
||||
if (difficulty !== 'master') return SEARCH_PROFILES[difficulty];
|
||||
|
||||
const cardsRemaining = state.players.reduce((sum, player) => sum + player.hand.length, 0);
|
||||
if (cardsRemaining <= 4) {
|
||||
return { timeBudgetMs: 3200, sampleCount: 4, maxDepth: cardsRemaining, batchSize: 1 };
|
||||
}
|
||||
if (cardsRemaining <= 6) {
|
||||
return { timeBudgetMs: 9800, sampleCount: 18, maxDepth: Math.min(cardsRemaining, 8), batchSize: 1 };
|
||||
return { timeBudgetMs: 3600, sampleCount: 6, maxDepth: cardsRemaining, batchSize: 1 };
|
||||
}
|
||||
if (cardsRemaining <= 8) {
|
||||
return { timeBudgetMs: 3900, sampleCount: 8, maxDepth: cardsRemaining, batchSize: 1 };
|
||||
}
|
||||
if (cardsRemaining <= 12) {
|
||||
return { timeBudgetMs: 9000, sampleCount: 16, maxDepth: 8, batchSize: 2 };
|
||||
return { timeBudgetMs: 4200, sampleCount: 8, maxDepth: 8, batchSize: 1 };
|
||||
}
|
||||
if (cardsRemaining <= 20) {
|
||||
return { timeBudgetMs: 8200, sampleCount: 14, maxDepth: 7, batchSize: 2 };
|
||||
return { timeBudgetMs: 4400, sampleCount: 9, maxDepth: 7, batchSize: 2 };
|
||||
}
|
||||
return SEARCH_PROFILES.master;
|
||||
}
|
||||
@@ -432,6 +655,8 @@ function advancedMove(state: GameState, playerIdx: PlayerIndex, tracker?: CardTr
|
||||
const table = state.table;
|
||||
const phase = gamePhase(state);
|
||||
const race = getRaceState(state, playerIdx);
|
||||
const roleContext = getDealerRoleContext(state, playerIdx);
|
||||
const parity = getParitySnapshot(tracker, player.hand, table);
|
||||
const next = nextPlayer(playerIdx);
|
||||
const nextIsOpp = isOpponent(playerIdx, next);
|
||||
const partner = partnerOf(playerIdx);
|
||||
@@ -447,14 +672,14 @@ function advancedMove(state: GameState, playerIdx: PlayerIndex, tracker?: CardTr
|
||||
for (const captureSet of captures) {
|
||||
const score = scoreCaptureAdv(
|
||||
card, captureSet, table, state, playerIdx, race,
|
||||
tracker, player.hand, phase, nextIsOpp, partnerHandSize, lastPlay,
|
||||
tracker, player.hand, phase, nextIsOpp, partnerHandSize, lastPlay, roleContext, parity,
|
||||
);
|
||||
if (score > bestScore) { bestScore = score; bestMove = { card, capture: captureSet }; }
|
||||
}
|
||||
} else {
|
||||
const score = scoreDumpAdv(
|
||||
card, table, state, playerIdx, race,
|
||||
tracker, player.hand, phase, nextIsOpp, partnerHandSize, lastPlay,
|
||||
tracker, player.hand, phase, nextIsOpp, partnerHandSize, lastPlay, roleContext, parity,
|
||||
);
|
||||
if (score > bestScore) { bestScore = score; bestMove = { card, capture: [] }; }
|
||||
}
|
||||
@@ -467,7 +692,7 @@ function scoreCaptureAdv(
|
||||
played: Card, captured: Card[], table: Card[], state: GameState,
|
||||
playerIdx: PlayerIndex, race: RaceState, tracker: CardTracker | undefined,
|
||||
myHand: Card[], phase: number, nextIsOpp: boolean, partnerHandSize: number,
|
||||
lastPlay: boolean,
|
||||
lastPlay: boolean, roleContext: DealerRoleContext, parity: ParitySnapshot | null,
|
||||
): number {
|
||||
let score = 100;
|
||||
const allCaptured = [played, ...captured];
|
||||
@@ -508,6 +733,8 @@ function scoreCaptureAdv(
|
||||
}
|
||||
}
|
||||
|
||||
score += scoreCaptureParityPlan(played, captured, afterTable, parity, roleContext, nextIsOpp);
|
||||
|
||||
// --- ANCHOR STRATEGY ---
|
||||
// Prefer captures that leave table cards matching values we hold (we can recapture)
|
||||
if (!isScopa) {
|
||||
@@ -543,6 +770,8 @@ function scoreCaptureAdv(
|
||||
}
|
||||
}
|
||||
|
||||
score += scoreRoleTablePlan(afterTable, roleContext, nextIsOpp);
|
||||
|
||||
// --- PARTNER COOPERATION ---
|
||||
const next = nextPlayer(playerIdx);
|
||||
if (!isScopa && !isOpponent(playerIdx, next)) {
|
||||
@@ -620,6 +849,14 @@ function scoreCaptureAdv(
|
||||
if (tableSum <= 5 && nextIsOpp) score -= 60;
|
||||
}
|
||||
|
||||
if (roleContext.role === 'first-hand' && !isScopa && afterTable.length >= 2) {
|
||||
score += Math.round(24 * roleContext.tablePressureBias);
|
||||
}
|
||||
if (roleContext.role === 'dealer' && !isScopa) {
|
||||
const tableSum = afterTable.reduce((s, c) => s + c.value, 0);
|
||||
if (tableSum >= 11) score += Math.round(30 * roleContext.controlBias);
|
||||
}
|
||||
|
||||
return score;
|
||||
}
|
||||
|
||||
@@ -627,7 +864,7 @@ function scoreDumpAdv(
|
||||
card: Card, table: Card[], state: GameState,
|
||||
playerIdx: PlayerIndex, race: RaceState, tracker: CardTracker | undefined,
|
||||
myHand: Card[], phase: number, nextIsOpp: boolean, partnerHandSize: number,
|
||||
lastPlay: boolean,
|
||||
lastPlay: boolean, roleContext: DealerRoleContext, parity: ParitySnapshot | null,
|
||||
): number {
|
||||
let score = 0;
|
||||
const afterTable = [...table, card];
|
||||
@@ -653,6 +890,8 @@ function scoreDumpAdv(
|
||||
const partnerProb = partnerLikelyHolds(card.value, playerIdx, state, tracker, myHand, table);
|
||||
if (partnerProb > 0.4) score += 55; // partner can recapture what we dump
|
||||
|
||||
score += scoreDumpParityPlan(card, afterTable, parity, roleContext, nextIsOpp);
|
||||
|
||||
// --- ANTI-SCOPA ---
|
||||
if (tableSum >= 11) {
|
||||
score += 150;
|
||||
@@ -694,6 +933,8 @@ function scoreDumpAdv(
|
||||
score += 20; // safe dump before partner's turn, signals we don't need this suit
|
||||
}
|
||||
|
||||
score += scoreRoleTablePlan(afterTable, roleContext, nextIsOpp);
|
||||
|
||||
// --- CARD TRACKING ---
|
||||
if (tracker) {
|
||||
const unseen = tracker.getUnseenCards(myHand, afterTable);
|
||||
@@ -729,6 +970,13 @@ function scoreDumpAdv(
|
||||
if (card.value >= 8) score += 15;
|
||||
}
|
||||
|
||||
if (roleContext.role === 'first-hand' && afterTable.length >= 2 && tableSum >= 8) {
|
||||
score += Math.round(18 * roleContext.tablePressureBias);
|
||||
}
|
||||
if (roleContext.role === 'dealer' && nextIsOpp && tableSum <= 10) {
|
||||
score -= Math.round(24 * roleContext.controlBias);
|
||||
}
|
||||
|
||||
return score;
|
||||
}
|
||||
|
||||
@@ -744,6 +992,8 @@ function tableControlPressure(
|
||||
tracker: CardTracker | undefined,
|
||||
myHand: Card[],
|
||||
race: RaceState,
|
||||
roleContext: DealerRoleContext,
|
||||
parity: ParitySnapshot | null,
|
||||
): number {
|
||||
if (afterTable.length === 0) return 0;
|
||||
|
||||
@@ -790,6 +1040,8 @@ function tableControlPressure(
|
||||
}
|
||||
|
||||
if (race.aheadOverall && nextIsOpp && tableSum <= 10) score -= 60;
|
||||
score += scoreRoleTablePlan(afterTable, roleContext, nextIsOpp);
|
||||
score += scoreParityTableState(afterTable, parity, roleContext, nextIsOpp);
|
||||
return score;
|
||||
}
|
||||
|
||||
@@ -814,9 +1066,11 @@ async function masterMove(
|
||||
// Quick-eval move ordering for better pruning
|
||||
const lastPlay = isLastPlay(state, playerIdx);
|
||||
const race = getRaceState(state, playerIdx);
|
||||
const roleContext = getDealerRoleContext(state, playerIdx);
|
||||
const parity = getParitySnapshot(tracker, state.players[playerIdx].hand, state.table);
|
||||
const quickScored = legalMoves.map(m => ({
|
||||
move: m,
|
||||
quick: quickEval(m, state, playerIdx, tracker, lastPlay, race),
|
||||
quick: quickEval(m, state, playerIdx, tracker, lastPlay, race, roleContext, parity),
|
||||
}));
|
||||
quickScored.sort((a, b) => b.quick - a.quick);
|
||||
const sortedMoves = quickScored.map(qs => qs.move);
|
||||
@@ -891,15 +1145,19 @@ function quickEval(
|
||||
move: AIMove, state: GameState, playerIdx: PlayerIndex,
|
||||
tracker: CardTracker | undefined, lastPlay: boolean,
|
||||
race: RaceState,
|
||||
roleContext: DealerRoleContext,
|
||||
parity: ParitySnapshot | null,
|
||||
): number {
|
||||
let score = 0;
|
||||
const table = state.table;
|
||||
const afterTable = table.filter(c => !move.capture.some(cc => cc.id === c.id));
|
||||
const afterCaptureTable = table.filter(c => !move.capture.some(cc => cc.id === c.id));
|
||||
const projectedTable = move.capture.length > 0 ? afterCaptureTable : [...afterCaptureTable, move.card];
|
||||
const projectedHand = state.players[playerIdx].hand.filter(card => card.id !== move.card.id);
|
||||
const allCaptured = [move.card, ...move.capture];
|
||||
const nextIsOpp = isOpponent(playerIdx, nextPlayer(playerIdx));
|
||||
|
||||
// Scopa (not on last play!)
|
||||
if (move.capture.length > 0 && afterTable.length === 0) {
|
||||
if (move.capture.length > 0 && projectedTable.length === 0) {
|
||||
score += lastPlay ? 50 : 1200;
|
||||
}
|
||||
|
||||
@@ -924,21 +1182,35 @@ function quickEval(
|
||||
}
|
||||
|
||||
// Anti-scopa
|
||||
if (afterTable.length > 0) {
|
||||
const sum = afterTable.reduce((s, c) => s + c.value, 0);
|
||||
if (projectedTable.length > 0) {
|
||||
const sum = projectedTable.reduce((s, c) => s + c.value, 0);
|
||||
if (sum <= 10 && nextIsOpp) score -= 180;
|
||||
if (sum >= 11) score += 60;
|
||||
if (afterTable.length === 1 && nextIsOpp) score -= 120;
|
||||
if (projectedTable.length === 1 && nextIsOpp) score -= 120;
|
||||
}
|
||||
|
||||
// Partner awareness
|
||||
const next = nextPlayer(playerIdx);
|
||||
if (!isOpponent(playerIdx, next) && afterTable.length > 0) {
|
||||
const sum = afterTable.reduce((s, c) => s + c.value, 0);
|
||||
if (!isOpponent(playerIdx, next) && projectedTable.length > 0) {
|
||||
const sum = projectedTable.reduce((s, c) => s + c.value, 0);
|
||||
if (sum >= 1 && sum <= 10) score += 40; // partner might scopa
|
||||
}
|
||||
|
||||
score += tableControlPressure(afterTable, state, playerIdx, tracker, state.players[playerIdx].hand, race);
|
||||
score += scoreCaptureParityPlan(move.card, move.capture, projectedTable, parity, roleContext, nextIsOpp);
|
||||
if (move.capture.length === 0) {
|
||||
score += scoreDumpParityPlan(move.card, projectedTable, parity, roleContext, nextIsOpp);
|
||||
}
|
||||
|
||||
score += tableControlPressure(
|
||||
projectedTable,
|
||||
state,
|
||||
playerIdx,
|
||||
tracker,
|
||||
projectedHand,
|
||||
race,
|
||||
roleContext,
|
||||
parity,
|
||||
);
|
||||
|
||||
return score;
|
||||
}
|
||||
@@ -1036,20 +1308,22 @@ function alphaBeta(
|
||||
tracker: CardTracker | undefined,
|
||||
): number {
|
||||
if (depth === 0 || state.roundOver || Date.now() > deadline) {
|
||||
return evaluateFast(state, myTeam, phase);
|
||||
return evaluateFast(state, myTeam, phase, tracker, rootPlayer);
|
||||
}
|
||||
|
||||
const cur = state.currentPlayer;
|
||||
const isMyTeam = teamOf(cur) === myTeam;
|
||||
const moves = getLegalMoves(state, cur);
|
||||
|
||||
if (moves.length === 0) return evaluateFast(state, myTeam, phase);
|
||||
if (moves.length === 0) return evaluateFast(state, myTeam, phase, tracker, rootPlayer);
|
||||
|
||||
// Move ordering: settebello captures first, then scopa, then captures by size, then dumps
|
||||
if (moves.length > 2) {
|
||||
const race = getRaceState(state, cur);
|
||||
const lastPlay = isLastPlay(state, cur);
|
||||
moves.sort((a, b) => quickEval(b, state, cur, tracker, lastPlay, race) - quickEval(a, state, cur, tracker, lastPlay, race));
|
||||
const roleContext = getDealerRoleContext(state, cur);
|
||||
const parity = getParitySnapshot(tracker, state.players[rootPlayer].hand, state.table);
|
||||
moves.sort((a, b) => quickEval(b, state, cur, tracker, lastPlay, race, roleContext, parity) - quickEval(a, state, cur, tracker, lastPlay, race, roleContext, parity));
|
||||
}
|
||||
|
||||
if (isMyTeam) {
|
||||
@@ -1076,12 +1350,20 @@ function alphaBeta(
|
||||
}
|
||||
|
||||
/** Fast evaluation: avoids flatMap/filter at every leaf node */
|
||||
function evaluateFast(state: GameState, myTeam: 0 | 1, phase: number): number {
|
||||
function evaluateFast(
|
||||
state: GameState,
|
||||
myTeam: 0 | 1,
|
||||
phase: number,
|
||||
tracker: CardTracker | undefined,
|
||||
rootPlayer: PlayerIndex,
|
||||
): number {
|
||||
const p0 = state.players[0], p1 = state.players[1], p2 = state.players[2], p3 = state.players[3];
|
||||
const myA = myTeam === 0 ? p0 : p1;
|
||||
const myB = myTeam === 0 ? p2 : p3;
|
||||
const oppA = myTeam === 0 ? p1 : p0;
|
||||
const oppB = myTeam === 0 ? p3 : p2;
|
||||
const roleContext = getDealerRoleContext(state, state.currentPlayer);
|
||||
const parity = getParitySnapshot(tracker, state.players[rootPlayer].hand, state.table);
|
||||
|
||||
// Single-pass pile scan — no flatMap/filter allocations
|
||||
let myCards = 0, oppCards = 0;
|
||||
@@ -1204,6 +1486,21 @@ function evaluateFast(state: GameState, myTeam: 0 | 1, phase: number): number {
|
||||
// Good: table has cards we can capture
|
||||
score += state.table.length * 5;
|
||||
}
|
||||
|
||||
const parityPressure = scoreParityTableState(state.table, parity, roleContext, !myTurn);
|
||||
score += myTurn ? parityPressure : -parityPressure;
|
||||
|
||||
const rolePlan = scoreRoleTablePlan(state.table, roleContext, !myTurn);
|
||||
score += myTurn ? rolePlan : -rolePlan;
|
||||
|
||||
if (parity) {
|
||||
const { oddValues, evenValues } = countParityValuesOnTable(state.table, parity);
|
||||
if (roleContext.defendingDealerAdvantage) {
|
||||
score += (myTurn ? evenValues : -oddValues) * 14;
|
||||
} else {
|
||||
score += (myTurn ? oddValues : -evenValues) * 14;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return score;
|
||||
|
||||
Reference in New Issue
Block a user