feat: commands and basic chat

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",
@@ -34,6 +36,7 @@ members = [
     "src/lib/utils/logging",
     "src/lib/utils/profiling",
     "src/lib/world",
+    "src/lib/entity_utils",
 ]
 
 #================== Lints ==================#
@@ -87,6 +90,8 @@ codegen-units = 1
 ferrumc-anvil = { path = "src/lib/adapters/anvil" }
 ferrumc-config = { path = "src/lib/utils/config" }
 ferrumc-core = { path = "src/lib/core" }
+ferrumc-default-commands = { path = "src/lib/default_commands" }
+ferrumc-commands = { path = "src/lib/commands" }
 ferrumc-ecs = { path = "src/lib/ecs" }
 ferrumc-events = { path = "src/lib/events"}
 ferrumc-general-purpose = { path = "src/lib/utils/general_purpose" }
@@ -103,7 +108,7 @@ ferrumc-storage = { path = "src/lib/storage" }
 ferrumc-text = { path = "src/lib/text" }
 ferrumc-utils = { path = "src/lib/utils" }
 ferrumc-world = { path = "src/lib/world" }
-
+ferrumc-entity-utils = { path = "src/lib/entity_utils" }
 
 
 # Asynchronous
@@ -156,7 +161,7 @@ whirlwind = "0.1.1"
 # Macros
 lazy_static = "1.5.0"
 quote = "1.0.37"
-syn = "2.0.77"
+syn = { version = "2.0.77", features = ["full"] }
 proc-macro2 = "1.0.86"
 proc-macro-crate = "3.2.0"
 paste = "1.0.15"
@@ -187,6 +192,7 @@ colored = "2.1.0"
 # Misc
 deepsize = "0.2.0"
 page_size = "0.6.0"
+enum-ordinalize = "4.3.0"
 regex = "1.11.1"
 
 # I/O
@@ -195,5 +201,3 @@ memmap2 = "0.9.5"
 
 # Benchmarking
 criterion = { version = "0.5.1", features = ["html_reports"] }
-
-

src/bin/Cargo.toml

@@ -26,6 +26,9 @@ ferrumc-macros = { workspace = true }
 ferrumc-nbt = { workspace = true }
 ferrumc-general-purpose = { workspace = true }
 ferrumc-state = { workspace = true }
+ferrumc-commands = { workspace = true }
+ferrumc-default-commands = { workspace = true }
+ferrumc-text = { workspace = true }
 
 parking_lot = { workspace = true, features = ["deadlock_detection"] }
 tracing = { workspace = true }

src/bin/src/main.rs

