init

src/clean.rs

@@ -0,0 +1,14 @@
+use tf_demo_parser::demo::message::Message;
+use tf_demo_parser::demo::message::usermessage::UserMessageType;
+use crate::mutate::MutatorList;
+
+/// General cleanup we always want to do
+pub fn clean_demo(mutators: &mut MutatorList) {
+    mutators.push_message_filter(|message: &Message| {
+        if let Message::UserMessage(usr_message) = message {
+            UserMessageType::CloseCaption != usr_message.message_type()
+        } else {
+            true
+        }
+    });
+}

src/cond.rs

@@ -0,0 +1,73 @@
+use tf_demo_parser::demo::message::Message;
+use tf_demo_parser::demo::message::packetentities::{EntityId, PacketEntity};
+use tf_demo_parser::demo::sendprop::{SendPropIdentifier, SendPropValue};
+use tf_demo_parser::ParserState;
+use crate::mutate::MessageMutator;
+use crate::MutatorList;
+
+#[allow(dead_code)]
+#[derive(Copy, Clone, Debug)]
+#[repr(u8)]
+pub enum Cond {
+    Uber = 5,
+    UberDecay = 8,
+    Quickfix = 28,
+    Kritz = 11,
+    Jarate = 24,
+    Bleed = 25,
+}
+
+pub struct CondMask {
+    cond: i64,
+    entity: Option<EntityId>,
+}
+
+#[allow(dead_code)]
+impl CondMask {
+    pub fn new(entity: Option<EntityId>) -> Self {
+        CondMask {
+            cond: i64::MAX,
+            entity,
+        }
+    }
+
+    pub fn remove_cond(&mut self, cond: Cond) {
+        self.cond &= !(1 << cond as u8);
+    }
+}
+
+const PROP_ID: SendPropIdentifier = SendPropIdentifier::new("DT_TFPlayerShared", "m_nPlayerCond");
+
+impl CondMask {
+    fn mutate_entity(&self, entity: &mut PacketEntity) {
+        if Some(entity.entity_index) == self.entity || self.entity.is_none() {
+            entity
+                .props
+                .iter_mut()
+                .filter(|prop| prop.identifier == PROP_ID)
+                .for_each(|prop| {
+                    if let SendPropValue::Integer(value) = &mut prop.value {
+                        *value &= self.cond;
+                    }
+                })
+        }
+    }
+}
+
+impl MessageMutator for CondMask {
+    fn mutate_message(&self, message: &mut Message, _state: &ParserState) {
+        if let Message::PacketEntities(entity_message) = message {
+            entity_message
+                .entities
+                .iter_mut()
+                .for_each(|ent| self.mutate_entity(ent))
+        }
+    }
+}
+
+pub fn strip_cond(mutators: &mut MutatorList, entity: Option<EntityId>, mask: u32) {
+    mutators.push_message_mutator(CondMask {
+        entity,
+        cond: mask as i64,
+    });
+}

src/edit.rs

@@ -0,0 +1,17 @@
+use clap::Parser;
+use edit::{EditOptions, rust_edit};
+use std::fs;
+
+#[derive(Parser, Debug)]
+#[clap(author, version, about, long_about = None)]
+struct Args {
+    /// Path to the source demo
+    path: String,
+}
+
+fn main() {
+    let args = Args::parse();
+    let file = fs::read(&args.path).unwrap();
+    let output = rust_edit(&file, EditOptions::default());
+    fs::write("out.dem", output).unwrap();
+}

src/lib.rs

