kento2
997906cd02
All checks were successful
Build and Deploy artifact / build (push) Successful in 1m17s
91 lines
No EOL
2.7 KiB
Markdown
91 lines
No EOL
2.7 KiB
Markdown
## Build
|
|
|
|
after installing bazel:
|
|
```shell
|
|
bazel build //bukkit
|
|
bazel build //core
|
|
bazel build //velocity
|
|
```
|
|
|
|
## Limitations
|
|
|
|
- argument's can't require specific permissions.
|
|
|
|
## Design
|
|
|
|
Commands are trees of Literals.
|
|
Literals can have arguments.
|
|
Literals can also have Executors.
|
|
|
|
arguments can be optional by giving them a default value.
|
|
arguments can have suggestions.
|
|
|
|
`/feed <user>`:
|
|
- feed is the root literal
|
|
- `<user>` is an argument: it's value is a User Object
|
|
|
|
To allow the use of `/feed` without giving a user's name, i.e. to make the argument optional, we need to assign the
|
|
user-argument a default value.
|
|
|
|
### An example command
|
|
|
|
Let's say we want to make a command that allows seeing how many coins another User has.
|
|
If we don't specify a user, it should instead show the coins the sender has.
|
|
|
|
### As a tree
|
|
|
|
Visualized as a tree, we have a Node/Literal `coins` with an alias `balance` with an optional argument called `user`.
|
|
To make an argument optional, it must have a default value.
|
|
|
|
```text
|
|
literal:coins/balance
|
|
- has argument:user
|
|
- has executor:getCoins
|
|
```
|
|
|
|
### As code
|
|
|
|
```java
|
|
/**
|
|
* Show the amount coins a user has.
|
|
* If no user is given, it should show the amount the sender of the command has.
|
|
*/
|
|
public final class CoinsCommand {
|
|
|
|
private final RootLiteral<User> rootLiteral;
|
|
private final CommandArgumentSpec<User, User> userArg;
|
|
|
|
public CoinsCommand() {
|
|
userArg = CommandArgumentSpec.builder("user", new UserArgumentType<User>())
|
|
.withRequirement(user -> !user.hasPermission("economy.immune.getcoins"),
|
|
"you can't see that player's balance")
|
|
.withDefaultValue(CommandContext::sender)
|
|
.build();
|
|
rootLiteral = Literal.<User>builder("coins", "balance")
|
|
.withPermission("economy.command.coins")
|
|
.withArgument(userArg)
|
|
.withSyncExecutor(this::getCoins)
|
|
.asRootLiteral(MessageStyle.PLAIN);
|
|
}
|
|
|
|
private Result<Object, String> getCoins(CommandContext<User> ctx) {
|
|
var user = ctx.getArg(userArg);
|
|
ctx.getSender().sendMessage(user.name() + " has " + user.coins() + " coins");
|
|
return Results.success(new Object());
|
|
}
|
|
|
|
public RootLiteral<User> rootLiteral() {
|
|
return rootLiteral;
|
|
}
|
|
}
|
|
```
|
|
|
|
If we wanted to report an error, we could do for example `return Results.failure("That user doesn't exist")`.
|
|
However, if we have a smart UserArgumentType, it automatically makes sure that the user exists.
|
|
Additionally, we can also a Requirement in the CommandArgumentSpec.
|
|
|
|
The registration of the command is platform-dependant. Typically, a class called CommandAPI can be used.
|
|
```java
|
|
CommandAPI api = new CommandAPI();
|
|
register(new CoinsCommand().rootLiteral());
|
|
``` |