Fixed 1.19.4 support

Yet another economyshopgui fix

build.gradle.kts

@@ -26,6 +26,7 @@ dependencies {
     implementation(project(path = ":eco-core:core-nms:v1_18_R2", configuration = "reobf"))
     implementation(project(path = ":eco-core:core-nms:v1_19_R1", configuration = "reobf"))
     implementation(project(path = ":eco-core:core-nms:v1_19_R2", configuration = "reobf"))
+    implementation(project(path = ":eco-core:core-nms:v1_19_R3", configuration = "reobf"))
 }
 
 allprojects {

eco-api/src/main/java/com/willfp/eco/core/EcoPlugin.java

@@ -713,7 +713,9 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
      *
      * @return A list of all listeners.
      */
-    protected abstract List<Listener> loadListeners();
+    protected List<Listener> loadListeners() {
+        return new ArrayList<>();
+    }
 
     /**
      * Useful for custom LangYml implementations.
@@ -862,6 +864,7 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
      * @param pluginName The name.
      * @return The plugin.
      */
+    @Nullable
     public static EcoPlugin getPlugin(@NotNull final String pluginName) {
         return Eco.get().getPluginByName(pluginName);
     }
@@ -871,6 +874,7 @@ public abstract class EcoPlugin extends JavaPlugin implements PluginLike {
      *
      * @return The set of names.
      */
+    @NotNull
     public static Set<String> getPluginNames() {
         return new HashSet<>(Eco.get().getLoadedPlugins());
     }

eco-api/src/main/java/com/willfp/eco/core/config/ExtendableConfig.java

@@ -16,6 +16,8 @@ import org.jetbrains.annotations.NotNull;
  */
 public abstract class ExtendableConfig extends LoadableConfigWrapper {
     /**
+     * Create a new extendable config.
+     *
      * @param configName       The name of the config
      * @param removeUnused     Whether keys not present in the default config should be removed on update.
      * @param plugin           The plugin.

eco-api/src/main/java/com/willfp/eco/core/config/TransientConfig.java

@@ -26,6 +26,8 @@ import java.util.Map;
 @Deprecated(since = "6.44.0", forRemoval = true)
 public class TransientConfig extends ConfigWrapper<Config> {
     /**
+     * Create new transient config from bukkit config.
+     *
      * @param config The ConfigurationSection handle.
      */
     public TransientConfig(@NotNull final ConfigurationSection config) {
@@ -42,6 +44,8 @@ public class TransientConfig extends ConfigWrapper<Config> {
     }
 
     /**
+     * Create a transient config from an input stream.
+     *
      * @param stream The InputStream.
      */
     public TransientConfig(@Nullable final InputStream stream) {
@@ -51,6 +55,8 @@ public class TransientConfig extends ConfigWrapper<Config> {
     }
 
     /**
+     * Load a file to a config.
+     *
      * @param file The File.
      * @deprecated Specify the config type to prevent bugs.
      */
@@ -60,6 +66,8 @@ public class TransientConfig extends ConfigWrapper<Config> {
     }
 
     /**
+     * Load a file to a config.
+     *
      * @param file The file.
      * @param type The config type to try read from.
      */
@@ -97,6 +105,8 @@ public class TransientConfig extends ConfigWrapper<Config> {
     }
 
     /**
+     * Load a config from a string.
+     *
      * @param contents The contents of the config.
      * @param type     The config type.
      */

eco-api/src/main/java/com/willfp/eco/core/entities/ai/CustomGoal.java

@@ -20,6 +20,13 @@ public abstract class CustomGoal<T extends Mob> implements EntityGoal<T>, Target
      */
     private final Set<GoalFlag> flags = EnumSet.noneOf(GoalFlag.class);
 
+    /**
+     * Create a new custom goal.
+     */
+    protected CustomGoal() {
+
+    }
+
     /**
      * Initialize the goal with a mob.
      * <p>

eco-api/src/main/java/com/willfp/eco/core/entities/ai/entity/EntityGoalTempt.java

@@ -28,6 +28,8 @@ public record EntityGoalTempt(
         boolean canBeScared
 ) implements EntityGoal<Mob> {
     /**
+     * Create a new entity goal.
+     *
      * @param speed       The speed at which the entity follows the item.
      * @param item        The item that the entity will be attracted by.
      * @param canBeScared If the entity can be scared and lose track of the item.

eco-api/src/main/java/com/willfp/eco/core/entities/ai/target/TargetGoalNearestAttackable.java

@@ -30,6 +30,8 @@ public record TargetGoalNearestAttackable(
         @NotNull Predicate<LivingEntity> targetFilter
 ) implements TargetGoal<Raider> {
     /**
+     * Create a new target goal.
+     *
      * @param target           The type of entities to attack.
      * @param checkVisibility  If visibility should be checked.
      * @param checkCanNavigate If navigation should be checked.

eco-api/src/main/java/com/willfp/eco/core/entities/ai/target/TargetGoalNearestAttackableWitch.java

@@ -30,6 +30,8 @@ public record TargetGoalNearestAttackableWitch(
         @NotNull Predicate<LivingEntity> targetFilter
 ) implements TargetGoal<Raider> {
     /**
+     * Create a new target goal.
+     *
      * @param target           The type of entities to attack.
      * @param checkVisibility  If visibility should be checked.
      * @param checkCanNavigate If navigation should be checked.

eco-api/src/main/java/com/willfp/eco/core/entities/ai/target/TargetGoalNearestHealableRaider.java

@@ -26,6 +26,8 @@ public record TargetGoalNearestHealableRaider(
         @NotNull Predicate<LivingEntity> targetFilter
 ) implements TargetGoal<Raider> {
     /**
+     * Create a new target goal.
+     *
      * @param target          The target.
      * @param checkVisibility If visibility should be checked.
      */

eco-api/src/main/java/com/willfp/eco/core/entities/ai/target/TargetGoalNonTameRandom.java

@@ -26,6 +26,8 @@ public record TargetGoalNonTameRandom(
         @NotNull Predicate<LivingEntity> targetFilter
 ) implements TargetGoal<Tameable> {
     /**
+     * Create a new target goal.
+     *
      * @param target          The types of entities to heal.
      * @param checkVisibility If visibility should be checked.
      */

eco-api/src/main/java/com/willfp/eco/core/entities/args/EntityArgParseResult.java

@@ -7,6 +7,8 @@ import java.util.function.Consumer;
 import java.util.function.Predicate;
 
 /**
+ * The result of an arg parses.
+ *
  * @param test     The test for the entity.
  * @param modifier The modifier to apply to the entity.
  * @see EntityArgParser

eco-api/src/main/java/com/willfp/eco/core/integrations/placeholder/PlaceholderManager.java

@@ -276,6 +276,35 @@ public final class PlaceholderManager {
                                                @NotNull final Collection<AdditionalPlayer> additionalPlayers) {
         String processed = text;
 
+        /*
+
+        Why am I doing statics at the start, but player statics at the end?
+
+        Additional players let you use something like victim as a player to parse in relation to,
+        for example doing %victim_player_health%, which would parse the health of the victim.
+
+        However, something like libreforge will also inject %victim_max_health%, which is unrelated
+        to additional players, and instead holds a constant value. So, eco saw this, smartly thought
+        "ah, it's an additional player, let's parse it", and then tried to parse %max_health% with
+        relation to the victim, which resolved to zero. So, we have to parse statics and player statics
+        that might include a prefix first, then additional players, then player statics with the support
+        of additional players.
+
+        This was a massive headache and took so many reports before I clocked what was going on.
+
+        Oh well, at least it's fixed now.
+
+         */
+
+
+        for (InjectablePlaceholder injection : context.getPlaceholderInjections()) {
+            if (injection instanceof StaticPlaceholder placeholder) {
+                processed = processed.replace("%" + placeholder.getIdentifier() + "%", placeholder.getValue());
+            } else if (injection instanceof PlayerStaticPlaceholder placeholder && player != null) {
+                processed = processed.replace("%" + placeholder.getIdentifier() + "%", placeholder.getValue(player));
+            }
+        }
+
         // Prevent running 2 scans if there are no additional players.
         if (!additionalPlayers.isEmpty()) {
             List<String> found = findPlaceholdersIn(text);
@@ -301,15 +330,14 @@ public final class PlaceholderManager {
             processed = integration.translate(processed, player);
         }
 
+        // DON'T REMOVE THIS, IT'S NOT DUPLICATE CODE.
         for (InjectablePlaceholder injection : context.getPlaceholderInjections()) {
             // Do I know this is a bad way of doing this? Yes.
-            // I know it's deprecated, but it's fast.
-            if (injection instanceof StaticPlaceholder placeholder) {
-                processed = processed.replace("%" + placeholder.getIdentifier() + "%", placeholder.getValue());
-            } else if (injection instanceof PlayerStaticPlaceholder placeholder && player != null) {
+            if (injection instanceof PlayerStaticPlaceholder placeholder && player != null) {
                 processed = processed.replace("%" + placeholder.getIdentifier() + "%", placeholder.getValue(player));
             }
         }
+
         return processed;
     }
 

eco-api/src/main/java/com/willfp/eco/core/map/DefaultMap.java

@@ -0,0 +1,147 @@
+package com.willfp.eco.core.map;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A map with a default value.
+ *
+ * @param <K> The key type.
+ * @param <V> The value type.
+ */
+public class DefaultMap<K, V> implements Map<K, V> {
+    /**
+     * The map.
+     */
+    private final Map<K, V> map;
+
+    /**
+     * The default value.
+     */
+    private final V defaultValue;
+
+    /**
+     * Create a new default map.
+     *
+     * @param defaultValue The default value.
+     */
+    public DefaultMap(@NotNull final V defaultValue) {
+        this.map = new HashMap<>();
+        this.defaultValue = defaultValue;
+    }
+
+    /**
+     * Create a new default map.
+     *
+     * @param map          The map.
+     * @param defaultValue The default value.
+     */
+    public DefaultMap(@NotNull final Map<K, V> map, @NotNull final V defaultValue) {
+        this.map = map;
+        this.defaultValue = defaultValue;
+    }
+
+    @Override
+    @NotNull
+    @SuppressWarnings("unchecked")
+    public V get(@Nullable final Object key) {
+        if (key == null) {
+            return defaultValue;
+        }
+
+        if (map.get(key) == null) {
+            map.put((K) key, defaultValue);
+        }
+
+        return map.get(key);
+    }
+
+    @Override
+    public int size() {
+        return map.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return map.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(@Nullable final Object key) {
+        return map.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(@Nullable final Object value) {
+        return map.containsValue(value);
+    }
+
+    @Override
+    public V put(@NotNull final K key, @Nullable final V value) {
+        return map.put(key, value);
+    }
+
+    @Override
+    public V remove(@NotNull final Object key) {
+        return map.remove(key);
+    }
+
+    @Override
+    public void putAll(@NotNull final Map<? extends K, ? extends V> m) {
+        map.putAll(m);
+    }
+
+    @Override
+    public void clear() {
+        map.clear();
+    }
+
+    @NotNull
+    @Override
+    public Set<K> keySet() {
+        return map.keySet();
+    }
+
+    @NotNull
+    @Override
+    public Collection<V> values() {
+        return map.values();
+    }
+
+    @NotNull
+    @Override
+    public Set<Entry<K, V>> entrySet() {
+        return map.entrySet();
+    }
+
+    /**
+     * Create a new nested map.
+     *
+     * @param <K>  The key type.
+     * @param <K1> The nested key type.
+     * @param <V>  The value type.
+     * @return The nested map.
+     */
+    @NotNull
+    public static <K, K1, V> DefaultMap<K, Map<K1, V>> createNestedMap() {
+        return new DefaultMap<>(new HashMap<>());
+    }
+
+    /**
+     * Create a new nested list map.
+     *
+     * @param <K>  The key type.
+     * @param <K1> The nested key type.
+     * @param <V>  The value type.
+     * @return The nested list map.
+     */
+    @NotNull
+    public static <K, K1, V> DefaultMap<K, ListMap<K1, V>> createNestedListMap() {
+        return new DefaultMap<>(new ListMap<>());
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/map/ListMap.java

@@ -0,0 +1,33 @@
+package com.willfp.eco.core.map;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Maps keys to lists of values.
+ *
+ * @param <K> The key type.
+ * @param <V> The value type.
+ */
+public class ListMap<K, V> extends DefaultMap<K, List<V>> {
+    /**
+     * Create a new list map.
+     */
+    public ListMap() {
+        super(new ArrayList<>());
+    }
+
+    /**
+     * Append a value to a key.
+     *
+     * @param key   The key.
+     * @param value The value.
+     */
+    void append(@NotNull final K key,
+                @NotNull final V value) {
+        this.get(key).add(value);
+    }
+}
+

eco-api/src/main/java/com/willfp/eco/core/particle/impl/EmptyParticle.java

@@ -8,6 +8,13 @@ import org.jetbrains.annotations.NotNull;
  * Empty (invalid) particle that is spawned when an invalid key is provided.
  */
 public final class EmptyParticle implements SpawnableParticle {
+    /**
+     * Instantiate a new empty particle.
+     */
+    public EmptyParticle() {
+
+    }
+
     @Override
     public void spawn(@NotNull final Location location,
                       final int amount) {

eco-api/src/main/java/com/willfp/eco/core/proxy/ProxyConstants.java

@@ -22,7 +22,8 @@ public final class ProxyConstants {
             "v1_18_R1",
             "v1_18_R2",
             "v1_19_R1",
-            "v1_19_R2"
+            "v1_19_R2",
+            "v1_19_R3"
     );
 
     private ProxyConstants() {

eco-api/src/main/java/com/willfp/eco/core/registry/Registrable.java

@@ -0,0 +1,36 @@
+package com.willfp.eco.core.registry;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * An object that can be registered.
+ *
+ * @see Registry
+ */
+public interface Registrable {
+    /**
+     * Get the ID of the element.
+     *
+     * @return The ID.
+     */
+    @NotNull
+    String getID();
+
+    /**
+     * Called when the element is registered.
+     * <p>
+     * This is called after registration.
+     */
+    default void onRegister() {
+        // Do nothing by default.
+    }
+
+    /**
+     * Called when the element is removed.
+     * <p>
+     * This is called before removal.
+     */
+    default void onRemove() {
+        // Do nothing by default.
+    }
+}

eco-api/src/main/java/com/willfp/eco/core/registry/Registry.java

@@ -0,0 +1,111 @@
+package com.willfp.eco.core.registry;
+
+import org.apache.commons.lang.Validate;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+/**
+ * A registry for {@link Registrable}s.
+ *
+ * @param <T> The type of {@link Registrable}.
+ */
+public abstract class Registry<T extends Registrable> {
+    /**
+     * The ID pattern.
+     */
+    private static final Pattern ID_PATTERN = Pattern.compile("[a-z0-9_]{1,100}");
+
+    /**
+     * The registry.
+     */
+    private final Map<String, T> registry = new HashMap<>();
+
+    /**
+     * Instantiate a new registry.
+     */
+    protected Registry() {
+
+    }
+
+    /**
+     * Register a new element.
+     *
+     * @param element The element to register.
+     * @return The element.
+     */
+    @NotNull
+    public T register(@NotNull final T element) {
+        Validate.isTrue(ID_PATTERN.matcher(element.getID()).matches(), "ID must match pattern: " + ID_PATTERN.pattern());
+
+        registry.put(element.getID(), element);
+
+        element.onRegister();
+
+        return element;
+    }
+
+    /**
+     * Remove an element.
+     *
+     * @param element The element.
+     * @return The element.
+     */
+    public T remove(@NotNull final T element) {
+        element.onRemove();
+
+        registry.remove(element.getID());
+
+        return element;
+    }
+
+    /**
+     * Remove an element by ID.
+     *
+     * @param id The ID.
+     * @return The element.
+     */
+    @Nullable
+    public T remove(@NotNull final String id) {
+        T element = registry.get(id);
+
+        if (element != null) {
+            element.onRemove();
+        }
+
+        return registry.remove(id);
+    }
+
+    /**
+     * Get an element by ID.
+     *
+     * @param id The ID.
+     * @return The element, or null if not found.
+     */
+    @Nullable
+    public T get(@NotNull final String id) {
+        return registry.get(id);
+    }
+
+    /**
+     * Clear the registry.
+     */
+    public void clear() {
+        for (T value : registry.values()) {
+            remove(value);
+        }
+    }
+
+    /**
+     * Get all elements.
+     *
+     * @return All elements.
+     */
+    public Set<T> values() {
+        return Set.copyOf(registry.values());
+    }
+}

eco-api/src/main/kotlin/com/willfp/eco/core/map/DefaultMap.kt

@@ -0,0 +1,48 @@
+@file:JvmName("DefaultMapExtensions")
+
+package com.willfp.eco.core.map
+
+/**
+ * Required to avoid type ambiguity.
+ *
+ * @see ListMap
+ */
+@Suppress("RedundantOverride")
+class MutableListMap<K : Any, V : Any> : ListMap<K, V>() {
+    /**
+     * Override with enforced MutableList type.
+     */
+    override fun get(key: K?): MutableList<V> =
+        super.get(key)
+
+    /**
+     * Override with enforced MutableList type.
+     */
+    override fun getOrDefault(key: K, defaultValue: MutableList<V>?): MutableList<V> {
+        return super.getOrDefault(key, defaultValue)
+    }
+}
+
+/**
+ * @see DefaultMap
+ */
+fun <K : Any, V : Any> defaultMap(defaultValue: V) =
+    DefaultMap<K, V>(defaultValue)
+
+/**
+ * @see ListMap
+ */
+fun <K : Any, V : Any> listMap() =
+    MutableListMap<K, V>()
+
+/**
+ * @see DefaultMap.createNestedMap
+ */
+fun <K : Any, K1 : Any, V : Any> nestedMap() =
+    DefaultMap.createNestedMap<K, K1, V>()
+
+/**
+ * @see DefaultMap.createNestedListMap
+ */
+fun <K : Any, K1 : Any, V : Any> nestedListMap() =
+    DefaultMap<K, MutableListMap<K1, V>>(MutableListMap())

eco-core/core-nms/build.gradle.kts

@@ -1,3 +1,8 @@
+plugins {
+    id("io.papermc.paperweight.userdev") version "1.5.3" apply false
+}
+
+
 group = "com.willfp"
 version = rootProject.version
 
@@ -9,4 +14,4 @@ subprojects {
         // libraries.minecraft.net machine broke
         compileOnly("com.github.Mojang:brigadier:1.0.18")
     }
-}
+}

eco-core/core-nms/nms-common/build.gradle.kts

@@ -1,10 +1,10 @@
 plugins {
-    id("io.papermc.paperweight.userdev") version "1.3.6"
+    id("io.papermc.paperweight.userdev")
 }
 
 group = "com.willfp"
 version = rootProject.version
 
 dependencies {
-    paperDevBundle("1.17.1-R0.1-SNAPSHOT")
+    paperweight.paperDevBundle("1.17.1-R0.1-SNAPSHOT")
 }

eco-core/core-nms/nms-common/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/common/packet/PacketInjectorListener.kt

@@ -6,6 +6,8 @@ import org.bukkit.event.Listener
 import org.bukkit.event.player.PlayerJoinEvent
 import org.bukkit.event.player.PlayerQuitEvent
 
+const val baseName = "packet_handler"
+
 object PacketInjectorListener : Listener {
     @EventHandler
     fun onJoin(event: PlayerJoinEvent) {
@@ -13,7 +15,11 @@ object PacketInjectorListener : Listener {
 
         val channel = player.toNMS().connection.connection.channel
 
-        channel.pipeline().addBefore("packet_handler", "eco_packets", EcoChannelDuplexHandler(player.uniqueId))
+        if (baseName !in channel.pipeline().names()) {
+            return
+        }
+
+        channel.pipeline().addBefore(baseName, "eco_packets", EcoChannelDuplexHandler(player.uniqueId))
     }
 
     @EventHandler

eco-core/core-nms/v1_17_R1/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    id("io.papermc.paperweight.userdev") version "1.3.6"
+    id("io.papermc.paperweight.userdev")
 }
 
 group = "com.willfp"
@@ -7,7 +7,7 @@ version = rootProject.version
 
 dependencies {
     implementation(project(":eco-core:core-nms:nms-common"))
-    paperDevBundle("1.17.1-R0.1-SNAPSHOT")
+    paperweight.paperDevBundle("1.17.1-R0.1-SNAPSHOT")
 
     implementation("net.kyori:adventure-text-minimessage:4.2.0-SNAPSHOT") {
         version {

eco-core/core-nms/v1_18_R1/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    id("io.papermc.paperweight.userdev") version "1.3.6"
+    id("io.papermc.paperweight.userdev")
 }
 
 group = "com.willfp"
@@ -7,7 +7,7 @@ version = rootProject.version
 
 dependencies {
     implementation(project(":eco-core:core-nms:nms-common"))
-    paperDevBundle("1.18.1-R0.1-SNAPSHOT")
+    paperweight.paperDevBundle("1.18.1-R0.1-SNAPSHOT")
 
     implementation("net.kyori:adventure-text-minimessage:4.2.0-SNAPSHOT") {
         version {

eco-core/core-nms/v1_18_R2/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    id("io.papermc.paperweight.userdev") version "1.3.6"
+    id("io.papermc.paperweight.userdev")
 }
 
 group = "com.willfp"
@@ -7,7 +7,7 @@ version = rootProject.version
 
 dependencies {
     implementation(project(":eco-core:core-nms:nms-common"))
-    paperDevBundle("1.18.2-R0.1-SNAPSHOT")
+    paperweight.paperDevBundle("1.18.2-R0.1-SNAPSHOT")
 
     implementation("net.kyori:adventure-text-minimessage:4.10.0") {
         version {

eco-core/core-nms/v1_19_R1/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    id("io.papermc.paperweight.userdev") version "1.3.6"
+    id("io.papermc.paperweight.userdev")
 }
 
 group = "com.willfp"
@@ -7,7 +7,7 @@ version = rootProject.version
 
 dependencies {
     implementation(project(":eco-core:core-nms:nms-common"))
-    paperDevBundle("1.19-R0.1-SNAPSHOT")
+    paperweight.paperDevBundle("1.19-R0.1-SNAPSHOT")
 
     implementation("net.kyori:adventure-text-minimessage:4.11.0") {
         version {

eco-core/core-nms/v1_19_R1/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R1/EntityControllerFactory.kt

@@ -2,7 +2,7 @@ package com.willfp.eco.internal.spigot.proxy.v1_19_R1
 
 import com.willfp.eco.core.entities.ai.EntityController
 import com.willfp.eco.internal.spigot.proxy.EntityControllerFactoryProxy
-import com.willfp.eco.internal.spigot.proxy.common.ai.EcoEntityController
+import com.willfp.eco.internal.spigot.proxy.v1_19_R1.entity.EcoEntityController
 import org.bukkit.entity.Mob
 
 class EntityControllerFactory : EntityControllerFactoryProxy {

eco-core/core-nms/v1_19_R1/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R1/entity/EcoEntityController.kt

@@ -0,0 +1,95 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R1.entity
+
+import com.willfp.eco.core.entities.ai.CustomGoal
+import com.willfp.eco.core.entities.ai.EntityController
+import com.willfp.eco.core.entities.ai.EntityGoal
+import com.willfp.eco.core.entities.ai.TargetGoal
+import com.willfp.eco.internal.spigot.proxy.common.ai.CustomGoalFactory
+import com.willfp.eco.internal.spigot.proxy.common.ai.getGoalFactory
+import com.willfp.eco.internal.spigot.proxy.common.toPathfinderMob
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.ai.goal.Goal
+import org.bukkit.entity.Mob
+
+class EcoEntityController<T : Mob>(
+    private val handle: T
+) : EntityController<T> {
+    override fun addEntityGoal(priority: Int, goal: EntityGoal<in T>): EntityController<T> {
+        val nms = getNms() ?: return this
+
+        nms.goalSelector.addGoal(
+            priority,
+            goal.getGoalFactory()?.create(goal, nms) ?: return this
+        )
+
+        return this
+    }
+
+    override fun removeEntityGoal(goal: EntityGoal<in T>): EntityController<T> {
+        val nms = getNms() ?: return this
+
+        val predicate: (Goal) -> Boolean = if (goal is CustomGoal<*>) {
+            { CustomGoalFactory.isGoalOfType(it, goal) }
+        } else {
+            { goal.getGoalFactory()?.isGoalOfType(it) == true }
+        }
+
+        for (wrapped in nms.goalSelector.availableGoals.toSet()) {
+            if (predicate(wrapped.goal)) {
+                nms.goalSelector.removeGoal(wrapped.goal)
+            }
+        }
+
+        return this
+    }
+
+    override fun clearEntityGoals(): EntityController<T> {
+        val nms = getNms() ?: return this
+        nms.goalSelector.availableGoals.clear()
+        return this
+    }
+
+    override fun addTargetGoal(priority: Int, goal: TargetGoal<in T>): EntityController<T> {
+        val nms = getNms() ?: return this
+
+        nms.targetSelector.addGoal(
+            priority, goal.getGoalFactory()?.create(goal, nms) ?: return this
+        )
+
+        nms.targetSelector
+
+        return this
+    }
+
+    override fun removeTargetGoal(goal: TargetGoal<in T>): EntityController<T> {
+        val nms = getNms() ?: return this
+
+        val predicate: (Goal) -> Boolean = if (goal is CustomGoal<*>) {
+            { CustomGoalFactory.isGoalOfType(it, goal) }
+        } else {
+            { goal.getGoalFactory()?.isGoalOfType(it) == true }
+        }
+
+        for (wrapped in nms.targetSelector.availableGoals.toSet()) {
+            if (predicate(wrapped.goal)) {
+                nms.targetSelector.removeGoal(wrapped.goal)
+            }
+        }
+
+        return this
+    }
+
+    override fun clearTargetGoals(): EntityController<T> {
+        val nms = getNms() ?: return this
+        nms.targetSelector.availableGoals.clear()
+        return this
+    }
+
+    private fun getNms(): PathfinderMob? {
+        return handle.toPathfinderMob()
+    }
+
+    override fun getEntity(): T {
+        return handle
+    }
+}

eco-core/core-nms/v1_19_R2/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
-    id("io.papermc.paperweight.userdev") version "1.3.6"
+    id("io.papermc.paperweight.userdev")
 }
 
 group = "com.willfp"
@@ -7,7 +7,7 @@ version = rootProject.version
 
 dependencies {
     implementation(project(":eco-core:core-nms:nms-common"))
-    paperDevBundle("1.19.3-R0.1-SNAPSHOT")
+    paperweight.paperDevBundle("1.19.3-R0.1-SNAPSHOT")
 
     implementation("net.kyori:adventure-text-minimessage:4.11.0") {
         version {

eco-core/core-nms/v1_19_R2/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R2/CommonsInitializer.kt

@@ -5,11 +5,13 @@ import com.willfp.eco.internal.spigot.proxy.CommonsInitializerProxy
 import com.willfp.eco.internal.spigot.proxy.common.CommonsProvider
 import com.willfp.eco.internal.spigot.proxy.common.packet.PacketInjectorListener
 import com.willfp.eco.internal.spigot.proxy.common.toResourceLocation
+import io.netty.channel.Channel
 import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.nbt.CompoundTag
 import net.minecraft.nbt.Tag
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.network.ServerGamePacketListenerImpl
 import net.minecraft.world.entity.PathfinderMob
 import net.minecraft.world.item.Item
 import org.bukkit.Bukkit

eco-core/core-nms/v1_19_R2/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R2/EntityControllerFactory.kt

@@ -2,7 +2,7 @@ package com.willfp.eco.internal.spigot.proxy.v1_19_R2
 
 import com.willfp.eco.core.entities.ai.EntityController
 import com.willfp.eco.internal.spigot.proxy.EntityControllerFactoryProxy
-import com.willfp.eco.internal.spigot.proxy.common.ai.EcoEntityController
+import com.willfp.eco.internal.spigot.proxy.v1_19_R2.entity.EcoEntityController
 import org.bukkit.entity.Mob
 
 class EntityControllerFactory : EntityControllerFactoryProxy {

eco-core/core-nms/v1_19_R2/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R2/entity/EcoEntityController.kt

@@ -0,0 +1,95 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R2.entity
+
+import com.willfp.eco.core.entities.ai.CustomGoal
+import com.willfp.eco.core.entities.ai.EntityController
+import com.willfp.eco.core.entities.ai.EntityGoal
+import com.willfp.eco.core.entities.ai.TargetGoal
+import com.willfp.eco.internal.spigot.proxy.common.ai.CustomGoalFactory
+import com.willfp.eco.internal.spigot.proxy.common.ai.getGoalFactory
+import com.willfp.eco.internal.spigot.proxy.common.toPathfinderMob
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.ai.goal.Goal
+import org.bukkit.entity.Mob
+
+class EcoEntityController<T : Mob>(
+    private val handle: T
+) : EntityController<T> {
+    override fun addEntityGoal(priority: Int, goal: EntityGoal<in T>): EntityController<T> {
+        val nms = getNms() ?: return this
+
+        nms.goalSelector.addGoal(
+            priority,
+            goal.getGoalFactory()?.create(goal, nms) ?: return this
+        )
+
+        return this
+    }
+
+    override fun removeEntityGoal(goal: EntityGoal<in T>): EntityController<T> {
+        val nms = getNms() ?: return this
+
+        val predicate: (Goal) -> Boolean = if (goal is CustomGoal<*>) {
+            { CustomGoalFactory.isGoalOfType(it, goal) }
+        } else {
+            { goal.getGoalFactory()?.isGoalOfType(it) == true }
+        }
+
+        for (wrapped in nms.goalSelector.availableGoals.toSet()) {
+            if (predicate(wrapped.goal)) {
+                nms.goalSelector.removeGoal(wrapped.goal)
+            }
+        }
+
+        return this
+    }
+
+    override fun clearEntityGoals(): EntityController<T> {
+        val nms = getNms() ?: return this
+        nms.goalSelector.availableGoals.clear()
+        return this
+    }
+
+    override fun addTargetGoal(priority: Int, goal: TargetGoal<in T>): EntityController<T> {
+        val nms = getNms() ?: return this
+
+        nms.targetSelector.addGoal(
+            priority, goal.getGoalFactory()?.create(goal, nms) ?: return this
+        )
+
+        nms.targetSelector
+
+        return this
+    }
+
+    override fun removeTargetGoal(goal: TargetGoal<in T>): EntityController<T> {
+        val nms = getNms() ?: return this
+
+        val predicate: (Goal) -> Boolean = if (goal is CustomGoal<*>) {
+            { CustomGoalFactory.isGoalOfType(it, goal) }
+        } else {
+            { goal.getGoalFactory()?.isGoalOfType(it) == true }
+        }
+
+        for (wrapped in nms.targetSelector.availableGoals.toSet()) {
+            if (predicate(wrapped.goal)) {
+                nms.targetSelector.removeGoal(wrapped.goal)
+            }
+        }
+
+        return this
+    }
+
+    override fun clearTargetGoals(): EntityController<T> {
+        val nms = getNms() ?: return this
+        nms.targetSelector.availableGoals.clear()
+        return this
+    }
+
+    private fun getNms(): PathfinderMob? {
+        return handle.toPathfinderMob()
+    }
+
+    override fun getEntity(): T {
+        return handle
+    }
+}

eco-core/core-nms/v1_19_R3/build.gradle.kts

@@ -0,0 +1,39 @@
+plugins {
+    id("io.papermc.paperweight.userdev")
+}
+
+group = "com.willfp"
+version = rootProject.version
+
+dependencies {
+    implementation(project(":eco-core:core-nms:nms-common"))
+    paperweight.paperDevBundle("1.19.4-R0.1-SNAPSHOT")
+
+    implementation("net.kyori:adventure-text-minimessage:4.11.0") {
+        version {
+            strictly("4.11.0")
+        }
+        exclude(group = "net.kyori", module = "adventure-api")
+    }
+}
+
+tasks {
+    build {
+        dependsOn(reobfJar)
+    }
+
+    reobfJar {
+        mustRunAfter(shadowJar)
+    }
+
+    shadowJar {
+        relocate(
+            "com.willfp.eco.internal.spigot.proxy.common",
+            "com.willfp.eco.internal.spigot.proxy.v1_19_R3.common"
+        )
+        relocate(
+            "net.kyori.adventure.text.minimessage",
+            "com.willfp.eco.internal.spigot.proxy.v1_19_R3.minimessage"
+        )
+    }
+}

eco-core/core-nms/v1_19_R3/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R3/BukkitCommands.kt

@@ -0,0 +1,35 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R3
+
+import com.willfp.eco.core.command.PluginCommandBase
+import com.willfp.eco.internal.spigot.proxy.BukkitCommandsProxy
+import org.bukkit.Bukkit
+import org.bukkit.command.Command
+import org.bukkit.command.SimpleCommandMap
+import org.bukkit.craftbukkit.v1_19_R3.CraftServer
+import java.lang.reflect.Field
+
+class BukkitCommands : BukkitCommandsProxy {
+    private val knownCommandsField: Field by lazy {
+        SimpleCommandMap::class.java.getDeclaredField("knownCommands")
+            .apply {
+                isAccessible = true
+            }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private val knownCommands: MutableMap<String, Command>
+        get() = knownCommandsField.get(getCommandMap()) as MutableMap<String, Command>
+
+    override fun getCommandMap(): SimpleCommandMap {
+        return (Bukkit.getServer() as CraftServer).commandMap
+    }
+
+    override fun syncCommands() {
+        (Bukkit.getServer() as CraftServer).syncCommands()
+    }
+
+    override fun unregisterCommand(command: PluginCommandBase) {
+        knownCommands.remove(command.name)
+        knownCommands.remove("${command.plugin.name.lowercase()}:${command.name}")
+    }
+}

eco-core/core-nms/v1_19_R3/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R3/CommonsInitializer.kt

@@ -0,0 +1,159 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R3
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.internal.spigot.proxy.CommonsInitializerProxy
+import com.willfp.eco.internal.spigot.proxy.common.CommonsProvider
+import com.willfp.eco.internal.spigot.proxy.common.packet.PacketInjectorListener
+import com.willfp.eco.internal.spigot.proxy.common.toResourceLocation
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.nbt.CompoundTag
+import net.minecraft.nbt.Tag
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.item.Item
+import org.bukkit.Bukkit
+import org.bukkit.Material
+import org.bukkit.NamespacedKey
+import org.bukkit.craftbukkit.v1_19_R3.CraftServer
+import org.bukkit.craftbukkit.v1_19_R3.entity.CraftEntity
+import org.bukkit.craftbukkit.v1_19_R3.entity.CraftMob
+import org.bukkit.craftbukkit.v1_19_R3.entity.CraftPlayer
+import org.bukkit.craftbukkit.v1_19_R3.inventory.CraftItemStack
+import org.bukkit.craftbukkit.v1_19_R3.persistence.CraftPersistentDataContainer
+import org.bukkit.craftbukkit.v1_19_R3.persistence.CraftPersistentDataTypeRegistry
+import org.bukkit.craftbukkit.v1_19_R3.util.CraftMagicNumbers
+import org.bukkit.craftbukkit.v1_19_R3.util.CraftNamespacedKey
+import org.bukkit.entity.LivingEntity
+import org.bukkit.entity.Mob
+import org.bukkit.entity.Player
+import org.bukkit.inventory.ItemStack
+import org.bukkit.persistence.PersistentDataContainer
+import java.lang.reflect.Field
+
+class CommonsInitializer : CommonsInitializerProxy {
+    override fun init(plugin: EcoPlugin) {
+        CommonsProvider.setIfNeeded(CommonsProviderImpl)
+        plugin.onEnable {
+            plugin.eventManager.registerListener(PacketInjectorListener)
+        }
+    }
+
+    object CommonsProviderImpl : CommonsProvider {
+        private val cisHandle: Field = CraftItemStack::class.java.getDeclaredField("handle").apply {
+            isAccessible = true
+        }
+
+        private val pdcRegsitry = Class.forName("org.bukkit.craftbukkit.v1_19_R3.inventory.CraftMetaItem")
+            .getDeclaredField("DATA_TYPE_REGISTRY")
+            .apply { isAccessible = true }
+            .get(null) as CraftPersistentDataTypeRegistry
+
+        override val nbtTagString = CraftMagicNumbers.NBT.TAG_STRING
+
+        override fun toPathfinderMob(mob: Mob): PathfinderMob? {
+            val craft = mob as? CraftMob ?: return null
+            return craft.handle as? PathfinderMob
+        }
+
+        override fun toResourceLocation(namespacedKey: NamespacedKey): ResourceLocation =
+            CraftNamespacedKey.toMinecraft(namespacedKey)
+
+        override fun asNMSStack(itemStack: ItemStack): net.minecraft.world.item.ItemStack {
+            return if (itemStack !is CraftItemStack) {
+                CraftItemStack.asNMSCopy(itemStack)
+            } else {
+                cisHandle[itemStack] as net.minecraft.world.item.ItemStack? ?: CraftItemStack.asNMSCopy(itemStack)
+            }
+        }
+
+        override fun asBukkitStack(itemStack: net.minecraft.world.item.ItemStack): ItemStack {
+            return CraftItemStack.asCraftMirror(itemStack)
+        }
+
+        override fun mergeIfNeeded(itemStack: ItemStack, nmsStack: net.minecraft.world.item.ItemStack) {
+            if (itemStack !is CraftItemStack) {
+                itemStack.itemMeta = CraftItemStack.asCraftMirror(nmsStack).itemMeta
+            }
+        }
+
+        override fun toBukkitEntity(entity: net.minecraft.world.entity.LivingEntity): LivingEntity? =
+            CraftEntity.getEntity(Bukkit.getServer() as CraftServer, entity) as? LivingEntity
+
+        override fun makePdc(tag: CompoundTag, base: Boolean): PersistentDataContainer {
+            fun emptyPdc(): CraftPersistentDataContainer = CraftPersistentDataContainer(pdcRegsitry)
+
+            fun CompoundTag?.toPdc(): PersistentDataContainer {
+                val pdc = emptyPdc()
+                this ?: return pdc
+                val keys = this.allKeys
+                for (key in keys) {
+                    pdc.put(key, this[key])
+                }
+
+                return pdc
+            }
+
+            return if (base) {
+                tag.toPdc()
+            } else {
+                if (tag.contains("PublicBukkitValues")) {
+                    tag.getCompound("PublicBukkitValues").toPdc()
+                } else {
+                    emptyPdc()
+                }
+            }
+        }
+
+        override fun setPdc(
+            tag: CompoundTag,
+            pdc: PersistentDataContainer?,
+            item: net.minecraft.world.item.ItemStack?
+        ) {
+            fun CraftPersistentDataContainer.toTag(): CompoundTag {
+                val compound = CompoundTag()
+                val rawPublicMap: Map<String, Tag> = this.raw
+                for ((key, value) in rawPublicMap) {
+                    compound.put(key, value)
+                }
+
+                return compound
+            }
+
+            val container = when (pdc) {
+                is CraftPersistentDataContainer? -> pdc
+                else -> null
+            }
+
+            if (item != null) {
+                if (container != null && !container.isEmpty) {
+                    for (key in tag.allKeys.toSet()) {
+                        tag.remove(key)
+                    }
+
+                    tag.merge(container.toTag())
+                } else {
+                    item.tag = null
+                }
+            } else {
+                if (container != null && !container.isEmpty) {
+                    tag.put("PublicBukkitValues", container.toTag())
+                } else {
+                    tag.remove("PublicBukkitValues")
+                }
+            }
+        }
+
+        override fun materialToItem(material: Material): Item =
+            BuiltInRegistries.ITEM.getOptional(material.key.toResourceLocation())
+                .orElseThrow { IllegalArgumentException("Material is not item!") }
+
+        override fun itemToMaterial(item: Item) =
+            Material.getMaterial(BuiltInRegistries.ITEM.getKey(item).path.uppercase())
+                ?: throw IllegalArgumentException("Invalid material!")
+
+        override fun toNMS(player: Player): ServerPlayer {
+            return (player as CraftPlayer).handle
+        }
+    }
+}

eco-core/core-nms/v1_19_R3/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R3/DummyEntityFactory.kt

@@ -0,0 +1,16 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R3
+
+import com.willfp.eco.internal.entities.EcoDummyEntity
+import com.willfp.eco.internal.spigot.proxy.DummyEntityFactoryProxy
+import org.bukkit.Location
+import org.bukkit.craftbukkit.v1_19_R3.CraftWorld
+import org.bukkit.entity.Entity
+import org.bukkit.entity.EntityType
+
+class DummyEntityFactory : DummyEntityFactoryProxy {
+    override fun createDummyEntity(location: Location): Entity {
+        val world = location.world as CraftWorld
+        @Suppress("UsePropertyAccessSyntax")
+        return EcoDummyEntity(world.createEntity(location, EntityType.ZOMBIE.entityClass).getBukkitEntity())
+    }
+}

eco-core/core-nms/v1_19_R3/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R3/EntityControllerFactory.kt

@@ -0,0 +1,12 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R3
+
+import com.willfp.eco.core.entities.ai.EntityController
+import com.willfp.eco.internal.spigot.proxy.EntityControllerFactoryProxy
+import com.willfp.eco.internal.spigot.proxy.v1_19_R3.entity.EcoEntityController
+import org.bukkit.entity.Mob
+
+class EntityControllerFactory : EntityControllerFactoryProxy {
+    override fun <T : Mob> createEntityController(entity: T): EntityController<T> {
+        return EcoEntityController(entity)
+    }
+}

eco-core/core-nms/v1_19_R3/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R3/ExtendedPersistentDataContainerFactory.kt

@@ -0,0 +1,82 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R3
+
+import com.willfp.eco.core.data.ExtendedPersistentDataContainer
+import com.willfp.eco.internal.spigot.proxy.ExtendedPersistentDataContainerFactoryProxy
+import net.minecraft.nbt.Tag
+import org.bukkit.Material
+import org.bukkit.craftbukkit.v1_19_R3.inventory.CraftItemStack
+import org.bukkit.craftbukkit.v1_19_R3.persistence.CraftPersistentDataContainer
+import org.bukkit.craftbukkit.v1_19_R3.persistence.CraftPersistentDataTypeRegistry
+import org.bukkit.inventory.ItemStack
+import org.bukkit.persistence.PersistentDataContainer
+import org.bukkit.persistence.PersistentDataType
+
+class ExtendedPersistentDataContainerFactory : ExtendedPersistentDataContainerFactoryProxy {
+    private val registry: CraftPersistentDataTypeRegistry
+
+    init {
+        /*
+         Can't grab actual instance since it's in CraftMetaItem (which is package-private)
+         And getting it would mean more janky reflection
+         */
+        val item = CraftItemStack.asCraftCopy(ItemStack(Material.STONE))
+        val pdc = item.itemMeta!!.persistentDataContainer
+        this.registry = CraftPersistentDataContainer::class.java.getDeclaredField("registry")
+            .apply { isAccessible = true }.get(pdc) as CraftPersistentDataTypeRegistry
+    }
+
+    override fun adapt(pdc: PersistentDataContainer): ExtendedPersistentDataContainer {
+        return when (pdc) {
+            is CraftPersistentDataContainer -> EcoPersistentDataContainer(pdc)
+            else -> throw IllegalArgumentException("Custom PDC instance ims not supported!")
+        }
+    }
+
+    override fun newPdc(): PersistentDataContainer {
+        return CraftPersistentDataContainer(registry)
+    }
+
+    inner class EcoPersistentDataContainer(
+        private val handle: CraftPersistentDataContainer
+    ) : ExtendedPersistentDataContainer {
+        @Suppress("UNCHECKED_CAST")
+        private val customDataTags: MutableMap<String, Tag> =
+            CraftPersistentDataContainer::class.java.getDeclaredField("customDataTags")
+                .apply { isAccessible = true }.get(handle) as MutableMap<String, Tag>
+
+        override fun <T : Any, Z : Any> set(key: String, dataType: PersistentDataType<T, Z>, value: Z) {
+            customDataTags[key] =
+                registry.wrap(dataType.primitiveType, dataType.toPrimitive(value, handle.adapterContext))
+        }
+
+        override fun <T : Any, Z : Any> has(key: String, dataType: PersistentDataType<T, Z>): Boolean {
+            val value = customDataTags[key] ?: return false
+            return registry.isInstanceOf(dataType.primitiveType, value)
+        }
+
+        override fun <T : Any, Z : Any> get(key: String, dataType: PersistentDataType<T, Z>): Z? {
+            val value = customDataTags[key] ?: return null
+            return dataType.fromPrimitive(registry.extract(dataType.primitiveType, value), handle.adapterContext)
+        }
+
+        override fun <T : Any, Z : Any> getOrDefault(
+            key: String,
+            dataType: PersistentDataType<T, Z>,
+            defaultValue: Z
+        ): Z {
+            return get(key, dataType) ?: defaultValue
+        }
+
+        override fun remove(key: String) {
+            customDataTags.remove(key)
+        }
+
+        override fun getAllKeys(): MutableSet<String> {
+            return customDataTags.keys
+        }
+
+        override fun getBase(): PersistentDataContainer {
+            return handle
+        }
+    }
+}

eco-core/core-nms/v1_19_R3/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R3/FastItemStackFactory.kt

@@ -0,0 +1,12 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R3
+
+import com.willfp.eco.core.fast.FastItemStack
+import com.willfp.eco.internal.spigot.proxy.FastItemStackFactoryProxy
+import com.willfp.eco.internal.spigot.proxy.common.item.EcoFastItemStack
+import org.bukkit.inventory.ItemStack
+
+class FastItemStackFactory : FastItemStackFactoryProxy {
+    override fun create(itemStack: ItemStack): FastItemStack {
+        return EcoFastItemStack(itemStack)
+    }
+}

eco-core/core-nms/v1_19_R3/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R3/MiniMessageTranslator.kt

@@ -0,0 +1,33 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R3
+
+import com.willfp.eco.core.display.Display
+import com.willfp.eco.internal.spigot.proxy.MiniMessageTranslatorProxy
+import com.willfp.eco.util.toLegacy
+import net.kyori.adventure.text.minimessage.MiniMessage
+
+class MiniMessageTranslator : MiniMessageTranslatorProxy {
+    override fun format(message: String): String {
+        var mut = message
+
+        val startsWithPrefix = mut.startsWith(Display.PREFIX)
+        if (startsWithPrefix) {
+            mut = mut.substring(2)
+        }
+
+        mut = mut.replace('§', '&')
+
+        val miniMessage = runCatching {
+            MiniMessage.miniMessage().deserialize(
+                mut
+            ).toLegacy()
+        }.getOrNull() ?: mut
+
+        mut = if (startsWithPrefix) {
+            Display.PREFIX + miniMessage
+        } else {
+            miniMessage
+        }
+
+        return mut
+    }
+}

eco-core/core-nms/v1_19_R3/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R3/PacketHandler.kt

@@ -0,0 +1,46 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R3
+
+import com.willfp.eco.core.EcoPlugin
+import com.willfp.eco.core.packet.PacketListener
+import com.willfp.eco.internal.spigot.proxy.PacketHandlerProxy
+import com.willfp.eco.internal.spigot.proxy.common.packet.display.PacketAutoRecipe
+import com.willfp.eco.internal.spigot.proxy.common.packet.display.PacketHeldItemSlot
+import com.willfp.eco.internal.spigot.proxy.common.packet.display.PacketOpenWindowMerchant
+import com.willfp.eco.internal.spigot.proxy.common.packet.display.PacketSetCreativeSlot
+import com.willfp.eco.internal.spigot.proxy.common.packet.display.PacketSetSlot
+import com.willfp.eco.internal.spigot.proxy.common.packet.display.PacketWindowItems
+import com.willfp.eco.internal.spigot.proxy.common.packet.display.frame.clearFrames
+import net.minecraft.network.protocol.Packet
+import org.bukkit.craftbukkit.v1_19_R3.entity.CraftPlayer
+import org.bukkit.entity.Player
+
+class PacketHandler : PacketHandlerProxy {
+    override fun sendPacket(player: Player, packet: com.willfp.eco.core.packet.Packet) {
+        if (player !is CraftPlayer) {
+            return
+        }
+
+        val handle = packet.handle
+
+        if (handle !is Packet<*>) {
+            return
+        }
+
+        player.handle.connection.send(handle)
+    }
+
+    override fun clearDisplayFrames() {
+        clearFrames()
+    }
+
+    override fun getPacketListeners(plugin: EcoPlugin): List<PacketListener> {
+        return listOf(
+            PacketAutoRecipe(plugin),
+            PacketHeldItemSlot,
+            PacketOpenWindowMerchant,
+            PacketSetCreativeSlot,
+            PacketSetSlot,
+            PacketWindowItems(plugin)
+        )
+    }
+}

eco-core/core-nms/v1_19_R3/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R3/SNBTConverter.kt

@@ -0,0 +1,52 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R3
+
+import com.willfp.eco.core.items.TestableItem
+import com.willfp.eco.core.recipe.parts.EmptyTestableItem
+import com.willfp.eco.internal.spigot.proxy.SNBTConverterProxy
+import net.minecraft.nbt.CompoundTag
+import net.minecraft.nbt.SnbtPrinterTagVisitor
+import net.minecraft.nbt.TagParser
+import org.bukkit.craftbukkit.v1_19_R3.inventory.CraftItemStack
+import org.bukkit.inventory.ItemStack
+
+class SNBTConverter : SNBTConverterProxy {
+    override fun fromSNBT(snbt: String): ItemStack? {
+        val nbt = runCatching { TagParser.parseTag(snbt) }.getOrNull() ?: return null
+        val nms = net.minecraft.world.item.ItemStack.of(nbt)
+        return CraftItemStack.asBukkitCopy(nms)
+    }
+
+    override fun toSNBT(itemStack: ItemStack): String {
+        val nms = CraftItemStack.asNMSCopy(itemStack)
+        return SnbtPrinterTagVisitor().visit(nms.save(CompoundTag()))
+    }
+
+    override fun makeSNBTTestable(snbt: String): TestableItem {
+        val nbt = runCatching { TagParser.parseTag(snbt) }.getOrNull() ?: return EmptyTestableItem()
+        val nms = net.minecraft.world.item.ItemStack.of(nbt)
+        if (nms == net.minecraft.world.item.ItemStack.EMPTY) {
+            return EmptyTestableItem()
+        }
+
+        nbt.remove("Count")
+        return SNBTTestableItem(CraftItemStack.asBukkitCopy(nms), nbt)
+    }
+
+    class SNBTTestableItem(
+        private val item: ItemStack,
+        private val tag: CompoundTag
+    ) : TestableItem {
+        override fun matches(itemStack: ItemStack?): Boolean {
+            if (itemStack == null) {
+                return false
+            }
+
+            val nms = CraftItemStack.asNMSCopy(itemStack)
+            val nmsTag = nms.save(CompoundTag())
+            nmsTag.remove("Count")
+            return tag.copy().merge(nmsTag) == nmsTag
+        }
+
+        override fun getItem(): ItemStack = item
+    }
+}

eco-core/core-nms/v1_19_R3/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R3/Skull.kt

@@ -0,0 +1,18 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R3
+
+import com.willfp.eco.internal.spigot.proxy.SkullProxy
+import com.willfp.eco.internal.spigot.proxy.common.texture
+import org.bukkit.inventory.meta.SkullMeta
+
+class Skull : SkullProxy {
+    override fun setSkullTexture(
+        meta: SkullMeta,
+        base64: String
+    ) {
+        meta.texture = base64
+    }
+
+    override fun getSkullTexture(
+        meta: SkullMeta
+    ): String? = meta.texture
+}

eco-core/core-nms/v1_19_R3/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R3/TPS.kt

@@ -0,0 +1,11 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R3
+
+import com.willfp.eco.internal.spigot.proxy.TPSProxy
+import org.bukkit.Bukkit
+import org.bukkit.craftbukkit.v1_19_R3.CraftServer
+
+class TPS : TPSProxy {
+    override fun getTPS(): Double {
+        return (Bukkit.getServer() as CraftServer).handle.server.recentTps[0]
+    }
+}

eco-core/core-nms/v1_19_R3/src/main/kotlin/com/willfp/eco/internal/spigot/proxy/v1_19_R3/entity/EcoEntityController.kt

@@ -0,0 +1,95 @@
+package com.willfp.eco.internal.spigot.proxy.v1_19_R3.entity
+
+import com.willfp.eco.core.entities.ai.CustomGoal
+import com.willfp.eco.core.entities.ai.EntityController
+import com.willfp.eco.core.entities.ai.EntityGoal
+import com.willfp.eco.core.entities.ai.TargetGoal
+import com.willfp.eco.internal.spigot.proxy.common.ai.CustomGoalFactory
+import com.willfp.eco.internal.spigot.proxy.common.ai.getGoalFactory
+import com.willfp.eco.internal.spigot.proxy.common.toPathfinderMob
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.ai.goal.Goal
+import org.bukkit.entity.Mob
+
+class EcoEntityController<T : Mob>(
+    private val handle: T
+) : EntityController<T> {
+    override fun addEntityGoal(priority: Int, goal: EntityGoal<in T>): EntityController<T> {
+        val nms = getNms() ?: return this
+
+        nms.goalSelector.addGoal(
+            priority,
+            goal.getGoalFactory()?.create(goal, nms) ?: return this
+        )
+
+        return this
+    }
+
+    override fun removeEntityGoal(goal: EntityGoal<in T>): EntityController<T> {
+        val nms = getNms() ?: return this
+
+        val predicate: (Goal) -> Boolean = if (goal is CustomGoal<*>) {
+            { CustomGoalFactory.isGoalOfType(it, goal) }
+        } else {
+            { goal.getGoalFactory()?.isGoalOfType(it) == true }
+        }
+
+        for (wrapped in nms.goalSelector.availableGoals.toSet()) {
+            if (predicate(wrapped.goal)) {
+                nms.goalSelector.removeGoal(wrapped.goal)
+            }
+        }
+
+        return this
+    }
+
+    override fun clearEntityGoals(): EntityController<T> {
+        val nms = getNms() ?: return this
+        nms.goalSelector.availableGoals.clear()
+        return this
+    }
+
+    override fun addTargetGoal(priority: Int, goal: TargetGoal<in T>): EntityController<T> {
+        val nms = getNms() ?: return this
+
+        nms.targetSelector.addGoal(
+            priority, goal.getGoalFactory()?.create(goal, nms) ?: return this
+        )
+
+        nms.targetSelector
+
+        return this
+    }
+
+    override fun removeTargetGoal(goal: TargetGoal<in T>): EntityController<T> {
+        val nms = getNms() ?: return this
+
+        val predicate: (Goal) -> Boolean = if (goal is CustomGoal<*>) {
+            { CustomGoalFactory.isGoalOfType(it, goal) }
+        } else {
+            { goal.getGoalFactory()?.isGoalOfType(it) == true }
+        }
+
+        for (wrapped in nms.targetSelector.availableGoals.toSet()) {
+            if (predicate(wrapped.goal)) {
+                nms.targetSelector.removeGoal(wrapped.goal)
+            }
+        }
+
+        return this
+    }
+
+    override fun clearTargetGoals(): EntityController<T> {
+        val nms = getNms() ?: return this
+        nms.targetSelector.availableGoals.clear()
+        return this
+    }
+
+    private fun getNms(): PathfinderMob? {
+        return handle.toPathfinderMob()
+    }
+
+    override fun getEntity(): T {
+        return handle
+    }
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/shop/ShopEconomyShopGUI.kt

@@ -35,23 +35,9 @@ class ShopEconomyShopGUI : ShopIntegration {
     }
 
     object EconomyShopGUISellEventListeners : Listener {
-        private val sellTypes = listOf(
-            "SELL_GUI_SCREEN",
-            "SELL_SCREEN",
-            "SELL_ALL_SCREEN",
-            "SELL_ALL_COMMAND",
-            "QUICK_SELL",
-            "AUTO_SELL_CHEST",
-        )
-
-        private val sellAllTypes = listOf(
-            "SELL_GUI_SCREEN",
-            "SELL_ALL_COMMAND",
-        )
-
         @EventHandler
         fun shopEventToEcoEvent(event: PreTransactionEvent) {
-            if (event.transactionType.name.uppercase() !in sellTypes) {
+            if (!event.transactionType.mode.equals(Transaction.Mode.SELL.name, true)) {
                 return
             }
 
@@ -59,11 +45,7 @@ class ShopEconomyShopGUI : ShopIntegration {
                 return
             }
 
-            val prices = if (event.transactionType.name.uppercase() in sellAllTypes) {
-                event.items!!
-            } else {
-                mapOf(event.shopItem to event.amount)
-            }
+            val prices = event.items ?: mapOf(event.shopItem to event.amount)
 
             var total = 0.0
 
@@ -83,4 +65,4 @@ class ShopEconomyShopGUI : ShopIntegration {
     override fun getPluginName(): String {
         return "EconomyShopGUI"
     }
-}
+}

eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/math/CrunchHandler.kt

@@ -3,8 +3,8 @@ package com.willfp.eco.internal.spigot.math
 import com.github.benmanes.caffeine.cache.Cache
 import com.github.benmanes.caffeine.cache.Caffeine
 import com.willfp.eco.core.integrations.placeholder.PlaceholderManager
-import com.willfp.eco.core.placeholder.AdditionalPlayer
 import com.willfp.eco.core.math.MathContext
+import com.willfp.eco.core.placeholder.AdditionalPlayer
 import com.willfp.eco.core.placeholder.PlaceholderInjectable
 import org.bukkit.entity.Player
 import redempt.crunch.CompiledExpression
@@ -28,6 +28,7 @@ private val max = Function("max", 2) {
 
 fun evaluateExpression(expression: String, context: MathContext) =
     evaluateExpression(expression, context.player, context.injectableContext, context.additionalPlayers)
+        .let { if (!it.isFinite()) 0.0 else it } // Fixes NaN bug.
 
 private fun evaluateExpression(
     expression: String,

gradle.properties

@@ -1,3 +1,3 @@
-version = 6.51.2
+version = 6.52.3
 plugin-name = eco
 kotlin.code.style = official

settings.gradle.kts

@@ -17,6 +17,7 @@ include(":eco-core:core-nms:v1_18_R1")
 include(":eco-core:core-nms:v1_18_R2")
 include(":eco-core:core-nms:v1_19_R1")
 include(":eco-core:core-nms:v1_19_R2")
+include(":eco-core:core-nms:v1_19_R3")
 include(":eco-core:core-proxy")
 include(":eco-core:core-plugin")
 include(":eco-core:core-backend")