feat(hyperion)!: hardcoded SystemId → auto SystemOrder (#661)

Introduces a new `system-order` module to manage system execution
ordering dynamically, removing hardcoded system IDs throughout the
codebase. Key changes:

- Add a new `system-order` crate with depth-based ordering logic
- Update system execution to use `EntityView` for system context
- Replace `SystemId` constants with dynamic `SystemOrder` values
- Update packet handling APIs to receive system context instead of IDs
- Refactor bundle management to include system context
- Remove redundant world parameters where system context provides it
- Fixes #510 

Breaking: APIs using `SystemId` must be updated to use the new
`SystemOrder` system

Author: andrewgazelka

Cargo.lock

@@ -1,3 +1,4 @@
+[profile]
 [profile.release-debug]
 debug = true
 inherits = 'release'
@@ -36,6 +37,7 @@ members = [
   'crates/hyperion-item',
   'crates/geometry',
   'crates/simd-utils',
+  'crates/system-order',
 ]
 resolver = '2'
 
@@ -83,7 +85,7 @@ quote = '1.0.37'
 rand = '0.8.5'
 rayon = '1.10.0'
 rkyv = '0.8.8'
-rustc-hash = '2.0.0'
+rustc-hash = { version = '2.0.0' , features = ["nightly"] }
 serde = '1.0.214'
 serde_json = '1.0.117'
 slotmap = '1.0.7'
@@ -203,6 +205,9 @@ version = '0.10.8'
 [workspace.dependencies.simd-utils]
 path = 'crates/simd-utils'
 
+[workspace.dependencies.system-order]
+path = 'crates/system-order'
+
 [workspace.dependencies.tokio-util]
 features = ['full']
 version = '0.7.12'
@@ -255,19 +260,17 @@ branch = 'feat-open'
 git = 'https://github.com/andrewgazelka/valence'
 
 [workspace.lints]
-
 [workspace.lints.clippy]
 cast_precision_loss = 'allow'
 future_not_send = 'allow'
 missing_errors_doc = 'allow'
 missing_panics_doc = 'allow'
 module_name_repetitions = 'allow'
+print_stdout = 'deny'
 single_match_else = 'allow'
 too_long_first_doc_paragraph = 'allow'
 too_many_lines = 'allow'
 
-print_stdout = 'deny'
-
 [workspace.lints.clippy.complexity]
 level = 'deny'
 priority = -1

Cargo.toml

@@ -2,14 +2,13 @@ use std::iter::zip;
 
 use clap::{Arg as ClapArg, Parser, ValueEnum, ValueHint, error::ErrorKind};
 use flecs_ecs::{
-    core::{Entity, EntityViewGet, World, WorldGet},
+    core::{Entity, EntityView, EntityViewGet, World, WorldGet, WorldProvider},
     prelude::{Component, Module},
 };
 use hyperion::{
     net::{Compose, ConnectionId, DataBundle, agnostic},
     simulation::{IgnMap, command::get_root_command_entity, handlers::PacketSwitchQuery},
     storage::{CommandCompletionRequest, EventFn},
-    system_registry::SystemId,
 };
 pub use hyperion_clap_macros::CommandPermission;
 pub use hyperion_command;
@@ -24,7 +23,7 @@ use valence_protocol::{
 };
 
 pub trait MinecraftCommand: Parser + CommandPermission {
-    fn execute(self, world: &World, caller: Entity);
+    fn execute(self, system: EntityView<'_>, caller: Entity);
 
     fn pre_register(_world: &World) {}
 
@@ -60,8 +59,9 @@ pub trait MinecraftCommand: Parser + CommandPermission {
             on = world.entity().set(node_to_register).child_of_id(on);
         }
 
-        let on_execute = |input: &str, world: &World, caller: Entity| {
+        let on_execute = |input: &str, system: EntityView<'_>, caller: Entity| {
             let input = input.split_whitespace();
+            let world = system.world();
 
             match Self::try_parse_from(input) {
                 Ok(elem) => {
@@ -75,16 +75,16 @@ pub trait MinecraftCommand: Parser + CommandPermission {
                                         "§cYou do not have permission to use this command!",
                                     );
 
-                                    let mut bundle = DataBundle::new(compose);
-                                    bundle.add_packet(&chat, world).unwrap();
-                                    bundle.send(world, *stream, SystemId(8)).unwrap();
+                                    let mut bundle = DataBundle::new(compose, system);
+                                    bundle.add_packet(&chat).unwrap();
+                                    bundle.send(*stream).unwrap();
 
                                     false
                                 }
                             },
                         )
                     }) {
-                        elem.execute(world, caller);
+                        elem.execute(system, caller);
                     }
                 }
                 Err(e) => {
@@ -102,7 +102,7 @@ pub trait MinecraftCommand: Parser + CommandPermission {
                             .entity_view(world)
                             .get::<&hyperion::net::ConnectionId>(|stream| {
                                 let msg = agnostic::chat(msg);
-                                compose.unicast(&msg, *stream, SystemId(8), world).unwrap();
+                                compose.unicast(&msg, *stream, system).unwrap();
                             });
                     });
 
