More performance improvements (v1.7.1)

- Elimination (empathy) is now significantly faster.
- Removed some unnecessary transformations.
- The bot now announces when its settings have been changed if it is currently in a table (fixes #440).

Author: WillFlame14

.gitignore

@@ -2,3 +2,4 @@ node_modules/
 seeds/
 .env
 .DS_Store
+*.0x/

src/basics.js

@@ -42,12 +42,15 @@ export function onClue(game, action) {
 
 		for (const player of game.allPlayers) {
 			const { possible, inferred } = player.thoughts[order];
+
+			const operation = list.includes(order) ? 'intersect' : 'subtract';
+			const new_inferred = inferred[operation](new_possible);
+
 			player.updateThoughts(order, (draft) => {
-				const operation = list.includes(order) ? 'intersect' : 'subtract';
 				draft.possible = possible[operation](new_possible);
-				draft.inferred = inferred[operation](new_possible);
+				draft.inferred = new_inferred;
 
-				if (list.includes(order) && draft.inferred.length < inferred.length) {
+				if (list.includes(order) && new_inferred.length < inferred.length) {
 					draft.reasoning.push(state.actionList.length - 1);
 					draft.reasoning_turn.push(state.turn_count);
 				}

src/basics/Player.js

@@ -15,6 +15,7 @@ import { produce } from '../StateProxy.js';
  * @typedef {import('../types.js').Identity} Identity
  * @typedef {import('../types.js').Link} Link
  * @typedef {import('../types.js').WaitingConnection} WaitingConnection
+ * @typedef {import('../StateProxy.js').Patch} Patch
  */
 
 export class Player {
@@ -34,6 +35,9 @@ export class Player {
 	/** @type {Set<number>} */
 	hypo_plays;
 
+	/** @type {Map<number, Patch[]>} */
+	patches = new Map();
+
 	/**
 	 * @param {number} playerIndex
 	 * @param {IdentitySet} all_possible
@@ -99,10 +103,13 @@ export class Player {
 	/**
 	 * @param {number} order
 	 * @param {(draft: import('../types.js').Writable<Card>) => void} func
-	 * @param {(patches: import('../StateProxy.js').Patch[]) => void} [patchListener]
+	 * @param {boolean} [listenPatches]
 	 */
-	updateThoughts(order, func, patchListener) {
-		this.thoughts = this.thoughts.with(order, produce(this.thoughts[order], func, patchListener));
+	updateThoughts(order, func, listenPatches = this.playerIndex === -1) {
+		this.thoughts = this.thoughts.with(order, produce(this.thoughts[order], func, listenPatches ? (patches) => {
+			if (patches.length > 0)
+				this.patches.set(order, (this.patches.get(order) ?? []).concat(patches));
+		} : undefined));
 	}
 
 	/**
@@ -309,12 +316,10 @@ export class Player {
 					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)); });
-
-				const playable = state.hasConsistentInferences(diff) &&
-					(delayed_playable(diff.possible.array) ||
-						delayed_playable(diff.inferred.array) ||
-						(diff.finessed && delayed_playable([card])) ||
+				const playable = state.hasConsistentInferences(card) &&
+					(delayed_playable(card.possible.array) ||
+						delayed_playable(card.inferred.subtract(fake_wcs.flatMap(wc => wc.inference)).array) ||
+						(card.finessed && delayed_playable([card])) ||
 						this.play_links.some(pl => pl.connected === order && pl.orders.every(o => unknown_plays.has(o))));
 
 				if (!playable)

src/basics/helper.js

@@ -2,6 +2,7 @@ import { visibleFind } from './hanabi-util.js';
 
 import logger from '../tools/logger.js';
 import { logCard } from '../tools/log.js';
+import { applyPatches } from '../StateProxy.js';
 
 /**
  * @typedef {import('./Game.js').Game} Game
@@ -21,39 +22,25 @@ import { logCard } from '../tools/log.js';
  * @param {Game} game
  */
 export function team_elim(game) {
-	const { state } = game;
+	const { common, state } = game;
 
 	for (const player of game.players) {
-		for (let i = 0; i < game.common.thoughts.length; i++) {
-			const ccard = game.common.thoughts[i];
-			const card = player.thoughts[i];
-
-			const new_possible = ccard.possible.intersect(card.possible);
-			let new_inferred = ccard.inferred.intersect(card.possible);
-
-			// Reset to GTP if common interpretation doesn't make sense
-			if (new_inferred.length === 0 && !card.chop_moved)
-				new_inferred = new_possible;
-
-			player.updateThoughts(i, (draft) => {
-				draft.possible = new_possible;
-				draft.inferred = new_inferred;
-
-				for (const property of Object.getOwnPropertyNames(ccard)) {
-					if (!['suitIndex', 'rank', 'possible', 'inferred', 'reasoning', 'reasoning_turn'].includes(property))
-						draft[property] = ccard[property];
-				}
-
-				draft.reasoning = ccard.reasoning.slice();
-				draft.reasoning_turn = ccard.reasoning_turn.slice();
-			});
+		for (const [order, patches] of common.patches) {
+			const { possible, inferred } = common.thoughts[order];
+			player.updateThoughts(order, (draft) => {
+				draft.possible = possible.intersect(player.thoughts[order].possible);
+				draft.inferred = inferred.intersect(player.thoughts[order].inferred);
+				applyPatches(draft, patches.filter(p => !(p.path[0] === 'inferred' || p.path[0] === 'possible')));
+			}, false);
 		}
 
-		player.waiting_connections = game.common.waiting_connections.slice();
+		player.waiting_connections = common.waiting_connections.slice();
 		player.good_touch_elim(state, state.numPlayers === 2);
 		player.refresh_links(state);
 		player.update_hypo_stacks(state);
 	}
+
+	common.patches = new Map();
 }
 
 /**

src/basics/player-elim.js

@@ -28,34 +28,40 @@ export function card_elim(state) {
 
 	const candidates = state.hands.flatMap((hand, playerIndex) => hand.map(order => ({ playerIndex, order })));
 
-	const all_ids = state.hands.flatMap(hand => hand.flatMap(o => this.thoughts[o].possible.array));
-	const identities = state.base_ids.union(all_ids).array;
+	let identities = state.base_ids;
+	for (const order of state.hands.flat()) {
+		identities = identities.union(this.thoughts[order].possible);
+
+		if (identities.length === this.all_possible.length)
+			break;
+	}
+
+	/** @type {(order: number) => void} */
+	const addToMap = (order) => {
+		const card = this.thoughts[order];
+		const id = card.identity({ symmetric: this.playerIndex === -1 });
+
+		if (id !== undefined) {
+			const id_hash = logCard(id);
+			certain_map.set(id_hash, (certain_map.get(id_hash) ?? new Set()).add(order));
+			candidates.splice(candidates.findIndex(c => c.order === order), 1);
+		}
+	};
+
+	for (const order of state.hands.flat())
+		addToMap(order);
 
 	/**
 	 * The "typical" empathy operation. If there are enough known instances of an identity, it is removed from every card (including future cards).
 	 * Returns true if at least one card was modified.
 	 */
 	const basic_elim = () => {
 		let changed = false;
+		const curr_identities = identities.array;
+		let new_identities = identities;
 
-		/** @type {(index: number) => void} */
-		const addToMap = (index) => {
-			const { order } = candidates[index];
-			const card = this.thoughts[order];
-			const id = card.identity({ symmetric: this.playerIndex === -1 });
-
-			if (id !== undefined) {
-				const id_hash = logCard(id);
-				certain_map.set(id_hash, (certain_map.get(id_hash) ?? new Set()).add(order));
-				candidates.splice(index, 1);
-			}
-		};
-
-		for (let i = candidates.length - 1; i >= 0; i--)
-			addToMap(i);
-
-		for (let i = 0; i < identities.length; i++) {
-			const identity = identities[i];
+		for (let i = 0; i < curr_identities.length; i++) {
+			const identity = curr_identities[i];
 			const id_hash = logCard(identity);
 
 			const known_count = state.baseCount(identity) + (certain_map.get(id_hash)?.size ?? 0) + (uncertain_ids.has(identity) ? 1 : 0);
@@ -67,9 +73,9 @@ export function card_elim(state) {
 			// Remove it from the list of future possibilities
 			this.all_possible = this.all_possible.subtract(identity);
 			this.all_inferred = this.all_inferred.subtract(identity);
+			new_identities = new_identities.subtract(identity);
 
-			for (let i = candidates.length - 1; i >= 0; i--) {
-				const { order } = candidates[i];
+			for (const { order } of candidates) {
 				const { possible, inferred } = this.thoughts[order];
 
 				if (!possible.has(identity) || certain_map.get(id_hash)?.has(order) || uncertain_map.get(order)?.has(identity))
@@ -89,12 +95,13 @@ export function card_elim(state) {
 				}
 				// Card can be further eliminated
 				else if (updated_card.possible.length === 1) {
-					identities.push(updated_card.identity());
-					addToMap(i);
+					curr_identities.push(updated_card.identity());
+					addToMap(order);
 				}
 			}
-			logger.debug(`removing ${id_hash} from ${state.playerNames[this.playerIndex]} possibilities, now ${this.all_possible.map(logCard)}`);
+			// logger.debug(`removing ${id_hash} from ${state.playerNames[this.playerIndex]} possibilities, now ${this.all_possible.map(logCard)}`);
 		}
+		identities = new_identities;
 		return changed;
 	};
 
@@ -155,13 +162,22 @@ export function card_elim(state) {
 		const total_multiplicity = (identities) => identities.reduce((acc, id) => acc += cardCount(state.variant, id) - state.baseCount(id), 0);
 
 		for (let i = 2; i <= cross_elim_candidates.length; i++) {
-			const subsets = Utils.allSubsetsOfSize(cross_elim_candidates, i);
+			const subsets = Utils.allSubsetsOfSize(cross_elim_candidates.filter(({ order }) => this.thoughts[order].possible.length <= i), i);
 
 			for (const subset of subsets) {
-				const identities = subset.reduce((acc, { order }) => acc.union(this.thoughts[order].possible), state.base_ids);
+				let failed = false;
+				let acc_ids = state.base_ids;
+				for (const { order } of subset) {
+					acc_ids = acc_ids.union(this.thoughts[order].possible);
+
+					if (total_multiplicity(acc_ids) > subset.length) {
+						failed = true;
+						break;
+					}
+				}
 
-				if (subset.length === total_multiplicity(identities))
-					perform_elim(subset, identities);
+				if (!failed && subset.length === total_multiplicity(acc_ids))
+					perform_elim(subset, acc_ids);
 			}
 		}
 

src/command-handler.js

@@ -136,7 +136,7 @@ export const handle = {
 		}
 		// Displays or modifies the current settings (format: /settings [convention = 'HGroup'] [level = 1])
 		if (data.msg.startsWith('/settings')) {
-			assignSettings(data, true);
+			assignSettings(data, game.tableID === undefined);
 			return;
 		}
 		if (data.msg.startsWith('/terminate')) {

src/constants.js

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

test/playful-sieve/safe-actions.js

@@ -109,13 +109,20 @@ describe('connecting cards', () => {
 		const game = setup(PlayfulSieve, [
 			['xx', 'xx', 'xx', 'xx', 'xx'],
 			['g2', 'y4', 'g3', 'r4', 'r4']
-		]);
-
-		// Alice has a fully known g1 in slot 2
-		const card = game.common.thoughts[game.state.hands[PLAYER.ALICE][1]];
-		card.clued = true;
-		for (const poss of /** @type {const} */ (['possible', 'inferred']))
-			card[poss] = card[poss].intersect([{ suitIndex: 2, rank: 1 }]);
+		], {
+			init: (game) => {
+				const { common, state } = game;
+
+				// Alice has a fully known g1 in slot 2
+				const order = state.hands[PLAYER.ALICE][1];
+				const { possible, inferred } = common.thoughts[order];
+				common.updateThoughts(order, (draft) => {
+					draft.clued = true;
+					draft.possible = possible.intersect([{ suitIndex: 2, rank: 1 }]);
+					draft.inferred = inferred.intersect([{ suitIndex: 2, rank: 1 }]);
+				});
+			}
+		});
 
 		team_elim(game);
 		game.common.update_hypo_stacks(game.state);