--- a/rust/landgen/src/template_based.rs	Fri Nov 02 01:34:21 2018 +0100
+++ b/rust/landgen/src/template_based.rs	Fri Nov 02 09:45:54 2018 +0100
@@ -1,192 +1,11 @@
-use itertools::Itertools;
-
-use integral_geometry::{Point, Rect, Size};
+use integral_geometry::{Point, Size};
 use land2d::Land2D;
 use LandGenerationParameters;
 use LandGenerator;
 
-struct OutlinePoints {
-    islands: Vec<Vec<Point>>,
-    fill_points: Vec<Point>,
-    size: Size,
-}
-
-impl OutlinePoints {
-    fn from_outline_template<I: Iterator<Item = u32>>(
-        outline_template: &OutlineTemplate,
-        random_numbers: &mut I,
-    ) -> Self {
-        Self {
-            islands: outline_template
-                .islands
-                .iter()
-                .map(|i| {
-                    i.iter()
-                        .zip(random_numbers.tuples())
-                        .map(|(rect, (rnd_a, rnd_b))| {
-                            Point::new(
-                                rect.x + (rnd_a % rect.width) as i32,
-                                rect.y + (rnd_b % rect.height) as i32,
-                            )
-                        }).collect()
-                }).collect(),
-            fill_points: outline_template.fill_points.clone(),
-            size: outline_template.size,
-        }
-    }
-
-    fn total_len(&self) -> usize {
-        self.islands.iter().map(|i| i.len()).sum::<usize>() + self.fill_points.len()
-    }
-
-    fn iter_mut(&mut self) -> impl Iterator<Item = &mut Point> {
-        self.islands
-            .iter_mut()
-            .flat_map(|i| i.iter_mut())
-            .chain(self.fill_points.iter_mut())
-    }
-
-    fn divide_edge<I: Iterator<Item = u32>>(
-        &self,
-        start_point: Point,
-        end_point: Point,
-        random_numbers: &mut I,
-    ) -> Option<Point> {
-        None
-    }
-
-    fn divide_edges<I: Iterator<Item = u32>>(&mut self, random_numbers: &mut I) {
-        for is in 0..self.islands.len() {
-            let mut i = 0;
-            let mut start_point = Point::zero();
-            let mut end_point = Point::zero();
-
-            loop {
-                {
-                    let island = &self.islands[is];
-                    if i < island.len() {
-                        start_point = island[i];
-                        end_point = if i + 1 < island.len() {
-                            island[i + 1]
-                        } else {
-                            island[0]
-                        };
-                    } else {
-                        break
-                    }
-                }
-
-                if let Some(new_point) = self.divide_edge(start_point, end_point, random_numbers) {
-                    self.islands[is].insert(i + 1, new_point);
-                    i += 2;
-                } else {
-                    i += 1;
-                }
-            }
-        }
-    }
-
-    fn bezierize(&mut self) {
-        unimplemented!()
-    }
-
-    fn distort<I: Iterator<Item = u32>>(&mut self, random_numbers: &mut I) {
-        loop {
-            let old_len = self.total_len();
-            self.divide_edges(random_numbers);
+use outline::OutlinePoints;
+use outline_template::OutlineTemplate;
 
-            if self.total_len() != old_len {
-                break;
-            }
-        }
-
-        self.bezierize();
-    }
-
-    fn draw<T: Copy + PartialEq>(&self, land: &mut Land2D<T>, value: T) {
-        for island in &self.islands {
-            if island.len() > 1 {
-                for i in 0..island.len() - 1 {
-                    land.draw_line(island[i], island[i + 1], value);
-                }
-                land.draw_line(island[island.len() - 1], island[0], value);
-            }
-        }
-    }
-}
-
-pub struct OutlineTemplate {
-    islands: Vec<Vec<Rect>>,
-    fill_points: Vec<Point>,
-    size: Size,
-    can_flip: bool,
-    can_invert: bool,
-    can_mirror: bool,
-    is_negative: bool,
-}
-
-impl OutlineTemplate {
-    pub fn new(size: Size) -> Self {
-        OutlineTemplate {
-            size,
-            islands: Vec::new(),
-            fill_points: Vec::new(),
-            can_flip: false,
-            can_invert: false,
-            can_mirror: false,
-            is_negative: false,
-        }
-    }
-
-    pub fn flippable(self) -> Self {
-        Self {
-            can_flip: true,
-            ..self
-        }
-    }
-
-    pub fn mirrorable(self) -> Self {
-        Self {
-            can_mirror: true,
-            ..self
-        }
-    }
-
-    pub fn invertable(self) -> Self {
-        Self {
-            can_invert: true,
-            ..self
-        }
-    }
-
-    pub fn negative(self) -> Self {
-        Self {
-            is_negative: true,
-            ..self
-        }
-    }
-
-    pub fn with_fill_points(self, fill_points: Vec<Point>) -> Self {
-        Self {
-            fill_points,
-            ..self
-        }
-    }
-
-    pub fn with_islands(self, islands: Vec<Vec<Rect>>) -> Self {
-        Self { islands, ..self }
-    }
-
-    pub fn add_fill_points(mut self, points: &[Point]) -> Self {
-        self.fill_points.extend_from_slice(points);
-        self
-    }
-
-    pub fn add_island(mut self, island: &[Rect]) -> Self {
-        self.islands.push(island.into());
-        self
-    }
-}
 
 pub struct TemplatedLandGenerator {
     outline_template: OutlineTemplate,