Skip to main content

StartPos

azalea_entity::metadata

Struct StartPos 

Source 
pub struct StartPos(pub BlockPos);
Expand description

A metadata field for FallingBlock.

Tuple Fields§

§0: BlockPos

Methods from Deref<Target = BlockPos>§

pub const ZERO: BlockPos

pub fn length_squared(&self) -> i32

Get the distance of this vector to the origin by doing x^2 + y^2 + z^2.

pub fn horizontal_distance_squared(&self) -> i32

pub fn down(&self, y: i32) -> BlockPos

Return a new instance of this position with the y coordinate decreased by the given number.

Examples found in repository?
azalea/examples/testbot/commands/movement.rs (line 93)
13pub fn register(commands: &mut Dispatcher) {
14    commands.register(
15        literal("goto")
16            .executes(|ctx: &Ctx| {
17                let source = ctx.source.lock();
18                println!("got goto");
19                // look for the sender
20                let Some(entity) = source.entity() else {
21                    source.reply("I can't see you!");
22                    return Ok(0);
23                };
24                let position = entity.position()?;
25                source.reply("ok");
26                source
27                    .bot
28                    .start_goto(BlockPosGoal(BlockPos::from(position.up(0.5))));
29                Ok(1)
30            })
31            .then(literal("xz").then(argument("x", integer()).then(
32                argument("z", integer()).executes(|ctx: &Ctx| {
33                    let source = ctx.source.lock();
34                    let x = get_integer(ctx, "x").unwrap();
35                    let z = get_integer(ctx, "z").unwrap();
36                    println!("goto xz {x} {z}");
37                    source.reply("ok");
38                    source.bot.start_goto(XZGoal { x, z });
39                    Ok(1)
40                }),
41            )))
42            .then(literal("radius").then(argument("radius", float()).then(
43                argument("x", integer()).then(argument("y", integer()).then(
44                    argument("z", integer()).executes(|ctx: &Ctx| {
45                        let source = ctx.source.lock();
46                        let radius = get_float(ctx, "radius").unwrap();
47                        let x = get_integer(ctx, "x").unwrap();
48                        let y = get_integer(ctx, "y").unwrap();
49                        let z = get_integer(ctx, "z").unwrap();
50                        println!("goto radius {radius}, position: {x} {y} {z}");
51                        source.reply("ok");
52                        source.bot.start_goto(RadiusGoal {
53                            pos: BlockPos::new(x, y, z).center(),
54                            radius,
55                        });
56                        Ok(1)
57                    }),
58                )),
59            )))
60            .then(argument("x", integer()).then(argument("y", integer()).then(
61                argument("z", integer()).executes(|ctx: &Ctx| {
62                    let source = ctx.source.lock();
63                    let x = get_integer(ctx, "x").unwrap();
64                    let y = get_integer(ctx, "y").unwrap();
65                    let z = get_integer(ctx, "z").unwrap();
66                    println!("goto xyz {x} {y} {z}");
67                    source.reply("ok");
68                    source.bot.start_goto(BlockPosGoal(BlockPos::new(x, y, z)));
69                    Ok(1)
70                }),
71            ))),
72    );
73
74    commands.register(literal("follow").executes(|ctx: &Ctx| {
75        let source = ctx.source.lock();
76        println!("got follow");
77        // look for the sender
78        let Some(entity) = source.entity() else {
79            source.reply("I can't see you!");
80            return Ok(0);
81        };
82        source.reply("ok");
83        *source.state.following_entity.lock() = Some(entity);
84        Ok(1)
85    }));
86
87    commands.register(literal("down").executes(|ctx: &Ctx| {
88        let source = ctx.source.clone();
89        let bot = source.lock().bot.clone();
90        let position = BlockPos::from(bot.position()?);
91        tokio::spawn(async move {
92            source.lock().reply("mining...");
93            bot.mine(position.down(1)).await;
94            source.lock().reply("done");
95        });
96        Ok(1)
97    }));
98
99    commands.register(
100        literal("look")
101            .executes(|ctx: &Ctx| {
102                // look for the sender
103                let source = ctx.source.lock();
104                let Some(entity) = source.entity() else {
105                    source.reply("I can't see you!");
106                    return Ok(0);
107                };
108                let eye_position = entity.eye_position()?;
109                source.bot.look_at(eye_position);
110                Ok(1)
111            })
112            .then(argument("x", integer()).then(argument("y", integer()).then(
113                argument("z", integer()).executes(|ctx: &Ctx| {
114                    let pos = BlockPos::new(
115                        get_integer(ctx, "x").unwrap(),
116                        get_integer(ctx, "y").unwrap(),
117                        get_integer(ctx, "z").unwrap(),
118                    );
119                    println!("{pos:?}");
120                    let source = ctx.source.lock();
121                    source.bot.look_at(pos.center());
122                    Ok(1)
123                }),
124            ))),
125    );
126
127    commands.register(
128        literal("walk").then(argument("seconds", float()).executes(|ctx: &Ctx| {
129            let mut seconds = get_float(ctx, "seconds").unwrap();
130            let source = ctx.source.lock();
131            let bot = source.bot.clone();
132
133            if seconds < 0. {
134                bot.walk(WalkDirection::Backward);
135                seconds = -seconds;
136            } else {
137                bot.walk(WalkDirection::Forward);
138            }
139
140            tokio::spawn(async move {
141                tokio::time::sleep(Duration::from_secs_f32(seconds)).await;
142                bot.walk(WalkDirection::None);
143            });
144            source.reply(format!("ok, walking for {seconds} seconds"));
145            Ok(1)
146        })),
147    );
148    commands.register(
149        literal("sprint").then(argument("seconds", float()).executes(|ctx: &Ctx| {
150            let seconds = get_float(ctx, "seconds").unwrap();
151            let source = ctx.source.lock();
152            let bot = source.bot.clone();
153            bot.sprint(SprintDirection::Forward);
154            tokio::spawn(async move {
155                tokio::time::sleep(Duration::from_secs_f32(seconds)).await;
156                bot.walk(WalkDirection::None);
157            });
158            source.reply(format!("ok, sprinting for {seconds} seconds"));
159            Ok(1)
160        })),
161    );
162
163    commands.register(literal("north").executes(|ctx: &Ctx| {
164        let source = ctx.source.lock();
165        source.bot.set_direction(180., 0.)?;
166        source.reply("ok");
167        Ok(1)
168    }));
169    commands.register(literal("south").executes(|ctx: &Ctx| {
170        let source = ctx.source.lock();
171        source.bot.set_direction(0., 0.)?;
172        source.reply("ok");
173        Ok(1)
174    }));
175    commands.register(literal("east").executes(|ctx: &Ctx| {
176        let source = ctx.source.lock();
177        source.bot.set_direction(-90., 0.)?;
178        source.reply("ok");
179        Ok(1)
180    }));
181    commands.register(literal("west").executes(|ctx: &Ctx| {
182        let source = ctx.source.lock();
183        source.bot.set_direction(90., 0.)?;
184        source.reply("ok");
185        Ok(1)
186    }));
187    commands.register(
188        literal("jump")
189            .executes(|ctx: &Ctx| {
190                let source = ctx.source.lock();
191                source.bot.jump();
192                source.reply("ok");
193                Ok(1)
194            })
195            .then(argument("enabled", bool()).executes(|ctx: &Ctx| {
196                let jumping = get_bool(ctx, "enabled").unwrap();
197                let source = ctx.source.lock();
198                source.bot.set_jumping(jumping)?;
199                Ok(1)
200            })),
201    );
202
203    let sneak = |ctx: &Ctx| {
204        let source = ctx.source.lock();
205        source.bot.set_crouching(!source.bot.crouching())?;
206        source.reply("ok");
207        Ok(1)
208    };
209    let sneak_enabled = argument("enabled", bool()).executes(|ctx: &Ctx| {
210        let sneaking = get_bool(ctx, "enabled").unwrap();
211        let source = ctx.source.lock();
212        source.bot.set_crouching(sneaking)?;
213        Ok(1)
214    });
215    commands.register(literal("sneak").executes(sneak).then(sneak_enabled.clone()));
216    commands.register(literal("crouch").executes(sneak).then(sneak_enabled));
217
218    commands.register(literal("stop").executes(|ctx: &Ctx| {
219        let source = ctx.source.lock();
220        source.bot.stop_pathfinding();
221        source.reply("ok");
222        *source.state.following_entity.lock() = None;
223        Ok(1)
224    }));
225    commands.register(literal("forcestop").executes(|ctx: &Ctx| {
226        let source = ctx.source.lock();
227        source.bot.force_stop_pathfinding();
228        source.reply("ok");
229        *source.state.following_entity.lock() = None;
230        Ok(1)
231    }));
232}

