experimental graph data structure wrapping components

Author: JoeHowarth

.idea/workspace.xml

@@ -3,7 +3,7 @@ use population_simulation::pop::components::RegionPop;
 
 fn main() {
     println!("hi");
-    let x = RegionPop::new(&[1./17.;17], 200);
+    //let x = RegionPop::new(&[1./17.;17], 200);
 
     dbg!(RegionPop::type_script_ify());
 

src/bin/gen_typescript.rs

@@ -77,6 +77,7 @@ use crate::{
         core_loop::game_loop,
     },
 };
+use crate::misc::graph_ds::test_graph_ds;
 
 //lazy_static! {
 //    pub static ref SETTINGS : RwLock<config::Config> = RwLock::new(config::Config::default());
@@ -90,7 +91,7 @@ pub fn setup() -> Result<(), Error> {
 
     let mut world = setup_world()?;
 
-    let foo = Some("hi");
+    test_graph_ds(&mut world);
     // blocks until connection established to a client
     let WsReturn { server_thread, out, sub_req_recv} = wait_client()?;
     trace!("after waiting for connect");

src/lib.rs

@@ -0,0 +1,56 @@
+use crate::prelude::*;
+use specs::join::JoinIter;
+use serde_json::value::Value::Array;
+
+pub trait AdjList {
+    fn get_nbs<'a>(&self, e: Entity) -> ArrayVec<[usize; 256]>;
+    //fn nbs_ent_u(&self, id: usize, map: &[Entity]) -> Vec<Entity>;
+    //fn nbs_ent(&self, e: &Entity) -> ArrayVec<[Entity; 256]>;
+}
+
+pub struct Graph<'a, A: AdjList> {
+    adj: A,
+    id_map: Read<'a, VecMap<Entity>>,
+    ents: Entities<'a>,
+}
+
+impl<'a, A: AdjList> Graph<'a, A> {
+    pub fn new(adj: A, id_map: Read<'a, VecMap<Entity>>, ents: Entities<'a>) -> Self {
+        Graph { adj, id_map, ents }
+    }
+
+    pub fn nbs_iter<T: Join>(&mut self, res: &mut JoinIter<T>, id: usize) -> impl Iterator<Item=<T as Join>::Type> {
+        dbg!(id);
+        let e: Entity = self.id_map[id];
+
+        let nbs = self.adj.get_nbs(e);
+
+        let v: Vec<_> = nbs.iter()
+                           .map(|&id| self.id_map.get(id).expect("boom2"))
+                           .filter_map(|&e| res.get(e, &self.ents)).collect();
+        v.into_iter()
+    }
+}
+
+impl<'a> AdjList for ReadStorage<'a, RegionAdjacency> {
+    fn get_nbs(&self, e: Entity) -> ArrayVec<[usize; 256]> {
+        let ra = self.get(e).expect("boom");
+        ArrayVec::from_iter(ra.nbs.iter().map(|&i| i))
+    }
+}
+
+pub fn test_graph_ds(world: &mut World) {
+    println!("in test graph ds");
+    let (r, rp, rfd): (ReadStorage<Region>, ReadStorage<RegionPop>, ReadStorage<RegBaseFarmData>) = world.system_data();
+    let adj: ReadStorage<RegionAdjacency> = world.system_data();
+    let (r2e, ents): (Read<Region2Entity>, Entities) = world.system_data();
+
+    let mut graph = Graph::new(adj, r2e, ents);
+    let mut res = (&rp, &rfd).join();
+
+
+    for Region { id, .. } in r.join() {
+        dbg!(id);
+        graph.nbs_iter(&mut res, *id).for_each(|(rp, rfd)| { dbg!(rfd); });
+    }
+}

src/misc/graph_ds.rs

@@ -3,6 +3,7 @@ pub mod core_loop;
 pub mod normalize;
 pub mod time;
 pub mod systems;
