Upstream/Minestom
1
0
Fork 0
mirror of https://github.com/Minestom/Minestom.git synced 2024-09-24 20:42:39 +02:00
Code Issues Projects Releases Wiki Activity

Outsource node building to other classes

Browse Source
This commit is contained in:
LeoDog896 2021-02-08 18:25:10 -05:00
parent 04c792c302
commit 4379f4b1e1
27 changed files with 370 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

204
src/main/java/net/minestom/server/command/CommandManager.java
View File

@ -8,15 +8,7 @@ import net.minestom.server.command.builder.CommandData;
import net.minestom.server.command.builder.CommandDispatcher;
import net.minestom.server.command.builder.CommandSyntax;
import net.minestom.server.command.builder.arguments.*;
import net.minestom.server.command.builder.arguments.minecraft.*;
import net.minestom.server.command.builder.arguments.minecraft.registry.*;
import net.minestom.server.command.builder.arguments.number.ArgumentDouble;
import net.minestom.server.command.builder.arguments.number.ArgumentFloat;
import net.minestom.server.command.builder.arguments.number.ArgumentInteger;
import net.minestom.server.command.builder.arguments.number.ArgumentNumber;
import net.minestom.server.command.builder.arguments.relative.ArgumentRelativeBlockPosition;
import net.minestom.server.command.builder.arguments.relative.ArgumentRelativeVec2;
import net.minestom.server.command.builder.arguments.relative.ArgumentRelativeVec3;
import net.minestom.server.command.builder.condition.CommandCondition;
import net.minestom.server.entity.Player;
import net.minestom.server.event.player.PlayerCommandEvent;
@ -33,7 +25,6 @@ import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.util.function.Consumer;
/**
* Manager used to register {@link Command} and {@link CommandProcessor}.
@ -447,8 +438,8 @@ public final class CommandManager {
}
final List<DeclareCommandsPacket.Node> argumentNodes = toNodes(argument, isLast);
storedArgumentsNodes.put(argument, argumentNodes);
final DeclareCommandsPacket.Node[] argumentNodes = toNodes(argument, isLast);
storedArgumentsNodes.put(argument, Arrays.asList(argumentNodes));
for (DeclareCommandsPacket.Node node : argumentNodes) {
final int childId = nodes.size();
@ -513,183 +504,20 @@ public final class CommandManager {
* @return the list of nodes that the argument require
*/
@NotNull
private List<DeclareCommandsPacket.Node> toNodes(@NotNull Argument<?> argument, boolean executable) {
List<DeclareCommandsPacket.Node> nodes = new ArrayList<>();
private DeclareCommandsPacket.Node[] toNodes(@NotNull Argument<?> argument, boolean executable) {
// You can uncomment this to test any brigadier parser on the client
/*DeclareCommandsPacket.Node testNode = simpleArgumentNode(nodes, argument, executable, false);
/*
DeclareCommandsPacket.Node testNode = simpleArgumentNode(nodes, argument, executable, false);
testNode.parser = "minecraft:block_state";
if (true) {
return nodes;
}*/
if (argument instanceof ArgumentBoolean) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "brigadier:bool";
} else if (argument instanceof ArgumentDouble) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
ArgumentDouble argumentDouble = (ArgumentDouble) argument;
argumentNode.parser = "brigadier:double";
argumentNode.properties = packetWriter -> {
packetWriter.writeByte(getNumberProperties(argumentDouble));
if (argumentDouble.hasMin())
packetWriter.writeDouble(argumentDouble.getMin());
if (argumentDouble.hasMax())
packetWriter.writeDouble(argumentDouble.getMax());
};
} else if (argument instanceof ArgumentFloat) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
ArgumentFloat argumentFloat = (ArgumentFloat) argument;
argumentNode.parser = "brigadier:float";
argumentNode.properties = packetWriter -> {
packetWriter.writeByte(getNumberProperties(argumentFloat));
if (argumentFloat.hasMin())
packetWriter.writeFloat(argumentFloat.getMin());
if (argumentFloat.hasMax())
packetWriter.writeFloat(argumentFloat.getMax());
};
} else if (argument instanceof ArgumentInteger) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
ArgumentInteger argumentInteger = (ArgumentInteger) argument;
argumentNode.parser = "brigadier:integer";
argumentNode.properties = packetWriter -> {
packetWriter.writeByte(getNumberProperties(argumentInteger));
if (argumentInteger.hasMin())
packetWriter.writeInt(argumentInteger.getMin());
if (argumentInteger.hasMax())
packetWriter.writeInt(argumentInteger.getMax());
};
} else if (argument instanceof ArgumentWord) {
ArgumentWord argumentWord = (ArgumentWord) argument;
// Add the single word properties + parser
final Consumer<DeclareCommandsPacket.Node> wordConsumer = node -> {
node.parser = "brigadier:string";
node.properties = packetWriter -> {
packetWriter.writeVarInt(0); // Single word
};
};
final boolean hasRestriction = argumentWord.hasRestrictions();
if (hasRestriction) {
// Create a node for each restrictions as literal
for (String restrictionWord : argumentWord.getRestrictions()) {
DeclareCommandsPacket.Node argumentNode = new DeclareCommandsPacket.Node();
nodes.add(argumentNode);
argumentNode.flags = getFlag(NodeType.LITERAL, executable, false, false);
argumentNode.name = restrictionWord;
wordConsumer.accept(argumentNode);
}
} else {
// Can be any word, add only one argument node
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
wordConsumer.accept(argumentNode);
}
} else if (argument instanceof ArgumentDynamicWord) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, true);
final SuggestionType suggestionType = ((ArgumentDynamicWord) argument).getSuggestionType();
argumentNode.parser = "brigadier:string";
argumentNode.properties = packetWriter -> {
packetWriter.writeVarInt(0); // Single word
};
argumentNode.suggestionsType = suggestionType.getIdentifier();
} else if (argument instanceof ArgumentString) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "brigadier:string";
argumentNode.properties = packetWriter -> {
packetWriter.writeVarInt(1); // Quotable phrase
};
} else if (argument instanceof ArgumentStringArray) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "brigadier:string";
argumentNode.properties = packetWriter -> {
packetWriter.writeVarInt(2); // Greedy phrase
};
} else if (argument instanceof ArgumentDynamicStringArray) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, true);
argumentNode.parser = "brigadier:string";
argumentNode.properties = packetWriter -> {
packetWriter.writeVarInt(2); // Greedy phrase
};
argumentNode.suggestionsType = "minecraft:ask_server";
} else if (argument instanceof ArgumentColor) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:color";
} else if (argument instanceof ArgumentTime) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:time";
} else if (argument instanceof ArgumentEnchantment) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:item_enchantment";
} else if (argument instanceof ArgumentParticle) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:particle";
} else if (argument instanceof ArgumentPotionEffect) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:mob_effect";
} else if (argument instanceof ArgumentEntityType) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:entity_summon";
} else if (argument instanceof ArgumentBlockState) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:block_state";
} else if (argument instanceof ArgumentIntRange) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:int_range";
} else if (argument instanceof ArgumentFloatRange) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:float_range";
} else if (argument instanceof ArgumentEntity) {
ArgumentEntity argumentEntity = (ArgumentEntity) argument;
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:entity";
argumentNode.properties = packetWriter -> {
byte mask = 0;
if (argumentEntity.isOnlySingleEntity()) {
mask += 1;
}
if (argumentEntity.isOnlyPlayers()) {
mask += 2;
}
packetWriter.writeByte(mask);
};
} else if (argument instanceof ArgumentItemStack) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:item_stack";
} else if (argument instanceof ArgumentNbtCompoundTag) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:nbt_compound_tag";
} else if (argument instanceof ArgumentNbtTag) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:nbt_tag";
} else if (argument instanceof ArgumentRelativeBlockPosition) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:block_pos";
} else if (argument instanceof ArgumentRelativeVec3) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:vec3";
} else if (argument instanceof ArgumentRelativeVec2) {
DeclareCommandsPacket.Node argumentNode = simpleArgumentNode(nodes, argument, executable, false);
argumentNode.parser = "minecraft:vec2";
}
return nodes;
*/
return argument.toNodes(executable);
}
private byte getNumberProperties(@NotNull ArgumentNumber<? extends Number> argumentNumber) {
public byte getNumberProperties(@NotNull ArgumentNumber<? extends Number> argumentNumber) {
byte result = 0;
if (argumentNumber.hasMin())
result += 1;
@ -699,18 +527,16 @@ public final class CommandManager {
}
/**
* Builds an argument nod and add it to the nodes list.
* Builds an argument node.
*
* @param nodes the current nodes list
* @param argument the argument
* @param executable true if this will be the last argument, false otherwise
* @return the created {@link DeclareCommandsPacket.Node}
*/
@NotNull
private DeclareCommandsPacket.Node simpleArgumentNode(@NotNull List<DeclareCommandsPacket.Node> nodes,
@NotNull Argument<?> argument, boolean executable, boolean suggestion) {
public DeclareCommandsPacket.Node simpleArgumentNode(@NotNull Argument<?> argument,
boolean executable, boolean suggestion) {
DeclareCommandsPacket.Node argumentNode = new DeclareCommandsPacket.Node();
nodes.add(argumentNode);
argumentNode.flags = getFlag(NodeType.ARGUMENT, executable, false, suggestion);
argumentNode.name = argument.getId();
@ -718,7 +544,7 @@ public final class CommandManager {
return argumentNode;
}
private byte getFlag(@NotNull NodeType type, boolean executable, boolean redirect, boolean suggestionType) {
public byte getFlag(@NotNull NodeType type, boolean executable, boolean redirect, boolean suggestionType) {
byte result = (byte) type.mask;
if (executable) {
@ -735,7 +561,7 @@ public final class CommandManager {
return result;
}
private enum NodeType {
public enum NodeType {
ROOT(0), LITERAL(0b1), ARGUMENT(0b10), NONE(0x11);
private final int mask;

11
src/main/java/net/minestom/server/command/builder/arguments/Argument.java
View File

@ -4,9 +4,12 @@ import net.minestom.server.command.builder.ArgumentCallback;
import net.minestom.server.command.builder.Command;
import net.minestom.server.command.builder.CommandExecutor;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
/**
* An argument is meant to be parsed when added into a {@link Command}'s syntax with {@link Command#addSyntax(CommandExecutor, Argument[])}.
* <p>
@ -69,6 +72,14 @@ public abstract class Argument<T> {
@NotNull
public abstract T parse(@NotNull String input) throws ArgumentSyntaxException;
/**
* Turns the argument into a list of nodes for command dispatching. Make sure to set the Node's parser.
*
* @return the argument as a list of command packet nodes
*/
@NotNull
public abstract DeclareCommandsPacket.Node[] toNodes(boolean executable);
/**
* Gets the ID of the argument, showed in-game above the chat bar
* and used to retrieve the data when the command is parsed in {@link net.minestom.server.command.builder.Arguments}.

15
src/main/java/net/minestom/server/command/builder/arguments/ArgumentBoolean.java
View File

@ -1,8 +1,13 @@
package net.minestom.server.command.builder.arguments;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.CommandManager;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import org.jetbrains.annotations.NotNull;
import java.util.List;
/**
* Represents a boolean value.
* <p>
@ -27,4 +32,14 @@ public class ArgumentBoolean extends Argument<Boolean> {
throw new ArgumentSyntaxException("Not a boolean", input, NOT_BOOLEAN_ERROR);
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "brigadier:bool";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

16
src/main/java/net/minestom/server/command/builder/arguments/ArgumentDynamicStringArray.java
View File

@ -1,7 +1,9 @@
package net.minestom.server.command.builder.arguments;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.CommandSender;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.callback.validator.StringArrayValidator;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
@ -36,6 +38,20 @@ public class ArgumentDynamicStringArray extends Argument<String[]> {
return value;
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, true);
argumentNode.parser = "brigadier:string";
argumentNode.properties = packetWriter -> {
packetWriter.writeVarInt(2); // Greedy phrase
};
argumentNode.suggestionsType = "minecraft:ask_server";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
/**
* Sets the dynamic restriction of this dynamic argument.
* <p>

17
src/main/java/net/minestom/server/command/builder/arguments/ArgumentDynamicWord.java
View File

@ -1,8 +1,10 @@
package net.minestom.server.command.builder.arguments;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.CommandSender;
import net.minestom.server.command.builder.arguments.minecraft.SuggestionType;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.callback.validator.StringValidator;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
@ -43,6 +45,21 @@ public class ArgumentDynamicWord extends Argument<String> {
return input;
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, true);
final SuggestionType suggestionType = this.getSuggestionType();
argumentNode.parser = "brigadier:string";
argumentNode.properties = packetWriter -> {
packetWriter.writeVarInt(0); // Single word
};
argumentNode.suggestionsType = suggestionType.getIdentifier();
return new DeclareCommandsPacket.Node[]{argumentNode};
}
/**
* Gets the suggestion type of this argument.
* <p>

14
src/main/java/net/minestom/server/command/builder/arguments/ArgumentString.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import org.apache.commons.text.StringEscapeUtils;
import org.jetbrains.annotations.NotNull;
@ -23,6 +25,18 @@ public class ArgumentString extends Argument<String> {
return staticParse(input);
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "brigadier:string";
argumentNode.properties = packetWriter -> {
packetWriter.writeVarInt(1); // Quotable phrase
};
return new DeclareCommandsPacket.Node[]{argumentNode};
}
@NotNull
public static String staticParse(@NotNull String input) throws ArgumentSyntaxException {
// Check if value start and end with quote

14
src/main/java/net/minestom/server/command/builder/arguments/ArgumentStringArray.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
@ -22,4 +24,16 @@ public class ArgumentStringArray extends Argument<String[]> {
public String[] parse(@NotNull String input) throws ArgumentSyntaxException {
return input.split(Pattern.quote(StringUtils.SPACE));
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "brigadier:string";
argumentNode.properties = packetWriter -> {
packetWriter.writeVarInt(2); // Greedy phrase
};
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

41
src/main/java/net/minestom/server/command/builder/arguments/ArgumentWord.java
View File

@ -1,12 +1,16 @@
package net.minestom.server.command.builder.arguments;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.CommandManager;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.validate.Check;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Arrays;
import java.util.function.Consumer;
/**
* Represents a single word in the command.
@ -68,6 +72,43 @@ public class ArgumentWord extends Argument<String> {
return input;
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
// Add the single word properties + parser
final Consumer<DeclareCommandsPacket.Node> wordConsumer = node -> {
node.parser = "brigadier:string";
node.properties = packetWriter -> {
packetWriter.writeVarInt(0); // Single word
};
};
final boolean hasRestriction = this.hasRestrictions();
if (hasRestriction) {
// Create a primitive array for mapping
DeclareCommandsPacket.Node[] nodes = new DeclareCommandsPacket.Node[this.getRestrictions().length];
// Create a node for each restrictions as literal
for (int i = 0; i < nodes.length; i++) {
DeclareCommandsPacket.Node argumentNode = new DeclareCommandsPacket.Node();
argumentNode.flags = MinecraftServer.getCommandManager().getFlag(CommandManager.NodeType.LITERAL, executable, false, false);
argumentNode.name = this.getRestrictions()[i];
wordConsumer.accept(argumentNode);
nodes[i] = argumentNode;
}
return nodes;
} else {
// Can be any word, add only one argument node
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
wordConsumer.accept(argumentNode);
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}
/**
* Gets if this argument allow complete freedom in the word choice or if a list has been defined.
*

10
src/main/java/net/minestom/server/command/builder/arguments/minecraft/ArgumentColor.java
View File

@ -1,8 +1,10 @@
package net.minestom.server.command.builder.arguments.minecraft;
import net.minestom.server.MinecraftServer;
import net.minestom.server.chat.ChatColor;
import net.minestom.server.command.builder.arguments.Argument;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import org.jetbrains.annotations.NotNull;
/**
@ -27,4 +29,12 @@ public class ArgumentColor extends Argument<ChatColor> {
return color;
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:color";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

20
src/main/java/net/minestom/server/command/builder/arguments/minecraft/ArgumentEntity.java
View File

@ -6,6 +6,7 @@ import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.entity.EntityType;
import net.minestom.server.entity.GameMode;
import net.minestom.server.network.ConnectionManager;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.registry.Registries;
import net.minestom.server.utils.entity.EntityFinder;
import net.minestom.server.utils.math.IntRange;
@ -67,6 +68,25 @@ public class ArgumentEntity extends Argument<EntityFinder> {
return staticParse(input, onlySingleEntity, onlyPlayers);
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:entity";
argumentNode.properties = packetWriter -> {
byte mask = 0;
if (this.isOnlySingleEntity()) {
mask += 1;
}
if (this.isOnlyPlayers()) {
mask += 2;
}
packetWriter.writeByte(mask);
};
return new DeclareCommandsPacket.Node[]{argumentNode};
}
@NotNull
public static EntityFinder staticParse(@NotNull String input,
boolean onlySingleEntity, boolean onlyPlayers) throws ArgumentSyntaxException {

10
src/main/java/net/minestom/server/command/builder/arguments/minecraft/ArgumentFloatRange.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments.minecraft;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.math.FloatRange;
import org.jetbrains.annotations.NotNull;
@ -52,4 +54,12 @@ public class ArgumentFloatRange extends ArgumentRange<FloatRange> {
throw new ArgumentSyntaxException("Invalid number", input, FORMAT_ERROR);
}
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:float_range";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/minecraft/ArgumentIntRange.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments.minecraft;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.math.IntRange;
import org.jetbrains.annotations.NotNull;
@ -57,4 +59,12 @@ public class ArgumentIntRange extends ArgumentRange<IntRange> {
throw new ArgumentSyntaxException("Invalid number", input, FORMAT_ERROR);
}
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:int_range";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/minecraft/ArgumentItemStack.java
View File

@ -1,9 +1,11 @@
package net.minestom.server.command.builder.arguments.minecraft;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.arguments.Argument;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.item.ItemStack;
import net.minestom.server.item.Material;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.registry.Registries;
import net.minestom.server.utils.NBTUtils;
import org.jetbrains.annotations.NotNull;
@ -61,4 +63,12 @@ public class ArgumentItemStack extends Argument<ItemStack> {
return itemStack;
}
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:item_stack";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/minecraft/ArgumentNbtCompoundTag.java
View File

@ -1,7 +1,9 @@
package net.minestom.server.command.builder.arguments.minecraft;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.arguments.Argument;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import org.jetbrains.annotations.NotNull;
import org.jglrxavpok.hephaistos.nbt.NBT;
import org.jglrxavpok.hephaistos.nbt.NBTCompound;
@ -37,4 +39,12 @@ public class ArgumentNbtCompoundTag extends Argument<NBTCompound> {
throw new ArgumentSyntaxException("NBTCompound is invalid", input, INVALID_NBT);
}
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:nbt_compound_tag";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/minecraft/ArgumentNbtTag.java
View File

@ -1,7 +1,9 @@
package net.minestom.server.command.builder.arguments.minecraft;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.arguments.Argument;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import org.jetbrains.annotations.NotNull;
import org.jglrxavpok.hephaistos.nbt.NBT;
import org.jglrxavpok.hephaistos.nbt.NBTException;
@ -33,4 +35,12 @@ public class ArgumentNbtTag extends Argument<NBT> {
throw new ArgumentSyntaxException("Invalid NBT", input, INVALID_NBT);
}
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:nbt_tag";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/minecraft/ArgumentTime.java
View File

@ -2,8 +2,10 @@ package net.minestom.server.command.builder.arguments.minecraft;
import it.unimi.dsi.fastutil.chars.CharArrayList;
import it.unimi.dsi.fastutil.chars.CharList;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.arguments.Argument;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.time.TimeUnit;
import net.minestom.server.utils.time.UpdateOption;
import org.jetbrains.annotations.NotNull;
@ -51,4 +53,12 @@ public class ArgumentTime extends Argument<UpdateOption> {
throw new ArgumentSyntaxException("Time needs to be a number", input, NO_NUMBER);
}
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:time";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/minecraft/registry/ArgumentBlockState.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments.minecraft.registry;
import net.minestom.server.MinecraftServer;
import net.minestom.server.instance.block.Block;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.registry.Registries;
import org.jetbrains.annotations.NotNull;
@ -14,4 +16,12 @@ public class ArgumentBlockState extends ArgumentRegistry<Block> {
public Block getRegistry(@NotNull String value) {
return Registries.getBlock(value);
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:block_state";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/minecraft/registry/ArgumentEnchantment.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments.minecraft.registry;
import net.minestom.server.MinecraftServer;
import net.minestom.server.item.Enchantment;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.registry.Registries;
import org.jetbrains.annotations.NotNull;
@ -17,4 +19,12 @@ public class ArgumentEnchantment extends ArgumentRegistry<Enchantment> {
public Enchantment getRegistry(@NotNull String value) {
return Registries.getEnchantment(value);
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:item_enchantment";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/minecraft/registry/ArgumentEntityType.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments.minecraft.registry;
import net.minestom.server.MinecraftServer;
import net.minestom.server.entity.EntityType;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.registry.Registries;
import org.jetbrains.annotations.NotNull;
@ -17,4 +19,12 @@ public class ArgumentEntityType extends ArgumentRegistry<EntityType> {
public EntityType getRegistry(@NotNull String value) {
return Registries.getEntityType(value);
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:entity_summon";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/minecraft/registry/ArgumentParticle.java
View File

@ -1,5 +1,7 @@
package net.minestom.server.command.builder.arguments.minecraft.registry;
import net.minestom.server.MinecraftServer;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.particle.Particle;
import net.minestom.server.registry.Registries;
import org.jetbrains.annotations.NotNull;
@ -17,4 +19,12 @@ public class ArgumentParticle extends ArgumentRegistry<Particle> {
public Particle getRegistry(@NotNull String value) {
return Registries.getParticle(value);
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:particle";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/minecraft/registry/ArgumentPotionEffect.java
View File

@ -1,5 +1,7 @@
package net.minestom.server.command.builder.arguments.minecraft.registry;
import net.minestom.server.MinecraftServer;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.potion.PotionEffect;
import net.minestom.server.registry.Registries;
import org.jetbrains.annotations.NotNull;
@ -17,4 +19,12 @@ public class ArgumentPotionEffect extends ArgumentRegistry<PotionEffect> {
public PotionEffect getRegistry(@NotNull String value) {
return Registries.getPotionEffect(value);
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:mob_effect";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

19
src/main/java/net/minestom/server/command/builder/arguments/number/ArgumentDouble.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments.number;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import org.jetbrains.annotations.NotNull;
public class ArgumentDouble extends ArgumentNumber<Double> {
@ -40,4 +42,21 @@ public class ArgumentDouble extends ArgumentNumber<Double> {
}
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "brigadier:double";
argumentNode.properties = packetWriter -> {
packetWriter.writeByte(MinecraftServer.getCommandManager().getNumberProperties(this));
if (this.hasMin())
packetWriter.writeDouble(this.getMin());
if (this.hasMax())
packetWriter.writeDouble(this.getMax());
};
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

19
src/main/java/net/minestom/server/command/builder/arguments/number/ArgumentFloat.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments.number;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import org.jetbrains.annotations.NotNull;
public class ArgumentFloat extends ArgumentNumber<Float> {
@ -40,4 +42,21 @@ public class ArgumentFloat extends ArgumentNumber<Float> {
}
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "brigadier:float";
argumentNode.properties = packetWriter -> {
packetWriter.writeByte(MinecraftServer.getCommandManager().getNumberProperties(this));
if (this.hasMin())
packetWriter.writeFloat(this.getMin());
if (this.hasMax())
packetWriter.writeFloat(this.getMax());
};
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

19
src/main/java/net/minestom/server/command/builder/arguments/number/ArgumentInteger.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments.number;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import org.jetbrains.annotations.NotNull;
public class ArgumentInteger extends ArgumentNumber<Integer> {
@ -31,4 +33,21 @@ public class ArgumentInteger extends ArgumentNumber<Integer> {
}
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "brigadier:integer";
argumentNode.properties = packetWriter -> {
packetWriter.writeByte(MinecraftServer.getCommandManager().getNumberProperties(this));
if (this.hasMin())
packetWriter.writeInt(this.getMin());
if (this.hasMax())
packetWriter.writeInt(this.getMax());
};
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/relative/ArgumentRelativeBlockPosition.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments.relative;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.BlockPosition;
import net.minestom.server.utils.location.RelativeBlockPosition;
import org.apache.commons.lang3.StringUtils;
@ -78,4 +80,12 @@ public class ArgumentRelativeBlockPosition extends ArgumentRelative<RelativeBloc
return new RelativeBlockPosition(blockPosition, relativeX, relativeY, relativeZ);
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:block_pos";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/relative/ArgumentRelativeVec2.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments.relative;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.Vector;
import net.minestom.server.utils.location.RelativeVec;
import org.apache.commons.lang3.StringUtils;
@ -67,4 +69,12 @@ public class ArgumentRelativeVec2 extends ArgumentRelative<RelativeVec> {
return new RelativeVec(vector, relativeX, false, relativeZ);
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:vec2";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}

10
src/main/java/net/minestom/server/command/builder/arguments/relative/ArgumentRelativeVec3.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.command.builder.arguments.relative;
import net.minestom.server.MinecraftServer;
import net.minestom.server.command.builder.exception.ArgumentSyntaxException;
import net.minestom.server.network.packet.server.play.DeclareCommandsPacket;
import net.minestom.server.utils.Vector;
import net.minestom.server.utils.location.RelativeVec;
import org.apache.commons.lang3.StringUtils;
@ -73,4 +75,12 @@ public class ArgumentRelativeVec3 extends ArgumentRelative<RelativeVec> {
return new RelativeVec(vector, relativeX, relativeY, relativeZ);
}
@NotNull
@Override
public DeclareCommandsPacket.Node[] toNodes(boolean executable) {
DeclareCommandsPacket.Node argumentNode = MinecraftServer.getCommandManager().simpleArgumentNode(this, executable, false);
argumentNode.parser = "minecraft:vec3";
return new DeclareCommandsPacket.Node[]{argumentNode};
}
}