Add level switching, fix bugs

- New /settings command to change which conventions the bot plays with.

- The focused card is no longer considered to be bad touch.
- No longer gives fix clues before level 3.
- Fixed finding unknown playable connecting cards.
- Fixed identification of forward finesses.
- No longer interprets 5cms in early game.
- Fixed stall identification when giver's hand is locked.
- Fixed console on Windows terminals.
- Cleaned up some logging.

Author: WillFlame14

src/command-handler.js

@@ -14,7 +14,15 @@ let self;
 const tables = {};
 
 /** @type {State} */
-let state;
+let state = {};
+
+/** @type {boolean} */
+let gameStarted = false;
+
+const settings = {
+	convention: 'HGroup',
+	level: 1
+};
 
 export const handle = {
 	// Received when any message in chat is sent
@@ -72,6 +80,35 @@ export const handle = {
 			else if (data.msg.startsWith('/start')) {
 				Utils.sendCmd('tableStart', { tableID: Number(data.msg.slice(data.msg.indexOf(' ') + 1)) });
 			}
+			// Displays or modifies the current settings (format: /settings [convention = 'HGroup'] [level = 1])
+			else if (data.msg.startsWith('/settings')) {
+				const parts = data.msg.split(' ');
+
+				if (parts.length > 1) {
+					if (gameStarted) {
+						Utils.sendChat(data.who, 'Settings cannot be modified in the middle of a game.');
+					}
+					else {
+						if (conventions[parts[1]]) {
+							settings.convention = parts[1];
+
+							if (settings.convention === 'HGroup' && (parts.length === 2 || !isNaN(Number(parts[2])))) {
+								const level = Number(parts[2]) || 1;
+
+								if (level <= 0 || level > 4) {
+									Utils.sendChat(data.who, 'This bot can currently only play between levels 1 and 4.');
+								}
+								settings.level = Math.max(Math.min(level, 4), 1);
+							}
+						}
+						else {
+							Utils.sendChat(data.who, `Correct format is /settings [convention = 'HGroup'] [level = 1].`);
+						}
+					}
+				}
+				const settingsString = (settings.convention === 'HGroup') ? `H-Group level ${settings.level}` : 'Referential Sieve';
+				Utils.sendChat(data.who, `Currently playing with ${settingsString} conventions.`);
+			}
 		}
 	},
 	// Received when an action is taken in the current active game
@@ -97,19 +134,27 @@ export const handle = {
 			setTimeout(() => state.take_action(state), 3000);
 		}
 	},
+	joined: (data) => {
+		const { tableID } = data;
+		state.tableID = tableID;
+	},
 	// Received at the beginning of the game, with information about the game
 	init: async (data) => {
 		const { tableID, playerNames, ourPlayerIndex, options } = data;
 		const variant = await getVariant(options.variantName);
 
 		// Initialize game state using convention set
-		const convention = process.env.MODE || 'HGroup';
-		state = new conventions[convention](tableID, playerNames, ourPlayerIndex, variant.suits);
+		state = new conventions[settings.convention](tableID, playerNames, ourPlayerIndex, variant.suits, settings.level);
 
 		Utils.globalModify({state});
 
 		// Ask the server for more info
 		Utils.sendCmd('getGameInfo2', { tableID: data.tableID });
+		gameStarted = true;
+	},
+	left: () => {
+		state.tableID = undefined;
+		gameStarted = false;
 	},
 	// Received when a table updates its information
 	table: (data) => {

src/conventions/h-group.js

@@ -24,6 +24,6 @@ export default class HGroup extends State {
 	}
 
 	createBlank() {
-		return new HGroup(this.tableID, this.playerNames, this.ourPlayerIndex, this.suits);
+		return new HGroup(this.tableID, this.playerNames, this.ourPlayerIndex, this.suits, this.level);
 	}
 }

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

