Start bucket consolidation refactor

Author: BloodStainedCrow

src/bucket_store/const_reinsertion.rs

@@ -0,0 +1,93 @@
+pub(crate) struct ConstReinsertionBucketStore<
+    const STATE_COUNT: usize,
+    Reinsertion: super::Reinsertion,
+> {
+    pub reinsertion_time: u32,
+
+    states: [State<Reinsertion>; STATE_COUNT],
+}
+
+struct State<Reinsertion: super::Reinsertion> {
+    moving_time_counts: Box<[u32]>,
+    moving_values: Vec<Reinsertion::MovingValue>,
+    ticking_values: Vec<Reinsertion::TickingValue>,
+}
+
+impl<const STATE_COUNT: usize, Reinsertion: super::Reinsertion>
+    ConstReinsertionBucketStore<STATE_COUNT, Reinsertion>
+{
+    pub fn new(reinsertion_time: u32) -> Self {
+        assert_eq!(Reinsertion::STATE_COUNT, STATE_COUNT);
+        assert!(Reinsertion::STATE_COUNT > 0);
+        assert!(reinsertion_time > 0);
+        Self {
+            reinsertion_time,
+            states: std::array::from_fn(|_| State {
+                moving_time_counts: vec![0; reinsertion_time as usize].into_boxed_slice(),
+                moving_values: vec![],
+                ticking_values: vec![],
+            }),
+        }
+    }
+
+    pub fn update<'a>(&mut self, world_state: &mut Reinsertion::WorldState<'a>) {
+        for state in &mut self.states {
+            // Done moving
+            let (ticking, (moving, moving_time_counts)) = {
+                (
+                    &mut state.ticking_values,
+                    (&mut state.moving_values, &mut state.moving_time_counts),
+                )
+            };
+
+            let amount_done_moving = moving_time_counts[0];
+            let extract_range = 0..(amount_done_moving as usize);
+
+            let removed_moving = moving.drain(extract_range);
+            let added_ticking = removed_moving.map(|moving| Reinsertion::moving_to_ticking(moving));
+
+            ticking.extend(added_ticking);
+
+            moving_time_counts.rotate_left(1);
+            assert_eq!(
+                amount_done_moving,
+                moving_time_counts[self.reinsertion_time as usize - 1]
+            );
+            moving_time_counts[self.reinsertion_time as usize - 1] = 0;
+        }
+
+        for state in 0..STATE_COUNT {
+            let next_state = (state + 1) % STATE_COUNT;
+
+            // Start Moving
+            let (ticking, (moving, moving_time_counts)) = if state == next_state {
+                assert!(STATE_COUNT == 1);
+                let state = &mut self.states[state];
+                (
+                    &mut state.ticking_values,
+                    (&mut state.moving_values, &mut state.moving_time_counts),
+                )
+            } else {
+                assert!(STATE_COUNT > 1);
+                let [this, next] = self.states.get_disjoint_mut([state, next_state]).unwrap();
+
+                (
+                    &mut this.ticking_values,
+                    (&mut next.moving_values, &mut next.moving_time_counts),
+                )
+            };
+
+            let extracted_ticking =
+                ticking.extract_if(.., |ticking| Reinsertion::tick(state, ticking, world_state));
+
+            let reinserted_moving =
+                extracted_ticking.filter_map(|ticking| Reinsertion::ticking_to_moving(ticking));
+
+            let moving_old_len = moving.len();
+            moving.extend(reinserted_moving);
+            let added = moving.len() - moving_old_len;
+
+            moving_time_counts[self.reinsertion_time as usize - 1] += added as u32;
+        }
+    }
+}

src/bucket_store/mod.rs

