strip captions

src/lib.rs

@@ -1,3 +1,5 @@
+mod mutate;
+
 use wasm_bindgen::prelude::*;
 use tf_demo_parser::{Demo};
 use tf_demo_parser::demo::header::Header;
@@ -6,7 +8,9 @@ use tf_demo_parser::demo::packet::{Packet, PacketType};
 use tf_demo_parser::demo::message::Message;
 use bitbuffer::{BitWriteStream, LittleEndian, BitRead, BitWrite};
 use tf_demo_parser::demo::message::packetentities::PacketEntitiesMessage;
+use tf_demo_parser::demo::message::usermessage::UserMessageType;
 use tf_demo_parser::demo::sendprop::{SendProp, SendPropIdentifier, SendPropValue};
+use crate::mutate::{MutatorList, PacketMutator};
 
 extern crate web_sys;
 
@@ -49,6 +53,15 @@ pub fn unlock(input: &[u8]) -> Vec<u8> {
 
         let mut local_player_entity_id = None;
 
+        let mut mutators = MutatorList::new();
+        mutators.push_message_filter(|message: &Message| {
+            if let Message::UserMessage(usr_message) = message {
+                UserMessageType::CloseCaption != usr_message.message_type()
+            } else {
+                true
+            }
+        });
+
         while let Some(mut packet) = packets.next(&handler.state_handler).unwrap() {
             match &mut packet {
                 Packet::Signon(message_packet) | Packet::Message(message_packet) => {
@@ -93,6 +106,8 @@ pub fn unlock(input: &[u8]) -> Vec<u8> {
                 _ => {}
             }
 
+            mutators.mutate_packet(&mut packet);
+
             if packet.packet_type() != PacketType::ConsoleCmd && packet.packet_type() != PacketType::UserCmd {
                 packet
                     .encode(&mut out_stream, &handler.state_handler)

src/mutate.rs

@@ -0,0 +1,110 @@
+use std::mem::take;
+use tf_demo_parser::demo::message::packetentities::PacketEntity;
+use tf_demo_parser::demo::message::Message;
+use tf_demo_parser::demo::packet::Packet;
+
+pub trait PacketMutator {
+    fn mutate_packet(&self, packet: &mut Packet);
+}
+
+pub trait MessageMutator {
+    fn mutate_message(&self, message: &mut Message);
+}
+
+pub trait MessageFilter {
+    fn filter(&self, message: &Message) -> bool;
+}
+
+struct PacketMessageMutator<T: MessageMutator> {
+    mutator: T,
+}
+
+impl<T: MessageMutator> PacketMutator for PacketMessageMutator<T> {
+    fn mutate_packet(&self, packet: &mut Packet) {
+        if let Packet::Message(msg_packet) = packet {
+            msg_packet
+                .messages
+                .iter_mut()
+                .for_each(|msg| self.mutator.mutate_message(msg));
+        }
+    }
+}
+
+impl<F: Fn(&mut Packet)> PacketMutator for F {
+    fn mutate_packet(&self, packet: &mut Packet) {
+        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) {
+        self(message)
+    }
+}
+
+struct PacketMessageFilter<T: MessageFilter> {
+    filter: T,
+}
+
+impl<T: MessageFilter> PacketMutator for PacketMessageFilter<T> {
+    fn mutate_packet(&self, packet: &mut Packet) {
+        if let Packet::Message(msg_packet) = 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) {
+        for mutator in self.mutators.iter() {
+            mutator.mutate_packet(packet);
+        }
+    }
+}