Add Referential Sieve (v1.9.0)

- RefSieve is now playable. It understands the basics, sarcastic discards, loaded plays and trash push.
- Notably, it does not understand delayed plays, prompts, or finesses yet.
- NOTE: Loaded rank play clues are right referential and not direct (as in the doc). This is a more powerful convention that has seen success in 2p.
- Fixed some issues with counting bad touch.
- Fixed a faulty self-elim check in good touch elim.
- No longer fetches the variants JSON for every self-play game (fixes #910).

Author: WillFlame14

README.md

@@ -1,7 +1,7 @@
 # hanabi-bot
 A deterministic NodeJS bot that plays on the [hanab.live](https://hanab.live/) interface. Basic structure and ideas were taken from [Zamiell's example bot](https://github.com/Zamiell/hanabi-live-bot) (Python). You can play with it by inviting any of the `will-bot`'s to your table.
 
-It can play with [H-Group](https://hanabi.github.io/) and [Playful Sieve](https://hackmd.io/@sodiumdebt/playful_sieve) conventions. The goal of the bot is to play with humans, so it can handle suboptimal play within reason. However, it still expects that the conventions are followed (in terms of focus, chop, etc.) and does not perform any "learning" during a game.
+It can play with [H-Group](https://hanabi.github.io/), [Referential Sieve](https://hackmd.io/Ui6LXAK3TdC7AKSDcN20PQ?view) and [Playful Sieve](https://hackmd.io/@sodiumdebt/playful_sieve) conventions. The goal of the bot is to play with humans, so it can handle suboptimal play within reason. However, it still expects that the conventions are followed (in terms of focus, chop, etc.) and does not perform any "learning" during a game.
 
 A demo game at H-Group level 3:
 
@@ -40,20 +40,20 @@ Send a PM to the bot on hanab.live (`/pm <HANABI_USERNAME> <message>`) to intera
 - `/leave` to kick the bot from your table.
 - `/create <name> <maxPlayers> <password>` to have the bot create a table. The name can't have spaces.
 - `/start` to have the bot start the game (only works if it is the table leader).
-- `/settings [conventions=HGroup,PlayfulSieve] [level]` to set the bot's conventions. To view the current settings, provide no parameters. The bot remembers its settings between games, but plays with H-Group conventions at level 1 on first boot.
+- `/settings [conventions=HGroup,RefSieve,PlayfulSieve] [level]` to set the bot's conventions. To view the current settings, provide no parameters. The bot remembers its settings between games, but plays with H-Group conventions at level 1 on first boot.
     - If only a level is provided (without a convention set), H-Group is assumed.
 - `/restart` and `/remake` to have the bot perform the corresponding room actions after the game has finished (only works if it is the table leader).
 
 Some commands can be sent inside a room to affect all bots that have joined.
-- `/setall [conventions=HGroup, PlayfulSieve] [level]` to set conventions and level for all bots.
+- `/setall [conventions=HGroup,RefSieve,PlayfulSieve] [level]` to set conventions and level for all bots.
 - `/leaveall` to kick all bots from the table.
 
 ## Watching replays
 A replay from hanab.live or from a file (in JSON) can be simulated using `npm run replay [-- <options>]`. Possible options:
 - `id=<id>` indicates the ID of the hanab.live replay to load
 - `file=<filePath>` indicates the path to the JSON replay to load (relative from the root directory)
 - `index=<index>` sets the index of the player the bot will simulate as (defaults to 0)
-- `convention=<HGroup, PlayfulSieve>` sets the conventions for the bot (defaults to HGroup)
+- `convention=<HGroup,RefSieve,PlayfulSieve>` sets the conventions for the bot (defaults to HGroup)
 - `level=<level>` sets the HGroup level for the bot (defaults to 1)
 
 In a replay, the following commands are also supported (in addition to `hand` and `state`):
@@ -68,7 +68,7 @@ The bot can play games with copies of itself using `npm run self-play [-- <optio
 - `seed=<seed>` sets the seed of the first game to be played (defaults to 0)
     - The seeding algorithm is different from the one used on hanab.live.
 - `variant=<variantName>` sets the variant to be played for all games (defaults to No Variant)
-- `convention=<HGroup, PlayfulSieve>` sets the conventions for the bot (defaults to HGroup)
+- `convention=<HGroup,RefSieve,PlayfulSieve>` sets the conventions for the bot (defaults to HGroup)
 - `level=<level>` sets the HGroup level for the bot (defaults to 1)
 
 The final score for each seed as well as how each game terminated are logged to the console. JSON replays of each game are saved to a `seeds` folder, which can be loaded into hanab.live for viewing.

src/StateProxy.js

@@ -224,8 +224,8 @@ function finalizeObject(state, path, patches) {
 		}
 	}
 
-	// return copy;
-	return Object.freeze(copy);
+	return copy;
+	// return Object.freeze(copy);
 }
 
 /**
@@ -244,7 +244,7 @@ function finalizeNonProxiedObject(state) {
 			finalizeNonProxiedObject(value);
 
 	}
-	Object.freeze(state);
+	// Object.freeze(state);
 }
 
 /**

src/basics/Card.js

@@ -159,6 +159,7 @@ export class Card extends ActualCard {
 	superposition = false;	// Whether the card is currently in a superposition
 	hidden = false;
 	called_to_discard = false;
+	permission_to_discard = false;
 	certain_finessed = false;
 	trash = false;
 	uncertain = false;
@@ -179,36 +180,11 @@ export class Card extends ActualCard {
 	 * @param {boolean} [clued]
 	 * @param {boolean} [newly_clued]
 	 * @param {(BaseClue & { giver: number, turn: number })[]} [clues]	List of clues that have touched this card
-	 * @param {Partial<Card>} extras
 	 */
-	constructor(suitIndex, rank, possible, inferred, order = -1, drawn_index = -1, clued = false, newly_clued = false, clues = [], extras = {}) {
+	constructor(suitIndex, rank, possible, inferred, order = -1, drawn_index = -1, clued = false, newly_clued = false, clues = []) {
 		super(suitIndex, rank, order, drawn_index, clued, newly_clued, clues);
 		this.possible = possible;
 		this.inferred = inferred;
-		this.rewind_ids = extras.rewind_ids;
-		this.finesse_ids = extras.finesse_ids;
-		this.old_inferred = extras.old_inferred;
-		this.old_possible = extras.old_possible;
-		this.focused = extras.focused ?? false;
-		this.finessed = extras.finessed ?? false;
-		this.bluffed = extras.bluffed ?? false;
-		this.possibly_bluffed = extras.possibly_bluffed ?? false;
-		this.chop_moved = extras.chop_moved ?? false;
-		this.reset = extras.reset ?? false;
-		this.chop_when_first_clued = extras.chop_when_first_clued ?? false;
-		this.was_cm = extras.was_cm ?? false;
-		this.superposition = extras.superposition ?? false;
-		this.hidden = extras.hidden ?? false;
-		this.called_to_discard = extras.called_to_discard ?? false;
-		this.certain_finessed = extras.certain_finessed ?? false;
-		this.trash = extras.trash ?? false;
-		this.uncertain = extras.uncertain ?? false;
-		this.known = extras.known ?? false;
-		this.info_lock = extras.info_lock ?? undefined;
-		this.finesse_index = extras.finesse_index ?? -1;
-		this.reasoning = extras.reasoning?.slice() ?? [];
-		this.reasoning_turn = extras.reasoning_turn?.slice() ?? [];
-		this.rewinded = extras.rewinded ?? false;
 	}
 
 	/** @param {Card} json */
@@ -254,7 +230,12 @@ export class Card extends ActualCard {
 	}
 
 	shallowCopy() {
-		return new Card(this.suitIndex, this.rank, this.possible, this.inferred, this.order, this.drawn_index, this.clued, this.newly_clued, this.clues.slice(), this);
+		const copy = new Card(this.suitIndex, this.rank, this.possible, this.inferred, this.order, this.drawn_index, this.clued, this.newly_clued, this.clues);
+
+		for (const property of Object.getOwnPropertyNames(this))
+			copy[property] = this[property];
+
+		return copy;
 	}
 
 	get possibilities() {

src/basics/Player.js

@@ -144,6 +144,25 @@ export class Player {
 		return copy;
 	}
 
+	/**
+	 * Finds the order referred to by the given order.
+	 * @param {'left' | 'right'} direction
+	 * @param {number[]} hand
+	 * @param {number} order
+	 */
+	refer(direction, hand, order) {
+		const offset = direction === 'right' ? 1 : -1;
+		const index = hand.indexOf(order);
+
+		let target_index = (index + offset + hand.length) % hand.length;
+
+		while (this.thoughts[hand[target_index]].touched && !this.thoughts[hand[target_index]].newly_clued)
+			target_index = (target_index + offset + hand.length) % hand.length;
+
+		return hand[target_index];
+	}
+
+
 	/**
 	 * Returns whether they think the given player is locked (i.e. every card is clued, chop moved, or finessed AND not loaded).
 	 * @param {State} state
@@ -163,7 +182,7 @@ export class Player {
 	 * Returns whether they they think the given player is loaded (i.e. has a known playable or trash).
 	 * @param {State} state
 	 * @param {number} playerIndex
-	 * @param {{assume?: boolean}} options
+	 * @param {{assume?: boolean, symmetric?: boolean}} options
 	 */
 	thinksLoaded(state, playerIndex, options = {}) {
 		return this.thinksPlayables(state, playerIndex, options).length > 0 || this.thinksTrash(state, playerIndex).length > 0;
@@ -173,7 +192,7 @@ export class Player {
 	 * Returns playables in the given player's hand, according to this player.
 	 * @param {State} state
 	 * @param {number} playerIndex
-	 * @param {{assume?: boolean}} options
+	 * @param {{assume?: boolean, symmetric?: boolean}} options
 	 */
 	thinksPlayables(state, playerIndex, options = {}) {
 		const linked_orders = this.linkedOrders(state);
@@ -213,8 +232,8 @@ export class Player {
 
 			return 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) || known_playable() || ((!card.uncertain || playerIndex === state.ourPlayerIndex) && !conflicting_conn())) &&
-				state.hasConsistentInferences(card);
+				((options.assume ?? true) || known_playable() || ((!card.uncertain || playerIndex === state.ourPlayerIndex) && !conflicting_conn())) &&
+				(options.symmetric || state.hasConsistentInferences(card));
 		});
 	}
 

src/basics/clue-result.js

@@ -43,7 +43,6 @@ export function elim_result(state, player, hypo_player, hand, list) {
  * @param  {number} target
  */
 export function bad_touch_result(game, hypo_game, hypo_player, giver, target) {
-	const { me: old_me } = game;
 	const { me, state } = hypo_game;
 
 	const dupe_scores = game.players.map((player, pi) => {
@@ -94,16 +93,18 @@ export function bad_touch_result(game, hypo_game, hypo_player, giver, target) {
 			cm_dupe.push(order);
 			continue;
 		}
+	}
 
-		const duplicates = state.hands.flatMap(hand => hand.filter(o => {
-			const old_thoughts = old_me.thoughts[o];
-			const thoughts = me.thoughts[o];
+	for (const order of state.hands[target]) {
+		const card = state.deck[order];
+
+		if (!card.newly_clued || bad_touch.includes(order) || trash.includes(order) || cm_dupe.includes(order))
+			continue;
 
-			// We need to check old thoughts, since the clue may cause good touch elim that removes earlier notes
-			return o !== order && old_thoughts.matches(card, { infer: true }) && (old_thoughts.touched || thoughts.touched);
-		}));
+		const duplicates = state.hands.flatMap((hand, i) => hand.filter(o =>
+			((c = me.thoughts[o]) => c.touched && c.matches(card, { infer: true }) && !trash.includes(order) && (i !== target || o < order))()));
 
-		if (duplicates.length > 0 && !(duplicates.every(o => state.deck[o].newly_clued) && order < Math.min(...duplicates)))
+		if (duplicates.length > 0)
 			bad_touch.push(order);
 	}
 

src/basics/hanabi-util.js

@@ -127,20 +127,6 @@ export function cardValue(state, player, identity, order = -1) {
 	return 5 - (rank - player.hypo_stacks[suitIndex]);
 }
 
-/**
- * Finds the index to the right referred to by the given index.
- * @param  {ActualCard[]} hand
- * @param  {number} index
- */
-export function refer_right(hand, index) {
-	let target_index = (index + 1) % hand.length;
-
-	while (hand[target_index].clued && !hand[target_index].newly_clued)
-		target_index = (target_index + 1) % hand.length;
-
-	return target_index;
-}
-
 /**
  * Returns whether the order is known to be a particular special suit from empathy.
  * @param {Game} game

src/basics/helper.js

@@ -124,15 +124,15 @@ export function checkFix(game, oldThoughts, clueAction) {
 	}
 
 	// Any clued cards that lost all inferences
-	const clued_reset = list.find(order => all_resets.has(order) && !state.deck[order].newly_clued);
+	const clued_resets = list.filter(order => all_resets.has(order) && !state.deck[order].newly_clued);
 
-	if (clued_reset)
-		logger.info('clued card', clued_reset, 'was newly reset!');
+	if (clued_resets.length > 0)
+		logger.info('clued cards', clued_resets, 'were newly reset!');
 
-	const duplicate_reveal = state.hands[target].find(order => {
+	const duplicate_reveal = list.filter(order => {
 		const card = common.thoughts[order];
 
-		if (!list.includes(order) || game.common.thoughts[order].identity() === undefined)
+		if (game.common.thoughts[order].identity() === undefined || card.clues.filter(clue => clue.type === card.clues.at(-1).type && clue.value === card.clues.at(-1).value ).length > 1)
 			return false;
 
 		// The fix can be in anyone's hand except the giver's
@@ -145,7 +145,7 @@ export function checkFix(game, oldThoughts, clueAction) {
 		return copy !== undefined;
 	});
 
-	return { fix: clued_reset !== undefined || duplicate_reveal !== undefined };
+	return { clued_resets, duplicate_reveal };
 }
 
 /**

src/basics/player-elim.js

@@ -330,7 +330,7 @@ export function good_touch_elim(state, only_self = false) {
 				if (asymmetric_gt)
 					continue;
 
-				const self_elim = this.playerIndex !== -1 && matches_arr.every(o =>
+				const self_elim = this.playerIndex !== -1 && matches_arr.length > 0 && matches_arr.every(o =>
 					state.hands[playerIndex].includes(o) && this.thoughts[o].identity({ infer: true, symmetric: true}) === undefined);
 				if (self_elim)
 					continue;

src/command-handler.js

@@ -3,6 +3,7 @@ import logger from './tools/logger.js';
 import * as Utils from './tools/util.js';
 
 import HGroup from './conventions/h-group.js';
+import RefSieve from './conventions/ref-sieve.js';
 import PlayfulSieve from './conventions/playful-sieve.js';
 import { BOT_VERSION, MAX_H_LEVEL } from './constants.js';
 import { State } from './basics/State.js';
@@ -17,7 +18,7 @@ import { logPerformAction } from './tools/log.js';
  * @typedef {import('./types-live.js').Table} Table
  */
 
-const conventions = { HGroup, PlayfulSieve };
+const conventions = { HGroup, RefSieve, PlayfulSieve };
 const settings = {
 	convention: 'HGroup',
 	level: parseInt(process.env['HANABI_LEVEL'] ?? '1')
@@ -218,7 +219,7 @@ export const handle = {
 		const state = new State(playerNames, ourPlayerIndex, variant, options);
 
 		// Initialize game state using convention set
-		game = new conventions[/** @type {'HGroup' | 'PlayfulSieve'} */ (settings.convention)](tableID, state, true, settings.level);
+		game = new conventions[/** @type {'HGroup' | 'RefSieve' | 'PlayfulSieve'} */ (settings.convention)](tableID, state, true, settings.level);
 
 		Utils.globalModify({ game, cache: new Map() });
 

src/constants.js

@@ -1,7 +1,8 @@
-import { find_all_clues, find_all_discards } from './conventions/h-group/take-action.js';
+import { find_all_clues as h_find, find_all_discards as h_dc } from './conventions/h-group/take-action.js';
+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.8.19';
+export const BOT_VERSION = '1.9.0';
 
 export const ACTION =  /** @type {const} */ ({
 	PLAY: 0,
@@ -31,8 +32,12 @@ export const HAND_SIZE = [-1, -1, 5, 5, 4, 4, 3];
 
 export const ENDGAME_SOLVING_FUNCS = {
 	HGroup: {
-		find_clues: find_all_clues,
-		find_discards: find_all_discards
+		find_clues: h_find,
+		find_discards: h_dc
+	},
+	RefSieve: {
+		find_clues: rs_find,
+		find_discards: rs_dc
 	}
 };
 

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

@@ -76,8 +76,13 @@ function acceptable_clue(game, hypo_game, action, result) {
 		if (card.reset)
 			return `card ${logCard(state.deck[order])} ${order} lost all inferences and was reset`;
 
-		if (id !== undefined && !visible_card.matches(id))
-			return `card ${logCard(visible_card)} incorrectly inferred to be ${logCard(id)}`;
+		const linked = hypo_game.common.linkedOrders(hypo_game.state).has(order);
+
+		if (linked)
+			continue;
+
+		if (id !== undefined && linked && !visible_card.matches(id))
+			return `card ${logCard(visible_card)} ${order} incorrectly inferred to be ${logCard(id)}`;
 
 		const looks_playable = hypo_game.common.unknown_plays.has(order) ||
 			hypo_game.common.hypo_stacks[visible_card.suitIndex] >= visible_card.rank ||

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

@@ -73,7 +73,8 @@ function apply_good_touch(game, action, oldThoughts) {
 		}
 	}
 
-	return checkFix(game, oldThoughts, action);
+	const { clued_resets, duplicate_reveal } = checkFix(game, oldThoughts, action);
+	return { fix: clued_resets.length > 0 || duplicate_reveal.length > 0 };
 }
 
 /**

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

@@ -13,6 +13,7 @@ import * as Utils from '../../tools/util.js';
 
 import { Worker } from 'worker_threads';
 import * as path from 'path';
+import { shortForms } from '../../variants.js';
 
 /**
  * @typedef {import('../h-group.js').default} Game
@@ -456,7 +457,7 @@ export async function take_action(game) {
 	if (state.inEndgame()) {
 		logger.highlight('purple', 'Attempting to solve endgame...');
 
-		const workerData = { game: Utils.toJSON(game), playerTurn: state.ourPlayerIndex, conv: 'HGroup', logLevel: logger.level };
+		const workerData = { game: Utils.toJSON(game), playerTurn: state.ourPlayerIndex, conv: 'HGroup', logLevel: logger.level, shortForms };
 		const worker = new Worker(path.resolve(import.meta.dirname, '../', 'shared', 'endgame.js'), { workerData });
 
 		const result = await new Promise((resolve, reject) => {

src/conventions/playful-sieve/interpret-clue.js

@@ -1,6 +1,6 @@
 import { CLUE } from '../../constants.js';
 import { IdentitySet } from '../../basics/IdentitySet.js';
-import { isTrash, refer_right } from '../../basics/hanabi-util.js';
+import { isTrash } from '../../basics/hanabi-util.js';
 import { checkFix, team_elim } from '../../basics/helper.js';
 import * as Basics from '../../basics.js';
 import * as Utils from '../../tools/util.js';
@@ -111,7 +111,9 @@ export function interpret_clue(game, action) {
 
 	Basics.onClue(game, action);
 
-	let { fix } = checkFix(game, oldCommon.thoughts, action);
+	const { clued_resets, duplicate_reveal } = checkFix(game, oldCommon.thoughts, action);
+
+	let fix = clued_resets.length > 0 || duplicate_reveal.length > 0;
 
 	for (const order of hand) {
 		const card = common.thoughts[order];
@@ -187,7 +189,7 @@ export function interpret_clue(game, action) {
 		// Referential play (right)
 		if (clue.type === CLUE.COLOUR || trash_push) {
 			if (newly_touched.length > 0) {
-				const referred = newly_touched.map(index => refer_right(hand.map(o => state.deck[o]), index));
+				const referred = newly_touched.map(index => hand.indexOf(common.refer('right', hand, hand[index])));
 				const target_index = referred.reduce((max, curr) => Math.max(max, curr));
 
 				// Telling chop to play while not loaded, lock