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
+49
View File
@@ -0,0 +1,49 @@
<?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>GrindingSword</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Utils</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Shards</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Leaderboards</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Keys</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Spawners</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>StorageUtilsShaded</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/../StorageUtils/target/StorageUtils-1.0-shaded.jar</systemPath>
</dependency>
</dependencies>
</project>
@@ -0,0 +1,44 @@
package net.crankedpvp.grindingsword;
import de.tr7zw.nbtapi.NBTCompound;
import de.tr7zw.nbtapi.NBTItem;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import net.crankedpvp.grindingsword.struct.Enchant;
import org.bukkit.inventory.ItemStack;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public class GrindingSwordAPI {
public static boolean isGrindingSword(ItemStack itemStack) {
if(ItemUtils.isAirOrNull(itemStack)) return false;
NBTItem nbtItem = new NBTItem(itemStack);
if(!nbtItem.hasNBTData()) return false;
if(!nbtItem.hasKey("crankedCustomItem")) return false;
return nbtItem.getString("crankedCustomItem").equals("grindingSword");
}
public static UUID getGrindingSwordUUID(ItemStack itemStack) {
if(!isGrindingSword(itemStack)) return null;
NBTItem nbtItem = new NBTItem(itemStack);
return UUID.fromString(nbtItem.getString("grindingSwordUUID"));
}
public static Map<Enchant, Integer> getEnchantsOnGrindingSword(ItemStack itemStack) {
if(!isGrindingSword(itemStack)) return null;
Map<Enchant, Integer> enchantIntegerMap = new HashMap<>();
NBTItem nbtItem = new NBTItem(itemStack);
NBTCompound nbtCompound = nbtItem.getCompound("grindingSwordEnchants");
for(String enchantName : nbtCompound.getKeys()) {
if(nbtCompound.getInteger(enchantName) < 1) continue;
enchantIntegerMap.put(GrindingSwordPlugin.getInstance().getEnchantRegister().getEnchant(enchantName), nbtCompound.getInteger(enchantName));
}
return enchantIntegerMap;
}
}
@@ -0,0 +1,49 @@
package net.crankedpvp.grindingsword;
import lombok.Getter;
import me.mattstudios.mf.base.CommandManager;
import net.crankedpvp.grindingsword.cache.CacheStorage;
import net.crankedpvp.grindingsword.commands.GrindingSwordCommand;
import net.crankedpvp.grindingsword.listeners.GrindingSwordDeathListener;
import net.crankedpvp.grindingsword.listeners.OpenSwordInventoryListener;
import net.crankedpvp.grindingsword.struct.EnchantRegister;
import net.crankedpvp.grindingsword.tasks.GrindingRewardsTask;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;
public class GrindingSwordPlugin extends JavaPlugin {
@Getter
private static GrindingSwordPlugin instance;
@Getter
private CacheStorage cacheStorage;
private CommandManager commandManager;
@Getter
private EnchantRegister enchantRegister;
@Override
public void onEnable() {
instance = this;
this.cacheStorage = new CacheStorage();
this.commandManager = new CommandManager(this);
this.commandManager.register(new GrindingSwordCommand());
this.enchantRegister = new EnchantRegister(this);
this.enchantRegister.initialize();
this.registerListeners();
GrindingRewardsTask grindingRewardsTask = new GrindingRewardsTask();
grindingRewardsTask.runTaskTimer(this, 40L, 15 * 20L);
}
private void registerListeners() {
PluginManager pluginManager = this.getServer().getPluginManager();
pluginManager.registerEvents(new OpenSwordInventoryListener(this), this);
pluginManager.registerEvents(new GrindingSwordDeathListener(), this);
}
}
@@ -0,0 +1,49 @@
package net.crankedpvp.grindingsword.cache;
import lombok.Getter;
import net.crankedpvp.grindingsword.struct.GrindingSword;
import org.bukkit.entity.Player;
import java.util.HashMap;
import java.util.Map;
public class CacheStorage {
@Getter
private static CacheStorage cacheStorage;
private final Map<Player, PlayerCache> playerCacheMap;
public CacheStorage() {
cacheStorage = this;
this.playerCacheMap = new HashMap<>();
}
public Map<Player, PlayerCache> getPlayersInCache() {
return this.playerCacheMap;
}
public void removePlayerFromCache(Player player) {
this.playerCacheMap.remove(player);
}
public void putPlayerInCache(Player player) {
PlayerCache playerCache = new PlayerCache(player);
playerCacheMap.put(player, playerCache);
}
public void putPlayerInCache(Player player, GrindingSword grindingSword) {
PlayerCache playerCache = new PlayerCache(player);
playerCache.setGrindingSword(grindingSword);
playerCacheMap.put(player, playerCache);
}
public PlayerCache getPlayerCache(Player player) {
return this.playerCacheMap.get(player);
}
public boolean isCached(Player player) {
return this.playerCacheMap.containsKey(player);
}
}
@@ -0,0 +1,114 @@
package net.crankedpvp.grindingsword.cache;
import lombok.Getter;
import lombok.Setter;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.NumberUtils;
import net.crankedpvp.crankedutils.utils.XPUtils;
import net.crankedpvp.cratekeys.CrankedCrateKeysAPI;
import net.crankedpvp.cratekeys.enums.CrateKeyType;
import net.crankedpvp.grindingsword.struct.GrindingSword;
import net.crankedpvp.leaderboards.LeaderboardsAPI;
import net.crankedpvp.shards.ShardsAPI;
import org.bukkit.entity.Player;
import java.util.HashMap;
import java.util.Map;
@Getter
public class PlayerCache {
private final Player player;
private GrindingSword grindingSword;
@Setter
private long lastKilledInMs;
private final Map<CrateKeyType, Integer> keys;
private double shards;
private double exp;
private int mobsKilled;
public PlayerCache(Player player) {
this.player = player;
this.grindingSword = null;
this.keys = new HashMap<>();
this.shards = 0;
this.exp = 0;
this.mobsKilled = 0;
this.lastKilledInMs = System.currentTimeMillis();
}
public boolean hasBeenAmountOfTimeInSeconds(int seconds) {
return System.currentTimeMillis() - this.lastKilledInMs > (seconds * 1000L);
}
public void setGrindingSword(GrindingSword grindingSword) {
this.grindingSword = grindingSword;
}
public void addKey(CrateKeyType key) {
if(keys.containsKey(key)) {
int value = keys.get(key);
keys.put(key, value + 1);
return;
}
keys.put(key, 1);
}
public void addShards(double amount) {
this.shards = this.shards + amount;
}
public void addMobsKilled(int amount) {
this.mobsKilled = this.mobsKilled + amount;
}
public void addExp(double amount) {
this.exp = this.exp + amount;
}
public int getAmountOfKeys() {
int finalVal = 0;
for(Integer value : this.keys.values()) {
finalVal+=value;
}
return finalVal;
}
public void reset() {
this.mobsKilled = 0;
this.exp = 0;
this.shards = 0;
this.keys.clear();
}
public boolean areDefaultValues() {
return this.exp == 0 && this.shards == 0 && this.keys.isEmpty();
}
public void giveRewardsToPlayer() {
if(this.areDefaultValues()) return;
this.keys.forEach((keyName, amount) -> CrankedCrateKeysAPI.givePlayerKeys(player, keyName, amount));
XPUtils.addExperience(this.player, (int)this.exp);
ShardsAPI.getShardsUser(this.player).addShards(this.shards);
LeaderboardsAPI.getPlayerStats(player.getUniqueId()).addEXPGained((int) exp);
LeaderboardsAPI.getPlayerStats(player.getUniqueId()).addMobsKilled(this.mobsKilled);
player.sendMessage(CC.translate(""));
player.sendMessage(CC.translate("&c&lGrinding Rewards"));
player.sendMessage(CC.translate("&8 ➥ &7EXP: &e" + NumberUtils.formatMoney(exp)));
player.sendMessage(CC.translate("&8 ➥ &7Shards: &b" + NumberUtils.formatMoney(shards) + "♦"));
player.sendMessage(CC.translate("&8 ➥ &7Keys Gathered: &d" + NumberUtils.formatMoney(getAmountOfKeys())));
player.sendMessage(CC.translate("&8 ➥ &7Mobs Killed: &c" + NumberUtils.formatMoney(mobsKilled)));
player.sendMessage(CC.translate("&7&o(( Every &f15s &7&oyou will receive your grinding rewards from the last 15s. ))"));
player.sendMessage(CC.translate(""));
//player.sendMessage(CC.translate("&8 ➥ &7Money: &2$&a" + NumberUtils.formatMoney(moneyEarned)));
this.reset();
}
}
@@ -0,0 +1,60 @@
package net.crankedpvp.grindingsword.commands;
import de.tr7zw.nbtapi.NBTItem;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.grindingsword.GrindingSwordAPI;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.UUID;
@Command("cgs")
@Alias({"grindingsword", "crankedgrindingsword"})
public class GrindingSwordCommand extends CommandBase {
@Default
@Permission("cranked.admin")
public void defaultCommand(final CommandSender commandSender, @Optional Player receiver) {
if(receiver == null) {
if(!(commandSender instanceof Player)) {
commandSender.sendMessage(CC.translate("&cYou must be a player to receive this item"));
return;
}
receiver = (Player) commandSender;
}
ItemBuilder itemBuilder = new ItemBuilder(Material.GOLD_SWORD, "&4&lGrinding&8 &8➥ &f&lSword",
"", "&7&oAn upgradeable sword used to",
"&7&omake the most out of grinding...",
"",
"&4Enchantments:",
"",
"&7&nShift Right-Click&r &7to &fupgrade &7this weapon");
itemBuilder.addEnchantment(Enchantment.DAMAGE_ALL, 5);
itemBuilder.setUnbreakable(true);
NBTItem nbtItem = new NBTItem(itemBuilder.colorize().build());
nbtItem.setString("crankedCustomItem", "grindingSword");
nbtItem.setString("grindingSwordUUID", UUID.randomUUID().toString());
nbtItem.addCompound("grindingSwordEnchants");
receiver.getInventory().addItem(nbtItem.getItem());
}
@SubCommand("uuid")
@Permission("cranked.admin")
public void checkUuidCommand(final Player player) {
ItemStack itemStack = player.getItemInHand();
if(!GrindingSwordAPI.isGrindingSword(itemStack)) return;
player.sendMessage(CC.translate("&cGrinding Sword UUID: &f" + GrindingSwordAPI.getGrindingSwordUUID(itemStack)));
}
}
@@ -0,0 +1,23 @@
package net.crankedpvp.grindingsword.enchants;
import net.crankedpvp.crankedutils.utils.LuckpermUtils;
import net.crankedpvp.grindingsword.cache.CacheStorage;
import net.crankedpvp.grindingsword.struct.Enchant;
import net.crankedpvp.spawners.events.StackedMobDeathEvent;
import org.bukkit.Material;
import org.bukkit.entity.Player;
public class Inquisitive extends Enchant {
public Inquisitive() {
super("inquisitive", 25, Material.EXP_BOTTLE, "&6&lInquisitive", new String[]{"&7Gain more EXP from killing hostile", "&7mobs with this grinding sword"}, 11,
new int[]{50, 100, 150, 200, 250, 300, 400, 500, 750, 1000, 1500, 2500, 3500, 5000, 7500, 10000, 12500, 15000, 17500, 20000, 22500, 25000, 28500, 31000, 34500});
}
@Override
public void runStackedMobDeathEvent(StackedMobDeathEvent event, int level) {
double expDropped = event.getExp(event.getEntity().getType());
Player player = (Player) event.getDamager();
double multiplier = LuckpermUtils.playerHasRank(player, "satan") ? 1.5 : 1.0;
CacheStorage.getCacheStorage().getPlayerCache(player).addExp(multiplier * (int) (((expDropped * (1+(0.1 * level))) * (1 + Math.random()))) );
}
}
@@ -0,0 +1,37 @@
package net.crankedpvp.grindingsword.enchants;
import net.crankedpvp.cratekeys.enums.CrateKeyType;
import net.crankedpvp.grindingsword.cache.CacheStorage;
import net.crankedpvp.grindingsword.struct.Enchant;
import net.crankedpvp.spawners.events.StackedMobDeathEvent;
import org.bukkit.Material;
import org.bukkit.entity.Player;
public class KeyGrind extends Enchant {
public KeyGrind() {
super("key_grind", 15, Material.TRIPWIRE_HOOK, "&d&lKey Grind", new String[]{"&7Gain keys from killing hostile", "&7mobs with this grinding sword"}, 13,
new int[]{50, 100, 150, 200, 250, 300, 400, 500, 750, 1000, 1250, 1500, 1750, 2000, 2500});
}
@Override
public void runStackedMobDeathEvent(StackedMobDeathEvent event, int level) {
Player player = (Player) event.getDamager();
if((Math.random() * 1000) > (level * 16) * 3) return;
if(level < 8) {
CacheStorage.getCacheStorage().getPlayerCache(player).addKey(CrateKeyType.ABYSS_KEY);
}
if(level < 3) return;
if((Math.random() * 1000) > (level * 11) * 3) return;
CacheStorage.getCacheStorage().getPlayerCache(player).addKey(CrateKeyType.MYTHIC_KEY);
if(level < 8) return;
if((Math.random() * 1000) > (level * 6) * 3) return;
CacheStorage.getCacheStorage().getPlayerCache(player).addKey(CrateKeyType.SEASON_KEY);
}
// * 3 FOR BETA
}
@@ -0,0 +1,25 @@
package net.crankedpvp.grindingsword.enchants;
import net.crankedpvp.grindingsword.cache.CacheStorage;
import net.crankedpvp.grindingsword.struct.Enchant;
import net.crankedpvp.spawners.events.StackedMobDeathEvent;
import org.bukkit.Material;
import org.bukkit.entity.Player;
public class ShardGrind extends Enchant {
public ShardGrind() {
super("shard_grind", 10, Material.PRISMARINE_SHARD, "&b&lShard Grind", new String[]{"&7Gain shards from killing hostile", "&7mobs with this grinding sword"}, 15,
new int[]{0, 75, 125, 165, 200, 250, 325, 425, 550, 750});
}
@Override
public void runStackedMobDeathEvent(StackedMobDeathEvent event, int level) {
Player player = (Player) event.getDamager();
if((Math.random() * 1000) > (2 * ((level+1) * 30))) return;
CacheStorage.getCacheStorage().getPlayerCache(player).addShards(1);
}
// * 2 FOR BETA
}
@@ -0,0 +1,83 @@
package net.crankedpvp.grindingsword.inventory;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import net.crankedpvp.crankedutils.utils.Arrow;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.SoundUtils;
import net.crankedpvp.crankedutils.utils.StringUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.grindingsword.GrindingSwordPlugin;
import net.crankedpvp.grindingsword.cache.CacheStorage;
import net.crankedpvp.grindingsword.struct.Enchant;
import net.crankedpvp.grindingsword.struct.EnchantRegister;
import net.crankedpvp.grindingsword.struct.GrindingSword;
import net.crankedpvp.shards.ShardsAPI;
import net.crankedpvp.shards.data.ShardsUser;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class GrindingSwordInventory {
private final Gui grindingSwordInventory;
private final GrindingSword grindingSword;
private final EnchantRegister enchantRegister;
public Gui getUI() {
return this.grindingSwordInventory;
}
public GrindingSwordInventory(ItemStack itemStack) {
this.enchantRegister = GrindingSwordPlugin.getInstance().getEnchantRegister();
this.grindingSword = new GrindingSword(itemStack);
this.grindingSwordInventory = new Gui(3, "Grinding Sword");
this.grindingSwordInventory.setDefaultClickAction(event -> event.setCancelled(true));
this.addEnchantsToInventory();
}
private void addEnchantsToInventory() {
for(Enchant enchant : this.enchantRegister.getEnchants()) {
this.addEnchantToInventory(enchant);
}
}
private void addEnchantToInventory(Enchant enchant) {
List<String> lore = new ArrayList<>(Arrays.asList(enchant.getGuiLore()));
lore.add("");
lore.add("&7Current Level: " + this.grindingSword.getEnchantLevel(enchant) + "&f/&7" + enchant.getMaxLevel());
lore.add("");
int cost = this.grindingSword.getEnchantLevel(enchant) >= enchant.getMaxLevel() ? 0 : enchant.getPrices()[this.grindingSword.getEnchantLevel(enchant)];
lore.add("&b&lCOST &f" + cost + " Shards");
ItemStack itemStack = new ItemBuilder(enchant.getGuiMaterial(), enchant.getGuiName(), lore).colorize().build();
this.grindingSwordInventory.updateItem(enchant.getGuiPosition(), new GuiItem(itemStack, event -> {
if(this.grindingSword.getEnchantLevel(enchant) >= enchant.getMaxLevel()) return;
Player player = (Player) event.getWhoClicked();
ShardsUser shardsUser = ShardsAPI.getShardsUser(player);
if(!shardsUser.canAfford(cost)) {
//if(!XPUtils.hasEnoughExperience(player, cost)) {
player.sendMessage(CC.translate("&6&lGrinding &8" + Arrow.arrow() + " &cYou are missing " + (cost - shardsUser.getBalance()) + " shards"));
SoundUtils.tryPlayErrorSound(player);
return;
}
shardsUser.removeShards(cost);
//XPUtils.removeExperience(player, cost);
player.sendMessage(CC.translate("&6&lGrinding &8" + Arrow.arrow() + " &aYour " + StringUtils.fixName(enchant.getId()) + " enchant has been upgraded"));
SoundUtils.tryPlaySuccessSound(player);
this.grindingSword.upgradeEnchant(enchant);
this.addEnchantToInventory(enchant);
player.setItemInHand(this.grindingSword.buildNewSword());
//this.grindingSwordInventory.update();
CacheStorage cacheStorage = CacheStorage.getCacheStorage();
cacheStorage.putPlayerInCache(player, this.grindingSword);
}));
}
}
@@ -0,0 +1,47 @@
package net.crankedpvp.grindingsword.listeners;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import net.crankedpvp.grindingsword.GrindingSwordAPI;
import net.crankedpvp.grindingsword.cache.CacheStorage;
import net.crankedpvp.grindingsword.cache.PlayerCache;
import net.crankedpvp.grindingsword.struct.GrindingSword;
import net.crankedpvp.spawners.events.StackedMobDeathEvent;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.inventory.ItemStack;
public class GrindingSwordDeathListener implements Listener {
@EventHandler
public void onDeath(StackedMobDeathEvent event) {
if (event.getDamager() != null) {
if(!(event.getDamager() instanceof Player)) return;
Player player = ((Player) event.getDamager());
if(ItemUtils.isAirOrNull(player.getItemInHand())) return;
if(player.getInventory().getItemInHand().getType() != Material.GOLD_SWORD) return;
CacheStorage cacheStorage = CacheStorage.getCacheStorage();
if(cacheStorage.isCached(player)) {
PlayerCache playerCache = cacheStorage.getPlayerCache(player);
if(playerCache.hasBeenAmountOfTimeInSeconds(15)) {
cacheStorage.removePlayerFromCache(player);
return;
}
playerCache.setLastKilledInMs(System.currentTimeMillis());
playerCache.addMobsKilled(1);
GrindingSword grindingSword = playerCache.getGrindingSword();
grindingSword.getEnchantLevelsMap().forEach(((enchant, integer) -> {
if(grindingSword.getEnchantLevel(enchant) > 0) enchant.runStackedMobDeathEvent(event, integer);
}));
return;
}
ItemStack itemStack = player.getItemInHand();
if(!GrindingSwordAPI.isGrindingSword(itemStack)) return;
GrindingSword grindingSword = new GrindingSword(itemStack);
cacheStorage.putPlayerInCache(player, grindingSword);
}
}
}
@@ -0,0 +1,33 @@
package net.crankedpvp.grindingsword.listeners;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import net.crankedpvp.grindingsword.GrindingSwordAPI;
import net.crankedpvp.grindingsword.GrindingSwordPlugin;
import net.crankedpvp.grindingsword.inventory.GrindingSwordInventory;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
public class OpenSwordInventoryListener implements Listener {
private final GrindingSwordPlugin plugin;
public OpenSwordInventoryListener(GrindingSwordPlugin plugin) {
this.plugin = plugin;
}
@EventHandler
public void openSwordInventoryAction(PlayerInteractEvent event) {
if(ItemUtils.isAirOrNull(event.getItem())) return;
if(event.getPlayer() == null) return;
if(!(event.getAction() == Action.RIGHT_CLICK_AIR || event.getAction() == Action.RIGHT_CLICK_BLOCK)) return;
if(!event.getPlayer().isSneaking()) return;
ItemStack itemStack = event.getItem();
if(!GrindingSwordAPI.isGrindingSword(itemStack)) return;
GrindingSwordInventory grindingSwordInventory = new GrindingSwordInventory(itemStack);
grindingSwordInventory.getUI().open(event.getPlayer());
}
}
@@ -0,0 +1,23 @@
package net.crankedpvp.grindingsword.struct;
import lombok.AllArgsConstructor;
import lombok.Getter;
import net.crankedpvp.spawners.events.StackedMobDeathEvent;
import org.bukkit.Material;
import org.bukkit.event.Listener;
@Getter
@AllArgsConstructor
public abstract class Enchant implements Listener {
private final String id;
private final int maxLevel;
private final Material guiMaterial;
private final String guiName;
private final String[] guiLore;
private final int guiPosition;
private final int[] prices;
public abstract void runStackedMobDeathEvent(StackedMobDeathEvent event, int level);
}
@@ -0,0 +1,66 @@
package net.crankedpvp.grindingsword.struct;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Maps;
import net.crankedpvp.grindingsword.GrindingSwordPlugin;
import net.crankedpvp.grindingsword.enchants.Inquisitive;
import net.crankedpvp.grindingsword.enchants.KeyGrind;
import net.crankedpvp.grindingsword.enchants.ShardGrind;
import org.apache.commons.lang.Validate;
import org.bukkit.event.Listener;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.ThreadLocalRandom;
public class EnchantRegister {
private final GrindingSwordPlugin plugin;
public EnchantRegister(GrindingSwordPlugin plugin) {
this.plugin = plugin;
}
private final Map<String, Enchant> enchants = Maps.newConcurrentMap();
public void initialize() {
registerAll(new Enchant[] {
new ShardGrind(), new KeyGrind(), new Inquisitive()
});
}
public void registerAll(Enchant[] enchants) {
for (Enchant enchant : enchants) {
register(enchant);
}
}
public void register(Enchant enchant) {
try {
this.enchants.put(enchant.getId().toLowerCase(), enchant);
Listener.class.isAssignableFrom(enchant.getClass());
plugin.getServer().getPluginManager().registerEvents(enchant, plugin);
} catch (Exception var3) {
System.err.println("&8(&c!&8) Failed to register enchant, " + enchant.getId());
}
}
public boolean isEnchant(String name) {
return (getEnchant(name) != null);
}
public Enchant getEnchant(String name) {
Validate.notNull(name);
Validate.notEmpty(name);
return this.enchants.get(name.toLowerCase());
}
public Collection<Enchant> getEnchants() {
return Collections.unmodifiableCollection(this.enchants.values());
}
public Enchant select(Collection<Enchant> enchantCollection) {
return (enchantCollection.size() > 0) ? ImmutableList.copyOf(enchantCollection).get(ThreadLocalRandom.current().nextInt(enchantCollection.size())) : null;
}
}
@@ -0,0 +1,69 @@
package net.crankedpvp.grindingsword.struct;
import de.tr7zw.nbtapi.NBTItem;
import lombok.Getter;
import lombok.Setter;
import net.crankedpvp.crankedutils.utils.RomanNumeral;
import net.crankedpvp.crankedutils.utils.StringUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.grindingsword.GrindingSwordAPI;
import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.ItemStack;
import java.util.Map;
import java.util.UUID;
@Getter @Setter
public class GrindingSword {
private final UUID swordUUID;
private final Map<Enchant, Integer> enchantLevelsMap;
private final ItemStack itemStack;
public GrindingSword(ItemStack itemStack) {
this.itemStack = itemStack;
this.swordUUID = GrindingSwordAPI.getGrindingSwordUUID(itemStack);
this.enchantLevelsMap = GrindingSwordAPI.getEnchantsOnGrindingSword(itemStack);
}
public int getEnchantLevel(Enchant enchant) {
if(!hasEnchant(enchant)) return 0;
return enchantLevelsMap.get(enchant);
}
public boolean hasEnchant(Enchant enchant) {
return enchantLevelsMap.containsKey(enchant);
}
public void upgradeEnchant(Enchant enchant) {
if(!hasEnchant(enchant)) {
enchantLevelsMap.put(enchant, 1);
return;
}
int level = enchantLevelsMap.get(enchant);
enchantLevelsMap.put(enchant, level+1);
}
public ItemStack buildNewSword() {
ItemBuilder itemBuilder = new ItemBuilder(Material.GOLD_SWORD, "&4&lGrinding&8 &8➥ &f&lSword",
"", "&7&oAn upgradeable sword used to",
"&7&omake the most out of grinding...",
"",
"&4Enchantments:");
itemBuilder.addEnchantment(Enchantment.DAMAGE_ALL, 5);
itemBuilder.setUnbreakable(true);
this.enchantLevelsMap.forEach((enchant, level) -> itemBuilder.addLoreLine(" &f• &c" + StringUtils.fixName(enchant.getId()) + " " + RomanNumeral.convertToRoman(level)));
itemBuilder.addLoreLine("");
itemBuilder.addLoreLine("&7&nShift Right-Click&r &7to &fupgrade &7this weapon");
NBTItem nbtItem = new NBTItem(itemBuilder.colorize().build());
nbtItem.setString("crankedCustomItem", "grindingSword");
nbtItem.setString("grindingSwordUUID", UUID.randomUUID().toString());
nbtItem.addCompound("grindingSwordEnchants");
this.enchantLevelsMap.forEach((enchant, level) -> nbtItem.getCompound("grindingSwordEnchants").setInteger(enchant.getId(), level));
return nbtItem.getItem();
}
}
@@ -0,0 +1,14 @@
package net.crankedpvp.grindingsword.tasks;
import net.crankedpvp.grindingsword.cache.CacheStorage;
import net.crankedpvp.grindingsword.cache.PlayerCache;
import org.bukkit.scheduler.BukkitRunnable;
public class GrindingRewardsTask extends BukkitRunnable {
@Override
public void run() {
CacheStorage.getCacheStorage().getPlayersInCache().values().forEach(PlayerCache::giveRewardsToPlayer);
}
}
@@ -0,0 +1,7 @@
name: CrankedGrindingSword
main: net.crankedpvp.grindingsword.GrindingSwordPlugin
version: ${git.total.commit.count}.0
description: "§fCommit ID: §a${git.commit.id.abbrev}"
website: https://crankedpvp.net/
depend:
- CrankedUtils