@@ -81,7 +81,7 @@ function find_save(state, target, card) {
  * @returns {Clue | undefined} The TCM if valid, otherwise undefined.
  */
 function find_tcm(state, target, saved_cards, trash_card) {
-	logger.info(`saved cards ${saved_cards.map(c => Utils.logCard(c)).join(',')}, trash card ${Utils.logCard(trash_card)}`);
+	logger.info(`attempting tcm with trash card ${Utils.logCard(trash_card)}, saved cards ${saved_cards.map(c => Utils.logCard(c)).join(',')}`);
 	const chop = saved_cards.at(-1);
 
 	// Colour or rank save (if possible) is preferred over trash chop move
@@ -101,22 +101,17 @@ function find_tcm(state, target, saved_cards, trash_card) {
 		return;
 	}
 
-	let saved_trash = 0;
-	// At most 1 trash card should be saved
-	for (const card of saved_cards) {
-		const { suitIndex, rank, order } = card;
-
-		// Saving a trash card or two of the same card
-		if (isTrash(state, state.ourPlayerIndex, suitIndex, rank, order) ||
-			saved_cards.some(c => card.matches(c.suitIndex, c.rank) && card.order > c.order)
-		) {
-			saved_trash++;
-			logger.info(`would save trash ${Utils.logCard(card)}`);
-		}
-	}
+	const saved_trash = saved_cards.filter(card => {
+		const {suitIndex, rank, order} = card;
+
+		return isTrash(state, state.ourPlayerIndex, suitIndex, rank, order) ||					// Saving a trash card
+			saved_cards.some(c => card.matches(c.suitIndex, c.rank) && card.order > c.order);	// Saving 2 of the same card
+	}).map(c => Utils.logCard(c));
+
+	logger.info(`would save ${saved_trash.length === 0 ? 'no' : saved_trash.join()} trash`);
 
-	// There has to be more useful cards saved than trash cards, and a trash card should not be on chop (otherwise can wait)
-	if (saved_trash <= 1 && (saved_cards.length - saved_trash) > saved_trash) {
+	// There has to be more useful cards saved than trash cards
+	if (saved_trash.length <= 1 && (saved_cards.length - saved_trash.length) > saved_trash.length) {
 		const possible_clues = direct_clues(state, target, trash_card);
 
 		const tcm = possible_clues.find(clue => {
@@ -228,7 +223,6 @@ export function find_clues(state, options = {}) {
 				if (!options.ignoreCM && isBasicTrash(state, suitIndex, rank)) {
 					// Trash chop move (we only want to find the rightmost tcm)
 					if (!(card.clued || card.chop_moved) && cardIndex !== chopIndex && !found_tcm) {
-						logger.info('looking for tcm on', Utils.logCard(card));
 						const saved_cards = hand.slice(cardIndex + 1).filter(c => !(c.clued || c.chop_moved));
 						// Use original save clue if tcm not found
 						save_clues[target] = find_tcm(state, target, saved_cards, card) ?? save_clues[target];

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

@@ -69,8 +69,8 @@ export function determine_clue(state, target, target_card, options) {
 		const touch = hand.clueTouched(state.suits, clue);
 		const list = touch.map(c => c.order);
 
-		const bad_touch_cards = find_bad_touch(state, touch.filter(c => !c.clued));		// Ignore cards that were already clued
 		const { focused_card } = determine_focus(hand, list, { beforeClue: true });
+		const bad_touch_cards = find_bad_touch(state, touch.filter(c => !c.clued), focused_card.order);		// Ignore cards that were already clued
 
 		if (focused_card.order !== target_card.order) {
 			logger.info(`${Utils.logClue(clue)} doesn't focus, ignoring`);
@@ -83,9 +83,9 @@ export function determine_clue(state, target, target_card, options) {
 		// Prevent outputting logs until we know that the result is correct
 		logger.collect();
 
-		logger.info('------- ENTERING HYPO --------');
+		logger.info(`------- ENTERING HYPO ${Utils.logClue(clue)} --------`);
 
-		let hypo_state = state.simulate_clue(action, { enableLogs: true });
+		const hypo_state = state.simulate_clue(action, { enableLogs: true });
 
 		logger.info('------- EXITING HYPO --------');
 
@@ -153,23 +153,21 @@ export function determine_clue(state, target, target_card, options) {
 				}
 				else {
 					// Don't double count bad touch when cluing two of the same card
-					if (bad_touch_cards.some(c => c.matches(card.suitIndex, card.rank) && c.order > card.order)) {
+					// Focused card should not be bad touched?
+					if (bad_touch_cards.some(c => c.matches(card.suitIndex, card.rank) && c.order > card.order) || focused_card.order === card.order) {
 						continue;
 					}
 					bad_touch++;
 				}
 			}
 		}
 
-		// Re-simulate clue, but from our perspective so we can count the playable cards and finesses correctly
-		hypo_state = state.simulate_clue(action);
-
 		let finesses = 0;
 		const playables = [];
 
 		// Count the number of finesses and newly known playable cards
-		logger.info(`hypo stacks before clue: ${state.hypo_stacks}`);
-		logger.info(`hypo stacks after clue:  ${hypo_state.hypo_stacks}`);
+		logger.debug(`hypo stacks before clue: ${state.hypo_stacks}`);
+		logger.debug(`hypo stacks after clue:  ${hypo_state.hypo_stacks}`);
 		for (let suitIndex = 0; suitIndex < state.suits.length; suitIndex++) {
 			for (let rank = state.hypo_stacks[suitIndex] + 1; rank <= hypo_state.hypo_stacks[suitIndex]; rank++) {
 				// Find the card

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

@@ -1,3 +1,4 @@
+import { LEVEL } from '../h-constants.js';
 import { direct_clues } from './determine-clue.js';
 import { isBasicTrash, isSaved, isTrash, playableAway } from '../../../basics/hanabi-util.js';
 import logger from '../../../logger.js';
@@ -24,6 +25,11 @@ export function find_fix_clues(state, play_clues, save_clues, options = {}) {
 
 	for (let target = 0; target < state.numPlayers; target++) {
 		fix_clues[target] = [];
+
+		if (state.level <= LEVEL.FIX) {
+			continue;
+		}
+
 		// Ignore our own hand
 		if (target === state.ourPlayerIndex || target === options.ignorePlayerIndex) {
 			continue;

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

@@ -42,9 +42,9 @@ function find_playable(state, playerIndex, suitIndex, rank, ignoreOrders) {
 	return state.hands[playerIndex].find(card =>
 		!ignoreOrders.includes(card.order) &&
 		(card.inferred.every(c => playableAway(state, c.suitIndex, c.rank) === 0) || card.finessed) &&	// Card must be playable
-		playerIndex !== state.ourPlayerIndex ?
-			card.matches(suitIndex, rank) :								// If not in our hand, the card must match
-			card.inferred.some(c => c.matches(suitIndex, rank))			// If in our hand, at least one inference must match
+		(playerIndex !== state.ourPlayerIndex ?
+			card.matches(suitIndex, rank) :									// If not in our hand, the card must match
+			card.inferred.some(c => c.matches(suitIndex, rank)))			// If in our hand, at least one inference must match
 	);
 }
 
@@ -59,10 +59,8 @@ function find_playable(state, playerIndex, suitIndex, rank, ignoreOrders) {
  * @returns {Connection}
  */
 export function find_connecting(state, giver, target, suitIndex, rank, ignoreOrders = []) {
-	logger.info('looking for connecting', Utils.logCard({suitIndex, rank}));
-
 	if (state.discard_stacks[suitIndex][rank - 1] === cardCount(state.suits[suitIndex], rank)) {
-		logger.info('all cards in trash');
+		logger.info(`all ${Utils.logCard({suitIndex, rank})} in trash`);
 		return;
 	}
 
@@ -117,7 +115,7 @@ export function find_connecting(state, giver, target, suitIndex, rank, ignoreOrd
 			}
 			else if (finesse?.matches(suitIndex, rank)) {
 				// If target is after giver, then finesse must be in between. Otherwise, finesse must be outside.
-				if (state.level === 1 && !((target > giver) ? (giver < i && i < target) : (i < giver || i > target))) {
+				if (state.level === 1 && !inBetween(state.numPlayers, i, giver, target)) {
 					logger.warn(`found finesse ${Utils.logCard(finesse)} in ${state.playerNames[i]}'s hand, but not between giver and target`);
 					continue;
 				}
@@ -126,6 +124,19 @@ export function find_connecting(state, giver, target, suitIndex, rank, ignoreOrd
 			}
 		}
 	}
+
+	logger.info(`couldn't find connecting ${Utils.logCard({suitIndex, rank})}`);
+}
+
+function inBetween(numPlayers, playerIndex, giver, target) {
+	let i = (giver + 1) % numPlayers;
+	while(i !== target) {
+		if (i === playerIndex) {
+			return true;
+		}
+		i = (i + 1) % numPlayers;
+	}
+	return false;
 }
 
 /**

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

@@ -119,8 +119,8 @@ export function interpret_clue(state, action) {
 			interpret_tcm(state, target);
 			return;
 		}
-		// 5's chop move
-		else if (clue.type === CLUE.RANK && clue.value === 5 && focused_card.newly_clued) {
+		// 5's chop move - for now, 5cm cannot be done in early game.
+		else if (clue.type === CLUE.RANK && clue.value === 5 && focused_card.newly_clued && !state.early_game) {
 			if (interpret_5cm(state, target)) {
 				return;
 			}

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

@@ -27,15 +27,18 @@ export function interpret_tcm(state, target) {
 
 	logger.info(`oldest trash card is ${Utils.logCard(state.hands[target][oldest_trash_index])}`);
 
+	const cm_cards = [];
+
 	// Chop move every unclued card to the right of this
 	for (let i = oldest_trash_index + 1; i < state.hands[target].length; i++) {
 		const card = state.hands[target][i];
 
 		if (!card.clued) {
 			card.chop_moved = true;
-			logger.info(`trash chop move on ${Utils.logCard(card)}`);
+			cm_cards.push(Utils.logCard(card));
 		}
 	}
+	logger.info(`trash chop move on ${cm_cards.join(',')}`);
 }
 
 /**

src/conventions/h-group/hanabi-logic.js

@@ -133,13 +133,18 @@ export function determine_focus(hand, list, options = {}) {
  * @param {State} state
  * @param {Card[]} cards
  */
-export function find_bad_touch(state, cards) {
+export function find_bad_touch(state, cards, focusedCardOrder = -1) {
 	/** @type {Card[]} */
 	const bad_touch_cards = [];
 
 	for (const card of cards) {
 		let bad_touch = false;
 
+		// Assume focused card cannot be bad touched
+		if (card.order === focusedCardOrder) {
+			continue;
+		}
+
 		const { suitIndex, rank } = card;
 		// Card has already been played or can never be played
 		// Or someone else has the card finessed, clued or chop moved already
@@ -178,10 +183,7 @@ export function stall_severity(state, giver) {
 	if (state.clue_tokens === 7 && state.turn_count !== 0) {
 		return 4;
 	}
-	if (state.hands[giver].isLocked()) {
-		if (handLoaded(state, giver)) {
-			return 0;
-		}
+	if (state.hands[giver].isLocked() && !handLoaded(state, giver)) {
 		return 3;
 	}
 	if (state.early_game) {

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

@@ -118,8 +118,8 @@ export function take_action(state) {
 		return;
 	}
 
-	// Discard known trash at high pace
-	if (trash_cards.length > 0 && getPace(state) > state.numPlayers * 2) {
+	// Discard known trash at high pace, low clues
+	if (trash_cards.length > 0 && getPace(state) > state.numPlayers * 2 && state.clue_tokens <= 3) {
 		Utils.sendCmd('action', { tableID, type: ACTION.DISCARD, target: trash_cards[0].order });
 		return;
 	}

src/util.js

@@ -38,7 +38,8 @@ export function initConsole() {
 
 		process.stdout.write(key.sequence);
 		switch(key.sequence) {
-			case '\r': {
+			case '\r':
+			case '\n': {
 				console.log();
 				const parts = command.join('').split(' ');
 				const { state } = globals;