Struct DeterministicPredicted 

pub struct DeterministicPredicted {
    pub skip_despawn: bool,
    pub enable_rollback_after: u8,
}

Available on crate feature prediction only.

Marker component used to indicate this entity is predicted (it has a PredictionHistory), but it won’t check for rollback from state updates.

This can be used to mark predicted non-networked entities in deterministic replication, or to stop a state-replicated entity from being able to trigger rollbacks from state mismatch.

This entity will still get rolled back to its predicted history when a rollback happens.

Fields

skip_despawn: bool

After spawning a DeterministicPredicted entity, any rollback that happens shortly after might despawn the entity (since it didn’t exist at the start of rollback) or remove its components.

If the entity was spawned in a deterministic manner (for instance with a ‘Shoot’ input), then we want the entity to be despawned as it will get re-created during rollback. But if the entity was spawned as a one-off event (for example replicated by the server upon connection), we don’t want the entity to be affected by rollbacks for a short period after being spawned.

enable_rollback_after: u8

For entities where skip_despawn is True, after how many ticks do we start enabling back rollbacks?

Trait Implementations

impl Clone for DeterministicPredicted

fn clone(&self) -> DeterministicPredicted

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for DeterministicPredicted

where DeterministicPredicted: 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_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add 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<DeterministicPredicted>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

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

Gets the on_insert 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 Copy for DeterministicPredicted

impl Debug for DeterministicPredicted

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for DeterministicPredicted

fn default() -> DeterministicPredicted

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DeterministicPredicted

fn deserialize<__D>( __deserializer: __D, ) -> Result<DeterministicPredicted, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DeterministicPredicted

fn eq(&self, other: &DeterministicPredicted) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for DeterministicPredicted

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for DeterministicPredicted