Upstream/UltimateTimber
1
0
Fork 0
mirror of https://github.com/songoda/UltimateTimber.git synced 2024-06-26 06:34:50 +02:00
Code Issues Projects Releases Wiki Activity

Does it build?

Browse Source
This commit is contained in:
Esophose 2019-03-30 00:46:13 -06:00
parent d8bd19a08a
commit 5d83a2bd27
34 changed files with 587 additions and 1161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.gitignore vendored
View File

@ -1,9 +1,7 @@
.idea/ .idea/
UltimateTimber\.iml *.iml
target/ target/
.settings/ .settings/
bin/ bin/
.classpath .classpath
.project .project
src/main/main\.iml

9
UltimateTimber-Adapter/Current/pom.xml
View File

@ -6,14 +6,12 @@
<parent> <parent>
<groupId>com.songoda.ultimatetimber</groupId> <groupId>com.songoda.ultimatetimber</groupId>
<artifactId>UltimateTimber</artifactId> <artifactId>UltimateTimber-Parent</artifactId>
<version>maven-version-number</version> <version>maven-version-number</version>
<relativePath>../../pom.xml</relativePath> <relativePath>../../pom.xml</relativePath>
</parent> </parent>
<artifactId>UltimateTimber-CurrentAdapter</artifactId> <artifactId>UltimateTimber-CurrentAdapter</artifactId>
<packaging>jar</packaging>
<version>maven-version-number</version>
<dependencies> <dependencies>
<!--Spigot API--> <!--Spigot API-->
@ -45,4 +43,9 @@
<scope>compile</scope> <scope>compile</scope>
</dependency> </dependency>
</dependencies> </dependencies>
<build>
<defaultGoal>clean install</defaultGoal>
<finalName>${project.artifactId}</finalName>
</build>
</project> </project>

59
UltimateTimber-Adapter/Current/src/main/java/com.songoda.ultimatetimber.adapter.current/CurrentAdapter.java
View File

