Treat saves past finessed players as still urgent. (#303)

- Treat saves past finessed players as still urgent. This allows saving critical cards while allowing following players to play into their finesses. Fixes #273.
- Improves symmetry in detecting urgent actions.
- Use inspect in test-utils which can handle circular references.

Author: flackr

.vscode/settings.json

@@ -4,7 +4,7 @@
 	"editor.detectIndentation": false,
 	"eslint.format.enable": true,
 	"editor.codeActionsOnSave": {
-		"source.fixAll.eslint": true
+		"source.fixAll.eslint": "explicit"
 	},
 	// Never trim trailing whitespace in js files, because we allow trailing
 	// whitespace in comments

src/conventions/h-group/clue-finder/determine-clue.js

@@ -33,6 +33,10 @@ export function evaluate_clue(game, action, clue, target, target_card, bad_touch
 	logger.highlight('green', `------- ENTERING HYPO ${logClue(clue)} --------`);
 
 	const hypo_game = game.simulate_clue(action, { enableLogs: true });
+	// This is emulating the needed side effects of handle_action for a clue action.
+	// It might be simpler to call handle_action on the hypo_game.
+	hypo_game.last_actions[action.giver] = action;
+	hypo_game.handle_action({ type: 'turn', num: hypo_game.state.turn_count, currentPlayerIndex: hypo_game.state.nextPlayerIndex(hypo_game.state.ourPlayerIndex) }, true);
 
 	logger.highlight('green', '------- EXITING HYPO --------');
 
@@ -44,55 +48,66 @@ export function evaluate_clue(game, action, clue, target, target_card, bad_touch
 	/** @type {string} */
 	let reason;
 
-	for (const { order, clued } of state.hands[target]) {
-		const card = hypo_game.common.thoughts[order];
-		const visible_card = state.deck[order];
+	const get_finessed_cards = (game) => {
+		return game.state.hands[action.giver].filter(c => !game.common.thoughts[c.order].clued && game.common.thoughts[c.order].finessed);
+	};
+
+	const finessed_before_clue = get_finessed_cards(game);
+	const finessed_after_clue = get_finessed_cards(hypo_game);
+	const lost_finesse = finessed_before_clue.filter(c => finessed_after_clue.find(other => other.order == c.order) === undefined);
+	if (lost_finesse.length > 0) {
+		reason = `cards ${lost_finesse.map(c => logCard(state.deck[c.order])).join(', ')} lost finesse`;
+	} else {
+		for (const { order, clued } of state.hands[target]) {
+			const card = hypo_game.common.thoughts[order];
+			const visible_card = state.deck[order];
+
+			// The focused card must not have been reset and must match inferences
+			if (order === target_card.order) {
+				if (card.reset) {
+					reason = `card ${logCard(state.deck[card.order])} ${card.order} lost all inferences and was reset`;
+					break;
+				}
+
+				if (!card.inferred.has(visible_card)) {
+					reason = `card ${logCard(visible_card)} has inferences [${card.inferred.map(logCard).join(',')}]`;
+					break;
+				}
+				continue;
+			}
+
+			const old_card = game.common.thoughts[order];
+
+			const allowable_trash = card.chop_moved ||													// Chop moved (might have become trash)
+				old_card.reset || !state.hasConsistentInferences(old_card) || old_card.inferred.length === 0 ||	// Didn't match inference even before clue
+				(clued && isTrash(state, game.me, visible_card, order, { infer: true })) ||				// Previously-clued duplicate or recently became basic trash
+				bad_touch_cards.some(b => b.order === order) ||											// Bad touched
+				card.possible.every(id => isTrash(hypo_game.state, hypo_game.common, id, order, { infer: true }));		// Known trash
+
+			if (allowable_trash || card.possible.length === 1)
+				continue;
 
-		// The focused card must not have been reset and must match inferences
-		if (order === target_card.order) {
+			const id = card.identity({ infer: true });
+
+			// For non-focused cards:
 			if (card.reset) {
 				reason = `card ${logCard(state.deck[card.order])} ${card.order} lost all inferences and was reset`;
 				break;
 			}
 
-			if (!card.inferred.has(visible_card)) {
-				reason = `card ${logCard(visible_card)} has inferences [${card.inferred.map(logCard).join(',')}]`;
+			if (id !== undefined && !visible_card.matches(id)) {
+				reason = `card ${logCard(visible_card)} incorrectly inferred to be ${logCard(id)}`;
 				break;
 			}
-			continue;
-		}
-
-		const old_card = game.common.thoughts[order];
-
-		const allowable_trash = card.chop_moved ||													// Chop moved (might have become trash)
-			old_card.reset || !state.hasConsistentInferences(old_card) || old_card.inferred.length === 0 ||	// Didn't match inference even before clue
-			(clued && isTrash(state, game.me, visible_card, order, { infer: true })) ||				// Previously-clued duplicate or recently became basic trash
-			bad_touch_cards.some(b => b.order === order) ||											// Bad touched
-			card.possible.every(id => isTrash(hypo_game.state, hypo_game.common, id, order, { infer: true }));		// Known trash
 
-		if (allowable_trash || card.possible.length === 1)
-			continue;
+			const looks_playable = hypo_game.common.unknown_plays.has(order) ||
+				hypo_game.common.hypo_stacks[visible_card.suitIndex] >= visible_card.rank ||
+				card.inferred.every(i => i.rank <= hypo_game.common.hypo_stacks[i.suitIndex] + 1);
 
-		const id = card.identity({ infer: true });
-
-		// For non-focused cards:
-		if (card.reset) {
-			reason = `card ${logCard(state.deck[card.order])} ${card.order} lost all inferences and was reset`;
-			break;
-		}
-
-		if (id !== undefined && !visible_card.matches(id)) {
-			reason = `card ${logCard(visible_card)} incorrectly inferred to be ${logCard(id)}`;
-			break;
-		}
-
-		const looks_playable = hypo_game.common.unknown_plays.has(order) ||
-			hypo_game.common.hypo_stacks[visible_card.suitIndex] >= visible_card.rank ||
-			card.inferred.every(i => i.rank <= hypo_game.common.hypo_stacks[i.suitIndex] + 1);
-
-		if (looks_playable && !card.inferred.has(visible_card)) {
-			reason = `card ${logCard(visible_card)} looks incorrectly playable with inferences [${card.inferred.map(logCard).join(',')}]`;
-			break;
+			if (looks_playable && !card.inferred.has(visible_card)) {
+				reason = `card ${logCard(visible_card)} looks incorrectly playable with inferences [${card.inferred.map(logCard).join(',')}]`;
+				break;
+			}
 		}
 	}
 

src/conventions/h-group/clue-interpretation/interpret-clue.js

@@ -14,6 +14,7 @@ import * as Utils from '../../../tools/util.js';
 
 import logger from '../../../tools/logger.js';
 import { logCard, logConnection, logConnections, logHand } from '../../../tools/log.js';
+import { IdentitySet } from '../../../basics/IdentitySet.js';
 
 /**
  * @typedef {import('../../h-group.js').default} Game
@@ -250,9 +251,52 @@ export function interpret_clue(game, action) {
 	if (chop) {
 		focus_thoughts.chop_when_first_clued = true;
 
-		// A save is important if no one else could have given the save.
-		if (!old_focus_thoughts.saved && focus_thoughts.saved && (giver + 1) % state.numPlayers == target && !common.thinksLoaded(state, target, {assume: false}))
-			action.important = true;
+		// Check whether this is an urgent save.
+		if (!old_focus_thoughts.saved && focus_thoughts.saved && !common.thinksLoaded(state, target, {assume: false})) {
+			const hypo_game = game.minimalCopy();
+			const hypo_state = hypo_game.state;
+			let played = new IdentitySet(state.variant.suits.length);
+
+			const get_finessed_card = (index) => {
+				// Find the finessed card with the lowest finesse_index.
+				let result = undefined;
+				for (const c of hypo_state.hands[index]) {
+					const card = hypo_game.common.thoughts[c.order];
+					if (!card.finessed || result !== undefined && card.finesse_index > result.finesse_index)
+						continue;
+					result = card;
+				}
+				// Only return the card if it is thought to currently be playable.
+				if (!result || result.inferred.some(id => !played.has(id) && !hypo_state.isPlayable(id)))
+					return undefined;
+				return result;
+			};
+
+			// If there is at least one player without a finessed play between the giver and target, the save was not urgent.
+			let urgent = true;
+			let playerIndex = giver;
+
+			while (playerIndex !== target) {
+				const finessed_play = get_finessed_card(playerIndex);
+				if (!finessed_play) {
+					urgent = false;
+					break;
+				}
+
+				// If we know what the card is, update the play stacks. If we don't, then
+				// we can't know if playing it would make someone else's cards playable.
+				const card = hypo_game.common.thoughts[finessed_play.order].identity({infer: true});
+				if (card !== undefined) {
+					played = played.union(card);
+					hypo_state.play_stacks[card.suitIndex]++;
+				}
+
+				playerIndex = (playerIndex + 1) % state.numPlayers;
+			}
+
+			if (urgent)
+				action.important = true;
+		}
 	}
 
 	if (focus_thoughts.inferred.length === 0 && oldCommon.thoughts[focused_card.order].possible.length > 1) {

src/conventions/h-group/take-action.js

@@ -178,32 +178,21 @@ export function take_action(game) {
 		logger.info('discards', logHand(discards));
 
 	const playable_priorities = determine_playable_card(game, playable_cards);
-	const urgent_actions = find_urgent_actions(game, play_clues, save_clues, fix_clues, stall_clues, playable_priorities);
-
-	if (urgent_actions.some(actions => actions.length > 0))
-		logger.info('all urgent actions', urgent_actions.flatMap((actions, index) => actions.map(action => ({ [index]: logPerformAction(action) }))));
 
 	const actionPrioritySize = Object.keys(ACTION_PRIORITY).length;
 	const { priority, best_playable_card } = playable_priorities.some(playables => playables.length > 0) ?
 		find_best_playable(game, playable_cards, playable_priorities) :
 		{ priority: -1, best_playable_card: undefined };
+	const is_finessed = playable_cards.length > 0 && priority === 0;
 
-	// If we have a finesse
-	if (playable_cards.length > 0 && priority === 0) {
-		// Bluffs should never be deferred as they can lead to significant desync with human players
-		if (playable_cards.some(c => common.thoughts[c.order].bluffed))
-			return { tableID, type: ACTION.PLAY, target: best_playable_card.order };
+	// Bluffs should never be deferred as they can lead to significant desync with human players
+	if (is_finessed && playable_cards.some(c => common.thoughts[c.order].bluffed))
+		return { tableID, type: ACTION.PLAY, target: best_playable_card.order };
 
-		// Before playing a finesse, look for any urgent saves.
-		// TODO: We should be able to delay a finesse for any urgent action. This will require
-		// the other players being able to recognize the urgent action in update-turn.js.
-		const save_action = urgent_actions[ACTION_PRIORITY.ONLY_SAVE].find(action => (action.type === ACTION.RANK || action.type === ACTION.COLOUR) && action.target == nextPlayerIndex);
-		if (save_action)
-			return save_action;
+	const urgent_actions = find_urgent_actions(game, play_clues, save_clues, fix_clues, stall_clues, playable_priorities, is_finessed ? best_playable_card : undefined);
 
-		// If no urgent saves, play into the finesse
-		return { tableID, type: ACTION.PLAY, target: best_playable_card.order };
-	}
+	if (urgent_actions.some(actions => actions.length > 0))
+		logger.info('all urgent actions', urgent_actions.flatMap((actions, index) => actions.map(action => ({ [index]: logPerformAction(action) }))));
 
 	// Unlock next player
 	if (urgent_actions[ACTION_PRIORITY.UNLOCK].length > 0)
@@ -217,6 +206,10 @@ export function take_action(game) {
 			return action;
 	}
 
+	// If we have a finesse and there were no actions urgent enough to delay a finesse, play into the finesse.
+	if (is_finessed)
+		return { tableID, type: ACTION.PLAY, target: best_playable_card.order };
+
 	const discardable = trash_cards[0] ?? common.chop(state.hands[state.ourPlayerIndex]);
 
 	if (state.clue_tokens === 0 && state.numPlayers > 2 && discardable !== undefined) {

src/conventions/h-group/urgent-actions.js

@@ -11,6 +11,7 @@ import * as Utils from '../../tools/util.js';
 
 import logger from '../../tools/logger.js';
 import { logClue } from '../../tools/log.js';
+import { ActualCard } from '../../basics/Card.js';
 
 /**
  * @typedef {import('../h-group.js').default} Game
@@ -187,8 +188,9 @@ export function early_game_clue(game, playerIndex) {
  * @param {FixClue[][]} fix_clues
  * @param {Clue[][]} stall_clues
  * @param {Card[][]} playable_priorities
+ * @param {ActualCard} finessed_card
  */
-export function find_urgent_actions(game, play_clues, save_clues, fix_clues, stall_clues, playable_priorities) {
+export function find_urgent_actions(game, play_clues, save_clues, fix_clues, stall_clues, playable_priorities, finessed_card) {
 	const { common, me, state, tableID } = game;
 	const prioritySize = Object.keys(PRIORITY).length;
 	const urgent_actions = /** @type {PerformAction[][]} */ (Array.from({ length: prioritySize * 2 + 1 }, _ => []));
@@ -216,19 +218,19 @@ export function find_urgent_actions(game, play_clues, save_clues, fix_clues, sta
 		// They are locked, we should try to unlock
 		if (common.thinksLocked(state, target)) {
 			const unlock_order = find_unlock(game, target);
-			if (unlock_order !== undefined) {
+			if (unlock_order !== undefined && (!finessed_card || finessed_card.order == unlock_order)) {
 				urgent_actions[PRIORITY.UNLOCK + nextPriority].push({ tableID, type: ACTION.PLAY, target: unlock_order });
 				continue;
 			}
 
 			const play_over_save = find_play_over_save(game, target, play_clues.flat());
-			if (play_over_save !== undefined) {
+			if (!finessed_card && play_over_save !== undefined) {
 				urgent_actions[PRIORITY.PLAY_OVER_SAVE + nextPriority].push(play_over_save);
 				continue;
 			}
 
 			const trash_fixes = fix_clues[target].filter(clue => clue.trash);
-			if (trash_fixes.length > 0) {
+			if (!finessed_card && trash_fixes.length > 0) {
 				const trash_fix = Utils.maxOn(trash_fixes, ({ result }) => find_clue_value(result));
 				urgent_actions[PRIORITY.TRASH_FIX + nextPriority].push(Utils.clueToAction(trash_fix, tableID));
 				continue;
@@ -254,7 +256,7 @@ export function find_urgent_actions(game, play_clues, save_clues, fix_clues, sta
 			// Try to see if they have a playable card that connects directly through our hand
 			// Although this is only optimal for the next player, it is often a "good enough" action for future players.
 			const unlock_order = find_unlock(game, target);
-			if (unlock_order !== undefined) {
+			if (unlock_order !== undefined && (!finessed_card || finessed_card.order == unlock_order)) {
 				urgent_actions[PRIORITY.UNLOCK + nextPriority].push({ tableID, type: ACTION.PLAY, target: unlock_order });
 				continue;
 			}
@@ -263,14 +265,14 @@ export function find_urgent_actions(game, play_clues, save_clues, fix_clues, sta
 
 			// Give them a fix clue with known trash if possible (TODO: Re-examine if this should only be urgent fixes)
 			const trash_fixes = fix_clues[target].filter(clue => clue.trash);
-			if (trash_fixes.length > 0) {
+			if (!finessed_card && trash_fixes.length > 0) {
 				const trash_fix = Utils.maxOn(trash_fixes, ({ result }) => find_clue_value(result));
 				urgent_actions[PRIORITY.TRASH_FIX + nextPriority].push(Utils.clueToAction(trash_fix, tableID));
 				continue;
 			}
 
 			// Check if Order Chop Move is available - 4 (unknown card) must be highest priority, they must be 1s, and this cannot be a playable save
-			if (game.level >= LEVEL.BASIC_CM &&
+			if (!finessed_card && game.level >= LEVEL.BASIC_CM &&
 				playable_priorities.every((cards, priority) => priority >= 4 || cards.length === 0) &&
 				!save.playable
 			) {
@@ -301,7 +303,7 @@ export function find_urgent_actions(game, play_clues, save_clues, fix_clues, sta
 			}
 
 			// Check if Scream/Shout Discard is available (only to next player)
-			if (game.level >= LEVEL.LAST_RESORTS && playable_priorities.some(p => p.length > 0) && target === state.nextPlayerIndex(state.ourPlayerIndex)) {
+			if (!finessed_card && game.level >= LEVEL.LAST_RESORTS && playable_priorities.some(p => p.length > 0) && target === state.nextPlayerIndex(state.ourPlayerIndex)) {
 				const trash = me.thinksTrash(state, state.ourPlayerIndex).filter(c => c.clued && me.thoughts[c.order].inferred.every(i => state.isBasicTrash(i)));
 
 				if (trash.length > 0) {
@@ -371,7 +373,7 @@ export function find_urgent_actions(game, play_clues, save_clues, fix_clues, sta
 		}
 
 		// They require a fix clue
-		if (fix_clues[target].length > 0) {
+		if (!finessed_card && fix_clues[target].length > 0) {
 			const urgent_fixes = fix_clues[target].filter(clue => clue.urgent);
 
 			// Urgent fix on the next player is particularly urgent, but we should prioritize urgent fixes for others too

test/extra-asserts.js

@@ -1,4 +1,5 @@
 import { strict as assert } from 'node:assert';
+import { inspect } from 'node:util';
 import { expandShortCard } from './test-utils.js';
 import * as Utils from '../src/tools/util.js';
 import { logCard } from '../src/tools/log.js';
@@ -38,7 +39,7 @@ export function cardHasPossibilities(card, possibilities, message) {
  * @param  {string | Error} 		 [message]		The error message if the assertion fails.
  */
 export function objHasProperties(obj, properties, message) {
-	assert.ok(typeof obj === 'object', `Object (${JSON.stringify(obj)}) is not of type 'object'.`);
+	assert.ok(typeof obj === 'object', `Object (${inspect(obj)}) is not of type 'object'.`);
 	assert.ok(typeof properties === 'object', `Properties (${JSON.stringify(properties)} is not of type 'object'.`);
 
 	assert.deepEqual(Utils.objPick(obj, Object.keys(properties)), properties, message);

test/h-group/level-4.js

@@ -107,7 +107,7 @@ describe('trash chop move', () => {
 
 		const { play_clues, save_clues, fix_clues, stall_clues } = find_clues(game);
 		const playable_priorities = determine_playable_card(game, game.me.thinksPlayables(game.state, PLAYER.ALICE));
-		const urgent_actions = find_urgent_actions(game, play_clues, save_clues, fix_clues, stall_clues, playable_priorities);
+		const urgent_actions = find_urgent_actions(game, play_clues, save_clues, fix_clues, stall_clues, playable_priorities, undefined);
 
 		assert.deepEqual(urgent_actions[PRIORITY.ONLY_SAVE], []);
 		ExAsserts.objHasProperties(urgent_actions[PRIORITY.PLAY_OVER_SAVE][0], { type: ACTION.COLOUR, value: 1 });