From d62f4be2aa92ae68a1ecfefc09df3f0f4ea1e29f Mon Sep 17 00:00:00 2001
From: Robin Appelman <robin@icewind.nl>
Date: Thu, 21 Apr 2022 19:59:22 +0200
Subject: [PATCH] mutators wip

---
 src/lib.rs    |  25 ++++++------
 src/mutate.rs | 108 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 120 insertions(+), 13 deletions(-)
 create mode 100644 src/mutate.rs

diff --git a/src/lib.rs b/src/lib.rs
index c27e114..a41da79 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,10 +1,12 @@
 #![allow(unused_imports)]
 
 mod entity;
+mod mutate;
 mod string_tables;
 mod utils;
 
 use crate::entity::ActiveEntities;
+use crate::mutate::{MutatorList, PacketMutator};
 use crate::string_tables::StringTablesUpdates;
 use crate::utils::set_panic_hook;
 use bitbuffer::{BitRead, BitWrite, BitWriteStream, LittleEndian};
@@ -204,6 +206,15 @@ pub fn cut(input: &[u8], start_tick: u32, end_tick: u32) -> Vec<u8> {
                 .unwrap();
         }
 
+        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
+            }
+        });
+
         remove_already_deletes(&mut next, &start_entities, last_server_tick);
         next.set_tick(next.tick() - start_tick);
         next.encode(&mut out_stream, &handler.state_handler)
@@ -217,19 +228,7 @@ pub fn cut(input: &[u8], start_tick: u32, end_tick: u32) -> Vec<u8> {
 
             remove_already_deletes(&mut packet, &start_entities, last_server_tick);
 
-            if let Packet::Message(msg_packet) = &mut packet {
-                let messages = take(&mut msg_packet.messages);
-                msg_packet.messages = messages
-                    .into_iter()
-                    .filter(|msg| {
-                        if let Message::UserMessage(usr_msg) = msg {
-                            UserMessageType::CloseCaption != usr_msg.message_type()
-                        } else {
-                            true
-                        }
-                    })
-                    .collect();
-            }
+            mutators.mutate_packet(&mut packet);
 
             if ty != PacketType::ConsoleCmd {
                 packet
diff --git a/src/mutate.rs b/src/mutate.rs
new file mode 100644
index 0000000..b369ec8
--- /dev/null
+++ b/src/mutate.rs
@@ -0,0 +1,108 @@
+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;
+}
+
+pub trait EntityMutator {
+    fn mutate_entity(&self, entity: &mut PacketEntity);
+}
+
+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<T: MessageMutator> From<T> for PacketMessageMutator<T> {
+    fn from(mutator: T) -> Self {
+        PacketMessageMutator { mutator }
+    }
+}
+
+impl<T: EntityMutator> MessageMutator for T {
+    fn mutate_message(&self, message: &mut Message) {
+        if let Message::PacketEntities(entity_message) = message {
+            entity_message
+                .entities
+                .iter_mut()
+                .for_each(|ent| self.mutate_entity(ent))
+        }
+    }
+}
+
+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_mutator<M: PacketMutator + 'static, T: Into<M>>(&mut self, mutator: T) {
+        self.mutators.push(Box::new(mutator.into()))
+    }
+
+    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);
+        }
+    }
+}