From 73bf1ecc40028f3cc3c1e8ff19be369a398a0b45 Mon Sep 17 00:00:00 2001 From: Dueris <122416109+Dueris@users.noreply.github.com> Date: Fri, 7 Jun 2024 20:35:41 +0000 Subject: [PATCH] API Documentation and AT some stuff --- .github/workflows/gradle.yml | 2 +- API-DOCS.md | 317 ++++++++++++++++++ .../main/java/me/dueris/calio/CraftCalio.java | 1 - .../java/me/dueris/genesismc/Bootstrap.java | 65 ++++ .../java/me/dueris/genesismc/GenesisMC.java | 40 --- .../genesismc/factory/actions/Actions.java | 4 + .../actions/types/BiEntityActions.java | 2 +- .../factory/actions/types/BlockActions.java | 2 +- .../factory/actions/types/EntityActions.java | 2 +- .../factory/actions/types/ItemActions.java | 2 +- .../factory/conditions/ConditionExecutor.java | 28 +- .../conditions/types/BiEntityConditions.java | 2 +- .../conditions/types/BiomeConditions.java | 2 +- .../conditions/types/BlockConditions.java | 2 +- .../conditions/types/DamageConditions.java | 2 +- .../conditions/types/EntityConditions.java | 2 +- .../conditions/types/FluidConditions.java | 2 +- .../conditions/types/ItemConditions.java | 2 +- .../dueris/genesismc/registry/Registries.java | 53 +-- .../genesismc/util/TextureLocation.java | 4 +- .../genesismc/util/entity/PowerUtils.java | 1 - 21 files changed, 447 insertions(+), 90 deletions(-) create mode 100644 API-DOCS.md diff --git a/.github/workflows/gradle.yml b/.github/workflows/gradle.yml index c8dc3cdcf..8eac35cea 100644 --- a/.github/workflows/gradle.yml +++ b/.github/workflows/gradle.yml @@ -35,7 +35,7 @@ jobs: uses: softprops/action-gh-release@v1 with: name: Build ${{ github.run_number }} - tag_name: ${{ github.run_number }} + tag_name: mc1.20/6-v1.0.0 body: \"changes\"=${{ github.event.head_commit.message }} token: ${{ secrets.GIT_TOKEN }} files: build/libs/*.jar diff --git a/API-DOCS.md b/API-DOCS.md new file mode 100644 index 000000000..ce8fcb510 --- /dev/null +++ b/API-DOCS.md @@ -0,0 +1,317 @@ +# API Documentation + +## Introduction +Welcome to the **GenesisMC** API documentation. This document provides instructions on how to interact with GenesisMC's codebase for external plugin use, or contributing. + +## Adding the API to Gradle Kotlin Script + +Just add the repository where the API is hosted to your `build.gradle.kts` file and the dependency. Ensure you have paperweight installed aswell, because GenesisMC uses NMS and CraftBukkit instances throughout the plugin and API + +```kotlin +repositories { + mavenCentral() + maven { + url = uri("https://jitpack.io/") + } +} + +dependencies { + implemnetation("io.github.Dueris:GenesisMC:mc1.20/6-v1.0.0") +} +``` + +## Setting up GenesisMC hooking + +Setting up GenesisMC to hook into it is quite simple, and doesnt require much work at all. + +GenesisMC starts the Calio parser during its init process, meaning you need to add it to your dependencies list inside your `paper-plugin.yml` file. This guide will go over how to create new PowerTypes, Conditions, Actions, and how to even replace/remove instances of them within Genesis. +What your depend list should look like: +```yaml +dependencies: + server: + GenesisMC: + load: AFTER + required: true +``` + +### WARNING: You must have GenesisMC load AFTER your plugin or else your PowerTypes and others will not be registered properly and Calio will not recognize your instances. + +## Creating a new PowerType + +The Power system in Genesis works closely to the Apoli PowerType system, where each PowerType instance is a representation of a Power json inside the datapack. For example: + +I have a power in ``data/dueris/powers/test.json`` with the `"type"` field as `"apoli:test"`, and a PowerType of the type `"apoli:test"`. Calio will create a new instance of the PowerType and register it using defined AccessorKeys(more details bellow in the `Calio` section). + +Lets start by creating a new class: +```java +public class ApoliExamplePower extends PowerType { + +} +``` + +In Calio/Apoli, a PowerType is an extension of the FactoryHolder system which contains methods to create a valid instance for Calio to create the object. To create a FactoryHolder inside Calio during parsing, it reads the FactoryData provided by the FactoryHolder, which is defined by the method ``registerComponents(FactoryData data)``. FactoryData is the definition of a Constructor for the FactoryHolder. The first instance added is the first arg, the second being the second arg, etc. It also provides the key for the `"type"` field. +With adding the constructor, it beecomes: +```java +public class ApoliExamplePower extends PowerType { + public ApoliExamplePower(String name, String description, boolean hidden, FactoryJsonObject condition, int loading_priority) { + super(name, description, hidden, condition, loading_priority); + } +} +``` +Adding the method to create the FactoryData: +```java +public class ApoliExamplePower extends PowerType { + public ApoliExamplePower(String name, String description, boolean hidden, FactoryJsonObject condition, int loading_priority) { + super(name, description, hidden, condition, loading_priority); + } + + // registerComponents method. We call the PowerType.registerComponents method first to define those args + // from the base instead of Copy/Pasting its registerComponents method and adding to it. + // By default, the PowerType class does not contain a Namespace, which is why ofNamespace needs to be added. + // The way this is made allows for creating easy extensions of any power without too much struggle. + public static FactoryData registerComponents(FactoryData data) { + return PowerType.registerComponents(data).ofNamespace(new NamespacedKey("example", "apoli")); + } +} +``` + +To Add your own fields to the power json, its as simple as adding the ``add`` method to the FactoryData building. The ``add`` method takes a FactoryDataDefiner, which is an Object that defines the 3 args needed for FactoryData building, or you can provide the 3 args and the FactoryData will create the instance for you. The method takes 3 params, a `String` key, a `Class` class type, which defines the type of class the arg will be, and a `T` default value. Gradle should throw a compile error if your class type provided and the default value do not match. The default value can be null. To add a required param, you can replace the default value with a `new RequiredInstance()`, and Calio will throw a ParseException if the value isnt provided. To add an optional param, its the same thing but with a `new OptionalInstance()`. Calio will provide null if not found. +```java +public class ApoliExamplePower extends PowerType { + private String welcomeMessage; + + public ApoliExamplePower(String name, String description, boolean hidden, FactoryJsonObject condition, int loading_priority, String welcomeMessage) { + super(name, description, hidden, condition, loading_priority); + } + + public static FactoryData registerComponents(FactoryData data) { + return PowerType.registerComponents(data).ofNamespace(new NamespacedKey("example", "apoli")) + /* | Field name | Class type | Default value | */ + .add("welcome_message", String.class, "Hello World!"); + } + + public String welcomeMessage() { + return this.welcomeMessage; + } +} +``` + +By default, a PowerType is an implementation of a Listener instance, so there is no need to add `implements org.bukkit.Listener` to your class. However, if you are creating an external plugin, you will need to register your Class as a Listener with Bukkit, as Calio doesnt do this automagically. If you are contributing, then there is no need because during registration of the Power, GenesisMC takes care of this. + +Now that we have created our PowerType, lets register it. Its as simple as adding calling this method: +```java +// Registers the PowerType in the Calio "type" registry +CraftCalio.INSTANCE.register(ApoliExamplePower.class/*replace with your class*/); +``` + +### Adding functionality to your PowerType +By default, PowerType provides Overridable methods that can be used to create your Power. The methods are as such: + +| Method Name | Description | +|-------------|--------------------------------------------------------------------------------------------| +| tick | Acts as the run() method in BukkitRunnables | +| tick(Player) | Ticks the PowerType on the Player that currently has the Power | +| tickAsync(Player) | Ticks the PowerType on the Player that currently has the Power on the AsyncScheduler | + +For this example, we are going to use `tick(Player)`: +```java +public class ApoliExamplePower extends PowerType { + private String welcomeMessage; + + public ApoliExamplePower(String name, String description, boolean hidden, FactoryJsonObject condition, int loading_priority, String welcomeMessage) { + super(name, description, hidden, condition, loading_priority); + } + + public static FactoryData registerComponents(FactoryData data) { + return PowerType.registerComponents(data).ofNamespace(new NamespacedKey("example", "apoli")) + .add("welcome_message", String.class, "Hello World!"); + } + + public String welcomeMessage() { + return this.welcomeMessage; + } + + @Override + public void tick(Player player) { + if (player.getGameMode().equals(GameMode.CREATIVE)) { + player.sendMessage(Component.text("Your in creative mode!")); + } + } +} +``` +Now lets add functionality for our `welcome_message` field. If our instance was created successfully, then the provided `welcomeMessage` value should be the one that was provided in the json, or our default value: +```java +public class ApoliExamplePower extends PowerType { + private String welcomeMessage; + + public ApoliExamplePower(String name, String description, boolean hidden, FactoryJsonObject condition, int loading_priority, String welcomeMessage) { + super(name, description, hidden, condition, loading_priority); + } + + public static FactoryData registerComponents(FactoryData data) { + return PowerType.registerComponents(data).ofNamespace(new NamespacedKey("example", "apoli")) + .add("welcome_message", String.class, "Hello World!"); + } + + public String welcomeMessage() { + return this.welcomeMessage; + } + + @Override + public void tick(Player player) { + if (player.getGameMode().equals(GameMode.CREATIVE)) { + player.sendMessage(Component.text("Your in creative mode!")); + } + } + + @EventHandler + public void onJoin(PlayerJoinEvent e) { + e.getPlayer().sendMessage(Component.text(welcomeMessage())); + } +} +``` +And thats about it! In this section of the tutorial we have learned how to create and register a new PowerType, and add functionality to our new power. + +## Conditions + +To create a new Condition, is a little bit weirder. The current Condition system wasnt really built with external plugins in mind, but its possible to hook into the Condition system with ease. +In this tutorial, we are going to add a new entity condition that checks if the entity is currently in spectator mode. + +To register a Condition, you must first go through the ConditionExecutor to access the conditions `register` method. Each Condition class has its respective ConditionFactory class. A ConditionFactory is a builder for creating, registering, and calling Conditions. Conditions in GenesisMC are defined by a NamepacedKey as the associated type, and a Predicate to define if the condition is true or not. Each Condition type category has its own ConditionFactory. +```java +ConditionExecutor.entityConditions.register(new EntityConditions.ConditionFactory()); +``` + +Now, we are going to add our `"type"` param, which defines the type associated in the json, like "origins:sprinting": +```java +ConditionExecutor.entityConditions.register(new EntityConditions.ConditionFactory(new NamespacedKey("dueris", "in_spectator"))); +``` + +The 2nd and last arg is the Predicate. In the EntityConditon ConditionFactory, it is a BiPredicate, condition object and the entity. Each ConditionFactory has a FactoryJsonObject as its condition provider, which is a set of methods for reading and parsing data within the JsonObject provided. For more info on FactoryJsonObjects, please see the Calio docs. +```java +ConditionExecutor.entityConditions.register(new EntityConditions.ConditionFactory(new NamespacedKey("dueris", "in_spectator"), (condition, entity) -> { + if (entity instanceof Player player) { + return player.getGameMode().equals(GameMode.SPECTATOR); + } + return false; +})); +``` +Now we have a fully functioning condition added to the plugin! GenesisMC should automagically setup the rest of the registration to allow any origin to test the condition. + +## Actions + +Creating a new Action is quite similar to creating a new Condition, but with ActionFactories instead. In this tutorial, we are going to create a new Action called "dueris:welcome", which will send a welcome message to a Player. The ActionFactory system is quite literally the same thing as the Condition system, but with different registry points and we use BiFunctions instead of BiPredicates, since we dont need a return value for the action. +```java +Actions.entityActions.register(new EntityActions.ActionFactory()); +``` + +Now we define our `"type"` param, like before: +```java +Actions.entityActions.register(new EntityActions.ActionFactory(new NamespacedKey("dueris", "welcome"))); +``` + +And lets add our functionality to our Action: +```java +Actions.entityActions.register(new EntityActions.ActionFactory(new NamespacedKey("dueris", "welcome"), (action, entity) -> { + if (entity instanceof Player player) { + // We send the welcome message with a provided "message" param inside the Action. + player.sendMessage(Component.text(action.getString("message"))); + } +})); +``` + +And thats it! Almost the exact same thing as Condition registration, and the same process in the end aswell. + +## PowerHolderComponent + +The PowerHolderComponent class is the main utility class for accessing information about Powers. It holds and manages the switching of origins, adding and removal of powers, and a few misc things related to the PersistentDataContainer. Realistically, you only need to know a few things, how to get the powers of an entity, how to apply and remove powers, and setting the origin of the entity. + +### Retrieving the Powers of the Entity + +Lets start with getting any and all Powers of the entity. The method PowerHolderComponent.getPowers(Entity) returns all the Powers on all layers of the Entity, however if it is not a Player instance, it will return an empty list due to Entities not being able to hold Powers(yet): +```java +Entity entity = /*your entity instance*/; +List powers = PowerHolderComponent.getPowers(entity); +``` + +Now lets get all the Powers of a specific type. There are 2 ways of retrieving this information. +1, is by providing the String of the type key, like "apoli:multiple" or "apoli:phasing": +```java +Entity entity = /*your entity instance*/; +List phasingPowers = PowerHolderComponent.getPowers(entity, "apoli:phasing"); // Returns all the powers of the phasing powertype +``` +2, is by providing the PowerType *class* inside the source. This way allows GenesisMC to return that PowerType instance instead of the raw PowerType aswell, and is a lot faster than the 1st way. Lets do the same example as before, but with the other method. +```java +Entity entity = /*your entity instance*/; +List phasingPowers = PowerHolderComponent.getPowers(entity, Phasing.class); +``` + +Now we are going to get a *specific* Power from its *tag* instance now. A PowerType tag is the NamespacedKey assigned to the Power upon registration, and works the same way as the normal Minecraft registration. +```java +Entity entity = /*your entity instance*/; +PowerType phasingPower = PowerHolderComponent.getPower(entity, "origins:phasing"); +``` + +### Applying and Removing Powers + +Now lets apply a Power. To simplify the process, there is a different class that does this for you called the `PowerUtils` class. This class contains 2 methods, `grantPower` and `removePower`. Each method has the same args: +``` +(Nullable) CommandSender - allows for sending the return message from the `/power` command. If null, it wont send. +PowerType - the Power to grant or remove +Player - the Player to act upon +boolean - suppresses the return message from the CommandSender and the debug statement printed in console if true. +``` + +### Checking if a Player has a Power + +Checking if an Entity has a Power is similar to retrieving them. We have 2 methods for this, using the PowerType class, and the String tag. +Lets do it with a provided PowerType arg: +```java +Entity entity = /*your entity instance*/; +if (PowerHolderComponent.hasPowerType(entity, Phasing.class)) { + entity.sendMessage(Component.text("You have a phasing power!")); +} +``` +When using the one with a provided String, it takes a Power *tag*, not a Power *type*: +```java +Entity entity = /*your entity instance*/; +if (PowerHolderComponent.hasPower(entity, "origins:phasing")) { + entity.sendMessage(Component.text("You have the phantom phasing power!")); +} +``` + +### Setting and Getting the Origin of a Player + +To set the Origin of a Player, you need to get the Origin object, and Layer object. There are a few ways of getting a Layer or Origin, the easiest being in the `CraftApoli` class, which serves as a core utility class for the CraftApoli system. In this example, we will use the methods `getOriginFromTag` - returns the origin matching the tag, null if not found and `getLayersFromRegistry` - returns all the layers in the registrar. + +Setting an origin is quite simple, and requires an Origin and Layer to set it: +```java +Player player = /*your player instance*/; +/** + * Sets the origin on the default layer provided by Origins/GenesisMC + */ +PowerHolderComponent.setOrigin(player, CraftApoli.getOriginFromTag("origins:elytrian"), CraftApoli.getLayerFromTag("origins:origin")); + +/** + * Sets the origin on ALL layers in the GenesisMC registrar + */ +for (Layer layer : CraftApoli.getLayersFromRegistry()) { + PowerHolderComponent.setOrigin(player, CraftApoli.getOriginFromTag("origins:elytrian"), layer); +} +``` + +To get the Origin on a Player, there are a few ways. In GenesisMC, each Layer for the player has an assigned Origin to it in a Map inside the PowerHolderComponent. To get a specific layer, you can provide a Layer argument to the `getOrigin` method and return that specific origin. If the Layer isnt specified, it will return the full Layer -> Origin Map. +```java +Player player = /*your player instance*/; +/** + * Returns the Layer -> Origin Map. NotNull + */ +Map layerToOriginMap = PowerHolderComponent.getOrigin(player); + +/** + * Returns the Origin found on the origins:origin Layer. Null if not found. + */ +Origin originsOrigin = PowerHolderComponent.getOrigin(player, CraftApoli.getLayerFromTag("origins:origin")); +``` + +And thats it! That should cover everything important that you need to know for the GenesisMC CraftApoli system. Ping @dueris in the discord server if you have any questions regarding the API or specific functionalities of the plugin. \ No newline at end of file diff --git a/calio/src/main/java/me/dueris/calio/CraftCalio.java b/calio/src/main/java/me/dueris/calio/CraftCalio.java index 9edc09042..854357a32 100644 --- a/calio/src/main/java/me/dueris/calio/CraftCalio.java +++ b/calio/src/main/java/me/dueris/calio/CraftCalio.java @@ -18,7 +18,6 @@ import org.bukkit.NamespacedKey; import java.io.*; -import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.nio.file.Path; import java.util.*; diff --git a/origins/src/main/java/me/dueris/genesismc/Bootstrap.java b/origins/src/main/java/me/dueris/genesismc/Bootstrap.java index 142113698..69dc7cc03 100644 --- a/origins/src/main/java/me/dueris/genesismc/Bootstrap.java +++ b/origins/src/main/java/me/dueris/genesismc/Bootstrap.java @@ -2,8 +2,31 @@ import io.papermc.paper.plugin.bootstrap.BootstrapContext; import io.papermc.paper.plugin.bootstrap.PluginBootstrap; +import it.unimi.dsi.fastutil.Pair; +import me.dueris.calio.CraftCalio; +import me.dueris.calio.data.JsonObjectRemapper; +import me.dueris.calio.registry.Registrar; +import me.dueris.calio.registry.impl.CalioRegistry; +import me.dueris.genesismc.factory.actions.types.BiEntityActions; +import me.dueris.genesismc.factory.actions.types.BlockActions; +import me.dueris.genesismc.factory.actions.types.EntityActions; +import me.dueris.genesismc.factory.actions.types.ItemActions; +import me.dueris.genesismc.factory.conditions.types.BiEntityConditions; +import me.dueris.genesismc.factory.conditions.types.BiomeConditions; +import me.dueris.genesismc.factory.conditions.types.BlockConditions; +import me.dueris.genesismc.factory.conditions.types.DamageConditions; +import me.dueris.genesismc.factory.conditions.types.EntityConditions; +import me.dueris.genesismc.factory.conditions.types.FluidConditions; +import me.dueris.genesismc.factory.conditions.types.ItemConditions; +import me.dueris.genesismc.factory.powers.holder.PowerType; +import me.dueris.genesismc.registry.Registries; import me.dueris.genesismc.registry.nms.OriginLootCondition; import me.dueris.genesismc.registry.nms.PowerLootCondition; +import me.dueris.genesismc.registry.registries.DatapackRepository; +import me.dueris.genesismc.registry.registries.Layer; +import me.dueris.genesismc.registry.registries.Origin; +import me.dueris.genesismc.screen.ChoosingPage; +import me.dueris.genesismc.util.TextureLocation; import me.dueris.genesismc.util.Util; import net.minecraft.core.Registry; import net.minecraft.core.registries.BuiltInRegistries; @@ -29,6 +52,7 @@ // TODO: WaterProtection Enchantment - 1.21 public class Bootstrap implements PluginBootstrap { public static ArrayList oldDV = new ArrayList<>(); + private CalioRegistry registry; static { oldDV.add("OriginsGenesis"); @@ -144,6 +168,47 @@ public void bootstrap(@NotNull BootstrapContext context) { } Registry.register(BuiltInRegistries.LOOT_CONDITION_TYPE, new ResourceLocation("apoli", "power"), PowerLootCondition.TYPE); Registry.register(BuiltInRegistries.LOOT_CONDITION_TYPE, new ResourceLocation("origins", "origin"), OriginLootCondition.TYPE); + + JsonObjectRemapper.typeMappings.add(new Pair() { + @Override + public String left() { + return "origins"; + } + + @Override + public String right() { + return "apoli"; + } + }); + // Our version of restricted_armor allows handling of both. + JsonObjectRemapper.typeAlias.put("apoli:conditioned_restrict_armor", "apoli:restrict_armor"); + JsonObjectRemapper.typeAlias.put("apugli:edible_item", "apoli:edible_item"); + JsonObjectRemapper.typeAlias.put("apoli:modify_attribute", "apoli:conditioned_attribute"); + JsonObjectRemapper.typeAlias.put("apoli:add_to_set", "apoli:add_to_entity_set"); + JsonObjectRemapper.typeAlias.put("apoli:remove_from_set", "apoli:remove_from_entity_set"); + JsonObjectRemapper.typeAlias.put("apoli:action_on_set", "apoli:action_on_entity_set"); + JsonObjectRemapper.typeAlias.put("apoli:in_set", "apoli:in_entity_set"); + JsonObjectRemapper.typeAlias.put("apoli:set_size", "apoli:entity_set_size"); + + this.registry = CalioRegistry.INSTANCE; + // Create new registry instances + this.registry.create(Registries.ORIGIN, new Registrar(Origin.class)); + this.registry.create(Registries.LAYER, new Registrar(Layer.class)); + this.registry.create(Registries.CRAFT_POWER, new Registrar(PowerType.class)); + this.registry.create(Registries.FLUID_CONDITION, new Registrar(FluidConditions.ConditionFactory.class)); + this.registry.create(Registries.ENTITY_CONDITION, new Registrar(EntityConditions.ConditionFactory.class)); + this.registry.create(Registries.BIOME_CONDITION, new Registrar(BiomeConditions.ConditionFactory.class)); + this.registry.create(Registries.BIENTITY_CONDITION, new Registrar(BiEntityConditions.ConditionFactory.class)); + this.registry.create(Registries.BLOCK_CONDITION, new Registrar(BlockConditions.ConditionFactory.class)); + this.registry.create(Registries.ITEM_CONDITION, new Registrar(ItemConditions.ConditionFactory.class)); + this.registry.create(Registries.DAMAGE_CONDITION, new Registrar(DamageConditions.ConditionFactory.class)); + this.registry.create(Registries.ENTITY_ACTION, new Registrar(EntityActions.ActionFactory.class)); + this.registry.create(Registries.ITEM_ACTION, new Registrar(ItemActions.ActionFactory.class)); + this.registry.create(Registries.BLOCK_ACTION, new Registrar(BlockActions.ActionFactory.class)); + this.registry.create(Registries.BIENTITY_ACTION, new Registrar(BiEntityActions.ActionFactory.class)); + this.registry.create(Registries.TEXTURE_LOCATION, new Registrar(TextureLocation.class)); + this.registry.create(Registries.PACK_SOURCE, new Registrar(DatapackRepository.class)); + this.registry.create(Registries.CHOOSING_PAGE, new Registrar(ChoosingPage.class)); } public String parseDatapackPath() { diff --git a/origins/src/main/java/me/dueris/genesismc/GenesisMC.java b/origins/src/main/java/me/dueris/genesismc/GenesisMC.java index 4a62eefa6..84d9bac23 100644 --- a/origins/src/main/java/me/dueris/genesismc/GenesisMC.java +++ b/origins/src/main/java/me/dueris/genesismc/GenesisMC.java @@ -179,26 +179,6 @@ public void onEnable() { } debug(Component.text("* (-debugOrigins={true}) || BEGINNING DEBUG {")); - JsonObjectRemapper.typeMappings.add(new Pair() { - @Override - public String left() { - return "origins"; - } - - @Override - public String right() { - return "apoli"; - } - }); - // Our version of restricted_armor allows handling of both. - JsonObjectRemapper.typeAlias.put("apoli:conditioned_restrict_armor", "apoli:restrict_armor"); - JsonObjectRemapper.typeAlias.put("apugli:edible_item", "apoli:edible_item"); - JsonObjectRemapper.typeAlias.put("apoli:modify_attribute", "apoli:conditioned_attribute"); - JsonObjectRemapper.typeAlias.put("apoli:add_to_set", "apoli:add_to_entity_set"); - JsonObjectRemapper.typeAlias.put("apoli:remove_from_set", "apoli:remove_from_entity_set"); - JsonObjectRemapper.typeAlias.put("apoli:action_on_set", "apoli:action_on_entity_set"); - JsonObjectRemapper.typeAlias.put("apoli:in_set", "apoli:in_entity_set"); - JsonObjectRemapper.typeAlias.put("apoli:set_size", "apoli:entity_set_size"); ThreadFactory threadFactory = new NamedTickThreadFactory("OriginParsingPool"); placeholderapi = Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null; if (placeholderapi) new PlaceHolderAPI(this).register(); @@ -210,26 +190,6 @@ public String right() { OriginDataContainer.loadData(); conditionExecutor = new ConditionExecutor(); - this.registry = CalioRegistry.INSTANCE; - // Create new registry instances - this.registry.create(Registries.ORIGIN, new Registrar(Origin.class)); - this.registry.create(Registries.LAYER, new Registrar(Layer.class)); - this.registry.create(Registries.CRAFT_POWER, new Registrar(PowerType.class)); - this.registry.create(Registries.FLUID_CONDITION, new Registrar(FluidConditions.ConditionFactory.class)); - this.registry.create(Registries.ENTITY_CONDITION, new Registrar(EntityConditions.ConditionFactory.class)); - this.registry.create(Registries.BIOME_CONDITION, new Registrar(BiomeConditions.ConditionFactory.class)); - this.registry.create(Registries.BIENTITY_CONDITION, new Registrar(BiEntityConditions.ConditionFactory.class)); - this.registry.create(Registries.BLOCK_CONDITION, new Registrar(BlockConditions.ConditionFactory.class)); - this.registry.create(Registries.ITEM_CONDITION, new Registrar(ItemConditions.ConditionFactory.class)); - this.registry.create(Registries.DAMAGE_CONDITION, new Registrar(DamageConditions.ConditionFactory.class)); - this.registry.create(Registries.ENTITY_ACTION, new Registrar(EntityActions.ActionFactory.class)); - this.registry.create(Registries.ITEM_ACTION, new Registrar(ItemActions.ActionFactory.class)); - this.registry.create(Registries.BLOCK_ACTION, new Registrar(BlockActions.ActionFactory.class)); - this.registry.create(Registries.BIENTITY_ACTION, new Registrar(BiEntityActions.ActionFactory.class)); - this.registry.create(Registries.TEXTURE_LOCATION, new Registrar(TextureLocation.class)); - this.registry.create(Registries.PACK_SOURCE, new Registrar(DatapackRepository.class)); - this.registry.create(Registries.CHOOSING_PAGE, new Registrar(ChoosingPage.class)); - int avalibleJVMThreads = Runtime.getRuntime().availableProcessors() * 2; int dynamic_thread_count = avalibleJVMThreads < 4 ? avalibleJVMThreads : Math.min(avalibleJVMThreads, OriginConfiguration.getConfiguration().getInt("max-loader-threads")); loaderThreadPool = Executors.newFixedThreadPool(dynamic_thread_count, threadFactory); diff --git a/origins/src/main/java/me/dueris/genesismc/factory/actions/Actions.java b/origins/src/main/java/me/dueris/genesismc/factory/actions/Actions.java index a74142f56..c057707f7 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/actions/Actions.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/actions/Actions.java @@ -30,6 +30,10 @@ import java.util.function.Consumer; public class Actions { + public static BiEntityActions bientityActions = new BiEntityActions(); + public static BlockActions blockActions = new BlockActions(); + public static EntityActions entityActions = new EntityActions(); + public static ItemActions itemActions = new ItemActions(); public static HashMap resourceChangeTimeout = new HashMap<>(); diff --git a/origins/src/main/java/me/dueris/genesismc/factory/actions/types/BiEntityActions.java b/origins/src/main/java/me/dueris/genesismc/factory/actions/types/BiEntityActions.java index 5a4adb8e9..f41670c7b 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/actions/types/BiEntityActions.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/actions/types/BiEntityActions.java @@ -94,7 +94,7 @@ public void register() { })); } - private void register(BiEntityActions.ActionFactory factory) { + public void register(BiEntityActions.ActionFactory factory) { GenesisMC.getPlugin().registry.retrieve(Registries.BIENTITY_ACTION).register(factory); } diff --git a/origins/src/main/java/me/dueris/genesismc/factory/actions/types/BlockActions.java b/origins/src/main/java/me/dueris/genesismc/factory/actions/types/BlockActions.java index d696c76d0..feae0fbf8 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/actions/types/BlockActions.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/actions/types/BlockActions.java @@ -221,7 +221,7 @@ public void run() { })); } - private void register(BlockActions.ActionFactory factory) { + public void register(BlockActions.ActionFactory factory) { GenesisMC.getPlugin().registry.retrieve(Registries.BLOCK_ACTION).register(factory); } diff --git a/origins/src/main/java/me/dueris/genesismc/factory/actions/types/EntityActions.java b/origins/src/main/java/me/dueris/genesismc/factory/actions/types/EntityActions.java index c0c72fcc2..58e1a1e2d 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/actions/types/EntityActions.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/actions/types/EntityActions.java @@ -581,7 +581,7 @@ public void run() { })); } - private void register(EntityActions.ActionFactory factory) { + public void register(EntityActions.ActionFactory factory) { GenesisMC.getPlugin().registry.retrieve(Registries.ENTITY_ACTION).register(factory); } diff --git a/origins/src/main/java/me/dueris/genesismc/factory/actions/types/ItemActions.java b/origins/src/main/java/me/dueris/genesismc/factory/actions/types/ItemActions.java index 97d356a12..27fe6af40 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/actions/types/ItemActions.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/actions/types/ItemActions.java @@ -54,7 +54,7 @@ public void register() { })); } - private void register(ItemActions.ActionFactory factory) { + public void register(ItemActions.ActionFactory factory) { GenesisMC.getPlugin().registry.retrieve(Registries.ITEM_ACTION).register(factory); } diff --git a/origins/src/main/java/me/dueris/genesismc/factory/conditions/ConditionExecutor.java b/origins/src/main/java/me/dueris/genesismc/factory/conditions/ConditionExecutor.java index 0e8a49464..54cd1544b 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/conditions/ConditionExecutor.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/conditions/ConditionExecutor.java @@ -27,22 +27,22 @@ import java.util.Random; public class ConditionExecutor { - public static BiEntityConditions biEntityCondition = new BiEntityConditions(); - public static BiomeConditions biomeCondition = new BiomeConditions(); - public static BlockConditions blockCondition = new BlockConditions(); - public static DamageConditions damageCondition = new DamageConditions(); - public static EntityConditions entityCondition = new EntityConditions(); - public static FluidConditions fluidCondition = new FluidConditions(); - public static ItemConditions itemCondition = new ItemConditions(); + public static BiEntityConditions biEntityConditions = new BiEntityConditions(); + public static BiomeConditions biomeConditions = new BiomeConditions(); + public static BlockConditions blockConditions = new BlockConditions(); + public static DamageConditions damageConditions = new DamageConditions(); + public static EntityConditions entityConditions = new EntityConditions(); + public static FluidConditions fluidConditions = new FluidConditions(); + public static ItemConditions itemConditions = new ItemConditions(); public static void registerAll() { - biEntityCondition.registerConditions(); - biomeCondition.registerConditions(); - blockCondition.registerConditions(); - damageCondition.registerConditions(); - entityCondition.registerConditions(); - fluidCondition.registerConditions(); - itemCondition.registerConditions(); + biEntityConditions.registerConditions(); + biomeConditions.registerConditions(); + blockConditions.registerConditions(); + damageConditions.registerConditions(); + entityConditions.registerConditions(); + fluidConditions.registerConditions(); + itemConditions.registerConditions(); ConditionTypes.ConditionFactory.addMetaConditions(); } diff --git a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/BiEntityConditions.java b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/BiEntityConditions.java index fa468c5c6..9cc6c8728 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/BiEntityConditions.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/BiEntityConditions.java @@ -129,7 +129,7 @@ public void registerConditions() { register(new ConditionFactory(GenesisMC.apoliIdentifier("equal"), (condition, pair) -> pair.first() == pair.second())); } - private void register(ConditionFactory factory) { + public void register(ConditionFactory factory) { GenesisMC.getPlugin().registry.retrieve(Registries.BIENTITY_CONDITION).register(factory); } diff --git a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/BiomeConditions.java b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/BiomeConditions.java index 5d6ab79c1..ed6f4bc04 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/BiomeConditions.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/BiomeConditions.java @@ -65,7 +65,7 @@ private net.minecraft.world.level.biome.Biome.Precipitation getPrecipitation(Fac } } - private void register(ConditionFactory factory) { + public void register(ConditionFactory factory) { GenesisMC.getPlugin().registry.retrieve(Registries.BIOME_CONDITION).register(factory); } diff --git a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/BlockConditions.java b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/BlockConditions.java index 247b02535..c31084789 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/BlockConditions.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/BlockConditions.java @@ -230,7 +230,7 @@ public void registerConditions() { register(new ConditionFactory(GenesisMC.apoliIdentifier("water_loggable"), (condition, block) -> block.getHandle().getBlockState(block.getPosition()).getBlock() instanceof LiquidBlockContainer)); } - private void register(ConditionFactory factory) { + public void register(ConditionFactory factory) { GenesisMC.getPlugin().registry.retrieve(Registries.BLOCK_CONDITION).register(factory); } diff --git a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/DamageConditions.java b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/DamageConditions.java index a99821753..59b955c0f 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/DamageConditions.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/DamageConditions.java @@ -75,7 +75,7 @@ public void registerConditions() { register(new ConditionFactory(GenesisMC.apoliIdentifier("unblockable"), (condition, event) -> GenesisMC.server.reloadableRegistries().get().registry(net.minecraft.core.registries.Registries.DAMAGE_TYPE).orElseThrow().wrapAsHolder(CraftDamageType.bukkitToMinecraft(event.getDamageSource().getDamageType())).is(DamageTypeTags.BYPASSES_SHIELD))); } - private void register(ConditionFactory factory) { + public void register(ConditionFactory factory) { GenesisMC.getPlugin().registry.retrieve(Registries.DAMAGE_CONDITION).register(factory); } diff --git a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/EntityConditions.java b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/EntityConditions.java index 54d55021f..af8d28869 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/EntityConditions.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/EntityConditions.java @@ -765,7 +765,7 @@ public void registerConditions() { register(new ConditionFactory(GenesisMC.apoliIdentifier("in_thunderstorm"), (condition, entity) -> entity.isInRain() && entity.getWorld().isThundering())); } - private void register(EntityConditions.ConditionFactory factory) { + public void register(EntityConditions.ConditionFactory factory) { GenesisMC.getPlugin().registry.retrieve(Registries.ENTITY_CONDITION).register(factory); } diff --git a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/FluidConditions.java b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/FluidConditions.java index 7d7f1e2f7..04b0c1131 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/FluidConditions.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/FluidConditions.java @@ -23,7 +23,7 @@ public void registerConditions() { register(new ConditionFactory(GenesisMC.apoliIdentifier("fluid"), (condition, fluid) -> fluid.builtInRegistryHolder().key().location().equals(CraftNamespacedKey.toMinecraft(NamespacedKey.fromString(condition.getString("fluid")))))); } - private void register(ConditionFactory factory) { + public void register(ConditionFactory factory) { GenesisMC.getPlugin().registry.retrieve(Registries.FLUID_CONDITION).register(factory); } diff --git a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/ItemConditions.java b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/ItemConditions.java index 804ee7a3e..11c3ed3a6 100644 --- a/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/ItemConditions.java +++ b/origins/src/main/java/me/dueris/genesismc/factory/conditions/types/ItemConditions.java @@ -158,7 +158,7 @@ public void registerConditions() { })); } - private void register(ConditionFactory factory) { + public void register(ConditionFactory factory) { GenesisMC.getPlugin().registry.retrieve(Registries.ITEM_CONDITION).register(factory); } diff --git a/origins/src/main/java/me/dueris/genesismc/registry/Registries.java b/origins/src/main/java/me/dueris/genesismc/registry/Registries.java index eb78f24fd..ff87424b8 100644 --- a/origins/src/main/java/me/dueris/genesismc/registry/Registries.java +++ b/origins/src/main/java/me/dueris/genesismc/registry/Registries.java @@ -1,5 +1,7 @@ package me.dueris.genesismc.registry; +import org.bukkit.NamespacedKey; + import me.dueris.calio.registry.RegistryKey; import me.dueris.genesismc.GenesisMC; import me.dueris.genesismc.factory.actions.types.BiEntityActions; @@ -15,25 +17,36 @@ import me.dueris.genesismc.util.TextureLocation; public class Registries { - public static final RegistryKey ORIGIN = new RegistryKey<>(Origin.class, GenesisMC.apoliIdentifier("origin")); - public static final RegistryKey LAYER = new RegistryKey<>(Layer.class, GenesisMC.apoliIdentifier("layer")); - public static final RegistryKey CRAFT_POWER = new RegistryKey<>(PowerType.class, GenesisMC.apoliIdentifier("craft_power")); - - public static final RegistryKey FLUID_CONDITION = new RegistryKey<>(FluidConditions.ConditionFactory.class, GenesisMC.apoliIdentifier("fluid_condition")); - public static final RegistryKey ITEM_CONDITION = new RegistryKey<>(ItemConditions.ConditionFactory.class, GenesisMC.apoliIdentifier("item_condition")); - public static final RegistryKey ENTITY_CONDITION = new RegistryKey<>(EntityConditions.ConditionFactory.class, GenesisMC.apoliIdentifier("entity_condition")); - public static final RegistryKey DAMAGE_CONDITION = new RegistryKey<>(DamageConditions.ConditionFactory.class, GenesisMC.apoliIdentifier("damage_condition")); - public static final RegistryKey BIENTITY_CONDITION = new RegistryKey<>(BiEntityConditions.ConditionFactory.class, GenesisMC.apoliIdentifier("bientity_condition")); - public static final RegistryKey BLOCK_CONDITION = new RegistryKey<>(BlockConditions.ConditionFactory.class, GenesisMC.apoliIdentifier("block_condition")); - public static final RegistryKey BIOME_CONDITION = new RegistryKey<>(BiomeConditions.ConditionFactory.class, GenesisMC.apoliIdentifier("biome_condition")); - - public static final RegistryKey ITEM_ACTION = new RegistryKey<>(ItemActions.ActionFactory.class, GenesisMC.apoliIdentifier("item_action")); - public static final RegistryKey ENTITY_ACTION = new RegistryKey<>(EntityActions.ActionFactory.class, GenesisMC.apoliIdentifier("entity_action")); - public static final RegistryKey BIENTITY_ACTION = new RegistryKey<>(BiEntityActions.ActionFactory.class, GenesisMC.apoliIdentifier("bientity_action")); - public static final RegistryKey BLOCK_ACTION = new RegistryKey<>(BlockActions.ActionFactory.class, GenesisMC.apoliIdentifier("block_action")); - - public static final RegistryKey TEXTURE_LOCATION = new RegistryKey<>(TextureLocation.class, GenesisMC.apoliIdentifier("texture_location")); - public static final RegistryKey PACK_SOURCE = new RegistryKey<>(DatapackRepository.class, GenesisMC.apoliIdentifier("pack_source")); - public static final RegistryKey CHOOSING_PAGE = new RegistryKey<>(ChoosingPage.class, GenesisMC.originIdentifier("choosing_page")); + public static final RegistryKey ORIGIN = new RegistryKey<>(Origin.class, apoliIdentifier("origin")); + public static final RegistryKey LAYER = new RegistryKey<>(Layer.class, apoliIdentifier("layer")); + public static final RegistryKey CRAFT_POWER = new RegistryKey<>(PowerType.class, apoliIdentifier("craft_power")); + + public static final RegistryKey FLUID_CONDITION = new RegistryKey<>(FluidConditions.ConditionFactory.class, apoliIdentifier("fluid_condition")); + public static final RegistryKey ITEM_CONDITION = new RegistryKey<>(ItemConditions.ConditionFactory.class, apoliIdentifier("item_condition")); + public static final RegistryKey ENTITY_CONDITION = new RegistryKey<>(EntityConditions.ConditionFactory.class, apoliIdentifier("entity_condition")); + public static final RegistryKey DAMAGE_CONDITION = new RegistryKey<>(DamageConditions.ConditionFactory.class, apoliIdentifier("damage_condition")); + public static final RegistryKey BIENTITY_CONDITION = new RegistryKey<>(BiEntityConditions.ConditionFactory.class, apoliIdentifier("bientity_condition")); + public static final RegistryKey BLOCK_CONDITION = new RegistryKey<>(BlockConditions.ConditionFactory.class, apoliIdentifier("block_condition")); + public static final RegistryKey BIOME_CONDITION = new RegistryKey<>(BiomeConditions.ConditionFactory.class, apoliIdentifier("biome_condition")); + + public static final RegistryKey ITEM_ACTION = new RegistryKey<>(ItemActions.ActionFactory.class, apoliIdentifier("item_action")); + public static final RegistryKey ENTITY_ACTION = new RegistryKey<>(EntityActions.ActionFactory.class, apoliIdentifier("entity_action")); + public static final RegistryKey BIENTITY_ACTION = new RegistryKey<>(BiEntityActions.ActionFactory.class, apoliIdentifier("bientity_action")); + public static final RegistryKey BLOCK_ACTION = new RegistryKey<>(BlockActions.ActionFactory.class, apoliIdentifier("block_action")); + + public static final RegistryKey TEXTURE_LOCATION = new RegistryKey<>(TextureLocation.class, apoliIdentifier("texture_location")); + public static final RegistryKey PACK_SOURCE = new RegistryKey<>(DatapackRepository.class, apoliIdentifier("pack_source")); + public static final RegistryKey CHOOSING_PAGE = new RegistryKey<>(ChoosingPage.class, originIdentifier("choosing_page")); + + public static NamespacedKey identifier(String path) { + return new NamespacedKey("genesismc", path); + } + + public static NamespacedKey originIdentifier(String path) { + return new NamespacedKey("origins", path); + } + public static NamespacedKey apoliIdentifier(String path) { + return new NamespacedKey("apoli", path); + } } \ No newline at end of file diff --git a/origins/src/main/java/me/dueris/genesismc/util/TextureLocation.java b/origins/src/main/java/me/dueris/genesismc/util/TextureLocation.java index 87c0a9e7c..e33ef0616 100644 --- a/origins/src/main/java/me/dueris/genesismc/util/TextureLocation.java +++ b/origins/src/main/java/me/dueris/genesismc/util/TextureLocation.java @@ -94,8 +94,8 @@ public static void registerAll() throws IOException { index++; } - } catch (IOException e) { - e.printStackTrace(); + } catch (Throwable e) { + if (e instanceof IOException) e.printStackTrace(); } } } diff --git a/origins/src/main/java/me/dueris/genesismc/util/entity/PowerUtils.java b/origins/src/main/java/me/dueris/genesismc/util/entity/PowerUtils.java index 8610d54b9..7ca37062e 100644 --- a/origins/src/main/java/me/dueris/genesismc/util/entity/PowerUtils.java +++ b/origins/src/main/java/me/dueris/genesismc/util/entity/PowerUtils.java @@ -33,7 +33,6 @@ public static void removePower(CommandSender executor, PowerType poweR, Player p } } - // New Rewrite public static void grantPower(CommandSender executor, PowerType power, Player p, Layer layer, boolean suppress) throws InstantiationException, IllegalAccessException { if (!PowerHolderComponent.playerPowerMapping.get(p).get(layer).contains(power)) { PowerHolderComponent.playerPowerMapping.get(p).get(layer).add(power);