@@ -78,6 +78,9 @@ async fn entry() -> Result<()> {
     let global_state = Arc::new(state);
     create_whitelist().await;
 
+    // Needed for some reason because ctor doesn't really want to do ctor things otherwise.
+    ferrumc_default_commands::init();
+
     let all_system_handles = tokio::spawn(definition::start_all_systems(global_state.clone()));
 
     //Start the systems and wait until all of them are done

src/bin/src/packet_handlers/chat_message.rs

@@ -0,0 +1,24 @@
+use ferrumc_core::identity::player_identity::PlayerIdentity;
+use ferrumc_macros::event_handler;
+use ferrumc_net::{
+    packets::{
+        incoming::chat_message::ChatMessageEvent, outgoing::system_message::SystemMessagePacket,
+    },
+    utils::broadcast::{BroadcastOptions, BroadcastToAll},
+    NetResult,
+};
+use ferrumc_state::GlobalState;
+use ferrumc_text::TextComponentBuilder;
+
+#[event_handler]
+async fn chat_message(event: ChatMessageEvent, state: GlobalState) -> NetResult<ChatMessageEvent> {
+    let identity = state.universe.get::<PlayerIdentity>(event.player_conn_id)?;
+    let message =
+        TextComponentBuilder::new(format!("<{}> {}", identity.username, event.message)).build();
+    let packet = SystemMessagePacket::new(message, false);
+    state
+        .broadcast(&packet, BroadcastOptions::default().all())
+        .await?;
+
+    Ok(event)
+}

src/bin/src/packet_handlers/commands.rs

@@ -0,0 +1,82 @@
+use std::sync::{Arc, Mutex};
+
+use ferrumc_commands::{ctx::CommandContext, infrastructure::find_command, input::CommandInput};
+use ferrumc_macros::event_handler;
+use ferrumc_net::{
+    connection::StreamWriter,
+    errors::NetError,
+    packets::{
+        incoming::command::CommandDispatchEvent, outgoing::system_message::SystemMessagePacket,
+    },
+};
+use ferrumc_net_codec::encode::NetEncodeOpts;
+use ferrumc_state::GlobalState;
+use ferrumc_text::{NamedColor, TextComponentBuilder};
+
+#[event_handler]
+async fn handle_command_dispatch(
+    event: CommandDispatchEvent,
+    state: GlobalState,
+) -> Result<CommandDispatchEvent, NetError> {
+    let mut writer = state.universe.get_mut::<StreamWriter>(event.conn_id)?;
+
+    let command = find_command(event.command.as_str());
+    if command.is_none() {
+        writer
+            .send_packet(
+                &SystemMessagePacket::new(
+                    TextComponentBuilder::new("Unknown command")
+                        .color(NamedColor::Red)
+                        .build(),
+                    false,
+                ),
+                &NetEncodeOpts::WithLength,
+            )
+            .await?;
+        return Ok(event);
+    }
+
+    let command = command.unwrap();
+
+    let input = &event
+        .command
+        .strip_prefix(command.name)
+        .unwrap_or(&event.command)
+        .trim_start();
+    let input = CommandInput::of(input.to_string());
+    let ctx = CommandContext::new(input.clone(), command.clone(), state.clone(), event.conn_id);
+    if let Err(err) = command.validate(&ctx, &Arc::new(Mutex::new(input))) {
+        writer
+            .send_packet(
+                &SystemMessagePacket::new(
+                    TextComponentBuilder::new("Invalid arguments: ")
+                        .extra(err)
+                        .color(NamedColor::Red)
+                        .build(),
+                    false,
+                ),
+                &NetEncodeOpts::WithLength,
+            )
+            .await?;
+        return Ok(event);
+    }
+
+    drop(writer); // Avoid deadlocks if the executor accesses the stream writer
+    if let Err(err) = command.execute(ctx).await {
+        let mut writer = state.universe.get_mut::<StreamWriter>(event.conn_id)?;
+        writer
+            .send_packet(
+                &SystemMessagePacket::new(
+                    TextComponentBuilder::new("Failed executing command: ")
+                        .extra(err)
+                        .color(NamedColor::Red)
+                        .build(),
+                    false,
+                ),
+                &NetEncodeOpts::WithLength,
+            )
+            .await?;
+    };
+
+    Ok(event)
+}

src/bin/src/packet_handlers/login_process.rs

@@ -1,3 +1,4 @@
+use ferrumc_commands::graph::CommandsPacket;
 use ferrumc_config::statics::{get_global_config, get_whitelist};
 use ferrumc_core::chunks::chunk_receiver::ChunkReceiver;
 use ferrumc_core::identity::player_identity::PlayerIdentity;
@@ -202,6 +203,14 @@ async fn handle_ack_finish_configuration(
                 &NetEncodeOpts::WithLength,
             )
             .await?;
+
+        trace!(
+            "Sending command graph: {:#?}",
+            ferrumc_commands::infrastructure::get_graph()
+        );
+        writer
+            .send_packet(&CommandsPacket::create(), &NetEncodeOpts::WithLength)
+            .await?;
 
         send_keep_alive(entity_id, &state, &mut writer).await?;
 

src/bin/src/packet_handlers/mod.rs

@@ -1,3 +1,5 @@
+mod chat_message;
+mod commands;
 mod animations;
 mod handshake;
 mod login_process;

src/lib/adapters/anvil/src/lib.rs

@@ -103,7 +103,7 @@ impl LoadedAnvilFile {
             let location = (u32::from(self.table[i * 4]) << 24)
                 | (u32::from(self.table[i * 4 + 1]) << 16)
                 | (u32::from(self.table[i * 4 + 2]) << 8)
-                | u32::from(self.table[i * 4 + 3]);
+                | (u32::from(self.table[i * 4 + 3]));
             if location != 0 {
                 locations.push(location);
             }

src/lib/commands/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "ferrumc-commands"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+thiserror = { workspace = true }
+tracing = { workspace = true }
+dashmap = { workspace = true }
+tokio = { workspace = true }
+ferrumc-text = { workspace = true }
+ferrumc-state = { workspace = true }
+enum-ordinalize = { workspace = true }
+ferrumc-macros = { workspace = true }
+
+ferrumc-net-codec = { workspace = true }
+ferrumc-net = { workspace = true }
+ferrumc-config = { workspace = true }
+flate2 = { workspace = true }
+
+[dev-dependencies] # Needed for the ServerState mock... :concern:
+ferrumc-ecs = { workspace = true }
+ferrumc-world = { workspace = true }
+ctor = { workspace = true }

src/lib/commands/src/arg/mod.rs

@@ -0,0 +1,19 @@
+use parser::ArgumentParser;
+
+pub mod parser;
+
+pub struct CommandArgument {
+    pub name: String,
+    pub required: bool,
+    pub parser: Box<dyn ArgumentParser>,
+}
+
+impl CommandArgument {
+    pub fn new(name: String, required: bool, parser: Box<dyn ArgumentParser>) -> Self {
+        CommandArgument {
+            name,
+            required,
+            parser,
+        }
+    }
+}

src/lib/commands/src/arg/parser/int.rs

@@ -0,0 +1,68 @@
+use std::sync::{Arc, Mutex};
+
+use crate::{ctx::CommandContext, input::CommandInput, ParserResult};
+
+use super::{
+    utils::error,
+    vanilla::{
+        int::IntParserFlags, MinecraftArgument, MinecraftArgumentProperties, MinecraftArgumentType,
+    },
+    ArgumentParser,
+};
+
+pub struct IntParser;
+
+impl ArgumentParser for IntParser {
+    fn parse(&self, _ctx: Arc<CommandContext>, input: Arc<Mutex<CommandInput>>) -> ParserResult {
+        let token = input.lock().unwrap().read_string();
+
+        match token.parse::<i32>() {
+            Ok(int) => Ok(Box::new(int)),
+            Err(err) => Err(error(err)),
+        }
+    }
+
+    fn new() -> Self
+    where
+        Self: Sized,
+    {
+        IntParser
+    }
+
+    fn vanilla(&self) -> MinecraftArgument {
+        MinecraftArgument {
+            argument_type: MinecraftArgumentType::Int,
+            props: MinecraftArgumentProperties::Int(IntParserFlags::default()),
+        }
+    }
+
+    fn completions(
+        &self,
+        _ctx: Arc<CommandContext>,
+        input: Arc<Mutex<CommandInput>>,
+    ) -> Vec<String> {
+        let input = input.lock().unwrap();
+
+        let mut numbers = Vec::new();
+        let token = input.peek_string();
+
+        let input_num = if token == "-" {
+            "-0".to_string()
+        } else if token.is_empty() {
+            "0".to_string()
+        } else {
+            token
+        };
+
+        if input_num.parse::<i32>().is_err() {
+            return numbers;
+        }
+
+        for n in 0..=9 {
+            let n = n.to_string();
+            numbers.push(input_num.clone() + &n);
+        }
+
+        numbers
+    }
+}

src/lib/commands/src/arg/parser/mod.rs

@@ -0,0 +1,19 @@
+use std::sync::{Arc, Mutex};
+
+use crate::{ctx::CommandContext, input::CommandInput, ParserResult};
+
+pub mod int;
+pub mod string;
+pub mod utils;
+pub mod vanilla;
+
+pub trait ArgumentParser: Send + Sync {
+    fn parse(&self, ctx: Arc<CommandContext>, input: Arc<Mutex<CommandInput>>) -> ParserResult;
+    fn completions(&self, ctx: Arc<CommandContext>, input: Arc<Mutex<CommandInput>>)
+        -> Vec<String>;
+
+    fn new() -> Self
+    where
+        Self: Sized;
+    fn vanilla(&self) -> vanilla::MinecraftArgument;
+}