Handle one more belt case for the load_ext

src/belt.rs

@@ -221,15 +221,15 @@ where
         self.t.extension_len() > 0
     }
 
-    pub fn extend_by_belt(&mut self, mut other: Belt<Entity>) -> bool {
+    pub fn extend_by_belt(&mut self, mut other: Belt<Entity>) -> (bool, Option<Vec<Entity>>) {
         if self.dir != other.dir {
-            return false;
+            return (false, None);
         }
 
         println!("EXT BY BELT: {:?} {:?}", self, other);
 
         if !self.tile_on_same_axis(other.front_tile) {
-            return false;
+            return (false, None);
         }
 
         let (swap_transport, front_tile, end_tile) = if self
@@ -241,17 +241,20 @@ where
             (false, self.front_tile, other.end_tile())
         };
 
-        assert!(
-            self.t.length_core() == self.t.length(),
-            "I have not yet implemented this!"
-        );
+        // Disable the extension of the belt front that is joined
+        let popped_ents = if swap_transport {
+            self.disable_load_ext()
+        } else {
+            other.disable_load_ext()
+        };
 
+        // Check if the two are adjacent:
         let new_len = ((self.dir.diff(front_tile, end_tile).abs() + 1) * BELT_TILE_SIZE_PX) as u32;
         if new_len < self.t.length() {
-            return false;
+            return (false, None);
         }
         if new_len != (self.t.length() + other.t.length()) {
-            return false;
+            return (false, None);
         }
 
         if swap_transport {
@@ -263,7 +266,7 @@ where
             self.set_front(front_tile)
         }
 
-        true
+        (true, popped_ents)
     }
 
     pub fn iter_all<F: FnMut((i32, i32), Entity)>(&self, f: &mut F) {
@@ -303,11 +306,11 @@ where
     }
 
     pub fn iter_tiles<F: FnMut(Dir, (i32, i32))>(&self, f: &mut F) {
-        if self.t.length_core() == 0 {
+        let tile_count = self.tile_length();
+        if tile_count == 0 {
             return;
         }
 
-        let tile_count = self.t.length_core() / (BELT_TILE_SIZE_PX as u32);
         let mut cur = self.front_tile;
         let walk_dir = self.dir.reverse();
 
@@ -448,10 +451,9 @@ where
     }
 
     pub fn end_tile(&self) -> (i32, i32) {
-        let tile_count = self.tile_length();
         self.dir
             .reverse()
-            .offs_tile_by_n(self.front_tile, tile_count.max(1) as i32 - 1)
+            .offs_tile_by_n(self.front_tile, self.tile_length().max(1) as i32 - 1)
     }
 
     pub fn tick(&mut self) {
@@ -737,6 +739,14 @@ where
         }
     }
 
