Merge branch '0.3.1' into 'master'

gen-world

See merge request mhart/DancingDroids!59

src/main.rs

@@ -59,18 +59,15 @@ fn create_hash_map(pool: &Vec<robot::Robot>, hash: &mut HashMap<robot::Position,
     }
 }
 
-/// Generate random instructions.
-fn gen_random_instructions() -> String {
+fn gen_world(pool: &mut Vec<robot::Robot>) -> world::World {
+    let w = world::random_world();
     let mut rng = rand::thread_rng();
-    let n = rng.gen_range(5, 10);
-    let mut instructions = String::with_capacity(n);
-    const CHARSET: &[u8] = b"LRF";
-    for _ in 0..n {
-        let l = rng.gen_range(0, CHARSET.len());
-        instructions.push(CHARSET[l] as char);
-    }
+    let x = rng.gen_range(2, 10);
 
-    instructions
+    for i in 0..=x {
+        pool.push(robot::Robot::new_random(i, w.x - 2, w.y - 2));
+    }
+    w
 }
 
 /// Parse the config file, generate the world and robot pool.
@@ -98,7 +95,7 @@ fn parse_config(conf: String, pool: &mut Vec<robot::Robot>) -> Result<world::Wor
             Err(_) => return Err(String::from("Robot setup is broken.")),
         };
 
-        let rand_instructions = gen_random_instructions();
+        let rand_instructions = robot::gen_random_instructions();
         let l = lines.remove(0);
 
         let instructions = match ConfParser::parse(Rule::robot_instructions, l) {
@@ -213,16 +210,27 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 .takes_value(false)
                 .help("Generate random world"),
         )
+        .arg(
+            Arg::with_name("random")
+                .short("r")
+                .long("random")
+                .takes_value(false)
+                .help("Generate random world with 2 random robots"),
+        )
         .get_matches();
-
-    let raw_conf = open_file(matches.value_of("file").unwrap_or("two_robots.txt"))?;
-
     let mut robot_pool: Vec<robot::Robot> = Vec::new();
+    let world = match matches.is_present("random") {
+        true => gen_world(&mut robot_pool),
+        false => {
+            let raw_conf = open_file(matches.value_of("file").unwrap_or("two_robots.txt"))?;
             let mut world: world::World = parse_config(raw_conf, &mut robot_pool)?;
             world = match matches.is_present("random-world") {
                 false => world,
                 true => world::random_world(),
             };
+            world
+        }
+    };
 
     let mut hash: HashMap<robot::Position, u32> = HashMap::new();
     create_hash_map(&robot_pool, &mut hash);

src/robot.rs

@@ -17,6 +17,19 @@ impl Robot {
     pub fn new(id: u32, o: Orientation, p: Position, i: Vec<char>) -> Robot {
         Robot { id, o, p, i }
     }
+    pub fn new_random(id: u32, posx_max: i32, posy_max: i32) -> Robot {
+        let mut rng = rand::thread_rng();
+        let x = rng.gen_range(2, posx_max);
+        let y = rng.gen_range(2, posy_max);
+        let instructions: Vec<char> = gen_random_instructions().chars().rev().collect();
+        let o: Orientation = rand::random();
+        Robot {
+            id,
+            o,
+            p: Position { x, y },
+            i: instructions,
+        }
+    }
     /// Apply given instruction to a `Robot`.
     pub fn execute_instruction(&mut self) {
         match self.i.pop() {
@@ -86,6 +99,20 @@ pub fn is_instructions(v: &Vec<char>) -> bool {
     true
 }
 
+/// Generate random instructions.
+pub fn gen_random_instructions() -> String {
+    let mut rng = rand::thread_rng();
+    let n = rng.gen_range(5, 10);
+    let mut instructions = String::with_capacity(n);
+    const CHARSET: &[u8] = b"LRF";
+    for _ in 0..n {
+        let l = rng.gen_range(0, CHARSET.len());
+        instructions.push(CHARSET[l] as char);
+    }
+
+    instructions
+}
+
 /// Check if a robot is piouff.
 pub fn is_piouff(r: &Robot) -> bool {
     if r.i.len() == 0 {