Add Splinter

src/main/java/com/strangeone101/holoitemsapi/enchantment/EnchantManager.java

@@ -5,10 +5,7 @@
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.EnchantmentStorageMeta;
 import xyz.holocons.mc.holoitemsrevamp.HoloItemsRevamp;
-import xyz.holocons.mc.holoitemsrevamp.enchantment.Backdash;
-import xyz.holocons.mc.holoitemsrevamp.enchantment.Magnet;
-import xyz.holocons.mc.holoitemsrevamp.enchantment.Memento;
-import xyz.holocons.mc.holoitemsrevamp.enchantment.TideRider;
+import xyz.holocons.mc.holoitemsrevamp.enchantment.*;
 import xyz.holocons.mc.holoitemsrevamp.integration.Integrations;
 
 import java.util.List;
@@ -112,6 +109,8 @@ private static Set<CustomEnchantment> buildCustomEnchantments(HoloItemsRevamp pl
                 new Magnet(plugin),
                 new Memento(plugin),
                 new TideRider(plugin),
-                new Backdash(plugin));
+                new Backdash(plugin),
+                new Splinter(plugin)
+        );
     }
 }

src/main/java/xyz/holocons/mc/holoitemsrevamp/collection/CollectionManager.java

@@ -14,11 +14,7 @@
 import net.kyori.adventure.text.format.TextColor;
 import net.kyori.adventure.text.format.TextDecoration;
 import xyz.holocons.mc.holoitemsrevamp.HoloItemsRevamp;
