Merge branch 'development' of github.com:ImperaZim/EasyLibrary into development

Author: ImperaZim

src/imperazim/command/Command.php

@@ -16,6 +16,7 @@
 use imperazim\command\constraint\PermissionConstraint;
 use imperazim\command\result\CommandResult;
 use imperazim\command\result\CommandFailure;
+use imperazim\command\HelpGenerator;
 
 /**
  * Abstract base class for custom commands.
@@ -30,6 +31,15 @@ abstract class Command extends PMMPCommand {
   /** @var Plugin The plugin that owns this command */
   private readonly Plugin $plugin;
 
+  /** @var array Custom messages for command failures */
+  private array $messages = [];
+
+  /** @var float|null Command cooldown in seconds */
+  private ?float $cooldown = null;
+
+  /** @var array Last usage timestamps per sender */
+  private static array $cooldowns = [];
+
   /**
    * Constructor.
    *
@@ -44,6 +54,12 @@ public function __construct(Plugin $plugin) {
     $aliases = $config["aliases"] ?? [];
     $permission = $config["permission"] ?? DefaultPermissions::ROOT_USER;
 
+    // Store custom messages
+    $this->messages = $config["messages"] ?? [];
+
+    // Store cooldown if provided
+    $this->cooldown = $config["cooldown"] ?? null;
+
     parent::__construct(
       $name,
       $description,
@@ -81,6 +97,96 @@ public function getPlugin(): Plugin {
     return $this->plugin;
   }
 
+  /**
+   * Gets a custom message by key.
+   *
+   * @param string $key The message key
+   * @param string $default Default message if key not found
+   * @return string The message
+   */
+  public function getMessage(string $key, string $default = ""): string {
+    return $this->messages[$key] ?? $default;
+  }
+
+  /**
+   * Sets a custom message.
+   *
+   * @param string $key The message key
+   * @param string $message The message text
+   */
+  public function setMessage(string $key, string $message): void {
+    $this->messages[$key] = $message;
+  }
+
+  /**
+   * Generates help text for this command.
+   *
+   * @param string $format The format style (detailed, compact, usage)
+   * @return string The help text
+   */
+  public function getHelp(string $format = "detailed"): string {
+    return HelpGenerator::generate($this, $format);
+  }
+
+  /**
+   * Checks if sender is on cooldown.
+   *
+   * @param CommandSender $sender The sender to check
+   * @return bool True if on cooldown
+   */
+  private function isOnCooldown(CommandSender $sender): bool {
+    if ($this->cooldown === null) {
+      return false;
+    }
+
+    $name = $sender->getName();
+    $key = $this->getName() . ":" . $name;
+
+    if (!isset(self::$cooldowns[$key])) {
+      return false;
+    }
+
+    $elapsed = microtime(true) - self::$cooldowns[$key];
+    return $elapsed < $this->cooldown;
+  }
+
+  /**
+   * Gets remaining cooldown time.
+   *
+   * @param CommandSender $sender The sender to check
+   * @return float Remaining seconds
+   */
+  private function getRemainingCooldown(CommandSender $sender): float {
+    if ($this->cooldown === null) {
+      return 0.0;
+    }
+
+    $name = $sender->getName();
+    $key = $this->getName() . ":" . $name;
+
+    if (!isset(self::$cooldowns[$key])) {
+      return 0.0;
+    }
+
+    $elapsed = microtime(true) - self::$cooldowns[$key];
+    return max(0.0, $this->cooldown - $elapsed);
+  }
+
+  /**
+   * Updates sender's cooldown.
+   *
+   * @param CommandSender $sender The sender
+   */
+  private function updateCooldown(CommandSender $sender): void {
+    if ($this->cooldown === null) {
+      return;
+    }
+
+    $name = $sender->getName();
+    $key = $this->getName() . ":" . $name;
+    self::$cooldowns[$key] = microtime(true);
+  }
+
   /**
    * Executes the command.
    *
@@ -93,8 +199,18 @@ public function execute(
     string $label,
     array $rawArgs
   ): void {
+    // Check cooldown
+    if ($this->isOnCooldown($sender)) {
+      $remaining = $this->getRemainingCooldown($sender);
+      $this->onFailure(
+        new CommandFailure($sender, CommandFailure::COOLDOWN, [
+          "remaining" => $remaining,
+        ])
+      );
+      return;
+    }
     // Handle subcommands
-    if (!empty($rawArgs)) {
+    if (!empty($rawArgs) && !empty($this->getSubCommands())) {
       $key = strtolower(array_shift($rawArgs));
       foreach ($this->getSubCommands() as $sub) {
         $name = $sub->getName();
@@ -104,6 +220,7 @@ public function execute(
           return;
         }
       }
+      array_unshift($rawArgs, $key);
     }
 
     // Check constraints
@@ -133,6 +250,9 @@ public function execute(
     $parsedArgs = $this->parseArguments($sender, $rawArgs);
 
     try {
+      // Update cooldown before execution
+      $this->updateCooldown($sender);
+      
       // Execute command logic
       $this->onExecute(new CommandResult($sender, $parsedArgs, $label));
     } catch (\Throwable $e) {

src/imperazim/command/LibCommand.php

@@ -6,7 +6,6 @@
 
 use pocketmine\Server;
 use pocketmine\player\Player;
-use pocketmine\event\EventPriority;
 use pocketmine\command\CommandSender;
 use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
 use pocketmine\network\mcpe\protocol\serializer\AvailableCommandsPacketAssembler;
@@ -23,6 +22,9 @@
 */
 final class LibCommandInterceptor implements PacketHandlerInterface {
 
+    /** @var array<int, bool> Track processed packets to avoid recursion */
+    private static array $processedPackets = [];
+
     /**
     * Gets the packet IDs this handler manages.
     *
@@ -45,14 +47,32 @@ public function handle($packet, $session): bool {
             return true;
         }
 
+        $packetId = spl_object_id($packet);
+        
+        // Skip if already processed to avoid recursion
+        if (isset(self::$processedPackets[$packetId])) {
+            return true;
+        }
+
         $player = $session->getPlayer();
         if (!($player instanceof Player)) {
             return true;
         }
 
+        // Mark as processing
+        self::$processedPackets[$packetId] = true;
+
         $server = Server::getInstance();
-        $disassembled = AvailableCommandsPacketDisassembler::disassemble($packet);
+        $logger = $server->getLogger();
+
+        try {
+            $disassembled = AvailableCommandsPacketDisassembler::disassemble($packet);
+        } catch (\Throwable $e) {
+            $logger->warning("[LibCommand] Failed to disassemble packet: " . $e->getMessage());
+            return true;
+        }
         $commandDataList = $disassembled->commandData;
+
         foreach($commandDataList as $index => $commandData) {
             $cmd = $server->getCommandMap()->getCommand($commandData->getName());
             if (!($cmd instanceof Command)) {
@@ -68,12 +88,26 @@ public function handle($packet, $session): bool {
             }
 
             // Rebuild command UI
-            $commandData->overloads = $this->getOverloads($player, $cmd);
+            $overloads = $this->getOverloads($player, $cmd);
+            $logger->debug("[LibCommand] Command '{$commandData->getName()}' overloads: " . count($overloads) . ", args: " . count($cmd->getArguments()));
+            $commandData->overloads = $overloads;
         }
 
-        // Update dynamic enums 
-        //$session->sendDataPacket(AvailableCommandsPacketAssembler::assemble($commandDataList, [], CommandEnumManager::getEnums()));
-        return true;
+        // Send modified packet
+        try {
+            $modifiedPacket = AvailableCommandsPacketAssembler::assemble(array_values($commandDataList), [], CommandEnumManager::getEnums());
+        } catch (\Throwable $e) {
+            $logger->warning("[LibCommand] Failed to assemble packet: " . $e->getMessage());
+            return true;
+        }
+        self::$processedPackets[spl_object_id($modifiedPacket)] = true;
+
+        $session->sendDataPacket($modifiedPacket);
+        
+        // Clean up old packet ID from tracking
+        unset(self::$processedPackets[$packetId]);
+        
+        return false; // Cancel original packet
     }
 
     /**

src/imperazim/command/LibCommandInterceptor.php

@@ -11,6 +11,7 @@
 use imperazim\command\traits\ArgumentableTrait;
 use imperazim\command\traits\ConstraintableTrait;
 use imperazim\command\constraint\PermissionConstraint;
+use pocketmine\plugin\Plugin;
 
 /**
 * Represents a subcommand within a main command.

src/imperazim/command/SubCommand.php

@@ -21,19 +21,31 @@ abstract class Argument {
     *
     * @param string $name Argument name (must be unique per command)
     * @param bool $optional Whether the argument is optional
+    * @param mixed $default Default value when argument is not provided (only for optional arguments)
+    * @param string $description Human-readable description of the argument
+    * @param array $aliases Alternative names for this argument
+    * @param callable|null $validator Custom validation function (receives value, returns bool)
     * @param CommandParameter|null $parameterData Pre-configured network parameter data
     *
-    * @throws ArgumentException If argument name contains spaces
+    * @throws ArgumentException If argument name contains spaces or default provided for required argument
     */
     public function __construct(
         private string $name,
         private bool $optional = false,
+        private mixed $default = null,
+        private string $description = '',
+        private array $aliases = [],
+        private $validator = null,
         private ?CommandParameter $parameterData = null
     ) {
         if (str_contains($name, ' ')) {
             throw new ArgumentException("Argument name cannot contain spaces: '{$name}'");
         }
 
+        if (!$optional && $default !== null) {
+            throw new ArgumentException("Cannot set default value for required argument: '{$name}'");
+        }
+
         if ($this->parameterData === null) {
             $this->parameterData = CommandParameter::standard($name, $this->getNetworkType(), 0, $this->isOptional());
         }
@@ -57,6 +69,56 @@ public function isOptional(): bool {
         return $this->optional;
     }
 
+    /**
+    * Gets the default value for optional arguments
+    *
+    * @return mixed Default value or null
+    */
+    public function getDefault(): mixed {
+        return $this->default;
+    }
+
+    /**
+    * Gets the argument description
+    *
+    * @return string Description text
+    */
+    public function getDescription(): string {
+        return $this->description;
+    }
+
+    /**
+    * Gets the argument aliases
+    *
+    * @return array Array of alternative names
+    */
+    public function getAliases(): array {
+        return $this->aliases;
+    }
+
+    /**
+    * Checks if a name matches this argument (including aliases)
+    *
+    * @param string $name Name to check
+    * @return bool True if matches
+    */
+    public function matchesName(string $name): bool {
+        return $name === $this->name || in_array($name, $this->aliases, true);
+    }
+
+    /**
+    * Validates value using custom validator if provided
+    *
+    * @param mixed $value Value to validate
+    * @return bool True if valid
+    */
+    public function validate(mixed $value): bool {
+        if ($this->validator !== null) {
+            return ($this->validator)($value);
+        }
+        return true;
+    }
+
     /**
     * Gets the network-ready parameter data
     *