Standardize using card orders

Also fixed various bugs introduced in the last commit.

Author: WillFlame14

src/action-handler.js

@@ -25,11 +25,6 @@ export function handle_action(action) {
 	if (action.type === 'clue' && action.giver === state.ourPlayerIndex)
 		this.handHistory[state.turn_count] = Utils.objClone(state.ourHand);
 
-	const update_func = (suitIndex, rank) => (draft) => {
-		draft.suitIndex = suitIndex;
-		draft.rank = rank;
-	};
-
 	switch(action.type) {
 		case 'clue': {
 			// {type: 'clue', clue: { type: 1, value: 1 }, giver: 0, list: [ 8, 9 ], target: 1, turn: 0}
@@ -61,8 +56,8 @@ export function handle_action(action) {
 			const card = state.deck[order];
 
 			if (card.identity() === undefined)
-				state.deck = state.deck.with(order, produce(card, update_func(suitIndex, rank)));
-			this.players[playerIndex].updateThoughts(order, update_func(suitIndex, rank));
+				state.deck = state.deck.with(order, produce(card, Utils.assignId({ suitIndex, rank })));
+			this.players[playerIndex].updateThoughts(order, Utils.assignId({ suitIndex, rank }));
 
 			logger.highlight('yellowb', `Turn ${state.turn_count}: ${logAction(action)}`);
 
@@ -138,8 +133,8 @@ export function handle_action(action) {
 			const card = state.deck[order];
 
 			if (card.identity() === undefined)
-				state.deck = state.deck.with(order, produce(card, update_func(suitIndex, rank)));
-			this.players[playerIndex].updateThoughts(order, update_func(suitIndex, rank));
+				state.deck = state.deck.with(order, produce(card, Utils.assignId({ suitIndex, rank })));
+			this.players[playerIndex].updateThoughts(order, Utils.assignId({ suitIndex, rank }));
 
 			logger.highlight('yellowb', `Turn ${state.turn_count}: ${logAction(action)}`);
 
@@ -174,8 +169,9 @@ export function handle_action(action) {
 			});
 
 			if (!infer && identities.length === 1) {
-				this.me.updateThoughts(order, update_func(identities[0].suitIndex, identities[0].rank));
-				state.deck = state.deck.with(order, produce(state.deck[order], update_func(identities[0].suitIndex, identities[0].rank)));
+				const { suitIndex, rank } = identities[0];
+				this.me.updateThoughts(order, Utils.assignId({ suitIndex, rank }));
+				state.deck = state.deck.with(order, produce(state.deck[order], Utils.assignId({ suitIndex, rank })));
 			}
 			team_elim(this);
 			break;

src/basics.js

@@ -1,5 +1,6 @@
 import { ActualCard, Card } from './basics/Card.js';
 import { cardCount, find_possibilities } from './variants.js';
+import * as Utils from './tools/util.js';
 import { produce } from './StateProxy.js';
 
 /**
@@ -78,17 +79,15 @@ export function onDiscard(game, action) {
 
 	if (suitIndex !== -1 && rank !== -1) {
 		state.discard_stacks[suitIndex][rank - 1]++;
-		state.deck[order] = produce(state.deck[order], (draft) => {
-			draft.suitIndex = suitIndex;
-			draft.rank = rank;
-		});
+		state.deck[order] = produce(state.deck[order], Utils.assignId({ suitIndex, rank }));
 
 		for (const player of game.allPlayers) {
+			const { possible, inferred } = player.thoughts[order];
 			player.updateThoughts(order, (draft) => {
 				draft.suitIndex = suitIndex;
 				draft.rank = rank;
-				draft.possible = player.thoughts[order].possible.intersect(identity);
-				draft.inferred = player.thoughts[order].inferred.intersect(identity);
+				draft.possible = possible.intersect(identity);
+				draft.inferred = inferred.intersect(identity);
 			});
 
 			player.card_elim(state);
@@ -158,10 +157,7 @@ export function onPlay(game, action) {
 
 	if (suitIndex !== undefined && rank !== undefined) {
 		state.play_stacks[suitIndex] = rank;
-		state.deck[order] = produce(state.deck[order], (draft) => {
-			draft.suitIndex = suitIndex;
-			draft.rank = rank;
-		});
+		state.deck[order] = produce(state.deck[order], Utils.assignId({ suitIndex, rank }));
 
 		for (const player of game.allPlayers) {
 			const { possible, inferred } = player.thoughts[order];

src/basics/Player.js

@@ -157,13 +157,13 @@ export class Player {
 				card.possibilities.some(p => state.isPlayable(p)) &&	// Exclude empty case
 				((options?.assume ?? true) || !this.waiting_connections.some((wc, i1) =>
 					// Unplayable target of possible waiting connection
-					(wc.focused_card.order === o && !state.isPlayable(wc.inference) && card.possible.has(wc.inference)) ||
+					(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.focused_card.order === wc.focused_card.order && wc2.connections.every(conn2 => conn2.order !== o))))
+							i1 !== i2 && wc2.focus === wc.focus && wc2.connections.every(conn2 => conn2.order !== o))))
 				)) &&
 				state.hasConsistentInferences(card);
 		});
@@ -305,7 +305,7 @@ export class Player {
 					continue;
 
 				const fake_wcs = this.waiting_connections.filter(wc =>
-					wc.focused_card.order === order && !state.deck[wc.focused_card.order].matches(wc.inference, { assume: true }));
+					wc.focus === order && !state.deck[wc.focus].matches(wc.inference, { assume: true }));
 
 				// Ignore all waiting connections that will be proven wrong
 				const diff = produce(card, (draft) => { draft.inferred = card.inferred.subtract(fake_wcs.flatMap(wc => wc.inference)); });
@@ -358,7 +358,7 @@ export class Player {
 
 				if (rank !== hypo_stacks[suitIndex] + 1) {
 					// e.g. a duplicated 1 before any 1s have played will have all bad possibilities eliminated by good touch
-					logger.warn(`tried to add new playable card ${logCard(id)} ${card.order}, hypo stacks at ${hypo_stacks[suitIndex]}`);
+					logger.warn(`tried to add new playable card ${logCard(id)} ${order}, hypo stacks at ${hypo_stacks[suitIndex]}`);
 					continue;
 				}
 

src/basics/clue-result.js

@@ -51,28 +51,23 @@ export function bad_touch_result(game, hypo_game, hypo_player, giver, target) {
 	const dupe_scores = game.players.map((player, pi) => {
 		if (pi == target)
 			return Infinity;
-		let possible_dupe = 0;
+
 		// Check if the giver may have a touched duplicate card.
-		// TODO: Should we consider chop moved cards?
-		for (const order of state.hands[target]) {
+		return state.hands[target].reduce((acc, order) => {
 			const card = state.deck[order];
-			// Ignore cards that aren't newly clued
 			if (!card.newly_clued)
-				continue;
+				return acc;
 
 			const identity = card.identity();
 			// TODO: Should we cluing cards where receiver knows they are duplicated?
 			if (!identity || hypo_game.state.isBasicTrash(identity))
-				continue;
-			for (const giverOrder of state.hands[pi]) {
-				// Allow known duplication since we can discard to resolve it.
-				if (state.deck[giverOrder].clued &&
-					player.thoughts[giverOrder].inferred.length > 1 &&
-					player.thoughts[giverOrder].inferred.has(identity))
-					possible_dupe++;
-			}
-		}
-		return possible_dupe;
+				return acc;
+
+			// Allow known duplication since we can discard to resolve it.
+			acc += state.hands[pi].filter(o => ((c = player.thoughts[o]) =>
+				c.clued && c.inferred.length > 1 && c.inferred.has(identity))()).length;
+			return acc;
+		}, 0);
 	});
 
 	const min_dupe = Math.min(...dupe_scores);
@@ -102,7 +97,7 @@ export function bad_touch_result(game, hypo_game, hypo_player, giver, target) {
 			const thoughts = me.thoughts[o];
 
 			// We need to check old thoughts, since the clue may cause good touch elim that removes earlier notes
-			return old_thoughts.matches(card, { infer: true }) && (old_thoughts.touched || thoughts.touched) && o !== order;
+			return o !== order && old_thoughts.matches(card, { infer: true }) && (old_thoughts.touched || thoughts.touched);
 		}));
 
 		if (duplicates.length > 0 && !(duplicates.every(o => state.deck[o].newly_clued) && order < Math.min(...duplicates)))

src/basics/helper.js

@@ -87,7 +87,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 new_game = game.rewind(reset_card.drawn_index, [{ type: 'identify', order: reset_card.order, playerIndex: target, identities: [reset_card.possible.array[0].raw()] }]);
+			const new_game = game.rewind(reset_card.drawn_index, [{ type: 'identify', order: reset_order, playerIndex: target, identities: [reset_card.possible.array[0].raw()] }]);
 			Object.assign(game, new_game);
 			return { rewinded: true };
 		}

src/constants.js

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

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

@@ -65,7 +65,7 @@ export function order_1s(state, player, orders, options = { no_filter: false })
 	const unknown_1s = options.no_filter ? orders : orders.filter(o => ((card = state.deck[o]) =>
 		card.clues.length > 0 &&
 			card.clues.every(clue => clue.type === CLUE.RANK && clue.value === 1) &&
-			player.thoughts[card.order].possible.every(p => p.rank === 1))());
+			player.thoughts[o].possible.every(p => p.rank === 1))());
 
 	return unknown_1s.sort((order1, order2) => {
 		const [c1_start, c2_start] = [order1, order2].map(o => state.inStartingHand(o));
@@ -81,7 +81,7 @@ export function order_1s(state, player, orders, options = { no_filter: false })
 			return 1;
 
 		if (c1.chop_when_first_clued && c2.chop_when_first_clued)
-			return c2.order - c1.order;
+			return order2 - order1;
 
 		// c1 is chop focus
 		if (c1.chop_when_first_clued)

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

@@ -39,7 +39,7 @@ function save_clue_value(game, hypo_game, save_clue, all_clues) {
 
 	if (chop_moved.length === 0) {
 		// Chop can be clued later
-		if (state.hands.some(hand => hand.some(o => state.deck[o].matches(old_chop_card) && o !== old_chop)))
+		if (state.hands.some(hand => hand.some(o => o !== old_chop && state.deck[o].matches(old_chop_card))))
 			return -10;
 
 		return Math.max(find_clue_value(result), state.isCritical(old_chop_card) ? 0.1 : -Infinity);
@@ -129,8 +129,8 @@ export function find_clues(game, options = {}) {
 			const focused_card = state.deck[focus];
 
 			const in_finesse = common.waiting_connections.some(w_conn => {
-				const { focused_card: wc_focus, inference } = w_conn;
-				const matches = player.thoughts[wc_focus.order].matches(inference, { assume: true });
+				const { focus: wc_focus, inference } = w_conn;
+				const matches = player.thoughts[wc_focus].matches(inference, { assume: true });
 
 				return matches && focused_card.playedBefore(inference, { equal: true });
 			});
@@ -152,8 +152,8 @@ export function find_clues(game, options = {}) {
 				continue;
 
 			const stomped_finesse = common.waiting_connections.some(w_conn => {
-				const { focused_card: wc_focus, connections, conn_index, inference } = w_conn;
-				const matches = player.thoughts[wc_focus.order].matches(inference, { assume: true });
+				const { focus: wc_focus, connections, conn_index, inference } = w_conn;
+				const matches = player.thoughts[wc_focus].matches(inference, { assume: true });
 
 				return matches && list.some(o => {
 					const card = hypo_game.common.thoughts[o];
@@ -218,7 +218,7 @@ export function find_clues(game, options = {}) {
 					break;
 
 				case CLUE_INTERP.CM_TEMPO: {
-					const { tempo, valuable } = valuable_tempo_clue(game, clue, clue.result.playables, focused_card);
+					const { tempo, valuable } = valuable_tempo_clue(game, clue, clue.result.playables, focus);
 
 					if (!safe) {
 						logger.highlight('yellow', 'unsafe!');

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

@@ -76,7 +76,7 @@ export function evaluate_clue(game, action, clue, target, target_card) {
 			// The focused card must not have been reset and must match inferences
 			if (order === target_card.order) {
 				if (card.reset && !game.common.thoughts[order].reset) {
-					reason = `card ${logCard(state.deck[card.order])} ${card.order} lost all inferences and was reset`;
+					reason = `card ${logCard(state.deck[order])} ${order} lost all inferences and was reset`;
 					break;
 				}
 
@@ -103,7 +103,7 @@ export function evaluate_clue(game, action, clue, target, target_card) {
 
 			// For non-focused cards:
 			if (card.reset) {
-				reason = `card ${logCard(state.deck[card.order])} ${card.order} lost all inferences and was reset`;
+				reason = `card ${logCard(state.deck[order])} ${order} lost all inferences and was reset`;
 				break;
 			}
 
@@ -117,7 +117,7 @@ export function evaluate_clue(game, action, clue, target, target_card) {
 				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)} ${visible_card.order} looks incorrectly playable with inferences [${card.inferred.map(logCard).join(',')}]`;
+				reason = `card ${logCard(visible_card)} ${order} looks incorrectly playable with inferences [${card.inferred.map(logCard).join(',')}]`;
 				break;
 			}
 		}

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

@@ -63,7 +63,7 @@ export function find_known_connecting(game, giver, identity, ignoreOrders = [],
 				inferences = old_card.inferred.subtract(old_card.inferred.filter(inf => inf.playedBefore(identity)));
 
 				// If a waiting connection will reveal this card, assume it will be known in time.
-				const connection = common.waiting_connections.find(conn => !conn.symmetric && conn.focused_card.order == order && conn.target !== state.ourPlayerIndex);
+				const connection = common.waiting_connections.find(conn => !conn.symmetric && conn.focus == order && conn.target !== state.ourPlayerIndex);
 				if (connection !== undefined)
 					inferences = inferences.intersect(connection.inference);
 			}
@@ -186,7 +186,7 @@ function find_unknown_connecting(game, action, reacting, identity, connected = [
 
 			return card.touched && !card.newly_clued &&
 				(state.deck[order].identity() !== undefined || common.dependentConnections(order).every(wc =>
-					!wc.symmetric && wc.focused_card.matches(wc.inference, { assume: true })));
+					!wc.symmetric && state.deck[wc.focus].matches(wc.inference, { assume: true })));
 		};
 
 		if (state.hands.some((hand, index) => index !== giver && hand.some(o => order_touched(o) && state.deck[o].matches(finesse_card)))) {

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

@@ -73,12 +73,12 @@ export function valid_bluff(game, action, identity, reacting, connected) {
  * @param {State} state
  * @param {SymFocusPossibility[]} sym_possibilities
  * @param {FocusPossibility[]} existing_connections
- * @param {ActualCard} focused_card
+ * @param {number} focus
  * @param {number} giver
  * @param {number} target
  * @returns {WaitingConnection[]}
  */
-export function generate_symmetric_connections(state, sym_possibilities, existing_connections, focused_card, giver, target) {
+export function generate_symmetric_connections(state, sym_possibilities, existing_connections, focus, giver, target) {
 	const symmetric_connections = [];
 
 	for (const sym of sym_possibilities) {
@@ -95,7 +95,7 @@ export function generate_symmetric_connections(state, sym_possibilities, existin
 		symmetric_connections.push({
 			connections,
 			conn_index: 0,
-			focused_card,
+			focus,
 			inference: { suitIndex, rank },
 			giver,
 			target,

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

@@ -123,7 +123,7 @@ function resolve_clue(game, old_game, action, inf_possibilities, focused_card) {
 			common.waiting_connections.push({
 				connections,
 				conn_index: 0,
-				focused_card,
+				focus,
 				inference,
 				giver,
 				target,
@@ -143,7 +143,7 @@ function resolve_clue(game, old_game, action, inf_possibilities, focused_card) {
 		));
 		const ownBlindPlays = correct_match?.connections.filter(conn => conn.type === 'finesse' && conn.reacting === state.ourPlayerIndex).length || 0;
 		const symmetric_fps = find_symmetric_connections(game, old_game, action, inf_possibilities, selfRanks, ownBlindPlays);
-		const symmetric_connections = generate_symmetric_connections(state, symmetric_fps, inf_possibilities, focused_card, giver, target);
+		const symmetric_connections = generate_symmetric_connections(state, symmetric_fps, inf_possibilities, focus, giver, target);
 
 		if (correct_match?.connections[0]?.bluff) {
 			const { reacting } = correct_match.connections[0];
@@ -363,7 +363,7 @@ export function interpret_clue(game, action) {
 	const to_remove = new Set();
 
 	for (const [i, waiting_connection] of Object.entries(common.waiting_connections)) {
-		const { connections, conn_index, action_index, focused_card: wc_focus, inference, target: wc_target } = waiting_connection;
+		const { connections, conn_index, action_index, focus: wc_focus, inference, target: wc_target } = waiting_connection;
 		const focus_id = state.deck[focus].identity();
 
 		if (focus_id !== undefined && list.length === 1) {
@@ -387,17 +387,17 @@ export function interpret_clue(game, action) {
 		if (impossible_conn !== undefined)
 			logger.warn(`connection [${connections.map(logConnection)}] depends on revealed card having identities ${impossible_conn.identities.map(logCard)}`);
 
-		else if (!common.thoughts[wc_focus.order].possible.has(inference))
+		else if (!common.thoughts[wc_focus].possible.has(inference))
 			logger.warn(`connection [${connections.map(logConnection)}] depends on focused card having identity ${logCard(inference)}`);
 
 		else
 			continue;
 
-		const rewind_card = state.deck[impossible_conn?.order] ?? wc_focus;
-		const rewind_identity = common.thoughts[rewind_card.order]?.identity();
+		const rewind_order = impossible_conn?.order ?? wc_focus;
+		const rewind_identity = common.thoughts[rewind_order]?.identity();
 
-		if (rewind_identity !== undefined && !common.thoughts[rewind_card.order].rewinded && wc_target === state.ourPlayerIndex && state.ourHand.includes(rewind_card.order)) {
-			const new_game = game.rewind(rewind_card.drawn_index, [{ type: 'identify', order: rewind_card.order, playerIndex: state.ourPlayerIndex, identities: [rewind_identity.raw()] }]);
+		if (rewind_identity !== undefined && !common.thoughts[rewind_order].rewinded && wc_target === state.ourPlayerIndex && state.ourHand.includes(rewind_order)) {
+			const new_game = game.rewind(state.deck[rewind_order].drawn_index, [{ type: 'identify', order: rewind_order, playerIndex: state.ourPlayerIndex, identities: [rewind_identity.raw()] }]);
 			if (new_game) {
 				Object.assign(game, new_game);
 				return;
@@ -680,7 +680,7 @@ export function interpret_clue(game, action) {
 	}
 
 	try {
-		logger.debug('hand state after clue', logHand(state.hands[target].map(o => state.deck[o])));
+		logger.debug('hand state after clue', logHand(state.hands[target]));
 	}
 	catch (err) {
 		logger.info('Failed to debug hand state', err, state.hands[target], Utils.globals.game.common.thoughts.map(c => c.order));

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

@@ -40,7 +40,7 @@ export function interpret_tcm(game, target, focus_order) {
 	for (let i = oldest_trash_index + 1; i < state.hands[target].length; i++) {
 		const order = state.hands[target][i];
 
-		if (!state.deck[state.hands[target][i]].clued && !common.thoughts[order].chop_moved) {
+		if (!state.deck[order].clued && !common.thoughts[order].chop_moved) {
 			const { inferred } = common.thoughts[order];
 			common.updateThoughts(order, (draft) => {
 				// Remove all commonly trash identities