Add quaterdirection and fix multistation off by one errors

factorio-blueprint/src/abstraction.rs

@@ -4,6 +4,7 @@ use factorio_core::{
     direction,
     pathfield::PathField,
     prelude::{Direction, Position, PositionType, Transformable, Transformation},
+    quaterdirection::QuaterDirection,
 };
 use std::{collections::HashMap, sync::atomic::AtomicUsize};
 
@@ -101,10 +102,15 @@ impl RailType {
     }
 }
 
+enum DirectionType {
+    Dir(Direction),
+    QuarterDir(QuaterDirection),
+}
+
 pub struct Entity {
     entity: EntityType,
     position: Position,
-    direction: Direction,
+    direction: DirectionType,
     quality: Quality,
 }
 
@@ -124,7 +130,6 @@ pub enum EntityType {
     },
     Rail {
         rail_type: RailType,
-        direction: u8,
     },
     Unknown {
         name: String,
@@ -138,7 +143,20 @@ impl Entity {
         Self {
             entity,
             position,
-            direction,
+            direction: DirectionType::Dir(direction),
+            quality: Quality::Normal,
+        }
+    }
+
+    pub fn new_quarter_direction(
+        entity: EntityType,
+        position: Position,
+        direction: QuaterDirection,
+    ) -> Self {
+        Self {
+            entity,
+            position,
+            direction: DirectionType::QuarterDir(direction),
             quality: Quality::Normal,
         }
     }
@@ -206,15 +224,12 @@ impl Entity {
         )
     }
 
-    pub fn new_rail(rail_type: RailType, position: Position, direction: u8) -> Self {
-        Self::new(
-            EntityType::Rail {
-                rail_type,
-                direction,
-            },
-            position,
-            Direction::Up,
-        )
+    pub fn new_rail(
+        rail_type: RailType,
+        position: Position,
+        direction: impl Into<QuaterDirection>,
+    ) -> Self {
+        Self::new_quarter_direction(EntityType::Rail { rail_type }, position, direction.into())
     }
 
     pub fn new_unknown(
@@ -261,10 +276,7 @@ impl Entity {
                 recipe: _,
                 size: _,
             } => name.clone(),
-            EntityType::Rail {
-                rail_type,
-                direction: _,
-            } => rail_type.string(),
+            EntityType::Rail { rail_type } => rail_type.string(),
         }
     }
 
@@ -313,17 +325,19 @@ impl Entity {
                 size,
             } => *size,
             EntityType::ElectricPole(electric_pole_type) => electric_pole_type.size(),
-            EntityType::Rail {
-                rail_type,
-                direction: _,
-            } => rail_type.size(),
+            EntityType::Rail { rail_type } => rail_type.size(),
             _ => Position::new(2, 2),
         }
     }
 
     pub fn transform(&mut self, transform: Transformation) {
         self.position = self.position.transform(transform);
-        self.direction = self.direction.transform(transform);
+        self.direction = match self.direction {
+            DirectionType::Dir(direction) => DirectionType::Dir(direction.transform(transform)),
+            DirectionType::QuarterDir(quater_direction) => {
+                DirectionType::QuarterDir(quater_direction.transform(transform))
+            }
+        };
     }
 }
 
@@ -416,17 +430,11 @@ impl Blueprint {
                     i as u32 + 1,
                     BlueprintPosition::new(0.5 * e.position.x as f64, 0.5 * e.position.y as f64),
                 )
-                .direction(match &e.entity {
-                    &EntityType::Rail {
-                        rail_type: _,
-                        direction,
-                    } => direction,
-                    _ => match e.direction {
-                        Direction::Up => 0,
-                        Direction::Right => 4,
-                        Direction::Down => 8,
-                        Direction::Left => 12,
-                    },
+                .direction(match e.direction {
+                    DirectionType::Dir(direction) => 4 * direction.get_index(),
+                    DirectionType::QuarterDir(quater_direction) => {
+                        quater_direction.to_int_direction()
+                    }
                 })
                 .maybe_underground_type(e.get_maybe_underground_type_string())
                 .maybe_override_stack_size(e.get_maybe_override_stack_size())