argmax materials

1 files changed, 35 insertions, 57 deletions

diff --git a/src/proc_gen/tileset_loader.rs b/src/proc_gen/tileset_loader.rs
index e0d9d18..24bb053 100644
--- a/src/proc_gen/tileset_loader.rs
+++ b/src/proc_gen/tileset_loader.rs
@@ -2,8 +2,6 @@ use glam::IVec2;
 use serde::Deserialize;
 use std::{collections::HashMap, error::Error, fs::File, io::BufReader, path::Path};
 
-use crate::sim::lib::marching_squares::Marchable;
-
 fn load_img(path: &Path) -> Result<(Vec<u8>, u32, u32), Box<dyn Error>> {
     let mut decoder = png::Decoder::new(BufReader::new(File::open(path)?));
     decoder.set_transformations(png::Transformations::IDENTITY);
@@ -35,16 +33,22 @@ pub struct TileDimensions {
     pub long: u32,
 }
 
-#[derive(Deserialize, Clone, Copy, Debug, PartialEq, Eq)]
-pub enum TilesetPixelType {
-    Void = 0,
-    Terrain,
+#[derive(Deserialize, Clone, Copy, Debug)]
+pub enum TilePixelType {
+    Void,
+    Terrain(f32),
+    Custom(u8),
+}
+
+#[derive(Deserialize, Debug)]
+pub struct PaletteEntry {
+    pub solidity: f32,
 }
 
 #[derive(Deserialize, Debug)]
-struct TilesetManifest {
-    dimensions: TileDimensions,
-    palette: HashMap<u8, TilesetPixelType>,
+pub struct TilesetManifest {
+    pub dimensions: TileDimensions,
+    pub palette: HashMap<u8, PaletteEntry>,
 }
 
 fn load_manifest(path: &Path) -> Result<TilesetManifest, Box<dyn Error>> {
@@ -55,39 +59,7 @@ fn load_manifest(path: &Path) -> Result<TilesetManifest, Box<dyn Error>> {
 pub struct Tile {
     pub orientation: TileOrientation,
     pub dimensions: TileDimensions,
-    pub pixels: Vec<TilesetPixelType>,
-}
-
-// TODO might want to use newtypes to hoist to biome
-impl Marchable for Tile {
-    fn occupied(&self, pos: IVec2) -> bool {
-        // TODO this will break for tileset dimensions other than 22x44
-        if pos.x < 0 || pos.x >= self.size().x || pos.y < 0 || pos.y >= self.size().y {
-            match self.orientation {
-                TileOrientation::Horizontal => {
-                    let a = (pos.x == -1 || pos.x == (self.dimensions.long as i32))
-                        && pos.y >= 8
-                        && pos.y <= 13;
-                    let b = (pos.y == -1 || pos.y == (self.dimensions.short as i32))
-                        && ((pos.x >= 8 && pos.x <= 13) || (pos.x >= 30 && pos.x <= 35));
-                    !(a || b)
-                }
-                TileOrientation::Vertical => {
-                    let a = (pos.y == -1 || pos.y == (self.dimensions.long as i32))
-                        && pos.x >= 8
-                        && pos.x <= 13;
-                    let b = (pos.x == -1 || pos.x == (self.dimensions.short as i32))
-                        && ((pos.y >= 8 && pos.y <= 13) || (pos.y >= 30 && pos.y <= 35));
-                    !(a || b)
-                }
-            }
-        } else {
-            self.pixel_at(pos) == TilesetPixelType::Terrain
-        }
-    }
-    fn marchable_size(&self) -> IVec2 {
-        self.size()
-    }
+    pub pixels: Vec<TilePixelType>,
 }
 
 impl Tile {
@@ -101,14 +73,14 @@ impl Tile {
     }
 
     #[inline]
-    pub fn pixel_at(&self, position: IVec2) -> TilesetPixelType {
+    pub fn pixel_at(&self, position: IVec2) -> TilePixelType {
         self.pixels[(position.x + position.y * self.size().x) as usize]
     }
 }
 
 #[derive(Debug)]
 pub struct Tileset {
-    pub dimensions: TileDimensions,
+    pub manifest: TilesetManifest,
     pub vertical_tiles: Vec<Tile>,
     pub horizontal_tiles: Vec<Tile>,
 }
@@ -136,8 +108,7 @@ fn parse_row(
             break;
         }
         let left_border = img.0[(x - 1 + y * img.1) as usize];
-        // 2 = border color
-        if left_border != 2 {
+        if left_border != 9 {
             break;
         }
 
@@ -150,16 +121,23 @@ fn parse_row(
         for py in y..ey {
             for px in x..ex {
                 let idx = img.0[(px + py * img.1) as usize];
-                let palette = manifest.palette.get(&idx);
 
-                match palette {
-                    Some(pixel_type) => tile_pixels.push(*pixel_type),
-                    None => {
-                        return Err(format!(
-                            "Pixel ({px},{py}) resolved to idx {idx} which isn't in the palette"
-                        ));
-                    }
-                }
+                let pixel_type = match idx {
+                    0 => TilePixelType::Void,
+                    1 => TilePixelType::Terrain(0.125),
+                    2 => TilePixelType::Terrain(0.25),
+                    3 => TilePixelType::Terrain(0.375),
+                    4 => TilePixelType::Terrain(0.5),
+                    5 => TilePixelType::Terrain(0.625),
+                    6 => TilePixelType::Terrain(0.75),
+                    7 => TilePixelType::Terrain(0.875),
+                    8 => TilePixelType::Terrain(1.0),
+                    // 9 = border
+                    9 => unreachable!(),
+                    _ => TilePixelType::Custom(idx),
+                };
+
+                tile_pixels.push(pixel_type);
             }
         }
 
@@ -190,7 +168,7 @@ fn parse_tiles(
             break;
         }
 
-        let edge = img.0[((y) * img.1) as usize] == 2;
+        let edge = img.0[((y) * img.1) as usize] == 9;
         if !edge {
             y += 1;
             continue;
@@ -242,7 +220,7 @@ pub fn load_tileset(path: &str) -> Tileset {
                         parse_tiles(&img_result, &manifest).unwrap();
 
                     Tileset {
-                        dimensions: manifest.dimensions,
+                        manifest,
                         vertical_tiles,
                         horizontal_tiles,
                     }