@ -4,13 +4,22 @@ import com.songoda.ultimatetimber.adapter.IBlockData;
import com.songoda.ultimatetimber.adapter.VersionAdapter; import com.songoda.ultimatetimber.adapter.VersionAdapter;
import com.songoda.ultimatetimber.adapter.VersionAdapterType; import com.songoda.ultimatetimber.adapter.VersionAdapterType;
import com.songoda.ultimatetimber.tree.FallingTreeBlock; import com.songoda.ultimatetimber.tree.FallingTreeBlock;
import com.songoda.ultimatetimber.tree.TreeBlock; import com.songoda.ultimatetimber.tree.ITreeBlock;
import com.songoda.ultimatetimber.tree.TreeBlockSet; import com.songoda.ultimatetimber.tree.TreeBlockSet;
import com.songoda.ultimatetimber.utils.Methods;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.block.Block; import org.bukkit.block.Block;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.FallingBlock;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.Damageable;
import org.bukkit.inventory.meta.ItemMeta;
import java.util.Collection; import java.util.Collection;
import java.util.HashSet;
public class CurrentAdapter implements VersionAdapter { public class CurrentAdapter implements VersionAdapter {
@ -21,27 +30,52 @@ public class CurrentAdapter implements VersionAdapter {
@Override @Override
public IBlockData parseBlockDataFromString(String blockDataString) { public IBlockData parseBlockDataFromString(String blockDataString) {
return null; return new CurrentBlockData(Material.matchMaterial(blockDataString));
} }
@Override @Override
public ItemStack parseItemStackFromString(String itemStackString) { public ItemStack parseItemStackFromString(String itemStackString) {
return null; return new ItemStack(Material.matchMaterial(itemStackString));
} }
@Override @Override
public Collection<ItemStack> getBlockDrops(TreeBlock treeBlock) { public Collection<ItemStack> getBlockDrops(ITreeBlock treeBlock) {
return null; if (treeBlock.getBlock() instanceof Block) {
Block block = (Block)treeBlock.getBlock();
return block.getDrops(); // TODO: Do this properly
}
return new HashSet<>();
} }
@Override @Override
public void applyToolDurability(ItemStack tool, int damage) { public void applyToolDurability(Player player, int damage) {
ItemStack tool = this.getItemInHand(player);
if (!tool.hasItemMeta() || !(tool.getItemMeta() instanceof Damageable))
return;
int unbreakingLevel = tool.getEnchantmentLevel(Enchantment.DURABILITY);
Damageable damageable = (Damageable)tool.getItemMeta();
int actualDamage = 0;
for (int i = 0; i < damage; i++)
if (Methods.checkUnbreakingChance(unbreakingLevel))
actualDamage++;
damageable.setDamage(damageable.getDamage() + actualDamage);
tool.setItemMeta((ItemMeta) damageable);
} }
@Override @Override
public boolean hasEnoughDurability(ItemStack tool, int requiredAmount) { public boolean hasEnoughDurability(ItemStack tool, int requiredAmount) {
return false; if (!tool.hasItemMeta() || !(tool.getItemMeta() instanceof Damageable))
return false;
Damageable damageable = (Damageable)tool.getItemMeta();
int durabilityRemaining = tool.getType().getMaxDurability() - damageable.getDamage();
return durabilityRemaining > requiredAmount;
} }
@Override @Override
@ -49,6 +83,11 @@ public class CurrentAdapter implements VersionAdapter {
return player.getInventory().getItemInMainHand(); return player.getInventory().getItemInMainHand();
} }
@Override
public void removeItemInHand(Player player) {
player.getInventory().setItemInMainHand(null);
}
@Override @Override
public void playFallingParticles(TreeBlockSet<Block> treeBlocks) { public void playFallingParticles(TreeBlockSet<Block> treeBlocks) {
@ -61,12 +100,14 @@ public class CurrentAdapter implements VersionAdapter {
@Override @Override
public void playFallingSound(TreeBlockSet<Block> treeBlocks) { public void playFallingSound(TreeBlockSet<Block> treeBlocks) {
Location location = treeBlocks.getInitialLogBlock().getLocation();
location.getWorld().playSound(location, Sound.BLOCK_CHEST_OPEN, 3F, 0.1F);
} }
@Override @Override
public void playLandingSound(FallingTreeBlock treeBlock) { public void playLandingSound(FallingTreeBlock treeBlock) {
Location location = treeBlock.getLocation();
location.getWorld().playSound(location, Sound.BLOCK_WOOD_FALL, 3F, 0.1F);
} }
} }

9
UltimateTimber-Adapter/Legacy/pom.xml
View File

@ -6,14 +6,12 @@
<parent> <parent>
<groupId>com.songoda.ultimatetimber</groupId> <groupId>com.songoda.ultimatetimber</groupId>
<artifactId>UltimateTimber</artifactId> <artifactId>UltimateTimber-Parent</artifactId>
<version>maven-version-number</version> <version>maven-version-number</version>
<relativePath>../../pom.xml</relativePath> <relativePath>../../pom.xml</relativePath>
</parent> </parent>
<artifactId>UltimateTimber-LegacyAdapter</artifactId> <artifactId>UltimateTimber-LegacyAdapter</artifactId>
<packaging>jar</packaging>
<version>maven-version-number</version>
<dependencies> <dependencies>
<!--Spigot API--> <!--Spigot API-->
@ -45,4 +43,9 @@
<scope>compile</scope> <scope>compile</scope>
</dependency> </dependency>
</dependencies> </dependencies>
<build>
<defaultGoal>clean install</defaultGoal>
<finalName>${project.artifactId}</finalName>
</build>
</project> </project>

28
UltimateTimber-Adapter/Legacy/src/main/java/com.songoda.ultimatetimber.adapter.legacy/LegacyAdapter.java
View File

@ -4,8 +4,11 @@ import com.songoda.ultimatetimber.adapter.IBlockData;
import com.songoda.ultimatetimber.adapter.VersionAdapter; import com.songoda.ultimatetimber.adapter.VersionAdapter;
import com.songoda.ultimatetimber.adapter.VersionAdapterType; import com.songoda.ultimatetimber.adapter.VersionAdapterType;
import com.songoda.ultimatetimber.tree.FallingTreeBlock; import com.songoda.ultimatetimber.tree.FallingTreeBlock;
import com.songoda.ultimatetimber.tree.TreeBlock; import com.songoda.ultimatetimber.tree.ITreeBlock;
import com.songoda.ultimatetimber.tree.TreeBlockSet; import com.songoda.ultimatetimber.tree.TreeBlockSet;
import com.songoda.ultimatetimber.utils.NMSUtil;
import org.bukkit.Location;
import org.bukkit.Sound;
import org.bukkit.block.Block; import org.bukkit.block.Block;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
@ -31,12 +34,12 @@ public class LegacyAdapter implements VersionAdapter {
} }
@Override @Override
public Collection<ItemStack> getBlockDrops(TreeBlock treeBlock) { public Collection<ItemStack> getBlockDrops(ITreeBlock treeBlock) {
return null; return null;
} }
@Override @Override
public void applyToolDurability(ItemStack tool, int damage) { public void applyToolDurability(Player player, int damage) {
} }
@ -50,6 +53,11 @@ public class LegacyAdapter implements VersionAdapter {
return player.getItemInHand(); return player.getItemInHand();
} }
@Override
public void removeItemInHand(Player player) {
player.setItemInHand(null);
}
@Override @Override
public void playFallingParticles(TreeBlockSet<Block> treeBlocks) { public void playFallingParticles(TreeBlockSet<Block> treeBlocks) {
@ -62,12 +70,22 @@ public class LegacyAdapter implements VersionAdapter {
@Override @Override
public void playFallingSound(TreeBlockSet<Block> treeBlocks) { public void playFallingSound(TreeBlockSet<Block> treeBlocks) {
Location location = treeBlocks.getInitialLogBlock().getLocation();
if (NMSUtil.getVersionNumber() > 8) {
location.getWorld().playSound(location, Sound.BLOCK_CHEST_OPEN, 3F, 0.1F);
} else {
location.getWorld().playSound(location, Sound.valueOf("CHEST_OPEN"), 3F, 0.1F);
}
} }
@Override @Override
public void playLandingSound(FallingTreeBlock treeBlock) { public void playLandingSound(FallingTreeBlock treeBlock) {
Location location = treeBlock.getLocation();
if (NMSUtil.getVersionNumber() > 8) {
location.getWorld().playSound(location, Sound.BLOCK_WOOD_FALL, 3F, 0.1F);
} else {
location.getWorld().playSound(location, Sound.valueOf("DIG_WOOD"), 3F, 0.1F);
}
} }
} }

9
UltimateTimber/Core/pom.xml
View File

@ -6,14 +6,12 @@
<parent> <parent>
<groupId>com.songoda.ultimatetimber</groupId> <groupId>com.songoda.ultimatetimber</groupId>
<artifactId>UltimateTimber</artifactId> <artifactId>UltimateTimber-Parent</artifactId>
<version>maven-version-number</version> <version>maven-version-number</version>
<relativePath>../../pom.xml</relativePath> <relativePath>../../pom.xml</relativePath>
</parent> </parent>
<artifactId>UltimateTimber-Core</artifactId> <artifactId>UltimateTimber-Core</artifactId>
<packaging>jar</packaging>
<version>maven-version-number</version>
<dependencies> <dependencies>
<!--Spigot API--> <!--Spigot API-->
@ -24,4 +22,9 @@
<scope>provided</scope> <scope>provided</scope>
</dependency> </dependency>
</dependencies> </dependencies>
<build>
<defaultGoal>clean install</defaultGoal>
<finalName>${project.artifactId}</finalName>
</build>
</project> </project>

15
UltimateTimber/Core/src/main/java/com/songoda/ultimatetimber/adapter/VersionAdapter.java
View File

@ -1,7 +1,7 @@
package com.songoda.ultimatetimber.adapter; package com.songoda.ultimatetimber.adapter;
import com.songoda.ultimatetimber.tree.FallingTreeBlock; import com.songoda.ultimatetimber.tree.FallingTreeBlock;
import com.songoda.ultimatetimber.tree.TreeBlock; import com.songoda.ultimatetimber.tree.ITreeBlock;
import com.songoda.ultimatetimber.tree.TreeBlockSet; import com.songoda.ultimatetimber.tree.TreeBlockSet;
import org.bukkit.block.Block; import org.bukkit.block.Block;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
@ -40,15 +40,15 @@ public interface VersionAdapter {
* @param treeBlock The tree block * @param treeBlock The tree block
* @return A Set of ItemStacks that should be dropped * @return A Set of ItemStacks that should be dropped
*/ */
Collection<ItemStack> getBlockDrops(TreeBlock treeBlock); Collection<ItemStack> getBlockDrops(ITreeBlock treeBlock);
/** /**
* Applies damage to a tool * Applies damage to a tool
* *
* @param tool The tool to apply damage to * @param player The Player who's tool to apply damage to
* @param damage The amount of damage to apply * @param damage The amount of damage to apply
*/ */
void applyToolDurability(ItemStack tool, int damage); void applyToolDurability(Player player, int damage);
/** /**
* Checks if a given tool has enough durability remaining * Checks if a given tool has enough durability remaining
@ -67,6 +67,13 @@ public interface VersionAdapter {
*/ */
ItemStack getItemInHand(Player player); ItemStack getItemInHand(Player player);
/**
* Removes the item in the player's main hand
*
* @param player The Player to remove the item from
*/
void removeItemInHand(Player player);
/** /**
* Plays particles to indicate a tree has started falling * Plays particles to indicate a tree has started falling
*/ */

27
UltimateTimber/Core/src/main/java/com/songoda/ultimatetimber/utils/Methods.java
View File

@ -2,14 +2,31 @@ package com.songoda.ultimatetimber.utils;
import org.bukkit.ChatColor; import org.bukkit.ChatColor;
import java.util.Random;
public class Methods { public class Methods {
private static Random random = new Random();
/**
* Formats a given string replacing colors
*
* @param text The string
* @return The formatted string
*/
public static String formatText(String text) { public static String formatText(String text) {
if (text == null || text.equals("")) if (text == null || text.equals(""))
return ""; return "";
return formatText(text, false); return formatText(text, false);
} }
/**
* Formats a given string replacing colors and optionally capitalizing the first word
*
* @param text The string
* @param cap If the first word should be capitalized
* @return The formatted string
*/
private static String formatText(String text, boolean cap) { private static String formatText(String text, boolean cap) {
if (text == null || text.equals("")) if (text == null || text.equals(""))
return ""; return "";
@ -18,4 +35,14 @@ public class Methods {
return ChatColor.translateAlternateColorCodes('&', text); return ChatColor.translateAlternateColorCodes('&', text);
} }
/**
* Check if durbility should be applied based on the unbreaking enchantment
*
* @param level The level of the unbreaking enchantment
* @return True if durability should be applied, otherwise false
*/
public static boolean checkUnbreakingChance(int level) {
return ((double) 1 / (level + 1)) > random.nextDouble();
}
} }

4
UltimateTimber/Plugin/UltimateTimber-Plugin.iml
View File

@ -12,7 +12,7 @@
<orderEntry type="sourceFolder" forTests="false" /> <orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="library" scope="PROVIDED" name="Maven: org.spigotmc:spigot:1.13.2" level="project" /> <orderEntry type="library" scope="PROVIDED" name="Maven: org.spigotmc:spigot:1.13.2" level="project" />
<orderEntry type="module" module-name="UltimateTimber-Core" /> <orderEntry type="module" module-name="UltimateTimber-Core" />
<orderEntry type="module" module-name="Current" /> <orderEntry type="module" module-name="UltimateTimber-CurrentAdapter" />
<orderEntry type="module" module-name="Legacy" /> <orderEntry type="module" module-name="UltimateTimber-LegacyAdapter" />
</component> </component>
</module> </module>

23
UltimateTimber/Plugin/pom.xml
View File

@ -6,14 +6,12 @@
<parent> <parent>
<groupId>com.songoda.ultimatetimber</groupId> <groupId>com.songoda.ultimatetimber</groupId>
<artifactId>UltimateTimber</artifactId> <artifactId>UltimateTimber-Parent</artifactId>
<version>maven-version-number</version> <version>maven-version-number</version>
<relativePath>../../pom.xml</relativePath> <relativePath>../../pom.xml</relativePath>
</parent> </parent>
<artifactId>UltimateTimber-Plugin</artifactId> <artifactId>UltimateTimber-Plugin</artifactId>
<packaging>jar</packaging>
<version>maven-version-number</version>
<dependencies> <dependencies>
<!--Spigot API--> <!--Spigot API-->
@ -47,29 +45,22 @@
</dependencies> </dependencies>
<build> <build>
<finalName>${parent.artifactId}-${project.version}</finalName> <defaultGoal>clean install</defaultGoal>
<finalName>${project.artifactId}-${project.version}</finalName>
<plugins> <plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<showDeprecation>false</showDeprecation>
</configuration>
</plugin>
<plugin> <plugin>
<groupId>org.apache.maven.plugins</groupId> <groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId> <artifactId>maven-shade-plugin</artifactId>
<version>3.1.0</version> <version>3.2.0</version>
<configuration>
<createDependencyReducedPom>false</createDependencyReducedPom>
</configuration>
<executions> <executions>
<execution> <execution>
<phase>package</phase> <phase>package</phase>
<goals> <goals>
<goal>shade</goal> <goal>shade</goal>
</goals> </goals>
<configuration>
<createDependencyReducedPom>false</createDependencyReducedPom>
</configuration>
</execution> </execution>
</executions> </executions>
</plugin> </plugin>

31
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimation.java
View File

@ -1,29 +1,44 @@
package com.songoda.ultimatetimber.animation; package com.songoda.ultimatetimber.animation;
import com.songoda.ultimatetimber.UltimateTimber;
import com.songoda.ultimatetimber.manager.ConfigurationManager;
import com.songoda.ultimatetimber.manager.SaplingManager;
import com.songoda.ultimatetimber.tree.DetectedTree; import com.songoda.ultimatetimber.tree.DetectedTree;
import com.songoda.ultimatetimber.tree.TreeBlockSet; import com.songoda.ultimatetimber.tree.TreeBlockSet;
import com.songoda.ultimatetimber.tree.TreeDefinition; import com.songoda.ultimatetimber.tree.TreeDefinition;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.block.Block; import org.bukkit.block.Block;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
public abstract class TreeAnimation { public abstract class TreeAnimation {
protected final TreeAnimationType treeAnimationType; protected final TreeAnimationType treeAnimationType;
protected final TreeBlockSet<Block> treeBlocks; protected final DetectedTree detectedTree;
protected final TreeDefinition treeDefinition; protected final Player player;
TreeAnimation(TreeAnimationType treeAnimationType, TreeBlockSet<Block> treeBlocks, TreeDefinition treeDefinition) { TreeAnimation(TreeAnimationType treeAnimationType, DetectedTree detectedTree, Player player) {
this.treeAnimationType = treeAnimationType; this.treeAnimationType = treeAnimationType;
this.treeBlocks = treeBlocks; this.detectedTree = detectedTree;
this.treeDefinition = treeDefinition; this.player = player;
} }
/** /**
* Plays this tree topple animation * Plays this tree topple animation
* *
* @param detectedTree The DetectedTree * @param whenFinished The runnable to run when the animation is done
* @param player The Player who toppled the tree
*/ */
abstract void playAnimation(DetectedTree detectedTree, Player player); public abstract void playAnimation(Runnable whenFinished);
/**
* Replaces a given block with a new one
*
* @param treeDefinition The tree definition for the replacement
* @param block The block to replace
*/
protected void replaceBlock(TreeDefinition treeDefinition, Block block) {
block.setType(Material.AIR);
UltimateTimber.getInstance().getSaplingManager().replantSapling(treeDefinition, block.getLocation());
}
} }

6
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationChaos.java
View File

@ -8,12 +8,12 @@ import org.bukkit.entity.Player;
public class TreeAnimationChaos extends TreeAnimation { public class TreeAnimationChaos extends TreeAnimation {
public TreeAnimationChaos(TreeBlockSet<Block> treeBlocks, TreeDefinition treeDefinition) { public TreeAnimationChaos(DetectedTree detectedTree, Player player) {
super(TreeAnimationType.CHAOS, treeBlocks, treeDefinition); super(TreeAnimationType.CHAOS, detectedTree, player);
} }
@Override @Override
public void playAnimation(DetectedTree detectedTree, Player player) { public void playAnimation(Runnable whenFinished) {
} }

6
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationDisintegrate.java
View File

@ -8,12 +8,12 @@ import org.bukkit.entity.Player;
public class TreeAnimationDisintegrate extends TreeAnimation { public class TreeAnimationDisintegrate extends TreeAnimation {
public TreeAnimationDisintegrate(TreeBlockSet<Block> treeBlocks, TreeDefinition treeDefinition) { public TreeAnimationDisintegrate(DetectedTree detectedTree, Player player) {
super(TreeAnimationType.DISINTIGRATE, treeBlocks, treeDefinition); super(TreeAnimationType.DISINTIGRATE, detectedTree, player);
} }
@Override @Override
public void playAnimation(DetectedTree detectedTree, Player player) { public void playAnimation(Runnable whenFinished) {
} }

6
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationFancy.java
View File

@ -8,12 +8,12 @@ import org.bukkit.entity.Player;
public class TreeAnimationFancy extends TreeAnimation { public class TreeAnimationFancy extends TreeAnimation {
public TreeAnimationFancy(TreeBlockSet<Block> treeBlocks, TreeDefinition treeDefinition) { public TreeAnimationFancy(DetectedTree detectedTree, Player player) {
super(TreeAnimationType.FANCY, treeBlocks, treeDefinition); super(TreeAnimationType.FANCY, detectedTree, player);
} }
@Override @Override
public void playAnimation(DetectedTree detectedTree, Player player) { public void playAnimation(Runnable whenFinished) {
} }

9
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/animation/TreeAnimationNone.java
View File

@ -1,6 +1,7 @@
package com.songoda.ultimatetimber.animation; package com.songoda.ultimatetimber.animation;
import com.songoda.ultimatetimber.tree.DetectedTree; import com.songoda.ultimatetimber.tree.DetectedTree;
import com.songoda.ultimatetimber.tree.ITreeBlock;
import com.songoda.ultimatetimber.tree.TreeBlockSet; import com.songoda.ultimatetimber.tree.TreeBlockSet;
import com.songoda.ultimatetimber.tree.TreeDefinition; import com.songoda.ultimatetimber.tree.TreeDefinition;
import org.bukkit.block.Block; import org.bukkit.block.Block;
@ -8,13 +9,15 @@ import org.bukkit.entity.Player;
public class TreeAnimationNone extends TreeAnimation { public class TreeAnimationNone extends TreeAnimation {
public TreeAnimationNone(TreeBlockSet<Block> treeBlocks, TreeDefinition treeDefinition) { public TreeAnimationNone(DetectedTree detectedTree, Player player) {
super(TreeAnimationType.NONE, treeBlocks, treeDefinition); super(TreeAnimationType.NONE, detectedTree, player);
} }
@Override @Override
public void playAnimation(DetectedTree detectedTree, Player player) { public void playAnimation(Runnable whenFinished) {
for (ITreeBlock<Block> treeBlock : this.detectedTree.getDetectedTreeBlocks().getAllTreeBlocks()) {
}
} }
} }

2
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/manager/CommandManager.java
View File

@ -1,7 +1,7 @@
package com.songoda.ultimatetimber.manager; package com.songoda.ultimatetimber.manager;
import com.songoda.ultimatetimber.UltimateTimber; import com.songoda.ultimatetimber.UltimateTimber;
import utils.Methods; import com.songoda.ultimatetimber.utils.Methods;
import org.bukkit.command.*; import org.bukkit.command.*;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.util.StringUtil; import org.bukkit.util.StringUtil;

1
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/manager/ConfigurationManager.java
View File

@ -33,6 +33,7 @@ public class ConfigurationManager extends Manager {
USE_CUSTOM_SOUNDS, USE_CUSTOM_SOUNDS,
USE_CUSTOM_PARTICLES, USE_CUSTOM_PARTICLES,
BONUS_LOOT_MULTIPLIER, BONUS_LOOT_MULTIPLIER,
TREE_ANIMATION_TYPE,
SCATTER_TREE_BLOCKS_ON_GROUND, SCATTER_TREE_BLOCKS_ON_GROUND,
MIX_ALL_TREE_TYPES; MIX_ALL_TREE_TYPES;

17
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/manager/SaplingManager.java
View File

@ -7,6 +7,7 @@ import org.bukkit.Bukkit;
import org.bukkit.Location; import org.bukkit.Location;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.block.Block; import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import java.util.HashSet; import java.util.HashSet;
import java.util.Random; import java.util.Random;
@ -44,7 +45,7 @@ public class SaplingManager extends Manager {
if (!ConfigurationManager.Setting.REPLANT_SAPLINGS.getBoolean()) if (!ConfigurationManager.Setting.REPLANT_SAPLINGS.getBoolean())
return; return;
this.internalReplant(treeDefinition, location); Bukkit.getScheduler().scheduleSyncDelayedTask(this.ultimateTimber, () -> this.internalReplant(treeDefinition, location), 1L);
} }
/** /**
@ -62,7 +63,7 @@ public class SaplingManager extends Manager {
if (this.random.nextDouble() > chance / 100) if (this.random.nextDouble() > chance / 100)
return; return;
this.internalReplant(treeDefinition, location); Bukkit.getScheduler().scheduleSyncDelayedTask(this.ultimateTimber, () -> this.internalReplant(treeDefinition, location), 1L);
} }
/** /**
@ -76,6 +77,18 @@ public class SaplingManager extends Manager {
if (!block.getType().equals(Material.AIR)) if (!block.getType().equals(Material.AIR))
return; return;
Block blockBelow = block.getRelative(BlockFace.DOWN);
boolean isValidSoil = false;
for (IBlockData soilBlockData : treeDefinition.getPlantableSoilBlockData()) {
if (soilBlockData.isSimilar(blockBelow)) {
isValidSoil = true;
break;
}
}
if (!isValidSoil)
return;
IBlockData saplingBlockData = treeDefinition.getSaplingBlockData(); IBlockData saplingBlockData = treeDefinition.getSaplingBlockData();
saplingBlockData.setBlock(location.getBlock()); saplingBlockData.setBlock(location.getBlock());

34
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/manager/TreeAnimationManager.java
View File

@ -1,6 +1,7 @@
package com.songoda.ultimatetimber.manager; package com.songoda.ultimatetimber.manager;
import com.songoda.ultimatetimber.UltimateTimber; import com.songoda.ultimatetimber.UltimateTimber;
import com.songoda.ultimatetimber.animation.*;
import com.songoda.ultimatetimber.tree.DetectedTree; import com.songoda.ultimatetimber.tree.DetectedTree;
import com.songoda.ultimatetimber.tree.TreeDefinition; import com.songoda.ultimatetimber.tree.TreeDefinition;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
@ -10,21 +11,27 @@ import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener; import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityChangeBlockEvent; import org.bukkit.event.entity.EntityChangeBlockEvent;
import java.util.HashSet;
import java.util.Set;
public class TreeAnimationManager extends Manager implements Listener { public class TreeAnimationManager extends Manager implements Listener {
private Set<TreeAnimation> activeAnimations;
public TreeAnimationManager(UltimateTimber ultimateTimber) { public TreeAnimationManager(UltimateTimber ultimateTimber) {
super(ultimateTimber); super(ultimateTimber);
this.activeAnimations = new HashSet<>();
Bukkit.getPluginManager().registerEvents(this, ultimateTimber); Bukkit.getPluginManager().registerEvents(this, ultimateTimber);
} }
@Override @Override
public void reload() { public void reload() {
this.activeAnimations.clear();
} }
@Override @Override
public void disable() { public void disable() {
this.activeAnimations.clear();
} }
/** /**
@ -34,7 +41,28 @@ public class TreeAnimationManager extends Manager implements Listener {
* @param player The Player who toppled the tree * @param player The Player who toppled the tree
*/ */
public void runAnimation(DetectedTree detectedTree, Player player) { public void runAnimation(DetectedTree detectedTree, Player player) {
TreeDefinition treeDefinition = detectedTree.getTreeDefinition(); switch (ConfigurationManager.Setting.TREE_ANIMATION_TYPE.getString()) {
case "FANCY":
this.registerTreeAnimation(new TreeAnimationFancy(detectedTree, player));
break;
case "DISINTEGRATE":
this.registerTreeAnimation(new TreeAnimationDisintegrate(detectedTree, player));
break;
case "CHAOS":
this.registerTreeAnimation(new TreeAnimationChaos(detectedTree, player));
break;
case "NONE":
this.registerTreeAnimation(new TreeAnimationNone(detectedTree, player));
break;
}
}
/**
* Registers and runs a tree animation
*/
private void registerTreeAnimation(TreeAnimation treeAnimation) {
this.activeAnimations.add(treeAnimation);
treeAnimation.playAnimation(() -> this.activeAnimations.remove(treeAnimation));
} }
@EventHandler(priority = EventPriority.HIGH) @EventHandler(priority = EventPriority.HIGH)

7
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/manager/TreeDefinitionManager.java
View File

@ -207,8 +207,9 @@ public class TreeDefinitionManager extends Manager {
* @param treeBlock The TreeBlock to drop for * @param treeBlock The TreeBlock to drop for
* @param player The Player to drop for * @param player The Player to drop for
*/ */
@SuppressWarnings("unchecked")
public void dropTreeLoot(TreeDefinition treeDefinition, ITreeBlock treeBlock, Player player) { public void dropTreeLoot(TreeDefinition treeDefinition, ITreeBlock treeBlock, Player player) {
VersionAdapter versionAdapter = this.ultimateTimber.getVersionAdapter();
boolean addToInventory = ConfigurationManager.Setting.ADD_ITEMS_TO_INVENTORY.getBoolean(); boolean addToInventory = ConfigurationManager.Setting.ADD_ITEMS_TO_INVENTORY.getBoolean();
ItemStack itemInHand = this.ultimateTimber.getVersionAdapter().getItemInHand(player); ItemStack itemInHand = this.ultimateTimber.getVersionAdapter().getItemInHand(player);
boolean hasSilkTouch = itemInHand != null && itemInHand.hasItemMeta() && itemInHand.getItemMeta().hasEnchant(Enchantment.SILK_TOUCH); boolean hasSilkTouch = itemInHand != null && itemInHand.hasItemMeta() && itemInHand.getItemMeta().hasEnchant(Enchantment.SILK_TOUCH);
@ -223,13 +224,13 @@ public class TreeDefinitionManager extends Manager {
toTry.addAll(treeDefinition.getLogLoot()); toTry.addAll(treeDefinition.getLogLoot());
toTry.addAll(this.globalLogLoot); toTry.addAll(this.globalLogLoot);
if (treeDefinition.shouldDropOriginalLog() || hasSilkTouch) if (treeDefinition.shouldDropOriginalLog() || hasSilkTouch)
lootedItems.addAll(treeBlock.getDrops()); lootedItems.addAll(versionAdapter.getBlockDrops(treeBlock));
break; break;
case LEAF: case LEAF:
toTry.addAll(treeDefinition.getLeafLoot()); toTry.addAll(treeDefinition.getLeafLoot());
toTry.addAll(this.globalLeafLoot); toTry.addAll(this.globalLeafLoot);
if (treeDefinition.shouldDropOriginalLeaf() || hasSilkTouch) if (treeDefinition.shouldDropOriginalLeaf() || hasSilkTouch)
lootedItems.addAll(treeBlock.getDrops()); lootedItems.addAll(versionAdapter.getBlockDrops(treeBlock));
break; break;
} }

2
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/manager/TreeFallManager.java
View File

@ -89,7 +89,7 @@ public class TreeFallManager extends Manager implements Listener {
event.setCancelled(true); event.setCancelled(true);
if (!player.getGameMode().equals(GameMode.CREATIVE)) { if (!player.getGameMode().equals(GameMode.CREATIVE)) {
versionAdapter.applyToolDurability(tool, toolDamage); versionAdapter.applyToolDurability(player, toolDamage);
hookManager.applyHooks(player, detectedTree.getDetectedTreeBlocks()); hookManager.applyHooks(player, detectedTree.getDetectedTreeBlocks());
} }

85
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/old_code/AxeDurability.java
View File

@ -1,85 +0,0 @@
package com.songoda.ultimatetimber.old_code;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.Damageable;
import org.bukkit.inventory.meta.ItemMeta;
import java.util.HashSet;
import java.util.Random;
public class AxeDurability {
private static Random random = new Random();
/**
* Applies damage to the axe the player is holding based on logs they broke
*
* @param blocks The blocks that are part of the tree
* @param player The player
*/
public static void adjustAxeDamage(HashSet<Block> blocks, Player player) {
if (player.getGameMode().equals(GameMode.CREATIVE))
return;
ItemStack item = player.getInventory().getItemInMainHand();
Material itemType = item.getType();
if (!(itemType.equals(Material.DIAMOND_AXE) ||
itemType.equals(Material.GOLDEN_AXE) ||
itemType.equals(Material.IRON_AXE) ||
itemType.equals(Material.STONE_AXE) ||
itemType.equals(Material.WOODEN_AXE))) return;
int unbreakingLevel = item.getEnchantmentLevel(Enchantment.DURABILITY);
ItemMeta itemMeta = item.getItemMeta();
Damageable damageableMeta = (Damageable) itemMeta;
for (Block block : blocks) {
Material material = WoodToLogConverter.convert(block.getType());
if (isMaterialDurable(material) && checkUnbreakingChance(unbreakingLevel))
damageableMeta.setDamage(damageableMeta.getDamage() + 1);
}
item.setItemMeta((ItemMeta) damageableMeta);
if (damageableMeta.getDamage() >= item.getType().getMaxDurability())
player.getInventory().setItemInMainHand(new ItemStack(Material.AIR));
}
/**
* Checks is a material should apply durability
*
* @param material The material to check
* @return If durability should be applied
*/
private static boolean isMaterialDurable(Material material) {
return material.equals(Material.ACACIA_LOG) ||
material.equals(Material.BIRCH_LOG) ||
material.equals(Material.DARK_OAK_LOG) ||
material.equals(Material.JUNGLE_LOG) ||
material.equals(Material.OAK_LOG) ||
material.equals(Material.SPRUCE_LOG) ||
material.equals(Material.STRIPPED_ACACIA_LOG) ||
material.equals(Material.STRIPPED_BIRCH_LOG) ||
material.equals(Material.STRIPPED_DARK_OAK_LOG) ||
material.equals(Material.STRIPPED_JUNGLE_LOG) ||
material.equals(Material.STRIPPED_OAK_LOG) ||
material.equals(Material.STRIPPED_SPRUCE_LOG);
}
/**
* Check if durbility should be applied based on the unbreaking enchantment
*
* @param level The level of the unbreaking enchantment
* @return True if durability should be applied, otherwise false
*/
private static boolean checkUnbreakingChance(int level) {
return ((double) 1 / (level + 1)) > random.nextDouble();
}
}

68
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/old_code/CustomLoot.java
View File

@ -1,68 +0,0 @@
package com.songoda.ultimatetimber.old_code;
import com.songoda.ultimatetimber.UltimateTimber;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.inventory.ItemStack;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
public class CustomLoot {
/*
This is a very simple config parser for items
Each item is a new line in a list
Each line includes the keywords "Material:" and "Chance:" seperated by a ","
The chance is a percentage
It throws specific errors on startup when an invalid configuration is detected
*/
private static HashMap<ItemStack, Double> itemMap = new HashMap<>();
static void doCustomItemDrop(Location location) {
for (ItemStack itemStack : itemMap.keySet())
if ((ThreadLocalRandom.current().nextDouble()) < itemMap.get(itemStack) / 100)
location.getWorld().dropItem(location, itemStack);
}
public static void initializeCustomItems() {
itemMap.clear();
FileConfiguration fileConfiguration = UltimateTimber.getInstance().getConfig();
List<String> arrayList = fileConfiguration.getStringList(DefaultConfig.CUSTOM_LOOT_LIST);
for (String string : arrayList) {
Material material = null;
double chance = 0;
String materialString = string.split(",")[0].replace("Material:", "");
try {
material = Material.valueOf(materialString);
} catch (Exception ex) {
Bukkit.getLogger().warning("[UltimateTimber] Warning: " + materialString + " is not a valid material name.");
}
String chanceString = string.split(",")[1].replace("Chance:", "");
try {
chance = Double.parseDouble(chanceString);
} catch (Exception ex) {
Bukkit.getLogger().warning("[UltimateTimber] Warning: " + chanceString + " is not a valid chance.");
}
if (material == null || chance == 0) continue;
ItemStack itemStack = new ItemStack(material);
itemMap.put(itemStack, chance);
}
}
}

77
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/old_code/DefaultConfig.java
View File

@ -1,77 +0,0 @@
package com.songoda.ultimatetimber.old_code;
import com.songoda.ultimatetimber.UltimateTimber;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.configuration.Configuration;
import java.util.Collections;
public class DefaultConfig {
/*
Storing these values in final strings makes it so you can change the keys or refactor their names later on without
ever having to alter any code directly.
Also they are easier to refer to using an IDE.
*/
public static final String MAX_BRANCH_BLOCKS = "Max amount of logs that can be broken with one chop";
public static final String LEAVES_FOR_TREE = "The number of leaves required to detect a valid tree";
public static final String ONLY_BREAK_LOGS_UPWARDS = "Only break logs above the block broken";
public static final String ALLOW_MIXED_TREE_TYPES = "Allow mixed log/leaf to be considered as one tree";
public static final String ENTIRE_TREE_BASE = "Entire tree base must be broken for the tree to fall";
public static final String AXES_ONLY = "Only topple down trees cut down using axes";
public static final String TIMEOUT_BREAK = "Five second time out before you can break saplings";
public static final String SNEAK_ONLY = "Only topple down trees cut down while sneaking";
public static final String ACCURATE_AXE_DURABILITY = "Lower durability proportionately to the amount of blocks toppled down";
public static final String CREATIVE_DISALLOWED = "Players in creative mode can't topple down trees";
public static final String PERMISSIONS_ONLY = "Only allow players with the permission node to topple down trees";
public static final String VALID_WORLDS = "Valid worlds.";
public static final String DAMAGE_PLAYERS = "Damage players when trees fall on them";
public static final String DELETE_BROKEN_LOG = "Delete the log that initiated the tree fall";
public static final String REPLANT_SAPLING = "Replant sapling when tree is cut down";
public static final String REPLANT_FROM_LEAVES = "Fallen leaves have a chance to plant saplings";
public static final String CUSTOM_AUDIO = "Use custom sounds for trees falling";
public static final String SHOW_ANIMATION = "Show tree fall animation";
public static final String SCATTER_FALLEN_BLOCKS = "Scatter fallen tree blocks on the ground when animated";
public static final String CUSTOM_LOOT_LIST = "Custom loot";
public static final String CUSTOM_LOOT_ITEM = "Material:GOLDEN_APPLE,Chance:1";
public static void initialize() {
UltimateTimber plugin = UltimateTimber.getInstance();
Configuration configuration = plugin.getConfig();
configuration.addDefault(MAX_BRANCH_BLOCKS, 120);
configuration.addDefault(LEAVES_FOR_TREE, 5);
configuration.addDefault(ONLY_BREAK_LOGS_UPWARDS, true);
configuration.addDefault(ALLOW_MIXED_TREE_TYPES, false);
configuration.addDefault(ENTIRE_TREE_BASE, false);
configuration.addDefault(AXES_ONLY, true);
configuration.addDefault(TIMEOUT_BREAK, true);
configuration.addDefault(SNEAK_ONLY, false);
configuration.addDefault(ACCURATE_AXE_DURABILITY, true);
configuration.addDefault(CREATIVE_DISALLOWED, true);
configuration.addDefault(PERMISSIONS_ONLY, true);
configuration.addDefault(DAMAGE_PLAYERS, true);
configuration.addDefault(DELETE_BROKEN_LOG, false);
configuration.addDefault(REPLANT_SAPLING, true);
configuration.addDefault(REPLANT_FROM_LEAVES, true);
configuration.addDefault(CUSTOM_AUDIO, true);
configuration.addDefault(SHOW_ANIMATION, true);
configuration.addDefault(SCATTER_FALLEN_BLOCKS, false);
/*
Add all worlds that exist in the world at startup
*/
for (World world : Bukkit.getServer().getWorlds())
configuration.addDefault(VALID_WORLDS + world.getName(), true);
configuration.addDefault(CUSTOM_LOOT_LIST, Collections.singletonList(CUSTOM_LOOT_ITEM));
configuration.options().copyDefaults(true);
plugin.saveConfig();
plugin.saveDefaultConfig();
}
}

51
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/old_code/EventFilter.java
View File

@ -1,51 +0,0 @@
package com.songoda.ultimatetimber.old_code;
import com.songoda.ultimatetimber.UltimateTimber;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.event.block.BlockBreakEvent;
class EventFilter {
/*
Incorporate all checks that would disqualify this event from happening
Mostly config settings, also permissions
*/
static boolean eventIsValid(BlockBreakEvent event) {
UltimateTimber plugin = UltimateTimber.getInstance();
/*
General catchers
*/
if (event.isCancelled()
|| !plugin.isWorldValid(event.getPlayer().getWorld())
|| !TreeChecker.getValidWoodMaterials().contains(event.getBlock().getType())) return false;
FileConfiguration fileConfiguration = UltimateTimber.getInstance().getConfig();
/*
Config-based catchers
*/
if (fileConfiguration.getBoolean(DefaultConfig.CREATIVE_DISALLOWED) &&
event.getPlayer().getGameMode().equals(GameMode.CREATIVE))
return false;
if (fileConfiguration.getBoolean(DefaultConfig.AXES_ONLY) &&
!(event.getPlayer().getInventory().getItemInMainHand().getType().equals(Material.DIAMOND_AXE) ||
event.getPlayer().getInventory().getItemInMainHand().getType().equals(Material.GOLDEN_AXE) ||
event.getPlayer().getInventory().getItemInMainHand().getType().equals(Material.IRON_AXE) ||
event.getPlayer().getInventory().getItemInMainHand().getType().equals(Material.STONE_AXE) ||
event.getPlayer().getInventory().getItemInMainHand().getType().equals(Material.WOODEN_AXE)))
return false;
if (fileConfiguration.getBoolean(DefaultConfig.SNEAK_ONLY) &&
!event.getPlayer().isSneaking())
return false;
return !fileConfiguration.getBoolean(DefaultConfig.PERMISSIONS_ONLY) ||
event.getPlayer().hasPermission("ultimatetimber.chop");
}
}

40
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/old_code/NoAnimationTreeDestroyer.java
View File

@ -1,20 +1,20 @@
package com.songoda.ultimatetimber.old_code; //package com.songoda.ultimatetimber.old_code;
//
import org.bukkit.block.Block; //import org.bukkit.block.Block;
//
import java.util.HashSet; //import java.util.HashSet;
//
class NoAnimationTreeDestroyer { //class NoAnimationTreeDestroyer {
//
/* // /*
Only ever triggers when people have tree falling animations off in the config // Only ever triggers when people have tree falling animations off in the config
*/ // */
static void destroyTree(HashSet<Block> blocks, boolean hasBonusLoot, boolean hasSilkTouch) { // static void destroyTree(HashSet<Block> blocks, boolean hasBonusLoot, boolean hasSilkTouch) {
// Drop loot and plant a new sapling // // Drop loot and plant a new sapling
for (Block block : blocks) { // for (Block block : blocks) {
TreeLoot.dropTreeLoot(block.getBlockData(), block.getLocation().clone().add(0.5, 0.5, 0.5), hasBonusLoot, hasSilkTouch); // TreeLoot.dropTreeLoot(block.getBlockData(), block.getLocation().clone().add(0.5, 0.5, 0.5), hasBonusLoot, hasSilkTouch);
TreeReplant.replaceOriginalBlock(block); // TreeReplant.replaceOriginalBlock(block);
} // }
} // }
//
} //}

42
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/old_code/TreeEntityDamage.java
View File

@ -1,21 +1,21 @@
package com.songoda.ultimatetimber.old_code; //package com.songoda.ultimatetimber.old_code;
//
import org.bukkit.entity.Entity; //import org.bukkit.entity.Entity;
import org.bukkit.entity.FallingBlock; //import org.bukkit.entity.FallingBlock;
import org.bukkit.entity.LivingEntity; //import org.bukkit.entity.LivingEntity;
//
class TreeEntityDamage { //class TreeEntityDamage {
//
static void runDamage(FallingBlock fallingBlock) { // static void runDamage(FallingBlock fallingBlock) {
//
for (Entity entity : fallingBlock.getNearbyEntities(0.5, 0.5, 0.5)) { // for (Entity entity : fallingBlock.getNearbyEntities(0.5, 0.5, 0.5)) {
//
if (!(entity instanceof LivingEntity)) continue; // if (!(entity instanceof LivingEntity)) continue;
//
((LivingEntity) entity).damage(1); // ((LivingEntity) entity).damage(1);
//
} // }
//
} // }
//
} //}

596
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/old_code/TreeFallAnimation.java
View File

@ -1,298 +1,298 @@
package com.songoda.ultimatetimber.old_code; //package com.songoda.ultimatetimber.old_code;
//
import com.songoda.ultimatetimber.UltimateTimber; //import com.songoda.ultimatetimber.UltimateTimber;
import org.bukkit.Bukkit; //import org.bukkit.Bukkit;
import org.bukkit.Material; //import org.bukkit.Material;
import org.bukkit.Particle; //import org.bukkit.Particle;
import org.bukkit.block.Block; //import org.bukkit.block.Block;
import org.bukkit.configuration.file.FileConfiguration; //import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.enchantments.Enchantment; //import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.FallingBlock; //import org.bukkit.entity.FallingBlock;
import org.bukkit.entity.Player; //import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler; //import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener; //import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityChangeBlockEvent; //import org.bukkit.event.entity.EntityChangeBlockEvent;
import org.bukkit.scheduler.BukkitRunnable; //import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.util.Vector; //import org.bukkit.util.Vector;
//
import java.util.ArrayList; //import java.util.ArrayList;
import java.util.HashSet; //import java.util.HashSet;
import java.util.Random; //import java.util.Random;
import java.util.Set; //import java.util.Set;
//
public class TreeFallAnimation implements Listener, Runnable { //public class TreeFallAnimation implements Listener, Runnable {
//
/* // /*
Register all instances of falling trees. // Register all instances of falling trees.
*/ // */
private static ArrayList<TreeFallAnimation> treeFallAnimationInstances = new ArrayList<>(); // private static ArrayList<TreeFallAnimation> treeFallAnimationInstances = new ArrayList<>();
private static Random random = new Random(); // private static Random random = new Random();
/* // /*
This field gets updated based on player permissions, doubles loot from trees // This field gets updated based on player permissions, doubles loot from trees
*/ // */
private boolean hasBonusLoot; // private boolean hasBonusLoot;
/* // /*
If a player's tool has the silk touch enchantment, it changes the loot table // If a player's tool has the silk touch enchantment, it changes the loot table
*/ // */
private boolean hasSilkTouch; // private boolean hasSilkTouch;
/* // /*
This field stores every falling block in this instance of the animation // This field stores every falling block in this instance of the animation
This list is also used to identify if a falling block is a part of an animation // This list is also used to identify if a falling block is a part of an animation
*/ // */
private ArrayList<FallingBlock> fallingBlocks = new ArrayList<>(); // private ArrayList<FallingBlock> fallingBlocks = new ArrayList<>();
//
/* // /*
The ID of the task that manages the falling block detection // The ID of the task that manages the falling block detection
*/ // */
private int fallingBlockTaskId; // private int fallingBlockTaskId;
//
private boolean hasBonusLoot() { // private boolean hasBonusLoot() {
return this.hasBonusLoot; // return this.hasBonusLoot;
} // }
//
private void setHasBonusLoot(boolean bool) { // private void setHasBonusLoot(boolean bool) {
this.hasBonusLoot = bool; // this.hasBonusLoot = bool;
} // }
//
private boolean hasSilkTouch() { // private boolean hasSilkTouch() {
return this.hasSilkTouch; // return this.hasSilkTouch;
} // }
//
private void setHasSilkTouch(boolean bool) { // private void setHasSilkTouch(boolean bool) {
this.hasSilkTouch = bool; // this.hasSilkTouch = bool;
} // }
//
private boolean isFallingTreeBlock(FallingBlock fallingBlock) { // private boolean isFallingTreeBlock(FallingBlock fallingBlock) {
return this.fallingBlocks.contains(fallingBlock); // return this.fallingBlocks.contains(fallingBlock);
} // }
//
private void registerFallingBlock(FallingBlock fallingBlock) { // private void registerFallingBlock(FallingBlock fallingBlock) {
this.fallingBlocks.add(fallingBlock); // this.fallingBlocks.add(fallingBlock);
} // }
//
private void unregisterFallingBlock(FallingBlock fallingBlock) { // private void unregisterFallingBlock(FallingBlock fallingBlock) {
this.fallingBlocks.remove(fallingBlock); // this.fallingBlocks.remove(fallingBlock);
} // }
//
private ArrayList<FallingBlock> getAllFallingBlocks() { // private ArrayList<FallingBlock> getAllFallingBlocks() {
return this.fallingBlocks; // return this.fallingBlocks;
} // }
//
private boolean isInTreeFallInstance(FallingBlock fallingBlock) { // private boolean isInTreeFallInstance(FallingBlock fallingBlock) {
for (TreeFallAnimation treeFallAnimation : treeFallAnimationInstances) // for (TreeFallAnimation treeFallAnimation : treeFallAnimationInstances)
if (treeFallAnimation.isFallingTreeBlock(fallingBlock)) // if (treeFallAnimation.isFallingTreeBlock(fallingBlock))
return true; // return true;
return false; // return false;
} // }
//
private TreeFallAnimation getTreeFallAnimation(FallingBlock fallingBlock) { // private TreeFallAnimation getTreeFallAnimation(FallingBlock fallingBlock) {
for (TreeFallAnimation treeFallAnimation : treeFallAnimationInstances) // for (TreeFallAnimation treeFallAnimation : treeFallAnimationInstances)
if (treeFallAnimation.isFallingTreeBlock(fallingBlock)) // if (treeFallAnimation.isFallingTreeBlock(fallingBlock))
return treeFallAnimation; // return treeFallAnimation;
return null; // return null;
} // }
//
private void registerTreeFallInstance() { // private void registerTreeFallInstance() {
treeFallAnimationInstances.add(this); // treeFallAnimationInstances.add(this);
} // }
//
private void unregisterTreeFallAnimation() { // private void unregisterTreeFallAnimation() {
if (this.fallingBlocks.isEmpty()) { // if (this.fallingBlocks.isEmpty()) {
treeFallAnimationInstances.remove(this); // treeFallAnimationInstances.remove(this);
Bukkit.getScheduler().cancelTask(this.fallingBlockTaskId); // Bukkit.getScheduler().cancelTask(this.fallingBlockTaskId);
} // }
} // }
//
/* // /*
This is used to detect after the falling tree blocks have hit the ground // This is used to detect after the falling tree blocks have hit the ground
Using the event was too unreliable since multiple entities could hit the ground at the same time // Using the event was too unreliable since multiple entities could hit the ground at the same time
*/ // */
@Override // @Override
public void run() { // public void run() {
Set<FallingBlock> groundedBlocks = new HashSet<>(); // Set<FallingBlock> groundedBlocks = new HashSet<>();
for (FallingBlock fallingBlock : this.fallingBlocks) // for (FallingBlock fallingBlock : this.fallingBlocks)
if (fallingBlock.isDead()) // if (fallingBlock.isDead())
groundedBlocks.add(fallingBlock); // groundedBlocks.add(fallingBlock);
for (FallingBlock fallingBlock : groundedBlocks) // for (FallingBlock fallingBlock : groundedBlocks)
runFallingBlockImpact(fallingBlock); // runFallingBlockImpact(fallingBlock);
} // }
//
/* // /*
This animation has multiple phases. // This animation has multiple phases.
Initially, the tree will start slowly toppling over. // Initially, the tree will start slowly toppling over.
After a short while, it goes over the tipping point and the fall accelerates. // After a short while, it goes over the tipping point and the fall accelerates.
*/ // */
void startAnimation(Block originalBlock, HashSet<Block> blocks, Player player) { // void startAnimation(Block originalBlock, HashSet<Block> blocks, Player player) {
/* // /*
This vector makes sure that the entire tree falls in the same direction from the same reference point // This vector makes sure that the entire tree falls in the same direction from the same reference point
*/ // */
Vector velocityVector = originalBlock.getLocation().clone().subtract(player.getLocation().clone()).toVector().normalize().setY(0); // Vector velocityVector = originalBlock.getLocation().clone().subtract(player.getLocation().clone()).toVector().normalize().setY(0);
//
registerTreeFallInstance(); // registerTreeFallInstance();
setHasBonusLoot(player.hasPermission("ultimatetimber.bonusloot")); // setHasBonusLoot(player.hasPermission("ultimatetimber.bonusloot"));
//
/* // /*
Register private properties // Register private properties
*/ // */
if (player.getInventory().getItemInMainHand().getType().equals(Material.DIAMOND_AXE) || // if (player.getInventory().getItemInMainHand().getType().equals(Material.DIAMOND_AXE) ||
player.getInventory().getItemInMainHand().getType().equals(Material.GOLDEN_AXE) || // player.getInventory().getItemInMainHand().getType().equals(Material.GOLDEN_AXE) ||
player.getInventory().getItemInMainHand().getType().equals(Material.IRON_AXE) || // player.getInventory().getItemInMainHand().getType().equals(Material.IRON_AXE) ||
player.getInventory().getItemInMainHand().getType().equals(Material.STONE_AXE) || // player.getInventory().getItemInMainHand().getType().equals(Material.STONE_AXE) ||
player.getInventory().getItemInMainHand().getType().equals(Material.WOODEN_AXE)) // player.getInventory().getItemInMainHand().getType().equals(Material.WOODEN_AXE))
if (player.getInventory().getItemInMainHand().getEnchantments().containsKey(Enchantment.SILK_TOUCH)) // if (player.getInventory().getItemInMainHand().getEnchantments().containsKey(Enchantment.SILK_TOUCH))
setHasSilkTouch(true); // setHasSilkTouch(true);
else // else
setHasSilkTouch(false); // setHasSilkTouch(false);
else // else
setHasSilkTouch(false); // setHasSilkTouch(false);
//
for (Block block : blocks) { // for (Block block : blocks) {
//
/* // /*
Dropping air causes some issues // Dropping air causes some issues
*/ // */
if (block.getType().equals(Material.AIR)) continue; // if (block.getType().equals(Material.AIR)) continue;
//
FallingBlock fallingBlock = block.getWorld().spawnFallingBlock(block.getLocation().clone().add(0.5, 0, 0.5), block.getBlockData()); // FallingBlock fallingBlock = block.getWorld().spawnFallingBlock(block.getLocation().clone().add(0.5, 0, 0.5), block.getBlockData());
fallingBlock.setDropItem(false); // fallingBlock.setDropItem(false);
registerFallingBlock(fallingBlock); // registerFallingBlock(fallingBlock);
//
/* // /*
Remove original block // Remove original block
*/ // */
TreeReplant.replaceOriginalBlock(block); // TreeReplant.replaceOriginalBlock(block);
//
/* // /*
Set tipping over effect // Set tipping over effect
The horizontal velocity going away from the player increases as the Y moves away from the player // The horizontal velocity going away from the player increases as the Y moves away from the player
*/ // */
double multiplier = (block.getLocation().getY() - player.getLocation().getY()) * 0.1; // double multiplier = (block.getLocation().getY() - player.getLocation().getY()) * 0.1;
//
startPhaseOneAnimation(fallingBlock, velocityVector, multiplier); // startPhaseOneAnimation(fallingBlock, velocityVector, multiplier);
//
} // }
//
/* // /*
Kick off a task for detecting when the falling blocks have hit the ground // Kick off a task for detecting when the falling blocks have hit the ground
*/ // */
this.fallingBlockTaskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(UltimateTimber.getInstance(), this, 0, 1); // this.fallingBlockTaskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(UltimateTimber.getInstance(), this, 0, 1);
//
} // }
//
/* // /*
Phase one of the animation, the tree starts slowly tipping over // Phase one of the animation, the tree starts slowly tipping over
*/ // */
private void startPhaseOneAnimation(FallingBlock fallingBlock, Vector velocityVector, double multiplier) { // private void startPhaseOneAnimation(FallingBlock fallingBlock, Vector velocityVector, double multiplier) {
//
/* // /*
Vertical offset so top of the tree sways faster than the base // Vertical offset so top of the tree sways faster than the base
*/ // */
fallingBlock.setVelocity(velocityVector.clone().multiply(multiplier)); // fallingBlock.setVelocity(velocityVector.clone().multiply(multiplier));
/* // /*
No gravity helps with the initial surrounding block detection (somehow) and with the initial trunk rigidity aspect // No gravity helps with the initial surrounding block detection (somehow) and with the initial trunk rigidity aspect
required for the effect to look convincing // required for the effect to look convincing
*/ // */
fallingBlock.setGravity(false); // fallingBlock.setGravity(false);
//
fallingBlock.setVelocity(fallingBlock.getVelocity().multiply(0.2)); // fallingBlock.setVelocity(fallingBlock.getVelocity().multiply(0.2));
//
new BukkitRunnable() { // new BukkitRunnable() {
@Override // @Override
public void run() { // public void run() {
//
fallingBlock.setGravity(true); // fallingBlock.setGravity(true);
//
/* // /*
Phase 2 has to be launched from here as to not override effects // Phase 2 has to be launched from here as to not override effects
*/ // */
runPhaseTwoAnimation(fallingBlock); // runPhaseTwoAnimation(fallingBlock);
//
} // }
}.runTaskLater(UltimateTimber.getInstance(), 20); // }.runTaskLater(UltimateTimber.getInstance(), 20);
//
} // }
//
/* // /*
Phase two of the animation, the tree picks up speed until it is on the ground // Phase two of the animation, the tree picks up speed until it is on the ground
For safety's sake, it disintegrates after a 4 seconds // For safety's sake, it disintegrates after a 4 seconds
*/ // */
private void runPhaseTwoAnimation(FallingBlock fallingBlock) { // private void runPhaseTwoAnimation(FallingBlock fallingBlock) {
UltimateTimber plugin = UltimateTimber.getInstance(); // UltimateTimber plugin = UltimateTimber.getInstance();
new BukkitRunnable() { // new BukkitRunnable() {
int counter = 0; // int counter = 0;
//
@Override // @Override
public void run() { // public void run() {
//
if (!fallingBlock.isValid()) { // if (!fallingBlock.isValid()) {
cancel(); // cancel();
return; // return;
} // }
//
/* // /*
Safeguard to prevent errors that come from glitchy Minecraft behavior // Safeguard to prevent errors that come from glitchy Minecraft behavior
*/ // */
if (counter > 20 * 3) { // if (counter > 20 * 3) {
runFallingBlockImpact(fallingBlock); // runFallingBlockImpact(fallingBlock);
cancel(); // cancel();
} // }
//
if (counter < 10) // if (counter < 10)
fallingBlock.setVelocity(fallingBlock.getVelocity().multiply(1.3)); // fallingBlock.setVelocity(fallingBlock.getVelocity().multiply(1.3));
//
counter++; // counter++;
} // }
}.runTaskTimer(plugin, 0, 1); // }.runTaskTimer(plugin, 0, 1);
//
} // }
//
/* // /*
Catch tree blocks falling down and prevent them from interacting with the ground // Catch tree blocks falling down and prevent them from interacting with the ground
*/ // */
@EventHandler // @EventHandler
public void blockDrop(EntityChangeBlockEvent event) { // public void blockDrop(EntityChangeBlockEvent event) {
if (!(event.getEntity() instanceof FallingBlock)) return; // if (!(event.getEntity() instanceof FallingBlock)) return;
FallingBlock fallingBlock = (FallingBlock) event.getEntity(); // FallingBlock fallingBlock = (FallingBlock) event.getEntity();
if (!isInTreeFallInstance(fallingBlock)) return; // if (!isInTreeFallInstance(fallingBlock)) return;
//
if (UltimateTimber.getInstance().getConfig().getBoolean(DefaultConfig.SCATTER_FALLEN_BLOCKS)) { // if (UltimateTimber.getInstance().getConfig().getBoolean(DefaultConfig.SCATTER_FALLEN_BLOCKS)) {
boolean isLeaf = fallingBlock.getBlockData().getMaterial().name().endsWith("LEAVES"); // boolean isLeaf = fallingBlock.getBlockData().getMaterial().name().endsWith("LEAVES");
if (!isLeaf || (isLeaf && random.nextDouble() > 0.5)) { // Only let about half the leafs turn back into blocks // if (!isLeaf || (isLeaf && random.nextDouble() > 0.5)) { // Only let about half the leafs turn back into blocks
getTreeFallAnimation(fallingBlock).unregisterFallingBlock(fallingBlock); // getTreeFallAnimation(fallingBlock).unregisterFallingBlock(fallingBlock);
return; // return;
} // }
} // }
//
event.setCancelled(true); // event.setCancelled(true);
} // }
//
private void runFallingBlockImpact(FallingBlock fallingBlock) { // private void runFallingBlockImpact(FallingBlock fallingBlock) {
//
TreeFallAnimation treeFallAnimation = getTreeFallAnimation(fallingBlock); // TreeFallAnimation treeFallAnimation = getTreeFallAnimation(fallingBlock);
treeFallAnimation.unregisterFallingBlock(fallingBlock); // treeFallAnimation.unregisterFallingBlock(fallingBlock);
if (treeFallAnimation.getAllFallingBlocks().isEmpty()) // if (treeFallAnimation.getAllFallingBlocks().isEmpty())
unregisterTreeFallAnimation(); // unregisterTreeFallAnimation();
//
FileConfiguration fileConfiguration = UltimateTimber.getInstance().getConfig(); // FileConfiguration fileConfiguration = UltimateTimber.getInstance().getConfig();
//
/* // /*
Run block fall aftermath // Run block fall aftermath
*/ // */
TreeLoot.dropTreeLoot(fallingBlock.getBlockData(), fallingBlock.getLocation(), treeFallAnimation.hasBonusLoot(), treeFallAnimation.hasSilkTouch()); // TreeLoot.dropTreeLoot(fallingBlock.getBlockData(), fallingBlock.getLocation(), treeFallAnimation.hasBonusLoot(), treeFallAnimation.hasSilkTouch());
if (UltimateTimber.getInstance().getConfig().getBoolean(DefaultConfig.REPLANT_FROM_LEAVES)) // if (UltimateTimber.getInstance().getConfig().getBoolean(DefaultConfig.REPLANT_FROM_LEAVES))
TreeReplant.leafFallReplant(fallingBlock); // TreeReplant.leafFallReplant(fallingBlock);
if (fileConfiguration.getBoolean(DefaultConfig.DAMAGE_PLAYERS)) // if (fileConfiguration.getBoolean(DefaultConfig.DAMAGE_PLAYERS))
TreeEntityDamage.runDamage(fallingBlock); // TreeEntityDamage.runDamage(fallingBlock);
if (fileConfiguration.getBoolean(DefaultConfig.CUSTOM_AUDIO)) // if (fileConfiguration.getBoolean(DefaultConfig.CUSTOM_AUDIO))
TreeSounds.fallNoise(fallingBlock); // TreeSounds.fallNoise(fallingBlock);
//
fallingBlock.getLocation().getWorld().spawnParticle(Particle.SMOKE_LARGE, fallingBlock.getLocation(), 3, 0.2, 0.2, 0.2, 0.05); // fallingBlock.getLocation().getWorld().spawnParticle(Particle.SMOKE_LARGE, fallingBlock.getLocation(), 3, 0.2, 0.2, 0.2, 0.05);
//
/* // /*
Make sure the falling block gets culled // Make sure the falling block gets culled
*/ // */
fallingBlock.remove(); // fallingBlock.remove();
//
} // }
//
} //}

86
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/old_code/TreeFallListener.java
View File

@ -1,86 +0,0 @@
package com.songoda.ultimatetimber.old_code;
import com.songoda.ultimatetimber.UltimateTimber;
import com.songoda.ultimatetimber.events.TreeFallEvent;
import com.songoda.ultimatetimber.events.TreeFellEvent;
import com.songoda.ultimatetimber.manager.HookManager;
import org.bukkit.Bukkit;
import org.bukkit.block.Block;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import java.util.HashSet;
public class TreeFallListener implements Listener {
/*
This is the starting point for the whole effect
It's been broken up instead of chained in order to make step-by-step debugging easier
*/
@EventHandler(priority = EventPriority.HIGHEST)
public void onTreeBreak(BlockBreakEvent event) {
FileConfiguration config = UltimateTimber.getInstance().getConfig();
Block block = event.getBlock();
if (block != null && block.getType().name().contains("SAPLING") &&
config.getBoolean(DefaultConfig.TIMEOUT_BREAK) && TreeReplant.isTimeout(block))
event.setCancelled(true);
if (!EventFilter.eventIsValid(event)) return;
if (config.getBoolean(DefaultConfig.SNEAK_ONLY) && !event.getPlayer().isSneaking()) return;
if (!UltimateTimber.getInstance().isChopping(event.getPlayer())) return;
TreeChecker treeChecker = new TreeChecker();
HashSet<Block> blocks = treeChecker.parseTree(block);
/*
Previous list will be null if no valid tree is found
*/
if (blocks == null)
return;
//Call event that tree will fall
TreeFallEvent treeFallEvent = new TreeFallEvent(event.getPlayer(), treeChecker, block);
Bukkit.getPluginManager().callEvent(treeFallEvent);
if (treeFallEvent.isCancelled()) return;
/*
Everything beyond this point assumes that the tree was valid
*/
// Do not let any items drop, it will be handled later
event.setDropItems(false);
// Remove log if it's enabled
if (config.getBoolean(DefaultConfig.DELETE_BROKEN_LOG))
TreeReplant.replaceOriginalBlock(block);
// Apply hooks
HookManager.getInstance().applyHooks(event.getPlayer(), blocks);
if (config.getBoolean(DefaultConfig.ACCURATE_AXE_DURABILITY))
AxeDurability.adjustAxeDamage(blocks, event.getPlayer());
if (config.getBoolean(DefaultConfig.CUSTOM_AUDIO))
TreeSounds.tipOverNoise(block.getLocation());
if (config.getBoolean(DefaultConfig.SHOW_ANIMATION)) {
TreeFallAnimation treeFallAnimation = new TreeFallAnimation();
treeFallAnimation.startAnimation(block, blocks, event.getPlayer());
} else {
NoAnimationTreeDestroyer.destroyTree(blocks, event.getPlayer().hasPermission("ultimatetimber.bonusloot"),
event.getPlayer().getInventory().getItemInMainHand().containsEnchantment(Enchantment.SILK_TOUCH));
}
//Call event that a tree has fell
TreeFellEvent treeFellEvent = new TreeFellEvent(event.getPlayer(), treeChecker, block);
Bukkit.getPluginManager().callEvent(treeFellEvent);
}
}

85
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/old_code/TreeLoot.java
View File

@ -1,85 +0,0 @@
package com.songoda.ultimatetimber.old_code;
import utils.LeafToSaplingConverter;
import utils.WoodToLogConverter;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.data.BlockData;
import org.bukkit.inventory.ItemStack;
import java.util.Random;
class TreeLoot {
static Random random = new Random();
static void dropTreeLoot(BlockData blockData, Location location, boolean hasBonusLoot, boolean hasSilkTouch) {
World world = location.getWorld();
Material originalMaterial = blockData.getMaterial();
Material material = LeafToSaplingConverter.convertLeaves(originalMaterial);
if (originalMaterial.equals(Material.AIR) || originalMaterial.equals(Material.CAVE_AIR) || originalMaterial.equals(Material.VOID_AIR))
return;
if (hasSilkTouch) { // No bonus loot for silk touch
world.dropItem(location, new ItemStack(WoodToLogConverter.convert(originalMaterial), 1));
return;
}
switch (material) {
case VINE:
case MUSHROOM_STEM:
break;
case BROWN_MUSHROOM_BLOCK:
case RED_MUSHROOM_BLOCK:
boolean isRed = material.equals(Material.RED_MUSHROOM_BLOCK);
int numToDrop = Math.max(0, random.nextInt(10) - 7); // 80% chance to drop nothing, 10% chance for 1, 10% chance for 2
if (numToDrop != 0)
world.dropItem(location, new ItemStack(isRed ? Material.RED_MUSHROOM : Material.BROWN_MUSHROOM, numToDrop));
break;
case ACACIA_SAPLING:
case BIRCH_SAPLING:
case SPRUCE_SAPLING:
boolean dropChance = random.nextInt(20) == 0; // 1/20 chance to drop sapling
if (dropChance)
world.dropItem(location, new ItemStack(material, 1));
if (hasBonusLoot)
CustomLoot.doCustomItemDrop(location);
break;
case JUNGLE_SAPLING:
boolean jungleDropChance = random.nextInt(40) == 0; // 1/40 chance to drop sapling
if (jungleDropChance)
world.dropItem(location, new ItemStack(material, 1));
if (hasBonusLoot)
CustomLoot.doCustomItemDrop(location);
break;
case DARK_OAK_SAPLING:
case OAK_SAPLING:
boolean oakDropChance = random.nextInt(20) == 0; // 1/20 chance to drop sapling
if (oakDropChance)
world.dropItem(location, new ItemStack(material, 1));
boolean appleDropChance = random.nextInt(200) == 0; // 1/200 chance to drop apple
if (appleDropChance)
world.dropItem(location, new ItemStack(Material.APPLE, 1));
if (hasBonusLoot)
CustomLoot.doCustomItemDrop(location);
break;
default:
Material dropMaterial = WoodToLogConverter.convert(material);
world.dropItem(location, new ItemStack(dropMaterial, 1));
break;
}
}
}

141
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/old_code/TreeReplant.java
View File

@ -1,141 +0,0 @@
package com.songoda.ultimatetimber.old_code;
import com.songoda.ultimatetimber.UltimateTimber;
import utils.WoodToLogConverter;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.entity.FallingBlock;
import org.bukkit.util.Vector;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;
class TreeReplant {
private static List<Location> timeout = new ArrayList<>();
static void replaceOriginalBlock(Block block) {
boolean isTimeout = UltimateTimber.getInstance().getConfig().getBoolean(DefaultConfig.TIMEOUT_BREAK);
Material material = WoodToLogConverter.convert(block.getType());
if (!UltimateTimber.getInstance().getConfig().getBoolean(DefaultConfig.REPLANT_SAPLING)) {
block.setType(Material.AIR);
return;
}
Block below = block.getRelative(BlockFace.DOWN);
Material belowType = below.getType();
if (belowType.equals(Material.AIR) && UltimateTimber.getInstance().getConfig().getBoolean(DefaultConfig.ENTIRE_TREE_BASE)) {
if (isValidGround(below.getRelative(BlockFace.DOWN).getType())) {
if (isTimeout) {
timeout.add(below.getLocation());
Bukkit.getScheduler().scheduleSyncDelayedTask(UltimateTimber.getInstance(), () -> timeout.remove(below.getLocation()), 20 * 5);
}
Bukkit.getScheduler().scheduleSyncDelayedTask(UltimateTimber.getInstance(), () -> performReplacement(below, material), 1);
}
}
if (!isValidGround(belowType)) {
block.setType(Material.AIR);
return;
}
if (isTimeout) {
timeout.add(block.getLocation());
Bukkit.getScheduler().scheduleSyncDelayedTask(UltimateTimber.getInstance(), () -> timeout.remove(block.getLocation()), 20 * 5);
}
Bukkit.getScheduler().scheduleSyncDelayedTask(UltimateTimber.getInstance(), () -> performReplacement(block, material), 1);
}
static void performReplacement(Block block, Material material) {
switch (material) {
case ACACIA_LOG:
case STRIPPED_ACACIA_LOG:
block.setType(Material.ACACIA_SAPLING);
return;
case BIRCH_LOG:
case STRIPPED_BIRCH_LOG:
block.setType(Material.BIRCH_SAPLING);
return;
case DARK_OAK_LOG:
case STRIPPED_DARK_OAK_LOG:
block.setType(Material.DARK_OAK_SAPLING);
return;
case JUNGLE_LOG:
case STRIPPED_JUNGLE_LOG:
block.setType(Material.JUNGLE_SAPLING);
return;
case OAK_LOG:
case STRIPPED_OAK_LOG:
block.setType(Material.OAK_SAPLING);
return;
case SPRUCE_LOG:
case STRIPPED_SPRUCE_LOG:
block.setType(Material.SPRUCE_SAPLING);
return;
case BROWN_MUSHROOM_BLOCK:
block.setType(Material.BROWN_MUSHROOM);
return;
case RED_MUSHROOM_BLOCK:
block.setType(Material.RED_MUSHROOM);
return;
default:
block.setType(Material.AIR);
}
}
static void leafFallReplant(FallingBlock fallingBlock) {
Material material;
switch (fallingBlock.getBlockData().getMaterial()) {
case ACACIA_LEAVES:
material = Material.ACACIA_SAPLING;
break;
case BIRCH_LEAVES:
material = Material.BIRCH_SAPLING;
break;
case DARK_OAK_LEAVES:
material = Material.DARK_OAK_SAPLING;
break;
case JUNGLE_LEAVES:
material = Material.JUNGLE_SAPLING;
break;
case OAK_LEAVES:
material = Material.OAK_SAPLING;
break;
case SPRUCE_LEAVES:
material = Material.SPRUCE_SAPLING;
break;
default:
material = null;
}
if (material == null) return;
if (ThreadLocalRandom.current().nextDouble() > 0.01) return;
Block block = fallingBlock.getLocation().clone().subtract(new Vector(0, 1, 0)).getBlock();
if (isValidGround(block.getType())) {
Block blockAbove = block.getLocation().clone().add(new Vector(0, 1, 0)).getBlock();
if (blockAbove.getType().equals(Material.AIR))
fallingBlock.getLocation().getBlock().setType(material);
}
}
static boolean isTimeout(Block block) {
return timeout.contains(block.getLocation());
}
private static boolean isValidGround(Material material) {
return material.equals(Material.DIRT) || material.equals(Material.COARSE_DIRT) || material.equals(Material.PODZOL) || material.equals(Material.GRASS_BLOCK);
}
}

35
UltimateTimber/Plugin/src/main/java/com/songoda/ultimatetimber/old_code/TreeSounds.java
View File

@ -1,35 +0,0 @@
package com.songoda.ultimatetimber.old_code;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Sound;
import org.bukkit.entity.FallingBlock;
class TreeSounds {
static void tipOverNoise(Location location) {
if (Bukkit.getServer().getClass().getPackage().toString().contains("8")) {
location.getWorld().playSound(location, Sound.valueOf("CHEST_OPEN"), 3f, 0.1f);
} else {
location.getWorld().playSound(location, Sound.BLOCK_CHEST_OPEN, 3F, 0.1F);
}
}
static void fallNoise(FallingBlock fallingBlock) {
if (Bukkit.getServer().getClass().getPackage().toString().contains("8")) {
fallingBlock.getWorld().playSound(fallingBlock.getLocation(), Sound.valueOf("ANVIL_LAND"), 3F, 0.1F);
return;
}
if (fallingBlock.getTicksLived() < 20)
fallingBlock.getWorld().playSound(fallingBlock.getLocation(), Sound.BLOCK_ANVIL_FALL, 3F, 0.1F);
else
fallingBlock.getWorld().playSound(fallingBlock.getLocation(), Sound.BLOCK_WOOD_FALL, 3F, 0.1F);
}
}

94
pom-old.xml
View File

@ -1,94 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>ultimatetimber</groupId>
<artifactId>UltimateTimber</artifactId>
<version>maven-version-number</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<build>
<finalName>UltimateTimber-${project.version}</finalName>
<defaultGoal>clean resources:resources package</defaultGoal>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.6.2</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
<plugin>
<groupId>com.google.code.maven-replacer-plugin</groupId>
<artifactId>replacer</artifactId>
<version>1.5.3</version>
<executions>
<execution>
<phase>prepare-package</phase>
<goals>
<goal>replace</goal>
</goals>
</execution>
</executions>
<configuration>
<file>${project.build.directory}/classes/plugin.yml</file>
<replacements>
<replacement>
<token>maven-version-number</token>
<value>${project.version}</value>
</replacement>
</replacements>
</configuration>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spigot-repo</id>
<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
</repository>
<repository>
<id>songoda-repo</id>
<url>http://repo.songoda.com/artifactory/private</url>
</repository>
</repositories>
<dependencies>
<!--Spigot API-->
<dependency>
<groupId>org.spigotmc</groupId>
<artifactId>spigot-api</artifactId>
<version>1.13-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<!--Bukkit API-->
<dependency>
<groupId>org.bukkit</groupId>
<artifactId>bukkit</artifactId>
<version>1.13-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<!--mcMMO-->
<dependency>
<groupId>com.gmail.nossr50</groupId>
<artifactId>mcmmo</artifactId>
<version>1.5.09</version>
<scope>provided</scope>
</dependency>
<!--Jobs Reborn-->
<dependency>
<groupId>com.gamingmesh</groupId>
<artifactId>jobs</artifactId>
<version>4.6.0</version>
<scope>provided</scope>
</dependency>
</dependencies>
</project>

38
pom.xml
View File

@ -5,40 +5,36 @@
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<groupId>com.songoda.ultimatetimber</groupId> <groupId>com.songoda.ultimatetimber</groupId>
<artifactId>UltimateTimber</artifactId> <artifactId>UltimateTimber-Parent</artifactId>
<packaging>pom</packaging> <packaging>pom</packaging>
<version>maven-version-number</version> <version>maven-version-number</version>
<modules> <modules>
<module>UltimateTimber/Core</module>
<module>UltimateTimber-Adapter/Current</module> <module>UltimateTimber-Adapter/Current</module>
<module>UltimateTimber-Adapter/Legacy</module> <module>UltimateTimber-Adapter/Legacy</module>
<module>UltimateTimber/Core</module>
<module>UltimateTimber/Plugin</module> <module>UltimateTimber/Plugin</module>
</modules> </modules>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<build>
<defaultGoal>clean install</defaultGoal>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.6.2</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
<repositories> <repositories>
<repository> <repository>
<id>songoda-repo</id> <id>songoda-repo</id>
<url>http://repo.songoda.com/artifactory/private</url> <url>http://repo.songoda.com/artifactory/private</url>
</repository> </repository>
</repositories> </repositories>
<build>
<defaultGoal>clean install</defaultGoal>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project> </project>