From aada3cac55700435c8f5f79a9939625230a51078 Mon Sep 17 00:00:00 2001 From: Robin Appelman Date: Mon, 18 Apr 2022 13:09:20 +0200 Subject: [PATCH] more baseline --- src/entity.rs | 54 +++++++++++++++++++++++-------------------- src/lib.rs | 60 +++++++++++++++++++++++++++--------------------- tests/reparse.rs | 1 + 3 files changed, 64 insertions(+), 51 deletions(-) diff --git a/src/entity.rs b/src/entity.rs index 3e7ac9e..471f0c4 100644 --- a/src/entity.rs +++ b/src/entity.rs @@ -4,18 +4,21 @@ use std::mem::replace; use tf_demo_parser::demo::message::packetentities::{ EntityId, PacketEntitiesMessage, PacketEntity, UpdateType, }; +use tf_demo_parser::demo::sendprop::SendPropIdentifier; use tf_demo_parser::ParserState; #[derive(Default)] pub struct ActiveEntities { baselines: [HashMap; 2], entities: HashMap, + max_entities: u16, } impl ActiveEntities { pub fn handle_message(&mut self, msg: &PacketEntitiesMessage, state: &ParserState) { + self.max_entities = self.max_entities.max(msg.max_entries); for entity in &msg.entities { - if entity.update_type == UpdateType::Delete { + if entity.update_type == UpdateType::Delete || entity.update_type == UpdateType::Leave { self.remove_entity(entity.entity_index); } else { self.handle_entity(entity, state); @@ -32,14 +35,18 @@ impl ActiveEntities { for entity in &msg.entities { if entity.update_type == UpdateType::Enter { - let entity = match self.baselines[old_index].get(&entity.entity_index) { - Some(baseline) if baseline.server_class == entity.server_class => { + let mut entity = match self.baselines[old_index].get(&entity.entity_index) { + Some(baseline) + if baseline.server_class == entity.server_class + && msg.delta.is_some() => + { let mut baseline = baseline.clone(); baseline.apply_update(&entity.props); baseline } _ => entity.clone(), }; + entity.baseline_props = vec![]; self.baselines[new_index].insert(entity.entity_index, entity); } } @@ -48,8 +55,6 @@ impl ActiveEntities { fn remove_entity(&mut self, entity_index: EntityId) { self.entities.remove(&entity_index); - self.baselines[0].remove(&entity_index); - self.baselines[1].remove(&entity_index); } fn handle_entity(&mut self, entity: &PacketEntity, state: &ParserState) { @@ -77,40 +82,39 @@ impl ActiveEntities { .or_insert_with(|| entity.clone()); } - pub fn encode(mut self) -> impl IntoIterator { + pub fn encode( + mut self, + state: &ParserState, + ) -> impl IntoIterator { + // baselines in reverse order let mut baselines = [ - encode_entities(self.baselines[0].clone().into_values().collect::>()), - encode_entities(self.baselines[1].clone().into_values().collect::>()), + encode_entities( + self.baselines[1].clone().into_values().collect::>(), + self.max_entities, + ), + encode_entities( + self.baselines[0].clone().into_values().collect::>(), + self.max_entities, + ), ]; for entity in self.entities.values_mut() { entity.update_type = UpdateType::Enter; } - let entities = encode_entities(self.entities.into_values().collect::>()); + let entities = encode_entities( + self.entities.into_values().collect::>(), + self.max_entities, + ); baselines[0].updated_base_line = true; - baselines[0].base_line = 1; //the baseline that is updated is the other one - baselines[1].base_line = 0; - - for ent in baselines[0] - .entities - .iter() - .chain(baselines[1].entities.iter()) - .chain(entities.entities.iter()) - { - if ent.entity_index == 650 { - // dbg!(ent.update_type, &ent.props); - } - } - baselines[1].updated_base_line = true; + baselines[1].base_line = 1; baselines.into_iter().chain(once(entities)) } } -fn encode_entities(mut entities: Vec) -> PacketEntitiesMessage { +fn encode_entities(mut entities: Vec, max_entries: u16) -> PacketEntitiesMessage { entities.sort_by(|a, b| a.entity_index.cmp(&b.entity_index)); - let max_entries = entities.len() as u16; PacketEntitiesMessage { entities, removed_entities: vec![], diff --git a/src/lib.rs b/src/lib.rs index f48632c..9454875 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -16,7 +16,7 @@ use tf_demo_parser::demo::packet::message::{MessagePacket, MessagePacketMeta}; use tf_demo_parser::demo::packet::stop::StopPacket; use tf_demo_parser::demo::packet::{Packet, PacketType}; use tf_demo_parser::demo::parser::{DemoHandler, Encode, NullHandler, RawPacketStream}; -use tf_demo_parser::Demo; +use tf_demo_parser::{Demo, MessageType}; use wasm_bindgen::prelude::*; use web_sys::console; @@ -82,27 +82,35 @@ pub fn cut(input: &[u8], start_tick: u32, end_tick: u32) -> Vec { panic!("first packet is not a MessagePacket") } - let msgs = entities.encode().into_iter().map(Message::PacketEntities); - let packet = Packet::Message(MessagePacket { - tick: 0, - messages: once(Message::NetTick(NetTickMessage { - tick: delta_tick, - frame_time: 1881, - std_dev: 263, - })) - .chain(msgs) - .collect(), - meta: MessagePacketMeta { - flags: 0, - view_angles: Default::default(), - sequence_in: 0, - sequence_out: 0, - }, + let msgs = entities + .encode(&start_handler.state_handler) + .into_iter() + .map(Message::PacketEntities); + let start_packets = msgs.map(|msg| { + Packet::Message(MessagePacket { + tick: 0, + messages: vec![ + Message::NetTick(NetTickMessage { + tick: delta_tick, + frame_time: 1881, + std_dev: 263, + }), + msg, + ], + meta: MessagePacketMeta { + flags: 0, + view_angles: Default::default(), + sequence_in: 0, + sequence_out: 0, + }, + }) }); - packet - .encode(&mut out_stream, &handler.state_handler) - .unwrap(); - handler.handle_packet(packet).unwrap(); + for packet in start_packets { + packet + .encode(&mut out_stream, &handler.state_handler) + .unwrap(); + handler.handle_packet(packet).unwrap(); + } // create the net ticks needed for later deltas let fill_ticks = ((delta_tick + 1)..=last_server_tick) @@ -151,11 +159,11 @@ pub fn cut(input: &[u8], start_tick: u32, end_tick: u32) -> Vec { let ty = packet.packet_type(); let original_tick = packet.tick(); packet.set_tick(original_tick - start_tick); - // if ty != PacketType::ConsoleCmd { - packet - .encode(&mut out_stream, &handler.state_handler) - .unwrap(); - // } + if ty != PacketType::ConsoleCmd { + packet + .encode(&mut out_stream, &handler.state_handler) + .unwrap(); + } handler.handle_packet(packet).unwrap(); if original_tick >= end_tick { diff --git a/tests/reparse.rs b/tests/reparse.rs index 07bd962..8824362 100644 --- a/tests/reparse.rs +++ b/tests/reparse.rs @@ -49,6 +49,7 @@ fn test_reparse_with_analyser= 50000 { break; } + // println!("tick {}", original_tick.tick); assert_eq!(original_tick.tick, cut_tick.tick + 30000); let original_state = &original_tick.state; let cut_state = &cut_tick.state;