demostf/cutter
1
0
Fork 0
mirror of https://github.com/demostf/cutter.git synced 2026-06-03 20:04:07 +02:00
Code Issues Projects Releases Packages Wiki Activity

more baseline

Browse source
This commit is contained in:
Robin Appelman 2022-04-18 13:09:20 +02:00
commit aada3cac55
3 changed files with 64 additions and 51 deletions
Download patch file Download diff file Expand all files Collapse all files

54
src/entity.rs
View file

@ -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<EntityId, PacketEntity>; 2],
entities: HashMap<EntityId, PacketEntity>,
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<Item = PacketEntitiesMessage> {
pub fn encode(
mut self,
state: &ParserState,
) -> impl IntoIterator<Item = PacketEntitiesMessage> {
// baselines in reverse order
let mut baselines = [
encode_entities(self.baselines[0].clone().into_values().collect::<Vec<_>>()),
encode_entities(self.baselines[1].clone().into_values().collect::<Vec<_>>()),
encode_entities(
self.baselines[1].clone().into_values().collect::<Vec<_>>(),
self.max_entities,
),
encode_entities(
self.baselines[0].clone().into_values().collect::<Vec<_>>(),
self.max_entities,
),
];
for entity in self.entities.values_mut() {
entity.update_type = UpdateType::Enter;
}
let entities = encode_entities(self.entities.into_values().collect::<Vec<_>>());
let entities = encode_entities(
self.entities.into_values().collect::<Vec<_>>(),
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<PacketEntity>) -> PacketEntitiesMessage {
fn encode_entities(mut entities: Vec<PacketEntity>, 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![],

60
src/lib.rs
View file

@ -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<u8> {
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<u8> {
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 {