Decode baselines when needed when encoding

src/Parser/Packet/PacketEntities.ts

@@ -77,11 +77,22 @@ function writeEnterPVS(entity: PacketEntity, stream: BitStream, state: ParserSta
 	stream.writeBits(serverClassId, getClassBits(state));
 	stream.writeBits(entity.serialNumber || 0, 10);
 
-	const cachedBaseLine = state.baseLineCache.get(serverClass);
-	const propsToEncode = cachedBaseLine ? entity.diffFromBaseLine(cachedBaseLine) : entity.props;
-
 	const sendTable = getSendTable(state, serverClass.dataTable);
 
+	let cachedBaseLine = state.baseLineCache.get(serverClass);
+	if (!cachedBaseLine) {
+		const staticBaseLine = state.staticBaseLines.get(serverClass.id);
+		if (staticBaseLine) {
+			cachedBaseLine = new PacketEntity(serverClass, entity.entityIndex, PVS.ENTER);
+			staticBaseLine.index = 0;
+			const props = getEntityUpdate(sendTable, staticBaseLine);
+			cachedBaseLine.applyPropUpdate(props);
+			state.baseLineCache.set(serverClass, cachedBaseLine.clone());
+		}
+	}
+
+	const propsToEncode = cachedBaseLine ? entity.diffFromBaseLine(cachedBaseLine) : entity.props;
+
 	encodeEntityUpdate(propsToEncode, sendTable, stream);
 }
 
@@ -95,6 +106,9 @@ function getPacketEntityForExisting(entityId: EntityId, state: ParserState, pvs:
 }
 
 export function ParsePacketEntities(stream: BitStream, state: ParserState, skip: boolean = false): PacketEntitiesPacket { // 26: packetEntities
+	// require('fs').writeFileSync('src/tests/data/packetEntitiesParserState.json', JSON.stringify(state), 'utf8');
+	// process.exit();
+
 	// https://github.com/skadistats/smoke/blob/master/smoke/replay/handler/svc_packetentities.pyx
 	// https://github.com/StatsHelix/demoinfo/blob/3d28ea917c3d44d987b98bb8f976f1a3fcc19821/DemoInfo/DP/Handler/PacketEntitesHandler.cs
 	// https://github.com/StatsHelix/demoinfo/blob/3d28ea917c3d44d987b98bb8f976f1a3fcc19821/DemoInfo/DP/Entity.cs
@@ -112,7 +126,7 @@ export function ParsePacketEntities(stream: BitStream, state: ParserState, skip:
 	const receivedEntities: PacketEntity[] = [];
 	const removedEntityIds: EntityId[] = [];
 
-	if (!skip) {
+	if (true) {
 		for (let i = 0; i < updatedEntries; i++) {
 			const diff = readUBitVar(stream);
 			entityId += 1 + diff;

src/tests/unit/Parser/Packet/PacketEntitiesTest.ts

@@ -15,6 +15,7 @@ const packetData = JSON.parse(gunzipSync(readFileSync(__dirname + '/../../../dat
 const sendTableData = JSON.parse(gunzipSync(readFileSync(__dirname + '/../../../data/packetEntitiesSendTables.json.gz')).toString('utf8'));
 const serverClassesData = JSON.parse(readFileSync(__dirname + '/../../../data/packetEntitiesServerClasses.json', 'utf8'));
 const baselineData: [number, number[]][] = JSON.parse(readFileSync(__dirname + '/../../../data/packetEntityBaseLines.json', 'utf8'));
+const playerEntityData = JSON.parse(readFileSync(__dirname + '/../../../data/packetEntitiesPlayerEntity.json', 'utf8'));
 
 const expected: PacketEntitiesPacket = {
 	packetType: 'packetEntities',
@@ -26,30 +27,34 @@ const expected: PacketEntitiesPacket = {
 	entities: packetData.entities.map(hydrateEntity)
 };
 
-const state = createParserState();
+function createTestParserState() {
-state.serverClasses.length = 348;
+	const state = createParserState();
-for (const serverClass of serverClassesData) {
+	state.serverClasses.length = 348;
-	state.serverClasses[serverClass.id] = new ServerClass(serverClass.id, serverClass.name, serverClass.dataTable);
+	for (const serverClass of serverClassesData) {
-}
+		state.serverClasses[serverClass.id] = new ServerClass(serverClass.id, serverClass.name, serverClass.dataTable);
-for (const sendTable of sendTableData) {
+	}
-	const table = hydrateTable(sendTable);
+	for (const sendTable of sendTableData) {
-	state.sendTables.set(table.name, table);
+		const table = hydrateTable(sendTable);
-}
+		state.sendTables.set(table.name, table);
+	}
 
-for (const entity of expected.entities) {
+	for (const entity of expected.entities) {
-	state.entityClasses.set(entity.entityIndex, entity.serverClass);
+		state.entityClasses.set(entity.entityIndex, entity.serverClass);
-}
+	}
 
-for (const [serverClassId, baseLine] of baselineData) {
+	for (const [serverClassId, baseLine] of baselineData) {
-	state.staticBaseLines.set(serverClassId, getStream(baseLine));
+		state.staticBaseLines.set(serverClassId, getStream(baseLine));
+	}
+
+	return state;
 }
 
 function parse(stream: BitStream) {
-	return ParsePacketEntities(stream, state);
+	return ParsePacketEntities(stream, createTestParserState());
 }
 
 function encode(value: PacketEntitiesPacket, stream: BitStream) {
-	EncodePacketEntities(value, stream, state);
+	EncodePacketEntities(value, stream, createTestParserState());
 }
 
 const sunEntityData = {
@@ -144,7 +149,11 @@ suite('PacketEntities', () => {
 	// });
 
 	// test('Encode packetEntities', () => {
-	// 	assertEncoder(parse, encode, expected, Math.ceil(data.length / 8));
+	// 	const toEncode = {...expected};
+	// 	const entity = toEncode.entities[1];
+	// 	// entity.props = [entity.props[0]];
+	// 	toEncode.entities = [entity];
+	// 	assertEncoder(parse, encode, toEncode, 11266);
 	// });
 
 
@@ -183,4 +192,30 @@ suite('PacketEntities', () => {
 			entities: []
 		}, 102);
 	});
+
+	test('Encode multiple packetEntities', () => {
+		const secondEntity = {...sunEntityData};
+		secondEntity.entityIndex++;
+		assertEncoder(parse, encode, {
+			packetType: 'packetEntities',
+			removedEntities: [],
+			updatedBaseLine: false,
+			baseLine: 0,
+			delta: 0,
+			maxEntries: 16,
+			entities: [hydrateEntity(sunEntityData), hydrateEntity(secondEntity)]
+		}, 351);
+	});
+
+	test('Encode player packetEntities', () => {
+		assertEncoder(parse, encode, {
+			packetType: 'packetEntities',
+			removedEntities: [],
+			updatedBaseLine: false,
+			baseLine: 0,
+			delta: 0,
+			maxEntries: 16,
+			entities: [hydrateEntity(playerEntityData)]
+		}, 3576);
+	});
 });