Struct Position 

pub struct Position(/* private fields */);

The position of the entity right now.

If this is being used as an ECS component then you are free to modify it, because there are systems that will update the indexes automatically.

Its value is set to a default of [Vec3::ZERO] when it receives the login packet, its true position may be set ticks later.

Implementations

impl Position

pub fn new(pos: Vec3) -> Self

Methods from Deref<Target = Vec3>

pub fn with_delta(&self, delta: &impl PositionDeltaTrait) -> Vec3

pub fn normalize(&self) -> Vec3

pub fn multiply(&self, x: f64, y: f64, z: f64) -> Vec3

pub fn scale(&self, amount: f64) -> Vec3

pub const ZERO: Vec3

pub fn length_squared(&self) -> f64

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

pub fn horizontal_distance_squared(&self) -> f64

pub fn down(&self, y: f64) -> Vec3

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

pub fn up(&self, y: f64) -> Vec3

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

Examples found in repository

azalea/examples/testbot/commands/movement.rs (line 28)

pub fn register(commands: &mut Dispatcher) {
    commands.register(
        literal("goto")
            .executes(|ctx: &Ctx| {
                let source = ctx.source.lock();
                println!("got goto");
                // look for the sender
                let Some(entity) = source.entity() else {
                    source.reply("I can't see you!");
                    return Ok(0);
                };
                let position = entity.position()?;
                source.reply("ok");
                source
                    .bot
                    .start_goto(BlockPosGoal(BlockPos::from(position.up(0.5))));
                Ok(1)
            })
            .then(literal("xz").then(argument("x", integer()).then(
                argument("z", integer()).executes(|ctx: &Ctx| {
                    let source = ctx.source.lock();
                    let x = get_integer(ctx, "x").unwrap();
                    let z = get_integer(ctx, "z").unwrap();
                    println!("goto xz {x} {z}");
                    source.reply("ok");
                    source.bot.start_goto(XZGoal { x, z });
                    Ok(1)
                }),
            )))
            .then(literal("radius").then(argument("radius", float()).then(
                argument("x", integer()).then(argument("y", integer()).then(
                    argument("z", integer()).executes(|ctx: &Ctx| {
                        let source = ctx.source.lock();
                        let radius = get_float(ctx, "radius").unwrap();
                        let x = get_integer(ctx, "x").unwrap();
                        let y = get_integer(ctx, "y").unwrap();
                        let z = get_integer(ctx, "z").unwrap();
                        println!("goto radius {radius}, position: {x} {y} {z}");
                        source.reply("ok");
                        source.bot.start_goto(RadiusGoal {
                            pos: BlockPos::new(x, y, z).center(),
                            radius,
                        });
                        Ok(1)
                    }),
                )),
            )))
            .then(argument("x", integer()).then(argument("y", integer()).then(
                argument("z", integer()).executes(|ctx: &Ctx| {
                    let source = ctx.source.lock();
                    let x = get_integer(ctx, "x").unwrap();
                    let y = get_integer(ctx, "y").unwrap();
                    let z = get_integer(ctx, "z").unwrap();
                    println!("goto xyz {x} {y} {z}");
                    source.reply("ok");
                    source.bot.start_goto(BlockPosGoal(BlockPos::new(x, y, z)));
                    Ok(1)
                }),
            ))),
    );

    commands.register(literal("follow").executes(|ctx: &Ctx| {
        let source = ctx.source.lock();
        println!("got follow");
        // look for the sender
        let Some(entity) = source.entity() else {
            source.reply("I can't see you!");
            return Ok(0);
        };
        source.reply("ok");
        *source.state.following_entity.lock() = Some(entity);
        Ok(1)
    }));

    commands.register(literal("down").executes(|ctx: &Ctx| {
        let source = ctx.source.clone();
        let bot = source.lock().bot.clone();
        let position = BlockPos::from(bot.position()?);
        tokio::spawn(async move {
            source.lock().reply("mining...");
            bot.mine(position.down(1)).await;
            source.lock().reply("done");
        });
        Ok(1)
    }));

    commands.register(
        literal("look")
            .executes(|ctx: &Ctx| {
                // look for the sender
                let source = ctx.source.lock();
                let Some(entity) = source.entity() else {
                    source.reply("I can't see you!");
                    return Ok(0);
                };
                let eye_position = entity.eye_position()?;
                source.bot.look_at(eye_position);
                Ok(1)
            })
            .then(argument("x", integer()).then(argument("y", integer()).then(
                argument("z", integer()).executes(|ctx: &Ctx| {
                    let pos = BlockPos::new(
                        get_integer(ctx, "x").unwrap(),
                        get_integer(ctx, "y").unwrap(),
                        get_integer(ctx, "z").unwrap(),
                    );
                    println!("{pos:?}");
                    let source = ctx.source.lock();
                    source.bot.look_at(pos.center());
                    Ok(1)
                }),
            ))),
    );

    fn walk_command(ctx: &Ctx, direction: WalkDirection) -> eyre::Result<i32> {
        let mut seconds = get_float(ctx, "seconds").unwrap();
        let source = ctx.source.lock();
        let bot = source.bot.clone();

        if seconds < 0. {
            bot.walk(direction.opposite());
            seconds = -seconds;
        } else {
            bot.walk(direction);
        }

        tokio::spawn(async move {
            tokio::time::sleep(Duration::from_secs_f32(seconds)).await;
            bot.walk(WalkDirection::None);
        });
        source.reply(format!("ok, walking {direction:?} for {seconds} seconds"));
        Ok(1)
    }

    commands.register(
        literal("walk").then(
            argument("seconds", float())
                .executes(|ctx: &Ctx| walk_command(ctx, WalkDirection::Forward)),
        ),
    );
    commands.register(literal("left").then(
        argument("seconds", float()).executes(|ctx: &Ctx| walk_command(ctx, WalkDirection::Left)),
    ));
    commands.register(literal("right").then(
        argument("seconds", float()).executes(|ctx: &Ctx| walk_command(ctx, WalkDirection::Left)),
    ));
    commands.register(
        literal("sprint").then(argument("seconds", float()).executes(|ctx: &Ctx| {
            let seconds = get_float(ctx, "seconds").unwrap();
            let source = ctx.source.lock();
            let bot = source.bot.clone();
            bot.sprint(SprintDirection::Forward);
            tokio::spawn(async move {
                tokio::time::sleep(Duration::from_secs_f32(seconds)).await;
                bot.walk(WalkDirection::None);
            });
            source.reply(format!("ok, sprinting for {seconds} seconds"));
            Ok(1)
        })),
    );

    commands.register(literal("north").executes(|ctx: &Ctx| {
        let source = ctx.source.lock();
        source.bot.set_direction(180., 0.)?;
        source.reply("ok");
        Ok(1)
    }));
    commands.register(literal("south").executes(|ctx: &Ctx| {
        let source = ctx.source.lock();
        source.bot.set_direction(0., 0.)?;
        source.reply("ok");
        Ok(1)
    }));
    commands.register(literal("east").executes(|ctx: &Ctx| {
        let source = ctx.source.lock();
        source.bot.set_direction(-90., 0.)?;
        source.reply("ok");
        Ok(1)
    }));
    commands.register(literal("west").executes(|ctx: &Ctx| {
        let source = ctx.source.lock();
        source.bot.set_direction(90., 0.)?;
        source.reply("ok");
        Ok(1)
    }));
    commands.register(
        literal("jump")
            .executes(|ctx: &Ctx| {
                let source = ctx.source.lock();
                source.bot.jump();
                source.reply("ok");
                Ok(1)
            })
            .then(argument("enabled", bool()).executes(|ctx: &Ctx| {
                let jumping = get_bool(ctx, "enabled").unwrap();
                let source = ctx.source.lock();
                source.bot.set_jumping(jumping)?;
                Ok(1)
            })),
    );

    let sneak = |ctx: &Ctx| {
        let source = ctx.source.lock();
        source.bot.set_crouching(!source.bot.crouching())?;
        source.reply("ok");
        Ok(1)
    };
    let sneak_enabled = argument("enabled", bool()).executes(|ctx: &Ctx| {
        let sneaking = get_bool(ctx, "enabled").unwrap();
        let source = ctx.source.lock();
        source.bot.set_crouching(sneaking)?;
        Ok(1)
    });
    commands.register(literal("sneak").executes(sneak).then(sneak_enabled.clone()));
    commands.register(literal("crouch").executes(sneak).then(sneak_enabled));

    commands.register(literal("stop").executes(|ctx: &Ctx| {
        let source = ctx.source.lock();
        source.bot.stop_pathfinding();
        source.reply("ok");
        *source.state.following_entity.lock() = None;
        Ok(1)
    }));
    commands.register(literal("forcestop").executes(|ctx: &Ctx| {
        let source = ctx.source.lock();
        source.bot.force_stop_pathfinding();
        source.reply("ok");
        *source.state.following_entity.lock() = None;
        Ok(1)
    }));
}

