Added support for 1.19.4

settings.gradle

@@ -52,4 +52,5 @@ include 'v119'
 include 'v1191'
 include 'v1192'
 include 'v1193'
+include 'v1194'
 

src/main/java/com/bgsoftware/wildtools/WildToolsPlugin.java

@@ -129,7 +129,8 @@ private boolean loadNMSAdapter() {
                     new Pair<>(3105, "v119"),
                     new Pair<>(3117, "v1191"),
                     new Pair<>(3120, "v1192"),
-                    new Pair<>(3218, "v1193")
+                    new Pair<>(3218, "v1193"),
+                    new Pair<>(3337, "v1194")
             );
 
             for (Pair<Integer, String> versionData : versions) {

v1194/build.gradle

@@ -0,0 +1,36 @@
+plugins {
+    id("io.papermc.paperweight.userdev") version "1.3.8"
+}
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(17))
+    }
+}
+
+dependencies {
+    paperweightDevelopmentBundle("io.papermc.paper:dev-bundle:1.19.4-R0.1-SNAPSHOT")
+    compileOnly project(":NMS-Spigot")
+    compileOnly project(":NMS-Paper")
+    compileOnly project(":API")
+    compileOnly parent
+}
+
+shadowJar {
+    archiveFileName = "${project.name}-exclude.jar"
+}
+
+assemble {
+    dependsOn(reobfJar)
+}
+
+tasks {
+    reobfJar {
+        File outputFile = new File(parent.projectDir, "archive/${project.name}.jar")
+        outputJar.set(layout.buildDirectory.file(outputFile.getPath()))
+    }
+}
+
+if (project.hasProperty('nms.compile_v1_19') && !Boolean.valueOf(project.findProperty("nms.compile_v1_19").toString())) {
+    project.tasks.all { task -> task.enabled = false }
+}

v1194/src/main/java/com/bgsoftware/wildtools/nms/v1194/NMSAdapter.java

