Struct Merge 

pub struct Merge<T>(pub T)
where
    T: MergeComponent;

An EntityCommand which is used to add components.

Usage

It is impossible to have duplicate components on an Entity in Bevy. However, in some cases, multiple instances of some components can be “merged” into one.

If a component implements MergeComponent, you can use this command to merge multiple instances of the component into one.

use bevy::prelude::*;
use moonshine_util::prelude::*;

#[derive(Component, Default)]
struct N(usize);

impl MergeComponent for N {
    fn merge(&mut self, other: Self) {
        self.0 += other.0;
    }
}

let mut world = World::new();
let entity = world.spawn_empty().id();
world.commands().entity(entity).queue(Merge(N(1)));
world.commands().entity(entity).queue(Merge(N(2)));
world.flush();
let &N(value) = world.get(entity).unwrap();
assert_eq!(value, 3);

This command may also be used as a Component itself. This can be used in a Bundle or as a requirement to merge components.

use bevy::prelude::*;
use moonshine_util::prelude::*;

#[derive(Component, Default)]
struct N(usize);

impl MergeComponent for N {
    fn merge(&mut self, other: Self) {
        self.0 += other.0;
    }
}

let mut world = World::new();
let entity = world.spawn((N(1), Merge(N(2))));
let &N(value) = entity.get().unwrap();
assert_eq!(value, 3);

Because Merge<T> is a component itself, it can be used as a component requirement. However, because of the component uniqueness rule, multiple Merge<T> instances may not exist on the same entity. To work around this, you can use MergeFrom and MergeWith.

Tuple Fields

0: T

Implementations

impl<T> Merge<T>

where T: MergeComponent,

pub fn with<F>(f: F) -> MergeWith<T, impl Static + FnOnce() -> T>

where F: Static + FnOnce() -> T,

Ergonomic alias for MergeWith::new.

Trait Implementations

impl<T> Component for Merge<T>

where T: MergeComponent, Merge<T>: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy_ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<Merge<T>>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

impl<T> EntityCommand for Merge<T>

where T: MergeComponent,

fn apply(self, entity: EntityWorldMut<'_>)

Executes this command for the given Entity.

impl<T> From<T> for Merge<T>

where T: MergeComponent,

fn from(value: T) -> Merge<T>

Converts to this type from the input type.