Initial commit

This commit is contained in:
Scifi9902
2026-10-12 13:57:05 -03:00
commit 4bde3b176a
2576 changed files with 212659 additions and 0 deletions
+71
View File
@@ -0,0 +1,71 @@
<?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">
<parent>
<artifactId>ProjectCranked</artifactId>
<groupId>net.crankedpvp</groupId>
<version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>Enchants</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<artifactId>Utils</artifactId>
<groupId>net.crankedpvp</groupId>
</dependency>
<dependency>
<groupId>com.massivecraft</groupId>
<artifactId>Factions</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Masks</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Pets</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Bosses</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Armor</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>StarItems</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>AdminWeapons</artifactId>
</dependency>
<dependency>
<groupId>coreprotect</groupId>
<artifactId>coreprotect</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/../.lib/CoreProtect_2.12.0.jar</systemPath>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Staff</artifactId>
</dependency>
<dependency>
<groupId>com.earth2me.essentials</groupId>
<artifactId>EssentialsX</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/../.lib/EssentialsX-2.19.7.jar</systemPath>
</dependency>
</dependencies>
</project>
@@ -0,0 +1,105 @@
package net.crankedpvp.crankedenchants;
import lombok.Getter;
import me.mattstudios.mf.base.CommandManager;
import me.mattstudios.mf.base.components.TypeResult;
import net.crankedpvp.crankedenchants.commands.*;
import net.crankedpvp.crankedenchants.language.LanguageHandler;
import net.crankedpvp.crankedenchants.listeners.*;
import net.crankedpvp.crankedenchants.struct.EnchantRegister;
import net.crankedpvp.crankedenchants.struct.config.ConfigManager;
import net.crankedpvp.crankedenchants.struct.config.EnchantConfigManager;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.items.OrbBuilder;
import net.crankedpvp.crankedenchants.struct.souls.SoulManager;
import net.crankedpvp.crankedenchants.tasks.SoulDrainTask;
import org.bukkit.Bukkit;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;
import java.util.Locale;
import java.util.stream.Collectors;
@Getter
public class CrankedEnchants extends JavaPlugin {
@Getter
private static CrankedEnchants instance;
private EnchantRegister enchantRegister;
private CommandManager commandManager;
private EnchantConfigManager enchantConfigManager;
private SoulManager soulManager;
private LanguageHandler languageHandler;
private ConfigManager configManager;
@Override
public void onEnable() {
instance = this;
this.languageHandler = new LanguageHandler(this);
this.languageHandler.load();
this.soulManager = new SoulManager();
this.enchantRegister = new EnchantRegister(this);
this.enchantRegister.initialize();
this.configManager = new ConfigManager(this);
this.configManager.setupFiles();
this.commandManager = new CommandManager(this);
this.registerListeners();
new SoulDrainTask(this).runTaskTimer(this, 0L, 10L);
//So it runs after all plugins are loaded cause I register enchants in other plugins too
Bukkit.getScheduler().runTask(this, () -> {
this.enchantConfigManager = new EnchantConfigManager(this);
this.enchantConfigManager.setupFiles();
this.registerCommandParameters();
this.registerCommandCompletion();
this.commandManager.register(new AdminEnchantsCommand(this), new EnchantsCommand(), new EnchanterCommand(), new ApplyCommand(), new SplitSoulsCommand(), new WithdrawSoulsCommand(), new DupeCommand(this));
});
}
@Override
public void onDisable() {
instance = null;
}
private void registerCommandParameters() {
this.commandManager.getParameterHandler().register(Enchantment.class, argument -> {
Enchantment enchantment = this.enchantRegister.getEnchantmentFromID(String.valueOf(argument).toLowerCase(Locale.ROOT));
return new TypeResult(enchantment, argument);
});
this.commandManager.getParameterHandler().register(EnchantTier.class, argument -> {
EnchantTier enchantTier = EnchantTier.valueOf(String.valueOf(argument).toUpperCase());
return new TypeResult(enchantTier, argument);
});
this.commandManager.getParameterHandler().register(OrbBuilder.OrbType.class, argument -> {
OrbBuilder.OrbType orbType = OrbBuilder.OrbType.valueOf(String.valueOf(argument).toUpperCase());
return new TypeResult(orbType, argument);
});
}
private void registerCommandCompletion() {
this.commandManager.getCompletionHandler().register("#enchants", input -> this.enchantRegister.getEnchantments().stream().map(Enchantment::getID).collect(Collectors.toList()));
}
private void registerListeners() {
PluginManager pm = Bukkit.getPluginManager();
pm.registerEvents(new BookListeners(this), this);
pm.registerEvents(new EnchantmentListener(), this);
pm.registerEvents(new ItemListener(this), this);
pm.registerEvents(new SoulListener(this), this);
pm.registerEvents(new ArmorSwapListener(this), this);
pm.registerEvents(new TinkererListeners(), this);
}
}
@@ -0,0 +1,354 @@
package net.crankedpvp.crankedenchants;
import net.crankedpvp.crankedenchants.events.EnchantProcEvent;
import net.crankedpvp.crankedenchants.events.EnchantProcOnEquipEvent;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.cache.EnchantmentCache;
import net.crankedpvp.crankedenchants.struct.cache.WeaponEnchantCache;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorEquipEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedutils.utils.NbtWrapper;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import net.crankedpvp.crankedenchants.struct.NbtTags;
import net.crankedpvp.crankedutils.utils.cache.CacheManager;
import de.tr7zw.nbtapi.NBTItem;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.jetbrains.annotations.NotNull;
import java.util.Locale;
import java.util.Set;
import static net.crankedpvp.crankedenchants.struct.NbtTags.ENCHANTS_TAG;
public class CrankedEnchantsAPI {
public static boolean isRandomEnchantBook(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.BOOK) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.BOOK_DATA_STRING);
}
public static boolean itemHasEnchantment(ItemStack itemStack, @NotNull String enchantment) {
if (ItemUtils.isAirOrNull(itemStack)) return false;
return NbtWrapper.hasKeyInCompound(itemStack, ENCHANTS_TAG, enchantment);
}
public static boolean itemHasEnchantment(ItemStack itemStack, @NotNull Enchantment enchantment) {
return itemHasEnchantment(itemStack, enchantment.getID());
}
public static int getEnchantmentLevelFromItem(@NotNull ItemStack itemStack, @NotNull String enchantment) {
return NbtWrapper.getIntegerFromCompound(itemStack, ENCHANTS_TAG, enchantment);
}
public static int getEnchantmentLevelFromItem(@NotNull ItemStack itemStack, @NotNull Enchantment enchantment) {
return getEnchantmentLevelFromItem(itemStack, enchantment.getID());
}
public static EnchantTier getRandomEnchantBookTier(ItemStack itemStack) {
NBTItem nbtItem = new NBTItem(itemStack);
return EnchantTier.valueOf(nbtItem.getString(NbtTags.BOOK_TIER_DATA_STRING).toUpperCase(Locale.ROOT));
}
public static boolean isCustomItem(ItemStack itemStack) {
if (itemStack == null) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return (nbtItem.hasKey(NbtTags.DATA_STRING));
}
public static boolean isEnchantBook(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.BOOK) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.ENCHANT_BOOK_DATA_STRING);
}
public static boolean isSoulTracker(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.PAPER) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.SOUL_TRACKER_DATA_STRING);
}
public static boolean isSecretDust(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.FIREBALL) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.SECRET_DUST_DATA_STRING);
}
public static boolean isEnchantmentOrb(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.EYE_OF_ENDER) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.ORB_DATA_STRING);
}
public static boolean isSoulGem(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.EMERALD) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.SOUL_GEM_DATA_STRING);
}
public static boolean isDust(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.SUGAR && itemStack.getType() != Material.GLOWSTONE_DUST) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.DUST_DATA_STRING);
}
public static boolean isInfernalDust(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.REDSTONE) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.INFERNAL_DUST_DATA_STRING);
}
public static boolean isBlackScroll(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.INK_SACK) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.BLACK_SCROLL_DATA_STRING);
}
public static boolean isHeroicBlackScroll(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.INK_SACK) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.HEROIC_BLACK_SCROLL_DATA_STRING);
}
public static boolean isOmniBlackScroll(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.INK_SACK) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.OMNI_BLACK_SCROLL_DATA_STRING);
}
public static boolean isWhiteScroll(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.EMPTY_MAP) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.WHITE_SCROLL_DATA_STRING);
}
public static boolean isTransmogScroll(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.PAPER) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.TRANSMOG_SCROLL_DATA_STRING);
}
public static boolean isRandomizationScroll(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.PAPER) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.RANDOMIZATION_SCROLL_DATA_STRING);
}
public static boolean isSoulPearl(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.ENDER_PEARL) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.SOUL_PEARL_DATA_STRING);
}
public static boolean isRenameTag(ItemStack itemStack) {
if (itemStack == null) return false;
if (itemStack.getType() != Material.NAME_TAG) return false;
NBTItem nbtItem = new NBTItem(itemStack);
return nbtItem.getString(NbtTags.DATA_STRING).equals(NbtTags.RENAME_TAG_DATA_STRING);
}
public static Set<Enchantment> getEnchantments(Player player) {
EnchantmentCache enchantmentCache = getEnchantCache(player);
return enchantmentCache.getEnchants();
}
public static void addEnchantmentToPlayer(Player player, Enchantment enchantment, int level) {
EnchantmentCache enchantmentCache = getEnchantCache(player);
enchantmentCache.addEnchantment(enchantment, level);
}
public static void removeEnchantmentFromPlayer(Player player, Enchantment enchantment, int level) {
EnchantmentCache enchantmentCache = getEnchantCache(player);
enchantmentCache.removeEnchantment(enchantment, level);
}
public static boolean hasEnchantment(Player player, Enchantment enchantment) {
EnchantmentCache enchantmentCache = getEnchantCache(player);
return enchantmentCache.hasEnchantment(enchantment);
}
public static boolean hasEnchantment(Player player, String enchantmentID) {
EnchantmentCache enchantmentCache = getEnchantCache(player);
return enchantmentCache.hasEnchantment(enchantmentID);
}
public static Integer getEnchantmentLevel(Player player, Enchantment enchantment) {
EnchantmentCache enchantmentCache = getEnchantCache(player);
return enchantmentCache.getEnchantInfo(enchantment).getLevel();
}
public static Integer getEnchantmentLevel(Player player, String enchantmentID) {
EnchantmentCache enchantmentCache = getEnchantCache(player);
return enchantmentCache.getEnchantInfo(enchantmentID).getLevel();
}
public static Integer getEnchantmentAmount(Player player, Enchantment enchantment) {
EnchantmentCache enchantmentCache = getEnchantCache(player);
return enchantmentCache.getEnchantInfo(enchantment).getAmount();
}
public static Integer getEnchantmentAmount(Player player, String enchantmentID) {
EnchantmentCache enchantmentCache = getEnchantCache(player);
return enchantmentCache.getEnchantInfo(enchantmentID).getAmount();
}
public static EnchantInfo getEnchantmentInfo(Player player, Enchantment enchantment) {
EnchantmentCache enchantmentCache = getEnchantCache(player);
return enchantmentCache.getEnchantInfo(enchantment);
}
public static EnchantInfo getEnchantmentInfo(Player player, String enchantmentID) {
EnchantmentCache enchantmentCache = getEnchantCache(player);
return enchantmentCache.getEnchantInfo(enchantmentID);
}
private static EnchantmentCache getEnchantCache(Player player) {
EnchantmentCache enchantmentCache = (EnchantmentCache) CacheManager.getInstance().getCachedPlayer(player).getCache(NbtTags.ENCHANTMENT_CACHE_ID);
if (enchantmentCache == null) {
enchantmentCache = (EnchantmentCache) CacheManager.getInstance().getCachedPlayer(player).registerCache(new EnchantmentCache());
}
return enchantmentCache;
}
public static void clearEnchantsFromCache(Player player) {
EnchantmentCache enchantmentCache = getEnchantCache(player);
enchantmentCache.clearEnchantments();
}
public static void clearEnchantsFromCacheFromOneArmorItem(Player player, ItemStack itemStack) {
if (!ItemUtils.isArmor(itemStack)) return;
EnchantmentCache enchantmentCache = getEnchantCache(player);
EnchantedItemBuilder enchantedItemBuilder = new EnchantedItemBuilder(itemStack);
enchantedItemBuilder.getEnchantments().forEach((enchantment, level) -> {
enchantmentCache.removeEnchantment(enchantment, level);
if (enchantment instanceof ArmorEquipEventEnchant) {
ArmorEquipEventEnchant equipEventEnchant = ((ArmorEquipEventEnchant) enchantment);
equipEventEnchant.runArmorUnEquipEvent(player, level);
}
});
}
public static void reprocEnchants(Player player) {
if (player == null || player.isDead()) return;
clearEnchantsFromCache(player);
PotionEffectUtils.clearPlayerEffects(player);
for (ItemStack itemStack : player.getInventory().getArmorContents()) {
if (!ItemUtils.isEnchantable(itemStack)) continue;
EnchantedItemBuilder enchantedItemBuilder = new EnchantedItemBuilder(itemStack);
enchantedItemBuilder.getEnchantments().forEach((enchant, level) -> {
if (enchant instanceof ArmorEquipEventEnchant) {
EnchantProcEvent procEvent = new EnchantProcOnEquipEvent(player, enchant, level);
Bukkit.getPluginManager().callEvent(procEvent);
if(procEvent.isCancelled()) return;
((ArmorEquipEventEnchant) enchant).runArmorEquipEvent(player, level);
}
addEnchantmentToPlayer(player, enchant, level);
});
}
}
public static void reprocEnchantsFromOneArmorItem(Player player, ItemStack itemStack) {
if (player == null || player.isDead()) return;
EnchantedItemBuilder enchantedItemBuilder = new EnchantedItemBuilder(itemStack);
enchantedItemBuilder.getEnchantments().forEach((enchant, level) -> {
if (enchant instanceof ArmorEquipEventEnchant) {
EnchantProcEvent procEvent = new EnchantProcOnEquipEvent(player, enchant, level);
Bukkit.getPluginManager().callEvent(procEvent);
if(procEvent.isCancelled()) return;
((ArmorEquipEventEnchant) enchant).runArmorEquipEvent(player, level);
}
addEnchantmentToPlayer(player, enchant, level);
});
}
public static WeaponEnchantCache getWeaponEnchantCache(Player player) {
WeaponEnchantCache enchantmentCache = (WeaponEnchantCache) CacheManager.getInstance().getCachedPlayer(player).getCache(NbtTags.WEAPON_ENCHANTMENT_CACHE_ID);
if (enchantmentCache == null) {
enchantmentCache = (WeaponEnchantCache) CacheManager.getInstance().getCachedPlayer(player).registerCache(new WeaponEnchantCache());
}
return enchantmentCache;
}
public static Set<Enchantment> getWeaponEnchantments(Player player) {
WeaponEnchantCache enchantmentCache = getWeaponEnchantCache(player);
return enchantmentCache.getEnchants();
}
public static void addWeaponEnchantmentToPlayer(Player player, Enchantment enchantment, int level) {
WeaponEnchantCache enchantmentCache = getWeaponEnchantCache(player);
enchantmentCache.addEnchantment(enchantment, level);
}
public static void removeEnchantmentFromPlayer(Player player, Enchantment enchantment) {
WeaponEnchantCache enchantmentCache = getWeaponEnchantCache(player);
enchantmentCache.removeEnchantment(enchantment);
}
public static boolean hasWeaponEnchantment(Player player, Enchantment enchantment) {
WeaponEnchantCache enchantmentCache = getWeaponEnchantCache(player);
return enchantmentCache.hasEnchantment(enchantment);
}
public static boolean hasWeaponEnchantment(Player player, String enchantmentID) {
WeaponEnchantCache enchantmentCache = getWeaponEnchantCache(player);
return enchantmentCache.hasEnchantment(enchantmentID);
}
public static Integer getWeaponEnchantmentLevel(Player player, Enchantment enchantment) {
WeaponEnchantCache enchantmentCache = getWeaponEnchantCache(player);
return enchantmentCache.getEnchantLevel(enchantment);
}
public static int getWeaponSlot(Player player) {
return getWeaponEnchantCache(player).getSwordSlot();
}
public static Integer getWeaponEnchantmentLevel(Player player, String enchantmentID) {
WeaponEnchantCache enchantmentCache = getWeaponEnchantCache(player);
return enchantmentCache.getEnchantLevel(enchantmentID);
}
public static void cacheWeaponEnchants(Player player, EnchantedItemBuilder enchantedItemBuilder) {
WeaponEnchantCache enchantmentCache = getWeaponEnchantCache(player);
enchantmentCache.clearEnchantments();
enchantedItemBuilder.getEnchantments().forEach(enchantmentCache::addEnchantment);
enchantmentCache.setSwordSlot(player.getInventory().getHeldItemSlot());
enchantmentCache.updateTime();
}
public static void cacheWeaponEnchants(Player player, ItemStack itemStack) {
WeaponEnchantCache enchantmentCache = getWeaponEnchantCache(player);
enchantmentCache.clearEnchantments();
for (String enchantID : NbtWrapper.getKeysFromCompound(itemStack, ENCHANTS_TAG)) {
enchantmentCache.addEnchantment(enchantID, NbtWrapper.getIntegerFromCompound(itemStack, ENCHANTS_TAG, enchantID));
}
enchantmentCache.setSwordSlot(player.getInventory().getHeldItemSlot());
enchantmentCache.updateTime();
}
}
@@ -0,0 +1,473 @@
package net.crankedpvp.crankedenchants.commands;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
import net.crankedpvp.crankedenchants.inventories.EnchanterUI;
import net.crankedpvp.crankedenchants.language.Language;
import net.crankedpvp.crankedenchants.language.LanguageHandler;
import net.crankedpvp.crankedenchants.struct.cache.SoulTrackerCache;
import net.crankedpvp.crankedenchants.struct.config.ConfigManager;
import net.crankedpvp.crankedenchants.struct.config.EnchantConfigManager;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.items.*;
import net.crankedpvp.crankedenchants.utils.CacheUtils;
import me.mattstudios.mf.annotations.*;
import net.crankedpvp.crankedutils.utils.InventoryUtils;
import net.crankedpvp.crankedutils.utils.TimeUtils;
import me.mattstudios.mf.base.CommandBase;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import xyz.xenondevs.particle.ParticleBuilder;
import xyz.xenondevs.particle.ParticleEffect;
import xyz.xenondevs.particle.data.texture.BlockTexture;
@Command("ce")
public class AdminEnchantsCommand extends CommandBase {
private final ConfigManager configManager;
private final EnchantConfigManager enchantConfigManager;
private final LanguageHandler languageHandler;
public AdminEnchantsCommand(CrankedEnchants plugin) {
this.enchantConfigManager = plugin.getEnchantConfigManager();
this.languageHandler = plugin.getLanguageHandler();
this.configManager = plugin.getConfigManager();
}
@Default
public void mainCommand(CommandSender sender) {
if (sender instanceof Player) {
Player player = (Player) sender;
if (player.hasPermission("cranked.admin")) {
Language.NE_COMMAND_HELP.send(sender);
return;
}
EnchanterUI enchanterUI = new EnchanterUI();
enchanterUI.getEnchantersUI().open(player);
return;
}
Language.NE_COMMAND_HELP.send(sender);
}
@SubCommand("book")
@WrongUsage("&cUsage: /ce book <enchant> <level> [player]")
@Permission("cranked.admin")
public void bookCommand(CommandSender sender, @Completion("#enchants") Enchantment enchantment, Integer level, @Completion("#players") @Optional Player player) {
if (enchantment == null) {
Language.INVALID_ENCHANTMENT_NAME.send(sender);
return;
}
if (level == null || level < 1 || level > enchantment.getMax()) {
Language.INVALID_ENCHANTMENT_LEVEL.send(sender, s -> s.replace("{max}", String.valueOf(enchantment.getMax())));
return;
}
ItemStack itemStack = new BookBuilder(enchantment, level)
.setSuccessRate(100)
.setDestroyRate(0)
.build();
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("dust")
@WrongUsage("&cUsage: /ce dust <tier> <percent> [player]")
@Permission("cranked.admin")
public void dustCommand(CommandSender sender, @Completion("#enum") EnchantTier tier, @Completion("#range:1-15") Integer percent, @Completion("#players") @Optional Player player) {
if (tier == null) {
return;
}
ItemStack itemStack = new DustBuilder(tier, percent).build();
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("idust")
@WrongUsage("&cUsage: /ce idust <tier> [player]")
@Permission("cranked.admin")
public void infernalDustCommand(CommandSender sender, @Completion("#enum") EnchantTier tier, @Completion("#players") @Optional Player player) {
if (tier == null) {
return;
}
ItemStack itemStack = new InfernalDustBuilder(tier).build();
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("omniblackscroll")
@Alias("obscroll")
@WrongUsage("&cUsage: /ce omniblackscroll <percent> [player]")
@Permission("cranked.admin")
public void omniBlackScrollCommand(CommandSender sender, @Completion("#range:1-100") Integer percent, @Completion("#players") @Optional Player player) {
ItemStack itemStack = new OmniBlackScrollBuilder(percent).build();
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("blackscroll")
@Alias("bscroll")
@WrongUsage("&cUsage: /ce blackscroll <percent> [player]")
@Permission("cranked.admin")
public void blackScrollCommand(CommandSender sender, @Completion("#range:1-100") Integer percent, @Completion("#players") @Optional Player player) {
ItemStack itemStack = new BlackScrollBuilder(percent).build();
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("heroicblackscroll")
@Alias({"hbscroll", "hblackscroll", "heroicbs", "heroicbscroll"})
@WrongUsage("&cUsage: /ce heroicbs <percent> [player]")
@Permission("cranked.admin")
public void heroicBlackScrollCommand(CommandSender sender, @Completion("#range:1-100") Integer percent, @Completion("#players") @Optional Player player) {
ItemStack itemStack = new HeroicBlackScrollBuilder(percent).build();
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("soulgem")
@Alias("sgem")
@WrongUsage("&cUsage: /ce soulgem <souls> [player]")
@Permission("cranked.admin")
public void soulGemCommand(CommandSender sender, Integer souls, @Completion("#players") @Optional Player player) {
ItemStack itemStack = new SoulGemBuilder(souls).build();
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("orb")
@Alias("eorb")
@WrongUsage("&cUsage: /ce orb <slots> <success> <type> [player]")
@Permission("cranked.admin")
public void orbCommand(CommandSender sender, @Completion("#range:10-16") Integer slots, @Completion("#range:1-100") Integer success, @Completion("#enum") OrbBuilder.OrbType type, @Completion("#players") @Optional Player player) {
ItemStack itemStack = new OrbBuilder(type, slots, success).build();
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("whitescroll")
@Alias("wscroll")
@WrongUsage("&cUsage: /ce whitescroll <amount> [player]")
@Permission("cranked.admin")
public void whiteScrollCommand(CommandSender sender, @Completion("#range:1-64") Integer amount, @Completion("#players") @Optional Player player) {
ItemStack itemStack = new WhiteScrollBuilder().build();
itemStack.setAmount(amount);
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("transmogscroll")
@Alias({"tscroll", "transmog"})
@WrongUsage("&cUsage: /ce transmogscroll <amount> [player]")
@Permission("cranked.admin")
public void transmogScrollCommand(CommandSender sender, @Completion("#range:1-64") Integer amount, @Completion("#players") @Optional Player player) {
ItemStack itemStack = new TransmogScrollBuilder().build();
itemStack.setAmount(amount);
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("randomizationscroll")
@Alias({"rscroll"})
@WrongUsage("&cUsage: /ce randomizationscroll <amount> <tier> [player]")
@Permission("cranked.admin")
public void randomizationScrollCommand(CommandSender sender, @Completion("#range:1-64") Integer amount, @Completion("#enum") EnchantTier tier, @Completion("#players") @Optional Player player) {
if (tier == null) {
return;
}
ItemStack itemStack = new RandomizationScrollBuilder(tier).build();
itemStack.setAmount(amount);
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("nametag")
@Alias("renametag")
@WrongUsage("&cUsage: /ce nametag <amount> [player]")
@Permission("cranked.admin")
public void renameTagCommand(CommandSender sender, @Completion("#range:1-64") Integer amount, @Completion("#players") @Optional Player player) {
ItemStack itemStack = new ItemRenameTagBuilder().build();
itemStack.setAmount(amount);
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("soulpearl")
@WrongUsage("&cUsage: /ce soulpearl <amount> [player]")
@Permission("cranked.admin")
public void soulPearlCommand(CommandSender sender, @Completion("#range:1-64") Integer amount, @Completion("#players") @Optional Player player) {
ItemStack itemStack = new SoulPearlBuilder().build();
itemStack.setAmount(amount);
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("soultracker")
@WrongUsage("&cUsage: /ce soultracker <amount> <tier> [player]")
@Permission("cranked.admin")
public void soulTrackerCommand(CommandSender sender, @Completion("#range:1-64") Integer amount, @Completion("#enum") EnchantTier tier, @Completion("#players") @Optional Player player) {
if (tier == null) {
return;
}
ItemStack itemStack = new SoulTrackerBuilder(tier).build();
itemStack.setAmount(amount);
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("rbook")
@Alias({"randombook", "randbook"})
@WrongUsage("&cUsage: /ce rbook <tier> <amount> [player]")
@Permission("cranked.admin")
public void randomBookCommand(CommandSender sender, @Completion("#enum") EnchantTier tier, Integer amount, @Optional Player player) {
if (amount == null) {
amount = 1;
}
if (tier == null) {
return;
}
ItemStack itemStack = EnchantTier.createMysteryBook(tier, amount);
if (player != null) {
player.getInventory().addItem(itemStack);
return;
}
if (sender instanceof Player) {
InventoryUtils.giveItemToPlayer(((Player) sender), itemStack);
}
}
@SubCommand("enchant")
@Alias({"addenchant", "addenchantment"})
@WrongUsage("&cUsage: /ce enchant <enchant> [level]")
@Permission("cranked.admin")
public void enchantCommand(Player sender, @Completion("#enchants") Enchantment enchantment, @Optional Integer level) {
if (enchantment == null) {
Language.INVALID_ENCHANTMENT_NAME.send(sender);
return;
}
if (level == null) {
level = enchantment.getMax();
}
if (level < 1) { // || level > enchantment.getMax()
Language.INVALID_ENCHANTMENT_LEVEL.send(sender, s -> s.replace("{max}", String.valueOf(enchantment.getMax())));
return;
}
if (sender.getItemInHand() == null || sender.getItemInHand().getType() == Material.AIR) {
Language.EMPTY_HAND.send(sender);
return;
}
EnchantedItemBuilder enchantedItemBuilder = new EnchantedItemBuilder(sender.getItemInHand());
if (enchantedItemBuilder.hasEnchantment(enchantment)) {
enchantedItemBuilder.removeEnchantment(enchantment);
}
enchantedItemBuilder.addEnchantment(enchantment, level);
sender.setItemInHand(enchantedItemBuilder.build());
sender.updateInventory();
}
@SubCommand("unenchant")
@Alias({"removeenchant", "removeenchantment", "deenchant"})
@WrongUsage("&cUsage: /ce unenchant <enchant>")
@Permission("cranked.admin")
public void unenchantCommand(Player sender, @Completion("#enchants") Enchantment enchantment) {
if (sender.getItemInHand() == null || sender.getItemInHand().getType() == Material.AIR) {
Language.EMPTY_HAND.send(sender);
return;
}
EnchantedItemBuilder enchantedItemBuilder = new EnchantedItemBuilder(sender.getItemInHand());
if (!enchantedItemBuilder.hasEnchantment(enchantment)) {
return;
}
enchantedItemBuilder.removeEnchantment(enchantment);
sender.setItemInHand(enchantedItemBuilder.build());
sender.updateInventory();
}
@SubCommand("reload")
@Permission("cranked.admin")
public void reloadCommand(Player sender) {
Language.ADMIN_RELOADING.send(sender);
long then = System.currentTimeMillis();
this.configManager.reloadFiles();
this.languageHandler.load();
this.enchantConfigManager.reloadFiles();
long diff = System.currentTimeMillis() - then;
Language.ADMIN_RELOADED.send(sender, str -> str.replace("%took%", String.valueOf(diff)));
}
@SubCommand("debug")
@Permission("cranked.admin")
public void debugCommand(Player sender) {
for (Enchantment enchantment : CrankedEnchantsAPI.getEnchantments(sender)) {
System.out.println(enchantment.getName());
}
}
@SubCommand("particle")
@Permission("cranked.admin")
public void particleCommand(Player sender) {
ParticleBuilder particle1 = new ParticleBuilder(ParticleEffect.BLOCK_DUST)
.setParticleData(new BlockTexture(Material.DIAMOND_BLOCK))
.setAmount(100)
.setOffsetY(1)
.setSpeed(0.15f);
particle1.setLocation(sender.getLocation()).display(sender);
SoulTrackerCache soulTrackerCache = CacheUtils.getSoulTrackerCache(sender);
if (soulTrackerCache.isOnHarvestCooldown(sender)) {
Language.SOUL_HARVEST_COOLDOWN.send(sender, str -> str
.replace("{player}", sender.getName())
.replace("{time}", TimeUtils.formatSeconds(soulTrackerCache.getSecondsLeftOnHarvestCooldown(sender)))
);
return;
}
soulTrackerCache.addHarvestCooldown(sender);
}
@SubCommand("test")
@Permission("cranked.admin")
public void testCommand(Player sender) {
ItemStack itemStack = sender.getItemInHand();
System.out.println(CrankedEnchantsAPI.itemHasEnchantment(itemStack, "gears"));
System.out.println("level: " + CrankedEnchantsAPI.getEnchantmentLevelFromItem(itemStack, "gears"));
}
}
@@ -0,0 +1,18 @@
package net.crankedpvp.crankedenchants.commands;
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
import me.mattstudios.mf.annotations.Alias;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.base.CommandBase;
import org.bukkit.entity.Player;
@Command("apply")
@Alias("reapply")
public class ApplyCommand extends CommandBase {
@Default
public void mainCommand(Player sender) {
CrankedEnchantsAPI.reprocEnchants(sender);
}
}
@@ -0,0 +1,68 @@
package net.crankedpvp.crankedenchants.commands;
import me.mattstudios.mf.annotations.Alias;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
import net.crankedpvp.crankedenchants.language.Language;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.items.BookBuilder;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.Arrays;
import java.util.List;
@Command("dupe")
@Alias("duplicate")
public class DupeCommand extends CommandBase {
private final List<EnchantTier> blockedTiers = Arrays.asList(
EnchantTier.HEROIC, EnchantTier.CURSED, EnchantTier.UNDERWORLD
);
private CrankedEnchants plugin;
public DupeCommand(CrankedEnchants plugin) {
this.plugin = plugin;
}
@Default
public void defaultCommand(final Player player) {
ItemStack itemStack = player.getItemInHand();
if(!(CrankedEnchantsAPI.isRandomEnchantBook(itemStack) || CrankedEnchantsAPI.isEnchantBook(itemStack))) {
Language.CANNOT_DUPE_ITEM.send(player);
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0f, 2.0f);
return;
}
EnchantTier enchantTier = null;
if (CrankedEnchantsAPI.isRandomEnchantBook(itemStack)) {
enchantTier = CrankedEnchantsAPI.getRandomEnchantBookTier(itemStack);
}
if (CrankedEnchantsAPI.isEnchantBook(itemStack)) {
enchantTier = new BookBuilder(itemStack).getBookEnchantment().getTier();
}
if (blockedTiers.contains(enchantTier)) {
Language.CANNOT_DUPE_TIER.send(player);
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0f, 2.0f);
return;
}
if (itemStack.getAmount() >= 64) {
Language.CANNOT_DUPE_MORE.send(player);
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0f, 2.0f);
return;
}
itemStack.setAmount(64);
player.setItemInHand(itemStack);
Language.DUPED_ITEM.send(player);
player.playSound(player.getLocation(), Sound.LEVEL_UP, 2.0f, 2.0f);
}
}
@@ -0,0 +1,17 @@
package net.crankedpvp.crankedenchants.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedenchants.inventories.EnchanterUI;
import org.bukkit.entity.Player;
@Command("enchanter")
public class EnchanterCommand extends CommandBase {
@Default
public void mainCommand(Player sender) {
EnchanterUI enchanterUI = new EnchanterUI();
enchanterUI.getEnchantersUI().open(sender);
}
}
@@ -0,0 +1,18 @@
package net.crankedpvp.crankedenchants.commands;
import me.mattstudios.mf.annotations.Alias;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedenchants.inventories.MainEnchantsUI;
import org.bukkit.entity.Player;
@Command("enchants")
@Alias("enchantslist")
public class EnchantsCommand extends CommandBase {
@Default
public void mainCommand(Player sender) {
MainEnchantsUI enchantsUI = new MainEnchantsUI();
enchantsUI.getEnchantsGUI().open(sender);
}
}
@@ -0,0 +1,36 @@
package net.crankedpvp.crankedenchants.commands;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
import net.crankedpvp.crankedenchants.language.Language;
import net.crankedpvp.crankedenchants.struct.items.SoulGemBuilder;
import net.crankedpvp.crankedutils.utils.InventoryUtils;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.base.CommandBase;
import org.bukkit.entity.Player;
@Command("splitsouls")
public class SplitSoulsCommand extends CommandBase {
@Default
public void mainCommand(Player sender, Integer amount) {
if (!CrankedEnchantsAPI.isSoulGem(sender.getItemInHand())) return;
if (amount <= 0) return;
if (!InventoryUtils.hasAvailableSlot(sender)) {
Language.FULL_INVENTORY.send(sender);
return;
}
CrankedEnchants.getInstance().getSoulManager().disableSoulMode(sender);
SoulGemBuilder soulGemBuilder = new SoulGemBuilder(sender.getItemInHand());
if (soulGemBuilder.getSouls() <= amount) return;
soulGemBuilder.removeSouls(amount);
sender.setItemInHand(soulGemBuilder.build());
sender.getInventory().addItem(new SoulGemBuilder(amount).build());
}
}
@@ -0,0 +1,46 @@
package net.crankedpvp.crankedenchants.commands;
import net.crankedpvp.crankedenchants.language.Language;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedenchants.struct.items.SoulGemBuilder;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import net.crankedpvp.crankedutils.utils.InventoryUtils;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.base.CommandBase;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
@Command("withdrawsouls")
public class WithdrawSoulsCommand extends CommandBase {
@Default
public void mainCommand(Player sender, Integer amount) {
if (!ItemUtils.isWeapon(sender.getItemInHand())) return;
if (amount <= 0) return;
if (!InventoryUtils.hasAvailableSlot(sender)) {
Language.FULL_INVENTORY.send(sender);
return;
}
EnchantedItemBuilder enchantedItemBuilder = new EnchantedItemBuilder(sender.getItemInHand());
if (!enchantedItemBuilder.hasSoulTrackerAlreadyApplied()) {
Language.DOESNT_HAVE_SOUL_TRACKER.send(sender);
return;
}
if (enchantedItemBuilder.getHarvestedSouls() < amount) {
Language.OUT_OF_SOULS.send(sender);
sender.playSound(sender.getLocation(), Sound.ITEM_BREAK, 0.7f, 0.4f);
return;
}
enchantedItemBuilder.removeHarvestedSouls(amount);
enchantedItemBuilder.updateSoulsHarvested();
sender.setItemInHand(enchantedItemBuilder.build());
sender.getInventory().addItem(new SoulGemBuilder(amount * enchantedItemBuilder.getSoulTrackerTier().getSoulValue()).build());
}
}
@@ -0,0 +1,76 @@
package net.crankedpvp.crankedenchants.enchantments.cursed;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.cache.enchantscache.AbyssCache;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.utils.CacheUtils;
import net.crankedpvp.crankedutils.utils.Arrow;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import net.crankedpvp.staritems.StarItemsAPI;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.player.PlayerKickEvent;
import org.bukkit.event.player.PlayerQuitEvent;
public class Abyss extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.075;
@ConfigValue
private int durationInSeconds = 3;
public Abyss() {
super("Abyss", EnchantTier.CURSED, false, 4, GearType.BOOTS, "When at low health, you have a chance", "to freeze enemies in a 6 block radius", "for a short amount of time.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (super.isOnCooldown(victim)) return;
if (Math.random() < procChance * enchantInfo.getLevel() && victim.getHealth() < enchantInfo.getLevel()*2) {
for (Player enemy : PVPUtils.getNearbyEnemyPlayersExceptPlayer(victim, 6)) {
if(StarItemsAPI.playerHasStarItem(enemy, "void")) {
enemy.sendMessage(CC.translate("&d&lVoid &8" + Arrow.arrow() + " &7You have bypassed &4" + victim.getName() + "'s &7abyss enchantment"));
} if(StarItemsAPI.playerHasStarItem(enemy, "santasbeard")) {
enemy.sendMessage(CC.translate("&c&lSantas Beard &8" + Arrow.arrow() + " &7You have bypassed &4" + victim.getName() + "'s &7abyss enchantment"));
} else {
AbyssCache abyssCache = CacheUtils.getAbyssCache(enemy);
abyssCache.applyAbyssEffect(enemy, enchantInfo.getLevel());
enemy.sendMessage(CC.translate("&4&lAbyss &8" + Arrow.arrow() + " &7You have been frozen by &4" + victim.getName() + "'s &7abyss enchantment"));
}
}
super.registerCooldown(victim, 45);
}
}
@EventHandler
public void onPlayerLeaveWhileAbyss(PlayerQuitEvent event) {
AbyssCache abyssCache = CacheUtils.getAbyssCache(event.getPlayer());
if (abyssCache.isAffected()) {
abyssCache.removeAbyssEffect(event.getPlayer());
}
}
@EventHandler
public void onPlayerLeaveWhileAbyss(PlayerKickEvent event) {
AbyssCache abyssCache = CacheUtils.getAbyssCache(event.getPlayer());
if (abyssCache.isAffected()) {
abyssCache.removeAbyssEffect(event.getPlayer());
}
}
@EventHandler
public void onPlayerDeathWhileAbyss(PlayerDeathEvent event) {
AbyssCache abyssCache = CacheUtils.getAbyssCache(event.getEntity());
if (abyssCache.isAffected()) {
abyssCache.removeAbyssEffect(event.getEntity());
}
}
}
@@ -0,0 +1,25 @@
package net.crankedpvp.crankedenchants.enchantments.cursed;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffectType;
public class AntiCactus extends ArmorIncomingPVPDamageEventEnchant {
public AntiCactus() {
super("Anti Cactus", EnchantTier.CURSED, false, 1, GearType.LEGGINGS, "Immune to enemy cactus enchant effect");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
}
}
@@ -0,0 +1,26 @@
package net.crankedpvp.crankedenchants.enchantments.cursed;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorPlayerDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageEvent;
public class AntiLife extends ArmorPlayerDamageEventEnchant {
@ConfigValue
private double procChance = 0.025;
public AntiLife() {
super("Anti Life", EnchantTier.CURSED, false, 10, GearType.HELMET, "Wither and poison damage has a chance", "to heal the wearer");
}
@Override
public void runOnDamage(EntityDamageEvent event, Player player, EnchantInfo enchantInfo) {
if ((event.getCause() == EntityDamageEvent.DamageCause.POISON || event.getCause() == EntityDamageEvent.DamageCause.WITHER) && Math.random() < procChance*enchantInfo.getLevel()) {
event.setCancelled(true);
super.getDamageHandler().healEntity(player, Math.max(1, enchantInfo.getLevel()/2), "Anti Life");
}
}
}
@@ -0,0 +1,32 @@
package net.crankedpvp.crankedenchants.enchantments.cursed;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffectType;
public class Fat extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.075;
public Fat() {
super("Fat", EnchantTier.CURSED, false, 6, GearType.CHESTPLATE, "Gain a chance to receive absorption", "hearts when under health boost hearts");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (super.isOnCooldown(victim)) return;
if ((Math.random() < procChance * enchantInfo.getLevel()) && (victim.getMaxHealth() > 20) && (victim.getHealth() < 20)) {
PotionEffectUtils.addPotionEffect(victim, PotionEffectType.ABSORPTION, enchantInfo.getLevel(),"FatEnchant", enchantInfo.getLevel());
super.registerCooldown(victim, 75);
}
}
}
@@ -0,0 +1,40 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.language.Language;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorEquipEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import net.crankedpvp.crankedutils.utils.RomanNumeral;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
public class AntiGravity extends ArmorEquipEventEnchant {
public AntiGravity() {
super("Anti Gravity", EnchantTier.ELITE, false, 1, GearType.BOOTS, "Added extreme jump boost when equipped.");
}
@Override
public void runArmorEquipEvent(Player player, int level) {
PotionEffectUtils.addPotionEffect(player, PotionEffectType.JUMP, level+2, "AntiGravityEnchant");
Language.EQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Jump Boost")
.replace("{effect-level}", RomanNumeral.convertToRoman(level+2))
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level+2))
);
}
@Override
public void runArmorUnEquipEvent(Player player, int level) {
PotionEffectUtils.removePotionEffect(player, "AntiGravityEnchant");
Language.UNEQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Jump Boost")
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level+2))
);
}
}
@@ -0,0 +1,30 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.BowEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.BlindingEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.entity.Arrow;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Blind extends BowEventEnchant implements BlindingEnchant {
@ConfigValue
private double procChance = 0.03;
public Blind() {
super("Blind", EnchantTier.ELITE, 3, GearType.BOW, "Chance of causing blindness", "when attacking.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, Player victim, Player attacker, Arrow arrow, EnchantedItemBuilder enchantedItemBuilder) {
if (victim.hasPotionEffect(PotionEffectType.BLINDNESS)) return;
if (Math.random() <= procChance * enchantedItemBuilder.getEnchantmentLevel(this))
victim.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, enchantedItemBuilder.getEnchantmentLevel(this) * 20, 0, true));
}
}
@@ -0,0 +1,42 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.cache.enchantscache.RageStacksCache;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Silenceable;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.utils.CacheUtils;
import net.crankedpvp.crankedmasks.CrankedMasksAPI;
import org.bukkit.Effect;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Cactus extends ArmorIncomingPVPDamageEventEnchant implements Silenceable {
public Cactus() {
super("Cactus", EnchantTier.ELITE, false, 2, GearType.ARMOR, "Injures your attacker but does not", "affect your durability.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (!(attacker instanceof Player)) return;
Player attackerPlayer = ((Player) attacker);
if (CrankedEnchantsAPI.hasEnchantment(attackerPlayer, "anticactus")) return;
if (CrankedMasksAPI.hasMaskEquipped(attackerPlayer, "coyote")) return;
Location particleSpawnLocation = victim.getLocation();
particleSpawnLocation.setY(particleSpawnLocation.getY() + 1);
attackerPlayer.playEffect(particleSpawnLocation, Effect.STEP_SOUND, Material.CACTUS);
RageStacksCache attackerRageStack = CacheUtils.getRageStackCache(attackerPlayer);
if (attackerRageStack.getRageStack() > 0) {
attackerRageStack.resetRageStack();
}
}
}
@@ -0,0 +1,30 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.inventory.ItemStack;
public class Demonforged extends WeaponDamageEventEnchant {
public Demonforged() {
super("Demonforged", EnchantTier.ELITE, 4, GearType.SWORD, "Increases durability loss on your enemy's armor.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (!(victim instanceof Player)) return;
Player playerVictim = ((Player) victim);
for (ItemStack itemStack : playerVictim.getInventory().getArmorContents()) {
if (!ItemUtils.isArmor(itemStack)) continue;
itemStack.setDurability((short) (itemStack.getDurability() + 1));
}
}
}
@@ -0,0 +1,36 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.events.SlownessEnchantProcEvent;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.BowEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.Bukkit;
import org.bukkit.entity.Arrow;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Entangle extends BowEventEnchant {
@ConfigValue
private double procChance = 0.005;
public Entangle() {
super("Entangle", EnchantTier.ELITE, 4, GearType.BOW, "Chance to immobilize your target when", "they are hit.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, Player victim, Player attacker, Arrow arrow, EnchantedItemBuilder enchantedItemBuilder) {
if (Math.random() < procChance * enchantedItemBuilder.getEnchantmentLevel(this)) {
SlownessEnchantProcEvent slownessEnchantProcEvent = new SlownessEnchantProcEvent(attacker, victim, this, enchantedItemBuilder.getEnchantmentLevel(this));
Bukkit.getPluginManager().callEvent(slownessEnchantProcEvent);
if (event.isCancelled()) return;
victim.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, 5, Integer.MAX_VALUE, true));
}
}
}
@@ -0,0 +1,60 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Reloadable;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.Effect;
import org.bukkit.Material;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import xyz.xenondevs.particle.ParticleBuilder;
import xyz.xenondevs.particle.ParticleEffect;
import xyz.xenondevs.particle.data.texture.BlockTexture;
public class Execute extends WeaponDamageEventEnchant implements Reloadable {
@ConfigValue
public double procChance = 0.05;
@ConfigValue
public double damageBuff = 25;
@ConfigValue
private int requiredHealthForActivation = 14;
public ParticleBuilder particle;
@ConfigValue
private int particleAmount = 50;
@ConfigValue
private double particleYoffset = 0.7;
@ConfigValue
private double particleSpeed = 0.1;
public Execute() {
super("Execute", EnchantTier.ELITE, 7, GearType.SWORD, "Damage buff when your target is at low hp.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (!(victim instanceof Player)) return;
if (victim.getHealth() > requiredHealthForActivation) return;
if (Math.random() < procChance * level) {
Player victimPlayer = (Player) victim;
super.getDamageHandler().increaseDamage(damageBuff, event, this.getName());
victimPlayer.getWorld().playEffect(victimPlayer.getEyeLocation(), Effect.STEP_SOUND, Material.REDSTONE_WIRE);
this.particle.setLocation(victimPlayer.getLocation()).display(PVPUtils.getNearbyPlayersExceptPlayer(victimPlayer, 20));
}
}
@Override
public void reloadValues() {
this.particle = new ParticleBuilder(ParticleEffect.BLOCK_DUST)
.setParticleData(new BlockTexture(Material.REDSTONE_WIRE))
.setAmount(particleAmount)
.setOffsetY((float) particleYoffset)
.setSpeed((float) particleSpeed);
}
}
@@ -0,0 +1,39 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.events.SlownessEnchantProcEvent;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.SlownessEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.Bukkit;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Frozen extends ArmorIncomingPVPDamageEventEnchant implements SlownessEnchant {
@ConfigValue
private double procChance = 0.003;
@ConfigValue
private int slownessLength = 5;
public Frozen() {
super("Frozen", EnchantTier.ELITE, false, 3, GearType.ARMOR, "Can cause slowness to the attacker", "when attacked.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (Math.random() < procChance * enchantInfo.getLevel()) {
SlownessEnchantProcEvent slownessEnchantProcEvent = new SlownessEnchantProcEvent(attacker, victim, this, enchantInfo.getLevel());
Bukkit.getPluginManager().callEvent(slownessEnchantProcEvent);
if (event.isCancelled()) return;
attacker.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, this.slownessLength, 0, true));
}
}
}
@@ -0,0 +1,35 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.Material;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Greatsword extends WeaponDamageEventEnchant {
@ConfigValue
private double procChance = 0.4;
@ConfigValue
private double damageBuff = 20;
public Greatsword() {
super("Greatsword", EnchantTier.ELITE, 5, GearType.SWORD, "Multiplies damage against players who are wielding a BOW", "at the time they are hit. ");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (!(victim instanceof Player)) return;
Player playerVictim = ((Player) victim);
if (playerVictim.getItemInHand() == null) return;
if (playerVictim.getItemInHand().getType() != Material.BOW) return;
if (Math.random() < procChance) {
super.getDamageHandler().increaseDamage(damageBuff, event, this.getName());
}
}
}
@@ -0,0 +1,54 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Reloadable;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.inventory.ItemStack;
import xyz.xenondevs.particle.ParticleBuilder;
import xyz.xenondevs.particle.ParticleEffect;
public class Hardened extends ArmorIncomingPVPDamageEventEnchant implements Reloadable {
@ConfigValue
public double procChance = 0.2;
public ParticleBuilder particle;
@ConfigValue
public int particleAmount = 10;
@ConfigValue
public double particleYoffset = 0.3;
@ConfigValue
public double particleSpeed = 0.1;
public Hardened() {
super("Hardened", EnchantTier.ELITE, false, 3, GearType.ARMOR, "Armor takes less durability damage.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (Math.random() < procChance * enchantInfo.getLevel()) {
this.particle.setLocation(victim.getLocation()).display(PVPUtils.getNearbyPlayersExceptPlayer(victim, 30));
for (ItemStack itemStack : victim.getInventory().getArmorContents()) {
if (!ItemUtils.isArmor(itemStack)) continue;
itemStack.setDurability((short) (itemStack.getDurability() - (enchantInfo.getLevel() + 2)));
}
}
}
@Override
public void reloadValues() {
this.particle = new ParticleBuilder(ParticleEffect.SPELL_WITCH)
.setAmount(particleAmount)
.setOffsetY((float) particleYoffset)
.setSpeed((float) particleSpeed);
}
}
@@ -0,0 +1,21 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.enchantstruct.BlockBreakEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Haste extends BlockBreakEventEnchant {
public Haste() {
super("Haste", EnchantTier.ELITE, 3, GearType.PICKAXE, "allows you to swing your tools faster.");
}
@Override
public void runBlockBreakEvent(BlockBreakEvent event, EnchantedItemBuilder enchantedItemBuilder) {
event.getPlayer().addPotionEffect(new PotionEffect(PotionEffectType.FAST_DIGGING, 100, enchantedItemBuilder.getEnchantmentLevel(this) - 1, true));
}
}
@@ -0,0 +1,48 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.events.SlownessEnchantProcEvent;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.SlownessEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.Bukkit;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Paralyze extends WeaponDamageEventEnchant implements SlownessEnchant {
@ConfigValue
private double procChance = 0.05;
@ConfigValue
private int slownessLength = 5;
@ConfigValue
private int miningFatigueLength = 5;
public Paralyze() {
super("Paralyze", EnchantTier.ELITE, 4, GearType.SWORD, "Gives lightning effect and a chance for slowness and slow swinging.", "Also inflicts direct damage on proc.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (!(victim instanceof Player)) return;
if (Math.random() < procChance) {
SlownessEnchantProcEvent slownessEnchantProcEvent = new SlownessEnchantProcEvent(attacker, victim, this, level);
Bukkit.getPluginManager().callEvent(slownessEnchantProcEvent);
if (event.isCancelled()) return;
Player playerVictim = ((Player) victim);
playerVictim.getLocation().getWorld().strikeLightningEffect(playerVictim.getLocation());
playerVictim.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, this.slownessLength, level > 2 ? 1 : 0));
if (level == 4) {
playerVictim.addPotionEffect(new PotionEffect(PotionEffectType.SLOW_DIGGING, this.miningFatigueLength, 1));
}
}
}
}
@@ -0,0 +1,29 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Poison extends WeaponDamageEventEnchant {
@ConfigValue
private double procChance = 0.002;
public Poison() {
super("Poison", EnchantTier.ELITE, 3, GearType.SWORD, "A chance of giving the poison effect. ");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (Math.random() < procChance * level) {
victim.addPotionEffect(new PotionEffect(PotionEffectType.POISON, 5, level - 1), true);
}
}
}
@@ -0,0 +1,29 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Poisoned extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.003;
public Poisoned() {
super("Poisoned", EnchantTier.ELITE, false, 4, GearType.ARMOR, " Chance to give poison to your attacker.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (Math.random() < procChance * enchantInfo.getLevel()) {
attacker.addPotionEffect(new PotionEffect(PotionEffectType.POISON, 5, enchantInfo.getLevel() - 1), true);
}
}
}
@@ -0,0 +1,58 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.perms.Relation;
import net.crankedpvp.crankedenchants.events.SlownessEnchantProcEvent;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.SlownessEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Pummel extends WeaponDamageEventEnchant implements SlownessEnchant {
@ConfigValue
private double procChance = 0.08;
@ConfigValue
private double range = 7.0;
@ConfigValue
private int slownessLevel = 1;
@ConfigValue
private int cooldown = 30;
public Pummel() {
super("Pummel", EnchantTier.ELITE, 3, GearType.AXE, "Chance to slow nearby enemy players", "for a short period of time.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (super.isOnCooldown(attacker)) return;
if (Math.random() < procChance) {
SlownessEnchantProcEvent slownessEnchantProcEvent = new SlownessEnchantProcEvent(attacker, victim, this, level);
Bukkit.getPluginManager().callEvent(slownessEnchantProcEvent);
if (event.isCancelled()) return;
FPlayer fPlayer = FPlayers.getInstance().getByPlayer(attacker);
attacker.getNearbyEntities(range, range, range).forEach(entity -> {
if (!(entity instanceof Player)) return;
Player nearbyPlayer = (Player) entity;
if (nearbyPlayer.getGameMode() != GameMode.SURVIVAL) return;
if (!PVPUtils.canPvPInRegion(nearbyPlayer)) return;
FPlayer fPlayerNearby = FPlayers.getInstance().getByPlayer(nearbyPlayer);
if (fPlayer.getRelationTo(fPlayerNearby).isAtLeast(Relation.TRUCE)) return;
nearbyPlayer.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, (level + 2) * 20, slownessLevel, true));
});
super.registerCooldown(attacker, cooldown);
}
}
}
@@ -0,0 +1,45 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.inventory.ItemStack;
public class Reforged extends WeaponDamageEventEnchant {
public Reforged() {
super("Reforged", EnchantTier.ELITE,10, GearType.WEAPONS_AND_TOOLS, "Protects durability, items will take longer to break.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
ItemStack itemStack = attacker.getItemInHand();
itemStack.setDurability((short) (itemStack.getDurability() - 2));
attacker.setItemInHand(itemStack);
}
@EventHandler
public void blockBreakEvent(BlockBreakEvent event) {
if (event.isCancelled()) return;
ItemStack itemStack = event.getPlayer().getItemInHand();
if (itemStack == null) return;
if (!this.getType().getItems().contains(itemStack.getType())) return;
EnchantedItemBuilder enchantedItemBuilder = new EnchantedItemBuilder(itemStack);
if (!enchantedItemBuilder.hasEnchantment(this)) return;
itemStack.setDurability((short) (itemStack.getDurability() - 10));
event.getPlayer().setItemInHand(itemStack);
}
}
@@ -0,0 +1,33 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorEquipEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class RepairGuard extends ArmorEquipEventEnchant {
@ConfigValue
private int cooldown = 60;
@ConfigValue
private int duration = 8;
public RepairGuard() {
super("Repair Guard", EnchantTier.ELITE, false, 3, GearType.ARMOR, "Whenever you remove a low durability piece of armor to repair it,", "ou will get up to 10 absorption hearts (depending on level)", "while you are fixing it.");
}
@Override
public void runArmorEquipEvent(Player player, int level) {
}
@Override
public void runArmorUnEquipEvent(Player player, int level) {
if (super.isOnCooldown(player)) return;
player.addPotionEffect(new PotionEffect(PotionEffectType.ABSORPTION, duration * 20, level + 1), true);
super.registerCooldown(player, cooldown);
}
}
@@ -0,0 +1,101 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Reloadable;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.player.PlayerKickEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
import org.bukkit.util.Vector;
import xyz.xenondevs.particle.ParticleBuilder;
import xyz.xenondevs.particle.ParticleEffect;
import xyz.xenondevs.particle.data.texture.BlockTexture;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class RocketEscape extends ArmorIncomingPVPDamageEventEnchant implements Reloadable {
@ConfigValue
private double procChance = 0.2;
@ConfigValue
private int cooldown = 150;
@ConfigValue
private List<String> message = Arrays.asList("&r ", "&a&l(!) &ayour Roecket Escape boots have activated, recover while they last!", "&r ");
private ParticleBuilder particle;
@ConfigValue
private int particleAmount = 50;
@ConfigValue
private double particleYoffset = 0.7;
@ConfigValue
private double particleSpeed = 0.05;
private final List<Player> noFallDamage;
public RocketEscape() {
super("Rocket Escape", EnchantTier.ELITE, false, 3, GearType.BOOTS, "Chance to blast off into the air", "at low health.");
this.noFallDamage = new ArrayList<>();
this.reloadValues();
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (victim.getHealth() - event.getFinalDamage() > 2) return;
if (super.isOnCooldown(victim)) return;
if (Math.random() < this.procChance * enchantInfo.getLevel()) {
super.getDamageHandler().cancelDamage(event, this.getName());
victim.setVelocity(new Vector(0, (enchantInfo.getLevel() + 2) * 3, 0));
victim.addPotionEffect(new PotionEffect(PotionEffectType.REGENERATION, 20 * (enchantInfo.getLevel() + 2), 19, true, false));
super.registerCooldown(victim, this.cooldown);
this.particle.setLocation(victim.getLocation()).display(PVPUtils.getNearbyPlayersExceptPlayer(victim, 30));
super.sendMessage(victim, this.message);
this.noFallDamage.add(victim);
Bukkit.getScheduler().runTaskLater(CrankedEnchants.getInstance(), () -> this.noFallDamage.remove(victim), 160L);
}
}
@EventHandler
public void onFallDamageAfterRocketEscape(EntityDamageEvent event) {
if (event.getCause() != EntityDamageEvent.DamageCause.FALL) return;
if (event.getDamage() <= 0) return;
if (!(event.getEntity() instanceof Player)) return;
if (!this.noFallDamage.contains((Player) event.getEntity())) return;
event.setCancelled(true);
}
@EventHandler
public void onLeaveWhileInNoFallDamageList(PlayerQuitEvent event) {
this.noFallDamage.remove(event.getPlayer());
}
@EventHandler
public void onLeaveWhileInNoFallDamageList(PlayerKickEvent event) {
this.noFallDamage.remove(event.getPlayer());
}
@Override
public void reloadValues() {
this.particle = new ParticleBuilder(ParticleEffect.BLOCK_DUST)
.setParticleData(new BlockTexture(Material.CACTUS))
.setAmount(this.particleAmount)
.setOffsetY((float) this.particleYoffset)
.setSpeed((float) this.particleSpeed);
}
}
@@ -0,0 +1,50 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.perms.Relation;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.GameMode;
import org.bukkit.Sound;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Shockwave extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.004;
@ConfigValue
private int cooldown = 100;
@ConfigValue
private int range = 5;
public Shockwave() {
super("Shockwave", EnchantTier.ELITE, false, 5, GearType.CHESTPLATE, "Chance of explosive knockback", "surrounding players when you are hit.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (super.isOnCooldown(victim)) return;
if (Math.random() < procChance * enchantInfo.getLevel()) {
FPlayer fPlayer = FPlayers.getInstance().getByPlayer(victim);
victim.getNearbyEntities(range, range, range).forEach(entity -> {
if (!(entity instanceof Player)) return;
Player nearbyPlayer = (Player) entity;
if (nearbyPlayer.getGameMode() != GameMode.SURVIVAL) return;
if (!PVPUtils.canPvPInRegion(nearbyPlayer)) return;
FPlayer fPlayerNearby = FPlayers.getInstance().getByPlayer(nearbyPlayer);
if (fPlayer.getRelationTo(fPlayerNearby).isAtLeast(Relation.TRUCE)) return;
nearbyPlayer.setVelocity(victim.getLocation().toVector().subtract(nearbyPlayer.getLocation().toVector()).normalize().multiply(3));
});
victim.playSound(victim.getLocation(), Sound.FIREWORK_LAUNCH, 1.0f, 0.1f);
super.registerCooldown(victim, cooldown);
}
}
}
@@ -0,0 +1,21 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class SmokeBomb extends ArmorIncomingPVPDamageEventEnchant {
public SmokeBomb() {
super("Smoke Bomb", EnchantTier.ELITE, false, 8, GearType.HELMET, "When you are near death, you will spawn a smoke bomb", "to distract your enemies.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
//TODO: smoke bomb effect
}
}
@@ -0,0 +1,12 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
public class Solitude extends Enchantment {
public Solitude() {
super("Solitude", EnchantTier.ELITE, false, 3, GearType.WEAPON, "Increases chance and length of the Silence enchantment", "procing on enemy players by up to 3X. ");
}
}
@@ -0,0 +1,51 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.perms.Relation;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.GameMode;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class SpiritLink extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.004;
@ConfigValue
private int cooldown = 100;
@ConfigValue
private int range = 5;
@ConfigValue
private int healAmount = 5;
public SpiritLink() {
super("Spirit Link", EnchantTier.ELITE, false, 5, GearType.CHESTPLATE, "Heals nearby faction/allies when you are damaged.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (super.isOnCooldown(victim)) return;
if (Math.random() < procChance * enchantInfo.getLevel()) {
FPlayer fPlayer = FPlayers.getInstance().getByPlayer(victim);
for (Entity nearbyEntity : victim.getNearbyEntities(range, range, range)) {
if (!(nearbyEntity instanceof Player)) continue;
Player nearbyPlayer = (Player) nearbyEntity;
if (nearbyPlayer.getGameMode() != GameMode.SURVIVAL) continue;
if (!PVPUtils.canPvPInRegion(nearbyPlayer)) continue;
FPlayer fPlayerNearby = FPlayers.getInstance().getByPlayer(nearbyPlayer);
if (fPlayer.getRelationTo(fPlayerNearby).isAtMost(Relation.NEUTRAL)) continue;
super.getDamageHandler().healEntity(nearbyPlayer, healAmount, this.getName());
}
super.registerCooldown(victim, cooldown);
}
}
}
@@ -0,0 +1,41 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.language.Language;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorEquipEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import net.crankedpvp.crankedutils.utils.RomanNumeral;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
public class Springs extends ArmorEquipEventEnchant {
public Springs() {
super("Springs", EnchantTier.ELITE, false, 2, GearType.BOOTS, "Added extreme jump boost when equipped.");
}
@Override
public void runArmorEquipEvent(Player player, int level) {
PotionEffectUtils.addPotionEffect(player, PotionEffectType.JUMP, level, "SpringsEnchant");
Language.EQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Jump Boost")
.replace("{effect-level}", RomanNumeral.convertToRoman(level))
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
}
@Override
public void runArmorUnEquipEvent(Player player, int level) {
PotionEffectUtils.removePotionEffect(player, "SpringsEnchant");
Language.UNEQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Jump Boost")
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
}
}
@@ -0,0 +1,27 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Stormcaller extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.01;
public Stormcaller() {
super("Stormcaller", EnchantTier.ELITE, false, 4, GearType.ARMOR, "Strikes lightning on attacking players. ");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (Math.random() < procChance * enchantInfo.getLevel()) {
attacker.getLocation().getWorld().strikeLightningEffect(attacker.getLocation());
}
}
}
@@ -0,0 +1,59 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.perms.Relation;
import net.crankedpvp.crankedenchants.events.EnchantProcEvent;
import net.crankedpvp.crankedenchants.events.EnchantProcOnEntityEvent;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.Bukkit;
import org.bukkit.entity.Arrow;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.inventory.ItemStack;
public class Teleportation extends Enchantment {
public Teleportation() {
super("Teleportation", EnchantTier.ELITE, false, 5, GearType.BOW, "When an ally or faction member is hit", "with your arrow, you teleport to them.");
}
@EventHandler
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event) {
if (!(event.getEntity() instanceof Player) || !(event.getDamager() instanceof Arrow)) return;
Arrow arrow = (Arrow) event.getDamager();
if (!(arrow.getShooter() instanceof Player)) return;
Player victim = (Player) event.getEntity();
Player attacker = (Player) arrow.getShooter();
ItemStack itemStack = attacker.getItemInHand();
if (!ItemUtils.isEnchantable(itemStack)) return;
EnchantedItemBuilder enchantedItemBuilder = new EnchantedItemBuilder(itemStack);
if (!enchantedItemBuilder.hasEnchantment(this)) return;
EnchantProcEvent procEvent = new EnchantProcOnEntityEvent(victim, attacker, this, enchantedItemBuilder.getEnchantmentLevel(this));
Bukkit.getPluginManager().callEvent(procEvent);
if (procEvent.isCancelled()) return;
FPlayer fPlayerVictim = FPlayers.getInstance().getByPlayer(victim);
FPlayer fPlayerAttacker = FPlayers.getInstance().getByPlayer(attacker);
Relation relation = fPlayerVictim.getRelationTo(fPlayerAttacker);
if (!relation.isAlly() && !relation.isTruce() && !relation.isMember()) return;
attacker.teleport(victim.getLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
}
}
@@ -0,0 +1,40 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.events.SlownessEnchantProcEvent;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.SlownessEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.Bukkit;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Trap extends WeaponDamageEventEnchant implements SlownessEnchant {
@ConfigValue
private double procChance = 0.003;
@ConfigValue
private int slownessAmplifier = 1;
@ConfigValue
private int slownessTime = 4;
public Trap() {
super("Trap", EnchantTier.ELITE, 3, GearType.SWORD, "A chance of causing the slowness", "effect to your enemy.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (Math.random() < procChance * level) {
SlownessEnchantProcEvent slownessEnchantProcEvent = new SlownessEnchantProcEvent(attacker, victim, this, level);
Bukkit.getPluginManager().callEvent(slownessEnchantProcEvent);
if (event.isCancelled()) return;
victim.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, this.slownessTime, this.slownessAmplifier, true));
}
}
}
@@ -0,0 +1,38 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import java.util.HashSet;
public class Trickster extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.0125;
public Trickster() {
super("Trickster", EnchantTier.ELITE, false, 8, GearType.ARMOR, "When hit you have a chance to teleport directly behind", "your opponent and take them by surprise.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (Math.random() < procChance * enchantInfo.getLevel()) {
Location l1 = victim.getLocation().add(0.0, 1.0, 0.0);
Location l2 = victim.getTargetBlock((HashSet<Byte>) null, 4).getLocation().add(0.0, 1.0, 0.0).setDirection(attacker.getLocation().getDirection());
if (l2.getBlock().getType() == Material.AIR && l2.getBlock().getLocation().subtract(0.0, 1.0, 0.0).getBlock().getType() == Material.AIR) {
victim.teleport(l2, PlayerTeleportEvent.TeleportCause.PLUGIN);
victim.getWorld().playSound(l1, Sound.PORTAL_TRIGGER, 0.8f, 1.4f);
}
}
}
}
@@ -0,0 +1,48 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class UndeadRuse extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.005;
@ConfigValue
private int cooldown = 200;
public UndeadRuse() {
super("Undead Ruse", EnchantTier.ELITE, false, 10, GearType.ARMOR, "When hit you have a chance to spawn zombie hordes", "to distract and disorient your opponents.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (!(attacker instanceof Player)) return;
/* if (super.isOnCooldown(victim)) return;
if (Math.random() < procChance * enchantInfo.getLevel()) {
Player target = (Player) attacker;
Entity entity = EntityTypes.spawnEntity(new UndeadRuseZombie(victim.getWorld(), victim, target), victim.getLocation());
Bukkit.getScheduler().runTaskLater(CrankedEnchants.getInstance(), entity::remove, 400L);
super.registerCooldown(victim, cooldown);
}*/
}
/*
@EventHandler
public void onEntityTargetPlayer(EntityTargetLivingEntityEvent event) {
if (event.getEntityType() != EntityType.ZOMBIE) return;
if (!(event.getTarget() instanceof Player)) return;
if (!event.getEntity().hasMetadata("zombie-target")) return;
String uuid = String.valueOf(event.getEntity().getMetadata("zombie-target").get(0).asString());
if (!uuid.equals(event.getTarget().getUniqueId().toString())) event.setCancelled(true);
}
*/
}
@@ -0,0 +1,38 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.Bukkit;
import org.bukkit.Sound;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Vampire extends WeaponDamageEventEnchant {
@ConfigValue
private double procChance = 0.01;
@ConfigValue
private int cooldown = 20;
public Vampire() {
super("Vampire", EnchantTier.ELITE, 3, GearType.SWORD, "A chance to heal you for up to 3hp", "a few seconds after you strike.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (super.isOnCooldown(attacker)) return;
if (Math.random() < procChance * level) {
Bukkit.getScheduler().runTaskLater(CrankedEnchants.getInstance(), () -> {
super.getDamageHandler().healEntity(attacker, level, this.getName());
}, 30L);
attacker.playSound(attacker.getLocation(), Sound.FIREWORK_LAUNCH, 0.75f, 2.0f);
super.registerCooldown(attacker, cooldown);
}
}
}
@@ -0,0 +1,59 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorOutgoingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Reloadable;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
import xyz.xenondevs.particle.ParticleBuilder;
import xyz.xenondevs.particle.ParticleEffect;
public class Voodoo extends ArmorOutgoingPVPDamageEventEnchant implements Reloadable {
@ConfigValue
private double procChance = 0.01;
@ConfigValue
private int duration = 3;
@ConfigValue
private int weaknessAmplifier = 0;
private ParticleBuilder particle;
@ConfigValue
private int particleAmount = 300;
@ConfigValue
private double particleYoffset = 1.8;
@ConfigValue
private double particleSpeed = 0.1;
public Voodoo() {
super("Voodoo", EnchantTier.ELITE, false, 6, GearType.ARMOR, "Has a chance to deal weakness to", "your enemy.");
}
@Override
public void runOutgoingDamageEvent(EntityDamageByEntityEvent event, Player attacker, LivingEntity victim, EnchantInfo enchantInfo) {
if (!(victim instanceof Player)) return;
if (event.getDamage() <= 0) return;
if (Math.random() < this.procChance * enchantInfo.getLevel()) {
Player victimPlayer = ((Player) victim);
victim.addPotionEffect(new PotionEffect(PotionEffectType.WEAKNESS, this.duration * 20, this.weaknessAmplifier, true));
this.particle.setLocation(victimPlayer.getLocation()).display(PVPUtils.getNearbyPlayersExceptPlayer(victimPlayer, 20));
}
}
@Override
public void reloadValues() {
this.particle = new ParticleBuilder(ParticleEffect.SPELL_MOB)
.setAmount(this.particleAmount)
.setOffsetY((float) this.particleYoffset)
.setSpeed((float) this.particleSpeed);
}
}
@@ -0,0 +1,33 @@
package net.crankedpvp.crankedenchants.enchantments.elite;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Wither extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.008;
@ConfigValue
private int duration = 3;
@ConfigValue
private int witherAmplifier = 0;
public Wither() {
super("Wither", EnchantTier.ELITE, false, 5, GearType.ARMOR, "A chance to give the wither effect.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (Math.random() < procChance * enchantInfo.getLevel()) {
attacker.addPotionEffect(new PotionEffect(PotionEffectType.WITHER, duration * 20, witherAmplifier, true));
}
}
}
@@ -0,0 +1,38 @@
package net.crankedpvp.crankedenchants.enchantments.heroic;
import net.crankedpvp.crankedenchants.struct.enchantstruct.BlockBreakEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.HeroicEnchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedenchants.utils.DetonateUtils;
import org.bukkit.Material;
import org.bukkit.event.block.BlockBreakEvent;
import java.util.Arrays;
import java.util.List;
public class AtomicDetonate extends BlockBreakEventEnchant implements HeroicEnchantment {
public static List<Material> trenchBlackListedBlocks = Arrays.asList(Material.AIR, Material.BEDROCK, Material.MOB_SPAWNER, Material.WATER,
Material.LAVA, Material.STATIONARY_WATER,
Material.STATIONARY_LAVA, Material.SIGN, Material.GLOWSTONE, Material.LADDER, Material.WALL_SIGN, Material.SIGN_POST, Material.SPONGE, Material.CHEST, Material.ENDER_CHEST,
Material.TRAPPED_CHEST, Material.PISTON_BASE, Material.PISTON_EXTENSION, Material.PISTON_MOVING_PIECE, Material.PISTON_STICKY_BASE, Material.DISPENSER, Material.ENDER_PORTAL_FRAME,
Material.ENDER_PORTAL, Material.PORTAL, Material.SUGAR_CANE, Material.SUGAR_CANE_BLOCK, Material.JUKEBOX, Material.ENCHANTMENT_TABLE);
public AtomicDetonate() {
super("Atomic Detonate", EnchantTier.HEROIC, 2, GearType.TOOL, "Mine blocks in a very large radius.");
}
@Override
public void runBlockBreakEvent(BlockBreakEvent event, EnchantedItemBuilder enchantedItemBuilder) {
if (event.isCancelled()) return;
int level = enchantedItemBuilder.getEnchantmentLevel(this);
DetonateUtils.trenchEffect(event.getBlock(), 5 + level, event.getPlayer(), trenchBlackListedBlocks);
}
@Override
public String getBaseEnchantment() {
return "detonate";
}
}
@@ -0,0 +1,82 @@
package net.crankedpvp.crankedenchants.enchantments.heroic;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.perms.Relation;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
import net.crankedpvp.crankedenchants.enchantments.ultimate.Bleed;
import net.crankedpvp.crankedenchants.struct.cache.enchantscache.BleedStacksCache;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.HeroicEnchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.utils.CacheUtils;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.Effect;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class DeepBleed extends WeaponDamageEventEnchant implements HeroicEnchantment {
private Bleed baseEnchantment;
public DeepBleed() {
super("Deep Bleed", EnchantTier.HEROIC, 6, GearType.AXE, "Applies bleed stacks to enemies that", "decrease their movement speed.");
Enchantment enchantment = CrankedEnchants.getInstance().getEnchantRegister().getEnchantmentFromID(this.getBaseEnchantment());
if(enchantment instanceof Bleed) this.baseEnchantment = (Bleed) enchantment;
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if(!(victim instanceof Player)) return;
int deepWoundsLevel = CrankedEnchantsAPI.hasEnchantment(attacker, "deepwounds") ? CrankedEnchantsAPI.getEnchantmentLevel(attacker, "deepwounds") : 0;
if(Math.random() < (this.baseEnchantment.procChance * ((this.baseEnchantment.getMax() + level) + deepWoundsLevel))) {
Player victimPlayer = (Player) victim;
BleedStacksCache victimBleedStack = CacheUtils.getBleedStackCache(victimPlayer);
if(victimBleedStack.getLastBleedStackTime() + 30000 < System.currentTimeMillis()) {
victimBleedStack.updateLastBleedStackTime();
victimBleedStack.resetBleedStack();
return;
}
victim.addPotionEffect(
new PotionEffect(PotionEffectType.SLOW,
(victimBleedStack.getBleedStack() + 1) * 20,
Math.min(victimBleedStack.getBleedStack() - 1, 1)),
true
);
victim.getWorld().playEffect(victim.getEyeLocation(), Effect.STEP_SOUND, Material.REDSTONE_BLOCK);
victimBleedStack.incrementBleedStack();
victimBleedStack.updateLastBleedStackTime();
FPlayer fPlayer = FPlayers.getInstance().getByPlayer(victimPlayer);
for(Entity entity : victim.getNearbyEntities(7, 7, 7)) {
if(!(entity instanceof Player)) continue;
Player nearbyPlayer = (Player) entity;
if(nearbyPlayer.getGameMode() != GameMode.SURVIVAL) continue;
if(!PVPUtils.canPvPInRegion(nearbyPlayer)) continue;
FPlayer fPlayerNearby = FPlayers.getInstance().getByPlayer(nearbyPlayer);
if(fPlayer.getRelationTo(fPlayerNearby).isAtLeast(Relation.TRUCE)) continue;
Enchantment enchantment = CrankedEnchants.getInstance().getEnchantRegister().getEnchantmentFromID("bloodlust");
if(CrankedEnchantsAPI.hasEnchantment(nearbyPlayer, enchantment))
super.getDamageHandler().healEntity(nearbyPlayer, 2, "Blood Lust");
}
}
}
@Override
public String getBaseEnchantment() {
return "bleed";
}
}
@@ -0,0 +1,40 @@
package net.crankedpvp.crankedenchants.enchantments.heroic;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.enchantments.legendary.Enlighted;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.HeroicEnchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class DivineEnlighted extends ArmorIncomingPVPDamageEventEnchant implements HeroicEnchantment {
private Enlighted baseEnchantment;
public DivineEnlighted() {
super("Divine Enlighted", EnchantTier.HEROIC, true, 3, GearType.ARMOR, "Has a chance to heal you", "while taking damage");
Enchantment enchantment = CrankedEnchants.getInstance().getEnchantRegister().getEnchantmentFromID(this.getBaseEnchantment());
if(enchantment instanceof Enlighted) this.baseEnchantment = (Enlighted) enchantment;
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (super.isOnCooldown(victim)) return;
if (Math.random() < this.baseEnchantment.procChance * (baseEnchantment.getMax() + enchantInfo.getLevel())) {
super.getDamageHandler().healEntity(victim, enchantInfo.getAmount() * (1 + ((double) enchantInfo.getLevel() /10)), this.getName());
super.registerCooldown(victim, this.baseEnchantment.cooldown);
}
}
@Override
public String getBaseEnchantment() {
return "enlighted";
}
}
@@ -0,0 +1,57 @@
package net.crankedpvp.crankedenchants.enchantments.heroic;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.enchantments.ultimate.Dodge;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.HeroicEnchantment;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Reloadable;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.Sound;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class EtherealDodge extends ArmorIncomingPVPDamageEventEnchant implements Reloadable, HeroicEnchantment {
@ConfigValue
private String message = "&d&l** ETHEREAL DODGED **";
private Dodge baseEnchantment;
public EtherealDodge() {
super("Ethereal Dodge", EnchantTier.HEROIC, false, 1, GearType.ARMOR, "Has a chance to dodge physical", "attacks, increased chance when sneaking.");
Enchantment enchantment = CrankedEnchants.getInstance().getEnchantRegister().getEnchantmentFromID(this.getBaseEnchantment());
if(enchantment instanceof Dodge) this.baseEnchantment = (Dodge) enchantment;
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (this.isOnCooldown(victim)) return;
double chance = victim.isSneaking() ? this.baseEnchantment.procChanceWhenSneaking * (baseEnchantment.getMax() + 1) : this.baseEnchantment.procChance * (baseEnchantment.getMax() + 1);
if (Math.random() < chance) {
super.getDamageHandler().cancelDamage(event, this.getName());
super.sendMessage(victim, this.message);
victim.getWorld().playSound(victim.getLocation(), Sound.BAT_TAKEOFF, 1.0f, 0.75f);
this.baseEnchantment.particle.setLocation(victim.getLocation()).display(PVPUtils.getNearbyPlayersExceptPlayer(victim, 30));
super.registerCooldown(victim, this.baseEnchantment.cooldown);
}
}
@Override
public String getBaseEnchantment() {
return "dodge";
}
@Override
public void reloadValues() {
}
}
@@ -0,0 +1,55 @@
package net.crankedpvp.crankedenchants.enchantments.heroic;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.enchantments.legendary.Overload;
import net.crankedpvp.crankedenchants.language.Language;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorEquipEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.HeroicEnchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import net.crankedpvp.crankedutils.utils.RomanNumeral;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
public class GodlyOverload extends ArmorEquipEventEnchant implements HeroicEnchantment {
private Overload baseEnchantment;
public GodlyOverload() {
super("Godly Overload", EnchantTier.HEROIC, false, 1, GearType.ARMOR, "Increases the wearer's total health.");
Enchantment enchantment = CrankedEnchants.getInstance().getEnchantRegister().getEnchantmentFromID(this.getBaseEnchantment());
if(enchantment instanceof Overload) this.baseEnchantment = (Overload) enchantment;
}
@Override
public void runArmorEquipEvent(Player player, int level) {
PotionEffectUtils.addPotionEffect(player, PotionEffectType.HEALTH_BOOST, baseEnchantment.getMax()+level, "GodlyOverloadEnchant");
Language.EQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Health Boost")
.replace("{effect-level}", RomanNumeral.convertToRoman(baseEnchantment.getMax()+level))
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
}
@Override
public void runArmorUnEquipEvent(Player player, int level) {
PotionEffectUtils.removePotionEffect(player, "GodlyOverloadEnchant");
Language.UNEQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Health Boost")
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
}
@Override
public String getBaseEnchantment() {
return "overload";
}
}
@@ -0,0 +1,50 @@
package net.crankedpvp.crankedenchants.enchantments.heroic;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.enchantments.elite.Execute;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.HeroicEnchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.Effect;
import org.bukkit.Material;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class PermanentExecute extends WeaponDamageEventEnchant implements HeroicEnchantment {
@ConfigValue
private double damageBuffPerLevel = 5;
private Execute baseEnchantment;
public PermanentExecute() {
super("Permanent Execute", EnchantTier.HEROIC, 3, GearType.SWORD, "Constant damage buff, regardless of", "your opponents current health");
Enchantment enchantment = CrankedEnchants.getInstance().getEnchantRegister().getEnchantmentFromID(this.getBaseEnchantment());
if(enchantment instanceof Execute) this.baseEnchantment = (Execute) enchantment;
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (!(victim instanceof Player)) return;
if (Math.random() < this.baseEnchantment.procChance * (7+(level*2))) {
Player victimPlayer = (Player) victim;
super.getDamageHandler().increaseDamage((this.damageBuffPerLevel * level), event, this.getName());
victimPlayer.getWorld().playEffect(victimPlayer.getEyeLocation(), Effect.STEP_SOUND, Material.REDSTONE_WIRE);
this.baseEnchantment.particle.setLocation(victimPlayer.getLocation()).display(PVPUtils.getNearbyPlayersExceptPlayer(victimPlayer, 20));
}
}
@Override
public String getBaseEnchantment() {
return "execute";
}
}
@@ -0,0 +1,43 @@
package net.crankedpvp.crankedenchants.enchantments.heroic;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.enchantments.legendary.Deathbringer;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.cache.cooldowns.DoubleDamageCooldown;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorOutgoingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.HeroicEnchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class PlanetaryDeathbringer extends ArmorOutgoingPVPDamageEventEnchant implements HeroicEnchantment {
private Deathbringer baseEnchantment;
public PlanetaryDeathbringer() {
super("Planetary Deathbringer", EnchantTier.HEROIC, false, 3, GearType.ARMOR, "Has a chance to deal 2.5x damage", "to your target.");
Enchantment enchantment = CrankedEnchants.getInstance().getEnchantRegister().getEnchantmentFromID(this.getBaseEnchantment());
if(enchantment instanceof Deathbringer) this.baseEnchantment = (Deathbringer) enchantment;
}
@Override
public void runOutgoingDamageEvent(EntityDamageByEntityEvent event, Player attacker, LivingEntity victim, EnchantInfo enchantInfo) {
if (Math.random() < this.baseEnchantment.procChance * (this.baseEnchantment.getMax() + enchantInfo.getLevel())) {
if (CooldownUtils.isCooldownActive(attacker, "doubleDamageCooldown")) return;
CooldownUtils.registerCooldown(attacker, new DoubleDamageCooldown("doubleDamageCooldown", this.baseEnchantment.cooldown));
super.getDamageHandler().increaseDamage(this.baseEnchantment.damageBuff, event, this.getName());
attacker.sendMessage(CC.translate("&d&l** PLANETARY DEATHBRINGER **"));
}
}
@Override
public String getBaseEnchantment() {
return "deathbringer";
}
}
@@ -0,0 +1,43 @@
package net.crankedpvp.crankedenchants.enchantments.heroic;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
import net.crankedpvp.crankedenchants.enchantments.ultimate.Metaphysical;
import net.crankedpvp.crankedenchants.events.SlownessEnchantProcEvent;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.HeroicEnchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
public class PolymorphicMetaphysical extends Enchantment implements HeroicEnchantment {
@ConfigValue
private String message = "&d&l** POLYMORPHIC METAPHYSICAL (&8{blocked-enchantment} blocked&d&l) **";
private Metaphysical baseEnchantment;
public PolymorphicMetaphysical() {
super("Polymorphic Metaphysical", EnchantTier.HEROIC, false, 4, GearType.BOOTS, "A chance to resist the slowness given by enemy Trap, Snare, and Pummel enchantments.", "At max level, you will only be affected approx. 10% of the time.");
Enchantment enchantment = CrankedEnchants.getInstance().getEnchantRegister().getEnchantmentFromID(this.getBaseEnchantment());
if(enchantment instanceof Metaphysical) this.baseEnchantment = (Metaphysical) enchantment;
}
@EventHandler
public void runEnchantDamageProcEvent(SlownessEnchantProcEvent event) {
if (!(event.getVictim() instanceof Player)) return;
if (CrankedEnchantsAPI.hasEnchantment(((Player) event.getVictim()), this)) {
if (Math.random() < this.baseEnchantment.procChance * (this.baseEnchantment.getMax() + CrankedEnchantsAPI.getEnchantmentLevel((Player) event.getVictim(), this))) {
event.setCancelled(true);
super.sendMessage(event.getVictim(), this.message, str -> str.replace("{blocked-enchantment}", event.getEnchantment().getName()));
}
}
}
@Override
public String getBaseEnchantment() {
return "metaphysical";
}
}
@@ -0,0 +1,56 @@
package net.crankedpvp.crankedenchants.enchantments.heroic;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.enchantments.ultimate.Assassin;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.HeroicEnchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class ShadowAssassin extends WeaponDamageEventEnchant implements HeroicEnchantment {
private Assassin baseEnchantment;
public ShadowAssassin() {
super("Shadow Assassin", EnchantTier.HEROIC, 5, GearType.SWORD, "The closer you are to your enemy,", "the more damage you deal (up to 1.5x).", "However, if you are more than 2 blocks away,", "you will deal LESS damage than normal.");
Enchantment enchantment = CrankedEnchants.getInstance().getEnchantRegister().getEnchantmentFromID(this.getBaseEnchantment());
if(enchantment instanceof Assassin) this.baseEnchantment = (Assassin) enchantment;
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if(!(victim instanceof Player)) return;
final double distance = victim.getLocation().distance(attacker.getLocation());
if (distance < 0.25) {
super.getDamageHandler().increaseDamage(this.baseEnchantment.getOneQuarterBlocksPerLevel() * level * 2, event, this.getName());
return;
}
if (distance < 0.5) {
super.getDamageHandler().increaseDamage(this.baseEnchantment.getOneHalfBlocksPerLevel() * level * 2, event, this.getName());
return;
}
if (distance < 0.75) {
super.getDamageHandler().increaseDamage(this.baseEnchantment.getThreeQuartersBlocksPerLevel() * level * 2, event, this.getName());
return;
}
if (distance < 1.0) {
super.getDamageHandler().increaseDamage(this.baseEnchantment.getOneBlockPerLevel() * level * 2, event, this.getName());
return;
}
if (distance < 2.0) {
super.getDamageHandler().increaseDamage(this.baseEnchantment.getTwoBlocksPerLevel() * level * 2, event, this.getName());
}
}
@Override
public String getBaseEnchantment() {
return "assassin";
}
}
@@ -0,0 +1,48 @@
package net.crankedpvp.crankedenchants.enchantments.heroic;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.enchantments.elite.Hardened;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.HeroicEnchantment;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Reloadable;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.inventory.ItemStack;
public class SoulHardened extends ArmorIncomingPVPDamageEventEnchant implements Reloadable, HeroicEnchantment {
private Hardened baseEnchantment;
public SoulHardened() {
super("Soul Hardened", EnchantTier.HEROIC, false, 3, GearType.ARMOR, "Armor takes less durability damage.");
Enchantment enchantment = CrankedEnchants.getInstance().getEnchantRegister().getEnchantmentFromID(this.getBaseEnchantment());
if(enchantment instanceof Hardened) this.baseEnchantment = (Hardened) enchantment;
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (Math.random() < this.baseEnchantment.procChance * enchantInfo.getLevel()) {
this.baseEnchantment.particle.setLocation(victim.getLocation()).display(PVPUtils.getNearbyPlayersExceptPlayer(victim, 30));
for (ItemStack itemStack : victim.getInventory().getArmorContents()) {
if (!ItemUtils.isArmor(itemStack)) continue;
itemStack.setDurability((short) (itemStack.getDurability() - (this.baseEnchantment.getMax() + enchantInfo.getLevel() + 2)));
}
}
}
@Override
public void reloadValues() {
}
@Override
public String getBaseEnchantment() {
return "hardened";
}
}
@@ -0,0 +1,45 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.cache.enchantscache.AegisCache;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.utils.CacheUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Aegis extends ArmorIncomingPVPDamageEventEnchant {
public Aegis() {
super("Aegis", EnchantTier.LEGENDARY, false, 6, GearType.CHESTPLATE, "If you are taking damage from more than (8-level) enemies in a short period,", "the damage from any additional players beyond that initial group", "will be halved.");
}
@ConfigValue
private double damageReduction = 2;
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (!(attacker instanceof Player)) return;
Player attackerPlayer = ((Player) attacker);
AegisCache aegisCache = CacheUtils.getAegisCache(victim);
aegisCache.addPlayerToList(attackerPlayer);
if (!aegisCache.isStillActive()) {
aegisCache.updateHitTime();
aegisCache.clearPlayers();
return;
}
if (aegisCache.getAmountOfPlayers() >= 4) {
//super.getDamageHandler().reduceDamage(aegisCache.getAmountOfPlayers() * damageReduction, event, this.getName());
super.getDamageHandler().reduceDamage(damageReduction, event, this.getName());
}
}
}
@@ -0,0 +1,41 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.enchantscache.AntiGankCache;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.utils.CacheUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class AntiGank extends WeaponDamageEventEnchant {
public AntiGank() {
super("Anti Gank", EnchantTier.LEGENDARY, 4, GearType.AXE, "If more than (6-level) enemies hit you in a short period,", "your outgoing damage will be multiplied by up to 1.5x", "depending on the amount of enemies nearby.");
}
@ConfigValue
private double damageAddition = 5;
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (!(victim instanceof Player)) return;
Player victimPlayer = ((Player) victim);
AntiGankCache antiGankCache = CacheUtils.getAntiGankCache(attacker);
antiGankCache.addPlayerToList(victimPlayer);
if (!antiGankCache.isStillActive()) {
antiGankCache.updateHitTime();
antiGankCache.clearPlayers();
return;
}
if (antiGankCache.getAmountOfPlayers() >= 6 - level) {
super.getDamageHandler().increaseDamage(damageAddition * antiGankCache.getAmountOfPlayers(), event, this.getName());
}
}
}
@@ -0,0 +1,59 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Reloadable;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Silenceable;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.Effect;
import org.bukkit.Material;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import xyz.xenondevs.particle.ParticleBuilder;
import xyz.xenondevs.particle.ParticleEffect;
import xyz.xenondevs.particle.data.texture.BlockTexture;
public class Armored extends ArmorIncomingPVPDamageEventEnchant implements Silenceable, Reloadable {
@ConfigValue
private double damageNegationMultiplier = 1.85;
private ParticleBuilder particle;
@ConfigValue
private int particleAmount = 1000;
@ConfigValue
private double particleYoffset = 0.7;
@ConfigValue
private double particleSpeed = 0.05;
public Armored() {
super("Armored", EnchantTier.LEGENDARY, true, 4, GearType.ARMOR, "Decreases damage from enemy swords by", "x1.85 per level");
this.reloadValues();
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (!(attacker instanceof Player)) return;
if (((Player) attacker).getItemInHand() == null) return;
if (!ItemUtils.isSword(((Player) attacker).getItemInHand())) return;
double damageNegation = enchantInfo.getLevel() * damageNegationMultiplier;
super.getDamageHandler().reduceDamage(damageNegation, event, this.getName());
this.particle.setLocation(victim.getLocation()).display(PVPUtils.getNearbyPlayersExceptPlayer(victim, 20));
victim.playEffect(victim.getLocation(), Effect.STEP_SOUND, Material.DIAMOND_BLOCK);
}
@Override
public void reloadValues() {
this.particle = new ParticleBuilder(ParticleEffect.BLOCK_DUST)
.setParticleData(new BlockTexture(Material.DIAMOND_BLOCK))
.setAmount(particleAmount)
.setOffsetY((float) particleYoffset)
.setSpeed((float) particleSpeed);
}
}
@@ -0,0 +1,34 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.Material;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Barbarian extends WeaponDamageEventEnchant {
@ConfigValue
private int damageBuff = 20;
public Barbarian() {
super("Barbarian", EnchantTier.LEGENDARY, 4, GearType.AXE, "Multiplies damage against players who are wielding an AXE", " at the time they are hit.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (!(victim instanceof Player)) return;
Player playerVictim = ((Player) victim);
if (playerVictim.getItemInHand() == null || playerVictim.getItemInHand().getType() == Material.AIR) return;
if (!ItemUtils.isAxe(playerVictim.getItemInHand())) return;
super.getDamageHandler().increaseDamage(damageBuff, event, this.getName());
}
}
@@ -0,0 +1,33 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.inventory.ItemStack;
public class Blacksmith extends WeaponDamageEventEnchant {
@ConfigValue
private double procChance = 0.06;
public Blacksmith() {
super("Blacksmith", EnchantTier.LEGENDARY, 5, GearType.AXE, "Chance to heal your most damaged piece of armor", "by 1-2 durability whenever you hit a player,", " but when it procs your attack will", "only deal 50% of the normal damage.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (Math.random() < procChance * level) {
for (ItemStack itemStack : attacker.getInventory().getArmorContents()) {
if (!ItemUtils.isArmor(itemStack)) continue;
itemStack.setDurability((short) (itemStack.getDurability() - 2));
}
super.getDamageHandler().reduceDamage(50, event, this.getName());
}
}
}
@@ -0,0 +1,38 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.Bukkit;
import org.bukkit.entity.Entity;
import org.bukkit.entity.IronGolem;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class BloodLink extends Enchantment {
public BloodLink() {
super("Blood Link", EnchantTier.LEGENDARY, false, 5, GearType.ARMOR, "A chance to heal you for 1-2hp whenever", "your Guardians take damage.");
}
@EventHandler
public void onDamageGuardian(EntityDamageByEntityEvent event) {
if (!(event.getEntity() instanceof IronGolem)) return;
if (!(event.getDamager() instanceof Player)) return;
Entity entity = event.getEntity();
if (entity.isDead()) return;
if (!entity.hasMetadata("guardian-owner")) return;
Player golemOwner = Bukkit.getPlayer(String.valueOf(entity.getMetadata("guardian-owner")));
if (golemOwner == null) return;
if (CrankedEnchantsAPI.hasEnchantment(golemOwner, this)) {
super.getDamageHandler().healEntity(golemOwner, 2, this.getName());
}
}
}
@@ -0,0 +1,12 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
public class BloodLust extends Enchantment {
public BloodLust() {
super("Blood Lust", EnchantTier.LEGENDARY, false, 6, GearType.CHESTPLATE, "A chance to heal you whenever an enemy", "player within 7x7 blocks is damaged", "by the Bleed enchantment. ");
}
}
@@ -0,0 +1,27 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class BossSlayer extends WeaponDamageEventEnchant {
private double percent = 20;
public BossSlayer() {
super("Boss Slayer", EnchantTier.LEGENDARY, 5, GearType.WEAPON, "Deal significantly more damage to bosses");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if(victim instanceof Player) return;
super.getDamageHandler().increaseDamage(percent * level, event, "Boss Slayer");
}
}
@@ -0,0 +1,26 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
import net.crankedpvp.crankedenchants.events.EnchantProcOnEntityEvent;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.BlindingEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
public class Clarity extends Enchantment {
public Clarity() {
super("Clarity", EnchantTier.LEGENDARY, false, 3, GearType.ARMOR, "Immune to Blindness up to level of clarity enchantment.");
}
@EventHandler
public void runEnchantDamageProcEvent(EnchantProcOnEntityEvent event) {
if (!(event.getEnchantment() instanceof BlindingEnchant)) return;
if (!(event.getVictim() instanceof Player)) return;
if (CrankedEnchantsAPI.hasEnchantment((Player) event.getVictim(), this)) {
event.setCancelled(true);
}
}
}
@@ -0,0 +1,35 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class DeathGod extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.07;
@ConfigValue
private int cooldown = 30;
@ConfigValue
private String message = "&6&l* DEATH GOD [&6{heal-amount} HP&l] *";
public DeathGod() {
super("Death God", EnchantTier.LEGENDARY, false, 3, GearType.HELMET, "Attacks that bring your HP to (level+4) hearts or lower", "have a chance to heal you for (level+5) hearts instead.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (super.isOnCooldown(victim)) return;
if (victim.getHealth() > enchantInfo.getLevel() + 4) return;
if (Math.random() < procChance * enchantInfo.getLevel()) {
super.getDamageHandler().healEntity(victim, enchantInfo.getLevel() + 5, this.getName());
super.registerCooldown(victim, cooldown);
super.sendMessage(victim, message, str -> str.replace("{heal-amount}", String.valueOf(enchantInfo.getLevel() + 5)));
}
}
}
@@ -0,0 +1,37 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.cache.cooldowns.DoubleDamageCooldown;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorOutgoingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Deathbringer extends ArmorOutgoingPVPDamageEventEnchant {
@ConfigValue
public double procChance = 0.03;
@ConfigValue
public double damageBuff = 25;
@ConfigValue
public int cooldown = 5;
public Deathbringer() {
super("Deathbringer", EnchantTier.LEGENDARY, false, 3, GearType.ARMOR, "Has a chance to deal double damage", "to your target.");
}
@Override
public void runOutgoingDamageEvent(EntityDamageByEntityEvent event, Player attacker, LivingEntity victim, EnchantInfo enchantInfo) {
if (Math.random() < procChance * enchantInfo.getLevel()) {
if (CooldownUtils.isCooldownActive(attacker, "doubleDamageCooldown")) return;
CooldownUtils.registerCooldown(attacker, new DoubleDamageCooldown("doubleDamageCooldown", cooldown));
super.getDamageHandler().increaseDamage(damageBuff, event, this.getName());
attacker.sendMessage(CC.translate("&6&l** DEATHBRINGER **"));
}
}
}
@@ -0,0 +1,55 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.perms.Relation;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.GameMode;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Destruction extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.08;
@ConfigValue
private double range = 7.0;
@ConfigValue
private int witherLevel = 1;
@ConfigValue
private int cooldown = 30;
public Destruction() {
super("Destruction", EnchantTier.LEGENDARY, false, 5, GearType.HELMET, "Automatically damages and debuffs all nearby enemies.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (super.isOnCooldown(victim)) return;
if (Math.random() < procChance) {
int level = enchantInfo.getLevel();
FPlayer fPlayer = FPlayers.getInstance().getByPlayer(victim);
victim.getNearbyEntities(range, range, range).forEach(entity -> {
if (!(entity instanceof Player)) return;
Player nearbyPlayer = (Player) entity;
if (nearbyPlayer.getGameMode() != GameMode.SURVIVAL) return;
if (!PVPUtils.canPvPInRegion(nearbyPlayer)) return;
FPlayer fPlayerNearby = FPlayers.getInstance().getByPlayer(nearbyPlayer);
if (fPlayer.getRelationTo(fPlayerNearby).isAtLeast(Relation.TRUCE)) return;
super.getDamageHandler().damage(nearbyPlayer, level > 4 ? 2 : 1, this.getName());
if (enchantInfo.getLevel() > 4 && Math.random() < 0.55) {
nearbyPlayer.addPotionEffect(new PotionEffect(PotionEffectType.WITHER, enchantInfo.getLevel() * 20, witherLevel, true));
}
});
super.registerCooldown(victim, cooldown);
}
}
}
@@ -0,0 +1,53 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.enchantscache.BleedStacksCache;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Reloadable;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedenchants.utils.CacheUtils;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.Material;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import xyz.xenondevs.particle.ParticleBuilder;
import xyz.xenondevs.particle.ParticleEffect;
import xyz.xenondevs.particle.data.texture.BlockTexture;
public class Devour extends WeaponDamageEventEnchant implements Reloadable {
private ParticleBuilder particle;
@ConfigValue
private int particleAmount = 50;
@ConfigValue
private double particleYoffset = 0.7;
@ConfigValue
private double particleSpeed = 0.1;
public Devour() {
super("Devour", EnchantTier.LEGENDARY, 4, GearType.AXE, "Multiplies damage dealt to players with active bleed stacks", "from the Bleed enchantment.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (!(victim instanceof Player)) return;
Player victimPlayer = ((Player) victim);
BleedStacksCache victimBleedStack = CacheUtils.getBleedStackCache(victimPlayer);
this.particle.setLocation(victim.getLocation()).display(PVPUtils.getNearbyPlayersExceptPlayer(victimPlayer, 20));
super.getDamageHandler().increaseDamage(victimBleedStack.getBleedStack() * 10, event, this.getName());
}
@Override
public void reloadValues() {
this.particle = new ParticleBuilder(ParticleEffect.BLOCK_DUST)
.setParticleData(new BlockTexture(Material.MYCEL))
.setAmount(particleAmount)
.setOffsetY((float) particleYoffset)
.setSpeed((float) particleSpeed);
}
}
@@ -0,0 +1,50 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.cache.enchantscache.DiminishCache;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.utils.CacheUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import java.text.DecimalFormat;
public class Diminish extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.0015;
@ConfigValue
private String message = "&e&l* DIMINISH [&eDMG {damage}&l] *";
private DecimalFormat df;
public Diminish() {
super("Diminish", EnchantTier.LEGENDARY, false, 6, GearType.CHESTPLATE, "When this effect procs, the next", "attack dealt to you cannot deal more", "than the total amount of damage / 2", "you took from the previous attack.");
this.df = new DecimalFormat("#.##");
}
//TODO: finish message
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
DiminishCache diminishCache = CacheUtils.getDiminishLastAttackCache(victim);
if (diminishCache.getLastDamage() != -1.0) {
final double maxDmg = diminishCache.getLastDamage() / 2;
if (event.getDamage() > maxDmg) {
super.getDamageHandler().setDamage(event, maxDmg, super.getName());
diminishCache.setLastDamage(-1.0);
return;
}
}
if (Math.random() < this.procChance * enchantInfo.getLevel()) {
diminishCache.setLastDamage(event.getDamage(EntityDamageEvent.DamageModifier.BASE));
super.sendMessage(victim, this.message, str -> str.replace("{damage}", String.valueOf(this.df.format(Math.max(0.0, event.getFinalDamage())))));
}
}
}
@@ -0,0 +1,42 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.cooldowns.DoubleDamageCooldown;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import org.bukkit.Bukkit;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class DoubleStrike extends WeaponDamageEventEnchant {
@ConfigValue
private double procChance = 0.04;
@ConfigValue
private int cooldown = 5;
public DoubleStrike() {
super("Double Strike", EnchantTier.LEGENDARY, 3, GearType.SWORD, "Has a chance to attack twice in one swing.", "All your enchants can re-proc on", "this second attack, and it occurs", "instantly");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if(victim instanceof Player) {
if(Math.random() < procChance * level) {
if (CooldownUtils.isCooldownActive(attacker, "doubleDamageCooldown")) return;
CooldownUtils.registerCooldown(attacker, new DoubleDamageCooldown("doubleDamageCooldown", cooldown));
Bukkit.getScheduler().runTaskLater(CrankedEnchants.getInstance(), () -> {
if(victim.isDead()) return;
super.getDamageHandler().damage(victim, event.getFinalDamage(), "Double Strike");
attacker.sendMessage(CC.translate("&6&l** DOUBLE STRIKE **"));
}, 2L);
}
}
}
}
@@ -0,0 +1,73 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.language.Language;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorEquipEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import net.crankedpvp.crankedutils.utils.RomanNumeral;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
public class Drunk extends ArmorEquipEventEnchant {
public Drunk() {
super("Drunk", EnchantTier.LEGENDARY, false, 4, GearType.HELMET, "Slowness and slow swing with", "buffed strength.");
}
@Override
public void runArmorEquipEvent(Player player, int level) {
PotionEffectUtils.addPotionEffect(player, PotionEffectType.INCREASE_DAMAGE, Math.min(level, 3), "DrunkStrength");
PotionEffectUtils.addPotionEffect(player, PotionEffectType.SLOW, Math.min(level, 3), "DrunkSlow");
PotionEffectUtils.addPotionEffect(player, PotionEffectType.SLOW_DIGGING, Math.min(level, 3), "DrunkSlowDigging");
Language.EQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Strength")
.replace("{effect-level}", RomanNumeral.convertToRoman(Math.min(level, 3)))
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
Language.EQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Slowness")
.replace("{effect-level}", RomanNumeral.convertToRoman(Math.min(level, 3)))
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
Language.EQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Mining Fatigue")
.replace("{effect-level}", RomanNumeral.convertToRoman(3))
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
}
@Override
public void runArmorUnEquipEvent(Player player, int level) {
PotionEffectUtils.removePotionEffect(player, "DrunkStrength");
PotionEffectUtils.removePotionEffect(player, "DrunkSlow");
PotionEffectUtils.removePotionEffect(player, "DrunkSlowDigging");
Language.UNEQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Strength")
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
Language.UNEQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Slowness")
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
Language.UNEQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Mining Fatigue")
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
}
}
@@ -0,0 +1,32 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Enlighted extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
public double procChance = 0.075;
@ConfigValue
public int cooldown = 20;
public Enlighted() {
super("Enlighted", EnchantTier.LEGENDARY, true, 3, GearType.ARMOR, "Has a chance to heal you", "while taking damage");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (super.isOnCooldown(victim)) return;
if (Math.random() < procChance * enchantInfo.getLevel()) {
super.getDamageHandler().healEntity(victim, enchantInfo.getAmount(), this.getName());
super.registerCooldown(victim, cooldown);
}
}
}
@@ -0,0 +1,40 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.language.Language;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorEquipEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import net.crankedpvp.crankedutils.utils.RomanNumeral;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
public class Gears extends ArmorEquipEventEnchant {
public Gears() {
super("Gears", EnchantTier.LEGENDARY, false, 3, GearType.BOOTS, "Added speed when equipped.");
}
@Override
public void runArmorEquipEvent(Player player, int level) {
PotionEffectUtils.addPotionEffect(player, PotionEffectType.SPEED, level, "GearsEnchant");
Language.EQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Speed")
.replace("{effect-level}", RomanNumeral.convertToRoman(level))
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
}
@Override
public void runArmorUnEquipEvent(Player player, int level) {
PotionEffectUtils.removePotionEffect(player, "GearsEnchant");
Language.UNEQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Speed")
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
}
}
@@ -0,0 +1,25 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDeathEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDeathEvent;
public class Inquisitive extends WeaponDeathEventEnchant {
@ConfigValue
private int expMultiplier = 2;
public Inquisitive() {
super("Inquisitive", EnchantTier.LEGENDARY, 4, GearType.SWORD, "Increases EXP drops from mobs.");
}
@Override
public void runEntityDeathEvent(EntityDeathEvent event, Player killer, LivingEntity victim, int level) {
event.setDroppedExp((event.getDroppedExp() * level) * expMultiplier);
}
}
@@ -0,0 +1,41 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.inventory.ItemStack;
public class Insanity extends WeaponDamageEventEnchant {
@ConfigValue
private double hookBuff = 1;
@ConfigValue
private double axeBuff = 4.5;
public Insanity() {
super("Insanity", EnchantTier.LEGENDARY, 8, GearType.AXE, "Multiplies damage against players who", "are wielding a sword at the time", "they are hit");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (!(victim instanceof Player)) return;
Player playerVictim = (Player) victim;
if (playerVictim.getItemInHand() == null) return;
if (attacker.getItemInHand() == null) return;
if (!GearType.SWORD.getItems().contains(playerVictim.getItemInHand().getType())) return;
double damageBuff = isActuallyAnAxe(attacker.getItemInHand()) ? this.axeBuff : this.hookBuff;
super.getDamageHandler().increaseDamage(damageBuff * level, event, this.getName());
}
private boolean isActuallyAnAxe(ItemStack itemStack) {
return (!ItemUtils.isAirOrNull(itemStack) && itemStack
.getType().name().contains("_AXE"));
}
}
@@ -0,0 +1,30 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponIncomingDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import java.util.concurrent.ThreadLocalRandom;
public class Inversion extends WeaponIncomingDamageEventEnchant {
@ConfigValue
private double procChance = 0.035;
public Inversion() {
super("Inversion", EnchantTier.LEGENDARY, 4, GearType.SWORD, "Damage dealt to you has a % chance to be blocked", "and heal you for 1-3 HP instead.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, int level) {
if (Math.random() < procChance * level) {
super.getDamageHandler().cancelDamage(event, this.getName());
super.getDamageHandler().healEntity(victim, ThreadLocalRandom.current().nextInt(1, 4), this.getName());
}
}
}
@@ -0,0 +1,34 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffectType;
public class Judgement extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.01;
@ConfigValue
private int durationInSeconds = 2;
public Judgement() {
super("Judgement", EnchantTier.LEGENDARY, false, 5, GearType.ARMOR, "Chance of adding regeneration to", "yourself when being attacked");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (super.isOnCooldown(victim)) return;
int level = enchantInfo.getLevel() <= 3 ? 0 : enchantInfo.getLevel() - 3;
if (Math.random() < procChance * enchantInfo.getLevel()) {
PotionEffectUtils.addPotionEffect(victim, PotionEffectType.REGENERATION, level, "JudgementEnchant", durationInSeconds);
super.registerCooldown(victim, 30);
}
}
}
@@ -0,0 +1,48 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.perms.Relation;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorOutgoingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.GameMode;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Leadership extends ArmorOutgoingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.06;
@ConfigValue
private int range = 12;
public Leadership() {
super("Leadership", EnchantTier.LEGENDARY, false, 5, GearType.ARMOR, "The more allies near you, the more damage you deal.");
}
@Override
public void runOutgoingDamageEvent(EntityDamageByEntityEvent event, Player attacker, LivingEntity victim, EnchantInfo enchantInfo) {
if (Math.random() < this.procChance * enchantInfo.getLevel()) {
int counter = 0;
FPlayer fPlayer = FPlayers.getInstance().getByPlayer(attacker);
for (Entity nearbyEntity : attacker.getNearbyEntities(this.range, this.range, this.range)) {
if (!(nearbyEntity instanceof Player)) return;
Player nearbyPlayer = (Player) nearbyEntity;
if (nearbyPlayer.getGameMode() != GameMode.SURVIVAL) return;
if (!PVPUtils.canPvPInRegion(nearbyPlayer)) return;
FPlayer fPlayerNearby = FPlayers.getInstance().getByPlayer(nearbyPlayer);
if (fPlayer.getRelationTo(fPlayerNearby).isAtMost(Relation.NEUTRAL)) return;
counter++;
}
super.getDamageHandler().increaseDamage(Math.max(counter, 5) * 4, event, this.getName());
}
}
}
@@ -0,0 +1,39 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedmasks.CrankedMasks;
import net.crankedpvp.crankedmasks.CrankedMasksAPI;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Lifesteal extends WeaponDamageEventEnchant {
@ConfigValue
private double procChance = 0.01;
@ConfigValue
private double healAmount = 5.0;
@ConfigValue
private int cooldown = 15;
public Lifesteal() {
super("Lifesteal", EnchantTier.LEGENDARY, 5, GearType.SWORD, "Has a chance of regaining health when", "attacking a player");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (!(victim instanceof Player)) return;
if (super.isOnCooldown(attacker)) return;
if (CrankedMasksAPI.hasMaskEquipped((Player) victim, CrankedMasks.getInstance().getMasksRegister().getMaskFromID("vampire"))) {
return;
}
if (Math.random() < this.procChance * level) {
super.getDamageHandler().healEntity(attacker, this.healAmount, this.getName());
super.getDamageHandler().removeHealth(attacker, this.healAmount, this.getName());
super.registerCooldown(attacker, this.cooldown);
}
}
}
@@ -0,0 +1,42 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.language.Language;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorEquipEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import net.crankedpvp.crankedutils.utils.RomanNumeral;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType;
public class Overload extends ArmorEquipEventEnchant {
public Overload() {
super("Overload", EnchantTier.LEGENDARY, false, 3, GearType.ARMOR, "Increases the wearer's total health.");
}
@Override
public void runArmorEquipEvent(Player player, int level) {
PotionEffectUtils.addPotionEffect(player, PotionEffectType.HEALTH_BOOST, level, "OverloadEnchant");
Language.EQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Health Boost")
.replace("{effect-level}", RomanNumeral.convertToRoman(level))
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
}
@Override
public void runArmorUnEquipEvent(Player player, int level) {
PotionEffectUtils.removePotionEffect(player, "OverloadEnchant");
Language.UNEQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Health Boost")
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
}
}
@@ -0,0 +1,68 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorEquipEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.Player;
public class Platemail extends ArmorEquipEventEnchant {
public Platemail() {
super("Platemail", EnchantTier.LEGENDARY, false, 2, GearType.ARMOR, "This enchant is currently disabled");
//"Gain damage resistance at the tradeoff", "of slowness."
}
@Override
public void runArmorEquipEvent(Player player, int level) {
}
@Override
public void runArmorUnEquipEvent(Player player, int level) {
}
/*
@Override
public void runArmorEquipEvent(Player player, int level) {
PotionEffectUtils.addPotionEffect(player, PotionEffectType.DAMAGE_RESISTANCE, level, "PlatemailEnchantRes");
PotionEffectUtils.addPotionEffect(player, PotionEffectType.SLOW, level, "PlatemailEnchantSlow");
Language.EQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Resistance")
.replace("{effect-level}", RomanNumeral.convertToRoman(level))
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
Language.EQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Slowness")
.replace("{effect-level}", RomanNumeral.convertToRoman(level))
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
}
@Override
public void runArmorUnEquipEvent(Player player, int level) {
PotionEffectUtils.removePotionEffect(player, "PlatemailEnchantRes");
PotionEffectUtils.removePotionEffect(player, "PlatemailEnchantSlow");
player.removePotionEffect(PotionEffectType.SLOW);
Language.UNEQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Resistance")
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
Language.UNEQUIP_POTION_ENCHANT.send(player,
str -> str
.replace("{effect}", "Slowness")
.replace("{enchant}", this.getName())
.replace("{enchant-level}", RomanNumeral.convertToRoman(level))
);
}
*/
}
@@ -0,0 +1,55 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.perms.Relation;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.GameMode;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Protection extends ArmorIncomingPVPDamageEventEnchant {
@ConfigValue
private double procChance = 0.08;
@ConfigValue
private double range = 7.0;
@ConfigValue
private int regenerationLevel = 1;
@ConfigValue
private int cooldown = 20;
public Protection() {
super("Protection", EnchantTier.LEGENDARY, false, 5, GearType.ARMOR, "Automatically heals and buffs all nearby faction allies.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (super.isOnCooldown(victim)) return;
if (Math.random() < procChance) {
int level = enchantInfo.getLevel();
FPlayer fPlayer = FPlayers.getInstance().getByPlayer(victim);
victim.getNearbyEntities(range, range, range).forEach(entity -> {
if (!(entity instanceof Player)) return;
Player nearbyPlayer = (Player) entity;
if (nearbyPlayer.getGameMode() != GameMode.SURVIVAL) return;
if (!PVPUtils.canPvPInRegion(nearbyPlayer)) return;
FPlayer fPlayerNearby = FPlayers.getInstance().getByPlayer(nearbyPlayer);
if (fPlayer.getRelationTo(fPlayerNearby).isAtMost(Relation.NEUTRAL)) return;
super.getDamageHandler().healEntity(nearbyPlayer, level > 4 ? 2 : 1, this.getName());
if (enchantInfo.getLevel() > 3 && Math.random() < 0.5) {
nearbyPlayer.addPotionEffect(new PotionEffect(PotionEffectType.REGENERATION, enchantInfo.getLevel() * 20, regenerationLevel, true));
}
});
super.registerCooldown(victim, cooldown);
}
}
}
@@ -0,0 +1,95 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.enchantscache.RageStacksCache;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Reloadable;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.utils.CacheUtils;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import net.crankedpvp.staritems.StarItemsAPI;
import net.objecthunter.exp4j.Expression;
import net.objecthunter.exp4j.ExpressionBuilder;
import org.bukkit.Material;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import xyz.xenondevs.particle.ParticleBuilder;
import xyz.xenondevs.particle.ParticleEffect;
import xyz.xenondevs.particle.data.texture.BlockTexture;
public class Rage extends WeaponDamageEventEnchant implements Reloadable {
@ConfigValue
private String damageFormula = "(level * rageStack) * 2";
private Expression damageExpression;
private ParticleBuilder particle;
@ConfigValue
private int particleAmount = 1000;
@ConfigValue
private double particleYoffset = 1.2;
@ConfigValue
private double particleSpeed = 0.05;
public Rage() {
super("Rage", EnchantTier.LEGENDARY, 6, GearType.WEAPON, "More consecutive hits cause more", "damage to be dealt.");
this.reloadValues();
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (!(victim instanceof Player)) return;
Player victimPlayer = (Player) victim;
RageStacksCache rageStacksCache = CacheUtils.getRageStackCache(attacker);
if (rageStacksCache.getLastRageStackTime() + 30000 < System.currentTimeMillis() || !rageStacksCache.isSameVictim(victimPlayer)) {
rageStacksCache.updateLastRageStackTime();
rageStacksCache.resetRageStack();
rageStacksCache.updateVictim(victimPlayer);
return;
}
double rageDamage = this.damageExpression
.setVariable("level", level)
.setVariable("rageStack", rageStacksCache.getRageStack())
.evaluate();
//if(AdminWeaponsAPI.hasAdminWeaponEquipped(attacker, "nanoblackreaper")) rageDamage *= 1.075;
//if(AdminWeaponsAPI.hasAdminWeaponEquipped(attacker, "elementalexcalibur")) rageDamage *= 1.035;
if(StarItemsAPI.playerHasStarItem(attacker, "combo")) rageDamage*=1.25;
super.getDamageHandler().increaseDamage(rageDamage, event, this.getName());
if (rageStacksCache.getRageStack() > 1) {
this.particle.setLocation(victim.getLocation()).display(PVPUtils.getNearbyPlayersExceptPlayer(victimPlayer, 20));
}
rageStacksCache.incrementRageStack();
rageStacksCache.updateLastRageStackTime();
rageStacksCache.updateVictim(victimPlayer);
}
@EventHandler
public void onDamage(EntityDamageByEntityEvent event) {
if (event.getEntity() instanceof Player && event.getDamager() instanceof Player) {
Player player = (Player) event.getEntity();
RageStacksCache victimRageStack = CacheUtils.getRageStackCache(player);
if (victimRageStack.getRageStack() > 0) {
victimRageStack.resetRageStack();
}
}
}
@Override
public void reloadValues() {
this.damageExpression = new ExpressionBuilder(this.damageFormula).variable("level").variable("rageStack").build();
this.particle = new ParticleBuilder(ParticleEffect.BLOCK_DUST)
.setParticleData(new BlockTexture(Material.REDSTONE_BLOCK))
.setAmount(this.particleAmount)
.setOffsetY((float) this.particleYoffset)
.setSpeed((float) this.particleSpeed);
}
}
@@ -0,0 +1,133 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import net.crankedpvp.adminweapons.AdminWeaponsAPI;
import net.crankedpvp.crankedarmor.CrankedArmorAPI;
import net.crankedpvp.crankedarmor.struct.ArmorSet;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
import net.crankedpvp.crankedenchants.events.EnchantProcOnEntityEvent;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.cooldowns.DragonReflectSilenceCooldown;
import net.crankedpvp.crankedenchants.struct.cache.enchantscache.SilenceCache;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Silenceable;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.utils.CacheUtils;
import net.crankedpvp.crankedmasks.CrankedMasksAPI;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import net.crankedpvp.staritems.StarItemsAPI;
import net.crankedpvp.staritems.StarItemsPlugin;
import org.bukkit.Bukkit;
import org.bukkit.Sound;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import java.util.concurrent.ThreadLocalRandom;
public class Silence extends WeaponDamageEventEnchant {
@ConfigValue
private double procChance = 0.05;
@ConfigValue
private int cooldown = 30;
@ConfigValue
private String messageAttacker = "&5&l* SILENCE &7[{duration}s]&5&l *";
@ConfigValue
private String messageVictim = "&5&l* SILENCED &7[{duration}s]&5&l *";
@ConfigValue
private int dragonSetReflectSilenceCooldown = 15;
@ConfigValue
private int dragonSetReflectSilenceChance = 20;
@ConfigValue
private String dragonSetReflectSilenceMessage = "&d&lDragon &8➥ &7You have reflected your opponents &6silence &7enchant";
public Silence() {
super("Silence", EnchantTier.LEGENDARY, 4, GearType.SWORD, "Chance to stop activation of your enemies enchants.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victimEntity, Player attacker, int level) {
if (!(victimEntity instanceof Player)) return;
if (super.isOnCooldown(attacker)) return;
Player victimPlayer = (Player) victimEntity;
double extraProcChance = 0;
if(AdminWeaponsAPI.hasAdminWeaponEquipped(attacker, "yorukazu")) {
extraProcChance+=15;
}
if (Math.random() < (this.procChance * level) * (1+(extraProcChance/100))) {
SilenceCache silenceCache = CacheUtils.getSilenceCache(victimPlayer);
if (silenceCache.isSilenced()) return;
ArmorSet armorSet = CrankedArmorAPI.getCurrentArmorSet(victimPlayer);
if(armorSet!= null && armorSet.getID().equals("dragon") && ThreadLocalRandom.current().nextInt(101) < (this.dragonSetReflectSilenceChance)) {
if(!CooldownUtils.isCooldownActive(victimPlayer, "dragonreflectsilence")) {
CooldownUtils.registerCooldown(victimPlayer, new DragonReflectSilenceCooldown("dragonreflectsilence", this.dragonSetReflectSilenceCooldown));
this.runEntityDamageByEntityEvent(event, attacker, victimPlayer, level);
victimPlayer.sendMessage(CC.translate(this.dragonSetReflectSilenceMessage));
}
}
if(CrankedMasksAPI.hasMaskEquipped(victimPlayer, "antisilence") && Math.random() <= 0.1) {
victimPlayer.sendMessage(CC.translate("&f&l* ANTI SILENCE &7[BLOCKED SILENCE]&f&l *"));
return;
}
silenceCache.setSilenced(true);
int silenceTime = level;
if (CrankedEnchantsAPI.hasWeaponEnchantment(attacker, "solitude")) {
silenceTime += CrankedEnchantsAPI.getWeaponEnchantmentLevel(attacker, "solitude");
}
if(StarItemsAPI.playerHasStarItemInCache(victimPlayer)) {
if (StarItemsAPI.getStarItemFromCache(attacker).contains(StarItemsPlugin.getInstance().getStarItemManager().getStarItemFromID("blackoutblindfold"))) {
silenceTime*=1.35;
}
if (StarItemsAPI.getStarItemFromCache(victimPlayer).contains(StarItemsPlugin.getInstance().getStarItemManager().getStarItemFromID("absence"))) {
silenceTime*=0.75;
}
}
if(AdminWeaponsAPI.hasAdminWeaponEquipped(attacker, "kazeshini")) {
silenceTime*=1.125;
}
if(AdminWeaponsAPI.hasAdminWeaponEquipped(attacker, "yorukazu")) {
silenceTime*=1.25;
}
if(CrankedMasksAPI.hasMaskEquipped(victimPlayer, "antisilence")) {
silenceTime*=0.85;
}
Bukkit.getScheduler().runTaskLater(CrankedEnchants.getInstance(), () -> silenceCache.setSilenced(false), silenceTime * 20L);
super.registerCooldown(attacker, this.cooldown);
int finalSilenceTime = silenceTime;
super.sendMessage(attacker, this.messageAttacker, str -> str.replace("{duration}", String.valueOf(finalSilenceTime)));
super.sendMessage(victimEntity, this.messageVictim, str -> str.replace("{duration}", String.valueOf(finalSilenceTime)));
victimEntity.getWorld().playSound(victimEntity.getLocation(), Sound.WITHER_HURT, 1.0f, 0.25f);
}
}
@EventHandler
public void runEnchantDamageProcEvent(EnchantProcOnEntityEvent event) {
if (!(event.getEnchantment() instanceof Silenceable)) return;
if (!(event.getVictim() instanceof Player)) return;
if (CacheUtils.getSilenceCache((Player) event.getVictim()).isSilenced()) event.setCancelled(true);
}
}
@@ -0,0 +1,76 @@
package net.crankedpvp.crankedenchants.enchantments.legendary;
import com.massivecraft.factions.*;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.BlockBreakEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedutils.utils.BlockUtil;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockBreakEvent;
import java.util.Arrays;
import java.util.List;
public class Tray extends BlockBreakEventEnchant {
private final Board board = Board.getInstance();
private final FPlayers fPlayers = FPlayers.getInstance();
public Tray() {
super("Tray", EnchantTier.LEGENDARY, 1, GearType.PICKAXE, "Mine netherrack blocks in a large radius.");
}
public static List<Material> trayWhiteListedBlocks = Arrays.asList(Material.NETHERRACK);
@ConfigValue
private int radius = 6;
@Override
public void runBlockBreakEvent(BlockBreakEvent event, EnchantedItemBuilder enchantedItemBuilder) {
if (event.isCancelled()) return;
trayEffect(event.getBlock(), radius, event.getPlayer());
}
public void trayEffect(Block block, int r, Player p) {
FPlayer fplayer = fPlayers.getByPlayer(p);
Block target;
Faction locFac;
double borderRadius = block.getWorld().getWorldBorder().getSize() / 2;
final World world = block.getWorld();
final int startX = block.getX();
final int startY = block.getY();
final int startZ = block.getZ();
for (int x = -r; x <= r; x++) {
for (int z = -r; z <= r; z++) {
if (Math.abs(getAccurateCoord(startX + x)) >= borderRadius || Math.abs(getAccurateCoord(startZ + z)) >= borderRadius) continue;
target = world.getBlockAt(startX + x, startY, startZ + z);
locFac = board.getFactionAt(new FLocation(target.getLocation()));
if (!fplayer.getFaction().equals(locFac) && !locFac.isWilderness()) continue;
Material type = target.getType();
if (trayWhiteListedBlocks.contains(type)) {
BlockUtil.setAir(world, startX + x, startY, startZ + z, false);
}
if (type == Material.WATER || type == Material.STATIONARY_WATER || type == Material.NETHERRACK) {
BlockUtil.updatePhysics(world, startX + x, startY, startZ + z);
}
}
}
}
private double getAccurateCoord(double coord) {
if (coord < 0) return coord + 1.0;
return coord;
}
}
@@ -0,0 +1,25 @@
package net.crankedpvp.crankedenchants.enchantments.simple;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorEquipEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Aquatic extends ArmorEquipEventEnchant {
public Aquatic() {
super("Aquatic", EnchantTier.SIMPLE, false,1, GearType.HELMET, "Added water breathing when equipped.");
}
@Override
public void runArmorEquipEvent(Player player, int level) {
player.addPotionEffect(new PotionEffect(PotionEffectType.WATER_BREATHING, Integer.MAX_VALUE, level - 1), true);
}
@Override
public void runArmorUnEquipEvent(Player player, int level) {
player.removePotionEffect(PotionEffectType.WATER_BREATHING);
}
}
@@ -0,0 +1,36 @@
package net.crankedpvp.crankedenchants.enchantments.simple;
import net.crankedpvp.crankedenchants.struct.enchantstruct.BlockBreakEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.inventory.ItemStack;
public class AutoSmelt extends BlockBreakEventEnchant {
public AutoSmelt() {
super("Auto Smelt", EnchantTier.SIMPLE, 1, GearType.PICKAXE, "Smelts mined ores into ingots.");
}
@Override
public void runBlockBreakEvent(BlockBreakEvent event, EnchantedItemBuilder enchantedItemBuilder) {
Location location = event.getBlock().getLocation().add(0.5, 0.5, 0.5);
switch (event.getBlock().getType()) {
case IRON_ORE:
location.getWorld().dropItem(location, new ItemStack(Material.IRON_INGOT));
break;
case GOLD_ORE:
location.getWorld().dropItem(location, new ItemStack(Material.GOLD_INGOT));
break;
default:
return;
}
event.setCancelled(true);
event.getBlock().setType(Material.AIR);
}
}
@@ -0,0 +1,29 @@
package net.crankedpvp.crankedenchants.enchantments.simple;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Confusion extends WeaponDamageEventEnchant {
@ConfigValue
private double procChance = 0.006;
public Confusion() {
super("Insomnia", EnchantTier.SIMPLE, 7, GearType.AXE, "Chance to deal nausea to your victim. ");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (Math.random() < procChance * level) {
victim.addPotionEffect(new PotionEffect(PotionEffectType.CONFUSION, 80, 0, true));
}
}
}
@@ -0,0 +1,23 @@
package net.crankedpvp.crankedenchants.enchantments.simple;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDeathEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedutils.utils.items.SkullUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDeathEvent;
public class Decapitation extends WeaponDeathEventEnchant {
public Decapitation() {
super("Decapitation", EnchantTier.SIMPLE, 3, GearType.AXE, "Victims have a chance of dropping their head on death.");
}
@Override
public void runEntityDeathEvent(EntityDeathEvent event, Player killer, LivingEntity victim, int level) {
if (!(victim instanceof Player)) return;
killer.getInventory().addItem(SkullUtils.getSkullFromPlayer(((Player) victim)));
}
}
@@ -0,0 +1,21 @@
package net.crankedpvp.crankedenchants.enchantments.simple;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Epicness extends WeaponDamageEventEnchant {
public Epicness() {
super("Epicness", EnchantTier.SIMPLE, 3, GearType.SWORD, "Gives particles and sound effects.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
}
}
@@ -0,0 +1,26 @@
package net.crankedpvp.crankedenchants.enchantments.simple;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.BlockBreakEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.entity.EntityType;
import org.bukkit.event.block.BlockBreakEvent;
public class Experience extends BlockBreakEventEnchant {
@ConfigValue
private double procChance = 0.05;
public Experience() {
super("Experience", EnchantTier.SIMPLE, 5, GearType.TOOL, "Gives more exp when mining blocks. ");
}
@Override
public void runBlockBreakEvent(BlockBreakEvent event, EnchantedItemBuilder enchantedItemBuilder) {
if (Math.random() < procChance * enchantedItemBuilder.getEnchantmentLevel(this)) {
event.getBlock().getWorld().spawnEntity(event.getBlock().getLocation(), EntityType.EXPERIENCE_ORB);
}
}
}
@@ -0,0 +1,25 @@
package net.crankedpvp.crankedenchants.enchantments.simple;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorEquipEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;
public class Glowing extends ArmorEquipEventEnchant {
public Glowing() {
super("Glowing", EnchantTier.SIMPLE, false,1, GearType.HELMET, "Added Night Vision when equipped.");
}
@Override
public void runArmorEquipEvent(Player player, int level) {
player.addPotionEffect(new PotionEffect(PotionEffectType.NIGHT_VISION, Integer.MAX_VALUE, level - 1), true);
}
@Override
public void runArmorUnEquipEvent(Player player, int level) {
player.removePotionEffect(PotionEffectType.NIGHT_VISION);
}
}
@@ -0,0 +1,23 @@
package net.crankedpvp.crankedenchants.enchantments.simple;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDeathEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedutils.utils.items.SkullUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDeathEvent;
public class Headless extends WeaponDeathEventEnchant {
public Headless() {
super("Headless", EnchantTier.SIMPLE, 3, GearType.SWORD, "Victims have a chance of dropping their head on death.");
}
@Override
public void runEntityDeathEvent(EntityDeathEvent event, Player killer, LivingEntity victim, int level) {
if (!(victim instanceof Player)) return;
killer.getInventory().addItem(SkullUtils.getSkullFromPlayer(((Player) victim)));
}
}
@@ -0,0 +1,38 @@
package net.crankedpvp.crankedenchants.enchantments.simple;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.SlownessEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.potion.PotionEffectType;
public class Insomnia extends WeaponDamageEventEnchant implements SlownessEnchant {
@ConfigValue
private double procChance = 0.006;
public Insomnia() {
super("Insomnia", EnchantTier.SIMPLE, 7, GearType.SWORD, "Chance to proc slowness, mining fatigue", "and confusion against other", "players.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if(!(victim instanceof Player))return;
if (Math.random() < procChance * level) {
Player victim2 = (Player) victim;
PotionEffectUtils.addPotionEffect(victim2, PotionEffectType.SLOW, 0, "insomnia_slow", 80);
PotionEffectUtils.addPotionEffect(victim2, PotionEffectType.SLOW, 0, "insomnia_slowdigging", 80);
PotionEffectUtils.addPotionEffect(victim2, PotionEffectType.SLOW, 0, "insomnia_confusion", 80);
//victim.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, 80, 0, true));
//victim.addPotionEffect(new PotionEffect(PotionEffectType.SLOW_DIGGING, 80, 0, true));
//victim.addPotionEffect(new PotionEffect(PotionEffectType.CONFUSION, 80, 0, true));
}
}
}
@@ -0,0 +1,27 @@
package net.crankedpvp.crankedenchants.enchantments.simple;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Obliterate extends WeaponDamageEventEnchant {
@ConfigValue
private double procChance = 0.1;
public Obliterate() {
super("Obliterate", EnchantTier.SIMPLE, 5, GearType.AXE, "Chance to give extreme knockback", "to your enemy.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (Math.random() < procChance * level) {
victim.setVelocity(attacker.getLocation().getDirection().multiply(6));
}
}
}
@@ -0,0 +1,19 @@
package net.crankedpvp.crankedenchants.enchantments.simple;
import net.crankedpvp.crankedenchants.struct.enchantstruct.BlockBreakEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.event.block.BlockBreakEvent;
public class Oxygenate extends BlockBreakEventEnchant {
public Oxygenate() {
super("Oxygenate", EnchantTier.SIMPLE, 1, GearType.TOOL, "Refills oxygen levels when breaking blocks under water.");
}
@Override
public void runBlockBreakEvent(BlockBreakEvent event, EnchantedItemBuilder enchantedItemBuilder) {
event.getPlayer().setRemainingAir(event.getPlayer().getMaximumAir());
}
}
@@ -0,0 +1,28 @@
package net.crankedpvp.crankedenchants.enchantments.simple;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class ThunderingBlow extends WeaponDamageEventEnchant {
@ConfigValue
private double procChance = 0.06;
public ThunderingBlow() {
super("Thundering Blow", EnchantTier.SIMPLE, 3, GearType.SWORD, "Chance to smite ur victim", "during combat.");
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (Math.random() < procChance) {
victim.getWorld().strikeLightningEffect(victim.getLocation());
victim.setHealth(victim.getHealth() - level);
}
}
}
@@ -0,0 +1,112 @@
package net.crankedpvp.crankedenchants.enchantments.soul;
import com.earth2me.essentials.Essentials;
import com.earth2me.essentials.User;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.perms.Relation;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.enchantstruct.WeaponDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.DrainSoulEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.Reloadable;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.utils.CacheUtils;
import net.crankedpvp.crankedutils.utils.EssentialsUtils;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import net.crankedpvp.staff.StaffPlugin;
import net.crankedpvp.staritems.StarItemsAPI;
import net.objecthunter.exp4j.Expression;
import net.objecthunter.exp4j.ExpressionBuilder;
import org.bukkit.GameMode;
import org.bukkit.Sound;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import xyz.xenondevs.particle.ParticleBuilder;
import xyz.xenondevs.particle.ParticleEffect;
import java.util.List;
public class DivineImmolation extends WeaponDamageEventEnchant implements DrainSoulEnchant, Reloadable {
@ConfigValue
private String damageFormula = "level * 1.1";
@ConfigValue
private String message = "&c&l** DIVINE IMMOLATION **";
private Expression damageExpression;
private ParticleBuilder particle;
private Essentials essentials;
public DivineImmolation() {
super("Divine Immolation", EnchantTier.SOUL, 4, GearType.SWORD, "Active soul enchant. Your weapons are imbued with divine fire,", "turning all your physical attacks into Area of Effect spells", "and igniting divine fire upon all nearby enemies.");
this.reloadValues();
this.essentials = EssentialsUtils.getEssentials();
this.particle = new ParticleBuilder(ParticleEffect.LAVA)
.setAmount(50)
.setOffsetY(1)
.setSpeed(0.15f);
}
@Override
public void runEntityDamageByEntityEvent(EntityDamageByEntityEvent event, LivingEntity victim, Player attacker, int level) {
if (!(victim instanceof Player)) return;
FPlayer fPlayer = FPlayers.getInstance().getByPlayer(attacker);
List<Entity> nearbyPlayers = victim.getNearbyEntities(level, level, level);
nearbyPlayers.add(victim);
for (Entity nearbyEntity : nearbyPlayers) {
if (nearbyEntity.equals(attacker)) continue;
if (!(nearbyEntity instanceof Player)) continue;
Player nearbyPlayer = ((Player) nearbyEntity);
User user = this.essentials.getUser(nearbyPlayer);
if (user.isGodModeEnabled() || user.isVanished()) continue;
if (nearbyPlayer.getGameMode() != GameMode.SURVIVAL) continue;
if (!PVPUtils.canPvPInRegion(nearbyPlayer)) continue;
if (StaffPlugin.getInstance().getFreezeManager().getFrozenPlayers().containsKey(nearbyPlayer)) continue;
if (StarItemsAPI.playerHasStarItemInCache(nearbyPlayer) && StarItemsAPI.playerHasStarItem(nearbyPlayer, "frostbite"))
continue;
FPlayer fPlayerNearby = FPlayers.getInstance().getByPlayer(nearbyPlayer);
if (fPlayer.getRelationTo(fPlayerNearby).isAtLeast(Relation.TRUCE)) continue;
//nearbyPlayer.addPotionEffect(new PotionEffect(PotionEffectType.WITHER, 60, 1, true, false));
nearbyPlayer.playSound(nearbyEntity.getLocation(), Sound.FIREWORK_BLAST, 1.0f, 0.3f);
nearbyPlayer.playSound(nearbyEntity.getLocation(), Sound.ZOMBIE_PIG_ANGRY, 0.8f, 0.5f);
CacheUtils.getDivineCache(nearbyPlayer).updateLastProcTime();
super.getDamageHandler().damage(nearbyPlayer, this.damageExpression.setVariable("level", level).evaluate(), "&c&lDivine Tick");
super.sendMessage(nearbyPlayer, this.message);
}
}
/* @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void onEntityDamage(EntityDamageEvent event) {
if (!(event.getEntity() instanceof Player)) return;
if (event.getCause() != EntityDamageEvent.DamageCause.WITHER) return;
Player player = ((Player) event.getEntity());
if (CacheUtils.getDivineCache(player).isDivineActive()) {
if(StarItemsAPI.playerHasStarItemInCache(player) && StarItemsAPI.playerHasStarItem(player, "frostbite")) return;
super.getDamageHandler().damage(player, this.damageExpression.setVariable("level", 4).evaluate(), "&c&lDivine Tick");
player.playSound(player.getLocation(), Sound.ZOMBIE_PIG_ANGRY, 0.8f, 0.5f);
super.sendMessage(player, this.message);
this.particle.setLocation(player.getLocation()).display(PVPUtils.getNearbyPlayersExceptPlayer(player, 30));
}
}*/
@Override
public int getSoulCost() {
return 5;
}
@Override
public void reloadValues() {
this.damageExpression = new ExpressionBuilder(this.damageFormula).variable("level").build();
}
}
@@ -0,0 +1,21 @@
package net.crankedpvp.crankedenchants.enchantments.soul;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class Immortal extends ArmorIncomingPVPDamageEventEnchant {
public Immortal() {
super("Immortal", EnchantTier.SOUL, false, 4, GearType.ARMOR, "Prevents your armor from taking durability damage in exchange for souls.");
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
}
}
@@ -0,0 +1,169 @@
package net.crankedpvp.crankedenchants.enchantments.soul;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.perms.Relation;
import net.crankedpvp.crankedarmor.CrankedArmor;
import net.crankedpvp.crankedarmor.CrankedArmorAPI;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.language.Language;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.cache.SoulModeCache;
import net.crankedpvp.crankedenchants.struct.cache.enchantscache.NaturesWrathCache;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.SoulEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.souls.SoulManager;
import net.crankedpvp.crankedenchants.tasks.NaturesWrathTask;
import net.crankedpvp.crankedenchants.utils.CacheUtils;
import net.crankedpvp.crankedmasks.CrankedMasks;
import net.crankedpvp.crankedmasks.CrankedMasksAPI;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.GameMode;
import org.bukkit.Sound;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.player.PlayerKickEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import xyz.xenondevs.particle.ParticleBuilder;
import xyz.xenondevs.particle.ParticleEffect;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
public class NaturesWrath extends ArmorIncomingPVPDamageEventEnchant implements SoulEnchant {
@ConfigValue
private double procChance = 0.02;
@ConfigValue
private int cooldown = 200;
@ConfigValue
private List<String> procMessage = Arrays.asList("&r ", "&c&l** NATURE'S WRATH **", "&c&l- 75 Soul Gems", "&7&n{souls-left}&7 souls left.", "&r ");
@ConfigValue
private String zeusBlockedMessage = "&b&l* ZEUS MASK [&7Blocked Natures Wrath&b&l] *";
private String luciferSetBlockedMessage = "&5&l* LUCIFER SET [&7Blocked Natures Wrath&5&l] *";
private final SoulManager soulManager;
private final ParticleBuilder spellParticle;
private final ParticleBuilder explosionParticle;
private final ParticleBuilder lavaParticle;
public NaturesWrath() {
super("Natures Wrath", EnchantTier.SOUL, false, 4, GearType.ARMOR, "Passive Soul Enchantment. Temporarily freeze all enemies in a massive area around you,", "pushing them back and dealing massive nature damage.");
this.soulManager = CrankedEnchants.getInstance().getSoulManager();
this.explosionParticle = new ParticleBuilder(ParticleEffect.EXPLOSION_LARGE)
.setAmount(5)
.setOffsetY(0.5f)
.setSpeed(0.15f);
this.spellParticle = new ParticleBuilder(ParticleEffect.SPELL)
.setAmount(50)
.setOffsetY(0.5f)
.setSpeed(0.15f);
this.lavaParticle = new ParticleBuilder(ParticleEffect.LAVA)
.setAmount(30)
.setOffsetY(0.5f)
.setSpeed(0.15f);
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (!(attacker instanceof Player)) return;
if (event.getCause() != EntityDamageEvent.DamageCause.ENTITY_ATTACK && event.getCause() != EntityDamageEvent.DamageCause.PROJECTILE) return;
if (super.isOnCooldown(victim)) return;
if (Math.random() < this.procChance) {
SoulModeCache soulModeCache = this.soulManager.getSoulModeCache(victim);
if (!soulModeCache.hasEnoughSouls(this.getSoulCost())) {
this.lavaParticle.setLocation(victim.getLocation()).display(PVPUtils.getNearbyPlayers(victim, 30));
victim.playSound(victim.getLocation(), Sound.ITEM_BREAK, 0.7f, 0.4f);
Language.OUT_OF_SOULS.send(victim);
super.registerCooldown(victim, this.cooldown);
return;
}
soulModeCache.getSoulGemBuilder().removeSouls(this.getSoulCost());
soulModeCache.updateSoulGem();
super.sendMessage(victim, this.procMessage, str -> str.replace("{souls-left}", String.valueOf(soulModeCache.getSouls())));
int level = enchantInfo.getLevel();
//int radius = 8 + level * 5;
int radius = level * 3;
FPlayer fPlayer = FPlayers.getInstance().getByPlayer(victim);
List<Player> affectedPlayers = new ArrayList<>();
for (Entity nearbyEntity : victim.getNearbyEntities(radius, radius, radius)) {
if (!(nearbyEntity instanceof Player)) continue;
Player nearbyPlayer = ((Player) nearbyEntity);
if (nearbyPlayer.getGameMode() != GameMode.SURVIVAL) continue;
if (!PVPUtils.canPvPInRegion(nearbyPlayer)) continue;
FPlayer fPlayerNearby = FPlayers.getInstance().getByPlayer(nearbyPlayer);
if (fPlayer.getRelationTo(fPlayerNearby).isAtLeast(Relation.TRUCE)) continue;
if (CrankedMasksAPI.hasMaskEquipped( fPlayerNearby.getPlayer(), CrankedMasks.getInstance().getMasksRegister().getMaskFromID("zeus"))) {
fPlayerNearby.getPlayer().sendMessage(zeusBlockedMessage);
continue;
}
if (Objects.equals(CrankedArmorAPI.getCurrentArmorSet(fPlayerNearby.getPlayer()), CrankedArmor.getInstance().getArmorSetRegister().getArmorSetFromID("lucifer"))) {
fPlayerNearby.getPlayer().sendMessage(luciferSetBlockedMessage);
continue;
}
affectedPlayers.add(nearbyPlayer);
this.spellParticle.setLocation(nearbyPlayer.getLocation()).display(PVPUtils.getNearbyPlayers(nearbyPlayer, 30));
this.explosionParticle.setLocation(nearbyPlayer.getLocation()).display(PVPUtils.getNearbyPlayers(nearbyPlayer, 30));
CacheUtils.getNaturesWrathCache(nearbyPlayer).applyNaturesWrathEffect(nearbyPlayer, level);
}
NaturesWrathTask naturesWrathTask = new NaturesWrathTask(affectedPlayers, level);
naturesWrathTask.runTaskTimer(CrankedEnchants.getInstance(), 20L, 20L);
super.registerCooldown(victim, this.cooldown);
}
}
@EventHandler
public void onPlayerLeaveWhileNatured(PlayerQuitEvent event) {
NaturesWrathCache naturesWrathCache = CacheUtils.getNaturesWrathCache(event.getPlayer());
if (naturesWrathCache.isAffected()) {
naturesWrathCache.removeNaturesWrathEffect(event.getPlayer());
}
}
@EventHandler
public void onPlayerDeathWhileNatured(PlayerDeathEvent event) {
NaturesWrathCache naturesWrathCache = CacheUtils.getNaturesWrathCache(event.getEntity());
if (naturesWrathCache.isAffected()) {
naturesWrathCache.removeNaturesWrathEffect(event.getEntity());
}
}
@EventHandler
public void onPlayerLeaveWhileNatured(PlayerKickEvent event) {
NaturesWrathCache naturesWrathCache = CacheUtils.getNaturesWrathCache(event.getPlayer());
if (naturesWrathCache.isAffected()) {
naturesWrathCache.removeNaturesWrathEffect(event.getPlayer());
}
}
@Override
public int getSoulCost() {
return 75;
}
}
@@ -0,0 +1,127 @@
package net.crankedpvp.crankedenchants.enchantments.soul;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.perms.Relation;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.language.Language;
import net.crankedpvp.crankedenchants.struct.annotations.ConfigValue;
import net.crankedpvp.crankedenchants.struct.cache.EnchantInfo;
import net.crankedpvp.crankedenchants.struct.cache.SoulModeCache;
import net.crankedpvp.crankedenchants.struct.enchantstruct.ArmorIncomingPVPDamageEventEnchant;
import net.crankedpvp.crankedenchants.struct.enchantstruct.interfaces.SoulEnchant;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.enums.GearType;
import net.crankedpvp.crankedenchants.struct.souls.SoulManager;
import net.crankedpvp.crankedutils.utils.PVPUtils;
import org.bukkit.GameMode;
import org.bukkit.Sound;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import xyz.xenondevs.particle.ParticleBuilder;
import xyz.xenondevs.particle.ParticleEffect;
public class Paradox extends ArmorIncomingPVPDamageEventEnchant implements SoulEnchant {
@ConfigValue
private double procChance = 0.06;
@ConfigValue
private int cooldown = 80;
@ConfigValue
private String message = "&2&l** PARADOX [{healer}] (+{amount}HP) **]";
private final SoulManager soulManager;
private ParticleBuilder particle1;
private ParticleBuilder particle2;
private ParticleBuilder particle3;
private ParticleBuilder particle4;
private ParticleBuilder lavaParticle;
public Paradox() {
super("Paradox", EnchantTier.SOUL, false, 5, GearType.ARMOR, "Passive soul enchantment. Heals all nearby allies in a massive area", "around you for a portion of all damage dealt to you.");
this.soulManager = CrankedEnchants.getInstance().getSoulManager();
this.initParticles();
}
@Override
public void runIncomingDamageEvent(EntityDamageByEntityEvent event, Player victim, LivingEntity attacker, EnchantInfo enchantInfo) {
if (super.isOnCooldown(victim)) return;
if (Math.random() < procChance) {
SoulModeCache soulModeCache = soulManager.getSoulModeCache(victim);
if (!soulModeCache.hasEnoughSouls(this.getSoulCost())) {
this.lavaParticle.setLocation(victim.getLocation()).display(PVPUtils.getNearbyPlayers(victim, 30));
victim.playSound(victim.getLocation(), Sound.ITEM_BREAK, 0.7f, 0.4f);
Language.OUT_OF_SOULS.send(victim);
super.registerCooldown(victim, cooldown);
return;
}
int level = enchantInfo.getLevel();
int radius = 8 + level * 4;
double amountToHeal = event.getDamage() * (double)(level / 10);
FPlayer fPlayer = FPlayers.getInstance().getByPlayer(victim);
soulModeCache.getSoulGemBuilder().removeSouls(5);
soulModeCache.updateSoulGem();
for (Entity nearbyEntity : victim.getNearbyEntities(radius, radius, radius)) {
if (nearbyEntity.equals(victim)) continue;
if (!(nearbyEntity instanceof Player)) continue;
Player nearbyPlayer = ((Player) nearbyEntity);
if (nearbyPlayer.getGameMode() != GameMode.SURVIVAL) continue;
if (!PVPUtils.canPvPInRegion(nearbyPlayer)) return;
FPlayer fPlayerNearby = FPlayers.getInstance().getByPlayer(nearbyPlayer);
if (fPlayer.getRelationTo(fPlayerNearby).isAtMost(Relation.NEUTRAL)) continue;
this.particle1.setLocation(nearbyPlayer.getLocation()).display(PVPUtils.getNearbyPlayers(nearbyPlayer, 30));
this.particle2.setLocation(nearbyPlayer.getLocation()).display(PVPUtils.getNearbyPlayers(nearbyPlayer, 30));
this.particle3.setLocation(nearbyPlayer.getLocation()).display(PVPUtils.getNearbyPlayers(nearbyPlayer, 30));
this.particle4.setLocation(nearbyPlayer.getLocation()).display(PVPUtils.getNearbyPlayers(nearbyPlayer, 30));
super.sendMessage(nearbyPlayer, message, str -> str.replace("{healer}", victim.getName()).replace("{amount}", String.valueOf(amountToHeal)));
super.getDamageHandler().healEntity(nearbyPlayer, amountToHeal, this.getName());
}
super.registerCooldown(victim, cooldown);
}
}
@Override
public int getSoulCost() {
return 5;
}
private void initParticles() {
this.particle1 = new ParticleBuilder(ParticleEffect.VILLAGER_HAPPY)
.setAmount(20)
.setOffsetY(1.5f)
.setOffsetX(0.8f)
.setOffsetZ(0.8f)
.setSpeed(0.4f);
this.particle2 = new ParticleBuilder(ParticleEffect.VILLAGER_HAPPY)
.setAmount(20)
.setOffsetY(1.5f)
.setOffsetX(-0.8f)
.setOffsetZ(0.8f)
.setSpeed(0.4f);
this.particle3 = new ParticleBuilder(ParticleEffect.VILLAGER_HAPPY)
.setAmount(20)
.setOffsetY(1.5f)
.setOffsetX(0.8f)
.setOffsetZ(-0.8f)
.setSpeed(0.4f);
this.particle4 = new ParticleBuilder(ParticleEffect.VILLAGER_HAPPY)
.setAmount(20)
.setOffsetY(1.5f)
.setOffsetX(-0.8f)
.setOffsetZ(-0.8f)
.setSpeed(0.4f);
this.lavaParticle = new ParticleBuilder(ParticleEffect.LAVA)
.setAmount(30)
.setOffsetY(0.5f)
.setSpeed(0.15f);
}
}

Some files were not shown because too many files have changed in this diff Show More