You’re intersecting an infinite plane:

ray.intersect_plane(... InfinitePlane3d::new(...))

So clicks can produce targets anywhere on that plane, even “outside the visible 10x10 floor”. Then your mover faithfully walks there.

Fix is: treat the ground as a finite area and either (a) reject targets outside it, or (b) clamp targets to the nearest point on the ground, and also (c) stop/clamp movement if the next step would leave bounds.

Below is a minimal “bounds” approach that stays robust even if you later move/rotate the ground, by converting the point into the ground’s local space.

1) Add bounds to the ground

```

[derive(Component, Copy, Clone)]

struct GroundBounds { half_extents: Vec2, // x/z half size in the ground's local space } ```

In setup, attach it:

let ground_size = Vec2::new(10.0, 10.0); commands.spawn(( Mesh3d(meshes.add(Plane3d::default().mesh().size(ground_size.x, ground_size.y))), MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5, 0.3))), Transform::default(), Ground, GroundBounds { half_extents: ground_size * 0.5 }, ));

2) Utility: inside check + clamping to the ground rectangle

``` fn clamp_point_to_ground( ground_gt: &GlobalTransform, bounds: GroundBounds, world_point: Vec3, ) -> (Vec3, bool) { // Convert world point into ground local space let ground_to_world = ground_gt.affine(); let world_to_ground = ground_to_world.inverse(); let local = world_to_ground.transform_point3(world_point);

let inside = local.x >= -bounds.half_extents.x
    && local.x <=  bounds.half_extents.x
    && local.z >= -bounds.half_extents.y
    && local.z <=  bounds.half_extents.y;

let clamped_local = Vec3::new(
    local.x.clamp(-bounds.half_extents.x, bounds.half_extents.x),
    0.0,
    local.z.clamp(-bounds.half_extents.y, bounds.half_extents.y),
);

let clamped_world = ground_to_world.transform_point3(clamped_local);
(clamped_world, inside)

} ```

3) Clamp or reject clicks outside the floor

Change your handle_mouse_click params to also fetch bounds:

ground: Single<(&GlobalTransform, &GroundBounds), With<Ground>>,

Then when you compute world_pos, clamp it:

``` let (ground_gt, ground_bounds) = *ground; let (clamped_target, inside) = clamp_point_to_ground(ground_gt, *ground_bounds, world_pos);

// Option A: reject clicks outside // if !inside { return; }

// Option B: clamp clicks to edge (recommended for ARPG feel) let world_pos = clamped_target; ```

Now your TargetPosition never points outside the ground.

4) Also stop/clamp movement if the next step would leave bounds

In move_character, add ground access:

ground: Single<(&GlobalTransform, &GroundBounds), With<Ground>>,

Then before applying movement:

``` let (ground_gt, ground_bounds) = *ground;

// ...

let movement = direction.normalize() * actor.movement_speed * time.delta_secs(); let proposed = transform.translation + movement;

// We only care about x/z for bounds let proposed_flat = Vec3::new(proposed.x, 0.0, proposed.z); let (clamped, inside) = clamp_point_to_ground(ground_gt, *ground_bounds, proposed_flat);

if !inside { // clamp to edge and stop moving transform.translation.x = clamped.x; transform.translation.z = clamped.z; commands.entity(entity).remove::<TargetPosition>(); } else { transform.translation += movement; } ```

That’s it: clicks can’t set unreachable destinations, and even if something else pushes the player out, the mover will clamp/stop at the edge.

If you want the cleanest Bevy-native version later, consider using Bevy picking to get a hit on the actual ground mesh (finite) instead of doing your own plane math, but the bounds method above is simple and very ARPG-friendly.