14 impl OutlinePoints {

    15     fn from_outline_template<I: Iterator<Item = u32>>(

    16         outline_template: &OutlineTemplate,

    17         random_numbers: &mut I,

    18     ) -> Self {

    19         Self {

    20             islands: outline_template

    21                 .islands

    22                 .iter()

    23                 .map(|i| {

    24                     i.iter()

    25                         .zip(random_numbers.tuples())

    26                         .map(|(rect, (rnd_a, rnd_b))| {

    27                             Point::new(

    28                                 rect.x + (rnd_a % rect.width) as i32,

    29                                 rect.y + (rnd_b % rect.height) as i32,

    30                             )

    31                         }).collect()

    32                 }).collect(),

    33             fill_points: outline_template.fill_points.clone(),

    34             size: outline_template.size,

    35         }

    36     }

    37 

    38     fn total_len(&self) -> usize {

    39         self.islands.iter().map(|i| i.len()).sum::<usize>() + self.fill_points.len()

    40     }

    41 

    42     fn iter_mut(&mut self) -> impl Iterator<Item = &mut Point> {

    43         self.islands

    44             .iter_mut()

    45             .flat_map(|i| i.iter_mut())

    46             .chain(self.fill_points.iter_mut())

    47     }

    48 

    49     fn divide_edge<I: Iterator<Item = u32>>(

    50         &self,

    51         start_point: Point,

    52         end_point: Point,

    53         random_numbers: &mut I,

    54     ) -> Option<Point> {

    55         None

    56     }

    57 

    58     fn divide_edges<I: Iterator<Item = u32>>(&mut self, random_numbers: &mut I) {

    59         for is in 0..self.islands.len() {

    60             let mut i = 0;

    61             let mut start_point = Point::zero();

    62             let mut end_point = Point::zero();

    63 

    64             loop {

    65                 {

    66                     let island = &self.islands[is];

    67                     if i < island.len() {

    68                         start_point = island[i];

    69                         end_point = if i + 1 < island.len() {

    70                             island[i + 1]

    71                         } else {

    72                             island[0]

    73                         };

    74                     } else {

    75                         break

    76                     }

    77                 }

    78 

    79                 if let Some(new_point) = self.divide_edge(start_point, end_point, random_numbers) {

    80                     self.islands[is].insert(i + 1, new_point);

    81                     i += 2;

    82                 } else {

    83                     i += 1;

    84                 }

    85             }

    86         }

    87     }

    88 

    89     fn bezierize(&mut self) {

    90         unimplemented!()

    91     }

    92 

    93     fn distort<I: Iterator<Item = u32>>(&mut self, random_numbers: &mut I) {

    94         loop {

    95             let old_len = self.total_len();

    96             self.divide_edges(random_numbers);

    97 

    98             if self.total_len() != old_len {

    99                 break;

   100             }

   101         }

   102 

   103         self.bezierize();

   104     }

   105 

   106     fn draw<T: Copy + PartialEq>(&self, land: &mut Land2D<T>, value: T) {

   107         for island in &self.islands {

   108             if island.len() > 1 {

   109                 for i in 0..island.len() - 1 {

   110                     land.draw_line(island[i], island[i + 1], value);

   111                 }

   112                 land.draw_line(island[island.len() - 1], island[0], value);

   113             }

   114         }

   115     }

   116 }

   117 

   118 pub struct OutlineTemplate {

   119     islands: Vec<Vec<Rect>>,

   120     fill_points: Vec<Point>,

   121     size: Size,

   122     can_flip: bool,

   123     can_invert: bool,

   124     can_mirror: bool,

   125     is_negative: bool,

   126 }

   127 

   128 impl OutlineTemplate {

   129     pub fn new(size: Size) -> Self {

   130         OutlineTemplate {

   131             size,

   132             islands: Vec::new(),

   133             fill_points: Vec::new(),

   134             can_flip: false,

   135             can_invert: false,

   136             can_mirror: false,

   137             is_negative: false,

   138         }

   139     }

   140 

   141     pub fn flippable(self) -> Self {

   142         Self {

   143             can_flip: true,

   144             ..self

   145         }

   146     }

   147 

   148     pub fn mirrorable(self) -> Self {

   149         Self {

   150             can_mirror: true,

   151             ..self

   152         }

   153     }

   154 

   155     pub fn invertable(self) -> Self {

   156         Self {

   157             can_invert: true,

   158             ..self

   159         }

   160     }

   161 

   162     pub fn negative(self) -> Self {

   163         Self {

   164             is_negative: true,

   165             ..self

   166         }

   167     }

   168 

   169     pub fn with_fill_points(self, fill_points: Vec<Point>) -> Self {

   170         Self {

   171             fill_points,

   172             ..self

   173         }

   174     }

   175 

   176     pub fn with_islands(self, islands: Vec<Vec<Rect>>) -> Self {

   177         Self { islands, ..self }

   178     }

   179 

   180     pub fn add_fill_points(mut self, points: &[Point]) -> Self {

   181         self.fill_points.extend_from_slice(points);

   182         self

   183     }

   184 

   185     pub fn add_island(mut self, island: &[Rect]) -> Self {

   186         self.islands.push(island.into());

   187         self

   188     }

   189 }