pub fn up(&self, y: i32) -> BlockPos

Return a new instance of this position with the y coordinate increased by the given number.

pub fn north(&self, z: i32) -> BlockPos

Return a new instance of this position with the z coordinate subtracted by the given number.

pub fn east(&self, x: i32) -> BlockPos

Return a new instance of this position with the x coordinate increased by the given number.

pub fn south(&self, z: i32) -> BlockPos

Return a new instance of this position with the z coordinate increased by the given number.

pub fn west(&self, x: i32) -> BlockPos

Return a new instance of this position with the x coordinate subtracted by the given number.

pub fn dot(&self, other: BlockPos) -> i32

pub fn cross(&self, other: BlockPos) -> BlockPos

pub fn min(&self, other: BlockPos) -> BlockPos

Make a new position with the lower coordinates for each axis.

pub fn max(&self, other: BlockPos) -> BlockPos

Make a new position with the higher coordinates for each axis.

pub fn xz(&self) -> BlockPos

Replace the Y with 0.

pub fn with_x(&self, x: i32) -> BlockPos

pub fn with_y(&self, y: i32) -> BlockPos

pub fn with_z(&self, z: i32) -> BlockPos

pub fn center(&self) -> Vec3

Get the absolute center of a block position by adding 0.5 to each coordinate.