+    pub fn iter_load_ext_tiles<F: FnMut(Dir, (i32, i32))>(&self, mut f: F) {
+        for (_, belt) in self.belts.iter() {
+            if belt.has_load_ext() {
+                f(belt.dir(), belt.end_target_pos());
+            }
+        }
+    }
+
     pub fn iter_underground_tiles<F: FnMut(Dir, bool, (i32, i32))>(&self, mut f: F) {
         for (_, belt) in self.belts.iter() {
             if belt.belt_type() == BeltType::Underground {
@@ -903,7 +913,9 @@ where
                 let belt2 = self
                     .unmount_belt(adj_2_id)
                     .expect("Belt 2 must be present too!");
-                assert!(belt.extend_by_belt(belt2));
+                let (ok, popped_ents) = belt.extend_by_belt(belt2);
+                assert!(ok);
+                assert!(popped_ents.is_none());
             }
             //            println!("BELT POST EXTBB: {:?}", belt);
 
@@ -1318,7 +1330,7 @@ mod test {
         b2.set_front((1, 0));
         b2.extend(1);
 
-        assert!(b2.extend_by_belt(b));
+        assert!(b2.extend_by_belt(b).0);
 
         assert_eq!(b2.tile_length(), 2);
         assert_eq!(e_tiles(&b2), vec![(Dir::R, (1, 0)), (Dir::R, (0, 0)),]);
@@ -1333,8 +1345,8 @@ mod test {
         b2.set_front((3, 0));
         b2.extend(3);
 
-        assert!(b2.extend_by_belt(b.clone()));
-        assert!(!b2.extend_by_belt(b));
+        assert!(b2.extend_by_belt(b.clone()).0);
+        assert!(!b2.extend_by_belt(b).0);
 
         assert_eq!(b2.tile_length(), 4);
         assert_eq!(
@@ -1466,14 +1478,14 @@ mod test {
     #[test]
     fn check_belt_extend_by_belt_u_items_swap() {
         let (b, mut b2) = setup_u_item_belts();
-        assert!(b2.extend_by_belt(b));
+        assert!(b2.extend_by_belt(b).0);
         check_u_items_result(&b2);
     }
 
     #[test]
     fn check_belt_extend_by_belt_u_items_noswap() {
         let (mut b, b2) = setup_u_item_belts();
-        assert!(b.extend_by_belt(b2));
+        assert!(b.extend_by_belt(b2).0);
         check_u_items_result(&b);
     }
 
@@ -1495,7 +1507,7 @@ mod test {
 
         assert_eq!(e_ents(&b2), vec![(47, 0, Chem::Fe), (31, 0, Chem::H2),]);
 
-        assert!(b2.extend_by_belt(b));
+        assert!(b2.extend_by_belt(b).0);
 
         assert_eq!(b2.tile_length(), 2);
         assert_eq!(e_tiles(&b2), vec![(Dir::R, (1, 0)), (Dir::R, (0, 0)),]);
@@ -1525,7 +1537,7 @@ mod test {
         b2.insert_entity((16, 0), Chem::H2);
         b2.insert_entity((32, 0), Chem::Fe);
 
-        assert!(b2.extend_by_belt(b));
+        assert!(b2.extend_by_belt(b).0);
         assert_eq!(e_tiles(&b2), vec![(Dir::L, (0, 0)), (Dir::L, (1, 0)),]);
 
         assert_eq!(
@@ -1553,7 +1565,7 @@ mod test {
         b2.insert_entity((0, -17), Chem::H2);
         b2.insert_entity((0, -32), Chem::Fe);
 
-        assert!(b2.extend_by_belt(b));
+        assert!(b2.extend_by_belt(b).0);
         assert_eq!(e_tiles(&b2), vec![(Dir::D, (0, 0)), (Dir::D, (0, -1)),]);
 
         assert_eq!(
@@ -3093,4 +3105,84 @@ mod test {
         assert_eq!(e.front_pos(), (-64, 0));
         assert_eq!(e.back_pos(), (15, 0));
     }
+
+    #[test]
+    fn check_belt_load_ext_by_full_full_belt_a_ext_b_no_ext() {
+        let mut a = Belt::new(0, Dir::D);
+        a.set_front((0, 0));
+        a.extend(1);
+        a.enable_load_ext();
+        a.fill_from_pattern(&[Chem::O2, Chem::H2, Chem::Fe2O3]);
+
+        let mut b = Belt::new(1, Dir::D);
+        b.set_front((0, 1));
+        b.extend(1);
+        b.fill_from_pattern(&[Chem::O2, Chem::H2, Chem::Fe2O3]);
+
+        assert_eq!(e_tiles(&a), vec![(Dir::D, (0, 0))]);
+        assert_eq!(e_tiles(&b), vec![(Dir::D, (0, 1))]);
+
+        assert_eq!(
+            e_ents(&a),
+            vec![
+                (0, 31, Chem::O2),
+                (0, 15, Chem::H2),
+                (0, -1, Chem::Fe2O3),
+            ]
+        );
+
+        assert_eq!(
+            e_ents(&b),
+            vec![
+                (0, 47, Chem::O2),
+                (0, 31, Chem::H2),
+            ]
+        );
+
+        let mut ta = a.clone();
+        let mut tb = b.clone();
+
+        // Test appending b to a:
+        let (ok, popped_ents) = ta.extend_by_belt(b.clone());
+        assert!(ok, "extension ok");
+        assert_eq!(popped_ents, Some(vec![Chem::O2]));
+
+        assert_eq!(ta.end_target_pos(), (0, 48));
+        assert_eq!(ta.end_tile(), (0, 0));
+        assert_eq!(ta.end_target_tile_pos(), (0, 2));
+        assert_eq!(ta.front_pos(), (0, 47));
+        assert_eq!(ta.back_pos(), (0, -16));
+
+        assert_eq!(
+            e_ents(&ta),
+            vec![
+                (0, 47, Chem::O2),
+                (0, 31, Chem::H2),
+                (0, 15, Chem::H2),
+                (0, -1, Chem::Fe2O3),
+            ]
+        );
+
+
+        // Test appending a to b:
+        let (ok, popped_ents) = tb.extend_by_belt(a.clone());
+        assert!(ok, "extension ok");
+        assert_eq!(popped_ents, Some(vec![Chem::O2]));
+
+        assert_eq!(tb.end_target_pos(), (0, 48));
+        assert_eq!(tb.end_tile(), (0, 0));
+        assert_eq!(tb.end_target_tile_pos(), (0, 2));
+        assert_eq!(tb.front_pos(), (0, 47));
+        assert_eq!(tb.back_pos(), (0, -16));
+
+        assert_eq!(
+            e_ents(&tb),
+            vec![
+                (0, 47, Chem::O2),
+                (0, 31, Chem::H2),
+                (0, 15, Chem::H2),
+                (0, -1, Chem::Fe2O3),
+            ]
+        );
+    }
 }