@@ -0,0 +1,189 @@
+package com.bgsoftware.wildtools.nms.v1194;
+
+import com.bgsoftware.common.reflection.ReflectField;
+import com.bgsoftware.wildtools.nms.alogrithms.PaperGlowEnchantment;
+import com.bgsoftware.wildtools.nms.alogrithms.SpigotGlowEnchantment;
+import com.bgsoftware.wildtools.nms.v1194.tool.ToolItemStackImpl;
+import com.bgsoftware.wildtools.nms.v1194.world.FakeCraftBlock;
+import com.bgsoftware.wildtools.recipes.AdvancedShapedRecipe;
+import com.bgsoftware.wildtools.utils.items.DestroySpeedCategory;
+import com.bgsoftware.wildtools.utils.items.ToolItemStack;
+import net.minecraft.network.protocol.game.ClientboundTakeItemEntityPacket;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.item.ItemEntity;
+import net.minecraft.world.inventory.AnvilMenu;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.craftbukkit.v1_19_R3.block.data.CraftBlockData;
+import org.bukkit.craftbukkit.v1_19_R3.entity.CraftItem;
+import org.bukkit.craftbukkit.v1_19_R3.entity.CraftLivingEntity;
+import org.bukkit.craftbukkit.v1_19_R3.inventory.CraftInventoryView;
+import org.bukkit.craftbukkit.v1_19_R3.inventory.CraftItemStack;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.InventoryView;
+import org.bukkit.inventory.Recipe;
+import org.bukkit.inventory.RecipeChoice;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.inventory.ShapelessRecipe;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class NMSAdapter implements com.bgsoftware.wildtools.nms.NMSAdapter {
+
+    private static final ReflectField<ItemStack> ITEM_STACK_HANDLE = new ReflectField<>(
+            CraftItemStack.class, ItemStack.class, "handle");
+
+    @Override
+    public ToolItemStack createToolItemStack(org.bukkit.inventory.ItemStack bukkitItem) {
+        ItemStack nmsItem;
+
+        if (bukkitItem instanceof CraftItemStack) {
+            nmsItem = ITEM_STACK_HANDLE.get(bukkitItem);
+        } else {
+            nmsItem = CraftItemStack.asNMSCopy(bukkitItem);
+        }
+
+        return new ToolItemStackImpl(nmsItem);
+    }
+
+    @Override
+    public org.bukkit.inventory.ItemStack getItemInHand(Player player) {
+        return player.getInventory().getItemInMainHand();
+    }
+
+    @Override
+    public org.bukkit.inventory.ItemStack getItemInHand(Player player, Event event) {
+        boolean offHand = false;
+
+        if (event instanceof PlayerInteractEvent playerInteractEvent) {
+            offHand = playerInteractEvent.getHand() == org.bukkit.inventory.EquipmentSlot.OFF_HAND;
+        } else if (event instanceof PlayerInteractEntityEvent playerInteractEntityEvent) {
+            offHand = playerInteractEntityEvent.getHand() == org.bukkit.inventory.EquipmentSlot.OFF_HAND;
+        }
+
+        return offHand ? player.getInventory().getItemInOffHand() : getItemInHand(player);
+    }
+
+    @Override
+    public Collection<Player> getOnlinePlayers() {
+        return new ArrayList<>(Bukkit.getOnlinePlayers());
+    }
+
+    @Override
+    public Enchantment getGlowEnchant() {
+        try {
+            return new PaperGlowEnchantment("wildtools_glowing_enchant");
+        } catch (Throwable error) {
+            return new SpigotGlowEnchantment("wildtools_glowing_enchant");
+        }
+    }
+
+    @Override
+    public int getFarmlandId() {
+        return Block.getId(Blocks.FARMLAND.defaultBlockState());
+    }
+
+    @Override
+    public BlockPlaceEvent getFakePlaceEvent(Player player, org.bukkit.block.Block block, org.bukkit.block.Block copyBlock) {
+        org.bukkit.block.BlockState originalState = block.getState();
+        FakeCraftBlock fakeBlock = new FakeCraftBlock(block, copyBlock.getType(), originalState);
+        return new BlockPlaceEvent(
+                fakeBlock,
+                originalState,
+                fakeBlock.getRelative(BlockFace.DOWN),
+                new org.bukkit.inventory.ItemStack(copyBlock.getType()),
+                player,
+                true,
+                org.bukkit.inventory.EquipmentSlot.HAND
+        );
+    }
+
+    @Override
+    public void playPickupAnimation(org.bukkit.entity.LivingEntity bukkitLivingEntity, org.bukkit.entity.Item item) {
+        LivingEntity livingEntity = ((CraftLivingEntity) bukkitLivingEntity).getHandle();
+        ItemEntity itemEntity = (ItemEntity) ((CraftItem) item).getHandle();
+        ServerLevel serverLevel = (ServerLevel) livingEntity.level;
+
+        ClientboundTakeItemEntityPacket takeItemEntityPacket = new ClientboundTakeItemEntityPacket(itemEntity.getId(),
+                livingEntity.getId(), itemEntity.getItem().getCount());
+
+        serverLevel.getChunkSource().broadcast(itemEntity, takeItemEntityPacket);
+    }
+
+    @Override
+    public DestroySpeedCategory getDestroySpeedCategory(Material material) {
+        BlockState blockState = ((CraftBlockData) material.createBlockData()).getState();
+
+        if (Items.DIAMOND_AXE.getDestroySpeed(new ItemStack(Items.DIAMOND_AXE), blockState) == 8f)
+            return DestroySpeedCategory.AXE;
+
+        if (Items.DIAMOND_SHOVEL.getDestroySpeed(new ItemStack(Items.DIAMOND_SHOVEL), blockState) == 8f)
+            return DestroySpeedCategory.SHOVEL;
+
+        return DestroySpeedCategory.PICKAXE;
+    }
+
+    @Override
+    public org.bukkit.inventory.ItemStack[] parseChoice(Recipe recipe, org.bukkit.inventory.ItemStack itemStack) {
+        List<org.bukkit.inventory.ItemStack> ingredients = new ArrayList<>();
+        List<RecipeChoice> recipeChoices = new ArrayList<>();
+
+        ingredients.add(itemStack);
+
+        if (recipe instanceof ShapedRecipe) {
+            recipeChoices.addAll(((ShapedRecipe) recipe).getChoiceMap().values());
+        } else if (recipe instanceof ShapelessRecipe) {
+            recipeChoices.addAll(((ShapelessRecipe) recipe).getChoiceList());
+        }
+
+        if (!recipeChoices.isEmpty()) {
+            for (RecipeChoice recipeChoice : recipeChoices) {
+                if (recipeChoice instanceof RecipeChoice.MaterialChoice && recipeChoice.test(itemStack)) {
+                    ingredients.clear();
+                    for (Material material : ((RecipeChoice.MaterialChoice) recipeChoice).getChoices())
+                        ingredients.add(new org.bukkit.inventory.ItemStack(material));
+                    break;
+                }
+            }
+        }
+
+        return ingredients.toArray(new org.bukkit.inventory.ItemStack[0]);
+    }
+
+    @Override
+    public void setExpCost(InventoryView inventoryView, int expCost) {
+        AnvilMenu anvilMenu = (AnvilMenu) ((CraftInventoryView) inventoryView).getHandle();
+        anvilMenu.cost.set(expCost);
+    }
+
+    @Override
+    public int getExpCost(InventoryView inventoryView) {
+        AnvilMenu anvilMenu = (AnvilMenu) ((CraftInventoryView) inventoryView).getHandle();
+        return anvilMenu.getCost();
+    }
+
+    @Override
+    public String getRenameText(InventoryView inventoryView) {
+        return ((AnvilMenu) ((CraftInventoryView) inventoryView).getHandle()).itemName;
+    }
+
+    @Override
+    public AdvancedShapedRecipe createRecipe(String toolName, org.bukkit.inventory.ItemStack result) {
+        return new com.bgsoftware.wildtools.nms.recipe.AdvancedRecipeClassImpl(toolName, result);
+    }
+
+}