Examples found in repository?
azalea/examples/steal.rs (line 69)
42async fn steal(bot: Client, state: State) -> eyre::Result<()> {
43    {
44        let mut is_stealing = state.is_stealing.lock();
45        if *is_stealing {
46            bot.chat("Already stealing");
47            return Ok(());
48        }
49        *is_stealing = true;
50    }
51
52    state.checked_chests.lock().clear();
53
54    loop {
55        let chest_block = bot
56            .world()?
57            .read()
58            .find_blocks(bot.position()?, &BlockKind::Chest.into())
59            .find(
60                // find the closest chest that hasn't been checked
61                |block_pos| !state.checked_chests.lock().contains(block_pos),
62            );
63        let Some(chest_block) = chest_block else {
64            break;
65        };
66
67        state.checked_chests.lock().push(chest_block);
68
69        bot.goto(RadiusGoal::new(chest_block.center(), 3.)).await;
70
71        let Some(chest) = bot.open_container_at(chest_block).await? else {
72            println!("Couldn't open chest at {chest_block:?}");
73            continue;
74        };
75
76        println!("Getting contents of chest at {chest_block:?}");
77        for (index, slot) in chest.contents().unwrap_or_default().iter().enumerate() {
78            println!("Checking slot {index}: {slot:?}");
79            let ItemStack::Present(item) = slot else {
80                continue;
81            };
82            if item.kind == ItemKind::Diamond {
83                println!("clicking slot ^");
84                chest.left_click(index);
85            }
86        }
87    }
88
89    bot.chat("Done");
90
91    *state.is_stealing.lock() = false;
92
93    Ok(())
94}
More examples
Hide additional examples
azalea/examples/testbot/commands/movement.rs (line 53)
13pub fn register(commands: &mut Dispatcher) {
14    commands.register(
15        literal("goto")
16            .executes(|ctx: &Ctx| {
17                let source = ctx.source.lock();
18                println!("got goto");
19                // look for the sender
20                let Some(entity) = source.entity() else {
21                    source.reply("I can't see you!");
22                    return Ok(0);
23                };
24                let position = entity.position()?;
25                source.reply("ok");
26                source
27                    .bot
28                    .start_goto(BlockPosGoal(BlockPos::from(position.up(0.5))));
29                Ok(1)
30            })
31            .then(literal("xz").then(argument("x", integer()).then(
32                argument("z", integer()).executes(|ctx: &Ctx| {
33                    let source = ctx.source.lock();
34                    let x = get_integer(ctx, "x").unwrap();
35                    let z = get_integer(ctx, "z").unwrap();
36                    println!("goto xz {x} {z}");
37                    source.reply("ok");
38                    source.bot.start_goto(XZGoal { x, z });
39                    Ok(1)
40                }),
41            )))
42            .then(literal("radius").then(argument("radius", float()).then(
43                argument("x", integer()).then(argument("y", integer()).then(
44                    argument("z", integer()).executes(|ctx: &Ctx| {
45                        let source = ctx.source.lock();
46                        let radius = get_float(ctx, "radius").unwrap();
47                        let x = get_integer(ctx, "x").unwrap();
48                        let y = get_integer(ctx, "y").unwrap();
49                        let z = get_integer(ctx, "z").unwrap();
50                        println!("goto radius {radius}, position: {x} {y} {z}");
51                        source.reply("ok");
52                        source.bot.start_goto(RadiusGoal {
53                            pos: BlockPos::new(x, y, z).center(),
54                            radius,
55                        });
56                        Ok(1)
57                    }),
58                )),
59            )))
60            .then(argument("x", integer()).then(argument("y", integer()).then(
61                argument("z", integer()).executes(|ctx: &Ctx| {
62                    let source = ctx.source.lock();
63                    let x = get_integer(ctx, "x").unwrap();
64                    let y = get_integer(ctx, "y").unwrap();
65                    let z = get_integer(ctx, "z").unwrap();
66                    println!("goto xyz {x} {y} {z}");
67                    source.reply("ok");
68                    source.bot.start_goto(BlockPosGoal(BlockPos::new(x, y, z)));
69                    Ok(1)
70                }),
71            ))),
72    );
73
74    commands.register(literal("follow").executes(|ctx: &Ctx| {
75        let source = ctx.source.lock();
76        println!("got follow");
77        // look for the sender
78        let Some(entity) = source.entity() else {
79            source.reply("I can't see you!");
80            return Ok(0);
81        };
82        source.reply("ok");
83        *source.state.following_entity.lock() = Some(entity);
84        Ok(1)
85    }));
86
87    commands.register(literal("down").executes(|ctx: &Ctx| {
88        let source = ctx.source.clone();
89        let bot = source.lock().bot.clone();
90        let position = BlockPos::from(bot.position()?);
91        tokio::spawn(async move {
92            source.lock().reply("mining...");
93            bot.mine(position.down(1)).await;
94            source.lock().reply("done");
95        });
96        Ok(1)
97    }));
98
99    commands.register(
100        literal("look")
101            .executes(|ctx: &Ctx| {
102                // look for the sender
103                let source = ctx.source.lock();
104                let Some(entity) = source.entity() else {
105                    source.reply("I can't see you!");
106                    return Ok(0);
107                };
108                let eye_position = entity.eye_position()?;
109                source.bot.look_at(eye_position);
110                Ok(1)
111            })
112            .then(argument("x", integer()).then(argument("y", integer()).then(
113                argument("z", integer()).executes(|ctx: &Ctx| {
114                    let pos = BlockPos::new(
115                        get_integer(ctx, "x").unwrap(),
116                        get_integer(ctx, "y").unwrap(),
117                        get_integer(ctx, "z").unwrap(),
118                    );
119                    println!("{pos:?}");
120                    let source = ctx.source.lock();
121                    source.bot.look_at(pos.center());
122                    Ok(1)
123                }),
124            ))),
125    );
126
127    commands.register(
128        literal("walk").then(argument("seconds", float()).executes(|ctx: &Ctx| {
129            let mut seconds = get_float(ctx, "seconds").unwrap();
130            let source = ctx.source.lock();
131            let bot = source.bot.clone();
132
133            if seconds < 0. {
134                bot.walk(WalkDirection::Backward);
135                seconds = -seconds;
136            } else {
137                bot.walk(WalkDirection::Forward);
138            }
139
140            tokio::spawn(async move {
141                tokio::time::sleep(Duration::from_secs_f32(seconds)).await;
142                bot.walk(WalkDirection::None);
143            });
144            source.reply(format!("ok, walking for {seconds} seconds"));
145            Ok(1)
146        })),
147    );
148    commands.register(
149        literal("sprint").then(argument("seconds", float()).executes(|ctx: &Ctx| {
150            let seconds = get_float(ctx, "seconds").unwrap();
151            let source = ctx.source.lock();
152            let bot = source.bot.clone();
153            bot.sprint(SprintDirection::Forward);
154            tokio::spawn(async move {
155                tokio::time::sleep(Duration::from_secs_f32(seconds)).await;
156                bot.walk(WalkDirection::None);
157            });
158            source.reply(format!("ok, sprinting for {seconds} seconds"));
159            Ok(1)
160        })),
161    );
162
163    commands.register(literal("north").executes(|ctx: &Ctx| {
164        let source = ctx.source.lock();
165        source.bot.set_direction(180., 0.)?;
166        source.reply("ok");
167        Ok(1)
168    }));
169    commands.register(literal("south").executes(|ctx: &Ctx| {
170        let source = ctx.source.lock();
171        source.bot.set_direction(0., 0.)?;
172        source.reply("ok");
173        Ok(1)
174    }));
175    commands.register(literal("east").executes(|ctx: &Ctx| {
176        let source = ctx.source.lock();
177        source.bot.set_direction(-90., 0.)?;
178        source.reply("ok");
179        Ok(1)
180    }));
181    commands.register(literal("west").executes(|ctx: &Ctx| {
182        let source = ctx.source.lock();
183        source.bot.set_direction(90., 0.)?;
184        source.reply("ok");
185        Ok(1)
186    }));
187    commands.register(
188        literal("jump")
189            .executes(|ctx: &Ctx| {
190                let source = ctx.source.lock();
191                source.bot.jump();
192                source.reply("ok");
193                Ok(1)
194            })
195            .then(argument("enabled", bool()).executes(|ctx: &Ctx| {
196                let jumping = get_bool(ctx, "enabled").unwrap();
197                let source = ctx.source.lock();
198                source.bot.set_jumping(jumping)?;
199                Ok(1)
200            })),
201    );
202
203    let sneak = |ctx: &Ctx| {
204        let source = ctx.source.lock();
205        source.bot.set_crouching(!source.bot.crouching())?;
206        source.reply("ok");
207        Ok(1)
208    };
209    let sneak_enabled = argument("enabled", bool()).executes(|ctx: &Ctx| {
210        let sneaking = get_bool(ctx, "enabled").unwrap();
211        let source = ctx.source.lock();
212        source.bot.set_crouching(sneaking)?;
213        Ok(1)
214    });
215    commands.register(literal("sneak").executes(sneak).then(sneak_enabled.clone()));
216    commands.register(literal("crouch").executes(sneak).then(sneak_enabled));
217
218    commands.register(literal("stop").executes(|ctx: &Ctx| {
219        let source = ctx.source.lock();
220        source.bot.stop_pathfinding();
221        source.reply("ok");
222        *source.state.following_entity.lock() = None;
223        Ok(1)
224    }));
225    commands.register(literal("forcestop").executes(|ctx: &Ctx| {
226        let source = ctx.source.lock();
227        source.bot.force_stop_pathfinding();
228        source.reply("ok");
229        *source.state.following_entity.lock() = None;
230        Ok(1)
231    }));
232}

