add encoder for tempEntities

src/Parser/EntityDecoder.ts

@@ -31,7 +31,7 @@ export function encodeEntityUpdate(props: SendProp[], sendTable: SendTable, stre
 		stream.writeBoolean(true);
 		const index = allProps.findIndex(propDef => propDef.fullName === prop.definition.fullName);
 		if (index === -1) {
-			throw new Error('Unknown definition for property');
+			throw new Error(`Unknown definition for property ${prop.definition.fullName} in ${sendTable.name}`);
 		}
 		writeFieldIndex(index, stream, lastIndex);
 		lastIndex = index;

src/Parser/Message/Packet.ts

@@ -8,7 +8,7 @@ import {ParsePacketEntities} from '../Packet/PacketEntities';
 import {PacketHandler, voidEncoder} from '../Packet/Parser';
 import {EncodeParseSounds, ParseParseSounds} from '../Packet/ParseSounds';
 import {EncodeSetConVar, ParseSetConVar} from '../Packet/SetConVar';
-import {ParseTempEntities} from '../Packet/TempEntities';
+import {EncodeTempEntities, ParseTempEntities} from '../Packet/TempEntities';
 import {EncodeUpdateStringTable, ParseUpdateStringTable} from '../Packet/UpdateStringTable';
 import {EncodeUserMessage, ParseUserMessage} from '../Packet/UserMessage';
 import {EncodeVoiceData, ParseVoiceData} from '../Packet/VoiceData';
@@ -67,7 +67,7 @@ export class Packet extends Parser {
 		[PacketTypeId.packetEntities,
 			{parser: ParsePacketEntities, encoder: voidEncoder}],
 		[PacketTypeId.tempEntities,
-			{parser: ParseTempEntities, encoder: voidEncoder}],
+			{parser: ParseTempEntities, encoder: EncodeTempEntities}],
 		[PacketTypeId.preFetch,
 			make('preFetch', 'index{14}')],
 		[PacketTypeId.menu,

src/Parser/Packet/TempEntities.ts

@@ -2,47 +2,78 @@ import {BitStream} from 'bit-buffer';
 import {Match} from '../../Data/Match';
 import {TempEntitiesPacket} from '../../Data/Packet';
 import {PacketEntity, PVS} from '../../Data/PacketEntity';
-import {getEntityUpdate} from '../EntityDecoder';
-import {readVarInt} from '../readBitVar';
+import {encodeEntityUpdate, getEntityUpdate} from '../EntityDecoder';
+import {readVarInt, writeVarInt} from '../readBitVar';
+import {DynamicBitStream} from '../../DynamicBitStream';
 
 export function ParseTempEntities(stream: BitStream, match: Match, skip: boolean = false): TempEntitiesPacket { // 10: classInfo
-	const entityCount = stream.readBits(8);
+	const entityCount = stream.readUint8();
 	const length = readVarInt(stream);
-	const end = stream.index + length;
+	const entityData = stream.readBitStream(length);
 
 	let entity: PacketEntity | null = null;
 	const entities: PacketEntity[] = [];
 	if (!skip) {
 		for (let i = 0; i < entityCount; i++) {
-			const delay = (stream.readBoolean()) ? stream.readUint8() / 100 : 0; // unused it seems
-			if (stream.readBoolean()) {
-				const classId = stream.readBits(match.classBits);
+			const delay = (entityData.readBoolean()) ? entityData.readUint8() / 100 : 0; // unused it seems
+			if (entityData.readBoolean()) {
+				const classId = entityData.readBits(match.classBits);
 				const serverClass = match.serverClasses[classId - 1];
+				if (!serverClass) {
+					throw new Error(`Unknown serverClass ${classId}`);
+				}
 				// no clue why the -1 but it works
-				// maybe because world (id=0) can never be temp
-				// but it's not like the -1 saves any space
 				const sendTable = match.getSendTable(serverClass.dataTable);
 				entity = new PacketEntity(serverClass, 0, PVS.ENTER);
 				entity.delay = delay;
-				entity.props = getEntityUpdate(sendTable, stream);
+				entity.props = getEntityUpdate(sendTable, entityData);
 				entities.push(entity);
 			} else {
 				if (entity) {
-					const updatedProps = getEntityUpdate(match.getSendTable(entity.serverClass.dataTable), stream);
+					const updatedProps = getEntityUpdate(match.getSendTable(entity.serverClass.dataTable), entityData);
 					entity.applyPropUpdate(updatedProps);
 				} else {
 					throw new Error('no entity set to update');
 				}
 			}
 		}
-		if (end - stream.index > 8) {
-			throw new Error('unexpected content after TempEntities');
+		if (entityData.bitsLeft > 8) {
+			throw new Error(`unexpected content after TempEntities ${entityData.bitsLeft} bits`);
 		}
 	}
 
-	stream.index = end;
 	return {
 		packetType: 'tempEntities',
 		entities,
 	};
 }
+
+export function EncodeTempEntities(packet: TempEntitiesPacket, stream: BitStream, match: Match) {
+	stream.writeUint8(packet.entities.length);
+
+	const entityStream = new DynamicBitStream();
+	for (const entity of packet.entities) {
+		if (entity.delay) {
+			entityStream.writeBoolean(true);
+			entityStream.writeUint8(Math.round(entity.delay * 100));
+		} else {
+			entityStream.writeBoolean(false);
+		}
+
+		entityStream.writeBoolean(true);
+
+		const classId = match.serverClasses.findIndex(serverClass => serverClass && serverClass.name === entity.serverClass.name) + 1;
+		entityStream.writeBits(classId, match.classBits);
+
+		const sendTable = match.getSendTable(entity.serverClass.dataTable);
+
+		encodeEntityUpdate(entity.props, sendTable, entityStream);
+	}
+
+	const entityDataLength = entityStream.index;
+	entityStream.index = 0;
+
+	writeVarInt(entityDataLength, stream);
+
+	stream.writeBitStream(entityStream, entityDataLength);
+}

src/Parser/SendPropParser.ts

@@ -23,7 +23,7 @@ export class SendPropParser {
 			case SendPropType.DPT_Array:
 				return SendPropParser.readArray(propDefinition, stream);
 		}
-		throw new Error('Unknown property type');
+		throw new Error(`Unknown property type ${propDefinition.type}`);
 	}
 
 	public static readInt(propDefinition: SendPropDefinition, stream: BitStream) {