369 lines
11 KiB
Rust
369 lines
11 KiB
Rust
extern crate csv;
|
|
extern crate serde;
|
|
#[macro_use]
|
|
extern crate structopt;
|
|
#[macro_use]
|
|
extern crate serde_derive;
|
|
extern crate fnv;
|
|
extern crate humantime;
|
|
use fnv::{FnvHashMap, FnvHashSet};
|
|
use humantime::format_duration;
|
|
use rstar::{PointDistance, RTree, RTreeObject, AABB};
|
|
use std::collections::VecDeque;
|
|
use std::hash::{Hash, Hasher};
|
|
use std::io::Write;
|
|
use std::path::PathBuf;
|
|
use std::time::Instant;
|
|
use structopt::StructOpt;
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct Record {
|
|
id: i64,
|
|
star_type: String,
|
|
name: String,
|
|
mult: f32,
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
}
|
|
#[derive(Debug, Clone)]
|
|
struct System {
|
|
id: i64,
|
|
star_type: String,
|
|
name: String,
|
|
mult: f32,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
struct Point {
|
|
id: i64,
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
}
|
|
#[derive(Debug, StructOpt)]
|
|
#[structopt(name = "ed_lrr", about = "Elite: Dangerous Long-Range Router")]
|
|
/// Plots a route through multiple systems using breadth-first search (Currently needs a lot of RAM (8+GB), sorry)
|
|
struct Opt {
|
|
#[structopt(short = "r", long = "range")]
|
|
/// Jump Range
|
|
range: f32,
|
|
#[structopt(
|
|
parse(from_os_str),
|
|
short = "p",
|
|
long = "path",
|
|
default_value = "./stars.csv"
|
|
)]
|
|
/// Path to stars.csv
|
|
file_path: PathBuf,
|
|
/// Systems to route through
|
|
systems: Vec<String>,
|
|
}
|
|
fn dist(p1: &[f32; 3], p2: &[f32; 3]) -> f32 {
|
|
let dx = p1[0] - p2[0];
|
|
let dy = p1[1] - p2[1];
|
|
let dz = p1[2] - p2[2];
|
|
|
|
return (dx * dx + dy * dy + dz * dz).sqrt();
|
|
}
|
|
|
|
impl Point {
|
|
pub fn dist2(&self, p: &[f32; 3]) -> f32 {
|
|
let dx = self.x - p[0];
|
|
let dy = self.y - p[1];
|
|
let dz = self.z - p[2];
|
|
|
|
return dx * dx + dy * dy + dz * dz;
|
|
}
|
|
pub fn distp(&self, p: &Point) -> f32 {
|
|
return self.distp2(p).sqrt();
|
|
}
|
|
pub fn distp2(&self, p: &Point) -> f32 {
|
|
return self.dist2(&[p.x, p.y, p.z]);
|
|
}
|
|
}
|
|
impl PartialEq for Point {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
self.id == other.id
|
|
}
|
|
}
|
|
|
|
impl Eq for Point {}
|
|
|
|
impl Hash for Point {
|
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
self.id.hash(state);
|
|
}
|
|
}
|
|
|
|
impl RTreeObject for Point {
|
|
type Envelope = AABB<[f32; 3]>;
|
|
|
|
fn envelope(&self) -> Self::Envelope {
|
|
return AABB::from_point([self.x, self.y, self.z]);
|
|
}
|
|
}
|
|
|
|
impl PointDistance for Point {
|
|
fn distance_2(&self, point: &[f32; 3]) -> f32 {
|
|
return self.dist2(&point);
|
|
}
|
|
}
|
|
|
|
struct Router {
|
|
tree: RTree<Point>,
|
|
systems: FnvHashMap<i64, System>,
|
|
scoopable: FnvHashSet<i64>,
|
|
}
|
|
|
|
impl Router {
|
|
pub fn new(path: &PathBuf) -> Self {
|
|
let mut scoopable = FnvHashSet::default();
|
|
let mut systems: FnvHashMap<i64, System> = FnvHashMap::default();
|
|
let mut reader = csv::ReaderBuilder::new()
|
|
.has_headers(false)
|
|
.from_path(path)
|
|
.unwrap_or_else(|e| {
|
|
println!("Error loading {}: {}", path.to_str().unwrap(), e);
|
|
std::process::exit(1);
|
|
});
|
|
println!("Loading {}...", path.to_str().unwrap());
|
|
let points = reader
|
|
.deserialize()
|
|
.map(|res: Result<Record, _>| {
|
|
let sys = res.unwrap();
|
|
systems.insert(
|
|
sys.id,
|
|
System {
|
|
id: sys.id,
|
|
star_type: sys.star_type.clone(),
|
|
name: sys.name,
|
|
mult: sys.mult,
|
|
},
|
|
);
|
|
if sys.mult > 1.0f32 {
|
|
scoopable.insert(sys.id);
|
|
} else {
|
|
for c in "KGBFOAM".chars() {
|
|
if sys.star_type.starts_with(c) {
|
|
scoopable.insert(sys.id);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return Point {
|
|
x: sys.x,
|
|
y: sys.y,
|
|
z: sys.z,
|
|
id: sys.id,
|
|
};
|
|
})
|
|
.collect();
|
|
return Self {
|
|
tree: RTree::<Point>::bulk_load(points),
|
|
systems,
|
|
scoopable,
|
|
};
|
|
}
|
|
|
|
fn preload_points(&self) -> FnvHashMap<i64, &Point> {
|
|
let mut ret = FnvHashMap::default();
|
|
for point in &self.tree {
|
|
ret.insert(point.id, point);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
fn closest(&self, point: &[f32; 3]) -> &Point {
|
|
return self.tree.nearest_neighbor(point).unwrap();
|
|
}
|
|
fn points_in_sphere(&self, center: &[f32; 3], radius: f32) -> impl Iterator<Item = &Point> {
|
|
let center: [f32; 3] = *center;
|
|
return self
|
|
.tree
|
|
.locate_in_envelope(&AABB::from_corners(
|
|
[
|
|
center[0] - radius * 1f32,
|
|
center[1] - radius * 1f32,
|
|
center[2] - radius * 1f32,
|
|
],
|
|
[
|
|
center[0] + radius * 1f32,
|
|
center[1] + radius * 1f32,
|
|
center[2] + radius * 1f32,
|
|
],
|
|
))
|
|
.filter(move |p| (p.dist2(¢er) < (radius * radius)));
|
|
}
|
|
|
|
fn mult(&self, id: i64) -> f32 {
|
|
if let Some(sys) = self.systems.get(&id) {
|
|
return sys.mult;
|
|
};
|
|
return 1.0;
|
|
}
|
|
fn neighbours(&self, sys: &Point, r: f32) -> impl Iterator<Item = &Point> {
|
|
return self.points_in_sphere(&[sys.x, sys.y, sys.z], self.mult(sys.id) * r);
|
|
}
|
|
|
|
fn valid(&self, sys: &Point) -> bool {
|
|
return self.scoopable.contains(&sys.id);
|
|
}
|
|
|
|
pub fn name_multiroute(&self, waypoints: &Vec<String>, range: f32) -> Vec<(&System, &Point)> {
|
|
let mut coords = Vec::new();
|
|
for p in waypoints {
|
|
let p = self.name_to_point(p);
|
|
let s = [p.x, p.y, p.z];
|
|
coords.push(s);
|
|
}
|
|
return self.multiroute(coords.as_slice(), range);
|
|
}
|
|
pub fn multiroute(&self, waypoints: &[[f32; 3]], range: f32) -> Vec<(&System, &Point)> {
|
|
let mut route = Vec::new();
|
|
for pair in waypoints.windows(2) {
|
|
match pair {
|
|
&[src, dst] => {
|
|
let block = self.route(&src, &dst, range);
|
|
if route.is_empty() {
|
|
route.extend(block.iter());
|
|
} else {
|
|
route.extend(block.iter().skip(1));
|
|
}
|
|
}
|
|
_ => panic!("Invalid routing parameters!"),
|
|
}
|
|
}
|
|
return route;
|
|
}
|
|
|
|
fn sys_to_point(&self, id: i64) -> Option<&Point> {
|
|
for p in &self.tree {
|
|
if p.id == id {
|
|
return Some(p);
|
|
}
|
|
}
|
|
return None;
|
|
}
|
|
|
|
fn name_to_point(&self, name: &str) -> &Point {
|
|
for sys in self.systems.values() {
|
|
if sys.name == name {
|
|
return self.sys_to_point(sys.id).unwrap();
|
|
}
|
|
}
|
|
eprintln!("Sytem not found: \"{}\"", name);
|
|
std::process::exit(1);
|
|
}
|
|
|
|
pub fn route(&self, src: &[f32; 3], dst: &[f32; 3], range: f32) -> Vec<(&System, &Point)> {
|
|
let start_sys = self.closest(src);
|
|
let goal_sys = self.closest(dst);
|
|
{
|
|
let d = dist(src, dst);
|
|
let start_sys_name = self.systems.get(&start_sys.id).unwrap().name.clone();
|
|
let goal_sys_name = self.systems.get(&goal_sys.id).unwrap().name.clone();
|
|
println!(
|
|
"Plotting route from {} to {}...",
|
|
start_sys_name, goal_sys_name
|
|
);
|
|
println!(
|
|
"Jump Range: {} Ly, Distance: {} Ly, Theoretical Jumps: {}",
|
|
range,
|
|
d,
|
|
d / range
|
|
);
|
|
}
|
|
let total = self.tree.size() as f32;
|
|
let mut prev = FnvHashMap::default();
|
|
let mut seen = FnvHashSet::default();
|
|
let t_start = Instant::now();
|
|
let mut depth = 0;
|
|
let mut found = false;
|
|
let mut queue: VecDeque<(usize, &Point)> = VecDeque::new();
|
|
let mut queue_next: VecDeque<(usize, &Point)> = VecDeque::new();
|
|
queue.push_front((0, &start_sys));
|
|
seen.insert(start_sys.id);
|
|
while !(queue.is_empty() || found) {
|
|
print!(
|
|
"[{}] Depth: {}, Queue: {}, Seen: {} ({:.02}%) \r",
|
|
format_duration(t_start.elapsed()),
|
|
depth,
|
|
queue.len(),
|
|
seen.len(),
|
|
((seen.len() * 100) as f32) / total
|
|
);
|
|
std::io::stdout().flush().unwrap();
|
|
while let Some((d, sys)) = queue.pop_front() {
|
|
if sys.id == goal_sys.id {
|
|
found = true;
|
|
break;
|
|
}
|
|
queue_next.extend(
|
|
self.neighbours(&sys, range)
|
|
.filter(|&nb| (self.valid(nb) || (nb.id == goal_sys.id)))
|
|
.filter(|&nb| seen.insert(nb.id))
|
|
.map(|nb| {
|
|
prev.insert(nb.id, sys.id);
|
|
return (d + 1, nb);
|
|
}),
|
|
);
|
|
}
|
|
std::mem::swap(&mut queue, &mut queue_next);
|
|
depth += 1;
|
|
}
|
|
println!();
|
|
if !found {
|
|
return Vec::new();
|
|
}
|
|
let points = self.preload_points();
|
|
let mut v: Vec<(&System, &Point)> = Vec::new();
|
|
let mut prev_sys_id = goal_sys.id;
|
|
loop {
|
|
if let Some(sys) = self.systems.get(&prev_sys_id) {
|
|
v.push((sys, points[&sys.id]));
|
|
} else {
|
|
break;
|
|
};
|
|
match prev.get(&prev_sys_id) {
|
|
Some(sys_id) => prev_sys_id = *sys_id,
|
|
None => {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
v.reverse();
|
|
return v;
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let opts = Opt::from_args();
|
|
let path = opts.file_path;
|
|
let t_load = Instant::now();
|
|
let router: Router = Router::new(&path);
|
|
println!("Done in {}!", format_duration(t_load.elapsed()));
|
|
let t_route = Instant::now();
|
|
let route = router.name_multiroute(&opts.systems, opts.range);
|
|
println!(
|
|
"Done in {} ({} Jumps)!\n",
|
|
format_duration(t_route.elapsed()),
|
|
route.len(),
|
|
);
|
|
let mut total: f32 = 0.0;
|
|
for ((sys1, p1), (_, p2)) in route.iter().zip(route.iter().skip(1)) {
|
|
let dist = p1.distp(p2);
|
|
total += dist;
|
|
println!(
|
|
"{} [{}] ({},{},{}): {:.2} Ly",
|
|
sys1.name, sys1.star_type, p1.x, p1.y, p1.z, dist
|
|
);
|
|
}
|
|
let (sys, p) = route.iter().last().unwrap();
|
|
println!(
|
|
"{} [{}] ({},{},{}): {:.2} Ly",
|
|
sys.name, sys.star_type, p.x, p.y, p.z, 0.0
|
|
);
|
|
println!("Total: {:.2} Ly", total);
|
|
}
|