pub fn center_bottom(&self) -> Vec3

Get the center of the bottom of a block position by adding 0.5 to the x and z coordinates.

pub fn to_vec3_floored(&self) -> Vec3

Convert the block position into a Vec3 without centering it.

pub fn length_manhattan(&self) -> u32

Get the distance of this vector from the origin by doing x + y + z.

pub fn length(&self) -> f64

Get the distance (as an f64) of this BlockPos to the origin by doing sqrt(x^2 + y^2 + z^2).

Trait Implementations§

Source§

impl Clone for StartPos

Source§

fn clone(&self) -> StartPos

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Component for StartPos
where Self: Send + Sync + 'static,

Source§

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

A constant indicating the storage type used for this component.
Source§

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>]. Read more
Source§

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

Registers required components. Read more
Source§

fn clone_behavior() -> ComponentCloneBehavior

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

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<Self>>

Returns [ComponentRelationshipAccessor] required for working with relationships in dynamic contexts. Read more
§

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

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

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] Read more
Source§

impl Deref for StartPos

Source§

type Target = BlockPos

The resulting type after dereferencing.
Source§

fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

impl DerefMut for StartPos

Source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
Source§

impl PartialEq for StartPos

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 (const: unstable) · Source§

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

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

impl StructuralPartialEq for StartPos

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<C> Bundle for C
where C: Component,

