🚧 Continue working state

ed-journals/src/modules/logs/content/log_event_content.rs

@@ -871,6 +871,8 @@ impl LogEventContent {
             LogEventContent::ScanBaryCentre(event) => event.body_id,
             LogEventContent::Scan(event) => event.body_id,
             LogEventContent::Touchdown(event) => event.body_id,
+            LogEventContent::ScanOrganic(event) => event.body,
+            LogEventContent::Touchdown(event) => event.body_id,
             _ => return None,
         })
     }

ed-journals/src/modules/logs/content/log_event_content/saa_signals_found_event.rs

@@ -10,13 +10,13 @@ pub struct SAASignalsFoundEvent {
 
     #[serde(rename = "BodyID")]
     pub body_id: u8,
-    pub signals: Vec<SAAScanCompleteEventSignal>,
-    pub genuses: Vec<SAAScanCompleteEventGenus>,
+    pub signals: Vec<SAASignalsFoundEventSignal>,
+    pub genuses: Vec<SAASignalsFoundEventGenus>,
 }
 
 #[derive(Debug, Deserialize, Clone, PartialEq)]
 #[serde(rename_all = "PascalCase")]
-pub struct SAAScanCompleteEventSignal {
+pub struct SAASignalsFoundEventSignal {
     #[serde(rename = "Type")]
     pub kind: PlanetarySignalType,
 
@@ -27,7 +27,7 @@ pub struct SAAScanCompleteEventSignal {
 
 #[derive(Debug, Deserialize, Clone, PartialEq)]
 #[serde(rename_all = "PascalCase")]
-pub struct SAAScanCompleteEventGenus {
+pub struct SAASignalsFoundEventGenus {
     pub genus: Genus,
 
     #[serde(rename = "Genus_Localised")]

ed-journals/src/modules/logs/content/log_event_content/scan_organic_event.rs

@@ -31,7 +31,7 @@ pub struct ScanOrganicEvent {
     pub body: u8,
 }
 
-#[derive(Debug, Deserialize, Clone, PartialEq)]
+#[derive(Debug, Deserialize, Clone, PartialEq, Ord, PartialOrd, Eq)]
 #[serde(rename_all = "PascalCase")]
 pub enum ScanOrganicEventScanType {
     Sample,

ed-journals/src/modules/state/models/body_state.rs

@@ -1,6 +1,70 @@
+use std::collections::HashMap;
 use crate::logs::content::log_event_content::scan_event::ScanEvent;
+use crate::logs::content::{LogEvent, LogEventContent};
+use crate::logs::content::log_event_content::fss_body_signals_event::FSSBodySignalEventSignal;
+use crate::logs::content::log_event_content::saa_scan_complete_event::SAAScanCompleteEvent;
+use crate::logs::content::log_event_content::saa_signals_found_event::{SAASignalsFoundEventGenus, SAASignalsFoundEventSignal};
+use crate::shared::exploration::genus::Genus;
+use crate::shared::exploration::species::Species;
+use crate::state::models::feed_result::FeedResult;
 
 #[derive(Debug)]
 pub struct BodyState {
     pub scan: ScanEvent,
+
+    pub fss_signals: Vec<FSSBodySignalEventSignal>,
+
+    pub saa_scan: Option<SAAScanCompleteEvent>,
+    pub saa_signals: Vec<SAASignalsFoundEventSignal>,
+    pub saa_genuses: Vec<Genus>,
+
+    // pub scanned_organics: HashMap<>
+
+    // pub confirmed_species: Vec<Species>,
+    // pub variants_species: Vec<Species>,
+    // pub scanned_organics: Vec<>
+}
+
+impl BodyState {
+    pub fn new(scan_event: ScanEvent) -> Self {
+        BodyState {
+            scan: scan_event,
+            fss_signals: Vec::new(),
+            saa_scan: None,
+            saa_signals: Vec::new(),
+            saa_genuses: Vec::new(),
+        }
+    }
+
+    pub fn feed_log_event(&mut self, log_event: &LogEvent) -> FeedResult {
+        let Some(body_id) = log_event.content.body_id() else {
+            return FeedResult::Skipped;
+        };
+
+        if body_id != self.scan.body_id {
+            return FeedResult::Skipped;
+        }
+
+        match &log_event.content {
+            LogEventContent::SAAScanComplete(scan_complete) => {
+                self.saa_scan = Some(scan_complete.clone());
+            },
+            LogEventContent::SAASignalsFound(signals) => {
+                self.saa_signals = signals.signals.clone();
+                self.saa_genuses = signals.genuses.iter()
+                    .map(|signal| signal.genus.clone())
+                    .collect();
+            },
+            LogEventContent::FSSBodySignals(body_signals) => {
+                self.fss_signals = body_signals.signals.clone();
+            },
+            LogEventContent::ScanOrganic(scanned_organic) => {
+
+            },
+
+            _ => {},
+        }
+
+        FeedResult::Accepted
+    }
 }

ed-journals/src/modules/state/models/commander_state.rs

@@ -12,13 +12,15 @@ pub struct CommanderState {
     pub fid: String,
     pub name: String,
     pub systems: HashMap<u64, SystemState>,
-    pub queued_events: Vec<LogEvent>,
+    pub current_system: Option<u64>,
 }
 
 impl CommanderState {
     pub fn feed_log_event(&mut self, log_event: &LogEvent) -> FeedResult {
         match &log_event.content {
             LogEventContent::Location(location) => {
+                self.current_system = Some(location.system_info.system_address);
+
                 let system = self.upset_system(&location.system_info);
                 system.visit(&log_event.timestamp);
             },
@@ -27,6 +29,8 @@ impl CommanderState {
                 system.carrier_visit(&log_event.timestamp);
             },
             LogEventContent::FSDJump(fsd_jump) => {
+                self.current_system = Some(fsd_jump.system_info.system_address);
+
                 let system = self.upset_system(&fsd_jump.system_info);
                 system.visit(&log_event.timestamp);
             },
@@ -53,6 +57,10 @@ impl CommanderState {
         self.systems.get_mut(&system_info.system_address)
             .expect("Should have been added")
     }
+
+    pub fn current_system(&self) -> Option<&SystemState> {
+        self.systems.get(&self.current_system?)
+    }
 }
 
 
@@ -83,7 +91,7 @@ impl From<&CommanderEvent> for CommanderState {
             fid: value.fid.to_string(),
             name: value.name.to_string(),
             systems: HashMap::new(),
-            queued_events: Vec::new(),
+            current_system: None,
         }
     }
 }

ed-journals/src/modules/state/models/system_state.rs

@@ -44,14 +44,18 @@ impl SystemState {
             },
             LogEventContent::Scan(event) => {
                 if !self.bodies.contains_key(&event.body_id) {
-                    self.bodies.insert(event.body_id, BodyState {
-                        scan: event.clone(),
-                    });
+                    self.bodies.insert(event.body_id, BodyState::new(event.clone()));
                 }
             },
 
             _ => {
+                if let Some(body_id) = log_event.content.body_id() {
+                    let Some(body) = self.bodies.get_mut(&body_id) else {
+                        return FeedResult::Later;
+                    };
 
+                    return body.feed_log_event(log_event);
+                }
             }
         }