Initial commit

1 files changed, 119 insertions, 0 deletions

diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..7c904d6
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,119 @@
+extern crate json;
+extern crate rand;
+
+use std::env;
+use std::path::Path;
+use std::path::PathBuf;
+use std::io::prelude::*;
+use std::fs::File;
+use std::fmt;
+
+use rand::distributions::{IndependentSample, Range};
+
+const COMMAND_FILE: &'static str = "command.txt";
+const PLACE_FILE: &'static str = "place.txt";
+const STATE_FILE: &'static str = "state.json";
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+enum Orientation {
+    North,
+    East,
+    South,
+    West,
+}
+
+impl fmt::Display for Orientation {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(
+            match self {
+                &Orientation::North => "North",
+                &Orientation::East => "East",
+                &Orientation::South => "South",
+                &Orientation::West => "West"
+            }
+        )
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+enum Action {
+    PlaceShips(Vec<(String, u32, u32, Orientation)>),
+    Shoot(u32, u32)
+}
+
+impl fmt::Display for Action {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            &Action::Shoot(x, y) => writeln!(f, "1,{},{}", x, y),
+            &Action::PlaceShips(ref ships) => ships.iter().map(|&(ref ship_type, x, y, orientation)| {
+                writeln!(f, "{} {} {} {}", ship_type, x, y, orientation)
+            }).fold(Ok(()), |acc, next| acc.and(next))
+        }
+    }
+}
+
+fn main() {
+    let working_dir = env::args()
+        .nth(2)
+        .map(|pwd| PathBuf::from(pwd))
+        .expect("Requires game state folder to be passed as the second parameter");
+
+    // The state file is read here. Chances are, you'll want to read
+    // more values out of it than the sample bot currently does.
+    let state = read_file(&working_dir).expect("Failed to read state.json");
+
+    let is_place_phase = state["Phase"] == 1;
+    let map_dimension = state["MapDimension"].as_u32().expect("Could not read map dimension from the state");
+
+    let action = if is_place_phase {
+        place_ships()
+    }
+    else {
+        shoot_randomly(map_dimension)
+    };
+
+    
+    write_action(&working_dir, is_place_phase, action).expect("Failed to write action to file");
+}
+
+fn read_file(working_dir: &Path) -> Result<json::JsonValue, String> {
+    let state_path = working_dir.join(STATE_FILE);
+    let mut file = File::open(state_path.as_path()).map_err(|e| e.to_string())?;
+    let mut content = String::new();
+    file.read_to_string(&mut content).map_err(|e| e.to_string())?;
+    json::parse(content.as_ref()).map_err(|e| e.to_string())
+}
+
+fn place_ships() -> Action {
+    let ships = vec!(
+        (String::from("Battleship"), 1, 0, Orientation::North),
+        (String::from("Carrier"), 3, 1, Orientation::East),
+        (String::from("Cruiser"), 4, 2, Orientation::North),
+        (String::from("Destroyer"), 7, 3, Orientation::North),
+        (String::from("Submarine"), 1, 8, Orientation::East)
+    );
+    
+    Action::PlaceShips(ships)
+}
+
+fn shoot_randomly(map_dimension: u32) -> Action {
+    let mut rng = rand::thread_rng();
+    let between = Range::new(0, map_dimension);
+    let x = between.ind_sample(&mut rng);
+    let y = between.ind_sample(&mut rng);
+    Action::Shoot(x, y)
+}
+
+fn write_action(working_dir: &Path, is_place_phase: bool, action: Action) -> Result<(), String> {
+    let filename = if is_place_phase {
+        PLACE_FILE
+    }
+    else {
+        COMMAND_FILE
+    };
+    
+    let full_filename = working_dir.join(filename);
+    let mut file = File::create(full_filename.as_path()).map_err(|e| e.to_string())?;
+    writeln!(file, "{}", action).map_err(|e| e.to_string())?;
+    Ok(())
+}