Clue finding improvements, crash fixes (v1.4.12)

- Fixed a hypo stack-related regression that caused crashes.
- Fixed the clue finding algorithm to be more symmetric, no longer gives bad stall clues (fixes #278, fixes #285).
- Now connects on promised links (fixes #270).
- Now writes trash on cards from a TCM (fixes #271).
- No longer performs Shout Discards with non-basic trash (fixes #272).
- Fixes a bug where it thought a card was prompted when it was playable when finding own finesses (fixes #289).
- Correctly re-interprets clues that reveal a hidden/layered finesse.
- Allows giving plays over saves where the play clue would touch all cards needing to be saved.
- Now urgently plays into cards part of a finesse (even if they were previously clued).
- Fixed a bug that occasionally caused it to give clues containing a finesse that duplicated clued cards.

Author: WillFlame14

src/action-handler.js

@@ -138,22 +138,27 @@ export function handle_action(action, catchup = false) {
 			break;
 		}
 		case 'identify': {
-			const { order, playerIndex, suitIndex, rank, infer = false } = action;
+			const { order, playerIndex, identities, infer = false } = action;
 			const card = this.common.thoughts[order];
 
 			if (state.hands[playerIndex].findOrder(order) === undefined)
 				throw new Error('Could not find card to rewrite!');
 
-			logger.info(`identifying card with order ${order} as ${logCard({ suitIndex, rank })}, infer? ${infer}`);
+			logger.info(`identifying card with order ${order} as ${identities.map(logCard)}, infer? ${infer}`);
 
 			if (!infer) {
-				Object.assign(card, { suitIndex, rank });
-				Object.assign(this.me.thoughts[order], { suitIndex, rank });
-				Object.assign(state.hands[playerIndex].findOrder(order), { suitIndex, rank });
-				Object.assign(state.deck[order], { suitIndex, rank });
+				if (identities.length === 1) {
+					Object.assign(card, identities[0]);
+					Object.assign(this.me.thoughts[order], identities[0]);
+					Object.assign(state.hands[playerIndex].findOrder(order), identities[0]);
+					Object.assign(state.deck[order], identities[0]);
+				}
+				else {
+					card.rewind_ids = identities;
+				}
 			}
 			else {
-				card.inferred = card.inferred.intersect({ suitIndex, rank });
+				card.inferred = card.inferred.intersect(identities);
 			}
 			card.rewinded = true;
 			team_elim(this);

src/basics/Card.js

@@ -106,6 +106,12 @@ export class Card extends BasicCard {
 	 */
 	inferred;
 
+	/**
+	 * All possibilities of the card (from future information)
+	 * @type {Identity[] | undefined}
+	 */
+	rewind_ids;
+
 	/**
 	 * Only used when undoing a finesse.
 	 * @type {IdentitySet | undefined}
@@ -123,6 +129,7 @@ export class Card extends BasicCard {
 	hidden = false;
 	called_to_discard = false;
 	certain_finessed = false;
+	trash = false;
 
 	finesse_index = -1;	// Action index of when the card was finessed
 	reasoning = /** @type {number[]} */ ([]);		// The action indexes of when the card's possibilities/inferences were updated
@@ -148,9 +155,9 @@ export class Card extends BasicCard {
 			rank: this.rank
 		});
 
-		for (const field of ['inferred', 'possible', 'old_inferred', 'focused',
+		for (const field of ['inferred', 'possible', 'rewind_ids', 'old_inferred', 'focused',
 			'finessed', 'bluffed', 'chop_moved', 'reset', 'chop_when_first_clued', 'superposition',
-			'hidden', 'called_to_discard', 'certain_finessed','finesse_index', 'rewinded'])
+			'hidden', 'called_to_discard', 'certain_finessed', 'trash', 'finesse_index', 'rewinded'])
 			new_card[field] = this[field];
 
 		for (const field of ['reasoning', 'reasoning_turn'])

src/basics/Game.js

@@ -181,8 +181,9 @@ export class Game {
 	 * @param {number} action_index
 	 * @param {Action} rewind_action	The rewind action to insert before the target action
 	 * @param {boolean} [mistake] 		Whether the target action was a mistake
+	 * @param {boolean} [ephemeral]		Whether the action should be saved in the action list
 	 */
-	rewind(action_index, rewind_action, mistake = false) {
+	rewind(action_index, rewind_action, mistake = false, ephemeral = false) {
 		const { actionList } = this.state;
 
 		this.rewinds++;
@@ -257,6 +258,8 @@ export class Game {
 
 		// Rewrite and save as a rewind action
 		newGame.handle_action(rewind_action, true);
+		if (ephemeral)
+			newGame.state.actionList.pop();
 		newGame.handle_action(pivotal_action, true);
 
 		// Redo all the following actions

src/basics/IdentitySet.js

@@ -96,6 +96,10 @@ export class IdentitySet {
 		return this.#array;
 	}
 
+	clone() {
+		return new IdentitySet(this.numSuits, this.value);
+	}
+
 	/**
 	 * @template T
 	 * @param {(i: BasicCard) => T} func

src/basics/Player.js

@@ -126,7 +126,7 @@ export class Player {
 					card.possible.some(p => state.play_stacks[p.suitIndex] + 1 < p.rank && p.rank <= state.max_ranks[p.suitIndex]) ||
 					Array.from(linked_orders).some(o => this.thoughts[o].focused && o !== c.order));
 
-			return !unsafe_linked &&
+			return !card.trash && !unsafe_linked &&
 				card.possibilities.every(p => (card.chop_moved ? state.isBasicTrash(p) : false) || state.isPlayable(p)) &&	// cm cards can ignore trash ids
 				card.possibilities.some(p => state.isPlayable(p)) &&	// Exclude empty case
 				((options?.assume ?? true) || !this.waiting_connections.some((wc, i1) =>
@@ -161,6 +161,9 @@ export class Player {
 			});
 
 		return Array.from(state.hands[playerIndex].filter(c => {
+			if (this.thoughts[c.order].trash)
+				return true;
+
 			const poss = this.thoughts[c.order].possibilities;
 
 			// Every possibility is trash or duplicated somewhere

src/basics/helper.js

@@ -37,7 +37,7 @@ export function team_elim(game) {
 
 			card.old_inferred = ccard.old_inferred;
 
-			for (const property of ['focused', 'finessed', 'chop_moved', 'reset', 'chop_when_first_clued', 'hidden', 'called_to_discard', 'finesse_index', 'rewinded', 'certain_finessed'])
+			for (const property of ['rewind_ids', 'focused', 'finessed', 'chop_moved', 'reset', 'chop_when_first_clued', 'hidden', 'called_to_discard', 'finesse_index', 'rewinded', 'certain_finessed', 'trash'])
 				card[property] = ccard[property];
 
 			card.reasoning = ccard.reasoning.slice();
@@ -82,8 +82,7 @@ export function checkFix(game, oldThoughts, clueAction) {
 		// There is a waiting connection that depends on this card
 		if (reset_order !== undefined) {
 			const reset_card = common.thoughts[reset_order];
-			const { suitIndex, rank } = reset_card.possible.array[0];
-			game.rewind(reset_card.drawn_index, { type: 'identify', order: reset_card.order, playerIndex: target, suitIndex, rank });
+			game.rewind(reset_card.drawn_index, { type: 'identify', order: reset_card.order, playerIndex: target, identities: [reset_card.possible.array[0].raw()] });
 			return;
 		}
 
@@ -96,7 +95,7 @@ export function checkFix(game, oldThoughts, clueAction) {
 			if (old_id !== undefined) {
 				infs_to_recheck.push(old_id);
 
-				common.hypo_stacks[old_id.suitIndex] = old_id.rank - 1;
+				common.hypo_stacks[old_id.suitIndex] = Math.min(common.hypo_stacks[old_id.suitIndex], old_id.rank - 1);
 				logger.info('setting hypo stacks to', common.hypo_stacks);
 
 				const id_hash = logCard(old_id);

src/basics/player-elim.js

@@ -211,6 +211,9 @@ export function good_touch_elim(state, only_self = false) {
 		for (const { order } of state.hands[i]) {
 			addToMaps(order);
 
+			if (this.thoughts[order].trash)
+				continue;
+
 			const card = this.thoughts[order];
 
 			if (card.inferred.length > 0 && card.inferred.some(inf => !state.isBasicTrash(inf)) && !card.certain_finessed) {

src/constants.js

@@ -1,5 +1,5 @@
 export const MAX_H_LEVEL = 11;
-export const BOT_VERSION = '1.4.11';
+export const BOT_VERSION = '1.4.12';
 
 export const ACTION =  /** @type {const} */ ({
 	PLAY: 0,

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

@@ -98,7 +98,7 @@ export function order_1s(state, player, cards) {
  * @param {ActualCard[]} playable_cards
  */
 export function determine_playable_card(game, playable_cards) {
-	const { state } = game;
+	const { common, state } = game;
 
 	/** @type {Card[][]} */
 	const priorities = [[], [], [], [], [], []];
@@ -108,7 +108,7 @@ export function determine_playable_card(game, playable_cards) {
 		const card = game.me.thoughts[order];
 
 		// Part of a finesse
-		if (card.finessed) {
+		if (card.finessed || common.dependentConnections(order).some(wc => wc.connections.some((conn, i) => i >= wc.conn_index && conn.type === 'finesse'))) {
 			priorities[state.numPlayers > 2 ? 0 : 1].push(card);
 			continue;
 		}

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

@@ -1,10 +1,9 @@
-import { CLUE } from '../../../constants.js';
 import { CLUE_INTERP, LEVEL } from '../h-constants.js';
 import { cardTouched } from '../../../variants.js';
 import { clue_safe } from './clue-safe.js';
 import { find_fix_clues } from './fix-clues.js';
 import { evaluate_clue, get_result } from './determine-clue.js';
-import { determine_focus, stall_severity, valuable_tempo_clue } from '../hanabi-logic.js';
+import { determine_focus, valuable_tempo_clue } from '../hanabi-logic.js';
 import { cardValue, isTrash, visibleFind } from '../../../basics/hanabi-util.js';
 import { find_clue_value } from '../action-helper.js';
 
@@ -160,9 +159,6 @@ export function find_clues(game, giver = game.state.ourPlayerIndex, early_exits
 			};
 			logger.info('result,', JSON.stringify(result_log), find_clue_value(Object.assign(result, { remainder })));
 
-			/** @type {typeof CLUE_INTERP[keyof typeof CLUE_INTERP]} */
-			let clue_interp;
-
 			if ((/** @type {any} */ ([CLUE_INTERP.SAVE, CLUE_INTERP.CM_5, CLUE_INTERP.CM_TRASH]).includes(hypo_game.moveHistory.at(-1).move))) {
 				if (chop && focused_card.rank === 2) {
 					const copies = visibleFind(state, player, focused_card);
@@ -174,72 +170,55 @@ export function find_clues(game, giver = game.state.ourPlayerIndex, early_exits
 					}
 				}
 
-				if (game.level < LEVEL.CONTEXT || clue.result.avoidable_dupe == 0) {
+				if (game.level < LEVEL.CONTEXT || clue.result.avoidable_dupe == 0)
 					saves.push(Object.assign(clue, { game: hypo_game, playable: playables.length > 0, cm: chop_moved, safe }));
-					clue_interp = CLUE_INTERP.SAVE;
-				}
-				else {
+				else
 					logger.highlight('yellow', `${logClue(clue)} save results in avoidable potential duplication`);
-				}
 			}
 
-			const focus_known_bluff = hypo_game.common.waiting_connections.some(c => {
-				return c.connections[0].bluff && c.focused_card.order == focused_card.order;
-			});
-			// Clues where the focus isn't playable but may be assumed playable or that cause chop moves aren't plays/stalls
-			if ((playables.length > 0 && !playables.some(({ card }) => card.order === focused_card.order) && !focus_known_bluff) ||
-				(playables.length === 0 && chop_moved.length > 0) ||
-				isTrash(state, player, focused_card, focused_card.order)) {
-				logger.highlight('yellow', 'invalid play clue');
+			if (!safe)
 				continue;
-			}
 
-			if (playables.length > 0) {
-				if (safe) {
-					const { tempo, valuable } = valuable_tempo_clue(game, clue, playables, focused_card);
+			switch (hypo_game.moveHistory.at(-1).move) {
+				case CLUE_INTERP.CM_TEMPO: {
+					const { tempo, valuable } = valuable_tempo_clue(game, clue, clue.result.playables, focused_card);
+
 					if (tempo && !valuable) {
+						logger.info('tempo clue chop move', logClue(clue));
 						stall_clues[1].push(clue);
-						clue_interp = CLUE_INTERP.CM_TEMPO;
-					}
-					else if (game.level < LEVEL.CONTEXT || clue.result.avoidable_dupe == 0) {
-						play_clues[target].push(clue);
-						clue_interp = CLUE_INTERP.PLAY;
 					}
 					else {
-						logger.highlight('yellow', `${logClue(clue)} results in avoidable potential duplication`);
+						logger.info('clue', logClue(clue), tempo, valuable);
 					}
+					break;
 				}
-				else {
-					logger.highlight('yellow', `${logClue(clue)} is an unsafe play clue`);
-				}
-			}
-			// Stall clues
-			else if (stall_severity(state, common, giver) > 0 && safe) {
-				if (clue.type === CLUE.RANK && clue.value === 5 && !focused_card.clued) {
+				case CLUE_INTERP.PLAY:
+					if (clue.result.playables.length === 0)
+						continue;
+
+					if (game.level < LEVEL.CONTEXT || clue.result.avoidable_dupe == 0)
+						play_clues[target].push(clue);
+					else
+						logger.highlight('yellow', `${logClue(clue)} results in avoidable potential duplication`);
+					break;
+
+				case CLUE_INTERP.STALL_5:
 					logger.info('5 stall', logClue(clue));
 					stall_clues[0].push(clue);
-					clue_interp = CLUE_INTERP.STALL_5;
-				}
-				else if (player.thinksLocked(state, giver) && chop) {
+					break;
+
+				case CLUE_INTERP.STALL_LOCKED:
 					logger.info('locked hand save', logClue(clue));
 					stall_clues[3].push(clue);
-					clue_interp = CLUE_INTERP.STALL_LOCKED;
-				}
-				else if (new_touched.length === 0) {
-					if (elim > 0) {
-						logger.info('fill in', logClue(clue));
-						stall_clues[2].push(clue);
-						clue_interp = CLUE_INTERP.STALL_FILLIN;
-					}
-					else {
-						logger.info('hard burn', logClue(clue));
-						stall_clues[5].push(clue);
-						clue_interp = CLUE_INTERP.STALL_BURN;
-					}
-				}
+					break;
+
+				case CLUE_INTERP.STALL_BURN:
+					logger.info('hard burn', logClue(clue));
+					stall_clues[5].push(clue);
+					break;
 			}
 
-			if (clue_interp !== undefined && early_exits(game, clue, clue_interp)) {
+			if (early_exits(game, clue, /** @type {typeof CLUE_INTERP[keyof typeof CLUE_INTERP]} */ (hypo_game.moveHistory.at(-1).move))) {
 				early_exit = true;
 				break;
 			}

src/conventions/h-group/clue-interpretation/connecting-cards.js

@@ -14,6 +14,7 @@ import { ActualCard } from '../../../basics/Card.js';
  * @typedef {import('../../../basics/Card.js').Card} Card
  * @typedef {import('../../../types.js').Connection} Connection
  * @typedef {import('../../../types.js').Identity} Identity
+ * @typedef {import('../../../types.js').Link} Link
  */
 
 /**
@@ -65,6 +66,23 @@ export function find_known_connecting(game, giver, identity, ignoreOrders = [],
 
 		if (globally_known)
 			return { type: 'known', reacting: playerIndex, card: globally_known, identities: [identity] };
+
+		/** @type {Link} */
+		let known_link;
+
+		const known_linked = state.hands[playerIndex].find(({ order }) => {
+			if (ignoreOrders.includes(order))
+				return false;
+
+			known_link = common.links.find(link =>
+				link.promised &&
+				link.identities.some(i => i.suitIndex === identity.suitIndex && i.rank === identity.rank) &&
+				link.cards.some(c => c.order === order));
+			return known_link !== undefined;
+		});
+
+		if (known_linked)
+			return { type: 'playable', reacting: playerIndex, card: known_linked, linked: known_link.cards, identities: [identity] };
 	}
 
 	// Visible and already going to be played (excluding giver)
@@ -151,7 +169,8 @@ function find_unknown_connecting(game, giver, target, reacting, identity, looksD
 			const card = common.thoughts[order];
 
 			return card.touched && !card.newly_clued &&
-				common.dependentConnections(order).every(wc => !wc.symmetric && wc.focused_card.matches(wc.inference, { assume: true }));
+				(state.deck[order].identity() !== undefined || common.dependentConnections(order).every(wc =>
+					!wc.symmetric && wc.focused_card.matches(wc.inference, { assume: true })));
 		};
 
 		if (state.hands.some((hand, index) => index !== giver && hand.some(c => order_touched(c.order) && c.matches(finesse)))) {

src/conventions/h-group/clue-interpretation/connection-helper.js

@@ -1,7 +1,7 @@
 import { CLUE } from '../../../constants.js';
 import { IdentitySet } from '../../../basics/IdentitySet.js';
 import { determine_focus } from '../hanabi-logic.js';
-import { IllegalInterpretation, find_own_finesses } from './own-finesses.js';
+import { IllegalInterpretation, RewindEscape, find_own_finesses } from './own-finesses.js';
 
 import logger from '../../../tools/logger.js';
 import { logCard, logConnection, logConnections } from '../../../tools/log.js';
@@ -145,11 +145,17 @@ export function find_symmetric_connections(game, action, inf_possibilities, self
 				non_self_connections.push({ id, connections, fake });
 		}
 		catch (error) {
-			if (error instanceof IllegalInterpretation)
+			if (error instanceof IllegalInterpretation) {
 				// Will probably never be seen
 				logger.warn(error.message);
-			else
+			}
+			else if (error instanceof RewindEscape) {
+				logger.flush(false);
+				return [];
+			}
+			else {
 				throw error;
+			}
 		}
 		logger.flush(false);
 	}
@@ -217,6 +223,9 @@ export function assign_connections(game, connections, giver) {
 				card.certain_finessed = true;
 		}
 
+		if (connections.some(conn => conn.type === 'finesse'))
+			card.finesse_index = card.finesse_index ?? state.actionList.length;
+
 		if (bluff || hidden) {
 			const playable_identities = hypo_stacks.map((stack_rank, index) => ({ suitIndex: index, rank: stack_rank + 1 })).filter(id => id.rank <= state.max_ranks[id.suitIndex]);
 			card.inferred = card.inferred.intersect(playable_identities);