pub fn north(&self, z: f64) -> Vec3

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

pub fn east(&self, x: f64) -> Vec3

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

pub fn south(&self, z: f64) -> Vec3

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

pub fn west(&self, x: f64) -> Vec3

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

pub fn dot(&self, other: Vec3) -> f64

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

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

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

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

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

pub fn xz(&self) -> Vec3

Replace the Y with 0.

pub fn with_x(&self, x: f64) -> Vec3

pub fn with_y(&self, y: f64) -> Vec3

pub fn with_z(&self, z: f64) -> Vec3

pub fn length(&self) -> f64

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

pub fn to_block_pos_floor(&self) -> BlockPos

pub fn to_block_pos_ceil(&self) -> BlockPos

pub fn closer_than(&self, other: Vec3, range: f64) -> bool

Whether the distance between this point and other is less than range.

Trait Implementations

impl Clone for Position

fn clone(&self) -> Position

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for Position

where Self: 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 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<Self>>

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_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 Position

impl Debug for Position

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

Formats the value using the given formatter.

impl Default for Position

fn default() -> Position

Returns the “default value” for a type.

impl Deref for Position

type Target = Vec3

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for Position

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

Mutably dereferences the value.

impl From<&Position> for BlockPos

fn from(value: &Position) -> Self

Converts to this type from the input type.

impl From<&Position> for ChunkPos

fn from(value: &Position) -> Self

Converts to this type from the input type.

impl From<&Position> for Vec3

fn from(value: &Position) -> Self

Converts to this type from the input type.

impl From<Position> for BlockPos

fn from(value: Position) -> Self

Converts to this type from the input type.

impl From<Position> for ChunkPos

fn from(value: Position) -> Self

Converts to this type from the input type.

impl PartialEq for Position

fn eq(&self, other: &Position) -> 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 StructuralPartialEq for Position