v1194/src/main/java/com/bgsoftware/wildtools/nms/v1194/NMSUtils.java

@@ -0,0 +1,73 @@
+package com.bgsoftware.wildtools.nms.v1194;
+
+import com.bgsoftware.common.reflection.ReflectField;
+import com.bgsoftware.common.reflection.ReflectMethod;
+import net.minecraft.network.protocol.Packet;
+import net.minecraft.server.level.ChunkHolder;
+import net.minecraft.server.level.ChunkMap;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.item.ItemEntity;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.ChunkPos;
+import org.bukkit.craftbukkit.v1_19_R3.event.CraftEventFactory;
+
+import java.lang.reflect.Modifier;
+import java.util.Map;
+
+public class NMSUtils {
+
+    private static final ReflectMethod<Void> SEND_PACKETS_TO_RELEVANT_PLAYERS = new ReflectMethod<>(
+            ChunkHolder.class, 1, Packet.class, boolean.class);
+    private static final ReflectField<Map<Long, ChunkHolder>> VISIBLE_CHUNKS = new ReflectField<>(
+            ChunkMap.class, Map.class, Modifier.PUBLIC | Modifier.VOLATILE, 1);
+
+    private NMSUtils() {
+
+    }
+
+    public static void sendPacketToRelevantPlayers(ServerLevel serverLevel, int chunkX, int chunkZ, Packet<?> packet) {
+        ChunkMap chunkMap = serverLevel.getChunkSource().chunkMap;
+        ChunkPos chunkPos = new ChunkPos(chunkX, chunkZ);
+        ChunkHolder chunkHolder;
+
+        try {
+            chunkHolder = chunkMap.getVisibleChunkIfPresent(chunkPos.toLong());
+        } catch (Throwable ex) {
+            chunkHolder = VISIBLE_CHUNKS.get(chunkMap).get(chunkPos.toLong());
+        }
+
+        if (chunkHolder != null) {
+            SEND_PACKETS_TO_RELEVANT_PLAYERS.invoke(chunkHolder, packet, false);
+        }
+    }
+
+    public static boolean canMerge(ItemEntity itemEntity) {
+        ItemStack itemStack = itemEntity.getItem();
+        return !itemStack.isEmpty() && itemStack.getCount() < itemStack.getMaxStackSize();
+    }
+
+    public static boolean mergeEntityItems(ItemEntity itemEntity, ItemEntity otherItemEntity) {
+        ItemStack itemOfEntity = itemEntity.getItem();
+        ItemStack itemOfOtherEntity = otherItemEntity.getItem();
+        if (ItemEntity.areMergable(itemOfEntity, itemOfOtherEntity)) {
+            if (!CraftEventFactory.callItemMergeEvent(otherItemEntity, itemEntity).isCancelled()) {
+                mergeItemsInternal(itemEntity, itemOfEntity, itemOfOtherEntity);
+                itemEntity.age = Math.max(itemEntity.age, otherItemEntity.age);
+                itemEntity.pickupDelay = Math.max(itemEntity.pickupDelay, otherItemEntity.pickupDelay);
+                if (itemOfOtherEntity.isEmpty()) {
+                    otherItemEntity.discard();
+                }
+            }
+        }
+
+        return !itemEntity.isAlive();
+    }
+
+    private static void mergeItemsInternal(ItemEntity itemEntity, ItemStack itemStack, ItemStack otherItem) {
+        ItemStack leftOver = ItemEntity.merge(itemStack, otherItem, itemStack.getMaxStackSize());
+        if (!leftOver.isEmpty()) {
+            itemEntity.setItem(leftOver);
+        }
+    }
+
+}