From 57ce7f3f2768b47294d5952c3e44bdf6e125a9d5 Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Sun, 8 May 2022 15:13:43 -0500 Subject: [PATCH 01/18] Initial commit Getting the ball rolling, followed bukkit impl as a guide --- .../sponge/SpongeAsyncExecutionProvider.java | 11 +++ .../triumphteam/cmd/sponge/SpongeCommand.java | 84 +++++++++++++++++++ .../cmd/sponge/SpongeCommandManager.java | 30 +++++++ .../cmd/sponge/SpongeSenderValidator.java | 20 +++++ .../cmd/sponge/SpongeSubCommand.java | 12 +++ .../cmd/sponge/SpongeSubCommandProcessor.java | 15 ++++ .../cmd/sponge/annotation/Permission.java | 38 +++++++++ .../message/NoPermissionMessageContext.java | 46 ++++++++++ .../cmd/sponge/message/SpongeMessageKey.java | 65 ++++++++++++++ settings.gradle.kts | 1 + 10 files changed, 322 insertions(+) create mode 100644 minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java create mode 100644 minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java create mode 100644 minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java create mode 100644 minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java create mode 100644 minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommand.java create mode 100644 minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java create mode 100644 minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/annotation/Permission.java create mode 100644 minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/NoPermissionMessageContext.java create mode 100644 minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/SpongeMessageKey.java diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java new file mode 100644 index 00000000..b6ed55ac --- /dev/null +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java @@ -0,0 +1,11 @@ +package dev.triumphteam.cmd.sponge; + +import dev.triumphteam.cmd.core.execution.ExecutionProvider; +import org.jetbrains.annotations.NotNull; + +public class SpongeAsyncExecutionProvider implements ExecutionProvider { + @Override + public void execute(@NotNull Runnable command) { + + } +} diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java new file mode 100644 index 00000000..bb5619ca --- /dev/null +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java @@ -0,0 +1,84 @@ +/** + * MIT License + * + * Copyright (c) 2019-2021 Matt + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package dev.triumphteam.cmd.sponge; + +import net.kyori.adventure.text.Component; +import org.checkerframework.checker.nullness.qual.NonNull; +import org.jetbrains.annotations.NotNull; +import org.spongepowered.api.command.Command; +import org.spongepowered.api.command.CommandCause; +import org.spongepowered.api.command.CommandCompletion; +import org.spongepowered.api.command.CommandResult; +import org.spongepowered.api.command.exception.CommandException; +import org.spongepowered.api.command.parameter.ArgumentReader; +import org.spongepowered.api.command.registrar.tree.CommandTreeNode; + +import java.util.*; + +public final class SpongeCommand implements Command.Raw, dev.triumphteam.cmd.core.Command> { + + @Override + public CommandResult process(CommandCause cause, ArgumentReader.Mutable arguments) throws CommandException { + return null; + } + + @Override + public List complete(CommandCause cause, ArgumentReader.Mutable arguments) throws CommandException { + return null; + } + + @Override + public boolean canExecute(CommandCause cause) { + return false; + } + + @Override + public Optional shortDescription(CommandCause cause) { + return Optional.empty(); + } + + @Override + public Optional extendedDescription(CommandCause cause) { + return Optional.empty(); + } + + @Override + public Optional help(@NonNull CommandCause cause) { + return Raw.super.help(cause); + } + + @Override + public Component usage(CommandCause cause) { + return null; + } + @Override + public CommandTreeNode.Root commandTree() { + return Raw.super.commandTree(); + } + + @Override + public void addSubCommands(@NotNull Map> subCommands, @NotNull Map> subCommandAliases) { + + } +} diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java new file mode 100644 index 00000000..0f12cf43 --- /dev/null +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java @@ -0,0 +1,30 @@ +package dev.triumphteam.cmd.sponge; + +import dev.triumphteam.cmd.core.BaseCommand; +import dev.triumphteam.cmd.core.CommandManager; +import dev.triumphteam.cmd.core.registry.RegistryContainer; +import dev.triumphteam.cmd.core.sender.SenderMapper; +import dev.triumphteam.cmd.core.sender.SenderValidator; +import org.jetbrains.annotations.NotNull; +import org.spongepowered.api.command.CommandCause; + +public class SpongeCommandManager extends CommandManager { + public SpongeCommandManager(@NotNull SenderMapper senderMapper, @NotNull SenderValidator senderValidator) { + super(senderMapper, senderValidator); + } + + @Override + public void registerCommand(@NotNull BaseCommand baseCommand) { + + } + + @Override + public void unregisterCommand(@NotNull BaseCommand command) { + + } + + @Override + protected @NotNull RegistryContainer getRegistryContainer() { + return null; + } +} diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java new file mode 100644 index 00000000..5ead91a2 --- /dev/null +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java @@ -0,0 +1,20 @@ +package dev.triumphteam.cmd.sponge; + +import dev.triumphteam.cmd.core.SubCommand; +import dev.triumphteam.cmd.core.message.MessageRegistry; +import dev.triumphteam.cmd.core.sender.SenderValidator; +import org.jetbrains.annotations.NotNull; + +import java.util.Set; + +public class SpongeSenderValidator implements SenderValidator { + @Override + public @NotNull Set> getAllowedSenders() { + return null; + } + + @Override + public boolean validate(@NotNull MessageRegistry messageRegistry, @NotNull SubCommand subCommand, @NotNull S sender) { + return false; + } +} diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommand.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommand.java new file mode 100644 index 00000000..f773fd70 --- /dev/null +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommand.java @@ -0,0 +1,12 @@ +package dev.triumphteam.cmd.sponge; + +import dev.triumphteam.cmd.core.AbstractSubCommand; +import dev.triumphteam.cmd.core.execution.ExecutionProvider; +import dev.triumphteam.cmd.core.processor.AbstractSubCommandProcessor; +import org.jetbrains.annotations.NotNull; + +public class SpongeSubCommand extends AbstractSubCommand { + public SpongeSubCommand(@NotNull AbstractSubCommandProcessor processor, @NotNull String parentName, @NotNull ExecutionProvider executionProvider) { + super(processor, parentName, executionProvider); + } +} diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java new file mode 100644 index 00000000..97a592ea --- /dev/null +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java @@ -0,0 +1,15 @@ +package dev.triumphteam.cmd.sponge; + +import dev.triumphteam.cmd.core.BaseCommand; +import dev.triumphteam.cmd.core.processor.AbstractSubCommandProcessor; +import dev.triumphteam.cmd.core.registry.RegistryContainer; +import dev.triumphteam.cmd.core.sender.SenderValidator; +import org.jetbrains.annotations.NotNull; + +import java.lang.reflect.Method; + +public class SpongeSubCommandProcessor extends AbstractSubCommandProcessor { + protected SpongeSubCommandProcessor(@NotNull BaseCommand baseCommand, @NotNull String parentName, @NotNull Method method, @NotNull RegistryContainer registryContainer, @NotNull SenderValidator senderValidator) { + super(baseCommand, parentName, method, registryContainer, senderValidator); + } +} diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/annotation/Permission.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/annotation/Permission.java new file mode 100644 index 00000000..9877a0c9 --- /dev/null +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/annotation/Permission.java @@ -0,0 +1,38 @@ +/** + * MIT License + * + * Copyright (c) 2019-2021 Matt + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package dev.triumphteam.cmd.sponge.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Annotate a method using this Annotation to add a required permission + */ +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.METHOD) +public @interface Permission { + String value(); +} diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/NoPermissionMessageContext.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/NoPermissionMessageContext.java new file mode 100644 index 00000000..ad192939 --- /dev/null +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/NoPermissionMessageContext.java @@ -0,0 +1,46 @@ +/** + * MIT License + * + * Copyright (c) 2019-2021 Matt + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package dev.triumphteam.cmd.sponge.message; + +import dev.triumphteam.cmd.core.message.context.AbstractMessageContext; +import org.jetbrains.annotations.NotNull; + +public final class NoPermissionMessageContext extends AbstractMessageContext { + + private final String permission; + + public NoPermissionMessageContext( + @NotNull final String command, + @NotNull final String subCommand, + @NotNull final String permission + ) { + super(command, subCommand); + this.permission = permission; + } + + public String getPermission() { + return permission; + } + +} diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/SpongeMessageKey.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/SpongeMessageKey.java new file mode 100644 index 00000000..a8ab9eb2 --- /dev/null +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/SpongeMessageKey.java @@ -0,0 +1,65 @@ +/** + * MIT License + * + * Copyright (c) 2019-2021 Matt + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package dev.triumphteam.cmd.sponge.message; + +import dev.triumphteam.cmd.core.message.ContextualKey; +import dev.triumphteam.cmd.core.message.context.MessageContext; +import org.jetbrains.annotations.Contract; +import org.jetbrains.annotations.NotNull; + +/** + * {@link SpongeMessageKey} is used for easier registering of messages with different {@link MessageContext}. + * + * @param A {@link MessageContext} type, this allows for better customization of the messages. + */ +public final class SpongeMessageKey extends ContextualKey { + + // Default keys + public static final SpongeMessageKey NO_PERMISSION = of("no.permission", NoPermissionMessageContext.class); + public static final SpongeMessageKey PLAYER_ONLY = of("player.only", MessageContext.class); + public static final SpongeMessageKey CONSOLE_ONLY = of("console.only", MessageContext.class); + + private SpongeMessageKey(@NotNull final String key, @NotNull final Class type) { + super(key, type); + } + + /** + * Factory method for creating a {@link SpongeMessageKey}. + * + * @param key The value of the key, normally separated by .. + * @param type The {@link MessageContext} type. + * @param Generic {@link MessageContext} type. + * @return A new {@link SpongeMessageKey} for a specific {@link MessageContext}. + */ + @NotNull + @Contract("_, _ -> new") + private static SpongeMessageKey of(@NotNull final String key, @NotNull final Class type) { + return new SpongeMessageKey<>(key, type); + } + + @Override + public String toString() { + return "SpongeMessageKey{super=" + super.toString() + "}"; + } +} diff --git a/settings.gradle.kts b/settings.gradle.kts index ff163ce7..290c852f 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -13,6 +13,7 @@ listOf( listOf( "minecraft/bukkit", + "minecraft/sponge", "discord/jda-common", "discord/jda-prefixed", "discord/jda-slash", From d554bd9ff55c56619b31275acf4879dad060b7df Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Sun, 8 May 2022 19:30:09 -0500 Subject: [PATCH 02/18] SpongeCommand mostly done Most is pulled from bukkitCommands and modified! --- .../triumphteam/cmd/sponge/SpongeCommand.java | 134 ++++++++++++++++-- .../cmd/sponge/SpongeCommandProcessor.java | 30 ++++ .../cmd/sponge/SpongeSubCommand.java | 45 +++++- .../cmd/sponge/SpongeSubCommandProcessor.java | 34 ++++- 4 files changed, 227 insertions(+), 16 deletions(-) create mode 100644 minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java index bb5619ca..02e9aad1 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java @@ -23,44 +23,127 @@ */ package dev.triumphteam.cmd.sponge; +import dev.triumphteam.cmd.core.SubCommand; +import dev.triumphteam.cmd.core.annotation.Default; +import dev.triumphteam.cmd.core.message.MessageRegistry; +import dev.triumphteam.cmd.core.registry.RegistryContainer; +import dev.triumphteam.cmd.core.sender.SenderMapper; import net.kyori.adventure.text.Component; import org.checkerframework.checker.nullness.qual.NonNull; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.spongepowered.api.command.Command; import org.spongepowered.api.command.CommandCause; import org.spongepowered.api.command.CommandCompletion; import org.spongepowered.api.command.CommandResult; import org.spongepowered.api.command.exception.CommandException; import org.spongepowered.api.command.parameter.ArgumentReader; -import org.spongepowered.api.command.registrar.tree.CommandTreeNode; import java.util.*; +import java.util.stream.Collectors; + +import static java.util.Collections.emptyList; public final class SpongeCommand implements Command.Raw, dev.triumphteam.cmd.core.Command> { + private final MessageRegistry messageRegistry; + + private final SenderMapper senderMapper; + + private final Map> subCommands = new HashMap<>(); + private final Map> subCommandAliases = new HashMap<>(); + private final String description; + + public SpongeCommand(@NotNull final SpongeCommandProcessor processor) { + RegistryContainer registryContainer = processor.getRegistryContainer(); + description = processor.getDescription(); + this.messageRegistry = registryContainer.getMessageRegistry(); + this.senderMapper = processor.getSenderMapper(); + } + @Override - public CommandResult process(CommandCause cause, ArgumentReader.Mutable arguments) throws CommandException { - return null; + public void addSubCommands( + @NotNull Map> subCommands, + @NotNull Map> subCommandAliases + ) { + this.subCommands.putAll(subCommands); + this.subCommandAliases.putAll(subCommandAliases); + } + + + @Override + public CommandResult process(CommandCause cause,ArgumentReader.Mutable arguments) throws CommandException { + final String[] args = arguments.totalLength() == 0 ? new String[0] : arguments.input().split(" "); + + SpongeSubCommand subCommand = getDefaultSubCommand(); + + String subCommandName = ""; + if (args.length > 0) subCommandName = args[0].toLowerCase(); + if (subCommand == null || subCommandExists(subCommandName)) { + subCommand = getSubCommand(subCommandName); + } + + final S mappedSender = senderMapper.map(cause); + + if (subCommand == null || (args.length > 0 && subCommand.isDefault() && !subCommand.hasArguments())) { + //TODO Utilize MessageKey.UNKNOWN_COMMAND + return CommandResult.error(Component.text("Unknown Command")); + } + + final String permission = subCommand.getPermission(); + if (!permission.isEmpty() && !cause.hasPermission(permission)) { + return CommandResult.error(Component.text("No Permission")); + } + + final List commandArgs = Arrays.asList(!subCommand.isDefault() ? Arrays.copyOfRange(args, 1, args.length) : args); + + subCommand.execute(mappedSender, commandArgs); + return CommandResult.success(); } @Override public List complete(CommandCause cause, ArgumentReader.Mutable arguments) throws CommandException { - return null; + String[] args = arguments.input().isEmpty() ? new String[]{""} : arguments.input().split(" "); + + if (args.length == 0) return emptyList(); + SpongeSubCommand subCommand = getDefaultSubCommand(); + + final String arg = args[0].toLowerCase(); + + if (args.length == 1 && (subCommand == null || !subCommand.hasArguments())) { + + return subCommands.entrySet().stream().filter(it -> !it.getValue().isDefault()).filter(it -> it.getKey().startsWith(arg)).filter(it -> { + final String permission = it.getValue().getPermission(); + if (permission.isEmpty()) return true; + return cause.hasPermission(permission); + }).map(s -> CommandCompletion.of(s.getKey())).collect(Collectors.toList()); + } + + if (subCommandExists(arg)) subCommand = getSubCommand(arg); + if (subCommand == null) return emptyList(); + + final String permission = subCommand.getPermission(); + if (!permission.isEmpty() && !cause.hasPermission(permission)) return emptyList(); + + final S mappedSender = senderMapper.map(cause); + + final List commandArgs = Arrays.asList(args); + return subCommand.getSuggestions(mappedSender, !subCommand.isDefault() ? commandArgs.subList(1, commandArgs.size()) : commandArgs); } @Override public boolean canExecute(CommandCause cause) { - return false; + return true; } @Override public Optional shortDescription(CommandCause cause) { - return Optional.empty(); + return Optional.of(Component.text(description)); } @Override public Optional extendedDescription(CommandCause cause) { - return Optional.empty(); + return Optional.of(Component.text(description)); } @Override @@ -70,15 +153,40 @@ public Optional help(@NonNull CommandCause cause) { @Override public Component usage(CommandCause cause) { - return null; + return Component.text(Objects.requireNonNull(getDefaultSubCommand()).getName()); } - @Override - public CommandTreeNode.Root commandTree() { - return Raw.super.commandTree(); + + + /** + * Gets a default command if present. + * + * @return A default SubCommand. + */ + @Nullable + private SpongeSubCommand getDefaultSubCommand() { + return subCommands.get(Default.DEFAULT_CMD_NAME); } - @Override - public void addSubCommands(@NotNull Map> subCommands, @NotNull Map> subCommandAliases) { + /** + * Used in order to search for the given {@link SubCommand} in the {@link #subCommandAliases} + * + * @param key the String to look for the {@link SubCommand} + * @return the {@link SubCommand} for the particular key or NULL + */ + @Nullable + private SpongeSubCommand getSubCommand(@NotNull final String key) { + final SpongeSubCommand subCommand = subCommands.get(key); + if (subCommand != null) return subCommand; + return subCommandAliases.get(key); + } + /** + * Checks if a SubCommand with the specified key exists. + * + * @param key the Key to check for + * @return whether a SubCommand with that key exists + */ + private boolean subCommandExists(@NotNull final String key) { + return subCommands.containsKey(key) || subCommandAliases.containsKey(key); } } diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java new file mode 100644 index 00000000..cee9fb53 --- /dev/null +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java @@ -0,0 +1,30 @@ +package dev.triumphteam.cmd.sponge; + +import dev.triumphteam.cmd.core.BaseCommand; +import dev.triumphteam.cmd.core.execution.ExecutionProvider; +import dev.triumphteam.cmd.core.processor.AbstractCommandProcessor; +import dev.triumphteam.cmd.core.registry.RegistryContainer; +import dev.triumphteam.cmd.core.sender.SenderMapper; +import dev.triumphteam.cmd.core.sender.SenderValidator; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.spongepowered.api.command.CommandCause; + +import java.lang.reflect.Method; + +//extends AbstractCommandProcessor, BukkitSubCommandProcessor> { +public class SpongeCommandProcessor extends AbstractCommandProcessor, SpongeSubCommandProcessor> { + protected SpongeCommandProcessor(@NotNull BaseCommand baseCommand, @NotNull RegistryContainer registryContainer, @NotNull SenderMapper senderMapper, @NotNull SenderValidator senderValidator, @NotNull ExecutionProvider syncExecutionProvider, @NotNull ExecutionProvider asyncExecutionProvider) { + super(baseCommand, registryContainer, senderMapper, senderValidator, syncExecutionProvider, asyncExecutionProvider); + } + + @Override + protected @NotNull SpongeSubCommandProcessor createProcessor(@NotNull Method method) { + return null; + } + + @Override + protected @Nullable SpongeSubCommand createSubCommand(@NotNull SpongeSubCommandProcessor processor, @NotNull ExecutionProvider executionProvider) { + return null; + } +} diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommand.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommand.java index f773fd70..7e333eee 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommand.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommand.java @@ -1,12 +1,53 @@ package dev.triumphteam.cmd.sponge; import dev.triumphteam.cmd.core.AbstractSubCommand; +import dev.triumphteam.cmd.core.argument.InternalArgument; +import dev.triumphteam.cmd.core.argument.LimitlessInternalArgument; import dev.triumphteam.cmd.core.execution.ExecutionProvider; -import dev.triumphteam.cmd.core.processor.AbstractSubCommandProcessor; +import dev.triumphteam.cmd.core.suggestion.SuggestionContext; import org.jetbrains.annotations.NotNull; +import org.spongepowered.api.command.CommandCompletion; + +import java.util.List; +import java.util.stream.Collectors; + +import static java.util.Collections.emptyList; public class SpongeSubCommand extends AbstractSubCommand { - public SpongeSubCommand(@NotNull AbstractSubCommandProcessor processor, @NotNull String parentName, @NotNull ExecutionProvider executionProvider) { + + private final String permission; + public SpongeSubCommand( + @NotNull final SpongeSubCommandProcessor processor, + @NotNull final String parentName, + @NotNull final ExecutionProvider executionProvider + ) { super(processor, parentName, executionProvider); + this.permission = processor.getPermission(); + } + + // TODO: Comments + public String getPermission() { + return permission; + } + public List getSuggestions(@NotNull final S sender, @NotNull final List args) { + final int index = args.size() - 1; + final InternalArgument internalArgument = getArgument(index); + if (internalArgument == null) return emptyList(); + + final List trimmed; + if (internalArgument instanceof LimitlessInternalArgument) { + trimmed = args.subList(getArguments().size() - 1, args.size()); + } else { + trimmed = args.subList(index, args.size()); + } + + final SuggestionContext context = new SuggestionContext(args, getParentName(), getName()); + + return convertCompletions(internalArgument.suggestions(sender, trimmed, context)); } + + public List convertCompletions(List stringList) { + return stringList.stream().map(CommandCompletion::of).collect(Collectors.toList()); + } + } diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java index 97a592ea..42fe2cc3 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java @@ -1,15 +1,47 @@ package dev.triumphteam.cmd.sponge; import dev.triumphteam.cmd.core.BaseCommand; +import dev.triumphteam.cmd.core.exceptions.SubCommandRegistrationException; import dev.triumphteam.cmd.core.processor.AbstractSubCommandProcessor; import dev.triumphteam.cmd.core.registry.RegistryContainer; import dev.triumphteam.cmd.core.sender.SenderValidator; +import dev.triumphteam.cmd.sponge.annotation.Permission; import org.jetbrains.annotations.NotNull; import java.lang.reflect.Method; public class SpongeSubCommandProcessor extends AbstractSubCommandProcessor { - protected SpongeSubCommandProcessor(@NotNull BaseCommand baseCommand, @NotNull String parentName, @NotNull Method method, @NotNull RegistryContainer registryContainer, @NotNull SenderValidator senderValidator) { + + private String permission = ""; + + protected SpongeSubCommandProcessor( + @NotNull BaseCommand baseCommand, + @NotNull String parentName, + @NotNull Method method, + @NotNull RegistryContainer registryContainer, + @NotNull SenderValidator senderValidator + ) { super(baseCommand, parentName, method, registryContainer, senderValidator); + if (getName() == null) return; + checkPermission(getMethod()); + } + + @NotNull + public String getPermission() { + return permission; + } + + // TODO: 2/4/2022 comments + private void checkPermission(@NotNull final Method method) { + final Permission permission = method.getAnnotation(Permission.class); + if (permission == null) return; + + final String annotatedPermission = permission.value(); + + if (annotatedPermission.isEmpty()) { + throw new SubCommandRegistrationException("Permission cannot be empty", method, getBaseCommand().getClass()); + } + + this.permission = annotatedPermission; } } From a505bf6529022a0ab1f836b385a882698df1c2db Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Sun, 8 May 2022 19:55:55 -0500 Subject: [PATCH 03/18] Use message Registry instead of manual components The caveat is that we always return success (for now) --- .../java/dev/triumphteam/cmd/sponge/SpongeCommand.java | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java index 02e9aad1..5da67914 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java @@ -25,9 +25,13 @@ import dev.triumphteam.cmd.core.SubCommand; import dev.triumphteam.cmd.core.annotation.Default; +import dev.triumphteam.cmd.core.message.MessageKey; import dev.triumphteam.cmd.core.message.MessageRegistry; +import dev.triumphteam.cmd.core.message.context.DefaultMessageContext; import dev.triumphteam.cmd.core.registry.RegistryContainer; import dev.triumphteam.cmd.core.sender.SenderMapper; +import dev.triumphteam.cmd.sponge.message.NoPermissionMessageContext; +import dev.triumphteam.cmd.sponge.message.SpongeMessageKey; import net.kyori.adventure.text.Component; import org.checkerframework.checker.nullness.qual.NonNull; import org.jetbrains.annotations.NotNull; @@ -87,12 +91,14 @@ public CommandResult process(CommandCause cause,ArgumentReader.Mutable arguments if (subCommand == null || (args.length > 0 && subCommand.isDefault() && !subCommand.hasArguments())) { //TODO Utilize MessageKey.UNKNOWN_COMMAND - return CommandResult.error(Component.text("Unknown Command")); + messageRegistry.sendMessage(MessageKey.UNKNOWN_COMMAND, mappedSender, new DefaultMessageContext(cause.identifier(), subCommandName)); + return CommandResult.success(); } final String permission = subCommand.getPermission(); if (!permission.isEmpty() && !cause.hasPermission(permission)) { - return CommandResult.error(Component.text("No Permission")); + messageRegistry.sendMessage(SpongeMessageKey.NO_PERMISSION, mappedSender, new NoPermissionMessageContext(cause.identifier(), subCommand.getName(), permission)); + return CommandResult.success(); } final List commandArgs = Arrays.asList(!subCommand.isDefault() ? Arrays.copyOfRange(args, 1, args.length) : args); From 87c66ce51882091b00e1b0ea9a9a94409e61a76a Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Mon, 9 May 2022 14:09:10 -0500 Subject: [PATCH 04/18] More stuff and what nots --- .../sponge/SpongeAsyncExecutionProvider.java | 14 +++++- .../cmd/sponge/SpongeCommandManager.java | 45 ++++++++++++++++--- .../cmd/sponge/SpongeCommandProcessor.java | 30 +++++++++---- 3 files changed, 72 insertions(+), 17 deletions(-) diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java index b6ed55ac..2b65627e 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java @@ -2,10 +2,20 @@ import dev.triumphteam.cmd.core.execution.ExecutionProvider; import org.jetbrains.annotations.NotNull; +import org.spongepowered.api.Sponge; +import org.spongepowered.plugin.PluginContainer; -public class SpongeAsyncExecutionProvider implements ExecutionProvider { +public final class SpongeAsyncExecutionProvider implements ExecutionProvider { + + private final PluginContainer plugin; + + public SpongeAsyncExecutionProvider(@NotNull final PluginContainer plugin) { this.plugin = plugin; } + + /** + * {@inheritDoc} + */ @Override public void execute(@NotNull Runnable command) { - + Sponge.asyncScheduler().executor(plugin).submit(command); } } diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java index 0f12cf43..09a7d62c 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java @@ -2,29 +2,60 @@ import dev.triumphteam.cmd.core.BaseCommand; import dev.triumphteam.cmd.core.CommandManager; +import dev.triumphteam.cmd.core.execution.ExecutionProvider; +import dev.triumphteam.cmd.core.execution.SyncExecutionProvider; import dev.triumphteam.cmd.core.registry.RegistryContainer; import dev.triumphteam.cmd.core.sender.SenderMapper; import dev.triumphteam.cmd.core.sender.SenderValidator; import org.jetbrains.annotations.NotNull; import org.spongepowered.api.command.CommandCause; +import org.spongepowered.plugin.PluginContainer; -public class SpongeCommandManager extends CommandManager { - public SpongeCommandManager(@NotNull SenderMapper senderMapper, @NotNull SenderValidator senderValidator) { +import java.util.HashMap; +import java.util.Map; + +public final class SpongeCommandManager extends CommandManager { + + private final PluginContainer plugin; + + private final RegistryContainer registryContainer = new RegistryContainer<>(); + + private final Map> commands = new HashMap<>(); + + private final ExecutionProvider syncExecutionProvider = new SyncExecutionProvider(); + private final ExecutionProvider asyncExecutionProvider; + + + public SpongeCommandManager( + @NotNull final PluginContainer plugin, + @NotNull SenderMapper senderMapper, + @NotNull SenderValidator senderValidator + ) { super(senderMapper, senderValidator); + this.plugin = plugin; + this.asyncExecutionProvider = new SpongeAsyncExecutionProvider(plugin); } @Override - public void registerCommand(@NotNull BaseCommand baseCommand) { + public void registerCommand(@NotNull final BaseCommand baseCommand) { + final SpongeCommandProcessor processor = new SpongeCommandProcessor<>( + baseCommand, + registryContainer, + getSenderMapper(), + getSenderValidator(), + syncExecutionProvider, + asyncExecutionProvider + ); } @Override - public void unregisterCommand(@NotNull BaseCommand command) { - + public void unregisterCommand(@NotNull BaseCommand command) throws UnsupportedOperationException { + throw new UnsupportedOperationException(); } @Override - protected @NotNull RegistryContainer getRegistryContainer() { - return null; + protected @NotNull RegistryContainer getRegistryContainer() { + return registryContainer; } } diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java index cee9fb53..bc4767c8 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java @@ -7,24 +7,38 @@ import dev.triumphteam.cmd.core.sender.SenderMapper; import dev.triumphteam.cmd.core.sender.SenderValidator; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.spongepowered.api.command.CommandCause; import java.lang.reflect.Method; -//extends AbstractCommandProcessor, BukkitSubCommandProcessor> { -public class SpongeCommandProcessor extends AbstractCommandProcessor, SpongeSubCommandProcessor> { - protected SpongeCommandProcessor(@NotNull BaseCommand baseCommand, @NotNull RegistryContainer registryContainer, @NotNull SenderMapper senderMapper, @NotNull SenderValidator senderValidator, @NotNull ExecutionProvider syncExecutionProvider, @NotNull ExecutionProvider asyncExecutionProvider) { +final class SpongeCommandProcessor extends AbstractCommandProcessor, SpongeSubCommandProcessor> { + public SpongeCommandProcessor( + @NotNull final BaseCommand baseCommand, + @NotNull final RegistryContainer registryContainer, + @NotNull final SenderMapper senderMapper, + @NotNull final SenderValidator senderValidator, + @NotNull final ExecutionProvider syncExecutionProvider, + @NotNull final ExecutionProvider asyncExecutionProvider + ) { super(baseCommand, registryContainer, senderMapper, senderValidator, syncExecutionProvider, asyncExecutionProvider); } @Override - protected @NotNull SpongeSubCommandProcessor createProcessor(@NotNull Method method) { - return null; + protected @NotNull SpongeSubCommandProcessor createProcessor(@NotNull final Method method) { + return new SpongeSubCommandProcessor<>( + getBaseCommand(), + getName(), + method, + getRegistryContainer(), + getSenderValidator() + ); } @Override - protected @Nullable SpongeSubCommand createSubCommand(@NotNull SpongeSubCommandProcessor processor, @NotNull ExecutionProvider executionProvider) { - return null; + protected SpongeSubCommand createSubCommand( + @NotNull SpongeSubCommandProcessor processor, + @NotNull ExecutionProvider executionProvider + ) { + return new SpongeSubCommand<>(processor, getName(), executionProvider); } } From 6f3422caa31df369b989670d24f09eeb4ffb8fc1 Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Mon, 9 May 2022 16:39:58 -0500 Subject: [PATCH 05/18] Finish implementing rest of classes --- .../triumphteam/cmd/sponge/SpongeCommand.java | 1 - .../cmd/sponge/SpongeCommandManager.java | 20 ++++++++- .../cmd/sponge/SpongeSenderValidator.java | 43 ++++++++++++++++--- 3 files changed, 57 insertions(+), 7 deletions(-) diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java index 5da67914..922330d4 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java @@ -90,7 +90,6 @@ public CommandResult process(CommandCause cause,ArgumentReader.Mutable arguments final S mappedSender = senderMapper.map(cause); if (subCommand == null || (args.length > 0 && subCommand.isDefault() && !subCommand.hasArguments())) { - //TODO Utilize MessageKey.UNKNOWN_COMMAND messageRegistry.sendMessage(MessageKey.UNKNOWN_COMMAND, mappedSender, new DefaultMessageContext(cause.identifier(), subCommandName)); return CommandResult.success(); } diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java index 09a7d62c..610eca1a 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java @@ -8,7 +8,12 @@ import dev.triumphteam.cmd.core.sender.SenderMapper; import dev.triumphteam.cmd.core.sender.SenderValidator; import org.jetbrains.annotations.NotNull; +import org.spongepowered.api.Sponge; +import org.spongepowered.api.command.Command; import org.spongepowered.api.command.CommandCause; +import org.spongepowered.api.event.Listener; +import org.spongepowered.api.event.Order; +import org.spongepowered.api.event.lifecycle.RegisterCommandEvent; import org.spongepowered.plugin.PluginContainer; import java.util.HashMap; @@ -26,7 +31,7 @@ public final class SpongeCommandManager extends CommandManager senderMapper, @NotNull SenderValidator senderValidator @@ -34,6 +39,8 @@ public SpongeCommandManager( super(senderMapper, senderValidator); this.plugin = plugin; this.asyncExecutionProvider = new SpongeAsyncExecutionProvider(plugin); + + Sponge.eventManager().registerListeners(plugin,this); } @Override @@ -46,7 +53,13 @@ public void registerCommand(@NotNull final BaseCommand baseCommand) { syncExecutionProvider, asyncExecutionProvider ); + final SpongeCommand command = commands.computeIfAbsent(processor.getName(), ignored -> new SpongeCommand<>(processor)); + command.addSubCommands(processor.getSubCommands(), processor.getSubCommandsAlias()); + processor.getAlias().forEach(it -> { + final SpongeCommand aliasCommand = commands.computeIfAbsent(processor.getName(),ignored -> new SpongeCommand<>(processor)); + aliasCommand.addSubCommands(processor.getSubCommands(), processor.getSubCommandsAlias()); + }); } @Override @@ -58,4 +71,9 @@ public void unregisterCommand(@NotNull BaseCommand command) throws UnsupportedOp protected @NotNull RegistryContainer getRegistryContainer() { return registryContainer; } + + @Listener(order = Order.LAST) + public void onCommandRegister(RegisterCommandEvent event) { + commands.forEach((str,raw) -> event.register(plugin,raw,str)); + } } diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java index 5ead91a2..9140d195 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java @@ -1,20 +1,53 @@ package dev.triumphteam.cmd.sponge; +import com.google.common.collect.ImmutableSet; import dev.triumphteam.cmd.core.SubCommand; import dev.triumphteam.cmd.core.message.MessageRegistry; +import dev.triumphteam.cmd.core.message.context.DefaultMessageContext; import dev.triumphteam.cmd.core.sender.SenderValidator; +import dev.triumphteam.cmd.sponge.message.SpongeMessageKey; import org.jetbrains.annotations.NotNull; +import org.spongepowered.api.SystemSubject; +import org.spongepowered.api.entity.living.player.server.ServerPlayer; +import org.spongepowered.api.service.permission.Subject; import java.util.Set; -public class SpongeSenderValidator implements SenderValidator { +class SpongeSenderValidator implements SenderValidator { + + + @NotNull @Override - public @NotNull Set> getAllowedSenders() { - return null; + public Set> getAllowedSenders() { + return ImmutableSet.of(ServerPlayer.class, SystemSubject.class); } @Override - public boolean validate(@NotNull MessageRegistry messageRegistry, @NotNull SubCommand subCommand, @NotNull S sender) { - return false; + public boolean validate( + @NotNull MessageRegistry messageRegistry, + @NotNull SubCommand subCommand, + @NotNull Subject sender + ) { + final Class senderClass = subCommand.getSenderType(); + + if(ServerPlayer.class.isAssignableFrom(senderClass) && !(sender instanceof ServerPlayer)) { + messageRegistry.sendMessage( + SpongeMessageKey.PLAYER_ONLY, + sender, + new DefaultMessageContext(subCommand.getParentName(), subCommand.getName()) + ); + return false; + } + + if (SystemSubject.class.isAssignableFrom(senderClass) && !(sender instanceof SystemSubject)) { + messageRegistry.sendMessage( + SpongeMessageKey.CONSOLE_ONLY, + sender, + new DefaultMessageContext(subCommand.getParentName(), subCommand.getName()) + ); + return false; + } + + return true; } } From 6312242a82efe3a858fbe1cd301ec420ae2761b2 Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Mon, 9 May 2022 16:42:05 -0500 Subject: [PATCH 06/18] Update copyright fix typo --- .../sponge/SpongeAsyncExecutionProvider.java | 23 +++++++++++++++++++ .../cmd/sponge/SpongeCommandManager.java | 23 +++++++++++++++++++ .../cmd/sponge/SpongeCommandProcessor.java | 23 +++++++++++++++++++ .../cmd/sponge/SpongeSenderValidator.java | 23 +++++++++++++++++++ .../cmd/sponge/SpongeSubCommand.java | 23 +++++++++++++++++++ .../cmd/sponge/SpongeSubCommandProcessor.java | 23 +++++++++++++++++++ 6 files changed, 138 insertions(+) diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java index 2b65627e..7bf7cd76 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java @@ -1,3 +1,26 @@ +/** + * MIT License + * + * Copyright (c) 2019-2021 Matt + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ package dev.triumphteam.cmd.sponge; import dev.triumphteam.cmd.core.execution.ExecutionProvider; diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java index 610eca1a..975d3626 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java @@ -1,3 +1,26 @@ +/** + * MIT License + * + * Copyright (c) 2019-2021 Matt + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ package dev.triumphteam.cmd.sponge; import dev.triumphteam.cmd.core.BaseCommand; diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java index bc4767c8..8aecf9cb 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java @@ -1,3 +1,26 @@ +/** + * MIT License + * + * Copyright (c) 2019-2021 Matt + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ package dev.triumphteam.cmd.sponge; import dev.triumphteam.cmd.core.BaseCommand; diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java index 9140d195..9f014fb0 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java @@ -1,3 +1,26 @@ +/** + * MIT License + * + * Copyright (c) 2019-2021 Matt + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ package dev.triumphteam.cmd.sponge; import com.google.common.collect.ImmutableSet; diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommand.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommand.java index 7e333eee..3c436333 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommand.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommand.java @@ -1,3 +1,26 @@ +/** + * MIT License + * + * Copyright (c) 2019-2021 Matt + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ package dev.triumphteam.cmd.sponge; import dev.triumphteam.cmd.core.AbstractSubCommand; diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java index 42fe2cc3..35d18c88 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java @@ -1,3 +1,26 @@ +/** + * MIT License + * + * Copyright (c) 2019-2021 Matt + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ package dev.triumphteam.cmd.sponge; import dev.triumphteam.cmd.core.BaseCommand; From b857bff5759e015c363ab8250c1c364580e7f350 Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Tue, 10 May 2022 13:17:31 -0500 Subject: [PATCH 07/18] This should finish out the port One small caveat SpongeCommandManager has a method commented out due to some type erasure issues. Updated javadocs in some areas. --- .../sponge/SpongeAsyncExecutionProvider.java | 6 ++ .../cmd/sponge/SpongeCommandManager.java | 61 ++++++++++++++++++- .../cmd/sponge/annotation/Permission.java | 3 + .../message/NoPermissionMessageContext.java | 9 +++ 4 files changed, 78 insertions(+), 1 deletion(-) diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java index 7bf7cd76..f54dc539 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java @@ -28,10 +28,16 @@ import org.spongepowered.api.Sponge; import org.spongepowered.plugin.PluginContainer; +/** + * {@inheritDoc} + */ public final class SpongeAsyncExecutionProvider implements ExecutionProvider { private final PluginContainer plugin; + /** + * {@inheritDoc} + */ public SpongeAsyncExecutionProvider(@NotNull final PluginContainer plugin) { this.plugin = plugin; } /** diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java index 975d3626..60cbd1e4 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java @@ -27,9 +27,14 @@ import dev.triumphteam.cmd.core.CommandManager; import dev.triumphteam.cmd.core.execution.ExecutionProvider; import dev.triumphteam.cmd.core.execution.SyncExecutionProvider; +import dev.triumphteam.cmd.core.message.MessageKey; import dev.triumphteam.cmd.core.registry.RegistryContainer; import dev.triumphteam.cmd.core.sender.SenderMapper; import dev.triumphteam.cmd.core.sender.SenderValidator; +import dev.triumphteam.cmd.sponge.message.SpongeMessageKey; +import net.kyori.adventure.identity.Identity; +import net.kyori.adventure.text.Component; +import org.jetbrains.annotations.Contract; import org.jetbrains.annotations.NotNull; import org.spongepowered.api.Sponge; import org.spongepowered.api.command.Command; @@ -53,7 +58,6 @@ public final class SpongeCommandManager extends CommandManager senderMapper, @@ -65,6 +69,45 @@ private SpongeCommandManager( Sponge.eventManager().registerListeners(plugin,this); } +/* + /** + * Creates a new instance of the {@link SpongeCommandManager}. + * This factory adds all the defaults based on the default sender {@link CommandCause}. + * + * @param plugin The {@link PluginContainer} instance created. + * @return A new instance of the {@link SpongeCommandManager}. + */ + /* + @NotNull + @Contract("_ -> new") + public static SpongeCommandManager create(@NotNull final PluginContainer plugin) { + final SpongeCommandManager commandManager = new SpongeCommandManager<>( + plugin, + SenderMapper.defaultMapper(), + new SpongeSenderValidator() + ); + setUpDefaults(commandManager); + return commandManager; + } +*/ + /** + * Creates a new instance of the {@link SpongeCommandManager}. + * This factory is used for adding custom senders. + * + * @param plugin The {@link PluginContainer} instance created. + * @param senderMapper The {@link SenderMapper} used to map the {@link CommandCause} to the {@link S} type. + * @param senderValidator The {@link SenderValidator} used to validate the {@link S} type. + * @return A new instance of the {@link SpongeCommandManager}. + */ + @NotNull + @Contract("_, _, _ -> new") + public static SpongeCommandManager create( + @NotNull final PluginContainer plugin, + @NotNull final SenderMapper senderMapper, + @NotNull final SenderValidator senderValidator + ) { + return new SpongeCommandManager<>(plugin, senderMapper, senderValidator); + } @Override public void registerCommand(@NotNull final BaseCommand baseCommand) { @@ -95,6 +138,22 @@ public void unregisterCommand(@NotNull BaseCommand command) throws UnsupportedOp return registryContainer; } + /** + * Sets up all the default values for the Bukkit implementation. + * + * @param manager The {@link SpongeCommandManager} instance to set up. + */ + private static void setUpDefaults(@NotNull final SpongeCommandManager manager) { + manager.registerMessage(MessageKey.UNKNOWN_COMMAND, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("Unknown command: `" + context.getCommand() + "`."))); + manager.registerMessage(MessageKey.TOO_MANY_ARGUMENTS, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("Invalid usage."))); + manager.registerMessage(MessageKey.NOT_ENOUGH_ARGUMENTS, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("Invalid usage."))); + manager.registerMessage(MessageKey.INVALID_ARGUMENT, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("Invalid argument `" + context.getTypedArgument() + "` for type `" + context.getArgumentType().getSimpleName() + "`."))); + + manager.registerMessage(SpongeMessageKey.NO_PERMISSION, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("You do not have permission to perform this command. Permission needed: `" + context.getPermission() + "`."))); + manager.registerMessage(SpongeMessageKey.PLAYER_ONLY, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("This command can only be used by players."))); + manager.registerMessage(SpongeMessageKey.CONSOLE_ONLY, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("This command can only be used by the console."))); + } + @Listener(order = Order.LAST) public void onCommandRegister(RegisterCommandEvent event) { commands.forEach((str,raw) -> event.register(plugin,raw,str)); diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/annotation/Permission.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/annotation/Permission.java index 9877a0c9..25edc09f 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/annotation/Permission.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/annotation/Permission.java @@ -34,5 +34,8 @@ @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface Permission { + /** + * @return Permission with nodes separated by periods "." + */ String value(); } diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/NoPermissionMessageContext.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/NoPermissionMessageContext.java index ad192939..25227f05 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/NoPermissionMessageContext.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/NoPermissionMessageContext.java @@ -26,10 +26,16 @@ import dev.triumphteam.cmd.core.message.context.AbstractMessageContext; import org.jetbrains.annotations.NotNull; +/** + * {@inheritDoc} + */ public final class NoPermissionMessageContext extends AbstractMessageContext { private final String permission; + /** + * {@inheritDoc} + */ public NoPermissionMessageContext( @NotNull final String command, @NotNull final String subCommand, @@ -39,6 +45,9 @@ public NoPermissionMessageContext( this.permission = permission; } + /** + * {@inheritDoc} + */ public String getPermission() { return permission; } From d5555f7082955b3522e09a36b13f92de55b04638 Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Fri, 13 May 2022 02:03:07 -0500 Subject: [PATCH 08/18] Use subject in place of CommandCause where applicable --- .../triumphteam/cmd/sponge/SpongeCommand.java | 3 ++- .../cmd/sponge/SpongeCommandManager.java | 24 ++++++++++--------- .../cmd/sponge/SpongeCommandProcessor.java | 6 ++--- .../cmd/sponge/SpongeSenderValidator.java | 3 ++- settings.gradle.kts | 3 ++- 5 files changed, 22 insertions(+), 17 deletions(-) diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java index 922330d4..e83e06e6 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java @@ -42,6 +42,7 @@ import org.spongepowered.api.command.CommandResult; import org.spongepowered.api.command.exception.CommandException; import org.spongepowered.api.command.parameter.ArgumentReader; +import org.spongepowered.api.service.permission.Subject; import java.util.*; import java.util.stream.Collectors; @@ -52,7 +53,7 @@ public final class SpongeCommand implements Command.Raw, dev.triumphteam.cmd. private final MessageRegistry messageRegistry; - private final SenderMapper senderMapper; + private final SenderMapper senderMapper; private final Map> subCommands = new HashMap<>(); private final Map> subCommandAliases = new HashMap<>(); diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java index 60cbd1e4..9ab086ff 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java @@ -42,12 +42,13 @@ import org.spongepowered.api.event.Listener; import org.spongepowered.api.event.Order; import org.spongepowered.api.event.lifecycle.RegisterCommandEvent; +import org.spongepowered.api.service.permission.Subject; import org.spongepowered.plugin.PluginContainer; import java.util.HashMap; import java.util.Map; -public final class SpongeCommandManager extends CommandManager { +public final class SpongeCommandManager extends CommandManager { private final PluginContainer plugin; @@ -60,16 +61,16 @@ public final class SpongeCommandManager extends CommandManager senderMapper, - @NotNull SenderValidator senderValidator + @NotNull final SenderMapper senderMapper, + @NotNull final SenderValidator senderValidator ) { super(senderMapper, senderValidator); this.plugin = plugin; this.asyncExecutionProvider = new SpongeAsyncExecutionProvider(plugin); - + System.out.println("CommandManager Called"); Sponge.eventManager().registerListeners(plugin,this); } -/* + /** * Creates a new instance of the {@link SpongeCommandManager}. * This factory adds all the defaults based on the default sender {@link CommandCause}. @@ -77,19 +78,19 @@ private SpongeCommandManager( * @param plugin The {@link PluginContainer} instance created. * @return A new instance of the {@link SpongeCommandManager}. */ - /* + @NotNull @Contract("_ -> new") - public static SpongeCommandManager create(@NotNull final PluginContainer plugin) { - final SpongeCommandManager commandManager = new SpongeCommandManager<>( + public static SpongeCommandManager create(@NotNull final PluginContainer plugin) { + final SpongeCommandManager commandManager = new SpongeCommandManager<>( plugin, SenderMapper.defaultMapper(), new SpongeSenderValidator() ); - setUpDefaults(commandManager); + //setUpDefaults(commandManager); return commandManager; } -*/ + /** * Creates a new instance of the {@link SpongeCommandManager}. * This factory is used for adding custom senders. @@ -103,7 +104,7 @@ public static SpongeCommandManager create(@NotNull final PluginCon @Contract("_, _, _ -> new") public static SpongeCommandManager create( @NotNull final PluginContainer plugin, - @NotNull final SenderMapper senderMapper, + @NotNull final SenderMapper senderMapper, @NotNull final SenderValidator senderValidator ) { return new SpongeCommandManager<>(plugin, senderMapper, senderValidator); @@ -156,6 +157,7 @@ private static void setUpDefaults(@NotNull final SpongeCommandManager event) { + System.out.println("Registering commands.."); commands.forEach((str,raw) -> event.register(plugin,raw,str)); } } diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java index 8aecf9cb..bfc539f6 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandProcessor.java @@ -30,15 +30,15 @@ import dev.triumphteam.cmd.core.sender.SenderMapper; import dev.triumphteam.cmd.core.sender.SenderValidator; import org.jetbrains.annotations.NotNull; -import org.spongepowered.api.command.CommandCause; +import org.spongepowered.api.service.permission.Subject; import java.lang.reflect.Method; -final class SpongeCommandProcessor extends AbstractCommandProcessor, SpongeSubCommandProcessor> { +final class SpongeCommandProcessor extends AbstractCommandProcessor, SpongeSubCommandProcessor> { public SpongeCommandProcessor( @NotNull final BaseCommand baseCommand, @NotNull final RegistryContainer registryContainer, - @NotNull final SenderMapper senderMapper, + @NotNull final SenderMapper senderMapper, @NotNull final SenderValidator senderValidator, @NotNull final ExecutionProvider syncExecutionProvider, @NotNull final ExecutionProvider asyncExecutionProvider diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java index 9f014fb0..dd555ebe 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java @@ -31,6 +31,7 @@ import dev.triumphteam.cmd.sponge.message.SpongeMessageKey; import org.jetbrains.annotations.NotNull; import org.spongepowered.api.SystemSubject; +import org.spongepowered.api.command.CommandCause; import org.spongepowered.api.entity.living.player.server.ServerPlayer; import org.spongepowered.api.service.permission.Subject; @@ -42,7 +43,7 @@ class SpongeSenderValidator implements SenderValidator { @NotNull @Override public Set> getAllowedSenders() { - return ImmutableSet.of(ServerPlayer.class, SystemSubject.class); + return ImmutableSet.of(ServerPlayer.class, SystemSubject.class, CommandCause.class); } @Override diff --git a/settings.gradle.kts b/settings.gradle.kts index 290c852f..bd863649 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -14,6 +14,7 @@ listOf( listOf( "minecraft/bukkit", "minecraft/sponge", + "minecraft/spongeTest", "discord/jda-common", "discord/jda-prefixed", "discord/jda-slash", @@ -22,7 +23,7 @@ listOf( includeProject(name, folder) } -include("test-module") +include("Spawn-Protection") fun includeProject(name: String) { include(name) { From 581f64d5f400e876420285d0f903b44133cb3331 Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Fri, 13 May 2022 02:04:11 -0500 Subject: [PATCH 09/18] remove Test --- settings.gradle.kts | 1 - 1 file changed, 1 deletion(-) diff --git a/settings.gradle.kts b/settings.gradle.kts index bd863649..cfa6d4a1 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -14,7 +14,6 @@ listOf( listOf( "minecraft/bukkit", "minecraft/sponge", - "minecraft/spongeTest", "discord/jda-common", "discord/jda-prefixed", "discord/jda-slash", From 110813258cbc84bbdea54dc3175738ff848fa82c Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Fri, 13 May 2022 02:29:44 -0500 Subject: [PATCH 10/18] Abolish printline statements --- .../java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java index 9ab086ff..3a264c1f 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java @@ -67,7 +67,6 @@ private SpongeCommandManager( super(senderMapper, senderValidator); this.plugin = plugin; this.asyncExecutionProvider = new SpongeAsyncExecutionProvider(plugin); - System.out.println("CommandManager Called"); Sponge.eventManager().registerListeners(plugin,this); } @@ -157,7 +156,6 @@ private static void setUpDefaults(@NotNull final SpongeCommandManager event) { - System.out.println("Registering commands.."); commands.forEach((str,raw) -> event.register(plugin,raw,str)); } } From 6279488835ef64a9bdc28fdcd9ab469a810b07a6 Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Fri, 13 May 2022 03:06:36 -0500 Subject: [PATCH 11/18] Fix message registration --- .../cmd/sponge/SpongeCommandManager.java | 26 +++++++++++-------- 1 file changed, 15 insertions(+), 11 deletions(-) diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java index 3a264c1f..57c61110 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java @@ -32,6 +32,7 @@ import dev.triumphteam.cmd.core.sender.SenderMapper; import dev.triumphteam.cmd.core.sender.SenderValidator; import dev.triumphteam.cmd.sponge.message.SpongeMessageKey; +import net.kyori.adventure.audience.Audience; import net.kyori.adventure.identity.Identity; import net.kyori.adventure.text.Component; import org.jetbrains.annotations.Contract; @@ -86,7 +87,7 @@ public static SpongeCommandManager create(@NotNull final PluginContaine SenderMapper.defaultMapper(), new SpongeSenderValidator() ); - //setUpDefaults(commandManager); + setUpDefaults(commandManager); return commandManager; } @@ -139,19 +140,22 @@ public void unregisterCommand(@NotNull BaseCommand command) throws UnsupportedOp } /** - * Sets up all the default values for the Bukkit implementation. + * Sets up all the default values for the Sponge implementation. * * @param manager The {@link SpongeCommandManager} instance to set up. */ - private static void setUpDefaults(@NotNull final SpongeCommandManager manager) { - manager.registerMessage(MessageKey.UNKNOWN_COMMAND, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("Unknown command: `" + context.getCommand() + "`."))); - manager.registerMessage(MessageKey.TOO_MANY_ARGUMENTS, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("Invalid usage."))); - manager.registerMessage(MessageKey.NOT_ENOUGH_ARGUMENTS, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("Invalid usage."))); - manager.registerMessage(MessageKey.INVALID_ARGUMENT, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("Invalid argument `" + context.getTypedArgument() + "` for type `" + context.getArgumentType().getSimpleName() + "`."))); - - manager.registerMessage(SpongeMessageKey.NO_PERMISSION, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("You do not have permission to perform this command. Permission needed: `" + context.getPermission() + "`."))); - manager.registerMessage(SpongeMessageKey.PLAYER_ONLY, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("This command can only be used by players."))); - manager.registerMessage(SpongeMessageKey.CONSOLE_ONLY, (sender, context) -> sender.sendMessage(Identity.nil(), Component.text("This command can only be used by the console."))); + private static void setUpDefaults(@NotNull final SpongeCommandManager manager) { + manager.registerMessage(MessageKey.UNKNOWN_COMMAND, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("Unknown command: `" + context.getCommand() + "`."))); + manager.registerMessage(MessageKey.TOO_MANY_ARGUMENTS, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("Invalid usage."))); + manager.registerMessage(MessageKey.NOT_ENOUGH_ARGUMENTS, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("Invalid usage."))); + manager.registerMessage(MessageKey.INVALID_ARGUMENT, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("Invalid argument `" + context.getTypedArgument() + "` for type `" + context.getArgumentType().getSimpleName() + "`."))); + manager.registerMessage(SpongeMessageKey.NO_PERMISSION, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("You do not have permission to perform this command. Permission needed: `" + context.getPermission() + "`."))); + manager.registerMessage(SpongeMessageKey.PLAYER_ONLY, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("This command can only be used by players."))); + manager.registerMessage(SpongeMessageKey.CONSOLE_ONLY, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("This command can only be used by the console."))); + } + + private Audience getAudience(Subject subject) { + return (Audience) subject.contextCause().root(); } @Listener(order = Order.LAST) From bb375539fe7bc8b8d6889f61de49b706009ed7fb Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Fri, 13 May 2022 11:15:45 -0500 Subject: [PATCH 12/18] Command Aliases working --- .../dev/triumphteam/cmd/sponge/SpongeCommandManager.java | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java index 57c61110..15a4691e 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java @@ -47,6 +47,7 @@ import org.spongepowered.plugin.PluginContainer; import java.util.HashMap; +import java.util.List; import java.util.Map; public final class SpongeCommandManager extends CommandManager { @@ -56,6 +57,7 @@ public final class SpongeCommandManager extends CommandManager { private final RegistryContainer registryContainer = new RegistryContainer<>(); private final Map> commands = new HashMap<>(); + private final Map> commandAliases = new HashMap<>(); private final ExecutionProvider syncExecutionProvider = new SyncExecutionProvider(); private final ExecutionProvider asyncExecutionProvider; @@ -127,6 +129,8 @@ public void registerCommand(@NotNull final BaseCommand baseCommand) { final SpongeCommand aliasCommand = commands.computeIfAbsent(processor.getName(),ignored -> new SpongeCommand<>(processor)); aliasCommand.addSubCommands(processor.getSubCommands(), processor.getSubCommandsAlias()); }); + + commandAliases.put(processor.getName(), processor.getAlias()); } @Override @@ -160,6 +164,6 @@ private Audience getAudience(Subject subject) { @Listener(order = Order.LAST) public void onCommandRegister(RegisterCommandEvent event) { - commands.forEach((str,raw) -> event.register(plugin,raw,str)); + commands.forEach((str,raw) -> event.register(plugin,raw,str, commandAliases.get(str).toArray(new String[0]))); } } From 22322b261c283492ddbc8359a93cdaf3b155ade4 Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Fri, 13 May 2022 11:40:30 -0500 Subject: [PATCH 13/18] Commit build file --- minecraft/sponge/build.gradle.kts | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 minecraft/sponge/build.gradle.kts diff --git a/minecraft/sponge/build.gradle.kts b/minecraft/sponge/build.gradle.kts new file mode 100644 index 00000000..5c27a7ad --- /dev/null +++ b/minecraft/sponge/build.gradle.kts @@ -0,0 +1,16 @@ +plugins { + id("cmds.base-conventions") + id("cmds.library-conventions") +} + +repositories { + maven { + name = "Sponge" + url = uri("https://repo.spongepowered.org/maven") + } +} + +dependencies { + api(project(":triumph-cmd-core")) + compileOnly("org.spongepowered:spongeapi:8.0.0") +} From eeb08b5916aea52b09e85214615cc02fef8b2d6f Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Fri, 13 May 2022 12:29:48 -0500 Subject: [PATCH 14/18] Common minecraft code --- minecraft/bukkit/build.gradle.kts | 2 +- .../triumphteam/cmd/bukkit/BukkitCommand.java | 6 +- .../cmd/bukkit/BukkitCommandManager.java | 8 +-- .../cmd/bukkit/BukkitSenderValidator.java | 6 +- .../cmd/bukkit/BukkitSubCommandProcessor.java | 2 +- .../cmd/bukkit/annotation/Permission.java | 38 ----------- .../message/NoPermissionMessageContext.java | 46 ------------- minecraft/mc-common/build.gradle.kts | 10 +++ .../message/MinecraftMessageKey.java} | 24 +++---- .../message/NoPermissionMessageContext.java | 2 +- minecraft/sponge/build.gradle.kts | 2 +- .../triumphteam/cmd/sponge/SpongeCommand.java | 6 +- .../cmd/sponge/SpongeCommandManager.java | 8 +-- .../cmd/sponge/SpongeSenderValidator.java | 6 +- .../cmd/sponge/SpongeSubCommandProcessor.java | 2 +- .../cmd/sponge/annotation/Permission.java | 41 ------------ .../cmd/sponge/message/SpongeMessageKey.java | 65 ------------------- 17 files changed, 47 insertions(+), 227 deletions(-) delete mode 100644 minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/annotation/Permission.java delete mode 100644 minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/message/NoPermissionMessageContext.java create mode 100644 minecraft/mc-common/build.gradle.kts rename minecraft/{bukkit/src/main/java/dev/triumphteam/cmd/bukkit/message/BukkitMessageKey.java => mc-common/src/main/java/dev/triumphteam/cmd/minecraft/message/MinecraftMessageKey.java} (61%) rename minecraft/{sponge/src/main/java/dev/triumphteam/cmd/sponge => mc-common/src/main/java/dev/triumphteam/cmd/minecraft}/message/NoPermissionMessageContext.java (97%) delete mode 100644 minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/annotation/Permission.java delete mode 100644 minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/SpongeMessageKey.java diff --git a/minecraft/bukkit/build.gradle.kts b/minecraft/bukkit/build.gradle.kts index b6407f1a..c0e08d85 100644 --- a/minecraft/bukkit/build.gradle.kts +++ b/minecraft/bukkit/build.gradle.kts @@ -8,6 +8,6 @@ repositories { } dependencies { - api(project(":triumph-cmd-core")) + api(project(":triumph-cmd-mc-common")) compileOnly(libs.spigot) } \ No newline at end of file diff --git a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitCommand.java b/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitCommand.java index 02352c43..362fa4cc 100644 --- a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitCommand.java +++ b/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitCommand.java @@ -23,8 +23,6 @@ */ package dev.triumphteam.cmd.bukkit; -import dev.triumphteam.cmd.bukkit.message.BukkitMessageKey; -import dev.triumphteam.cmd.bukkit.message.NoPermissionMessageContext; import dev.triumphteam.cmd.core.Command; import dev.triumphteam.cmd.core.SubCommand; import dev.triumphteam.cmd.core.annotation.Default; @@ -33,6 +31,8 @@ import dev.triumphteam.cmd.core.message.context.DefaultMessageContext; import dev.triumphteam.cmd.core.registry.RegistryContainer; import dev.triumphteam.cmd.core.sender.SenderMapper; +import dev.triumphteam.cmd.minecraft.message.MinecraftMessageKey; +import dev.triumphteam.cmd.minecraft.message.NoPermissionMessageContext; import org.bukkit.command.CommandSender; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -98,7 +98,7 @@ public boolean execute(@NotNull final CommandSender sender, @NotNull final Strin final String permission = subCommand.getPermission(); if (!permission.isEmpty() && !sender.hasPermission(permission)) { - messageRegistry.sendMessage(BukkitMessageKey.NO_PERMISSION, mappedSender, new NoPermissionMessageContext(getName(), subCommand.getName(), permission)); + messageRegistry.sendMessage(MinecraftMessageKey.NO_PERMISSION, mappedSender, new NoPermissionMessageContext(getName(), subCommand.getName(), permission)); return true; } diff --git a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitCommandManager.java b/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitCommandManager.java index 1c727196..0a327ef6 100644 --- a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitCommandManager.java +++ b/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitCommandManager.java @@ -23,7 +23,6 @@ */ package dev.triumphteam.cmd.bukkit; -import dev.triumphteam.cmd.bukkit.message.BukkitMessageKey; import dev.triumphteam.cmd.core.BaseCommand; import dev.triumphteam.cmd.core.CommandManager; import dev.triumphteam.cmd.core.exceptions.CommandRegistrationException; @@ -33,6 +32,7 @@ import dev.triumphteam.cmd.core.registry.RegistryContainer; import dev.triumphteam.cmd.core.sender.SenderMapper; import dev.triumphteam.cmd.core.sender.SenderValidator; +import dev.triumphteam.cmd.minecraft.message.MinecraftMessageKey; import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.Server; @@ -174,9 +174,9 @@ private static void setUpDefaults(@NotNull final BukkitCommandManager sender.sendMessage("Invalid usage.")); manager.registerMessage(MessageKey.INVALID_ARGUMENT, (sender, context) -> sender.sendMessage("Invalid argument `" + context.getTypedArgument() + "` for type `" + context.getArgumentType().getSimpleName() + "`.")); - manager.registerMessage(BukkitMessageKey.NO_PERMISSION, (sender, context) -> sender.sendMessage("You do not have permission to perform this command. Permission needed: `" + context.getPermission() + "`.")); - manager.registerMessage(BukkitMessageKey.PLAYER_ONLY, (sender, context) -> sender.sendMessage("This command can only be used by players.")); - manager.registerMessage(BukkitMessageKey.CONSOLE_ONLY, (sender, context) -> sender.sendMessage("This command can only be used by the console.")); + manager.registerMessage(MinecraftMessageKey.NO_PERMISSION, (sender, context) -> sender.sendMessage("You do not have permission to perform this command. Permission needed: `" + context.getPermission() + "`.")); + manager.registerMessage(MinecraftMessageKey.PLAYER_ONLY, (sender, context) -> sender.sendMessage("This command can only be used by players.")); + manager.registerMessage(MinecraftMessageKey.CONSOLE_ONLY, (sender, context) -> sender.sendMessage("This command can only be used by the console.")); manager.registerArgument(Material.class, (sender, arg) -> Material.matchMaterial(arg)); manager.registerArgument(Player.class, (sender, arg) -> Bukkit.getPlayer(arg)); diff --git a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitSenderValidator.java b/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitSenderValidator.java index a5440bcf..81230ee7 100644 --- a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitSenderValidator.java +++ b/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitSenderValidator.java @@ -24,11 +24,11 @@ package dev.triumphteam.cmd.bukkit; import com.google.common.collect.ImmutableSet; -import dev.triumphteam.cmd.bukkit.message.BukkitMessageKey; import dev.triumphteam.cmd.core.SubCommand; import dev.triumphteam.cmd.core.message.MessageRegistry; import dev.triumphteam.cmd.core.message.context.DefaultMessageContext; import dev.triumphteam.cmd.core.sender.SenderValidator; +import dev.triumphteam.cmd.minecraft.message.MinecraftMessageKey; import org.bukkit.command.CommandSender; import org.bukkit.command.ConsoleCommandSender; import org.bukkit.entity.Player; @@ -60,7 +60,7 @@ public boolean validate( if (Player.class.isAssignableFrom(senderClass) && !(sender instanceof Player)) { messageRegistry.sendMessage( - BukkitMessageKey.PLAYER_ONLY, + MinecraftMessageKey.PLAYER_ONLY, sender, new DefaultMessageContext(subCommand.getParentName(), subCommand.getName()) ); @@ -69,7 +69,7 @@ public boolean validate( if (ConsoleCommandSender.class.isAssignableFrom(senderClass) && !(sender instanceof ConsoleCommandSender)) { messageRegistry.sendMessage( - BukkitMessageKey.CONSOLE_ONLY, + MinecraftMessageKey.CONSOLE_ONLY, sender, new DefaultMessageContext(subCommand.getParentName(), subCommand.getName()) ); diff --git a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitSubCommandProcessor.java b/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitSubCommandProcessor.java index d90c150e..9c4c0721 100644 --- a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitSubCommandProcessor.java +++ b/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/BukkitSubCommandProcessor.java @@ -23,12 +23,12 @@ */ package dev.triumphteam.cmd.bukkit; -import dev.triumphteam.cmd.bukkit.annotation.Permission; import dev.triumphteam.cmd.core.BaseCommand; import dev.triumphteam.cmd.core.exceptions.SubCommandRegistrationException; import dev.triumphteam.cmd.core.processor.AbstractSubCommandProcessor; import dev.triumphteam.cmd.core.registry.RegistryContainer; import dev.triumphteam.cmd.core.sender.SenderValidator; +import dev.triumphteam.cmd.minecraft.annotation.Permission; import org.jetbrains.annotations.NotNull; import java.lang.reflect.Method; diff --git a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/annotation/Permission.java b/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/annotation/Permission.java deleted file mode 100644 index 0c57d4b5..00000000 --- a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/annotation/Permission.java +++ /dev/null @@ -1,38 +0,0 @@ -/** - * MIT License - * - * Copyright (c) 2019-2021 Matt - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ -package dev.triumphteam.cmd.bukkit.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Annotate a method using this Annotation to add a required permission - */ -@Retention(RetentionPolicy.RUNTIME) -@Target(ElementType.METHOD) -public @interface Permission { - String value(); -} diff --git a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/message/NoPermissionMessageContext.java b/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/message/NoPermissionMessageContext.java deleted file mode 100644 index 641e2b06..00000000 --- a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/message/NoPermissionMessageContext.java +++ /dev/null @@ -1,46 +0,0 @@ -/** - * MIT License - * - * Copyright (c) 2019-2021 Matt - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ -package dev.triumphteam.cmd.bukkit.message; - -import dev.triumphteam.cmd.core.message.context.AbstractMessageContext; -import org.jetbrains.annotations.NotNull; - -public final class NoPermissionMessageContext extends AbstractMessageContext { - - private final String permission; - - public NoPermissionMessageContext( - @NotNull final String command, - @NotNull final String subCommand, - @NotNull final String permission - ) { - super(command, subCommand); - this.permission = permission; - } - - public String getPermission() { - return permission; - } - -} diff --git a/minecraft/mc-common/build.gradle.kts b/minecraft/mc-common/build.gradle.kts new file mode 100644 index 00000000..6d6103cb --- /dev/null +++ b/minecraft/mc-common/build.gradle.kts @@ -0,0 +1,10 @@ +plugins { + id("cmds.base-conventions") + id("cmds.library-conventions") +} + +repositories {} + +dependencies { + api(project(":triumph-cmd-core")) +} diff --git a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/message/BukkitMessageKey.java b/minecraft/mc-common/src/main/java/dev/triumphteam/cmd/minecraft/message/MinecraftMessageKey.java similarity index 61% rename from minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/message/BukkitMessageKey.java rename to minecraft/mc-common/src/main/java/dev/triumphteam/cmd/minecraft/message/MinecraftMessageKey.java index 8d7d8294..ab689769 100644 --- a/minecraft/bukkit/src/main/java/dev/triumphteam/cmd/bukkit/message/BukkitMessageKey.java +++ b/minecraft/mc-common/src/main/java/dev/triumphteam/cmd/minecraft/message/MinecraftMessageKey.java @@ -21,7 +21,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ -package dev.triumphteam.cmd.bukkit.message; +package dev.triumphteam.cmd.minecraft.message; import dev.triumphteam.cmd.core.message.ContextualKey; import dev.triumphteam.cmd.core.message.context.MessageContext; @@ -29,37 +29,37 @@ import org.jetbrains.annotations.NotNull; /** - * {@link BukkitMessageKey} is used for easier registering of messages with different {@link MessageContext}. + * {@link MinecraftMessageKey} is used for easier registering of messages with different {@link MessageContext}. * * @param A {@link MessageContext} type, this allows for better customization of the messages. */ -public final class BukkitMessageKey extends ContextualKey { +public final class MinecraftMessageKey extends ContextualKey { // Default keys - public static final BukkitMessageKey NO_PERMISSION = of("no.permission", NoPermissionMessageContext.class); - public static final BukkitMessageKey PLAYER_ONLY = of("player.only", MessageContext.class); - public static final BukkitMessageKey CONSOLE_ONLY = of("console.only", MessageContext.class); + public static final MinecraftMessageKey NO_PERMISSION = of("no.permission", NoPermissionMessageContext.class); + public static final MinecraftMessageKey PLAYER_ONLY = of("player.only", MessageContext.class); + public static final MinecraftMessageKey CONSOLE_ONLY = of("console.only", MessageContext.class); - private BukkitMessageKey(@NotNull final String key, @NotNull final Class type) { + private MinecraftMessageKey(@NotNull final String key, @NotNull final Class type) { super(key, type); } /** - * Factory method for creating a {@link BukkitMessageKey}. + * Factory method for creating a {@link MinecraftMessageKey}. * * @param key The value of the key, normally separated by .. * @param type The {@link MessageContext} type. * @param Generic {@link MessageContext} type. - * @return A new {@link BukkitMessageKey} for a specific {@link MessageContext}. + * @return A new {@link MinecraftMessageKey} for a specific {@link MessageContext}. */ @NotNull @Contract("_, _ -> new") - private static BukkitMessageKey of(@NotNull final String key, @NotNull final Class type) { - return new BukkitMessageKey<>(key, type); + private static MinecraftMessageKey of(@NotNull final String key, @NotNull final Class type) { + return new MinecraftMessageKey<>(key, type); } @Override public String toString() { - return "BukkitMessageKey{super=" + super.toString() + "}"; + return "MinecraftMessageKey{super=" + super.toString() + "}"; } } diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/NoPermissionMessageContext.java b/minecraft/mc-common/src/main/java/dev/triumphteam/cmd/minecraft/message/NoPermissionMessageContext.java similarity index 97% rename from minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/NoPermissionMessageContext.java rename to minecraft/mc-common/src/main/java/dev/triumphteam/cmd/minecraft/message/NoPermissionMessageContext.java index 25227f05..ed94022f 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/NoPermissionMessageContext.java +++ b/minecraft/mc-common/src/main/java/dev/triumphteam/cmd/minecraft/message/NoPermissionMessageContext.java @@ -21,7 +21,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ -package dev.triumphteam.cmd.sponge.message; +package dev.triumphteam.cmd.minecraft.message; import dev.triumphteam.cmd.core.message.context.AbstractMessageContext; import org.jetbrains.annotations.NotNull; diff --git a/minecraft/sponge/build.gradle.kts b/minecraft/sponge/build.gradle.kts index 5c27a7ad..2fb35e72 100644 --- a/minecraft/sponge/build.gradle.kts +++ b/minecraft/sponge/build.gradle.kts @@ -11,6 +11,6 @@ repositories { } dependencies { - api(project(":triumph-cmd-core")) + api(project(":triumph-cmd-mc-common")) compileOnly("org.spongepowered:spongeapi:8.0.0") } diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java index e83e06e6..72446855 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommand.java @@ -30,8 +30,8 @@ import dev.triumphteam.cmd.core.message.context.DefaultMessageContext; import dev.triumphteam.cmd.core.registry.RegistryContainer; import dev.triumphteam.cmd.core.sender.SenderMapper; -import dev.triumphteam.cmd.sponge.message.NoPermissionMessageContext; -import dev.triumphteam.cmd.sponge.message.SpongeMessageKey; +import dev.triumphteam.cmd.minecraft.message.MinecraftMessageKey; +import dev.triumphteam.cmd.minecraft.message.NoPermissionMessageContext; import net.kyori.adventure.text.Component; import org.checkerframework.checker.nullness.qual.NonNull; import org.jetbrains.annotations.NotNull; @@ -97,7 +97,7 @@ public CommandResult process(CommandCause cause,ArgumentReader.Mutable arguments final String permission = subCommand.getPermission(); if (!permission.isEmpty() && !cause.hasPermission(permission)) { - messageRegistry.sendMessage(SpongeMessageKey.NO_PERMISSION, mappedSender, new NoPermissionMessageContext(cause.identifier(), subCommand.getName(), permission)); + messageRegistry.sendMessage(MinecraftMessageKey.NO_PERMISSION, mappedSender, new NoPermissionMessageContext(cause.identifier(), subCommand.getName(), permission)); return CommandResult.success(); } diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java index 15a4691e..9457157d 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java @@ -31,7 +31,7 @@ import dev.triumphteam.cmd.core.registry.RegistryContainer; import dev.triumphteam.cmd.core.sender.SenderMapper; import dev.triumphteam.cmd.core.sender.SenderValidator; -import dev.triumphteam.cmd.sponge.message.SpongeMessageKey; +import dev.triumphteam.cmd.minecraft.message.MinecraftMessageKey; import net.kyori.adventure.audience.Audience; import net.kyori.adventure.identity.Identity; import net.kyori.adventure.text.Component; @@ -153,9 +153,9 @@ private static void setUpDefaults(@NotNull final SpongeCommandManager m manager.registerMessage(MessageKey.TOO_MANY_ARGUMENTS, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("Invalid usage."))); manager.registerMessage(MessageKey.NOT_ENOUGH_ARGUMENTS, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("Invalid usage."))); manager.registerMessage(MessageKey.INVALID_ARGUMENT, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("Invalid argument `" + context.getTypedArgument() + "` for type `" + context.getArgumentType().getSimpleName() + "`."))); - manager.registerMessage(SpongeMessageKey.NO_PERMISSION, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("You do not have permission to perform this command. Permission needed: `" + context.getPermission() + "`."))); - manager.registerMessage(SpongeMessageKey.PLAYER_ONLY, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("This command can only be used by players."))); - manager.registerMessage(SpongeMessageKey.CONSOLE_ONLY, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("This command can only be used by the console."))); + manager.registerMessage(MinecraftMessageKey.NO_PERMISSION, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("You do not have permission to perform this command. Permission needed: `" + context.getPermission() + "`."))); + manager.registerMessage(MinecraftMessageKey.PLAYER_ONLY, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("This command can only be used by players."))); + manager.registerMessage(MinecraftMessageKey.CONSOLE_ONLY, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("This command can only be used by the console."))); } private Audience getAudience(Subject subject) { diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java index dd555ebe..47ccf091 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSenderValidator.java @@ -28,7 +28,7 @@ import dev.triumphteam.cmd.core.message.MessageRegistry; import dev.triumphteam.cmd.core.message.context.DefaultMessageContext; import dev.triumphteam.cmd.core.sender.SenderValidator; -import dev.triumphteam.cmd.sponge.message.SpongeMessageKey; +import dev.triumphteam.cmd.minecraft.message.MinecraftMessageKey; import org.jetbrains.annotations.NotNull; import org.spongepowered.api.SystemSubject; import org.spongepowered.api.command.CommandCause; @@ -56,7 +56,7 @@ public boolean validate( if(ServerPlayer.class.isAssignableFrom(senderClass) && !(sender instanceof ServerPlayer)) { messageRegistry.sendMessage( - SpongeMessageKey.PLAYER_ONLY, + MinecraftMessageKey.PLAYER_ONLY, sender, new DefaultMessageContext(subCommand.getParentName(), subCommand.getName()) ); @@ -65,7 +65,7 @@ public boolean validate( if (SystemSubject.class.isAssignableFrom(senderClass) && !(sender instanceof SystemSubject)) { messageRegistry.sendMessage( - SpongeMessageKey.CONSOLE_ONLY, + MinecraftMessageKey.CONSOLE_ONLY, sender, new DefaultMessageContext(subCommand.getParentName(), subCommand.getName()) ); diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java index 35d18c88..b4f84c59 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeSubCommandProcessor.java @@ -28,7 +28,7 @@ import dev.triumphteam.cmd.core.processor.AbstractSubCommandProcessor; import dev.triumphteam.cmd.core.registry.RegistryContainer; import dev.triumphteam.cmd.core.sender.SenderValidator; -import dev.triumphteam.cmd.sponge.annotation.Permission; +import dev.triumphteam.cmd.minecraft.annotation.Permission; import org.jetbrains.annotations.NotNull; import java.lang.reflect.Method; diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/annotation/Permission.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/annotation/Permission.java deleted file mode 100644 index 25edc09f..00000000 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/annotation/Permission.java +++ /dev/null @@ -1,41 +0,0 @@ -/** - * MIT License - * - * Copyright (c) 2019-2021 Matt - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ -package dev.triumphteam.cmd.sponge.annotation; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -/** - * Annotate a method using this Annotation to add a required permission - */ -@Retention(RetentionPolicy.RUNTIME) -@Target(ElementType.METHOD) -public @interface Permission { - /** - * @return Permission with nodes separated by periods "." - */ - String value(); -} diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/SpongeMessageKey.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/SpongeMessageKey.java deleted file mode 100644 index a8ab9eb2..00000000 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/message/SpongeMessageKey.java +++ /dev/null @@ -1,65 +0,0 @@ -/** - * MIT License - * - * Copyright (c) 2019-2021 Matt - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ -package dev.triumphteam.cmd.sponge.message; - -import dev.triumphteam.cmd.core.message.ContextualKey; -import dev.triumphteam.cmd.core.message.context.MessageContext; -import org.jetbrains.annotations.Contract; -import org.jetbrains.annotations.NotNull; - -/** - * {@link SpongeMessageKey} is used for easier registering of messages with different {@link MessageContext}. - * - * @param A {@link MessageContext} type, this allows for better customization of the messages. - */ -public final class SpongeMessageKey extends ContextualKey { - - // Default keys - public static final SpongeMessageKey NO_PERMISSION = of("no.permission", NoPermissionMessageContext.class); - public static final SpongeMessageKey PLAYER_ONLY = of("player.only", MessageContext.class); - public static final SpongeMessageKey CONSOLE_ONLY = of("console.only", MessageContext.class); - - private SpongeMessageKey(@NotNull final String key, @NotNull final Class type) { - super(key, type); - } - - /** - * Factory method for creating a {@link SpongeMessageKey}. - * - * @param key The value of the key, normally separated by .. - * @param type The {@link MessageContext} type. - * @param Generic {@link MessageContext} type. - * @return A new {@link SpongeMessageKey} for a specific {@link MessageContext}. - */ - @NotNull - @Contract("_, _ -> new") - private static SpongeMessageKey of(@NotNull final String key, @NotNull final Class type) { - return new SpongeMessageKey<>(key, type); - } - - @Override - public String toString() { - return "SpongeMessageKey{super=" + super.toString() + "}"; - } -} From 404d66997890eb057be0e1a5573212090c4e66b2 Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Fri, 13 May 2022 12:30:10 -0500 Subject: [PATCH 15/18] Permission Annotation --- .../cmd/minecraft/annotation/Permission.java | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 minecraft/mc-common/src/main/java/dev/triumphteam/cmd/minecraft/annotation/Permission.java diff --git a/minecraft/mc-common/src/main/java/dev/triumphteam/cmd/minecraft/annotation/Permission.java b/minecraft/mc-common/src/main/java/dev/triumphteam/cmd/minecraft/annotation/Permission.java new file mode 100644 index 00000000..fe716c2f --- /dev/null +++ b/minecraft/mc-common/src/main/java/dev/triumphteam/cmd/minecraft/annotation/Permission.java @@ -0,0 +1,41 @@ +/** + * MIT License + * + * Copyright (c) 2019-2021 Matt + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +package dev.triumphteam.cmd.minecraft.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * Annotate a method using this Annotation to add a required permission + */ +@Retention(RetentionPolicy.RUNTIME) +@Target(ElementType.METHOD) +public @interface Permission { + /** + * @return Permission with nodes separated by periods "." + */ + String value(); +} From 46543bbee92286754c9cd251ed769ef9701bdf2e Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Fri, 13 May 2022 21:24:29 -0500 Subject: [PATCH 16/18] Register Arguments and suggestions --- .../cmd/sponge/SpongeCommandManager.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java index 9457157d..4e2d83ea 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java @@ -37,18 +37,25 @@ import net.kyori.adventure.text.Component; import org.jetbrains.annotations.Contract; import org.jetbrains.annotations.NotNull; +import org.spongepowered.api.ResourceKey; import org.spongepowered.api.Sponge; import org.spongepowered.api.command.Command; import org.spongepowered.api.command.CommandCause; +import org.spongepowered.api.entity.living.player.server.ServerPlayer; import org.spongepowered.api.event.Listener; import org.spongepowered.api.event.Order; import org.spongepowered.api.event.lifecycle.RegisterCommandEvent; +import org.spongepowered.api.item.ItemType; +import org.spongepowered.api.item.ItemTypes; import org.spongepowered.api.service.permission.Subject; +import org.spongepowered.api.world.WorldType; +import org.spongepowered.api.world.WorldTypes; import org.spongepowered.plugin.PluginContainer; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.stream.Collectors; public final class SpongeCommandManager extends CommandManager { @@ -156,6 +163,12 @@ private static void setUpDefaults(@NotNull final SpongeCommandManager m manager.registerMessage(MinecraftMessageKey.NO_PERMISSION, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("You do not have permission to perform this command. Permission needed: `" + context.getPermission() + "`."))); manager.registerMessage(MinecraftMessageKey.PLAYER_ONLY, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("This command can only be used by players."))); manager.registerMessage(MinecraftMessageKey.CONSOLE_ONLY, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("This command can only be used by the console."))); + + manager.registerArgument(ItemType.class, ((sender, arg) -> ItemTypes.registry().findValue(ResourceKey.resolve(arg)).orElse(null))); + manager.registerArgument(ServerPlayer.class, ((sender, arg) -> Sponge.server().player(arg).orElse(null))); + manager.registerArgument(WorldType.class, ((sender, arg) -> WorldTypes.registry().findValue(ResourceKey.resolve(arg)).orElse(null))); + + manager.registerSuggestion(ServerPlayer.class, ((sender, context) -> Sponge.server().onlinePlayers().stream().map(ServerPlayer::name).collect(Collectors.toList()))); } private Audience getAudience(Subject subject) { From 29a2e77bda0c45691821a125d3a8f3996c50758a Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Tue, 24 May 2022 18:47:03 -0500 Subject: [PATCH 17/18] exclude test module remove unused plugin and repo block in gradle condense sponge maven repo make Runnable final --- minecraft/mc-common/build.gradle.kts | 3 --- minecraft/sponge/build.gradle.kts | 5 +---- .../triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java | 2 +- settings.gradle.kts | 3 +-- 4 files changed, 3 insertions(+), 10 deletions(-) diff --git a/minecraft/mc-common/build.gradle.kts b/minecraft/mc-common/build.gradle.kts index 6d6103cb..5b6670da 100644 --- a/minecraft/mc-common/build.gradle.kts +++ b/minecraft/mc-common/build.gradle.kts @@ -1,10 +1,7 @@ plugins { id("cmds.base-conventions") - id("cmds.library-conventions") } -repositories {} - dependencies { api(project(":triumph-cmd-core")) } diff --git a/minecraft/sponge/build.gradle.kts b/minecraft/sponge/build.gradle.kts index 2fb35e72..722c70e9 100644 --- a/minecraft/sponge/build.gradle.kts +++ b/minecraft/sponge/build.gradle.kts @@ -4,10 +4,7 @@ plugins { } repositories { - maven { - name = "Sponge" - url = uri("https://repo.spongepowered.org/maven") - } + maven("https://repo.spongepowered.org/maven") } dependencies { diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java index f54dc539..2f2d74f7 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeAsyncExecutionProvider.java @@ -44,7 +44,7 @@ public final class SpongeAsyncExecutionProvider implements ExecutionProvider { * {@inheritDoc} */ @Override - public void execute(@NotNull Runnable command) { + public void execute(@NotNull final Runnable command) { Sponge.asyncScheduler().executor(plugin).submit(command); } } diff --git a/settings.gradle.kts b/settings.gradle.kts index cfa6d4a1..ff07dc51 100644 --- a/settings.gradle.kts +++ b/settings.gradle.kts @@ -14,6 +14,7 @@ listOf( listOf( "minecraft/bukkit", "minecraft/sponge", + "minecraft/mc-common", "discord/jda-common", "discord/jda-prefixed", "discord/jda-slash", @@ -22,8 +23,6 @@ listOf( includeProject(name, folder) } -include("Spawn-Protection") - fun includeProject(name: String) { include(name) { this.name = "${rootProject.name}-$name" From ba4f8c301f10229b226d212704992a5097a2c31e Mon Sep 17 00:00:00 2001 From: DrZoddiak Date: Wed, 25 May 2022 04:05:21 -0500 Subject: [PATCH 18/18] Fix argument registration and add suggestions for ItemTypes --- .../dev/triumphteam/cmd/sponge/SpongeCommandManager.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java index 4e2d83ea..6bd5882b 100644 --- a/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java +++ b/minecraft/sponge/src/main/java/dev/triumphteam/cmd/sponge/SpongeCommandManager.java @@ -46,10 +46,10 @@ import org.spongepowered.api.event.Order; import org.spongepowered.api.event.lifecycle.RegisterCommandEvent; import org.spongepowered.api.item.ItemType; -import org.spongepowered.api.item.ItemTypes; +import org.spongepowered.api.registry.RegistryEntry; +import org.spongepowered.api.registry.RegistryTypes; import org.spongepowered.api.service.permission.Subject; import org.spongepowered.api.world.WorldType; -import org.spongepowered.api.world.WorldTypes; import org.spongepowered.plugin.PluginContainer; import java.util.HashMap; @@ -164,11 +164,12 @@ private static void setUpDefaults(@NotNull final SpongeCommandManager m manager.registerMessage(MinecraftMessageKey.PLAYER_ONLY, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("This command can only be used by players."))); manager.registerMessage(MinecraftMessageKey.CONSOLE_ONLY, (sender, context) -> manager.getAudience(sender).sendMessage(Identity.nil(), Component.text("This command can only be used by the console."))); - manager.registerArgument(ItemType.class, ((sender, arg) -> ItemTypes.registry().findValue(ResourceKey.resolve(arg)).orElse(null))); + manager.registerArgument(ItemType.class, ((sender, arg) -> Sponge.game().registry(RegistryTypes.ITEM_TYPE).findValue(ResourceKey.resolve(arg)).orElse(null))); manager.registerArgument(ServerPlayer.class, ((sender, arg) -> Sponge.server().player(arg).orElse(null))); - manager.registerArgument(WorldType.class, ((sender, arg) -> WorldTypes.registry().findValue(ResourceKey.resolve(arg)).orElse(null))); + manager.registerArgument(WorldType.class, ((sender, arg) -> Sponge.game().registry(RegistryTypes.WORLD_TYPE).findValue(ResourceKey.resolve(arg)).orElse(null))); manager.registerSuggestion(ServerPlayer.class, ((sender, context) -> Sponge.server().onlinePlayers().stream().map(ServerPlayer::name).collect(Collectors.toList()))); + manager.registerSuggestion(ItemType.class, ((sender, context) -> Sponge.game().registry(RegistryTypes.ITEM_TYPE).streamEntries().map(RegistryEntry::key).map(ResourceKey::formatted).collect(Collectors.toList()))); } private Audience getAudience(Subject subject) {