Add belt finding to layouting

src/layout/mod.rs

@@ -1,37 +1,34 @@
 use crate::common::visualize::{Color, Symbol, Visualization, Visualize};
 use crate::prelude::*;
-use crate::{belt_finding::common::print_map, misc::Map};
-
 use rand::Rng;
 use serde::{Deserialize, Serialize};
-use termcolor::ColorSpec;
 
 #[derive(Debug, Serialize, Deserialize)]
-struct Block {
-    size: Position,
-    input: Vec<Interface>,
-    output: Vec<Interface>,
+pub(crate) struct Block {
+    pub(crate) size: Position,
+    pub(crate) input: Vec<Interface>,
+    pub(crate) output: Vec<Interface>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-struct Interface {
-    offset: Position,
-    dir: Direction,
+pub(crate) struct Interface {
+    pub(crate) offset: Position,
+    pub(crate) dir: Direction,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
-struct Connection {
-    startblock: usize,
-    startpoint: usize,
-    endblock: usize,
-    endpoint: usize,
+pub(crate) struct Connection {
+    pub(crate) startblock: usize,
+    pub(crate) startpoint: usize,
+    pub(crate) endblock: usize,
+    pub(crate) endpoint: usize,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Problem {
-    size: Position,
-    blocks: Vec<Block>,
-    connections: Vec<Connection>,
+    pub(crate) size: Position,
+    pub(crate) blocks: Vec<Block>,
+    pub(crate) connections: Vec<Connection>,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -39,8 +36,8 @@ pub struct BlockHandle(usize);
 
 #[derive(Debug, Clone)]
 pub struct Layout<'a> {
-    problem: &'a Problem,
-    blocks: Vec<(Position, Direction)>,
+    pub(crate) problem: &'a Problem,
+    pub(crate) blocks: Vec<(Position, Direction)>,
 }
 
 impl Problem {
@@ -164,7 +161,7 @@ impl Layout<'_> {
             && npos1.y + nsize1.y > npos2.y
     }
 
-    fn normalize_pos(block: (&Block, Position, Direction)) -> (Position, Position) {
+    pub(crate) fn normalize_pos(block: (&Block, Position, Direction)) -> (Position, Position) {
         let npos = match block.2 {
             Direction::Up => block.1,
             Direction::Right => block.1.in_direction(&Direction::Left, block.0.size.y - 1),
@@ -203,7 +200,7 @@ impl Layout<'_> {
         sum
     }
 
-    fn transform(pos: Position, dir: Direction, offset: Position) -> Position {
+    pub(crate) fn transform(pos: Position, dir: Direction, offset: Position) -> Position {
         match dir {
             Direction::Up => pos + offset,
             Direction::Right => pos + Position::new(-offset.y, offset.x),
@@ -211,6 +208,24 @@ impl Layout<'_> {
             Direction::Left => pos + Position::new(offset.y, -offset.x),
         }
     }
+
+    pub(crate) fn rotate(dir: Direction, rot: Direction) -> Direction {
+        match (rot, dir) {
+            (Direction::Up, _) => dir,
+            (Direction::Right, Direction::Up) => Direction::Right,
+            (Direction::Right, Direction::Right) => Direction::Down,
+            (Direction::Right, Direction::Down) => Direction::Left,
+            (Direction::Right, Direction::Left) => Direction::Up,
+            (Direction::Down, Direction::Up) => Direction::Down,
+            (Direction::Down, Direction::Right) => Direction::Left,
+            (Direction::Down, Direction::Down) => Direction::Up,
+            (Direction::Down, Direction::Left) => Direction::Right,
+            (Direction::Left, Direction::Up) => Direction::Left,
+            (Direction::Left, Direction::Right) => Direction::Up,
+            (Direction::Left, Direction::Down) => Direction::Right,
+            (Direction::Left, Direction::Left) => Direction::Down,
+        }
+    }
 }
 
 impl<'a> Visualize for Layout<'a> {