added Facade::visit_world_mut, World::remove_node

Author: schell

crates/apecs/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "apecs"
-version = "0.8.3"
+version = "0.8.4"
 edition = "2021"
 license = "MIT OR Apache-2.0"
 keywords = ["gamedev", "ecs", "async"]
@@ -26,7 +26,7 @@ bench = false
 any_vec = "0.10"
 apecs-derive = { version = "0.3.0", path = "../apecs-derive" }
 async-channel = "1.6"
-moongraph = { version = "0.4.2", default-features = false, features = ["parallel"] }
+moongraph = { version = "0.4.3", default-features = false, features = ["parallel"] }
 itertools = "0.10"
 log = "0.4"
 parking_lot = "0.12"

crates/apecs/src/facade.rs

@@ -1,6 +1,10 @@
 //! Access the [`World`]s resources from async futures.
+use std::{any::Any, sync::Arc};
+
 use moongraph::{Edges, Function, GraphError, Node, Resource, TypeKey, TypeMap};
 
+use crate::{world::LazyOp, World};
+
 pub(crate) struct Request {
     pub(crate) reads: Vec<TypeKey>,
     pub(crate) writes: Vec<TypeKey>,
@@ -45,6 +49,7 @@ pub struct Facade {
     // Unbounded. Sending a request from the facade will not yield the future.
     // In other words, it will not cause the async to stop at an await point.
     pub(crate) request_tx: async_channel::Sender<Request>,
+    pub(crate) lazy_tx: async_channel::Sender<LazyOp>,
 }
 
 impl Facade {
@@ -71,7 +76,7 @@ impl Facade {
                 writes,
                 moves,
                 prepare: |resources: &mut TypeMap| {
-                    log::trace!(
+                    log::debug!(
                         "request got resources - constructing {}",
                         std::any::type_name::<D>()
                     );
@@ -87,14 +92,41 @@ impl Facade {
         let box_d: Box<D> = rez.downcast().unwrap();
         let d = *box_d;
         let t = f(d);
-        log::trace!("request for {} done", std::any::type_name::<D>());
+        log::debug!("request for {} done", std::any::type_name::<D>());
         Ok(t)
     }
 
     /// Return the total number of facades.
     pub fn count(&self) -> usize {
         self.request_tx.sender_count()
     }
+
+    pub async fn visit_world_mut<T>(
+        &mut self,
+        f: impl FnOnce(&mut World) -> T + Send + Sync + 'static,
+    ) -> Result<T, GraphError>
+    where
+        T: Any + Send + Sync,
+    {
+        let (tx, rx) = async_channel::bounded(1);
+        // UNWRAP: safe because this channel is unbounded
+        self.lazy_tx
+            .try_send(LazyOp {
+                op: Box::new(|world| {
+                    let t = f(world);
+                    let any_t = Arc::new(t);
+                    Ok(any_t)
+                }),
+                tx,
+            })
+            .unwrap();
+        let any_t: Arc<_> = rx.recv().await.map_err(GraphError::other)?;
+        // UNWRAP: safe because we know we will only receive the type we expect, as we packed it
+        // in the closure above.
+        let arc_t: Arc<T> = any_t.downcast().unwrap();
+        // UNWRAP: safe because we know nothing has cloned this arc
+        Ok(Arc::try_unwrap(arc_t).unwrap_or_else(|_| unreachable!("something cloned the arc")))
+    }
 }
 
 /// A fulfillment schedule of requests for world resources,
@@ -142,6 +174,10 @@ impl<'a> FacadeSchedule<'a> {
         self.batches.len()
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
     /// Attempt to unify resources, returning `true` if resources are unified, `false` if not.
     pub fn unify(&mut self) -> bool {
         self.batches.unify()

crates/apecs/src/storage/archetype/components.rs

@@ -429,21 +429,23 @@ impl Components {
     }
 }
 
+type LazyComponentUpdate = Box<dyn FnOnce(&mut Components) + Send + Sync + 'static>;
+
 /// Add components lazily, at the time of your choosing.
 ///
 /// Used in instances where you can't apply changes to Components because of a
 /// borrow conflict (eg while iterating over a component query).
 #[derive(Default)]
-pub struct LazyComponents(Vec<Box<dyn FnOnce(&mut Components)>>);
+pub struct LazyComponents(Vec<LazyComponentUpdate>);
 
-impl Extend<Box<dyn FnOnce(&mut Components)>> for LazyComponents {
-    fn extend<T: IntoIterator<Item = Box<dyn FnOnce(&mut Components)>>>(&mut self, iter: T) {
+impl Extend<LazyComponentUpdate> for LazyComponents {
+    fn extend<T: IntoIterator<Item = LazyComponentUpdate>>(&mut self, iter: T) {
         self.0.extend(iter);
     }
 }
 
 impl IntoIterator for LazyComponents {
-    type Item = Box<dyn FnOnce(&mut Components)>;
+    type Item = LazyComponentUpdate;
 
     type IntoIter = std::vec::IntoIter<Self::Item>;
 
@@ -454,7 +456,11 @@ impl IntoIterator for LazyComponents {
 
 impl LazyComponents {
     /// Inserts the bundled components for the given entity.
-    pub fn insert_bundle<B: IsBundle + 'static>(&mut self, entity_id: usize, bundle: B) {
+    pub fn insert_bundle<B: IsBundle + Send + Sync + 'static>(
+        &mut self,
+        entity_id: usize,
+        bundle: B,
+    ) {
         self.0.push(Box::new(move |components| {
             components.insert_bundle(entity_id, bundle)
         }));
@@ -475,8 +481,7 @@ impl LazyComponents {
         }));
     }
 
-    /// Remove a single component from the given entity, returning it if the
-    /// entity had a component of that type.
+    /// Remove a single component from the given entity.
     pub fn remove_component<T: Send + Sync + 'static>(&mut self, entity_id: usize) {
         self.0.push(Box::new(move |components| {
             components.remove_component::<T>(entity_id);

crates/apecs/src/world.rs

@@ -62,16 +62,14 @@ impl EntityUpkeepSystem {
     fn tick(mut self) -> Result<(), GraphError> {
         let dead_ids: Vec<usize> = {
             let mut dead_ids = vec![];
-            while let Some(id) = self.entities.delete_rx.try_recv().ok() {
+            while let Ok(id) = self.entities.delete_rx.try_recv() {
                 dead_ids.push(id);
             }
             dead_ids
         };
         if !dead_ids.is_empty() {
-            let ids_and_types: Vec<(usize, smallvec::SmallVec<[TypeId; 4]>)> = {
-                let ids_and_types = self.components.upkeep(&dead_ids);
-                ids_and_types
-            };
+            let ids_and_types: Vec<(usize, smallvec::SmallVec<[TypeId; 4]>)> =
+                { self.components.upkeep(&dead_ids) };
             self.entities
                 .recycle
                 .extend(ids_and_types.iter().map(|(id, _)| *id));
@@ -228,7 +226,10 @@ impl Default for World {
         let lazy_ops = async_channel::unbounded();
         let entities = Entities::new(lazy_ops.0.clone());
         let (tx, rx) = async_channel::unbounded();
-        let facade = Facade { request_tx: tx };
+        let facade = Facade {
+            request_tx: tx,
+            lazy_tx: lazy_ops.0.clone(),
+        };
         let mut world = Self {
             graph: Graph::default(),
             facade: facade.clone(),
@@ -268,6 +269,16 @@ impl World {
         self
     }
 
+    pub fn remove_node(&mut self, name: impl AsRef<str>) {
+        let _ = self.graph.remove_node(name);
+    }
+
+    pub fn remove_nodes<T: AsRef<str>>(&mut self, names: impl IntoIterator<Item = T>) {
+        for name in names.into_iter() {
+            self.remove_node(name);
+        }
+    }
+
     pub fn interleave_subgraph(&mut self, graph: Graph) -> &mut Self {
         self.graph.interleave_subgraph(graph);
         let _ = self.graph.reschedule_if_necessary();