Play clue fixes (v1.10.0)

- Corrected some OCM logic (fixes #1084).
- Now plays non-connecting cards to force the next player into anxiety (fixes #1065).
- Recognizes more known finesses when the focus cannot be a finessed card (fixes #1046).
- Allows self-prompts with a colour clue when the focus cannot be the next direct identity (fixes #1026).
- Fixed some instances of being too cautious about whether someone has a playable (fixes #1140).
- Fixed false positives of out-of-order play clues (fixes #1021).

Author: WillFlame14

src/basics/Player.js

@@ -6,7 +6,7 @@ import * as Utils from '../tools/util.js';
 import * as Elim from './player-elim.js';
 
 import logger from '../tools/logger.js';
-import { logCard } from '../tools/log.js';
+import { logCard, logConnection } from '../tools/log.js';
 import { produce } from '../StateProxy.js';
 
 /**
@@ -228,18 +228,41 @@ export class Player {
 				card.possible.every(p => state.isBasicTrash(p) || state.isPlayable(p)) && card.possible.some(p => state.isPlayable(p));
 
 			const conflicting_conn = () => {
-				const wc = this.waiting_connections.find((wc, i1) =>
-					(playerIndex !== state.ourPlayerIndex || !wc.symmetric) &&
+				/** @type {WaitingConnection[]} */
+				const dependents = [];
+
+				for (const wc of this.waiting_connections) {
+					// Ignore symmetric connections when looking at our own playables, since no one else will consider them
+					if (playerIndex === state.ourPlayerIndex && wc.symmetric)
+						continue;
+
 					// Unplayable target of possible waiting connection
-					(wc.focus === o && !state.isPlayable(wc.inference) && card.possible.has(wc.inference)) ||
-					wc.connections.some((conn, ci) => ci >= wc.conn_index && conn.order === o && (
-						// Unplayable connecting card
-						conn.identities.some(i => !state.isPlayable(i) && card.possible.has(i)) ||
-						// A different connection on the same focus doesn't use this connecting card
-						this.waiting_connections.some((wc2, i2) =>
-							i1 !== i2 && wc2.focus === wc.focus && wc2.connections.every(conn2 => conn2.order !== o))))
-				);
-				return wc !== undefined;
+					if (wc.focus === o && !state.isPlayable(wc.inference) && card.possible.has(wc.inference)) {
+						logger.debug(`order ${o} has conflicting connection ${wc.connections.map(logConnection).join(' -> ')} (unplayable target)`);
+						return true;
+					}
+
+					if (wc.connections.some((conn, ci) => ci >= wc.conn_index && conn.order === o))
+						dependents.push(wc);
+				}
+
+				for (const wc of dependents) {
+					const depending_conn = wc.connections.find((conn, ci) => ci >= wc.conn_index && conn.order === o);
+					const unplayable_ids = depending_conn.identities.filter(i => !state.isPlayable(i) && card.possible.has(i));
+					if (unplayable_ids.length > 0) {
+						logger.debug(`order ${o} has conflicting connection ${wc.connections.map(logConnection).join(' -> ')} with unplayable ids ${unplayable_ids.map(logCard)})`);
+						return true;
+					}
+				}
+
+				// Every connection using this card has another connection with the same focus that doesn't use it
+				const replaceable = dependents.map(wc =>
+					this.waiting_connections.find(wc2 => wc !== wc2 && wc2.focus === wc.focus && wc2.connections.every(conn2 => conn2.order !== o)));
+
+				if (replaceable.every(r => r !== undefined))
+					logger.debug(`order ${o} has connections replaceable with ${replaceable.map(wc => wc.connections.map(logConnection).join(' -> '))}`);
+
+				return replaceable.every(r => r !== undefined);
 			};
 
 			return card.possibilities.every(p => (card.chop_moved ? state.isBasicTrash(p) : false) || state.isPlayable(p)) &&	// cm cards can ignore trash ids

src/basics/helper.js

@@ -166,7 +166,7 @@ export function checkFix(game, oldThoughts, clueAction) {
 		const card = newCommon.thoughts[order];
 
 		// No new eliminations
-		if (card.possible.length === common.thoughts[order].possible.length)
+		if (card.possible.length === oldThoughts[order].possible.length)
 			return false;
 
 		if (newCommon.thoughts[order].identity() === undefined || card.clues.filter(clue => clue.type === card.clues.at(-1).type && clue.value === card.clues.at(-1).value ).length > 1)

src/constants.js

@@ -2,7 +2,7 @@ import { find_all_clues as h_find, find_all_discards as h_dc } from './conventio
 import { find_all_clues as rs_find, find_all_discards as rs_dc } from './conventions/ref-sieve/take-action.js';
 
 export const MAX_H_LEVEL = 11;
-export const BOT_VERSION = '1.9.9';
+export const BOT_VERSION = '1.10.0';
 
 export const ACTION =  /** @type {const} */ ({
 	PLAY: 0,

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

@@ -70,6 +70,12 @@ export function order_1s(state, player, orders, options = { no_filter: false })
 		const [c1_start, c2_start] = [order1, order2].map(o => state.inStartingHand(o));
 		const [c1, c2] = [order1, order2].map(o => player.thoughts[o]);
 
+		/** @param {number} o */
+		const first_clued_turn = (o) => (state.deck[o].clues[0] ?? { turn: state.turn_count }).turn;
+
+		if (first_clued_turn(order1) !== first_clued_turn(order2))
+			return first_clued_turn(order2) - first_clued_turn(order1);
+
 		if (c1.finessed && c2.finessed)
 			return c1.finesse_index - c2.finesse_index;
 

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

@@ -282,7 +282,7 @@ export function get_clue_interp(game, clue, giver, options) {
 				return;
 			}
 
-			if (finesses.length > 0 && list.some(o => ((id = state.deck[o]) => id.playedBefore(focused_card) && common.hypo_stacks[id.suitIndex] < id.rank)())) {
+			if (finesses.some(f => list.some(o => f.card.order !== o && state.deck[f.card.order].matches(state.deck[o])))) {
 				logger.warn('looks like out-of-order play clue, not giving');
 				return;
 			}

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

@@ -196,7 +196,7 @@ function find_unknown_connecting(game, action, reacting, identity, connected = [
 		if (game.level >= LEVEL.INTERMEDIATE_FINESSES && state.play_stacks[prompt_c.suitIndex] + 1 === prompt_c.rank) {
 			// Could be duplicated in giver's hand - disallow hidden prompt
 			if (giver === state.ourPlayerIndex && state.hands[giver].some(o => state.deck[o].clued && game.players[giver].thoughts[o].inferred.has(identity))) {
-				logger.warn(`disallowed hidden prompt on ${logCard(prompt_c)} ${prompt_order}, true ${logCard(identity)}  could be duplicated in giver's hand`);
+				logger.warn(`disallowed hidden prompt on ${logCard(prompt_c)} ${prompt_order}, true ${logCard(identity)} could be duplicated in giver's hand`);
 				return { tried: true };
 			}
 			return { tried: true, conn: { type: 'prompt', reacting, order: prompt_order, hidden: true, identities: [prompt_c.raw()] } };

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

@@ -301,15 +301,18 @@ export function assign_all_connections(game, simplest_poss, all_poss, action, fo
 					if (card.uncertain || giver === state.ourPlayerIndex || card.rewinded)
 						return false;
 
-					if (reacting === state.ourPlayerIndex)
+					if (reacting === state.ourPlayerIndex) {
 						// We are uncertain if the card isn't known and there's some other card in our hand that allows for a swap
-						return type !== 'known' && identities.some(i => state.ourHand.some(o => o !== order && me.thoughts[o].possible.has(i)));
+						return type !== 'known' && identities.some(i => state.ourHand.some(o => o !== order && me.thoughts[o].possible.has(i))) &&
+							// The card also needs to be playable in some other suit
+							card.possible.some(i => i.suitIndex !== identities[0].suitIndex && i.rank <= common.hypo_stacks[i.suitIndex] + 1);
+					}
 
 					// We are uncertain if the connection is a finesse that could be ambiguous
 					const uncertain_conn = (type === 'finesse' && all_poss.length > 1) ||
 						(type === 'prompt' && me.thoughts[focus].possible.some(p => p.suitIndex !== identities[0].suitIndex));
 
-					return uncertain_conn && (!(identities.every(i => state.isCritical(i)) && focused_card.matches(inference)) ||
+					return uncertain_conn && !((identities.every(i => state.isCritical(i)) && focused_card.matches(inference)) ||
 						// Colour finesses are guaranteed if the focus cannot be a finessed identity
 						(clue.type === CLUE.COLOUR && identities.every(i => !me.thoughts[focused_card.order].possible.has(i))));
 				})();

src/conventions/h-group/clue-interpretation/own-finesses.js

@@ -87,7 +87,7 @@ function connect(game, action, identity, looksDirect, connected, ignoreOrders, i
 
 	const focus = connected[0];
 
-	const self_allowed = giver !== state.ourPlayerIndex && !(target === state.ourPlayerIndex && looksDirect);
+	const self_allowed = giver !== state.ourPlayerIndex && !(target === state.ourPlayerIndex && looksDirect && me.thoughts[connected[0]].possible.has(identity));
 
 	if (self_allowed) {
 		if (options.bluffed) {

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

@@ -24,6 +24,22 @@ import { produce } from '../../StateProxy.js';
  * @typedef {import('../../types.js').PerformAction} PerformAction
  */
 
+/**
+ * Determines whether the order can be placed into anxiety.
+ * @param {Game} game
+ * @param {number} target
+ * @param {number} order
+ * @returns {boolean}
+ */
+export function anxiety_targetable(game, target, order) {
+	const { common, state } = game;
+
+	return game.level >= LEVEL.STALLING &&
+			common.thinksLocked(state, target) &&
+			state.clue_tokens === 0 &&
+			game.players[target].anxietyPlay(state, state.hands[target]) === order;
+}
+
 /**
  * Determines whether we can play a connecting card into the target's hand.
  * @param {Game} game
@@ -45,12 +61,8 @@ export function find_unlock(game, target) {
 		if (our_connecting === undefined)
 			continue;
 
-		// The card must become playable
-		const known = game.players[target].thoughts[order].inferred.every(c => state.isPlayable(c) || c.matches(card)) ||
-			(game.level >= LEVEL.STALLING &&
-				common.thinksLocked(state, target) &&
-				state.clue_tokens === 0 &&
-				game.players[target].anxietyPlay(state, state.hands[target]) === order);
+		// The card must become playable (TODO: maybe anxiety should only be on next player?)
+		const known = game.players[target].thoughts[order].inferred.every(c => state.isPlayable(c) || c.matches(card)) || anxiety_targetable(game, target, order);
 
 		if (known) {
 			// Reorder if unknown 1 (e.g. we have a good touch link for the last remaining 1)
@@ -217,6 +229,12 @@ export function find_urgent_actions(game, play_clues, save_clues, fix_clues, sta
 
 		// They are locked (or will be locked), we should try to unlock
 		if (locked) {
+			const playable = playable_priorities.flat()[0];
+			if (playable !== undefined && state.hands[target].some(order => anxiety_targetable(game, target, order))) {
+				urgent_actions[PRIORITY.UNLOCK + nextPriority].push({ tableID, type: ACTION.PLAY, target: playable });
+				continue;
+			}
+
 			const unlock_order = find_unlock(game, target);
 			if (unlock_order !== undefined && (finessed_order === -1 || finessed_order == unlock_order)) {
 				urgent_actions[PRIORITY.UNLOCK + nextPriority].push({ tableID, type: ACTION.PLAY, target: unlock_order });

test/h-group/level-2.js

@@ -115,6 +115,50 @@ describe('reverse finesse', () => {
 		// Alice's slot 1 should be i4, not [i4,i5].
 		ExAsserts.cardHasInferences(game.common.thoughts[game.state.hands[PLAYER.ALICE][0]], ['i4']);
 	});
+
+	it(`self-prompts if impossible to be direct`, () => {
+		const game = setup(HGroup, [
+			['xx', 'xx', 'xx', 'xx', 'xx'],
+			['r4', 'g1', 'y2', 'g4', 'b4'],
+			['r1', 'g3', 'b3', 'r5', 'm3']
+		], {
+			level: { min: 2 },
+			play_stacks: [0, 0, 1, 0, 0],
+			starting: PLAYER.CATHY,
+			variant: VARIANTS.RAINBOW
+		});
+
+		takeTurn(game, 'Cathy clues 2 to Alice (slots 1,2)');
+		takeTurn(game, 'Alice plays g2 (slot 1)');
+		takeTurn(game, 'Bob clues red to Alice (slots 2,5)');		// slot 5 is !2, so this is either r1, m1 or r3
+
+		ExAsserts.cardHasInferences(game.common.thoughts[game.state.hands[PLAYER.ALICE][4]], ['r1', 'r3', 'm1']);
+
+		takeTurn(game, 'Cathy plays r1', 'b1');
+
+		// Alice knows she has r3.
+		ExAsserts.cardHasInferences(game.common.thoughts[game.state.hands[PLAYER.ALICE][4]], ['r3']);
+	});
+
+	it(`recognizes known finesses`, () => {
+		const game = setup(HGroup, [
+			['xx', 'xx', 'xx', 'xx', 'xx'],
+			['r1', 'r4', 'r4', 'g4', 'g4'],
+			['y4', 'y4', 'b4', 'b4', 'r3']
+		], {
+			level: { min: 2 },
+			starting: PLAYER.CATHY,
+			discarded: ['r1', 'r1']
+		});
+
+		takeTurn(game, 'Cathy clues red to Alice (slot 1)');
+
+		// Bob's r1 is definitely finessed.
+		assert.equal(game.common.thoughts[game.state.hands[PLAYER.ALICE][0]].uncertain, false);
+
+		// Alice knows that her card is r2.
+		ExAsserts.cardHasInferences(game.players[PLAYER.ALICE].thoughts[game.state.hands[PLAYER.ALICE][0]], ['r2']);
+	});
 });
 
 describe('self-finesse', () => {

test/h-group/level-9.js

@@ -387,6 +387,27 @@ describe('anxiety plays', () => {
 		ExAsserts.objHasProperties(action, { type: ACTION.PLAY, target: game.state.hands[PLAYER.ALICE][0] });
 	});
 
+	it('forces the next player into anxiety by playing an unrelated card', async () => {
+		const game = setup(HGroup, [
+			['xx', 'xx', 'xx', 'xx'],
+			['r5', 'y5', 'b5', 'g5'],
+			['b3', 'g4', 'b4', 'b2'],
+			['y4', 'y4', 'r4', 'r3']
+		], {
+			level: { min: 9 },
+			play_stacks: [4, 0, 0, 0, 0],
+			clue_tokens: 2,
+			starting: PLAYER.CATHY
+		});
+
+		takeTurn(game, 'Cathy clues 5 to Bob');
+		takeTurn(game, 'Donald clues blue to Alice (slot 1)');
+
+		// Alice should play slot 1 as b1.
+		const action = await game.take_action();
+		ExAsserts.objHasProperties(action, { type: ACTION.PLAY, target: game.state.hands[PLAYER.ALICE][0] });
+	});
+
 	/*it('gives an anxiety clue to the next player', async () => {
 		const game = setup(HGroup, [
 			['xx', 'xx', 'xx', 'xx'],