feat: primitive save state

Author: syntaxerror-9

.gitignore

@@ -1,4 +1,5 @@
 /target
 .idea
 .vscode
-data.txt
+data.txt
+chunks

Cargo.lock

@@ -6,17 +6,18 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-winit = { version = "0.29" , features=[ "rwh_05", "rwh_06"] }
+winit = { version = "0.29", features = ["rwh_05", "rwh_06"] }
 env_logger = "0.10"
 log = "0.4"
 wgpu = "0.18"
 pollster = "0.3.0"
-bytemuck = { version = "1.14.0" , features= ["derive"] }
-tobj = { version = "3.2.1", features = ["async"]}
-glam = { version = "0.24.2" , features=["bytemuck"]}
+bytemuck = { version = "1.14.0", features = ["derive"] }
+tobj = { version = "3.2.1", features = ["async"] }
+glam = { version = "0.24.2", features = ["bytemuck"] }
 obj-rs = "0.7.1"
 lazy_static = "1.4.0"
 rand = "0.8.5"
+
 [dependencies.image]
 version = "0.24.7"
 default-features = false

Cargo.toml

@@ -5,7 +5,6 @@ use crate::world::CHUNK_SIZE;
 use glam::Vec3;
 use std::sync::MutexGuard;
 
-#[derive(Debug)]
 pub struct Block {
     pub position: glam::Vec3,
     pub absolute_position: glam::Vec3,

src/blocks/block.rs

@@ -1,4 +1,5 @@
 use rand::random;
+use std::any::Any;
 
 use super::block::{FaceDirections, TexturedBlock};
 
@@ -16,6 +17,8 @@ pub struct BlockTypeConfigs {
     pub bottom_texture: Option<FaceTexture>,
     pub is_translucent: bool,
 }
+
+#[repr(u32)]
 #[derive(Clone, Copy, Debug)]
 pub enum BlockType {
     Grass(BlockTypeConfigs),
@@ -26,6 +29,29 @@ pub enum BlockType {
     Stone(BlockTypeConfigs),
 }
 impl BlockType {
+    pub fn from_id(id: u32) -> BlockType {
+        match id {
+            0 => Self::dirt(),
+            1 => Self::water(),
+            2 => Self::leaf(),
+            3 => Self::stone(),
+            4 => Self::wood(),
+            5 => Self::grass(),
+            _ => panic!("Invalid id")
+        }
+    }
+    pub fn to_id(&self) -> u32 {
+        // meh
+        match self {
+            Self::Grass(f) => f.id,
+            Self::Dirt(f) => f.id,
+            Self::Water(f) => f.id,
+            Self::Wood(f) => f.id,
+            Self::Leaf(f) => f.id,
+            Self::Stone(f) => f.id,
+        }
+    }
+
     pub fn dirt() -> Self {
         Self::Dirt(BlockTypeConfigs {
             id: 0,

src/blocks/block_type.rs

@@ -1,13 +1,15 @@
+use crate::persistance::{Loadable, Saveable};
 use crate::{
     blocks::{
         block::{Block, BlockVertexData, FaceDirections},
         block_type::BlockType,
     },
     structures::Structure,
-    utils::{ChunkFromPosition, RelativeFromAbsolute},
     world::{NoiseData, CHUNK_SIZE, MAX_TREES_PER_CHUNK, NOISE_CHUNK_PER_ROW, NOISE_SIZE},
 };
 use glam::Vec3;
+use std::any::Any;
+use std::error::Error;
 use std::sync::{Arc, Mutex};
 use wgpu::util::DeviceExt;
 
@@ -302,7 +304,11 @@ impl Chunk {
         chunk_data_layout: Arc<wgpu::BindGroupLayout>,
         other_chunks: Vec<Arc<Mutex<Chunk>>>,
     ) -> Self {
-        let blocks = Self::create_blocks_data(x, y, noise_data.clone());
+        let blocks = if let Ok(blocks) = Self::load(Box::new((x, y))) {
+            blocks
+        } else {
+            Self::create_blocks_data(x, y, noise_data.clone())
+        };
 
         let chunk_position_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
             contents: bytemuck::cast_slice(&[x, y]),
@@ -339,3 +345,98 @@ impl Chunk {
         return chunk;
     }
 }
+
+impl Saveable<Chunk> for Chunk {
+    fn save(&self) -> Result<(), Box<dyn Error>> {
+        if let Ok(_) = std::fs::create_dir("chunks") {
+            println!("Created dir");
+        }
+        let mut data = String::new();
+
+        for col in self.blocks.iter() {
+            for block in col.iter() {
+                if let Some(block_ptr) = block {
+                    let blockbrw = block_ptr.lock().unwrap();
+                    data += &format!(
+                        "{},{},{},{}\n",
+                        blockbrw.position.x,
+                        blockbrw.position.y,
+                        blockbrw.position.z,
+                        blockbrw.block_type.to_id()
+                    );
+                }
+            }
+        }
+
+        let chunk_file_name = format!("chunks/chunk{}_{}", self.x, self.y);
+        std::fs::write(chunk_file_name.clone(), data.as_bytes())?;
+
+        Ok(())
+    }
+}
+
+impl Loadable<BlockVec> for Chunk {
+    fn load(args: Box<dyn Any>) -> Result<BlockVec, Box<dyn Error>> {
+        if let Ok(chunk_position) = args.downcast::<(i32, i32)>() {
+            for entry in std::fs::read_dir("chunks")? {
+                let file = entry?;
+                let filename_chunk = file.file_name();
+                let mut coords = filename_chunk
+                    .to_str()
+                    .unwrap()
+                    .split("k")
+                    .last()
+                    .expect("Invalid filename")
+                    .split("_");
+                let x = coords.next().unwrap().parse::<i32>().unwrap();
+                let y = coords.next().unwrap().parse::<i32>().unwrap();
+
+                let mut blocks: BlockVec = vec![];
+                if *chunk_position == (x, y) {
+                    let file_contents =
+                        std::fs::read_to_string(format!("chunks/chunk{}_{}", x, y))?;
+                    for line in file_contents.lines() {
+                        let mut i = line.split(",");
+                        let bx = i.next().unwrap().parse::<u32>()?;
+                        let by = i.next().unwrap().parse::<u32>()?;
+                        let bz = i.next().unwrap().parse::<u32>()?;
+                        let block_type = i.next().unwrap().parse::<u32>()?;
+                        let block_type = BlockType::from_id(block_type);
+
+                        let block = Block::new(
+                            glam::vec3(bx as f32, by as f32, bz as f32),
+                            (x, y),
+                            block_type,
+                        );
+
+                        if let None = blocks.get_mut(
+                            (block.position.x as u32 * CHUNK_SIZE + block.position.z as u32)
+                                as usize,
+                        ) {
+                            // This works only because chunks rows are in order
+                            blocks.push(vec![]);
+                        }
+                        let y_blocks = blocks
+                            .get_mut(
+                                (block.position.x as u32 * CHUNK_SIZE + block.position.z as u32)
+                                    as usize,
+                            )
+                            .unwrap();
+
+                        let start_len = y_blocks.len();
+                        let y_position = block.position.y as usize;
+
+                        for i in start_len..=y_position {
+                            if i >= y_blocks.len() {
+                                y_blocks.push(None);
+                            }
+                        }
+                        y_blocks[y_position] = Some(Arc::new(Mutex::new(block)));
+                    }
+                    return Ok(blocks);
+                }
+            }
+        }
+        return Err("Not valid args".into());
+    }
+}

src/chunk.rs

@@ -34,6 +34,7 @@ pub mod blocks;
 pub mod chunk;
 pub mod collision;
 pub mod material;
+mod persistance;
 pub mod pipeline;
 pub mod player;
 pub mod state;
@@ -84,7 +85,10 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
                                 ..
                             },
                         ..
-                    } => target.exit(),
+                    } => {
+                        state.world.save_state();
+                        target.exit();
+                    },
 
                     WindowEvent::KeyboardInput { event, .. } => {
                         state.handle_keypress(event, delta_time.as_secs_f32())

src/main.rs

@@ -0,0 +1,10 @@
+use std::any::Any;
+use std::error::Error;
+
+pub trait Saveable<T> {
+    fn save(&self) -> Result<(), Box<dyn Error>>;
+}
+
+pub trait Loadable<T> {
+    fn load(args: Box<dyn Any>) -> Result<T, Box<dyn Error>>;
+}

src/persistance.rs

@@ -4,6 +4,7 @@ use std::{
     thread,
 };
 
+use crate::persistance::Saveable;
 use crate::utils::{ChunkFromPosition, RelativeFromAbsolute};
 use crate::{blocks::block::Block, chunk::Chunk, player::Player, utils::threadpool::ThreadPool};
 
@@ -282,6 +283,14 @@ impl World {
 
         player.current_chunk = current_chunk;
     }
+    pub fn save_state(&self) {
+
+        // TODO: Player position
+        for chunk in self.chunks.iter() {
+            let chunkbrw = chunk.lock().unwrap();
+            chunkbrw.save().unwrap();
+        }
+    }
     pub fn init_chunks(&mut self) {
         let (sender, receiver) = mpsc::channel();