+pub mod graph_ds;
 
 use crate::prelude::*;
 pub use self::{

src/misc/mod.rs

@@ -10,7 +10,7 @@ use vec_map::VecMap;
 
 // resource for going the other way
 pub type Tile2Entity = Vec<Entity>;
-pub type Region2Entity = Vec<Entity>;
+pub type Region2Entity = VecMap<Entity>;
 
 #[derive(Component, Copy, Clone, Debug, Serialize, Deserialize, PartialOrd, PartialEq, Ord, Eq)]
 pub struct TileID {

src/terrain/components.rs

@@ -146,20 +146,20 @@ pub fn init_farm_data((base, reg, topo, pop, mut farm, entities): (ReadStorage<R
         let cleared = (needed_area * rng.gen_range(1.01, 1.5)).min(arable);
         let auc = needed_area.min(arable);
 
-        dbg!(needed_grain / high_yield);
-        dbg!(needed_grain);
-        dbg!(high_yield);
-        dbg!(pop.pop());
-        dbg!(arable);
-        dbg!(topo.area);
-        dbg!(fertility);
-        println!("");
+//        dbg!(needed_grain / high_yield);
+//        dbg!(needed_grain);
+//        dbg!(high_yield);
+//        dbg!(pop.pop());
+//        dbg!(arable);
+//        dbg!(topo.area);
+//        dbg!(fertility);
+//        println!("");
         farm.insert(e, FarmData {auc, cleared}).unwrap();
     }
 
-    dbg!(base_yield(0, 1., 1.));
-
-    dbg!(count);
+//    dbg!(base_yield(0, 1., 1.));
+//
+//    dbg!(count);
 }
 
 

src/worldbuilding/agr_init.rs

@@ -27,7 +27,7 @@ pub fn register_pop_ecs(world: &mut World) {
             let total_est = region.tiles.iter().filter_map(|id| est.get(t2e[id.id]))
                 .fold(0, |a, est| a + est.0);
 
-            dbg!(total_est);
+            //dbg!(total_est);
             let rp = RegionPop::new(&dist, total_est);
             //dbg!(&rp);
             updater.insert(e, rp);
@@ -49,9 +49,7 @@ pub fn init_pop_est(world: &mut World) {
     let keys: Vec<_> = v.keys().collect();
 
     let dist = WeightedIndex::new(goodness.iter()).unwrap();
-
     let mut rng = SmallRng::from_entropy();
-
     let mut arr = ArrayVec::<[usize; 30]>::new();
     for i in 0..10 {
         arr.push(dist.sample(&mut rng));
@@ -62,8 +60,8 @@ pub fn init_pop_est(world: &mut World) {
         let g = goodness[i];
         WeightedNode { weight: ((g as f32).sqrt() as i32) * 10, inner: &v[keys[i]] }
     }));
-    let mut seen = VecMap::with_capacity(goodness.len());
 
+    let mut seen = VecMap::with_capacity(goodness.len());
     let mut pop_est = VecMap::with_capacity(v.len());
     while let Some(WeightedNode { weight, inner: (id, t, b, a) }) = heap.pop() {
         let coef = ((t.hillratio / 2. + b.fertility) as f32 / 2.).sqrt();
@@ -72,7 +70,7 @@ pub fn init_pop_est(world: &mut World) {
 
         seen.insert(id.id, ());
         for &n in a.nbs.iter().filter(|&&n| !seen.contains_key(n)) {
-            let e = t2e.get(id.id).unwrap();
+            //let e = t2e.get(id.id).unwrap();
 
             if let Some(x) = v.get(n) {
                 heap.push(WeightedNode {
@@ -84,7 +82,7 @@ pub fn init_pop_est(world: &mut World) {
     }
 
 
-    dbg!(&pop_est);
+    //dbg!(&pop_est);
     for (k, p) in pop_est {
         pop.insert(t2e[k], PopEst(p as usize)).unwrap();
     }

src/worldbuilding/pop_init.rs

@@ -79,6 +79,7 @@ pub fn register_terrain_ecs(mesh: &Mesh, world: &mut World) {
     }
     world.maintain();
     world.add_resource(tile2entity);
+    world.add_resource(Region2Entity::default());
 }
 
 pub const RIVER_FLUX_THRESH: f32 = 0.006;
@@ -129,6 +130,7 @@ type ConsRegionData<'a> = (ReadStorage<'a, TileTopography>,
                            WriteStorage<'a, Region>,
                            WriteStorage<'a, RegionID>,
                            Read<'a, Tile2Entity>,
+                           Write<'a, Region2Entity>,
                            Entities<'a>,
                            Write<'a, LazyUpdate>);
 
@@ -141,7 +143,7 @@ pub const MAX_TILES_PER_REGION: u8 = 12;
 pub const REGION_BASE_FOOD_MAX: f32 = 30.;// too high, bring down eventually
 
 // TODO refactor and simplify
-fn construct_regions_inner((tile_topo, tile_id, tile_adj, farm, region, region_id, t2e, entities, updater): ConsRegionData) -> Option<()> {
+fn construct_regions_inner((tile_topo, tile_id, tile_adj, farm, region, region_id, t2e, mut r2e, entities, updater): ConsRegionData) -> Option<()> {
     // N: num tiles
     // R: num regions
     // A: tiles per region; N / R
@@ -265,7 +267,7 @@ fn construct_regions_inner((tile_topo, tile_id, tile_adj, farm, region, region_i
                 region_pool.swap_remove(i);
             } else {
                 error!("Should have removed max");
-                dbg!( &region_pool);
+                dbg!(&region_pool);
                 dbg!(max);
             }
 
@@ -290,19 +292,24 @@ fn construct_regions_inner((tile_topo, tile_id, tile_adj, farm, region, region_i
         }
     }
 
+
     debug!("num loops: {}", loops);
     debug!("num_regions: {}", region_map.len());
 
+
     for (i, r) in region_map.drain() {
+        let id = r.id;
         let b = updater.create_entity(&entities)
                        .with(r)
                        .with(reg_topo.remove(i).unwrap())
                        .with(reg_adj.remove(i).unwrap());
-        if let Some(farm) = reg_agr.remove(i) {
-            b.with(farm).build();
+        let e = if let Some(farm) = reg_agr.remove(i) {
+            b.with(farm).build()
         } else {
-            b.build();
-        }
+            b.build()
+        };
+
+        r2e.insert(id, e);
     }
 
     Some(())