sensors now run in correct order

src/util/idvec.rs

@@ -0,0 +1,76 @@
+use std::ops::{Deref, Index, IndexMut};
+
+use crate::util::{HashMap, id::Id};
+
+/// a vec that's indexed with permanent ids rather than an offset
+pub struct IdVec<T> {
+    map: HashMap<Id, usize>,
+    vec: Vec<(Id, T)>,
+}
+
+impl<T> IdVec<T> {
+    pub fn insert(&mut self, id: Id, v: T) {
+        let idx = self.vec.len();
+        self.map.insert(id.duplicate(), idx);
+        self.vec.push((id, v));
+    }
+
+    pub fn remove(&mut self, id: &Id) -> Option<T> {
+        let i = self.map.remove(id)?;
+        let v = self.vec.remove(i).1;
+        for (id, _) in &self.vec[i..] {
+            *self.map.get_mut(id).unwrap() -= 1;
+        }
+        Some(v)
+    }
+
+    pub fn len(&self) -> usize {
+        self.map.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.map.is_empty()
+    }
+
+    pub fn idx(&self, id: &Id) -> usize {
+        self.map[id]
+    }
+
+    pub fn clear(&mut self) {
+        self.map.clear();
+        self.vec.clear();
+    }
+}
+
+impl<T> Default for IdVec<T> {
+    fn default() -> Self {
+        Self {
+            map: Default::default(),
+            vec: Default::default(),
+        }
+    }
+}
+
+impl<T> Index<&Id> for IdVec<T> {
+    type Output = T;
+
+    fn index(&self, id: &Id) -> &Self::Output {
+        let i = self.idx(id);
+        &self.vec[i].1
+    }
+}
+
+impl<T> IndexMut<&Id> for IdVec<T> {
+    fn index_mut(&mut self, id: &Id) -> &mut Self::Output {
+        let i = self.idx(id);
+        &mut self.vec[i].1
+    }
+}
+
+impl<T> Deref for IdVec<T> {
+    type Target = Vec<(Id, T)>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.vec
+    }
+}

src/util/mod.rs

@@ -1,12 +1,14 @@
 mod bitflags;
 mod borrow;
 mod id;
+mod idvec;
 mod math;
 mod refcount;
 
 pub(crate) use bitflags::*;
 pub(crate) use borrow::*;
 pub(crate) use id::*;
+pub(crate) use idvec::*;
 pub(crate) use math::*;
 pub(crate) use refcount::*;