@@ -0,0 +1,21 @@
+pub(crate) mod const_reinsertion;
+
+mod storage_storage_inserter_store;
+
+pub(crate) trait Reinsertion {
+    const STATE_COUNT: usize;
+
+    type MovingValue: Copy;
+    type TickingValue: Copy;
+
+    type WorldState<'a>;
+
+    fn tick<'a>(
+        state: usize,
+        value: &mut Self::TickingValue,
+        world_state: &mut Self::WorldState<'a>,
+    ) -> bool;
+    fn ticking_to_moving(value: Self::TickingValue) -> Option<Self::MovingValue>;
+
+    fn moving_to_ticking(value: Self::MovingValue) -> Self::TickingValue;
+}

src/bucket_store/storage_storage_inserter_store/mod.rs

@@ -0,0 +1,115 @@
+use std::num::NonZero;
+
+use enum_map::Enum;
+
+use crate::{bucket_store::Reinsertion, item::ITEMCOUNTTYPE};
+
+struct StorageStorageInserterStore {}
+
+struct Info {
+    last_ticked: u16,
+    state_at_last_tick: ImplicitState,
+}
+
+enum ImplicitState {
+    WaitingForSourceItems(ITEMCOUNTTYPE),
+    WaitingForSpaceInDestination(ITEMCOUNTTYPE),
+}
+
+struct StorageStorageInserterReinsertion;
+
+#[derive(Debug, Enum)]
+enum State {
+    PickingUpItems,
+    DroppingOffItems,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct MovingInserter {
+    id: u32,
+    todo: !,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct TickingInserter {
+    id: u32,
+    hand: ITEMCOUNTTYPE,
+    todo: !,
+}
+
+struct WorldState<'a> {
+    max_hand_size: ITEMCOUNTTYPE,
+
+    current_tick: u32,
+    infos: &'a mut [Info],
+}
+
+impl Reinsertion for StorageStorageInserterReinsertion {
+    const STATE_COUNT: usize = State::LENGTH;
+
+    type MovingValue = MovingInserter;
+
+    type TickingValue = TickingInserter;
+
+    type WorldState<'a> = WorldState<'a>;
+
+    #[inline]
+    fn tick<'a>(
+        state: usize,
+        value: &mut Self::TickingValue,
+        world_state: &mut Self::WorldState<'a>,
+    ) -> bool {
+        let WorldState {
+            current_tick,
+            infos,
+            max_hand_size,
+        } = world_state;
+
+        infos[value.id as usize].last_ticked = *current_tick as u16;
+
+        match State::from_usize(state) {
+            State::PickingUpItems => {
+                let amount_picked_up: ITEMCOUNTTYPE = todo!("Pick up actually");
+
+                if amount_picked_up > 0 {
+                    value.hand += amount_picked_up;
+                    infos[value.id as usize].state_at_last_tick =
+                        ImplicitState::WaitingForSourceItems(value.hand);
+                    if value.hand == *max_hand_size {
+                        todo!("Try to put it in waitlist");
+                        true
+                    } else {
+                        false
+                    }
+                } else {
+                    false
+                }
+            },
+            State::DroppingOffItems => {
+                let amount_dropped_off: ITEMCOUNTTYPE = todo!("Drop off actually");
+
+                if amount_dropped_off > 0 {
+                    value.hand -= amount_dropped_off;
+                    infos[value.id as usize].state_at_last_tick =
+                        ImplicitState::WaitingForSpaceInDestination(value.hand);
+                    if value.hand == 0 {
+                        todo!("Try to put it in waitlist");
+                        true
+                    } else {
+                        false
+                    }
+                } else {
+                    false
+                }
+            },
+        }
+    }
+
+    fn ticking_to_moving(value: Self::TickingValue) -> Option<Self::MovingValue> {
+        todo!()
+    }
+
+    fn moving_to_ticking(value: Self::MovingValue) -> Self::TickingValue {
+        todo!()
+    }
+}

src/lib.rs

@@ -119,6 +119,7 @@ pub mod liquid;
 
 mod par_generation;
 
+mod bucket_store;
 mod lockfile;
 
 impl WeakIdxTrait for u8 {}