feat: save state for player and chunks

Author: syntaxerror-9

.gitignore

@@ -2,4 +2,5 @@
 .idea
 .vscode
 data.txt
-chunks
+chunks
+data

src/chunk.rs

@@ -10,6 +10,7 @@ use crate::{
 use glam::Vec3;
 use std::any::Any;
 use std::error::Error;
+use std::ptr::drop_in_place;
 use std::sync::{Arc, Mutex};
 use wgpu::util::DeviceExt;
 
@@ -304,7 +305,9 @@ impl Chunk {
         chunk_data_layout: Arc<wgpu::BindGroupLayout>,
         other_chunks: Vec<Arc<Mutex<Chunk>>>,
     ) -> Self {
+        let mut was_loaded = false;
         let blocks = if let Ok(blocks) = Self::load(Box::new((x, y))) {
+            was_loaded = true;
             blocks
         } else {
             Self::create_blocks_data(x, y, noise_data.clone())
@@ -324,7 +327,6 @@ impl Chunk {
                 resource: chunk_position_buffer.as_entire_binding(),
             }],
         });
-
         let mut chunk = Chunk {
             blocks,
             x,
@@ -339,7 +341,10 @@ impl Chunk {
             indices: 0,
             outside_blocks: vec![],
         };
-        chunk.place_trees();
+
+        if !was_loaded {
+            chunk.place_trees();
+        }
         chunk.build_mesh(other_chunks);
 
         return chunk;
@@ -348,7 +353,7 @@ impl Chunk {
 
 impl Saveable<Chunk> for Chunk {
     fn save(&self) -> Result<(), Box<dyn Error>> {
-        if let Ok(_) = std::fs::create_dir("chunks") {
+        if let Ok(_) = std::fs::create_dir("data") {
             println!("Created dir");
         }
         let mut data = String::new();
@@ -368,17 +373,25 @@ impl Saveable<Chunk> for Chunk {
             }
         }
 
-        let chunk_file_name = format!("chunks/chunk{}_{}", self.x, self.y);
+        let chunk_file_name = format!("data/chunk{}_{}", self.x, self.y);
         std::fs::write(chunk_file_name.clone(), data.as_bytes())?;
+        println!("WROTE FILE {:?}", chunk_file_name);
 
         Ok(())
     }
 }
 
+// Whenever a chunk gets dropped save it
+impl Drop for Chunk {
+    fn drop(&mut self) {
+        let _ = self.save();
+    }
+}
+
 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")? {
+            for entry in std::fs::read_dir("data")? {
                 let file = entry?;
                 let filename_chunk = file.file_name();
                 let mut coords = filename_chunk
@@ -388,13 +401,12 @@ impl Loadable<BlockVec> for Chunk {
                     .last()
                     .expect("Invalid filename")
                     .split("_");
-                let x = coords.next().unwrap().parse::<i32>().unwrap();
-                let y = coords.next().unwrap().parse::<i32>().unwrap();
+                let x = coords.next().unwrap().parse::<i32>()?;
+                let y = coords.next().unwrap().parse::<i32>()?;
 
                 let mut blocks: BlockVec = vec![];
                 if *chunk_position == (x, y) {
-                    let file_contents =
-                        std::fs::read_to_string(format!("chunks/chunk{}_{}", x, y))?;
+                    let file_contents = std::fs::read_to_string(format!("data/chunk{}_{}", x, y))?;
                     for line in file_contents.lines() {
                         let mut i = line.split(",");
                         let bx = i.next().unwrap().parse::<u32>()?;

src/main.rs

@@ -76,7 +76,6 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
                         state.resize(new_size);
                         window.lock().unwrap().request_redraw();
                     }
-                    // WindowEvent::RedrawRequested => {}
                     WindowEvent::CloseRequested
                     | WindowEvent::KeyboardInput {
                         event:
@@ -86,7 +85,8 @@ async fn run(event_loop: EventLoop<()>, window: Window) {
                             },
                         ..
                     } => {
-                        state.world.save_state();
+                        state.save_state();
+                        state.dispose();
                         target.exit();
                     }
 

src/player.rs

@@ -1,10 +1,14 @@
+use std::any::Any;
+use std::error::Error;
+use std::f32::consts;
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 
 use glam::{vec2, vec3, Mat2, Vec2, Vec3};
 
 use crate::blocks::block::{Block, FaceDirections};
 use crate::collision::{CollisionPoint, RayResult};
+use crate::persistance::{Loadable, Saveable};
 use crate::{
     collision::CollisionBox,
     world::{World, CHUNK_SIZE},
@@ -105,7 +109,6 @@ impl Player {
         return match (block_collision, point) {
             (Some(block_collision), Some(point)) => {
                 // TODO: This can be precomputed
-
                 let point_dir = ((block_collision.center() - point).normalize()) * -1.0;
 
                 let face_directions = FaceDirections::all();
@@ -225,6 +228,24 @@ pub struct Camera {
 }
 
 impl Camera {
+    pub fn new(surface_width: f32, surface_height: f32) -> Camera {
+        let eye = if let Ok(eye) = Camera::load(Box::new(())) {
+            eye
+        } else {
+            glam::vec3(-4.0, 50.0, 4.0)
+        };
+        Self {
+            aspect_ratio: surface_width / surface_height,
+            eye,
+            yaw: consts::FRAC_PI_2,
+            pitch: 0.0,
+
+            fovy: consts::FRAC_PI_4,
+            znear: 0.1,
+            zfar: 1000.,
+            needs_update: false,
+        }
+    }
     pub fn build_view_matrix(&self) -> glam::Mat4 {
         glam::Mat4::look_at_lh(self.eye, self.eye + self.calc_target(), glam::Vec3::Y)
     }
@@ -250,3 +271,30 @@ impl Camera {
         self.needs_update = true;
     }
 }
+
+impl Saveable<glam::Vec3> for Camera {
+    fn save(&self) -> Result<(), Box<dyn Error>> {
+        if let Ok(_) = std::fs::create_dir("data") {
+            println!("Created dir");
+        }
+        let data = format!("{},{},{}", self.eye.x, self.eye.y, self.eye.z);
+
+        let player_file_name = "data/player";
+        std::fs::write(player_file_name, data.as_bytes())?;
+        println!("WROTE FILE {:?}", player_file_name);
+
+        Ok(())
+    }
+}
+
+impl Loadable<glam::Vec3> for Camera {
+    fn load(_: Box<dyn Any>) -> Result<Vec3, Box<dyn Error>> {
+        let data = String::from_utf8(std::fs::read("data/player")?)?;
+        let mut data = data.split(",");
+        let x = data.next().unwrap().parse::<f32>().unwrap();
+        let y = data.next().unwrap().parse::<f32>().unwrap();
+        let z = data.next().unwrap().parse::<f32>().unwrap();
+
+        return Ok(glam::vec3(x, y, z));
+    }
+}

src/state.rs

@@ -21,6 +21,7 @@ use winit::{
     keyboard::{KeyCode, PhysicalKey},
     window::Window,
 };
+use crate::persistance::Saveable;
 
 impl State {
     pub async fn new(window: Arc<Mutex<Window>>) -> Self {
@@ -120,6 +121,13 @@ impl State {
 
         state
     }
+    pub fn save_state(&mut self) {
+        self.player.camera.save().expect("Failed to save camera state");
+        self.world.save_state();
+    }
+    pub fn dispose(&mut self) {
+        self.world.dispose();
+    }
     pub fn handle_keypress(&mut self, event: KeyEvent, delta_time: f32) {
         let is_pressed: f32 = if event.state.is_pressed() { 1. } else { 0. };
 

src/world.rs

@@ -33,7 +33,7 @@ pub type NoiseData = Vec<f32>;
 
 pub struct World {
     pub chunks: Vec<Arc<Mutex<Chunk>>>,
-    pub thread_pool: ThreadPool,
+    pub thread_pool: Option<ThreadPool>,
     pub seed: u32,
     pub noise_data: Arc<NoiseData>,
     pub chunk_data_layout: Arc<wgpu::BindGroupLayout>,
@@ -260,7 +260,7 @@ impl World {
                 let queue = Arc::clone(&queue);
                 let other_chunks = self.chunks.iter().map(|c| c.clone()).collect::<Vec<_>>();
 
-                self.thread_pool.execute(move || {
+                self.thread_pool.as_ref().unwrap().execute(move || {
                     let chunk = Chunk::new(
                         new_chunk_pos.0,
                         new_chunk_pos.1,
@@ -283,8 +283,10 @@ impl World {
 
         player.current_chunk = current_chunk;
     }
+    pub fn dispose(&mut self) {
+        self.thread_pool = None;
+    }
     pub fn save_state(&self) {
-        // TODO: Player position
         for chunk in self.chunks.iter() {
             let chunkbrw = chunk.lock().unwrap();
             chunkbrw.save().unwrap();
@@ -301,7 +303,7 @@ impl World {
                 let device = Arc::clone(&self.device);
                 let queue = Arc::clone(&self.queue);
 
-                self.thread_pool.execute(move || {
+                self.thread_pool.as_ref().unwrap().execute(move || {
                     let chunk = Chunk::new(
                         chunk_x,
                         chunk_y,
@@ -373,7 +375,7 @@ impl World {
             device,
             queue,
             seed: 0,
-            thread_pool,
+            thread_pool: Some(thread_pool),
         }
     }
 }