From 9872d22c06b64031857d3153a6d729983675f9c3 Mon Sep 17 00:00:00 2001 From: dfsek Date: Sun, 19 Dec 2021 17:41:04 -0700 Subject: [PATCH] implement getType method in registries --- .../addons/terrascript/TerraScriptAddon.java | 4 +- .../terra/api/command/RegistryArgument.java | 91 +++++++++++++++++++ .../dfsek/terra/api/config/ConfigPack.java | 12 +-- .../dfsek/terra/api/registry/Registry.java | 6 ++ .../terra/api/util/reflection/TypeKey.java | 13 +++ .../com/dfsek/terra/AbstractPlatform.java | 7 +- .../com/dfsek/terra/addon/InternalAddon.java | 36 ++++++++ .../terra/config/pack/ConfigPackImpl.java | 22 +++-- .../terra/registry/CheckedRegistryImpl.java | 8 ++ .../terra/registry/LockedRegistryImpl.java | 10 +- .../terra/registry/OpenRegistryImpl.java | 18 +++- .../terra/registry/master/ConfigRegistry.java | 9 +- .../src/test/java/registry/RegistryTest.java | 8 +- .../dfsek/terra/bukkit/TerraBukkitPlugin.java | 44 +++++---- .../dfsek/terra/fabric/FabricEntryPoint.java | 18 ++++ 15 files changed, 260 insertions(+), 46 deletions(-) create mode 100644 common/api/core/src/main/java/com/dfsek/terra/api/command/RegistryArgument.java diff --git a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java index 077778559..9d2b56503 100644 --- a/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java +++ b/common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java @@ -26,9 +26,11 @@ import com.dfsek.terra.api.registry.CheckedRegistry; import com.dfsek.terra.api.structure.LootTable; import com.dfsek.terra.api.structure.Structure; import com.dfsek.terra.api.util.StringUtil; +import com.dfsek.terra.api.util.reflection.TypeKey; public class TerraScriptAddon implements AddonInitializer { + public static TypeKey> FUNCTION_BUILDER_TYPE = new TypeKey<>() {}; @Inject private Platform platform; @@ -50,7 +52,7 @@ public class TerraScriptAddon implements AddonInitializer { StructureScript structureScript = new StructureScript(entry.getValue(), id, platform, structureRegistry, lootRegistry, event.getPack().getOrCreateRegistry( - (Type) FunctionBuilder.class)); + FUNCTION_BUILDER_TYPE)); structureRegistry.register(structureScript.getID(), structureScript); } catch(ParseException e) { throw new LoadException("Failed to load script \"" + entry.getKey() + "\"", e); diff --git a/common/api/core/src/main/java/com/dfsek/terra/api/command/RegistryArgument.java b/common/api/core/src/main/java/com/dfsek/terra/api/command/RegistryArgument.java new file mode 100644 index 000000000..331413b48 --- /dev/null +++ b/common/api/core/src/main/java/com/dfsek/terra/api/command/RegistryArgument.java @@ -0,0 +1,91 @@ +package com.dfsek.terra.api.command; + +import cloud.commandframework.ArgumentDescription; +import cloud.commandframework.arguments.CommandArgument; +import cloud.commandframework.arguments.parser.ArgumentParseResult; +import cloud.commandframework.arguments.parser.ArgumentParser; +import cloud.commandframework.context.CommandContext; + +import com.dfsek.terra.api.registry.Registry; + +import com.dfsek.terra.api.registry.exception.NoSuchEntryException; + +import io.leangen.geantyref.TypeToken; +import org.checkerframework.checker.nullness.qual.NonNull; +import org.checkerframework.checker.nullness.qual.Nullable; + +import java.util.List; +import java.util.Queue; +import java.util.function.BiFunction; +import java.util.stream.Collectors; + + +public class RegistryArgument extends CommandArgument { + + + @SuppressWarnings("unchecked") + private RegistryArgument( + final boolean required, + final @NonNull String name, + final Registry registry, + final @NonNull String defaultValue, + final @Nullable BiFunction<@NonNull CommandContext, @NonNull String, + @NonNull List<@NonNull String>> suggestionsProvider, + final @NonNull ArgumentDescription description + ) { + super(required, + name, + new RegistryArgumentParser<>(registry), + defaultValue, + (TypeToken) TypeToken.get(registry.getType().getType()), + suggestionsProvider, + description); + } + + public static Builder builder(String name, Registry registry) { + return new Builder<>(name, registry); + } + + public static final class Builder extends CommandArgument.Builder { + private final Registry registry; + + @SuppressWarnings("unchecked") + private Builder(@NonNull String name, Registry registry) { + super((TypeToken) registry.getType().getType(), name); + this.registry = registry; + } + + @Override + public @NonNull RegistryArgument build() { + return new RegistryArgument<>( + isRequired(), + getName(), + registry, + getDefaultValue(), + getSuggestionsProvider(), + getDefaultDescription() + ); + } + } + + + private static final class RegistryArgumentParser implements ArgumentParser { + private final Registry registry; + + private RegistryArgumentParser(Registry registry) { + this.registry = registry; + } + + @Override + public @NonNull ArgumentParseResult<@NonNull R> parse(@NonNull CommandContext<@NonNull T> commandContext, + @NonNull Queue<@NonNull String> inputQueue) { + String input = inputQueue.remove(); + return registry.get(input).map(ArgumentParseResult::success).orElse(ArgumentParseResult.failure(new NoSuchEntryException("No such entry: " + input))); + } + + @Override + public @NonNull List<@NonNull String> suggestions(@NonNull CommandContext commandContext, @NonNull String input) { + return registry.keys().stream().sorted().collect(Collectors.toList()); + } + } +} diff --git a/common/api/core/src/main/java/com/dfsek/terra/api/config/ConfigPack.java b/common/api/core/src/main/java/com/dfsek/terra/api/config/ConfigPack.java index 934ef52c5..048eb7a60 100644 --- a/common/api/core/src/main/java/com/dfsek/terra/api/config/ConfigPack.java +++ b/common/api/core/src/main/java/com/dfsek/terra/api/config/ConfigPack.java @@ -35,15 +35,11 @@ public interface ConfigPack extends LoaderRegistrar, ConfigLoadingDelegate, Regi BiomeProvider getBiomeProvider(); - CheckedRegistry getOrCreateRegistry(Type clazz); - default CheckedRegistry getOrCreateRegistry(Class clazz) { - return getOrCreateRegistry((Type) clazz); + return getOrCreateRegistry(TypeKey.of(clazz)); } - default CheckedRegistry getOrCreateRegistry(TypeKey type) { - return getOrCreateRegistry(type.getType()); - } + CheckedRegistry getOrCreateRegistry(TypeKey type); List getStages(); @@ -53,10 +49,10 @@ public interface ConfigPack extends LoaderRegistrar, ConfigLoadingDelegate, Regi Version getVersion(); - ConfigPack registerShortcut(Type clazz, String shortcut, ShortcutLoader loader); + ConfigPack registerShortcut(TypeKey clazz, String shortcut, ShortcutLoader loader); default ConfigPack registerShortcut(Class clazz, String shortcut, ShortcutLoader loader) { - return registerShortcut((Type) clazz, shortcut, loader); + return registerShortcut(TypeKey.of(clazz), shortcut, loader); } ChunkGeneratorProvider getGeneratorProvider(); diff --git a/common/api/registry/src/main/java/com/dfsek/terra/api/registry/Registry.java b/common/api/registry/src/main/java/com/dfsek/terra/api/registry/Registry.java index 26f4f8bb2..d1a02b542 100644 --- a/common/api/registry/src/main/java/com/dfsek/terra/api/registry/Registry.java +++ b/common/api/registry/src/main/java/com/dfsek/terra/api/registry/Registry.java @@ -8,6 +8,10 @@ package com.dfsek.terra.api.registry; import com.dfsek.tectonic.api.loader.type.TypeLoader; + +import com.dfsek.terra.api.util.reflection.TypeKey; + +import com.google.common.reflect.TypeToken; import org.jetbrains.annotations.Contract; import org.jetbrains.annotations.NotNull; @@ -70,4 +74,6 @@ public interface Registry extends TypeLoader { @NotNull @Contract(pure = true) Set keys(); + + TypeKey getType(); } diff --git a/common/api/util/src/main/java/com/dfsek/terra/api/util/reflection/TypeKey.java b/common/api/util/src/main/java/com/dfsek/terra/api/util/reflection/TypeKey.java index e73be44d7..2e3399f32 100644 --- a/common/api/util/src/main/java/com/dfsek/terra/api/util/reflection/TypeKey.java +++ b/common/api/util/src/main/java/com/dfsek/terra/api/util/reflection/TypeKey.java @@ -7,6 +7,8 @@ package com.dfsek.terra.api.util.reflection; +import com.dfsek.tectonic.util.ClassAnnotatedTypeImpl; + import java.lang.reflect.AnnotatedParameterizedType; import java.lang.reflect.AnnotatedType; import java.lang.reflect.GenericArrayType; @@ -33,6 +35,17 @@ public class TypeKey { this.hashCode = type.hashCode(); } + protected TypeKey(Class clazz) { + this.type = clazz; + this.rawType = clazz; + this.annotatedType = new ClassAnnotatedTypeImpl(clazz); + this.hashCode = type.hashCode(); + } + + public static TypeKey of(Class clazz) { + return new TypeKey<>(clazz); + } + public static boolean equals(Type a, Type b) { if(a == b) { return true; diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java b/common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java index c5b340188..b6f36d591 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java @@ -18,6 +18,9 @@ package com.dfsek.terra; import com.dfsek.tectonic.api.TypeRegistry; + +import com.dfsek.terra.api.util.reflection.TypeKey; + import org.apache.commons.io.FileUtils; import org.apache.commons.io.IOUtils; import org.jetbrains.annotations.NotNull; @@ -93,7 +96,7 @@ public abstract class AbstractPlatform implements Platform { private final CommandManager manager = new TerraCommandManager(this); - private final CheckedRegistry addonRegistry = new CheckedRegistryImpl<>(new OpenRegistryImpl<>()); + private final CheckedRegistry addonRegistry = new CheckedRegistryImpl<>(new OpenRegistryImpl<>(TypeKey.of(BaseAddon.class))); private final Registry lockedAddonRegistry = new LockedRegistryImpl<>(addonRegistry); @@ -172,7 +175,7 @@ public abstract class AbstractPlatform implements Platform { List addonList = new ArrayList<>(); - InternalAddon internalAddon = new InternalAddon(); + InternalAddon internalAddon = new InternalAddon(this); addonList.add(internalAddon); diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/addon/InternalAddon.java b/common/implementation/base/src/main/java/com/dfsek/terra/addon/InternalAddon.java index f5716bbdb..52f13ec06 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/addon/InternalAddon.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/addon/InternalAddon.java @@ -20,12 +20,48 @@ package com.dfsek.terra.addon; import ca.solostudios.strata.Versions; import ca.solostudios.strata.version.Version; +import cloud.commandframework.ArgumentDescription; +import cloud.commandframework.CommandManager; +import cloud.commandframework.Description; + +import cloud.commandframework.arguments.standard.StringArgument; + +import com.dfsek.terra.api.Platform; import com.dfsek.terra.api.addon.BaseAddon; +import com.dfsek.terra.api.entity.CommandSender; +import com.dfsek.terra.api.event.events.platform.CommandRegistrationEvent; +import com.dfsek.terra.api.event.functional.FunctionalEventHandler; public class InternalAddon implements BaseAddon { private static final Version VERSION = Versions.getVersion(1, 0, 0); + public InternalAddon(Platform platform) { + platform.getEventManager() + .getHandler(FunctionalEventHandler.class) + .register(this, CommandRegistrationEvent.class) + .then(event -> { + CommandManager manager = event.getCommandManager(); + manager.command( + manager.commandBuilder("addons", ArgumentDescription.of("Get information about installed Terra addons")) + .handler(context -> { + StringBuilder addons = new StringBuilder("Installed addons:\n"); + platform.getAddons() + .forEach(addon -> addons + .append("- ") + .append(addon.getID()) + .append('@') + .append(addon.getVersion()) + .append('\n')); + context.getSender().sendMessage(addons.toString()); + }) + ); + + + }); + + } + @Override public String getID() { return "terra"; diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java index f61734547..fa55ca006 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java @@ -48,6 +48,7 @@ import com.dfsek.terra.api.tectonic.ShortcutLoader; import com.dfsek.terra.api.util.generic.Construct; import com.dfsek.terra.api.util.generic.pair.Pair; import com.dfsek.terra.api.util.reflection.ReflectionUtil; +import com.dfsek.terra.api.util.reflection.TypeKey; import com.dfsek.terra.api.world.biome.generation.BiomeProvider; import com.dfsek.terra.api.world.chunk.generation.stage.GenerationStage; import com.dfsek.terra.api.world.chunk.generation.util.provider.ChunkGeneratorProvider; @@ -82,6 +83,7 @@ import java.util.zip.ZipFile; * Represents a Terra configuration pack. */ public class ConfigPackImpl implements ConfigPack { + public static final TypeKey> CONFIG_TYPE_TYPE_KEY = new TypeKey<>() {}; private static final Logger logger = LoggerFactory.getLogger(ConfigPackImpl.class); private final ConfigPackTemplate template = new ConfigPackTemplate(); @@ -274,14 +276,14 @@ public class ConfigPackImpl implements ConfigPack { @SuppressWarnings("unchecked") @Override - public CheckedRegistry getOrCreateRegistry(Type type) { - return (CheckedRegistry) registryMap.computeIfAbsent(type, c -> { - OpenRegistry registry = new OpenRegistryImpl<>(); + public CheckedRegistry getOrCreateRegistry(TypeKey typeKey) { + return (CheckedRegistry) registryMap.computeIfAbsent(typeKey.getType(), c -> { + OpenRegistry registry = new OpenRegistryImpl<>(typeKey); selfLoader.registerLoader(c, registry); abstractConfigLoader.registerLoader(c, registry); logger.debug("Registered loader for registry of class {}", ReflectionUtil.typeToString(c)); - if(type instanceof ParameterizedType param) { + if(typeKey.getType() instanceof ParameterizedType param) { Type base = param.getRawType(); if(base instanceof Class // should always be true but we'll check anyways && Supplier.class.isAssignableFrom((Class) base)) { // If it's a supplier @@ -327,12 +329,12 @@ public class ConfigPackImpl implements ConfigPack { @SuppressWarnings("unchecked,rawtypes") @Override - public ConfigPack registerShortcut(Type clazz, String shortcut, ShortcutLoader loader) { + public ConfigPack registerShortcut(TypeKey clazz, String shortcut, ShortcutLoader loader) { ShortcutHolder holder = shortcuts - .computeIfAbsent(clazz, c -> new ShortcutHolder<>(getOrCreateRegistry(clazz))) + .computeIfAbsent(clazz.getType(), c -> new ShortcutHolder<>(getOrCreateRegistry(clazz))) .register(shortcut, (ShortcutLoader) loader); - selfLoader.registerLoader(clazz, holder); - abstractConfigLoader.registerLoader(clazz, holder); + selfLoader.registerLoader(clazz.getType(), holder); + abstractConfigLoader.registerLoader(clazz.getType(), holder); return this; } @@ -342,13 +344,13 @@ public class ConfigPackImpl implements ConfigPack { } private OpenRegistry> createConfigRegistry() { - return new OpenRegistryImpl<>(new LinkedHashMap<>()) { + return new OpenRegistryImpl<>(new LinkedHashMap<>(), CONFIG_TYPE_TYPE_KEY) { @Override public boolean register(@NotNull String identifier, @NotNull ConfigType value) { if(!registryMap .containsKey(value.getTypeKey() .getType())) { - OpenRegistry openRegistry = new OpenRegistryImpl<>(); + OpenRegistry openRegistry = new OpenRegistryImpl<>(value.getTypeKey()); selfLoader.registerLoader(value.getTypeKey().getType(), openRegistry); abstractConfigLoader.registerLoader(value.getTypeKey().getType(), openRegistry); registryMap.put(value.getTypeKey().getType(), new CheckedRegistryImpl<>(openRegistry)); diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/registry/CheckedRegistryImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/registry/CheckedRegistryImpl.java index f210a1b10..a12d9beb3 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/registry/CheckedRegistryImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/registry/CheckedRegistryImpl.java @@ -19,6 +19,9 @@ package com.dfsek.terra.registry; import com.dfsek.tectonic.api.exception.LoadException; import com.dfsek.tectonic.api.loader.ConfigLoader; + +import com.dfsek.terra.api.util.reflection.TypeKey; + import org.jetbrains.annotations.ApiStatus.Internal; import org.jetbrains.annotations.NotNull; @@ -86,6 +89,11 @@ public class CheckedRegistryImpl implements CheckedRegistry { return registry.keys(); } + @Override + public TypeKey getType() { + return registry.getType(); + } + @Override public T load(@NotNull AnnotatedType t, @NotNull Object c, @NotNull ConfigLoader loader) throws LoadException { return registry.load(t, c, loader); diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/registry/LockedRegistryImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/registry/LockedRegistryImpl.java index 07cbd7941..e19577b70 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/registry/LockedRegistryImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/registry/LockedRegistryImpl.java @@ -19,6 +19,9 @@ package com.dfsek.terra.registry; import com.dfsek.tectonic.api.exception.LoadException; import com.dfsek.tectonic.api.loader.ConfigLoader; + +import com.dfsek.terra.api.util.reflection.TypeKey; + import org.jetbrains.annotations.NotNull; import java.lang.reflect.AnnotatedType; @@ -74,7 +77,12 @@ public class LockedRegistryImpl implements Registry { } @Override - public T load(AnnotatedType t, Object c, ConfigLoader loader) throws LoadException { + public TypeKey getType() { + return registry.getType(); + } + + @Override + public T load(@NotNull AnnotatedType t, @NotNull Object c, @NotNull ConfigLoader loader) throws LoadException { return registry.load(t, c, loader); } } diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/registry/OpenRegistryImpl.java b/common/implementation/base/src/main/java/com/dfsek/terra/registry/OpenRegistryImpl.java index 8a1c615e3..0a1a0eb56 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/registry/OpenRegistryImpl.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/registry/OpenRegistryImpl.java @@ -19,6 +19,9 @@ package com.dfsek.terra.registry; import com.dfsek.tectonic.api.exception.LoadException; import com.dfsek.tectonic.api.loader.ConfigLoader; + +import com.dfsek.terra.api.util.reflection.TypeKey; + import org.jetbrains.annotations.NotNull; import java.lang.reflect.AnnotatedType; @@ -46,17 +49,19 @@ public class OpenRegistryImpl implements OpenRegistry { private static final Entry NULL = new Entry<>(null); private static final Pattern ID_PATTERN = Pattern.compile("^[a-zA-Z0-9_-]*$"); private final Map> objects; + private final TypeKey typeKey; - public OpenRegistryImpl() { - objects = new HashMap<>(); + public OpenRegistryImpl(TypeKey typeKey) { + this(new HashMap<>(), typeKey); } - protected OpenRegistryImpl(Map> init) { + protected OpenRegistryImpl(Map> init, TypeKey typeKey) { this.objects = init; + this.typeKey = typeKey; } @Override - public T load(AnnotatedType type, Object o, ConfigLoader configLoader) throws LoadException { + public T load(@NotNull AnnotatedType type, @NotNull Object o, @NotNull ConfigLoader configLoader) throws LoadException { return get((String) o).orElseThrow(() -> { String list = objects.keySet().stream().sorted().reduce("", (a, b) -> a + "\n - " + b); if(objects.isEmpty()) list = "[ ]"; @@ -123,6 +128,11 @@ public class OpenRegistryImpl implements OpenRegistry { return objects.keySet(); } + @Override + public TypeKey getType() { + return typeKey; + } + public Map getDeadEntries() { Map dead = new HashMap<>(); objects.forEach((id, entry) -> { diff --git a/common/implementation/base/src/main/java/com/dfsek/terra/registry/master/ConfigRegistry.java b/common/implementation/base/src/main/java/com/dfsek/terra/registry/master/ConfigRegistry.java index 5932d39ed..82e1d7006 100644 --- a/common/implementation/base/src/main/java/com/dfsek/terra/registry/master/ConfigRegistry.java +++ b/common/implementation/base/src/main/java/com/dfsek/terra/registry/master/ConfigRegistry.java @@ -18,6 +18,9 @@ package com.dfsek.terra.registry.master; import com.dfsek.tectonic.api.exception.ConfigException; + +import com.dfsek.terra.api.util.reflection.TypeKey; + import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -36,7 +39,11 @@ import com.dfsek.terra.registry.OpenRegistryImpl; */ public class ConfigRegistry extends OpenRegistryImpl { private static final Logger logger = LoggerFactory.getLogger(ConfigRegistry.class); - + + public ConfigRegistry() { + super(TypeKey.of(ConfigPack.class)); + } + public void load(File folder, Platform platform) throws ConfigException { ConfigPack pack = new ConfigPackImpl(folder, platform); register(pack.getID(), pack); diff --git a/common/implementation/base/src/test/java/registry/RegistryTest.java b/common/implementation/base/src/test/java/registry/RegistryTest.java index 2c630e241..06e0345c0 100644 --- a/common/implementation/base/src/test/java/registry/RegistryTest.java +++ b/common/implementation/base/src/test/java/registry/RegistryTest.java @@ -17,6 +17,8 @@ package registry; +import com.dfsek.terra.api.util.reflection.TypeKey; + import org.junit.jupiter.api.Test; import com.dfsek.terra.api.registry.CheckedRegistry; @@ -31,7 +33,7 @@ import static org.junit.jupiter.api.Assertions.*; public class RegistryTest { @Test public void openRegistry() { - OpenRegistry test = new OpenRegistryImpl<>(); + OpenRegistry test = new OpenRegistryImpl<>(TypeKey.of(String.class)); test.register("test", "bazinga"); @@ -40,7 +42,7 @@ public class RegistryTest { @Test public void openRegistryChecked() { - OpenRegistry test = new OpenRegistryImpl<>(); + OpenRegistry test = new OpenRegistryImpl<>(TypeKey.of(String.class)); test.registerChecked("test", "bazinga"); @@ -54,7 +56,7 @@ public class RegistryTest { @Test public void checkedRegistry() { - CheckedRegistry test = new CheckedRegistryImpl<>(new OpenRegistryImpl<>()); + CheckedRegistry test = new CheckedRegistryImpl<>(new OpenRegistryImpl<>(TypeKey.of(String.class))); test.register("test", "bazinga"); diff --git a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java index 5ac84f324..e136f306c 100644 --- a/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java +++ b/platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/TerraBukkitPlugin.java @@ -17,6 +17,13 @@ package com.dfsek.terra.bukkit; +import cloud.commandframework.brigadier.CloudBrigadierManager; +import cloud.commandframework.bukkit.CloudBukkitCapabilities; +import cloud.commandframework.execution.CommandExecutionCoordinator; +import cloud.commandframework.paper.PaperCommandManager; + +import com.dfsek.terra.api.entity.CommandSender; + import org.bukkit.Bukkit; import org.bukkit.command.PluginCommand; import org.bukkit.generator.ChunkGenerator; @@ -30,19 +37,16 @@ import java.util.HashMap; import java.util.Map; import java.util.Objects; -import com.dfsek.terra.api.command.CommandManager; -import com.dfsek.terra.api.command.exception.MalformedCommandException; import com.dfsek.terra.api.config.ConfigPack; +import com.dfsek.terra.api.event.events.platform.CommandRegistrationEvent; import com.dfsek.terra.api.event.events.platform.PlatformInitializationEvent; -import com.dfsek.terra.bukkit.command.BukkitCommandAdapter; import com.dfsek.terra.bukkit.generator.BukkitChunkGeneratorWrapper; import com.dfsek.terra.bukkit.listeners.CommonListener; import com.dfsek.terra.bukkit.listeners.PaperListener; import com.dfsek.terra.bukkit.listeners.SpigotListener; import com.dfsek.terra.bukkit.util.PaperUtil; import com.dfsek.terra.bukkit.util.VersionUtil; -import com.dfsek.terra.commands.CommandUtil; -import com.dfsek.terra.commands.TerraCommandManager; +import com.dfsek.terra.bukkit.world.BukkitAdapter; public class TerraBukkitPlugin extends JavaPlugin { @@ -61,12 +65,26 @@ public class TerraBukkitPlugin extends JavaPlugin { PluginCommand cmd = Objects.requireNonNull(getCommand("terra")); - CommandManager manager = new TerraCommandManager(platform); - - try { - CommandUtil.registerAll(manager); - } catch(MalformedCommandException e) { // This should never happen. + PaperCommandManager commandManager = new PaperCommandManager<>(this, + CommandExecutionCoordinator.simpleCoordinator(), + BukkitAdapter::adapt, + BukkitAdapter::adapt); + if (commandManager.queryCapability(CloudBukkitCapabilities.NATIVE_BRIGADIER)) { + commandManager.registerBrigadier(); + final CloudBrigadierManager brigManager = commandManager.brigadierManager(); + if (brigManager != null) { + brigManager.setNativeNumberSuggestions(false); + } + } + + if (commandManager.queryCapability(CloudBukkitCapabilities.ASYNCHRONOUS_COMPLETION)) { + commandManager.registerAsynchronousCompletions(); + } + + platform.getEventManager().callEvent(new CommandRegistrationEvent(commandManager)); + + } catch(Exception e) { // This should never happen. logger.error(""" TERRA HAS BEEN DISABLED @@ -77,12 +95,6 @@ public class TerraBukkitPlugin extends JavaPlugin { return; } - BukkitCommandAdapter command = new BukkitCommandAdapter(manager); - - cmd.setExecutor(command); - cmd.setTabCompleter(command); - - Bukkit.getPluginManager().registerEvents(new CommonListener(), this); // Register master event listener PaperUtil.checkPaper(this); diff --git a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java index 11f6c64a6..1a84db49a 100644 --- a/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java +++ b/platforms/fabric/src/main/java/com/dfsek/terra/fabric/FabricEntryPoint.java @@ -17,7 +17,15 @@ package com.dfsek.terra.fabric; +import cloud.commandframework.execution.CommandExecutionCoordinator; +import cloud.commandframework.fabric.FabricServerCommandManager; + +import com.dfsek.terra.api.entity.CommandSender; + +import com.dfsek.terra.api.event.events.platform.CommandRegistrationEvent; + import net.fabricmc.api.ModInitializer; +import net.minecraft.server.command.ServerCommandSource; import net.minecraft.util.Identifier; import net.minecraft.util.registry.Registry; import org.slf4j.Logger; @@ -43,5 +51,15 @@ public class FabricEntryPoint implements ModInitializer { // register the things Registry.register(Registry.CHUNK_GENERATOR, new Identifier("terra:terra"), FabricChunkGeneratorWrapper.CODEC); Registry.register(Registry.BIOME_SOURCE, new Identifier("terra:terra"), TerraBiomeSource.CODEC); + + FabricServerCommandManager manager = new FabricServerCommandManager<>( + CommandExecutionCoordinator.simpleCoordinator(), + serverCommandSource -> (CommandSender) serverCommandSource, + commandSender -> (ServerCommandSource) commandSender + ); + + manager.brigadierManager().setNativeNumberSuggestions(false); + + TERRA_PLUGIN.getEventManager().callEvent(new CommandRegistrationEvent(manager)); } }