minor cleanup

src/Data/Match.ts

@@ -11,7 +11,7 @@ import {GameEventDefinition} from './GameEvent';
 import {EntityId, PacketEntity} from './PacketEntity';
 import {Player} from './Player';
 import {PlayerResource} from './PlayerResource';
-import {SendTable} from './SendTable';
+import {SendTable, SendTableName} from './SendTable';
 import {ServerClass} from './ServerClass';
 import {StringTable} from './StringTable';
 import {Team, TeamNumber} from './Team';
@@ -21,6 +21,7 @@ import {World} from './World';
 import {Round} from './Round';
 import {Chat} from './Chat';
 import {GameEvent} from './GameEventTypes';
+import {Packet} from './Packet';
 
 export class Match {
 	public tick: number = 0;
@@ -38,7 +39,7 @@ export class Match {
 	};
 	public playerEntityMap: Map<EntityId, Player> = new Map();
 	public entityClasses: Map<EntityId, ServerClass> = new Map();
-	public sendTables: Map<string, SendTable> = new Map();
+	public sendTables: Map<SendTableName, SendTable> = new Map();
 	public baseLineCache: Map<ServerClass, PacketEntity> = new Map();
 	public weaponMap: Map<EntityId, Weapon> = new Map();
 	public outerMap: Map<number, EntityId> = new Map();
@@ -91,7 +92,7 @@ export class Match {
 		};
 	}
 
