IBlockData and soil changes

src/main/java/com/songoda/ultimatetimber/UltimateTimber.java

@@ -19,9 +19,11 @@ import java.util.Set;
  */
 public class UltimateTimber extends JavaPlugin {
 
-    private static final CommandSender console = Bukkit.getConsoleSender();
     private static UltimateTimber INSTANCE;
 
+    private final String prefix = "&8[&6UltimateTimber&8]";
+    private final CommandSender console = Bukkit.getConsoleSender();
+
     private Set<Manager> managers;
 
     private VersionAdapter versionAdapter;
@@ -120,6 +122,15 @@ public class UltimateTimber extends JavaPlugin {
         }
     }
 
+    /**
+     * Gets the plugin prefix for chat
+     *
+     * @return The plugin prefix
+     */
+    public String getPrefix() {
+        return this.prefix;
+    }
+
     /**
      * Gets the active version adapter being used
      *

src/main/java/com/songoda/ultimatetimber/adapter/IBlockData.java

@@ -0,0 +1,36 @@
+package com.songoda.ultimatetimber.adapter;
+
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+
+public interface IBlockData {
+
+    /**
+     * Gets the Material of the BlockData
+     *
+     * @return The Material
+     */
+    Material getMaterial();
+
+    /**
+     * Gets the data of the BlockData
+     *
+     * @return The data
+     */
+    byte getData();
+
+    /**
+     * Compares this IBlockData with another one to see if they are similar
+     *
+     * @return True if they are similar, otherwise false
+     */
+    boolean isSimilar(IBlockData otherBlockData);
+
+    /**
+     * Compares this IBlockData with a block to see if they are similar
+     *
+     * @return True if they are similar, otherwise false
+     */
+    boolean isSimilar(Block block);
+
+}

src/main/java/com/songoda/ultimatetimber/adapter/VersionAdapter.java

@@ -3,14 +3,11 @@ package com.songoda.ultimatetimber.adapter;
 import com.songoda.ultimatetimber.tree.FallingTreeBlock;
 import com.songoda.ultimatetimber.tree.TreeBlock;
 import com.songoda.ultimatetimber.tree.TreeBlockSet;
-import com.songoda.ultimatetimber.tree.TreeDefinition;
 import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
 import java.util.Collection;
