core: make usage hints more colorful

Author: Paul1365972

crates/core/src/commands/builtin/core.rs

@@ -6,7 +6,7 @@ use crate::plot::Plot;
 use crate::server::Message;
 use crate::worldedit::ray_trace_block;
 use crate::{
-    player::{Gamemode, PacketSender, PlayerPos},
+    player::{Gamemode, PlayerPos},
     plot::database,
 };
 use mchprs_blocks::items::ItemStack;
@@ -417,15 +417,17 @@ pub(super) fn register_commands(registry: &mut CommandRegistry) {
             let msg =
                 "Redpiler optimization is highly unstable and can break builds. Use with caution!";
             tracing::warn!("{}", msg);
-            ctx.player()?.send_system_message(msg);
+            ctx.reply(msg)?;
         }
 
         ctx.plot.reset_redpiler();
         let start_time = Instant::now();
         ctx.plot.start_redpiler(options);
         let duration = start_time.elapsed();
-        debug!("Compile took {:?}", duration);
-        ctx.reply(&format!("Compilation completed in {:?}", duration))
+        let msg = format!("Compilation completed in {:?}", duration);
+        debug!(msg);
+        ctx.reply(&msg)?;
+        Ok(())
     }
 
     let redpiler_flag_arg = ArgumentType::flags()

crates/core/src/commands/builtin/mod.rs

@@ -50,20 +50,20 @@ fn register_help(registry: &mut CommandRegistry) {
                 | parser::ParseResult::TooManyArguments { path, .. }
                 | parser::ParseResult::InvalidArgument { path, .. } => {
                     let usage = usage::generate_usage(&path);
-                    ctx.reply(&format!("Usage: {}", usage))?;
+                    ctx.reply_legacy(&format!("&6Usage: &e{}", usage))?;
                     let flag_details = usage::generate_flag_details(path.last().unwrap());
                     if !flag_details.is_empty() {
-                        ctx.reply("Available flags:")?;
+                        ctx.reply_legacy("&6Available flags:")?;
                         for flag in flag_details {
                             let flag_part = match flag.short {
-                                Some(short) => format!("-{} | --{}", short, flag.long),
-                                None => format!("--{}", flag.long),
+                                Some(short) => format!("&a-{} &e| &a--{}", short, flag.long),
+                                None => format!("&a--{}", flag.long),
                             };
                             let flag_details = match &flag.description {
-                                Some(desc) => format!(" {} ({})", flag_part, desc),
+                                Some(desc) => format!(" {}&e: {}", flag_part, desc),
                                 None => format!(" {}", flag_part),
                             };
-                            ctx.reply(&flag_details)?;
+                            ctx.reply_legacy(&flag_details)?;
                         }
                     }
                 }

crates/core/src/commands/context.rs

@@ -4,6 +4,7 @@ use crate::player::{PacketSender, Player};
 use crate::plot::{Plot, PlotWorld};
 use crate::worldedit::{create_clipboard, WorldEditClipboard, WorldEditUndo};
 use mchprs_blocks::BlockPos;
+use mchprs_text::TextComponent;
 
 pub struct ExecutionContext<'a> {
     pub plot: &'a mut Plot,
@@ -48,6 +49,19 @@ impl<'a> ExecutionContext<'a> {
         Ok(())
     }
 
+    pub fn reply_legacy(&self, message: &str) -> CommandResult<()> {
+        match &self.sender {
+            CommandSender::Player(_) => {
+                let components = TextComponent::from_legacy_text(message);
+                self.player()?.send_chat_message(&components);
+            }
+            CommandSender::Console => {
+                println!("{}", message);
+            }
+        }
+        Ok(())
+    }
+
     pub fn has_permission(&self, permission: &str) -> bool {
         match &self.sender {
             CommandSender::Player(_) => {

crates/core/src/commands/error.rs

@@ -63,3 +63,18 @@ impl CommandError {
 }
 
 pub type CommandResult<T> = Result<T, CommandError>;
+
+pub(crate) trait UnwrapRuntimeError<T> {
+    fn unwrap_runtime(self) -> Result<T, InternalError>;
+}
+
+impl<T> UnwrapRuntimeError<T> for CommandResult<T> {
+    fn unwrap_runtime(self) -> Result<T, InternalError> {
+        self.map_err(|err| match err {
+            CommandError::Runtime(err) => InternalError::Message {
+                message: format!("Runtime Error: {}", err),
+            },
+            CommandError::Internal(err) => err,
+        })
+    }
+}

crates/core/src/commands/executor.rs

@@ -2,7 +2,7 @@ use crate::{
     commands::{
         argument_set::ArgumentSet,
         context::ExecutionContext,
-        error::{CommandError, CommandResult, InternalError},
+        error::{CommandError, CommandResult, InternalError, UnwrapRuntimeError},
         node::CommandNode,
         parser::{self, ParseResult},
         registry::CommandRegistry,
@@ -36,7 +36,7 @@ impl CommandRegistry {
                 match Self::execute_impl(&mut ctx, node, &path) {
                     Ok(()) => Ok(()),
                     Err(CommandError::Runtime(err)) => {
-                        Self::send_error(&ctx, &err.to_string())?;
+                        ctx.error(&err.to_string()).unwrap_runtime()?;
                         Ok(())
                     }
                     Err(CommandError::Internal(err)) => Err(err),
@@ -62,7 +62,7 @@ impl CommandRegistry {
 
             ParseResult::NothingMatched { .. } => {
                 let ctx = ExecutionContext::new(plot, sender, ArgumentSet::empty());
-                Self::send_error(&ctx, "Command not found!")?;
+                ctx.error("Command not found!").unwrap_runtime()?;
                 Ok(())
             }
         }
@@ -116,26 +116,18 @@ impl CommandRegistry {
     ) -> Result<(), InternalError> {
         let ctx = ExecutionContext::new(plot, sender, ArgumentSet::empty());
 
-        Self::send_error(&ctx, error_message)?;
+        ctx.error(error_message).unwrap_runtime()?;
 
         let usage = usage::generate_usage(path);
-        Self::send_error(&ctx, &usage)?;
+        ctx.reply_legacy(&format!("&6Usage: &e{}", usage))
+            .unwrap_runtime()?;
         let base_name = usage::generate_base_name(path);
-        Self::send_error(
-            &ctx,
-            &format!("Run /help {base_name} for more information."),
-        )?;
+        ctx.reply_legacy(&format!(
+            "&eRun &e/help {}&e for more information.",
+            base_name
+        ))
+        .unwrap_runtime()?;
 
         Ok(())
     }
-
-    fn send_error(ctx: &ExecutionContext<'_>, message: &str) -> Result<(), InternalError> {
-        match ctx.error(message) {
-            Ok(()) => Ok(()),
-            Err(CommandError::Internal(err)) => Err(err),
-            Err(CommandError::Runtime(_)) => {
-                unreachable!("ExecutionContext::error should never return a runtime error")
-            }
-        }
-    }
 }