├── .idea
├── .gitignore
├── Commando.iml
├── misc.xml
├── modules.xml
├── php.xml
└── vcs.xml
├── .poggit.yml
├── LICENSE
├── README.md
├── commando.png
├── composer.json
├── composer.lock
├── docs
└── MIGRATION.md
├── src
└── CortexPE
│ └── Commando
│ ├── BaseCommand.php
│ ├── BaseSubCommand.php
│ ├── IRunnable.php
│ ├── PacketHooker.php
│ ├── args
│ ├── BaseArgument.php
│ ├── BlockPositionArgument.php
│ ├── BooleanArgument.php
│ ├── FloatArgument.php
│ ├── IntegerArgument.php
│ ├── RawStringArgument.php
│ ├── StringEnumArgument.php
│ ├── TargetPlayerArgument.php
│ ├── TextArgument.php
│ └── Vector3Argument.php
│ ├── constraint
│ ├── BaseConstraint.php
│ ├── ConsoleRequiredConstraint.php
│ └── InGameRequiredConstraint.php
│ ├── exception
│ ├── ArgumentOrderException.php
│ ├── CommandoException.php
│ ├── HookAlreadyRegistered.php
│ └── InvalidErrorCode.php
│ ├── store
│ └── SoftEnumStore.php
│ └── traits
│ ├── ArgumentableTrait.php
│ └── IArgumentable.php
└── virion.yml
/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 | # Datasource local storage ignored files
5 | /dataSources/
6 | /dataSources.local.xml
7 | # Editor-based HTTP Client requests
8 | /httpRequests/
9 |
--------------------------------------------------------------------------------
/.idea/Commando.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
8 |
--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
6 |
--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
7 |
8 |
--------------------------------------------------------------------------------
/.idea/php.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
8 |
9 |
--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
6 |
--------------------------------------------------------------------------------
/.poggit.yml:
--------------------------------------------------------------------------------
1 | --- # Poggit-CI Manifest. Open the CI at https://poggit.pmmp.io/ci/Paroxity/Commando
2 | build-by-default: true
3 | branches:
4 | - master
5 | projects:
6 | Commando:
7 | model: virion
8 | type: library
9 | libs:
10 | - src: Muqsit/SimplePacketHandler/SimplePacketHandler
11 | version: ^0.1.4
12 | ...
13 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU LESSER GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc. Commando
2 |
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando;
31 |
32 | use CortexPE\Commando\constraint\BaseConstraint;
33 | use CortexPE\Commando\exception\InvalidErrorCode;
34 | use CortexPE\Commando\traits\ArgumentableTrait;
35 | use CortexPE\Commando\traits\IArgumentable;
36 | use InvalidArgumentException;
37 | use pocketmine\command\Command;
38 | use pocketmine\command\CommandSender;
39 | use pocketmine\lang\Translatable;
40 | use pocketmine\plugin\Plugin;
41 | use pocketmine\plugin\PluginOwned;
42 | use pocketmine\utils\TextFormat;
43 | use function array_shift;
44 | use function array_unique;
45 | use function array_unshift;
46 | use function count;
47 | use function dechex;
48 | use function str_replace;
49 |
50 | abstract class BaseCommand extends Command implements IArgumentable, IRunnable, PluginOwned {
51 | use ArgumentableTrait;
52 |
53 | public const ERR_INVALID_ARG_VALUE = 0x01;
54 | public const ERR_TOO_MANY_ARGUMENTS = 0x02;
55 | public const ERR_INSUFFICIENT_ARGUMENTS = 0x03;
56 | public const ERR_NO_ARGUMENTS = 0x04;
57 | public const ERR_INVALID_ARGUMENTS = 0x05;
58 |
59 | /** @var string[] */
60 | protected $errorMessages = [
61 | self::ERR_INVALID_ARG_VALUE => TextFormat::RED . "Invalid value '{value}' for argument #{position}. Expecting: {expected}.",
62 | self::ERR_TOO_MANY_ARGUMENTS => TextFormat::RED . "Too many arguments given.",
63 | self::ERR_INSUFFICIENT_ARGUMENTS => TextFormat::RED . "Insufficient number of arguments given.",
64 | self::ERR_NO_ARGUMENTS => TextFormat::RED . "No arguments are required for this command.",
65 | self::ERR_INVALID_ARGUMENTS => TextFormat::RED . "Invalid arguments supplied.",
66 | ];
67 |
68 | /** @var CommandSender */
69 | protected CommandSender $currentSender;
70 |
71 | /** @var BaseSubCommand[] */
72 | private array $subCommands = [];
73 |
74 | /** @var BaseConstraint[] */
75 | private array $constraints = [];
76 |
77 | /** @var Plugin */
78 | protected Plugin $plugin;
79 |
80 | public function __construct(
81 | Plugin $plugin,
82 | string $name,
83 | Translatable|string $description = "",
84 | array $aliases = []
85 | ) {
86 | $this->plugin = $plugin;
87 | parent::__construct($name, $description, null, $aliases);
88 |
89 | $this->prepare();
90 |
91 | $this->usageMessage = $this->generateUsageMessage();
92 | }
93 |
94 | public function getOwningPlugin(): Plugin {
95 | return $this->plugin;
96 | }
97 |
98 | final public function execute(CommandSender $sender, string $commandLabel, array $args){
99 | $this->currentSender = $sender;
100 | if(!$this->testPermission($sender)){
101 | return;
102 | }
103 | /** @var BaseCommand|BaseSubCommand $cmd */
104 | $cmd = $this;
105 | $passArgs = [];
106 | if(count($args) > 0){
107 | if(isset($this->subCommands[($label = $args[0])])){
108 | array_shift($args);
109 | $this->subCommands[$label]->execute($sender, $label, $args);
110 | return;
111 | }
112 |
113 | $passArgs = $this->attemptArgumentParsing($cmd, $args);
114 | } elseif($this->hasRequiredArguments()){
115 | $this->sendError(self::ERR_INSUFFICIENT_ARGUMENTS);
116 | return;
117 | }
118 | if($passArgs !== null) {
119 | foreach ($cmd->getConstraints() as $constraint){
120 | if(!$constraint->test($sender, $commandLabel, $passArgs)){
121 | $constraint->onFailure($sender, $commandLabel, $passArgs);
122 | return;
123 | }
124 | }
125 | $cmd->onRun($sender, $commandLabel, $passArgs);
126 | }
127 | }
128 |
129 | /**
130 | * @param ArgumentableTrait $ctx
131 | * @param array $args
132 | *
133 | * @return array|null
134 | */
135 | private function attemptArgumentParsing($ctx, array $args): ?array {
136 | $dat = $ctx->parseArguments($args, $this->currentSender);
137 | if(!empty(($errors = $dat["errors"]))) {
138 | foreach($errors as $error) {
139 | $this->sendError($error["code"], $error["data"]);
140 | }
141 |
142 | return null;
143 | }
144 |
145 | return $dat["arguments"];
146 | }
147 |
148 | abstract public function onRun(CommandSender $sender, string $aliasUsed, array $args): void;
149 |
150 | protected function sendUsage(): void {
151 | $this->currentSender->sendMessage(TextFormat::RED . "Usage: " . $this->getUsage());
152 | }
153 |
154 | public function sendError(int $errorCode, array $args = []): void {
155 | $str = (string)$this->errorMessages[$errorCode];
156 | foreach($args as $item => $value) {
157 | $str = str_replace('{' . $item . '}', (string) $value, $str);
158 | }
159 | $this->currentSender->sendMessage($str);
160 | $this->sendUsage();
161 | }
162 |
163 | public function setErrorFormat(int $errorCode, string $format): void {
164 | if(!isset($this->errorMessages[$errorCode])) {
165 | throw new InvalidErrorCode("Invalid error code 0x" . dechex($errorCode));
166 | }
167 | $this->errorMessages[$errorCode] = $format;
168 | }
169 |
170 | public function setErrorFormats(array $errorFormats): void {
171 | foreach($errorFormats as $errorCode => $format) {
172 | $this->setErrorFormat($errorCode, $format);
173 | }
174 | }
175 |
176 | public function registerSubCommand(BaseSubCommand $subCommand): void {
177 | $keys = $subCommand->getAliases();
178 | array_unshift($keys, $subCommand->getName());
179 | $keys = array_unique($keys);
180 | foreach($keys as $key) {
181 | if(!isset($this->subCommands[$key])) {
182 | $subCommand->setParent($this);
183 | $this->subCommands[$key] = $subCommand;
184 | } else {
185 | throw new InvalidArgumentException("SubCommand with same name / alias for '$key' already exists");
186 | }
187 | }
188 | }
189 |
190 | /**
191 | * @return BaseSubCommand[]
192 | */
193 | public function getSubCommands(): array {
194 | return $this->subCommands;
195 | }
196 |
197 | public function addConstraint(BaseConstraint $constraint) : void {
198 | $this->constraints[] = $constraint;
199 | }
200 |
201 | /**
202 | * @return BaseConstraint[]
203 | */
204 | public function getConstraints(): array {
205 | return $this->constraints;
206 | }
207 |
208 | public function getUsageMessage(): string {
209 | return $this->getUsage();
210 | }
211 |
212 | public function setCurrentSender(CommandSender $sender): void{
213 | $this->currentSender = $sender;
214 | }
215 | }
216 |
--------------------------------------------------------------------------------
/src/CortexPE/Commando/BaseSubCommand.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando;
31 |
32 | use pocketmine\command\CommandSender;
33 | use pocketmine\plugin\PluginBase;
34 | use function trim;
35 |
36 | abstract class BaseSubCommand extends BaseCommand{
37 | /** @var BaseCommand */
38 | protected BaseCommand $parent;
39 |
40 | public function __construct(PluginBase $plugin, string $name, string $description = "", array $aliases = []){
41 | parent::__construct($plugin, $name, $description, $aliases);
42 |
43 | $this->usageMessage = "";
44 | }
45 |
46 | public function getParent(): BaseCommand {
47 | return $this->parent;
48 | }
49 |
50 | /**
51 | * @param BaseCommand $parent
52 | *
53 | * @internal Used to pass the parent context from the parent command
54 | */
55 | public function setParent(BaseCommand $parent): void {
56 | $this->parent = $parent;
57 | }
58 |
59 | public function getUsage(): string{
60 | if(empty($this->usageMessage)){
61 | $parent = $this->parent;
62 | $parentNames = "";
63 |
64 | while($parent instanceof BaseSubCommand) {
65 | $parentNames = $parent->getName() . $parentNames;
66 | $parent = $parent->getParent();
67 | }
68 |
69 | if($parent instanceof BaseCommand){
70 | $parentNames = $parent->getName() . " " . $parentNames;
71 | }
72 |
73 | $this->usageMessage = $this->generateUsageMessage(trim($parentNames));
74 | }
75 |
76 | return $this->usageMessage;
77 | }
78 |
79 | public function testPermissionSilent(CommandSender $sender, ?string $permission = null): bool {
80 | if($permission === null && count($this->getPermissions()) === 0) {
81 | return true;
82 | }
83 | return parent::testPermissionSilent($sender, $permission);
84 | }
85 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/IRunnable.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando;
31 |
32 |
33 | use CortexPE\Commando\constraint\BaseConstraint;
34 |
35 | /**
36 | * Interface IRunnable
37 | *
38 | * An interface which is declares the minimum required information
39 | * to get background information for a command and/or a sub-command
40 | *
41 | * @package CortexPE\Commando
42 | */
43 | interface IRunnable {
44 | public function getName(): string;
45 |
46 | /**
47 | * @return string[]
48 | */
49 | public function getAliases(): array;
50 |
51 | public function getUsageMessage():string;
52 |
53 | /**
54 | * @return string[]
55 | */
56 | public function getPermissions(): array;
57 |
58 | /**
59 | * @return BaseConstraint[]
60 | */
61 | public function getConstraints():array;
62 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/PacketHooker.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando;
31 |
32 | use CortexPE\Commando\exception\HookAlreadyRegistered;
33 | use CortexPE\Commando\store\SoftEnumStore;
34 | use CortexPE\Commando\traits\IArgumentable;
35 | use muqsit\simplepackethandler\SimplePacketHandler;
36 | use pocketmine\command\CommandSender;
37 | use pocketmine\event\EventPriority;
38 | use pocketmine\event\Listener;
39 | use pocketmine\network\mcpe\NetworkSession;
40 | use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
41 | use pocketmine\network\mcpe\protocol\types\command\CommandEnum;
42 | use pocketmine\network\mcpe\protocol\types\command\CommandOverload;
43 | use pocketmine\network\mcpe\protocol\types\command\CommandParameter;
44 | use pocketmine\plugin\Plugin;
45 | use pocketmine\Server;
46 | use ReflectionClass;
47 | use function array_unshift;
48 | use function count;
49 |
50 | class PacketHooker implements Listener {
51 | /** @var bool */
52 | private static bool $isRegistered = false;
53 |
54 | /** @var bool */
55 | private static bool $isIntercepting = false;
56 |
57 | public static function isRegistered(): bool {
58 | return self::$isRegistered;
59 | }
60 |
61 | public static function register(Plugin $registrant): void {
62 | if(self::$isRegistered) {
63 | throw new HookAlreadyRegistered("Event listener is already registered by another plugin.");
64 | }
65 | $interceptor = SimplePacketHandler::createInterceptor($registrant, EventPriority::HIGHEST, false);
66 | $interceptor->interceptOutgoing(function(AvailableCommandsPacket $pk, NetworkSession $target) : bool{
67 | if(self::$isIntercepting)return true;
68 | $p = $target->getPlayer();
69 | foreach($pk->commandData as $commandName => $commandData) {
70 | $cmd = Server::getInstance()->getCommandMap()->getCommand($commandName);
71 | if($cmd instanceof BaseCommand) {
72 | foreach($cmd->getConstraints() as $constraint){
73 | if(!$constraint->isVisibleTo($p)){
74 | continue 2;
75 | }
76 | }
77 | $pk->commandData[$commandName]->overloads = self::generateOverloads($p, $cmd);
78 | }
79 | }
80 | $pk->softEnums = SoftEnumStore::getEnums();
81 | self::$isIntercepting = true;
82 | $target->sendDataPacket($pk);
83 | self::$isIntercepting = false;
84 | return false;
85 | });
86 |
87 | self::$isRegistered = true;
88 | }
89 |
90 | /**
91 | * @param CommandSender $cs
92 | * @param BaseCommand $command
93 | *
94 | * @return CommandOverload[]
95 | */
96 | private static function generateOverloads(CommandSender $cs, BaseCommand $command): array {
97 | $overloads = [];
98 |
99 | foreach($command->getSubCommands() as $label => $subCommand) {
100 | if(!$subCommand->testPermissionSilent($cs) || $subCommand->getName() !== $label){ // hide aliases
101 | continue;
102 | }
103 | foreach($subCommand->getConstraints() as $constraint){
104 | if(!$constraint->isVisibleTo($cs)){
105 | continue 2;
106 | }
107 | }
108 | $scParam = new CommandParameter();
109 | $scParam->paramName = $label;
110 | $scParam->paramType = AvailableCommandsPacket::ARG_FLAG_VALID | AvailableCommandsPacket::ARG_FLAG_ENUM;
111 | $scParam->isOptional = false;
112 | $scParam->enum = new CommandEnum($label, [$label]);
113 |
114 | $overloadList = self::generateOverloads($cs, $subCommand);
115 | if(!empty($overloadList)){
116 | foreach($overloadList as $overload) {
117 | $overloads[] = new CommandOverload(false, [$scParam, ...$overload->getParameters()]);
118 | }
119 | } else {
120 | $overloads[] = new CommandOverload(false, [$scParam]);
121 | }
122 | }
123 |
124 | foreach(self::generateOverloadList($command) as $overload) {
125 | $overloads[] = $overload;
126 | }
127 |
128 | return $overloads;
129 | }
130 |
131 | /**
132 | * @param IArgumentable $argumentable
133 | *
134 | * @return CommandOverload[]
135 | */
136 | private static function generateOverloadList(IArgumentable $argumentable): array {
137 | $input = $argumentable->getArgumentList();
138 | $combinations = [];
139 | $outputLength = array_product(array_map("count", $input));
140 | $indexes = [];
141 | foreach($input as $k => $charList){
142 | $indexes[$k] = 0;
143 | }
144 | do {
145 | /** @var CommandParameter[] $set */
146 | $set = [];
147 | foreach($indexes as $k => $index){
148 | $param = $set[$k] = clone $input[$k][$index]->getNetworkParameterData();
149 |
150 | if (isset($param->enum) && $param->enum instanceof CommandEnum) {
151 | $refClass = new ReflectionClass(CommandEnum::class);
152 | $refProp = $refClass->getProperty("enumName");
153 | $refProp->setAccessible(true);
154 | $refProp->setValue($param->enum, "enum#" . spl_object_id($param->enum));
155 | }
156 | }
157 | $combinations[] = new CommandOverload(false, $set);
158 |
159 | foreach($indexes as $k => $v){
160 | $indexes[$k]++;
161 | $lim = count($input[$k]);
162 | if($indexes[$k] >= $lim){
163 | $indexes[$k] = 0;
164 | continue;
165 | }
166 | break;
167 | }
168 | } while(count($combinations) !== $outputLength);
169 |
170 | return $combinations;
171 | }
172 | }
173 |
--------------------------------------------------------------------------------
/src/CortexPE/Commando/args/BaseArgument.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\args;
31 |
32 |
33 | use pocketmine\command\CommandSender;
34 | use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
35 | use pocketmine\network\mcpe\protocol\types\command\CommandParameter;
36 |
37 | abstract class BaseArgument {
38 | /** @var string */
39 | protected string $name;
40 | /** @var bool */
41 | protected bool $optional = false;
42 | /** @var CommandParameter */
43 | protected CommandParameter $parameterData;
44 |
45 | public function __construct(string $name, bool $optional = false) {
46 | $this->name = $name;
47 | $this->optional = $optional;
48 |
49 | $this->parameterData = new CommandParameter();
50 | $this->parameterData->paramName = $name;
51 | $this->parameterData->paramType = AvailableCommandsPacket::ARG_FLAG_VALID;
52 | $this->parameterData->paramType |= $this->getNetworkType();
53 | $this->parameterData->isOptional = $this->isOptional();
54 | }
55 |
56 | abstract public function getNetworkType(): int;
57 |
58 | /**
59 | * @param string $testString
60 | * @param CommandSender $sender
61 | *
62 | * @return bool
63 | */
64 | abstract public function canParse(string $testString, CommandSender $sender): bool;
65 |
66 | /**
67 | * @param string $argument
68 | * @param CommandSender $sender
69 | *
70 | * @return mixed
71 | */
72 | abstract public function parse(string $argument, CommandSender $sender) : mixed;
73 |
74 | /**
75 | * @return string
76 | */
77 | public function getName(): string {
78 | return $this->name;
79 | }
80 |
81 | /**
82 | * @return bool
83 | */
84 | public function isOptional(): bool {
85 | return $this->optional;
86 | }
87 |
88 | /**
89 | * Returns how much command arguments
90 | * it takes to build the full argument
91 | *
92 | * @return int
93 | */
94 | public function getSpanLength(): int {
95 | return 1;
96 | }
97 |
98 | abstract public function getTypeName(): string;
99 |
100 | public function getNetworkParameterData():CommandParameter {
101 | return $this->parameterData;
102 | }
103 | }
104 |
--------------------------------------------------------------------------------
/src/CortexPE/Commando/args/BlockPositionArgument.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\args;
31 |
32 |
33 | use pocketmine\command\CommandSender;
34 | use pocketmine\math\Vector3;
35 | use function preg_match;
36 |
37 | class BlockPositionArgument extends Vector3Argument {
38 | public function isValidCoordinate(string $coordinate, bool $locatable): bool {
39 | return (bool)preg_match("/^(?:" . ($locatable ? "(?:~-|~\+)?" : "") . "-?\d+)" . ($locatable ? "|~" : "") . "$/", $coordinate);
40 | }
41 |
42 | public function parse(string $argument, CommandSender $sender) : Vector3{
43 | $v = parent::parse($argument, $sender);
44 |
45 | return $v->floor();
46 | }
47 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/args/BooleanArgument.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\args;
31 |
32 |
33 | use pocketmine\command\CommandSender;
34 |
35 | class BooleanArgument extends StringEnumArgument {
36 |
37 | protected const VALUES = [
38 | "true" => true,
39 | "false" => false,
40 | ];
41 |
42 | public function getTypeName(): string {
43 | return "bool";
44 | }
45 |
46 | public function getEnumName(): string {
47 | return "bool";
48 | }
49 |
50 | public function parse(string $argument, CommandSender $sender): bool{
51 | return (bool) $this->getValue($argument);
52 | }
53 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/args/FloatArgument.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\args;
31 |
32 |
33 | use pocketmine\command\CommandSender;
34 | use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
35 | use function preg_match;
36 |
37 | class FloatArgument extends BaseArgument {
38 | public function getNetworkType(): int {
39 | return AvailableCommandsPacket::ARG_TYPE_FLOAT;
40 | }
41 |
42 | public function getTypeName(): string {
43 | return "decimal";
44 | }
45 |
46 | public function canParse(string $testString, CommandSender $sender): bool {
47 | return (bool)preg_match("/^-?(?:\d+|\d*\.\d+)$/", $testString);
48 | }
49 |
50 | public function parse(string $argument, CommandSender $sender) : float{
51 | return (float) $argument;
52 | }
53 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/args/IntegerArgument.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\args;
31 |
32 |
33 | use pocketmine\command\CommandSender;
34 | use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
35 | use function preg_match;
36 |
37 | class IntegerArgument extends BaseArgument {
38 | public function getNetworkType(): int {
39 | return AvailableCommandsPacket::ARG_TYPE_INT;
40 | }
41 |
42 | public function getTypeName(): string {
43 | return "int";
44 | }
45 |
46 | public function canParse(string $testString, CommandSender $sender): bool {
47 | return (bool)preg_match("/^-?(?:\d+)$/", $testString);
48 | }
49 |
50 | public function parse(string $argument, CommandSender $sender) : int{
51 | return (int) $argument;
52 | }
53 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/args/RawStringArgument.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\args;
31 |
32 | use pocketmine\command\CommandSender;
33 | use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
34 |
35 | class RawStringArgument extends BaseArgument {
36 | public function getNetworkType(): int {
37 | return AvailableCommandsPacket::ARG_TYPE_STRING;
38 | }
39 |
40 | public function getTypeName(): string {
41 | return "string";
42 | }
43 |
44 | public function canParse(string $testString, CommandSender $sender): bool {
45 | return true;
46 | }
47 |
48 | public function parse(string $argument, CommandSender $sender) : string{
49 | return $argument;
50 | }
51 | }
52 |
--------------------------------------------------------------------------------
/src/CortexPE/Commando/args/StringEnumArgument.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\args;
31 |
32 |
33 | use pocketmine\command\CommandSender;
34 | use pocketmine\network\mcpe\protocol\types\command\CommandEnum;
35 | use function array_keys;
36 | use function array_map;
37 | use function implode;
38 | use function preg_match;
39 | use function strtolower;
40 |
41 | abstract class StringEnumArgument extends BaseArgument {
42 |
43 | protected const VALUES = [];
44 |
45 | public function __construct(string $name, bool $optional = false) {
46 | parent::__construct($name, $optional);
47 |
48 | $this->parameterData->enum = new CommandEnum($this->getEnumName(), $this->getEnumValues());
49 | }
50 |
51 | public function getNetworkType(): int {
52 | // this will be disregarded by PM anyways because this will be considered as a string enum
53 | return -1;
54 | }
55 |
56 | public function canParse(string $testString, CommandSender $sender): bool {
57 | return (bool)preg_match(
58 | "/^(" . implode("|", array_map("\\strtolower", $this->getEnumValues())) . ")$/iu",
59 | $testString
60 | );
61 | }
62 |
63 | public abstract function getEnumName(): string;
64 |
65 | public function getValue(string $string) {
66 | return static::VALUES[strtolower($string)];
67 | }
68 |
69 | public function getEnumValues(): array {
70 | return array_keys(static::VALUES);
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/src/CortexPE/Commando/args/TargetPlayerArgument.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\args;
31 |
32 |
33 | use pocketmine\command\CommandSender;
34 | use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
35 |
36 | class TextArgument extends RawStringArgument {
37 | public function getNetworkType(): int {
38 | return AvailableCommandsPacket::ARG_TYPE_RAWTEXT;
39 | }
40 |
41 | public function getTypeName(): string {
42 | return "text";
43 | }
44 |
45 | public function getSpanLength(): int {
46 | return PHP_INT_MAX;
47 | }
48 | public function canParse(string $testString, CommandSender $sender): bool {
49 | return $testString !== "";
50 | }
51 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/args/Vector3Argument.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\args;
31 |
32 |
33 | use pocketmine\command\CommandSender;
34 | use pocketmine\entity\Entity;
35 | use pocketmine\math\Vector3;
36 | use pocketmine\network\mcpe\protocol\AvailableCommandsPacket;
37 | use function count;
38 | use function explode;
39 | use function preg_match;
40 | use function substr;
41 |
42 | class Vector3Argument extends BaseArgument {
43 | public function getNetworkType(): int {
44 | return AvailableCommandsPacket::ARG_TYPE_POSITION;
45 | }
46 |
47 | public function getTypeName(): string {
48 | return "x y z";
49 | }
50 |
51 | public function canParse(string $testString, CommandSender $sender): bool {
52 | $coords = explode(" ", $testString);
53 | if(count($coords) === 3) {
54 | foreach($coords as $coord) {
55 | if(!$this->isValidCoordinate($coord, $sender instanceof Vector3)) {
56 | return false;
57 | }
58 | }
59 |
60 | return true;
61 | }
62 |
63 | return false;
64 | }
65 |
66 | public function isValidCoordinate(string $coordinate, bool $locatable): bool {
67 | return (bool)preg_match("/^(?:" . ($locatable ? "(\\?:~-|~\+)?" : "") . "-?(?:\d+|\d*\.\d+))" . ($locatable ? "|~" : "") . "$/", $coordinate);
68 | }
69 |
70 | public function parse(string $argument, CommandSender $sender) : Vector3{
71 | $coords = explode(" ", $argument);
72 | $vals = [];
73 | foreach($coords as $k => $coord){
74 | $offset = 0;
75 | // if it's locatable and starts with ~- or ~+
76 | if($sender instanceof Entity && preg_match("/^(?:~-|~\+)|~/", $coord)){
77 | // this will work with -n, +n and "" due to typecast later
78 | $offset = substr($coord, 1);
79 |
80 | // replace base coordinate with actual entity coordinates
81 | $position = $sender->getPosition();
82 | $coord = match ($k) {
83 | 0 => $position->x,
84 | 1 => $position->y,
85 | 2 => $position->z,
86 | };
87 | }
88 | $vals[] = (float)$coord + (float)$offset;
89 | }
90 | return new Vector3(...$vals);
91 | }
92 |
93 | public function getSpanLength(): int {
94 | return 3;
95 | }
96 | }
97 |
--------------------------------------------------------------------------------
/src/CortexPE/Commando/constraint/BaseConstraint.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\constraint;
31 |
32 |
33 | use CortexPE\Commando\IRunnable;
34 | use pocketmine\command\CommandSender;
35 |
36 | abstract class BaseConstraint {
37 | /** @var IRunnable */
38 | protected IRunnable $context;
39 |
40 | /**
41 | * BaseConstraint constructor.
42 | *
43 | * "Context" is required so that this new-constraint-system doesn't hinder getting command info
44 | *
45 | * @param IRunnable $context
46 | */
47 | public function __construct(IRunnable $context) {
48 | $this->context = $context;
49 | }
50 |
51 | /**
52 | * @return IRunnable
53 | */
54 | public function getContext(): IRunnable {
55 | return $this->context;
56 | }
57 |
58 | abstract public function test(CommandSender $sender, string $aliasUsed, array $args): bool;
59 |
60 | abstract public function onFailure(CommandSender $sender, string $aliasUsed, array $args): void;
61 |
62 | abstract public function isVisibleTo(CommandSender $sender): bool;
63 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/constraint/ConsoleRequiredConstraint.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\constraint;
31 |
32 |
33 | use pocketmine\command\CommandSender;
34 | use pocketmine\player\Player;
35 | use pocketmine\utils\TextFormat;
36 |
37 | class ConsoleRequiredConstraint extends BaseConstraint {
38 |
39 | public function test(CommandSender $sender, string $aliasUsed, array $args): bool {
40 | return $this->isVisibleTo($sender);
41 | }
42 |
43 | public function onFailure(CommandSender $sender, string $aliasUsed, array $args): void {
44 | $sender->sendMessage(TextFormat::RED . "This command must be executed from a server console."); // f*ck off grammar police
45 | }
46 |
47 | public function isVisibleTo(CommandSender $sender): bool {
48 | return !($sender instanceof Player);
49 | }
50 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/constraint/InGameRequiredConstraint.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\constraint;
31 |
32 |
33 | use pocketmine\command\CommandSender;
34 | use pocketmine\player\Player;
35 | use pocketmine\utils\TextFormat;
36 |
37 | class InGameRequiredConstraint extends BaseConstraint {
38 |
39 | public function test(CommandSender $sender, string $aliasUsed, array $args): bool {
40 | return $this->isVisibleTo($sender);
41 | }
42 |
43 | public function onFailure(CommandSender $sender, string $aliasUsed, array $args): void {
44 | $sender->sendMessage(TextFormat::RED . "This command must be executed in-game."); // f*ck off grammar police
45 | }
46 |
47 | public function isVisibleTo(CommandSender $sender): bool {
48 | return $sender instanceof Player;
49 | }
50 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/exception/ArgumentOrderException.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\exception;
31 |
32 |
33 | class ArgumentOrderException extends CommandoException {
34 |
35 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/exception/CommandoException.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\exception;
31 |
32 |
33 | use Exception;
34 |
35 | class CommandoException extends Exception {
36 |
37 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/exception/HookAlreadyRegistered.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\exception;
31 |
32 |
33 | class HookAlreadyRegistered extends CommandoException {
34 |
35 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/exception/InvalidErrorCode.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\exception;
31 |
32 |
33 | class InvalidErrorCode extends CommandoException {
34 |
35 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/store/SoftEnumStore.php:
--------------------------------------------------------------------------------
1 | getName()] = $enum;
31 | self::broadcastSoftEnum($enum, UpdateSoftEnumPacket::TYPE_ADD);
32 | }
33 |
34 | public static function updateEnum(string $enumName, array $values):void {
35 | if(self::getEnumByName($enumName) === null){
36 | throw new CommandoException("Unknown enum named " . $enumName);
37 | }
38 | self::$enums[$enumName] = $enum = new CommandEnum($enumName, $values);
39 | self::broadcastSoftEnum($enum, UpdateSoftEnumPacket::TYPE_SET);
40 | }
41 |
42 | public static function removeEnum(string $enumName):void {
43 | if(($enum = self::getEnumByName($enumName)) === null){
44 | throw new CommandoException("Unknown enum named " . $enumName);
45 | }
46 | unset(static::$enums[$enumName]);
47 | self::broadcastSoftEnum($enum, UpdateSoftEnumPacket::TYPE_REMOVE);
48 | }
49 |
50 | public static function broadcastSoftEnum(CommandEnum $enum, int $type):void {
51 | $pk = new UpdateSoftEnumPacket();
52 | $pk->enumName = $enum->getName();
53 | $pk->values = $enum->getValues();
54 | $pk->type = $type;
55 | self::broadcastPacket($pk);
56 | }
57 |
58 | private static function broadcastPacket(ClientboundPacket $pk):void {
59 | $sv = Server::getInstance();
60 | NetworkBroadcastUtils::broadcastPackets($sv->getOnlinePlayers(), [$pk]);
61 | }
62 | }
--------------------------------------------------------------------------------
/src/CortexPE/Commando/traits/ArgumentableTrait.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\traits;
31 |
32 |
33 | use CortexPE\Commando\args\BaseArgument;
34 | use CortexPE\Commando\args\TextArgument;
35 | use CortexPE\Commando\BaseCommand;
36 | use CortexPE\Commando\exception\ArgumentOrderException;
37 | use pocketmine\command\CommandSender;
38 | use pocketmine\utils\TextFormat;
39 | use function array_slice;
40 | use function count;
41 | use function implode;
42 | use function is_array;
43 | use function rtrim;
44 | use function trim;
45 | use function usort;
46 |
47 | trait ArgumentableTrait{
48 | /** @var BaseArgument[][] */
49 | private array $argumentList = []; // [argumentPosition => [...possible BaseArgument(s)]]
50 | /** @var bool[] */
51 | private array $requiredArgumentCount = [];
52 |
53 | /**
54 | * This is where all the arguments, permissions, sub-commands, etc would be registered
55 | */
56 | abstract protected function prepare() : void;
57 |
58 | /**
59 | * @param int $position
60 | * @param BaseArgument $argument
61 | *
62 | * @throws ArgumentOrderException
63 | */
64 | public function registerArgument(int $position, BaseArgument $argument): void {
65 | if($position < 0) {
66 | throw new ArgumentOrderException("You cannot register arguments at negative positions");
67 | }
68 | if($position > 0 && !isset($this->argumentList[$position - 1])) {
69 | throw new ArgumentOrderException("There were no arguments before $position");
70 | }
71 | foreach($this->argumentList[$position - 1] ?? [] as $arg) {
72 | if($arg instanceof TextArgument) {
73 | throw new ArgumentOrderException("No other arguments can be registered after a TextArgument");
74 | }
75 | if($arg->isOptional() && !$argument->isOptional()){
76 | throw new ArgumentOrderException("You cannot register a required argument after an optional argument");
77 | }
78 | }
79 | $this->argumentList[$position][] = $argument;
80 | if(!$argument->isOptional()) {
81 | $this->requiredArgumentCount[$position] = true;
82 | }
83 | }
84 |
85 | public function parseArguments(array $rawArgs, CommandSender $sender): array {
86 | $return = [
87 | "arguments" => [],
88 | "errors" => []
89 | ];
90 | // try parsing arguments
91 | $required = count($this->requiredArgumentCount);
92 | if(!$this->hasArguments() && count($rawArgs) > 0) { // doesnt take args but sender gives args anyways
93 | $return["errors"][] = [
94 | "code" => BaseCommand::ERR_NO_ARGUMENTS,
95 | "data" => []
96 | ];
97 | }
98 | $offset = 0;
99 | $argOffset = 0;
100 | if(count($rawArgs) > 0) {
101 | foreach($this->argumentList as $pos => $possibleArguments) {
102 | // try the one that spans more first... before the others
103 | usort($possibleArguments, function (BaseArgument $a): int {
104 | if($a->getSpanLength() === PHP_INT_MAX) { // if it takes unlimited arguments, pull it down
105 | return 1;
106 | }
107 |
108 | return -1;
109 | });
110 | $parsed = false;
111 | $optional = true;
112 | foreach($possibleArguments as $argument) {
113 | $arg = trim(implode(" ", array_slice($rawArgs, $offset, ($len = $argument->getSpanLength()))));
114 | if(!$argument->isOptional()) {
115 | $optional = false;
116 | }
117 | if($arg !== "" && $argument->canParse($arg, $sender)) {
118 | $k = $argument->getName();
119 | $result = (clone $argument)->parse($arg, $sender);
120 | if(isset($return["arguments"][$k]) && !is_array($return["arguments"][$k])) {
121 | $old = $return["arguments"][$k];
122 | unset($return["arguments"][$k]);
123 | $return["arguments"][$k] = [$old];
124 | $return["arguments"][$k][] = $result;
125 | } else {
126 | $return["arguments"][$k] = $result;
127 | }
128 | if(!$optional) {
129 | $required--;
130 | }
131 | $offset += $len;
132 | ++$argOffset;
133 | $parsed = true;
134 | break;
135 | }
136 | if($offset > count($rawArgs)) {
137 | break; // we've reached the end of the argument list the user passed
138 | }
139 | }
140 | if(!$parsed && !($optional && empty($arg))) { // we tried every other possible argument type, none was satisfied
141 | $expectedArgs = $this->argumentList[$argOffset];
142 | $expected = "";
143 | foreach($expectedArgs as $expectedArg){
144 | $expected .= $expectedArg->getTypeName() . "|";
145 | }
146 |
147 | $return["errors"][] = [
148 | "code" => BaseCommand::ERR_INVALID_ARG_VALUE,
149 | "data" => [
150 | "value" => $rawArgs[$offset] ?? "",
151 | "position" => $pos + 1,
152 | "expected" => rtrim($expected, "|")
153 | ]
154 | ];
155 |
156 | return $return; // let's break it here.
157 | }
158 | }
159 | }
160 | if($offset < count($rawArgs)) { // this means that the arguments our user sent is more than the needed amount
161 | $return["errors"][] = [
162 | "code" => BaseCommand::ERR_TOO_MANY_ARGUMENTS,
163 | "data" => []
164 | ];
165 | }
166 | if($required > 0) {// We still have more unfilled required arguments
167 | $return["errors"][] = [
168 | "code" => BaseCommand::ERR_INSUFFICIENT_ARGUMENTS,
169 | "data" => []
170 | ];
171 | }
172 |
173 | // up to my testing this occurs when BaseCommand::ERR_NO_ARGUMENTS and BaseCommand::ERR_TOO_MANY_ARGUMENTS are given as errors
174 | // this only (as far as my testing) happens when command accepts arguments (e.g. a subcommand) but the user supplied invalid argument
175 | // also the error code remains as shown due to the way they are passed
176 | // have a better way? pr please :)
177 | if(
178 | count($return["errors"]) === 2 &&
179 | $return["errors"][0]["code"] === BaseCommand::ERR_NO_ARGUMENTS &&
180 | $return["errors"][1]["code"] === BaseCommand::ERR_TOO_MANY_ARGUMENTS
181 | ){
182 | unset($return["errors"]);
183 |
184 | $return["errors"][] = [
185 | "code" => BaseCommand::ERR_INVALID_ARGUMENTS,
186 | "data" => []
187 | ];
188 | }
189 |
190 | return $return;
191 | }
192 |
193 | public function generateUsageMessage(string $parent = ""): string {
194 | $name = $parent . (empty($parent) ? "" : " ") . $this->getName();
195 | $msg = TextFormat::RED . "/" . $name;
196 | $args = [];
197 | foreach($this->argumentList as $arguments){
198 | $hasOptional = false;
199 | $names = [];
200 | foreach($arguments as $argument){
201 | $names[] = $argument->getName() . ":" . $argument->getTypeName();
202 | if($argument->isOptional()){
203 | $hasOptional = true;
204 | }
205 | }
206 | $names = implode("|", $names);
207 | if($hasOptional){
208 | $args[] = "[" . $names . "]";
209 | } else {
210 | $args[] = "<" . $names . ">";
211 | }
212 | }
213 | $msg .= ((empty($args)) ? "" : " ") . implode(TextFormat::RED . " ", $args) . ": " . $this->getDescription();
214 | foreach($this->subCommands as $label => $subCommand){
215 | if($label === $subCommand->getName()){
216 | $msg .= "\n - " . $subCommand->generateUsageMessage($name);
217 | }
218 | }
219 |
220 | return trim($msg);
221 | }
222 |
223 | public function hasArguments(): bool {
224 | return !empty($this->argumentList);
225 | }
226 |
227 | public function hasRequiredArguments(): bool {
228 | foreach($this->argumentList as $arguments) {
229 | foreach($arguments as $argument) {
230 | if(!$argument->isOptional()) {
231 | return true;
232 | }
233 | }
234 | }
235 |
236 | return false;
237 | }
238 |
239 | /**
240 | * @return BaseArgument[][]
241 | */
242 | public function getArgumentList(): array {
243 | return $this->argumentList;
244 | }
245 | }
246 |
--------------------------------------------------------------------------------
/src/CortexPE/Commando/traits/IArgumentable.php:
--------------------------------------------------------------------------------
1 | .
24 | *
25 | * Written by @CortexPE
26 | *
27 | */
28 | declare(strict_types=1);
29 |
30 | namespace CortexPE\Commando\traits;
31 |
32 |
33 | use CortexPE\Commando\args\BaseArgument;
34 | use pocketmine\command\CommandSender;
35 |
36 | interface IArgumentable {
37 | public function generateUsageMessage(string $parent = ""): string;
38 | public function hasArguments(): bool;
39 |
40 | /**
41 | * @return BaseArgument[][]
42 | */
43 | public function getArgumentList(): array;
44 | public function parseArguments(array $rawArgs, CommandSender $sender): array;
45 | public function registerArgument(int $position, BaseArgument $argument): void;
46 | }
--------------------------------------------------------------------------------
/virion.yml:
--------------------------------------------------------------------------------
1 | name: Commando
2 | antigen: CortexPE\Commando
3 | api: 5.3.0
4 | version: 3.2.1
5 | author: CortexPE
6 | authors: [ParoxityTeam]
7 |
--------------------------------------------------------------------------------
