feat: additional tracking (#91)

* feat: track turn duration

* refactor: discover events moved to a single parser class

* feat: implemented discover history

* feat: track match length

* fix(data): update cards.json (#90)

Co-authored-by: Tespa <[email protected]>

* fix(data): update cards.json (#92)

Co-authored-by: Tespa <[email protected]>

* fix(data): update cards.json (New data for Darkmoon) (#93)

* fix(data): update cards.json

* feat: update secrets.ts for new cards

Co-authored-by: Tespa <[email protected]>
Co-authored-by: Keiichiro Amemiya <[email protected]>

* feat: corruption and partial refactor

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Tespa <[email protected]>
Co-authored-by: Keiichiro Amemiya <[email protected]>

Author: 4 people

src/GameState.ts

@@ -8,10 +8,31 @@ const UNKNOWN_CARDNAME = 'UNKNOWN ENTITY [cardType=INVALID]';
  * Tests if a card name is empty or the "empty string"
  * @param cardName
  */
-const isEmpty = (cardName: string) => {
+const isEmpty = (cardName?: string) => {
 	return !cardName || cardName === UNKNOWN_CARDNAME;
 };
 
+/**
+ * Returns an array of special tags that can be used to communicate additional properties of a card.
+ * Currently the available properties deal with corruption.
+ * @param entity
+ */
+const identifySpecialTags = (entity: CardEntity | undefined) => {
+	if (!entity || !entity.tags) {
+		return;
+	}
+
+	// Tags are handled here. These are the "simplified" version.
+	const tags = new Array<EntityTags>();
+	if (entity.tags.CORRUPTEDCARD === '1') {
+		tags.push('corrupt');
+	} else if (entity.tags.CORRUPT === '1') {
+		tags.push('can-corrupt');
+	}
+
+	return tags.length > 0 ? tags : undefined;
+};
+
 export interface Secret {
 	cardId: string;
 	cardClass: Class;
@@ -34,52 +55,91 @@ export interface Card {
 	/**
 	 * ID used by logs to distinguish same cards
 	 */
-	cardEntityId: number;
+	entityId: number;
+
 	/**
 	 * Numeric ID for the card (same for same card)
 	 * Unknown card has this undefined
 	 */
 	cardId?: number;
+
 	/**
 	 * Unknown card has this undefined
 	 */
 	cardName?: string;
+
 	state: CardState;
+
 	/**
 	 * If card is originally from the deck
 	 */
 	readonly isSpawnedCard: boolean;
+
+	/**
+	 * Additional tags for when cards have special types
+	 */
+	tags?: EntityTags[];
+}
+
+type EntityTags = 'can-corrupt' | 'corrupt';
+
+export interface EntityProps {
+	entityId: number;
+	cardId?: number;
+	cardName: string;
+	player: 'top' | 'bottom';
+	damage?: number;
+	healing?: number;
+	dead?: boolean;
+
+	/**
+	 * Additional tags for when cards have special types
+	 */
+	tags?: EntityTags[];
+}
+
+/**
+ * Extracts a subset of entity data for presentational use.
+ * @param entity CardEntity to pull data from
+ */
+export const simplifyEntity = (entity: CardEntity): EntityProps => {
+	return {
+		cardId: entity.cardId,
+		cardName: entity.cardName,
+		entityId: entity.entityId,
+		player: entity.player
+	};
+};
+
+export interface Discovery {
+	enabled: boolean;
+	id: string | null;
+	source?: EntityProps;
+	chosen?: EntityProps;
+	options: EntityProps[];
 }
 
 export interface Player {
 	id: number;
 	name: string;
 	status: 'LOST' | 'WON' | 'TIED' | '';
 	turn: boolean;
+	turnHistory: Array<{
+		startTime: number;
+		duration?: number;
+	}>;
 	quests: Quest[];
 	timeout: number;
 	cardCount: number;
 	cards: Card[];
 	position: 'top' | 'bottom';
 	secrets: Secret[];
-	discovery: {
-		enabled: boolean;
-		id: string | null;
-	};
+	discovery: Discovery;
+	discoverHistory: Discovery[];
 	cardsReplacedInMulligan: number;
 	manaSpent: number;
 }
 
-export interface EntityProps {
-	cardId?: number;
-	cardName: string;
-	entityId: number;
-	player: 'top' | 'bottom';
-	damage?: number;
-	healing?: number;
-	dead?: boolean;
-}
-
 type MatchLogType = 'attack' | 'play' | 'trigger';
 
 export class MatchLogEntry {
@@ -117,25 +177,54 @@ export class MatchLogEntry {
 		this.targets.push(this.createProps(entity, ...props));
 	}
 
+	/**
+	 * Marks targets/sources using the death entries.
+	 * Returns the entity ids of the cards that were successfully marked.
+	 * @param deaths Entity IDs that need to be marked
+	 * @returns the subset of deaths that were present in this log entry
+	 */
+	markDeaths(deaths: Set<number>) {
+		const marked = new Set<number>();
+
+		if (deaths.has(this.source.entityId)) {
+			this.source.dead = true;
+			marked.add(this.source.entityId);
+		}
+
+		for (const target of this.targets) {
+			if (deaths.has(target.entityId)) {
+				target.dead = true;
+				marked.add(target.entityId);
+			}
+		}
+
+		return marked;
+	}
+
 	private createProps(entity: CardEntity, ...props: Array<Partial<EntityProps> | undefined>) {
-		return merge({
-			cardId: entity.cardId,
-			cardName: entity.cardName,
-			entityId: entity.entityId,
-			player: entity.player
-		}, ...props);
+		const tags = identifySpecialTags(entity);
+		const merged = merge(simplifyEntity(entity), ...props);
+		if (tags) {
+			merged.tags = tags;
+		}
+
+		return merged;
 	}
 }
 
 export class GameState {
 	startTime: number;
 
+	matchDuration: number;
+
 	playerCount: number;
 
 	gameOverCount: number;
 
 	players: Player[];
 
+	beginPhaseActive: boolean;
+
 	mulliganActive: boolean;
 
 	turnStartTime: Date;
@@ -177,6 +266,7 @@ export class GameState {
 	reset(): void {
 		this.players = [];
 		this.matchLog = [];
+		this.beginPhaseActive = true;
 		this.gameOverCount = 0;
 		this.#entities = {};
 		this.#missingEntityIds.clear();
@@ -248,22 +338,34 @@ export class GameState {
 	 * this handles the name resolution. Recommended place is the TAG_CHANGE event.
 	 * @param entity
 	 */
-	resolveEntity(entity: Pick<CardEntity, 'cardName' | 'entityId' | 'cardId'> & Partial<CardEntity>) {
+	resolveEntity(entity: Pick<CardEntity, 'entityId'> & Partial<CardEntity>) {
 		const existing = this.#entities[entity.entityId];
-		this.#entities[entity.entityId] = merge({
+		const newEntity = merge({
 			type: 'card',
 			tags: {},
-			player: 'bottom'
+			player: 'bottom',
+			cardName: ''
 		}, existing, entity);
 
-		const {cardName, entityId, cardId} = entity;
+		this.#entities[entity.entityId] = newEntity;
+		const {cardName, entityId, cardId} = newEntity;
 		const newProps = {entityId, cardName, cardId};
 
+		// Update player cards in case this entity updated any important tags (like corrupt)
+		for (const player of this.players) {
+			for (const card of player.cards.filter(c => c.entityId === entity.entityId)) {
+				const tags = identifySpecialTags(this.#entities[card.entityId]);
+				if (tags) {
+					card.tags = tags;
+				}
+			}
+		}
+
 		if (isEmpty(cardName) || !this.#missingEntityIds.has(entityId)) {
 			return;
 		}
 
-		// Update entities for each log entry
+		// Update entities for each match log entry (only card name, entity id, and card id)
 		for (const entry of this.matchLog) {
 			if (isEmpty(entry.source.cardName) && entry.source.entityId === entityId) {
 				entry.source = {...entry.source, ...newProps};

src/line-parsers/AbstractLineParser.ts

@@ -6,7 +6,7 @@ import {Events, HspEventsEmitter} from './index';
  * Root class of all classes that read lines and emit events.
  */
 export abstract class LineParser {
-	abstract readonly eventName: keyof Events;
+	abstract readonly eventName: string;
 
 	// eslint-disable-next-line @typescript-eslint/member-ordering
 	private _logger: debug.IDebugger;
@@ -27,10 +27,10 @@ export abstract class LineParser {
 }
 
 /**
- * Regex based parser class that exists for backwards compatibility.
- * Not a recommended way of solving it.
+ * Regex based parser class used to handle one time events
  */
 export abstract class AbstractLineParser extends LineParser {
+	abstract readonly eventName: keyof Events;
 	abstract readonly regex: RegExp;
 
 	// eslint-disable-next-line @typescript-eslint/member-ordering

src/line-parsers/card-init.ts

@@ -0,0 +1,39 @@
+import {LineParser} from './AbstractLineParser';
+import {HspEventsEmitter} from './index';
+import {GameState} from '../GameState';
+import {createSimpleRegexParser, FullEntityReader} from './readers';
+
+/**
+ * Handles when entities are first created to add the entries to the gamestate.
+ * Does nothing once mulligan phase has ended.
+ */
+export class CardInitParser extends LineParser {
+	eventName = 'card-init';
+
+	private readonly beginPhaseEndReader = createSimpleRegexParser(
+		/\[LoadingScreen\] MulliganManager.HandleGameStart\(\) - IsPastBeginPhase\(\)=False/,
+		_parts => ({ended: true})
+	);
+
+	private readonly fullEntityReader = new FullEntityReader('[Power] GameState.DebugPrintPower() -');
+
+	handleLine(_emitter: HspEventsEmitter, gameState: GameState, line: string): boolean {
+		// If this executes, the begin phase is done
+		if (this.beginPhaseEndReader(line)) {
+			gameState.beginPhaseActive = false;
+			return true;
+		}
+
+		// Does nothing if mulligan is inactive
+		// We should consider somehow detecting if we're in a block (aka only top level)
+		if (gameState.active && gameState.beginPhaseActive) {
+			const fullEntityResult = this.fullEntityReader.handleLine(line, gameState);
+			if (fullEntityResult.result) {
+				gameState.resolveEntity(fullEntityResult.result.entity);
+				return true;
+			}
+		}
+
+		return false;
+	}
+}