more preparation for encoders

src/Parser/Message/Packet.ts

@@ -9,7 +9,7 @@ import {ParseGameEvent} from '../Packet/GameEvent';
 import {ParseGameEventList} from '../Packet/GameEventList';
 import {ParseMenu} from '../Packet/Menu';
 import {ParsePacketEntities} from '../Packet/PacketEntities';
-import {PacketParserMap} from '../Packet/Parser';
+import {PacketParserMap, voidEncoder} from '../Packet/Parser';
 import {ParseParseSounds} from '../Packet/ParseSounds';
 import {ParseSetConVar} from '../Packet/SetConVar';
 import {ParseTempEntities} from '../Packet/TempEntities';
@@ -19,8 +19,6 @@ import {ParseVoiceData} from '../Packet/VoiceData';
 import {ParseVoiceInit} from '../Packet/VoiceInit';
 import {Parser} from './Parser';
 
-import {GameEventDefinitionMap} from '../../Data/GameEvent';
-
 import {Packet as IPacket} from '../../Data/Packet';
 
 // https://code.google.com/p/coldemoplayer/source/browse/branches/2.0/compLexity+Demo+Player/CDP.Source/Messages/?r=219
@@ -28,38 +26,39 @@ import {Packet as IPacket} from '../../Data/Packet';
 // https://github.com/stgn/netdecode/blob/master/Packet.cs
 // https://github.com/LestaD/SourceEngine2007/blob/master/src_main/common/netmessages.cpp
 