-import java.util.Set;
 
 public interface VersionAdapter {
 
@@ -22,12 +19,12 @@ public interface VersionAdapter {
     VersionAdapterType getVersionAdapterType();
 
     /**
-     * Parses a String into a BlockState
+     * Parses a String into an IBlockData instance
      *
-     * @param blockStateString The String to parse
+     * @param blockDataString The String to parse
-     * @return A BlockState that the given String represents
+     * @return An IBlockData instance that the given String represents
      */
-    BlockState parseBlockStateFromString(String blockStateString);
+    IBlockData parseBlockDataFromString(String blockDataString);
 
     /**
      * Parses a String into an ItemStack
@@ -45,15 +42,6 @@ public interface VersionAdapter {
      */
     Collection<ItemStack> getBlockDrops(TreeBlock treeBlock);
 
-    /**
-     * Checks if two block states are similar
-     *
-     * @param blockState1 The first BlockState
-     * @param blockState2 The second BlockState
-     * @return True if the BlockStates are similar, otherwise false
-     */
-    boolean areBlockStatesSimilar(BlockState blockState1, BlockState blockState2);
-
     /**
      * Applies damage to a tool
      *

src/main/java/com/songoda/ultimatetimber/adapter/current/CurrentAdapter.java

@@ -1,12 +1,12 @@
 package com.songoda.ultimatetimber.adapter.current;
 
+import com.songoda.ultimatetimber.adapter.IBlockData;
 import com.songoda.ultimatetimber.adapter.VersionAdapter;
 import com.songoda.ultimatetimber.adapter.VersionAdapterType;
 import com.songoda.ultimatetimber.tree.FallingTreeBlock;
 import com.songoda.ultimatetimber.tree.TreeBlock;
 import com.songoda.ultimatetimber.tree.TreeBlockSet;
 import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
@@ -20,7 +20,7 @@ public class CurrentAdapter implements VersionAdapter {
     }
 
     @Override
-    public BlockState parseBlockStateFromString(String blockStateString) {
+    public IBlockData parseBlockDataFromString(String blockDataString) {
         return null;
     }
 
@@ -34,11 +34,6 @@ public class CurrentAdapter implements VersionAdapter {
         return null;
     }
 
-    @Override
-    public boolean areBlockStatesSimilar(BlockState blockState1, BlockState blockState2) {
-        return false;
-    }
-
     @Override
     public void applyToolDurability(TreeBlockSet<Block> treeBlocks, ItemStack tool) {
 

src/main/java/com/songoda/ultimatetimber/adapter/current/CurrentBlockData.java

@@ -0,0 +1,35 @@
+package com.songoda.ultimatetimber.adapter.current;
+
+import com.songoda.ultimatetimber.adapter.IBlockData;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+
+public class CurrentBlockData implements IBlockData {
+
+    private final Material material;
+
+    public CurrentBlockData(Material material) {
+        this.material = material;
+    }
+
+    @Override
+    public Material getMaterial() {
+        return this.material;
+    }
+
+    @Override
+    public byte getData() {
+        return 0;
+    }
+
+    @Override
+    public boolean isSimilar(IBlockData otherBlockData) {
+        return this.material.equals(otherBlockData.getMaterial());
+    }
+
+    @Override
+    public boolean isSimilar(Block block) {
+        return this.material.equals(block.getType());
+    }
+
+}

src/main/java/com/songoda/ultimatetimber/adapter/legacy/LegacyAdapter.java

@@ -1,12 +1,12 @@
 package com.songoda.ultimatetimber.adapter.legacy;
 
+import com.songoda.ultimatetimber.adapter.IBlockData;
 import com.songoda.ultimatetimber.adapter.VersionAdapter;
 import com.songoda.ultimatetimber.adapter.VersionAdapterType;
 import com.songoda.ultimatetimber.tree.FallingTreeBlock;
 import com.songoda.ultimatetimber.tree.TreeBlock;
 import com.songoda.ultimatetimber.tree.TreeBlockSet;
 import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
@@ -20,7 +20,7 @@ public class LegacyAdapter implements VersionAdapter {
     }
 
     @Override
-    public BlockState parseBlockStateFromString(String blockStateString) {
+    public IBlockData parseBlockDataFromString(String blockDataString) {
         return null;
     }
 
@@ -34,11 +34,6 @@ public class LegacyAdapter implements VersionAdapter {
         return null;
     }
 
-    @Override
-    public boolean areBlockStatesSimilar(BlockState blockState1, BlockState blockState2) {
-        return false;
-    }
-
     @Override
     public void applyToolDurability(TreeBlockSet<Block> treeBlocks, ItemStack tool) {
 

src/main/java/com/songoda/ultimatetimber/adapter/legacy/LegacyBlockData.java

@@ -0,0 +1,40 @@
+package com.songoda.ultimatetimber.adapter.legacy;
+
+import com.songoda.ultimatetimber.adapter.IBlockData;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+
+@SuppressWarnings("deprecation")
+public class LegacyBlockData implements IBlockData {
+
+    private final Material material;
+    private final byte data;
+
+    public LegacyBlockData(Material material, byte data) {
+        this.material = material;
+        this.data = data;
+    }
+
+    @Override
+    public Material getMaterial() {
+        return this.material;
+    }
+
+    @Override
+    public byte getData() {
+        return this.data;
+    }
+
+    @Override
+    public boolean isSimilar(IBlockData otherBlockData) {
+        return this.getMaterial().equals(otherBlockData.getMaterial()) && this.getData() == otherBlockData.getData();
+    }
+
+    @Override
+    public boolean isSimilar(Block block) {
+        Material blockMaterial = block.getType();
+        byte blockData = block.getData();
+        return this.material.equals(blockMaterial) && this.data == blockData;
+    }
+
+}

src/main/java/com/songoda/ultimatetimber/manager/CommandManager.java

@@ -39,7 +39,7 @@ public class CommandManager extends Manager implements CommandExecutor, TabCompl
                     return true;
 
                 UltimateTimber.getInstance().reload();
-                commandSender.sendMessage(Methods.formatText(UltimateTimber.getInstance().getMessageManager().getPrefix() + " &7Configuration reloaded"));
+                commandSender.sendMessage(Methods.formatText(UltimateTimber.getInstance().getPrefix() + " &7Configuration reloaded"));
                 return true;
             } else if (args[0].equalsIgnoreCase("toggle")) {
                 if (!(commandSender instanceof Player)) {
@@ -51,9 +51,9 @@ public class CommandManager extends Manager implements CommandExecutor, TabCompl
                     return true;
 
                 if (UltimateTimber.getInstance().getChoppingManager().togglePlayer((Player)commandSender)) {
-                    commandSender.sendMessage(Methods.formatText(UltimateTimber.getInstance().getMessageManager().getPrefix() + " Chopping Mode: &aEnabled"));
+                    commandSender.sendMessage(Methods.formatText(UltimateTimber.getInstance().getPrefix() + " Chopping Mode: &aEnabled"));
                 } else {
-                    commandSender.sendMessage(Methods.formatText(UltimateTimber.getInstance().getMessageManager().getPrefix() + " Chopping Mode: &cDisabled"));
+                    commandSender.sendMessage(Methods.formatText(UltimateTimber.getInstance().getPrefix() + " Chopping Mode: &cDisabled"));
                 }
 
                 return true;
@@ -61,7 +61,7 @@ public class CommandManager extends Manager implements CommandExecutor, TabCompl
         }
 
         commandSender.sendMessage("");
-        commandSender.sendMessage(Methods.formatText(UltimateTimber.getInstance().getMessageManager().getPrefix() + " &7Version " + UltimateTimber.getInstance().getDescription().getVersion() + " Created with <3 by &5&l&oSongoda"));
+        commandSender.sendMessage(Methods.formatText(UltimateTimber.getInstance().getPrefix() + " &7Version " + UltimateTimber.getInstance().getDescription().getVersion() + " Created with <3 by &5&l&oSongoda"));
         commandSender.sendMessage(Methods.formatText("&8 - &a/ut reload &7 - Reloads the config."));
         commandSender.sendMessage(Methods.formatText("&8 - &a/ut toggle &7 - Toggles your chopping mode"));
         commandSender.sendMessage("");

src/main/java/com/songoda/ultimatetimber/manager/TreeDefinitionManager.java

@@ -1,6 +1,7 @@
 package com.songoda.ultimatetimber.manager;
 
 import com.songoda.ultimatetimber.UltimateTimber;
+import com.songoda.ultimatetimber.adapter.IBlockData;
 import com.songoda.ultimatetimber.adapter.VersionAdapter;
 import com.songoda.ultimatetimber.tree.ITreeBlock;
 import com.songoda.ultimatetimber.tree.TreeBlockType;
@@ -8,7 +9,7 @@ import com.songoda.ultimatetimber.tree.TreeDefinition;
 import com.songoda.ultimatetimber.tree.TreeLoot;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
-import org.bukkit.block.BlockState;
+import org.bukkit.block.Block;
 import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.enchantments.Enchantment;
@@ -51,9 +52,10 @@ public class TreeDefinitionManager extends Manager {
         for (String key : treeSection.getKeys(false)) {
             ConfigurationSection tree = treeSection.getConfigurationSection(key);
 
-            Set<BlockState> logBlockStates = new HashSet<>();
+            Set<IBlockData> logBlockData = new HashSet<>();
-            Set<BlockState> leafBlockStates = new HashSet<>();
+            Set<IBlockData> leafBlockData = new HashSet<>();
-            BlockState saplingBlockState;
+            IBlockData saplingBlockData;
+            Set<IBlockData> plantableSoilBlockData = new HashSet<>();
             int maxLeafDistanceFromLog;
             boolean detectLeavesDiagonally;
             boolean dropOriginalLog;
@@ -62,13 +64,17 @@ public class TreeDefinitionManager extends Manager {
             Set<TreeLoot> leafLoot = new HashSet<>();
             Set<ItemStack> requiredTools = new HashSet<>();
 
-            for (String blockStateString : tree.getStringList("logs"))
+            for (String blockDataString : tree.getStringList("logs"))
-                logBlockStates.add(versionAdapter.parseBlockStateFromString(blockStateString));
+                logBlockData.add(versionAdapter.parseBlockDataFromString(blockDataString));
 
-            for (String blockStateString : tree.getStringList("leaves"))
+            for (String blockDataString : tree.getStringList("leaves"))
-                leafBlockStates.add(versionAdapter.parseBlockStateFromString(blockStateString));
+                leafBlockData.add(versionAdapter.parseBlockDataFromString(blockDataString));
+
+            saplingBlockData = versionAdapter.parseBlockDataFromString(tree.getString("sapling"));
+
+            for (String blockDataString : tree.getStringList("plantable-soil"))
+                plantableSoilBlockData.add(versionAdapter.parseBlockDataFromString(blockDataString));
 
-            saplingBlockState = versionAdapter.parseBlockStateFromString(tree.getString("sapling"));
             maxLeafDistanceFromLog = tree.getInt("max-leaf-distance-from-log");
             detectLeavesDiagonally = tree.getBoolean("search-for-leaves-diagonally");
             dropOriginalLog = tree.getBoolean("drop-original-log");
@@ -85,7 +91,7 @@ public class TreeDefinitionManager extends Manager {
             for (String itemStackString : tree.getStringList("required-tools"))
                 requiredTools.add(versionAdapter.parseItemStackFromString(itemStackString));
 
-            this.treeDefinitions.add(new TreeDefinition(key, logBlockStates, leafBlockStates, saplingBlockState, maxLeafDistanceFromLog, detectLeavesDiagonally, dropOriginalLog, dropOriginalLeaf, logLoot, leafLoot, requiredTools));
+            this.treeDefinitions.add(new TreeDefinition(key, logBlockData, leafBlockData, saplingBlockData, plantableSoilBlockData, maxLeafDistanceFromLog, detectLeavesDiagonally, dropOriginalLog, dropOriginalLeaf, logLoot, leafLoot, requiredTools));
         }
 
         // Load global log drops
@@ -109,32 +115,32 @@ public class TreeDefinitionManager extends Manager {
     }
 
     /**
-     * Gets a Set of possible TreeDefinitions that match the given BlockState
+     * Gets a Set of possible TreeDefinitions that match the given Block
      *
-     * @param blockState The BlockState to check
+     * @param block The Block to check
-     * @return A Set of TreeDefinitions for the given BlockState
+     * @return A Set of TreeDefinitions for the given Block
      */
-    public Set<TreeDefinition> getTreeDefinitionsForLog(BlockState blockState) {
+    public Set<TreeDefinition> getTreeDefinitionsForLog(Block block) {
-        return this.narrowTreeDefinition(this.treeDefinitions, blockState, TreeBlockType.LOG);
+        return this.narrowTreeDefinition(this.treeDefinitions, block, TreeBlockType.LOG);
     }
 
     /**
-     * Narrows a Set of TreeDefinitions down to ones matching the given BlockState and TreeBlockType
+     * Narrows a Set of TreeDefinitions down to ones matching the given Block and TreeBlockType
      *
      * @param possibleTreeDefinitions The possible TreeDefinitions
-     * @param blockState The BlockState to narrow to
+     * @param block The Block to narrow to
-     * @param treeBlockType The TreeBlockType of the given BlockState
+     * @param treeBlockType The TreeBlockType of the given Block
      * @return A Set of TreeDefinitions narrowed down
      */
-    public Set<TreeDefinition> narrowTreeDefinition(Set<TreeDefinition> possibleTreeDefinitions, BlockState blockState, TreeBlockType treeBlockType) {
+    public Set<TreeDefinition> narrowTreeDefinition(Set<TreeDefinition> possibleTreeDefinitions, Block block, TreeBlockType treeBlockType) {
         VersionAdapter versionAdapter = this.ultimateTimber.getVersionAdapter();
 
         Set<TreeDefinition> matchingTreeDefinitions = new HashSet<>();
         switch (treeBlockType) {
             case LOG:
-                for (TreeDefinition treeDefinition : this.treeDefinitions) {
+                for (TreeDefinition treeDefinition : possibleTreeDefinitions) {
-                    for (BlockState logBlockState : treeDefinition.getLogBlockStates()) {
+                    for (IBlockData logBlockData : treeDefinition.getLogBlockData()) {
-                        if (versionAdapter.areBlockStatesSimilar(logBlockState, blockState)) {
+                        if (logBlockData.isSimilar(block)) {
                             matchingTreeDefinitions.add(treeDefinition);
                             break;
                         }
@@ -142,9 +148,9 @@ public class TreeDefinitionManager extends Manager {
                 }
                 break;
             case LEAF:
-                for (TreeDefinition treeDefinition : this.treeDefinitions) {
+                for (TreeDefinition treeDefinition : possibleTreeDefinitions) {
-                    for (BlockState leafBlockState : treeDefinition.getLeafBlockStates()) {
+                    for (IBlockData leafBlockData : treeDefinition.getLeafBlockData()) {
-                        if (versionAdapter.areBlockStatesSimilar(leafBlockState, blockState)) {
+                        if (leafBlockData.isSimilar(block)) {
                             matchingTreeDefinitions.add(treeDefinition);
                             break;
                         }
@@ -156,6 +162,23 @@ public class TreeDefinitionManager extends Manager {
         return matchingTreeDefinitions;
     }
 
+    /**
+     * Checks if a given tool is valid for any tree definitions, also takes into account global tools
+     *
+     * @param tool The tool to check
+     * @return True if the tool is allowed for toppling any trees
+     */
+    public boolean isToolValidForAnyTreeDefinition(ItemStack tool) {
+        for (TreeDefinition treeDefinition : this.treeDefinitions)
+            for (ItemStack requiredTool : treeDefinition.getRequiredTools())
+                if (requiredTool.isSimilar(tool))
+                    return true;
+        for (ItemStack requiredTool : this.globalRequiredTools)
+            if (requiredTool.isSimilar(tool))
+                return true;
+        return false;
+    }
+
     /**
      * Checks if a given tool is valid for a given tree definition, also takes into account global tools
      *

src/main/java/com/songoda/ultimatetimber/manager/TreeDetectionManager.java

@@ -1,11 +1,11 @@
 package com.songoda.ultimatetimber.manager;
 
 import com.songoda.ultimatetimber.UltimateTimber;
+import com.songoda.ultimatetimber.adapter.IBlockData;
 import com.songoda.ultimatetimber.adapter.VersionAdapter;
 import com.songoda.ultimatetimber.tree.*;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
-import org.bukkit.block.BlockState;
 import org.bukkit.util.Vector;
 
 import java.util.Comparator;
@@ -76,7 +76,7 @@ public class TreeDetectionManager extends Manager {
     public DetectedTree detectTree(Block initialBlock) {
         TreeBlock initialTreeBlock = new TreeBlock(initialBlock, TreeBlockType.LOG);
         TreeBlockSet<Block> detectedTreeBlocks = new TreeBlockSet<>(initialTreeBlock);
-        Set<TreeDefinition> possibleTreeDefinitions = treeDefinitionManager.getTreeDefinitionsForLog(initialBlock.getState());
+        Set<TreeDefinition> possibleTreeDefinitions = treeDefinitionManager.getTreeDefinitionsForLog(initialBlock);
 
         // Detect tree trunk
         Set<Block> trunkBlocks = new HashSet<>();
@@ -86,7 +86,7 @@ public class TreeDetectionManager extends Manager {
             TreeBlock treeBlock = new TreeBlock(targetBlock, TreeBlockType.LOG);
             detectedTreeBlocks.add(treeBlock);
             trunkBlocks.add(initialBlock);
-            possibleTreeDefinitions.retainAll(this.treeDefinitionManager.narrowTreeDefinition(possibleTreeDefinitions, targetBlock.getState(), TreeBlockType.LOG));
+            possibleTreeDefinitions.retainAll(this.treeDefinitionManager.narrowTreeDefinition(possibleTreeDefinitions, targetBlock, TreeBlockType.LOG));
         }
 
         // Tree must be at least 2 blocks tall
@@ -102,18 +102,23 @@ public class TreeDetectionManager extends Manager {
         for (ITreeBlock<Block> branchBlock : branchBlocks)
             this.recursiveLeafSearch(possibleTreeDefinitions, detectedTreeBlocks, branchBlock.getBlock(), 1);
 
+        TreeDefinition actualTreeDefinition = possibleTreeDefinitions.iterator().next();
+
         // Trees need at least a certain number of leaves
         if (detectedTreeBlocks.getLeafBlocks().size() < this.numLeavesRequiredForTree)
             return null;
 
         // TODO: Soil detection
+        if (this.entireTreeBase) {
+            // TODO: Yadda yadda
+        }
 
         // Delete the starting block if applicable
         if (this.destroyBaseLog)
             detectedTreeBlocks.remove(initialTreeBlock);
 
         // Use the first tree definition in the set
-        return new DetectedTree(possibleTreeDefinitions.iterator().next(), detectedTreeBlocks);
+        return new DetectedTree(actualTreeDefinition, detectedTreeBlocks);
     }
 
     /**
@@ -133,7 +138,7 @@ public class TreeDetectionManager extends Manager {
             TreeBlock treeBlock = new TreeBlock(targetBlock, TreeBlockType.LOG);
             if (this.isValidLogType(treeDefinitions, targetBlock) && !treeBlocks.contains(treeBlock)) {
                 treeBlocks.add(treeBlock);
-                treeDefinitions.retainAll(this.treeDefinitionManager.narrowTreeDefinition(treeDefinitions, block.getState(), TreeBlockType.LOG));
+                treeDefinitions.retainAll(this.treeDefinitionManager.narrowTreeDefinition(treeDefinitions, block, TreeBlockType.LOG));
                 if (!this.onlyBreakLogsUpwards || targetBlock.getLocation().getBlockY() > startingBlockY)
                     this.recursiveBranchSearch(treeDefinitions, treeBlocks, targetBlock, startingBlockY);
             }
@@ -161,7 +166,7 @@ public class TreeDetectionManager extends Manager {
             if (this.isValidLeafType(treeDefinitions, targetBlock)) {
                 if (!treeBlocks.contains(treeBlock) && !this.doesLeafBorderInvalidLog(treeDefinitions, treeBlocks, targetBlock)) {
                     treeBlocks.add(treeBlock);
-                    treeDefinitions.retainAll(this.treeDefinitionManager.narrowTreeDefinition(treeDefinitions, block.getState(), TreeBlockType.LEAF));
+                    treeDefinitions.retainAll(this.treeDefinitionManager.narrowTreeDefinition(treeDefinitions, block, TreeBlockType.LEAF));
                 }
                 this.recursiveLeafSearch(treeDefinitions, treeBlocks, targetBlock, distanceFromLog + 1);
             }
@@ -195,8 +200,8 @@ public class TreeDetectionManager extends Manager {
     private boolean isValidLogType(Set<TreeDefinition> treeDefinitions, Block block) {
         VersionAdapter versionAdapter = this.ultimateTimber.getVersionAdapter();
         for (TreeDefinition treeDefinition : treeDefinitions)
-            for (BlockState logBlockState : treeDefinition.getLogBlockStates())
+            for (IBlockData logBlockData : treeDefinition.getLogBlockData())
-                if (versionAdapter.areBlockStatesSimilar(logBlockState, block.getState()))
+                if (logBlockData.isSimilar(block))
                     return true;
         return false;
     }
@@ -211,8 +216,8 @@ public class TreeDetectionManager extends Manager {
     private boolean isValidLeafType(Set<TreeDefinition> treeDefinitions, Block block) {
         VersionAdapter versionAdapter = this.ultimateTimber.getVersionAdapter();
         for (TreeDefinition treeDefinition : treeDefinitions)
-            for (BlockState leafBlockState : treeDefinition.getLeafBlockStates())
+            for (IBlockData leafBlockData : treeDefinition.getLeafBlockData())
-                if (versionAdapter.areBlockStatesSimilar(leafBlockState, block.getState()))
+                if (leafBlockData.isSimilar(block))
                     return true;
         return false;
     }

src/main/java/com/songoda/ultimatetimber/old_code/TreeChecker.java

@@ -217,7 +217,7 @@ public class TreeChecker {
         
         for (Vector offset : !this.isMushroom ? VALID_LEAF_OFFSETS : VALID_TRUNK_OFFSETS) {
             Block targetBlock = block.getRelative(offset.getBlockX(), offset.getBlockY(), offset.getBlockZ());
-            if (this.isValidLeafType(targetBlock.getType()) || (this.isMushroom && this.isMushroomBlock(targetBlock.getType()))) {
+            if (this.isValidLeafType(targetBlock.getType())) {
                 if (!this.treeBlocks.contains(targetBlock) && !doesLeafBorderInvalidLog(targetBlock))
                     this.treeBlocks.add(targetBlock);
                 this.recursiveLeafSearch(targetBlock, distanceFromLog + 1);
@@ -252,16 +252,6 @@ public class TreeChecker {
         return material.equals(this.leafType);
     }
     
-    /**
-     * Checks if a block is a mushroom head block
-     * 
-     * @param block The block to check
-     * @return If the given block is a mushroom
-     */
-    private boolean isMushroomBlock(Material material) {
-        return material.equals(Material.BROWN_MUSHROOM_BLOCK) || material.equals(Material.RED_MUSHROOM_BLOCK);
-    }
-    
     /**
      * Gets the max distance away from a log based on how many logs there are and the leaf type
      * 

src/main/java/com/songoda/ultimatetimber/tree/TreeDefinition.java

@@ -1,6 +1,6 @@
 package com.songoda.ultimatetimber.tree;
 
-import org.bukkit.block.BlockState;
+import com.songoda.ultimatetimber.adapter.IBlockData;
 import org.bukkit.inventory.ItemStack;
 
 import java.util.Collections;
@@ -9,21 +9,23 @@ import java.util.Set;
 public class TreeDefinition {
 
     private final String key;
-    private final Set<BlockState> logBlockStates, leafBlockStates;
+    private final Set<IBlockData> logBlockData, leafBlockData, plantableSoilBlockData;
-    private final BlockState saplingBlockState;
+    private final IBlockData saplingBlockData;
     private final int maxLeafDistanceFromLog;
     private final boolean detectLeavesDiagonally;
     private final boolean dropOriginalLog, dropOriginalLeaf;
     private final Set<TreeLoot> logLoot, leafLoot;
     private final Set<ItemStack> requiredTools;
 
-    public TreeDefinition(String key, Set<BlockState> logBlocks, Set<BlockState> leafBlocks, BlockState saplingBlockState,
+    public TreeDefinition(String key, Set<IBlockData> logBlockData, Set<IBlockData> leafBlockData, IBlockData saplingBlockData,
-                          int maxLeafDistanceFromLog, boolean detectLeavesDiagonally, boolean dropOriginalLog, boolean dropOriginalLeaf,
+                          Set<IBlockData> plantableSoilBlockData, int maxLeafDistanceFromLog, boolean detectLeavesDiagonally,
-                          Set<TreeLoot> logLoot, Set<TreeLoot> leafLoot, Set<ItemStack> requiredTools) {
+                          boolean dropOriginalLog, boolean dropOriginalLeaf, Set<TreeLoot> logLoot,
+                          Set<TreeLoot> leafLoot, Set<ItemStack> requiredTools) {
         this.key = key;
-        this.logBlockStates = logBlocks;
+        this.logBlockData = logBlockData;
-        this.leafBlockStates = leafBlocks;
+        this.leafBlockData = leafBlockData;
-        this.saplingBlockState = saplingBlockState;
+        this.saplingBlockData = saplingBlockData;
+        this.plantableSoilBlockData = plantableSoilBlockData;
         this.maxLeafDistanceFromLog = maxLeafDistanceFromLog;
         this.detectLeavesDiagonally = detectLeavesDiagonally;
         this.dropOriginalLog = dropOriginalLog;
@@ -43,30 +45,39 @@ public class TreeDefinition {
     }
 
     /**
-     * Gets a set of valid log block states for this TreeDefinition
+     * Gets a set of valid log block data for this TreeDefinition
      *
-     * @return A Set of BlockStates
+     * @return A Set of IBlockData
      */
-    public Set<BlockState> getLogBlockStates() {
+    public Set<IBlockData> getLogBlockData() {
-        return Collections.unmodifiableSet(this.logBlockStates);
+        return Collections.unmodifiableSet(this.logBlockData);
     }
 
     /**
-     * Gets a set of valid leaf block states for this TreeDefinition
+     * Gets a set of valid leaf block data for this TreeDefinition
      *
-     * @return A Set of BlockStates
+     * @return A Set of IBlockData
      */
-    public Set<BlockState> getLeafBlockStates() {
+    public Set<IBlockData> getLeafBlockData() {
-        return Collections.unmodifiableSet(this.leafBlockStates);
+        return Collections.unmodifiableSet(this.leafBlockData);
     }
 
     /**
-     * Gets the sapling block state of this TreeDefinition
+     * Gets the sapling block data of this TreeDefinition
      *
-     * @return A BlockState for the sapling
+     * @return An IBlockData instance for the sapling
      */
-    public BlockState getSaplingBlockState() {
+    public IBlockData getSaplingBlockData() {
-        return this.saplingBlockState;
+        return this.saplingBlockData;
+    }
+
+    /**
+     * Gets a set of plantable soil block data for this TreeDefinition
+     *
+     * @return A Set of IBlockData
+     */
+    public Set<IBlockData> getPlantableSoilBlockData() {
+        return Collections.unmodifiableSet(this.plantableSoilBlockData);
     }
 
     /**

src/main/resources/config-current.yml

@@ -124,6 +124,7 @@ trees:
     leaves:
       - OAK_LEAVES
     sapling: OAK_SAPLING
+    plantable-soil: []
     max-leaf-distance-from-log: 6
     search-for-leaves-diagonally: false
     drop-original-log: true
@@ -146,6 +147,7 @@ trees:
     leaves:
       - SPRUCE_LEAVES
     sapling: SPRUCE_SAPLING
+    plantable-soil: []
     max-leaf-distance-from-log: 6
     search-for-leaves-diagonally: false
     drop-original-log: true
@@ -165,6 +167,7 @@ trees:
     leaves:
       - SPRUCE_BIRCH
     sapling: BIRCH_SAPLING
+    plantable-soil: []
     max-leaf-distance-from-log: 4
     search-for-leaves-diagonally: false
     drop-original-log: true
@@ -184,6 +187,7 @@ trees:
     leaves:
       - SPRUCE_LEAVES
     sapling: SPRUCE_SAPLING
+    plantable-soil: []
     max-leaf-distance-from-log: 5
     search-for-leaves-diagonally: false
     drop-original-log: true
@@ -203,6 +207,7 @@ trees:
     leaves:
       - ACACIA_LEAVES
     sapling: ACACIA_SAPLING
+    plantable-soil: []
     max-leaf-distance-from-log: 5
     search-for-leaves-diagonally: false
     drop-original-log: true
@@ -222,6 +227,7 @@ trees:
     leaves:
       - DARK_OAK_LEAVES
     sapling: DARK_OAK_SAPLING
+    plantable-soil: []
     max-leaf-distance-from-log: 5
     search-for-leaves-diagonally: false
     drop-original-log: true
@@ -241,6 +247,8 @@ trees:
     leaves:
       - BROWN_MUSHROOM_BLOCK
     sapling: BROWN_MUSHROOM
+    plantable-soil:
+      - MYCELIUM
     max-leaf-distance-from-log: 4
     search-for-leaves-diagonally: false
     drop-original-log: false
@@ -257,6 +265,8 @@ trees:
     leaves:
       - RED_MUSHROOM_BLOCK
     sapling: RED_MUSHROOM
+    plantable-soil:
+      - MYCELIUM
     max-leaf-distance-from-log: 4
     search-for-leaves-diagonally: true
     drop-original-log: false
@@ -268,6 +278,12 @@ trees:
         chance: 25
     required-tools: []
 
+# All soil types that the tree type's saplings can be planted on
+global-plantable-soil:
+  - GRASS_BLOCK
+  - DIRT
+  - COARSE_DIRT
+
 # Custom loot that is available for all tree types
 # The loot applies to each log broken in the tree
 # To add more, increment the number by 1

src/main/resources/config-legacy.yml

@@ -127,6 +127,7 @@ trees:
       - LEAVES:8
       - LEAVES:12
     sapling: SAPLING:0
+    plantable-soil: []
     max-leaf-distance-from-log: 6
     search-for-leaves-diagonally: false
     drop-original-log: true
@@ -152,6 +153,7 @@ trees:
       - LEAVES:9
       - LEAVES:13
     sapling: SAPLING:1
+    plantable-soil: []
     max-leaf-distance-from-log: 6
     search-for-leaves-diagonally: false
     drop-original-log: true
@@ -174,6 +176,7 @@ trees:
       - LEAVES:10
       - LEAVES:14
     sapling: SAPLING:2
+    plantable-soil: []
     max-leaf-distance-from-log: 4
     search-for-leaves-diagonally: false
     drop-original-log: true
@@ -196,6 +199,7 @@ trees:
       - LEAVES:11
       - LEAVES:15
     sapling: SAPLING:3
+    plantable-soil: []
     max-leaf-distance-from-log: 5
     search-for-leaves-diagonally: false
     drop-original-log: true
@@ -218,6 +222,7 @@ trees:
       - LEAVES_2:8
       - LEAVES_2:12
     sapling: SAPLING:4
+    plantable-soil: []
     max-leaf-distance-from-log: 5
     search-for-leaves-diagonally: false
     drop-original-log: true
@@ -240,6 +245,7 @@ trees:
       - LEAVES:9
       - LEAVES:13
     sapling: SAPLING:5
+    plantable-soil: []
     max-leaf-distance-from-log: 5
     search-for-leaves-diagonally: false
     drop-original-log: true
@@ -270,6 +276,8 @@ trees:
       - HUGE_MUSHROOM_1:9
       - HUGE_MUSHROOM_1:14
     sapling: BROWN_MUSHROOM
+    plantable-soil:
+      - MYCEL
     max-leaf-distance-from-log: 4
     search-for-leaves-diagonally: false
     drop-original-log: false
@@ -297,6 +305,8 @@ trees:
       - HUGE_MUSHROOM_2:9
       - HUGE_MUSHROOM_2:14
     sapling: RED_MUSHROOM
+    plantable-soil:
+      - MYCEL
     max-leaf-distance-from-log: 4
     search-for-leaves-diagonally: true
     drop-original-log: false
@@ -308,6 +318,12 @@ trees:
         chance: 25
     required-tools: []
 
+# All soil types that the tree type's saplings can be planted on
+global-plantable-soil:
+  - GRASS
+  - DIRT:0
+  - DIRT:1
+
 # Custom loot that is available for all tree types
 # The loot applies to each log broken in the tree
 # To add more, increment the number by 1