@@ -0,0 +1,111 @@
+mod mutate;
+mod pov;
+mod clean;
+mod cond;
+
+use wasm_bindgen::prelude::*;
+use tf_demo_parser::{Demo, DemoParser};
+use tf_demo_parser::demo::header::Header;
+use tf_demo_parser::demo::parser::{RawPacketStream, DemoHandler, Encode};
+use tf_demo_parser::demo::packet::PacketType;
+use bitbuffer::{BitRead, BitWriteStream, LittleEndian};
+use tf_demo_parser::demo::message::packetentities::EntityId;
+use serde::{Serialize, Deserialize};
+use bitbuffer::BitWrite;
+use crate::clean::clean_demo;
+use crate::cond::strip_cond;
+use crate::mutate::{MutatorList, PacketMutator};
+use crate::pov::unlock_pov;
+
+extern crate web_sys;
+
+// When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
+// allocator.
+#[cfg(feature = "wee_alloc")]
+#[global_allocator]
+static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
+
+fn set_panic_hook() {
+    // When the `console_error_panic_hook` feature is enabled, we can call the
+    // `set_panic_hook` function at least once during initialization, and then
+    // we will get better error messages if our code ever panics.
+    //
+    // For more details see
+    // https://github.com/rustwasm/console_error_panic_hook#readme
+    #[cfg(feature = "console_error_panic_hook")]
+    console_error_panic_hook::set_once();
+}
+
+#[derive(Debug, Serialize, Deserialize, Default)]
+pub struct EditOptions {
+    pub unlock_pov: bool,
+    pub remove_conditions: Vec<CondOptions>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CondOptions {
+    entity: u32,
+    mask: u32,
+}
+
+#[wasm_bindgen]
+pub fn edit(input: &[u8], options: JsValue) -> Vec<u8> {
+    set_panic_hook();
+    let options: EditOptions = options.into_serde().expect("invalid options");
+    rust_edit(input, options)
+}
+
+pub fn rust_edit(input: &[u8], options: EditOptions) -> Vec<u8> {
+    let mut out_buffer = Vec::with_capacity(input.len());
+    {
+        let mut out_stream = BitWriteStream::new(&mut out_buffer, LittleEndian);
+
+        let demo = Demo::new(&input);
+        let spectator_id = find_stv(&demo).expect("no stv bot found");
+        dbg!(spectator_id);
+
+        let mut stream = demo.get_stream();
+        let header = Header::read(&mut stream).unwrap();
+        header.write(&mut out_stream).unwrap();
+
+        let mut packets = RawPacketStream::new(stream.clone());
+        let mut handler = DemoHandler::default();
+        handler.handle_header(&header);
+
+        let mut mutators = MutatorList::new();
+        clean_demo(&mut mutators);
+
+        for cond_options in options.remove_conditions {
+            let entity = if cond_options.entity > 0 {
+                Some(EntityId::from(cond_options.entity))
+            } else {
+                None
+            };
+            strip_cond(&mut mutators, entity, cond_options.mask);
+        }
+
+        if options.unlock_pov {
+            unlock_pov(&mut mutators, spectator_id);
+        }
+
+
+        while let Some(mut packet) = packets.next(&handler.state_handler).unwrap() {
+            mutators.mutate_packet(&mut packet, &handler.state_handler);
+
+            if packet.packet_type() != PacketType::ConsoleCmd && packet.packet_type() != PacketType::UserCmd {
+                packet
+                    .encode(&mut out_stream, &handler.state_handler)
+                    .unwrap();
+            }
+            handler.handle_packet(packet).unwrap();
+        }
+    }
+    out_buffer
+}
+
+fn find_stv(demo: &Demo) -> Option<EntityId> {
+    let parser = DemoParser::new(demo.get_stream());
+    let (_, data) = parser.parse().expect("failed to parse demo");
+    data.users.values().find(|user| user.steam_id == "BOT")
+        .map(|user| user.entity_id)
+}

src/mutate.rs

@@ -0,0 +1,117 @@
+use std::mem::take;
+use tf_demo_parser::demo::message::Message;
+use tf_demo_parser::demo::packet::Packet;
+use tf_demo_parser::ParserState;
+
+pub trait PacketMutator {
+    fn mutate_packet(&self, packet: &mut Packet, state: &ParserState);
+}
+
+pub trait MessageMutator {
+    fn mutate_message(&self, message: &mut Message, state: &ParserState);
+}
+
+pub trait MessageFilter {
+    fn filter(&self, message: &Message) -> bool;
+}
+
+pub struct PacketMessageMutator<T: MessageMutator> {
+    pub mutator: T,
+}
+
+impl<T: MessageMutator> PacketMutator for PacketMessageMutator<T> {
+    fn mutate_packet(&self, packet: &mut Packet, state: &ParserState) {
+        match packet {
+            Packet::Message(msg_packet) | Packet::Signon(msg_packet) => {
+                msg_packet
+                    .messages
+                    .iter_mut()
+                    .for_each(|msg| self.mutator.mutate_message(msg, state));
+            },
+            _ => {}
+        }
+    }
+}
+
+impl<F: Fn(&mut Packet)> PacketMutator for F {
+    fn mutate_packet(&self, packet: &mut Packet, _state: &ParserState) {
+        self(packet)
+    }
+}
+
+impl<T: MessageMutator> From<T> for PacketMessageMutator<T> {
+    fn from(mutator: T) -> Self {
+        PacketMessageMutator { mutator }
+    }
+}
+
+impl<F: Fn(&mut Message)> MessageMutator for F {
+    fn mutate_message(&self, message: &mut Message, _state: &ParserState) {
+        self(message)
+    }
+}
+
+pub struct PacketMessageFilter<T: MessageFilter> {
+    pub filter: T,
+}
+
+impl<T: MessageFilter> PacketMutator for PacketMessageFilter<T> {
+    fn mutate_packet(&self, packet: &mut Packet, _state: &ParserState) {
+        match packet {
+            Packet::Message(msg_packet) | Packet::Signon(msg_packet) => {
+                let messages = take(&mut msg_packet.messages);
+                msg_packet.messages = messages
+                    .into_iter()
+                    .filter(|msg| self.filter.filter(msg))
+                    .collect();
+            }
+            _ => {}
+        }
+    }
+}
+
+impl<T: MessageFilter> From<T> for PacketMessageFilter<T> {
+    fn from(filter: T) -> Self {
+        PacketMessageFilter { filter }
+    }
+}
+
+impl<F: Fn(&Message) -> bool> MessageFilter for F {
+    fn filter(&self, message: &Message) -> bool {
+        self(message)
+    }
+}
+
+#[derive(Default)]
+pub struct MutatorList {
+    mutators: Vec<Box<dyn PacketMutator>>,
+}
+
+impl MutatorList {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn push_packet_mutator<M: PacketMutator + 'static>(&mut self, mutator: M) {
+        self.mutators.push(Box::new(mutator))
+    }
+
+    pub fn push_message_mutator<M: MessageMutator + 'static>(&mut self, mutator: M) {
+        self.mutators
+            .push(Box::new(PacketMessageMutator::from(mutator)))
+    }
+
+    pub fn push_message_filter<M: MessageFilter + 'static>(&mut self, filter: M) {
+        self.mutators
+            .push(Box::new(PacketMessageFilter::from(filter)))
+    }
+}
+
+impl PacketMutator for MutatorList {
+    fn mutate_packet(&self, packet: &mut Packet, state: &ParserState) {
+        for mutator in self.mutators.iter() {
+            mutator.mutate_packet(packet, state);
+        }
+    }
+}
+