-	public handlePacket(packet) {
+	public handlePacket(packet: Packet) {
 		switch (packet.packetType) {
 			case 'packetEntities':
 				handlePacketEntities(packet, this);

src/Data/Packet.ts

@@ -270,7 +270,43 @@ export type Packet = BSPDecalPacket |
 	PreFetchPacket |
 	GetCvarValuePacket;
 
-export enum PacketType {
+export type PacketType = Packet['packetType'];
+
+export type PacketMapType = {
+	bSPDecal: BSPDecalPacket;
+	stringTable: StringTablePacket;
+	createStringTable: CreateStringTablePacket;
+	updateStringTable: UpdateStringTablePacket;
+	dataTable: DataTablePacket;
+	classInfo: ClassInfoPacket;
+	entityMessage: EntityMessagePacket;
+	gameEvent: GameEventPacket;
+	gameEventList: GameEventListPacket;
+	packetEntities: PacketEntitiesPacket;
+	parseSounds: ParseSoundsPacket;
+	setConVar: SetConVarPacket;
+	tempEntities: TempEntitiesPacket;
+	userMessage: UserMessagePacket;
+	voiceInit: VoiceInitPacket;
+	voiceData: VoiceDataPacket;
+	menu: MenuPacket;
+	consoleCmd: ConsoleCmdPacket;
+	cmdKeyValues: CmdKeyValuesPacket;
+	'void': VoidPacket;
+	file: FilePacket;
+	netTick: NetTickPacket;
+	stringCmd: StringCmdPacket;
+	sigOnState: SigOnStatePacket;
+	print: PrintPacket;
+	serverInfo: ServerInfoPacket;
+	setPause: SetPausePacket;
+	setView: SetViewPacket;
+	fixAngle: FixAnglePacket;
+	preFetch: PreFetchPacket;
+	getCvarValue: GetCvarValuePacket;
+}
+
+export enum PacketTypeId {
 	file = 2,
 	netTick = 3,
 	stringCmd = 4,

src/Data/SendTable.ts

@@ -1,13 +1,15 @@
 import {SendPropDefinition, SendPropFlag, SendPropType} from './SendPropDefinition';
 
+export type SendTableName = string;
+
 export class SendTable {
-	public name: string;
+	public name: SendTableName;
 	public props: SendPropDefinition[];
 	private cachedFlattenedProps: SendPropDefinition[];
 
 	constructor(name) {
-		this.name            = name;
+		this.name = name;
-		this.props           = [];
+		this.props = [];
 		this.cachedFlattenedProps = [];
 	}
 
@@ -67,7 +69,7 @@ export class SendTable {
 
 	private flatten() {
 		const excludes: SendPropDefinition[] = this.excludes;
-		const props: SendPropDefinition[]    = [];
+		const props: SendPropDefinition[] = [];
 		this.getAllProps(excludes, props);
 
 		// sort often changed props before the others
@@ -75,8 +77,8 @@ export class SendTable {
 		for (let i = 0; i < props.length; i++) {
 			if (props[i].hasFlag(SendPropFlag.SPROP_CHANGES_OFTEN)) {
 				if (i !== start) {
-					const temp   = props[i];
+					const temp = props[i];
-					props[i]     = props[start];
+					props[i] = props[start];
 					props[start] = temp;
 				}
 				start++;

src/Demo.ts

@@ -1,7 +1,7 @@
 import {BitStream} from 'bit-buffer';
 import {Parser} from './Parser';
 import {StreamDemo} from './StreamDemo';
-import {PacketType} from './Data/Packet';
+import {PacketTypeId} from './Data/Packet';
 
 export {StreamDemo} from './StreamDemo';
 
@@ -30,9 +30,9 @@ export class Demo {
 	public getParser(fastMode: boolean = false) {
 		if (!this.parser) {
 			const skippedPackets = fastMode ? [
-				PacketType.packetEntities,
+				PacketTypeId.packetEntities,
-				PacketType.tempEntities,
+				PacketTypeId.tempEntities,
-				PacketType.entityMessage,
+				PacketTypeId.entityMessage,
 			] : [];
 			this.parser = new Parser(this.stream, skippedPackets);
 		}

src/Parser.ts

@@ -8,14 +8,14 @@ import {Packet} from './Parser/Message/Packet';
 import {Parser as MessageParser} from './Parser/Message/Parser';
 import {StringTable} from './Parser/Message/StringTable';
 import {UserCmd} from './Parser/Message/UserCmd';
-import {PacketType} from './Data/Packet';
+import {PacketTypeId} from './Data/Packet';
 
 export class Parser extends EventEmitter {
 	public stream: BitStream;
 	public match: Match;
-	protected skipPackets: PacketType[];
+	protected skipPackets: PacketTypeId[];
 
-	constructor(stream: BitStream, skipPackets: PacketType[] = []) {
+	constructor(stream: BitStream, skipPackets: PacketTypeId[] = []) {
 		super();
 		this.stream = stream;
 		this.match = new Match();

src/Parser/Message/Packet.ts

@@ -15,66 +15,66 @@ import {EncodeVoiceData, ParseVoiceData} from '../Packet/VoiceData';
 import {EncodeVoiceInit, ParseVoiceInit} from '../Packet/VoiceInit';
 import {Parser} from './Parser';
 
-import {Packet as IPacket, PacketType} from '../../Data/Packet';
+import {Packet as IPacket, PacketTypeId} from '../../Data/Packet';
 
 export class Packet extends Parser {
-	private static parsers: Map<PacketType, PacketHandler<IPacket>> = new Map([
+	private static parsers: Map<PacketTypeId, PacketHandler<IPacket>> = new Map([
-		[PacketType.file,
+		[PacketTypeId.file,
 			make('file', 'transferId{32}fileName{s}requested{b}')],
-		[PacketType.netTick,
+		[PacketTypeId.netTick,
 			make('netTick', 'tick{32}frameTime{16}stdDev{16}')],
-		[PacketType.stringCmd,
+		[PacketTypeId.stringCmd,
 			make('stringCmd', 'command{s}')],
-		[PacketType.setConVar,
+		[PacketTypeId.setConVar,
 			{parser: ParseSetConVar, encoder: EncodeSetConVar}],
-		[PacketType.sigOnState,
+		[PacketTypeId.sigOnState,
 			make('sigOnState', 'state{8}count{32}')],
-		[PacketType.print,
+		[PacketTypeId.print,
 			make('print', 'value{s}')],
-		[PacketType.serverInfo,
+		[PacketTypeId.serverInfo,
 			make('serverInfo',
 				'version{16}serverCount{32}stv{b}dedicated{b}maxCrc{32}maxClasses{16}' +
 				'mapHash{128}playerCount{8}maxPlayerCount{8}intervalPerTick{f32}platform{s1}' +
 				'game{s}map{s}skybox{s}serverName{s}replay{b}')],
-		[PacketType.classInfo,
+		[PacketTypeId.classInfo,
 			{parser: ParseClassInfo, encoder: EncodeClassInfo}],
-		[PacketType.setPause,
+		[PacketTypeId.setPause,
 			make('setPause', 'paused{b}')],
-		[PacketType.createStringTable,
+		[PacketTypeId.createStringTable,
 			{parser: ParseCreateStringTable, encoder: EncodeCreateStringTable}],
-		[PacketType.updateStringTable,
+		[PacketTypeId.updateStringTable,
 			{parser: ParseUpdateStringTable, encoder: EncodeUpdateStringTable}],
-		[PacketType.voiceInit,
+		[PacketTypeId.voiceInit,
 			{parser: ParseVoiceInit, encoder: EncodeVoiceInit}],
-		[PacketType.voiceData,
+		[PacketTypeId.voiceData,
 			{parser: ParseVoiceData, encoder: EncodeVoiceData}],
-		[PacketType.parseSounds,
+		[PacketTypeId.parseSounds,
 			{parser: ParseParseSounds, encoder: EncodeParseSounds}],
-		[PacketType.setView,
+		[PacketTypeId.setView,
 			make('setView', 'index{11}')],
-		[PacketType.fixAngle,
+		[PacketTypeId.fixAngle,
 			make('fixAngle', 'relative{b}x{16}y{16}z{16}')],
-		[PacketType.bspDecal,
+		[PacketTypeId.bspDecal,
 			{parser: ParseBSPDecal, encoder: EncodeBSPDecal}],
-		[PacketType.userMessage,
+		[PacketTypeId.userMessage,
 			{parser: ParseUserMessage, encoder: voidEncoder}],
-		[PacketType.entityMessage,
+		[PacketTypeId.entityMessage,
 			make('entityMessage', 'index{11}classId{9}length{11}data{$length}')],
-		[PacketType.gameEvent,
+		[PacketTypeId.gameEvent,
 			{parser: ParseGameEvent, encoder: voidEncoder}],
-		[PacketType.packetEntities,
+		[PacketTypeId.packetEntities,
 			{parser: ParsePacketEntities, encoder: voidEncoder}],
-		[PacketType.tempEntities,
+		[PacketTypeId.tempEntities,
 			{parser: ParseTempEntities, encoder: voidEncoder}],
-		[PacketType.preFetch,
+		[PacketTypeId.preFetch,
 			make('preFetch', 'index{14}')],
-		[PacketType.menu,
+		[PacketTypeId.menu,
 			make('menu', 'type{u16}length{u16}data{$length*8}')],
-		[PacketType.gameEventList,
+		[PacketTypeId.gameEventList,
 			{parser: ParseGameEventList, encoder: EncodeGameEventList}],
-		[PacketType.getCvarValue,
+		[PacketTypeId.getCvarValue,
 			make('getCvarValue', 'cookie{32}value{s}')],
-		[PacketType.cmdKeyValues,
+		[PacketTypeId.cmdKeyValues,
 			make('cmdKeyValues', 'length{32}data{$length}')],
 	]);
 
@@ -82,7 +82,7 @@ export class Packet extends Parser {
 		const packets: IPacket[] = [];
 		let lastPacketType = 0;
 		while (this.bitsLeft > 6) { // last 6 bits for NOOP
-			const type = this.stream.readBits(6) as PacketType;
+			const type = this.stream.readBits(6) as PacketTypeId;
 			if (type !== 0) {
 				const parser = Packet.parsers.get(type);
 				if (parser) {
@@ -90,7 +90,7 @@ export class Packet extends Parser {
 					const packet = parser.parser(this.stream, this.match, skip);
 					packets.push(packet);
 				} else {
-					throw new Error(`Unknown packet type ${type} just parsed a ${PacketType[lastPacketType]}`);
+					throw new Error(`Unknown packet type ${type} just parsed a ${PacketTypeId[lastPacketType]}`);
 				}
 				lastPacketType = type;
 			}

src/Parser/Message/Parser.ts

@@ -1,6 +1,6 @@
 import {BitStream} from 'bit-buffer';
 import {Match} from '../../Data/Match';
-import {Packet, PacketType} from '../../Data/Packet';
+import {Packet, PacketTypeId} from '../../Data/Packet';
 import {MessageType} from '../../Parser';
 
 export abstract class Parser {
@@ -9,9 +9,9 @@ export abstract class Parser {
 	protected stream: BitStream;
 	protected length: number;
 	protected match: Match;
-	protected skippedPackets: PacketType[];
+	protected skippedPackets: PacketTypeId[];
 
-	constructor(type: MessageType, tick: number, stream: BitStream, length: number, match: Match, skippedPacket: PacketType[] = []) {
+	constructor(type: MessageType, tick: number, stream: BitStream, length: number, match: Match, skippedPacket: PacketTypeId[] = []) {
 		this.type = type;
 		this.tick = tick;
 		this.stream = stream;

src/Parser/Packet/Parser.ts

@@ -1,6 +1,6 @@
 import {BitStream} from 'bit-buffer';
 import {Match} from '../../Data/Match';
-import {Packet, PacketType, VoidPacket} from '../../Data/Packet';
+import {Packet, VoidPacket} from '../../Data/Packet';
 
 export type Parser<P extends Packet> = (stream: BitStream, match?: Match, skip?: boolean) => P;
 export type Encoder<P extends Packet> = (packet: P, stream: BitStream, match?: Match) => void;

src/Parser/Packet/ParserGenerator.ts

@@ -1,8 +1,8 @@
-import {Packet} from '../../Data/Packet';
+import {Packet, PacketType} from '../../Data/Packet';
 import {Encoder, PacketHandler, Parser} from './Parser';
 import {BitStream} from 'bit-buffer';
 
-export function make<P extends Packet>(name: P['packetType'], definition: string): PacketHandler<P> {
+export function make<P extends Packet>(name: PacketType, definition: string): PacketHandler<P> {
 	const parts = definition.split('}');
 	const items = parts.map((part) => {
 		return part.split('{');