Something went wrong. Try again.
An experimental, status effects-as-entities system for Bevy.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275use crate::EffectMode;use bevy_ecs::component::{ComponentCloneBehavior, ComponentId};use bevy_ecs::prelude::{ AppTypeRegistry, Bundle, Entity, EntityRef, Name, ReflectComponent, Resource, World,};use bevy_ecs::ptr::OwningPtr;use bevy_ecs::relationship::RelationshipHookMode;use bevy_utils::prelude::DebugName;use std::alloc::alloc;use std::any::TypeId;use std::error::Error;use std::fmt::Formatter;use std::ptr::{NonNull, copy_nonoverlapping};
#[derive(Resource)]pub(crate) struct BundleInspector { world: World, scratch_entity: Entity,}
impl Default for BundleInspector { fn default() -> Self { let mut world = World::new(); let scratch_entity = world.spawn_empty().id(); Self { world, scratch_entity, } }}
impl BundleInspector { /// Stashes a bundle so it can be inspected. /// /// Calls [`clear`](Self::clear) first to avoid leakage. pub fn stash_bundle<B: Bundle>(&mut self, bundle: B) -> &mut Self { self.clear();
self.world .entity_mut(self.scratch_entity) .insert_with_relationship_hook_mode(bundle, RelationshipHookMode::Skip);
self }
/// Clears the [stashed bundle](Self::stash_bundle). pub fn clear(&mut self) -> &mut Self { self.world.entity_mut(self.scratch_entity).clear();
self }
/// Returns the [stashed bundle's](Self::stash_bundle) name and effect mode. pub fn get_effect_meta(&self) -> (Option<Name>, EffectMode) { let name = self .world .entity(self.scratch_entity) .get::<Name>() .cloned();
let mode = self .world .entity(self.scratch_entity) .get::<EffectMode>() .copied() .unwrap_or_default();
(name, mode) }
/// Returns a reference to the [stashed bundle](Self::stash_bundle). pub fn get_ref(&'_ self) -> EntityRef<'_> { self.world.entity(self.scratch_entity) }
/// Converts a component ID to a type ID, if registered. /// The component ID must be from the inspector's world, using [`get_type_id`](Self::get_type_id). pub fn get_type_id(&self, component_id: ComponentId) -> Option<TypeId> { self.world .components() .get_info(component_id) .and_then(|info| info.type_id()) }
/// Copies a component from the [stashed bundle](Self::stash_bundle) into an entity in a different world. /// The component ID must be from the inspector's world, using [`get_type_id`](Self::get_type_id). /// /// # Errors /// Will return an error if: /// - The component is not registered in `dst_world`. /// - The component cannot be cloned ([`ComponentCloneBehavior::Ignore`]). /// - The stashed bundle doesn't contain the component. /// - The destination entity doesn't exist in `dst_world`. /// - The resource AppTypeRegistry doesn't exist in `dst_world`. /// /// # Safety /// `src_component_id` must be for the same component as `type_id`. pub unsafe fn copy_to_world( &self, dst_world: &mut World, dst_entity: Entity, type_id: TypeId, src_component_id: ComponentId, ) -> Result<&Self, MultiWorldCopyError> { let Some(dst_component_id) = dst_world.components().get_id(type_id) else { return Err(MultiWorldCopyError::Unregistered(type_id)); }; let component_info = dst_world.components().get_info(dst_component_id).unwrap();
match component_info.clone_behavior() { ComponentCloneBehavior::Default | ComponentCloneBehavior::Custom(_) => {} ComponentCloneBehavior::Ignore => { return Err(MultiWorldCopyError::Uncloneable(component_info.name())); } }
let Some(src) = self.world.get_by_id(self.scratch_entity, src_component_id) else { return Err(MultiWorldCopyError::MissingSrcComponent( component_info.name(), self.scratch_entity, )); };
if component_info.drop().is_none() { unsafe { // SAFETY: Contract is required to be upheld by the world. let dst = alloc(component_info.layout());
// SAFETY: `dst` is allocated from the component's layout. // Both IDs provided by the caller must match, and `src` and `dst` are obtained using those IDs. // `src` and `dst` are from different worlds, so cannot overlap. copy_nonoverlapping(src.as_ptr(), dst, component_info.layout().size());
// SAFETY: Both IDs provided by the caller must match, and `dst` was created from `src`. let owning = OwningPtr::new(NonNull::new(dst).unwrap());
// SAFETY: `existing_component_id` is extracted from `dst_world`. // Both IDs provided by the caller must match, and `owning` was obtained using `src_component_id`. dst_world .get_entity_mut(dst_entity) .map_err(|_| MultiWorldCopyError::MissingDstEntity(dst_entity))? .insert_by_id(dst_component_id, owning); } } else { let Some(registry) = dst_world.get_resource::<AppTypeRegistry>().cloned() else { return Err(MultiWorldCopyError::MissingTypeRegistry); }; let registry = registry.read();
let reflect_component = registry .get_type_data::<ReflectComponent>(type_id) .ok_or(MultiWorldCopyError::Uncloneable(component_info.name()))?;
reflect_component.copy( &self.world, dst_world, self.scratch_entity, dst_entity, ®istry, ); }
Ok(self) }}
#[derive(Debug, Eq, PartialEq, Clone)]pub enum MultiWorldCopyError { Unregistered(TypeId), Uncloneable(DebugName), MissingDstEntity(Entity), MissingSrcComponent(DebugName, Entity), MissingTypeRegistry,}
impl std::fmt::Display for MultiWorldCopyError { fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result { match self { MultiWorldCopyError::Unregistered(type_id) => write!( f, "Component with {type_id:?} is not registered in the destination world, and therefor cannot be inserted using merge mode.", ), MultiWorldCopyError::Uncloneable(name) => write!( f, "Component {name} cannot be cloned, and therefor cannot be inserted using merge mode.", ), MultiWorldCopyError::MissingDstEntity(entity) => write!( f, "Entity {entity} does not exist in the destination world." ), MultiWorldCopyError::MissingSrcComponent(name, entity) => write!( f, "Component {name} does not exist on the scratch entity {entity}, and therefor cannot be cloned.", ), MultiWorldCopyError::MissingTypeRegistry => write!( f, "Resource AppTypeRegistry does not exist in the destination world, and therefor no components can be cloned.", ), } }}
impl Error for MultiWorldCopyError {}
#[cfg(test)]mod tests { use super::*; use crate::Effecting;
#[test] fn get_effect_meta() { let mut inspector = BundleInspector::default();
let name = Name::new("Effect"); let mode = EffectMode::Insert;
assert_eq!( inspector .stash_bundle((name.clone(), mode)) .get_effect_meta(), (Some(name), mode) ); }
#[test] fn get_effect_meta_no_name() { let mut inspector = BundleInspector::default();
let mode = EffectMode::Insert;
assert_eq!(inspector.stash_bundle(mode).get_effect_meta(), (None, mode)); }
#[test] fn get_effect_meta_no_mode() { let mut inspector = BundleInspector::default();
let name = Name::new("Effect");
assert_eq!( inspector.stash_bundle(name.clone()).get_effect_meta(), (Some(name), EffectMode::default()) ); }
#[test] fn get_effect_meta_nothing() { let mut inspector = BundleInspector::default();
assert_eq!( inspector.stash_bundle(()).get_effect_meta(), (None, EffectMode::default()) ); }
#[test] fn get_effect_mode_with_relation() { let mut inspector = BundleInspector::default();
let name = Name::new("Effect"); let mode = EffectMode::Insert;
assert_eq!( inspector .stash_bundle(( name.clone(), mode, Effecting(Entity::from_raw_u32(32).unwrap()) )) .get_effect_meta(), (Some(name), mode) ); }}