move stuff out of cell struct until benchmarks

Author: bgkillas

src/world/cell.rs

@@ -5,6 +5,7 @@ pub type CellId = u16;
 pub struct CellData {
     pub color: CellColor,
     pub name: &'static str,
+    pub density: u8,
     pub type_data: CellDataType,
 }
 #[derive(Debug)]
@@ -81,22 +82,19 @@ impl CellColor {
     }
     pub const AIR: Self = Self::new(0x00, 0x00, 0x00, 0x00);
 }
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct Cell {
-    pub color: CellColor,
     pub cell_data: &'static CellData,
-    pub id: CellId,
-    pub cell_type: CellType,
     pub last_changed: u8,
     pub velocity: CellVelocity,
     pub friction: CellFriction,
 }
-#[derive(Clone, Default)]
+#[derive(Clone, Default, Debug)]
 pub struct CellVelocity {
     pub x: i8,
     pub y: i8,
 }
-#[derive(Clone, Default)]
+#[derive(Clone, Default, Debug)]
 pub struct CellFriction {
     pub x: u8,
     pub y: u8,
@@ -106,18 +104,15 @@ impl Cell {
     pub fn new(id: CellId) -> Self {
         let cell_data = &CELLS[id.strict_cast::<usize>()];
         Self {
-            color: cell_data.color,
             cell_data,
-            id,
-            cell_type: cell_data.type_data.cell_type(),
             last_changed: 0,
             velocity: CellVelocity::default(),
             friction: CellFriction::default(),
         }
     }
     pub fn friction(&mut self, x: u8, y: u8) {
         fn run(f: &mut i8, r: &mut u8, i: u8) {
-            let (n, over) = r.overflowing_shl(i.strict_cast());
+            let (n, over) = r.overflowing_add(i);
             *r = n;
             if over {
                 if f.is_positive() {
@@ -130,26 +125,41 @@ impl Cell {
         run(&mut self.velocity.x, &mut self.friction.x, x);
         run(&mut self.velocity.y, &mut self.friction.y, y);
     }
+    pub fn gravity(&mut self) {
+        self.velocity.y -= 1;
+    }
     #[must_use]
     pub fn is_air(&self) -> bool {
-        self.color.is_air()
+        self.color().is_air()
     }
     #[must_use]
     pub fn is_collider(&self) -> bool {
-        matches!(self.cell_type, CellType::Static | CellType::Granular)
+        matches!(self.cell_type(), CellType::Static | CellType::Granular)
+    }
+    #[must_use]
+    pub fn color(&self) -> CellColor {
+        self.cell_data.color
+    }
+    #[must_use]
+    pub fn cell_type(&self) -> CellType {
+        self.cell_data.type_data.cell_type()
+    }
+    #[must_use]
+    pub fn id(&self) -> CellId {
+        ((ptr::from_ref(self.cell_data).addr() - ptr::from_ref(&CELLS).addr())
+            / size_of::<CellData>())
+        .strict_cast()
+    }
+    #[must_use]
+    pub fn density(&self) -> u8 {
+        self.cell_data.density
     }
     #[must_use]
     pub fn can_move(&self, other: &Self) -> bool {
-        matches!(
-            other.cell_type,
-            CellType::Liquid | CellType::Gas | CellType::Air
-        ) && !ptr::eq(self.cell_data, other.cell_data)
+        self.density() > other.density()
     }
     pub fn into(&mut self, id: CellId) {
         let cell_data = &CELLS[id.strict_cast::<usize>()];
-        self.id = id;
         self.cell_data = cell_data;
-        self.cell_type = cell_data.type_data.cell_type();
-        self.color = cell_data.color;
     }
 }

src/world/cells.rs

@@ -8,59 +8,69 @@ pub static CELLS: [CellData; 10] = [
         color: CellColor::AIR,
         name: "air",
         type_data: CellDataType::Air,
+        density: 0,
     },
     //1
     CellData {
         color: CellColor::new(0xff, 0x6a, 0x00, 0xff),
         name: "fire",
         type_data: CellDataType::Fire(CellDataFire {}),
+        density: 1,
     },
     //2
     CellData {
         color: CellColor::new(0x2f, 0x8f, 0xff, 0xff),
         name: "water",
         type_data: CellDataType::Liquid(CellDataLiquid {}),
+        density: 64,
     },
     //3
     CellData {
         color: CellColor::new(0xd8, 0xd8, 0xd8, 0xff),
         name: "steam",
         type_data: CellDataType::Gas(CellDataGas {}),
+        density: 32,
     },
     //4
     CellData {
         color: CellColor::new(0xb8, 0xf0, 0xff, 0xff),
         name: "ice",
         type_data: CellDataType::Static(CellDataStatic {}),
+        density: 255,
     },
     //5
     CellData {
         color: CellColor::new(0x8b, 0x5a, 0x2b, 0xff),
         name: "dirt",
         type_data: CellDataType::Static(CellDataStatic {}),
+        density: 255,
     },
     //6
     CellData {
         color: CellColor::new(0x7a, 0x7a, 0x7a, 0xff),
         name: "stone",
         type_data: CellDataType::Static(CellDataStatic {}),
+        density: 255,
     },
     //7
     CellData {
         color: CellColor::new(0xc8, 0xc8, 0xd0, 0xff),
         name: "iron",
         type_data: CellDataType::Static(CellDataStatic {}),
+        density: 255,
     },
     //8
     CellData {
         color: CellColor::new(0x6b, 0x44, 0x22, 0xff),
         name: "wood",
         type_data: CellDataType::Static(CellDataStatic {}),
+        density: 255,
     },
     //9
     CellData {
         color: CellColor::new(0xcb, 0xbd, 0x93, 0xff),
         name: "sand",
         type_data: CellDataType::Granular(CellDataGranular {}),
+        density: 128,
     },
 ];

src/world/pixel_run.rs

@@ -80,9 +80,9 @@ impl PixelRunBuilder {
     }
     pub fn write_chunk(&mut self, chunk: &Chunk) {
         let mut iter = chunk.cells.iter();
-        self.current = iter.next().unwrap().id;
+        self.current = iter.next().unwrap().id();
         for cell in iter {
-            self.push(cell.id);
+            self.push(cell.id());
         }
     }
     pub fn write(&self, mut file: File) {

src/world/simulate_world.rs

@@ -200,7 +200,7 @@ impl World {
             return;
         }
         cell.last_changed = frame;
-        match cell.cell_type {
+        match cell.cell_type() {
             CellType::Liquid => {
                 let check = if rand.half() {
                     [
@@ -335,7 +335,7 @@ impl Chunk {
             return;
         }
         self[index].last_changed = frame;
-        match self[index].cell_type {
+        match self[index].cell_type() {
             CellType::Liquid => {
                 let check = if rand.half() {
                     [

src/world/world_image.rs

@@ -62,7 +62,7 @@ pub(crate) fn write_data(world: &World, chunks: &mut [[u8; 4]], sx: u16, ex: u16
         for (x, c) in (sx..).zip(arr.iter_mut()) {
             let idx = FullIndex::from((x, y));
             *c = <[u8; 4]>::from(if let Some(cell) = world.get(idx) {
-                cell.color
+                cell.color()
             } else {
                 CellColor::AIR
             });