src/pov.rs

@@ -0,0 +1,82 @@
+use std::cell::Cell;
+use tf_demo_parser::demo::message::Message;
+use tf_demo_parser::demo::message::packetentities::{EntityId, PacketEntity, UpdateType};
+use tf_demo_parser::demo::message::usermessage::{UserMessage};
+use tf_demo_parser::demo::packet::Packet;
+use tf_demo_parser::demo::sendprop::{SendPropIdentifier, SendPropValue};
+use tf_demo_parser::ParserState;
+use crate::mutate::{MessageMutator, MutatorList};
+
+struct AddStvEntity {
+    added: Cell<bool>,
+    entity_index: EntityId,
+}
+
+impl AddStvEntity {
+    pub fn new(entity_index: EntityId) -> AddStvEntity {
+        AddStvEntity {
+            added: Cell::new(false),
+            entity_index,
+        }
+    }
+}
+
+const TEAM_PROP: SendPropIdentifier = SendPropIdentifier::new("DT_BaseEntity", "m_iTeamNum");
+
+impl MessageMutator for AddStvEntity {
+    fn mutate_message(&self, message: &mut Message, state: &ParserState) {
+        if !self.added.get() {
+            if let Message::PacketEntities(ent_message) = message {
+                if ent_message.base_line == 0 {
+                    let player_entity = ent_message.entities.iter().find(|ent| ent.entity_index >= 1 && ent.entity_index < 255).expect("Failed to find a player entity");
+                    if player_entity.entity_index == self.entity_index {
+                        panic!("already an stv entity?");
+                    }
+                    let server_class = player_entity.server_class;
+
+                    let mut team_prop = player_entity.get_prop_by_identifier(&TEAM_PROP, state).unwrap().clone();
+                    team_prop.value = SendPropValue::Integer(1);
+
+                    ent_message.entities.push(PacketEntity {
+                        server_class,
+                        entity_index: self.entity_index,
+                        props: vec![team_prop],
+                        in_pvs: false,
+                        update_type: UpdateType::Enter,
+                        serial_number: 1234567,
+                        delay: None,
+                        delta: None,
+                        baseline_index: 0
+                    });
+                    ent_message.entities.sort_by(|a, b| a.entity_index.cmp(&b.entity_index));
+                    self.added.set(true);
+                }
+            }
+        }
+    }
+}
+
+pub fn unlock_pov(mutators: &mut MutatorList, spectator_id: EntityId) {
+    mutators.push_message_mutator(move |message: &mut Message| {
+        if let Message::ServerInfo(info) = message {
+            info.player_slot = u32::from(spectator_id) as u8 - 1;
+        }
+    });
+    mutators.push_message_filter(|message: &Message| {
+        !matches!(message, Message::SetView(_))
+    });
+    mutators.push_message_filter(|message: &Message| {
+        !matches!(message, Message::UserMessage(UserMessage::VGuiMenu(_)))
+    });
+    mutators.push_message_mutator(|message: &mut Message| {
+        if let Message::ServerInfo(info) = message {
+            info.stv = true;
+        }
+    });
+    mutators.push_packet_mutator(|packet: &mut Packet| {
+        if let Packet::Message(message_packet) = packet {
+            message_packet.meta.view_angles = Default::default();
+        };
+    });
+    mutators.push_message_mutator(AddStvEntity::new(spectator_id));
+}