type safe indecies

1 files changed, 49 insertions, 16 deletions

diff --git a/server/src/data.rs b/server/src/data.rs
index e467fefa..51347c7c 100644
--- a/server/src/data.rs
+++ b/server/src/data.rs
@@ -1,4 +1,7 @@
-use crate::{interaction::Recipe, protocol::TileIndex};
+use crate::{
+    interaction::Recipe,
+    protocol::{DemandIndex, ItemIndex, RecipeIndex, TileIndex},
+};
 use glam::{IVec2, Vec2};
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, sync::RwLock};
@@ -39,16 +42,16 @@ pub struct DemandDecl {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Demand {
-    pub from: usize,
-    pub to: usize,
+    pub from: ItemIndex,
+    pub to: ItemIndex,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct Gamedata {
-    pub recipes: Vec<Recipe>,
+    recipes: Vec<Recipe>,
     pub demands: Vec<Demand>,
-    pub item_names: Vec<String>,
-    pub tile_names: Vec<String>,
+    item_names: Vec<String>,
+    tile_names: Vec<String>,
     #[serde(skip)]
     pub initial_map: HashMap<IVec2, TileIndex>,
     pub chef_spawn: Vec2,
@@ -67,9 +70,15 @@ pub fn build_gamedata(
 
     for r in recipes_in {
         let r2 = r.clone();
-        let mut inputs = r.inputs.into_iter().map(|i| register(&item_names, i));
-        let mut outputs = r.outputs.into_iter().map(|o| register(&item_names, o));
-        let tile = r.tile.map(|t| register(&tile_names, t));
+        let mut inputs = r
+            .inputs
+            .into_iter()
+            .map(|i| ItemIndex(register(&item_names, i)));
+        let mut outputs = r
+            .outputs
+            .into_iter()
+            .map(|o| ItemIndex(register(&item_names, o)));
+        let tile = r.tile.map(|t| TileIndex(register(&tile_names, t)));
         match r.action {
             Action::Never => {}
             Action::Passive(duration) => recipes.push(Recipe::Passive {
@@ -98,8 +107,8 @@ pub fn build_gamedata(
 
     for d in demands_in {
         demands.push(Demand {
-            from: register(&item_names, d.from),
-            to: register(&item_names, d.to),
+            from: ItemIndex(register(&item_names, d.from)),
+            to: ItemIndex(register(&item_names, d.to)),
         })
     }
 
@@ -118,7 +127,7 @@ pub fn build_gamedata(
                 customer_spawn = pos.as_vec2();
                 tilename = "floor".to_owned();
             }
-            let tile = register(&tile_names, tilename);
+            let tile = TileIndex(register(&tile_names, tilename));
             initial_map.insert(pos, tile);
         }
     }
@@ -146,11 +155,35 @@ fn register(db: &RwLock<Vec<String>>, name: String) -> usize {
 }
 
 impl Gamedata {
-    pub fn get_tile(&self, name: &str) -> Option<TileIndex> {
-        self.tile_names.iter().position(|t| t == name)
+    pub fn tile_name(&self, index: TileIndex) -> &String {
+        &self.tile_names[index.0]
     }
-    pub fn get_item(&self, name: &str) -> Option<TileIndex> {
-        self.item_names.iter().position(|t| t == name)
+    pub fn item_name(&self, index: ItemIndex) -> &String {
+        &self.item_names[index.0]
+    }
+    pub fn recipe(&self, index: RecipeIndex) -> &Recipe {
+        &self.recipes[index.0]
+    }
+    pub fn demand(&self, index: DemandIndex) -> &Demand {
+        &self.demands[index.0]
+    }
+    pub fn get_tile_by_name(&self, name: &str) -> Option<TileIndex> {
+        self.tile_names
+            .iter()
+            .position(|t| t == name)
+            .map(TileIndex)
+    }
+    pub fn get_item_by_name(&self, name: &str) -> Option<ItemIndex> {
+        self.item_names
+            .iter()
+            .position(|t| t == name)
+            .map(ItemIndex)
+    }
+    pub fn recipes(&self) -> impl Iterator<Item = (RecipeIndex, &Recipe)> {
+        self.recipes
+            .iter()
+            .enumerate()
+            .map(|(i, e)| (RecipeIndex(i), e))
     }
 }
 impl Action {