chore: more scaffolding

ankjevel · ankjevel · commit 41ec730b7f44 · 2020-12-12T10:36:30.000+01:00
diff --git a/day_12/src/direction.rs b/day_12/src/direction.rs
@@ -0,0 +1,36 @@
+use crate::action::Action;
+
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+pub enum Direction {
+    Up,
+    Down,
+    Left,
+    Right,
+}
+
+use Direction::*;
+
+impl Direction {
+    pub fn turn(&mut self, action: &Action) {
+        *self = match action {
+            &Action::Left => match self {
+                Up => Left,
+                Left => Down,
+                Down => Right,
+                Right => Up,
+            },
+            &Action::Right | _ => match self {
+                Up => Right,
+                Right => Down,
+                Down => Left,
+                Left => Up,
+            },
+        };
+    }
+}
+
+impl Default for Direction {
+    fn default() -> Self {
+        Direction::Right
+    }
+}
diff --git a/day_12/src/facing.rs b/day_12/src/facing.rs
@@ -0,0 +1,20 @@
+use crate::action::Action::{self, *};
+
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug)]
+pub enum Facing {
+    East,
+    West,
+    North,
+    South,
+}
+
+impl Facing {
+    pub fn from(action: Action) -> Self {
+        match action {
+            North => Self::North,
+            West => Self::West,
+            South => Self::South,
+            East | _ => Self::East,
+        }
+    }
+}
diff --git a/day_12/src/lib.rs b/day_12/src/lib.rs
@@ -1,4 +1,10 @@
 pub mod action;
+pub mod direction;
+pub mod facing;
+pub mod manhattan;
+pub mod point;
+pub mod ship;
+
 pub mod part_01;
 pub mod part_02;
 
diff --git a/day_12/src/manhattan.rs b/day_12/src/manhattan.rs
@@ -0,0 +1,5 @@
+use crate::point::Point;
+
+pub fn manhattan(point: Point, current: Point) -> u64 {
+    ((point.x as i64 - current.x as i64).abs() + (point.y as i64 - current.y as i64).abs()) as u64
+}
diff --git a/day_12/src/part_01.rs b/day_12/src/part_01.rs
@@ -1,9 +1,10 @@
 use std::io::Result;
 
-use crate::Input;
+use crate::{manhattan::manhattan, point::Point, ship::Ship, Input};
 
-pub fn main(_input: &Input) -> Result<()> {
-    Ok(())
+pub fn main(input: &Input) -> Result<u64> {
+    let point = Ship::default().follow_instruction(&input);
+    Ok(manhattan(point, Point { x: 0, y: 0 }))
 }
 
 #[cfg(test)]
@@ -13,12 +14,16 @@ mod tests {
     use super::*;
 
     const EXAMPLE_DATA: &'static str = "
-        example
+        F10
+        N3
+        F7
+        R90
+        F11
     ";
 
     #[test]
     fn it_gets_the_example_correct() -> Result<()> {
-        assert_eq!(main(&parse_input(&EXAMPLE_DATA))?, ());
+        assert_eq!(main(&parse_input(&EXAMPLE_DATA))?, 25);
         Ok(())
     }
 }
diff --git a/day_12/src/point.rs b/day_12/src/point.rs
@@ -0,0 +1,11 @@
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Default)]
+pub struct Point {
+    pub x: isize,
+    pub y: isize,
+}
+
+impl Point {
+    pub fn new() -> Self {
+        Self { ..Point::default() }
+    }
+}
diff --git a/day_12/src/ship.rs b/day_12/src/ship.rs
@@ -0,0 +1,57 @@
+use crate::{
+    action::Action::{self, *},
+    direction::Direction,
+    point::Point,
+    Input,
+};
+
+#[derive(Clone, Copy, Eq, PartialEq, Hash, Debug, Default)]
+pub struct Ship {
+    facing: Direction,
+    x: isize,
+    y: isize,
+}
+
+impl Ship {
+    fn turn(&mut self, action: &Action) {
+        self.facing.turn(action);
+    }
+
+    fn forward(&mut self, value: &u16) {
+        let value = value.to_owned() as isize;
+        match self.facing {
+            Direction::Up => self.y += value,
+            Direction::Left => self.x -= value,
+            Direction::Down => self.y -= value,
+            Direction::Right => self.x += value,
+        }
+    }
+
+    fn directional_move(&mut self, action: &Action, value: &u16) {
+        let value = value.to_owned() as isize;
+        match action {
+            North => self.y += value,
+            East => self.x += value,
+            South => self.y -= value,
+            West | _ => self.x -= value,
+        }
+    }
+
+    pub fn follow_instruction(mut self, input: &Input) -> Point {
+        for (action, value) in input {
+            println!("action={:?}\taction={}", action, value);
+            match action {
+                North | South | East | West => self.directional_move(action, value),
+                Left | Right => self.turn(action),
+                Forward => self.forward(value),
+            }
+        }
+
+        println!("x={}\ty={}", self.x, self.y);
+
+        Point {
+            x: self.x,
+            y: self.y,
+        }
+    }
+}
