diff --git a/README.md b/README.md index 8a5d6c3..1b20e02 100644 --- a/README.md +++ b/README.md @@ -4,10 +4,10 @@ ## Fabric versioning -| Minecraft version | Fabric version | command-manager-fabric vebric | -|-------------------|----------------|-------------------------------| -| 1.20.1 | 0.15.10 | [1.0.0 - 1.0.6] | -| 1.21.1 | 0.16.9 | [1.1.0 - ] | +| Minecraft version | Fabric version | command-manager-fabric version | +|-------------------|----------------|--------------------------------| +| 1.20.1 | 0.15.10 | [1.0.0 - 1.0.6] | +| 1.21.1 | 0.16.9 | [1.1.0 - ] | ```kotlin repositories { diff --git a/build.gradle.kts b/build.gradle.kts index 959d3aa..915cfe9 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -10,6 +10,20 @@ var _group = libs.versions.group.get() version = _version group = _group +fun getProperty(name: String): String { + if (project.hasProperty(name)) { + return project.findProperty(name) as String + } + + val envName = name.uppercase().replace(".", "_") + + if (System.getenv().containsKey(envName)) { + return System.getenv(envName) as String + } + + return "" +} + fun DependencyHandlerScope.applyDependencies() { // Dependencies if (project.properties["com.raduvoinea.utils.local"] != null) { @@ -28,6 +42,9 @@ fun DependencyHandlerScope.applyDependencies() { annotationProcessor(libs.jetbrains.annotations) testCompileOnly(libs.jetbrains.annotations) testAnnotationProcessor(libs.jetbrains.annotations) + + testImplementation(platform(libs.junit.bom)) + testImplementation(libs.junit.jupiter) } fun RepositoryHandler.applyRepositories() { @@ -35,6 +52,24 @@ fun RepositoryHandler.applyRepositories() { maven("https://maven.parchmentmc.org/") maven("https://repo.papermc.io/repository/maven-public/") maven("https://repo.raduvoinea.com/repository/maven-releases/") + + if (getProperty("gg.mmorealms.proxy.europe") == "true") { + maven(url = getProperty("gg.mmorealms.proxy.europe.url")) { + name = "Europe-MMORealms-Repository-Proxy" + credentials(PasswordCredentials::class) { + username = getProperty("gg.mmorealms.proxy.europe.username") + password = getProperty("gg.mmorealms.proxy.europe.password") + } + } + } else if(getProperty("gg.mmorealms.url")=="") { + maven(url = getProperty("gg.mmorealms.url")) { + name = "MMORealms-Repository" + credentials(PasswordCredentials::class) { + username = getProperty("gg.mmorealms.username") + password = getProperty("gg.mmorealms.password") + } + } + } } repositories { @@ -78,13 +113,23 @@ subprojects { repositories { if (project.properties["com.raduvoinea.publish"] == "true") { maven(url = (project.findProperty("com.raduvoinea.url") ?: "") as String) { - name = "raduvoineaRepository" + name = "RaduVoinea" credentials(PasswordCredentials::class) { username = (project.findProperty("com.raduvoinea.auth.username") ?: "") as String password = (project.findProperty("com.raduvoinea.auth.password") ?: "") as String } } } + + if (project.properties["generic.publish"] == "true") { + maven(url = (project.findProperty("generic.url") ?: "") as String) { + name = "Generic" + credentials(PasswordCredentials::class) { + username = (project.findProperty("generic.auth.username") ?: "") as String + password = (project.findProperty("generic.auth.password") ?: "") as String + } + } + } } } } diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index c51e2aa..6052ff7 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -1,28 +1,18 @@ [versions] -version = "1.1.9" +version = "1.1.15" group = "com.raduvoinea" [plugins] - -loom_v20 = { id = "fabric-loom", version = "1.5.5" } -loom_v21 = { id = "fabric-loom", version = "1.8.12" } +fabric_loom = { id = "fabric-loom", version = "1.10-SNAPSHOT" } +jetbrin_gradle_plugin_idea_ext = { id = "org.jetbrains.gradle.plugin.idea-ext", version = "1.1.8" } [libraries] - -# Minecraft - -# Fabric 1.20 -minecraft_v20 = { module = "com.mojang:minecraft", version = "1.20.1" } -fabric_api_v20 = { module = "net.fabricmc.fabric-api:fabric-api", version = "0.90.7+1.20.3" } -fabric_loader_v20 = { module = "net.fabricmc:fabric-loader", version = "0.15.10" } -parchment_mappings_v20 = { module = "org.parchmentmc.data:parchment-1.20.1", version = "2023.09.03" } - -# Fabric 1.21 -minecraft_v21 = { module = "com.mojang:minecraft", version = "1.21.1" } -fabric_api_v21 = { module = "net.fabricmc.fabric-api:fabric-api", version = "0.109.0+1.21.1" } -fabric_loader_v21 = { module = "net.fabricmc:fabric-loader", version = "0.16.9" } -parchment_mappings_v21 = { module = "org.parchmentmc.data:parchment-1.21", version = "2024.11.10" } +# Fabric +minecraft = { module = "com.mojang:minecraft", version = "1.21.1" } +fabric_api = { module = "net.fabricmc.fabric-api:fabric-api", version = "0.109.0+1.21.1" } +fabric_loader = { module = "net.fabricmc:fabric-loader", version = "0.16.9" } +parchment = { module = "org.parchmentmc.data:parchment-1.21", version = "2024.11.10" } # Velocioty velocity = { module = "com.velocitypowered:velocity-api", version = "3.4.0-SNAPSHOT" } @@ -33,4 +23,8 @@ jetbrains_annotations = { module = "org.jetbrains:annotations", version = "26.0. luckperms = { module = "net.luckperms:api", version = "5.4" } kyori_minimessage = { module = "net.kyori:adventure-text-minimessage", version = "4.17.0" } kyori_adventure_fabric = { module = "net.kyori:adventure-platform-fabric", version = "5.9.0" } -raduvoinea_utils = { module = "com.raduvoinea:utils", version = "1.1.28" } +raduvoinea_utils = { module = "com.raduvoinea:utils", version = "1.1.35" } + +# Testing +junit_jupiter = { module = "org.junit.jupiter:junit-jupiter ", version = "5.11.4" } +junit_bom = { module = "org.junit:junit-bom", version = "5.11.4" } diff --git a/renovate.json b/renovate.json index 7bd9545..af02576 100644 --- a/renovate.json +++ b/renovate.json @@ -1,6 +1,6 @@ { - "$schema": "https://docs.renovatebot.com/renovate-schema.json", - "extends": [ - "config:base" - ] + "$schema": "https://docs.renovatebot.com/renovate-schema.json", + "extends": [ + "config:base" + ] } diff --git a/src/common/src/main/java/com/raduvoinea/commandmanager/common/annotation/Command.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/annotation/Command.java index 6b25a66..b595546 100644 --- a/src/common/src/main/java/com/raduvoinea/commandmanager/common/annotation/Command.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/annotation/Command.java @@ -11,17 +11,17 @@ @Target(ElementType.TYPE) public @interface Command { - String[] aliases(); + String[] aliases(); - String[] arguments() default {}; + String[] arguments() default {}; - OnlyFor onlyFor() default OnlyFor.BOTH; + OnlyFor onlyFor() default OnlyFor.BOTH; - Class parent() default CommonCommand.class; + Class parent() default CommonCommand.class; - enum OnlyFor { - PLAYERS, - CONSOLE, - BOTH - } + enum OnlyFor { + PLAYERS, + CONSOLE, + BOTH + } } diff --git a/src/common/src/main/java/com/raduvoinea/commandmanager/common/command/CommonCommand.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/command/CommonCommand.java index 997bccd..37c6efc 100644 --- a/src/common/src/main/java/com/raduvoinea/commandmanager/common/command/CommonCommand.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/command/CommonCommand.java @@ -16,200 +16,200 @@ @SuppressWarnings("unused") public abstract class CommonCommand { - // Provided - private final CommonCommandManager commandManager; - private final @Getter Command annotation; - private final List subCommands; - - public CommonCommand(CommonCommandManager commandManager) throws CommandNotAnnotated { - this.commandManager = commandManager; - if (!this.getClass().isAnnotationPresent(Command.class)) { - throw new CommandNotAnnotated("Command " + this.getClass().getName() + " is not annotated with @Command."); - } - - this.annotation = this.getClass().getAnnotation(Command.class); - - subCommands = commandManager.getReflectionsCrawler().getOfType(CommonCommand.class) - .stream() - .filter(commandClass -> commandClass.isAnnotationPresent(Command.class)) - .filter(commandClass -> commandClass.getAnnotation(Command.class).parent().equals(this.getClass())) - .map(commandClass -> { - try { - CommonCommand command = commandClass.getConstructor(CommonCommandManager.class).newInstance(commandManager); - if (!commandManager.getInjectorHolder().isEmpty()) { - commandManager.getInjectorHolder().value().inject(command); - } - return command; - } catch (Exception error) { - Logger.error("There was an error while registering sub command " + commandClass.getName() + " for command(s) " + this.getAliases()); - Logger.error(error); - return null; - } - }) - .filter(Objects::nonNull) - .collect(Collectors.toList()); - } - - private String getFullCommand() { - String parentFullCommand = ""; - - if (!isRootCommand()) { - CommonCommand parent = commandManager.getCommand(getParent()); - - if (parent == null) { - Logger.error("Command " + getParent().getName() + " is not registered."); - return "Registration Error"; - } - - parentFullCommand = parent.getFullCommand() + " "; - } - - return parentFullCommand + this.getMainAlias(); - } - - private String getSimpleUsage() { - return commandManager.getConfig().simpleUsage - .parse("command", this.getFullCommand()) - .parse("arguments", String.join(" ", - getArguments().stream() - .map(arg -> "<" + arg + ">") - .toList() - )) - .parse(); - } - - private List getFullCommandAndSubCommands() { - List lines = new ArrayList<>(); - lines.add(this.getSimpleUsage()); - - for (CommonCommand subCommand : subCommands) { - lines.addAll(subCommand.getFullCommandAndSubCommands()); - } - - lines.sort(String::compareTo); - - return lines; - } - - public String getUsage() { - List subcommands = getFullCommandAndSubCommands(); - subcommands = subcommands.subList(1, subcommands.size()); - - if(subcommands.isEmpty()){ - return getSimpleUsage(); - } - - return commandManager.getConfig().complexUsage - .parse("simple_usage", getSimpleUsage()) - .parse("sub_commands", String.join("\n", subcommands)) - .parse(); - } - - public void execute(@NotNull Object executor, @NotNull List arguments) { - if (!commandManager.checkPermission(executor, getPermission())) { - commandManager.sendMessage(executor, "You don't have permission to execute this command."); - return; - } - - if (!arguments.isEmpty()) { - String subCommandName = arguments.getFirst(); - CommonCommand subCommand = subCommands.stream() - .filter(command -> command.getAliases().contains(subCommandName)) - .findFirst() - .orElse(null); - - if (subCommand != null) { - subCommand.execute(executor, arguments.subList(1, arguments.size())); - return; - } - } - - if (arguments.size() < this.getArguments().size()) { - sendMessage(executor, getUsage()); - return; - } - - if (annotation.onlyFor().equals(Command.OnlyFor.PLAYERS)) { - if (commandManager.getPlayerClass().isInstance(executor)) { - internalExecutePlayer(commandManager.getPlayerClass().cast(executor), arguments); - return; - } - commandManager.sendMessage(executor, "This command can only be executed by players."); - return; - } - - if (annotation.onlyFor().equals(Command.OnlyFor.CONSOLE)) { - if (commandManager.getConsoleClass().isInstance(executor)) { - internalExecuteConsole(commandManager.getConsoleClass().cast(executor), arguments); - return; - } - commandManager.sendMessage(executor, "This command can only be executed by a console."); - return; - } - - if (commandManager.getSenderClass().isInstance(executor)) { - internalExecuteCommon(commandManager.getSenderClass().cast(executor), arguments); - return; - } - - Logger.error(executor.getClass() + " is not a known executor type for the current platform."); - } - - - protected abstract void internalExecutePlayer(@NotNull Object player, @NotNull List arguments); - - protected abstract void internalExecuteConsole(@NotNull Object console, @NotNull List arguments); - - protected abstract void internalExecuteCommon(@NotNull Object sender, @NotNull List arguments); - - public @NotNull String getPermission() { - if (isRootCommand()) { - return commandManager.getConfig().basePermission + "." + annotation.aliases()[0]; - } - - CommonCommand command = commandManager.getCommand(getParent()); - - if (command == null) { - throw new RuntimeException("Command " + getParent().getName() + " is not registered."); - } - - return command.getPermission() + "." + annotation.aliases()[0]; - } - - public final @NotNull List getPrimitiveSubCommands() { - return this.subCommands; - } - - public List getArguments() { - return List.of(annotation.arguments()); - } - - public Class getParent() { - return annotation.parent(); - } - - public boolean isRootCommand() { - return getParent().equals(CommonCommand.class); - } - - public final String getMainAlias() { - return annotation.aliases()[0]; - } - - public final List getAliases() { - return List.of(annotation.aliases()); - } - - protected final void sendMessage(Object target, GenericMessageBuilder message) { - sendMessage(target, message.toString()); - } - - protected final void sendMessage(Object target, String message) { - commandManager.sendMessage(target, message); - } - - protected final boolean checkPermission(Object target, String permission) { - return commandManager.checkPermission(target, permission); - } + // Provided + private final CommonCommandManager commandManager; + private final @Getter Command annotation; + private final List subCommands; + + public CommonCommand(CommonCommandManager commandManager) throws CommandNotAnnotated { + this.commandManager = commandManager; + if (!this.getClass().isAnnotationPresent(Command.class)) { + throw new CommandNotAnnotated("Command " + this.getClass().getName() + " is not annotated with @Command."); + } + + this.annotation = this.getClass().getAnnotation(Command.class); + + subCommands = commandManager.getReflectionsCrawler().getOfType(CommonCommand.class) + .stream() + .filter(commandClass -> commandClass.isAnnotationPresent(Command.class)) + .filter(commandClass -> commandClass.getAnnotation(Command.class).parent().equals(this.getClass())) + .map(commandClass -> { + try { + CommonCommand command = commandClass.getConstructor(CommonCommandManager.class).newInstance(commandManager); + if (!commandManager.getInjectorHolder().isEmpty()) { + commandManager.getInjectorHolder().value().inject(command); + } + return command; + } catch (Exception error) { + Logger.error("There was an error while registering sub command " + commandClass.getName() + " for command(s) " + this.getAliases()); + Logger.error(error); + return null; + } + }) + .filter(Objects::nonNull) + .collect(Collectors.toList()); + } + + private String getFullCommand() { + String parentFullCommand = ""; + + if (!isRootCommand()) { + CommonCommand parent = commandManager.getCommand(getParent()); + + if (parent == null) { + Logger.error("Command " + getParent().getName() + " is not registered."); + return "Registration Error"; + } + + parentFullCommand = parent.getFullCommand() + " "; + } + + return parentFullCommand + this.getMainAlias(); + } + + private String getSimpleUsage() { + return commandManager.getConfig().simpleUsage + .parse("command", this.getFullCommand()) + .parse("arguments", String.join(" ", + getArguments().stream() + .map(arg -> "<" + arg + ">") + .toList() + )) + .parse(); + } + + private List getFullCommandAndSubCommands() { + List lines = new ArrayList<>(); + lines.add(this.getSimpleUsage()); + + for (CommonCommand subCommand : subCommands) { + lines.addAll(subCommand.getFullCommandAndSubCommands()); + } + + lines.sort(String::compareTo); + + return lines; + } + + public String getUsage() { + List subcommands = getFullCommandAndSubCommands(); + subcommands = subcommands.subList(1, subcommands.size()); + + if (subcommands.isEmpty()) { + return getSimpleUsage(); + } + + return commandManager.getConfig().complexUsage + .parse("simple_usage", getSimpleUsage()) + .parse("sub_commands", String.join("\n", subcommands)) + .parse(); + } + + public void execute(@NotNull Object executor, @NotNull List arguments) { + if (!commandManager.checkPermission(executor, getPermission())) { + commandManager.sendMessage(executor, "You don't have permission to execute this command."); + return; + } + + if (!arguments.isEmpty()) { + String subCommandName = arguments.getFirst(); + CommonCommand subCommand = subCommands.stream() + .filter(command -> command.getAliases().contains(subCommandName)) + .findFirst() + .orElse(null); + + if (subCommand != null) { + subCommand.execute(executor, arguments.subList(1, arguments.size())); + return; + } + } + + if (arguments.size() < this.getArguments().size()) { + sendMessage(executor, getUsage()); + return; + } + + if (annotation.onlyFor().equals(Command.OnlyFor.PLAYERS)) { + if (commandManager.getPlayerClass().isInstance(executor)) { + internalExecutePlayer(commandManager.getPlayerClass().cast(executor), arguments); + return; + } + commandManager.sendMessage(executor, "This command can only be executed by players."); + return; + } + + if (annotation.onlyFor().equals(Command.OnlyFor.CONSOLE)) { + if (commandManager.getConsoleClass().isInstance(executor)) { + internalExecuteConsole(commandManager.getConsoleClass().cast(executor), arguments); + return; + } + commandManager.sendMessage(executor, "This command can only be executed by a console."); + return; + } + + if (commandManager.getSenderClass().isInstance(executor)) { + internalExecuteCommon(commandManager.getSenderClass().cast(executor), arguments); + return; + } + + Logger.error(executor.getClass() + " is not a known executor type for the current platform."); + } + + + protected abstract void internalExecutePlayer(@NotNull Object player, @NotNull List arguments); + + protected abstract void internalExecuteConsole(@NotNull Object console, @NotNull List arguments); + + protected abstract void internalExecuteCommon(@NotNull Object sender, @NotNull List arguments); + + public @NotNull String getPermission() { + if (isRootCommand()) { + return commandManager.getConfig().basePermission + "." + annotation.aliases()[0]; + } + + CommonCommand command = commandManager.getCommand(getParent()); + + if (command == null) { + throw new RuntimeException("Command " + getParent().getName() + " is not registered."); + } + + return command.getPermission() + "." + annotation.aliases()[0]; + } + + public final @NotNull List getPrimitiveSubCommands() { + return this.subCommands; + } + + public List getArguments() { + return List.of(annotation.arguments()); + } + + public Class getParent() { + return annotation.parent(); + } + + public boolean isRootCommand() { + return getParent().equals(CommonCommand.class); + } + + public final String getMainAlias() { + return annotation.aliases()[0]; + } + + public final List getAliases() { + return List.of(annotation.aliases()); + } + + protected final void sendMessage(Object target, GenericMessageBuilder message) { + sendMessage(target, message.toString()); + } + + protected final void sendMessage(Object target, String message) { + commandManager.sendMessage(target, message); + } + + protected final boolean checkPermission(Object target, String permission) { + return commandManager.checkPermission(target, permission); + } } diff --git a/src/common/src/main/java/com/raduvoinea/commandmanager/common/config/CommandManagerConfig.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/config/CommandManagerConfig.java index 759d72f..8080e49 100644 --- a/src/common/src/main/java/com/raduvoinea/commandmanager/common/config/CommandManagerConfig.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/config/CommandManagerConfig.java @@ -4,15 +4,15 @@ public class CommandManagerConfig { - public String basePermission = "project.command"; - public MessageBuilder simpleUsage = new MessageBuilder("/{command} {arguments}"); - public MessageBuilder complexUsage = new MessageBuilder(""" - Usage: {simple_usage} - - Sub commands: - {sub_commands} - """ - ); + public String basePermission = "project.command"; + public MessageBuilder simpleUsage = new MessageBuilder("/{command} {arguments}"); + public MessageBuilder complexUsage = new MessageBuilder(""" + Usage: {simple_usage} + + Sub commands: + {sub_commands} + """ + ); /* Usage: /discord diff --git a/src/common/src/main/java/com/raduvoinea/commandmanager/common/exception/CommandNotAnnotated.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/exception/CommandNotAnnotated.java index e23af75..c3bd1e3 100644 --- a/src/common/src/main/java/com/raduvoinea/commandmanager/common/exception/CommandNotAnnotated.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/exception/CommandNotAnnotated.java @@ -2,7 +2,7 @@ public class CommandNotAnnotated extends RuntimeException { - public CommandNotAnnotated(String message) { - super(message); - } + public CommandNotAnnotated(String message) { + super(message); + } } diff --git a/src/common/src/main/java/com/raduvoinea/commandmanager/common/manager/CommonCommandManager.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/manager/CommonCommandManager.java index 20c9a04..ec5b8fe 100644 --- a/src/common/src/main/java/com/raduvoinea/commandmanager/common/manager/CommonCommandManager.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/manager/CommonCommandManager.java @@ -21,95 +21,98 @@ @Getter public abstract class CommonCommandManager { - private final Reflections.Crawler reflectionsCrawler; - private final List commands = new ArrayList<>(); - private final Class playerClass; - private final Class consoleClass; - private final Class senderClass; - private final CommandManagerConfig config; - private final Holder injectorHolder; - - public CommonCommandManager(@NotNull Reflections.Crawler reflectionsCrawler, @NotNull Class playerClass, - @NotNull Class consoleClass, @NotNull Class senderClass, - @NotNull CommandManagerConfig config, @NotNull Holder injectorHolder) { - this.reflectionsCrawler = reflectionsCrawler; - this.playerClass = playerClass; - this.consoleClass = consoleClass; - this.senderClass = senderClass; - this.config = config; - this.injectorHolder = injectorHolder; - } - - public void register(@NotNull Class commandClass) { - try { - Command commandAnnotation = commandClass.getAnnotation(Command.class); - if (commandAnnotation != null && commandAnnotation.parent() != CommonCommand.class) { - return; - } - - if (Modifier.isAbstract(commandClass.getModifiers())) { - return; - } - - CommonCommand command = commandClass.getConstructor(CommonCommandManager.class).newInstance(this); - if (!injectorHolder.isEmpty()) { - injectorHolder.value().inject(command); - } - register(command); - } catch (Throwable error) { - // Do not print NotAnnotated error as errors, but was warnings. There are legitimate uses of it not being - // annotated, but it might also be an oversight that needs to be addressed. - if (error instanceof CommandNotAnnotated) { - Logger.warn(error.getMessage()); - return; - } - - if (error instanceof InvocationTargetException invocationError) { - if (invocationError.getTargetException() instanceof CommandNotAnnotated) { - Logger.warn(invocationError.getTargetException().getMessage()); - return; - } - } - - Logger.error(error); - Logger.error("There was an error while registering command " + commandClass.getName()); - } - } - - private void register(@NotNull CommonCommand command) { - Logger.log("Registering command(s) " + command.getAliases()); - commands.add(command); - platformRegister(command); - } - - public @Nullable CommonCommand getCommand(@NotNull Class commandClass) { - for (CommonCommand command : commands) { - if (command.getClass().equals(commandClass)) { - return command; - } - - for (CommonCommand subCommand : command.getPrimitiveSubCommands()) { - if (subCommand.getClass().equals(commandClass)) { - return subCommand; - } - } - } - - return null; - } - - public boolean checkPermission(Object target, String permission) { - if (consoleClass.isInstance(target)) { - return true; - } - if (playerClass.isInstance(target)) { - return LuckPermsUtils.checkPermission(playerClass, playerClass.cast(target), permission); - } - return LuckPermsUtils.checkPermission(playerClass, senderClass.cast(target), permission); - } - - protected abstract void platformRegister(@NotNull CommonCommand command); - - public abstract void sendMessage(Object target, String message); + private final Reflections.Crawler reflectionsCrawler; + private final List commands = new ArrayList<>(); + private final Class playerClass; + private final Class consoleClass; + private final Class senderClass; + private final CommandManagerConfig config; + private final Holder injectorHolder; + + public CommonCommandManager(@NotNull Reflections.Crawler reflectionsCrawler, @NotNull Class playerClass, + @NotNull Class consoleClass, @NotNull Class senderClass, + @NotNull CommandManagerConfig config, @NotNull Holder injectorHolder) { + this.reflectionsCrawler = reflectionsCrawler; + this.playerClass = playerClass; + this.consoleClass = consoleClass; + this.senderClass = senderClass; + this.config = config; + this.injectorHolder = injectorHolder; + } + + public void register(@NotNull Class commandClass) { + register(commandClass.getAnnotation(Command.class), commandClass); + } + + public void register(Command commandAnnotation, @NotNull Class commandClass) { + try { + if (commandAnnotation != null && commandAnnotation.parent() != CommonCommand.class) { + return; + } + + if (Modifier.isAbstract(commandClass.getModifiers())) { + return; + } + + CommonCommand command = commandClass.getConstructor(CommonCommandManager.class).newInstance(this); + if (!injectorHolder.isEmpty()) { + injectorHolder.value().inject(command); + } + register(command); + } catch (Throwable error) { + // Do not print NotAnnotated error as errors, but was warnings. There are legitimate uses of it not being + // annotated, but it might also be an oversight that needs to be addressed. + if (error instanceof CommandNotAnnotated) { + Logger.warn(error.getMessage()); + return; + } + + if (error instanceof InvocationTargetException invocationError) { + if (invocationError.getTargetException() instanceof CommandNotAnnotated) { + Logger.warn(invocationError.getTargetException().getMessage()); + return; + } + } + + Logger.error(error); + Logger.error("There was an error while registering command " + commandClass.getName()); + } + } + + private void register(@NotNull CommonCommand command) { + Logger.log("Registering command(s) " + command.getAliases()); + commands.add(command); + platformRegister(command); + } + + public @Nullable CommonCommand getCommand(@NotNull Class commandClass) { + for (CommonCommand command : commands) { + if (command.getClass().equals(commandClass)) { + return command; + } + + for (CommonCommand subCommand : command.getPrimitiveSubCommands()) { + if (subCommand.getClass().equals(commandClass)) { + return subCommand; + } + } + } + + return null; + } + + public boolean checkPermission(Object target, String permission) { + if (consoleClass.isInstance(target)) { + return true; + } + if (playerClass.isInstance(target)) { + return LuckPermsUtils.checkPermission(playerClass, playerClass.cast(target), permission); + } + return LuckPermsUtils.checkPermission(playerClass, senderClass.cast(target), permission); + } + + protected abstract void platformRegister(@NotNull CommonCommand command); + + public abstract void sendMessage(Object target, String message); } diff --git a/src/common/src/main/java/com/raduvoinea/commandmanager/common/manager/CommonMiniMessageManager.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/manager/CommonMiniMessageManager.java index b8b1ff0..179f900 100644 --- a/src/common/src/main/java/com/raduvoinea/commandmanager/common/manager/CommonMiniMessageManager.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/manager/CommonMiniMessageManager.java @@ -13,54 +13,54 @@ public abstract class CommonMiniMessageManager { - public abstract @NotNull NativeComponent toNative(@NotNull Component component); + public abstract @NotNull NativeComponent toNative(@NotNull Component component); - public @NotNull List parse(@NotNull List message) { - List output = new ArrayList<>(); + public @NotNull List parse(@NotNull List message) { + List output = new ArrayList<>(); - for (String line : message) { - output.add(parse(line)); - } + for (String line : message) { + output.add(parse(line)); + } - return output; - } + return output; + } - public @NotNull List parse(@NotNull MessageBuilderList message) { - return parse(message.parse()); - } + public @NotNull List parse(@NotNull MessageBuilderList message) { + return parse(message.parse()); + } - public @NotNull NativeComponent parse(@Nullable String message) { - if (message == null) { - message = "null"; - } - return toNative(toComponent(message)); - } + public @NotNull NativeComponent parse(@Nullable String message) { + if (message == null) { + message = "null"; + } + return toNative(toComponent(message)); + } - public @NotNull NativeComponent parse(@NotNull MessageBuilder message) { - return parse(message.parse()); - } + public @NotNull NativeComponent parse(@NotNull MessageBuilder message) { + return parse(message.parse()); + } - public @NotNull Component toComponent(@NotNull String message) { - return MiniMessage.miniMessage().deserialize(message); - } + public @NotNull Component toComponent(@NotNull String message) { + return MiniMessage.miniMessage().deserialize(message); + } - @SuppressWarnings("unused") - public @NotNull Component toComponent(@NotNull MessageBuilder builder) { - return toComponent(builder.parse()); - } + @SuppressWarnings("unused") + public @NotNull Component toComponent(@NotNull MessageBuilder builder) { + return toComponent(builder.parse()); + } - public @NotNull String sanitize(@NotNull String text) { - return sanitize(toComponent(text)); - } + public @NotNull String sanitize(@NotNull String text) { + return sanitize(toComponent(text)); + } - public abstract @NotNull String sanitize(Component component); + public abstract @NotNull String sanitize(Component component); - public String serialize(Component component) { - return MiniMessage.miniMessage().serialize(component); - } + public String serialize(Component component) { + return MiniMessage.miniMessage().serialize(component); + } - @SuppressWarnings("unused") - public TextComponent deserialize(String message) { - return (TextComponent) parse(message); - } + @SuppressWarnings("unused") + public TextComponent deserialize(String message) { + return (TextComponent) parse(message); + } } \ No newline at end of file diff --git a/src/common/src/main/java/com/raduvoinea/commandmanager/common/utils/ListUtils.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/utils/ListUtils.java index 59141d4..0996219 100644 --- a/src/common/src/main/java/com/raduvoinea/commandmanager/common/utils/ListUtils.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/utils/ListUtils.java @@ -6,8 +6,8 @@ public class ListUtils { - public static List getListThatStartsWith(List list, String prefix) { - return list.stream().filter(s -> s.toLowerCase().startsWith(prefix.toLowerCase())).collect(Collectors.toList()); - } + public static List getListThatStartsWith(List list, String prefix) { + return list.stream().filter(s -> s.toLowerCase().startsWith(prefix.toLowerCase())).collect(Collectors.toList()); + } } diff --git a/src/common/src/main/java/com/raduvoinea/commandmanager/common/utils/LuckPermsUtils.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/utils/LuckPermsUtils.java index f692671..7ad0ccd 100644 --- a/src/common/src/main/java/com/raduvoinea/commandmanager/common/utils/LuckPermsUtils.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/utils/LuckPermsUtils.java @@ -6,154 +6,129 @@ import net.luckperms.api.LuckPermsProvider; import net.luckperms.api.model.group.Group; import net.luckperms.api.model.user.User; -import net.luckperms.api.node.NodeType; -import net.luckperms.api.node.types.ChatMetaNode; import net.luckperms.api.platform.PlayerAdapter; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.*; +import java.util.OptionalInt; +import java.util.UUID; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; public class LuckPermsUtils { - private static final String DEFAULT_GROUP_NAME = "default"; + private static final String DEFAULT_GROUP_NAME = "default"; - public static boolean checkPermission(Class playerClass, Object player, String permission) { - try { - LuckPerms luckPerms = LuckPermsProvider.get(); + public static boolean checkPermission(Class playerClass, Object player, String permission) { + try { + LuckPerms luckPerms = LuckPermsProvider.get(); - //noinspection rawtypes - PlayerAdapter playerAdapter = luckPerms.getPlayerAdapter(playerClass); - //noinspection unchecked - return playerAdapter.getPermissionData(player).checkPermission(permission).asBoolean(); - } catch (Exception error) { - // No LuckPerms - has no permission - Logger.error(error); - return false; - } - } + //noinspection rawtypes + PlayerAdapter playerAdapter = luckPerms.getPlayerAdapter(playerClass); + //noinspection unchecked + return playerAdapter.getPermissionData(player).checkPermission(permission).asBoolean(); + } catch (Exception error) { + // No LuckPerms - has no permission + Logger.error(error); + return false; + } + } - public static @NotNull Group getGroup(@NotNull UUID userUUID) { - User user = getUser(userUUID); - return getGroup(user); - } + public static @NotNull Group getGroup(@NotNull UUID userUUID) { + User user = getUser(userUUID); + return getGroup(user); + } - public static @NotNull Group getGroup(@Nullable User user) { - LuckPerms luckPerms = LuckPermsProvider.get(); + public static @NotNull Group getGroup(@Nullable User user) { + LuckPerms luckPerms = LuckPermsProvider.get(); - if (user == null) { - return getDefaultGroup(); - } + if (user == null) { + return getDefaultGroup(); + } - String groupName = user.getPrimaryGroup(); - Group group = luckPerms.getGroupManager().getGroup(groupName); + String groupName = user.getPrimaryGroup(); + Group group = luckPerms.getGroupManager().getGroup(groupName); - if (group == null) { - return getDefaultGroup(); - } + if (group == null) { + return getDefaultGroup(); + } - return group; - } + return group; + } - public static @NotNull Group getDefaultGroup() { - LuckPerms luckPerms = LuckPermsProvider.get(); + public static @NotNull Group getDefaultGroup() { + LuckPerms luckPerms = LuckPermsProvider.get(); - Group group = luckPerms.getGroupManager().getGroup(DEFAULT_GROUP_NAME); + Group group = luckPerms.getGroupManager().getGroup(DEFAULT_GROUP_NAME); - if (group == null) { - throw new IllegalStateException("'default' group not found"); - } + if (group == null) { + throw new IllegalStateException("'default' group not found"); + } - return group; - } + return group; + } - public static String getPrefix(@Nullable User user, @Nullable Group group) { - return getNodeType(user, group, NodeType.PREFIX); - } + public static String getPrefix(@NotNull UUID uuid) { + User user = getUser(uuid); - public static String getSuffix(@Nullable User user, @Nullable Group group) { - return getNodeType(user, group, NodeType.SUFFIX); - } + return getPrefix(user); + } - @SuppressWarnings({"unchecked", "rawtypes"}) - public static String getNodeType(@Nullable User user, @Nullable Group group, - NodeType nodeType) { - List userPrefixNodes = new ArrayList<>(); - List groupPrefixNodes = new ArrayList<>(); + public static String getPrefix(@Nullable User user) { + if (user == null) { + return ""; + } - if (user != null) { - userPrefixNodes = (List) new ArrayList<>(user.getNodes(nodeType).stream().toList()); - } - if (group != null) { - groupPrefixNodes = (List) new ArrayList<>(group.getNodes(nodeType).stream().toList()); - } + return user.getCachedData().getMetaData().getPrefix(); + } - List prefixNodes = new ArrayList<>(); - prefixNodes.addAll(userPrefixNodes); - prefixNodes.addAll(groupPrefixNodes); + public static String getSuffix(@NotNull UUID uuid) { + User user = getUser(uuid); - prefixNodes.sort(Comparator.comparingInt(ChatMetaNode::getPriority)); - T prefix = prefixNodes.stream().findFirst().orElse(null); + return getSuffix(user); + } - String prefixString = prefix == null ? "" : prefix.getKey(); - if (prefixString.contains(".")) { - String[] split = prefixString.split("\\."); - prefixString = split[split.length - 1]; - } + public static String getSuffix(@Nullable User user) { + if (user == null) { + return ""; + } - return prefixString; - } + return user.getCachedData().getMetaData().getSuffix(); + } + @SneakyThrows(value = {InterruptedException.class, ExecutionException.class}) + public static @Nullable User getUser(@NotNull UUID userUUID) { + LuckPerms luckPerms = LuckPermsProvider.get(); + User user; - public static String getPrefix(@NotNull UUID uuid) { - User user = getUser(uuid); - Group group = getGroup(user); + user = luckPerms.getUserManager().getUser(userUUID); - return getPrefix(user, group); - } + if (user == null) { + CompletableFuture completableLPUser = luckPerms.getUserManager().loadUser(userUUID); + user = completableLPUser.get(); + } - public static String getSuffix(@NotNull UUID uuid) { - User user = getUser(uuid); - Group group = getGroup(user); + return user; + } - return getSuffix(user, group); - } + public static int getWeight(Group group) { + OptionalInt optionalWeight = group.getWeight(); - @SneakyThrows(value = {InterruptedException.class, ExecutionException.class}) - public static @Nullable User getUser(@NotNull UUID userUUID) { - LuckPerms luckPerms = LuckPermsProvider.get(); - User user; + if (optionalWeight.isEmpty()) { + return 0; + } - user = luckPerms.getUserManager().getUser(userUUID); + return optionalWeight.getAsInt(); + } - if (user == null) { - CompletableFuture completableLPUser = luckPerms.getUserManager().loadUser(userUUID); - user = completableLPUser.get(); - } + public static int getWeight(User user) { + Group group = getGroup(user); + return getWeight(group); + } - return user; - } - - public static int getWeight(Group group) { - OptionalInt optionalWeight = group.getWeight(); - - if (optionalWeight.isEmpty()) { - return 0; - } - - return optionalWeight.getAsInt(); - } - - public static int getWeight(User user) { - Group group = getGroup(user); - return getWeight(group); - } - - public static int getWeight(UUID userUUID) { - Group group = getGroup(userUUID); - return getWeight(group); - } + public static int getWeight(UUID userUUID) { + Group group = getGroup(userUUID); + return getWeight(group); + } } diff --git a/src/common/src/test/java/CommandTests.java b/src/common/src/test/java/CommandTests.java index 4b47993..b9947c2 100644 --- a/src/common/src/test/java/CommandTests.java +++ b/src/common/src/test/java/CommandTests.java @@ -11,54 +11,54 @@ public class CommandTests { - private static SimpleCommandManager commandManager; + private static SimpleCommandManager commandManager; - @BeforeAll - public static void setup() { - commandManager = new SimpleCommandManager(Reflections.simple( - CommandTests.class.getClassLoader(), - BaseCommand.class, - SubCommand1.class, - SubCommand2.class, - SubSubCommand1.class, - SubSubCommand2.class - ), new CommandManagerConfig()); - commandManager.register(BaseCommand.class); - } + @BeforeAll + public static void setup() { + commandManager = new SimpleCommandManager(Reflections.simple( + CommandTests.class.getClassLoader(), + BaseCommand.class, + SubCommand1.class, + SubCommand2.class, + SubSubCommand1.class, + SubSubCommand2.class + ), new CommandManagerConfig()); + commandManager.register(BaseCommand.class); + } - @Test - public void testCommandUsage() { - CommonCommand command = commandManager.getCommand(BaseCommand.class); + @Test + public void testCommandUsage() { + CommonCommand command = commandManager.getCommand(BaseCommand.class); - assertNotNull(command); + assertNotNull(command); - String usage = command.getUsage(); + String usage = command.getUsage(); - assertEquals(""" - Usage: /base - - Sub commands: - /base sub1 - /base sub1 subsub1 - /base sub2 - /base sub2 subsub2 - """, usage); - } + assertEquals(""" + Usage: /base + + Sub commands: + /base sub1 + /base sub1 subsub1 + /base sub2 + /base sub2 subsub2 + """, usage); + } - @Test - public void testSubCommandUsage() { - CommonCommand command = commandManager.getCommand(SubCommand1.class); + @Test + public void testSubCommandUsage() { + CommonCommand command = commandManager.getCommand(SubCommand1.class); - assertNotNull(command); + assertNotNull(command); - String usage = command.getUsage(); + String usage = command.getUsage(); - assertEquals(""" - Usage: /base sub1 - - Sub commands: - /base sub1 subsub1 - """, usage); - } + assertEquals(""" + Usage: /base sub1 + + Sub commands: + /base sub1 subsub1 + """, usage); + } } diff --git a/src/common/src/test/java/command/BaseCommand.java b/src/common/src/test/java/command/BaseCommand.java index c5413fc..daa934e 100644 --- a/src/common/src/test/java/command/BaseCommand.java +++ b/src/common/src/test/java/command/BaseCommand.java @@ -10,12 +10,12 @@ @Command(aliases = "base", arguments = {"b1", "b2"}) public class BaseCommand extends SimpleCommand { - public BaseCommand(CommonCommandManager commandManager) throws CommandNotAnnotated { - super(commandManager); - } + public BaseCommand(CommonCommandManager commandManager) throws CommandNotAnnotated { + super(commandManager); + } - @Override - protected void execute(CommandSender sender, List arguments) { + @Override + protected void execute(CommandSender sender, List arguments) { - } + } } diff --git a/src/common/src/test/java/command/SubCommand1.java b/src/common/src/test/java/command/SubCommand1.java index d13f6f6..b54936d 100644 --- a/src/common/src/test/java/command/SubCommand1.java +++ b/src/common/src/test/java/command/SubCommand1.java @@ -10,12 +10,12 @@ @Command(aliases = "sub1", arguments = {"s1", "s2"}, parent = BaseCommand.class) public class SubCommand1 extends SimpleCommand { - public SubCommand1(CommonCommandManager commandManager) throws CommandNotAnnotated { - super(commandManager); - } + public SubCommand1(CommonCommandManager commandManager) throws CommandNotAnnotated { + super(commandManager); + } - @Override - protected void execute(CommandSender sender, List arguments) { + @Override + protected void execute(CommandSender sender, List arguments) { - } + } } diff --git a/src/common/src/test/java/command/SubCommand2.java b/src/common/src/test/java/command/SubCommand2.java index 2d2c8ed..99fe51e 100644 --- a/src/common/src/test/java/command/SubCommand2.java +++ b/src/common/src/test/java/command/SubCommand2.java @@ -10,12 +10,12 @@ @Command(aliases = "sub2", arguments = {"s1", "s2"}, parent = BaseCommand.class) public class SubCommand2 extends SimpleCommand { - public SubCommand2(CommonCommandManager commandManager) throws CommandNotAnnotated { - super(commandManager); - } + public SubCommand2(CommonCommandManager commandManager) throws CommandNotAnnotated { + super(commandManager); + } - @Override - protected void execute(CommandSender sender, List arguments) { + @Override + protected void execute(CommandSender sender, List arguments) { - } + } } diff --git a/src/common/src/test/java/command/SubSubCommand1.java b/src/common/src/test/java/command/SubSubCommand1.java index 659a928..3eef76e 100644 --- a/src/common/src/test/java/command/SubSubCommand1.java +++ b/src/common/src/test/java/command/SubSubCommand1.java @@ -10,12 +10,12 @@ @Command(aliases = "subsub1", arguments = {"ss1", "ss2"}, parent = SubCommand1.class) public class SubSubCommand1 extends SimpleCommand { - public SubSubCommand1(CommonCommandManager commandManager) throws CommandNotAnnotated { - super(commandManager); - } + public SubSubCommand1(CommonCommandManager commandManager) throws CommandNotAnnotated { + super(commandManager); + } - @Override - protected void execute(CommandSender sender, List arguments) { + @Override + protected void execute(CommandSender sender, List arguments) { - } + } } diff --git a/src/common/src/test/java/command/SubSubCommand2.java b/src/common/src/test/java/command/SubSubCommand2.java index 8c69529..5dce73b 100644 --- a/src/common/src/test/java/command/SubSubCommand2.java +++ b/src/common/src/test/java/command/SubSubCommand2.java @@ -10,12 +10,12 @@ @Command(aliases = "subsub2", arguments = {"ss1", "ss2"}, parent = SubCommand2.class) public class SubSubCommand2 extends SimpleCommand { - public SubSubCommand2(CommonCommandManager commandManager) throws CommandNotAnnotated { - super(commandManager); - } + public SubSubCommand2(CommonCommandManager commandManager) throws CommandNotAnnotated { + super(commandManager); + } - @Override - protected void execute(CommandSender sender, List arguments) { + @Override + protected void execute(CommandSender sender, List arguments) { - } + } } diff --git a/src/common/src/test/java/dto/CommandSender.java b/src/common/src/test/java/dto/CommandSender.java index 834130e..a4922f2 100644 --- a/src/common/src/test/java/dto/CommandSender.java +++ b/src/common/src/test/java/dto/CommandSender.java @@ -2,6 +2,6 @@ public interface CommandSender { - void sendMessage(String message); + void sendMessage(String message); } diff --git a/src/common/src/test/java/dto/SimpleCommand.java b/src/common/src/test/java/dto/SimpleCommand.java index fce555c..ad97cce 100644 --- a/src/common/src/test/java/dto/SimpleCommand.java +++ b/src/common/src/test/java/dto/SimpleCommand.java @@ -8,24 +8,24 @@ import java.util.List; public abstract class SimpleCommand extends CommonCommand { - public SimpleCommand(CommonCommandManager commandManager) throws CommandNotAnnotated { - super(commandManager); - } + public SimpleCommand(CommonCommandManager commandManager) throws CommandNotAnnotated { + super(commandManager); + } - @Override - protected void internalExecutePlayer(@NotNull Object player, @NotNull List arguments) { - execute((CommandSender) player, arguments); - } + @Override + protected void internalExecutePlayer(@NotNull Object player, @NotNull List arguments) { + execute((CommandSender) player, arguments); + } - @Override - protected void internalExecuteConsole(@NotNull Object console, @NotNull List arguments) { - execute((CommandSender) console, arguments); - } + @Override + protected void internalExecuteConsole(@NotNull Object console, @NotNull List arguments) { + execute((CommandSender) console, arguments); + } - @Override - protected void internalExecuteCommon(@NotNull Object sender, @NotNull List arguments) { - execute((CommandSender) sender, arguments); - } + @Override + protected void internalExecuteCommon(@NotNull Object sender, @NotNull List arguments) { + execute((CommandSender) sender, arguments); + } - protected abstract void execute(CommandSender sender, List arguments); + protected abstract void execute(CommandSender sender, List arguments); } diff --git a/src/common/src/test/java/dto/SimpleConsole.java b/src/common/src/test/java/dto/SimpleConsole.java index 5ec33a7..6fe55f8 100644 --- a/src/common/src/test/java/dto/SimpleConsole.java +++ b/src/common/src/test/java/dto/SimpleConsole.java @@ -8,13 +8,13 @@ @Getter @NoArgsConstructor -public class SimpleConsole implements CommandSender{ +public class SimpleConsole implements CommandSender { - private final List messages = new ArrayList<>(); + private final List messages = new ArrayList<>(); - @Override - public void sendMessage(String message) { - messages.add(message); - } + @Override + public void sendMessage(String message) { + messages.add(message); + } } diff --git a/src/common/src/test/java/dto/SimplePlayer.java b/src/common/src/test/java/dto/SimplePlayer.java index 5547d9b..95ab180 100644 --- a/src/common/src/test/java/dto/SimplePlayer.java +++ b/src/common/src/test/java/dto/SimplePlayer.java @@ -10,11 +10,11 @@ @NoArgsConstructor public class SimplePlayer implements CommandSender { - private final List messages = new ArrayList<>(); + private final List messages = new ArrayList<>(); - @Override - public void sendMessage(String message) { - messages.add(message); - } + @Override + public void sendMessage(String message) { + messages.add(message); + } } diff --git a/src/common/src/test/java/manager/SimpleCommandManager.java b/src/common/src/test/java/manager/SimpleCommandManager.java index b2835af..fc21495 100644 --- a/src/common/src/test/java/manager/SimpleCommandManager.java +++ b/src/common/src/test/java/manager/SimpleCommandManager.java @@ -12,18 +12,18 @@ public class SimpleCommandManager extends CommonCommandManager { - public SimpleCommandManager(Reflections.@NotNull Crawler reflectionsCrawler, @NotNull CommandManagerConfig config) { - super(reflectionsCrawler, SimplePlayer.class, SimpleConsole.class, CommandSender.class, config, Holder.empty()); - } + public SimpleCommandManager(Reflections.@NotNull Crawler reflectionsCrawler, @NotNull CommandManagerConfig config) { + super(reflectionsCrawler, SimplePlayer.class, SimpleConsole.class, CommandSender.class, config, Holder.empty()); + } - @Override - protected void platformRegister(@NotNull CommonCommand command) { + @Override + protected void platformRegister(@NotNull CommonCommand command) { - } + } - @Override - public void sendMessage(Object target, String message) { - ((CommandSender) target).sendMessage(message); - } + @Override + public void sendMessage(Object target, String message) { + ((CommandSender) target).sendMessage(message); + } } diff --git a/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/command/FabricCommand.java b/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/command/FabricCommand.java index 561532a..f513791 100644 --- a/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/command/FabricCommand.java +++ b/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/command/FabricCommand.java @@ -7,6 +7,7 @@ import com.mojang.brigadier.context.CommandContext; import com.raduvoinea.commandmanager.common.command.CommonCommand; import com.raduvoinea.commandmanager.common.manager.CommonCommandManager; +import com.raduvoinea.commandmanager.common.utils.ListUtils; import com.raduvoinea.commandmanager.fabric.manager.FabricCommandManager; import com.raduvoinea.utils.logger.Logger; import net.minecraft.commands.CommandSource; @@ -28,148 +29,161 @@ @SuppressWarnings("unused") public abstract class FabricCommand extends CommonCommand { - public static final String commandSourceFiled = "field_9819"; - private final FabricCommandManager commandManager; - - public FabricCommand(CommonCommandManager commandManager) { - super(commandManager); - this.commandManager = (FabricCommandManager) commandManager; - } - - public @NotNull Set getSubCommands() { - return getPrimitiveSubCommands() - .stream().map(command -> (FabricCommand) command) - .collect(Collectors.toSet()); - } - - @SuppressWarnings("SameReturnValue") - private int internalExecute(@NotNull CommandContext context) { - try { - CommandSourceStack source = context.getSource(); - - List arguments = this.getArguments().stream() - .map(argument -> { - if (argument.startsWith("?")) { - argument = argument.substring(1); - } - - try { - return context.getArgument(argument, String.class); - } catch (IllegalArgumentException e) { - return null; - } - }) - .toList(); - - if (source.isPlayer()) { - execute(source.getPlayer(), arguments); - } else { - execute(source.getServer(), arguments); - } - - } catch (Throwable error) { - Logger.error(error); - } - - return 0; - } - - public LiteralArgumentBuilder getCommandBuilder(@NotNull String alias) { - LiteralArgumentBuilder command = literal(alias); - - for (FabricCommand subCommand : getSubCommands()) { - Logger.log("Registering subcommand(s): " + subCommand.getAliases() + " for " + alias); - for (String subAlias : subCommand.getAliases()) { - command = command.then(subCommand.getCommandBuilder(subAlias)); - } - } - - List> arguments = new ArrayList<>(); - - for (String argument : getArguments()) { - if (argument.startsWith("?")) { - argument = argument.substring(1); - } - ArgumentType argumentType = StringArgumentType.string(); - if (argument.endsWith("...")) { - argumentType = StringArgumentType.greedyString(); - } - - String finalArgument = argument; - arguments.add(Commands - .argument(argument, argumentType) - .suggests((context, builder) -> { - for (String suggestionString : onAutoComplete(finalArgument, context)) { - builder.suggest(suggestionString); - } - - return builder.buildFuture(); - } - )); - } - - ArgumentBuilder then = null; - - if (!arguments.isEmpty()) { - arguments.getLast().executes(this::internalExecute); - - if (arguments.size() != 1) { - for (int index = arguments.size() - 2; index >= 0; index--) { - arguments.get(index).then(arguments.get(index + 1)); - - if (getArguments().get(index + 1).startsWith("?")) { - arguments.get(index).executes(this::internalExecute); - } - } - } - - then = arguments.getFirst(); - } else { - command.executes(this::internalExecute); - } - - if (then != null) { - command.then(then); - } - - return command; - } - - protected List onAutoComplete(@NotNull String argument, @NotNull CommandContext context) { - return new ArrayList<>(); - } - - @Override - protected final void internalExecutePlayer(@NotNull Object player, @NotNull List arguments) { - executePlayer((ServerPlayer) player, arguments); - } - - @Override - protected final void internalExecuteConsole(@NotNull Object console, @NotNull List arguments) { - executeConsole((MinecraftServer) console, arguments); - } - - @Override - protected final void internalExecuteCommon(@NotNull Object sender, @NotNull List arguments) { - executeCommon((CommandSource) sender, arguments); - } - - protected void executePlayer(@NotNull ServerPlayer player, @NotNull List arguments) { - - } - - protected void executeConsole(@NotNull MinecraftServer console, @NotNull List arguments) { - - } - - protected void executeCommon(@NotNull CommandSource sender, @NotNull List arguments) { - - } + public static final String commandSourceFiled = "field_9819"; + private final FabricCommandManager commandManager; + + public FabricCommand(CommonCommandManager commandManager) { + super(commandManager); + this.commandManager = (FabricCommandManager) commandManager; + } + + public @NotNull Set getSubCommands() { + return getPrimitiveSubCommands() + .stream().map(command -> (FabricCommand) command) + .collect(Collectors.toSet()); + } + + @SuppressWarnings("SameReturnValue") + private int internalExecute(@NotNull CommandContext context) { + try { + CommandSourceStack source = context.getSource(); + + List arguments = this.getArguments().stream() + .map(argument -> { + if (argument.startsWith("?")) { + argument = argument.substring(1); + } + + try { + return context.getArgument(argument, String.class); + } catch (IllegalArgumentException e) { + return null; + } + }) + .toList(); + + if (source.isPlayer()) { + execute(source.getPlayer(), arguments); + } else { + execute(source.getServer(), arguments); + } + + } catch (Throwable error) { + Logger.error(error); + } + + return 0; + } + + public LiteralArgumentBuilder getCommandBuilder(@NotNull String alias) { + LiteralArgumentBuilder command = literal(alias); + + for (FabricCommand subCommand : getSubCommands()) { + Logger.log("Registering subcommand(s): " + subCommand.getAliases() + " for " + alias); + for (String subAlias : subCommand.getAliases()) { + command = command.then(subCommand.getCommandBuilder(subAlias)); + } + } + + List> arguments = new ArrayList<>(); + + for (String argument : getArguments()) { + ArgumentType argumentType = StringArgumentType.string(); + + if (argument.startsWith("?")) { + argument = argument.substring(1); + } + if (argument.endsWith("...")) { + argumentType = StringArgumentType.greedyString(); + } + + String finalArgument = argument; + arguments.add(Commands + .argument(argument, argumentType) + .suggests((context, builder) -> { + String argumentValue = ""; + try { + argumentValue = context.getArgument(finalArgument, String.class); + } catch (IllegalArgumentException ignored) { + } + + List suggestions = ListUtils.getListThatStartsWith(onAutoComplete(finalArgument, context), argumentValue); + + for (String suggestion : suggestions) { + builder.suggest(suggestion); + } + + return builder.buildFuture(); + } + )); + } + + ArgumentBuilder then = null; + + if (!arguments.isEmpty()) { + arguments.getLast().executes(this::internalExecute); + + if (arguments.size() != 1) { + for (int index = arguments.size() - 2; index >= 0; index--) { + arguments.get(index).then(arguments.get(index + 1)); + + if (getArguments().get(index + 1).startsWith("?")) { + arguments.get(index).executes(this::internalExecute); + } + } + } + + then = arguments.getFirst(); + + if (getArguments().get(0).startsWith("?")) { + command.executes(this::internalExecute); + } + } else { + command.executes(this::internalExecute); + } + + if (then != null) { + command.then(then); + } + + return command; + } + + protected List onAutoComplete(@NotNull String argument, @NotNull CommandContext context) { + return new ArrayList<>(); + } + + @Override + protected final void internalExecutePlayer(@NotNull Object player, @NotNull List arguments) { + executePlayer((ServerPlayer) player, arguments); + } + + @Override + protected final void internalExecuteConsole(@NotNull Object console, @NotNull List arguments) { + executeConsole((MinecraftServer) console, arguments); + } + + @Override + protected final void internalExecuteCommon(@NotNull Object sender, @NotNull List arguments) { + executeCommon((CommandSource) sender, arguments); + } - protected List recommendPlayersList() { - return commandManager.getServer().getPlayerList().getPlayers().stream() - .map(ServerPlayer::getDisplayName) - .map(Component::getString) - .toList(); - } + protected void executePlayer(@NotNull ServerPlayer player, @NotNull List arguments) { + + } + + protected void executeConsole(@NotNull MinecraftServer console, @NotNull List arguments) { + + } + + protected void executeCommon(@NotNull CommandSource sender, @NotNull List arguments) { + + } + + protected List recommendPlayersList() { + return commandManager.getServer().getPlayerList().getPlayers().stream() + .map(ServerPlayer::getDisplayName) + .map(Component::getString) + .toList(); + } } diff --git a/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricCommandManager.java b/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricCommandManager.java index be0c149..d55bd2e 100644 --- a/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricCommandManager.java +++ b/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricCommandManager.java @@ -18,48 +18,48 @@ @Getter public class FabricCommandManager extends CommonCommandManager { - private final MinecraftServer server; - private final FabricMiniMessageManager miniMessageManager; + private final MinecraftServer server; + private final FabricMiniMessageManager miniMessageManager; - public FabricCommandManager(@NotNull Reflections.Crawler reflectionsCrawler, @NotNull CommandManagerConfig config, - @NotNull MinecraftServer server, @NotNull Holder injector) { - super(reflectionsCrawler, ServerPlayer.class, MinecraftServer.class, CommandSource.class, config, injector); + public FabricCommandManager(@NotNull Reflections.Crawler reflectionsCrawler, @NotNull CommandManagerConfig config, + @NotNull MinecraftServer server, @NotNull Holder injector) { + super(reflectionsCrawler, ServerPlayer.class, MinecraftServer.class, CommandSource.class, config, injector); - this.server = server; - this.miniMessageManager = new FabricMiniMessageManager(server); - } + this.server = server; + this.miniMessageManager = new FabricMiniMessageManager(server); + } - @Override - protected void platformRegister(@NotNull CommonCommand primitiveCommand) { - FabricCommand command = (FabricCommand) primitiveCommand; + @Override + protected void platformRegister(@NotNull CommonCommand primitiveCommand) { + FabricCommand command = (FabricCommand) primitiveCommand; - for (String alias : command.getAliases()) { - server.getCommands().getDispatcher().register(command.getCommandBuilder(alias)); - } + for (String alias : command.getAliases()) { + server.getCommands().getDispatcher().register(command.getCommandBuilder(alias)); + } - server.getPlayerList().getPlayers().forEach(player -> - server.getCommands().sendCommands(player) - ); - } + server.getPlayerList().getPlayers().forEach(player -> + server.getCommands().sendCommands(player) + ); + } - @Override - public void sendMessage(Object target, String message) { - if (target instanceof ServerPlayer player) { - player.sendSystemMessage(miniMessageManager.parse(message)); - return; - } + @Override + public void sendMessage(Object target, String message) { + if (target instanceof ServerPlayer player) { + player.sendSystemMessage(miniMessageManager.parse(message)); + return; + } - if (target instanceof MinecraftServer console) { - console.sendSystemMessage(Component.literal(message)); - return; - } + if (target instanceof MinecraftServer console) { + console.sendSystemMessage(Component.literal(message)); + return; + } - if (target instanceof CommandSource output) { - output.sendSystemMessage(Component.literal(message)); - return; - } + if (target instanceof CommandSource output) { + output.sendSystemMessage(Component.literal(message)); + return; + } - Logger.error("Unknown target type: " + target.getClass().getName()); - } + Logger.error("Unknown target type: " + target.getClass().getName()); + } } diff --git a/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricMiniMessageManager.java b/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricMiniMessageManager.java index ed1083b..3f387aa 100644 --- a/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricMiniMessageManager.java +++ b/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricMiniMessageManager.java @@ -11,25 +11,25 @@ public class FabricMiniMessageManager extends CommonMiniMessageManager { - private final FabricAudiences audiences; - - public FabricMiniMessageManager(MinecraftServer server) { - this.audiences = FabricServerAudiences.of(server); - } - - @SuppressWarnings("unused") - public FabricMiniMessageManager(FabricAudiences audiences) { - this.audiences = audiences; - } - - @Override - public @NotNull Component toNative(@NotNull net.kyori.adventure.text.Component component) { - return audiences.toNative(component); - } - - @Override - public @NotNull String sanitize(net.kyori.adventure.text.Component component) { - TextComponent textComponent = (TextComponent) component; - return textComponent.content(); - } + private final FabricAudiences audiences; + + public FabricMiniMessageManager(MinecraftServer server) { + this.audiences = FabricServerAudiences.of(server); + } + + @SuppressWarnings("unused") + public FabricMiniMessageManager(FabricAudiences audiences) { + this.audiences = audiences; + } + + @Override + public @NotNull Component toNative(@NotNull net.kyori.adventure.text.Component component) { + return audiences.toNative(component); + } + + @Override + public @NotNull String sanitize(net.kyori.adventure.text.Component component) { + TextComponent textComponent = (TextComponent) component; + return textComponent.content(); + } } diff --git a/src/fabric-21/src/main/resources/fabric.mod.json b/src/fabric-21/src/main/resources/fabric.mod.json index 94cd04f..643abbc 100644 --- a/src/fabric-21/src/main/resources/fabric.mod.json +++ b/src/fabric-21/src/main/resources/fabric.mod.json @@ -1,18 +1,18 @@ { - "schemaVersion": 1, - "id": "command_manager_fabric", - "version": "UNKNOWN", - "name": "Command Manager Fabric", - "description": "", - "authors": [], - "contact": {}, - "license": "All-Rights-Reserved", - "icon": "assets/command_manager/icon.png", - "environment": "server", - "entrypoints": { - "client": [], - "main": [] - }, - "mixins": [], - "depends": {} + "schemaVersion": 1, + "id": "command_manager_fabric", + "version": "UNKNOWN", + "name": "Command Manager Fabric", + "description": "", + "authors": [], + "contact": {}, + "license": "All-Rights-Reserved", + "icon": "assets/command_manager/icon.png", + "environment": "server", + "entrypoints": { + "client": [], + "main": [] + }, + "mixins": [], + "depends": {} } diff --git a/src/velocity/build.gradle.kts b/src/velocity/build.gradle.kts index c9c198d..9546b1a 100644 --- a/src/velocity/build.gradle.kts +++ b/src/velocity/build.gradle.kts @@ -1,5 +1,9 @@ @file:Suppress("VulnerableLibrariesLocal") +plugins{ + alias(libs.plugins.jetbrin.gradle.plugin.idea.ext) +} + dependencies { // Velocity compileOnly(libs.velocity) @@ -27,3 +31,32 @@ dependencies { testAnnotationProcessor(libs.jetbrains.annotations) } +tasks { + sourceSets.main { + java { + srcDir("$buildDir/generated/sources/templates") + } + } + + compileJava { + dependsOn(generateTemplates) + } + +} + +val generateTemplates = tasks.register("generateTemplates") { + duplicatesStrategy = DuplicatesStrategy.INCLUDE + + println("$projectDir") + + from("$projectDir/src/main/templates") + into("$buildDir/generated/sources/templates") + + filter { line -> + line.replace("\${id}", project.name.lowercase().replace(".", "_")) + .replace("\${version}", project.version as String) + .replace("{id}", project.name.lowercase().replace(".", "_")) + .replace("{version}", project.version as String) + } +} + diff --git a/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/command/VelocityCommand.java b/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/command/VelocityCommand.java index d9d575a..e6173e2 100644 --- a/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/command/VelocityCommand.java +++ b/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/command/VelocityCommand.java @@ -20,131 +20,131 @@ // TODO(low) Send help command instead of the the "This command does not implement the logic for <> execution" public abstract class VelocityCommand extends CommonCommand implements SimpleCommand { - private final VelocityCommandManager commandManager; - - public VelocityCommand(CommonCommandManager commandManager) { - super(commandManager); - this.commandManager = (VelocityCommandManager) commandManager; - } - - @Override - public final List suggest(Invocation invocation) { - int argsLength = invocation.arguments().length; - List arguments = Arrays.asList(invocation.arguments()); - - if (argsLength == 0) { - return onAutoComplete(arguments); - } - - String lastArg = invocation.arguments()[argsLength - 1]; - VelocityCommand subCommand = getSubCommand(lastArg); - - if (subCommand == null) { - if (argsLength == 1) { - return ListUtils.getListThatStartsWith(onAutoComplete(arguments), lastArg); - } - - String lastArg2 = invocation.arguments()[argsLength - 2]; - subCommand = getSubCommand(lastArg2); - - if (subCommand == null) { - return ListUtils.getListThatStartsWith(onAutoComplete(arguments), lastArg2); - } - - return ListUtils.getListThatStartsWith(subCommand.onAutoComplete(arguments), lastArg); - } - - return ListUtils.getListThatStartsWith(onAutoComplete(arguments), lastArg); - } - - private @Nullable VelocityCommand getSubCommand(String name) { - for (VelocityCommand subCommand : getSubCommands()) { - for (String commandName : subCommand.getAliases()) { - if (name.equalsIgnoreCase(commandName)) { - return subCommand; - } - } - } - - return null; - } - - @SuppressWarnings("unused") - public @NotNull List onAutoComplete(List arguments) { - return defaultAutoComplete(); - } - - public @NotNull List defaultAutoComplete() { - List allArguments = new ArrayList<>(); - - for (VelocityCommand subCommand : getSubCommands()) { - allArguments.addAll(subCommand.getAliases()); - } - - return allArguments; - } - - @Override - public final void execute(Invocation invocation) { - execute(invocation.source(), Arrays.asList(invocation.arguments())); - } - - public @NotNull Set getSubCommands() { - return getPrimitiveSubCommands() - .stream().map(command -> (VelocityCommand) command) - .collect(Collectors.toSet()); - } - - @Override - protected final void internalExecutePlayer(@NotNull Object player, @NotNull List arguments) { - executePlayer((Player) player, arguments); - } - - @Override - protected final void internalExecuteConsole(@NotNull Object console, @NotNull List arguments) { - executeConsole((ConsoleCommandSource) console, arguments); - } - - @Override - protected final void internalExecuteCommon(@NotNull Object sender, @NotNull List arguments) { - executeCommon((CommandSource) sender, arguments); - } - - protected void executePlayer(Player player, List arguments) { - player.sendMessage(Component.text("This command does not implement the logic for player-only execution.")); - } - - @SuppressWarnings({"unused"}) - protected void executeConsole(ConsoleCommandSource console, List arguments) { - console.sendMessage(Component.text("This command does not implement the logic for console-only execution.")); - } - - protected void executeCommon(CommandSource sender, List arguments) { - if (sender instanceof Player) { - executePlayer((Player) sender, arguments); - return; - } - - if (sender instanceof ConsoleCommandSource) { - executeConsole((ConsoleCommandSource) sender, arguments); - return; - } - - Logger.error("Unknown command sender type: " + sender.getClass().getName() + " for command: " + getAliases().get(0)); - } - - protected List recommendPlayersList() { - return commandManager.getProxy().getAllPlayers().stream() - .map(Player::getUsername) - .toList(); - } - - protected @Nullable Player getPlayer(String usernameOrUUID) { - try { - UUID uuid = UUID.fromString(usernameOrUUID); - return commandManager.getProxy().getPlayer(uuid).orElse(null); - } catch (Exception e) { - return commandManager.getProxy().getPlayer(usernameOrUUID).orElse(null); - } - } + private final VelocityCommandManager commandManager; + + public VelocityCommand(CommonCommandManager commandManager) { + super(commandManager); + this.commandManager = (VelocityCommandManager) commandManager; + } + + @Override + public final List suggest(Invocation invocation) { + int argsLength = invocation.arguments().length; + List arguments = Arrays.asList(invocation.arguments()); + + if (argsLength == 0) { + return onAutoComplete(arguments); + } + + String lastArg = invocation.arguments()[argsLength - 1]; + VelocityCommand subCommand = getSubCommand(lastArg); + + if (subCommand == null) { + if (argsLength == 1) { + return ListUtils.getListThatStartsWith(onAutoComplete(arguments), lastArg); + } + + String lastArg2 = invocation.arguments()[argsLength - 2]; + subCommand = getSubCommand(lastArg2); + + if (subCommand == null) { + return ListUtils.getListThatStartsWith(onAutoComplete(arguments), lastArg2); + } + + return ListUtils.getListThatStartsWith(subCommand.onAutoComplete(arguments), lastArg); + } + + return ListUtils.getListThatStartsWith(onAutoComplete(arguments), lastArg); + } + + private @Nullable VelocityCommand getSubCommand(String name) { + for (VelocityCommand subCommand : getSubCommands()) { + for (String commandName : subCommand.getAliases()) { + if (name.equalsIgnoreCase(commandName)) { + return subCommand; + } + } + } + + return null; + } + + @SuppressWarnings("unused") + public @NotNull List onAutoComplete(List arguments) { + return defaultAutoComplete(); + } + + public @NotNull List defaultAutoComplete() { + List allArguments = new ArrayList<>(); + + for (VelocityCommand subCommand : getSubCommands()) { + allArguments.addAll(subCommand.getAliases()); + } + + return allArguments; + } + + @Override + public final void execute(Invocation invocation) { + execute(invocation.source(), Arrays.asList(invocation.arguments())); + } + + public @NotNull Set getSubCommands() { + return getPrimitiveSubCommands() + .stream().map(command -> (VelocityCommand) command) + .collect(Collectors.toSet()); + } + + @Override + protected final void internalExecutePlayer(@NotNull Object player, @NotNull List arguments) { + executePlayer((Player) player, arguments); + } + + @Override + protected final void internalExecuteConsole(@NotNull Object console, @NotNull List arguments) { + executeConsole((ConsoleCommandSource) console, arguments); + } + + @Override + protected final void internalExecuteCommon(@NotNull Object sender, @NotNull List arguments) { + executeCommon((CommandSource) sender, arguments); + } + + protected void executePlayer(Player player, List arguments) { + player.sendMessage(Component.text("This command does not implement the logic for player-only execution.")); + } + + @SuppressWarnings({"unused"}) + protected void executeConsole(ConsoleCommandSource console, List arguments) { + console.sendMessage(Component.text("This command does not implement the logic for console-only execution.")); + } + + protected void executeCommon(CommandSource sender, List arguments) { + if (sender instanceof Player) { + executePlayer((Player) sender, arguments); + return; + } + + if (sender instanceof ConsoleCommandSource) { + executeConsole((ConsoleCommandSource) sender, arguments); + return; + } + + Logger.error("Unknown command sender type: " + sender.getClass().getName() + " for command: " + getAliases().get(0)); + } + + protected List recommendPlayersList() { + return commandManager.getProxy().getAllPlayers().stream() + .map(Player::getUsername) + .toList(); + } + + protected @Nullable Player getPlayer(String usernameOrUUID) { + try { + UUID uuid = UUID.fromString(usernameOrUUID); + return commandManager.getProxy().getPlayer(uuid).orElse(null); + } catch (Exception e) { + return commandManager.getProxy().getPlayer(usernameOrUUID).orElse(null); + } + } } \ No newline at end of file diff --git a/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityCommandManager.java b/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityCommandManager.java index aba64f9..31ed4de 100644 --- a/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityCommandManager.java +++ b/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityCommandManager.java @@ -18,39 +18,39 @@ @Getter public class VelocityCommandManager extends CommonCommandManager { - private final ProxyServer proxy; - private final VelocityMiniMessageManager miniMessageManager; - private final Object plugin; + private final ProxyServer proxy; + private final VelocityMiniMessageManager miniMessageManager; + private final Object plugin; - public VelocityCommandManager(@NotNull Object plugin, @NotNull ProxyServer proxy, - @NotNull Reflections.Crawler reflectionsCrawler, @NotNull CommandManagerConfig config, - @NotNull Holder injectorHolder) { - super(reflectionsCrawler, Player.class, ConsoleCommandSource.class, CommandSource.class, config, injectorHolder); + public VelocityCommandManager(@NotNull Object plugin, @NotNull ProxyServer proxy, + @NotNull Reflections.Crawler reflectionsCrawler, @NotNull CommandManagerConfig config, + @NotNull Holder injectorHolder) { + super(reflectionsCrawler, Player.class, ConsoleCommandSource.class, CommandSource.class, config, injectorHolder); - this.plugin = plugin; - this.proxy = proxy; - this.miniMessageManager = new VelocityMiniMessageManager(); - } + this.plugin = plugin; + this.proxy = proxy; + this.miniMessageManager = new VelocityMiniMessageManager(); + } - @Override - protected void platformRegister(@NotNull CommonCommand primitiveCommand) { - VelocityCommand command = (VelocityCommand) primitiveCommand; + @Override + protected void platformRegister(@NotNull CommonCommand primitiveCommand) { + VelocityCommand command = (VelocityCommand) primitiveCommand; - com.velocitypowered.api.command.CommandManager commandManager = proxy.getCommandManager(); + com.velocitypowered.api.command.CommandManager commandManager = proxy.getCommandManager(); - CommandMeta commandMeta = commandManager.metaBuilder(command.getMainAlias()) - .aliases(command.getAliases().subList(1, command.getAliases().size()).toArray(new String[0])) - .plugin(this.plugin) - .build(); + CommandMeta commandMeta = commandManager.metaBuilder(command.getMainAlias()) + .aliases(command.getAliases().subList(1, command.getAliases().size()).toArray(new String[0])) + .plugin(this.plugin) + .build(); - commandManager.register(commandMeta, command); - } + commandManager.register(commandMeta, command); + } - @Override - public final void sendMessage(Object user, String message) { - CommandSource source = (CommandSource) user; - source.sendMessage(miniMessageManager.parse(message)); - } + @Override + public final void sendMessage(Object user, String message) { + CommandSource source = (CommandSource) user; + source.sendMessage(miniMessageManager.parse(message)); + } } diff --git a/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityMiniMessageManager.java b/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityMiniMessageManager.java index 245b8b6..eb79f79 100644 --- a/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityMiniMessageManager.java +++ b/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityMiniMessageManager.java @@ -7,14 +7,14 @@ public class VelocityMiniMessageManager extends CommonMiniMessageManager { - @Override - public @NotNull Component toNative(@NotNull Component component) { - return component; - } + @Override + public @NotNull Component toNative(@NotNull Component component) { + return component; + } - @Override - public @NotNull String sanitize(Component component) { - TextComponent textComponent = (TextComponent) component; - return textComponent.content(); - } + @Override + public @NotNull String sanitize(Component component) { + TextComponent textComponent = (TextComponent) component; + return textComponent.content(); + } }