more preparation for encoders

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,26 +1,30 @@
 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) => {
-		const result = {
-			packetType: name,
-		};
-		try {
-			for (const group of items) {
-				const value = readItem(stream, group[1], result);
-				if (group[0] !== '_') {
-					result[group[0]] = value;
+	return {
+		parser: (stream) => {
+			const result = {
+				packetType: name,
+			};
+			try {
+				for (const group of items) {
+					const value = readItem(stream, group[1], result);
+					if (group[0] !== '_') {
+						result[group[0]] = value;
+					}
 				}
+			} catch (e) {
+				throw new Error('Failed reading pattern ' + definition + '. ' + e);
 			}
-		} catch (e) {
-			throw new Error('Failed reading pattern ' + definition + '. ' + e);
+			return result as Packet;
+		},
+		encoder: (packet, match, stream) => {
 		}
-		return result as Packet;
 	};
 }
 

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,