diff --git a/compatibility-crucible-r1/build.gradle.kts b/compatibility-crucible-r1/build.gradle.kts new file mode 100644 index 0000000..8ed7a91 --- /dev/null +++ b/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 { + options.encoding = "UTF-8" + options.release.set(17) +} + +java { + sourceCompatibility = JavaVersion.VERSION_21 + targetCompatibility = JavaVersion.VERSION_21 + toolchain { + languageVersion = JavaLanguageVersion.of(21) + } +} \ No newline at end of file diff --git a/compatibility-crucible-r1/src/main/java/net/momirealms/customcrops/bukkit/integration/custom/crucible_r1/CrucibleListener.java b/compatibility-crucible-r1/src/main/java/net/momirealms/customcrops/bukkit/integration/custom/crucible_r1/CrucibleListener.java new file mode 100644 index 0000000..75d89ae --- /dev/null +++ b/compatibility-crucible-r1/src/main/java/net/momirealms/customcrops/bukkit/integration/custom/crucible_r1/CrucibleListener.java @@ -0,0 +1,173 @@ +/* + * Copyright (C) <2024> + * + * 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 . + */ + +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 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 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 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 maybeBlock = provider.getBlockManager().getBlockFromItem(itemStack); + maybeBlock.ifPresent(customBlockItemContext -> itemManager.handlePlayerPlace( + event.getPlayer(), + event.getBlock().getLocation(), + customBlockItemContext.getCrucibleItem().getInternalName(), + event.getHand(), + event.getItemInHand(), + event + )); + } +} diff --git a/compatibility-crucible-r1/src/main/java/net/momirealms/customcrops/bukkit/integration/custom/crucible_r1/CrucibleProvider.java b/compatibility-crucible-r1/src/main/java/net/momirealms/customcrops/bukkit/integration/custom/crucible_r1/CrucibleProvider.java new file mode 100644 index 0000000..e78fbe0 --- /dev/null +++ b/compatibility-crucible-r1/src/main/java/net/momirealms/customcrops/bukkit/integration/custom/crucible_r1/CrucibleProvider.java @@ -0,0 +1,147 @@ +/* + * Copyright (C) <2024> + * + * 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 . + */ + +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 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 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 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 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 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 optionalContext = blockManager.getBlockFromBlock(block); + return optionalContext.map(customBlockItemContext -> customBlockItemContext.getCrucibleItem().getInternalName()).orElse(null); + } + + @Override + public @Nullable String itemID(ItemStack itemStack) { + Optional optionalCI = itemManager.getItem(itemStack); + return optionalCI.map(CrucibleItem::getInternalName).orElse(null); + } + + @Override + public @Nullable ItemStack itemStack(Player player, String id) { + Optional 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 optionalFurniture = furnitureManager.getFurniture(interaction); + return optionalFurniture.map(furniture -> furniture.getFurnitureData().getItem().getInternalName()).orElse(null); + } else { + Optional 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; + } +} diff --git a/gradle.properties b/gradle.properties index 30b469d..d79bb46 100644 --- a/gradle.properties +++ b/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 diff --git a/plugin/build.gradle.kts b/plugin/build.gradle.kts index fe5b781..a4c4abd 100644 --- a/plugin/build.gradle.kts +++ b/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"]}") diff --git a/plugin/src/main/java/net/momirealms/customcrops/bukkit/item/BukkitItemManager.java b/plugin/src/main/java/net/momirealms/customcrops/bukkit/item/BukkitItemManager.java index ebbca6e..64dd96d 100644 --- a/plugin/src/main/java/net/momirealms/customcrops/bukkit/item/BukkitItemManager.java +++ b/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 { diff --git a/plugin/src/main/resources/plugin.yml b/plugin/src/main/resources/plugin.yml index 4432501..9de2047 100644 --- a/plugin/src/main/resources/plugin.yml +++ b/plugin/src/main/resources/plugin.yml @@ -9,6 +9,7 @@ softdepend: - Vault - ItemsAdder - Oraxen + - MythicCrucible - PlaceholderAPI - BattlePass - BetonQuest diff --git a/settings.gradle.kts b/settings.gradle.kts index 760b8fd..ad375cc 100644 --- a/settings.gradle.kts +++ b/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")