-import xyz.holocons.mc.holoitemsrevamp.item.BackdashBoots;
-import xyz.holocons.mc.holoitemsrevamp.item.DummyBlockBlock;
-import xyz.holocons.mc.holoitemsrevamp.item.MagnetBook;
-import xyz.holocons.mc.holoitemsrevamp.item.MementoItem;
-import xyz.holocons.mc.holoitemsrevamp.item.TideRiderItem;
+import xyz.holocons.mc.holoitemsrevamp.item.*;
 
 public class CollectionManager {
 
@@ -1055,7 +1051,7 @@ public List<Component> getLore() {
     }
 
     private static Idol buildFlare(HoloItemsRevamp plugin) {
-        return new Idol() {
+        return new Idol(new SplinterBook(plugin)) {
 
             @Override
             public @NotNull String getSkinUrl() {

src/main/java/xyz/holocons/mc/holoitemsrevamp/enchantment/Splinter.java

@@ -0,0 +1,290 @@
+package xyz.holocons.mc.holoitemsrevamp.enchantment;
+
+import com.destroystokyo.paper.MaterialSetTag;
+import com.destroystokyo.paper.MaterialTags;
+import com.strangeone101.holoitemsapi.enchantment.CustomEnchantment;
+import com.strangeone101.holoitemsapi.enchantment.EnchantmentAbility;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.TextDecoration;
+import org.bukkit.*;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.Orientable;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.jetbrains.annotations.NotNull;
+import xyz.holocons.mc.holoitemsrevamp.HoloItemsRevamp;
+import xyz.holocons.mc.holoitemsrevamp.integration.Integrations;
+
+import java.util.*;
+
+public class Splinter extends CustomEnchantment implements EnchantmentAbility {
+
+    private final HoloItemsRevamp plugin;
+
+    private final MaterialSetTag COMPATIBLE_MATERIALS;
+
+    private static final Map<Player, ActiveSplinter> splinters = new HashMap<>();
+
+    public Splinter(HoloItemsRevamp plugin){
+        super(plugin, "splinter");
+        this.plugin = plugin;
+        var materialSetTagKey = new NamespacedKey(plugin, "splinter_materials");
+        this.COMPATIBLE_MATERIALS = new MaterialSetTag(materialSetTagKey, this::isCompatibleMaterial).lock();
+    }
+
+    @Override
+    public int getMaxLevel() {
+        return 1;
+    }
+
+    @Override
+    public boolean conflictsWith(@NotNull Enchantment enchantment) {
+        return false;
+    }
+
+    @Override
+    public boolean canEnchantItem(@NotNull ItemStack itemStack) {
+        return MaterialTags.AXES.isTagged(itemStack);
+    }
+
+    @Override
+    public @NotNull Component displayName(int i) {
+        return Component.text()
+            .color(NamedTextColor.GRAY)
+            .decoration(TextDecoration.ITALIC, false)
+            .append(Component.text("Splinter"))
+            .build();
+    }
+
+    @Override
+    public int getCostMultiplier() {
+        return 12;
+    }
+
+    @Override
+    public void onBlockBreak(BlockBreakEvent event, ItemStack itemStack) {
+        Block blockBroken = event.getBlock();
+        if(isInvalidSplinterType(blockBroken.getType()) || isInvalidSplinterLocation(blockBroken.getLocation())){
+            return;
+        }
+        // Presuming the block is a log - ie, it has an orientation.
+        var player = event.getPlayer();
+        tryCleanupSplinterData(player, blockBroken);
+
+        boolean isTree = isLogBlock(blockBroken.getType());
+        boolean isShroom = isShroomBlock(blockBroken.getType());
+        boolean isTrunk = isTrunkBlock(blockBroken);
+        if(isTree && isTrunk){
+            handleTreeTrunkBroken(player, blockBroken);
+        }
+        else if(isTree){
+            // && !isTrunk
+            // aka && isBranch
+            handleTreeBranchBroken(player, blockBroken);
+        }
+        else if(isShroom && isTrunk){
+            handleShroomStemBroken(player, blockBroken);
+        }
+        else if(isShroom){
+            // && !isTrunk
+            // aka && isBranch
+            handleShroomBlockBroken(player, blockBroken);
+        }
+        // else{} here shouldnt be reachable since anything else would be an invalid splinter type
+    }
+
+    /**
+     * Try to cleanup a player's Splinter data. If the data is scheduled for cleanup, but the newTrunk isn't a valid
+     * new trunk block, it will delete the data from the map entirely.
+     * @param player The player's
+     * @param newTrunk The proposed new trunk block
+     */
+    private void tryCleanupSplinterData(Player player, Block newTrunk){
+        final var activeSplinter = splinters.get(player);
+        // if(!shouldCleanup)
+        if(activeSplinter != null && activeSplinter.scheduledSplinters != 0){
+            // there is still a splinter going, so don't cleanup until that one's done
+            return;
+        }
+
+        splinters.remove(player);
+
+        if(!isTrunkBlock(newTrunk)){
+            return;
+        }
+
+        ActiveSplinter newData = new ActiveSplinter();
+        newData.origin = newTrunk;
+        newData.remainingCharges = 32; // In the future we can make this based on enchLevel
+        newData.scheduledSplinters = 0;
+        splinters.put(player, newData);
+    }
+
+    private void handleTreeTrunkBroken(Player player, Block trunkBlock){
+        // TODO
+    }
+
+    private void handleTreeBranchBroken(Player player, Block branchBlock){
+        // TODO
+    }
+
+    private void handleShroomStemBroken(Player player, Block stemBlock){
+        // aka the shroom stem
+        // TODO
+    }
+
+    private void handleShroomBlockBroken(Player player, Block branchBlock){
+        // TODO
+    }
+
+    private void scheduleSplinterAbility(Player player, Block block) {
+        var data = splinters.get(player);
+        if(data.remainingCharges <= 0){
+            // No power left to schedule anything.
+            return;
+        }
+        int splinterDelay = data.scheduledSplinters;
+        // Update and save data
+        data.remainingCharges -= 1;
+        data.scheduledSplinters += 1;
+        splinters.put(player, data);
+
+        // Schedule a splinter
+        new BukkitRunnable(){
+            @Override
+            public void run() {
+                // Break the block
+                // TODO: Check if the player is holding a Splinter axe first.
+                //  I got the itemStack to check for splinter, but idk how to check for splinter.
+                var activeItem = player.getActiveItem();
+                player.breakBlock(block);
+
+                // ... then update the data.
+                var updatedData = splinters.get(player);
+                updatedData.scheduledSplinters -= 1;
+                splinters.put(player, updatedData);
+            }
+        }.runTaskLater(plugin, splinterDelay);
+    }
+
+    /**
+     * Gets the potential next-branch blocks from this starting branch block. The trunk block is used since branches
+     * don't "curl in" on theirself, they continue to go farther from the trunk. If the branch is actually part
+     * of the trunk, all 8 adjacent blocks plus the 8 additional branches are returned.
+     */
+    private List<Block> getPossibleBranches(Block trunk, Block branch){
+        // Since the main operations afaik will be append and iterator, this is slightly better than arraylist.
+        // Not by much.
+        List<Block> ret = new LinkedList<>();
+
+        int deltaX = branch.getX() - trunk.getX();
+        int deltaZ = branch.getZ() - trunk.getZ();
+
+        int[] relXs = getRelsToCheck(deltaX);
+        int[] relZs = getRelsToCheck(deltaZ);
+
+        boolean isShroom = isShroomBlock(branch.getType());
+
+        for(int relX : relXs){
+            for(int relZ : relZs){
+                if(relX == 0 && relZ == 0){
+                    continue;
+                }
+                if(isShroom){
+                    // Remember shroom branches also go downwards
+                    ret.add(branch.getRelative(relX, -1, relZ));
+                }
+                ret.add(branch.getRelative(relX, 0, relZ));
+                ret.add(branch.getRelative(relX, 1, relZ));
+            }
+        }
+
+        return ret;
+    }
+
+    private int[] getRelsToCheck(int delta){
+        // "Get relatives to check"
+        if(delta > 0){
+            return new int[]{1};
+        }
+        else if(delta < 0){
+            return new int[]{-1};
+        }
+        else{
+            // start == 0
+            return new int[]{-1, 0, 1};
+        }
+    }
+
+    /**
+     * In summary: Log-splinters should only continue with other log-splinters, but shroom-splinters should be able
+     * to move from stem to mushroom block. (That said, mushroom block shouldn't be able to move back to stem.)
+     * Note: This will also return an empty list (aka "no legal next material") if the baseMaterial is not a legal
+     * splinter material.
+     */
+    private List<Material> getLegalNextMaterials(Block block){
+        List<Material> ret = new LinkedList<>();
+        if(isLogBlock(block.getType())){
+            ret.add(block.getType());
+        }
+        else if(isShroomBlock(block.getType())){
+            ret.add(block.getType());
+            if(isTrunkBlock(block)){
+                // shroom trunks (aka stems) should also be able to go to shroom leaves (aka mushroom blocks)
+                ret.add(Material.RED_MUSHROOM_BLOCK);
+                ret.add(Material.BROWN_MUSHROOM_BLOCK);
+            }
+        }
+        // else: return empty list, aka unchanged
+        return ret;
+    }
+
+    private boolean isInvalidSplinterType(Material type) {
+        return !this.COMPATIBLE_MATERIALS.isTagged(type);
+    }
+
+    private boolean isInvalidSplinterLocation(Location loc){
+        return !Integrations.WORLDGUARD.canUseEnchantment(loc, Splinter.class);
+    }
+
+    private boolean isCompatibleMaterial(Material material) {
+        return isLogBlock(material) || isShroomBlock(material);
+    }
+
+    private boolean isLogBlock(Material material){
+        // Remember later: All log-blocks are orientable. (shrooms are compatible-material but not orientable.)
+        return Tag.LOGS.isTagged(material);
+    }
+
+    private boolean isShroomBlock(Material material){
+        return MaterialTags.MUSHROOM_BLOCKS.isTagged(material);
+    }
+
+    private boolean isTrunkBlock(Block block){
+        var material = block.getType();
+        if(isLogBlock(material)){
+            if(block.getBlockData() instanceof Orientable orientable){
+                return orientable.getAxis() == Axis.Y;
+            }
+            // non-orientable log shouldn't be possible, but just in case:
+            return false;
+        }
+        else if(isShroomBlock(material)){
+            return Material.MUSHROOM_STEM == material;
+        }
+        else{
+            return false;
+        }
+    }
+
+    private static class ActiveSplinter {
+        Block origin;
+        int remainingCharges;
+        int scheduledSplinters;
+    }
+}