Add power connection and steiner tree

factorio-blueprint/src/abstraction.rs

@@ -1,11 +1,18 @@
 use factorio_core::{
-    aabb::AABB, beltoptions::Beltspeed, pathfield::PathField, prelude::*,
+    aabb::AABB,
+    beltoptions::Beltspeed,
+    pathfield::PathField,
+    prelude::*,
     quaterdirection::QuaterDirection,
+    visualize::{Color, Visualization},
 };
 use std::{collections::HashMap, sync::atomic::AtomicUsize};
 
 use crate::{BlueprintEntity, BlueprintPosition};
 
+mod power_connection;
+mod visualize;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum UndergroundType {
     Input,
@@ -94,15 +101,26 @@ impl RailType {
     }
 
     fn size(&self) -> Position {
-        todo!()
+        Position::new(12, 12)
     }
 }
 
+#[derive(Debug, Clone)]
 enum DirectionType {
     Dir(Direction),
     QuarterDir(QuaterDirection),
 }
 
+impl DirectionType {
+    fn unwrap_dir(&self) -> Direction {
+        match self {
+            DirectionType::Dir(direction) => *direction,
+            DirectionType::QuarterDir(_quater_direction) => panic!(),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
 pub struct Entity {
     entity: EntityType,
     position: Position,
@@ -110,6 +128,7 @@ pub struct Entity {
     quality: Quality,
 }
 
+#[derive(Debug, Clone)]
 pub enum EntityType {
     Belt(Beltspeed),
     UndergroundBelt(Beltspeed, UndergroundType),
@@ -335,6 +354,96 @@ impl Entity {
             }
         };
     }
+
+    pub fn get_aabb(&self) -> AABB {
+        let halve_size = self.size() / 2;
+        match self.direction {
+            DirectionType::Dir(direction) => match direction {
+                Direction::Up | Direction::Down => {
+                    AABB::new(self.position - halve_size, self.position + halve_size)
+                }
+                Direction::Right | Direction::Left => AABB::new(
+                    self.position - Position::new(halve_size.y, halve_size.x),
+                    self.position + Position::new(halve_size.y, halve_size.x),
+                ),
+            },
+            DirectionType::QuarterDir(_) => {
+                AABB::new(self.position - halve_size, self.position + halve_size)
+            }
+        }
+    }
+    fn visualize(&self, v: &mut Visualization, offset: Position) {
+        match &self.entity {
+            EntityType::Belt(beltspeed) => {
+                v.add_symbol(
+                    (self.position - Position::new(1, 1)) / 2 + offset,
+                    factorio_core::visualize::Symbol::Arrow(self.direction.unwrap_dir()),
+                    Some(factorio_core::visualize::Color::white()),
+                    None,
+                );
+            }
+            EntityType::UndergroundBelt(beltspeed, underground_type) => match underground_type {
+                UndergroundType::Input => {
+                    v.add_symbol(
+                        (self.position - Position::new(1, 1)) / 2 + offset,
+                        factorio_core::visualize::Symbol::ArrowEnter(self.direction.unwrap_dir()),
+                        Some(factorio_core::visualize::Color::white()),
+                        None,
+                    );
+                }
+                UndergroundType::Output => {
+                    v.add_symbol(
+                        (self.position - Position::new(1, 1)) / 2 + offset,
+                        factorio_core::visualize::Symbol::ArrowExit(self.direction.unwrap_dir()),
+                        Some(factorio_core::visualize::Color::white()),
+                        None,
+                    );
+                }
+            },
+            EntityType::Splitter(beltspeed) => (),
+            EntityType::ElectricPole(electric_pole_type) => match electric_pole_type {
+                ElectricPoleType::Small => v.add_symbol(
+                    (self.position - Position::new(1, 1)) / 2 + offset,
+                    factorio_core::visualize::Symbol::Char('s'),
+                    Some(Color::cyan()),
+                    None,
+                ),
+                ElectricPoleType::Medium => v.add_symbol(
+                    (self.position - Position::new(1, 1)) / 2 + offset,
+                    factorio_core::visualize::Symbol::Char('m'),
+                    Some(Color::cyan()),
+                    None,
+                ),
+                ElectricPoleType::Big => {
+                    for (dx, dy) in [(-1, -1), (1, -1), (-1, 1), (1, 1)] {
+                        v.add_symbol(
+                            (self.position + Position::new(dx, dy)) / 2 + offset,
+                            factorio_core::visualize::Symbol::Char('l'),
+                            Some(Color::cyan()),
+                            None,
+                        )
+                    }
+                }
+                ElectricPoleType::Substation => {
+                    for (dx, dy) in [(-1, -1), (1, -1), (-1, 1), (1, 1)] {
+                        v.add_symbol(
+                            (self.position + Position::new(dx, dy)) / 2 + offset,
+                            factorio_core::visualize::Symbol::Char('S'),
+                            Some(Color::cyan()),
+                            None,
+                        )
+                    }
+                }
+            },
+            EntityType::Inserter {
+                inserter_type,
+                override_stack_size,
+            } => (),
+            EntityType::Production { name, recipe, size } => (),
+            EntityType::Rail { rail_type } => (),
+            EntityType::Unknown { name, size, misc } => (),
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -459,6 +568,13 @@ impl Blueprint {
             .build()
     }
 
+    pub fn get_aabb(&self) -> Option<AABB> {
+        self.entities
+            .iter()
+            .map(|(_, e)| e.get_aabb())
+            .reduce(AABB::combine)
+    }
+
     pub fn transform(&mut self, transform: Transformation) {
         for (_, e) in &mut self.entities {
             e.transform(transform);