+
 export class Packet extends Parser {
 	private static parsers: PacketParserMap = {
 		2: ParserGenerator.make('file', 'transferId{32}fileName{s}requested{b}'),
 		3: ParserGenerator.make('netTick', 'tick{32}frameTime{16}stdDev{16}'),
 		4: ParserGenerator.make('stringCmd', 'command{s}'),
-		5:  ParseSetConVar,
+		5: {parser: ParseSetConVar, encoder: voidEncoder},
 		6: ParserGenerator.make('sigOnState', 'state{8}count{32}'),
 		7: ParserGenerator.make('print', 'value{s}'),
 		8: ParserGenerator.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}'),
-		10: ParseClassInfo,
+		10: {parser: ParseClassInfo, encoder: voidEncoder},
 		11: ParserGenerator.make('setPause', 'paused{b}'),
-		12: ParseCreateStringTable,
+		12: {parser: ParseCreateStringTable, encoder: voidEncoder},
-		13: ParseUpdateStringTable,
+		13: {parser: ParseUpdateStringTable, encoder: voidEncoder},
-		14: ParseVoiceInit,
+		14: {parser: ParseVoiceInit, encoder: voidEncoder},
-		15: ParseVoiceData,
+		15: {parser: ParseVoiceData, encoder: voidEncoder},
-		17: ParseParseSounds,
+		17: {parser: ParseParseSounds, encoder: voidEncoder},
 		18: ParserGenerator.make('setView', 'index{11}'),
 		19: ParserGenerator.make('fixAngle', 'relative{b}x{16}y{16}z{16}'),
-		21: ParseBSPDecal,
+		21: {parser: ParseBSPDecal, encoder: voidEncoder},
-		23: ParseUserMessage,
+		23: {parser: ParseUserMessage, encoder: voidEncoder},
-		24: ParseEntityMessage,
+		24: {parser: ParseEntityMessage, encoder: voidEncoder},
-		25: ParseGameEvent,
+		25: {parser: ParseGameEvent, encoder: voidEncoder},
-		26: ParsePacketEntities,
+		26: {parser: ParsePacketEntities, encoder: voidEncoder},
-		27: ParseTempEntities,
+		27: {parser: ParseTempEntities, encoder: voidEncoder},
 		28: ParserGenerator.make('preFetch', 'index{14}'),
-		29: ParseMenu,
+		29: {parser: ParseMenu, encoder: voidEncoder},
-		30: ParseGameEventList,
+		30: {parser: ParseGameEventList, encoder: voidEncoder},
 		31: ParserGenerator.make('getCvarValue', 'cookie{32}value{s}'),
-		32: ParseCmdKeyValues,
+		32: {parser: ParseCmdKeyValues, encoder: voidEncoder},
 	};
 
 	public parse() {
@@ -70,7 +69,7 @@ export class Packet extends Parser {
 			if (type !== 0) {
 				if (Packet.parsers[type]) {
 					const skip = this.skippedPackets.indexOf(type) !== -1;
-					const packet = Packet.parsers[type].call(this, this.stream, this.match, skip);
+					const packet = Packet.parsers[type].parser.call(this, this.stream, this.match, skip);
 					packets.push(packet);
 				} else {
 					throw new Error('Unknown packet type ' + type + ' just parsed a ' + PacketType[lastPacketType]);

src/Parser/Packet/EntityMessage.ts

@@ -7,8 +7,7 @@ import {EntityMessagePacket} from '../../Data/Packet';
 const baseParser = make('entityMessage', 'index{11}classId{9}length{11}data{$length}');
 
 export function ParseEntityMessage(stream: BitStream, match: Match): EntityMessagePacket { // 24: entityMessage
-	const basePacketData: EntityMessagePacket = baseParser(stream) as EntityMessagePacket;
 	// entity messages seem pretty unimportant, they are unreliable messages and from testing only the "clear decals"
 	// message seems to be used in practice, probably safe to just leave as is
-	return basePacketData; // todo parse data further?
+	return baseParser.parser(stream) as EntityMessagePacket;
 }

src/Parser/Packet/Parser.ts

@@ -3,7 +3,17 @@ import {Match} from '../../Data/Match';
 import {Packet} from '../../Data/Packet';
 
 export type Parser = (stream: BitStream, match?: Match, skip?: boolean) => Packet;
+export type Encoder = (packet: Packet, match: Match, stream: BitStream) => void;
+
+export interface PacketHandler {
+	parser: Parser,
+	encoder: Encoder
+}
+
+
+export const voidEncoder: Encoder = () => {
+};
 
 export interface PacketParserMap {
-	[id: number]: Parser;
+	[id: number]: PacketHandler;
 }

src/Parser/Packet/ParserGenerator.ts

@@ -1,12 +1,13 @@
 import {Packet} from '../../Data/Packet';
-import {Parser} from './Parser';
+import {PacketHandler, Parser} from './Parser';
 
-export function make(name: string, definition: string): Parser {
+export function make(name: string, definition: string): PacketHandler {
 	const parts = definition.substr(0, definition.length - 1).split('}'); // remove leading } to prevent empty part
 	const items = parts.map((part) => {
 		return part.split('{');
 	});
-	return (stream) => {
+	return {
+		parser: (stream) => {
 			const result = {
 				packetType: name,
 			};
@@ -21,6 +22,9 @@ export function make(name: string, definition: string): Parser {
 				throw new Error('Failed reading pattern ' + definition + '. ' + e);
 			}
 			return result as Packet;
+		},
+		encoder: (packet, match, stream) => {
+		}
 	};
 }
 

src/Parser/Packet/UserMessage.ts

@@ -2,6 +2,7 @@ import {BitStream} from 'bit-buffer';
 import {UserMessagePacket} from '../../Data/Packet';
 import {SayText2} from '../UserMessage/SayText2';
 import {make} from './ParserGenerator';
+import {voidEncoder} from './Parser';
 
 enum UserMessageType {
 	Geiger = 0,
@@ -65,7 +66,7 @@ enum UserMessageType {
 }
 
 const userMessageParsers = {
-	4: SayText2,
+	4: {parser: SayText2, voidEncoder},
 	5: make('textMsg', 'destType{8}text{s}'),
 };
 
@@ -74,7 +75,7 @@ export function ParseUserMessage(stream: BitStream): UserMessagePacket { // 23:
 	const length = stream.readBits(11);
 	const messageData = stream.readBitStream(length);
 
-	return userMessageParsers[type] ? userMessageParsers[type](messageData) : {
+	return userMessageParsers[type] ? userMessageParsers[type].parser(messageData) : {
 		packetType: 'unknownUserMessage',
 		type,
 		data: messageData,