3.6.9

compatibility-crucible-r1/build.gradle.kts

@@ -0,0 +1,26 @@
+repositories {
+    mavenCentral()
+    maven("https://repo.papermc.io/repository/maven-public/")
+    maven("https://mvn.lumine.io/repository/maven-public/")
+}
+
+dependencies {
+    compileOnly(project(":api"))
+    compileOnly(project(":common"))
+    compileOnly("io.papermc.paper:paper-api:1.20.4-R0.1-SNAPSHOT")
+    compileOnly("io.lumine:Mythic-Dist:5.7.1")
+    compileOnly("io.lumine:MythicCrucible-Dist:2.1.0-SNAPSHOT")
+}
+
+tasks.withType<JavaCompile> {
+    options.encoding = "UTF-8"
+    options.release.set(17)
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(21)
+    }
+}

compatibility-crucible-r1/src/main/java/net/momirealms/customcrops/bukkit/integration/custom/crucible_r1/CrucibleListener.java

@@ -0,0 +1,173 @@
+/*
+ *  Copyright (C) <2024> <XiaoMoMi>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package net.momirealms.customcrops.bukkit.integration.custom.crucible_r1;
+
+import io.lumine.mythic.api.adapters.AbstractLocation;
+import io.lumine.mythic.bukkit.adapters.BukkitEntity;
+import io.lumine.mythiccrucible.events.MythicFurniturePlaceEvent;
+import io.lumine.mythiccrucible.events.MythicFurnitureRemoveEvent;
+import io.lumine.mythiccrucible.items.blocks.CustomBlockItemContext;
+import net.momirealms.customcrops.api.core.AbstractCustomEventListener;
+import net.momirealms.customcrops.api.core.AbstractItemManager;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Interaction;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+public class CrucibleListener extends AbstractCustomEventListener {
+
+    private final CrucibleProvider provider;
+
+    private static final Set<Material> IGNORED = new HashSet<>(
+            List.of(
+                    Material.NOTE_BLOCK,
+                    Material.RED_MUSHROOM_BLOCK,
+                    Material.BROWN_MUSHROOM_BLOCK,
+                    Material.MUSHROOM_STEM,
+                    Material.TRIPWIRE,
+                    Material.CHORUS_PLANT
+            )
+    );
+
+    @Override
+    protected Set<Material> ignoredMaterials() {
+        return IGNORED;
+    }
+
+    public CrucibleListener(AbstractItemManager itemManager, CrucibleProvider provider) {
+        super(itemManager);
+        this.provider = provider;
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.LOW)
+    public void onInteractFurniture(PlayerInteractEntityEvent event) {
+        if (event.getRightClicked() instanceof Interaction interaction) {
+            provider.getFurnitureManager().getFurniture(interaction).ifPresent(furniture -> {
+                AbstractLocation location = furniture.getLocation();
+                itemManager.handlePlayerInteractFurniture(
+                        event.getPlayer(),
+                        new Location(event.getPlayer().getWorld(), location.getX(), location.getY(), location.getZ()),
+                        furniture.getFurnitureData().getItem().getInternalName(),
+                        event.getHand(),
+                        event.getPlayer().getInventory().getItem(event.getHand()),
+                        event
+                );
+            });
+        } else {
+            provider.getFurnitureManager().getFurniture(new BukkitEntity(event.getRightClicked())).ifPresent(furniture -> {
+                AbstractLocation location = furniture.getLocation();
+                itemManager.handlePlayerInteractFurniture(
+                        event.getPlayer(),
+                        new Location(event.getPlayer().getWorld(), location.getX(), location.getY(), location.getZ()),
+                        furniture.getFurnitureData().getItem().getInternalName(),
+                        event.getHand(),
+                        event.getPlayer().getInventory().getItem(event.getHand()),
+                        event
+                );
+            });
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.LOW)
+    public void onInteractCustomBlock(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_BLOCK)
+            return;
+        Block clicked = event.getClickedBlock();
+        provider.getBlockManager().getBlockFromBlock(clicked).ifPresent(block -> {
+            itemManager.handlePlayerInteractBlock(
+                    event.getPlayer(),
+                    clicked,
+                    block.getCrucibleItem().getInternalName(),
+                    event.getBlockFace(),
+                    event.getHand(),
+                    event.getItem(),
+                    event
+            );
+        });
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onBreakFurniture(MythicFurnitureRemoveEvent event) {
+        if (event.getBreaker() instanceof Player player) {
+            AbstractLocation location = event.getFurniture().getLocation();
+            itemManager.handlePlayerBreak(
+                    player,
+                    new Location(player.getWorld(), location.getX(), location.getY(), location.getZ()),
+                    player.getInventory().getItemInMainHand(),
+                    event.getFurniture().getFurnitureData().getItem().getInternalName(),
+                    event
+            );
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.LOW)
+    public void onBreakCustomBlock(BlockBreakEvent event) {
+        Player player = event.getPlayer();
+        Optional<CustomBlockItemContext> maybeBlock = provider.getBlockManager().getBlockFromBlock(event.getBlock());
+        maybeBlock.ifPresent(block -> {
+            itemManager.handlePlayerBreak(
+                    player,
+                    event.getBlock().getLocation(),
+                    event.getPlayer().getInventory().getItemInMainHand(),
+                    block.getCrucibleItem().getInternalName(),
+                    event
+            );
+        });
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onPlaceFurniture(MythicFurniturePlaceEvent event) {
+        itemManager.handlePlayerPlace(
+                event.getPlayer(),
+                event.getBlock().getLocation(),
+                event.getFurnitureItemContext().getItem().getInternalName(),
+                EquipmentSlot.HAND,
+                event.getPlayer().getInventory().getItemInMainHand(),
+                event
+        );
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
+    public void onPlaceCustomBlock(BlockPlaceEvent event) {
+        ItemStack itemStack = event.getItemInHand();
+        Optional<CustomBlockItemContext> maybeBlock = provider.getBlockManager().getBlockFromItem(itemStack);
+        maybeBlock.ifPresent(customBlockItemContext -> itemManager.handlePlayerPlace(
+                event.getPlayer(),
+                event.getBlock().getLocation(),
+                customBlockItemContext.getCrucibleItem().getInternalName(),
+                event.getHand(),
+                event.getItemInHand(),
+                event
+        ));
+    }
+}

compatibility-crucible-r1/src/main/java/net/momirealms/customcrops/bukkit/integration/custom/crucible_r1/CrucibleProvider.java

@@ -0,0 +1,147 @@
+/*
+ *  Copyright (C) <2024> <XiaoMoMi>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package net.momirealms.customcrops.bukkit.integration.custom.crucible_r1;
+
+import io.lumine.mythic.bukkit.BukkitAdapter;
+import io.lumine.mythic.bukkit.adapters.BukkitEntity;
+import io.lumine.mythiccrucible.MythicCrucible;
+import io.lumine.mythiccrucible.items.CrucibleItem;
+import io.lumine.mythiccrucible.items.ItemManager;
+import io.lumine.mythiccrucible.items.blocks.CustomBlockItemContext;
+import io.lumine.mythiccrucible.items.blocks.CustomBlockManager;
+import io.lumine.mythiccrucible.items.furniture.Furniture;
+import io.lumine.mythiccrucible.items.furniture.FurnitureManager;
+import net.momirealms.customcrops.api.core.CustomItemProvider;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Interaction;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.Optional;
+
+public class CrucibleProvider implements CustomItemProvider {
+
+    private final ItemManager itemManager;
+    private final CustomBlockManager blockManager;
+    private final FurnitureManager furnitureManager;
+
+    public CrucibleProvider() {
+        this.itemManager = MythicCrucible.inst().getItemManager();
+        this.blockManager = itemManager.getCustomBlockManager();
+        this.furnitureManager = itemManager.getFurnitureManager();
+    }
+
+    @Override
+    public boolean removeCustomBlock(Location location) {
+        Block block = location.getBlock();
+        Optional<CustomBlockItemContext> optionalContext = blockManager.getBlockFromBlock(block);
+        if (optionalContext.isPresent()) {
+            block.setType(Material.AIR, false);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean placeCustomBlock(Location location, String id) {
+        Optional<CrucibleItem> optionalCI = itemManager.getItem(id);
+        if (optionalCI.isPresent()) {
+            location.getBlock().setBlockData(optionalCI.get().getBlockData().getBlockData(), false);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public @Nullable Entity placeFurniture(Location location, String id) {
+        Optional<CrucibleItem> optionalCI = itemManager.getItem(id);
+        return optionalCI.map(crucibleItem -> crucibleItem.getFurnitureData().placeFrame(location.getBlock(), BlockFace.UP, 0f, null)).orElse(null);
+    }
+
+    @Override
+    public boolean removeFurniture(Entity entity) {
+        if (isFurniture(entity)) {
+            Optional<Furniture> optionalFurniture = furnitureManager.getFurniture(new BukkitEntity(entity));
+            if (optionalFurniture.isPresent()) {
+                Furniture furniture = optionalFurniture.get();
+                furniture.getFurnitureData().remove(furniture, null, false, false);
+            }
+            return true;
+        } else if (entity instanceof Interaction interaction) {
+            Optional<Furniture> optionalFurniture = furnitureManager.getFurniture(interaction);
+            if (optionalFurniture.isPresent()) {
+                Furniture furniture = optionalFurniture.get();
+                furniture.getFurnitureData().remove(furniture, null, false, false);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public @Nullable String blockID(Block block) {
+        Optional<CustomBlockItemContext> optionalContext = blockManager.getBlockFromBlock(block);
+        return optionalContext.map(customBlockItemContext -> customBlockItemContext.getCrucibleItem().getInternalName()).orElse(null);
+    }
+
+    @Override
+    public @Nullable String itemID(ItemStack itemStack) {
+        Optional<CrucibleItem> optionalCI = itemManager.getItem(itemStack);
+        return optionalCI.map(CrucibleItem::getInternalName).orElse(null);
+    }
+
+    @Override
+    public @Nullable ItemStack itemStack(Player player, String id) {
+        Optional<CrucibleItem> optionalCI = itemManager.getItem(id);
+        return optionalCI.map(crucibleItem -> BukkitAdapter.adapt(crucibleItem.getMythicItem().generateItemStack(1))).orElse(null);
+    }
+
+    @Override
+    public @Nullable String furnitureID(Entity entity) {
+        if (entity instanceof Interaction interaction) {
+            Optional<Furniture> optionalFurniture = furnitureManager.getFurniture(interaction);
+            return optionalFurniture.map(furniture -> furniture.getFurnitureData().getItem().getInternalName()).orElse(null);
+        } else {
+            Optional<Furniture> optionalFurniture = furnitureManager.getFurniture(new BukkitEntity(entity));
+            return optionalFurniture.map(furniture -> furniture.getFurnitureData().getItem().getInternalName()).orElse(null);
+        }
+    }
+
+    @Override
+    public boolean isFurniture(Entity entity) {
+        return furnitureManager.isFurniture(new BukkitEntity(entity));
+    }
+
+    public ItemManager getItemManager() {
+        return itemManager;
+    }
+
+    public CustomBlockManager getBlockManager() {
+        return blockManager;
+    }
+
+    public FurnitureManager getFurnitureManager() {
+        return furnitureManager;
+    }
+}

gradle.properties

@@ -1,6 +1,6 @@
 # Project settings
 # Rule: [major update].[feature update].[bug fix]
-project_version=3.6.8
+project_version=3.6.9
 config_version=39
 project_group=net.momirealms
 
@@ -31,7 +31,7 @@ caffeine_version=3.1.8
 rtag_version=1.5.6
 exp4j_version=0.4.8
 placeholder_api_version=2.11.6
-anti_grief_version=0.12
+anti_grief_version=0.13
 zstd_version=1.5.6-5
 flow_nbt_version=2.0.2
 guava_version=33.2.0-jre

plugin/build.gradle.kts

@@ -25,6 +25,7 @@ dependencies {
     implementation(project(":compatibility-oraxen-r1"))
     implementation(project(":compatibility-oraxen-r2"))
     implementation(project(":compatibility-itemsadder-r1"))
+    implementation(project(":compatibility-crucible-r1"))
     implementation(project(":compatibility-asp-r1"))
 
     implementation("net.kyori:adventure-api:${rootProject.properties["adventure_bundle_version"]}")

plugin/src/main/java/net/momirealms/customcrops/bukkit/item/BukkitItemManager.java

@@ -156,6 +156,8 @@ public class BukkitItemManager extends AbstractItemManager {
             Constructor<?> oraxenListenerConstructor = oraxenListenerClass.getDeclaredConstructor(AbstractItemManager.class);
             oraxenListenerConstructor.setAccessible(true);
             this.setCustomEventListener((AbstractCustomEventListener) oraxenListenerConstructor.newInstance(this));
+
+            plugin.getPluginLogger().info("Oraxen hooked!");
         } else if (PluginUtils.isEnabled("ItemsAdder")) {
             String rVersion = "r1";
             Class<?> itemsAdderProviderClass = Class.forName("net.momirealms.customcrops.bukkit.integration.custom.itemsadder_" + rVersion + ".ItemsAdderProvider");
@@ -167,6 +169,21 @@ public class BukkitItemManager extends AbstractItemManager {
             Constructor<?> itemsAdderListenerConstructor = itemsAdderListenerClass.getDeclaredConstructor(AbstractItemManager.class);
             itemsAdderListenerConstructor.setAccessible(true);
             this.setCustomEventListener((AbstractCustomEventListener) itemsAdderListenerConstructor.newInstance(this));
+
+            plugin.getPluginLogger().info("ItemsAdder hooked!");
+        } else if (PluginUtils.isEnabled("MythicCrucible")) {
+            String rVersion = "r1";
+            Class<?> crucibleProviderClass = Class.forName("net.momirealms.customcrops.bukkit.integration.custom.crucible_" + rVersion + ".CrucibleProvider");
+            Constructor<?> crucibleProviderConstructor = crucibleProviderClass.getDeclaredConstructor();
+            crucibleProviderConstructor.setAccessible(true);
+            this.provider = (CustomItemProvider) crucibleProviderConstructor.newInstance();
+
+            Class<?> crucibleListenerClass = Class.forName("net.momirealms.customcrops.bukkit.integration.custom.crucible_" + rVersion + ".CrucibleListener");
+            Constructor<?> crucibleListenerConstructor = crucibleListenerClass.getDeclaredConstructor(AbstractItemManager.class, crucibleProviderClass);
+            crucibleListenerConstructor.setAccessible(true);
+            this.setCustomEventListener((AbstractCustomEventListener) crucibleListenerConstructor.newInstance(this, this.provider));
+
+            plugin.getPluginLogger().info("MythicCrucible hooked!");
         }
     }
 
@@ -330,7 +347,7 @@ public class BukkitItemManager extends AbstractItemManager {
             try {
                 return new ItemStack(Material.valueOf(id.toUpperCase(Locale.ENGLISH)));
             } catch (IllegalArgumentException e) {
-                plugin.getPluginLogger().severe("Item " + id + " not exists", e);
+                plugin.getPluginLogger().warn("Item " + id + " not exists", e);
                 return new ItemStack(Material.PAPER);
             }
         } else {

plugin/src/main/resources/plugin.yml

@@ -9,6 +9,7 @@ softdepend:
   - Vault
   - ItemsAdder
   - Oraxen
+  - MythicCrucible
   - PlaceholderAPI
   - BattlePass
   - BetonQuest

settings.gradle.kts

@@ -7,6 +7,7 @@ include(":compatibility-asp-r1")
 include(":compatibility-oraxen-r1")
 include(":compatibility-oraxen-r2")
 include(":compatibility-itemsadder-r1")
+include(":compatibility-crucible-r1")