diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index eb19aa3d..373d0a72 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -55,8 +55,8 @@ jobs: with: commit_message: Incremented patch version commit_options: '--no-verify --signoff' - commit_user_name: Voinea Radu - commit_user_email: contact@voinearadu.com + commit_user_name: Radu Voinea + commit_user_email: contact@raduvoinea.com # ==================== BUILD ==================== @@ -64,11 +64,11 @@ jobs: run: | mkdir -p ~/.gradle echo " - com.voinearadu.url=https://repository.voinearadu.com/repository/maven-releases/ - com.voinearadu.auth.username=admin - com.voinearadu.auth.password=${{ secrets.NEXUS_PASSWORD }} + com.raduvoinea.url=https://repo.raduvoinea.com/repository/maven-releases/ + com.raduvoinea.auth.username=admin + com.raduvoinea.auth.password=${{ secrets.NEXUS_PASSWORD }} " > ~/.gradle/gradle.properties - if [ "${{ secrets.NEXUS_PASSWORD }}" == "" ]; then echo "com.voinearadu.publish=false" >> ~/.gradle/gradle.properties; fi + if [ "${{ secrets.NEXUS_PASSWORD }}" == "" ]; then echo "com.raduvoinea.publish=false" >> ~/.gradle/gradle.properties; fi - name: Cache Gradle Dependencies uses: actions/cache@v4 diff --git a/README.md b/README.md index 9005e838..8a5d6c3d 100644 --- a/README.md +++ b/README.md @@ -11,13 +11,13 @@ ```kotlin repositories { - maven("https://repository.voinearadu.com/repository/maven-releases/") - maven("https://repo.voinearadu.com/") // The short version of the above (might be slower on high latency connections) + maven("https://repo.raduvoinea.com/repository/maven-releases/") + maven("https://repo.raduvoinea.com/") // The short version of the above (might be slower on high latency connections) } dependencies { - implementation("com.voinearadu:command-manager-common:VERSION") - implementation("com.voinearadu:command-manager-velocity:VERSION") - implementation("com.voinearadu:command-manager-fabric-1-19:VERSION") + implementation("com.raduvoinea:command-manager-common:VERSION") + implementation("com.raduvoinea:command-manager-velocity:VERSION") + implementation("com.raduvoinea:command-manager-fabric-1-19:VERSION") } ``` \ No newline at end of file diff --git a/build.gradle.kts b/build.gradle.kts index 98549c1b..959d3aa8 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -12,10 +12,10 @@ group = _group fun DependencyHandlerScope.applyDependencies() { // Dependencies - if(project.properties["com.voinearadu.utils.local"] != null){ - api(project(project.properties["com.voinearadu.utils.local"] as String)) - }else{ - api(libs.voinearadu.utils) + if (project.properties["com.raduvoinea.utils.local"] != null) { + api(project(project.properties["com.raduvoinea.utils.local"] as String)) + } else { + api(libs.raduvoinea.utils) } // Annotations @@ -34,7 +34,7 @@ fun RepositoryHandler.applyRepositories() { mavenCentral() maven("https://maven.parchmentmc.org/") maven("https://repo.papermc.io/repository/maven-public/") - maven("https://repository.voinearadu.com/repository/maven-releases/") + maven("https://repo.raduvoinea.com/repository/maven-releases/") } repositories { @@ -76,12 +76,12 @@ subprojects { } repositories { - if (project.properties["com.voinearadu.publish"] == "true") { - maven(url = (project.findProperty("com.voinearadu.url") ?: "") as String) { - name = "VoineaRaduRepository" + if (project.properties["com.raduvoinea.publish"] == "true") { + maven(url = (project.findProperty("com.raduvoinea.url") ?: "") as String) { + name = "raduvoineaRepository" credentials(PasswordCredentials::class) { - username = (project.findProperty("com.voinearadu.auth.username") ?: "") as String - password = (project.findProperty("com.voinearadu.auth.password") ?: "") as String + username = (project.findProperty("com.raduvoinea.auth.username") ?: "") as String + password = (project.findProperty("com.raduvoinea.auth.password") ?: "") as String } } } diff --git a/gradle.properties b/gradle.properties index 25c1d3c7..cdf203cc 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1 +1 @@ -com.voinearadu.publish=true \ No newline at end of file +com.raduvoinea.publish=true \ No newline at end of file diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 6779dbf9..bedd1e64 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -1,7 +1,7 @@ [versions] version = "1.1.7" -group = "com.voinearadu" +group = "com.raduvoinea" [plugins] @@ -33,4 +33,4 @@ 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" } -voinearadu_utils = { module = "com.voinearadu:utils", version = "1.1.28" } +raduvoinea_utils = { module = "com.raduvoinea:utils", version = "1.1.28" } diff --git a/renovate.json b/renovate.json index 39a2b6e9..7bd95455 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/build.gradle.kts b/src/common/build.gradle.kts index a928ef27..4d318632 100644 --- a/src/common/build.gradle.kts +++ b/src/common/build.gradle.kts @@ -1,9 +1,9 @@ dependencies { // Dependencies - if (project.properties["com.voinearadu.utils.local"] != null) { - api(project(project.properties["com.voinearadu.utils.local"] as String)) + if (project.properties["com.raduvoinea.utils.local"] != null) { + api(project(project.properties["com.raduvoinea.utils.local"] as String)) } else { - api(libs.voinearadu.utils) + api(libs.raduvoinea.utils) } api(libs.luckperms) api(libs.kyori.minimessage) diff --git a/src/common/src/main/java/com/voinearadu/commandmanager/common/annotation/Command.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/annotation/Command.java similarity index 74% rename from src/common/src/main/java/com/voinearadu/commandmanager/common/annotation/Command.java rename to src/common/src/main/java/com/raduvoinea/commandmanager/common/annotation/Command.java index 42cd6427..6b25a669 100644 --- a/src/common/src/main/java/com/voinearadu/commandmanager/common/annotation/Command.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/annotation/Command.java @@ -1,6 +1,6 @@ -package com.voinearadu.commandmanager.common.annotation; +package com.raduvoinea.commandmanager.common.annotation; -import com.voinearadu.commandmanager.common.command.CommonCommand; +import com.raduvoinea.commandmanager.common.command.CommonCommand; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; @@ -13,6 +13,8 @@ String[] aliases(); + String[] arguments() default {}; + OnlyFor onlyFor() default OnlyFor.BOTH; Class parent() default CommonCommand.class; diff --git a/src/common/src/main/java/com/voinearadu/commandmanager/common/command/CommonCommand.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/command/CommonCommand.java similarity index 55% rename from src/common/src/main/java/com/voinearadu/commandmanager/common/command/CommonCommand.java rename to src/common/src/main/java/com/raduvoinea/commandmanager/common/command/CommonCommand.java index d1ed19e5..997bccd1 100644 --- a/src/common/src/main/java/com/voinearadu/commandmanager/common/command/CommonCommand.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/command/CommonCommand.java @@ -1,16 +1,16 @@ -package com.voinearadu.commandmanager.common.command; +package com.raduvoinea.commandmanager.common.command; -import com.voinearadu.commandmanager.common.annotation.Command; -import com.voinearadu.commandmanager.common.exception.CommandNotAnnotated; -import com.voinearadu.commandmanager.common.manager.CommonCommandManager; -import com.voinearadu.utils.logger.Logger; +import com.raduvoinea.commandmanager.common.annotation.Command; +import com.raduvoinea.commandmanager.common.exception.CommandNotAnnotated; +import com.raduvoinea.commandmanager.common.manager.CommonCommandManager; +import com.raduvoinea.utils.logger.Logger; +import com.raduvoinea.utils.message_builder.GenericMessageBuilder; import lombok.Getter; import org.jetbrains.annotations.NotNull; -import java.util.HashSet; +import java.util.ArrayList; import java.util.List; import java.util.Objects; -import java.util.Set; import java.util.stream.Collectors; @SuppressWarnings("unused") @@ -19,8 +19,7 @@ public abstract class CommonCommand { // Provided private final CommonCommandManager commandManager; private final @Getter Command annotation; - private final Set subCommands = new HashSet<>(); - private boolean enabled = true; + private final List subCommands; public CommonCommand(CommonCommandManager commandManager) throws CommandNotAnnotated { this.commandManager = commandManager; @@ -30,14 +29,17 @@ public CommonCommand(CommonCommandManager commandManager) throws CommandNotAnnot this.annotation = this.getClass().getAnnotation(Command.class); - subCommands.addAll(commandManager.getReflectionsCrawler().getOfType(CommonCommand.class) + subCommands = commandManager.getReflectionsCrawler().getOfType(CommonCommand.class) .stream() .filter(commandClass -> commandClass.isAnnotationPresent(Command.class)) .filter(commandClass -> commandClass.getAnnotation(Command.class).parent().equals(this.getClass())) - .collect(Collectors.toSet()) - .stream().map(commandClass -> { + .map(commandClass -> { try { - return commandClass.getConstructor(CommonCommandManager.class).newInstance(commandManager); + 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); @@ -45,52 +47,65 @@ public CommonCommand(CommonCommandManager commandManager) throws CommandNotAnnot } }) .filter(Objects::nonNull) - .collect(Collectors.toSet())); + .collect(Collectors.toList()); } - public void enable() { - if (annotation.parent() == CommonCommand.class) { - Logger.log("Enabling command(s): " + this.getAliases()); - } else { - CommonCommand parentCommand = commandManager.getCommand(annotation.parent()); + private String getFullCommand() { + String parentFullCommand = ""; - if (parentCommand == null) { - throw new RuntimeException("Parent command " + annotation.parent().getName() + " of subcommand " + this.getAliases() + " is not registered."); + if (!isRootCommand()) { + CommonCommand parent = commandManager.getCommand(getParent()); + + if (parent == null) { + Logger.error("Command " + getParent().getName() + " is not registered."); + return "Registration Error"; } - Logger.log("Enabling subcommand(s) of " + parentCommand.getAliases() + ": " + this.getAliases()); + parentFullCommand = parent.getFullCommand() + " "; } - this.enabled = true; - for (CommonCommand subCommand : this.getPrimitiveSubCommands()) { - subCommand.enable(); - } + return parentFullCommand + this.getMainAlias(); } - public void disable() { - if (annotation.parent() == CommonCommand.class) { - Logger.log("Disabling command(s): " + this.getAliases()); - } else { - CommonCommand parentCommand = commandManager.getCommand(annotation.parent()); + private String getSimpleUsage() { + return commandManager.getConfig().simpleUsage + .parse("command", this.getFullCommand()) + .parse("arguments", String.join(" ", + getArguments().stream() + .map(arg -> "<" + arg + ">") + .toList() + )) + .parse(); + } - if (parentCommand == null) { - throw new RuntimeException("Parent command " + annotation.parent().getName() + " of subcommand " + this.getAliases() + " is not registered."); - } + private List getFullCommandAndSubCommands() { + List lines = new ArrayList<>(); + lines.add(this.getSimpleUsage()); - Logger.log("Enabling subcommand(s) of " + parentCommand.getAliases() + ": " + this.getAliases()); + for (CommonCommand subCommand : subCommands) { + lines.addAll(subCommand.getFullCommandAndSubCommands()); } - this.enabled = false; - for (CommonCommand subCommand : this.getPrimitiveSubCommands()) { - subCommand.disable(); - } + lines.sort(String::compareTo); + + return lines; } - public void execute(@NotNull Object executor, @NotNull List arguments) { - if (!enabled) { - return; + 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; @@ -109,6 +124,11 @@ public void execute(@NotNull Object executor, @NotNull List arguments) { } } + 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); @@ -143,30 +163,33 @@ public void execute(@NotNull Object executor, @NotNull List arguments) { protected abstract void internalExecuteCommon(@NotNull Object sender, @NotNull List arguments); public @NotNull String getPermission() { - Class parentClass = annotation.parent(); - - if (parentClass.equals(CommonCommand.class)) { - return commandManager.getBasePermission() + "." + annotation.aliases()[0]; + if (isRootCommand()) { + return commandManager.getConfig().basePermission + "." + annotation.aliases()[0]; } - CommonCommand command = commandManager.getCommand(parentClass); + CommonCommand command = commandManager.getCommand(getParent()); if (command == null) { - throw new RuntimeException("Command " + parentClass.getName() + " is not registered."); + throw new RuntimeException("Command " + getParent().getName() + " is not registered."); } return command.getPermission() + "." + annotation.aliases()[0]; } - public final @NotNull Set getPrimitiveSubCommands() { - Set subCommands = new HashSet<>(); + public final @NotNull List getPrimitiveSubCommands() { + return this.subCommands; + } - for (CommonCommand subCommand : this.subCommands) { - subCommands.add(subCommand); - subCommands.addAll(subCommand.getPrimitiveSubCommands()); - } + public List getArguments() { + return List.of(annotation.arguments()); + } + + public Class getParent() { + return annotation.parent(); + } - return subCommands; + public boolean isRootCommand() { + return getParent().equals(CommonCommand.class); } public final String getMainAlias() { @@ -177,18 +200,16 @@ public final List getAliases() { return List.of(annotation.aliases()); } - protected final void sendMessage(Object target, String message) { - commandManager.sendMessage(target, message); + protected final void sendMessage(Object target, GenericMessageBuilder message) { + sendMessage(target, message.toString()); } - protected final void broadcastMessage(String message) { - commandManager.broadcastMessage(message); + 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 new file mode 100644 index 00000000..759d72f3 --- /dev/null +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/config/CommandManagerConfig.java @@ -0,0 +1,32 @@ +package com.raduvoinea.commandmanager.common.config; + +import com.raduvoinea.utils.message_builder.MessageBuilder; + +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} + """ + ); + + /* + Usage: /discord + + Sub commands: + /discord link {code} + /discord sync + /discord unlink + /discord admin unlink {user} + /discord admin {user} + + + + */ + + +} diff --git a/src/common/src/main/java/com/voinearadu/commandmanager/common/exception/CommandNotAnnotated.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/exception/CommandNotAnnotated.java similarity index 71% rename from src/common/src/main/java/com/voinearadu/commandmanager/common/exception/CommandNotAnnotated.java rename to src/common/src/main/java/com/raduvoinea/commandmanager/common/exception/CommandNotAnnotated.java index 5a945e9d..e23af751 100644 --- a/src/common/src/main/java/com/voinearadu/commandmanager/common/exception/CommandNotAnnotated.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/exception/CommandNotAnnotated.java @@ -1,4 +1,4 @@ -package com.voinearadu.commandmanager.common.exception; +package com.raduvoinea.commandmanager.common.exception; public class CommandNotAnnotated extends RuntimeException { 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 new file mode 100644 index 00000000..20c9a04d --- /dev/null +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/manager/CommonCommandManager.java @@ -0,0 +1,115 @@ +package com.raduvoinea.commandmanager.common.manager; + +import com.raduvoinea.commandmanager.common.annotation.Command; +import com.raduvoinea.commandmanager.common.command.CommonCommand; +import com.raduvoinea.commandmanager.common.config.CommandManagerConfig; +import com.raduvoinea.commandmanager.common.exception.CommandNotAnnotated; +import com.raduvoinea.commandmanager.common.utils.LuckPermsUtils; +import com.raduvoinea.utils.dependency_injection.Injector; +import com.raduvoinea.utils.generic.dto.Holder; +import com.raduvoinea.utils.logger.Logger; +import com.raduvoinea.utils.reflections.Reflections; +import lombok.Getter; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Modifier; +import java.util.ArrayList; +import java.util.List; + +@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); + +} diff --git a/src/common/src/main/java/com/voinearadu/commandmanager/common/manager/CommonMiniMessageManager.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/manager/CommonMiniMessageManager.java similarity index 82% rename from src/common/src/main/java/com/voinearadu/commandmanager/common/manager/CommonMiniMessageManager.java rename to src/common/src/main/java/com/raduvoinea/commandmanager/common/manager/CommonMiniMessageManager.java index 85c83d80..b8b1ff07 100644 --- a/src/common/src/main/java/com/voinearadu/commandmanager/common/manager/CommonMiniMessageManager.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/manager/CommonMiniMessageManager.java @@ -1,11 +1,12 @@ -package com.voinearadu.commandmanager.common.manager; +package com.raduvoinea.commandmanager.common.manager; -import com.voinearadu.utils.message_builder.MessageBuilder; -import com.voinearadu.utils.message_builder.MessageBuilderList; +import com.raduvoinea.utils.message_builder.MessageBuilder; +import com.raduvoinea.utils.message_builder.MessageBuilderList; import net.kyori.adventure.text.Component; import net.kyori.adventure.text.TextComponent; import net.kyori.adventure.text.minimessage.MiniMessage; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import java.util.ArrayList; import java.util.List; @@ -28,7 +29,10 @@ public abstract class CommonMiniMessageManager { return parse(message.parse()); } - public @NotNull NativeComponent parse(@NotNull String message) { + public @NotNull NativeComponent parse(@Nullable String message) { + if (message == null) { + message = "null"; + } return toNative(toComponent(message)); } diff --git a/src/common/src/main/java/com/voinearadu/commandmanager/common/utils/ListUtils.java b/src/common/src/main/java/com/raduvoinea/commandmanager/common/utils/ListUtils.java similarity index 85% rename from src/common/src/main/java/com/voinearadu/commandmanager/common/utils/ListUtils.java rename to src/common/src/main/java/com/raduvoinea/commandmanager/common/utils/ListUtils.java index f35767e5..59141d4b 100644 --- a/src/common/src/main/java/com/voinearadu/commandmanager/common/utils/ListUtils.java +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/utils/ListUtils.java @@ -1,4 +1,4 @@ -package com.voinearadu.commandmanager.common.utils; +package com.raduvoinea.commandmanager.common.utils; import java.util.List; import java.util.stream.Collectors; 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 new file mode 100644 index 00000000..f692671f --- /dev/null +++ b/src/common/src/main/java/com/raduvoinea/commandmanager/common/utils/LuckPermsUtils.java @@ -0,0 +1,159 @@ +package com.raduvoinea.commandmanager.common.utils; + +import com.raduvoinea.utils.logger.Logger; +import lombok.SneakyThrows; +import net.luckperms.api.LuckPerms; +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.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; + +public class LuckPermsUtils { + + private static final String DEFAULT_GROUP_NAME = "default"; + + 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; + } + } + + 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(); + + if (user == null) { + return getDefaultGroup(); + } + + String groupName = user.getPrimaryGroup(); + Group group = luckPerms.getGroupManager().getGroup(groupName); + + if (group == null) { + return getDefaultGroup(); + } + + return group; + } + + public static @NotNull Group getDefaultGroup() { + LuckPerms luckPerms = LuckPermsProvider.get(); + + Group group = luckPerms.getGroupManager().getGroup(DEFAULT_GROUP_NAME); + + if (group == null) { + throw new IllegalStateException("'default' group not found"); + } + + return group; + } + + public static String getPrefix(@Nullable User user, @Nullable Group group) { + return getNodeType(user, group, NodeType.PREFIX); + } + + public static String getSuffix(@Nullable User user, @Nullable Group group) { + return getNodeType(user, group, NodeType.SUFFIX); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + public static String getNodeType(@Nullable User user, @Nullable Group group, + NodeType nodeType) { + List userPrefixNodes = new ArrayList<>(); + List groupPrefixNodes = new ArrayList<>(); + + if (user != null) { + userPrefixNodes = (List) new ArrayList<>(user.getNodes(nodeType).stream().toList()); + } + if (group != null) { + groupPrefixNodes = (List) new ArrayList<>(group.getNodes(nodeType).stream().toList()); + } + + List prefixNodes = new ArrayList<>(); + prefixNodes.addAll(userPrefixNodes); + prefixNodes.addAll(groupPrefixNodes); + + prefixNodes.sort(Comparator.comparingInt(ChatMetaNode::getPriority)); + T prefix = prefixNodes.stream().findFirst().orElse(null); + + String prefixString = prefix == null ? "" : prefix.getKey(); + if (prefixString.contains(".")) { + String[] split = prefixString.split("\\."); + prefixString = split[split.length - 1]; + } + + return prefixString; + } + + + public static String getPrefix(@NotNull UUID uuid) { + User user = getUser(uuid); + Group group = getGroup(user); + + return getPrefix(user, group); + } + + public static String getSuffix(@NotNull UUID uuid) { + User user = getUser(uuid); + Group group = getGroup(user); + + return getSuffix(user, group); + } + + @SneakyThrows(value = {InterruptedException.class, ExecutionException.class}) + public static @Nullable User getUser(@NotNull UUID userUUID) { + LuckPerms luckPerms = LuckPermsProvider.get(); + User user; + + user = luckPerms.getUserManager().getUser(userUUID); + + if (user == null) { + CompletableFuture completableLPUser = luckPerms.getUserManager().loadUser(userUUID); + user = completableLPUser.get(); + } + + 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); + } + +} diff --git a/src/common/src/main/java/com/voinearadu/commandmanager/common/manager/CommonCommandManager.java b/src/common/src/main/java/com/voinearadu/commandmanager/common/manager/CommonCommandManager.java deleted file mode 100644 index 96d09e2f..00000000 --- a/src/common/src/main/java/com/voinearadu/commandmanager/common/manager/CommonCommandManager.java +++ /dev/null @@ -1,140 +0,0 @@ -package com.voinearadu.commandmanager.common.manager; - -import com.voinearadu.commandmanager.common.annotation.Command; -import com.voinearadu.commandmanager.common.command.CommonCommand; -import com.voinearadu.commandmanager.common.exception.CommandNotAnnotated; -import com.voinearadu.commandmanager.common.utils.CommonPermissionUtils; -import com.voinearadu.utils.logger.Logger; -import com.voinearadu.utils.reflections.Reflections; -import lombok.Getter; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -import java.lang.reflect.InvocationTargetException; -import java.lang.reflect.Modifier; -import java.util.ArrayList; -import java.util.List; - -@SuppressWarnings("unused") -public abstract class CommonCommandManager { - - private final @Getter Reflections.Crawler reflectionsCrawler; - private final List commands = new ArrayList<>(); - private final @Getter Class playerClass; - private final @Getter Class consoleClass; - private final @Getter Class senderClass; - private final @Getter String basePermission; - - public CommonCommandManager(@NotNull Reflections.Crawler reflectionsCrawler, @NotNull Class playerClass, - @NotNull Class consoleClass, @NotNull Class senderClass, - @NotNull String basePermission) { - this.reflectionsCrawler = reflectionsCrawler; - this.playerClass = playerClass; - this.consoleClass = consoleClass; - this.senderClass = senderClass; - this.basePermission = basePermission; - } - - 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); - 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) { //NOPMD - suppressed AvoidInstanceofChecksInCatchClause - Logger.warn(error.getMessage()); - return; - } - - if (error instanceof InvocationTargetException invocationError) { //NOPMD - suppressed AvoidInstanceofChecksInCatchClause - 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 void enable(@NotNull Class commandClass) { - Command commandAnnotation = commandClass.getAnnotation(Command.class); - if (commandAnnotation != null && commandAnnotation.parent() != CommonCommand.class) { - return; - } - - CommonCommand command = getCommand(commandClass); - - if (command != null) { - command.enable(); - } else { - Logger.error("Command " + commandClass.getName() + " is not registered."); - } - } - - public void disable(@NotNull Class commandClass) { - Command commandAnnotation = commandClass.getAnnotation(Command.class); - if (commandAnnotation != null && commandAnnotation.parent() != CommonCommand.class) { - return; - } - - CommonCommand command = getCommand(commandClass); - - if (command != null) { - command.disable(); - } else { - Logger.error("Command " + commandClass.getName() + " is not registered."); - } - } - - public @Nullable CommonCommand getCommand(@NotNull Class commandClass) { - CommonCommand rootCommand = commands.stream() - .filter(commandHolder -> commandHolder.getClass().equals(commandClass)) - .findFirst() - .orElse(null); - - if (rootCommand != null) { - return rootCommand; - } - - return commands.stream() - .filter(commandHolder -> commandHolder.getPrimitiveSubCommands().stream() - .anyMatch(subCommand -> subCommand.getClass().equals(commandClass))) - .findFirst() - .orElse(null); - } - - protected abstract void platformRegister(@NotNull CommonCommand command); - - public boolean checkPermission(Object target, String permission) { - if (consoleClass.isInstance(target)) { - return true; - } - if (playerClass.isInstance(target)) { - return CommonPermissionUtils.checkPermission(playerClass, playerClass.cast(target), permission); - } - return CommonPermissionUtils.checkPermission(playerClass, senderClass.cast(target), permission); - } - - public abstract void sendMessage(Object target, String message); - public abstract void broadcastMessage(String message); - -} diff --git a/src/common/src/main/java/com/voinearadu/commandmanager/common/utils/CommonPermissionUtils.java b/src/common/src/main/java/com/voinearadu/commandmanager/common/utils/CommonPermissionUtils.java deleted file mode 100644 index 73003098..00000000 --- a/src/common/src/main/java/com/voinearadu/commandmanager/common/utils/CommonPermissionUtils.java +++ /dev/null @@ -1,25 +0,0 @@ -package com.voinearadu.commandmanager.common.utils; - -import com.voinearadu.utils.logger.Logger; -import net.luckperms.api.LuckPerms; -import net.luckperms.api.LuckPermsProvider; -import net.luckperms.api.platform.PlayerAdapter; - -public class CommonPermissionUtils { - - 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; - } - } - -} diff --git a/src/common/src/test/java/CommandTests.java b/src/common/src/test/java/CommandTests.java new file mode 100644 index 00000000..4b479937 --- /dev/null +++ b/src/common/src/test/java/CommandTests.java @@ -0,0 +1,64 @@ +import com.raduvoinea.commandmanager.common.command.CommonCommand; +import com.raduvoinea.commandmanager.common.config.CommandManagerConfig; +import com.raduvoinea.utils.reflections.Reflections; +import command.*; +import manager.SimpleCommandManager; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +public class CommandTests { + + 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); + } + + @Test + public void testCommandUsage() { + CommonCommand command = commandManager.getCommand(BaseCommand.class); + + assertNotNull(command); + + String usage = command.getUsage(); + + 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); + + assertNotNull(command); + + String usage = command.getUsage(); + + 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 new file mode 100644 index 00000000..c5413fc6 --- /dev/null +++ b/src/common/src/test/java/command/BaseCommand.java @@ -0,0 +1,21 @@ +package command; + +import com.raduvoinea.commandmanager.common.annotation.Command; +import com.raduvoinea.commandmanager.common.exception.CommandNotAnnotated; +import com.raduvoinea.commandmanager.common.manager.CommonCommandManager; +import dto.CommandSender; +import dto.SimpleCommand; + +import java.util.List; + +@Command(aliases = "base", arguments = {"b1", "b2"}) +public class BaseCommand extends SimpleCommand { + public BaseCommand(CommonCommandManager commandManager) throws CommandNotAnnotated { + super(commandManager); + } + + @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 new file mode 100644 index 00000000..d13f6f6b --- /dev/null +++ b/src/common/src/test/java/command/SubCommand1.java @@ -0,0 +1,21 @@ +package command; + +import com.raduvoinea.commandmanager.common.annotation.Command; +import com.raduvoinea.commandmanager.common.exception.CommandNotAnnotated; +import com.raduvoinea.commandmanager.common.manager.CommonCommandManager; +import dto.CommandSender; +import dto.SimpleCommand; + +import java.util.List; + +@Command(aliases = "sub1", arguments = {"s1", "s2"}, parent = BaseCommand.class) +public class SubCommand1 extends SimpleCommand { + public SubCommand1(CommonCommandManager commandManager) throws CommandNotAnnotated { + super(commandManager); + } + + @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 new file mode 100644 index 00000000..2d2c8edc --- /dev/null +++ b/src/common/src/test/java/command/SubCommand2.java @@ -0,0 +1,21 @@ +package command; + +import com.raduvoinea.commandmanager.common.annotation.Command; +import com.raduvoinea.commandmanager.common.exception.CommandNotAnnotated; +import com.raduvoinea.commandmanager.common.manager.CommonCommandManager; +import dto.CommandSender; +import dto.SimpleCommand; + +import java.util.List; + +@Command(aliases = "sub2", arguments = {"s1", "s2"}, parent = BaseCommand.class) +public class SubCommand2 extends SimpleCommand { + public SubCommand2(CommonCommandManager commandManager) throws CommandNotAnnotated { + super(commandManager); + } + + @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 new file mode 100644 index 00000000..659a928e --- /dev/null +++ b/src/common/src/test/java/command/SubSubCommand1.java @@ -0,0 +1,21 @@ +package command; + +import com.raduvoinea.commandmanager.common.annotation.Command; +import com.raduvoinea.commandmanager.common.exception.CommandNotAnnotated; +import com.raduvoinea.commandmanager.common.manager.CommonCommandManager; +import dto.CommandSender; +import dto.SimpleCommand; + +import java.util.List; + +@Command(aliases = "subsub1", arguments = {"ss1", "ss2"}, parent = SubCommand1.class) +public class SubSubCommand1 extends SimpleCommand { + public SubSubCommand1(CommonCommandManager commandManager) throws CommandNotAnnotated { + super(commandManager); + } + + @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 new file mode 100644 index 00000000..8c69529a --- /dev/null +++ b/src/common/src/test/java/command/SubSubCommand2.java @@ -0,0 +1,21 @@ +package command; + +import com.raduvoinea.commandmanager.common.annotation.Command; +import com.raduvoinea.commandmanager.common.exception.CommandNotAnnotated; +import com.raduvoinea.commandmanager.common.manager.CommonCommandManager; +import dto.CommandSender; +import dto.SimpleCommand; + +import java.util.List; + +@Command(aliases = "subsub2", arguments = {"ss1", "ss2"}, parent = SubCommand2.class) +public class SubSubCommand2 extends SimpleCommand { + public SubSubCommand2(CommonCommandManager commandManager) throws CommandNotAnnotated { + super(commandManager); + } + + @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 new file mode 100644 index 00000000..834130e3 --- /dev/null +++ b/src/common/src/test/java/dto/CommandSender.java @@ -0,0 +1,7 @@ +package dto; + +public interface CommandSender { + + void sendMessage(String message); + +} diff --git a/src/common/src/test/java/dto/SimpleCommand.java b/src/common/src/test/java/dto/SimpleCommand.java new file mode 100644 index 00000000..fce555c5 --- /dev/null +++ b/src/common/src/test/java/dto/SimpleCommand.java @@ -0,0 +1,31 @@ +package dto; + +import com.raduvoinea.commandmanager.common.command.CommonCommand; +import com.raduvoinea.commandmanager.common.exception.CommandNotAnnotated; +import com.raduvoinea.commandmanager.common.manager.CommonCommandManager; +import org.jetbrains.annotations.NotNull; + +import java.util.List; + +public abstract class SimpleCommand extends CommonCommand { + 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 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); + } + + 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 new file mode 100644 index 00000000..5ec33a7d --- /dev/null +++ b/src/common/src/test/java/dto/SimpleConsole.java @@ -0,0 +1,20 @@ +package dto; + +import lombok.Getter; +import lombok.NoArgsConstructor; + +import java.util.ArrayList; +import java.util.List; + +@Getter +@NoArgsConstructor +public class SimpleConsole implements CommandSender{ + + private final List messages = new ArrayList<>(); + + @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 new file mode 100644 index 00000000..5547d9b3 --- /dev/null +++ b/src/common/src/test/java/dto/SimplePlayer.java @@ -0,0 +1,20 @@ +package dto; + +import lombok.Getter; +import lombok.NoArgsConstructor; + +import java.util.ArrayList; +import java.util.List; + +@Getter +@NoArgsConstructor +public class SimplePlayer implements CommandSender { + + private final List messages = new ArrayList<>(); + + @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 new file mode 100644 index 00000000..b2835af9 --- /dev/null +++ b/src/common/src/test/java/manager/SimpleCommandManager.java @@ -0,0 +1,29 @@ +package manager; + +import com.raduvoinea.commandmanager.common.command.CommonCommand; +import com.raduvoinea.commandmanager.common.config.CommandManagerConfig; +import com.raduvoinea.commandmanager.common.manager.CommonCommandManager; +import com.raduvoinea.utils.generic.dto.Holder; +import com.raduvoinea.utils.reflections.Reflections; +import dto.CommandSender; +import dto.SimpleConsole; +import dto.SimplePlayer; +import org.jetbrains.annotations.NotNull; + +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()); + } + + @Override + protected void platformRegister(@NotNull CommonCommand command) { + + } + + @Override + public void sendMessage(Object target, String message) { + ((CommandSender) target).sendMessage(message); + } + +} diff --git a/src/fabric-20/build.gradle.kts b/src/fabric-20/build.gradle.kts deleted file mode 100644 index aa1bcea4..00000000 --- a/src/fabric-20/build.gradle.kts +++ /dev/null @@ -1,58 +0,0 @@ -@file:Suppress("UnstableApiUsage") - -plugins { - id(libs.plugins.loom.v20.get().pluginId) version libs.plugins.loom.v20.get().version.toString() -} - -dependencies { - // Minecraft - minecraft(libs.minecraft.v20) - mappings(loom.layered { - officialMojangMappings() - parchment(libs.parchment.mappings.v20) - }) - - modCompileOnly(libs.fabric.loader.v20) - modCompileOnly(libs.fabric.api.v20) - - // Project - api(project(":command-manager-common")) - - // Dependencies - if (project.properties["com.voinearadu.utils.local"] != null) { - api(project(project.properties["com.voinearadu.utils.local"] as String)) - } else { - api(libs.voinearadu.utils) - } - api(libs.luckperms) - modApi(libs.kyori.adventure.fabric) - - // Annotations - compileOnly(libs.lombok) - annotationProcessor(libs.lombok) - testCompileOnly(libs.lombok) - testAnnotationProcessor(libs.lombok) - - compileOnly(libs.jetbrains.annotations) - annotationProcessor(libs.jetbrains.annotations) - testCompileOnly(libs.jetbrains.annotations) - testAnnotationProcessor(libs.jetbrains.annotations) -} - -tasks { - jar { - archiveFileName = "FabricCommandManager-$version.jar" - } - - processResources { - inputs.property("version", version) - - filesMatching("fabric.mod.json") { - expand("version" to version) - } - } - - remapJar { - archiveFileName = "FabricCommandManager-$version.jar" - } -} \ No newline at end of file diff --git a/src/fabric-20/src/main/java/com/voinearadu/commandmanager/fabric/command/FabricCommand.java b/src/fabric-20/src/main/java/com/voinearadu/commandmanager/fabric/command/FabricCommand.java deleted file mode 100644 index 28088c62..00000000 --- a/src/fabric-20/src/main/java/com/voinearadu/commandmanager/fabric/command/FabricCommand.java +++ /dev/null @@ -1,178 +0,0 @@ -package com.voinearadu.commandmanager.fabric.command; - -import com.mojang.brigadier.arguments.StringArgumentType; -import com.mojang.brigadier.builder.ArgumentBuilder; -import com.mojang.brigadier.builder.LiteralArgumentBuilder; -import com.mojang.brigadier.context.CommandContext; -import com.voinearadu.commandmanager.common.command.CommonCommand; -import com.voinearadu.commandmanager.common.manager.CommonCommandManager; -import com.voinearadu.commandmanager.fabric.manager.FabricCommandManager; -import com.voinearadu.utils.logger.Logger; -import lombok.SneakyThrows; -import net.minecraft.commands.CommandSource; -import net.minecraft.commands.CommandSourceStack; -import net.minecraft.commands.Commands; -import net.minecraft.network.chat.Component; -import net.minecraft.server.MinecraftServer; -import net.minecraft.server.level.ServerPlayer; -import org.jetbrains.annotations.NotNull; - -import java.lang.reflect.Field; -import java.util.ArrayList; -import java.util.List; -import java.util.Set; -import java.util.stream.Collectors; - -import static net.minecraft.commands.Commands.literal; - - -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()); - } - - protected @NotNull List getArguments() { - return new ArrayList<>(); - } - - @SuppressWarnings("SameReturnValue") - private int internalExecute(@NotNull CommandContext context) { - try { - CommandSource source = getSource(context); - - 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(); - - execute(source, arguments); - } catch (Throwable error) { - Logger.error(error); - } - - return 0; - } - - @SuppressWarnings("JavaReflectionMemberAccess") - @SneakyThrows(value = {NoSuchFieldException.class, IllegalAccessException.class}) - private CommandSource getSource(@NotNull CommandContext context) { - Field field = CommandSourceStack.class.getDeclaredField(commandSourceFiled); - field.setAccessible(true); - return (CommandSource) field.get(context.getSource()); - } - - 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); - } - - String finalArgument = argument; - - arguments.add(Commands - .argument(argument, StringArgumentType.string()) - .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) { - - } - - protected List recommendPlayersList() { - return commandManager.getServer().getPlayerList().getPlayers().stream() - .map(ServerPlayer::getDisplayName) - .map(Component::getString) - .toList(); - } -} diff --git a/src/fabric-20/src/main/java/com/voinearadu/commandmanager/fabric/manager/FabricCommandManager.java b/src/fabric-20/src/main/java/com/voinearadu/commandmanager/fabric/manager/FabricCommandManager.java deleted file mode 100644 index b0fc3e26..00000000 --- a/src/fabric-20/src/main/java/com/voinearadu/commandmanager/fabric/manager/FabricCommandManager.java +++ /dev/null @@ -1,69 +0,0 @@ -package com.voinearadu.commandmanager.fabric.manager; - -import com.voinearadu.commandmanager.common.command.CommonCommand; -import com.voinearadu.commandmanager.common.manager.CommonCommandManager; -import com.voinearadu.commandmanager.fabric.command.FabricCommand; -import com.voinearadu.utils.logger.Logger; -import com.voinearadu.utils.reflections.Reflections; -import lombok.Getter; -import net.minecraft.commands.CommandSource; -import net.minecraft.network.chat.Component; -import net.minecraft.server.MinecraftServer; -import net.minecraft.server.level.ServerPlayer; -import org.jetbrains.annotations.NotNull; - -@Getter -public class FabricCommandManager extends CommonCommandManager { - - private final MinecraftServer server; - private final FabricMiniMessageManager miniMessageManager; - - public FabricCommandManager(@NotNull Reflections reflections, @NotNull String basePermission, - @NotNull MinecraftServer server) { - super(reflections, ServerPlayer.class, MinecraftServer.class, CommandSource.class, basePermission); - - this.server = server; - this.miniMessageManager = new FabricMiniMessageManager(server); - } - - @Override - protected void platformRegister(@NotNull CommonCommand primitiveCommand) { - FabricCommand command = (FabricCommand) primitiveCommand; - - for (String alias : command.getAliases()) { - server.getCommands().getDispatcher().register(command.getCommandBuilder(alias)); - } - - 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; - } - - if (target instanceof MinecraftServer console) { - console.sendSystemMessage(Component.literal(message)); - return; - } - - if (target instanceof CommandSource output) { - output.sendSystemMessage(Component.literal(message)); - return; - } - - Logger.error("Unknown target type: " + target.getClass().getName()); - } - - @Override - public void broadcastMessage(String message) { - server.getPlayerList().getPlayers().forEach(player -> - player.sendSystemMessage(miniMessageManager.parse(message)) - ); - } - -} diff --git a/src/fabric-20/src/main/java/com/voinearadu/commandmanager/fabric/manager/FabricMiniMessageManager.java b/src/fabric-20/src/main/java/com/voinearadu/commandmanager/fabric/manager/FabricMiniMessageManager.java deleted file mode 100644 index 981d8e45..00000000 --- a/src/fabric-20/src/main/java/com/voinearadu/commandmanager/fabric/manager/FabricMiniMessageManager.java +++ /dev/null @@ -1,34 +0,0 @@ -package com.voinearadu.commandmanager.fabric.manager; - -import com.voinearadu.commandmanager.common.manager.CommonMiniMessageManager; -import net.kyori.adventure.platform.fabric.FabricAudiences; -import net.kyori.adventure.platform.fabric.FabricServerAudiences; -import net.kyori.adventure.text.TextComponent; -import net.minecraft.network.chat.Component; -import net.minecraft.server.MinecraftServer; -import org.jetbrains.annotations.NotNull; - - -public class FabricMiniMessageManager extends CommonMiniMessageManager { - - private final FabricAudiences audiences; - - public FabricMiniMessageManager(MinecraftServer server) { - this.audiences = FabricServerAudiences.of(server); - } - - 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-20/src/main/resources/assets/command_manager/icon.png b/src/fabric-20/src/main/resources/assets/command_manager/icon.png deleted file mode 100644 index 5d31fa6b..00000000 Binary files a/src/fabric-20/src/main/resources/assets/command_manager/icon.png and /dev/null differ diff --git a/src/fabric-20/src/main/resources/fabric.mod.json b/src/fabric-20/src/main/resources/fabric.mod.json deleted file mode 100644 index 98c5b877..00000000 --- a/src/fabric-20/src/main/resources/fabric.mod.json +++ /dev/null @@ -1,20 +0,0 @@ -{ - "schemaVersion": 1, - "id": "command_manager_fabric_19", - "version": "UNKNOWN", - "name": "Command Manager Fabric 1.19", - "description": "", - "authors": [], - "contact": { - "repo": "https://github.com/PokeNinjas/Fabric_1_19" - }, - "license": "All-Rights-Reserved", - "icon": "assets/command_manager/icon.png", - "environment": "server", - "entrypoints": { - "client": [], - "main": [] - }, - "mixins": [], - "depends": {} -} diff --git a/src/fabric-21/build.gradle.kts b/src/fabric-21/build.gradle.kts index 20ca2c14..228908f3 100644 --- a/src/fabric-21/build.gradle.kts +++ b/src/fabric-21/build.gradle.kts @@ -1,28 +1,28 @@ @file:Suppress("UnstableApiUsage") plugins { - id(libs.plugins.loom.v21.get().pluginId) version libs.plugins.loom.v21.get().version.toString() + alias(libs.plugins.fabric.loom) } dependencies { // Minecraft - minecraft(libs.minecraft.v21) + minecraft(libs.minecraft) mappings(loom.layered { officialMojangMappings() - parchment(libs.parchment.mappings.v21) + parchment(libs.parchment) }) - modCompileOnly(libs.fabric.loader.v21) - modCompileOnly(libs.fabric.api.v21) + modCompileOnly(libs.fabric.loader) + modCompileOnly(libs.fabric.api) // Project api(project(":command-manager-common")) // Dependencies - if (project.properties["com.voinearadu.utils.local"] != null) { - api(project(project.properties["com.voinearadu.utils.local"] as String)) + if (project.properties["com.raduvoinea.utils.local"] != null) { + api(project(project.properties["com.raduvoinea.utils.local"] as String)) } else { - api(libs.voinearadu.utils) + api(libs.raduvoinea.utils) } api(libs.luckperms) modApi(libs.kyori.adventure.fabric) @@ -40,10 +40,6 @@ dependencies { } tasks { - jar { - archiveFileName = "FabricCommandManager-$version.jar" - } - processResources { inputs.property("version", version) @@ -52,6 +48,10 @@ tasks { } } + jar { + archiveFileName = "FabricCommandManager-$version.jar" + } + remapJar { archiveFileName = "FabricCommandManager-$version.jar" } diff --git a/src/fabric-21/src/main/java/com/voinearadu/commandmanager/fabric/command/FabricCommand.java b/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/command/FabricCommand.java similarity index 85% rename from src/fabric-21/src/main/java/com/voinearadu/commandmanager/fabric/command/FabricCommand.java rename to src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/command/FabricCommand.java index 6e4160c3..7f37800a 100644 --- a/src/fabric-21/src/main/java/com/voinearadu/commandmanager/fabric/command/FabricCommand.java +++ b/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/command/FabricCommand.java @@ -1,14 +1,13 @@ -package com.voinearadu.commandmanager.fabric.command; +package com.raduvoinea.commandmanager.fabric.command; import com.mojang.brigadier.arguments.StringArgumentType; import com.mojang.brigadier.builder.ArgumentBuilder; import com.mojang.brigadier.builder.LiteralArgumentBuilder; import com.mojang.brigadier.context.CommandContext; -import com.voinearadu.commandmanager.common.command.CommonCommand; -import com.voinearadu.commandmanager.common.manager.CommonCommandManager; -import com.voinearadu.commandmanager.fabric.manager.FabricCommandManager; -import com.voinearadu.utils.logger.Logger; -import lombok.SneakyThrows; +import com.raduvoinea.commandmanager.common.command.CommonCommand; +import com.raduvoinea.commandmanager.common.manager.CommonCommandManager; +import com.raduvoinea.commandmanager.fabric.manager.FabricCommandManager; +import com.raduvoinea.utils.logger.Logger; import net.minecraft.commands.CommandSource; import net.minecraft.commands.CommandSourceStack; import net.minecraft.commands.Commands; @@ -17,7 +16,6 @@ import net.minecraft.server.level.ServerPlayer; import org.jetbrains.annotations.NotNull; -import java.lang.reflect.Field; import java.util.ArrayList; import java.util.List; import java.util.Set; @@ -43,14 +41,10 @@ public FabricCommand(CommonCommandManager commandManager) { .collect(Collectors.toSet()); } - protected @NotNull List getArguments() { - return new ArrayList<>(); - } - @SuppressWarnings("SameReturnValue") private int internalExecute(@NotNull CommandContext context) { try { - CommandSource source = getSource(context); + CommandSourceStack source = context.getSource(); List arguments = this.getArguments().stream() .map(argument -> { @@ -65,7 +59,12 @@ private int internalExecute(@NotNull CommandContext context) }) .toList(); - execute(source, arguments); + if (source.isPlayer()) { + execute(source.getPlayer(), arguments); + } else { + execute(source.getServer(), arguments); + } + } catch (Throwable error) { Logger.error(error); } @@ -73,14 +72,6 @@ private int internalExecute(@NotNull CommandContext context) return 0; } - @SuppressWarnings("JavaReflectionMemberAccess") - @SneakyThrows(value = {NoSuchFieldException.class, IllegalAccessException.class}) - private CommandSource getSource(@NotNull CommandContext context) { - Field field = CommandSourceStack.class.getDeclaredField(commandSourceFiled); - field.setAccessible(true); - return (CommandSource) field.get(context.getSource()); - } - public LiteralArgumentBuilder getCommandBuilder(@NotNull String alias) { LiteralArgumentBuilder command = literal(alias); diff --git a/src/fabric-21/src/main/java/com/voinearadu/commandmanager/fabric/manager/FabricCommandManager.java b/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricCommandManager.java similarity index 70% rename from src/fabric-21/src/main/java/com/voinearadu/commandmanager/fabric/manager/FabricCommandManager.java rename to src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricCommandManager.java index c6a2fca8..be0c1494 100644 --- a/src/fabric-21/src/main/java/com/voinearadu/commandmanager/fabric/manager/FabricCommandManager.java +++ b/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricCommandManager.java @@ -1,10 +1,13 @@ -package com.voinearadu.commandmanager.fabric.manager; +package com.raduvoinea.commandmanager.fabric.manager; -import com.voinearadu.commandmanager.common.command.CommonCommand; -import com.voinearadu.commandmanager.common.manager.CommonCommandManager; -import com.voinearadu.commandmanager.fabric.command.FabricCommand; -import com.voinearadu.utils.logger.Logger; -import com.voinearadu.utils.reflections.Reflections; +import com.raduvoinea.commandmanager.common.command.CommonCommand; +import com.raduvoinea.commandmanager.common.config.CommandManagerConfig; +import com.raduvoinea.commandmanager.common.manager.CommonCommandManager; +import com.raduvoinea.commandmanager.fabric.command.FabricCommand; +import com.raduvoinea.utils.dependency_injection.Injector; +import com.raduvoinea.utils.generic.dto.Holder; +import com.raduvoinea.utils.logger.Logger; +import com.raduvoinea.utils.reflections.Reflections; import lombok.Getter; import net.minecraft.commands.CommandSource; import net.minecraft.network.chat.Component; @@ -18,9 +21,9 @@ public class FabricCommandManager extends CommonCommandManager { private final MinecraftServer server; private final FabricMiniMessageManager miniMessageManager; - public FabricCommandManager(@NotNull Reflections.Crawler reflectionsCrawler, @NotNull String basePermission, - @NotNull MinecraftServer server) { - super(reflectionsCrawler, ServerPlayer.class, MinecraftServer.class, CommandSource.class, basePermission); + 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); @@ -59,11 +62,4 @@ public void sendMessage(Object target, String message) { Logger.error("Unknown target type: " + target.getClass().getName()); } - @Override - public void broadcastMessage(String message) { - server.getPlayerList().getPlayers().forEach(player -> - player.sendSystemMessage(miniMessageManager.parse(message)) - ); - } - } diff --git a/src/fabric-21/src/main/java/com/voinearadu/commandmanager/fabric/manager/FabricMiniMessageManager.java b/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricMiniMessageManager.java similarity index 90% rename from src/fabric-21/src/main/java/com/voinearadu/commandmanager/fabric/manager/FabricMiniMessageManager.java rename to src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricMiniMessageManager.java index bc1ecf1a..ed1083be 100644 --- a/src/fabric-21/src/main/java/com/voinearadu/commandmanager/fabric/manager/FabricMiniMessageManager.java +++ b/src/fabric-21/src/main/java/com/raduvoinea/commandmanager/fabric/manager/FabricMiniMessageManager.java @@ -1,6 +1,6 @@ -package com.voinearadu.commandmanager.fabric.manager; +package com.raduvoinea.commandmanager.fabric.manager; -import com.voinearadu.commandmanager.common.manager.CommonMiniMessageManager; +import com.raduvoinea.commandmanager.common.manager.CommonMiniMessageManager; import net.kyori.adventure.platform.fabric.FabricAudiences; import net.kyori.adventure.platform.fabric.FabricServerAudiences; import net.kyori.adventure.text.TextComponent; diff --git a/src/fabric-21/src/main/resources/fabric.mod.json b/src/fabric-21/src/main/resources/fabric.mod.json index 98c5b877..94cd04f5 100644 --- a/src/fabric-21/src/main/resources/fabric.mod.json +++ b/src/fabric-21/src/main/resources/fabric.mod.json @@ -1,13 +1,11 @@ { "schemaVersion": 1, - "id": "command_manager_fabric_19", + "id": "command_manager_fabric", "version": "UNKNOWN", - "name": "Command Manager Fabric 1.19", + "name": "Command Manager Fabric", "description": "", "authors": [], - "contact": { - "repo": "https://github.com/PokeNinjas/Fabric_1_19" - }, + "contact": {}, "license": "All-Rights-Reserved", "icon": "assets/command_manager/icon.png", "environment": "server", diff --git a/src/velocity/build.gradle.kts b/src/velocity/build.gradle.kts index 8068ef8d..c9c198d2 100644 --- a/src/velocity/build.gradle.kts +++ b/src/velocity/build.gradle.kts @@ -9,10 +9,10 @@ dependencies { api(project(":command-manager-common")) // Dependencies - if (project.properties["com.voinearadu.utils.local"] != null) { - api(project(project.properties["com.voinearadu.utils.local"] as String)) + if (project.properties["com.raduvoinea.utils.local"] != null) { + api(project(project.properties["com.raduvoinea.utils.local"] as String)) } else { - api(libs.voinearadu.utils) + api(libs.raduvoinea.utils) } // Annotations diff --git a/src/velocity/src/main/java/com/voinearadu/commandmanager/velocity/command/VelocityCommand.java b/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/command/VelocityCommand.java similarity index 87% rename from src/velocity/src/main/java/com/voinearadu/commandmanager/velocity/command/VelocityCommand.java rename to src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/command/VelocityCommand.java index 48d50abd..d9d575a2 100644 --- a/src/velocity/src/main/java/com/voinearadu/commandmanager/velocity/command/VelocityCommand.java +++ b/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/command/VelocityCommand.java @@ -1,10 +1,10 @@ -package com.voinearadu.commandmanager.velocity.command; +package com.raduvoinea.commandmanager.velocity.command; -import com.voinearadu.commandmanager.common.command.CommonCommand; -import com.voinearadu.commandmanager.common.manager.CommonCommandManager; -import com.voinearadu.commandmanager.common.utils.ListUtils; -import com.voinearadu.commandmanager.velocity.manager.VelocityCommandManager; -import com.voinearadu.utils.logger.Logger; +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.velocity.manager.VelocityCommandManager; +import com.raduvoinea.utils.logger.Logger; import com.velocitypowered.api.command.CommandSource; import com.velocitypowered.api.command.SimpleCommand; import com.velocitypowered.api.proxy.ConsoleCommandSource; @@ -13,10 +13,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import java.util.Set; +import java.util.*; import java.util.stream.Collectors; // TODO(low) Maybe Add minimum number of arguments and check for it @@ -141,4 +138,13 @@ protected List recommendPlayersList() { .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/voinearadu/commandmanager/velocity/manager/VelocityCommandManager.java b/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityCommandManager.java similarity index 61% rename from src/velocity/src/main/java/com/voinearadu/commandmanager/velocity/manager/VelocityCommandManager.java rename to src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityCommandManager.java index 700d2459..aba64f99 100644 --- a/src/velocity/src/main/java/com/voinearadu/commandmanager/velocity/manager/VelocityCommandManager.java +++ b/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityCommandManager.java @@ -1,9 +1,12 @@ -package com.voinearadu.commandmanager.velocity.manager; - -import com.voinearadu.commandmanager.common.command.CommonCommand; -import com.voinearadu.commandmanager.common.manager.CommonCommandManager; -import com.voinearadu.commandmanager.velocity.command.VelocityCommand; -import com.voinearadu.utils.reflections.Reflections; +package com.raduvoinea.commandmanager.velocity.manager; + +import com.raduvoinea.commandmanager.common.command.CommonCommand; +import com.raduvoinea.commandmanager.common.config.CommandManagerConfig; +import com.raduvoinea.commandmanager.common.manager.CommonCommandManager; +import com.raduvoinea.commandmanager.velocity.command.VelocityCommand; +import com.raduvoinea.utils.dependency_injection.Injector; +import com.raduvoinea.utils.generic.dto.Holder; +import com.raduvoinea.utils.reflections.Reflections; import com.velocitypowered.api.command.CommandMeta; import com.velocitypowered.api.command.CommandSource; import com.velocitypowered.api.proxy.ConsoleCommandSource; @@ -17,11 +20,14 @@ public class VelocityCommandManager extends CommonCommandManager { private final ProxyServer proxy; private final VelocityMiniMessageManager miniMessageManager; + private final Object plugin; - public VelocityCommandManager(@NotNull Reflections.Crawler reflectionsCrawler, @NotNull String basePermission, - @NotNull ProxyServer proxy) { - super(reflectionsCrawler, Player.class, ConsoleCommandSource.class, CommandSource.class, basePermission); + 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(); } @@ -32,10 +38,9 @@ protected void platformRegister(@NotNull CommonCommand primitiveCommand) { 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.proxy) + .plugin(this.plugin) .build(); @@ -48,9 +53,4 @@ public final void sendMessage(Object user, String message) { source.sendMessage(miniMessageManager.parse(message)); } - @Override - public void broadcastMessage(String message) { - proxy.sendMessage(miniMessageManager.parse(message)); - } - } diff --git a/src/velocity/src/main/java/com/voinearadu/commandmanager/velocity/manager/VelocityMiniMessageManager.java b/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityMiniMessageManager.java similarity index 81% rename from src/velocity/src/main/java/com/voinearadu/commandmanager/velocity/manager/VelocityMiniMessageManager.java rename to src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityMiniMessageManager.java index f32d26e4..245b8b69 100644 --- a/src/velocity/src/main/java/com/voinearadu/commandmanager/velocity/manager/VelocityMiniMessageManager.java +++ b/src/velocity/src/main/java/com/raduvoinea/commandmanager/velocity/manager/VelocityMiniMessageManager.java @@ -1,6 +1,6 @@ -package com.voinearadu.commandmanager.velocity.manager; +package com.raduvoinea.commandmanager.velocity.manager; -import com.voinearadu.commandmanager.common.manager.CommonMiniMessageManager; +import com.raduvoinea.commandmanager.common.manager.CommonMiniMessageManager; import net.kyori.adventure.text.Component; import net.kyori.adventure.text.TextComponent; import org.jetbrains.annotations.NotNull;