1 files changed, 50 insertions, 54 deletions

diff --git a/src/server/mining.rs b/src/server/mining.rs
index 06f2418..c02937a 100644
--- a/src/server/mining.rs
+++ b/src/server/mining.rs
@@ -6,8 +6,8 @@ use std::collections::HashMap;
 
 use math::distance;
 use mass::{Mass, MassType};
-use module::{Module, ModuleType};
 use server::connection::ServerConnection;
+use module::{Navigation, Mining};
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct MiningData {
@@ -24,8 +24,10 @@ impl ServerConnection {
         let ship_clone = ship.clone();
 
 
-        if let MassType::Ship{ref mut modules, ..} = ship.mass_type {
-            let mining_data = get_mining_data(ship_clone, modules, masses_clone);
+        if let MassType::Ship{ref mut mining, ref navigation, ..} = ship.mass_type {
+            let mut mining = mining.as_mut().unwrap();
+            let mut navigation = navigation.as_ref().unwrap();
+            let mining_data = get_mining_data(ship_clone, mining, navigation, masses_clone);
 
             let send = serde_json::to_string(&mining_data).unwrap() + "\n";
             match self.stream.write(send.as_bytes()) {
@@ -33,66 +35,60 @@ impl ServerConnection {
                 Err(_error) => return false,
             }
 
-            if let ModuleType::Mining{ref mut status, ..} = modules.get_mut("Mining").unwrap().module_type {
-                let mut recv = String::new();
-                match self.buff_r.read_line(&mut recv) {
-                    Ok(result) => match recv.as_bytes() {
-                        b"F\n" => {
-                            if mining_data.is_within_range {
-                                *status = !*status;
-                            }
-                        },
-                        _ => {
-                            if result == 0 {
-                                return false
-                            }
-                        },
-                    }
-                    Err(_error) => (),
+            let mut recv = String::new();
+            match self.buff_r.read_line(&mut recv) {
+                Ok(result) => match recv.as_bytes() {
+                    b"F\n" => {
+                        if mining_data.is_within_range {
+                            mining.toggle();
+                        }
+                    },
+                    _ => {
+                        if result == 0 {
+                            return false
+                        }
+                    },
                 }
+                Err(_error) => (),
             }
         }
         true
     }
 }
 
-fn get_mining_data(ship : Mass, modules : &mut HashMap<String, Module>, masses_clone : HashMap<String, Mass>) -> MiningData {
-    let mut mining_range = 0.0;
-    let mut mining_status = false;
-    if let ModuleType::Mining{ref range, ref status, ..} = modules.get("Mining").unwrap().module_type {
-        mining_range = *range;
-        mining_status = *status;
-    }
-
-    let mut has_astroid_target = false;
-    let mut is_within_range = false;
-    if let ModuleType::Navigation{ref target_name, ..} = modules.get("Navigation").unwrap().module_type {
-        match target_name.clone() {
-            Some(name) => {
-                let target = masses_clone.get(&name);
-                has_astroid_target = match target {
-                    Some(target) => match target.mass_type {
-                        MassType::Astroid{..} => true,
-                        _ => false,
-                    },
-                    None => false,
-                };
-                is_within_range = match has_astroid_target {
-                    true => match target {
-                        Some(target) => mining_range > distance(ship.position, target.position),
-                        _ => false,
-                    }
+fn get_mining_data(ship : Mass, mining : &Mining, navigation : &Navigation, masses_clone : HashMap<String, Mass>) -> MiningData {
+    match navigation.target_name.clone() {
+        Some(name) => {
+            let target = masses_clone.get(&name);
+            let has_astroid_target = match target {
+                Some(target) => match target.mass_type {
+                    MassType::Astroid{..} => true,
+                    _ => false,
+                },
+                None => false,
+            };
+            let is_within_range = match has_astroid_target {
+                true => match target {
+                    Some(target) => mining.range > distance(ship.position, target.position),
                     _ => false,
-                };
+                }
+                _ => false,
+            };
+
+            MiningData {
+                has_astroid_target  : has_astroid_target,
+                is_within_range     : is_within_range,
+                range               : mining.range,
+                status              : mining.status,
+            }
+        }
+        _ => {
+            MiningData {
+                has_astroid_target  : false,
+                is_within_range     : false,
+                range               : mining.range,
+                status              : mining.status,
             }
-            _ => (),
         }
-    }
-
-    MiningData {
-        has_astroid_target  : has_astroid_target,
-        is_within_range     : is_within_range,
-        range               : mining_range,
-        status              : mining_status,
     }
 }