From 692fbed15796dde46109a59ed07aaa345d878f0c Mon Sep 17 00:00:00 2001
From: Daniel Flanagan <daniel@lyte.dev>
Date: Sat, 3 Aug 2024 00:52:19 -0500
Subject: [PATCH] WIP exclusive system?

---
 src/map.rs | 51 ++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 34 insertions(+), 17 deletions(-)

diff --git a/src/map.rs b/src/map.rs
index 64cb0b5..25bf576 100644
--- a/src/map.rs
+++ b/src/map.rs
@@ -1,5 +1,6 @@
 use crate::View;
 use crate::{inspector::HideFromInspector, prelude::*};
+use bevy::ecs::system::SystemState;
 use bevy::tasks::{block_on, futures_lite::future, AsyncComputeTaskPool, Task};
 use bevy_ecs_tilemap::prelude::*;
 use rand::prelude::*;
@@ -75,16 +76,33 @@ pub fn init(mut commands: Commands, assets: Res<AssetServer>) {
 
 const MAX_TILES_TO_LOAD_IN_ONE_UPDATE: usize = 5_000;
 pub fn tile_loaders(
-    mut commands: Commands,
-    mut query: Query<(Entity, &mut TileStorage), With<Tilemap>>,
-    mut chan: Query<&TileChan, With<Tilemap>>,
-    mut tasks: Query<&mut TileInit>,
-    mut app_state: ResMut<NextState<View>>,
+    world: &mut World,
+    params: &mut SystemState<(
+        Query<(Entity, &mut TileStorage), With<Tilemap>>,
+        Query<&TileChan, With<Tilemap>>,
+        Query<&mut TileInit>,
+        ResMut<NextState<View>>,
+    )>,
 ) {
-    // TODO: to avoid locking up the universe we only want to handle a certain number per iteration (Update)
+    let (mut query, mut chan, mut tasks, mut next_view) = params.get_mut(world);
     let mut tiles_done = true;
     let (tilemap, mut storage) = query.single_mut();
 
+    let mut tasks_iter = tasks.iter_mut().peekable();
+    let mut remove_tasks = false;
+    if tasks_iter.peek().is_none() && tiles_done {
+        next_view.set(View::InGame)
+    } else {
+        for mut task in tasks_iter {
+            let poll = future::poll_once(&mut task.0);
+            if block_on(poll).is_some() {
+                remove_tasks = true;
+                // task is done, remove it so we don't poll it again
+            }
+        }
+    }
+
+    let tile_bundles: Vec<TileBundle> = vec![];
     if let Ok(chan) = chan.get_single_mut() {
         let chan = chan.0.lock().unwrap();
         tiles_done = false;
@@ -93,7 +111,7 @@ pub fn tile_loaders(
             match chan.recv() {
                 Ok(ev) => {
                     let ref_position = &ev.position;
-                    let tile = commands.spawn((HideFromInspector, ev)).id();
+                    let tile = world.spawn((HideFromInspector, ev)).id();
                     storage.set(ref_position, tile);
                     counter += 1;
                     if counter >= MAX_TILES_TO_LOAD_IN_ONE_UPDATE {
@@ -102,7 +120,7 @@ pub fn tile_loaders(
                     }
                 }
                 Err(_) => {
-                    commands.entity(tilemap).remove::<TileChan>();
+                    world.entity_mut(tilemap).remove::<TileChan>();
                     if counter > 0 {
                         info!("Finished {counter}! Probably finishing mapgen soon...");
                     }
@@ -114,16 +132,15 @@ pub fn tile_loaders(
         }
     }
 
-    for mut task in &mut tasks {
-        let poll = future::poll_once(&mut task.0);
-        if block_on(poll).is_some() {
-            // task is done, remove it so we don't poll it again
-            commands.entity(tilemap).remove::<TileInit>();
-        }
-    }
-    if tasks.iter().peekable().peek().is_none() && tiles_done {
-        app_state.set(View::InGame);
+    if remove_tasks {
+        world.entity_mut(tilemap).remove::<TileInit>();
     }
+    world.spawn_batch(
+        tile_bundles
+            .into_iter()
+            .map(|t| (HideFromInspector, t))
+            .into_iter(),
+    );
 }
 
 pub fn exit(mut commands: Commands, q: Query<Entity, With<Tilemap>>) {