Change inner hex table code

src/hex_table.rs

@@ -1,12 +1,23 @@
-pub struct HexTable {
-    len: usize,
-    scale: f32,
+pub struct HexTable<T: Clone> {
+    default: T,
+    pub(crate) data: Vec<T>,
+    pub(crate) len: usize,
+    pub(crate) scale: f32,
+    pub(crate) dimensions: (usize, usize),
 }
 
 const VERTICAL_OFFSET: f32 = 0.866025;
-impl HexTable {
-    pub fn new(len: usize, scale: f32) -> Self {
-        Self { len, scale }
+impl<T: Clone> HexTable<T> {
+    pub fn new(len: usize, default: T, scale: f32) -> Self {
+        let rows = len - 1;
+        let columns = (len as f32 / VERTICAL_OFFSET) as usize;
+        Self {
+            default: default.clone(),
+            len,
+            scale,
+            data: vec![default; rows * columns],
+            dimensions: (rows, columns),
+        }
     }
 
     pub fn calculate(&self) -> Vec<(f32, f32)> {
@@ -30,25 +41,43 @@ impl HexTable {
         vec
     }
 
-    pub fn around(&self, x: f32, y: f32) -> Vec<(f32, f32)> {
-        let around = vec![
-            (x + self.scale, y),
-            (x - self.scale, y),
-            (x + 0.5 * self.scale, y + VERTICAL_OFFSET * self.scale),
-            (x - 0.5 * self.scale, y + VERTICAL_OFFSET * self.scale),
-            (x + 0.5 * self.scale, y - VERTICAL_OFFSET * self.scale),
-            (x - 0.5 * self.scale, y - VERTICAL_OFFSET * self.scale),
+    pub fn around(&self, x: usize, y: usize) -> Vec<&T> {
+        let x = x as isize;
+        let y = y as isize;
+        let around : Vec<(isize, isize)> = vec![
+            (x, y + 1),
+            (x + 1, y + 1),
+            (x, y - 1),
+            (x + 1, y - 1),
+            (x - 1, y),
+            (x + 1, y),
         ];
 
         around
             .iter()
             .filter(|(x, y)| {
-                *x >= 0.0
-                    && *x < self.scale * self.len as f32
-                    && *y >= 0.0
-                    && *y < self.scale * self.len as f32
+                *x >= 0
+                    && *x <= self.dimensions.0 as isize
+                    && *y >= 0
+                    && *y < self.dimensions.1 as isize
             })
-            .map(|(x, y)| (*x, *y))
+            .map(|(x, y)| self.get_dim(*x as usize, *y as usize))
             .collect()
     }
+
+    pub fn get(&self, index: usize) -> &T {
+        &self.data[index]
+    }
+
+    pub fn get_dim(&self, x: usize, y: usize) -> &T {
+        self.get(x + y * self.dimensions.0)
+    }
+
+    pub fn set(&mut self, index: usize, value: T) {
+        self.data[index] = value;
+    }
+
+    pub fn set_dim(&mut self, x: usize, y: usize, value: T) {
+        self.set(x + y * self.dimensions.0, value);
+    }
 }

src/main.rs

@@ -1,10 +1,10 @@
-mod basic;
+mod table;
 mod seed_automation;
 mod plate_automation;
 mod subplate_automation;
 mod hex_table;
 
-use crate::basic::{IntoImage, Table};
+use crate::table::{IntoImage, Table};
 use bevy::asset::io::embedded::GetAssetServer;
 use bevy::image::TextureFormatPixelInfo;
 use bevy::input::keyboard::keyboard_input_system;
@@ -84,7 +84,7 @@ struct SeededRng(ChaCha8Rng);
 
 #[cfg(test)]
 mod tests {
-    use crate::basic::Table;
+    use crate::table::Table;
 
     #[test]
     fn around_1(){

src/plate_automation.rs

@@ -1,7 +1,7 @@
 use rayon::iter::IndexedParallelIterator;
 use std::time::Instant;
 use crate::SeededRng;
-use crate::basic::{IntoImage, Table};
+use crate::table::{IntoImage, Table};
 use bevy::asset::{Assets, RenderAssetUsages};
 use bevy::image::{BevyDefault, Image};
 use bevy::input::ButtonInput;

src/seed_automation.rs

@@ -1,5 +1,5 @@
 use crate::SeededRng;
-use crate::basic::{IntoImage, Table};
+use crate::table::{IntoImage, Table};
 use bevy::asset::{Assets, RenderAssetUsages};
 use bevy::image::{BevyDefault, Image};
 use bevy::input::ButtonInput;

src/subplate_automation.rs

@@ -1,4 +1,4 @@
-use crate::basic::{IntoImage, Table};
+use crate::table::{IntoImage, Table};
 use crate::hex_table::HexTable;
 use crate::SeededRng;
 use bevy::asset::{Assets, RenderAssetUsages};
@@ -196,7 +196,7 @@ pub fn setup_hex_matrix(
 
     let resolution = automation.world.side / 4;
 
-    let generator = HexTable::new(resolution, 4.0);
+    let generator = HexTable::new(resolution, true, 4.0);
     let mut table = Table::new(false, automation.world.side);
     generator.calculate().iter().for_each(|(x, y)| {
         let x = *x as usize;
@@ -281,5 +281,5 @@ pub struct HexMatrixView;
 #[derive(Component)]
 pub struct HexMatrixBuild{
     points: Table<bool>,
-    hex_matrix: HexTable
+    hex_matrix: HexTable<bool>
 }