feat : add very basic AI for pig

Author: Tonguechaude

src/bin/src/systems/entities/entity_movement.rs

@@ -2,13 +2,15 @@ use bevy_ecs::prelude::*;
 use ferrumc_core::transform::grounded::OnGround;
 use ferrumc_core::transform::position::Position;
 use ferrumc_entities::components::*;
+use ferrumc_state::GlobalStateResource;
 
 const GRAVITY: f64 = -0.08; // Blocks per tick^2
 const TERMINAL_VELOCITY: f64 = -3.92; // Max fall speed
 
 /// System that apply basic physics to entity
 pub fn entity_physics_system(
     mut query: Query<(&mut Position, &mut Velocity, &OnGround), With<EntityType>>,
+    state: Res<GlobalStateResource>,
 ) {
     for (mut pos, mut vel, on_ground) in query.iter_mut() {
         // Apply gravity if not on ground
@@ -21,20 +23,121 @@ pub fn entity_physics_system(
             }
         }
 
-        pos.x += vel.x;
-        pos.y += vel.y;
-        pos.z += vel.z;
+        // Try to move in all three axes, checking collision at the final position
+        let new_x = pos.x + vel.x;
+        let new_y = pos.y + vel.y;
+        let new_z = pos.z + vel.z;
+
+        // Check collision at the new position (considering all movement)
+        if !check_collision(&state.0, new_x, new_y, new_z) {
+            // No collision, move freely
+            pos.x = new_x;
+            pos.y = new_y;
+            pos.z = new_z;
+        } else {
+            // Collision detected, try each axis separately
+
+            // Try Y movement first (jumping/falling)
+            if !check_collision(&state.0, pos.x, new_y, pos.z) {
+                pos.y = new_y;
+            } else {
+                vel.y = 0.0;
+            }
+
+            // Try X movement with updated Y position
+            if !check_collision(&state.0, new_x, pos.y, pos.z) {
+                pos.x = new_x;
+            } else {
+                vel.x = 0.0;
+            }
+
+            // Try Z movement with updated X and Y positions
+            if !check_collision(&state.0, pos.x, pos.y, new_z) {
+                pos.z = new_z;
+            } else {
+                vel.z = 0.0;
+            }
+        }
 
         if on_ground.0 {
-            vel.x *= 0.6;
-            vel.z *= 0.6;
+            // Less friction on ground for better movement (was 0.6)
+            vel.x *= 0.85;
+            vel.z *= 0.85;
         } else {
             vel.x *= 0.98;
             vel.z *= 0.98;
         }
     }
 }
 
