feat: bows 🏹 (#666)

Please someone fix Velocity, Yaw, and Pitch. It was working before
systems so im not sure what could've broken it.

Author: Tebarem

crates/hyperion/src/egress/sync_entity_state.rs

@@ -237,7 +237,7 @@ impl Module for EntityStateSyncModule {
                         entity_id,
                         #[allow(clippy::cast_possible_truncation)]
                         delta: (position_delta * 4096.0).to_array().map(|x| x as i16),
-                        on_ground: false,
+                        on_ground: velocity.velocity == Vec3::ZERO,
                     };
 
                     compose

crates/hyperion/src/simulation/bow.rs

@@ -0,0 +1,34 @@
+use std::time::{Duration, SystemTime};
+
+use flecs_ecs::prelude::*;
+
+#[derive(Component, Debug)]
+pub struct BowCharging {
+    pub start_time: SystemTime,
+}
+
+impl Default for BowCharging {
+    fn default() -> Self {
+        Self {
+            start_time: SystemTime::now(),
+        }
+    }
+}
+
+impl BowCharging {
+    #[must_use]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    #[must_use]
+    pub fn get_charge(&self) -> f32 {
+        let elapsed = self.start_time.elapsed().unwrap_or(Duration::ZERO);
+        let secs = elapsed.as_secs_f32();
+        // Minecraft bow charge mechanics:
+        // - Takes 1 second to fully charge
+        // - Minimum charge is 0.0
+        // - Maximum charge is 1.0
+        secs.min(1.0)
+    }
+}

crates/hyperion/src/simulation/event.rs

@@ -5,7 +5,7 @@ use flecs_ecs::{core::Entity, macros::Component};
 use glam::{IVec3, Vec3};
 use valence_generated::block::BlockState;
 use valence_protocol::Hand;
-use valence_server::entity::item_frame::ItemStack;
+use valence_server::{ItemKind, entity::item_frame::ItemStack};
 
 use crate::simulation::skin::PlayerSkin;
 
@@ -77,6 +77,12 @@ pub struct SwingArm {
     pub hand: Hand,
 }
 
+#[derive(Copy, Clone, Debug)]
+pub struct ReleaseUseItem {
+    pub from: Entity,
+    pub item: ItemKind,
+}
+
 pub struct PluginMessage<'a> {
     pub channel: &'a str,
     pub data: &'a [u8],

crates/hyperion/src/simulation/handlers.rs

@@ -3,7 +3,7 @@
 use std::borrow::Cow;
 
 use anyhow::{Context, bail};
-use flecs_ecs::core::{Entity, EntityView, World};
+use flecs_ecs::core::{Entity, EntityView, EntityViewGet, World};
 use geometry::aabb::Aabb;
 use glam::{IVec3, Vec3};
 use hyperion_utils::EntityExt;
@@ -27,6 +27,7 @@ use super::{
     animation::{self, ActiveAnimation},
     block_bounds,
     blocks::Blocks,
+    bow::BowCharging,
 };
 use crate::{
     net::{Compose, ConnectionId, decoder::BorrowedPacketFrame},
@@ -276,6 +277,14 @@ fn player_action(mut data: &[u8], query: &PacketSwitchQuery<'_>) -> anyhow::Resu
 
             query.events.push(event, query.world);
         }
+        PlayerAction::ReleaseUseItem => {
+            let event = event::ReleaseUseItem {
+                from: query.id,
+                item: query.inventory.get_cursor().item,
+            };
+
+            query.events.push(event, query.world);
+        }
         action => bail!("unimplemented {action:?}"),
     }
 
@@ -328,10 +337,20 @@ pub fn player_interact_item(
 
     let cursor = query.inventory.get_cursor();
 
-    if !cursor.is_empty() && cursor.item == ItemKind::WrittenBook {
-        let packet = play::OpenWrittenBookS2c { hand };
-
-        query.compose.unicast(&packet, query.io_ref, query.system)?;
+    if !cursor.is_empty() {
+        if cursor.item == ItemKind::WrittenBook {
+            let packet = play::OpenWrittenBookS2c { hand };
+            query.compose.unicast(&packet, query.io_ref, query.system)?;
+        } else if cursor.item == ItemKind::Bow {
+            // Start charging bow
+            let entity = query.world.entity_from_id(query.id);
+            entity.get::<Option<&BowCharging>>(|charging| {
+                if charging.is_some() {
+                    return;
+                }
+                entity.set(BowCharging::new());
+            });
+        }
     }
 
     query.handlers.interact.trigger_all(query, &event);

crates/hyperion/src/simulation/mod.rs

@@ -2,6 +2,7 @@ use std::{borrow::Borrow, collections::HashMap, hash::Hash, num::TryFromIntError
 
 use anyhow::Context;
 use blocks::Blocks;
+use bow::BowCharging;
 use bytemuck::{Pod, Zeroable};
 use derive_more::{Constructor, Deref, DerefMut, Display, From};
 use flecs_ecs::prelude::*;
@@ -29,6 +30,7 @@ use crate::{
 
 pub mod animation;
 pub mod blocks;
+pub mod bow;
 pub mod command;
 pub mod entity_kind;
 pub mod event;
@@ -634,6 +636,8 @@ impl Module for SimModule {
 
         world.component::<hyperion_inventory::PlayerInventory>();
 
+        world.component::<BowCharging>();
+
         observer!(
             world,
             Spawn,
@@ -709,49 +713,53 @@ impl Module for SimModule {
         .kind::<flecs::pipeline::OnStore>()
         .with_enum_wildcard::<EntityKind>()
         .each_entity(|entity, (position, yaw, pitch, velocity)| {
-            if velocity.velocity != Vec3::ZERO {
-                // Update position based on velocity with delta time
-                position.x += velocity.velocity.x;
-                position.y += velocity.velocity.y;
-                position.z += velocity.velocity.z;
-
-                // re calculate yaw and pitch based on velocity
-                let (new_yaw, new_pitch) = get_rotation_from_velocity(velocity.velocity);
-                *yaw = Yaw::new(new_yaw);
-                *pitch = Pitch::new(new_pitch);
-
-                let ray = entity.get::<(&Position, &Yaw, &Pitch)>(|(position, yaw, pitch)| {
-                    let center = **position;
-
-                    let direction = get_direction_from_rotation(**yaw, **pitch);
-
-                    geometry::ray::Ray::new(center, direction)
-                });
-
-                entity.world().get::<&mut Blocks>(|blocks| {
-                    // calculate distance limit based on velocity
-                    let distance_limit = velocity.velocity.length();
-                    let Some(collision) = blocks.first_collision(ray, distance_limit) else {
-                        velocity.velocity.x *= 0.99;
-                        velocity.velocity.z *= 0.99;
-
-                        velocity.velocity.y -= 0.005;
-                        return;
-                    };
-                    debug!("distance_limit = {}", distance_limit);
-
-                    debug!("collision = {collision:?}");
-
-                    velocity.velocity = Vec3::ZERO;
-
-                    // Set arrow position to the collision location
-                    **position = collision.normal;
-
-                    blocks
-                        .set_block(collision.location, BlockState::DIRT)
-                        .unwrap();
-                });
-            }
+            entity.get::<&EntityKind>(|kind| {
+                if kind == &EntityKind::Arrow && velocity.velocity != Vec3::ZERO {
+                    // Update position based on velocity with delta time
+                    position.x += velocity.velocity.x;
+                    position.y += velocity.velocity.y;
+                    position.z += velocity.velocity.z;
+
+                    // re calculate yaw and pitch based on velocity
+                    let (new_yaw, new_pitch) = get_rotation_from_velocity(velocity.velocity);
+                    *yaw = Yaw::new(new_yaw);
+                    *pitch = Pitch::new(new_pitch);
+
+                    let ray = entity.get::<(&Position, &Yaw, &Pitch)>(|(position, yaw, pitch)| {
+                        let center = **position;
+
+                        let direction = get_direction_from_rotation(**yaw, **pitch);
+
+                        geometry::ray::Ray::new(center, direction)
+                    });
+
+                    #[allow(clippy::excessive_nesting)]
+                    entity.world().get::<&mut Blocks>(|blocks| {
+                        // calculate distance limit based on velocity
+                        let distance_limit = velocity.velocity.length();
+                        let Some(collision) = blocks.first_collision(ray, distance_limit) else {
+                            // i think this velocity calculations are all wrong someone redo please
+                            velocity.velocity.x *= 0.99;
+                            velocity.velocity.z *= 0.99;
+
+                            velocity.velocity.y -= 0.05;
+                            return;
+                        };
+                        debug!("distance_limit = {}", distance_limit);
+
+                        debug!("collision = {collision:?}");
+
+                        velocity.velocity = Vec3::ZERO;
+
+                        // Set arrow position to the collision location
+                        **position = collision.normal;
+
+                        blocks
+                            .set_block(collision.location, BlockState::DIRT)
+                            .unwrap();
+                    });
+                }
+            });
         });
     }
 }

crates/hyperion/src/storage/event/queue/mod.rs

@@ -56,7 +56,8 @@ define_events! {
     event::PluginMessage<'static>,
     event::PostureUpdate,
     event::SwingArm,
-    event::ToggleDoor
+    event::ToggleDoor,
+    event::ReleaseUseItem,
 }
 
 pub trait ReducedLifetime {

events/tag/src/command.rs

@@ -2,11 +2,12 @@ use flecs_ecs::core::World;
 use hyperion_clap::{MinecraftCommand, hyperion_command::CommandRegistry};
 
 use crate::command::{
-    class::ClassCommand, fly::FlyCommand, gui::GuiCommand, raycast::RaycastCommand,
-    replace::ReplaceCommand, shoot::ShootCommand, spawn::SpawnCommand, speed::SpeedCommand,
-    xp::XpCommand,
+    bow::BowCommand, class::ClassCommand, fly::FlyCommand, gui::GuiCommand,
+    raycast::RaycastCommand, replace::ReplaceCommand, shoot::ShootCommand, spawn::SpawnCommand,
+    speed::SpeedCommand, xp::XpCommand,
 };
 
+mod bow;
 mod class;
 mod fly;
 mod gui;
@@ -18,6 +19,7 @@ mod speed;
 mod xp;
 
 pub fn register(registry: &mut CommandRegistry, world: &World) {
+    BowCommand::register(registry, world);
     ClassCommand::register(registry, world);
     FlyCommand::register(registry, world);
     RaycastCommand::register(registry, world);

events/tag/src/command/bow.rs

@@ -0,0 +1,32 @@
+use clap::Parser;
+use flecs_ecs::core::{Entity, EntityView, EntityViewGet, WorldProvider};
+use hyperion::{ItemKind, ItemStack};
+use hyperion_clap::{CommandPermission, MinecraftCommand};
+use hyperion_inventory::PlayerInventory;
+
+#[derive(Parser, CommandPermission, Debug)]
+#[command(name = "bow")]
+#[command_permission(group = "Normal")]
+pub struct BowCommand;
+
+impl MinecraftCommand for BowCommand {
+    fn execute(self, system: EntityView<'_>, caller: Entity) {
+        let world = system.world();
+
+        caller
+            .entity_view(world)
+            .get::<&mut PlayerInventory>(|inventory| {
+                inventory.try_add_item(ItemStack {
+                    item: ItemKind::Bow,
+                    count: 1,
+                    nbt: None,
+                });
+
+                inventory.try_add_item(ItemStack {
+                    item: ItemKind::Arrow,
+                    count: 64,
+                    nbt: None,
+                });
+            });
+    }
+}

events/tag/src/lib.rs

@@ -27,7 +27,7 @@ use spatial::SpatialIndex;
 use tracing::debug;
 
 use crate::{
-    module::{chat::ChatModule, spawn::SpawnModule, stats::StatsModule},
+    module::{bow::BowModule, chat::ChatModule, spawn::SpawnModule, stats::StatsModule},
     skin::SkinModule,
 };
 
@@ -91,6 +91,7 @@ impl Module for TagModule {
         world.import::<BlockModule>();
         world.import::<AttackModule>();
         world.import::<LevelModule>();
+        world.import::<BowModule>();
         world.import::<RegenerationModule>();
         world.import::<hyperion_permission::PermissionModule>();
         world.import::<hyperion_utils::HyperionUtilsModule>();

events/tag/src/module.rs

@@ -1,5 +1,6 @@
 pub mod attack;
 pub mod block;
+pub mod bow;
 pub mod chat;
 pub mod level;
 pub mod regeneration;