use stricter interface for parser state

src/Data/Match.ts

@@ -22,8 +22,9 @@ import {Round} from './Round';
 import {Chat} from './Chat';
 import {Packet} from './Packet';
 import {GameEventType} from './GameEventTypes';
+import {ParserState} from './ParserState';
 
-export class Match {
+export class Match implements ParserState {
 	public tick: number = 0;
 	public chat: Chat[] = [];
 	public users: Map<number, UserInfo> = new Map();
@@ -51,23 +52,6 @@ export class Match {
 	public stringTables: StringTable[] = [];
 	public serverClasses: ServerClass[] = [];
 
-	public getSendTable(name) {
-		const table = this.sendTables.get(name);
-		if (table) {
-			return table;
-		}
-		throw new Error('unknown SendTable ' + name);
-	}
-
-	public getStringTable(name) {
-		for (const table of this.stringTables) {
-			if (table.name === name) {
-				return table;
-			}
-		}
-		return null;
-	}
-
 	public getState() {
 		const users = {};
 		for (const [key, user] of this.users.entries()) {
@@ -161,17 +145,4 @@ export class Match {
 		}
 		throw new Error('User not found for entity ' + entity.entityIndex);
 	}
-
-	public getPlayerByUserId(userId: number): Player {
-		for (const player of this.playerEntityMap.values()) {
-			if (player.user.userId === userId) {
-				return player;
-			}
-		}
-		throw new Error('player not found for user id');
-	}
-
-	get classBits() {
-		return Math.ceil(Math.log(this.serverClasses.length) * Math.LOG2E);
-	}
 }

src/Data/ParserState.ts

@@ -0,0 +1,52 @@
+import {BitStream} from 'bit-buffer';
+import {GameEventDefinition} from './GameEvent';
+import {EntityId, PacketEntity} from './PacketEntity';
+import {SendTable, SendTableName} from './SendTable';
+import {ServerClass, ServerClassId} from './ServerClass';
+import {StringTable} from './StringTable';
+import {GameEventType} from './GameEventTypes';
+
+export interface ParserState {
+	staticBaseLines: Map<ServerClassId, BitStream>;
+	eventDefinitions: Map<number, GameEventDefinition<GameEventType>>;
+	entityClasses: Map<EntityId, ServerClass>;
+	sendTables: Map<SendTableName, SendTable>;
+	version: number;
+	stringTables: StringTable[];
+	serverClasses: ServerClass[];
+	baseLineCache: Map<ServerClass, PacketEntity>;
+}
+
+export function getClassBits(state: ParserState) {
+	return Math.ceil(Math.log(state.serverClasses.length) * Math.LOG2E);
+}
+
+export function getSendTable(state: ParserState, dataTable: string): SendTable {
+	const sendTable = state.sendTables.get(dataTable);
+	if (!sendTable) {
+		throw new Error(`Unknown sendTable ${dataTable}`);
+	}
+	return sendTable;
+}
+
+export function createParserState(): ParserState {
+	return {
+		staticBaseLines: new Map(),
+		eventDefinitions: new Map(),
+		entityClasses: new Map(),
+		sendTables: new Map(),
+		version: 0,
+		stringTables: [],
+		serverClasses: [],
+		baseLineCache: new Map()
+	};
+}
+
+export function getStringTable(state: ParserState, name: string) {
+	for (const table of state.stringTables) {
+		if (table.name === name) {
+			return table;
+		}
+	}
+	return null;
+}