+/// Check if the entity would collide with a block at the given position
+fn check_collision(state: &ferrumc_state::GlobalState, x: f64, y: f64, z: f64) -> bool {
+    // Pig hitbox is approximately 0.9 x 0.9 x 0.9 blocks
+    let half_width = 0.45;
+    let height = 0.9;
+
+    // Check corners of the bounding box at feet and head level
+    let check_positions = [
+        // Feet level - 4 corners
+        (
+            (x - half_width).floor() as i32,
+            y.floor() as i32,
+            (z - half_width).floor() as i32,
+        ),
+        (
+            (x + half_width).floor() as i32,
+            y.floor() as i32,
+            (z - half_width).floor() as i32,
+        ),
+        (
+            (x - half_width).floor() as i32,
+            y.floor() as i32,
+            (z + half_width).floor() as i32,
+        ),
+        (
+            (x + half_width).floor() as i32,
+            y.floor() as i32,
+            (z + half_width).floor() as i32,
+        ),
+        // Head level - 4 corners
+        (
+            (x - half_width).floor() as i32,
+            (y + height).floor() as i32,
+            (z - half_width).floor() as i32,
+        ),
+        (
+            (x + half_width).floor() as i32,
+            (y + height).floor() as i32,
+            (z - half_width).floor() as i32,
+        ),
+        (
+            (x - half_width).floor() as i32,
+            (y + height).floor() as i32,
+            (z + half_width).floor() as i32,
+        ),
+        (
+            (x + half_width).floor() as i32,
+            (y + height).floor() as i32,
+            (z + half_width).floor() as i32,
+        ),
+    ];
+
+    for (check_x, check_y, check_z) in check_positions {
+        if let Ok(block_state) =
+            state
+                .world
+                .get_block_and_fetch(check_x, check_y, check_z, "overworld")
+        {
+            // If there's a solid block, collision detected
+            if block_state.0 != 0 {
+                return true;
+            }
+        }
+    }
+
+    false
+}
+
 pub fn entity_age_system(mut query: Query<&mut Age, With<EntityType>>) {
     for mut age in query.iter_mut() {
         age.tick();

src/bin/src/systems/entities/entity_movement_sync.rs

@@ -0,0 +1,61 @@
+use bevy_ecs::prelude::*;
+use ferrumc_core::identity::player_identity::PlayerIdentity;
+use ferrumc_core::transform::grounded::OnGround;
+use ferrumc_core::transform::position::Position;
+use ferrumc_core::transform::rotation::Rotation;
+use ferrumc_entities::components::*;
+use ferrumc_net::connection::StreamWriter;
+use ferrumc_net::packets::outgoing::update_entity_position_and_rotation::UpdateEntityPositionAndRotationPacket;
+use ferrumc_net_codec::net_types::var_int::VarInt;
+use tracing::error;
+
+/// System that syncs entity movement to players
+pub fn entity_movement_sync_system(
+    mut entities: Query<
+        (
+            &EntityId,
+            &Position,
+            &Rotation,
+            &OnGround,
+            &SyncedToPlayers,
+            &mut LastSyncedPosition,
+        ),
+        (With<EntityType>, Without<PlayerIdentity>),
+    >,
+    players: Query<&StreamWriter, With<PlayerIdentity>>,
+) {
+    for (entity_id, pos, rot, on_ground, synced, mut last_pos) in entities.iter_mut() {
+        // Only sync if entity has moved
+        if !last_pos.has_moved(pos) {
+            continue;
+        }
+
+        let delta = last_pos.delta_to(pos);
+
+        // Send update to all players who have this entity spawned
+        for player_entity in &synced.player_entities {
+            if let Ok(stream_writer) = players.get(*player_entity) {
+                let packet = UpdateEntityPositionAndRotationPacket {
+                    entity_id: VarInt::new(entity_id.to_network_id()),
+                    delta_x: delta.0,
+                    delta_y: delta.1,
+                    delta_z: delta.2,
+                    yaw: ferrumc_net_codec::net_types::angle::NetAngle::from_degrees(
+                        rot.yaw as f64,
+                    ),
+                    pitch: ferrumc_net_codec::net_types::angle::NetAngle::from_degrees(
+                        rot.pitch as f64,
+                    ),
+                    on_ground: on_ground.0,
+                };
+
+                if let Err(e) = stream_writer.send_packet(packet) {
+                    error!("Failed to send entity movement packet: {:?}", e);
+                }
+            }
+        }
+
+        // Update last synced position
+        *last_pos = LastSyncedPosition::from_position(pos);
+    }
+}

src/bin/src/systems/entities/entity_spawner.rs

@@ -18,7 +18,10 @@ pub fn entity_spawner_system(
         event
             .entity_type
             .spawn(&mut commands, entity_id, &event.position);
-        info!("Spawned {:?} at {:?}", event.entity_type, event.position);
+        info!(
+            "Spawned {:?} with ID {} at ({:.2}, {:.2}, {:.2})",
+            event.entity_type, entity_id, event.position.x, event.position.y, event.position.z
+        );
     }
 }
 

src/bin/src/systems/entities/entity_tick.rs

@@ -1,15 +1,100 @@
 use bevy_ecs::prelude::*;
+use ferrumc_core::transform::grounded::OnGround;
+use ferrumc_core::transform::position::Position;
+use ferrumc_core::transform::rotation::Rotation;
+use ferrumc_entities::components::Velocity;
 use ferrumc_entities::types::passive::pig_data::PigData;
 use ferrumc_entities::GameEntity;
 use ferrumc_state::GlobalStateResource;
+use rand::Rng;
 
 /// System that ticks pig entities to update their AI/behavior
 pub fn pig_tick_system(
-    mut pigs: Query<&mut PigData>,
+    mut pigs: Query<(
+        &mut PigData,
+        &mut Velocity,
+        &mut Rotation,
+        &Position,
+        &OnGround,
+    )>,
     state: Res<GlobalStateResource>,
     mut commands: Commands,
 ) {
-    for mut pig_data in pigs.iter_mut() {
+    for (mut pig_data, mut velocity, mut rotation, position, on_ground) in pigs.iter_mut() {
+        // Call the entity's tick method for entity-specific behavior
         pig_data.tick(&state.0, &mut commands);
+
+        // Basic AI: Random wandering when on ground
+        if on_ground.0 {
+            let mut rng = rand::rng();
+
+            // Check for obstacle first - if blocked, try to jump or change direction
+            if should_avoid_obstacle(&state.0, position, velocity.x, velocity.z) {
+                // 50% chance to try jumping over obstacle, 50% chance to turn around
+                if rng.random_bool(0.5) && velocity.y.abs() < 0.01 {
+                    velocity.y = 0.42; // Jump to try to get over obstacle
+                } else {
+                    // Pick a new random direction when hitting a wall
+                    let angle = rng.random_range(0.0..std::f64::consts::TAU);
+                    velocity.x = angle.cos() * 0.25;
+                    velocity.z = angle.sin() * 0.25;
+                    rotation.yaw = (-velocity.x.atan2(velocity.z).to_degrees()) as f32;
+                }
+            } else {
+                // Only 1% chance to change direction when not blocked (less rotation)
+                if rng.random_bool(0.01) {
+                    let angle = rng.random_range(0.0..std::f64::consts::TAU);
+                    velocity.x = angle.cos() * 0.25;
+                    velocity.z = angle.sin() * 0.25;
+                    rotation.yaw = (-velocity.x.atan2(velocity.z).to_degrees()) as f32;
+                }
+            }
+        }
     }
 }
+
+/// Check if there's an obstacle in the movement direction
+fn should_avoid_obstacle(
+    state: &ferrumc_state::GlobalState,
+    pos: &Position,
+    vel_x: f64,
+    vel_z: f64,
+) -> bool {
+    // Pig hitbox is approximately 0.9 x 0.9 x 0.9 blocks
+    // Check multiple points around the entity's bounding box
+
+    let check_distance = 0.6; // Look slightly ahead
+    let next_x = pos.x + vel_x.signum() * check_distance;
+    let next_z = pos.z + vel_z.signum() * check_distance;
+
+    // Check at feet level and head level (entity is ~0.9 blocks tall)
+    let check_positions = [
+        // Feet level
+        (
+            next_x.floor() as i32,
+            pos.y.floor() as i32,
+            next_z.floor() as i32,
+        ),
+        // Head level
+        (
+            next_x.floor() as i32,
+            (pos.y + 0.5).floor() as i32,
+            next_z.floor() as i32,
+        ),
+    ];
+
+    for (check_x, check_y, check_z) in check_positions {
+        if let Ok(block_state) =
+            state
+                .world
+                .get_block_and_fetch(check_x, check_y, check_z, "overworld")
+        {
+            // If there's a solid block, obstacle detected
+            if block_state.0 != 0 {
+                return true;
+            }
+        }
+    }
+
+    false
+}

src/bin/src/systems/entities/ground_check.rs

@@ -0,0 +1,34 @@
+use bevy_ecs::prelude::*;
+use ferrumc_core::transform::grounded::OnGround;
+use ferrumc_core::transform::position::Position;
+use ferrumc_entities::EntityType;
+use ferrumc_state::GlobalStateResource;
+
+/// System that checks if entities are on the ground
+/// Updates the OnGround component based on the block below the entity
+pub fn ground_check_system(
+    mut query: Query<(&Position, &mut OnGround), With<EntityType>>,
+    state: Res<GlobalStateResource>,
+) {
+    for (pos, mut on_ground) in query.iter_mut() {
+        let block_x = pos.x.floor() as i32;
+        let block_y = (pos.y - 0.1).floor() as i32; // Slightly below feet
+        let block_z = pos.z.floor() as i32;
+
+        match state
+            .0
+            .world
+            .get_block_and_fetch(block_x, block_y, block_z, "overworld")
+        {
+            Ok(block_state) => {
+                // Block ID 0 is air, anything else is solid
+                // TODO: Check for specific non-solid blocks (water, lava, tall grass, etc.)
+                on_ground.0 = block_state.0 != 0;
+            }
+            Err(_) => {
+                // Chunk not loaded, assume in air
+                on_ground.0 = false;
+            }
+        }
+    }
+}

src/bin/src/systems/entities/mod.rs

@@ -1,7 +1,9 @@
 pub mod entity_movement;
+pub mod entity_movement_sync;
 pub mod entity_spawner;
 pub mod entity_sync;
 pub mod entity_tick;
+pub mod ground_check;
 pub mod spawn_command_processor;
 
 use bevy_ecs::schedule::Schedule;
@@ -11,9 +13,11 @@ pub fn register_entity_systems(schedule: &mut Schedule) {
     schedule.add_systems((
         spawn_command_processor::spawn_command_processor_system, // Process spawn commands from /spawnpig
         entity_spawner::entity_spawner_system,
-        entity_tick::pig_tick_system, // Tick AI/behavior for pigs
-        entity_movement::entity_physics_system,
+        ground_check::ground_check_system, // Check if entities are on ground
+        entity_tick::pig_tick_system,      // Tick AI/behavior for pigs
+        entity_movement::entity_physics_system, // Apply physics (gravity, movement)
         entity_movement::entity_age_system,
-        entity_sync::entity_sync_system,
+        entity_sync::entity_sync_system, // Sync new entities to clients
+        entity_movement_sync::entity_movement_sync_system, // Sync entity movement to clients
     ));
 }