§

fn component_ids( components: &mut ComponentsRegistrator<'_>, ) -> impl Iterator<Item = ComponentId> + use<C>

§

fn get_component_ids( components: &Components, ) -> impl Iterator<Item = Option<ComponentId>>

Return a iterator over this [Bundle]’s component ids. This will be None if the component has not been registered.
§

impl<C> BundleFromComponents for C
where C: Component,

§

unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C
where F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,

Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Converts Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>, which can then be downcast into Box<dyn ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Converts Rc<Trait> (where Trait: Downcast) to Rc<Any>, which can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Converts &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Converts &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSend for T
where T: Any + Send,

§

fn into_any_send(self: Box<T>) -> Box<dyn Any + Send>

Converts Box<Trait> (where Trait: DowncastSend) to Box<dyn Any + Send>, which can then be downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

impl<C> DynamicBundle for C
where C: Component,

§

type Effect = ()

An operation on the entity that happens after inserting this bundle.
§

unsafe fn get_components( ptr: MovingPtr<'_, C>, func: &mut impl FnMut(StorageType, OwningPtr<'_>), ) -> <C as DynamicBundle>::Effect

Moves the components out of the bundle. Read more
§

unsafe fn apply_effect( _ptr: MovingPtr<'_, MaybeUninit<C>>, _entity: &mut EntityWorldMut<'_>, )

Applies the after-effects of spawning this bundle. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

§

impl<T> IntoResult<T> for T

§

fn into_result(self) -> Result<T, RunSystemError>

Converts this type into the system output type.
§

impl<A> Is for A
where A: Any,

§

fn is<T>() -> bool
where T: Any,

Checks if the current type “is” another type, using a TypeId equality comparison. This is most useful in the context of generic logic. Read more
§

impl<T> PolicyExt for T
where T: ?Sized,

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more
Source§

impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

Source§

type Target = T

🔬This is a nightly-only experimental API. (arbitrary_self_types)
The target type on which the method may be called.
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> TypeData for T
where T: 'static + Send + Sync + Clone,

§

fn clone_type_data(&self) -> Box<dyn TypeData>

Creates a type-erased clone of this value.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<T> ConditionalSend for T
where T: Send,