WIP: send memory only if it changed since last read.

src/sync/pokemon_rb.rs

@@ -18,13 +18,10 @@ pub struct Message {
     active_pkmn: Option<Vec<u8>>
 }
 
-impl From<&Raw<'_>> for Message {
-    fn from(src: &Raw) -> Self {
+impl From<&mut Raw<'_>> for Message {
+    fn from(src: &mut Raw) -> Self {
         Message {
-            active_pkmn: match &src.active_pokemon_raw.slice {
-                Some(m) => Some(m.to_vec()),
-                None => None
-            }
+            active_pkmn: src.active_pokemon_raw.get_copy_if_changed_since_last_read()
         }
 
     }
@@ -42,12 +39,46 @@ struct EmulatorMemory<'a> {
     length: usize,
     bank_switch: usize,
     pub slice: Option<&'a mut [u8]>,
+    last_read_value: Option<Vec<u8>>,
 }
 
 impl EmulatorMemory<'_> {
     pub fn update_slice(&mut self, map: &ReadWriteMemoryMap) {
         self.slice = map.get_slice_from_region(self.offset, self.length, self.bank_switch);
     }
+
+    pub fn get_copy_if_changed_since_last_read(&mut self) -> Option<Vec<u8>> {
+        match &mut self.slice {
+            None => None,
+            Some(data) => match &mut self.last_read_value {
+                None => {
+                    // last read value isn't allocated yet
+                    let mut last = vec![0; data.len()];
+                    last.copy_from_slice(data); // ??? sizes are mismatching here.
+                    self.last_read_value = Some(last);
+                    self.last_read_value.clone()
+                },
+                Some(last) => {
+                    let mut index: usize = 0;
+                    let mut any_changes = false;
+
+                    for value in data.into_iter() {
+                        if last[index] != *value { // index out of range for last. last is not None but has size of 0??????
+                            last[index] = *value;
+                            any_changes = true;
+                        }
+                        index += 1;
+                    }
+
+                    if any_changes {
+                        return Some(last.clone());
+                    }
+                    None
+                }
+            }
+        }
+
+    }
 }
 
 struct BattleContext {
@@ -74,7 +105,7 @@ impl SyncedPokemonRedBlue {
 
         self.battle_context = battle_context;
 
-        let message: Message = (&self.raw).into();
+        let message: Message = (&mut self.raw).into();
 
         match &mut self.comms {
             Some(comms) => {
@@ -92,6 +123,7 @@ impl SyncedPokemonRedBlue {
     fn handle_message(&mut self, msg: Message) -> Result<(), failure::Error> {
         match msg.active_pkmn {
             Some(src) => {
+                println!("message contains a new active pokemon. data: {:?}", &src);
                 let target_slice = self.raw.active_pokemon_raw.slice.as_mut().ok_or(failure::err_msg("can't write message back to None memory slice"))?;
                 if src.len() != target_slice.len() {
                     return Err(failure::err_msg("message size and slice size differ."));
@@ -127,18 +159,21 @@ impl Raw<'_> {
                 length: 0x27,
                 bank_switch: 0,
                 slice: None,
+                last_read_value: None,
             },
             player_and_party: EmulatorMemory {
                 offset: 0xd158,
                 length: 0x19e,
                 bank_switch: 0,
                 slice: None,
+                last_read_value: None,
             },
             pokemon_out: EmulatorMemory {
                 offset: 0xcc2f,
                 length: 0x1,
                 bank_switch: 0,
                 slice: None,
+                last_read_value: None,
             },
             memory_map: map
         }