feat : enable to spawn an entity with /spawnpig

Author: Tonguechaude

Cargo.toml

@@ -23,6 +23,7 @@ members = [
     "src/lib/core/state",
     "src/lib/derive_macros",
     "src/lib/derive_macros",
+    "src/lib/entities",
     "src/lib/net",
     "src/lib/net/crates/codec",
     "src/lib/net/crates/encryption",
@@ -93,6 +94,7 @@ ferrumc-anvil = { path = "src/lib/adapters/anvil" }
 ferrumc-config = { path = "src/lib/config" }
 ferrumc-core = { path = "src/lib/core" }
 ferrumc-default-commands = { path = "src/lib/default_commands" }
+ferrumc-entities = { path = "src/lib/entities" }
 ferrumc-commands = { path = "src/lib/commands" }
 ferrumc-general-purpose = { path = "src/lib/utils/general_purpose" }
 ferrumc-logging = { path = "src/lib/utils/logging" }
@@ -213,4 +215,4 @@ criterion = { version = "0.7.0", features = ["html_reports"] }
 
 
 bitcode = { git = "https://github.com/SoftbearStudios/bitcode" }
-bitcode_derive = { git = "https://github.com/SoftbearStudios/bitcode" }
+bitcode_derive = { git = "https://github.com/SoftbearStudios/bitcode" }

src/bin/Cargo.toml

@@ -12,6 +12,7 @@ thiserror = { workspace = true }
 ferrumc-core = { workspace = true }
 bevy_ecs = { workspace = true }
 ferrumc-scheduler = { workspace = true }
+ferrumc-entities = { workspace = true }
 
 ferrumc-net = { workspace = true }
 ferrumc-net-codec = { workspace = true }

src/bin/src/register_events.rs

@@ -3,6 +3,7 @@ use bevy_ecs::prelude::World;
 use ferrumc_commands::events::{CommandDispatchEvent, ResolvedCommandDispatchEvent};
 use ferrumc_core::chunks::cross_chunk_boundary_event::CrossChunkBoundaryEvent;
 use ferrumc_core::conn::force_player_recount_event::ForcePlayerRecountEvent;
+use ferrumc_entities::SpawnEntityEvent;
 use ferrumc_net::packets::packet_events::TransformEvent;
 
 pub fn register_events(world: &mut World) {
@@ -11,4 +12,5 @@ pub fn register_events(world: &mut World) {
     EventRegistry::register_event::<ForcePlayerRecountEvent>(world);
     EventRegistry::register_event::<CommandDispatchEvent>(world);
     EventRegistry::register_event::<ResolvedCommandDispatchEvent>(world);
+    EventRegistry::register_event::<SpawnEntityEvent>(world);
 }

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

@@ -0,0 +1,42 @@
+use bevy_ecs::prelude::*;
+use ferrumc_core::transform::grounded::OnGround;
+use ferrumc_core::transform::position::Position;
+use ferrumc_entities::components::*;
+
+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>>,
+) {
+    for (mut pos, mut vel, on_ground) in query.iter_mut() {
+        // Apply gravity if not on ground
+        if !on_ground.0 {
+            vel.y = (vel.y + GRAVITY).max(TERMINAL_VELOCITY);
+        } else {
+            // Reset velocity Y if on ground
+            if vel.y < 0.0 {
+                vel.y = 0.0;
+            }
+        }
+
+        pos.x += vel.x;
+        pos.y += vel.y;
+        pos.z += vel.z;
+
+        if on_ground.0 {
+            vel.x *= 0.6;
+            vel.z *= 0.6;
+        } else {
+            vel.x *= 0.98;
+            vel.z *= 0.98;
+        }
+    }
+}
+
+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_spawner.rs

@@ -0,0 +1,43 @@
+use bevy_ecs::prelude::*;
+use ferrumc_core::transform::position::Position;
+use ferrumc_entities::components::SyncedToPlayers;
+use ferrumc_entities::types::passive::pig::PigBundle;
+use ferrumc_entities::SpawnEntityEvent;
+use ferrumc_state::GlobalStateResource;
+use tracing::info;
+
+/// System that listen spawn event and create entity
+pub fn entity_spawner_system(
+    mut commands: Commands,
+    mut spawn_events: EventReader<SpawnEntityEvent>,
+    _global_state: Res<GlobalStateResource>,
+) {
+    for event in spawn_events.read() {
+        // Generate new entity ID
+        let entity_id = generate_entity_id();
+
+        match event.entity_type {
+            ferrumc_entities::components::EntityType::Pig => {
+                let pig = PigBundle::new(
+                    entity_id,
+                    Position::new(event.position.x, event.position.y, event.position.z),
+                );
+                commands.spawn((pig, SyncedToPlayers::default()));
+                info!("Spawned pig at {:?}", event.position);
+            }
+            _ => {
+                tracing::warn!("Entity type {:?} not yet implemented", event.entity_type);
+            }
+        }
+    }
+}
+
+// TODO: Implémente true ID generator
+static mut NEXT_ENTITY_ID: i32 = 1000;
+fn generate_entity_id() -> i32 {
+    unsafe {
+        let id = NEXT_ENTITY_ID;
+        NEXT_ENTITY_ID += 1;
+        id
+    }
+}

src/bin/src/systems/entities/entity_sync.rs

@@ -0,0 +1,78 @@
+use bevy_ecs::prelude::*;
+use ferrumc_core::identity::player_identity::PlayerIdentity;
+use ferrumc_core::transform::position::Position;
+use ferrumc_core::transform::rotation::Rotation;
+use ferrumc_entities::components::*; // Includes SyncedToPlayers
+use ferrumc_entities::types::passive::pig::EntityUuid;
+use ferrumc_net::connection::StreamWriter;
+use ferrumc_net::packets::outgoing::spawn_entity::SpawnEntityPacket;
+use tracing::{debug, error};
+
+/// System that send new entities to players
+pub fn entity_sync_system(
+    // All non-player entities they needed to be sync
+    mut entity_query: Query<
+        (
+            Entity,
+            &EntityType,
+            &EntityId,
+            &EntityUuid,
+            &Position,
+            &Rotation,
+            &mut SyncedToPlayers,
+        ),
+        Without<PlayerIdentity>,
+    >,
+
+    // All connected players
+    player_query: Query<(Entity, &StreamWriter, &Position), With<PlayerIdentity>>,
+) {
+    for (entity, entity_type, entity_id, entity_uuid, pos, rot, mut synced) in
+        entity_query.iter_mut()
+    {
+        for (player_entity, stream_writer, player_pos) in player_query.iter() {
+            // Skip if already send to the player
+            if synced.player_entities.contains(&player_entity) {
+                continue;
+            }
+
+            // TODO: Check distance (render distance)
+            let distance = ((pos.x - player_pos.x).powi(2) + (pos.z - player_pos.z).powi(2)).sqrt();
+
+            if distance > 128.0 {
+                // 8 chunks de distance
+                continue;
+            }
+
+            // Create and send spawn packet
+            let protocol_id = entity_type.protocol_id();
+            debug!(
+                "Spawning {:?} (protocol_id={}) at ({:.2}, {:.2}, {:.2}) for player {:?}",
+                entity_type, protocol_id, pos.x, pos.y, pos.z, player_entity
+            );
+
+            let spawn_packet = SpawnEntityPacket::entity(
+                entity_id.0,
+                entity_uuid.0.as_u128(),
+                protocol_id,
+                pos,
+                rot,
+            );
+
+            if let Err(e) = stream_writer.send_packet(spawn_packet) {
+                error!("Failed to send spawn packet: {:?}", e);
+                continue;
+            }
+
+            // TODO: Send EntityMetadataPacket here to properly display the entity
+            // The EntityMetadata constructors are not publicly exported yet
+            // This might be why the pig appears as a phantom!
+
+            synced.player_entities.push(player_entity);
+            debug!(
+                "Successfully sent entity {:?} (ID: {}) to player {:?}",
+                entity, entity_id.0, player_entity
+            );
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+use bevy_ecs::prelude::*;
+use ferrumc_entities::types::passive::pig_data::PigData;
+use ferrumc_entities::GameEntity;
+use ferrumc_state::GlobalStateResource;
+
+/// System that ticks pig entities to update their AI/behavior
+pub fn pig_tick_system(
+    mut pigs: Query<&mut PigData>,
+    state: Res<GlobalStateResource>,
+    mut commands: Commands,
+) {
+    for mut pig_data in pigs.iter_mut() {
+        pig_data.tick(&state.0, &mut commands);
+    }
+}

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

@@ -0,0 +1,19 @@
+pub mod entity_movement;
+pub mod entity_spawner;
+pub mod entity_sync;
+pub mod entity_tick;
+pub mod spawn_command_processor;
+
+use bevy_ecs::schedule::Schedule;
+
+/// Save all systems bind to entities
+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,
+        entity_movement::entity_age_system,
+        entity_sync::entity_sync_system,
+    ));
+}

src/bin/src/systems/entities/spawn_command_processor.rs

@@ -0,0 +1,35 @@
+use bevy_ecs::prelude::*;
+use ferrumc_core::transform::position::Position;
+use ferrumc_entities::{drain_spawn_requests, SpawnEntityEvent};
+use tracing::{debug, warn};
+
+/// System that processes spawn commands from the queue and sends spawn events
+pub fn spawn_command_processor_system(
+    query: Query<&Position>,
+    mut spawn_events: EventWriter<SpawnEntityEvent>,
+) {
+    let requests = drain_spawn_requests();
+
+    for request in requests {
+        // Get player position
+        if let Ok(pos) = query.get(request.player_entity) {
+            // Spawn entity slightly in front of the player (2 blocks away)
+            let spawn_pos = Position::new(pos.x + 2.0, pos.y, pos.z + 2.0);
+
+            debug!(
+                "Processing spawn command: {:?} at ({:.2}, {:.2}, {:.2})",
+                request.entity_type, spawn_pos.x, spawn_pos.y, spawn_pos.z
+            );
+
+            spawn_events.write(SpawnEntityEvent {
+                entity_type: request.entity_type,
+                position: spawn_pos,
+            });
+        } else {
+            warn!(
+                "Failed to get position for entity {:?}",
+                request.player_entity
+            );
+        }
+    }
+}

src/bin/src/systems/mod.rs

@@ -1,5 +1,6 @@
 pub mod connection_killer;
 mod cross_chunk_boundary;
+pub mod entities;
 pub mod keep_alive_system;
 pub mod lan_pinger;
 mod mq;
@@ -15,7 +16,7 @@ pub fn register_game_systems(schedule: &mut bevy_ecs::schedule::Schedule) {
     schedule.add_systems(new_connections::accept_new_connections);
     schedule.add_systems(cross_chunk_boundary::cross_chunk_boundary);
     schedule.add_systems(mq::process);
-
+    entities::register_entity_systems(schedule);
     // Should always be last
     schedule.add_systems(connection_killer::connection_killer);
 }