code cleanup, fixed bug with food creating home ph

src/lib/ai.rs

@@ -1,80 +1,122 @@
-use crate::lib::entity::{Ant, Egg, Queen};
+use crate::lib::entity::{Ant, Egg, Food, FoodGenerator, Queen};
-use crate::lib::point::{astar, Point};
+use crate::lib::point::Point;
 use crate::lib::screen::{BoardCommand, Screen};
-use crate::lib::world::World;
+use crate::lib::world::{Pheremone, World};
+use rand::Rng;
 use rand::prelude::SliceRandom;
 use rand::thread_rng;
+use std::iter::zip;
 
 pub trait AI {
-    fn step(&mut self, b: &Screen, w: &mut World) -> BoardCommand;
+    fn step(&mut self, b: &Screen, w: &mut World, step: u32) -> BoardCommand;
-    fn plan(&mut self, w: &World) {}
+    fn plan(&mut self, b: &Screen, w: &mut World) -> BoardCommand {
+        BoardCommand::Noop
+    }
 }
 
 #[derive(Clone, Debug)]
 pub enum AIGoal {
-    Reach(Point),
+    Seek,
-    //Pickup(Point),
+    Return,
-    //Drop(),
-    Idle,
 }
 
 impl AI for Ant {
-    fn plan(&mut self, w: &World) {
+    fn plan(&mut self, b: &Screen, w: &mut World) -> BoardCommand {
-        // check last part of plan
+        match self.goal {
-        if let Some(goal) = self.plan.last() {
+            AIGoal::Seek => {
-            match goal {
+                // if we reach food, we change state
-                AIGoal::Reach(target) => {
+                if w.food.contains(&self.pos) {
-                    if self.pos == *target {
+                    for p in &self.history {
-                        self.plan.pop();
+                        w.drop_pheremone(&p, &self.goal);
                     }
+                    self.history.clear();
+                    self.about_face();
+                    self.goal = AIGoal::Return;
+                }
+                BoardCommand::Noop
+            }
+            AIGoal::Return => {
+                if w.home.contains(&self.pos) {
+                    for p in &self.history {
+                        w.drop_pheremone(&p, &self.goal);
+                    }
+                    self.history.clear();
+                    self.about_face();
+                    self.goal = AIGoal::Seek;
+                    return BoardCommand::SpawnAnt;
+                } else {
+                    BoardCommand::Noop
                 }
-                AIGoal::Idle => {}
             }
         }
     }
 
-    // return the next move for this ant
+    fn step(&mut self, b: &Screen, w: &mut World, t: u32) -> BoardCommand {
-    fn step(&mut self, b: &Screen, w: &mut World) -> BoardCommand {
+        let valid = vec![
-        let goal = match self.plan.last() {
+            (self.dir, self.dir.relative_point(&self.pos)),
-            Some(g) => g,
+            (self.dir.ccw(), self.dir.ccw().relative_point(&self.pos)),
-            None => &AIGoal::Idle,
+            (self.dir.cw(), self.dir.cw().relative_point(&self.pos)),
-        };
+        ];
 
-        let choice = match goal {
+        let ph: Vec<Pheremone> = valid
-            AIGoal::Idle => {
+            .iter()
-                // valid_movements does not return any diggables!
+            .map(|(_, pnt)| w.get_pheremone(pnt).clone())
-                let valid = w.get_valid_movements(&self.pos, b, true);
+            .collect();
-                let mut rng = thread_rng();
+
-                valid.choose(&mut rng).cloned()
+        let ph_fn = match self.goal {
-            }
+            AIGoal::Seek => |ph: &Pheremone| ph.food,
-            AIGoal::Reach(target) => {
+            AIGoal::Return => |ph: &Pheremone| ph.home,
-                // here astar only produces a path between the target & pos without digging
-                let result = astar(&self.pos, &target, Some(w), Some(b));
-                let mut movements = match result {
-                    Ok(m) => m,
-                    Err(_) => vec![]
-                };
-                movements.pop()
-            }
         };
 
-        if !choice.is_none() {
+        let r: f32 = rand::random();
-            let pos = choice.unwrap();
+
-            if w.cleared.contains(&pos) {
+        let mut dir = &valid[0].0;
-                self.pos = pos;
+        if r < 0.1 || ph.len() == 0 {
-            } else {
+            let mut rng = thread_rng();
-                if w.is_safe_to_dig(&pos, &b) {
+            let choice = valid.choose(&mut rng).unwrap();
-                    w.clear(pos);
+            dir = &choice.0;
+        } else {
+            let mut greatest = &ph[0];
+            for (tup, p) in zip(&valid, &ph) {
+                if ph_fn(p) > ph_fn(greatest) {
+                    greatest = p;
+                    dir = &tup.0;
                 }
             }
         }
 
+        if dir == &self.dir {
+            self.forward(b);
+        } else if dir == &self.dir.cw() {
+            self.cw();
+        } else if dir == &self.dir.ccw() {
+            self.ccw();
+        }
+        BoardCommand::Noop
+    }
+}
+
+impl AI for FoodGenerator {
+    fn step(&mut self, b: &Screen, w: &mut World, t: u32) -> BoardCommand {
+        // eventually  might want to use poisson disk distrib instead
+        if t % 600 == 0 && self.counter < 10 {
+            // generate random coords, if valid, spawn
+            // if not, try again next step
+            let (min, max) = b.get_dimensions();
+
+            let mut rng = rand::thread_rng();
+            let r_x = rng.gen_range(min.0..max.0 + 1);
+            let r_y = rng.gen_range(min.1..max.1 + 1);
+
+            self.counter += 1;
+            return BoardCommand::SpawnFood(Point(r_x, r_y));
+        }
         BoardCommand::Noop
     }
 }
 
 impl AI for Egg {
-    fn step(&mut self, b: &Screen, w: &mut World) -> BoardCommand {
+    fn step(&mut self, b: &Screen, w: &mut World, t: u32) -> BoardCommand {
         if self.counter > 0 {
             self.counter -= 1;
             return BoardCommand::Noop;
@@ -85,24 +127,33 @@ impl AI for Egg {
 }
 
 impl AI for Queen {
-    fn step(&mut self, b: &Screen, w: &mut World) -> BoardCommand {
+    fn step(&mut self, b: &Screen, w: &mut World, t: u32) -> BoardCommand {
-        let valid: Vec<Point> = w.get_valid_movements(&self.pos, b, false);
+        let valid: Vec<Point> = self.pos.get_neighbors();
         let mut rng = thread_rng();
 
         let choice = valid.choose(&mut rng).cloned();
 
         if !choice.is_none() {
             let pos = choice.unwrap();
-            if w.cleared.contains(&pos) {
+            // choose between laying an egg and moving
-                // choose between laying an egg and moving
+            if self.egg_count < 3 {
-                if self.egg_count < 3 {
+                self.egg_count += 1;
-                    self.egg_count += 1;
+                return BoardCommand::LayEgg(pos, self.id);
-                    return BoardCommand::LayEgg(pos, self.id);
+            } else {
-                } else {
+                self.pos = pos;
-                    self.pos = pos;
-                }
             }
         }
         BoardCommand::Noop
     }
 }
+
+impl AI for Food {
+    fn step(&mut self, b: &Screen, w: &mut World, t: u32) -> BoardCommand {
+        for n in self.pos.get_neighbors() {
+            w.drop_pheremone(&n, &AIGoal::Return);
+        }
+        w.drop_pheremone(&self.pos, &AIGoal::Return);
+
+        BoardCommand::Noop
+    }
+}

src/lib/entity.rs

@@ -1,10 +1,8 @@
 use crate::lib::ai::{AIGoal, AI};
-use crate::lib::point::Point;
+use crate::lib::point::{Direction, Point};
-use crate::lib::screen::{BoardCommand, Screen};
+use crate::lib::screen::Screen;
-use crate::lib::world::World;
-use rand::Rng;
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 use ncurses::*;
 
@@ -16,6 +14,7 @@ pub trait Entity: AI + Downcast {
     fn set_id(&mut self, id: u32);
 }
 
+
 macro_rules! impl_entity {
     ($t: ident) => {
         impl Entity for $t {
@@ -40,7 +39,9 @@ impl_downcast!(Renderable);
 pub struct Ant {
     pub pos: Point,
     pub id: u32,
-    pub plan: Vec<AIGoal>,
+    pub goal: AIGoal,
+    pub dir: Direction,
+    pub history: HashSet<Point>,
 }
 
 impl Ant {
@@ -48,10 +49,37 @@ impl Ant {
         Ant {
             pos: Point(x, y),
             id: 0,
-            plan: vec![],
+            goal: AIGoal::Seek,
+            dir: Direction::Up,
+            history: HashSet::new(),
+        }
+    }
+
+    pub fn forward(&mut self, s: &Screen) {
+        let target = self.dir.relative_point(&self.pos);
+        if s.is_in_bounds(&target) {
+            self.history.insert(self.pos);
+            self.pos = target;
+        } else {
+            self.cw();
+            self.cw();
         }
     }
+    
+    pub fn ccw(&mut self) {
+        self.dir = self.dir.ccw();
+    }
+
+    pub fn cw(&mut self) {
+        self.dir = self.dir.cw();
+    }
+
+    pub fn about_face(&mut self) {
+        self.cw();
+        self.cw();
+    }
 }
+
 impl_entity!(Ant);
 impl_entity!(Food);
 impl_entity!(FoodGenerator);
@@ -60,14 +88,27 @@ impl_entity!(Queen);
 
 impl Renderable for Ant {
     fn representation(&self) -> &str {
-        "o"
+        match self.dir {
+            Direction::Up => "^",
+            Direction::Down => "v",
+            Direction::Right => ">",
+            Direction::Left => "<",
+        }
     }
     fn before_render(&self) {
         attron(A_BOLD());
+        match self.goal {
+            AIGoal::Return => attron(A_UNDERLINE()),
+            AIGoal::Seek => 0,
+        };
     }
 
     fn after_render(&self) {
         attroff(A_BOLD());
+        match self.goal {
+            AIGoal::Return => attroff(A_UNDERLINE()),
+            AIGoal::Seek => 0,
+        };
     }
 }
 
@@ -173,7 +214,7 @@ impl Entities {
 
 #[derive(Clone)]
 pub struct Food {
-    pos: Point,
+    pub pos: Point,
     id: u32,
 }
 
@@ -186,14 +227,6 @@ impl Food {
     }
 }
 
-impl AI for Food {
-    fn step(&mut self, b: &Screen, w: &mut World) -> BoardCommand {
-        // perhaps check if we're in target?
-        // implement drag logic?
-        BoardCommand::Noop
-    }
-}
-
 impl Renderable for Food {
     fn representation(&self) -> &str {
         "f"
@@ -203,34 +236,20 @@ impl Renderable for Food {
 // no position, does not get rendered yet acts per turn
 #[derive(Clone)]
 pub struct FoodGenerator {
-    timer: u32,
+    pub timer: u32,
     pos: Point,
     id: u32,
-    counter: u32
+    pub counter: u32,
 }
 
 impl FoodGenerator {
     pub fn new() -> FoodGenerator {
-        FoodGenerator { timer: 0, id: 0, pos: Point(0,0), counter: 0 }
+        FoodGenerator {
-    }
+            timer: 0,
-}
+            id: 0,
-
+            pos: Point(0, 0),
-impl AI for FoodGenerator {
+            counter: 0,
-    fn step(&mut self, b: &Screen, w: &mut World) -> BoardCommand {
-        if self.timer % 600 == 0 && self.counter < 10 {
-            // generate random coords, if valid, spawn
-            // if not, try again next step
-            let (min, max) = b.get_dimensions();
-
-            let mut rng = rand::thread_rng();
-            let r_x = rng.gen_range(min.0..max.0 + 1);
-            let r_y = rng.gen_range(min.1..max.1 + 1);
-            
-            self.counter += 1;
-            return BoardCommand::SpawnFood(Point(r_x, r_y));
         }
-        self.timer += 1;
-        BoardCommand::Noop
     }
 }
 

src/lib/point.rs

@@ -1,7 +1,3 @@
-use crate::lib::screen::Screen;
-use crate::lib::world::World;
-use std::collections::{HashMap, HashSet};
-
 #[derive(Hash, PartialEq, Eq, Clone, Debug, Copy)]
 pub struct Point(pub i32, pub i32);
 
@@ -14,29 +10,10 @@ impl Point {
         Point(self.0 - 1, self.1)
     }
 
-    pub fn is_below(&self, other: Point) -> bool {
-        other.down() == *self
-    }
-
     pub fn right(&self) -> Point {
         Point(self.0 + 1, self.1)
     }
 
-    pub fn uldiag(&self) -> Point {
-        Point(self.0 - 1, self.1 - 1)
-    }
-
-    pub fn bldiag(&self) -> Point {
-        Point(self.0 + 1, self.1 - 1)
-    }
-
-    pub fn brdiag(&self) -> Point {
-        Point(self.0 + 1, self.1 + 1)
-    }
-
-    pub fn urdiag(&self) -> Point {
-        Point(self.0 - 1, self.1 + 1)
-    }
     // y values are reversed in ncurses
     pub fn down(&self) -> Point {
         Point(self.0, self.1 + 1)
@@ -47,111 +24,45 @@ impl Point {
     }
 }
 
-fn manhattan(c1: &Point, c2: &Point) -> i32 {
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-    return (c2.0 - c1.0).abs() + (c2.1 - c1.1).abs();
+pub enum Direction {
-}
+    Up = 0,
-
+    Right = 1,
-fn weigh_point(w: &World, p: &Point) -> i32 {
+    Down = 2,
-    if w.is_cleared(p) {
+    Left = 3,
-        3
-    } else {
-        15
-    }
 }
 
-pub struct PathNotFoundError;
+impl Direction {
-
+    pub fn from_u8(v: u8) -> Direction {
-pub fn astar(start: &Point, goal: &Point, w: Option<&World>, s: Option<&Screen>) -> Result<Vec<Point>, PathNotFoundError> {
+        match v {
-    let mut open_set: HashSet<Point> = HashSet::new();
+            0 => Direction::Up,
-    open_set.insert(*start);
+            1 => Direction::Right,
-
+            2 => Direction::Down,
-    let mut came_from: HashMap<Point, Point> = HashMap::new();
+            3 => Direction::Left,
-
+            _ => panic!("Shouldn't happen")
-    let mut gscore: HashMap<Point, i32> = HashMap::new();
-    gscore.insert(*start, 0);
-
-    let mut fscore: HashMap<Point, i32> = HashMap::new();
-    fscore.insert(*start, manhattan(&start, &goal));
-
-    let mut answer = Vec::new();
-
-    let mut current: Point = *start;
-    while !open_set.is_empty() {
-        let mut min_score = i32::MAX;
-        for c in open_set.iter() {
-            let val = fscore[c];
-            current = if val < min_score { c.clone() } else { current };
-            min_score = if val < min_score { val } else { min_score };
-        }
-
-        if current == *goal {
-            answer.push(current.clone());
-            while came_from.contains_key(&current) {
-                current = came_from[&current].clone();
-                if current != *start {
-                    answer.push(current.clone());
-                }
-            }
-            return Ok(answer);
         }
+    }
 
-        open_set.remove(&current);
+    pub fn cw(&self) -> Direction {
-
+        let val = *self as u8;
-        let current_gscore = gscore[&current];
+        Direction::from_u8((val + 1) % 4)
-
+    }
-        let all_neighbors: Vec<Point> = match w {
-            Some(w) => current
-                .get_neighbors()
-                .iter()
-                .filter(|p| w.is_valid_movement(&current, p, s.unwrap()))
-                .map(|e| e.clone())
-                .collect(),
-            None => current.get_neighbors(),
-        };
-
-        for neighbor in all_neighbors.iter() {
-            let neighbor_score = if gscore.contains_key(&neighbor) {
-                gscore[&neighbor]
-            } else {
-                i32::MAX
-            };
-
-            let weight = match w {
-                Some(w) => weigh_point(&w, neighbor),
-                None => 1,
-            };
-
-            let score = current_gscore + weight;
 
-            if score < neighbor_score {
+    pub fn ccw(&self) -> Direction {
-                gscore.insert(neighbor.clone(), score);
+        let val = *self as u8;
-                fscore.insert(neighbor.clone(), score + manhattan(&neighbor, &goal));
+        if val == 0 {
-                came_from.insert(neighbor.clone(), current.clone());
+            Direction::Left
-                open_set.insert(neighbor.clone());
+        } else {
-            }
+            Direction::from_u8(val - 1)
         }
     }
 
-    Err(PathNotFoundError)
+    pub fn relative_point(&self, p: &Point) -> Point {
-}
+        match self {
-
+            Direction::Up => p.up(),
-#[test]
+            Direction::Left => p.left(),
-fn test_astar() {
+            Direction::Right => p.right(),
-    let start = Point(0, 0);
+            Direction::Down => p.down(),
-
-    let goal = Point(10, 10);
-    let answers = astar(&start, &goal, None, None);
-    
-    match answers {
-        Ok(ans) => {
-            for a in ans.iter() {
-                println!("{:?}", &a);
-            }     
-        },
-        Err(_) => {
-            panic!("Path not found. That shouldn't happen!")
         }
     }
-
-    
 }

src/lib/screen.rs

@@ -1,16 +1,17 @@
 use crate::lib::point::Point;
+use ncurses::*;
 
 pub struct Screen {
     pub center: Point,
-    max_x: i32,
+    pub max_x: i32,
-    max_y: i32,
+    pub max_y: i32,
 }
 
-use ncurses::*;
-
 pub fn init_screen() -> Screen {
     initscr();
 
+    start_color();
+    init_pair(0, 0, 1);
     /* Invisible cursor. */
     curs_set(CURSOR_VISIBILITY::CURSOR_INVISIBLE);
 
@@ -32,16 +33,7 @@ impl Screen {
     }
 
     pub fn is_in_bounds(&self, pos: &Point) -> bool {
-        (pos.0 >= 0 && pos.0 < self.max_x) && (pos.1 >= 0 && pos.1 < self.max_y)
+        (pos.0 > 0 && pos.0 < self.max_x) && (pos.1 > 0 && pos.1 < self.max_y)
-    }
-
-    pub fn get_valid_movements(&self, pos: &Point) -> Vec<Point> {
-        let binding = pos.get_neighbors();
-        binding
-            .iter()
-            .filter(|e| self.is_in_bounds(e))
-            .map(|e| e.clone())
-            .collect()
     }
 
     pub fn render(&self, p: &Point, char: &str) {
@@ -53,33 +45,10 @@ impl Screen {
     }
 }
 
-/*#[test]
-fn test_in_bounds() {
-    let x = 20;
-    let y = 20;
-    let s = Screen::new(x, y);
-
-    assert!(&s.is_in_bounds(&Point(0, 0)));
-    assert!(!&s.is_in_bounds(&Point(21, 0)));
-}
-
-#[test]
-fn test_get_valid_movements_board() {
-    let x = 20;
-    let y = 20;
-    let s = Screen::new(x, y);
-
-    let valid = s.get_valid_movements(&Point(0,0));
-    assert_eq!(valid, Point(0,0).get_neighbors());
-
-    let border = s.get_valid_movements(&Point(19,19));
-    assert!(border.len() == 2);
-}*/
-
 pub enum BoardCommand {
-    Dig(Point),
     LayEgg(Point, u32),
     SpawnFood(Point),
     Hatch(u32, u32),
+    SpawnAnt,
     Noop,
 }

src/lib/world.rs

@@ -1,97 +1,77 @@
+use crate::lib::ai::AIGoal;
 use crate::lib::entity::{Ant, Egg, Entities, Food, Queen};
-use crate::lib::point::{astar, Point};
+use crate::lib::point::Point;
 use crate::lib::screen::{BoardCommand, Screen};
 use std::collections::HashSet;
 
+use ncurses::*;
+
 #[derive(Clone)]
 pub struct World {
-    pub cleared: HashSet<Point>,
+    pub pheremones: Vec<Pheremone>,
-    pub food: HashSet<u32>,
+    pub food: HashSet<Point>,
+    pub home: HashSet<Point>,
+    width: usize,
 }
 
-impl World {
+#[derive(Clone, PartialEq, PartialOrd, Debug)]
-    pub fn new() -> World {
+pub struct Pheremone {
-        World {
+    pub home: u32,
-            cleared: HashSet::new(),
+    pub food: u32,
-            food: HashSet::new(),
+}
-        }
-    }
 
-    pub fn clear(&mut self, pos: Point) {
+impl Pheremone {
-        self.cleared.insert(pos);
+    pub fn new() -> Pheremone {
+        Pheremone { home: 0, food: 0 }
     }
 
-    pub fn create_chamber(&mut self, center: Point, radius: i32) {
+    pub fn decay(&mut self) {
-       let cx = center.0;
+        if self.home > 0 {
-       let cy = center.1;
+            self.home -= 1;
-
+        }
-       for i in cx-radius..cx+radius {
+        if self.food > 0 {
-           for j in cy-radius..cy+radius {
+            self.food -= 1;
-                self.clear(Point(i,j));
+        }
-           }
-       }
     }
+}
 
-    pub fn is_valid_movement(&self, current: &Point, target: &Point, b: &Screen) -> bool {
+impl World {
-        // should allow down movements always
+    pub fn new(grid_size: &Point) -> World {
-        
+        let x = grid_size.0;
-        let safe = target.is_below(*current) || (
+        let y = grid_size.1;
-               !self.cleared.contains(&target.down())
+        let ph: Vec<Pheremone> = vec![Pheremone::new(); (x+1) as usize * (y+1) as usize];
-            || !self.cleared.contains(&target.left())
-            || !self.cleared.contains(&target.right())
-            || !self.cleared.contains(&target.bldiag())
-            || !self.cleared.contains(&target.uldiag())
-            || !self.cleared.contains(&target.brdiag())
-            || !self.cleared.contains(&target.urdiag()));
-
-        // of course, its only a valid move if you can walk there!
-        b.is_in_bounds(target) && self.cleared.contains(target) && safe
-    }
 
-    pub fn is_cleared(&self, pos: &Point) -> bool {
+        World {
-        self.cleared.contains(pos)
+            pheremones: ph,
+            food: HashSet::new(),
+            home: HashSet::new(), // should be a property per colony
+            width: (y as usize),  // width of map for Pheremone calculation
+        }
     }
 
-    pub fn is_safe_to_dig(&self, target: &Point, b: &Screen) -> bool {
+    pub fn get_mut_pheremone(&mut self, pos: &Point) -> &mut Pheremone {
-        let mut hypothetical_world = self.clone();
+        &mut self.pheremones[((pos.0 as usize) * self.width) + (pos.1 as usize)]
-        hypothetical_world.clear(*target);
-        let result = astar(target, &Point(0, 0), Some(&hypothetical_world), Some(b));
-        b.is_in_bounds(target) && result.is_ok()
     }
 
-    pub fn get_diggable(&self, b: &Screen, pos: &Point) -> Vec<Point> {
+    pub fn get_pheremone(&self, pos: &Point) -> &Pheremone {
-        let moves = b.get_valid_movements(pos);
+        &self.pheremones[((pos.0 as usize) * self.width) + (pos.1 as usize)]
-        moves
-            .iter()
-            .filter(|p| !self.is_cleared(p))
-            .map(|p| p.clone())
-            .collect()
     }
 
-    pub fn get_valid_movements(
+    pub fn drop_pheremone(&mut self, pos: &Point, state: &AIGoal) {
-        &self,
+        let ph = self.get_mut_pheremone(pos);
-        pos: &Point,
-        b: &Screen,
-        return_diggables: bool,
-    ) -> Vec<Point> {
-        let moves = b.get_valid_movements(pos);
-        let mut ans: Vec<Point> = moves
-            .iter()
-            .filter(|p| self.is_valid_movement(pos, p, b))
-            .map(|p| p.clone())
-            .collect();
-
-        if return_diggables {
-            ans.extend(self.get_diggable(b, pos));
-        }
 
-        ans
+        match state {
+            AIGoal::Seek => ph.home += 1,
+            AIGoal::Return => ph.food += 1,
+        }
     }
 }
 
 pub fn render(e: &Entities, w: &World, b: &Screen) {
-    for c in w.cleared.iter() {
+    erase();
-        b.render(c, "x");
+    
+    for h in w.home.iter() {
+        b.render(h, "x");
     }
 
     for a in e.data.values() {
@@ -99,20 +79,17 @@ pub fn render(e: &Entities, w: &World, b: &Screen) {
     }
 }
 
-pub fn simulate(e: &mut Entities, w: &mut World, b: &mut Screen) {
+pub fn simulate(e: &mut Entities, w: &mut World, b: &mut Screen, step: u32) {
-    let cmds: Vec<BoardCommand> = e
+    let plan_cmds: Vec<BoardCommand> = e.data.values_mut().map(|a| a.plan(b, w)).collect();
-        .data
+    let mut cmds: Vec<BoardCommand> = e.data.values_mut().map(|a| a.step(b, w, step)).collect();
-        .values_mut()
+
-        .map(|a| {
+    cmds.extend(plan_cmds);
-            a.plan(w);
-            a.step(b, w)
-        })
-        .collect();
 
     for cmd in cmds {
         match cmd {
-            BoardCommand::Dig(pos) => {
+            BoardCommand::SpawnAnt => {
-                w.clear(pos);
+                let ant = Ant::new(b.center.0, b.center.1);
+                e.add_entity(&ant);
             }
             BoardCommand::LayEgg(pos, id) => {
                 let egg = Egg::new(pos.0, pos.1, id);
@@ -131,8 +108,16 @@ pub fn simulate(e: &mut Entities, w: &mut World, b: &mut Screen) {
             BoardCommand::SpawnFood(pos) => {
                 let food = Food::new(pos.0, pos.1);
                 e.add_entity(&food);
+                w.food.insert(pos);
             }
             BoardCommand::Noop => {}
         }
     }
+
+    // decay all pheremones by some amount
+    if step % 600 == 0 {
+        for ph in w.pheremones.iter_mut() {
+            ph.decay();
+        }
+    }
 }

src/main.rs

@@ -7,34 +7,42 @@ use std::thread::sleep;
 use std::time;
 
 mod lib {
+    pub mod ai;
+    pub mod entity;
     pub mod point;
     pub mod screen;
     pub mod world;
-    pub mod entity;
-    pub mod ai;
 }
 
+use lib::entity::{Ant, Entities, FoodGenerator};
 use lib::point::Point;
 use lib::screen::init_screen;
-use lib::world::{World, simulate, render};
+use lib::world::{render, simulate, World};
-use lib::entity::{Entities, Queen};
 
 fn main() {
-    let mut board = init_screen(); 
+    let mut screen = init_screen();
-    let mut world = World::new();
+    let mut world = World::new(&Point(screen.max_x, screen.max_y));
+    world.home.insert(screen.center);
 
     let mut entities = Entities::new();
-    let q = Queen::new(board.center.0,board.center.1);
-    entities.add_entity(&q);
 
-    world.create_chamber(Point(board.center.0, board.center.1), 3);
+    let fg = FoodGenerator::new();
+    entities.add_entity(&fg);
+
+    for _ in 0..5 {
+        let mut a = Ant::new(screen.center.0, screen.center.1);
+        a.goal = lib::ai::AIGoal::Seek;
+        entities.add_entity(&a);
+    }
 
+    let mut t = 0;
     loop {
         // TODO: add way to break out of the loop by hitting a random key
-        simulate(&mut entities, &mut world, &mut board);
+        simulate(&mut entities, &mut world, &mut screen, t);
-        render(&entities, &world, &board);
+        render(&entities, &world, &screen);
         sleep(time::Duration::from_millis(100));
         refresh();
+        t += 1;
     }
     endwin();
 }

tests/ai_test.rs

@@ -13,9 +13,8 @@ use std::time;
 #[test]
 fn test_reach_astar() {
     let mut board = init_screen(); //Screen::new(40,40);
-    let mut world = World::new();
+    let mut world = World::new(&Point(board.max_x, board.max_y));
 
-    world.clear(Point(0, 0));
     let mut entities = Entities::new();
 
     let a = Ant::new(0, 0);
@@ -23,15 +22,15 @@ fn test_reach_astar() {
 
     let a = entities.data.get_mut(&id).unwrap();
     let ant: &mut Ant = a.downcast_mut::<Ant>().unwrap();
-    ant.plan.push(AIGoal::Reach(Point(0, 0)));
+    /*ant.plan.push(AIGoal::Reach(Point(0, 0)));
     ant.plan.push(AIGoal::Reach(Point(20, 20)));
     ant.plan.push(AIGoal::Reach(Point(0, 0)));
-    ant.plan.push(AIGoal::Reach(Point(20, 20)));
+    ant.plan.push(AIGoal::Reach(Point(20, 20)));*/
 
     // craps out... need to make sure unwrap() is safe
-    for _ in 0..420 {
+    for t in 0..420 {
         // TODO: add way to break out of the loop by hitting a random key
-        simulate(&mut entities, &mut world, &mut board);
+        simulate(&mut entities, &mut world, &mut board, t);
         render(&entities, &world, &board);
         sleep(time::Duration::from_millis(100));
         refresh();

tests/entity_test.rs

@@ -1,6 +1,7 @@
 use antf::lib::screen::init_screen;
 use antf::lib::world::{World, simulate, render};
 use antf::lib::entity::{Entities, FoodGenerator};
+use antf::lib::point::Point;
 
 use ncurses::*;
 use std::thread::sleep;
@@ -9,15 +10,15 @@ use std::time;
 #[test]
 fn test_foodgen() {
     let mut board = init_screen(); 
-    let mut world = World::new();
+    let mut world = World::new(&Point(board.max_x, board.max_y));
 
     let mut entities = Entities::new();
     let fg = FoodGenerator::new();
     entities.add_entity(&fg);
 
-    for _ in 0..60 {
+    for t in 0..60 {
         // TODO: add way to break out of the loop by hitting a random key
-        simulate(&mut entities, &mut world, &mut board);
+        simulate(&mut entities, &mut world, &mut board, t);
         render(&entities, &world, &board);
         sleep(time::Duration::from_millis(100));
         refresh();