feat: packet handling functions

Cargo.toml

@@ -28,6 +28,7 @@ members = [
     'crates/hyperion-item',
     'crates/hyperion-minecraft-proto',
     'crates/hyperion-nerd-font',
+    'crates/hyperion-packet-macros',
     'crates/hyperion-palette',
     'crates/hyperion-permission',
     'crates/hyperion-proto',
@@ -182,6 +183,9 @@ path = 'crates/hyperion-item'
 [workspace.dependencies.hyperion-nerd-font]
 path = 'crates/hyperion-nerd-font'
 
+[workspace.dependencies.hyperion-packet-macros]
+path = 'crates/hyperion-packet-macros'
+
 [workspace.dependencies.hyperion-palette]
 path = 'crates/hyperion-palette'
 

crates/hyperion-clap/src/lib.rs

@@ -8,7 +8,7 @@ use flecs_ecs::{
 use hyperion::{
     net::{Compose, ConnectionId, DataBundle, agnostic},
     simulation::{IgnMap, command::get_root_command_entity, handlers::PacketSwitchQuery},
-    storage::{CommandCompletionRequest, EventFn},
+    storage::CommandCompletionRequest,
 };
 pub use hyperion_clap_macros::CommandPermission;
 pub use hyperion_command;
@@ -111,7 +111,7 @@ pub trait MinecraftCommand: Parser + CommandPermission {
             };
         };
 
-        let on_tab_complete: EventFn<CommandCompletionRequest<'static>> = Box::new(
+        let on_tab_complete = Box::new(
             |packet_switch_query: &mut PacketSwitchQuery<'_>,
              completion: &CommandCompletionRequest<'_>| {
                 let full_query = completion.query;

crates/hyperion-command/Cargo.toml

@@ -9,6 +9,7 @@ publish = false
 [dependencies]
 flecs_ecs = { workspace = true }
 hyperion = { workspace = true }
+hyperion-utils = { workspace = true }
 indexmap = { workspace = true }
 tracing = { workspace = true }
 

crates/hyperion-command/src/component.rs

@@ -3,12 +3,14 @@ use flecs_ecs::{
     macros::Component,
     prelude::Module,
 };
-use hyperion::storage::{CommandCompletionRequest, EventFn};
+use hyperion::{simulation::handlers::PacketSwitchQuery, storage::CommandCompletionRequest};
 use indexmap::IndexMap;
 
+pub type OnTabComplete =
+    Box<dyn Fn(&mut PacketSwitchQuery<'_>, &CommandCompletionRequest<'_>) + 'static + Send + Sync>;
 pub struct CommandHandler {
     pub on_execute: fn(input: &str, system: EntityView<'_>, caller: Entity),
-    pub on_tab_complete: EventFn<CommandCompletionRequest<'static>>,
+    pub on_tab_complete: OnTabComplete,
     pub has_permissions: fn(world: &World, caller: Entity) -> bool,
 }
 

crates/hyperion-command/src/system.rs

@@ -7,9 +7,10 @@ use flecs_ecs::{
 };
 use hyperion::{
     net::agnostic,
-    simulation::event,
-    storage::{EventQueue, GlobalEventHandlers},
+    simulation::{event, handlers::PacketSwitchQuery, packet::HandlerRegistry},
+    storage::{CommandCompletionRequest, EventQueue},
 };
+use hyperion_utils::LifetimeHandle;
 
 use crate::component::CommandRegistry;
 
@@ -21,14 +22,15 @@ impl Module for CommandSystemModule {
         system!(
             "execute_command",
             world,
-            &mut EventQueue<event::Command<'_>>($),
+            &mut EventQueue<event::Command>($),
             &CommandRegistry($)
         )
         .each_iter(|it, _, (event_queue, registry)| {
             let system = it.system();
 
             let world = it.world();
             for event::Command { raw, by } in event_queue.drain() {
+                let raw = raw.get();
                 let Some(first_word) = raw.split_whitespace().next() else {
                     tracing::warn!("command is empty");
                     continue;
@@ -65,30 +67,36 @@ impl Module for CommandSystemModule {
             }
         });
 
-        world.get::<&mut GlobalEventHandlers>(|handlers| {
-            handlers.completion.register(|query, completion| {
-                let input = completion.query;
-
-                // should be in form "/{command}"
-                let command = input
-                    .strip_prefix("/")
-                    .unwrap_or(input)
-                    .split_whitespace()
-                    .next()
-                    .unwrap_or("");
-
-                if command.is_empty() {
-                    return;
-                }
-
-                query.world.get::<&CommandRegistry>(|registry| {
-                    let Some(cmd) = registry.commands.get(command) else {
-                        return;
-                    };
-                    let on_tab = &cmd.on_tab_complete;
-                    on_tab(query, completion);
-                });
-            });
+        world.get::<&mut HandlerRegistry>(|registry| {
+            registry.add_handler(Box::new(
+                |completion: &CommandCompletionRequest<'_>,
+                 _: &dyn LifetimeHandle<'_>,
+                 query: &mut PacketSwitchQuery<'_>| {
+                    let input = completion.query;
+
+                    // should be in form "/{command}"
+                    let command = input
+                        .strip_prefix("/")
+                        .unwrap_or(input)
+                        .split_whitespace()
+                        .next()
+                        .unwrap_or("");
+
+                    if command.is_empty() {
+                        return Ok(());
+                    }
+
+                    query.world.get::<&CommandRegistry>(|registry| {
+                        let Some(cmd) = registry.commands.get(command) else {
+                            return;
+                        };
+                        let on_tab = &cmd.on_tab_complete;
+                        on_tab(query, completion);
+                    });
+
+                    Ok(())
+                },
+            ));
         });
     }
 }

crates/hyperion-event-macros/src/lib.rs

@@ -2,7 +2,7 @@ use convert_case::{Case, Casing};
 use proc_macro::TokenStream;
 use quote::{format_ident, quote};
 use syn::{
-    Lifetime, Token, Type,
+    Token, Type,
     parse::{Parse, ParseStream, Result},
     parse_macro_input,
     punctuated::Punctuated,
@@ -40,19 +40,16 @@ impl Parse for EventsInput {
     }
 }
 
-/// Struct representing a single event type, possibly with a lifetime
+/// Struct representing a single event type
 struct EventType {
     path: syn::Ident,
     ty: Type,
-    lifetime: Option<Lifetime>,
     ident: syn::Ident,
 }
 
 impl EventType {
     /// Extracts necessary components from a `syn::Type`
     fn from_type(ty: Type) -> Result<Self> {
-        let mut lifetime = None;
-
         let Type::Path(type_path) = &ty else {
             return Err(syn::Error::new(ty.span(), "expected a path"));
         };
@@ -69,12 +66,14 @@ impl EventType {
         let ident = last_segment.ident.clone();
         let generics = last_segment.arguments.clone();
 
-        // Extract lifetime if present
         if let syn::PathArguments::AngleBracketed(args) = &generics {
             for generic_arg in &args.args {
                 if let syn::GenericArgument::Lifetime(l) = generic_arg {
-                    lifetime = Some(l.clone());
-                    break;
+                    return Err(syn::Error::new(
+                        l.span(),
+                        "lifetimes are not allowed in events, consider using \
+                         hyperion_utils::RuntimeLifetime to store references",
+                    ));
                 }
             }
         }
@@ -88,12 +87,7 @@ impl EventType {
 
         let path = first_segment.ident.clone();
 
-        Ok(Self {
-            path,
-            ty,
-            lifetime,
-            ident,
-        })
+        Ok(Self { path, ty, ident })
     }
 
     /// Generates the field definition for the Events struct
@@ -125,50 +119,16 @@ impl EventType {
         let field_name = self.ident.to_string().to_case(Case::Snake);
         let field_ident = format_ident!("{field_name}");
 
-        if self.lifetime.is_some() {
-            quote! {
-                impl Event for #path::#ident<'static> {
-                    fn input(elem: Self, events: &Events, world: &World) {
-                        unsafe {
-                            (*events.#field_ident.0).push(elem, world);
-                        }
-                    }
-                }
-
-                impl sealed::Sealed for #path::#ident<'static> {}
-
-                impl ReducedLifetime for #path::#ident<'static> {
-                    type Reduced<'a> = #path::#ident<'a>
-                    where
-                        Self: 'a;
-
-                    fn reduce<'a>(self) -> Self::Reduced<'a> {
-                        self
+        quote! {
+            impl Event for #path::#ident {
+                fn input(elem: Self, events: &Events, world: &World) {
+                    unsafe {
+                        (*events.#field_ident.0).push(elem, world);
                     }
                 }
             }
-        } else {
-            quote! {
-                impl Event for #path::#ident {
-                    fn input(elem: Self, events: &Events, world: &World) {
-                        unsafe {
-                            (*events.#field_ident.0).push(elem, world);
-                        }
-                    }
-                }
-
-                impl sealed::Sealed for #path::#ident {}
-
-                impl ReducedLifetime for #path::#ident {
-                    type Reduced<'a> = Self
-                    where
-                        Self: 'a;
 
-                    fn reduce<'a>(self) -> Self::Reduced<'a> {
-                        self
-                    }
-                }
-            }
+            impl sealed::Sealed for #path::#ident {}
         }
     }
 }

crates/hyperion-gui/Cargo.toml

@@ -4,8 +4,10 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
+anyhow = { workspace = true }
 flecs_ecs = { workspace = true }
 hyperion = { workspace = true }
+hyperion-utils = { workspace = true }
 serde = { version = "1.0", features = ["derive"] }
 valence_protocol = { workspace = true }