@@ -181,8 +181,7 @@ pub trait MinecraftCommand: Parser + CommandPermission {
                         .unicast(
                             &packet,
                             packet_switch_query.io_ref,
-                            SystemId(0),
-                            packet_switch_query.world,
+                            packet_switch_query.system,
                         )
                         .unwrap();
 
@@ -224,8 +223,7 @@ pub trait MinecraftCommand: Parser + CommandPermission {
                     .unicast(
                         &packet,
                         packet_switch_query.io_ref,
-                        SystemId(0),
-                        packet_switch_query.world,
+                        packet_switch_query.system,
                     )
                     .unwrap();
             },
@@ -297,7 +295,8 @@ pub enum PermissionCommand {
 }
 
 impl MinecraftCommand for PermissionCommand {
-    fn execute(self, world: &World, caller: Entity) {
+    fn execute(self, system: EntityView<'_>, caller: Entity) {
+        let world = system.world();
         world.get::<&IgnMap>(|ign_map| {
             match self {
                 Self::Set(cmd) => {
@@ -307,7 +306,7 @@ impl MinecraftCommand for PermissionCommand {
                             let msg = format!("§c{} not found", cmd.player);
                             let chat = hyperion::net::agnostic::chat(msg);
                             world.get::<&Compose>(|compose| {
-                                compose.unicast(&chat, *stream, SystemId(8), world).unwrap();
+                                compose.unicast(&chat, *stream, system).unwrap();
                             });
                         });
                         return;
@@ -326,7 +325,7 @@ impl MinecraftCommand for PermissionCommand {
                             );
                             let chat = hyperion::net::agnostic::chat(msg);
                             world.get::<&Compose>(|compose| {
-                                compose.unicast(&chat, *stream, SystemId(8), world).unwrap();
+                                compose.unicast(&chat, *stream, system).unwrap();
                             });
                         });
                     });
@@ -337,7 +336,7 @@ impl MinecraftCommand for PermissionCommand {
                             let msg = format!("§c{} not found", cmd.player);
                             let chat = hyperion::net::agnostic::chat(msg);
                             world.get::<&Compose>(|compose| {
-                                compose.unicast(&chat, *stream, SystemId(8), world).unwrap();
+                                compose.unicast(&chat, *stream, system).unwrap();
                             });
                         });
                         return;
@@ -348,7 +347,7 @@ impl MinecraftCommand for PermissionCommand {
                             let msg = format!("§b{}§r's group is §e{:?}", cmd.player, group);
                             let chat = hyperion::net::agnostic::chat(msg);
                             world.get::<&Compose>(|compose| {
-                                compose.unicast(&chat, *stream, SystemId(8), world).unwrap();
+                                compose.unicast(&chat, *stream, system).unwrap();
                             });
                         });
                     });

crates/hyperion-clap/src/lib.rs

