idk switching to bevy ecs again

src/client/mod.rs

@@ -2,7 +2,6 @@ mod app;
 mod camera;
 mod component;
 mod handle_input;
-mod init;
 mod input;
 pub mod render;
 mod rsc;
@@ -10,15 +9,20 @@ mod state;
 mod system;
 
 pub use app::*;
-use component::RenderComponent;
-use evenio::world::World;
-use init::init_world;
+use bevy_ecs::{system::SystemId, world::World};
+use component::RenderResource;
 use render::{RenderMessage, RendererChannel};
 pub use state::*;
+use system::voxel_grid::update_renderer;
+
+use crate::{server::Server, sync::ServerHandle, world::generation::generate};
 
 use self::{input::Input, render::Renderer, ClientState};
 use std::{sync::Arc, thread::JoinHandle, time::Instant};
-use winit::{event::WindowEvent, window::Window};
+use winit::{
+    event::WindowEvent,
+    window::{Window, WindowAttributes},
+};
 
 pub struct Client {
     window: Arc<Window>,
@@ -31,19 +35,26 @@ pub struct Client {
     grabbed_cursor: bool,
     keep_cursor: bool,
     world: World,
+    server: ServerHandle,
+    bruh: SystemId,
 }
 
 impl Client {
-    pub fn new(window: Arc<Window>) -> Self {
+    pub fn new(event_loop: &winit::event_loop::ActiveEventLoop) -> Self {
         let mut world = World::new();
+        let window = Arc::new(
+            event_loop
+                .create_window(WindowAttributes::default())
+                .expect("Failed to create window"),
+        );
 
         let (render_channel, render_handle) = Renderer::spawn(window.clone());
-        let e = world.spawn();
-        world.insert(e, RenderComponent(render_channel.clone()));
-        world.add_handler(system::voxel_grid::handle_create_grid);
+        world.insert_resource(RenderResource(render_channel.clone()));
+        let bruh = world.register_system(update_renderer);
 
-        init_world(&mut world);
         let state = ClientState::new();
+        let server = Server::spawn();
+        generate(&mut world);
 
         Self {
             window,
@@ -56,10 +67,12 @@ impl Client {
             grabbed_cursor: false,
             keep_cursor: false,
             world,
+            server,
+            bruh,
         }
     }
 
-    pub fn update(&mut self) -> bool {
+    pub fn update(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) {
         let now = Instant::now();
         let dt = now - self.prev_update;
         self.prev_update = now;
@@ -67,8 +80,12 @@ impl Client {
         self.handle_input(&dt);
         self.input.end();
 
+        self.recv();
+        self.world.run_system(self.bruh).expect("WHAT");
+        self.world.clear_trackers();
+
         if self.exit {
-            let _ = self.renderer.send(RenderMessage::Exit);
+            self.renderer.send(RenderMessage::Exit);
             // you know I'd like to do a timeout here...
             // only because I have an NVIDIA GPU HELP
             self.render_handle
@@ -76,21 +93,19 @@ impl Client {
                 .expect("uh oh")
                 .join()
                 .expect("bruh");
+            event_loop.exit();
         }
-        self.exit
+    }
+
+    pub fn recv(&mut self) {
+        for msg in self.server.recv() {}
     }
 
     pub fn window_event(&mut self, event: WindowEvent) {
         match event {
             WindowEvent::CloseRequested => self.exit = true,
-            WindowEvent::Resized(size) => self
-                .renderer
-                .send(RenderMessage::Resize(size))
-                .expect("render broke"),
-            WindowEvent::RedrawRequested => self
-                .renderer
-                .send(RenderMessage::Draw)
-                .expect("render broke"),
+            WindowEvent::Resized(size) => self.renderer.send(RenderMessage::Resize(size)),
+            WindowEvent::RedrawRequested => self.renderer.send(RenderMessage::Draw),
             WindowEvent::CursorLeft { .. } => {
                 self.input.clear();
             }