summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/astroid.rs26
-rw-r--r--src/bin/client.rs4
-rw-r--r--src/connection.rs3
-rw-r--r--src/engines.rs18
-rw-r--r--src/item.rs14
-rw-r--r--src/lib.rs3
-rw-r--r--src/mass.rs3
-rw-r--r--src/mining.rs124
-rw-r--r--src/module.rs1
-rw-r--r--src/navigation.rs6
-rw-r--r--src/ship.rs96
-rw-r--r--src/storage.rs16
-rw-r--r--src/targeting.rs14
13 files changed, 283 insertions, 45 deletions
diff --git a/src/astroid.rs b/src/astroid.rs
index 5b2a3b3..ef1d401 100644
--- a/src/astroid.rs
+++ b/src/astroid.rs
@@ -4,15 +4,18 @@ use astroid::rand::distributions::Sample;
extern crate rand;
extern crate serde_json;
-use mass::{Mass, Type};
+use storage::Storage;
use astroid::rand::Rng;
+use mass::{Mass, MassType};
+use item::Item;
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Astroid {
name : String,
- mass_type : Type,
+ mass_type : MassType,
position : (f64, f64, f64),
velocity : (f64, f64, f64),
+ resouces : Storage,
}
impl Astroid {
@@ -21,16 +24,25 @@ impl Astroid {
.gen_ascii_chars()
.take(8)
.collect();
- let mut pr = Range::new(-50.0, 50.0);
- let mut vr = Range::new(-0.5, 0.5);
let mut rng = rand::thread_rng();
+
+ let mut pr = Range::new(-50.0, 50.0);
let position = (pr.sample(&mut rng), pr.sample(&mut rng), pr.sample(&mut rng));
+
+ let mut vr = Range::new(-0.5, 0.5);
let velocity = (vr.sample(&mut rng), vr.sample(&mut rng), vr.sample(&mut rng));
+
+ let mut rr = Range::new(0, 20);
+ let mut resouces = Vec::new();
+ for _ in 0..rr.sample(&mut rng) {
+ resouces.push(Item::new("Iron", 1))
+ }
Astroid {
name : name,
- mass_type : Type::Astroid,
+ mass_type : MassType::Astroid,
position : position,
velocity : velocity,
+ resouces : Storage::new(resouces),
}
}
}
@@ -40,6 +52,10 @@ impl Mass for Astroid {
&self.name
}
+ fn recv_mass_type(&self) -> MassType {
+ self.mass_type.clone()
+ }
+
fn position(&self) -> (f64, f64, f64) {
self.position
}
diff --git a/src/bin/client.rs b/src/bin/client.rs
index 1c64b39..7eb89ae 100644
--- a/src/bin/client.rs
+++ b/src/bin/client.rs
@@ -6,8 +6,9 @@ use std::net::TcpStream;
extern crate serde_json;
extern crate space;
-use space::dashboard::client_dashboard;
+use space::mining::client_mining;
use space::engines::client_engines;
+use space::dashboard::client_dashboard;
use space::navigation::client_navigation;
use space::module::Module;
@@ -48,5 +49,6 @@ fn main() {
Module::Dashboard => client_dashboard(buff_r),
Module::Engines => client_engines(stream, buff_r),
Module::Navigation => client_navigation(name, stream, buff_r),
+ Module::Mining => client_mining(stream, buff_r),
}
}
diff --git a/src/connection.rs b/src/connection.rs
index 77afc06..081805b 100644
--- a/src/connection.rs
+++ b/src/connection.rs
@@ -32,7 +32,7 @@ impl Connection {
let mass = masses.iter().find(|ship| ship.name() == name).unwrap();
let ship = mass.downcast_ref::<Ship>().unwrap();
- let modules = ship.get_modules();
+ let modules = ship.recv_modules();
stream.write(modules.as_bytes()).unwrap();
let mut recv = String::new();
@@ -55,6 +55,7 @@ impl Connection {
Module::Engines => self.server_engines(&mut masses),
Module::Dashboard => self.server_dashboard(&mut masses),
Module::Navigation => self.server_navigation(&mut masses),
+ Module::Mining => self.server_mining(&mut masses),
};
}
}
diff --git a/src/engines.rs b/src/engines.rs
index 3966c1b..cba189e 100644
--- a/src/engines.rs
+++ b/src/engines.rs
@@ -7,9 +7,11 @@ use std::time::Duration;
use std::io::{BufRead, BufReader};
extern crate termion;
+extern crate serde_json;
use ship::Ship;
use mass::Mass;
+use targeting::TargetingStatus;
use connection::Connection;
pub fn client_engines(mut stream : TcpStream, mut buff_r : BufReader<TcpStream>) {
@@ -20,11 +22,7 @@ pub fn client_engines(mut stream : TcpStream, mut buff_r : BufReader<TcpStream>)
loop {
let mut recv = String::new();
buff_r.read_line(&mut recv).unwrap();
-
- let has_target = match recv.as_bytes() {
- b"true\n" => true,
- _ => false
- };
+ let has_target = serde_json::from_str(&recv.replace("\n", "")).unwrap();
write!(stdout, "{}{}use numpad to freely move\n", termion::clear::All, termion::cursor::Goto(1, 1)).unwrap();
write!(stdout, "{}+ : speedup", termion::cursor::Goto(1, 2)).unwrap();
@@ -61,11 +59,9 @@ impl Connection {
let mass = masses.into_iter().find(|ship| ship.name() == &self.name).unwrap();
let ship = mass.downcast_mut::<Ship>().unwrap();
- let mut send = String::new();
- match ship.recv_target().is_some() {
- true => send.push_str("true\n"),
- false => send.push_str("false\n"),
- }
+ let targeted = ship.recv_targeting_status() == TargetingStatus::Targeted;
+ let send = serde_json::to_string(&targeted).unwrap() + "\n";
+
match self.stream.write(send.as_bytes()) {
Ok(_result) => (),
Err(_error) => return false,
@@ -100,7 +96,7 @@ impl Connection {
match ship.recv_target() {
Some(name) => {
let target = m.into_iter().find(|target| target.name() == &name).unwrap();
- let d_p = target.recv_velocity();
+ let d_p = target.position();
let m_p = ship.position();
acceleration = ((d_p.0 - m_p.0) * 0.01,
(d_p.1 - m_p.1) * 0.01,
diff --git a/src/item.rs b/src/item.rs
new file mode 100644
index 0000000..63e7b01
--- /dev/null
+++ b/src/item.rs
@@ -0,0 +1,14 @@
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Item {
+ name : String,
+ size : usize,
+}
+
+impl Item {
+ pub fn new(name : &str, size : usize) -> Item {
+ Item {
+ name : String::from(name),
+ size : size,
+ }
+ }
+}
diff --git a/src/lib.rs b/src/lib.rs
index a8d9717..923ddd0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -7,9 +7,12 @@ extern crate termion;
extern crate time;
pub mod mass;
+pub mod item;
pub mod ship;
pub mod math;
pub mod module;
+pub mod mining;
+pub mod storage;
pub mod astroid;
pub mod engines;
pub mod dashboard;
diff --git a/src/mass.rs b/src/mass.rs
index 800ef58..186391b 100644
--- a/src/mass.rs
+++ b/src/mass.rs
@@ -2,6 +2,7 @@ use downcast::Any;
pub trait Mass : Any {
fn name(&self) -> &String;
+ fn recv_mass_type(&self) -> MassType;
fn position(&self) -> (f64, f64, f64);
fn serialize(&self) -> String;
fn process(&mut self);
@@ -17,7 +18,7 @@ impl Clone for Box<Mass> {
}
#[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum Type {
+pub enum MassType {
Ship,
Astroid,
}
diff --git a/src/mining.rs b/src/mining.rs
new file mode 100644
index 0000000..ecc83c5
--- /dev/null
+++ b/src/mining.rs
@@ -0,0 +1,124 @@
+use std::io::{BufReader, BufRead};
+use std::net::TcpStream;
+use std::io::{stdout, Read, Write};
+use termion::raw::IntoRawMode;
+use termion::async_stdin;
+
+extern crate serde_json;
+extern crate termion;
+
+use ship::Ship;
+use math::distance;
+use mass::{Mass, MassType};
+use connection::Connection;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+struct ServerData {
+ has_astroid_target : bool,
+ is_within_range : bool,
+ mining_range : f64,
+ mining_status : bool,
+}
+
+pub fn client_mining(mut stream : TcpStream, mut buff_r : BufReader<TcpStream>) {
+ let stdout = stdout();
+ let mut stdout = stdout.lock().into_raw_mode().unwrap();
+ let mut stdin = async_stdin().bytes();
+
+ loop {
+ let mut recv = String::new();
+ buff_r.read_line(&mut recv).unwrap();
+ let data : ServerData = serde_json::from_str(&recv.replace("\n", "")).unwrap();
+
+ write!(stdout, "{}", termion::clear::All).unwrap();
+
+ match data.has_astroid_target {
+ true => match data.is_within_range {
+ true => write!(stdout, "{}Press F to begin mining.", termion::cursor::Goto(1,1)).unwrap(),
+ false => write!(stdout, "{}Astroid must be within range of {}.", termion::cursor::Goto(1,1), data.mining_range).unwrap(),
+ },
+ false => write!(stdout, "{}Ship has no astroid targeted.", termion::cursor::Goto(1,1)).unwrap(),
+ }
+
+ match stdin.next() {
+ Some(c) => {
+ let c = c.unwrap();
+ let mut send = String::new();
+ send.push(c as char);
+ if send.as_bytes() == b"q" {
+ break;
+ }
+ send.push_str("\n");
+ stream.write(send.as_bytes()).unwrap();
+ }
+ None => ()
+ }
+
+ stdout.flush().unwrap();
+ }
+}
+
+impl Connection {
+ pub fn server_mining(&mut self, masses : &mut Vec<Box<Mass>>) -> bool {
+ let m = masses.to_vec();
+ let mass = masses.into_iter().find(|ship| ship.name() == &self.name).unwrap();
+ let ship = mass.downcast_mut::<Ship>().unwrap();
+ let target = match ship.recv_target() {
+ Some(name) => m.iter().find(|target| target.name() == &name),
+ None => None,
+ };
+
+ let has_astroid_target = match target {
+ Some(target) => match target.recv_mass_type() {
+ MassType::Ship => false,
+ MassType::Astroid => true,
+ },
+ None => false,
+ };
+
+ let is_within_range = match has_astroid_target {
+ true => match target {
+ Some(target) => match ship.recv_mining_range() > distance(ship.position(), target.position()) {
+ true => true,
+ false => false,
+ },
+ None => false,
+ }
+ false => false,
+ };
+
+ let send = serde_json::to_string(&ServerData {
+ has_astroid_target : has_astroid_target,
+ is_within_range : is_within_range,
+ mining_range : ship.recv_mining_range(),
+ mining_status : ship.recv_mining_status(),
+ }).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) => match recv.as_bytes() {
+ b"F\n" => {
+ if is_within_range {
+ match ship.recv_mining_status() {
+ true => ship.stop_mining(),
+ false => ship.start_mining(),
+ }
+ }
+ },
+ _ => {
+ if result == 0 {
+ return false
+ }
+ },
+ }
+ Err(_error) => (),
+ }
+
+ true
+ }
+}
diff --git a/src/module.rs b/src/module.rs
index b051e60..8d9a361 100644
--- a/src/module.rs
+++ b/src/module.rs
@@ -3,4 +3,5 @@ pub enum Module {
Dashboard,
Navigation,
Engines,
+ Mining,
}
diff --git a/src/navigation.rs b/src/navigation.rs
index f9fa92a..b15103e 100644
--- a/src/navigation.rs
+++ b/src/navigation.rs
@@ -43,7 +43,7 @@ pub fn client_navigation(name : String, mut stream : TcpStream, mut buff_r : Buf
let target_data = match ship.recv_target() {
Some(name) => {
if &name == mass.name() {
- serde_json::to_string(&ship.recv_target_status()).unwrap()
+ serde_json::to_string(&ship.recv_targeting_status()).unwrap()
}
else {
String::new()
@@ -100,7 +100,7 @@ impl Connection {
match ship.recv_target() {
Some(name) => {
let target = m.iter().find(|target| target.name() == &name).unwrap();
- if distance(target.position(), ship.position()) > ship.range() {
+ if distance(target.position(), ship.position()) > ship.recv_range() {
ship.give_target(None);
}
}
@@ -108,7 +108,7 @@ impl Connection {
}
let within_range : Vec<&Box<Mass>> = m.iter().filter(|mass|
- distance(ship.position(), mass.position()) < ship.range())
+ distance(ship.position(), mass.position()) < ship.recv_range())
.collect();
let mut send = String::new();
for mass in within_range {
diff --git a/src/ship.rs b/src/ship.rs
index 44f7d06..cfe913e 100644
--- a/src/ship.rs
+++ b/src/ship.rs
@@ -1,18 +1,23 @@
+use std::time::SystemTime;
+
extern crate serde_json;
use module::Module;
-use mass::{Mass, Type};
+use mass::{Mass, MassType};
use targeting::{Targeting, TargetingStatus};
+use storage::Storage;
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Ship {
name : String,
+ mass_type : MassType,
position : (f64, f64, f64),
velocity : (f64, f64, f64),
- mass_type : Type,
- r : f64,
+ range : f64,
modules : Vec<Module>,
targeting : Targeting,
+ mining : Mining,
+ storage : Storage,
}
impl Ship {
@@ -22,15 +27,18 @@ impl Ship {
modules.push(Module::Navigation);
modules.push(Module::Engines);
modules.push(Module::Dashboard);
+ modules.push(Module::Mining);
Ship {
- name : String::from(name),
- position : position,
- velocity : (0.0, 0.0, 0.0),
- mass_type : Type::Ship,
- r : 100.0,
- targeting : Targeting::new(),
- modules : modules,
+ name : String::from(name),
+ mass_type : MassType::Ship,
+ position : position,
+ velocity : (0.0, 0.0, 0.0),
+ range : 100.0,
+ modules : modules,
+ targeting : Targeting::new(),
+ mining : Mining::new(),
+ storage : Storage::new(Vec::new()),
}
}
@@ -63,8 +71,24 @@ impl Ship {
self.velocity.2 *= 1.05;
}
- pub fn range(&self) -> f64 {
- self.r
+ pub fn start_mining(&mut self) {
+ self.mining.start()
+ }
+
+ pub fn stop_mining(&mut self) {
+ self.mining.stop()
+ }
+
+ pub fn recv_range(&self) -> f64 {
+ self.range
+ }
+
+ pub fn recv_mining_range(&self) -> f64 {
+ self.mining.recv_range()
+ }
+
+ pub fn recv_mining_status(&self) -> bool {
+ self.mining.recv_status()
}
pub fn give_target(&mut self, target : Option<String>) {
@@ -72,14 +96,14 @@ impl Ship {
}
pub fn recv_target(&self) -> Option<String> {
- self.targeting.get_target()
+ self.targeting.recv_target()
}
- pub fn recv_target_status(&self) -> TargetingStatus {
- self.targeting.get_status()
+ pub fn recv_targeting_status(&self) -> TargetingStatus {
+ self.targeting.recv_status()
}
- pub fn get_modules(&self) -> String {
+ pub fn recv_modules(&self) -> String {
serde_json::to_string(&self.modules).unwrap() + "\n"
}
}
@@ -89,6 +113,10 @@ impl Mass for Ship {
&self.name
}
+ fn recv_mass_type(&self) -> MassType {
+ self.mass_type.clone()
+ }
+
fn process(&mut self) {
self.position.0 += self.velocity.0;
self.position.1 += self.velocity.1;
@@ -118,3 +146,39 @@ impl Mass for Ship {
self.velocity.2 += acceleration.2;
}
}
+
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+struct Mining {
+ range : f64,
+ status : bool,
+ time : u64,
+ start : Option<SystemTime>,
+}
+
+impl Mining {
+ pub fn new() -> Mining {
+ Mining {
+ range : 10.0,
+ status : false,
+ time : 1,
+ start : None,
+ }
+ }
+
+ pub fn start(&mut self) {
+ self.status = true;
+ }
+
+ pub fn stop(&mut self) {
+ self.status = false;
+ }
+
+ pub fn recv_range(&self) -> f64 {
+ self.range
+ }
+
+ pub fn recv_status(&self) -> bool {
+ self.status
+ }
+}
diff --git a/src/storage.rs b/src/storage.rs
new file mode 100644
index 0000000..00dca8b
--- /dev/null
+++ b/src/storage.rs
@@ -0,0 +1,16 @@
+use item::Item;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct Storage {
+ items : Vec<Item>,
+ capacity : usize,
+}
+
+impl Storage {
+ pub fn new(items : Vec<Item>) -> Storage {
+ Storage {
+ items : items,
+ capacity : 100,
+ }
+ }
+}
diff --git a/src/targeting.rs b/src/targeting.rs
index 754e7a4..49fdc54 100644
--- a/src/targeting.rs
+++ b/src/targeting.rs
@@ -1,6 +1,6 @@
use std::time::SystemTime;
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub enum TargetingStatus {
None,
Targeting,
@@ -28,10 +28,10 @@ impl Targeting {
pub fn process(&mut self) {
match self.start {
Some(time) => {
- if time.elapsed().unwrap().as_secs() > self.time {
- self.status = TargetingStatus::Targeted;
- self.start = None;
- }
+ if time.elapsed().unwrap().as_secs() > self.time {
+ self.status = TargetingStatus::Targeted;
+ self.start = None;
+ }
}
None => (),
}
@@ -50,11 +50,11 @@ impl Targeting {
}
}
- pub fn get_target(&self) -> Option<String> {
+ pub fn recv_target(&self) -> Option<String> {
self.target.clone()
}
- pub fn get_status(&self) -> TargetingStatus {
+ pub fn recv_status(&self) -> TargetingStatus {
self.status.clone()
}
}