Update to bevy 0.16

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "big-brain"
-version = "0.22.0"
+version = "0.23.0"
 authors = ["Kat Marchán <[email protected]>"]
 edition = "2021"
 description = "Rusty Utility AI library"
@@ -15,11 +15,11 @@ homepage = "https://github.com/zkat/big-brain"
 [workspace]
 
 [dependencies]
-bevy = { version = "0.15.0", default-features = false }
-big-brain-derive = { version = "=0.22.0", path = "./derive" }
+bevy = { version = "0.16.0", default-features = false, features = ["bevy_log"] }
+big-brain-derive = { version = "=0.23.0", path = "./derive" }
 
 [dev-dependencies]
-bevy = { version = "0.15.0", default-features = true }
+bevy = { version = "0.16.0", default-features = true }
 rand = { version = "0.8.5", features = ["small_rng"] }
 
 [features]

README.md

@@ -129,7 +129,7 @@ fn main() {
 
 #### bevy version and MSRV
 
-The current version of `big-brain` is compatible with `bevy` 0.15.0.
+The current version of `big-brain` is compatible with `bevy` 0.16.0.
 
 The Minimum Supported Rust Version for `big-brain` should be considered to
 be the same as `bevy`'s, which as of the time of this writing was "the

derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "big-brain-derive"
-version = "0.22.0"
+version = "0.23.0"
 authors = ["Kat Marchán <[email protected]>"]
 description = "Procedural macros to simplify implementation of Big Brain traits"
 documentation = "https://docs.rs/big-brain-derive"

examples/concurrent.rs

@@ -6,7 +6,6 @@
 
 use bevy::log::LogPlugin;
 use bevy::prelude::*;
-use bevy::utils::tracing::debug;
 use big_brain::prelude::*;
 use rand::rngs::SmallRng;
 use rand::{Rng, SeedableRng};

examples/custom_measure.rs

@@ -1,9 +1,9 @@
 //! This example demonstrates how to build a custom measure and use that
 //! in a Thinker.
 
+use bevy::ecs::component::Mutable;
 use bevy::log::LogPlugin;
 use bevy::prelude::*;
-use bevy::utils::tracing::debug;
 use big_brain::prelude::*;
 use big_brain::scorers::MeasuredScorer;
 
@@ -81,7 +81,7 @@ pub struct EatWaffles;
 
 fn eat_thing_action<
     TActionMarker: std::fmt::Debug + Component,
-    TActorMarker: Component + EatFood,
+    TActorMarker: Component<Mutability = Mutable> + EatFood,
 >(
     time: Res<Time>,
     mut items: Query<&mut TActorMarker>,

examples/farming_sim.rs

@@ -483,6 +483,7 @@ fn init_entities(
     commands.insert_resource(AmbientLight {
         color: Color::WHITE,
         brightness: 700.0,
+        ..default()
     });
 
     commands.spawn((

examples/one_off.rs

@@ -1,6 +1,5 @@
 use bevy::log::LogPlugin;
 use bevy::prelude::*;
-use bevy::utils::tracing::{debug, trace};
 use big_brain::prelude::*;
 
 #[derive(Clone, Component, Debug, ActionBuilder)]

examples/sequence.rs

@@ -8,7 +8,6 @@
 
 use bevy::log::LogPlugin;
 use bevy::prelude::*;
-use bevy::utils::tracing::{debug, trace};
 use big_brain::prelude::*;
 
 /// First, we make a simple Position component.

examples/thirst.rs

@@ -1,6 +1,5 @@
 use bevy::log::LogPlugin;
 use bevy::prelude::*;
-use bevy::utils::tracing::{debug, trace};
 use big_brain::prelude::*;
 
 // First, we define a "Thirst" component and associated system. This is NOT

src/actions.rs

@@ -3,8 +3,6 @@
 use std::sync::Arc;
 
 use bevy::prelude::*;
-#[cfg(feature = "trace")]
-use bevy::utils::tracing::trace;
 
 use crate::thinker::{Action, ActionSpan, Actor};
 
@@ -287,8 +285,8 @@ pub fn steps_system(
                         let step_state = step_state.clone();
                         let mut seq_state = states.get_mut(seq_ent).expect("idk");
                         *seq_state = step_state;
-                        if let Some(ent) = cmd.get_entity(steps_action.active_ent.entity()) {
-                            ent.despawn_recursive();
+                        if let Ok(mut ent) = cmd.get_entity(steps_action.active_ent.entity()) {
+                            ent.despawn();
                         }
                     }
                     Success if steps_action.active_step == steps_action.steps.len() - 1 => {
@@ -298,16 +296,16 @@ pub fn steps_system(
                         let step_state = step_state.clone();
                         let mut seq_state = states.get_mut(seq_ent).expect("idk");
                         *seq_state = step_state;
-                        if let Some(ent) = cmd.get_entity(steps_action.active_ent.entity()) {
-                            ent.despawn_recursive();
+                        if let Ok(mut ent) = cmd.get_entity(steps_action.active_ent.entity()) {
+                            ent.despawn();
                         }
                     }
                     Success => {
                         #[cfg(feature = "trace")]
                         trace!("Step succeeded, but there's more steps. Spawning next action.");
                         // Deactivate current step and go to the next step
-                        if let Some(ent) = cmd.get_entity(steps_action.active_ent.entity()) {
-                            ent.despawn_recursive();
+                        if let Ok(mut ent) = cmd.get_entity(steps_action.active_ent.entity()) {
+                            ent.despawn();
                         }
 
                         steps_action.active_step += 1;

src/scorers.rs

@@ -5,8 +5,6 @@
 use std::{cmp::Ordering, sync::Arc};
 
 use bevy::prelude::*;
-#[cfg(feature = "trace")]
-use bevy::utils::tracing::trace;
 
 use crate::{
     evaluators::Evaluator,

src/thinker.rs

@@ -1,19 +1,20 @@
 //! Thinkers are the "brain" of an entity. You attach Scorers to it, and the
 //! Thinker picks the right Action to run based on the resulting Scores.
 
-use std::{collections::VecDeque, sync::Arc};
+use std::{
+    collections::VecDeque,
+    sync::Arc,
+    time::{Duration, Instant},
+};
 
 use bevy::{
-    prelude::*,
-    utils::{
-        tracing::{debug, field, span, Level, Span},
-        Duration, Instant,
+    log::{
+        tracing::{field, span, Span},
+        Level,
     },
+    prelude::*,
 };
 
-#[cfg(feature = "trace")]
-use bevy::utils::tracing::trace;
-
 use crate::{
     actions::{self, ActionBuilder, ActionBuilderWrapper, ActionState},
     choices::{Choice, ChoiceBuilder},
@@ -263,8 +264,8 @@ pub fn thinker_component_detach_system(
     q: Query<(Entity, &HasThinker), Without<ThinkerBuilder>>,
 ) {
     for (actor, HasThinker(thinker)) in q.iter() {
-        if let Some(ent) = cmd.get_entity(*thinker) {
-            ent.despawn_recursive();
+        if let Ok(mut ent) = cmd.get_entity(*thinker) {
+            ent.despawn();
         }
         cmd.entity(actor).remove::<HasThinker>();
     }
@@ -278,8 +279,8 @@ pub fn actor_gone_cleanup(
     for (child, Actor(actor)) in q.iter() {
         if actors.get(*actor).is_err() {
             // Actor is gone. Let's clean up.
-            if let Some(ent) = cmd.get_entity(child) {
-                ent.despawn_recursive();
+            if let Ok(mut ent) = cmd.get_entity(child) {
+                ent.despawn();
             }
         }
     }
@@ -354,8 +355,8 @@ pub fn thinker_system(
                     match state {
                         ActionState::Success | ActionState::Failure => {
                             debug!("Action already wrapped up on its own. Cleaning up action in Thinker.");
-                            if let Some(ent) = cmd.get_entity(current.0 .0) {
-                                ent.despawn_recursive();
+                            if let Ok(mut ent) = cmd.get_entity(current.0 .0) {
+                                ent.despawn();
                             }
                             thinker.current_action = None;
                         }
@@ -436,8 +437,8 @@ pub fn thinker_system(
                             "Action completed and nothing was picked. Despawning action entity.",
                         );
                         // Despawn the action itself.
-                        if let Some(ent) = cmd.get_entity(action_ent.0) {
-                            ent.despawn_recursive();
+                        if let Ok(mut ent) = cmd.get_entity(action_ent.0) {
+                            ent.despawn();
                         }
                         thinker.current_action = None;
                     } else if *curr_action_state == ActionState::Init {
@@ -544,8 +545,8 @@ fn exec_picked_action(
                 ActionState::Init | ActionState::Success | ActionState::Failure => {
                     debug!("Previous action already completed. Despawning action entity.",);
                     // Despawn the action itself.
-                    if let Some(ent) = cmd.get_entity(action_ent.0) {
-                        ent.despawn_recursive();
+                    if let Ok(mut ent) = cmd.get_entity(action_ent.0) {
+                        ent.despawn();
                     }
                     if let Some((Scorer(ent), score)) = scorer_info {
                         let scorer_span = scorer_spans.get(*ent).expect("Where is it?");

tests/steps.rs

@@ -70,7 +70,7 @@ fn exit_action(
             *state = ActionState::Executing;
         }
         if *state == ActionState::Executing {
-            app_exit_events.send(AppExit::Success);
+            app_exit_events.write(AppExit::Success);
         }
     }
 }