1 files changed, 36 insertions, 36 deletions

diff --git a/src/server/navigation.rs b/src/server/navigation.rs
index f75c2b7..3813732 100644
--- a/src/server/navigation.rs
+++ b/src/server/navigation.rs
@@ -4,51 +4,51 @@ use std::io::Write;
 use std::io::BufRead;
 use std::collections::HashMap;
 
-use mass::Mass;
-use ship::Ship;
+use mass::{Mass, MassType};
 use math::distance;
 use connection::Connection;
 
 impl Connection {
-    pub fn server_navigation(&mut self, masses : &mut HashMap<String, Box<Mass>>) -> bool {
+    pub fn server_navigation(&mut self, masses : &mut HashMap<String, Mass>) -> bool {
         let masses_clone = masses.clone();
-        let mass = masses.get_mut(&self.name).unwrap();
-        let ship = mass.downcast_mut::<Ship>().unwrap();
-
-        match ship.recv_target() {
-            Some(name) => {
-                let target = masses_clone.get(&name).unwrap();
-                if distance(target.position(), ship.position()) > ship.recv_range() {
-                    ship.give_target(None);
+        let ship = masses.get_mut(&self.name).unwrap();
+        let ship_position = ship.position;
+
+        match ship.mass_type {
+            MassType::Ship{ref mut targeting, ..} => {
+                let target_name = targeting.clone().target;
+                match target_name {
+                    Some(target_name) => {
+                        let target = masses_clone.get(&target_name).unwrap();
+                        if distance(target.position, ship.position) > targeting.range {
+                            targeting.target = None;
+                        }
+                    },
+                    _ => (),
                 }
-            }
-            None => (),
-        }
 
-        let within_range : HashMap<&String, &Box<Mass>> = masses_clone.iter().filter(|&(_, mass)|
-                                                                                     distance(ship.position(), mass.position()) < ship.recv_range())
-                                                                                     .collect();
-        let mut send = String::new();
-        for (name, mass) in within_range {
-            send.push_str(name);
-            send.push_str("@");
-            send.push_str(&mass.serialize());
-            send.push_str(";");
-        }
-        send.push_str("\n");
-        match self.stream.write(send.as_bytes()) {
-            Ok(_result) => (),
-            Err(_error) => return false,
-        }
+                let within_range : HashMap<&String, &Mass> = masses_clone.iter().filter(|&(_, mass)|
+                                                                                        distance(ship_position, mass.position) < targeting.range)
+                                                                                        .collect();
 
-        let mut recv = String::new();
-        match self.buff_r.read_line(&mut recv) {
-            Ok(_result) => (),
-            Err(_error) => (),
-        }
-        if recv.len() > 0 {
-            ship.give_target(Some(recv.replace("\n", "")));
+                let send = serde_json::to_string(&within_range).unwrap() + "\n";
+                match self.stream.write(send.as_bytes()) {
+                    Ok(_result) => (),
+                    Err(_error) => return false,
+                }
+
+                let mut recv = String::new();
+                match self.buff_r.read_line(&mut recv) {
+                    Ok(_result) => (),
+                    Err(_error) => (),
+                }
+                if !recv.is_empty() {
+                    targeting.give_target(Some(recv.replace("\n", "")));
+                }
+            },
+            _ => (),
         }
+
         true
     }
 }