commands (#143)

ily bby

Author: radstevee

Cargo.toml

@@ -17,6 +17,8 @@ members = [
     "src/lib/adapters/anvil",
     "src/lib/adapters/nbt",
     "src/lib/adapters/nbt",
+    "src/lib/commands",
+    "src/lib/default_commands",
     "src/lib/core",
     "src/lib/core/state",
     "src/lib/derive_macros",
@@ -88,6 +90,8 @@ debug = true
 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-commands = { path = "src/lib/commands" }
 ferrumc-general-purpose = { path = "src/lib/utils/general_purpose" }
 ferrumc-logging = { path = "src/lib/utils/logging" }
 ferrumc-macros = { path = "src/lib/derive_macros" }
@@ -106,7 +110,6 @@ ferrumc-utils = { path = "src/lib/utils" }
 ferrumc-world = { path = "src/lib/world" }
 ferrumc-world-gen = { path = "src/lib/world_gen" }
 
-
 # Asynchronous
 tokio = { version = "1.47.1", features = ["macros", "net", "rt", "sync", "time", "io-util", "test-util"], default-features = false }
 
@@ -171,6 +174,7 @@ macro_rules_attribute = "0.2.2"
 
 # Magic
 dhat = "0.3.3"
+ctor = "0.4.2"
 
 # Compression/Decompression
 flate2 = { version = "1.1.2", features = ["zlib"], default-features = false }
@@ -191,6 +195,7 @@ colored = "3.0.0"
 # Misc
 deepsize = "0.2.0"
 page_size = "0.6.0"
+enum-ordinalize = "4.3.0"
 regex = "1.11.1"
 noise = "0.9.0"
 ctrlc = "3.4.7"

src/bin/Cargo.toml

@@ -25,10 +25,11 @@ ferrumc-world = { workspace = true }
 ferrumc-macros = { workspace = true }
 ferrumc-general-purpose = { workspace = true }
 ferrumc-state = { workspace = true }
+ferrumc-commands = { workspace = true }
+ferrumc-default-commands = { workspace = true }
 ferrumc-world-gen = { workspace = true }
 ferrumc-threadpool = { workspace = true }
 
-
 tracing = { workspace = true }
 clap = { workspace = true, features = ["derive", "env"] }
 flate2 = { workspace = true }

src/bin/src/game_loop.rs

@@ -7,6 +7,7 @@ use crate::systems::shutdown_systems::register_shutdown_systems;
 use bevy_ecs::prelude::World;
 use bevy_ecs::schedule::ExecutorKind;
 use crossbeam_channel::Sender;
+use ferrumc_commands::infrastructure::register_command_systems;
 use ferrumc_config::server_config::get_global_config;
 use ferrumc_net::connection::{handle_connection, NewConnection};
 use ferrumc_net::server::create_server_listener;
@@ -37,13 +38,16 @@ pub fn start_game_loop(global_state: GlobalState) -> Result<(), BinaryError> {
     let (shutdown_send, shutdown_recv) = tokio::sync::oneshot::channel();
     let (shutdown_response_send, shutdown_response_recv) = crossbeam_channel::unbounded();
 
+    ferrumc_default_commands::init();
+
     // Register systems and resources
     let global_state_res = GlobalStateResource(global_state.clone());
 
     register_events(&mut ecs_world);
     register_resources(&mut ecs_world, new_conn_recv, global_state_res);
     register_packet_handlers(&mut schedule);
     register_player_systems(&mut schedule);
+    register_command_systems(&mut schedule);
     register_game_systems(&mut schedule);
 
     register_shutdown_systems(&mut shutdown_schedule);

src/bin/src/packet_handlers/play_packets/chat_message.rs

@@ -0,0 +1,15 @@
+use bevy_ecs::prelude::*;
+use ferrumc_core::{identity::player_identity::PlayerIdentity, mq};
+use ferrumc_net::ChatMessagePacketReceiver;
+use ferrumc_text::TextComponent;
+
+pub fn handle(events: Res<ChatMessagePacketReceiver>, query: Query<&PlayerIdentity>) {
+    for (message, sender) in events.0.try_iter() {
+        let Ok(identity) = query.get(sender) else {
+            continue;
+        };
+
+        let message = format!("<{}> {}", identity.username, message.message);
+        mq::broadcast(TextComponent::from(message), false);
+    }
+}

src/bin/src/packet_handlers/play_packets/command.rs

@@ -0,0 +1,67 @@
+use std::sync::Arc;
+
+use bevy_ecs::prelude::*;
+use ferrumc_commands::{
+    events::{CommandDispatchEvent, ResolvedCommandDispatchEvent},
+    infrastructure, Command, CommandContext, CommandInput, Sender,
+};
+use ferrumc_core::mq;
+use ferrumc_net::ChatCommandPacketReceiver;
+use ferrumc_text::{NamedColor, TextComponent, TextComponentBuilder};
+
+fn resolve(
+    input: String,
+    sender: Sender,
+) -> Result<(Arc<Command>, CommandContext), Box<TextComponent>> {
+    let command = infrastructure::find_command(&input);
+    if command.is_none() {
+        return Err(Box::new(
+            TextComponentBuilder::new("Unknown command")
+                .color(NamedColor::Red)
+                .build(),
+        ));
+    }
+
+    let command = command.unwrap();
+    let input = input
+        .strip_prefix(command.name)
+        .unwrap_or(&input)
+        .trim_start();
+    let input = CommandInput::of(input.to_string());
+    let ctx = CommandContext {
+        input: input.clone(),
+        command: command.clone(),
+        sender,
+    };
+
+    Ok((command, ctx))
+}
+
+pub fn handle(
+    events: Res<ChatCommandPacketReceiver>,
+    mut dispatch_events: EventWriter<CommandDispatchEvent>,
+    mut resolved_dispatch_events: EventWriter<ResolvedCommandDispatchEvent>,
+) {
+    for (event, entity) in events.0.try_iter() {
+        let sender = Sender::Player(entity);
+        dispatch_events.write(CommandDispatchEvent {
+            command: event.command.clone(),
+            sender,
+        });
+
+        let resolved = resolve(event.command, sender);
+        match resolved {
+            Err(err) => {
+                mq::queue(*err, false, entity);
+            }
+
+            Ok((command, ctx)) => {
+                resolved_dispatch_events.write(ResolvedCommandDispatchEvent {
+                    command,
+                    ctx,
+                    sender,
+                });
+            }
+        }
+    }
+}

src/bin/src/packet_handlers/play_packets/command_suggestions.rs

@@ -0,0 +1,130 @@
+use std::sync::Arc;
+
+use bevy_ecs::prelude::*;
+use ferrumc_commands::{Command, CommandContext, CommandInput, Sender, ROOT_COMMAND};
+use ferrumc_net::{
+    connection::StreamWriter,
+    packets::outgoing::command_suggestions::{CommandSuggestionsPacket, Match},
+    CommandSuggestionRequestReceiver,
+};
+use ferrumc_net_codec::net_types::{
+    length_prefixed_vec::LengthPrefixedVec, prefixed_optional::PrefixedOptional, var_int::VarInt,
+};
+use ferrumc_state::GlobalStateResource;
+use tracing::error;
+
+fn find_command(input: String) -> Option<Arc<Command>> {
+    let mut input = input;
+    if input.starts_with("/") {
+        input.remove(0);
+    }
+
+    if let Some(command) = ferrumc_commands::infrastructure::get_command_by_name(&input) {
+        return Some(command);
+    }
+
+    if let Some(command) = ferrumc_commands::infrastructure::find_command(&input) {
+        return Some(command);
+    }
+
+    while !input.is_empty() {
+        // remove the last word and retry
+        if let Some(pos) = input.rfind(char::is_whitespace) {
+            input.truncate(pos);
+
+            if let Some(command) = ferrumc_commands::infrastructure::get_command_by_name(&input) {
+                return Some(command);
+            }
+
+            if let Some(command) = ferrumc_commands::infrastructure::find_command(&input) {
+                return Some(command);
+            }
+        } else {
+            break; // string does not have any further words, meaning it's just whitespace?
+        }
+    }
+
+    None
+}
+
+fn create_ctx(input: String, command: Option<Arc<Command>>, sender: Sender) -> CommandContext {
+    let input = input
+        .strip_prefix(command.clone().map(|c| c.name).unwrap_or_default())
+        .unwrap_or(&input)
+        .trim_start();
+
+    let input = CommandInput::of(input.to_string());
+    CommandContext {
+        input: input.clone(),
+        command: command.unwrap_or(ROOT_COMMAND.clone()),
+        sender,
+    }
+}
+
+pub fn handle(
+    events: Res<CommandSuggestionRequestReceiver>,
+    query: Query<&StreamWriter>,
+    state: Res<GlobalStateResource>,
+) {
+    for (request, entity) in events.0.try_iter() {
+        if !state.0.players.is_connected(entity) {
+            return;
+        }
+
+        let input = request.input;
+
+        let command = find_command(input.clone());
+        let command_arg = input
+            .clone()
+            .strip_prefix(&format!(
+                "/{} ",
+                command.clone().map(|c| c.name).unwrap_or_default()
+            ))
+            .unwrap_or(&input)
+            .to_string();
+        let mut ctx = create_ctx(command_arg.clone(), command.clone(), Sender::Player(entity));
+        let command_arg = command_arg.clone(); // ok borrow checker
+        let tokens = command_arg.split(" ").collect::<Vec<&str>>();
+        let Some(current_token) = tokens.last() else {
+            return; // whitespace
+        };
+
+        let mut suggestions = Vec::new();
+
+        if let Some(command) = command {
+            for arg in command.args.clone() {
+                let arg_suggestions = (arg.suggester)(&mut ctx);
+                ctx.input.skip_whitespace(u32::MAX, true);
+                if !ctx.input.has_remaining_input() {
+                    suggestions = arg_suggestions;
+                    break;
+                }
+            }
+        }
+
+        let length = input.len();
+        let start = length - current_token.len();
+
+        if let Err(e) = query
+            .get(entity)
+            .unwrap()
+            .send_packet(CommandSuggestionsPacket {
+                transaction_id: request.transaction_id,
+                matches: LengthPrefixedVec::new(
+                    suggestions
+                        .into_iter()
+                        .filter(|sug| sug.content.starts_with(current_token))
+                        .map(|sug| Match {
+                            content: sug.content,
+                            tooltip: PrefixedOptional::new(sug.tooltip),
+                        })
+                        .collect(),
+                ),
+                length: VarInt::new(length as i32),
+                start: VarInt::new(start as i32),
+            })
+        {
+            error!("failed sending command suggestions to player: {e}")
+        }
+    }
+}

src/bin/src/packet_handlers/play_packets/mod.rs

@@ -1,6 +1,9 @@
 use bevy_ecs::schedule::Schedule;
 
+mod chat_message;
 mod chunk_batch_ack;
+mod command;
+mod command_suggestions;
 mod confirm_player_teleport;
 mod keep_alive;
 mod place_block;
@@ -26,4 +29,7 @@ pub fn register_packet_handlers(schedule: &mut Schedule) {
     schedule.add_systems(set_player_rotation::handle);
     schedule.add_systems(swing_arm::handle);
     schedule.add_systems(player_loaded::handle);
+    schedule.add_systems(command::handle);
+    schedule.add_systems(command_suggestions::handle);
+    schedule.add_systems(chat_message::handle);
 }

src/bin/src/register_events.rs

@@ -1,5 +1,6 @@
 use bevy_ecs::event::EventRegistry;
 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_net::packets::packet_events::TransformEvent;
@@ -8,4 +9,6 @@ pub fn register_events(world: &mut World) {
     EventRegistry::register_event::<TransformEvent>(world);
     EventRegistry::register_event::<CrossChunkBoundaryEvent>(world);
     EventRegistry::register_event::<ForcePlayerRecountEvent>(world);
+    EventRegistry::register_event::<CommandDispatchEvent>(world);
+    EventRegistry::register_event::<ResolvedCommandDispatchEvent>(world);
 }

src/bin/src/systems/mod.rs

@@ -1,6 +1,7 @@
 pub mod connection_killer;
 mod cross_chunk_boundary;
 mod keep_alive_system;
+mod mq;
 pub mod new_connections;
 mod player_count_update;
 pub mod send_chunks;
@@ -13,6 +14,7 @@ pub fn register_game_systems(schedule: &mut bevy_ecs::schedule::Schedule) {
     schedule.add_systems(cross_chunk_boundary::cross_chunk_boundary);
     schedule.add_systems(player_count_update::player_count_updater);
     schedule.add_systems(world_sync::sync_world);
+    schedule.add_systems(mq::process);
 
     // Should always be last
     schedule.add_systems(connection_killer::connection_killer);

src/bin/src/systems/mq.rs

@@ -0,0 +1,47 @@
+use bevy_ecs::prelude::*;
+use ferrumc_core::mq;
+use ferrumc_net::{
+    connection::StreamWriter, packets::outgoing::system_message::SystemMessagePacket,
+};
+use ferrumc_state::GlobalStateResource;
+use tracing::error;
+
+fn send(
+    writer: &StreamWriter,
+    receiver: Entity,
+    state: &GlobalStateResource,
+    entry: ferrumc_core::mq::QueueEntry,
+) {
+    if !state.0.players.is_connected(receiver) {
+        return;
+    }
+
+    if let Err(err) = writer.send_packet(SystemMessagePacket {
+        message: entry.message,
+        overlay: entry.overlay,
+    }) {
+        error!("failed sending queued message to player: {err}");
+    }
+}
+
+pub fn process(query: Query<(Entity, &StreamWriter)>, state: Res<GlobalStateResource>) {
+    while !mq::QUEUE.is_empty() {
+        let entry = mq::QUEUE.pop().unwrap();
+
+        match entry.receiver {
+            Some(receiver) => {
+                let Ok((_, writer)) = query.get(receiver) else {
+                    continue;
+                };
+
+                send(writer, receiver, &state, entry);
+            }
+
+            None => {
+                for (receiver, writer) in query {
+                    send(writer, receiver, &state, entry.clone());
+                }
+            }
+        }
+    }
+}