From 73e5d676fd6b4b7f780dd937cb406a30d4dbfdb9 Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Tue, 6 Jan 2026 10:08:03 +0200 Subject: [PATCH 01/15] Implement providers --- .../eco/internal/spigot/EcoSpigotPlugin.kt | 7 +- .../customblocks/CustomBlocksCraftEngine.kt | 67 +++++++++++++++++++ .../customblocks/CustomBlocksItemsAdder.kt | 42 ++++++++++++ .../customblocks/CustomBlocksNexo.kt | 59 ++++++++++++++++ .../customblocks/CustomBlocksOraxen.kt | 10 ++- .../customitems/CustomItemsCraftEngine.kt | 4 +- .../customitems/CustomItemsOraxen.kt | 4 +- 7 files changed, 185 insertions(+), 8 deletions(-) create mode 100644 eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksCraftEngine.kt create mode 100644 eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksItemsAdder.kt create mode 100644 eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt index 365bbf49d..4f5fd577d 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt @@ -111,6 +111,9 @@ import com.willfp.eco.internal.spigot.integrations.antigrief.AntigriefRPGHorses import com.willfp.eco.internal.spigot.integrations.antigrief.AntigriefSuperiorSkyblock2 import com.willfp.eco.internal.spigot.integrations.antigrief.AntigriefTowny import com.willfp.eco.internal.spigot.integrations.antigrief.AntigriefWorldGuard +import com.willfp.eco.internal.spigot.integrations.customblocks.CustomBlocksCraftEngine +import com.willfp.eco.internal.spigot.integrations.customblocks.CustomBlocksItemsAdder +import com.willfp.eco.internal.spigot.integrations.customblocks.CustomBlocksNexo import com.willfp.eco.internal.spigot.integrations.customblocks.CustomBlocksOraxen import com.willfp.eco.internal.spigot.integrations.customentities.CustomEntitiesMythicMobs import com.willfp.eco.internal.spigot.integrations.customitems.CustomItemsCraftEngine @@ -160,7 +163,6 @@ import org.bukkit.Bukkit import org.bukkit.Material import org.bukkit.event.Listener import org.bukkit.inventory.ItemStack -import kotlin.jvm.java import su.nightexpress.coinsengine.api.CoinsEngineAPI abstract class EcoSpigotPlugin : EcoPlugin() { @@ -427,6 +429,9 @@ abstract class EcoSpigotPlugin : EcoPlugin() { // Custom Blocks IntegrationLoader("Oraxen") { CustomBlocksManager.register(CustomBlocksOraxen(this)) }, + IntegrationLoader("Nexo") { CustomBlocksManager.register(CustomBlocksNexo(this)) }, + IntegrationLoader("ItemsAdder") { CustomBlocksManager.register(CustomBlocksItemsAdder()) }, + IntegrationLoader("CraftEngine") { CustomBlocksManager.register(CustomBlocksCraftEngine(this)) }, // Misc IntegrationLoader("mcMMO") { McmmoManager.register(McmmoIntegrationImpl()) }, diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksCraftEngine.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksCraftEngine.kt new file mode 100644 index 000000000..8bfef1690 --- /dev/null +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksCraftEngine.kt @@ -0,0 +1,67 @@ +package com.willfp.eco.internal.spigot.integrations.customblocks + +import com.willfp.eco.core.EcoPlugin +import com.willfp.eco.core.blocks.Blocks +import com.willfp.eco.core.blocks.CustomBlock +import com.willfp.eco.core.blocks.TestableBlock +import com.willfp.eco.core.blocks.provider.BlockProvider +import com.willfp.eco.core.integrations.customblocks.CustomBlocksIntegration +import com.willfp.eco.util.namespacedKeyOf +import net.momirealms.craftengine.bukkit.api.CraftEngineBlocks +import net.momirealms.craftengine.bukkit.api.event.CraftEngineReloadEvent +import net.momirealms.craftengine.core.util.Key +import org.bukkit.block.Block +import org.bukkit.event.EventHandler +import org.bukkit.event.Listener +import java.util.function.Predicate + +class CustomBlocksCraftEngine( + private val plugin: EcoPlugin +) : CustomBlocksIntegration, Listener { + override fun registerProvider() { + plugin.eventManager.registerListener(this) + } + + override fun getPluginName(): String { + return "CraftEngine" + } + + @EventHandler + @Suppress("UNUSED_PARAMETER") + fun onItemRegister(event: CraftEngineReloadEvent) { + Blocks.registerBlockProvider(CraftEngineProvider()) + } + + private class CraftEngineProvider : BlockProvider("craftengine") { + override fun provideForKey(key: String): TestableBlock? { + val split = key.split(":").toMutableList() + + if (split.size < 2) { + return null + } + + val namespace = split[0] + val value = split[1] + + val id = Key.of(namespace, value) + val blockId = CraftEngineBlocks.byId(id) ?: return null + val namespacedKey = namespacedKeyOf("craftengine", key.lowercase().replace(":", "__")) + + return CustomBlock( + namespacedKey, + Predicate { test: Block -> + if (!CraftEngineBlocks.isCustomBlock(test)) { + return@Predicate false + } + val immutableBlockState = CraftEngineBlocks.getCustomBlockState(test) ?: return@Predicate false + return@Predicate immutableBlockState.owner().value().id().equals(id) + }, + { location -> + CraftEngineBlocks.place(location, id, true) + location.block + } + ) + } + + } +} \ No newline at end of file diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksItemsAdder.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksItemsAdder.kt new file mode 100644 index 000000000..2337f369d --- /dev/null +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksItemsAdder.kt @@ -0,0 +1,42 @@ +package com.willfp.eco.internal.spigot.integrations.customblocks + +import com.willfp.eco.core.blocks.Blocks +import com.willfp.eco.core.blocks.CustomBlock +import com.willfp.eco.core.blocks.TestableBlock +import com.willfp.eco.core.blocks.provider.BlockProvider +import com.willfp.eco.core.integrations.customblocks.CustomBlocksIntegration +import com.willfp.eco.util.NamespacedKeyUtils +import org.bukkit.block.Block +import java.util.function.Predicate + +class CustomBlocksItemsAdder : CustomBlocksIntegration { + override fun registerProvider() { + Blocks.registerBlockProvider(ItemsAdderProvider()) + } + + override fun getPluginName(): String { + return "ItemsAdder" + } + + private class ItemsAdderProvider : BlockProvider("itemsadder") { + override fun provideForKey(key: String): TestableBlock? { + val internalId = if (key.contains(":")) key else "itemsadder:$key" + + val block = dev.lone.itemsadder.api.CustomBlock.getInstance(internalId) ?: return null + val id = block.id + val namespacedKey = NamespacedKeyUtils.create("itemsadder", key.lowercase().replace(":", "__")) + return CustomBlock( + namespacedKey, + Predicate { test: Block -> + val customStack = + dev.lone.itemsadder.api.CustomBlock.byAlreadyPlaced(test) ?: return@Predicate false + customStack.id.equals(id, ignoreCase = true) + }, + { location -> + dev.lone.itemsadder.api.CustomBlock.place(id, location) + location.block + } + ) + } + } +} diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt new file mode 100644 index 000000000..6d0d4fef7 --- /dev/null +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt @@ -0,0 +1,59 @@ +package com.willfp.eco.internal.spigot.integrations.customblocks + +import com.nexomc.nexo.api.NexoBlocks +import com.nexomc.nexo.api.NexoItems +import com.nexomc.nexo.api.events.NexoItemsLoadedEvent +import com.willfp.eco.core.EcoPlugin +import com.willfp.eco.core.blocks.Blocks +import com.willfp.eco.core.blocks.CustomBlock +import com.willfp.eco.core.blocks.TestableBlock +import com.willfp.eco.core.blocks.provider.BlockProvider +import com.willfp.eco.core.integrations.customblocks.CustomBlocksIntegration +import com.willfp.eco.util.namespacedKeyOf +import io.th0rgal.oraxen.api.OraxenBlocks +import org.bukkit.event.EventHandler +import org.bukkit.event.Listener + +class CustomBlocksNexo( + private val plugin: EcoPlugin +) : CustomBlocksIntegration, Listener { + override fun registerProvider() { + plugin.eventManager.registerListener(this) + } + + override fun getPluginName(): String { + return "Nexo" + } + + @EventHandler + @Suppress("UNUSED_PARAMETER") + fun onItemRegister(event: NexoItemsLoadedEvent) { + Blocks.registerBlockProvider(NexoProvider()) + } + + private class NexoProvider : BlockProvider("nexo") { + override fun provideForKey(key: String): TestableBlock? { + // The key + if (!NexoBlocks.isCustomBlock(key)) { + return null + } + + val item = NexoItems.itemFromId(key) ?: return null + val id = NexoItems.idFromItem(item) + + val namespacedKey = namespacedKeyOf("oraxen", key) + + return CustomBlock( + namespacedKey, + { + NexoBlocks.isCustomBlock(it) && + id.equals(NexoBlocks.customBlockMechanic(it.location)?.itemID, ignoreCase = true) + }, + { location -> + OraxenBlocks.place(key, location) + location.block + } + ) + } + } +} diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt index 97ddebb3e..0fddb9e5e 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt @@ -8,6 +8,7 @@ import com.willfp.eco.core.blocks.provider.BlockProvider import com.willfp.eco.core.integrations.customblocks.CustomBlocksIntegration import com.willfp.eco.util.namespacedKeyOf import io.th0rgal.oraxen.api.OraxenBlocks +import io.th0rgal.oraxen.api.OraxenItems import io.th0rgal.oraxen.api.events.OraxenItemsLoadedEvent import org.bukkit.event.EventHandler import org.bukkit.event.Listener @@ -36,13 +37,16 @@ class CustomBlocksOraxen( return null } + val item = OraxenItems.getItemById(key) ?: return null + val id = OraxenItems.getIdByItem(item) + val namespacedKey = namespacedKeyOf("oraxen", key) return CustomBlock( namespacedKey, - { block -> - // TODO: Implement this - TODO("Not yet implemented") + { + OraxenBlocks.isOraxenBlock(it) && + id.equals(OraxenBlocks.getOraxenBlock(it.location).itemID, ignoreCase = true) }, { location -> OraxenBlocks.place(key, location) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsCraftEngine.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsCraftEngine.kt index d6c371841..68a0ab5ef 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsCraftEngine.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsCraftEngine.kt @@ -6,7 +6,7 @@ import com.willfp.eco.core.items.CustomItem import com.willfp.eco.core.items.Items import com.willfp.eco.core.items.TestableItem import com.willfp.eco.core.items.provider.ItemProvider -import com.willfp.eco.util.NamespacedKeyUtils +import com.willfp.eco.util.namespacedKeyOf import net.momirealms.craftengine.bukkit.api.CraftEngineItems import net.momirealms.craftengine.bukkit.api.event.CraftEngineReloadEvent import net.momirealms.craftengine.core.util.Key @@ -45,7 +45,7 @@ class CustomItemsCraftEngine( val id = Key.of(namespace, value) val item = CraftEngineItems.byId(id) ?: return null - val namespacedKey = NamespacedKeyUtils.create("craftengine", key.lowercase().replace(":", "__")) + val namespacedKey = namespacedKeyOf("craftengine", key.lowercase().replace(":", "__")) val stack = item.buildItemStack() return CustomItem( diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsOraxen.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsOraxen.kt index 9b4c7fb1a..c822a9b65 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsOraxen.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsOraxen.kt @@ -6,7 +6,7 @@ import com.willfp.eco.core.items.CustomItem import com.willfp.eco.core.items.Items import com.willfp.eco.core.items.TestableItem import com.willfp.eco.core.items.provider.ItemProvider -import com.willfp.eco.util.NamespacedKeyUtils +import com.willfp.eco.util.namespacedKeyOf import io.th0rgal.oraxen.api.OraxenItems import io.th0rgal.oraxen.api.events.OraxenItemsLoadedEvent import org.bukkit.event.EventHandler @@ -33,7 +33,7 @@ class CustomItemsOraxen( override fun provideForKey(key: String): TestableItem? { val item = OraxenItems.getItemById(key) ?: return null val id = OraxenItems.getIdByItem(item) - val namespacedKey = NamespacedKeyUtils.create("oraxen", id) + val namespacedKey = namespacedKeyOf("oraxen", id) return CustomItem( namespacedKey, { id.equals(OraxenItems.getIdByItem(it), ignoreCase = true) }, From 250fc2153c191cd02c8bae06ca709b2d08354be4 Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Tue, 6 Jan 2026 12:31:43 +0200 Subject: [PATCH 02/15] Utility & Tags --- .../com/willfp/eco/core/blocks/Blocks.java | 295 +++++++++++++++++- .../willfp/eco/core/blocks/TestableBlock.java | 11 + .../willfp/eco/core/blocks/tag/BlockTag.java | 58 ++++ .../eco/core/blocks/tag/CustomBlockTag.java | 29 ++ .../eco/core/blocks/tag/VanillaBlockTag.java | 54 ++++ .../com/willfp/eco/core/blocks/Blocks.kt | 27 ++ .../com/willfp/eco/internal/spigot/EcoImpl.kt | 7 + 7 files changed, 466 insertions(+), 15 deletions(-) create mode 100644 eco-api/src/main/java/com/willfp/eco/core/blocks/tag/BlockTag.java create mode 100644 eco-api/src/main/java/com/willfp/eco/core/blocks/tag/CustomBlockTag.java create mode 100644 eco-api/src/main/java/com/willfp/eco/core/blocks/tag/VanillaBlockTag.java create mode 100644 eco-api/src/main/kotlin/com/willfp/eco/core/blocks/Blocks.kt diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java index 1e75d5dd2..9e83394e0 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java @@ -1,20 +1,30 @@ package com.willfp.eco.core.blocks; +import com.github.benmanes.caffeine.cache.Caffeine; +import com.github.benmanes.caffeine.cache.LoadingCache; import com.willfp.eco.core.blocks.impl.EmptyTestableBlock; import com.willfp.eco.core.blocks.impl.MaterialTestableBlock; import com.willfp.eco.core.blocks.impl.UnrestrictedMaterialTestableBlock; import com.willfp.eco.core.blocks.provider.BlockProvider; +import com.willfp.eco.core.blocks.tag.BlockTag; +import com.willfp.eco.core.items.CustomItem; +import com.willfp.eco.core.items.HashedItem; +import com.willfp.eco.core.items.args.LookupArgParser; import com.willfp.eco.util.NamespacedKeyUtils; +import com.willfp.eco.util.NumberUtils; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.NamespacedKey; import org.bukkit.block.Block; +import org.bukkit.inventory.ItemStack; +import org.bukkit.inventory.meta.ItemMeta; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; -import java.util.HashSet; -import java.util.Map; -import java.util.Set; +import java.util.*; import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; /** * Class to manage all custom and vanilla blocks. @@ -25,6 +35,25 @@ public final class Blocks { */ private static final Map REGISTRY = new ConcurrentHashMap<>(); + /** + * Cached custom item lookups, using {@link HashedItem}. + */ + private static final LoadingCache> CACHE = Caffeine.newBuilder() + .expireAfterAccess(10, TimeUnit.MINUTES) + .build( + key -> { + TestableBlock match = null; + for (TestableBlock block : REGISTRY.values()) { + if (block.shouldMarkAsCustom() && block.matches(key.getBlock())) { + match = block; + break; + } + } + + return Optional.ofNullable(match); + } + ); + /** * All block providers. */ @@ -35,6 +64,21 @@ public final class Blocks { */ private static final BlocksLookupHandler BLOCKS_LOOKUP_HANDLER = new BlocksLookupHandler(Blocks::doParse); + /** + * Instance of EmptyTestableBlock. + */ + private static final TestableBlock EMPTY_TESTABLE_BLOCK = new EmptyTestableBlock(); + + /** + * Friendly material names (without underscores, etc.) + */ + private static final Map FRIENDLY_MATERIAL_NAMES = new HashMap<>(); + + /** + * All tags. + */ + private static final Map TAGS = new HashMap<>(); + /** * Register a new custom block. * @@ -64,6 +108,31 @@ public static void removeCustomBlock(@NotNull final NamespacedKey key) { REGISTRY.remove(key); } + /** + * Turn an Block back into a lookup string. + * + * @param block The Block. + * @return The lookup string. + */ + @NotNull + public static String toLookupString(@Nullable final Block block) { + if (block == null) { + return ""; + } + + StringBuilder builder = new StringBuilder(); + + CustomBlock customblock = getCustomBlock(block); + + if (customblock != null) { + builder.append(customblock.getKey()); + } else { + builder.append(block.getType().name().toLowerCase()); + } + + return builder.toString(); + } + /** * This is the backbone of the eco block system. *

@@ -88,14 +157,31 @@ private static TestableBlock doParse(@NotNull final String[] args) { } String[] split = args[0].toLowerCase().split(":"); + + String base = split[0]; + boolean isTag = base.startsWith("#"); + + if (isTag) { + String tag = base.substring(1); + BlockTag blockTag = TAGS.get(tag); + + if (blockTag == null) { + return new EmptyTestableBlock(); + } + return blockTag.toTestableBlock(); + } + if (split.length == 1) { - if (args[0].startsWith("*")) { - Material type = Material.getMaterial(args[0].substring(1)); - return (type == null) ? new EmptyTestableBlock() : new UnrestrictedMaterialTestableBlock(type); - } else { - Material type = Material.getMaterial(args[0].toUpperCase()); - return (type == null) ? new EmptyTestableBlock() : new MaterialTestableBlock(type); + String blockType = args[0]; + boolean isWildcard = blockType.startsWith("*"); + if (isWildcard) { + blockType = blockType.substring(1); } + Material material = FRIENDLY_MATERIAL_NAMES.get(blockType.toLowerCase()); + if (material == null || material == Material.AIR) { + return new EmptyTestableBlock(); + } + return isWildcard ? new UnrestrictedMaterialTestableBlock(material) : new MaterialTestableBlock(material); } NamespacedKey namespacedKey = NamespacedKeyUtils.create(split[0], split[1]); @@ -119,6 +205,37 @@ private static TestableBlock doParse(@NotNull final String[] args) { return block; } + /** + * Get a Testable Block from a Block. + *

+ * Will search for registered blocks first. If there are no matches in the registry, + * then it will return a {@link MaterialTestableBlock} matching the block type. + *

+ * Does not account for modifiers (arg parser data). + * + * @param block The Block. + * @return The found Testable Block. + */ + @NotNull + public static TestableBlock getBlock(@Nullable final Block block) { + if (block == null || block.getType().isAir()) { + return new EmptyTestableBlock(); + } + + CustomBlock customBlock = getCustomBlock(block); + + if (customBlock != null) { + return customBlock; + } + + for (TestableBlock known : REGISTRY.values()) { + if (known.matches(block)) { + return known; + } + } + return new MaterialTestableBlock(block.getType()); + } + /** * Get if block is a custom block. * @@ -126,24 +243,172 @@ private static TestableBlock doParse(@NotNull final String[] args) { * @return If is custom. */ public static boolean isCustomBlock(@NotNull final Block block) { - for (TestableBlock testable : REGISTRY.values()) { - if (testable.matches(block)) { + return getCustomBlock(block) != null; + } + + /** + * Get custom block from block. + * + * @param block The block. + * @return The custom block, or null if not exists. + */ + @Nullable + public static CustomBlock getCustomBlock(@Nullable final Block block) { + if (block == null) { + return null; + } + + return CACHE.get(block.getLocation()).map(Blocks::getOrWrap).orElse(null); + } + + /** + * Get all registered custom blocks. + * + * @return A set of all blocks. + */ + public static Set getCustomBlocks() { + return REGISTRY.values().stream().map(Blocks::getOrWrap).collect(Collectors.toSet()); + } + + /** + * Return a CustomBlock instance for a given TestableBlock. + * + * @param block The block. + * @return The CustomBlock. + */ + @NotNull + public static CustomBlock getOrWrap(@NotNull final TestableBlock block) { + if (block instanceof CustomBlock) { + return (CustomBlock) block; + } else { + return new CustomBlock( + NamespacedKeyUtils.createEcoKey("wrapped_" + NumberUtils.randInt(0, 100000)), + block::matches, + block::place + ); + } + } + + /** + * Convert an array of materials to an array of testable blocks. + * + * @param materials The materials. + * @return An array of functionally identical testable blocks. + */ + @NotNull + public static TestableBlock[] fromMaterials(@NotNull final Material... materials) { + return Arrays.stream(materials) + .filter(Material::isBlock) + .map(MaterialTestableBlock::new) + .toArray(MaterialTestableBlock[]::new); + } + + /** + * Convert a collection of materials into a collection of testable blocks. + * + * @param materials The materials. + * @return A collection of functionally identical testable blocks. + */ + @NotNull + public static Collection fromMaterials(@NotNull final Iterable materials) { + List items = new ArrayList<>(); + for (Material material : materials) { + if (material.isBlock()) { + items.add(new MaterialTestableBlock(material)); + } + } + + return items; + } + + /** + * Get if an block is empty. + * + * @param block The block. + * @return If empty. + */ + public static boolean isEmpty(@Nullable final Block block) { + return EMPTY_TESTABLE_BLOCK.matches(block); + } + + /** + * Get if a block matches any blocks. + * + * @param block The block. + * @param testableBlocks The testable blocks. + * @return If matches any. + */ + public static boolean matchesAny(@Nullable final Block block, + @NotNull final Collection testableBlocks) { + for (TestableBlock testableBlock : testableBlocks) { + if (testableBlock.matches(block)) { return true; } } + return false; } /** - * Get all registered custom blocks. + * Get if any item matches any item. * - * @return A set of all blocks. + * @param blocks The blocks. + * @param testableBlocks The testable blocks. + * @return If matches any. + */ + public static boolean matchesAny(@NotNull final Collection blocks, + @NotNull final Collection testableBlocks) { + for (Block block : blocks) { + if (matchesAny(block, testableBlocks)) { + return true; + } + } + + return false; + } + + /** + * Register a new block tag. + * + * @param tag The tag. */ - public static Set getCustomBlocks() { - return new HashSet<>(REGISTRY.values()); + public static void registerTag(@NotNull final BlockTag tag) { + TAGS.put(tag.getIdentifier(), tag); + } + + /** + * Get all tags. + * + * @return All tags. + */ + public static Collection getTags() { + return TAGS.values(); } private Blocks() { throw new UnsupportedOperationException("This is a utility class and cannot be instantiated"); } + + static { + for (Material material : Material.values()) { + if (!material.isBlock()) continue; // skip not blocks + + FRIENDLY_MATERIAL_NAMES.put(material.name().toLowerCase(), material); + + String oneWord = material.name().toLowerCase().replace("_", ""); + if (!FRIENDLY_MATERIAL_NAMES.containsKey(oneWord)) { + FRIENDLY_MATERIAL_NAMES.put(oneWord, material); + } + + String plural = material.name().toLowerCase() + "s"; + if (!FRIENDLY_MATERIAL_NAMES.containsKey(plural)) { + FRIENDLY_MATERIAL_NAMES.put(plural, material); + } + + String oneWordPlural = oneWord + "s"; + if (!FRIENDLY_MATERIAL_NAMES.containsKey(oneWordPlural)) { + FRIENDLY_MATERIAL_NAMES.put(oneWordPlural, material); + } + } + } } diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/TestableBlock.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/TestableBlock.java index aa16e0fe1..1ca93533d 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/TestableBlock.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/TestableBlock.java @@ -28,4 +28,15 @@ public interface TestableBlock extends Testable { */ @NotNull Block place(@NotNull Location location); + + /** + * If an block matching this test should be marked as a custom block. + *

+ * This is true by default for backwards compatibility reasons. + * + * @return If the block should be marked as custom. + */ + default boolean shouldMarkAsCustom() { + return true; + } } diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/BlockTag.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/BlockTag.java new file mode 100644 index 000000000..afcaf4c74 --- /dev/null +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/BlockTag.java @@ -0,0 +1,58 @@ +package com.willfp.eco.core.blocks.tag; + +import com.willfp.eco.core.blocks.TestableBlock; +import com.willfp.eco.core.items.TestableItem; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.inventory.ItemStack; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +/** + * A group of items that share a common trait. + */ +public interface BlockTag { + /** + * Get the identifier of the tag. + * + * @return The identifier. + */ + @NotNull + String getIdentifier(); + + /** + * Check if an block matches the tag. + * + * @param block The block to check. + * @return If the block matches the tag. + */ + boolean matches(@NotNull Block block); + + /** + * Convert this tag to a testable item. + * + * @return The testable item. + */ + @NotNull + default TestableBlock toTestableBlock() { + return new TestableBlock() { + @Override + public boolean matches(@Nullable final Block block) { + return block != null && BlockTag.this.matches(block); + } + + @Override + public @NotNull Block place(@NotNull final Location location) { + return location.getBlock(); + } + + @Override + public String toString() { + return "BlockTagTestableBlock{" + + "tag=" + BlockTag.this.getIdentifier() + + '}'; + } + }; + } +} diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/CustomBlockTag.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/CustomBlockTag.java new file mode 100644 index 000000000..cb4412d6d --- /dev/null +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/CustomBlockTag.java @@ -0,0 +1,29 @@ +package com.willfp.eco.core.blocks.tag; + +import org.bukkit.NamespacedKey; +import org.jetbrains.annotations.NotNull; + +/** + * A custom item tag. + */ +public abstract class CustomBlockTag implements BlockTag { + /** + * The key. + */ + private final NamespacedKey key; + + /** + * Create a new custom block tag. + * + * @param key The key. + */ + public CustomBlockTag(@NotNull final NamespacedKey key) { + this.key = key; + } + + @Override + @NotNull + public String getIdentifier() { + return key.toString(); + } +} diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/VanillaBlockTag.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/VanillaBlockTag.java new file mode 100644 index 000000000..f54e3a176 --- /dev/null +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/VanillaBlockTag.java @@ -0,0 +1,54 @@ +package com.willfp.eco.core.blocks.tag; + +import org.bukkit.Material; +import org.bukkit.Tag; +import org.bukkit.block.Block; +import org.bukkit.inventory.ItemStack; +import org.jetbrains.annotations.NotNull; + +/** + * A vanilla block tag. + */ +public final class VanillaBlockTag implements BlockTag { + /** + * The identifier. + */ + private final String identifier; + + /** + * The tag. + */ + private final Tag tag; + + /** + * Create a new vanilla block tag. + * + * @param identifier The identifier. + * @param tag The tag. + */ + public VanillaBlockTag(@NotNull final String identifier, + @NotNull final Tag tag) { + this.identifier = identifier; + this.tag = tag; + } + + /** + * Get the tag. + * + * @return The tag. + */ + public Tag getTag() { + return tag; + } + + @Override + @NotNull + public String getIdentifier() { + return identifier; + } + + @Override + public boolean matches(@NotNull final Block block) { + return tag.isTagged(block.getType()); + } +} diff --git a/eco-api/src/main/kotlin/com/willfp/eco/core/blocks/Blocks.kt b/eco-api/src/main/kotlin/com/willfp/eco/core/blocks/Blocks.kt new file mode 100644 index 000000000..a48d7a61b --- /dev/null +++ b/eco-api/src/main/kotlin/com/willfp/eco/core/blocks/Blocks.kt @@ -0,0 +1,27 @@ +@file:JvmName("ItemsExtensions") + +package com.willfp.eco.core.blocks + +import com.willfp.eco.core.items.Items +import org.bukkit.block.Block + +/** @see Items.toLookupString */ +fun Block?.toLookupString(): String = + Blocks.toLookupString(this) + +/** @see Items.isEmpty */ +@Deprecated("Use Block.isEcoEmpty", ReplaceWith("Block.isEmpty(this)")) +val Block?.isEmpty: Boolean + get() = Blocks.isEmpty(this) + +/** @see Block.isEmpty */ +val Block?.isEcoEmpty: Boolean + get() = Blocks.isEmpty(this) + +/** @see Blocks.matchesAny */ +fun Collection.matches(block: Block): Boolean = + Blocks.matchesAny(block, this) + +/** @see Blocks.matchesAny */ +fun Collection.matches(blocks: Collection): Boolean = + Blocks.matchesAny(blocks, this) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoImpl.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoImpl.kt index fcbfa1db1..6eb5117c6 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoImpl.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoImpl.kt @@ -4,6 +4,7 @@ import com.willfp.eco.core.Eco import com.willfp.eco.core.EcoPlugin import com.willfp.eco.core.PluginLike import com.willfp.eco.core.PluginProps +import com.willfp.eco.core.blocks.Blocks import com.willfp.eco.core.command.CommandBase import com.willfp.eco.core.command.PluginCommandBase import com.willfp.eco.core.config.ConfigType @@ -248,6 +249,12 @@ class EcoImpl : EcoSpigotPlugin(), Eco { } } + for (customBlock in Blocks.getCustomBlocks()) { + if (customBlock.key.namespace.equals(plugin.name.lowercase(), ignoreCase = true)) { + Blocks.removeCustomBlock(customBlock.key) + } + } + val classLoader = plugin::class.java.classLoader if (classLoader is URLClassLoader) { From 50b2d3f6aa99b0155f4ec0963f919d58a5a85252 Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Tue, 6 Jan 2026 13:33:31 +0200 Subject: [PATCH 03/15] Fix Nexo and Oraxen --- .../spigot/integrations/customblocks/CustomBlocksNexo.kt | 6 ++++-- .../spigot/integrations/customblocks/CustomBlocksOraxen.kt | 7 ++++--- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt index 6d0d4fef7..6516a64b4 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt @@ -9,6 +9,7 @@ import com.willfp.eco.core.blocks.CustomBlock import com.willfp.eco.core.blocks.TestableBlock import com.willfp.eco.core.blocks.provider.BlockProvider import com.willfp.eco.core.integrations.customblocks.CustomBlocksIntegration +import com.willfp.eco.internal.spigot.data.handlers.impl.LegacyMongoDBPersistentDataHandler.Factory.id import com.willfp.eco.util.namespacedKeyOf import io.th0rgal.oraxen.api.OraxenBlocks import org.bukkit.event.EventHandler @@ -38,8 +39,9 @@ class CustomBlocksNexo( return null } - val item = NexoItems.itemFromId(key) ?: return null - val id = NexoItems.idFromItem(item) + if (!NexoItems.exists(key)) { + return null + } val namespacedKey = namespacedKeyOf("oraxen", key) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt index 0fddb9e5e..264926a05 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt @@ -37,8 +37,9 @@ class CustomBlocksOraxen( return null } - val item = OraxenItems.getItemById(key) ?: return null - val id = OraxenItems.getIdByItem(item) + if (!OraxenItems.exists(key)) { + return null + } val namespacedKey = namespacedKeyOf("oraxen", key) @@ -46,7 +47,7 @@ class CustomBlocksOraxen( namespacedKey, { OraxenBlocks.isOraxenBlock(it) && - id.equals(OraxenBlocks.getOraxenBlock(it.location).itemID, ignoreCase = true) + key.equals(OraxenBlocks.getOraxenBlock(it.location).itemID, ignoreCase = true) }, { location -> OraxenBlocks.place(key, location) From 03e34887fc5a60d8466a783f83f45eea8de7618b Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Wed, 7 Jan 2026 11:13:34 +0200 Subject: [PATCH 04/15] Work further on custom blocks --- .../com/willfp/eco/core/blocks/Blocks.java | 16 +++++----- .../eco/internal/spigot/EcoSpigotPlugin.kt | 29 ++++++++++++------- .../customblocks/CustomBlocksCraftEngine.kt | 4 +-- .../customblocks/CustomBlocksItemsAdder.kt | 4 +-- .../customblocks/CustomBlocksNexo.kt | 7 ++--- .../customblocks/CustomBlocksOraxen.kt | 2 +- 6 files changed, 36 insertions(+), 26 deletions(-) diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java index 9e83394e0..abd56530e 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java @@ -7,17 +7,15 @@ import com.willfp.eco.core.blocks.impl.UnrestrictedMaterialTestableBlock; import com.willfp.eco.core.blocks.provider.BlockProvider; import com.willfp.eco.core.blocks.tag.BlockTag; -import com.willfp.eco.core.items.CustomItem; import com.willfp.eco.core.items.HashedItem; -import com.willfp.eco.core.items.args.LookupArgParser; +import com.willfp.eco.core.items.provider.ItemProvider; +import com.willfp.eco.core.recipe.parts.EmptyTestableItem; import com.willfp.eco.util.NamespacedKeyUtils; import com.willfp.eco.util.NumberUtils; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.NamespacedKey; import org.bukkit.block.Block; -import org.bukkit.inventory.ItemStack; -import org.bukkit.inventory.meta.ItemMeta; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -184,19 +182,23 @@ private static TestableBlock doParse(@NotNull final String[] args) { return isWildcard ? new UnrestrictedMaterialTestableBlock(material) : new MaterialTestableBlock(material); } - NamespacedKey namespacedKey = NamespacedKeyUtils.create(split[0], split[1]); + String namespace = split[0]; + String keyID = split[1]; + NamespacedKey namespacedKey = NamespacedKeyUtils.create(namespace, keyID); TestableBlock block = REGISTRY.get(namespacedKey); if (block != null) { return block; } - BlockProvider provider = PROVIDERS.get(split[0]); + BlockProvider provider = PROVIDERS.get(namespace); if (provider == null) { return new EmptyTestableBlock(); } - block = provider.provideForKey(split[1]); + String reformattedKey = keyID.replace("__", ":"); + + block = provider.provideForKey(reformattedKey); if (block == null) { return new EmptyTestableBlock(); } diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt index 4f5fd577d..70d9b2b5a 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt @@ -230,6 +230,7 @@ abstract class EcoSpigotPlugin : EcoPlugin() { SegmentParserUseIfPresent.register() CustomItemsManager.registerProviders() + CustomBlocksManager.registerProviders() ExternalDataStore.registerAdapter(VersionToStringAdapter) // Handle with shadow. @@ -266,6 +267,7 @@ abstract class EcoSpigotPlugin : EcoPlugin() { } CustomItemsManager.registerProviders() // Do it again here + CustomBlocksManager.registerProviders() // Do it again here // Register events for ShopSellEvent for (integration in ShopManager.getRegisteredIntegrations()) { @@ -315,6 +317,7 @@ abstract class EcoSpigotPlugin : EcoPlugin() { override fun handleAfterLoad() { CustomItemsManager.registerAllItems() + CustomBlocksManager.registerAllBlocks() CustomEntitiesManager.registerAllEntities() ShopManager.registerEcoProvider() } @@ -363,10 +366,22 @@ abstract class EcoSpigotPlugin : EcoPlugin() { IntegrationLoader("MythicMobs") { CustomEntitiesManager.register(CustomEntitiesMythicMobs()) }, // Custom Items - IntegrationLoader("Oraxen") { CustomItemsManager.register(CustomItemsOraxen(this)) }, - IntegrationLoader("Nexo") { CustomItemsManager.register(CustomItemsNexo(this)) }, - IntegrationLoader("ItemsAdder") { CustomItemsManager.register(CustomItemsItemsAdder()) }, - IntegrationLoader("CraftEngine") { CustomItemsManager.register(CustomItemsCraftEngine(this)) }, + IntegrationLoader("Oraxen") { + CustomItemsManager.register(CustomItemsOraxen(this)) + CustomBlocksManager.register(CustomBlocksOraxen(this)) + }, + IntegrationLoader("Nexo") { + CustomItemsManager.register(CustomItemsNexo(this)) + CustomBlocksManager.register(CustomBlocksNexo(this)) + }, + IntegrationLoader("ItemsAdder") { + CustomItemsManager.register(CustomItemsItemsAdder()) + CustomBlocksManager.register(CustomBlocksItemsAdder()) + }, + IntegrationLoader("CraftEngine") { + CustomItemsManager.register(CustomItemsCraftEngine(this)) + CustomBlocksManager.register(CustomBlocksCraftEngine(this)) + }, IntegrationLoader("HeadDatabase") { CustomItemsManager.register(CustomItemsHeadDatabase(this)) }, IntegrationLoader("ExecutableItems") { CustomItemsManager.register(CustomItemsExecutableItems()) }, IntegrationLoader("CustomCrafting") { @@ -427,12 +442,6 @@ abstract class EcoSpigotPlugin : EcoPlugin() { // Placeholder IntegrationLoader("PlaceholderAPI") { PlaceholderManager.addIntegration(PlaceholderIntegrationPAPI()) }, - // Custom Blocks - IntegrationLoader("Oraxen") { CustomBlocksManager.register(CustomBlocksOraxen(this)) }, - IntegrationLoader("Nexo") { CustomBlocksManager.register(CustomBlocksNexo(this)) }, - IntegrationLoader("ItemsAdder") { CustomBlocksManager.register(CustomBlocksItemsAdder()) }, - IntegrationLoader("CraftEngine") { CustomBlocksManager.register(CustomBlocksCraftEngine(this)) }, - // Misc IntegrationLoader("mcMMO") { McmmoManager.register(McmmoIntegrationImpl()) }, IntegrationLoader("Multiverse-Inventories") { diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksCraftEngine.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksCraftEngine.kt index 8bfef1690..96e174d49 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksCraftEngine.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksCraftEngine.kt @@ -28,7 +28,7 @@ class CustomBlocksCraftEngine( @EventHandler @Suppress("UNUSED_PARAMETER") - fun onItemRegister(event: CraftEngineReloadEvent) { + fun onBlockRegister(event: CraftEngineReloadEvent) { Blocks.registerBlockProvider(CraftEngineProvider()) } @@ -54,7 +54,7 @@ class CustomBlocksCraftEngine( return@Predicate false } val immutableBlockState = CraftEngineBlocks.getCustomBlockState(test) ?: return@Predicate false - return@Predicate immutableBlockState.owner().value().id().equals(id) + return@Predicate immutableBlockState.owner().value().id().equals(blockId.id()) }, { location -> CraftEngineBlocks.place(location, id, true) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksItemsAdder.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksItemsAdder.kt index 2337f369d..bfacc39e5 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksItemsAdder.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksItemsAdder.kt @@ -28,9 +28,9 @@ class CustomBlocksItemsAdder : CustomBlocksIntegration { return CustomBlock( namespacedKey, Predicate { test: Block -> - val customStack = + val customBlock = dev.lone.itemsadder.api.CustomBlock.byAlreadyPlaced(test) ?: return@Predicate false - customStack.id.equals(id, ignoreCase = true) + customBlock.id.equals(id, ignoreCase = true) }, { location -> dev.lone.itemsadder.api.CustomBlock.place(id, location) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt index 6516a64b4..2e7f70579 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt @@ -11,7 +11,6 @@ import com.willfp.eco.core.blocks.provider.BlockProvider import com.willfp.eco.core.integrations.customblocks.CustomBlocksIntegration import com.willfp.eco.internal.spigot.data.handlers.impl.LegacyMongoDBPersistentDataHandler.Factory.id import com.willfp.eco.util.namespacedKeyOf -import io.th0rgal.oraxen.api.OraxenBlocks import org.bukkit.event.EventHandler import org.bukkit.event.Listener @@ -28,7 +27,7 @@ class CustomBlocksNexo( @EventHandler @Suppress("UNUSED_PARAMETER") - fun onItemRegister(event: NexoItemsLoadedEvent) { + fun onBlockRegister(event: NexoItemsLoadedEvent) { Blocks.registerBlockProvider(NexoProvider()) } @@ -43,7 +42,7 @@ class CustomBlocksNexo( return null } - val namespacedKey = namespacedKeyOf("oraxen", key) + val namespacedKey = namespacedKeyOf("nexo", key) return CustomBlock( namespacedKey, @@ -52,7 +51,7 @@ class CustomBlocksNexo( id.equals(NexoBlocks.customBlockMechanic(it.location)?.itemID, ignoreCase = true) }, { location -> - OraxenBlocks.place(key, location) + NexoBlocks.place(key, location) location.block } ) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt index 264926a05..5f88fa217 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt @@ -26,7 +26,7 @@ class CustomBlocksOraxen( @EventHandler @Suppress("UNUSED_PARAMETER") - fun onItemRegister(event: OraxenItemsLoadedEvent) { + fun onBlockRegister(event: OraxenItemsLoadedEvent) { Blocks.registerBlockProvider(OraxenProvider()) } From 2aa4b159db9d51913fa3c578ab773a6b8f92b47d Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Wed, 7 Jan 2026 11:19:41 +0200 Subject: [PATCH 05/15] Remove unnecessary check for Nexo and Oraxen --- .../spigot/integrations/customblocks/CustomBlocksNexo.kt | 5 ----- .../spigot/integrations/customblocks/CustomBlocksOraxen.kt | 5 ----- 2 files changed, 10 deletions(-) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt index 2e7f70579..d192ffea3 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt @@ -1,7 +1,6 @@ package com.willfp.eco.internal.spigot.integrations.customblocks import com.nexomc.nexo.api.NexoBlocks -import com.nexomc.nexo.api.NexoItems import com.nexomc.nexo.api.events.NexoItemsLoadedEvent import com.willfp.eco.core.EcoPlugin import com.willfp.eco.core.blocks.Blocks @@ -38,10 +37,6 @@ class CustomBlocksNexo( return null } - if (!NexoItems.exists(key)) { - return null - } - val namespacedKey = namespacedKeyOf("nexo", key) return CustomBlock( diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt index 5f88fa217..eaf9cc928 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt @@ -8,7 +8,6 @@ import com.willfp.eco.core.blocks.provider.BlockProvider import com.willfp.eco.core.integrations.customblocks.CustomBlocksIntegration import com.willfp.eco.util.namespacedKeyOf import io.th0rgal.oraxen.api.OraxenBlocks -import io.th0rgal.oraxen.api.OraxenItems import io.th0rgal.oraxen.api.events.OraxenItemsLoadedEvent import org.bukkit.event.EventHandler import org.bukkit.event.Listener @@ -37,10 +36,6 @@ class CustomBlocksOraxen( return null } - if (!OraxenItems.exists(key)) { - return null - } - val namespacedKey = namespacedKeyOf("oraxen", key) return CustomBlock( From 3c8d7feb3bcd1a4c525cb7579e9b05da3109d6a1 Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Wed, 7 Jan 2026 11:46:23 +0200 Subject: [PATCH 06/15] Continue work & fixing --- .../com/willfp/eco/core/blocks/Blocks.java | 17 ++-- .../willfp/eco/core/blocks/HashedBlock.java | 78 +++++++++++++++++++ .../customblocks/CustomBlocksNexo.kt | 8 +- .../customblocks/CustomBlocksOraxen.kt | 7 +- 4 files changed, 95 insertions(+), 15 deletions(-) create mode 100644 eco-api/src/main/java/com/willfp/eco/core/blocks/HashedBlock.java diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java index abd56530e..c8699a967 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java @@ -7,9 +7,6 @@ import com.willfp.eco.core.blocks.impl.UnrestrictedMaterialTestableBlock; import com.willfp.eco.core.blocks.provider.BlockProvider; import com.willfp.eco.core.blocks.tag.BlockTag; -import com.willfp.eco.core.items.HashedItem; -import com.willfp.eco.core.items.provider.ItemProvider; -import com.willfp.eco.core.recipe.parts.EmptyTestableItem; import com.willfp.eco.util.NamespacedKeyUtils; import com.willfp.eco.util.NumberUtils; import org.bukkit.Location; @@ -34,9 +31,9 @@ public final class Blocks { private static final Map REGISTRY = new ConcurrentHashMap<>(); /** - * Cached custom item lookups, using {@link HashedItem}. + * Cached custom block lookups, using {@link Location}. */ - private static final LoadingCache> CACHE = Caffeine.newBuilder() + private static final LoadingCache> CACHE = Caffeine.newBuilder() .expireAfterAccess(10, TimeUnit.MINUTES) .build( key -> { @@ -260,7 +257,7 @@ public static CustomBlock getCustomBlock(@Nullable final Block block) { return null; } - return CACHE.get(block.getLocation()).map(Blocks::getOrWrap).orElse(null); + return CACHE.get(HashedBlock.of(block)).map(Blocks::getOrWrap).orElse(null); } /** @@ -313,14 +310,14 @@ public static TestableBlock[] fromMaterials(@NotNull final Material... materials */ @NotNull public static Collection fromMaterials(@NotNull final Iterable materials) { - List items = new ArrayList<>(); + List blocks = new ArrayList<>(); for (Material material : materials) { if (material.isBlock()) { - items.add(new MaterialTestableBlock(material)); + blocks.add(new MaterialTestableBlock(material)); } } - return items; + return blocks; } /** @@ -352,7 +349,7 @@ public static boolean matchesAny(@Nullable final Block block, } /** - * Get if any item matches any item. + * Get all registered custom blocks. * * @param blocks The blocks. * @param testableBlocks The testable blocks. diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/HashedBlock.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/HashedBlock.java new file mode 100644 index 000000000..5e24e364f --- /dev/null +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/HashedBlock.java @@ -0,0 +1,78 @@ +package com.willfp.eco.core.blocks; + +import com.willfp.eco.core.fast.FastItemStack; +import org.bukkit.block.Block; +import org.bukkit.inventory.ItemStack; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.Objects; + +/** + * An block and its hash. + */ +public final class HashedBlock { + /** + * The block. + */ + private final Block block; + + /** + * The hash. + */ + private final int hash; + + /** + * Create new hashed block. + * + * @param block The block. + * @param hash The hash. + */ + private HashedBlock(@NotNull final Block block, + final int hash) { + this.block = block; + this.hash = hash; + } + + /** + * Get the block. + * + * @return The Block. + */ + public Block getBlock() { + return this.block; + } + + /** + * Get the hash. + * + * @return The hash. + */ + public int getHash() { + return this.hash; + } + + @Override + public int hashCode() { + return this.hash; + } + + @Override + public boolean equals(@Nullable final Object other) { + if (!(other instanceof HashedBlock o)) { + return false; + } + + return o.hash == this.hash; + } + + /** + * Hashed block from a block. + * + * @param block The block. + * @return The hashed block. + */ + public static HashedBlock of(@NotNull final Block block) { + return new HashedBlock(block, Objects.hash(block.getWorld().getName(), block.getX(), block.getY(), block.getZ())); + } +} diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt index d192ffea3..6d65dcc1b 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt @@ -1,6 +1,7 @@ package com.willfp.eco.internal.spigot.integrations.customblocks import com.nexomc.nexo.api.NexoBlocks +import com.nexomc.nexo.api.NexoItems import com.nexomc.nexo.api.events.NexoItemsLoadedEvent import com.willfp.eco.core.EcoPlugin import com.willfp.eco.core.blocks.Blocks @@ -8,8 +9,7 @@ import com.willfp.eco.core.blocks.CustomBlock import com.willfp.eco.core.blocks.TestableBlock import com.willfp.eco.core.blocks.provider.BlockProvider import com.willfp.eco.core.integrations.customblocks.CustomBlocksIntegration -import com.willfp.eco.internal.spigot.data.handlers.impl.LegacyMongoDBPersistentDataHandler.Factory.id -import com.willfp.eco.util.namespacedKeyOf +import com.willfp.eco.util.NamespacedKeyUtils import org.bukkit.event.EventHandler import org.bukkit.event.Listener @@ -37,7 +37,9 @@ class CustomBlocksNexo( return null } - val namespacedKey = namespacedKeyOf("nexo", key) + val item = NexoItems.itemFromId(key) ?: return null + val id = NexoItems.idFromItem(item) + val namespacedKey = NamespacedKeyUtils.create("nexo", id.toString()) return CustomBlock( namespacedKey, diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt index eaf9cc928..c2a8f3d48 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt @@ -8,6 +8,7 @@ import com.willfp.eco.core.blocks.provider.BlockProvider import com.willfp.eco.core.integrations.customblocks.CustomBlocksIntegration import com.willfp.eco.util.namespacedKeyOf import io.th0rgal.oraxen.api.OraxenBlocks +import io.th0rgal.oraxen.api.OraxenItems import io.th0rgal.oraxen.api.events.OraxenItemsLoadedEvent import org.bukkit.event.EventHandler import org.bukkit.event.Listener @@ -36,13 +37,15 @@ class CustomBlocksOraxen( return null } - val namespacedKey = namespacedKeyOf("oraxen", key) + val item = OraxenItems.getItemById(key) ?: return null + val id = OraxenItems.getIdByItem(item) + val namespacedKey = namespacedKeyOf("oraxen", id) return CustomBlock( namespacedKey, { OraxenBlocks.isOraxenBlock(it) && - key.equals(OraxenBlocks.getOraxenBlock(it.location).itemID, ignoreCase = true) + id.equals(OraxenBlocks.getOraxenBlock(it.location).itemID, ignoreCase = true) }, { location -> OraxenBlocks.place(key, location) From c18208d2536512a6f34e014b674ca714b4c50c05 Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Wed, 7 Jan 2026 11:47:09 +0200 Subject: [PATCH 07/15] Continue work & fixing --- .../spigot/integrations/customblocks/CustomBlocksNexo.kt | 2 +- .../spigot/integrations/customblocks/CustomBlocksOraxen.kt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt index 6d65dcc1b..ecd09f26c 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt @@ -48,7 +48,7 @@ class CustomBlocksNexo( id.equals(NexoBlocks.customBlockMechanic(it.location)?.itemID, ignoreCase = true) }, { location -> - NexoBlocks.place(key, location) + NexoBlocks.place(id, location) location.block } ) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt index c2a8f3d48..ded95f9e5 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksOraxen.kt @@ -48,7 +48,7 @@ class CustomBlocksOraxen( id.equals(OraxenBlocks.getOraxenBlock(it.location).itemID, ignoreCase = true) }, { location -> - OraxenBlocks.place(key, location) + OraxenBlocks.place(id, location) location.block } ) From 1980bec7dd9efa5a60e9d3bb64d09bcc75a11b4d Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Wed, 7 Jan 2026 12:32:50 +0200 Subject: [PATCH 08/15] Correct stuff --- .../src/main/java/com/willfp/eco/core/blocks/Blocks.java | 4 ++-- .../java/com/willfp/eco/core/blocks/HashedBlock.java | 4 +--- .../java/com/willfp/eco/core/blocks/TestableBlock.java | 2 +- .../java/com/willfp/eco/core/blocks/tag/BlockTag.java | 5 +---- .../com/willfp/eco/core/blocks/tag/CustomBlockTag.java | 2 +- .../com/willfp/eco/core/blocks/tag/VanillaBlockTag.java | 1 - .../src/main/kotlin/com/willfp/eco/core/blocks/Blocks.kt | 9 ++++----- .../integrations/customblocks/CustomBlocksItemsAdder.kt | 4 ++-- .../spigot/integrations/customblocks/CustomBlocksNexo.kt | 4 ++-- .../integrations/customitems/CustomItemsItemsAdder.kt | 4 ++-- .../spigot/integrations/customitems/CustomItemsNexo.kt | 4 ++-- 11 files changed, 18 insertions(+), 25 deletions(-) diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java index c8699a967..b46962bc1 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java @@ -104,7 +104,7 @@ public static void removeCustomBlock(@NotNull final NamespacedKey key) { } /** - * Turn an Block back into a lookup string. + * Turn a Block back into a lookup string. * * @param block The Block. * @return The lookup string. @@ -321,7 +321,7 @@ public static Collection fromMaterials(@NotNull final Iterable { Block place(@NotNull Location location); /** - * If an block matching this test should be marked as a custom block. + * If a block matching this test should be marked as a custom block. *

* This is true by default for backwards compatibility reasons. * diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/BlockTag.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/BlockTag.java index afcaf4c74..bde8364b3 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/BlockTag.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/BlockTag.java @@ -1,11 +1,8 @@ package com.willfp.eco.core.blocks.tag; import com.willfp.eco.core.blocks.TestableBlock; -import com.willfp.eco.core.items.TestableItem; import org.bukkit.Location; -import org.bukkit.Material; import org.bukkit.block.Block; -import org.bukkit.inventory.ItemStack; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -22,7 +19,7 @@ public interface BlockTag { String getIdentifier(); /** - * Check if an block matches the tag. + * Check if a block matches the tag. * * @param block The block to check. * @return If the block matches the tag. diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/CustomBlockTag.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/CustomBlockTag.java index cb4412d6d..25f3385a4 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/CustomBlockTag.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/CustomBlockTag.java @@ -4,7 +4,7 @@ import org.jetbrains.annotations.NotNull; /** - * A custom item tag. + * A custom block tag. */ public abstract class CustomBlockTag implements BlockTag { /** diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/VanillaBlockTag.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/VanillaBlockTag.java index f54e3a176..fa8c3e80f 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/VanillaBlockTag.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/VanillaBlockTag.java @@ -3,7 +3,6 @@ import org.bukkit.Material; import org.bukkit.Tag; import org.bukkit.block.Block; -import org.bukkit.inventory.ItemStack; import org.jetbrains.annotations.NotNull; /** diff --git a/eco-api/src/main/kotlin/com/willfp/eco/core/blocks/Blocks.kt b/eco-api/src/main/kotlin/com/willfp/eco/core/blocks/Blocks.kt index a48d7a61b..371c34685 100644 --- a/eco-api/src/main/kotlin/com/willfp/eco/core/blocks/Blocks.kt +++ b/eco-api/src/main/kotlin/com/willfp/eco/core/blocks/Blocks.kt @@ -1,16 +1,15 @@ -@file:JvmName("ItemsExtensions") +@file:JvmName("BlocksExtensions") package com.willfp.eco.core.blocks -import com.willfp.eco.core.items.Items import org.bukkit.block.Block -/** @see Items.toLookupString */ +/** @see Blocks.toLookupString */ fun Block?.toLookupString(): String = Blocks.toLookupString(this) -/** @see Items.isEmpty */ -@Deprecated("Use Block.isEcoEmpty", ReplaceWith("Block.isEmpty(this)")) +/** @see Blocks.isEmpty */ +@Deprecated("Use Blocks.isEcoEmpty", ReplaceWith("Block.isEmpty(this)")) val Block?.isEmpty: Boolean get() = Blocks.isEmpty(this) diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksItemsAdder.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksItemsAdder.kt index bfacc39e5..4ffe171c1 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksItemsAdder.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksItemsAdder.kt @@ -5,7 +5,7 @@ import com.willfp.eco.core.blocks.CustomBlock import com.willfp.eco.core.blocks.TestableBlock import com.willfp.eco.core.blocks.provider.BlockProvider import com.willfp.eco.core.integrations.customblocks.CustomBlocksIntegration -import com.willfp.eco.util.NamespacedKeyUtils +import com.willfp.eco.util.namespacedKeyOf import org.bukkit.block.Block import java.util.function.Predicate @@ -24,7 +24,7 @@ class CustomBlocksItemsAdder : CustomBlocksIntegration { val block = dev.lone.itemsadder.api.CustomBlock.getInstance(internalId) ?: return null val id = block.id - val namespacedKey = NamespacedKeyUtils.create("itemsadder", key.lowercase().replace(":", "__")) + val namespacedKey = namespacedKeyOf("itemsadder", key.lowercase().replace(":", "__")) return CustomBlock( namespacedKey, Predicate { test: Block -> diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt index ecd09f26c..09aa99c4f 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customblocks/CustomBlocksNexo.kt @@ -9,7 +9,7 @@ import com.willfp.eco.core.blocks.CustomBlock import com.willfp.eco.core.blocks.TestableBlock import com.willfp.eco.core.blocks.provider.BlockProvider import com.willfp.eco.core.integrations.customblocks.CustomBlocksIntegration -import com.willfp.eco.util.NamespacedKeyUtils +import com.willfp.eco.util.namespacedKeyOf import org.bukkit.event.EventHandler import org.bukkit.event.Listener @@ -39,7 +39,7 @@ class CustomBlocksNexo( val item = NexoItems.itemFromId(key) ?: return null val id = NexoItems.idFromItem(item) - val namespacedKey = NamespacedKeyUtils.create("nexo", id.toString()) + val namespacedKey = namespacedKeyOf("nexo", id.toString()) return CustomBlock( namespacedKey, diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsItemsAdder.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsItemsAdder.kt index 9de79f999..2637641dc 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsItemsAdder.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsItemsAdder.kt @@ -5,7 +5,7 @@ import com.willfp.eco.core.items.CustomItem import com.willfp.eco.core.items.Items import com.willfp.eco.core.items.TestableItem import com.willfp.eco.core.items.provider.ItemProvider -import com.willfp.eco.util.NamespacedKeyUtils +import com.willfp.eco.util.namespacedKeyOf import dev.lone.itemsadder.api.CustomStack import org.bukkit.inventory.ItemStack import java.util.function.Predicate @@ -25,7 +25,7 @@ class CustomItemsItemsAdder : CustomItemsIntegration { val item = CustomStack.getInstance(internalId) ?: return null val id = item.id - val namespacedKey = NamespacedKeyUtils.create("itemsadder", key.lowercase().replace(":", "__")) + val namespacedKey = namespacedKeyOf("itemsadder", key.lowercase().replace(":", "__")) val stack = item.itemStack return CustomItem( namespacedKey, diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsNexo.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsNexo.kt index b5c1de865..8aca321d7 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsNexo.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/integrations/customitems/CustomItemsNexo.kt @@ -8,7 +8,7 @@ import com.willfp.eco.core.items.CustomItem import com.willfp.eco.core.items.Items import com.willfp.eco.core.items.TestableItem import com.willfp.eco.core.items.provider.ItemProvider -import com.willfp.eco.util.NamespacedKeyUtils +import com.willfp.eco.util.namespacedKeyOf import org.bukkit.event.EventHandler import org.bukkit.event.Listener @@ -33,7 +33,7 @@ class CustomItemsNexo( override fun provideForKey(key: String): TestableItem? { val item = NexoItems.itemFromId(key) ?: return null val id = NexoItems.idFromItem(item) - val namespacedKey = NamespacedKeyUtils.create("nexo", id.toString()) + val namespacedKey = namespacedKeyOf("nexo", id.toString()) return CustomItem( namespacedKey, { id.equals(NexoItems.idFromItem(it), ignoreCase = true) }, From 298461ae6147d62623c9eb9c41d333b0e747ec78 Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Thu, 8 Jan 2026 12:43:54 +0200 Subject: [PATCH 09/15] Continue working with block args --- .../com/willfp/eco/core/blocks/Blocks.java | 97 +++++++++++++++---- .../eco/core/blocks/args/BlockArgParser.java | 27 ++++++ ...Block.java => BlockDataTestableBlock.java} | 34 ++++--- .../core/blocks/impl/EmptyTestableBlock.java | 3 + .../blocks/impl/ModifiedTestableBlock.java | 63 ++++++++++++ .../java/com/willfp/eco/core/items/Items.java | 5 +- .../blocks/BlockArgParserDirection.kt | 35 +++++++ .../eco/internal/spigot/EcoSpigotPlugin.kt | 4 + 8 files changed, 232 insertions(+), 36 deletions(-) create mode 100644 eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java rename eco-api/src/main/java/com/willfp/eco/core/blocks/impl/{MaterialTestableBlock.java => BlockDataTestableBlock.java} (51%) create mode 100644 eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirection.kt diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java index b46962bc1..aa219163c 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java @@ -2,23 +2,31 @@ import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; +import com.willfp.eco.core.blocks.args.BlockArgParser; import com.willfp.eco.core.blocks.impl.EmptyTestableBlock; -import com.willfp.eco.core.blocks.impl.MaterialTestableBlock; +import com.willfp.eco.core.blocks.impl.BlockDataTestableBlock; +import com.willfp.eco.core.blocks.impl.ModifiedTestableBlock; import com.willfp.eco.core.blocks.impl.UnrestrictedMaterialTestableBlock; import com.willfp.eco.core.blocks.provider.BlockProvider; import com.willfp.eco.core.blocks.tag.BlockTag; +import com.willfp.eco.core.items.args.LookupArgParser; +import com.willfp.eco.core.recipe.parts.EmptyTestableItem; +import com.willfp.eco.core.recipe.parts.ModifiedTestableItem; import com.willfp.eco.util.NamespacedKeyUtils; import com.willfp.eco.util.NumberUtils; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.NamespacedKey; import org.bukkit.block.Block; +import org.bukkit.block.data.BlockData; +import org.bukkit.inventory.ItemStack; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.TimeUnit; +import java.util.function.Predicate; import java.util.stream.Collectors; /** @@ -54,6 +62,11 @@ public final class Blocks { */ private static final Map PROVIDERS = new ConcurrentHashMap<>(); + /** + * All block parsers. + */ + private static final List ARG_PARSERS = new ArrayList<>(); + /** * The lookup handler. */ @@ -94,6 +107,15 @@ public static void registerBlockProvider(@NotNull final BlockProvider provider) PROVIDERS.put(provider.getNamespace(), provider); } + /** + * Register a new arg parser. + * + * @param parser The parser. + */ + public static void registerArgParser(@NotNull final BlockArgParser parser) { + ARG_PARSERS.add(parser); + } + /** * Remove a block. * @@ -151,6 +173,8 @@ private static TestableBlock doParse(@NotNull final String[] args) { return new EmptyTestableBlock(); } + TestableBlock block = null; + String[] split = args[0].toLowerCase().split(":"); String base = split[0]; @@ -163,7 +187,7 @@ private static TestableBlock doParse(@NotNull final String[] args) { if (blockTag == null) { return new EmptyTestableBlock(); } - return blockTag.toTestableBlock(); + block = blockTag.toTestableBlock(); } if (split.length == 1) { @@ -176,31 +200,62 @@ private static TestableBlock doParse(@NotNull final String[] args) { if (material == null || material == Material.AIR) { return new EmptyTestableBlock(); } - return isWildcard ? new UnrestrictedMaterialTestableBlock(material) : new MaterialTestableBlock(material); + block = isWildcard ? new UnrestrictedMaterialTestableBlock(material) : new BlockDataTestableBlock(material); } - String namespace = split[0]; - String keyID = split[1]; - NamespacedKey namespacedKey = NamespacedKeyUtils.create(namespace, keyID); - TestableBlock block = REGISTRY.get(namespacedKey); + if (split.length == 2 && !isTag) { + String namespace = split[0]; + String keyID = split[1]; + NamespacedKey namespacedKey = NamespacedKeyUtils.create(namespace, keyID); + TestableBlock part = REGISTRY.get(namespacedKey); + + if (part == null && PROVIDERS.containsKey(namespace)) { + BlockProvider provider = PROVIDERS.get(namespace); + + String reformattedKey = keyID.replace("__", ":"); + + part = provider.provideForKey(reformattedKey); + if (part instanceof EmptyTestableBlock || part == null) { + return new EmptyTestableBlock(); + } - if (block != null) { - return block; + registerCustomBlock(namespacedKey, part); + } } - BlockProvider provider = PROVIDERS.get(namespace); - if (provider == null) { + if (block == null || block instanceof EmptyTestableBlock) { return new EmptyTestableBlock(); } - String reformattedKey = keyID.replace("__", ":"); + if (block instanceof BlockDataTestableBlock testableBlock) { - block = provider.provideForKey(reformattedKey); - if (block == null) { - return new EmptyTestableBlock(); + String[] modifierArgs = Arrays.copyOfRange(args, 1, args.length); + + List> predicates = new ArrayList<>(); + + for (BlockArgParser argParser : ARG_PARSERS) { + Predicate result = argParser.parseArguments(modifierArgs, testableBlock.getBlockData()); + if (result != null) { + predicates.add(result); + } + } + + if (!predicates.isEmpty()) { + block = new ModifiedTestableBlock( + block, + test -> { + for (Predicate predicate : predicates) { + if (!predicate.test(test)) { + return false; + } + } + + return true; + } + ); + } } - registerCustomBlock(namespacedKey, block); return block; } @@ -208,7 +263,7 @@ private static TestableBlock doParse(@NotNull final String[] args) { * Get a Testable Block from a Block. *

* Will search for registered blocks first. If there are no matches in the registry, - * then it will return a {@link MaterialTestableBlock} matching the block type. + * then it will return a {@link BlockDataTestableBlock} matching the block type. *

* Does not account for modifiers (arg parser data). * @@ -232,7 +287,7 @@ public static TestableBlock getBlock(@Nullable final Block block) { return known; } } - return new MaterialTestableBlock(block.getType()); + return new BlockDataTestableBlock(block.getType()); } /** @@ -298,8 +353,8 @@ public static CustomBlock getOrWrap(@NotNull final TestableBlock block) { public static TestableBlock[] fromMaterials(@NotNull final Material... materials) { return Arrays.stream(materials) .filter(Material::isBlock) - .map(MaterialTestableBlock::new) - .toArray(MaterialTestableBlock[]::new); + .map(BlockDataTestableBlock::new) + .toArray(BlockDataTestableBlock[]::new); } /** @@ -313,7 +368,7 @@ public static Collection fromMaterials(@NotNull final Iterable blocks = new ArrayList<>(); for (Material material : materials) { if (material.isBlock()) { - blocks.add(new MaterialTestableBlock(material)); + blocks.add(new BlockDataTestableBlock(material)); } } diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java new file mode 100644 index 000000000..9cbe0eee9 --- /dev/null +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java @@ -0,0 +1,27 @@ +package com.willfp.eco.core.blocks.args; + +import com.willfp.eco.core.blocks.TestableBlock; +import org.bukkit.Location; +import org.bukkit.block.Block; +import org.bukkit.block.data.BlockData; +import org.bukkit.inventory.ItemStack; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.function.Predicate; + +/** + * An argument parser should generate the predicate as well + * as modify the BlockData for {@link TestableBlock#place(Location)} . + */ +public interface BlockArgParser { + /** + * Parse the arguments. + * + * @param args The arguments. + * @param blockData The block data to modify. + * @return The predicate test to apply to the modified block data. + */ + @Nullable Predicate parseArguments(@NotNull String[] args, + @NotNull BlockData blockData); +} diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/MaterialTestableBlock.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/BlockDataTestableBlock.java similarity index 51% rename from eco-api/src/main/java/com/willfp/eco/core/blocks/impl/MaterialTestableBlock.java rename to eco-api/src/main/java/com/willfp/eco/core/blocks/impl/BlockDataTestableBlock.java index 713e069c3..bcad5dd71 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/MaterialTestableBlock.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/BlockDataTestableBlock.java @@ -6,30 +6,40 @@ import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.block.Block; +import org.bukkit.block.data.BlockData; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; /** * A testable block for vanilla materials. */ -public class MaterialTestableBlock implements TestableBlock { +public class BlockDataTestableBlock implements TestableBlock { /** * The block type. */ - private final Material material; + private final BlockData blockData; /** - * Create a new unrestricted material testable block. + * Create a new block data testable block. * * @param material The material. */ - public MaterialTestableBlock(@NotNull final Material material) { - this.material = material; + public BlockDataTestableBlock(@NotNull final Material material) { + this(material.createBlockData()); + } + + /** + * Create a new block data testable block. + * + * @param blockData The material. + */ + public BlockDataTestableBlock(@NotNull final BlockData blockData) { + this.blockData = blockData; } @Override public boolean matches(@Nullable final Block block) { - boolean simpleMatches = block != null && block.getType() == material; + boolean simpleMatches = block != null && block.getBlockData().equals(blockData); if (!simpleMatches) { return false; @@ -42,18 +52,18 @@ public boolean matches(@Nullable final Block block) { public @NotNull Block place(@NotNull Location location) { Validate.notNull(location.getWorld()); - Block block = location.getWorld().getBlockAt(location); - block.setType(material); + Block block = location.getBlock(); + block.setBlockData(blockData); return block; } /** - * Get the material. + * Get the block data. * - * @return The material. + * @return The block data. */ - public Material getMaterial() { - return this.material; + public BlockData getBlockData() { + return this.blockData; } } diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/EmptyTestableBlock.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/EmptyTestableBlock.java index 190470eb4..301e46791 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/EmptyTestableBlock.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/EmptyTestableBlock.java @@ -1,6 +1,7 @@ package com.willfp.eco.core.blocks.impl; import com.willfp.eco.core.blocks.TestableBlock; +import org.apache.commons.lang.Validate; import org.bukkit.Location; import org.bukkit.block.Block; import org.jetbrains.annotations.NotNull; @@ -24,6 +25,8 @@ public boolean matches(@Nullable final Block other) { @Override public @NotNull Block place(@NotNull final Location location) { + Validate.notNull(location.getWorld()); + return location.getBlock(); } } diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java new file mode 100644 index 000000000..3e900c538 --- /dev/null +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java @@ -0,0 +1,63 @@ +package com.willfp.eco.core.blocks.impl; + +import com.willfp.eco.core.blocks.TestableBlock; +import com.willfp.eco.core.entities.TestableEntity; +import org.apache.commons.lang.Validate; +import org.bukkit.Location; +import org.bukkit.block.Block; +import org.bukkit.block.data.BlockData; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.function.Function; +import java.util.function.Predicate; + +/** + * Existing testable block with an extra filter. + * + * @see com.willfp.eco.core.entities.CustomEntity + */ +public class ModifiedTestableBlock implements TestableBlock { + /** + * The block. + */ + private final TestableBlock handle; + + /** + * The test. + */ + private final Predicate test; + + /** + * Create a new modified testable block. + * + * @param block The base block. + * @param test The test. + */ + public ModifiedTestableBlock(@NotNull final TestableBlock block, + @NotNull final Predicate<@NotNull BlockData> test) { + this.handle = block; + this.test = test; + } + + @Override + public boolean matches(@Nullable final Block block) { + return block != null && handle.matches(block) && test.test(block.getBlockData()); + } + + @Override + public @NotNull Block place(@NotNull final Location location) { + Validate.notNull(location.getWorld()); + + return location.getBlock(); + } + + /** + * Get the handle. + * + * @return The handle. + */ + public TestableBlock getHandle() { + return this.handle; + } +} diff --git a/eco-api/src/main/java/com/willfp/eco/core/items/Items.java b/eco-api/src/main/java/com/willfp/eco/core/items/Items.java index f0b6047cc..643e22603 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/items/Items.java +++ b/eco-api/src/main/java/com/willfp/eco/core/items/Items.java @@ -324,11 +324,10 @@ private static TestableItem doParse(@NotNull final String[] args) { List> predicates = new ArrayList<>(); - for ( - LookupArgParser argParser : ARG_PARSERS) { + for (LookupArgParser argParser : ARG_PARSERS) { Predicate predicate = argParser.parseArguments(modifierArgs, meta); if (predicate != null) { - predicates.add(argParser.parseArguments(modifierArgs, meta)); + predicates.add(predicate); } } diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirection.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirection.kt new file mode 100644 index 000000000..dcd8aaa68 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirection.kt @@ -0,0 +1,35 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.BlockFace +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.Directional +import java.util.function.Predicate + +object BlockArgParserDirection : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): Predicate? { + var direction: BlockFace? = null + + val directional = blockData as? Directional ?: return null + val directions = directional.faces + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("direction", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + val argDirection = BlockFace.valueOf(argSplit[1].uppercase()) + if (!directions.contains(argDirection)) { + continue + } + direction = argDirection + } + + direction ?: return null + + return Predicate { it is Directional && it.facing == direction } + } +} \ No newline at end of file diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt index 70d9b2b5a..7a4aa6c3b 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt @@ -3,6 +3,7 @@ package com.willfp.eco.internal.spigot import com.willfp.eco.core.Eco import com.willfp.eco.core.EcoPlugin import com.willfp.eco.core.Prerequisite +import com.willfp.eco.core.blocks.Blocks import com.willfp.eco.core.data.ExternalDataStore import com.willfp.eco.core.entities.Entities import com.willfp.eco.core.integrations.IntegrationLoader @@ -21,6 +22,7 @@ import com.willfp.eco.core.items.Items import com.willfp.eco.core.packet.PacketListener import com.willfp.eco.core.particle.Particles import com.willfp.eco.core.price.Prices +import com.willfp.eco.internal.blocks.BlockArgParserDirection import com.willfp.eco.internal.data.MavenVersionToStringAdapter import com.willfp.eco.internal.data.VersionToStringAdapter import com.willfp.eco.internal.entities.EntityArgParserAdult @@ -193,6 +195,8 @@ abstract class EcoSpigotPlugin : EcoPlugin() { Items.registerArgParser(ArgParserTooltipStyle) Items.registerArgParser(ArgParserTrim) + Blocks.registerArgParser(BlockArgParserDirection) + Entities.registerArgParser(EntityArgParserName) Entities.registerArgParser(EntityArgParserNoAI) Entities.registerArgParser(EntityArgParserAttackDamage) From 876e0fe2be4af40c10c14dec73648dffd4a9babc Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Thu, 8 Jan 2026 13:41:39 +0200 Subject: [PATCH 10/15] Continue working with block args x2 --- .../com/willfp/eco/core/blocks/Blocks.java | 53 ++++++++++++------- .../core/blocks/args/BlockArgParseResult.java | 37 +++++++++++++ .../eco/core/blocks/args/BlockArgParser.java | 12 ++--- ...eBlock.java => MaterialTestableBlock.java} | 25 +++------ .../blocks/impl/ModifiedTestableBlock.java | 28 ++++++---- .../UnrestrictedMaterialTestableBlock.java | 17 +----- .../blocks/BlockArgParserDirection.kt | 20 +++++-- 7 files changed, 121 insertions(+), 71 deletions(-) create mode 100644 eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParseResult.java rename eco-api/src/main/java/com/willfp/eco/core/blocks/impl/{BlockDataTestableBlock.java => MaterialTestableBlock.java} (62%) diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java index aa219163c..7e209260d 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java @@ -2,16 +2,17 @@ import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; +import com.willfp.eco.core.blocks.args.BlockArgParseResult; import com.willfp.eco.core.blocks.args.BlockArgParser; import com.willfp.eco.core.blocks.impl.EmptyTestableBlock; -import com.willfp.eco.core.blocks.impl.BlockDataTestableBlock; +import com.willfp.eco.core.blocks.impl.MaterialTestableBlock; import com.willfp.eco.core.blocks.impl.ModifiedTestableBlock; import com.willfp.eco.core.blocks.impl.UnrestrictedMaterialTestableBlock; import com.willfp.eco.core.blocks.provider.BlockProvider; import com.willfp.eco.core.blocks.tag.BlockTag; -import com.willfp.eco.core.items.args.LookupArgParser; -import com.willfp.eco.core.recipe.parts.EmptyTestableItem; -import com.willfp.eco.core.recipe.parts.ModifiedTestableItem; +import com.willfp.eco.core.entities.args.EntityArgParseResult; +import com.willfp.eco.core.entities.args.EntityArgParser; +import com.willfp.eco.core.entities.impl.ModifiedTestableEntity; import com.willfp.eco.util.NamespacedKeyUtils; import com.willfp.eco.util.NumberUtils; import org.bukkit.Location; @@ -19,14 +20,14 @@ import org.bukkit.NamespacedKey; import org.bukkit.block.Block; import org.bukkit.block.data.BlockData; -import org.bukkit.inventory.ItemStack; +import org.bukkit.entity.Entity; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.TimeUnit; -import java.util.function.Predicate; +import java.util.function.Function; import java.util.stream.Collectors; /** @@ -200,7 +201,7 @@ private static TestableBlock doParse(@NotNull final String[] args) { if (material == null || material == Material.AIR) { return new EmptyTestableBlock(); } - block = isWildcard ? new UnrestrictedMaterialTestableBlock(material) : new BlockDataTestableBlock(material); + block = isWildcard ? new UnrestrictedMaterialTestableBlock(material) : new MaterialTestableBlock(material); } if (split.length == 2 && !isTag) { @@ -223,34 +224,46 @@ private static TestableBlock doParse(@NotNull final String[] args) { } } - if (block == null || block instanceof EmptyTestableBlock) { + if (block == null) { return new EmptyTestableBlock(); } - if (block instanceof BlockDataTestableBlock testableBlock) { + if (block instanceof MaterialTestableBlock materialTestableBlock) { String[] modifierArgs = Arrays.copyOfRange(args, 1, args.length); + List parseResults = new ArrayList<>(); - List> predicates = new ArrayList<>(); + BlockData blockData = materialTestableBlock.getMaterial().createBlockData(); for (BlockArgParser argParser : ARG_PARSERS) { - Predicate result = argParser.parseArguments(modifierArgs, testableBlock.getBlockData()); + BlockArgParseResult result = argParser.parseArguments(modifierArgs, blockData); if (result != null) { - predicates.add(result); + parseResults.add(result); } } - if (!predicates.isEmpty()) { + Function placer = block::place; + + if (!parseResults.isEmpty()) { block = new ModifiedTestableBlock( block, test -> { - for (Predicate predicate : predicates) { - if (!predicate.test(test)) { + for (BlockArgParseResult parseResult : parseResults) { + if (!parseResult.test().test(test)) { return false; } } return true; + }, + location -> { + Block placed = placer.apply(location); + + for (BlockArgParseResult parseResult : parseResults) { + parseResult.modifier().accept(placed); + } + + return placed; } ); } @@ -263,7 +276,7 @@ private static TestableBlock doParse(@NotNull final String[] args) { * Get a Testable Block from a Block. *

* Will search for registered blocks first. If there are no matches in the registry, - * then it will return a {@link BlockDataTestableBlock} matching the block type. + * then it will return a {@link MaterialTestableBlock} matching the block type. *

* Does not account for modifiers (arg parser data). * @@ -287,7 +300,7 @@ public static TestableBlock getBlock(@Nullable final Block block) { return known; } } - return new BlockDataTestableBlock(block.getType()); + return new MaterialTestableBlock(block.getType()); } /** @@ -353,8 +366,8 @@ public static CustomBlock getOrWrap(@NotNull final TestableBlock block) { public static TestableBlock[] fromMaterials(@NotNull final Material... materials) { return Arrays.stream(materials) .filter(Material::isBlock) - .map(BlockDataTestableBlock::new) - .toArray(BlockDataTestableBlock[]::new); + .map(MaterialTestableBlock::new) + .toArray(MaterialTestableBlock[]::new); } /** @@ -368,7 +381,7 @@ public static Collection fromMaterials(@NotNull final Iterable blocks = new ArrayList<>(); for (Material material : materials) { if (material.isBlock()) { - blocks.add(new BlockDataTestableBlock(material)); + blocks.add(new MaterialTestableBlock(material)); } } diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParseResult.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParseResult.java new file mode 100644 index 000000000..21101ab71 --- /dev/null +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParseResult.java @@ -0,0 +1,37 @@ +package com.willfp.eco.core.blocks.args; + +import com.willfp.eco.core.entities.args.EntityArgParser; +import org.bukkit.block.Block; +import org.bukkit.entity.Entity; +import org.jetbrains.annotations.NotNull; + +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 + */ +public record BlockArgParseResult(@NotNull Predicate test, + @NotNull Consumer modifier) { + /** + * Kotlin destructuring support. + * + * @return The test. + */ + public Predicate component1() { + return test; + } + + /** + * Kotlin destructuring support. + * + * @return The modifier. + */ + public Consumer component2() { + return modifier; + } +} diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java index 9cbe0eee9..f2e7facb9 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java @@ -11,17 +11,17 @@ import java.util.function.Predicate; /** - * An argument parser should generate the predicate as well - * as modify the BlockData for {@link TestableBlock#place(Location)} . + * An argument parser that should generate + * a modified BlockData for {@link TestableBlock#place(Location)} . */ public interface BlockArgParser { /** * Parse the arguments. * * @param args The arguments. - * @param blockData The block data to modify. - * @return The predicate test to apply to the modified block data. + * @param blockData The block data to be modified. + * @return The modified block data. */ - @Nullable Predicate parseArguments(@NotNull String[] args, - @NotNull BlockData blockData); + @Nullable BlockArgParseResult parseArguments(@NotNull String[] args, + @NotNull BlockData blockData); } diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/BlockDataTestableBlock.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/MaterialTestableBlock.java similarity index 62% rename from eco-api/src/main/java/com/willfp/eco/core/blocks/impl/BlockDataTestableBlock.java rename to eco-api/src/main/java/com/willfp/eco/core/blocks/impl/MaterialTestableBlock.java index bcad5dd71..82af42b3a 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/BlockDataTestableBlock.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/MaterialTestableBlock.java @@ -13,33 +13,24 @@ /** * A testable block for vanilla materials. */ -public class BlockDataTestableBlock implements TestableBlock { +public class MaterialTestableBlock implements TestableBlock { /** * The block type. */ - private final BlockData blockData; + protected final Material material; /** * Create a new block data testable block. * * @param material The material. */ - public BlockDataTestableBlock(@NotNull final Material material) { - this(material.createBlockData()); - } - - /** - * Create a new block data testable block. - * - * @param blockData The material. - */ - public BlockDataTestableBlock(@NotNull final BlockData blockData) { - this.blockData = blockData; + public MaterialTestableBlock(@NotNull final Material material) { + this.material = material; } @Override public boolean matches(@Nullable final Block block) { - boolean simpleMatches = block != null && block.getBlockData().equals(blockData); + boolean simpleMatches = block != null && block.getType() == material; if (!simpleMatches) { return false; @@ -53,7 +44,7 @@ public boolean matches(@Nullable final Block block) { Validate.notNull(location.getWorld()); Block block = location.getBlock(); - block.setBlockData(blockData); + block.setType(material); return block; } @@ -63,7 +54,7 @@ public boolean matches(@Nullable final Block block) { * * @return The block data. */ - public BlockData getBlockData() { - return this.blockData; + public Material getMaterial() { + return this.material; } } diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java index 3e900c538..d9d675d6d 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java @@ -5,7 +5,7 @@ import org.apache.commons.lang.Validate; import org.bukkit.Location; import org.bukkit.block.Block; -import org.bukkit.block.data.BlockData; +import org.bukkit.entity.Entity; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -13,43 +13,51 @@ import java.util.function.Predicate; /** - * Existing testable block with an extra filter. + * Existing testable entity with an extra filter. * * @see com.willfp.eco.core.entities.CustomEntity */ public class ModifiedTestableBlock implements TestableBlock { /** - * The block. + * The item. */ private final TestableBlock handle; /** - * The test. + * The amount. */ - private final Predicate test; + private final Predicate test; /** - * Create a new modified testable block. + * The provider to spawn the entity. + */ + private final Function provider; + + /** + * Create a new modified testable entity. * * @param block The base block. * @param test The test. + * @param provider The provider to spawn the entity. */ public ModifiedTestableBlock(@NotNull final TestableBlock block, - @NotNull final Predicate<@NotNull BlockData> test) { + @NotNull final Predicate<@NotNull Block> test, + @NotNull final Function provider) { this.handle = block; this.test = test; + this.provider = provider; } @Override public boolean matches(@Nullable final Block block) { - return block != null && handle.matches(block) && test.test(block.getBlockData()); + return block != null && handle.matches(block) && test.test(block); } @Override - public @NotNull Block place(@NotNull final Location location) { + public Block place(@NotNull final Location location) { Validate.notNull(location.getWorld()); - return location.getBlock(); + return provider.apply(location); } /** diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/UnrestrictedMaterialTestableBlock.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/UnrestrictedMaterialTestableBlock.java index 498c07aba..45923985e 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/UnrestrictedMaterialTestableBlock.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/UnrestrictedMaterialTestableBlock.java @@ -11,11 +11,7 @@ /** * A testable block for materials regardless of data. */ -public class UnrestrictedMaterialTestableBlock implements TestableBlock { - /** - * The block type. - */ - private final Material material; +public class UnrestrictedMaterialTestableBlock extends MaterialTestableBlock { /** * Create a new unrestricted material testable block. @@ -23,7 +19,7 @@ public class UnrestrictedMaterialTestableBlock implements TestableBlock { * @param material The material. */ public UnrestrictedMaterialTestableBlock(@NotNull final Material material) { - this.material = material; + super(material); } @Override @@ -40,13 +36,4 @@ public boolean matches(@Nullable final Block other) { return block; } - - /** - * Get the material. - * - * @return The material. - */ - public Material getMaterial() { - return this.material; - } } diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirection.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirection.kt index dcd8aaa68..aea73ba16 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirection.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirection.kt @@ -1,13 +1,13 @@ package com.willfp.eco.internal.blocks +import com.willfp.eco.core.blocks.args.BlockArgParseResult import com.willfp.eco.core.blocks.args.BlockArgParser import org.bukkit.block.BlockFace import org.bukkit.block.data.BlockData import org.bukkit.block.data.Directional -import java.util.function.Predicate object BlockArgParserDirection : BlockArgParser { - override fun parseArguments(args: Array, blockData: BlockData): Predicate? { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { var direction: BlockFace? = null val directional = blockData as? Directional ?: return null @@ -30,6 +30,20 @@ object BlockArgParserDirection : BlockArgParser { direction ?: return null - return Predicate { it is Directional && it.facing == direction } + directional.facing = direction + + return BlockArgParseResult( + { + val directional = it.blockData as? Directional ?: return@BlockArgParseResult false + + directional.facing == direction + }, + { + val directional = it.blockData as? Directional ?: return@BlockArgParseResult + + directional.facing = direction + it.blockData = directional + } + ) } } \ No newline at end of file From 97bc5b674a2b2cc137c579d585bb73619be54bcf Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Fri, 9 Jan 2026 14:11:11 +0200 Subject: [PATCH 11/15] Continue working with block args x3 --- .../blocks/impl/ModifiedTestableBlock.java | 4 +- .../internal/blocks/BlockArgParserAgeable.kt | 48 +++++++++++++ .../blocks/BlockArgParserAnaloguePowerable.kt | 48 +++++++++++++ .../blocks/BlockArgParserAttachable.kt | 38 ++++++++++ .../internal/blocks/BlockArgParserBamboo.kt | 43 ++++++++++++ .../eco/internal/blocks/BlockArgParserBed.kt | 43 ++++++++++++ .../blocks/BlockArgParserBubbleColumn.kt | 38 ++++++++++ .../eco/internal/blocks/BlockArgParserCake.kt | 48 +++++++++++++ .../internal/blocks/BlockArgParserCampfire.kt | 38 ++++++++++ .../internal/blocks/BlockArgParserCandle.kt | 48 +++++++++++++ .../blocks/BlockArgParserCaveVinesPlant.kt | 38 ++++++++++ .../internal/blocks/BlockArgParserChest.kt | 43 ++++++++++++ .../blocks/BlockArgParserCommandBlock.kt | 38 ++++++++++ .../blocks/BlockArgParserComparator.kt | 43 ++++++++++++ .../internal/blocks/BlockArgParserCrafter.kt | 70 +++++++++++++++++++ .../blocks/BlockArgParserDaylightDetector.kt | 38 ++++++++++ ...ection.kt => BlockArgParserDirectional.kt} | 4 +- .../blocks/BlockArgParserDispenser.kt | 38 ++++++++++ .../eco/internal/blocks/BlockArgParserDoor.kt | 43 ++++++++++++ .../blocks/BlockArgParserEndPortalFrame.kt | 38 ++++++++++ .../blocks/BlockArgParserFaceAttachable.kt | 43 ++++++++++++ .../internal/blocks/BlockArgParserFarmland.kt | 48 +++++++++++++ .../eco/internal/blocks/BlockArgParserGate.kt | 38 ++++++++++ .../internal/blocks/BlockArgParserHangable.kt | 38 ++++++++++ .../blocks/BlockArgParserHangingMoss.kt | 38 ++++++++++ .../blocks/BlockArgParserHatchable.kt | 48 +++++++++++++ .../internal/blocks/BlockArgParserJigsaw.kt | 43 ++++++++++++ .../internal/blocks/BlockArgParserLevelled.kt | 48 +++++++++++++ .../blocks/BlockArgParserLightable.kt | 38 ++++++++++ .../blocks/BlockArgParserMossyCarpet.kt | 57 +++++++++++++++ .../eco/internal/spigot/EcoSpigotPlugin.kt | 6 +- 31 files changed, 1227 insertions(+), 7 deletions(-) create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAgeable.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAnaloguePowerable.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAttachable.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBamboo.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBed.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBubbleColumn.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCake.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCampfire.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCandle.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCaveVinesPlant.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserChest.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCommandBlock.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserComparator.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCrafter.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDaylightDetector.kt rename eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/{BlockArgParserDirection.kt => BlockArgParserDirectional.kt} (89%) create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDispenser.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDoor.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserEndPortalFrame.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFaceAttachable.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFarmland.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserGate.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangable.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangingMoss.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHatchable.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserJigsaw.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLevelled.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLightable.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserMossyCarpet.kt diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java index d9d675d6d..cc563870f 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java @@ -1,11 +1,9 @@ package com.willfp.eco.core.blocks.impl; import com.willfp.eco.core.blocks.TestableBlock; -import com.willfp.eco.core.entities.TestableEntity; import org.apache.commons.lang.Validate; import org.bukkit.Location; import org.bukkit.block.Block; -import org.bukkit.entity.Entity; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -54,7 +52,7 @@ public boolean matches(@Nullable final Block block) { } @Override - public Block place(@NotNull final Location location) { + public @NotNull Block place(@NotNull final Location location) { Validate.notNull(location.getWorld()); return provider.apply(location); diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAgeable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAgeable.kt new file mode 100644 index 000000000..dfaa2a113 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAgeable.kt @@ -0,0 +1,48 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.Ageable +import org.bukkit.block.data.BlockData + +object BlockArgParserAgeable : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var age: Int? = null + + val ageable = blockData as? Ageable ?: return null + val maximumAge = ageable.maximumAge + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("age", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + val argAge = argSplit[1].toIntOrNull() ?: continue + if (argAge in (maximumAge + 1)..<0) { + continue + } + age = argAge + } + + age ?: return null + + ageable.age = age + + return BlockArgParseResult( + { + val ageable = it.blockData as? Ageable ?: return@BlockArgParseResult false + + ageable.age == age + }, + { + val ageable = it.blockData as? Ageable ?: return@BlockArgParseResult + + ageable.age = age + it.blockData = ageable + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAnaloguePowerable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAnaloguePowerable.kt new file mode 100644 index 000000000..ea64c8285 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAnaloguePowerable.kt @@ -0,0 +1,48 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.AnaloguePowerable +import org.bukkit.block.data.BlockData + +object BlockArgParserAnaloguePowerable : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var power: Int? = null + + val analoguePowerable = blockData as? AnaloguePowerable ?: return null + val maximumPower = analoguePowerable.maximumPower + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("power", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + val argPower = argSplit[1].toIntOrNull() ?: continue + if (argPower in (maximumPower + 1)..<0) { + continue + } + power = argPower + } + + power ?: return null + + analoguePowerable.power = power + + return BlockArgParseResult( + { + val analoguePowerable = it.blockData as? AnaloguePowerable ?: return@BlockArgParseResult false + + analoguePowerable.power == power + }, + { + val analoguePowerable = it.blockData as? AnaloguePowerable ?: return@BlockArgParseResult + + analoguePowerable.power = power + it.blockData = analoguePowerable + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAttachable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAttachable.kt new file mode 100644 index 000000000..666197bb0 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAttachable.kt @@ -0,0 +1,38 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.Attachable +import org.bukkit.block.data.BlockData + +object BlockArgParserAttachable : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var attached: Boolean? = null + + val attachable = blockData as? Attachable ?: return null + + for (arg in args) { + if (arg.equals("attached", true)) { + attached = true + } + } + + attached ?: return null + + attachable.isAttached = attached + + return BlockArgParseResult( + { + val attachable = it.blockData as? Attachable ?: return@BlockArgParseResult false + + attachable.isAttached == attached + }, + { + val attachable = it.blockData as? Attachable ?: return@BlockArgParseResult + + attachable.isAttached = attached + it.blockData = attachable + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBamboo.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBamboo.kt new file mode 100644 index 000000000..1199816b5 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBamboo.kt @@ -0,0 +1,43 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Bamboo + +object BlockArgParserBamboo : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var bambooLeaves: Bamboo.Leaves? = null + + val bamboo = blockData as? Bamboo ?: return null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("bamboo_leaves", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + bambooLeaves = runCatching { Bamboo.Leaves.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + bambooLeaves ?: return null + + bamboo.leaves = bambooLeaves + + return BlockArgParseResult( + { + val bamboo = it.blockData as? Bamboo ?: return@BlockArgParseResult false + + bamboo.leaves == bambooLeaves + }, + { + val bamboo = it.blockData as? Bamboo ?: return@BlockArgParseResult + + bamboo.leaves = bambooLeaves + it.blockData = bamboo + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBed.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBed.kt new file mode 100644 index 000000000..1dc61e811 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBed.kt @@ -0,0 +1,43 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Bed + +object BlockArgParserBed : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var bedPart: Bed.Part? = null + + val bed = blockData as? Bed ?: return null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("bed_part", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + bedPart = runCatching { Bed.Part.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + bedPart ?: return null + + bed.part = bedPart + + return BlockArgParseResult( + { + val bed = it.blockData as? Bed ?: return@BlockArgParseResult false + + bed.part == bedPart + }, + { + val bed = it.blockData as? Bed ?: return@BlockArgParseResult + + bed.part = bedPart + it.blockData = bed + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBubbleColumn.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBubbleColumn.kt new file mode 100644 index 000000000..fe40c2505 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBubbleColumn.kt @@ -0,0 +1,38 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.BubbleColumn + +object BlockArgParserBubbleColumn : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var drag: Boolean? = null + + val bubbleColumn = blockData as? BubbleColumn ?: return null + + for (arg in args) { + if (arg.equals("drag", true)) { + drag = true + } + } + + drag ?: return null + + bubbleColumn.isDrag = drag + + return BlockArgParseResult( + { + val bubbleColumn = it.blockData as? BubbleColumn ?: return@BlockArgParseResult false + + bubbleColumn.isDrag == drag + }, + { + val bubbleColumn = it.blockData as? BubbleColumn ?: return@BlockArgParseResult + + bubbleColumn.isDrag = drag + it.blockData = bubbleColumn + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCake.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCake.kt new file mode 100644 index 000000000..cd48b7d78 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCake.kt @@ -0,0 +1,48 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Cake + +object BlockArgParserCake : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var bites: Int? = null + + val cake = blockData as? Cake ?: return null + val maximumBites = cake.maximumBites + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("bites", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + val argBites = argSplit[1].toIntOrNull() ?: continue + if (argBites in (maximumBites + 1)..<0) { + continue + } + bites = argBites + } + + bites ?: return null + + cake.bites = bites + + return BlockArgParseResult( + { + val cake = it.blockData as? Cake ?: return@BlockArgParseResult false + + cake.bites == bites + }, + { + val cake = it.blockData as? Cake ?: return@BlockArgParseResult + + cake.bites = bites + it.blockData = cake + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCampfire.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCampfire.kt new file mode 100644 index 000000000..2d74886af --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCampfire.kt @@ -0,0 +1,38 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Campfire + +object BlockArgParserCampfire : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var signalFire: Boolean? = null + + val campfire = blockData as? Campfire ?: return null + + for (arg in args) { + if (arg.equals("signal_fire", true)) { + signalFire = true + } + } + + signalFire ?: return null + + campfire.isSignalFire = signalFire + + return BlockArgParseResult( + { + val campfire = it.blockData as? Campfire ?: return@BlockArgParseResult false + + campfire.isSignalFire == signalFire + }, + { + val campfire = it.blockData as? Campfire ?: return@BlockArgParseResult + + campfire.isSignalFire = signalFire + it.blockData = campfire + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCandle.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCandle.kt new file mode 100644 index 000000000..c9fe6d26f --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCandle.kt @@ -0,0 +1,48 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Candle + +object BlockArgParserCandle : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var candles: Int? = null + + val candle = blockData as? Candle ?: return null + val maximumCandles = candle.maximumCandles + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("candles", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + val argCandles = argSplit[1].toIntOrNull() ?: continue + if (argCandles in (maximumCandles + 1)..<0) { + continue + } + candles = argCandles + } + + candles ?: return null + + candle.candles = candles + + return BlockArgParseResult( + { + val candle = it.blockData as? Candle ?: return@BlockArgParseResult false + + candle.candles == candles + }, + { + val candle = it.blockData as? Candle ?: return@BlockArgParseResult + + candle.candles = candles + it.blockData = candle + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCaveVinesPlant.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCaveVinesPlant.kt new file mode 100644 index 000000000..630f0e243 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCaveVinesPlant.kt @@ -0,0 +1,38 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.CaveVinesPlant + +object BlockArgParserCaveVinesPlant : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var berries: Boolean? = null + + val caveVinesPlant = blockData as? CaveVinesPlant ?: return null + + for (arg in args) { + if (arg.equals("berries", true)) { + berries = true + } + } + + berries ?: return null + + caveVinesPlant.isBerries = berries + + return BlockArgParseResult( + { + val caveVinesPlant = it.blockData as? CaveVinesPlant ?: return@BlockArgParseResult false + + caveVinesPlant.isBerries == berries + }, + { + val caveVinesPlant = it.blockData as? CaveVinesPlant ?: return@BlockArgParseResult + + caveVinesPlant.isBerries = berries + it.blockData = caveVinesPlant + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserChest.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserChest.kt new file mode 100644 index 000000000..b8cdd1069 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserChest.kt @@ -0,0 +1,43 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Chest + +object BlockArgParserChest : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var chestType: Chest.Type? = null + + val chest = blockData as? Chest ?: return null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("chest_type", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + chestType = runCatching { Chest.Type.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + chestType ?: return null + + chest.type = chestType + + return BlockArgParseResult( + { + val chest = it.blockData as? Chest ?: return@BlockArgParseResult false + + chest.type == chestType + }, + { + val chest = it.blockData as? Chest ?: return@BlockArgParseResult + + chest.type = chestType + it.blockData = chest + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCommandBlock.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCommandBlock.kt new file mode 100644 index 000000000..80afaf5cd --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCommandBlock.kt @@ -0,0 +1,38 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.CommandBlock + +object BlockArgParserCommandBlock : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var conditional: Boolean? = null + + val commandBlock = blockData as? CommandBlock ?: return null + + for (arg in args) { + if (arg.equals("conditional", true)) { + conditional = true + } + } + + conditional ?: return null + + commandBlock.isConditional = conditional + + return BlockArgParseResult( + { + val commandBlock = it.blockData as? CommandBlock ?: return@BlockArgParseResult false + + commandBlock.isConditional == conditional + }, + { + val commandBlock = it.blockData as? CommandBlock ?: return@BlockArgParseResult + + commandBlock.isConditional = conditional + it.blockData = commandBlock + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserComparator.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserComparator.kt new file mode 100644 index 000000000..7ec9556c0 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserComparator.kt @@ -0,0 +1,43 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Comparator + +object BlockArgParserComparator : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var comparatorMode: Comparator.Mode? = null + + val comparator = blockData as? Comparator ?: return null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("comparator_mode", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + comparatorMode = runCatching { Comparator.Mode.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + comparatorMode ?: return null + + comparator.mode = comparatorMode + + return BlockArgParseResult( + { + val comparator = it.blockData as? Comparator ?: return@BlockArgParseResult false + + comparator.mode == comparatorMode + }, + { + val comparator = it.blockData as? Comparator ?: return@BlockArgParseResult + + comparator.mode = comparatorMode + it.blockData = comparator + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCrafter.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCrafter.kt new file mode 100644 index 000000000..030ccc350 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCrafter.kt @@ -0,0 +1,70 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Crafter + +object BlockArgParserCrafter : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var orientation: Crafter.Orientation? = null + var triggered: Boolean? = null + var crafting: Boolean? = null + + val crafter = blockData as? Crafter ?: return null + + for (arg in args) { + val argSplit = arg.split(":") + if (argSplit[0].equals("orientation", ignoreCase = true)) { + if (argSplit.size < 2) { + continue + } + orientation = + runCatching { Crafter.Orientation.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } else if (argSplit[0].equals("triggered", ignoreCase = true)) { + triggered = true + } else if (argSplit[0].equals("crafting", ignoreCase = true)) { + crafting = true + } + } + + if (orientation != null) { + crafter.orientation = orientation + } + + if (triggered != null) { + crafter.isTriggered = triggered + } + + if (crafting != null) { + crafter.isCrafting = crafting + } + + return BlockArgParseResult( + { + val crafter = it.blockData as? Crafter ?: return@BlockArgParseResult false + + (orientation == null || crafter.orientation == orientation) && + (triggered == null || crafter.isTriggered == triggered) && + (crafting == null || crafter.isCrafting == crafting) + }, + { + val crafter = it.blockData as? Crafter ?: return@BlockArgParseResult + + if (orientation != null) { + crafter.orientation = orientation + } + + if (triggered != null) { + crafter.isTriggered = triggered + } + + if (crafting != null) { + crafter.isCrafting = crafting + } + + it.blockData = crafter + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDaylightDetector.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDaylightDetector.kt new file mode 100644 index 000000000..41c34fe15 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDaylightDetector.kt @@ -0,0 +1,38 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.DaylightDetector + +object BlockArgParserDaylightDetector : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var inveted: Boolean? = null + + val daylightDetector = blockData as? DaylightDetector ?: return null + + for (arg in args) { + if (arg.equals("inverted", true)) { + inveted = true + } + } + + inveted ?: return null + + daylightDetector.isInverted = inveted + + return BlockArgParseResult( + { + val daylightDetector = it.blockData as? DaylightDetector ?: return@BlockArgParseResult false + + daylightDetector.isInverted == inveted + }, + { + val daylightDetector = it.blockData as? DaylightDetector ?: return@BlockArgParseResult + + daylightDetector.isInverted = inveted + it.blockData = daylightDetector + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirection.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirectional.kt similarity index 89% rename from eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirection.kt rename to eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirectional.kt index aea73ba16..c9e952e81 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirection.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirectional.kt @@ -6,7 +6,7 @@ import org.bukkit.block.BlockFace import org.bukkit.block.data.BlockData import org.bukkit.block.data.Directional -object BlockArgParserDirection : BlockArgParser { +object BlockArgParserDirectional : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { var direction: BlockFace? = null @@ -21,7 +21,7 @@ object BlockArgParserDirection : BlockArgParser { if (argSplit.size < 2) { continue } - val argDirection = BlockFace.valueOf(argSplit[1].uppercase()) + val argDirection = runCatching { BlockFace.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue if (!directions.contains(argDirection)) { continue } diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDispenser.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDispenser.kt new file mode 100644 index 000000000..98288c36c --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDispenser.kt @@ -0,0 +1,38 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Dispenser + +object BlockArgParserDispenser : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var triggered: Boolean? = null + + val dispenser = blockData as? Dispenser ?: return null + + for (arg in args) { + if (arg.equals("triggered", true)) { + triggered = true + } + } + + triggered ?: return null + + dispenser.isTriggered = triggered + + return BlockArgParseResult( + { + val dispenser = it.blockData as? Dispenser ?: return@BlockArgParseResult false + + dispenser.isTriggered == triggered + }, + { + val dispenser = it.blockData as? Dispenser ?: return@BlockArgParseResult + + dispenser.isTriggered = triggered + it.blockData = dispenser + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDoor.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDoor.kt new file mode 100644 index 000000000..303a90956 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDoor.kt @@ -0,0 +1,43 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Door + +object BlockArgParserDoor : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var doorHinge: Door.Hinge? = null + + val door = blockData as? Door ?: return null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("hinge", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + doorHinge = runCatching { Door.Hinge.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + doorHinge ?: return null + + door.hinge = doorHinge + + return BlockArgParseResult( + { + val door = it.blockData as? Door ?: return@BlockArgParseResult false + + door.hinge == doorHinge + }, + { + val door = it.blockData as? Door ?: return@BlockArgParseResult + + door.hinge = doorHinge + it.blockData = door + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserEndPortalFrame.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserEndPortalFrame.kt new file mode 100644 index 000000000..ed5b5908b --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserEndPortalFrame.kt @@ -0,0 +1,38 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.EndPortalFrame + +object BlockArgParserEndPortalFrame : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var eye: Boolean? = null + + val endPortalFrame = blockData as? EndPortalFrame ?: return null + + for (arg in args) { + if (arg.equals("eye", true)) { + eye = true + } + } + + eye ?: return null + + endPortalFrame.setEye(eye) + + return BlockArgParseResult( + { + val endPortalFrame = it.blockData as? EndPortalFrame ?: return@BlockArgParseResult false + + endPortalFrame.hasEye() == eye + }, + { + val endPortalFrame = it.blockData as? EndPortalFrame ?: return@BlockArgParseResult + + endPortalFrame.setEye(eye) + it.blockData = endPortalFrame + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFaceAttachable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFaceAttachable.kt new file mode 100644 index 000000000..5fbc4e30d --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFaceAttachable.kt @@ -0,0 +1,43 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.FaceAttachable + +object BlockArgParserFaceAttachable : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var attachedFace: FaceAttachable.AttachedFace? = null + + val faceAttachable = blockData as? FaceAttachable ?: return null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("attached_face", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + attachedFace = runCatching { FaceAttachable.AttachedFace.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + attachedFace ?: return null + + faceAttachable.attachedFace = attachedFace + + return BlockArgParseResult( + { + val faceAttachable = it.blockData as? FaceAttachable ?: return@BlockArgParseResult false + + faceAttachable.attachedFace == attachedFace + }, + { + val faceAttachable = it.blockData as? FaceAttachable ?: return@BlockArgParseResult + + faceAttachable.attachedFace = attachedFace + it.blockData = faceAttachable + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFarmland.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFarmland.kt new file mode 100644 index 000000000..222e8e995 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFarmland.kt @@ -0,0 +1,48 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Farmland + +object BlockArgParserFarmland : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var moisture: Int? = null + + val farmland = blockData as? Farmland ?: return null + val maximumMoisture = farmland.maximumMoisture + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("moisture", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + val argMoisture = argSplit[1].toIntOrNull() ?: continue + if (argMoisture in (maximumMoisture + 1)..<0) { + continue + } + moisture = argMoisture + } + + moisture ?: return null + + farmland.moisture = moisture + + return BlockArgParseResult( + { + val farmland = it.blockData as? Farmland ?: return@BlockArgParseResult false + + farmland.moisture == moisture + }, + { + val farmland = it.blockData as? Farmland ?: return@BlockArgParseResult + + farmland.moisture = moisture + it.blockData = farmland + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserGate.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserGate.kt new file mode 100644 index 000000000..1ed6363ad --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserGate.kt @@ -0,0 +1,38 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Gate + +object BlockArgParserGate : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var inWall: Boolean? = null + + val gate = blockData as? Gate ?: return null + + for (arg in args) { + if (arg.equals("in_wall", true)) { + inWall = true + } + } + + inWall ?: return null + + gate.isInWall = inWall + + return BlockArgParseResult( + { + val gate = it.blockData as? Gate ?: return@BlockArgParseResult false + + gate.isInWall == inWall + }, + { + val gate = it.blockData as? Gate ?: return@BlockArgParseResult + + gate.isInWall = inWall + it.blockData = gate + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangable.kt new file mode 100644 index 000000000..61335bf7d --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangable.kt @@ -0,0 +1,38 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.Hangable + +object BlockArgParserHangable : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var hanging: Boolean? = null + + val hangable = blockData as? Hangable ?: return null + + for (arg in args) { + if (arg.equals("hanging", true)) { + hanging = true + } + } + + hanging ?: return null + + hangable.isHanging = hanging + + return BlockArgParseResult( + { + val hangable = it.blockData as? Hangable ?: return@BlockArgParseResult false + + hangable.isHanging == hanging + }, + { + val hangable = it.blockData as? Hangable ?: return@BlockArgParseResult + + hangable.isHanging = hanging + it.blockData = hangable + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangingMoss.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangingMoss.kt new file mode 100644 index 000000000..b0e44ac3a --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangingMoss.kt @@ -0,0 +1,38 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.HangingMoss + +object BlockArgParserHangingMoss : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var tip: Boolean? = null + + val hangingMoss = blockData as? HangingMoss ?: return null + + for (arg in args) { + if (arg.equals("tip", true)) { + tip = true + } + } + + tip ?: return null + + hangingMoss.isTip = tip + + return BlockArgParseResult( + { + val hangingMoss = it.blockData as? HangingMoss ?: return@BlockArgParseResult false + + hangingMoss.isTip == tip + }, + { + val hangingMoss = it.blockData as? HangingMoss ?: return@BlockArgParseResult + + hangingMoss.isTip = tip + it.blockData = hangingMoss + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHatchable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHatchable.kt new file mode 100644 index 000000000..d98ce71bb --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHatchable.kt @@ -0,0 +1,48 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.Hatchable + +object BlockArgParserHatchable : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var hatching: Int? = null + + val hatchable = blockData as? Hatchable ?: return null + val maximumHatches = hatchable.maximumHatch + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("hatching", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + val argHatching = argSplit[1].toIntOrNull() ?: continue + if (argHatching in (maximumHatches + 1)..<0) { + continue + } + hatching = argHatching + } + + hatching ?: return null + + hatchable.hatch = hatching + + return BlockArgParseResult( + { + val hatchable = it.blockData as? Hatchable ?: return@BlockArgParseResult false + + hatchable.hatch == hatching + }, + { + val hatchable = it.blockData as? Hatchable ?: return@BlockArgParseResult + + hatchable.hatch = hatching + it.blockData = hatchable + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserJigsaw.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserJigsaw.kt new file mode 100644 index 000000000..92c80cd09 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserJigsaw.kt @@ -0,0 +1,43 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Jigsaw + +object BlockArgParserJigsaw : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var orientation: Jigsaw.Orientation? = null + + val jigsaw = blockData as? Jigsaw ?: return null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("orientation", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + orientation = runCatching { Jigsaw.Orientation.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + orientation ?: return null + + jigsaw.orientation = orientation + + return BlockArgParseResult( + { + val jigsaw = it.blockData as? Jigsaw ?: return@BlockArgParseResult false + + jigsaw.orientation == orientation + }, + { + val jigsaw = it.blockData as? Jigsaw ?: return@BlockArgParseResult + + jigsaw.orientation = orientation + it.blockData = jigsaw + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLevelled.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLevelled.kt new file mode 100644 index 000000000..211504995 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLevelled.kt @@ -0,0 +1,48 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.Levelled + +object BlockArgParserLevelled : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var level: Int? = null + + val levelled = blockData as? Levelled ?: return null + val maximumLevel = levelled.maximumLevel + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("level", ignoreCase = true)) { + continue + } + if (argSplit.size < 2) { + continue + } + val argLevel = argSplit[1].toIntOrNull() ?: continue + if (argLevel in (maximumLevel + 1)..<0) { + continue + } + level = argLevel + } + + level ?: return null + + levelled.level = level + + return BlockArgParseResult( + { + val levelled = it.blockData as? Levelled ?: return@BlockArgParseResult false + + levelled.level == level + }, + { + val levelled = it.blockData as? Levelled ?: return@BlockArgParseResult + + levelled.level = level + it.blockData = levelled + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLightable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLightable.kt new file mode 100644 index 000000000..bd9e8e139 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLightable.kt @@ -0,0 +1,38 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.Lightable + +object BlockArgParserLightable : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + var lit: Boolean? = null + + val lightable = blockData as? Lightable ?: return null + + for (arg in args) { + if (arg.equals("lit", true)) { + lit = true + } + } + + lit ?: return null + + lightable.isLit = lit + + return BlockArgParseResult( + { + val lightable = it.blockData as? Lightable ?: return@BlockArgParseResult false + + lightable.isLit == lit + }, + { + val lightable = it.blockData as? Lightable ?: return@BlockArgParseResult + + lightable.isLit = lit + it.blockData = lightable + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserMossyCarpet.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserMossyCarpet.kt new file mode 100644 index 000000000..7a877f588 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserMossyCarpet.kt @@ -0,0 +1,57 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.BlockFace +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.MossyCarpet + +object BlockArgParserMossyCarpet : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + val mossyCarpetHeight = BlockFace.entries.associateWith { MossyCarpet.Height.NONE }.toMutableMap() + var mossyCarpetBottom: Boolean? = null + + val mossyCarpet = blockData as? MossyCarpet ?: return null + + for (arg in args) { + val argSplit = arg.split(":") + if (argSplit[0].equals("height", ignoreCase = true)) { + if (argSplit.size < 3) { + continue + } + val face = runCatching { BlockFace.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + val height = runCatching { MossyCarpet.Height.valueOf(argSplit[2].uppercase()) }.getOrNull() ?: continue + mossyCarpetHeight += face to height + } else if (argSplit[0].equals("bottom", ignoreCase = true)) { + mossyCarpetBottom = true + } + } + + mossyCarpetHeight.forEach { mossyCarpet.setHeight(it.key, it.value) } + + if (mossyCarpetBottom != null) { + mossyCarpet.isBottom = mossyCarpetBottom + } + + return BlockArgParseResult( + { + val mossyCarpet = it.blockData as? MossyCarpet ?: return@BlockArgParseResult false + + BlockFace.entries.all { face -> + mossyCarpetHeight[face] != mossyCarpet.getHeight(face) + } && (mossyCarpetBottom == null || mossyCarpet.isBottom == mossyCarpetBottom) + }, + { + val mossyCarpet = it.blockData as? MossyCarpet ?: return@BlockArgParseResult + + mossyCarpetHeight.forEach { carpet -> mossyCarpet.setHeight(carpet.key, carpet.value) } + + if (mossyCarpetBottom != null) { + mossyCarpet.isBottom = mossyCarpetBottom + } + + it.blockData = mossyCarpet + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt index 7a4aa6c3b..b5ae6a00a 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt @@ -22,7 +22,8 @@ import com.willfp.eco.core.items.Items import com.willfp.eco.core.packet.PacketListener import com.willfp.eco.core.particle.Particles import com.willfp.eco.core.price.Prices -import com.willfp.eco.internal.blocks.BlockArgParserDirection +import com.willfp.eco.internal.blocks.BlockArgParserAgeable +import com.willfp.eco.internal.blocks.BlockArgParserDirectional import com.willfp.eco.internal.data.MavenVersionToStringAdapter import com.willfp.eco.internal.data.VersionToStringAdapter import com.willfp.eco.internal.entities.EntityArgParserAdult @@ -195,7 +196,8 @@ abstract class EcoSpigotPlugin : EcoPlugin() { Items.registerArgParser(ArgParserTooltipStyle) Items.registerArgParser(ArgParserTrim) - Blocks.registerArgParser(BlockArgParserDirection) + Blocks.registerArgParser(BlockArgParserDirectional) + Blocks.registerArgParser(BlockArgParserAgeable) Entities.registerArgParser(EntityArgParserName) Entities.registerArgParser(EntityArgParserNoAI) From dffc07665a8b86bd86f49fd60275d87d8aac5eeb Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Sun, 11 Jan 2026 02:36:27 +0200 Subject: [PATCH 12/15] Continue working with block args x4 --- .../com/willfp/eco/core/blocks/Blocks.java | 1 + .../eco/core/blocks/args/BlockArgParser.java | 1 + .../internal/blocks/BlockArgParserAgeable.kt | 32 +++++--- .../blocks/BlockArgParserAnaloguePowerable.kt | 10 +-- .../blocks/BlockArgParserAttachable.kt | 5 +- .../internal/blocks/BlockArgParserBamboo.kt | 7 +- .../eco/internal/blocks/BlockArgParserBed.kt | 43 ----------- .../internal/blocks/BlockArgParserBisected.kt | 40 ++++++++++ .../blocks/BlockArgParserBubbleColumn.kt | 5 +- .../eco/internal/blocks/BlockArgParserCake.kt | 10 +-- .../internal/blocks/BlockArgParserCampfire.kt | 5 +- .../internal/blocks/BlockArgParserCandle.kt | 48 ------------ .../blocks/BlockArgParserCaveVinesPlant.kt | 5 +- .../internal/blocks/BlockArgParserChest.kt | 7 +- .../blocks/BlockArgParserCommandBlock.kt | 5 +- .../blocks/BlockArgParserComparator.kt | 7 +- .../internal/blocks/BlockArgParserCrafter.kt | 36 +++------ .../blocks/BlockArgParserDaylightDetector.kt | 15 ++-- .../blocks/BlockArgParserDirectional.kt | 14 +--- .../blocks/BlockArgParserDispenser.kt | 5 +- .../eco/internal/blocks/BlockArgParserDoor.kt | 7 +- .../blocks/BlockArgParserEndPortalFrame.kt | 5 +- .../blocks/BlockArgParserFaceAttachable.kt | 7 +- .../internal/blocks/BlockArgParserFarmland.kt | 10 +-- .../eco/internal/blocks/BlockArgParserGate.kt | 5 +- .../internal/blocks/BlockArgParserHangable.kt | 5 +- .../blocks/BlockArgParserHangingMoss.kt | 5 +- .../blocks/BlockArgParserHatchable.kt | 48 ------------ .../internal/blocks/BlockArgParserJigsaw.kt | 7 +- .../internal/blocks/BlockArgParserLevelled.kt | 10 +-- .../blocks/BlockArgParserLightable.kt | 5 +- .../blocks/BlockArgParserMossyCarpet.kt | 23 ++---- .../blocks/BlockArgParserMultipleFacing.kt | 44 +++++++++++ .../blocks/BlockArgParserNoteBlock.kt | 40 ++++++++++ .../internal/blocks/BlockArgParserOpenable.kt | 35 +++++++++ .../blocks/BlockArgParserOrientable.kt | 41 ++++++++++ .../blocks/BlockArgParserPointedDripstone.kt | 54 +++++++++++++ .../blocks/BlockArgParserPowerable.kt | 35 +++++++++ .../internal/blocks/BlockArgParserQuantity.kt | 69 +++++++++++++++++ .../eco/internal/blocks/BlockArgParserRail.kt | 40 ++++++++++ .../blocks/BlockArgParserRedstoneWire.kt | 44 +++++++++++ .../internal/blocks/BlockArgParserRepeater.kt | 48 ++++++++++++ .../blocks/BlockArgParserRespawnAnchor.kt | 44 +++++++++++ .../blocks/BlockArgParserRotatable.kt | 41 ++++++++++ .../blocks/BlockArgParserScaffolding.kt | 48 ++++++++++++ .../blocks/BlockArgParserSculkSensor.kt | 40 ++++++++++ .../blocks/BlockArgParserSculkShrieker.kt | 41 ++++++++++ .../eco/internal/blocks/BlockArgParserSlab.kt | 40 ++++++++++ .../eco/internal/blocks/BlockArgParserSnow.kt | 44 +++++++++++ .../internal/blocks/BlockArgParserSnowy.kt | 35 +++++++++ .../internal/blocks/BlockArgParserStairs.kt | 40 ++++++++++ .../blocks/BlockArgParserStructureBlock.kt | 40 ++++++++++ .../eco/internal/blocks/BlockArgParserTNT.kt | 35 +++++++++ .../blocks/BlockArgParserTrialSpawner.kt | 75 +++++++++++++++++++ .../internal/blocks/BlockArgParserTripwire.kt | 35 +++++++++ .../eco/internal/blocks/BlockArgParserWall.kt | 48 ++++++++++++ .../blocks/BlockArgParserWaterlogged.kt | 35 +++++++++ 57 files changed, 1213 insertions(+), 316 deletions(-) delete mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBed.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBisected.kt delete mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCandle.kt delete mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHatchable.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserMultipleFacing.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserNoteBlock.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserOpenable.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserOrientable.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserPointedDripstone.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserPowerable.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserQuantity.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRail.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRedstoneWire.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRepeater.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRespawnAnchor.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRotatable.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserScaffolding.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSculkSensor.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSculkShrieker.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSlab.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSnow.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSnowy.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserStairs.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserStructureBlock.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTNT.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTrialSpawner.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTripwire.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserWall.kt create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserWaterlogged.kt diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java index 7e209260d..5b48b610d 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java @@ -19,6 +19,7 @@ import org.bukkit.Material; import org.bukkit.NamespacedKey; import org.bukkit.block.Block; +import org.bukkit.block.BlockState; import org.bukkit.block.data.BlockData; import org.bukkit.entity.Entity; import org.jetbrains.annotations.NotNull; diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java index f2e7facb9..9ee8d354a 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java @@ -3,6 +3,7 @@ import com.willfp.eco.core.blocks.TestableBlock; import org.bukkit.Location; import org.bukkit.block.Block; +import org.bukkit.block.BlockState; import org.bukkit.block.data.BlockData; import org.bukkit.inventory.ItemStack; import org.jetbrains.annotations.NotNull; diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAgeable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAgeable.kt index dfaa2a113..feea77914 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAgeable.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAgeable.kt @@ -4,17 +4,20 @@ import com.willfp.eco.core.blocks.args.BlockArgParseResult import com.willfp.eco.core.blocks.args.BlockArgParser import org.bukkit.block.data.Ageable import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Sapling object BlockArgParserAgeable : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + val maximumAge = when (blockData) { + is Ageable -> blockData.maximumAge + is Sapling -> blockData.maximumStage + else -> return null + } var age: Int? = null - val ageable = blockData as? Ageable ?: return null - val maximumAge = ageable.maximumAge - for (arg in args) { val argSplit = arg.split(":") - if (!argSplit[0].equals("age", ignoreCase = true)) { + if (!argSplit[0].equals("age", true)) { continue } if (argSplit.size < 2) { @@ -29,19 +32,24 @@ object BlockArgParserAgeable : BlockArgParser { age ?: return null - ageable.age = age - return BlockArgParseResult( { - val ageable = it.blockData as? Ageable ?: return@BlockArgParseResult false - - ageable.age == age + when (val data = it.blockData) { + is Ageable -> data.age == age + is Sapling -> data.stage == age + else -> false + } }, { - val ageable = it.blockData as? Ageable ?: return@BlockArgParseResult + val data = it.blockData + + when (data) { + is Ageable -> data.age = age + is Sapling -> data.stage = age + else -> return@BlockArgParseResult + } - ageable.age = age - it.blockData = ageable + it.blockData = data } ) } diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAnaloguePowerable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAnaloguePowerable.kt index ea64c8285..57e521669 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAnaloguePowerable.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAnaloguePowerable.kt @@ -7,21 +7,19 @@ import org.bukkit.block.data.BlockData object BlockArgParserAnaloguePowerable : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { - var power: Int? = null - val analoguePowerable = blockData as? AnaloguePowerable ?: return null - val maximumPower = analoguePowerable.maximumPower + var power: Int? = null for (arg in args) { val argSplit = arg.split(":") - if (!argSplit[0].equals("power", ignoreCase = true)) { + if (!argSplit[0].equals("power", true)) { continue } if (argSplit.size < 2) { continue } val argPower = argSplit[1].toIntOrNull() ?: continue - if (argPower in (maximumPower + 1)..<0) { + if (argPower in (analoguePowerable.maximumPower + 1)..<0) { continue } power = argPower @@ -29,8 +27,6 @@ object BlockArgParserAnaloguePowerable : BlockArgParser { power ?: return null - analoguePowerable.power = power - return BlockArgParseResult( { val analoguePowerable = it.blockData as? AnaloguePowerable ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAttachable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAttachable.kt index 666197bb0..f9b5c4ac3 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAttachable.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserAttachable.kt @@ -7,10 +7,9 @@ import org.bukkit.block.data.BlockData object BlockArgParserAttachable : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Attachable) return null var attached: Boolean? = null - val attachable = blockData as? Attachable ?: return null - for (arg in args) { if (arg.equals("attached", true)) { attached = true @@ -19,8 +18,6 @@ object BlockArgParserAttachable : BlockArgParser { attached ?: return null - attachable.isAttached = attached - return BlockArgParseResult( { val attachable = it.blockData as? Attachable ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBamboo.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBamboo.kt index 1199816b5..35e28a91c 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBamboo.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBamboo.kt @@ -7,13 +7,12 @@ import org.bukkit.block.data.type.Bamboo object BlockArgParserBamboo : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Bamboo) return null var bambooLeaves: Bamboo.Leaves? = null - val bamboo = blockData as? Bamboo ?: return null - for (arg in args) { val argSplit = arg.split(":") - if (!argSplit[0].equals("bamboo_leaves", ignoreCase = true)) { + if (!argSplit[0].equals("leaves", true)) { continue } if (argSplit.size < 2) { @@ -24,8 +23,6 @@ object BlockArgParserBamboo : BlockArgParser { bambooLeaves ?: return null - bamboo.leaves = bambooLeaves - return BlockArgParseResult( { val bamboo = it.blockData as? Bamboo ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBed.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBed.kt deleted file mode 100644 index 1dc61e811..000000000 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBed.kt +++ /dev/null @@ -1,43 +0,0 @@ -package com.willfp.eco.internal.blocks - -import com.willfp.eco.core.blocks.args.BlockArgParseResult -import com.willfp.eco.core.blocks.args.BlockArgParser -import org.bukkit.block.data.BlockData -import org.bukkit.block.data.type.Bed - -object BlockArgParserBed : BlockArgParser { - override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { - var bedPart: Bed.Part? = null - - val bed = blockData as? Bed ?: return null - - for (arg in args) { - val argSplit = arg.split(":") - if (!argSplit[0].equals("bed_part", ignoreCase = true)) { - continue - } - if (argSplit.size < 2) { - continue - } - bedPart = runCatching { Bed.Part.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue - } - - bedPart ?: return null - - bed.part = bedPart - - return BlockArgParseResult( - { - val bed = it.blockData as? Bed ?: return@BlockArgParseResult false - - bed.part == bedPart - }, - { - val bed = it.blockData as? Bed ?: return@BlockArgParseResult - - bed.part = bedPart - it.blockData = bed - } - ) - } -} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBisected.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBisected.kt new file mode 100644 index 000000000..e777117db --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBisected.kt @@ -0,0 +1,40 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.Bisected +import org.bukkit.block.data.BlockData + +object BlockArgParserBisected : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Bisected) return null + var bisectedHalf: Bisected.Half? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("bisected", true)) { + continue + } + if (argSplit.size < 2) { + continue + } + bisectedHalf = runCatching { Bisected.Half.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + bisectedHalf ?: return null + + return BlockArgParseResult( + { + val bisected = it.blockData as? Bisected ?: return@BlockArgParseResult false + + bisected.half == bisectedHalf + }, + { + val bisected = it.blockData as? Bisected ?: return@BlockArgParseResult + + bisected.half = bisectedHalf + it.blockData = bisected + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBubbleColumn.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBubbleColumn.kt index fe40c2505..145f2d039 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBubbleColumn.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserBubbleColumn.kt @@ -7,10 +7,9 @@ import org.bukkit.block.data.type.BubbleColumn object BlockArgParserBubbleColumn : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is BubbleColumn) return null var drag: Boolean? = null - val bubbleColumn = blockData as? BubbleColumn ?: return null - for (arg in args) { if (arg.equals("drag", true)) { drag = true @@ -19,8 +18,6 @@ object BlockArgParserBubbleColumn : BlockArgParser { drag ?: return null - bubbleColumn.isDrag = drag - return BlockArgParseResult( { val bubbleColumn = it.blockData as? BubbleColumn ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCake.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCake.kt index cd48b7d78..5cba8af5f 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCake.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCake.kt @@ -7,21 +7,19 @@ import org.bukkit.block.data.type.Cake object BlockArgParserCake : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { - var bites: Int? = null - val cake = blockData as? Cake ?: return null - val maximumBites = cake.maximumBites + var bites: Int? = null for (arg in args) { val argSplit = arg.split(":") - if (!argSplit[0].equals("bites", ignoreCase = true)) { + if (!argSplit[0].equals("bites", true)) { continue } if (argSplit.size < 2) { continue } val argBites = argSplit[1].toIntOrNull() ?: continue - if (argBites in (maximumBites + 1)..<0) { + if (argBites in (cake.maximumBites + 1)..<0) { continue } bites = argBites @@ -29,8 +27,6 @@ object BlockArgParserCake : BlockArgParser { bites ?: return null - cake.bites = bites - return BlockArgParseResult( { val cake = it.blockData as? Cake ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCampfire.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCampfire.kt index 2d74886af..2d5106449 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCampfire.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCampfire.kt @@ -7,10 +7,9 @@ import org.bukkit.block.data.type.Campfire object BlockArgParserCampfire : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Campfire) return null var signalFire: Boolean? = null - val campfire = blockData as? Campfire ?: return null - for (arg in args) { if (arg.equals("signal_fire", true)) { signalFire = true @@ -19,8 +18,6 @@ object BlockArgParserCampfire : BlockArgParser { signalFire ?: return null - campfire.isSignalFire = signalFire - return BlockArgParseResult( { val campfire = it.blockData as? Campfire ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCandle.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCandle.kt deleted file mode 100644 index c9fe6d26f..000000000 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCandle.kt +++ /dev/null @@ -1,48 +0,0 @@ -package com.willfp.eco.internal.blocks - -import com.willfp.eco.core.blocks.args.BlockArgParseResult -import com.willfp.eco.core.blocks.args.BlockArgParser -import org.bukkit.block.data.BlockData -import org.bukkit.block.data.type.Candle - -object BlockArgParserCandle : BlockArgParser { - override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { - var candles: Int? = null - - val candle = blockData as? Candle ?: return null - val maximumCandles = candle.maximumCandles - - for (arg in args) { - val argSplit = arg.split(":") - if (!argSplit[0].equals("candles", ignoreCase = true)) { - continue - } - if (argSplit.size < 2) { - continue - } - val argCandles = argSplit[1].toIntOrNull() ?: continue - if (argCandles in (maximumCandles + 1)..<0) { - continue - } - candles = argCandles - } - - candles ?: return null - - candle.candles = candles - - return BlockArgParseResult( - { - val candle = it.blockData as? Candle ?: return@BlockArgParseResult false - - candle.candles == candles - }, - { - val candle = it.blockData as? Candle ?: return@BlockArgParseResult - - candle.candles = candles - it.blockData = candle - } - ) - } -} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCaveVinesPlant.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCaveVinesPlant.kt index 630f0e243..e9667be63 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCaveVinesPlant.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCaveVinesPlant.kt @@ -7,10 +7,9 @@ import org.bukkit.block.data.type.CaveVinesPlant object BlockArgParserCaveVinesPlant : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is CaveVinesPlant) return null var berries: Boolean? = null - val caveVinesPlant = blockData as? CaveVinesPlant ?: return null - for (arg in args) { if (arg.equals("berries", true)) { berries = true @@ -19,8 +18,6 @@ object BlockArgParserCaveVinesPlant : BlockArgParser { berries ?: return null - caveVinesPlant.isBerries = berries - return BlockArgParseResult( { val caveVinesPlant = it.blockData as? CaveVinesPlant ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserChest.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserChest.kt index b8cdd1069..af86805d4 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserChest.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserChest.kt @@ -7,13 +7,12 @@ import org.bukkit.block.data.type.Chest object BlockArgParserChest : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Chest) return null var chestType: Chest.Type? = null - val chest = blockData as? Chest ?: return null - for (arg in args) { val argSplit = arg.split(":") - if (!argSplit[0].equals("chest_type", ignoreCase = true)) { + if (!argSplit[0].equals("type", true)) { continue } if (argSplit.size < 2) { @@ -24,8 +23,6 @@ object BlockArgParserChest : BlockArgParser { chestType ?: return null - chest.type = chestType - return BlockArgParseResult( { val chest = it.blockData as? Chest ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCommandBlock.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCommandBlock.kt index 80afaf5cd..f6727ae93 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCommandBlock.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCommandBlock.kt @@ -7,10 +7,9 @@ import org.bukkit.block.data.type.CommandBlock object BlockArgParserCommandBlock : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is CommandBlock) return null var conditional: Boolean? = null - val commandBlock = blockData as? CommandBlock ?: return null - for (arg in args) { if (arg.equals("conditional", true)) { conditional = true @@ -19,8 +18,6 @@ object BlockArgParserCommandBlock : BlockArgParser { conditional ?: return null - commandBlock.isConditional = conditional - return BlockArgParseResult( { val commandBlock = it.blockData as? CommandBlock ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserComparator.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserComparator.kt index 7ec9556c0..1ff13d5a3 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserComparator.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserComparator.kt @@ -7,13 +7,12 @@ import org.bukkit.block.data.type.Comparator object BlockArgParserComparator : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Comparator) return null var comparatorMode: Comparator.Mode? = null - val comparator = blockData as? Comparator ?: return null - for (arg in args) { val argSplit = arg.split(":") - if (!argSplit[0].equals("comparator_mode", ignoreCase = true)) { + if (!argSplit[0].equals("mode", true)) { continue } if (argSplit.size < 2) { @@ -24,8 +23,6 @@ object BlockArgParserComparator : BlockArgParser { comparatorMode ?: return null - comparator.mode = comparatorMode - return BlockArgParseResult( { val comparator = it.blockData as? Comparator ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCrafter.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCrafter.kt index 030ccc350..e539c6aae 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCrafter.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserCrafter.kt @@ -7,38 +7,28 @@ import org.bukkit.block.data.type.Crafter object BlockArgParserCrafter : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Crafter) return null + var orientation: Crafter.Orientation? = null var triggered: Boolean? = null var crafting: Boolean? = null - val crafter = blockData as? Crafter ?: return null - for (arg in args) { val argSplit = arg.split(":") - if (argSplit[0].equals("orientation", ignoreCase = true)) { + if (argSplit[0].equals("orientation", true)) { if (argSplit.size < 2) { continue } orientation = runCatching { Crafter.Orientation.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue - } else if (argSplit[0].equals("triggered", ignoreCase = true)) { + } else if (argSplit[0].equals("triggered", true)) { triggered = true - } else if (argSplit[0].equals("crafting", ignoreCase = true)) { + } else if (argSplit[0].equals("crafting", true)) { crafting = true } } - if (orientation != null) { - crafter.orientation = orientation - } - - if (triggered != null) { - crafter.isTriggered = triggered - } - - if (crafting != null) { - crafter.isCrafting = crafting - } + if (orientation == null && triggered == null && crafting == null) return null return BlockArgParseResult( { @@ -51,17 +41,9 @@ object BlockArgParserCrafter : BlockArgParser { { val crafter = it.blockData as? Crafter ?: return@BlockArgParseResult - if (orientation != null) { - crafter.orientation = orientation - } - - if (triggered != null) { - crafter.isTriggered = triggered - } - - if (crafting != null) { - crafter.isCrafting = crafting - } + if (orientation != null) crafter.orientation = orientation + if (triggered != null) crafter.isTriggered = triggered + if (crafting != null) crafter.isCrafting = crafting it.blockData = crafter } diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDaylightDetector.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDaylightDetector.kt index 41c34fe15..82bce4871 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDaylightDetector.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDaylightDetector.kt @@ -7,30 +7,27 @@ import org.bukkit.block.data.type.DaylightDetector object BlockArgParserDaylightDetector : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { - var inveted: Boolean? = null - - val daylightDetector = blockData as? DaylightDetector ?: return null + if (blockData !is DaylightDetector) return null + var inverted: Boolean? = null for (arg in args) { if (arg.equals("inverted", true)) { - inveted = true + inverted = true } } - inveted ?: return null - - daylightDetector.isInverted = inveted + inverted ?: return null return BlockArgParseResult( { val daylightDetector = it.blockData as? DaylightDetector ?: return@BlockArgParseResult false - daylightDetector.isInverted == inveted + daylightDetector.isInverted == inverted }, { val daylightDetector = it.blockData as? DaylightDetector ?: return@BlockArgParseResult - daylightDetector.isInverted = inveted + daylightDetector.isInverted = inverted it.blockData = daylightDetector } ) diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirectional.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirectional.kt index c9e952e81..44799af52 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirectional.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDirectional.kt @@ -8,30 +8,22 @@ import org.bukkit.block.data.Directional object BlockArgParserDirectional : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { - var direction: BlockFace? = null - val directional = blockData as? Directional ?: return null - val directions = directional.faces + var direction: BlockFace? = null for (arg in args) { val argSplit = arg.split(":") - if (!argSplit[0].equals("direction", ignoreCase = true)) { + if (!argSplit[0].equals("direction", true)) { continue } if (argSplit.size < 2) { continue } - val argDirection = runCatching { BlockFace.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue - if (!directions.contains(argDirection)) { - continue - } - direction = argDirection + direction = directional.faces.firstOrNull { it.name.equals(argSplit[1].uppercase(), true) } ?: continue } direction ?: return null - directional.facing = direction - return BlockArgParseResult( { val directional = it.blockData as? Directional ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDispenser.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDispenser.kt index 98288c36c..a9e42f575 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDispenser.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDispenser.kt @@ -7,10 +7,9 @@ import org.bukkit.block.data.type.Dispenser object BlockArgParserDispenser : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Dispenser) return null var triggered: Boolean? = null - val dispenser = blockData as? Dispenser ?: return null - for (arg in args) { if (arg.equals("triggered", true)) { triggered = true @@ -19,8 +18,6 @@ object BlockArgParserDispenser : BlockArgParser { triggered ?: return null - dispenser.isTriggered = triggered - return BlockArgParseResult( { val dispenser = it.blockData as? Dispenser ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDoor.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDoor.kt index 303a90956..27764ff81 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDoor.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserDoor.kt @@ -7,13 +7,12 @@ import org.bukkit.block.data.type.Door object BlockArgParserDoor : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Door) return null var doorHinge: Door.Hinge? = null - val door = blockData as? Door ?: return null - for (arg in args) { val argSplit = arg.split(":") - if (!argSplit[0].equals("hinge", ignoreCase = true)) { + if (!argSplit[0].equals("hinge", true)) { continue } if (argSplit.size < 2) { @@ -24,8 +23,6 @@ object BlockArgParserDoor : BlockArgParser { doorHinge ?: return null - door.hinge = doorHinge - return BlockArgParseResult( { val door = it.blockData as? Door ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserEndPortalFrame.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserEndPortalFrame.kt index ed5b5908b..43ba6bcb8 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserEndPortalFrame.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserEndPortalFrame.kt @@ -7,10 +7,9 @@ import org.bukkit.block.data.type.EndPortalFrame object BlockArgParserEndPortalFrame : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is EndPortalFrame) return null var eye: Boolean? = null - val endPortalFrame = blockData as? EndPortalFrame ?: return null - for (arg in args) { if (arg.equals("eye", true)) { eye = true @@ -19,8 +18,6 @@ object BlockArgParserEndPortalFrame : BlockArgParser { eye ?: return null - endPortalFrame.setEye(eye) - return BlockArgParseResult( { val endPortalFrame = it.blockData as? EndPortalFrame ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFaceAttachable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFaceAttachable.kt index 5fbc4e30d..687b6c596 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFaceAttachable.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFaceAttachable.kt @@ -7,13 +7,12 @@ import org.bukkit.block.data.FaceAttachable object BlockArgParserFaceAttachable : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is FaceAttachable) return null var attachedFace: FaceAttachable.AttachedFace? = null - val faceAttachable = blockData as? FaceAttachable ?: return null - for (arg in args) { val argSplit = arg.split(":") - if (!argSplit[0].equals("attached_face", ignoreCase = true)) { + if (!argSplit[0].equals("attached_face", true)) { continue } if (argSplit.size < 2) { @@ -24,8 +23,6 @@ object BlockArgParserFaceAttachable : BlockArgParser { attachedFace ?: return null - faceAttachable.attachedFace = attachedFace - return BlockArgParseResult( { val faceAttachable = it.blockData as? FaceAttachable ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFarmland.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFarmland.kt index 222e8e995..a4d5d5265 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFarmland.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserFarmland.kt @@ -7,21 +7,19 @@ import org.bukkit.block.data.type.Farmland object BlockArgParserFarmland : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { - var moisture: Int? = null - val farmland = blockData as? Farmland ?: return null - val maximumMoisture = farmland.maximumMoisture + var moisture: Int? = null for (arg in args) { val argSplit = arg.split(":") - if (!argSplit[0].equals("moisture", ignoreCase = true)) { + if (!argSplit[0].equals("moisture", true)) { continue } if (argSplit.size < 2) { continue } val argMoisture = argSplit[1].toIntOrNull() ?: continue - if (argMoisture in (maximumMoisture + 1)..<0) { + if (argMoisture in (farmland.maximumMoisture + 1)..<0) { continue } moisture = argMoisture @@ -29,8 +27,6 @@ object BlockArgParserFarmland : BlockArgParser { moisture ?: return null - farmland.moisture = moisture - return BlockArgParseResult( { val farmland = it.blockData as? Farmland ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserGate.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserGate.kt index 1ed6363ad..60fae3a5e 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserGate.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserGate.kt @@ -7,10 +7,9 @@ import org.bukkit.block.data.type.Gate object BlockArgParserGate : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Gate) return null var inWall: Boolean? = null - val gate = blockData as? Gate ?: return null - for (arg in args) { if (arg.equals("in_wall", true)) { inWall = true @@ -19,8 +18,6 @@ object BlockArgParserGate : BlockArgParser { inWall ?: return null - gate.isInWall = inWall - return BlockArgParseResult( { val gate = it.blockData as? Gate ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangable.kt index 61335bf7d..f25b7ae85 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangable.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangable.kt @@ -7,10 +7,9 @@ import org.bukkit.block.data.Hangable object BlockArgParserHangable : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Hangable) return null var hanging: Boolean? = null - val hangable = blockData as? Hangable ?: return null - for (arg in args) { if (arg.equals("hanging", true)) { hanging = true @@ -19,8 +18,6 @@ object BlockArgParserHangable : BlockArgParser { hanging ?: return null - hangable.isHanging = hanging - return BlockArgParseResult( { val hangable = it.blockData as? Hangable ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangingMoss.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangingMoss.kt index b0e44ac3a..d4c92899b 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangingMoss.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHangingMoss.kt @@ -7,10 +7,9 @@ import org.bukkit.block.data.type.HangingMoss object BlockArgParserHangingMoss : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is HangingMoss) return null var tip: Boolean? = null - val hangingMoss = blockData as? HangingMoss ?: return null - for (arg in args) { if (arg.equals("tip", true)) { tip = true @@ -19,8 +18,6 @@ object BlockArgParserHangingMoss : BlockArgParser { tip ?: return null - hangingMoss.isTip = tip - return BlockArgParseResult( { val hangingMoss = it.blockData as? HangingMoss ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHatchable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHatchable.kt deleted file mode 100644 index d98ce71bb..000000000 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserHatchable.kt +++ /dev/null @@ -1,48 +0,0 @@ -package com.willfp.eco.internal.blocks - -import com.willfp.eco.core.blocks.args.BlockArgParseResult -import com.willfp.eco.core.blocks.args.BlockArgParser -import org.bukkit.block.data.BlockData -import org.bukkit.block.data.Hatchable - -object BlockArgParserHatchable : BlockArgParser { - override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { - var hatching: Int? = null - - val hatchable = blockData as? Hatchable ?: return null - val maximumHatches = hatchable.maximumHatch - - for (arg in args) { - val argSplit = arg.split(":") - if (!argSplit[0].equals("hatching", ignoreCase = true)) { - continue - } - if (argSplit.size < 2) { - continue - } - val argHatching = argSplit[1].toIntOrNull() ?: continue - if (argHatching in (maximumHatches + 1)..<0) { - continue - } - hatching = argHatching - } - - hatching ?: return null - - hatchable.hatch = hatching - - return BlockArgParseResult( - { - val hatchable = it.blockData as? Hatchable ?: return@BlockArgParseResult false - - hatchable.hatch == hatching - }, - { - val hatchable = it.blockData as? Hatchable ?: return@BlockArgParseResult - - hatchable.hatch = hatching - it.blockData = hatchable - } - ) - } -} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserJigsaw.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserJigsaw.kt index 92c80cd09..e3b962e27 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserJigsaw.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserJigsaw.kt @@ -7,13 +7,12 @@ import org.bukkit.block.data.type.Jigsaw object BlockArgParserJigsaw : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Jigsaw) return null var orientation: Jigsaw.Orientation? = null - val jigsaw = blockData as? Jigsaw ?: return null - for (arg in args) { val argSplit = arg.split(":") - if (!argSplit[0].equals("orientation", ignoreCase = true)) { + if (!argSplit[0].equals("orientation", true)) { continue } if (argSplit.size < 2) { @@ -24,8 +23,6 @@ object BlockArgParserJigsaw : BlockArgParser { orientation ?: return null - jigsaw.orientation = orientation - return BlockArgParseResult( { val jigsaw = it.blockData as? Jigsaw ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLevelled.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLevelled.kt index 211504995..f1c9776a3 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLevelled.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLevelled.kt @@ -7,21 +7,19 @@ import org.bukkit.block.data.Levelled object BlockArgParserLevelled : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { - var level: Int? = null - val levelled = blockData as? Levelled ?: return null - val maximumLevel = levelled.maximumLevel + var level: Int? = null for (arg in args) { val argSplit = arg.split(":") - if (!argSplit[0].equals("level", ignoreCase = true)) { + if (!argSplit[0].equals("level", true)) { continue } if (argSplit.size < 2) { continue } val argLevel = argSplit[1].toIntOrNull() ?: continue - if (argLevel in (maximumLevel + 1)..<0) { + if (argLevel in (levelled.maximumLevel + 1)..<0) { continue } level = argLevel @@ -29,8 +27,6 @@ object BlockArgParserLevelled : BlockArgParser { level ?: return null - levelled.level = level - return BlockArgParseResult( { val levelled = it.blockData as? Levelled ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLightable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLightable.kt index bd9e8e139..4a518e3c8 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLightable.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserLightable.kt @@ -7,10 +7,9 @@ import org.bukkit.block.data.Lightable object BlockArgParserLightable : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Lightable) return null var lit: Boolean? = null - val lightable = blockData as? Lightable ?: return null - for (arg in args) { if (arg.equals("lit", true)) { lit = true @@ -19,8 +18,6 @@ object BlockArgParserLightable : BlockArgParser { lit ?: return null - lightable.isLit = lit - return BlockArgParseResult( { val lightable = it.blockData as? Lightable ?: return@BlockArgParseResult false diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserMossyCarpet.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserMossyCarpet.kt index 7a877f588..e455b474f 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserMossyCarpet.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserMossyCarpet.kt @@ -8,47 +8,38 @@ import org.bukkit.block.data.type.MossyCarpet object BlockArgParserMossyCarpet : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is MossyCarpet) return null + val mossyCarpetHeight = BlockFace.entries.associateWith { MossyCarpet.Height.NONE }.toMutableMap() var mossyCarpetBottom: Boolean? = null - val mossyCarpet = blockData as? MossyCarpet ?: return null - for (arg in args) { val argSplit = arg.split(":") - if (argSplit[0].equals("height", ignoreCase = true)) { + if (argSplit[0].equals("height", true)) { if (argSplit.size < 3) { continue } val face = runCatching { BlockFace.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue val height = runCatching { MossyCarpet.Height.valueOf(argSplit[2].uppercase()) }.getOrNull() ?: continue - mossyCarpetHeight += face to height - } else if (argSplit[0].equals("bottom", ignoreCase = true)) { + mossyCarpetHeight[face] = height + } else if (argSplit[0].equals("bottom", true)) { mossyCarpetBottom = true } } - mossyCarpetHeight.forEach { mossyCarpet.setHeight(it.key, it.value) } - - if (mossyCarpetBottom != null) { - mossyCarpet.isBottom = mossyCarpetBottom - } - return BlockArgParseResult( { val mossyCarpet = it.blockData as? MossyCarpet ?: return@BlockArgParseResult false BlockFace.entries.all { face -> - mossyCarpetHeight[face] != mossyCarpet.getHeight(face) + mossyCarpetHeight[face] == mossyCarpet.getHeight(face) } && (mossyCarpetBottom == null || mossyCarpet.isBottom == mossyCarpetBottom) }, { val mossyCarpet = it.blockData as? MossyCarpet ?: return@BlockArgParseResult mossyCarpetHeight.forEach { carpet -> mossyCarpet.setHeight(carpet.key, carpet.value) } - - if (mossyCarpetBottom != null) { - mossyCarpet.isBottom = mossyCarpetBottom - } + if (mossyCarpetBottom != null) mossyCarpet.isBottom = mossyCarpetBottom it.blockData = mossyCarpet } diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserMultipleFacing.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserMultipleFacing.kt new file mode 100644 index 000000000..8181c115b --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserMultipleFacing.kt @@ -0,0 +1,44 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.MultipleFacing + +object BlockArgParserMultipleFacing : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + val multipleFacing = blockData as? MultipleFacing ?: return null + + val faces = multipleFacing.allowedFaces.associateWith { false }.toMutableMap() + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("face", true)) { + continue + } + if (argSplit.size < 2) { + continue + } + + val face = multipleFacing.allowedFaces.firstOrNull { it.name.equals(argSplit[1].uppercase(), true) } ?: continue + faces[face] = true + } + + return BlockArgParseResult( + { + val multipleFacing = it.blockData as? MultipleFacing ?: return@BlockArgParseResult false + + multipleFacing.allowedFaces.all { face -> + faces[face] == multipleFacing.hasFace(face) + } + }, + { + val multipleFacing = it.blockData as? MultipleFacing ?: return@BlockArgParseResult + + faces.forEach { facing -> multipleFacing.setFace(facing.key, facing.value) } + + it.blockData = multipleFacing + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserNoteBlock.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserNoteBlock.kt new file mode 100644 index 000000000..35cf85bfe --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserNoteBlock.kt @@ -0,0 +1,40 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.Instrument +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.NoteBlock + +object BlockArgParserNoteBlock : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is NoteBlock) return null + var instrument: Instrument? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (argSplit[0].equals("instrument", true)) { + if (argSplit.size < 2) { + continue + } + instrument = runCatching { Instrument.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } // TODO: notes + } + + instrument ?: return null + + return BlockArgParseResult( + { + val noteBlock = it.blockData as? NoteBlock ?: return@BlockArgParseResult false + + noteBlock.instrument == instrument + }, + { + val noteBlock = it.blockData as? NoteBlock ?: return@BlockArgParseResult + + noteBlock.instrument = instrument + it.blockData = noteBlock + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserOpenable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserOpenable.kt new file mode 100644 index 000000000..58daa7932 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserOpenable.kt @@ -0,0 +1,35 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.Openable + +object BlockArgParserOpenable : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Openable) return null + var open: Boolean? = null + + for (arg in args) { + if (arg.equals("open", true)) { + open = true + } + } + + open ?: return null + + return BlockArgParseResult( + { + val openable = it.blockData as? Openable ?: return@BlockArgParseResult false + + openable.isOpen == open + }, + { + val openable = it.blockData as? Openable ?: return@BlockArgParseResult + + openable.isOpen = open + it.blockData = openable + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserOrientable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserOrientable.kt new file mode 100644 index 000000000..e0dca0bbb --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserOrientable.kt @@ -0,0 +1,41 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.Axis +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.Orientable + +object BlockArgParserOrientable : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + val orientable = blockData as? Orientable ?: return null + var axis: Axis? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("axis", true)) { + continue + } + if (argSplit.size < 2) { + continue + } + axis = orientable.axes.firstOrNull { it.name.equals(argSplit[1].uppercase(), true) } ?: continue + } + + axis ?: return null + + return BlockArgParseResult( + { + val orientable = it.blockData as? Orientable ?: return@BlockArgParseResult false + + orientable.axis == axis + }, + { + val orientable = it.blockData as? Orientable ?: return@BlockArgParseResult + + orientable.axis = axis + it.blockData = orientable + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserPointedDripstone.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserPointedDripstone.kt new file mode 100644 index 000000000..6df026474 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserPointedDripstone.kt @@ -0,0 +1,54 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.BlockFace +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.PointedDripstone + +object BlockArgParserPointedDripstone : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + val pointedDripstone = blockData as? PointedDripstone ?: return null + + var thickness: PointedDripstone.Thickness? = null + var verticalDirection: BlockFace? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (argSplit[0].equals("direction", true)) { + if (argSplit.size < 2) { + continue + } + verticalDirection = pointedDripstone.verticalDirections.firstOrNull { + it.name.equals(argSplit[1].uppercase(), true) + } ?: continue + } else if (argSplit[0].equals("thickness", true)) { + if (argSplit.size < 2) { + continue + } + thickness = + runCatching { PointedDripstone.Thickness.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + } + + if (verticalDirection == null && thickness == null) return null + + return BlockArgParseResult( + { + val pointedDripstone = it.blockData as? PointedDripstone ?: return@BlockArgParseResult false + + (verticalDirection == null || pointedDripstone.verticalDirection == verticalDirection) && + (thickness == null || pointedDripstone.thickness == thickness) + }, + { + val pointedDripstone = it.blockData as? PointedDripstone ?: return@BlockArgParseResult + + if (verticalDirection != null) pointedDripstone.verticalDirection = verticalDirection + if (thickness != null) pointedDripstone.thickness = thickness + + it.blockData = pointedDripstone + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserPowerable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserPowerable.kt new file mode 100644 index 000000000..4a504d4c5 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserPowerable.kt @@ -0,0 +1,35 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.Powerable + +object BlockArgParserPowerable : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Powerable) return null + var powered: Boolean? = null + + for (arg in args) { + if (arg.equals("powered", true)) { + powered = true + } + } + + powered ?: return null + + return BlockArgParseResult( + { + val powerable = it.blockData as? Powerable ?: return@BlockArgParseResult false + + powerable.isPowered == powered + }, + { + val powerable = it.blockData as? Powerable ?: return@BlockArgParseResult + + powerable.isPowered = powered + it.blockData = powerable + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserQuantity.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserQuantity.kt new file mode 100644 index 000000000..038392661 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserQuantity.kt @@ -0,0 +1,69 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.Hatchable +import org.bukkit.block.data.type.Candle +import org.bukkit.block.data.type.SeaPickle +import org.bukkit.block.data.type.TurtleEgg + +object BlockArgParserQuantity : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + val maximumQuantity = when (val blockData = blockData) { + is TurtleEgg -> blockData.maximumEggs + is Candle -> blockData.maximumCandles + is SeaPickle -> blockData.maximumPickles + is Hatchable -> blockData.maximumHatch + else -> return null + } + val minimumQuantity = when (val blockData = blockData) { + is TurtleEgg -> blockData.minimumEggs + else -> 0 + } + + var quantity: Int? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("quantity", true)) { + continue + } + if (argSplit.size < 2) { + continue + } + val argQuantity = argSplit[1].toIntOrNull() ?: continue + if (argQuantity in (maximumQuantity + 1).. data.eggs == quantity + is Candle -> data.candles == quantity + is SeaPickle -> data.pickles == quantity + is Hatchable -> data.hatch == quantity + else -> false + } + }, + { + val data = it.blockData + + when (data) { + is Candle -> data.candles = quantity + is SeaPickle -> data.pickles = quantity + is TurtleEgg -> data.eggs = quantity + is Hatchable -> data.hatch = quantity + else -> return@BlockArgParseResult + } + + it.blockData = data + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRail.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRail.kt new file mode 100644 index 000000000..f36d7db0d --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRail.kt @@ -0,0 +1,40 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.Rail + +object BlockArgParserRail : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + val rail = blockData as? Rail ?: return null + var shape: Rail.Shape? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("shape", true)) { + continue + } + if (argSplit.size < 2) { + continue + } + shape = rail.shapes.firstOrNull { it.name.equals(argSplit[1].uppercase(), true) } ?: continue + } + + shape ?: return null + + return BlockArgParseResult( + { + val rail = it.blockData as? Rail ?: return@BlockArgParseResult false + + rail.shape == shape + }, + { + val rail = it.blockData as? Rail ?: return@BlockArgParseResult + + rail.shape = shape + it.blockData = rail + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRedstoneWire.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRedstoneWire.kt new file mode 100644 index 000000000..b9d6e9745 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRedstoneWire.kt @@ -0,0 +1,44 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.RedstoneWire + +object BlockArgParserRedstoneWire : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + val redstoneWire = blockData as? RedstoneWire ?: return null + + val faces = redstoneWire.allowedFaces.associateWith { RedstoneWire.Connection.NONE }.toMutableMap() + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("face", true)) { + continue + } + if (argSplit.size < 3) { + continue + } + + val face = redstoneWire.allowedFaces.firstOrNull { it.name.equals(argSplit[1].uppercase(), true) } ?: continue + faces[face] = runCatching { RedstoneWire.Connection.valueOf(argSplit[2].uppercase()) }.getOrNull() ?: continue + } + + return BlockArgParseResult( + { + val redstoneWire = it.blockData as? RedstoneWire ?: return@BlockArgParseResult false + + redstoneWire.allowedFaces.all { face -> + faces[face] == redstoneWire.getFace(face) + } + }, + { + val redstoneWire = it.blockData as? RedstoneWire ?: return@BlockArgParseResult + + faces.forEach { facing -> redstoneWire.setFace(facing.key, facing.value) } + + it.blockData = redstoneWire + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRepeater.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRepeater.kt new file mode 100644 index 000000000..49aee3d5c --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRepeater.kt @@ -0,0 +1,48 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Repeater + +object BlockArgParserRepeater : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + val repeater = blockData as? Repeater ?: return null + var delay: Int? = null + var locked: Boolean? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (argSplit[0].equals("delay", true)) { + if (argSplit.size < 2) { + continue + } + val argDelay = argSplit[1].toIntOrNull() ?: continue + if (argDelay in (repeater.maximumDelay + 1).., blockData: BlockData): BlockArgParseResult? { + val respawnAnchor = blockData as? RespawnAnchor ?: return null + var charges: Int? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("charges", true)) { + continue + } + if (argSplit.size < 2) { + continue + } + val argCharges = argSplit[1].toIntOrNull() ?: continue + if (argCharges in (respawnAnchor.maximumCharges + 1)..<0) { + continue + } + charges = argCharges + } + + charges ?: return null + + return BlockArgParseResult( + { + val respawnAnchor = it.blockData as? RespawnAnchor ?: return@BlockArgParseResult false + + respawnAnchor.charges == charges + }, + { + val respawnAnchor = it.blockData as? RespawnAnchor ?: return@BlockArgParseResult + + respawnAnchor.charges = charges + it.blockData = respawnAnchor + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRotatable.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRotatable.kt new file mode 100644 index 000000000..96ccd4b93 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserRotatable.kt @@ -0,0 +1,41 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.BlockFace +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.Rotatable + +object BlockArgParserRotatable : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Rotatable) return null + var rotation: BlockFace? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("rotation", true)) { + continue + } + if (argSplit.size < 2) { + continue + } + rotation = runCatching { BlockFace.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + rotation ?: return null + + return BlockArgParseResult( + { + val rotatable = it.blockData as? Rotatable ?: return@BlockArgParseResult false + + rotatable.rotation == rotation + }, + { + val rotatable = it.blockData as? Rotatable ?: return@BlockArgParseResult + + rotatable.rotation = rotation + it.blockData = rotatable + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserScaffolding.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserScaffolding.kt new file mode 100644 index 000000000..d203e0a4c --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserScaffolding.kt @@ -0,0 +1,48 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Scaffolding + +object BlockArgParserScaffolding : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + val scaffolding = blockData as? Scaffolding ?: return null + var distance: Int? = null + var bottom: Boolean? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (argSplit[0].equals("distance", true)) { + if (argSplit.size < 2) { + continue + } + val argDistance = argSplit[1].toIntOrNull() ?: continue + if (argDistance in (scaffolding.maximumDistance + 1)..<0) { + continue + } + distance = argDistance + } else if (argSplit[0].equals("bottom", true)) { + bottom = true + } + } + + if (distance == null && bottom == null) return null + + return BlockArgParseResult( + { + val scaffolding = it.blockData as? Scaffolding ?: return@BlockArgParseResult false + + (distance == null || scaffolding.distance == distance) && (bottom == null || scaffolding.isBottom == bottom) + }, + { + val scaffolding = it.blockData as? Scaffolding ?: return@BlockArgParseResult + + if (distance != null) scaffolding.distance = distance + if (bottom != null) scaffolding.isBottom = bottom + + it.blockData = scaffolding + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSculkSensor.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSculkSensor.kt new file mode 100644 index 000000000..daa66e58b --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSculkSensor.kt @@ -0,0 +1,40 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.SculkSensor + +object BlockArgParserSculkSensor : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is SculkSensor) return null + var phase: SculkSensor.Phase? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("phase", true)) { + continue + } + if (argSplit.size < 2) { + continue + } + phase = runCatching { SculkSensor.Phase.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + phase ?: return null + + return BlockArgParseResult( + { + val sculkSensor = it.blockData as? SculkSensor ?: return@BlockArgParseResult false + + sculkSensor.phase == phase + }, + { + val sculkSensor = it.blockData as? SculkSensor ?: return@BlockArgParseResult + + sculkSensor.phase = phase + it.blockData = sculkSensor + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSculkShrieker.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSculkShrieker.kt new file mode 100644 index 000000000..08e452799 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSculkShrieker.kt @@ -0,0 +1,41 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.SculkShrieker + +object BlockArgParserSculkShrieker : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is SculkShrieker) return null + var canSummon: Boolean? = null + var shrieking: Boolean? = null + + for (arg in args) { + if (arg.equals("can_summon", true)) { + canSummon = true + } else if (arg.equals("shrieking", true)) { + shrieking = true + } + } + + if (canSummon == null && shrieking == null) return null + + return BlockArgParseResult( + { + val sculkShrieker = it.blockData as? SculkShrieker ?: return@BlockArgParseResult false + + (canSummon == null || sculkShrieker.isCanSummon == canSummon) && + (shrieking == null || sculkShrieker.isShrieking == shrieking) + }, + { + val sculkShrieker = it.blockData as? SculkShrieker ?: return@BlockArgParseResult + + if (canSummon != null) sculkShrieker.isCanSummon = canSummon + if (shrieking != null) sculkShrieker.isShrieking = shrieking + + it.blockData = sculkShrieker + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSlab.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSlab.kt new file mode 100644 index 000000000..ab98205ed --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSlab.kt @@ -0,0 +1,40 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Slab + +object BlockArgParserSlab : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Slab) return null + var slabType: Slab.Type? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("slab", true)) { + continue + } + if (argSplit.size < 2) { + continue + } + slabType = runCatching { Slab.Type.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + slabType ?: return null + + return BlockArgParseResult( + { + val slab = it.blockData as? Slab ?: return@BlockArgParseResult false + + slab.type == slabType + }, + { + val slab = it.blockData as? Slab ?: return@BlockArgParseResult + + slab.type = slabType + it.blockData = slab + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSnow.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSnow.kt new file mode 100644 index 000000000..06f1cddc8 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserSnow.kt @@ -0,0 +1,44 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Snow + +object BlockArgParserSnow : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + val snow = blockData as? Snow ?: return null + var layers: Int? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("layers", true)) { + continue + } + if (argSplit.size < 2) { + continue + } + val argLayers = argSplit[1].toIntOrNull() ?: continue + if (argLayers in (snow.maximumLayers + 1).., blockData: BlockData): BlockArgParseResult? { + if (blockData !is Snowable) return null + var snowy: Boolean? = null + + for (arg in args) { + if (arg.equals("snowy", true)) { + snowy = true + } + } + + snowy ?: return null + + return BlockArgParseResult( + { + val snowable = it.blockData as? Snowable ?: return@BlockArgParseResult false + + snowable.isSnowy == snowy + }, + { + val snowable = it.blockData as? Snowable ?: return@BlockArgParseResult + + snowable.isSnowy = snowy + it.blockData = snowable + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserStairs.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserStairs.kt new file mode 100644 index 000000000..a0206405e --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserStairs.kt @@ -0,0 +1,40 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Stairs + +object BlockArgParserStairs : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Stairs) return null + var shape: Stairs.Shape? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("shape", true)) { + continue + } + if (argSplit.size < 2) { + continue + } + shape = runCatching { Stairs.Shape.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + shape ?: return null + + return BlockArgParseResult( + { + val stairs = it.blockData as? Stairs ?: return@BlockArgParseResult false + + stairs.shape == shape + }, + { + val stairs = it.blockData as? Stairs ?: return@BlockArgParseResult + + stairs.shape = shape + it.blockData = stairs + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserStructureBlock.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserStructureBlock.kt new file mode 100644 index 000000000..375465467 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserStructureBlock.kt @@ -0,0 +1,40 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.StructureBlock + +object BlockArgParserStructureBlock : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is StructureBlock) return null + var mode: StructureBlock.Mode? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (!argSplit[0].equals("mode", true)) { + continue + } + if (argSplit.size < 2) { + continue + } + mode = runCatching { StructureBlock.Mode.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + } + + mode ?: return null + + return BlockArgParseResult( + { + val structureBlock = it.blockData as? StructureBlock ?: return@BlockArgParseResult false + + structureBlock.mode == mode + }, + { + val structureBlock = it.blockData as? StructureBlock ?: return@BlockArgParseResult + + structureBlock.mode = mode + it.blockData = structureBlock + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTNT.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTNT.kt new file mode 100644 index 000000000..330dbf5c0 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTNT.kt @@ -0,0 +1,35 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.TNT + +object BlockArgParserTNT : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is TNT) return null + var unstable: Boolean? = null + + for (arg in args) { + if (arg.equals("unstable", true)) { + unstable = true + } + } + + unstable ?: return null + + return BlockArgParseResult( + { + val tnt = it.blockData as? TNT ?: return@BlockArgParseResult false + + tnt.isUnstable == unstable + }, + { + val tnt = it.blockData as? TNT ?: return@BlockArgParseResult + + tnt.isUnstable = unstable + it.blockData = tnt + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTrialSpawner.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTrialSpawner.kt new file mode 100644 index 000000000..ed0c5d382 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTrialSpawner.kt @@ -0,0 +1,75 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.TrialSpawner +import org.bukkit.block.data.type.Vault + +object BlockArgParserTrialSpawner : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if ( + blockData !is TrialSpawner && + blockData !is Vault + ) return null + + var state: Any? = null + var ominous: Boolean? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (argSplit[0].equals("ominous", true)) { + ominous = true + } else if (argSplit[0].equals("state", true)) { + if (argSplit.size < 2) { + continue + } + state = when (blockData) { + is TrialSpawner -> runCatching { TrialSpawner.State.valueOf(argSplit[1].uppercase()) }.getOrNull() + ?: continue + + is Vault -> runCatching { Vault.State.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + else -> continue + } + } + + } + + if (state == null && ominous == null) return null + + return BlockArgParseResult( + { + when (val blockData = it.blockData) { + is TrialSpawner -> + (state == null || blockData.trialSpawnerState == state) && + (ominous == null || blockData.isOminous == ominous) + + is Vault -> (state == null || blockData.vaultState == state) && + (ominous == null || blockData.isOminous == ominous) + + else -> false + } + }, + { + val data = it.blockData + + when (data) { + is TrialSpawner -> { + if (ominous != null) data.isOminous = ominous + if (state != null) data.trialSpawnerState = + state as? TrialSpawner.State ?: return@BlockArgParseResult + } + + is Vault -> { + if (ominous != null) data.isOminous = ominous + if (state != null) data.vaultState = state as? Vault.State ?: return@BlockArgParseResult + } + + else -> return@BlockArgParseResult + } + + it.blockData = data + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTripwire.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTripwire.kt new file mode 100644 index 000000000..f499c842d --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTripwire.kt @@ -0,0 +1,35 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Tripwire + +object BlockArgParserTripwire : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Tripwire) return null + var disarmed: Boolean? = null + + for (arg in args) { + if (arg.equals("disarmed", true)) { + disarmed = true + } + } + + disarmed ?: return null + + return BlockArgParseResult( + { + val tripwire = it.blockData as? Tripwire ?: return@BlockArgParseResult false + + tripwire.isDisarmed == disarmed + }, + { + val tripwire = it.blockData as? Tripwire ?: return@BlockArgParseResult + + tripwire.isDisarmed = disarmed + it.blockData = tripwire + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserWall.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserWall.kt new file mode 100644 index 000000000..99c711b69 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserWall.kt @@ -0,0 +1,48 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.BlockFace +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.type.Wall + +object BlockArgParserWall : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Wall) return null + + val faces = BlockFace.entries.associateWith { Wall.Height.NONE }.toMutableMap() + var up: Boolean? = null + + for (arg in args) { + val argSplit = arg.split(":") + if (argSplit[0].equals("face", true)) { + if (argSplit.size < 3) { + continue + } + + val face = runCatching { BlockFace.valueOf(argSplit[1].uppercase()) }.getOrNull() ?: continue + faces[face] = runCatching { Wall.Height.valueOf(argSplit[2].uppercase()) }.getOrNull() ?: continue + } else if (argSplit[0].equals("up", true)) { + up = true + } + } + + return BlockArgParseResult( + { + val wall = it.blockData as? Wall ?: return@BlockArgParseResult false + + BlockFace.entries.all { face -> + faces[face] == wall.getHeight(face) + } && (up == null || wall.isUp == up) + }, + { + val wall = it.blockData as? Wall ?: return@BlockArgParseResult + + faces.forEach { facing -> wall.setHeight(facing.key, facing.value) } + if (up != null) wall.isUp = up + + it.blockData = wall + } + ) + } +} \ No newline at end of file diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserWaterlogged.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserWaterlogged.kt new file mode 100644 index 000000000..42ad3a8c1 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserWaterlogged.kt @@ -0,0 +1,35 @@ +package com.willfp.eco.internal.blocks + +import com.willfp.eco.core.blocks.args.BlockArgParseResult +import com.willfp.eco.core.blocks.args.BlockArgParser +import org.bukkit.block.data.BlockData +import org.bukkit.block.data.Waterlogged + +object BlockArgParserWaterlogged : BlockArgParser { + override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { + if (blockData !is Waterlogged) return null + var waterlogged: Boolean? = null + + for (arg in args) { + if (arg.equals("waterlogged", true)) { + waterlogged = true + } + } + + waterlogged ?: return null + + return BlockArgParseResult( + { + val waterloggedBlock = it.blockData as? Waterlogged ?: return@BlockArgParseResult false + + waterloggedBlock.isWaterlogged == waterlogged + }, + { + val waterloggedBlock = it.blockData as? Waterlogged ?: return@BlockArgParseResult + + waterloggedBlock.isWaterlogged = waterlogged + it.blockData = waterloggedBlock + } + ) + } +} \ No newline at end of file From 4693ee1d8d0060440ef62d8b6f8b22f78c31514d Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Sun, 11 Jan 2026 17:53:43 +0200 Subject: [PATCH 13/15] Continue working with block args x5 --- .../com/willfp/eco/core/blocks/Blocks.java | 7 +- .../core/blocks/args/BlockArgParseResult.java | 4 +- .../eco/core/blocks/args/BlockArgParser.java | 7 +- .../blocks/impl/ModifiedTestableBlock.java | 14 +-- .../UnrestrictedMaterialTestableBlock.java | 1 - .../willfp/eco/core/blocks/tag/BlockTag.java | 6 +- .../eco/core/blocks/tag/CustomBlockTag.java | 2 +- ...TrialSpawner.kt => BlockArgParserTrial.kt} | 2 +- .../internal/blocks/tags/VanillaBlockTags.kt | 39 ++++++ .../eco/internal/spigot/EcoSpigotPlugin.kt | 111 +++++++++++++++++- 10 files changed, 162 insertions(+), 31 deletions(-) rename eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/{BlockArgParserTrialSpawner.kt => BlockArgParserTrial.kt} (98%) create mode 100644 eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/tags/VanillaBlockTags.kt diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java index 5b48b610d..3e9451d38 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java @@ -10,18 +10,13 @@ import com.willfp.eco.core.blocks.impl.UnrestrictedMaterialTestableBlock; import com.willfp.eco.core.blocks.provider.BlockProvider; import com.willfp.eco.core.blocks.tag.BlockTag; -import com.willfp.eco.core.entities.args.EntityArgParseResult; -import com.willfp.eco.core.entities.args.EntityArgParser; -import com.willfp.eco.core.entities.impl.ModifiedTestableEntity; import com.willfp.eco.util.NamespacedKeyUtils; import com.willfp.eco.util.NumberUtils; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.NamespacedKey; import org.bukkit.block.Block; -import org.bukkit.block.BlockState; import org.bukkit.block.data.BlockData; -import org.bukkit.entity.Entity; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -41,7 +36,7 @@ public final class Blocks { private static final Map REGISTRY = new ConcurrentHashMap<>(); /** - * Cached custom block lookups, using {@link Location}. + * Cached custom block lookups, using {@link HashedBlock}. */ private static final LoadingCache> CACHE = Caffeine.newBuilder() .expireAfterAccess(10, TimeUnit.MINUTES) diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParseResult.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParseResult.java index 21101ab71..ee4435a89 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParseResult.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParseResult.java @@ -11,8 +11,8 @@ /** * The result of an arg parses. * - * @param test The test for the entity. - * @param modifier The modifier to apply to the entity. + * @param test The test for the block. + * @param modifier The modifier to apply to the block. * @see EntityArgParser */ public record BlockArgParseResult(@NotNull Predicate test, diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java index 9ee8d354a..e18988f22 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/args/BlockArgParser.java @@ -2,15 +2,10 @@ import com.willfp.eco.core.blocks.TestableBlock; import org.bukkit.Location; -import org.bukkit.block.Block; -import org.bukkit.block.BlockState; import org.bukkit.block.data.BlockData; -import org.bukkit.inventory.ItemStack; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import java.util.function.Predicate; - /** * An argument parser that should generate * a modified BlockData for {@link TestableBlock#place(Location)} . @@ -24,5 +19,5 @@ public interface BlockArgParser { * @return The modified block data. */ @Nullable BlockArgParseResult parseArguments(@NotNull String[] args, - @NotNull BlockData blockData); + @NotNull BlockData blockData); } diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java index cc563870f..19dc07407 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/ModifiedTestableBlock.java @@ -11,32 +11,32 @@ import java.util.function.Predicate; /** - * Existing testable entity with an extra filter. + * Existing testable block with an extra function. * * @see com.willfp.eco.core.entities.CustomEntity */ public class ModifiedTestableBlock implements TestableBlock { /** - * The item. + * The block. */ private final TestableBlock handle; /** - * The amount. + * The data. */ private final Predicate test; /** - * The provider to spawn the entity. + * The provider to place a block. */ private final Function provider; /** - * Create a new modified testable entity. + * Create a new modified testable block. * - * @param block The base block. + * @param block The base block. * @param test The test. - * @param provider The provider to spawn the entity. + * @param provider The provider to place a block. */ public ModifiedTestableBlock(@NotNull final TestableBlock block, @NotNull final Predicate<@NotNull Block> test, diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/UnrestrictedMaterialTestableBlock.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/UnrestrictedMaterialTestableBlock.java index 45923985e..51d915eec 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/UnrestrictedMaterialTestableBlock.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/impl/UnrestrictedMaterialTestableBlock.java @@ -1,6 +1,5 @@ package com.willfp.eco.core.blocks.impl; -import com.willfp.eco.core.blocks.TestableBlock; import org.apache.commons.lang.Validate; import org.bukkit.Location; import org.bukkit.Material; diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/BlockTag.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/BlockTag.java index bde8364b3..300288e62 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/BlockTag.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/BlockTag.java @@ -7,7 +7,7 @@ import org.jetbrains.annotations.Nullable; /** - * A group of items that share a common trait. + * A group of blocks that share a common trait. */ public interface BlockTag { /** @@ -27,9 +27,9 @@ public interface BlockTag { boolean matches(@NotNull Block block); /** - * Convert this tag to a testable item. + * Convert this tag to a testable block. * - * @return The testable item. + * @return The testable block. */ @NotNull default TestableBlock toTestableBlock() { diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/CustomBlockTag.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/CustomBlockTag.java index 25f3385a4..cfaf76315 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/CustomBlockTag.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/tag/CustomBlockTag.java @@ -15,7 +15,7 @@ public abstract class CustomBlockTag implements BlockTag { /** * Create a new custom block tag. * - * @param key The key. + * @param key The key. */ public CustomBlockTag(@NotNull final NamespacedKey key) { this.key = key; diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTrialSpawner.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTrial.kt similarity index 98% rename from eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTrialSpawner.kt rename to eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTrial.kt index ed0c5d382..08398900f 100644 --- a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTrialSpawner.kt +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/BlockArgParserTrial.kt @@ -6,7 +6,7 @@ import org.bukkit.block.data.BlockData import org.bukkit.block.data.type.TrialSpawner import org.bukkit.block.data.type.Vault -object BlockArgParserTrialSpawner : BlockArgParser { +object BlockArgParserTrial : BlockArgParser { override fun parseArguments(args: Array, blockData: BlockData): BlockArgParseResult? { if ( blockData !is TrialSpawner && diff --git a/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/tags/VanillaBlockTags.kt b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/tags/VanillaBlockTags.kt new file mode 100644 index 000000000..28ca2fc31 --- /dev/null +++ b/eco-core/core-backend/src/main/kotlin/com/willfp/eco/internal/blocks/tags/VanillaBlockTags.kt @@ -0,0 +1,39 @@ +package com.willfp.eco.internal.blocks.tags + +import com.willfp.eco.core.blocks.Blocks +import com.willfp.eco.core.blocks.tag.VanillaBlockTag +import org.bukkit.Keyed +import org.bukkit.Material +import org.bukkit.Tag + +object VanillaBlockTags { + fun register() { + // Get all tags + val allTags = Tag::class.java.declaredFields + .filter { it.type == Tag::class.java } + .mapNotNull { + val tag = it.get(null) as? Tag<*> + if (tag == null) { + null + } else { + NamedTag(it.name.lowercase(), tag) + } + } + + // Register all tags + for (tag in allTags) { + if (tag.isMaterial) { + Blocks.registerTag( + @Suppress("UNCHECKED_CAST") + (VanillaBlockTag(tag.name, tag.tag as Tag)) + ) + } + } + } + + private data class NamedTag(val name: String, val tag: Tag) { + // Check if tag is material + val isMaterial: Boolean + get() = tag.values.firstOrNull() is Material + } +} diff --git a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt index b5ae6a00a..1b4359cd4 100644 --- a/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt +++ b/eco-core/core-plugin/src/main/kotlin/com/willfp/eco/internal/spigot/EcoSpigotPlugin.kt @@ -23,7 +23,58 @@ import com.willfp.eco.core.packet.PacketListener import com.willfp.eco.core.particle.Particles import com.willfp.eco.core.price.Prices import com.willfp.eco.internal.blocks.BlockArgParserAgeable +import com.willfp.eco.internal.blocks.BlockArgParserAnaloguePowerable +import com.willfp.eco.internal.blocks.BlockArgParserAttachable +import com.willfp.eco.internal.blocks.BlockArgParserBamboo +import com.willfp.eco.internal.blocks.BlockArgParserBisected +import com.willfp.eco.internal.blocks.BlockArgParserBubbleColumn +import com.willfp.eco.internal.blocks.BlockArgParserCake +import com.willfp.eco.internal.blocks.BlockArgParserCampfire +import com.willfp.eco.internal.blocks.BlockArgParserCaveVinesPlant +import com.willfp.eco.internal.blocks.BlockArgParserChest +import com.willfp.eco.internal.blocks.BlockArgParserCommandBlock +import com.willfp.eco.internal.blocks.BlockArgParserComparator +import com.willfp.eco.internal.blocks.BlockArgParserCrafter +import com.willfp.eco.internal.blocks.BlockArgParserDaylightDetector import com.willfp.eco.internal.blocks.BlockArgParserDirectional +import com.willfp.eco.internal.blocks.BlockArgParserDispenser +import com.willfp.eco.internal.blocks.BlockArgParserDoor +import com.willfp.eco.internal.blocks.BlockArgParserEndPortalFrame +import com.willfp.eco.internal.blocks.BlockArgParserFaceAttachable +import com.willfp.eco.internal.blocks.BlockArgParserFarmland +import com.willfp.eco.internal.blocks.BlockArgParserGate +import com.willfp.eco.internal.blocks.BlockArgParserHangable +import com.willfp.eco.internal.blocks.BlockArgParserHangingMoss +import com.willfp.eco.internal.blocks.BlockArgParserJigsaw +import com.willfp.eco.internal.blocks.BlockArgParserLevelled +import com.willfp.eco.internal.blocks.BlockArgParserLightable +import com.willfp.eco.internal.blocks.BlockArgParserMossyCarpet +import com.willfp.eco.internal.blocks.BlockArgParserMultipleFacing +import com.willfp.eco.internal.blocks.BlockArgParserNoteBlock +import com.willfp.eco.internal.blocks.BlockArgParserOpenable +import com.willfp.eco.internal.blocks.BlockArgParserOrientable +import com.willfp.eco.internal.blocks.BlockArgParserPointedDripstone +import com.willfp.eco.internal.blocks.BlockArgParserPowerable +import com.willfp.eco.internal.blocks.BlockArgParserQuantity +import com.willfp.eco.internal.blocks.BlockArgParserRail +import com.willfp.eco.internal.blocks.BlockArgParserRedstoneWire +import com.willfp.eco.internal.blocks.BlockArgParserRepeater +import com.willfp.eco.internal.blocks.BlockArgParserRespawnAnchor +import com.willfp.eco.internal.blocks.BlockArgParserRotatable +import com.willfp.eco.internal.blocks.BlockArgParserScaffolding +import com.willfp.eco.internal.blocks.BlockArgParserSculkSensor +import com.willfp.eco.internal.blocks.BlockArgParserSculkShrieker +import com.willfp.eco.internal.blocks.BlockArgParserSlab +import com.willfp.eco.internal.blocks.BlockArgParserSnow +import com.willfp.eco.internal.blocks.BlockArgParserSnowy +import com.willfp.eco.internal.blocks.BlockArgParserStairs +import com.willfp.eco.internal.blocks.BlockArgParserStructureBlock +import com.willfp.eco.internal.blocks.BlockArgParserTNT +import com.willfp.eco.internal.blocks.BlockArgParserTrial +import com.willfp.eco.internal.blocks.BlockArgParserTripwire +import com.willfp.eco.internal.blocks.BlockArgParserWall +import com.willfp.eco.internal.blocks.BlockArgParserWaterlogged +import com.willfp.eco.internal.blocks.tags.VanillaBlockTags import com.willfp.eco.internal.data.MavenVersionToStringAdapter import com.willfp.eco.internal.data.VersionToStringAdapter import com.willfp.eco.internal.entities.EntityArgParserAdult @@ -196,8 +247,58 @@ abstract class EcoSpigotPlugin : EcoPlugin() { Items.registerArgParser(ArgParserTooltipStyle) Items.registerArgParser(ArgParserTrim) - Blocks.registerArgParser(BlockArgParserDirectional) Blocks.registerArgParser(BlockArgParserAgeable) + Blocks.registerArgParser(BlockArgParserAnaloguePowerable) + Blocks.registerArgParser(BlockArgParserAttachable) + Blocks.registerArgParser(BlockArgParserBamboo) + Blocks.registerArgParser(BlockArgParserBisected) + Blocks.registerArgParser(BlockArgParserBubbleColumn) + Blocks.registerArgParser(BlockArgParserCake) + Blocks.registerArgParser(BlockArgParserCampfire) + Blocks.registerArgParser(BlockArgParserCaveVinesPlant) + Blocks.registerArgParser(BlockArgParserChest) + Blocks.registerArgParser(BlockArgParserCommandBlock) + Blocks.registerArgParser(BlockArgParserComparator) + Blocks.registerArgParser(BlockArgParserCrafter) + Blocks.registerArgParser(BlockArgParserDaylightDetector) + Blocks.registerArgParser(BlockArgParserDirectional) + Blocks.registerArgParser(BlockArgParserDispenser) + Blocks.registerArgParser(BlockArgParserDoor) + Blocks.registerArgParser(BlockArgParserEndPortalFrame) + Blocks.registerArgParser(BlockArgParserFaceAttachable) + Blocks.registerArgParser(BlockArgParserFarmland) + Blocks.registerArgParser(BlockArgParserGate) + Blocks.registerArgParser(BlockArgParserHangable) + Blocks.registerArgParser(BlockArgParserHangingMoss) + Blocks.registerArgParser(BlockArgParserJigsaw) + Blocks.registerArgParser(BlockArgParserLevelled) + Blocks.registerArgParser(BlockArgParserLightable) + Blocks.registerArgParser(BlockArgParserMossyCarpet) + Blocks.registerArgParser(BlockArgParserMultipleFacing) + Blocks.registerArgParser(BlockArgParserNoteBlock) + Blocks.registerArgParser(BlockArgParserOpenable) + Blocks.registerArgParser(BlockArgParserOrientable) + Blocks.registerArgParser(BlockArgParserPointedDripstone) + Blocks.registerArgParser(BlockArgParserPowerable) + Blocks.registerArgParser(BlockArgParserQuantity) + Blocks.registerArgParser(BlockArgParserRail) + Blocks.registerArgParser(BlockArgParserRedstoneWire) + Blocks.registerArgParser(BlockArgParserRepeater) + Blocks.registerArgParser(BlockArgParserRespawnAnchor) + Blocks.registerArgParser(BlockArgParserRotatable) + Blocks.registerArgParser(BlockArgParserScaffolding) + Blocks.registerArgParser(BlockArgParserSculkSensor) + Blocks.registerArgParser(BlockArgParserSculkShrieker) + Blocks.registerArgParser(BlockArgParserSlab) + Blocks.registerArgParser(BlockArgParserSnow) + Blocks.registerArgParser(BlockArgParserSnowy) + Blocks.registerArgParser(BlockArgParserStairs) + Blocks.registerArgParser(BlockArgParserStructureBlock) + Blocks.registerArgParser(BlockArgParserTNT) + Blocks.registerArgParser(BlockArgParserTrial) + Blocks.registerArgParser(BlockArgParserTripwire) + Blocks.registerArgParser(BlockArgParserWall) + Blocks.registerArgParser(BlockArgParserWaterlogged) Entities.registerArgParser(EntityArgParserName) Entities.registerArgParser(EntityArgParserNoAI) @@ -272,8 +373,9 @@ abstract class EcoSpigotPlugin : EcoPlugin() { this.logger.info("No conflicts found!") } - CustomItemsManager.registerProviders() // Do it again here - CustomBlocksManager.registerProviders() // Do it again here + // Do it again here + CustomItemsManager.registerProviders() + CustomBlocksManager.registerProviders() // Register events for ShopSellEvent for (integration in ShopManager.getRegisteredIntegrations()) { @@ -291,8 +393,9 @@ abstract class EcoSpigotPlugin : EcoPlugin() { bukkitAudiences = BukkitAudiences.create(this) } - // Init vanilla item tags + // Init vanilla tags VanillaItemTags.register() + VanillaBlockTags.register() } override fun handleDisable() { From 6a8d3c93b36a85b56f1e091d8f0304648e409375 Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Mon, 12 Jan 2026 14:36:25 +0200 Subject: [PATCH 14/15] Custom blocks not returning --- eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java | 1 + 1 file changed, 1 insertion(+) diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java index 3e9451d38..d34bf5481 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java @@ -217,6 +217,7 @@ private static TestableBlock doParse(@NotNull final String[] args) { } registerCustomBlock(namespacedKey, part); + block = part; } } From e972dd581ecf43263fa24fe955bf258513616397 Mon Sep 17 00:00:00 2001 From: NicoNeko Date: Mon, 12 Jan 2026 14:52:32 +0200 Subject: [PATCH 15/15] Custom blocks not returning --- eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java index d34bf5481..2492d9d35 100644 --- a/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java +++ b/eco-api/src/main/java/com/willfp/eco/core/blocks/Blocks.java @@ -217,6 +217,9 @@ private static TestableBlock doParse(@NotNull final String[] args) { } registerCustomBlock(namespacedKey, part); + } + + if (part != null) { block = part; } }