@@ -1,13 +1,13 @@
 use flecs_ecs::{
-    core::{Entity, World},
+    core::{Entity, EntityView, World},
     macros::Component,
     prelude::Module,
 };
 use hyperion::storage::{CommandCompletionRequest, EventFn};
 use indexmap::IndexMap;
 
 pub struct CommandHandler {
-    pub on_execute: fn(input: &str, world: &World, caller: Entity),
+    pub on_execute: fn(input: &str, system: EntityView<'_>, caller: Entity),
     pub on_tab_complete: EventFn<CommandCompletionRequest<'static>>,
     pub has_permissions: fn(world: &World, caller: Entity) -> bool,
 }

crates/hyperion-command/src/component.rs

@@ -9,7 +9,6 @@ use hyperion::{
     net::agnostic,
     simulation::event,
     storage::{EventQueue, GlobalEventHandlers},
-    system_registry::SystemId,
 };
 
 use crate::component::CommandRegistry;
@@ -26,6 +25,8 @@ impl Module for CommandSystemModule {
             &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 Some(first_word) = raw.split_whitespace().next() else {
@@ -50,9 +51,7 @@ impl Module for CommandSystemModule {
                     world.get::<&hyperion::net::Compose>(|compose| {
                         by.entity_view(world)
                             .get::<&hyperion::net::ConnectionId>(|stream| {
-                                compose
-                                    .unicast(&chat, *stream, SystemId(8), &world)
-                                    .unwrap();
+                                compose.unicast(&chat, *stream, system).unwrap();
                             });
                     });
 
@@ -62,7 +61,7 @@ impl Module for CommandSystemModule {
                 tracing::debug!("executing command {first_word}");
 
                 let command = command.on_execute;
-                command(raw, &world, by);
+                command(raw, system, by);
             }
         });
 

crates/hyperion-command/src/system.rs

@@ -2,11 +2,10 @@
 
 use std::{borrow::Cow, cell::Cell, collections::HashMap};
 
-use flecs_ecs::core::{Entity, EntityViewGet, World, WorldGet};
+use flecs_ecs::core::{Entity, EntityView, EntityViewGet, WorldGet, WorldProvider};
 use hyperion::{
     net::{Compose, ConnectionId},
     storage::GlobalEventHandlers,
-    system_registry::SystemId,
     valence_protocol::{
         ItemStack, VarInt,
         packets::play::{
@@ -105,7 +104,7 @@ impl Gui {
         Ok(())
     }
 
-    pub fn draw<'a>(&'a self, world: &World, player: Entity) {
+    pub fn draw<'a>(&'a self, system: EntityView<'_>, player: Entity) {
         let container_items: Cow<'a, [ItemStack]> = (0..self.size)
             .map(|slot| {
                 self.items
@@ -123,37 +122,42 @@ impl Gui {
             carried_item: Cow::Borrowed(&binding),
         };
 
+        let world = system.world();
+
         world.get::<&Compose>(|compose| {
             player.entity_view(world).get::<&ConnectionId>(|stream| {
                 compose
-                    .unicast(&set_content_packet, *stream, SystemId(8), world)
+                    .unicast(&set_content_packet, *stream, system)
                     .unwrap();
             });
         });
     }
 
-    pub fn open(&mut self, world: &World, player: Entity) {
+    pub fn open(&mut self, system: EntityView<'_>, player: Entity) {
         let open_screen_packet = OpenScreenS2c {
             window_id: VarInt(i32::from(self.window_id)),
             window_type: self.get_window_type(),
             window_title: self.title.clone().into_cow_text(),
         };
 
+        let world = system.world();
+
         world.get::<&Compose>(|compose| {
             player.entity_view(world).get::<&ConnectionId>(|stream| {
                 compose
-                    .unicast(&open_screen_packet, *stream, SystemId(8), world)
+                    .unicast(&open_screen_packet, *stream, system)
                     .unwrap();
             });
         });
 
-        self.draw(world, player);
+        self.draw(system, player);
 
         world.get::<&mut GlobalEventHandlers>(|event_handlers| {
             let window_id = self.window_id;
             let items = self.items.clone();
             let gui = self.clone();
             event_handlers.click.register(move |query, event| {
+                let system = query.system;
                 let button = event.mode;
 
                 if event.window_id != window_id {
@@ -166,7 +170,7 @@ impl Gui {
                 };
 
                 (item.on_click)(player, button);
-                gui.draw(query.world, player);
+                gui.draw(query.system, player);
 
                 let inventory = &*query.inventory;
                 let compose = query.compose;
@@ -183,7 +187,7 @@ impl Gui {
                 };
 
                 compose
-                    .unicast(&set_content_packet, stream, SystemId(8), query.world)
+                    .unicast(&set_content_packet, stream, system)
                     .unwrap();
             });
         });

crates/hyperion-gui/src/lib.rs

@@ -1,16 +1,13 @@
 use clap::ValueEnum;
 use flecs_ecs::{
-    core::{
-        EntityViewGet, QueryBuilderImpl, SystemAPI, TermBuilderImpl, World, WorldGet, WorldProvider,
-    },
+    core::{EntityViewGet, QueryBuilderImpl, SystemAPI, TermBuilderImpl, World, WorldGet},
     macros::{Component, observer},
     prelude::{Module, flecs},
 };
 use hyperion::{
     net::{Compose, ConnectionId},
     simulation::{Player, Uuid, command::get_command_packet},
     storage::LocalDb,
-    system_registry::SystemId,
 };
 use num_derive::{FromPrimitive, ToPrimitive};
 
@@ -65,18 +62,18 @@ impl Module for PermissionModule {
                 permissions.set(**uuid, *group).unwrap();
             });
 
-        observer!(world, flecs::OnSet, &Group).each_entity(|entity, _group| {
-            let world = entity.world();
+        observer!(world, flecs::OnSet, &Group).each_iter(|it, row, _group| {
+            let system = it.system();
+            let world = it.world();
+            let entity = it.entity(row);
 
             let root_command = hyperion::simulation::command::get_root_command_entity();
 
             let cmd_pkt = get_command_packet(&world, root_command, Some(*entity));
 
             entity.get::<&ConnectionId>(|stream| {
                 world.get::<&Compose>(|compose| {
-                    compose
-                        .unicast(&cmd_pkt, *stream, SystemId(999), &world)
-                        .unwrap();
+                    compose.unicast(&cmd_pkt, *stream, system).unwrap();
                 });
             });
         });