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
+154
View File
@@ -0,0 +1,154 @@
<?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>Core</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<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>
<dependency>
<artifactId>Utils</artifactId>
<groupId>net.crankedpvp</groupId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>LunarAPI</artifactId>
</dependency>
<dependency>
<artifactId>ChatTitles</artifactId>
<groupId>net.crankedpvp</groupId>
</dependency>
<dependency>
<artifactId>Lootboxes</artifactId>
<groupId>net.crankedpvp</groupId>
</dependency>
<dependency>
<artifactId>Spawners</artifactId>
<groupId>net.crankedpvp</groupId>
<version>1.0</version>
</dependency>
<dependency>
<artifactId>Masks</artifactId>
<groupId>net.crankedpvp</groupId>
<version>1.0</version>
</dependency>
<dependency>
<artifactId>StarItems</artifactId>
<groupId>net.crankedpvp</groupId>
<version>1.0</version>
</dependency>
<dependency>
<artifactId>ItemFilter</artifactId>
<groupId>net.crankedpvp</groupId>
<version>1.0</version>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>AdminWeapons</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>DiscordSync</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>AdminArmor</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Armor</artifactId>
</dependency>
<dependency>
<groupId>com.sk89q</groupId>
<artifactId>worldguard</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>tab-api</artifactId>
<version>0.1</version>
<scope>system</scope>
<systemPath>${project.basedir}/../.lib/TAB.v3.1.2.jar</systemPath>
</dependency>
<dependency>
<groupId>com.massivecraft</groupId>
<artifactId>Factions</artifactId>
</dependency>
<dependency>
<groupId>net.luckperms</groupId>
<artifactId>api</artifactId>
</dependency>
<dependency>
<groupId>com.github.MilkBowl</groupId>
<artifactId>VaultAPI</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Enchants</artifactId>
<version>1.0</version>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Staff</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Shop</artifactId>
<version>1.0</version>
</dependency>
<dependency>
<groupId>com.comphenix.protocol</groupId>
<artifactId>ProtocolLib</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>CombatLog</artifactId>
</dependency>
<dependency>
<groupId>factionskore</groupId>
<artifactId>FactionsKore</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/../.lib/FactionsKore-1.3.62.1.jar</systemPath>
</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>
<dependency>
<groupId>winespigot</groupId>
<artifactId>WineSpigot</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/../.lib/WineSpigot-V1.7.4.2.jar</systemPath>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Collect</artifactId>
<version>1.0</version>
</dependency>
</dependencies>
</project>
@@ -0,0 +1,275 @@
package net.crankedpvp.crankedcore;
import com.comphenix.protocol.PacketType;
import com.comphenix.protocol.ProtocolLibrary;
import com.comphenix.protocol.ProtocolManager;
import com.comphenix.protocol.events.ListenerPriority;
import com.comphenix.protocol.events.PacketAdapter;
import com.comphenix.protocol.events.PacketContainer;
import com.comphenix.protocol.events.PacketEvent;
import com.comphenix.protocol.reflect.FieldAccessException;
import lombok.Getter;
import lombok.Setter;
import me.mattstudios.mf.base.CommandManager;
import me.mattstudios.mf.base.components.TypeResult;
import net.crankedpvp.crankedarmor.struct.ArmorSetRegister;
import net.crankedpvp.crankedcore.commands.*;
import net.crankedpvp.crankedcore.data.CrankedUserManager;
import net.crankedpvp.crankedcore.hotfix.CitizensReload;
import net.crankedpvp.crankedcore.items.IceWandItem;
import net.crankedpvp.crankedcore.items.MagicalLavaBucketItem;
import net.crankedpvp.crankedcore.items.MagicalWaterBucketItem;
import net.crankedpvp.crankedcore.items.SandWandItem;
import net.crankedpvp.crankedcore.language.LanguageHandler;
import net.crankedpvp.crankedcore.listeners.*;
import net.crankedpvp.crankedcore.managers.CommandBlockerManager;
import net.crankedpvp.crankedcore.managers.GiveAwayManager;
import net.crankedpvp.crankedcore.managers.HelmetSkinManager;
import net.crankedpvp.crankedcore.managers.StaffChatManager;
import net.crankedpvp.crankedcore.struct.crystals.EnchantEnum;
import net.crankedpvp.crankedcore.struct.gifts.Gift;
import net.crankedpvp.crankedcore.struct.kits.KitManager;
import net.crankedpvp.crankedcore.struct.netherpvp.NetherPvPQueueManager;
import net.crankedpvp.crankedcore.struct.reboot.Reboot;
import net.crankedpvp.crankedcore.struct.typeadapters.GiftAdapterSerializer;
import net.crankedpvp.crankedcore.struct.typeadapters.GiftsListAdapterSerializer;
import net.crankedpvp.crankedcore.tasks.AutoBroadcastTask;
import net.crankedpvp.crankedcore.tasks.ProxyPatchTask;
import net.crankedpvp.crankedcore.utils.ConfigManager;
import net.crankedpvp.crankedutils.utils.PluginUtils;
import net.crankedpvp.staritems.StarItemsAPI;
import net.crankedpvp.storageutils.StorageUtils;
import net.crankedpvp.storageutils.gson.Gson;
import net.crankedpvp.storageutils.gson.reflect.TypeToken;
import net.milkbowl.vault.economy.Economy;
import org.bukkit.Bukkit;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.RegisteredServiceProvider;
import org.bukkit.plugin.java.JavaPlugin;
import java.lang.reflect.Type;
import java.util.List;
@Getter
public class CrankedCore extends JavaPlugin {
private final Type itemstackListType = new TypeToken<List<ItemStack>>(){}.getType();
private final Type giftListType = new TypeToken<List<Gift>>(){}.getType();
private LanguageHandler languageHandler;
private Economy economy;
private StaffChatManager staffChatManager;
private CommandManager commandManager;
private CrankedUserManager crankedUserManager;
private AutoBroadcastTask autoBroadcastTask;
private CommandBlockerManager commandBlockerManager;
private ProtocolManager protocolManager;
private ConfigManager configManager;
private KitManager kitManager;
private HelmetSkinManager helmetSkinManager;
private GiveAwayManager giveAwayManager;
private NetherPvPQueueManager netherPvPQueueManager;
@Setter
private ProxyPatchTask proxyPatchTask;
private Gson gson;
@Setter
private Reboot reboot;
@Getter
private static CrankedCore instance;
public void onEnable() {
instance = this;
saveDefaultConfig();
this.gson = StorageUtils.getInstance()
.getGson()
.newBuilder()
//.registerTypeAdapter(Gift.class, new GiftAdapterDeserializer()).setLenient()
.registerTypeAdapter(Gift.class, new GiftAdapterSerializer()).setLenient()
.registerTypeAdapter(this.giftListType, new GiftsListAdapterSerializer()).setLenient()
//.registerTypeAdapter(this.giftListType, new GiftsListAdapterDeserializer()).setLenient()
.create();
this.commandManager = new CommandManager(this);
this.languageHandler = new LanguageHandler(this);
this.languageHandler.load();
this.staffChatManager = new StaffChatManager();
this.crankedUserManager = new CrankedUserManager(this);
this.commandBlockerManager = new CommandBlockerManager(this);
this.kitManager = new KitManager();
this.kitManager.loadAll();
this.configManager = new ConfigManager(this);
this.configManager.setupFiles();
this.commandBlockerManager.loadCommands(this);
this.giveAwayManager = new GiveAwayManager(this);
this.netherPvPQueueManager = new NetherPvPQueueManager(this);
this.setupEconomy();
this.registerCommands();
this.registerListeners();
this.crankedUserManager.loadAll();
this.autoBroadcastTask = new AutoBroadcastTask(this);
this.autoBroadcastTask.setupMessages();
this.autoBroadcastTask.runTaskTimerAsynchronously(this, 2, 90*20);
this.proxyPatchTask = new ProxyPatchTask();
this.proxyPatchTask.runTaskTimer(this, 80L, 20L);
this.protocolFix();
this.getServer().getScheduler().runTaskLater(this, CitizensReload::reloadCitizens, 10 * 20L);
this.helmetSkinManager = new HelmetSkinManager();
this.helmetSkinManager.load(this);
StarItemsAPI.addItemToStarItemsUI(ArmorSetRegister.getInstance().getArmorSetFromID("spectre").buildHeroicArmorUpgrade(100));
StarItemsAPI.addItemToStarItemsUI(ArmorSetRegister.getInstance().getArmorSetFromID("spectre").buildHeroicWeaponUpgrade(100));
//StarItemsAPI.addItemToStarItemsUI(ArmorSetRegister.getInstance().getArmorSetFromID("spectre").buildHeroicHookUpgrade(100));
}
public void onDisable() {
if (crankedUserManager != null) crankedUserManager.saveAll();
if (this.commandBlockerManager != null) this.commandBlockerManager.saveCommands(this);
if (this.helmetSkinManager != null) this.helmetSkinManager.unload();
instance = null;
}
private void registerListeners() {
PluginUtils.registerListeners(this,
new NetherPvpListener(this),
new ChatListener(this),
new AntiBoatListener(),
new AntiMinecartListener(),
new AntiBookEnchantListener(),
new AlwaysSunnyListener(),
new AntiBedListener(),
new AntiBlockGlitchListener(),
new AntiDroppedItemRemoveListener(),
new AntiDrownListener(),
new AntiFallDamageListener(),
new AntiHopperListener(),
new AntiMinecartListener(),
new AntiSlimeSplitListener(),
new NoHungerListener(),
new AutoFlyListener(),
new ExpBottleListener(),
new MoneyNoteListener(),
new EnderpearlStackListener(),
new MOTDListener(),
new WarzoneClaimListener(),
new KillTitleMessageListener(),
new BlockCommandListener(),
new ServerStatsListener(),
new GoldenAppleSicknessListener(),
new FirstJoinListener(this),
new WarpAliasListener(),
new CrystalListener(),
new AntiDoorHitListener(),
new SandWandItem(this),
new NetherDamageListener(),
new IceWandItem(),
new MagicalLavaBucketItem(this),
new MagicalWaterBucketItem(),
new ProtectLootListener(this),
new WarpCommandListener(),
new AntiBrewingStandListener(),
new LuckpermsRankFixListener(),
new LastHitListener(),
new AntiSlowInVanishListener(),
new ResetSpeedOnJoinListener(),
new EnderPearlCooldownListener(),
new NetherJoinListener()
);
}
private void registerCommands() {
this.commandManager.getParameterHandler().register(EnchantEnum.class, argument -> {
EnchantEnum enchantEnum = EnchantEnum.valueOf(String.valueOf(argument).toUpperCase());
return new TypeResult(enchantEnum, argument);
});
this.commandManager.register(new NetherPvPCommand(this));
this.commandManager.register(new BlessCommand(this));
this.commandManager.register(new InvseeCommand(this));
this.commandManager.register(new StaffChatCommand(this));
this.commandManager.register(new GodsetCommand(this));
this.commandManager.register(new ChatColorCommand(this));
this.commandManager.register(new AdminCoreCommand());
this.commandManager.register(new ExpBottleCommand());
this.commandManager.register(new WithdrawCommand());
this.commandManager.register(new NearCommand(this));
this.commandManager.register(new RenameCommand());
this.commandManager.register(new LoreCommand());
this.commandManager.register(new ClearInventoryCommand(this));
this.commandManager.register(new GiveallCommand());
this.commandManager.register(new BlockCommandCommand(this));
this.commandManager.register(new HealCommand());
this.commandManager.register(new AdminKitCommand(this));
this.commandManager.register(new CheckNBTCommand());
this.commandManager.register(new KitCommand());
this.commandManager.register(new PotsCommand());
this.commandManager.register(new CrystalCommand());
this.commandManager.register(new SandWandCommand());
this.commandManager.register(new IceWandCommand());
this.commandManager.register(new MagicalLavaBucketCommand());
this.commandManager.register(new MagicalWaterBucketCommand());
this.commandManager.register(new RebootCommand(this));
this.commandManager.register(new GiveAwayCommand());
this.commandManager.register(new BroadcastCommand());
this.commandManager.register(new ListCommand());
this.commandManager.register(new DiscordCommand());
this.commandManager.register(new AdminItemsCommand(this));
this.commandManager.register(new LFFCommand());
this.commandManager.register(new DebugPlayerCommand());
this.commandManager.register(new GiftCommand(this));
this.commandManager.register(new GiftsCommand());
this.commandManager.register(new SpawnerShopCommand());
this.commandManager.register(new CrankedStatsCommand());
this.commandManager.register(new RainbowifyCommand());
this.commandManager.register(new ProxyPatchCommand(this));
this.commandManager.register(new FixCommand(this));
this.commandManager.register(new MoreCommand(this));
this.commandManager.register(new SeeAllCommand());
}
private void setupEconomy() {
RegisteredServiceProvider<Economy> provider = Bukkit.getServicesManager().getRegistration(Economy.class);
if (provider != null) {
this.economy = provider.getProvider();
}
}
public void protocolFix() {
this.protocolManager = ProtocolLibrary.getProtocolManager();
this.protocolManager.addPacketListener(new PacketAdapter(this, ListenerPriority.NORMAL, PacketType.Play.Client.TAB_COMPLETE) {
public void onPacketReceiving(PacketEvent event) {
if (event.getPacketType() == PacketType.Play.Client.TAB_COMPLETE) {
if (event.getPlayer().isOp()) return;
try {
PacketContainer packet = event.getPacket();
String message = packet.getSpecificModifier(String.class).read(0).toLowerCase();
if (message.startsWith("/?") && !message.contains(" ") || message.startsWith("/") && !message.contains(" ")
|| message.startsWith("/help") && !message.contains(" ") || message.startsWith("/ver") && !message.contains(" ")
|| message.startsWith("/bukkit") && !message.contains(" ")) {
event.setCancelled(true);
}
} catch (FieldAccessException e) {
e.printStackTrace();
}
}
}
});
}
}
@@ -0,0 +1,29 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Permission;
import me.mattstudios.mf.annotations.SubCommand;
import me.mattstudios.mf.annotations.WrongUsage;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.language.Language;
import org.bukkit.entity.Player;
@Command("cc")
public class AdminCoreCommand extends CommandBase {
@SubCommand("reload")
@WrongUsage("&cUsage: /cc reload")
@Permission("cranked.admin")
public void reloadCommand(Player sender) {
Language.ADMIN_RELOADING.send(sender);
long then = System.currentTimeMillis();
CrankedCore.getInstance().getLanguageHandler().load();
CrankedCore.getInstance().getAutoBroadcastTask().reload();
CrankedCore.getInstance().getCommandBlockerManager().reloadConfig(CrankedCore.getInstance());
long diff = System.currentTimeMillis() - then;
Language.ADMIN_RELOADED.send(sender, str -> str.replace("%took%", String.valueOf(diff)));
}
}
@@ -0,0 +1,27 @@
package net.crankedpvp.crankedcore.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.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.guis.AdminItemsGUI;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
@Command("adminitems")
@Alias({"adminitem", "aitems", "admini"})
public class AdminItemsCommand extends CommandBase {
private final CrankedCore plugin;
public AdminItemsCommand(CrankedCore plugin) {
this.plugin = plugin;
}
@Default
public void defaultCommand(Player player) {
AdminItemsGUI adminItemsGUI = new AdminItemsGUI(player);
adminItemsGUI.getAdminItemGUI().open(player);
player.playSound(player.getLocation(), Sound.CHEST_OPEN, 1.0f, 1.0f);
}
}
@@ -0,0 +1,98 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedcore.struct.kits.Kit;
import net.crankedpvp.crankedcore.struct.kits.KitManager;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.Arrays;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
@Command("ckit")
public class AdminKitCommand extends CommandBase {
private final KitManager kitManager;
public AdminKitCommand(CrankedCore plugin) {
this.kitManager = plugin.getKitManager();
}
@Default
@Permission("cranked.admin")
public void defaultCommand(CommandSender commandSender) {
Language.ADMINKIT_HELP.send(commandSender);
}
@SubCommand("give")
@WrongUsage("&7/ckit &4give &c<kit> <player>")
@Permission("cranked.admin")
public void kitGive(CommandSender sender, String kitName, Player target) {
kitName = kitName.toLowerCase();
Kit kit = this.kitManager.getFromCache(kitName);
if (kit == null) {
Language.KIT_INVALID_NAME.send(sender);
return;
}
String finalKitStringed = kitName;
Language.KIT_RECEIVED.send(sender, string -> string.replace("%kit%", finalKitStringed));
kit.supplyKit(target);
}
@SubCommand("delete")
@WrongUsage("&7/ckit &4delete &c<name>")
@Permission("cranked.admin")
public void kitDelete(CommandSender sender, String kitName) {
kitName = kitName.toLowerCase();
Kit kit = this.kitManager.getFromCache(kitName);
if (kit == null) {
Language.KIT_INVALID_NAME.send(sender);
return;
}
this.kitManager.removeFromCache(kitName);
sender.sendMessage(CC.Green + "Deleted the kit!!");
this.kitManager.saveAll();
this.kitManager.purge();
}
@SubCommand("resetcooldown")
@Permission("cranked.admin")
public void resetCooldownCommand(final CommandSender commandSender, String kitName) {
}
@SubCommand("create")
@WrongUsage("&7/ckit &4create &c<name> <cooldown-in-seconds> <weight> [gkit]")
@Permission("cranked.admin")
public void kitCreate(final CommandSender sender, String kitName, final Integer cooldownInSeconds, final Integer weight, @Optional Boolean gkit) {
if(gkit == null) gkit = false;
kitName = kitName.toLowerCase();
final long cooldownInMs = TimeUnit.SECONDS.toMillis(cooldownInSeconds);
if (this.kitManager.containsKey(kitName)) {
//already exist
Language.ADMINKIT_ALREADY_EXISTS.send(sender);
return;
}
final ItemStack[] itemStacks = Arrays.stream(((Player) sender).getInventory().getContents())
.filter(Objects::nonNull)
.map(ItemStack::clone)
.toArray(ItemStack[]::new);
this.kitManager.addToCache(new Kit(itemStacks, cooldownInMs, gkit, weight, kitName));
this.kitManager.saveAll();
this.kitManager.purge();
Language.ADMINKIT_CREATED.send(sender);
}
}
@@ -0,0 +1,34 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.Optional;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("bless")
public class BlessCommand extends CommandBase {
private final CrankedCore plugin;
public BlessCommand(CrankedCore plugin) {
this.plugin = plugin;
}
@Default
public void defaultCommand(CommandSender commandSender, @Optional Player player) {
if(player != null && player.isOnline() && !commandSender.hasPermission("bless.other")) {
Language.NO_PERMISSION.send(commandSender);
return;
}
player = (Player) commandSender;
PotionEffectUtils.bless(player);
Language.BLESS.send(player);
}
}
@@ -0,0 +1,59 @@
package net.crankedpvp.crankedcore.commands;
import net.crankedpvp.crankedutils.utils.CC;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.managers.CommandBlockerManager;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("blockedcommand")
@Alias("blockcommand")
public class BlockCommandCommand extends CommandBase {
private CrankedCore plugin;
private CommandBlockerManager commandBlockerManager;
public BlockCommandCommand(CrankedCore plugin) {
this.plugin = plugin;
this.commandBlockerManager = plugin.getCommandBlockerManager();
}
@Default
@Permission("cranked.admin")
public void onDefault(CommandSender sender) {
Player player = (Player) sender;
player.sendMessage(CC.translate("&c&lBlockedCommand Commands"));
player.sendMessage(CC.translate("&c/blockedcommand add <command without />"));
player.sendMessage(CC.translate("&c/blockedcommand remove <command without />"));
player.sendMessage(CC.translate("&c/blockedcommand list"));
}
@SubCommand("add")
@Permission("cranked.admin")
public void addCommand(CommandSender sender, String command) {
Player player = (Player) sender;
commandBlockerManager.blockCommand(player, command);
commandBlockerManager.saveCommands(plugin);
}
@SubCommand("remove")
@Permission("cranked.admin")
public void removeCommand(CommandSender sender, String command) {
Player player = (Player) sender;
commandBlockerManager.unBlockCommand(player, command);
commandBlockerManager.saveCommands(plugin);
}
@SubCommand("list")
@Permission("cranked.admin")
public void listCommand(CommandSender sender) {
Player player = (Player) sender;
player.sendMessage(CC.translate("&c&lBlocked Commands List:"));
for (String cmd : commandBlockerManager.getBlockedCommands()) {
player.sendMessage(CC.Red + "/" + cmd);
}
player.sendMessage(CC.translate("&c "));
}
}
@@ -0,0 +1,24 @@
package net.crankedpvp.crankedcore.commands;
import net.crankedpvp.crankedutils.utils.CC;
import me.mattstudios.mf.annotations.Alias;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.Permission;
import me.mattstudios.mf.base.CommandBase;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
@Command("cbc")
@Alias({"abc"})
public class BroadcastCommand extends CommandBase {
@Default
@Permission("cranked.admin")
public void broadcastCommand(final CommandSender commandSender, String[] messages) {
Bukkit.broadcastMessage("");
Bukkit.broadcastMessage(CC.translate("&c&lAlert &8➥ &c" + String.join(" ", messages)));
Bukkit.broadcastMessage("");
}
}
@@ -0,0 +1,37 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.data.CrankedUser;
import net.crankedpvp.crankedcore.data.CrankedUserManager;
import net.crankedpvp.crankedcore.guis.ChatColorGUI;
import net.crankedpvp.crankedcore.language.Language;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("chatcolor")
public class ChatColorCommand extends CommandBase {
private final CrankedUserManager crankedUserManager;
private final CrankedCore plugin;
public ChatColorCommand(CrankedCore plugin) {
this.plugin = plugin;
this.crankedUserManager = plugin.getCrankedUserManager();
}
@Default
public void defaultCommand(CommandSender sender) {
Player player = (Player) sender;
if(!player.hasPermission("astrocore.chatcolor")) {
Language.NO_PERMISSION.send(sender);
return;
}
CrankedUser crankedUser = crankedUserManager.getCrankedUser(player.getUniqueId());
ChatColorGUI chatColorGUI = new ChatColorGUI(crankedUser);
chatColorGUI.getChatColorGUI().open(player);
}
}
@@ -0,0 +1,78 @@
package net.crankedpvp.crankedcore.commands;
import de.tr7zw.nbtapi.NBTItem;
import me.mattstudios.mf.annotations.Alias;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.Permission;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.Objects;
import java.util.StringJoiner;
@Command("checknbt")
@Alias({"nbtcheck", "printnbt"})
public class CheckNBTCommand extends CommandBase {
@Default
@Permission("cranked.admin")
public void defaultCommand(final Player player) {
ItemStack itemStack = player.getItemInHand();
if(ItemUtils.isAirOrNull(itemStack)) return;
NBTItem nbtItem = new NBTItem(itemStack);
if(!nbtItem.hasNBTData()) return;
player.sendMessage(CC.translate("&dNBT Tag Checker"));
for(String key : nbtItem.getKeys()) {
if(nbtItem.getCompound(key) != null) {
player.sendMessage(CC.translate(" &5* &fCompound: " + key));
for(String key2 : nbtItem.getCompound(key).getKeys()) {
player.sendMessage(CC.translate(" &d➥ &fKey: " + key2 + " &8| &f" + getStringOfWhateverDataTypeTheNbtTagIs(nbtItem, key, key2)));
//nbtItem.getCompound(key).getString(key2)));
}
}
}
player.sendMessage(CC.translate(" &5* &fNo Compound Keys"));
for(String key : nbtItem.getKeys()) {
if(nbtItem.getCompound(key) != null) continue;
player.sendMessage(CC.translate(" &d➥ &fKey: " + key + " &8| &f" + getStringOfWhateverDataTypeTheNbtTagIs(nbtItem, null, key)));
//nbtItem.getString(key)));
}
}
private String getStringOfWhateverDataTypeTheNbtTagIs(NBTItem nbtItem, String compoundKey, String key) {
if(compoundKey == null) {
if(!nbtItem.hasKey(key)) return "";
if(nbtItem.getString(key) != null && !Objects.equals(nbtItem.getString(key), "")) return "String: " + nbtItem.getString(key);
if(nbtItem.getBoolean(key) != null && (nbtItem.getBoolean(key) == Boolean.TRUE || nbtItem.getBoolean(key) == Boolean.FALSE)) return "Boolean:" + nbtItem.getBoolean(key);
if(nbtItem.getInteger(key) != null) return "Integer:" + nbtItem.getInteger(key);
if(nbtItem.getFloat(key) != null && !Objects.equals(String.valueOf(nbtItem.getFloat(key)), "")) return "Float:" + nbtItem.getFloat(key);
if(nbtItem.getLong(key) != null && !Objects.equals(String.valueOf(nbtItem.getLong(key)), "")) return "Long:" + nbtItem.getLong(key);
if(nbtItem.getStringList(key) != null) {
StringJoiner stringJoiner = new StringJoiner(", ");
for(String s : nbtItem.getStringList(key)) {
stringJoiner.add(s);
}
return "String List: " + stringJoiner;
}
} else {
if(!nbtItem.getCompound(compoundKey).hasKey(key)) return "";
if(nbtItem.getCompound(compoundKey).getString(key) != null && !Objects.equals(nbtItem.getString(key), "")) return "String:" + nbtItem.getCompound(compoundKey).getString(key);
if(nbtItem.getCompound(compoundKey).getBoolean(key) != null && (nbtItem.getCompound(compoundKey).getBoolean(key) == Boolean.TRUE || nbtItem.getCompound(compoundKey).getBoolean(key) == Boolean.FALSE)) return "Boolean:" + nbtItem.getCompound(compoundKey).getBoolean(key);
if(nbtItem.getCompound(compoundKey).getInteger(key) != null) return "Integer:" + nbtItem.getCompound(compoundKey).getInteger(key);
if(nbtItem.getCompound(compoundKey).getFloat(key) != null) return "Float:" + nbtItem.getCompound(compoundKey).getFloat(key);
if(nbtItem.getCompound(compoundKey).getLong(key) != null) return "Long:" + nbtItem.getCompound(compoundKey).getLong(key);
if(nbtItem.getCompound(compoundKey).getStringList(key) != null) {
StringJoiner stringJoiner = new StringJoiner(", ");
for(String s : nbtItem.getCompound(compoundKey).getStringList(key)) {
stringJoiner.add(s);
}
return "String List: " + stringJoiner;
}
}
return "";
}
}
@@ -0,0 +1,60 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.Sound;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
@Command("clearinventoryy")
@Alias("ci")
public class ClearInventoryCommand extends CommandBase {
private final List<Player> playersAbleToConfirm;
private final CrankedCore plugin;
public ClearInventoryCommand(CrankedCore plugin) {
this.plugin = plugin;
this.playersAbleToConfirm = new ArrayList<>();
}
@Default
public void defaultCommand(CommandSender commandSender, @Optional @Completion("#players") Player receiver) {
if(!(commandSender instanceof Player)) return;
if(receiver != null && commandSender.hasPermission("ci.admin")) {
this.clear(receiver);
receiver.sendMessage(CC.translate("&a&l(!) &aYour inventory has been fully cleared"));
commandSender.sendMessage(CC.translate("&a&l(!) &aYou have cleared " + receiver.getName() + "'s inventory"));
return;
}
Player player = (Player) commandSender;
if(this.plugin.getCrankedUserManager().getCrankedUser(player.getUniqueId()).isCiConfirmEnabled()) {
if(this.playersAbleToConfirm.contains(player)) {
player.sendMessage(CC.translate("&a&l(!) &aSuccessfully cleared all items from your inventory"));
this.clear(player);
this.playersAbleToConfirm.remove(player);
return;
}
this.playersAbleToConfirm.add(player);
player.sendMessage(CC.translate("&e&l(!) &eType &f/ci &eagain to confirm that you want to clear your inventory"));
plugin.getServer().getScheduler().runTaskLater(plugin, () -> this.playersAbleToConfirm.remove(player), 20L * 5);
return;
}
player.sendMessage(CC.translate("&a&l(!) &aSuccessfully cleared all items from your inventory"));
this.clear(player);
}
private void clear(Player player) {
player.getInventory().clear();
player.updateInventory();
player.playSound(player.getLocation(), Sound.SUCCESSFUL_HIT, 2.0F, 2.0F);
}
}
@@ -0,0 +1,20 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.Permission;
import me.mattstudios.mf.base.CommandBase;
import org.bukkit.Statistic;
import org.bukkit.entity.Player;
@Command("cstats")
public class CrankedStatsCommand extends CommandBase {
@Default
@Permission("cranked.admin")
public void test(final Player player) {
for(Statistic value : Statistic.values()) {
player.sendMessage(value.name() + ": " + player.getStatistic(value));
}
}
}
@@ -0,0 +1,32 @@
package net.crankedpvp.crankedcore.commands;
import net.crankedpvp.crankedutils.utils.CC;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.struct.crystals.CrystalItem;
import net.crankedpvp.crankedcore.struct.crystals.EnchantEnum;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("crystal")
public class CrystalCommand extends CommandBase {
@Default
@WrongUsage("&cUsage: /crystal <enchant> <level> [player]")
@Permission("cranked.admin")
public void onCommand(CommandSender sender, @Completion("#enum") EnchantEnum enchant, @Completion("#range:1-9") Integer level, @Optional @Completion("#players") Player player) {
if (level > enchant.getMaxLevel()) {
sender.sendMessage(CC.translate("&c&lWARNING &cyou redeemed a crystal above the max level"));
}
if (player != null) {
player.getInventory().addItem(CrystalItem.createCrystal(enchant, level));
return;
}
if (sender instanceof Player) {
((Player) sender).getInventory().addItem(CrystalItem.createCrystal(enchant, level));
}
}
}
@@ -0,0 +1,63 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedarmor.struct.ArmorSet;
import net.crankedpvp.crankedarmor.struct.cache.ArmorSetCache;
import net.crankedpvp.crankedmasks.CrankedMasksAPI;
import net.crankedpvp.crankedmasks.struct.Mask;
import net.crankedpvp.crankedutils.CrankedUtils;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.cache.CachedPlayer;
import net.crankedpvp.staritems.StarItemsAPI;
import net.crankedpvp.staritems.struct.StarItem;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
@Command("debugplayer")
public class DebugPlayerCommand extends CommandBase {
@Default()
@Permission("cranked.admin")
public void defaultCommand(Player sender, @Optional @Completion("#players") Player player) {
if (player == null) {
checkPlayer(sender, sender);
} else {
checkPlayer(player, sender);
}
}
public void checkPlayer(Player toCheck, Player sender) {
CachedPlayer armorSetPlayer = CrankedUtils.getInstance().getCacheManager().getCachedPlayer(toCheck);
ArmorSetCache cache = (ArmorSetCache) (armorSetPlayer.hasCache("armor_set") ? armorSetPlayer.getCache("armor_set") : armorSetPlayer.registerCache(new ArmorSetCache(toCheck)));
sender.sendMessage(CC.translate("&8----------------------------"));
String set = cache.getCurrentArmorSet().getName() != null ? cache.getCurrentArmorSet().getName() : "none";
sender.sendMessage(CC.translate("&dSet Information: &f" + set));
for (Map.Entry<ArmorSet, Integer> entry : cache.getArmorSets().entrySet()) {
sender.sendMessage(CC.translate("&d * &f" + entry.getKey().getName() + " &8: &7" + entry.getValue()));
}
if(StarItemsAPI.playerHasStarItemInCache(toCheck)) {
sender.sendMessage(CC.translate("&cStar Items"));
for(StarItem starItem : StarItemsAPI.getStarItemFromCache(toCheck)) {
sender.sendMessage(CC.translate(" &c* &f" + starItem.getName()));
}
}
ItemStack helmet = toCheck.getInventory().getHelmet();
if(helmet != null && helmet.getType() != Material.AIR) {
if(CrankedMasksAPI.itemHasMaskEquipped(helmet)) {
sender.sendMessage(CC.translate("&bMask: &f" + Objects.requireNonNull(CrankedMasksAPI.getMasksOnItem(helmet)).stream().map(Mask::getName).collect(Collectors.joining(", "))));
}
}
sender.sendMessage(CC.translate("&8----------------------------"));
}
}
@@ -0,0 +1,23 @@
package net.crankedpvp.crankedcore.commands;
import net.crankedpvp.crankedutils.utils.CC;
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.command.CommandSender;
@Command("discord")
@Alias({"discordlink", "disc"})
public class DiscordCommand extends CommandBase {
@Default
public void discordCommand(final CommandSender sender) {
sender.sendMessage("");
sender.sendMessage(CC.translate("&c&lCranked&f&lPvP &c&lDiscord"));
sender.sendMessage(CC.translate("&f&ndiscord.gg/crankedpvp"));
sender.sendMessage(CC.translate("&7Click to join the CrankedPvP Discord!"));
sender.sendMessage("");
}
}
@@ -0,0 +1,81 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedcore.utils.ExpBottleAPI;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.NumberUtils;
import net.crankedpvp.crankedutils.utils.PlayerUtils;
import net.crankedpvp.crankedutils.utils.XPUtils;
import org.bukkit.ChatColor;
import org.bukkit.Sound;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("xpbottle")
@Alias("expbottle")
public class ExpBottleCommand extends CommandBase {
private final int MAX_WITHDRAW = 10000000;
private final int MIN_WITHDRAW = 25;
@Default
public void onDefault(CommandSender sender, @Optional String amount) {
Player p = (Player) sender;
if (amount == null) {
for (String line : Language.EXP_BOTTLE_HELP.getValuesAsList()) {
p.sendMessage(CC.translate(line));
}
return;
}
if (amount.contains(".") || amount.contains(",")) {
Language.WITHDRAW_DECIMAL.send(p);
return;
}
int amountInt;
try {
amountInt = Integer.parseInt(amount);
} catch (NumberFormatException e) {
amountInt = (int) NumberUtils.getValueFromFormat(amount);
}
withdrawExp(p, amountInt);
}
@SubCommand("all")
public void onExpBottleString(CommandSender sender) {
Player p = (Player) sender;
int amount = p.getTotalExperience();
withdrawExp(p, amount);
}
public void withdrawExp(Player p, int amount) {
if (amount < MIN_WITHDRAW) {
p.sendMessage(ChatColor.RED + "You must withdraw at least " + NumberUtils.formatMoney(MIN_WITHDRAW) + " XP points per bottle.");
return;
}
if (amount > MAX_WITHDRAW) {
p.sendMessage(ChatColor.RED + "You can only withdraw a max of " + NumberUtils.formatMoney(MAX_WITHDRAW) + " XP points per bottle.");
return;
}
float currentXp = p.getTotalExperience();
if (currentXp < amount) {
Language.EXP_BOTTLE_NOT_ENOUGH.send(p);
return;
}
XPUtils.removeExperience(p, amount);
p.sendMessage(CC.translate(Language.EXP_BOTTLE_WITHDRAW.getMessage().replace("%amount%", NumberUtils.formatMoney(amount))));
p.playSound(p.getLocation(), Sound.ORB_PICKUP, 1.0f, 0.2f);
PlayerUtils.giveOrDropProtectedItem(p, ExpBottleAPI.getXpBottle(amount, p), 60);
}
}
@@ -0,0 +1,87 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedutils.utils.Arrow;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import net.crankedpvp.staritems.StarItemsAPI;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@Command("fix")
@Alias("repair")
public class FixCommand extends CommandBase {
private final CrankedCore plugin;
public FixCommand(CrankedCore plugin) {
this.plugin = plugin;
}
@Default
public void defaultCommand(final Player player) {
runFixCode(player);
}
@SubCommand("hand")
public void handCommand(final Player player) {
runFixCode(player);
}
@SubCommand("all")
@Permission("cranked.fix.all")
public void allCommand(final Player player) {
if(player == null) return;
List<ItemStack> items = new ArrayList<>();
items.addAll(Arrays.asList(player.getInventory().getContents()));
items.addAll(Arrays.asList(player.getInventory().getArmorContents()));
for(ItemStack item : items) {
if(ItemUtils.isAirOrNull(item)) continue;
if(!isDamageable(item.getType())) continue;
item.setDurability((short) 0);
}
player.playSound(player.getLocation(), Sound.LEVEL_UP, 2.0f, 1.0f);
player.sendMessage(CC.translate("&c&lFix &8" + Arrow.arrow() + " &7All items in your inventory have been repaired"));
}
private void runFixCode(Player player) {
if(player == null) return;
ItemStack itemStack = player.getItemInHand();
if(ItemUtils.isAirOrNull(itemStack)) {
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0f, 1.0f);
player.sendMessage(CC.translate("&c&lFix &8" + Arrow.arrow() + " &7You must be holding an item to fix"));
return;
}
if(!isDamageable(itemStack.getType())) {
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0f, 1.0f);
player.sendMessage(CC.translate("&c&lFix &8" + Arrow.arrow() + " &7You cannot fix an item that cannot take damage"));
return;
}
if(StarItemsAPI.isGoldenKnife(itemStack)) {
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0f, 1.0f);
player.sendMessage(CC.translate("&c&lFix &8" + Arrow.arrow() + " &7You cannot repair the &6&lGolden Knife"));
return;
}
itemStack.setDurability((short) 0);
player.playSound(player.getLocation(), Sound.LEVEL_UP, 2.0f, 1.0f);
player.sendMessage(CC.translate("&c&lFix &8" + Arrow.arrow() + " &7Your item has been successfully repaired"));
}
private boolean isDamageable(Material material) {
return material.getMaxDurability() > 0;
}
}
@@ -0,0 +1,54 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Completion;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.WrongUsage;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.data.CrankedUser;
import net.crankedpvp.crankedcore.data.CrankedUserManager;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.entity.Player;
@Command("gift")
public class GiftCommand extends CommandBase {
private final CrankedUserManager crankedUserManager;
public GiftCommand(CrankedCore plugin) {
this.crankedUserManager = plugin.getCrankedUserManager();
}
@Default
@WrongUsage("&c/gift <player> <message>")
public void giftToPlayer(Player sender, @Completion("#players") Player receiver, String[] message) {
if (sender.equals(receiver)) {
Language.GIFT_URSELF.send(sender);
return;
}
if (ItemUtils.isAirOrNull(sender.getItemInHand())) {
Language.CANNOT_HAVE_EMPTY_HAND.send(sender);
return;
}
CrankedUser crankedUser = this.crankedUserManager.getCrankedUser(receiver.getUniqueId());
if (crankedUser == null) {
sender.sendMessage(CC.Red + "Please enter a valid online player!");
return;
}
if (crankedUser.alreadyHasOver5GiftsFromPlayer(sender)) {
Language.ALREADY_HAS_GIFT.send(sender);
return;
}
crankedUser.addGift(sender, sender.getItemInHand(), message);
crankedUser.getPlayer().sendMessage(CC.translate(Language.RECEIVED_GIFT.getMessage().replace("{sender}", sender.getName())));
sender.sendMessage(CC.translate(Language.SENT_GIFT.getMessage().replace("{receiver}", crankedUser.getPlayer().getName())));
sender.setItemInHand(null);
}
}
@@ -0,0 +1,19 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.data.CrankedUserManager;
import net.crankedpvp.crankedcore.guis.GiftsGUI;
import org.bukkit.entity.Player;
@Command("gifts")
public class GiftsCommand extends CommandBase {
@Default
public void showGifts(Player sender) {
GiftsGUI giftsGui = new GiftsGUI(sender);
giftsGui.getGui().open(sender);
}
}
@@ -0,0 +1,55 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("giveaway")
@Alias({"ga", "giveaways"})
public class GiveAwayCommand extends CommandBase {
@Default
public boolean onDefault(CommandSender sender) {
Player player = (Player) sender;
player.sendMessage(CC.translate(""));
player.sendMessage(CC.translate("&b&lCranked Giveaways"));
player.sendMessage(CC.translate("&b&l* &f/giveaway join &b- &7Join an active giveaway"));
if (sender.hasPermission("cranked.giveaway")) {
player.sendMessage(CC.translate("&b&l* &f/giveaway start <winners> <timeInS> &b- &7Start a giveaway"));
player.sendMessage(CC.translate("&b&l* &f/giveaway cancel &b- &7Cancel a giveaway"));
}
player.sendMessage(CC.translate(""));
return true;
}
@SubCommand("join")
public void onCmdJoin(CommandSender sender) {
CrankedCore.getInstance().getGiveAwayManager().joinGiveAway((Player) sender);
}
@SubCommand("start")
@Permission("cranked.giveaway")
public void onGaStart(CommandSender sender, Integer winners, Integer timeInS) {
CrankedCore.getInstance().getGiveAwayManager().startGiveAway((Player) sender, winners, ((Player) sender).getItemInHand(), timeInS);
}
@SubCommand("cancel")
@Permission("cranked.giveaway")
public void onGaCancel(CommandSender sender) {
CrankedCore.getInstance().getGiveAwayManager().cancelGiveAway((Player) sender);
}
@SubCommand("addfakejoins")
@Permission("cranked.admin")
public void addFakeJoinsCommand(final CommandSender commandSender, Integer amount) {
CrankedCore.getInstance().getGiveAwayManager().addFakeJoins(amount);
}
}
@@ -0,0 +1,66 @@
package net.crankedpvp.crankedcore.commands;
import net.crankedpvp.crankedutils.utils.CC;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.Optional;
import me.mattstudios.mf.annotations.Permission;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedutils.utils.PlayerUtils;
import org.apache.commons.lang.WordUtils;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.HashMap;
import java.util.Map;
@Command("giveall")
public class GiveallCommand extends CommandBase {
@Permission("cranked.admin")
@Default
public void onCommand(CommandSender sender, @Optional Integer altLimit) {
Player player = (Player)sender;
if (altLimit == null) {
player.sendMessage(CC.translate("&c&lGiveall Commands"));
player.sendMessage(CC.translate("&c/giveall [Max Alts] &7- &fPut 0 for no alts allowed"));
return;
}
if (player.getItemInHand() == null || player.getItemInHand().getType() == Material.AIR) {
player.sendMessage(CC.translate("&c&l(!) &cYou must be holding an item to give all."));
}
final ItemStack itemToGive = player.getItemInHand().clone();
final Map<String, Integer> ipMap = new HashMap<>();
int given = 0;
String displayName = itemToGive.hasItemMeta() ? itemToGive.getItemMeta().getDisplayName() : null;
if (displayName == null) {
displayName = WordUtils.capitalizeFully(itemToGive.getType().name().replace("_", " "));
}
for (final Player p : Bukkit.getOnlinePlayers()) {
if (p.getUniqueId().toString().equals(player.getUniqueId().toString())) {
continue;
}
final String ip = p.getAddress().getAddress().toString();
if (ipMap.containsKey(ip) && ipMap.get(ip) > altLimit) {
continue;
}
String msg = Language.GIVEALL_RECEIVED.getMessage();
msg = msg.replace("%item%", displayName);
msg = msg.replace("%amount%", Integer.toString(itemToGive.getAmount()));
p.sendMessage(CC.translate(msg));
PlayerUtils.giveOrDropProtectedItem(p, itemToGive, 60);
given++;
ipMap.put(ip, ipMap.getOrDefault(ip, 0) + 1);
}
player.sendMessage(CC.translate("&a&l(!) &aSuccessfully gave all " + displayName + "&a to &f" + given + " &aplayers!"));
}
}
@@ -0,0 +1,73 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedenchants.CrankedEnchants;
import net.crankedpvp.crankedenchants.struct.EnchantRegister;
import net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment;
import net.crankedpvp.crankedenchants.struct.enums.EnchantTier;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedenchants.struct.items.SoulTrackerBuilder;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.GodsetUtils;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.apache.commons.codec.language.bm.Lang;
import org.bukkit.Sound;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Command("godset")
@Alias("quickenchant")
public class GodsetCommand extends CommandBase {
private final CrankedCore plugin;
private final EnchantRegister enchantRegister;
public GodsetCommand(CrankedCore plugin) {
this.plugin = plugin;
this.enchantRegister = CrankedEnchants.getInstance().getEnchantRegister();
}
@Default
@Permission("cranked.admin")
public void defaultCommand(CommandSender commandSender) {
Player player = (Player) commandSender;
ItemStack itemStack = player.getItemInHand();
if(!ItemUtils.isArmor(itemStack) && !ItemUtils.isWeapon(itemStack)) {
player.sendMessage(CC.translate("&cThis is not an armor piece or a weapon"));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
EnchantedItemBuilder enchantedItemBuilder = new EnchantedItemBuilder(player.getItemInHand());
for(String enchantName : GodsetUtils.enchantments.get(itemStack.getType().name().split("_")[1].toLowerCase())) {
Enchantment enchantment = this.enchantRegister.getEnchantmentFromID(enchantName);
enchantedItemBuilder.addEnchantment(enchantment, enchantment.getMax());
}
enchantedItemBuilder.sortEnchantLore();
enchantedItemBuilder.setProtected(true);
Language.GODSET_SUCCESS.send(player);
player.getInventory().setItemInHand(enchantedItemBuilder.build());
player.playSound(player.getLocation(), Sound.VILLAGER_YES, 2.0F, 2.0F);
}
}
@@ -0,0 +1,30 @@
package net.crankedpvp.crankedcore.commands;
import net.crankedpvp.crankedutils.utils.CC;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedcore.struct.cooldowns.HealCooldown;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("heal")
@Alias("eheal")
public class HealCommand extends CommandBase {
@Default
public void healOther(CommandSender sender) {
Player player = (Player) sender;
int cooldown = Integer.parseInt(Language.heal_cooldown.getValue());
if (CooldownUtils.isCooldownActive(player, "healCooldown")) {
player.sendMessage(CC.translate(Language.HEAL_COOLDOWN.getMessage().replace("%left%", CooldownUtils.getFormattedCooldown(player, "healCooldown"))));
return;
}
player.setHealth(player.getMaxHealth());
Language.HEALED.send(player);
CooldownUtils.registerCooldown(player, new HealCooldown("healCooldown", cooldown));
}
}
@@ -0,0 +1,25 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.items.IceWandItem;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("icewand")
public class IceWandCommand extends CommandBase {
@Default
@WrongUsage("&cUsage: /icewand <radius> <uses> [player]")
@Permission("cranked.admin")
public void onCommand(CommandSender sender, Integer radius, Integer uses, @Completion("#players") @Optional Player player) {
if (player != null) {
player.getInventory().addItem(IceWandItem.createItem(radius, uses));
return;
}
if (sender instanceof Player) {
((Player) sender).getInventory().addItem(IceWandItem.createItem(radius, uses));
}
}
}
@@ -0,0 +1,44 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Completion;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.WrongUsage;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.guis.InvseeGUI;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedmasks.CrankedMasks;
import net.crankedpvp.crankedmasks.CrankedMasksAPI;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
@Command("invsee")
public class InvseeCommand extends CommandBase {
private final CrankedCore plugin;
public InvseeCommand(CrankedCore plugin) {
this.plugin = plugin;
}
@Default
@WrongUsage("&c/invsee <Player>")
public void defaultCommand(Player sender, @Completion("#players") Player player) {
if (player == null) return;
if(player.getName().equals(sender.getName())) {
Language.CANNOT_INVSEE_YOURSELF.send(sender);
sender.playSound(sender.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
if (CrankedMasksAPI.hasMaskEquipped(player, CrankedMasks.getInstance().getMasksRegister().getMaskFromID("ghost")) && !player.hasPermission("cranked.admin")) {
Language.CANNOT_INVSEE_GHOST_MASK.send(sender);
return;
}
InvseeGUI invseeGUI = new InvseeGUI(sender, player);
invseeGUI.getGui().open(sender);
}
}
@@ -0,0 +1,48 @@
package net.crankedpvp.crankedcore.commands;
import net.crankedpvp.crankedutils.utils.CC;
import me.mattstudios.mf.annotations.Alias;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.Optional;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.data.CrankedUser;
import net.crankedpvp.crankedcore.guis.GlobalKitsGUI;
import net.crankedpvp.crankedcore.struct.kits.Kit;
import org.bukkit.entity.Player;
@Command("kit")
@Alias({"ekit", "kits", "ekits", "gkit"})
public class KitCommand extends CommandBase {
@Default
public void defaultCommand(final Player player, @Optional String kitName) {
if(kitName == null) {
GlobalKitsGUI globalKitsGUI = new GlobalKitsGUI(player);
globalKitsGUI.getGui().open(player);
return;
}
Kit kit = CrankedCore.getInstance().getKitManager().getFromCache(kitName);
if(kit == null) {
player.sendMessage(CC.translate("&cThat is not a valid kit name"));
return;
}
if(!kit.hasAccess(player)) {
player.sendMessage(CC.translate("&cYou do not have permission to access this kit"));
return;
}
CrankedUser crankedUser = CrankedCore.getInstance().getCrankedUserManager().getCrankedUser(player.getUniqueId());
if(crankedUser.hasCooldownOnKit(kit)) {
player.sendMessage(CC.translate("&cYou are currently on coolkdown for this kit"));
return;
}
crankedUser.newCooldownOnKit(kit);
kit.supplyKit(player);
}
}
@@ -0,0 +1,26 @@
package net.crankedpvp.crankedcore.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.crankedcore.cooldowns.LFFCooldown;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
@Command("lff")
@Alias("lookingforfaction")
public class LFFCommand extends CommandBase {
@Default
public void onCommand(Player player) {
if (CooldownUtils.isCooldownActive(player, "lff")) {
player.sendMessage(CC.translate( Language.LOOKING_FOR_FACTION_COOLDOWN.getMessage().replace("%time%", CooldownUtils.getFormattedCooldown(player, "lff"))));
return;
}
CooldownUtils.registerCooldown(player, new LFFCooldown("lff", 60));
Bukkit.broadcastMessage( Language.LOOKING_FOR_FACTION.getMessage().replace("%player_displayname%", player.getDisplayName()));
}
}
@@ -0,0 +1,21 @@
package net.crankedpvp.crankedcore.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.crankedutils.utils.CC;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
@Command("list")
@Alias({"elist", "playerlist", "plist"})
public class ListCommand extends CommandBase {
@Default
public void onDefault(Player p) {
p.sendMessage("");
p.sendMessage(CC.translate("&c&lCranked&f&lPvP List &7[" + Bukkit.getOnlinePlayers().size() + "&7 Online]"));
p.sendMessage("");
}
}
@@ -0,0 +1,59 @@
package net.crankedpvp.crankedcore.commands;
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 org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
@Command("lore")
public class LoreCommand extends CommandBase {
@Default
@Permission("cranked.admin")
public void defaultCommand(final CommandSender commandSender) {
commandSender.sendMessage(CC.Red + "/lore add (text)");
commandSender.sendMessage(CC.Red + "/lore delete <line>");
}
@Permission("cranked.admin")
@SubCommand("add")
public void addLine(CommandSender commandSender, String[] text) {
Player player = (Player) commandSender;
if(player.getItemInHand() == null || player.getItemInHand().getType() == Material.AIR) {
player.sendMessage(CC.Red + "Please hold an item");
return;
}
ItemBuilder itemBuilder = new ItemBuilder(player.getItemInHand());
List<String> listOfStrings = Arrays.stream(text).collect(Collectors.toList());
listOfStrings.remove(0);
itemBuilder.addLore(String.join(" ", listOfStrings));
player.setItemInHand(itemBuilder.colorize().build());
player.updateInventory();
player.sendMessage(CC.translate("&aSuccessfully &nadded&a lore line to your item"));
}
@Permission("cranked.admin")
@SubCommand("delete")
public void deleteLore(CommandSender commandSender, @Optional Integer line) {
Player player = (Player) commandSender;
if(player.getItemInHand() == null || player.getItemInHand().getType() == Material.AIR) {
player.sendMessage(CC.Red + "Please hold an item");
return;
}
line = line == null ? ((Player) commandSender).getItemInHand().getItemMeta().getLore().size()-1 : line - 1;
ItemBuilder itemBuilder = new ItemBuilder(player.getItemInHand());
itemBuilder.removeLoreLine(line);
player.setItemInHand(itemBuilder.colorize().build());
player.updateInventory();
player.sendMessage(CC.translate("&aSuccessfully &nremoved&a lore line from your item"));
}
}
@@ -0,0 +1,27 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.items.MagicalLavaBucketItem;
import net.crankedpvp.crankedcore.items.MagicalWaterBucketItem;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("mlb")
@Alias("magicallavabucket")
public class MagicalLavaBucketCommand extends CommandBase {
@Default
@WrongUsage("&cUsage: /mlb <uses> [player]")
@Permission("cranked.admin")
public void onCommand(CommandSender sender, Integer uses, @Completion("#players") @Optional Player player) {
if (player != null) {
player.getInventory().addItem(MagicalLavaBucketItem.createMagicalLavaBucket(uses));
return;
}
if (sender instanceof Player) {
((Player) sender).getInventory().addItem(MagicalLavaBucketItem.createMagicalLavaBucket(uses));
}
}
}
@@ -0,0 +1,28 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.items.IceWandItem;
import net.crankedpvp.crankedcore.items.MagicalLavaBucketItem;
import net.crankedpvp.crankedcore.items.MagicalWaterBucketItem;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("mwb")
@Alias("magicalwaterbucket")
public class MagicalWaterBucketCommand extends CommandBase {
@Default
@WrongUsage("&cUsage: /mwb <uses> [player]")
@Permission("cranked.admin")
public void onCommand(CommandSender sender, Integer uses, @Completion("#players") @Optional Player player) {
if (player != null) {
player.getInventory().addItem(MagicalWaterBucketItem.createMagicalWaterBucket(uses));
return;
}
if (sender instanceof Player) {
((Player) sender).getInventory().addItem(MagicalWaterBucketItem.createMagicalWaterBucket(uses));
}
}
}
@@ -0,0 +1,63 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.Permission;
import me.mattstudios.mf.annotations.SubCommand;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.Collections;
import java.util.List;
@Command("more")
public class MoreCommand extends CommandBase {
private final CrankedCore plugin;
public MoreCommand(CrankedCore plugin) {
this.plugin = plugin;
}
@Default
@Permission("cranked.admin")
public void defaultCommand(final Player player) {
ItemStack itemStack = player.getItemInHand();
if(ItemUtils.isAirOrNull(itemStack)) return;
player.getItemInHand().setAmount(64);
this.log(player, itemStack);
}
@SubCommand("logs")
@Permission("*")
public void logsCommand(final CommandSender commandSender) {
System.out.print("/more logs");
for (String logs : this.plugin.getConfig().getStringList("logs")) {
System.out.println(CC.translate(logs));
}
}
private void log(Player player, ItemStack itemStack) {
if(!itemStack.hasItemMeta()) return;
if(!this.plugin.getConfig().contains("logs") || this.plugin.getConfig().getStringList("logs").isEmpty()) {
this.plugin.getConfig().set("logs", Collections.singletonList("&c " + player.getName() + " &f=>&r " + ChatColor.stripColor(itemStack.getItemMeta().getDisplayName())));
this.plugin.saveConfig();
return;
}
List<String> logs = this.plugin.getConfig().getStringList("logs");
logs.add("&c " + player.getName() + " &f=>&r " + ChatColor.stripColor(itemStack.getItemMeta().getDisplayName()));
this.plugin.getConfig().set("logs", logs);
this.plugin.saveConfig();
}
}
@@ -0,0 +1,75 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedmasks.CrankedMasks;
import net.crankedpvp.crankedmasks.CrankedMasksAPI;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.EssentialsUtils;
import net.crankedpvp.crankedutils.utils.NumberUtils;
import net.crankedpvp.crankedutils.utils.SortUtils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Command("near")
public class NearCommand extends CommandBase {
private final CrankedCore plugin;
public NearCommand(CrankedCore plugin) {
this.plugin = plugin;
}
@Default
public void defaultCommand(final CommandSender commandSender) {
if (!(commandSender instanceof Player)) return;
Player sender = (Player) commandSender;
Map<Player, Double> nearbyPlayers = new HashMap<>();
sender.getNearbyEntities(200, 200, 200)
.stream()
.filter(entity -> entity instanceof Player)
.filter(entity -> !CrankedMasksAPI.hasMaskEquipped((Player) entity, CrankedMasks.getInstance().getMasksRegister().getMaskFromID("ghost")))
.filter(entity -> !entity.hasMetadata("NPC"))
.map(entity -> (Player) entity)
.filter(player -> !EssentialsUtils.getEssentials().getUser(player).isVanished())
.forEach(nearbyPlayer -> nearbyPlayers.put(nearbyPlayer, sender.getLocation().distance(nearbyPlayer.getLocation())));
Map<Player, Double> effectiveFinalNearbyPlayers = SortUtils.sort(nearbyPlayers);
if (effectiveFinalNearbyPlayers.size() > 30) {
Language.NEAR_TOO_MANY_PLAYERS.send(commandSender);
return;
}
List<String> playersAndDistances = effectiveFinalNearbyPlayers
.entrySet()
.stream()
.map(this::getStringByRadius)
.collect(Collectors.toList());
Collections.reverse(playersAndDistances);
String nearbyString = String.join(", ", playersAndDistances);
commandSender.sendMessage(CC.translate("&c&l(!)&c Nearby Players: " + nearbyString));
}
private String getStringByRadius(Map.Entry<Player, Double> entry) {
String name = "&e" + entry.getKey().getName();
String color = "&f";
if (entry.getValue() < 150) color = "&e";
if (entry.getValue() < 100) color = "&c";
if (entry.getValue() < 50) color = "&4";
String distance = "&f(" + color + NumberUtils.formatNum(entry.getValue()) + "m&f)";
return name + distance;
}
}
@@ -0,0 +1,67 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.Permission;
import me.mattstudios.mf.annotations.SubCommand;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.guis.NetherPvPGUI;
import net.crankedpvp.crankedcore.struct.netherpvp.NetherPvPQueueManager;
import net.crankedpvp.crankedutils.utils.Arrow;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("netherpvp")
public class NetherPvPCommand extends CommandBase {
private final CrankedCore plugin;
private final NetherPvPQueueManager netherPvPQueueManager;
public NetherPvPCommand(CrankedCore plugin) {
this.plugin = plugin;
this.netherPvPQueueManager = plugin.getNetherPvPQueueManager();
}
@Default
public void netherPvP(Player sender) {
NetherPvPGUI netherPvPGUI = new NetherPvPGUI();
netherPvPGUI.getGui().open(sender);
}
@SubCommand("leave")
public void leaveNetherPvP(Player sender) {
if (this.netherPvPQueueManager.isPlayerInPvPQueue(sender)) {
this.netherPvPQueueManager.removePlayerFromPvpQueue(sender);
sender.sendMessage(CC.translate("&c&lNetherPvP &8" + Arrow.arrow() + "&7 You have &cremoved&7 your NetherPvP match"));
}
if (this.netherPvPQueueManager.isPlayerInArena(sender)) {
Player oposingPlayer = this.netherPvPQueueManager.getOposingPlayer(sender);
if (oposingPlayer == null) {
System.out.println("something went wrong in netherpvp");
return;
}
this.netherPvPQueueManager.endMatch(oposingPlayer, sender);
}
}
@SubCommand("resetqueue")
@Permission("cranked.admin")
public void resetQueue(CommandSender sender) {
this.netherPvPQueueManager.resetQueue();
}
@SubCommand("resetarena")
@Permission("cranked.admin")
public void resetArenaPlayers(CommandSender sender) {
this.netherPvPQueueManager.resetArena();
}
@SubCommand("cancelMatch")
@Permission("cranked.admin")
public void cancelMatch(CommandSender sender) {
this.netherPvPQueueManager.cancelMatch();
}
}
@@ -0,0 +1,54 @@
package net.crankedpvp.crankedcore.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.crankedcore.language.Language;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.EconomyUtils;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.potion.Potion;
import org.bukkit.potion.PotionType;
import java.util.Arrays;
import java.util.Objects;
@Command("pots")
@Alias({"potfill", "potions", "pot"})
public class PotsCommand extends CommandBase {
@Default
public void defaultCommand(final Player sender) {
long potsToFill = 36 - Arrays.stream(sender.getInventory().getContents())
.filter(Objects::nonNull)
.filter(itemStack -> itemStack.getType() != Material.AIR)
.count();
long price = potsToFill * 75;
if(!EconomyUtils.hasBalance(sender, price)) {
sender.playSound(sender.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
sender.sendMessage(CC.translate(Language.POTS_TOO_EXPENSIVE.getValue().replace("%amount%", String.valueOf(potsToFill)).replace("%price%", String.valueOf(price))));
return;
}
EconomyUtils.withdrawBalance(sender, price);
for(int i = 0; i < potsToFill; i++) {
sender.getInventory().addItem(getPotion());
}
sender.sendMessage(CC.translate(Language.POTS_RECEIVED.getValue().replace("%amount%", String.valueOf(potsToFill)).replace("%price%", String.valueOf(price))));
sender.playSound(sender.getLocation(), Sound.SUCCESSFUL_HIT, 2.0F, 2.0F);
}
private ItemStack getPotion() {
Potion splash = new Potion(PotionType.INSTANT_HEAL, 2);
splash.setSplash(true);
return splash.toItemStack(1);
}
}
@@ -0,0 +1,51 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Alias;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Permission;
import me.mattstudios.mf.annotations.SubCommand;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.tasks.ProxyPatchTask;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.command.CommandSender;
@Command("proxypatch")
public class ProxyPatchCommand extends CommandBase {
private CrankedCore plugin;
public ProxyPatchCommand(CrankedCore plugin) {
this.plugin = plugin;
}
@SubCommand("end")
@Alias({"finish", "reset"})
@Permission("cranked.admin")
public void endCommand(final CommandSender commandSender) {
this.plugin.getProxyPatchTask().end();
}
@SubCommand("start")
@Permission("cranked.admin")
public void startCommand(final CommandSender commandSender) {
this.plugin.setProxyPatchTask(new ProxyPatchTask());
this.plugin.getProxyPatchTask().runTaskTimer(this.plugin, 60L, 20L);
commandSender.sendMessage(CC.translate("&aAttempting to fix proxy for: &f" + this.plugin.getProxyPatchTask().getPlayerNames().size() + " players"));
}
@SubCommand("restart")
@Permission("cranked.admin")
public void restartCommand(final CommandSender commandSender) {
this.plugin.getProxyPatchTask().end();
this.plugin.setProxyPatchTask(new ProxyPatchTask());
this.plugin.getProxyPatchTask().runTaskTimer(this.plugin, 60L, 20L);
commandSender.sendMessage(CC.translate("&aAttempting to fix proxy for: &f" + this.plugin.getProxyPatchTask().getPlayerNames().size() + " players"));
}
@SubCommand("stop")
@Alias("cancel")
@Permission("cranked.admin")
public void stopCommand(final CommandSender commandSender) {
this.plugin.getProxyPatchTask().cancel();
}
}
@@ -0,0 +1,35 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedutils.utils.StringUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("rainbowify")
@Alias("gayify")
public class RainbowifyCommand extends CommandBase {
@Default
@Permission("cranked.admin")
public void defaultCommand(final Player player, String[] strings) {
if(ItemUtils.isAirOrNull(player.getItemInHand())) return;
String finalString = String.join("_", strings);
finalString = finalString.replace("_", " ");
ItemBuilder itemBuilder = new ItemBuilder(player.getItemInHand());
itemBuilder.setName(StringUtils.rainbowify(finalString));
player.setItemInHand(itemBuilder.colorizeName().build());
}
@SubCommand("print")
@Permission("cranked.admin")
public void printCommand(final CommandSender commandSender, String[] strings) {
String finalString = String.join("_", strings);
finalString = finalString.replace("print", "").replace("_", " ");
System.out.println(ChatColor.stripColor(StringUtils.rainbowify(finalString)));
}
}
@@ -0,0 +1,50 @@
package net.crankedpvp.crankedcore.commands;
import net.crankedpvp.crankedutils.utils.CC;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedcore.struct.reboot.Reboot;
import org.bukkit.command.CommandSender;
@Command("reboot")
@Alias({"creboot", "shutdown"})
public class RebootCommand extends CommandBase {
private final CrankedCore plugin;
public RebootCommand(CrankedCore plugin) {
this.plugin = plugin;
}
@Default
@Permission("cranked.admin")
public void onCommand(CommandSender sender) {
sender.sendMessage(CC.translate("&cUsage: /reboot <start/cancel>"));
}
@SubCommand("cancel")
@WrongUsage("&cUsage: /reboot cancel")
public void cancel(CommandSender sender) {
if (plugin.getReboot() == null) {
Language.REBOOT_NOT_SCHEDULED.send(sender);
} else {
plugin.getReboot().cancel();
plugin.setReboot(null);
Language.REBOOT_CANCEL.send(sender);
}
}
@SubCommand("start")
@WrongUsage("&cUsage: /reboot start <seconds>")
public void start(CommandSender sender, Integer seconds) {
if (plugin.getReboot() == null) {
plugin.setReboot(new Reboot(seconds));
plugin.getReboot().runTaskTimer(plugin, 20L, 20L);
} else {
plugin.getReboot().setSecondsUntilShutdown(seconds);
}
Language.REBOOT_SCHEDULED.send(sender, str -> str.replace("%time%", String.valueOf(seconds)));
}
}
@@ -0,0 +1,28 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.Permission;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.Material;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("rename")
public class RenameCommand extends CommandBase {
@Default
@Permission("cranked.admin")
public void defaultCommand(final CommandSender commandSender, final String[] text) {
Player player = (Player) commandSender;
if(player.getItemInHand() == null || player.getItemInHand().getType() == Material.AIR) return;
ItemBuilder itemBuilder = new ItemBuilder(player.getItemInHand());
itemBuilder.setName(String.join(" ", text));
player.setItemInHand(itemBuilder.colorize().build());
player.updateInventory();
player.sendMessage(CC.translate("&aSuccessfully renamed your item"));
}
}
@@ -0,0 +1,26 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.items.IceWandItem;
import net.crankedpvp.crankedcore.items.SandWandItem;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("sandwand")
public class SandWandCommand extends CommandBase {
@Default
@WrongUsage("&cUsage: /sandwand <uses> [player]")
@Permission("cranked.admin")
public void onCommand(CommandSender sender, Integer uses, @Completion("#players") @Optional Player player) {
if (player != null) {
player.getInventory().addItem(SandWandItem.createSandWand(uses));
return;
}
if (sender instanceof Player) {
((Player) sender).getInventory().addItem(SandWandItem.createSandWand(uses));
}
}
}
@@ -0,0 +1,27 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.Permission;
import me.mattstudios.mf.base.CommandBase;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
@Command("seeall")
public class SeeAllCommand extends CommandBase {
@Default
@Permission("*")
public void seeAllCommand(Player player) {
List<Player> players = new ArrayList<>(Bukkit.getOnlinePlayers());
for (Player player1 : players) {
for (Player player2 : players) {
player1.showPlayer(player2);
}
}
player.sendMessage("shown all");
}
}
@@ -0,0 +1,31 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.Alias;
import me.mattstudios.mf.annotations.Command;
import me.mattstudios.mf.annotations.Default;
import me.mattstudios.mf.annotations.WrongUsage;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.guis.SpawnerShopGUI;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.entity.Player;
@Command("spawnershop")
@Alias("spawnersshop")
public class SpawnerShopCommand extends CommandBase {
@Default
@WrongUsage("&cUsage: /spawnershop <amount>")
public void onDefault(Player player, Integer amount) {
if (amount == null || amount <= 0) {
player.sendMessage(CC.translate("&c&l(!)&c Please enter a valid amount!"));
return;
}
if (amount > 100000) {
player.sendMessage(CC.translate("&c&l(!)&c Please enter an amount below 100,000!"));
return;
}
SpawnerShopGUI spawnerShopGUI = new SpawnerShopGUI(amount);
spawnerShopGUI.getSpawnerGUI().open(player);
}
}
@@ -0,0 +1,46 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedcore.managers.StaffChatManager;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("staffchat")
@Alias("sc")
public class StaffChatCommand extends CommandBase {
private final CrankedCore plugin;
private final StaffChatManager staffChatManager;
public StaffChatCommand(CrankedCore plugin) {
this.plugin = plugin;
this.staffChatManager = plugin.getStaffChatManager();
}
@Default
@Permission("crankedcore.staffchat")
public void defaultCommand(CommandSender sender, @Optional String[] message) {
Player player = (Player) sender;
if (!sender.hasPermission("crankedcore.staffchat")) {
Language.NO_PERMISSION.send(sender);
return;
}
StringBuilder text = new StringBuilder();
for (String arg : message) {
text.append(arg).append(" ");
}
if (text.toString().isEmpty()) {
if (staffChatManager.getInStaffChat().contains(player)) {
staffChatManager.getInStaffChat().remove(player);
Language.STAFF_CHAT_LEAVE.send(player);
} else {
staffChatManager.getInStaffChat().add(player);
Language.STAFF_CHAT_JOIN.send(player);
}
return;
}
staffChatManager.sendStaffMessage(player, text.toString());
}
}
@@ -0,0 +1,77 @@
package net.crankedpvp.crankedcore.commands;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedcore.utils.ExpBottleAPI;
import net.crankedpvp.crankedcore.utils.MoneyNotesAPI;
import net.crankedpvp.crankedutils.utils.*;
import org.bukkit.ChatColor;
import org.bukkit.Sound;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
@Command("withdraw")
@Alias({"w", "note", "banknote"})
public class WithdrawCommand extends CommandBase {
private final int MAX_WITHDRAW = 1000000000;
private final int MIN_WITHDRAW = 10000;
@Default
public void onDefault(CommandSender sender, @Optional String amount) {
Player p = (Player) sender;
if (amount == null) {
for (String line : Language.NOTE_HELP.getValuesAsList()) {
p.sendMessage(CC.translate(line));
}
return;
}
if (amount.contains(".") || amount.contains(",")) {
Language.WITHDRAW_DECIMAL.send(p);
return;
}
int amountInt;
try {
amountInt = Integer.parseInt(amount);
} catch (NumberFormatException e) {
amountInt = (int) NumberUtils.getValueFromFormat(amount);
}
withdrawMoney(p, amountInt);
}
@SubCommand("all")
public void onNoteString(CommandSender sender) {
Player p = (Player) sender;
int amount = (int) EconomyUtils.getBalance(p);
withdrawMoney(p, amount);
}
public void withdrawMoney(Player p, int amount) {
if (amount < MIN_WITHDRAW) {
p.sendMessage(ChatColor.RED + "You must withdraw at least $" + NumberUtils.formatMoney(MIN_WITHDRAW) + " per bank note.");
return;
}
if (amount > MAX_WITHDRAW) {
p.sendMessage(ChatColor.RED + "You can only withdraw a max of $" + NumberUtils.formatMoney(MAX_WITHDRAW) + " per bank note.");
return;
}
if (!EconomyUtils.hasBalance(p, amount)) {
Language.NOTE_NOT_ENOUGH.send(p);
return;
}
EconomyUtils.withdrawBalance(p, amount);
p.sendMessage(CC.translate(Language.NOTE_WITHDRAW.getMessage().replace("%amount%", NumberUtils.formatMoney(amount))));
p.playSound(p.getLocation(), Sound.ENDERDRAGON_WINGS, 1.0f, 0.1f);
PlayerUtils.giveOrDropProtectedItem(p, MoneyNotesAPI.getNote(amount, p), 60);
}
}
@@ -0,0 +1,9 @@
package net.crankedpvp.crankedcore.cooldowns;
import net.crankedpvp.crankedutils.utils.cache.cooldown.CurrentCooldown;
public class ChatCooldown extends CurrentCooldown {
public ChatCooldown(String name, int durationInSeconds) {
super(name, durationInSeconds);
}
}
@@ -0,0 +1,12 @@
package net.crankedpvp.crankedcore.cooldowns;
import net.crankedpvp.crankedutils.utils.cache.cooldown.CurrentCooldown;
public class EnderPearlCooldown extends CurrentCooldown {
public static final String ENDERPEARL_COOLDOWN_KEY = "enderpearl-cooldown";
public EnderPearlCooldown(int durationInSeconds) {
super(ENDERPEARL_COOLDOWN_KEY, durationInSeconds);
}
}
@@ -0,0 +1,9 @@
package net.crankedpvp.crankedcore.cooldowns;
import net.crankedpvp.crankedutils.utils.cache.cooldown.CurrentCooldown;
public class LFFCooldown extends CurrentCooldown {
public LFFCooldown(String name, int durationInSeconds) {
super(name, durationInSeconds);
}
}
@@ -0,0 +1,9 @@
package net.crankedpvp.crankedcore.cooldowns;
import net.crankedpvp.crankedutils.utils.cache.cooldown.CurrentCooldown;
public class LootProtectCooldown extends CurrentCooldown {
public LootProtectCooldown(String name, int durationInSeconds) {
super(name, durationInSeconds);
}
}
@@ -0,0 +1,106 @@
package net.crankedpvp.crankedcore.data;
import lombok.Getter;
import lombok.Setter;
import net.crankedpvp.crankedcore.struct.gifts.Gift;
import net.crankedpvp.crankedcore.struct.kits.Kit;
import net.crankedpvp.storageutils.utils.KeyToSave;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.*;
import java.util.concurrent.TimeUnit;
@Getter
@Setter
public class CrankedUser implements KeyToSave {
private ChatColor chatColor;
private boolean isLootTableMessageEnabled;
private boolean factionLandTitleEnabled;
private boolean killTitleEnabled;
private boolean isCombatTagTimerEnabled;
private boolean ciConfirmEnabled;
private boolean bossDeathMessagesEnabled;
private HashMap<String, Long> kitCooldownMap;
private List<Gift> gifts;
private UUID uuid;
public CrankedUser(UUID uuid) {
this.chatColor = ChatColor.WHITE;
this.isCombatTagTimerEnabled = true;
this.killTitleEnabled = true;
this.kitCooldownMap = new HashMap<>();
this.gifts = new ArrayList<>();
this.uuid = uuid;
}
public boolean alreadyHasOver5GiftsFromPlayer(Player sender) {
if (gifts == null) {
gifts = new ArrayList<>();
}
int giftsAmount = 0;
for (Gift gift : gifts) {
if (gift.getSender() == sender.getUniqueId()) {
giftsAmount++;
}
}
return giftsAmount >= 5;
}
public void addGift(Player sender, ItemStack itemStack, String[] message) {
this.getGifts().add(new Gift(sender, itemStack, Arrays.stream(message).reduce("", (firstString, secondString) -> firstString + " " + secondString)));
}
public long getLastKitUsage(Kit kit) {
Long value = this.kitCooldownMap.get(kit.getKey());
return value == null ? 0L : value;
}
public boolean hasCooldownOnKit(Kit kit) {
long claimedTime = getLastKitUsage(kit);
long currentTime = System.currentTimeMillis();
long difference = currentTime - claimedTime;
long cooldown = kit.getCooldown();
return difference < cooldown;
}
public void newCooldownOnKit(Kit kit) {
this.kitCooldownMap.put(kit.getKey(), System.currentTimeMillis());
}
public long getSecondsTillKitAvailable(Kit kit) {
long claimedTimeStamp = getLastKitUsage(kit);
long currentTimeStamp = System.currentTimeMillis();
long difference = currentTimeStamp - claimedTimeStamp;
long cooldown = kit.getCooldown();
return difference >= cooldown ? 0L :
TimeUnit.MILLISECONDS.toSeconds(cooldown-difference);
}
@Override
public String getKey() {
return uuid.toString();
}
@Override
public void setKey(String s) {
this.uuid = UUID.fromString(s);
}
public Player getPlayer() {
return Bukkit.getPlayer(uuid);
}
public List<Gift> getGifts() {
if (gifts == null)
this.gifts = new ArrayList<>();
return this.gifts;
}
}
@@ -0,0 +1,25 @@
package net.crankedpvp.crankedcore.data;
import lombok.Getter;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.storageutils.StorageUtils;
import net.crankedpvp.storageutils.utils.SaveLoadManager;
import org.bukkit.plugin.java.JavaPlugin;
import java.util.UUID;
@Getter
public class CrankedUserManager extends SaveLoadManager<CrankedUser> {
public CrankedUserManager(CrankedCore plugin) {
super(plugin, plugin.getGson(), "/data", CrankedUser.class);
}
public CrankedUser getCrankedUser(UUID uuid) {
if (!containsKey(uuid.toString())) {
CrankedUser crankedUser = new CrankedUser(uuid);
addToCache(crankedUser);
}
return getFromCache(uuid.toString());
}
}
@@ -0,0 +1,12 @@
package net.crankedpvp.crankedcore.data;
import org.bukkit.entity.Player;
import java.util.HashMap;
import java.util.Map;
public class LastHitCache {
public static Map<Player, Player> lastHitMapVictimAttacker = new HashMap<>();
}
@@ -0,0 +1,75 @@
package net.crankedpvp.crankedcore.guis;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import lombok.Getter;
import net.crankedpvp.adminarmor.inventory.AdminArmorInventory;
import net.crankedpvp.adminweapons.inventory.AdminWeaponsInventory;
import net.crankedpvp.crankedmasks.inventory.MasksInventory;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.staritems.StarItemsAPI;
import net.crankedpvp.staritems.inventory.StarItemsInventory;
import org.bukkit.Material;
import org.bukkit.entity.Player;
public class AdminItemsGUI {
@Getter
private final Gui adminItemGUI;
private final Player player;
public AdminItemsGUI(Player player) {
this.player = player;
this.adminItemGUI = new Gui(1, "Admin Items");
this.adminItemGUI.setDefaultClickAction(event -> event.setCancelled(true));
this.addAdminArmorToGUI();
this.addAdminWeaponsToGUI();
this.addStarItemsToGUI();
this.addMasksToGUI();
}
public void addAdminArmorToGUI() {
ItemBuilder itemBuilder = new ItemBuilder(Material.DIAMOND_CHESTPLATE, "&c&lAdmin Armor",
"&7Click to view all admin armor",
"&7currently unvaulted on the server");
this.adminItemGUI.addItem(new GuiItem(itemBuilder.setGlowing().colorize().build(), event -> {
this.player.closeInventory();
AdminArmorInventory adminArmorInventory = new AdminArmorInventory();
adminArmorInventory.getUI().open(this.player);
}));
}
public void addAdminWeaponsToGUI() {
ItemBuilder itemBuilder = new ItemBuilder(Material.GOLD_SWORD, "&6&lAdmin Weapons",
"&7Click to view all admin weapons",
"&7currently unvaulted on the server");
this.adminItemGUI.addItem(new GuiItem(itemBuilder.setGlowing().colorize().build(), event -> {
this.player.closeInventory();
AdminWeaponsInventory adminWeaponsInventory = new AdminWeaponsInventory();
adminWeaponsInventory.getUI().open(this.player);
}));
}
public void addStarItemsToGUI() {
ItemBuilder itemBuilder = new ItemBuilder(Material.NETHER_STAR, "&d&lStar Items",
"&7Click to view all star items",
"&7currently unvaulted on the server");
this.adminItemGUI.addItem(new GuiItem(itemBuilder.setGlowing().colorize().build(), event -> {
this.player.closeInventory();
StarItemsInventory starItemsInventory = StarItemsAPI.getStarItemsUI();
starItemsInventory.getUI().open(this.player);
}));
}
public void addMasksToGUI() {
ItemBuilder itemBuilder = new ItemBuilder(Material.SKULL_ITEM, "&a&lMasks",
"&7Click to view all masks",
"&7currently unvaulted on the server");
this.adminItemGUI.addItem(new GuiItem(itemBuilder.colorize().build(), event -> {
this.player.closeInventory();
new MasksInventory().getUI().open(this.player);
}));
}
}
@@ -0,0 +1,41 @@
package net.crankedpvp.crankedcore.guis;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import lombok.Getter;
import net.crankedpvp.crankedcore.commands.ChatColorCommand;
import net.crankedpvp.crankedcore.data.CrankedUser;
import net.crankedpvp.crankedcore.data.CrankedUserManager;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.StringUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.ChatColor;
import org.bukkit.Material;
@Getter
public class ChatColorGUI {
private final Gui chatColorGUI;
private final CrankedUser crankedUser;
public ChatColorGUI(CrankedUser crankedUser) {
this.crankedUser = crankedUser;
this.chatColorGUI = new Gui(1, "Select a chat color");
addPaneToGUI(0, (short)14, ChatColor.RED);
addPaneToGUI(1, (short)5, ChatColor.GREEN);
addPaneToGUI(2, (short)3, ChatColor.AQUA);
addPaneToGUI(3, (short)10, ChatColor.DARK_PURPLE);
addPaneToGUI(4, (short)6, ChatColor.LIGHT_PURPLE);
addPaneToGUI(5, (short)4, ChatColor.YELLOW);
addPaneToGUI(6, (short)1, ChatColor.GOLD);
addPaneToGUI(7, (short)0, ChatColor.WHITE);
addPaneToGUI(8, (short)15, ChatColor.BLACK);
this.chatColorGUI.setDefaultClickAction(event -> event.setCancelled(true));
}
public void addPaneToGUI(int slot, short colorCode, ChatColor chatColor) {
this.chatColorGUI.setItem(slot, new GuiItem(new ItemBuilder(Material.STAINED_GLASS_PANE,1, colorCode,
CC.translate(chatColor + CC.Bold + StringUtils.toNiceString(chatColor.name())), CC.translate("&7Click this to select this chat color.")).build(), event -> crankedUser.setChatColor(chatColor)));
}
}
@@ -0,0 +1,52 @@
package net.crankedpvp.crankedcore.guis;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import dev.triumphteam.gui.guis.PaginatedGui;
import lombok.Getter;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.data.CrankedUser;
import net.crankedpvp.crankedcore.data.CrankedUserManager;
import net.crankedpvp.crankedcore.struct.gifts.Gift;
import net.crankedpvp.crankedutils.utils.InventoryUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.kyori.adventure.text.Component;
import org.bukkit.DyeColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.List;
public class GiftsGUI {
private static final GuiItem FILLER_ITEM = new GuiItem(new ItemBuilder(Material.STAINED_GLASS_PANE).setColor(DyeColor.GRAY).setName("").build());
private static final ItemStack PREV_PAGE_ITEM = new ItemBuilder(Material.ARROW, "&c<- Previous Page", "&7Right-Click&7 to go to the previous page.").colorize().build();
private static final ItemStack NEXT_PAGE_ITEM = new ItemBuilder(Material.ARROW, "&aNext Page ->", "&7Right-Click&7 to go to the next page.").colorize().build();
@Getter
private final PaginatedGui gui;
public GiftsGUI(Player player) {
CrankedUserManager crankedUserManager = CrankedCore.getInstance().getCrankedUserManager();
CrankedUser crankedUser = crankedUserManager.getCrankedUser(player.getUniqueId());
this.gui = Gui.paginated()
.title(Component.text("Gifts"))
.pageSize(28)
.rows(6)
.disableAllInteractions()
.create();
this.gui.getFiller().fillBorder(FILLER_ITEM);
this.gui.setItem(6, 3, new GuiItem(PREV_PAGE_ITEM, event -> this.getGui().previous()));
this.gui.setItem(6, 7, new GuiItem(NEXT_PAGE_ITEM, event -> this.getGui().next()));
for (int i = 0; i < crankedUser.getGifts().size(); i++) {
int finalI = i;
this.gui.addItem(new GuiItem(crankedUser.getGifts().get(i).createGuiGiftItem(), event -> {
InventoryUtils.giveItemToPlayer(player, crankedUser.getGifts().get(finalI).getItemStack());
crankedUser.getGifts().remove(finalI);
player.closeInventory();
}));
}
}
}
@@ -0,0 +1,45 @@
package net.crankedpvp.crankedcore.guis;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import lombok.Getter;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.Material;
import org.bukkit.entity.Player;
public class GlobalKitsGUI {
private final Player player;
@Getter
private final Gui gui;
public GlobalKitsGUI(Player player) {
this.player = player;
this.gui = new Gui(1, "Cranked Kits Menu");
this.gui.setDefaultClickAction(event -> event.setCancelled(true));
setupMainKitsItem();
setupGodlyKitsItem();
}
private void setupMainKitsItem() {
ItemBuilder itemBuilder = new ItemBuilder(Material.CHEST, "&b&lDefault Kits",
"&7Click to view the default",
"&7kits on cranked");
this.gui.setItem(1, 4, new GuiItem(itemBuilder.colorize().build(), event -> {
RankedKitsGUI rankKitsGUI = new RankedKitsGUI(player);
rankKitsGUI.getGui().open(player);
}));
}
private void setupGodlyKitsItem() {
ItemBuilder itemBuilder = new ItemBuilder(Material.ENDER_CHEST, "&c&lGodly Kits",
"&7Click to view the godly",
"&7kits on cranked");
this.gui.setItem(1, 6, new GuiItem(itemBuilder.colorize().build(), event -> {
this.player.closeInventory();
GodlyKitsGUI godlyKitsGUI = new GodlyKitsGUI(player);
godlyKitsGUI.getGui().open(player);
}));
}
}
@@ -0,0 +1,102 @@
package net.crankedpvp.crankedcore.guis;
import net.crankedpvp.crankedutils.utils.CC;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import lombok.Getter;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.data.CrankedUser;
import net.crankedpvp.crankedcore.struct.kits.Kit;
import net.crankedpvp.crankedcore.struct.kits.KitManager;
import net.crankedpvp.crankedutils.utils.TimeUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.DyeColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.stream.Collectors;
public class GodlyKitsGUI {
private final Player player;
private KitManager kitManager = CrankedCore.getInstance().getKitManager();
@Getter
private final Gui gui;
public GodlyKitsGUI(Player player) {
this.player = player;
this.gui = new Gui(1, "Godly Kits");
this.gui.setDefaultClickAction(event -> event.setCancelled(true));
for (Kit kit : kitManager.getCacheValues().stream().filter(Kit::isGkit).collect(Collectors.toList())) {
if (kit.hasAccess(player)) {
CrankedUser crankedUser = CrankedCore.getInstance().getCrankedUserManager().getCrankedUser(player.getUniqueId());
if (crankedUser.hasCooldownOnKit(kit)) {
gui.addItem(new GuiItem(getCooldownKit(kit, player, crankedUser.getSecondsTillKitAvailable(kit)), event -> {
if (event.isRightClick()) {
KitPreviewGUI kitPreviewGUI = new KitPreviewGUI(player, kit);
kitPreviewGUI.getGui().open(player);
}
}));
} else {
gui.addItem(new GuiItem(getAvailableKit(kit, player), event -> {
if(event.isLeftClick()) {
crankedUser.newCooldownOnKit(kit);
kit.supplyKit(player);
gui.updateItem(event.getSlot(), new GuiItem(getCooldownKit(kit, player, crankedUser.getSecondsTillKitAvailable(kit)), evente -> {
if (evente.isRightClick()) {
KitPreviewGUI kitPreviewGUI = new KitPreviewGUI(player, kit);
kitPreviewGUI.getGui().open(player);
}
}));
}
if (event.isRightClick()) {
KitPreviewGUI kitPreviewGUI = new KitPreviewGUI(player, kit);
kitPreviewGUI.getGui().open(player);
}
}));
}
} else {
gui.addItem(new GuiItem(getUnavailableKit(kit, player), event -> {
if (event.isRightClick()) {
KitPreviewGUI kitPreviewGUI = new KitPreviewGUI(player, kit);
kitPreviewGUI.getGui().open(player);
}
}));
}
}
}
public ItemStack getUnavailableKit(Kit kit, Player player) {
return new ItemBuilder(new ItemStack(Material.STAINED_GLASS_PANE, 1, DyeColor.RED.getData()))
.setName(CC.translate("&f&ki&r&c&lGKIT&f&ki&r &f&l") + kit.getDisplayName())
.addLore("&7Right-Click to preview this gkit")
.addLore("")
.addLore("&c&lNO PERMISSION")
.addLore("")
.addLore("&7Unlocked @ &cbuy.crankedpvp.org")
.colorize()
.build();
}
public ItemStack getAvailableKit(Kit kit, Player player) {
return new ItemBuilder(Material.CHEST)
.setName(CC.translate("&f&ki&r&c&lGKIT&f&ki&r &f&l") + kit.getDisplayName())
.addLore("&7Left-Click to redeem this gkit")
.addLore("&7Right-Click to preview this gkit")
.addLore("")
.addLore("&a&lAVAILABLE")
.colorize()
.build();
}
public ItemStack getCooldownKit(Kit kit, Player player, long secondsLeft) {
return new ItemBuilder(new ItemStack(Material.STAINED_GLASS_PANE, 1, DyeColor.YELLOW.getData()))
.setName(CC.translate("&f&ki&r&c&lGKIT&f&ki&r &f&l") + kit.getDisplayName())
.addLore("&7Right-Click to preview this gkit")
.addLore("")
.addLore("&e&lON COOLDOWN &7(" + TimeUtils.formatSeconds(secondsLeft) + ")")
.colorize()
.build();
}
}
@@ -0,0 +1,43 @@
package net.crankedpvp.crankedcore.guis;
import dev.triumphteam.gui.guis.GuiItem;
import dev.triumphteam.gui.guis.PaginatedGui;
import lombok.Getter;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.PlayerInventory;
public class InvseeGUI {
@Getter
private PaginatedGui gui;
public InvseeGUI(Player viewer, Player toView) {
this.gui = new PaginatedGui(5, 54, toView.getName() + "'s Inventory");
this.gui.setDefaultClickAction(event -> event.setCancelled(true));
ItemStack[] items = toView.getInventory().getContents();
for (int i = 0; i < 36; i++) {
if (items[i] != null)
gui.setItem(i, new GuiItem(items[i]));
}
gui.setItem(36, getFillterItem());
gui.setItem(37, getFillterItem());
gui.setItem(40, getFillterItem());
gui.setItem(43, getFillterItem());
gui.setItem(44, getFillterItem());
PlayerInventory oldInv = toView.getInventory();
if (oldInv.getHelmet() != null)
gui.setItem(38, new GuiItem( oldInv.getHelmet()));
if (oldInv.getChestplate() != null)
gui.setItem(39, new GuiItem(oldInv.getChestplate()));
if (oldInv.getLeggings() != null)
gui.setItem(41, new GuiItem(oldInv.getLeggings()));
if (oldInv.getBoots() != null)
gui.setItem(42, new GuiItem(oldInv.getBoots()));
}
public GuiItem getFillterItem() {
return new GuiItem(new ItemBuilder(Material.STAINED_GLASS_PANE, 1, (byte)7, "&7 ").colorize().build());
}
}
@@ -0,0 +1,46 @@
package net.crankedpvp.crankedcore.guis;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import lombok.Getter;
import net.crankedpvp.crankedcore.struct.kits.Kit;
import net.crankedpvp.crankedutils.utils.GuiUtil;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class KitPreviewGUI {
@Getter
private final Gui gui;
public KitPreviewGUI(Player player, Kit kit) {
this.gui = new Gui(4, "Previewing " + kit.getDisplayName() + " Kit");
this.gui.setDefaultClickAction(event -> event.setCancelled(true));
for (ItemStack item : kit.getLootList()) {
this.gui.addItem(new GuiItem(item));
}
ItemStack backPage = new ItemBuilder(Material.ARROW, "&c<- Go Back", "&7Right-Click&7 to go back.").colorize().build();
gui.setItem(35, new GuiItem(backPage, event -> {
if(kit.isGkit()) {
GodlyKitsGUI godlyKitsGUI = new GodlyKitsGUI(player);
godlyKitsGUI.getGui().open(player);
} else {
RankedKitsGUI rankedKitsGUI = new RankedKitsGUI(player);
rankedKitsGUI.getGui().open(player);
}
}));
gui.setItem(34, GuiUtil.createFillerGuiItem());
gui.setItem(33, GuiUtil.createFillerGuiItem());
gui.setItem(32, GuiUtil.createFillerGuiItem());
gui.setItem(31, GuiUtil.createFillerGuiItem());
gui.setItem(30, GuiUtil.createFillerGuiItem());
gui.setItem(29, GuiUtil.createFillerGuiItem());
gui.setItem(28, GuiUtil.createFillerGuiItem());
gui.setItem(27, GuiUtil.createFillerGuiItem());
}
}
@@ -0,0 +1,103 @@
package net.crankedpvp.crankedcore.guis;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import dev.triumphteam.gui.guis.PaginatedGui;
import lombok.Getter;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.struct.netherpvp.NetherPvPQueueManager;
import net.crankedpvp.crankedutils.utils.*;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.crankedutils.utils.items.SkullUtils;
import net.kyori.adventure.text.Component;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
public class NetherPvPGUI {
@Getter
private final PaginatedGui gui;
private final NetherPvPQueueManager netherPvPQueueManager;
public NetherPvPGUI() {
this.netherPvPQueueManager = CrankedCore.getInstance().getNetherPvPQueueManager();
this.gui = Gui.paginated()
.title(Component.text("Nether PvP"))
.disableAllInteractions()
.pageSize(27)
.rows(4)
.create();
this.gui.setDefaultClickAction(event -> event.setCancelled(true));
this.gui.getFiller().fillBottom(GuiUtil.createFillerGuiItem());
this.gui.setItem(4, 1, new GuiItem(GuiUtil.createPreviousItem(), event -> this.gui.previous()));
this.gui.setItem(4, 9, new GuiItem(GuiUtil.createNextItem(), event -> this.gui.next()));
this.gui.setItem(4, 5, this.getJoinQueueItem());
for (Player player : this.netherPvPQueueManager.getPlayersFromPvpQueue()) {
this.gui.addItem(this.getPlayerItem(player));
}
}
private GuiItem getJoinQueueItem() {
return new GuiItem(new ItemBuilder(Material.FIREBALL)
.setName("&4&lNether Arena 1v1")
.setLore(
"&fFight to the death in a 1v1 match",
"&fat the Nether Warp Arena",
"",
"&cInformation:",
"&f• Located at &c/warp nether",
"&f• Holy White Scrolls are &cdisabled",
"",
"&cClick to &4&lCREATE&c a match!"
)
.colorize()
.build(), event -> {
Player player = (Player) event.getWhoClicked();
if (this.netherPvPQueueManager.isPlayerInPvPQueue(player)) return;
this.netherPvPQueueManager.addPlayerToPvpQueue(player);
player.closeInventory();
SoundUtils.playSuccessSound(player);
//player.sendMessage(CC.translate("&c&lNetherPvP &8" + Arrow.arrow() + "&7 You have successfully created a NetherPvP match, make sure you stay in &aSafezone&7 for the match to start"));
Bukkit.broadcastMessage((CC.translate("&c&lNetherPvP &8" + Arrow.arrow() + " " + LuckpermUtils.getDisplayName(player) + "&f has created a NetherPvP match, go defeat them (&c/netherpvp&f)!")));
player.sendMessage(CC.translate("&c&lNetherPvP &8" + Arrow.arrow() + "&7 You have successfully created a NetherPvP match, make sure you stay in &aSafezone&7 for the match to start!"));
Clickable clickable = new Clickable("&c[Click here to leave]", "&7&o/netherpvp leave", "/netherpvp leave");
clickable.sendToPlayer(player);
});
}
private GuiItem getPlayerItem(Player player) {
return new GuiItem(new ItemBuilder(SkullUtils.getSkullFromPlayer(player))
.setName(CC.Red + player.getName())
.setLore(
"",
"&aLeft-Click&7 to accept match",
"&cRight-Click&7 to view inventory"
)
.colorize()
.build(), event -> {
Player playerWhoClicked = (Player) event.getWhoClicked();
if (event.getClick().isLeftClick()) {
if (player == playerWhoClicked) {
SoundUtils.playErrorSound(playerWhoClicked);
playerWhoClicked.sendMessage(CC.translate("&c&lNetherPvP &8" + Arrow.arrow() + "&7 You cannot accept your own match"));
return;
}
boolean matchStarted = this.netherPvPQueueManager.acceptMatch(player, playerWhoClicked);
if (matchStarted) {
this.netherPvPQueueManager.removePlayerFromPvpQueue(player);
}
} else if (event.getClick().isRightClick()) {
if (player == playerWhoClicked) {
SoundUtils.playErrorSound(playerWhoClicked);
playerWhoClicked.sendMessage(CC.translate("&c&lNetherPvP &8" + Arrow.arrow() + "&7 You cannot invsee yourself"));
return;
}
playerWhoClicked.closeInventory();
playerWhoClicked.performCommand("invsee " + player.getName());
}
});
}
}
@@ -0,0 +1,112 @@
package net.crankedpvp.crankedcore.guis;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import lombok.Getter;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.data.CrankedUser;
import net.crankedpvp.crankedcore.struct.kits.Kit;
import net.crankedpvp.crankedcore.struct.kits.KitManager;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.TimeUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.kyori.adventure.text.Component;
import org.bukkit.DyeColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.List;
import java.util.stream.Collectors;
public class RankedKitsGUI {
private static final KitManager KIT_MANAGER = CrankedCore.getInstance().getKitManager();
@Getter
private final Gui gui;
public RankedKitsGUI(Player player) {
this.gui = Gui.gui()
.rows(1)
.title(Component.text("Rank Kits"))
.create();
this.gui.setDefaultClickAction(event -> event.setCancelled(true));
for (Kit kit : getAllRankKits()) {
if (kit.hasAccess(player)) {
CrankedUser crankedUser = CrankedCore.getInstance().getCrankedUserManager().getCrankedUser(player.getUniqueId());
if (crankedUser.hasCooldownOnKit(kit)) {
this.gui.addItem(new GuiItem(getCooldownKit(kit, crankedUser.getSecondsTillKitAvailable(kit)), event -> {
if (event.isRightClick()) {
KitPreviewGUI kitPreviewGUI = new KitPreviewGUI(player, kit);
kitPreviewGUI.getGui().open(player);
}
}));
} else {
gui.addItem(new GuiItem(getAvailableKit(kit), event -> {
if(event.isLeftClick()) {
crankedUser.newCooldownOnKit(kit);
kit.supplyKit(player);
gui.updateItem(event.getSlot(), new GuiItem(getCooldownKit(kit, crankedUser.getSecondsTillKitAvailable(kit)), evente -> {
if (evente.isRightClick()) {
KitPreviewGUI kitPreviewGUI = new KitPreviewGUI(player, kit);
kitPreviewGUI.getGui().open(player);
}
}));
}
if (event.isRightClick()) {
KitPreviewGUI kitPreviewGUI = new KitPreviewGUI(player, kit);
kitPreviewGUI.getGui().open(player);
}
}));
}
} else {
gui.addItem(new GuiItem(getUnavailableKit(kit), event -> {
if (event.isRightClick()) {
KitPreviewGUI kitPreviewGUI = new KitPreviewGUI(player, kit);
kitPreviewGUI.getGui().open(player);
}
}));
}
}
}
private List<Kit> getAllRankKits() {
return KIT_MANAGER.getCacheValues().stream().filter(kit -> !kit.isGkit()).sorted().collect(Collectors.toList());
}
private static ItemStack getUnavailableKit(Kit kit) {
return new ItemBuilder(new ItemStack(Material.STAINED_GLASS_PANE, 1, DyeColor.RED.getData()))
.setName(CC.translate("&a&l") + kit.getDisplayName() + " Kit")
.addLore("&7Right-Click to preview this kit")
.addLore("")
.addLore("&c&lNO PERMISSION")
.addLore("")
.addLore("&7Unlocked @ &cbuy.crankedpvp.org")
.colorize()
.build();
}
private static ItemStack getAvailableKit(Kit kit) {
return new ItemBuilder(Material.CHEST)
.setName(CC.translate("&a&l") + kit.getDisplayName() + " Kit")
.addLore("&7Left-Click to redeem this kit")
.addLore("&7Right-Click to preview this kit")
.addLore("")
.addLore("&a&lAVAILABLE")
.colorize()
.build();
}
private static ItemStack getCooldownKit(Kit kit, long secondsLeft) {
return new ItemBuilder(new ItemStack(Material.STAINED_GLASS_PANE, 1, DyeColor.YELLOW.getData()))
.setName(CC.translate("&a&l") + kit.getDisplayName() + " Kit")
.addLore("&7Right-Click to preview this kit")
.addLore("")
.addLore("&e&lON COOLDOWN &7(" + TimeUtils.formatSeconds(secondsLeft) + ")")
.colorize()
.build();
}
}
@@ -0,0 +1,47 @@
package net.crankedpvp.crankedcore.guis;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import lombok.Getter;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.EconomyUtils;
import net.crankedpvp.crankedutils.utils.NumberUtils;
import net.crankedpvp.crankedutils.utils.PlayerUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.shop.ShopPlugin;
import net.crankedpvp.shop.handlers.ShopItem;
import net.crankedpvp.spawners.items.ItemSpawner;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
@Getter
public class SpawnerShopGUI {
private Gui spawnerGUI;
private int amount;
public SpawnerShopGUI(int amount) {
this.amount = amount;
this.spawnerGUI = new Gui(1, "Spawner Shop (" + amount + ")");
this.spawnerGUI.setDefaultClickAction(event -> event.setCancelled(true));
for (ShopItem shopItem : ShopPlugin.getShopHandler().getItems("Spawnershop")) {
this.spawnerGUI.addItem(getSpawnerGuiItem(shopItem));
}
}
private GuiItem getSpawnerGuiItem(ShopItem shopItem) {
double totalPrice = shopItem.getBuyPrice() * amount;
ItemStack spawner = ItemSpawner.getItem(EntityType.valueOf(shopItem.getSpawner()), amount);
ItemStack item = new ItemBuilder(spawner.clone()).addLore("&aBuy Price").addLore("&a $" + NumberUtils.formatMoney(totalPrice)).colorize().build();
return new GuiItem(item, event -> {
Player player = (Player) event.getWhoClicked();
if (EconomyUtils.hasBalance(player, totalPrice)) {
PlayerUtils.giveOrDropProtectedItem(player, spawner.clone(), 60);
EconomyUtils.withdrawBalance(player, totalPrice);
player.sendMessage(CC.translate("&a&l- $" + NumberUtils.formatMoney(totalPrice)));
} else {
player.sendMessage(CC.translate("&c&l(!)&c You do not have enough money to buy this!"));
}
});
}
}
@@ -0,0 +1,39 @@
package net.crankedpvp.crankedcore.guis;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import dev.triumphteam.gui.guis.PaginatedGui;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class WarpGUI {
private final Gui warpUI;
public Gui getWarpUI() {
return this.warpUI;
}
public WarpGUI(Player player) {
this.warpUI = new Gui(1, "Warp GUI");
warpUI.setDefaultClickAction(event -> {
event.setCancelled(true);
});
ItemStack desert = new ItemBuilder(Material.SAND, CC.translate("&e&lDesert Warp"), CC.translate("&7Click to teleport to this warp")).build();
ItemStack crates = new ItemBuilder(Material.CHEST, CC.translate("&b&lCrates Warp"), CC.translate("&7Click to teleport to this warp")).build();
ItemStack nether = new ItemBuilder(Material.NETHERRACK, CC.translate("&4&lNether Warp"), CC.translate("&7Click to teleport to this warp")).build();
ItemStack flat = new ItemBuilder(Material.RED_SANDSTONE, CC.translate("&6&lFlat World"), CC.translate("&7Click to teleport to this warp")).build();
ItemStack koth = new ItemBuilder(Material.EYE_OF_ENDER, CC.translate("&d&lKoth Warp"), CC.translate("&7Click to teleport to this warp")).build();
warpUI.setItem(1, 1, new GuiItem((desert), event -> player.performCommand("warp desert")));
warpUI.setItem(1, 2, new GuiItem((crates), event -> player.performCommand("warp crates")));
warpUI.setItem(1, 3, new GuiItem((flat), event -> player.performCommand("warp flat")));
warpUI.setItem(1, 4, new GuiItem((koth), event -> player.performCommand("warp koth")));
warpUI.setItem(1, 5, new GuiItem((nether), event -> player.performCommand("warp nether")));
}
}
@@ -0,0 +1,14 @@
package net.crankedpvp.crankedcore.hotfix;
import net.crankedpvp.crankedcore.CrankedCore;
import org.bukkit.Bukkit;
import org.bukkit.event.server.ServerCommandEvent;
public class CitizensReload {
public static void reloadCitizens() {
ServerCommandEvent serverCommandEvent = new ServerCommandEvent(Bukkit.getConsoleSender(), "citizens reload");
serverCommandEvent.callEvent();
Bukkit.getScheduler().runTaskLater(CrankedCore.getInstance(), serverCommandEvent::callEvent, 2L);
}
}
@@ -0,0 +1,108 @@
package net.crankedpvp.crankedcore.items;
import com.massivecraft.factions.Board;
import com.massivecraft.factions.FLocation;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.Faction;
import net.crankedpvp.crankedutils.utils.CC;
import de.tr7zw.nbtapi.NBTCompound;
import de.tr7zw.nbtapi.NBTItem;
import net.crankedpvp.crankedutils.utils.NumberUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import java.util.UUID;
public class IceWandItem implements Listener {
private final Board board = Board.getInstance();
private final FPlayers fPlayers = FPlayers.getInstance();
public static ItemStack createItem(int radius, int iceWandUses) {
boolean unlimited = iceWandUses < 1;
ItemStack item = new ItemBuilder(Material.BLAZE_ROD, 1, (short) 0,
"&bIce Wand &8(&7" + (unlimited ? "Unlimited" : NumberUtils.formatNum(iceWandUses)) + " uses&8)",
"",
"&7&oWith this magical ice wand, you",
"&7&ohave the ability to control ice.",
"",
"&b* &7Radius: &f" + radius + "x" + radius,
"",
"&b* &7Usage: &fRight-Click to melt ice."
).setGlowing().colorize().build();
NBTItem nbtItem = new NBTItem(item);
nbtItem.setString("extinctCustomItem", "iceWand");
nbtItem.setString("NoStackingUUID", UUID.randomUUID().toString());
NBTCompound extinctItemData = nbtItem.addCompound("ExtinctItemData");
extinctItemData.setInteger("iceWandUses", iceWandUses);
extinctItemData.setBoolean("iceWandUnlimited", unlimited);
extinctItemData.setInteger("iceWandRadius", radius);
return nbtItem.getItem();
}
@EventHandler
public void onInteract(PlayerInteractEvent event) {
Player player = event.getPlayer();
if (event.getClickedBlock() == null || player.getItemInHand() == null) return;
if (event.getClickedBlock().getType() != Material.ICE) return;
if (player.getItemInHand().getType() != Material.BLAZE_ROD) return;
Faction playerFac = fPlayers.getByPlayer(player).getFaction();
Faction facAtBlock = board.getFactionAt(new FLocation(event.getClickedBlock().getLocation()));
if (!playerFac.equals(facAtBlock) && !facAtBlock.isWilderness()) return;
NBTItem iceWand = new NBTItem(player.getItemInHand());
if (!iceWand.getString("extinctCustomItem").equals("iceWand")) return;
event.setCancelled(true);
NBTCompound extinctItemData = iceWand.getCompound("ExtinctItemData");
int radius = extinctItemData.getInteger("iceWandRadius");
int usesLeft = extinctItemData.getInteger("iceWandUses");
Block target;
Faction facAtLoc;
for (int x = -radius; x <= radius; x++) {
for (int z = -radius; z <= radius; z++) {
target = event.getClickedBlock().getRelative(x,0, z);
facAtLoc = board.getFactionAt(new FLocation(target.getLocation()));
if (!playerFac.equals(facAtLoc) && !facAtLoc.isWilderness()) continue;
for (int y = -radius; y <= radius; y++) {
target = event.getClickedBlock().getRelative(x, y, z);
if (target.getType() == Material.ICE) target.setType(Material.WATER, false);
}
}
}
boolean unlimited = extinctItemData.getBoolean("iceWandUnlimited");
if (!unlimited) {
usesLeft -= 1;
extinctItemData.setInteger("iceWandUses", usesLeft);
if (usesLeft < 1) {
player.setItemInHand(new ItemStack(Material.AIR));
player.playSound(player.getLocation(), Sound.ITEM_BREAK,0.8f,0.9f);
return;
}
}
ItemMeta meta = iceWand.getItem().getItemMeta();
meta.setDisplayName(CC.translate("&bIce Wand &8(&7" + (unlimited ? "Unlimited" : NumberUtils.formatNum(usesLeft)) + " uses&8)"));
iceWand.getItem().setItemMeta(meta);
player.setItemInHand(iceWand.getItem());
}
}
@@ -0,0 +1,56 @@
package net.crankedpvp.crankedcore.items;
import de.tr7zw.nbtapi.NBTItem;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedutils.utils.NumberUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerBucketEmptyEvent;
import org.bukkit.inventory.ItemStack;
import java.util.UUID;
public class MagicalLavaBucketItem implements Listener {
private final CrankedCore plugin;
public MagicalLavaBucketItem(CrankedCore plugin) {
this.plugin = plugin;
}
public static ItemStack createMagicalLavaBucket(int lavaBucketUses) {
ItemStack item = new ItemBuilder(Material.LAVA_BUCKET, 1, (short) 0,
"&cMagical Lava Bucket&8 (&7" + NumberUtils.formatNum(lavaBucketUses) + " uses&8)",
"",
"&7&oThis lava bucket is capable of",
"&7&orefilling its self when used",
"",
"&c* &7Usage: &fRight-Click on a block"
).setGlowing().colorize().build();
NBTItem nbtItem = new NBTItem(item);
nbtItem.setString("randomUUID", String.valueOf(UUID.randomUUID()));
nbtItem.setString("extinctCustomItem", "magicalLavaBucket");
nbtItem.setInteger("lavaBucketUses", lavaBucketUses);
return nbtItem.getItem();
}
@EventHandler
public void onLavaBucketPlace(PlayerBucketEmptyEvent event) {
Player p = event.getPlayer();
NBTItem nbtItem = new NBTItem(p.getItemInHand());
if (nbtItem.hasKey("extinctCustomItem")) {
if (nbtItem.getString("extinctCustomItem").equalsIgnoreCase("magicalLavaBucket")) {
int uses = nbtItem.getInteger("lavaBucketUses");
if (uses <= 1) {
p.getInventory().setItemInHand(new ItemStack(Material.BUCKET));
p.updateInventory();
} else {
plugin.getServer().getScheduler().runTaskAsynchronously(plugin, () -> p.getInventory().setItem(p.getInventory().getHeldItemSlot(), createMagicalLavaBucket(uses - 1)));
}
}
}
}
}
@@ -0,0 +1,75 @@
package net.crankedpvp.crankedcore.items;
import de.tr7zw.nbtapi.NBTItem;
import com.massivecraft.factions.*;
import net.crankedpvp.crankedutils.utils.NumberUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.BlockFace;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerBucketEmptyEvent;
import org.bukkit.inventory.ItemFlag;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import java.util.UUID;
public class MagicalWaterBucketItem implements Listener {
public static ItemStack createMagicalWaterBucket(int waterBucketUses) {
ItemStack itemStack = new ItemBuilder(Material.WATER_BUCKET, 1, (short) 0,
"&9Magical Water Bucket&8 (&7" + NumberUtils.formatNum(waterBucketUses) + " uses&8)",
"",
"&7&oThis water bucket is capable of",
"&7&orefilling its self when used",
"",
"&9* &7Usage: &fRight-Click on a block"
).colorize().build();
ItemMeta meta = itemStack.getItemMeta();
meta.addEnchant(Enchantment.DURABILITY, 3, true);
meta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
itemStack.setItemMeta(meta);
NBTItem nbtItem = new NBTItem(itemStack);
nbtItem.setString("randomUUID", String.valueOf(UUID.randomUUID()));
nbtItem.setString("extinctCustomItem", "magicalWaterBucket");
nbtItem.setInteger("waterBucketUses", waterBucketUses);
return nbtItem.getItem();
}
@EventHandler
public void onWaterBucketPlace(PlayerBucketEmptyEvent event) {
Player player = event.getPlayer();
NBTItem nbtItem = new NBTItem(player.getItemInHand());
BlockFace blockFace = event.getBlockFace();
Location location = event.getBlockClicked().getLocation().add(blockFace.getModX(), blockFace.getModY(), blockFace.getModZ());
FLocation fLocation = new FLocation(location);
FPlayer fPlayer = FPlayers.getInstance().getByPlayer(player);
Faction faction = fPlayer.getFaction();
if (nbtItem.hasKey("extinctCustomItem")) {
if (nbtItem.getString("extinctCustomItem").equalsIgnoreCase("magicalWaterBucket")) {
event.setCancelled(true);
if (!Board.getInstance().getFactionAt(fLocation).isWilderness() &&
Board.getInstance().getFactionAt(fLocation) != faction) {
event.getPlayer().setItemInHand(nbtItem.getItem());
return;
}
event.getBlockClicked().getRelative(event.getBlockFace()).setType(Material.WATER);
int uses = nbtItem.getInteger("waterBucketUses");
if (uses <= 1) {
player.getInventory().setItemInHand(new ItemStack(Material.BUCKET));
player.updateInventory();
} else {
player.getInventory().setItem(player.getInventory().getHeldItemSlot(), createMagicalWaterBucket(uses - 1));
}
}
}
}
}
@@ -0,0 +1,97 @@
package net.crankedpvp.crankedcore.items;
import de.tr7zw.nbtapi.NBTItem;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedutils.utils.NumberUtils;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import com.massivecraft.factions.*;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.block.Block;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemFlag;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
public class SandWandItem implements Listener {
private final CrankedCore plugin;
public SandWandItem(CrankedCore plugin) {
this.plugin = plugin;
}
public static ItemStack createSandWand(int sandWandUses) {
ItemStack itemStack = new ItemBuilder(Material.IRON_HOE, 1, (short) 0,
"&eSand Wand&8 (&7" + NumberUtils.formatNum(sandWandUses) + " uses&8)",
"",
"&7&oThis wand can be used to remove",
"&7&osand pillars in your territory",
"",
"&e* &7Usage: &fRight-Click Sand to use"
).colorize().build();
ItemMeta meta = itemStack.getItemMeta();
meta.addEnchant(Enchantment.DURABILITY, 3, true);
meta.spigot().setUnbreakable(true);
meta.addItemFlags(ItemFlag.HIDE_UNBREAKABLE);
meta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
itemStack.setItemMeta(meta);
NBTItem nbtItem = new NBTItem(itemStack);
nbtItem.setString("extinctCustomItem", "sandWand");
nbtItem.setInteger("sandWandUses", sandWandUses);
return nbtItem.getItem();
}
@EventHandler
public void onInteract(PlayerInteractEvent event) {
if (event.getClickedBlock() == null || event.getPlayer().getItemInHand() == null) return;
if (event.getClickedBlock().getType() == Material.SAND || event.getClickedBlock().getType() == Material.GRAVEL) {
ItemStack itemStack = event.getPlayer().getInventory().getItemInHand();
if (itemStack.getType() == Material.IRON_HOE) {
NBTItem nbtItem = new NBTItem(itemStack);
if (nbtItem.hasKey("extinctCustomItem")) {
if (nbtItem.getString("extinctCustomItem").equalsIgnoreCase("sandWand")) {
Player p = event.getPlayer();
int uses = nbtItem.getInteger("sandWandUses");
if (uses <= 1) {
p.getInventory().setItemInHand(null);
p.playSound(p.getLocation(), Sound.ITEM_BREAK, 10.0F, 1.2F);
} else {
FPlayer fplayer = FPlayers.getInstance().getByPlayer(p);
if (!fplayer.getFaction().isWilderness()) {
Location startLocation = event.getClickedBlock().getLocation();
FLocation flocation = new FLocation(startLocation);
Faction faction = Board.getInstance().getFactionAt(flocation);
if (faction == fplayer.getFaction()) {
plugin.getServer().getScheduler().runTask(plugin, () -> p.getInventory().setItem(p.getInventory().getHeldItemSlot(), createSandWand(uses - 1)));
int count = 0;
for (int y = 255; y >= 1; y--) {
startLocation.setY(y);
Block b = startLocation.getBlock();
if (b.getType().equals(Material.SAND) || b.getType().equals(Material.GRAVEL)) {
b.setType(Material.AIR);
count++;
}
}
int finalCount = count;
Language.WAND_REMOVED_SAND.send(p, str -> str.replace("%count%", String.valueOf(finalCount)));
} else {
Language.WRONG_TERRITORY.send(p);
}
} else {
Language.NEED_FACTION_TO_USE.send(p);
}
}
}
}
}
}
}
}
@@ -0,0 +1,172 @@
package net.crankedpvp.crankedcore.language;
import com.google.common.collect.ImmutableList;
import net.crankedpvp.crankedutils.utils.CC;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.UnaryOperator;
import java.util.stream.Collectors;
public enum Language {
ADMINKIT_HELP,
ADMINKIT_GIVE_HELP,
ADMINKIT_CREATE_HELP,
ADMINKIT_ALREADY_EXISTS,
ADMINKIT_CREATED,
KIT_RECEIVED,
KIT_COOLDOWN,
KIT_INVALID_NAME,
KIT_NO_ACCESS,
WAND_REMOVED_SAND,
WRONG_TERRITORY,
NEED_FACTION_TO_USE,
REBOOT_SCHEDULED,
REBOOT_CANCEL,
REBOOT_NOT_SCHEDULED,
REBOOT_IN,
REBOOT_CAN_NOT_DO_THIS,
CANNOT_HAVE_EMPTY_HAND,
ALREADY_HAS_GIFT,
GIFT_URSELF,
RECEIVED_GIFT,
SENT_GIFT,
BLESS,
MOTD,
NO_PERMISSION,
INVSEE,
CANNOT_INVSEE_YOURSELF,
POTS_RECEIVED,
POTS_TOO_EXPENSIVE,
STAFF_CHAT_JOIN,
STAFF_CHAT_LEAVE,
FULL_INVENTORY,
GODSET_SUCCESS,
EXP_BOTTLE_WITHDRAW,
EXP_BOTTLE_DEPOSIT,
EXP_BOTTLE_HELP,
EXP_BOTTLE_NOT_ENOUGH,
NOTE_WITHDRAW,
NOTE_DEPOSIT,
NOTE_HELP,
NOTE_NOT_ENOUGH,
INVALID_NUMBER,
WITHDRAW_DECIMAL,
NEAR_TOO_MANY_PLAYERS,
CANNOT_INVSEE_GHOST_MASK,
ADMIN_RELOADING,
CLAIM_MAX_REACHED,
CLAIM_OBTAINED,
CLAIM_OBTAINED_OTHER,
max_warzone_claims,
ENABLED_FAC_TITLE,
DISABLED_FAC_TITLE,
ENABLED_KILL_TITLE,
ENABLED_BOSS_DEATH_MESSAGES,
DISABLED_BOSS_DEATH_MESSAGES,
DISABLED_KILL_TITLE,
GIVEALL_RECEIVED,
BLOCKED_COMMAND,
golden_apple_cooldown,
GOLDEN_APPLE_ENTERED_COOLDOWN,
GOLDEN_APPLE_COOLDOWN,
heal_cooldown,
HEALED,
HEAL_COOLDOWN,
LOOKING_FOR_FACTION,
LOOKING_FOR_FACTION_COOLDOWN,
ADMIN_RELOADED
;
private String value;
private ImmutableList<String> valueList;
public String getValue() {
return this.value != null ? this.value : this.name();
}
public String getValue(UnaryOperator<String> function) {
return this.value != null ? function.apply(this.value) : this.name();
}
public String getPath() {
return this.name();
}
public List<String> getValuesAsList() {
return this.valueList;
}
public List<String> getValuesAsList(String oldString, String newString) {
List<String> list = new ArrayList<>(this.valueList);
list.replaceAll(s -> s.replace(oldString, newString));
return list;
}
void setValue(String value) {
if (value == null) value = this.name();
this.value = CC.translate(value);
String[] lines = StringUtils.split(value, System.lineSeparator());
List<String> tempList = Arrays.stream(lines == null ? new String[0] : lines)
.map(CC::translate)
.collect(Collectors.toList());
this.valueList = ImmutableList.copyOf(tempList);
}
void setValue(List<String> valueList) {
this.value = CC.translate(valueList.stream().map(value -> value == null ? "" : value)
.collect(Collectors.joining(System.lineSeparator())));
List<String> tempList = valueList.stream()
.map(value -> CC.translate(value == null ? "" : value))
.collect(Collectors.toList());
this.valueList = ImmutableList.copyOf(tempList);
}
public void send(CommandSender sender, UnaryOperator<String> function) {
sender.sendMessage(CC.translate(this.getValue(function)));
}
public void send(CommandSender sender) {
sender.sendMessage(CC.translate(this.getValue()));
}
public void send(List<CommandSender> senders, UnaryOperator<String> function) {
String msg = CC.translate(this.getValue(function));
senders.forEach(sender -> sender.sendMessage(msg));
}
public void sendPlayers(List<Player> senders, UnaryOperator<String> function) {
String msg = CC.translate(this.getValue(function));
senders.forEach(sender -> sender.sendMessage(msg));
}
public void send(CommandSender ...senders) {
String msg = CC.translate(this.getValue());
Arrays.asList(senders).forEach(sender -> sender.sendMessage(msg));
}
public String getMessage() {
return CC.translate(this.getValue());
}
public String getMessage(UnaryOperator<String> function) {
return CC.translate(this.getValue(function));
}
}
@@ -0,0 +1,82 @@
package net.crankedpvp.crankedcore.language;
import net.crankedpvp.crankedcore.CrankedCore;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public final class LanguageHandler {
private final File file;
private final FileConfiguration config;
private final String path;
private final CrankedCore plugin;
public LanguageHandler(CrankedCore plugin) {
this.plugin = plugin;
this.path = "language.yml";
file = new File(plugin.getDataFolder(), path);
config = new YamlConfiguration();
}
public void load() {
this.saveDefaultConfig();
this.loadConfigFromDisk();
this.copyDefaults();
this.save();
this.loadConfigFromDisk();
this.loadLangMessages();
}
private void loadLangMessages() {
for (Language entry : Language.values()) {
String path = entry.getPath();
if (config.isList(path)) {
entry.setValue(config.getStringList(path));
continue;
}
entry.setValue(config.getString(path));
}
}
private void loadConfigFromDisk() {
try {
config.load(file);
} catch (IOException | InvalidConfigurationException e) {
e.printStackTrace();
}
}
public void save() {
try {
config.save(file);
} catch (IOException e) {
plugin.getLogger().severe("Could not save config file for " + file.getPath() + "!");
e.printStackTrace();
}
}
private void copyDefaults() {
InputStream defConfig = plugin.getResource(this.path);
if (defConfig != null) {
config.setDefaults(YamlConfiguration.loadConfiguration(new InputStreamReader(defConfig)));
}
config.options().copyDefaults(true);
}
private void saveDefaultConfig() {
if (!file.exists()) {
file.getParentFile().mkdirs();
plugin.saveResource(file.getName(),false);
}
}
}
@@ -0,0 +1,23 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedcore.CrankedCore;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.weather.WeatherChangeEvent;
public class AlwaysSunnyListener implements Listener {
public AlwaysSunnyListener() {
Bukkit.getScheduler().scheduleSyncRepeatingTask(CrankedCore.getInstance(), ()-> {
for (World w : Bukkit.getServer().getWorlds()) {
w.setTime(0L);
}
},0, 10000L);
}
@EventHandler
public void DisableWeather(WeatherChangeEvent event) {
event.setCancelled(event.toWeatherState());
}
}
@@ -0,0 +1,25 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.Material;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.player.PlayerBedEnterEvent;
public class AntiBedListener implements Listener {
@EventHandler
public void clickBed(PlayerBedEnterEvent e) {
e.setCancelled(true);
}
@EventHandler
public void onBlockplace(BlockPlaceEvent e) {
if (e.getBlock().getType() == Material.BED) {
e.getPlayer().sendMessage(CC.Red + "You cannot place this beds!");
e.setCancelled(true);
}
}
}
@@ -0,0 +1,33 @@
package net.crankedpvp.crankedcore.listeners;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.util.Vector;
public class AntiBlockGlitchListener implements Listener {
@EventHandler
public void preventBlockGlitch(BlockPlaceEvent event) {
if (!event.isCancelled()) return;
Player player = event.getPlayer();
Location location = player.getLocation();
Location blockLocation = event.getBlock().getLocation();
blockLocation.setX(getAccurateCoord(blockLocation.getX()));
blockLocation.setZ(getAccurateCoord(blockLocation.getZ()));
if ((int) location.getX() != (int) blockLocation.getX() ) return;
if ((int) location.getZ() != (int) blockLocation.getZ()) return;
player.setVelocity(new Vector(0, -1, 0));
}
private double getAccurateCoord(double coord) {
if (coord < 0) return coord + 1.0;
return coord;
}
}
@@ -0,0 +1,31 @@
package net.crankedpvp.crankedcore.listeners;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Boat;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
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.event.vehicle.VehicleCreateEvent;
public class AntiBoatListener implements Listener {
@EventHandler
public void onVehicleCreateEvent(VehicleCreateEvent e) {
if (e.getVehicle() instanceof Boat) {
e.getVehicle().remove();
}
}
@EventHandler
public void onPlayerInteractEvent(PlayerInteractEvent e) {
Player pl = e.getPlayer();
if (e.hasItem() && e.getItem().getType() == Material.BOAT && (e.getAction() == Action.RIGHT_CLICK_AIR || e.getAction() == Action.RIGHT_CLICK_BLOCK)) {
pl.sendMessage(ChatColor.RED + "Boat placement is currently " + ChatColor.UNDERLINE + "disabled.");
e.setCancelled(true);
e.setUseItemInHand(Event.Result.DENY);
}
}
}
@@ -0,0 +1,30 @@
package net.crankedpvp.crankedcore.listeners;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.event.Event;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.enchantment.EnchantItemEvent;
import org.bukkit.event.inventory.InventoryClickEvent;
public class AntiBookEnchantListener implements Listener {
@EventHandler
public void onInventoryClick(InventoryClickEvent e) {
if (e.getInventory().getTitle().equals("Enchant") && e.getCurrentItem() != null && (e.getCurrentItem().getType() == Material.BOOK || e.getCurrentItem().getType() == Material.ENCHANTED_BOOK)) {
e.setCancelled(true);
e.setResult(Event.Result.DENY);
e.getWhoClicked().sendMessage(ChatColor.RED + "You cannot currently inscribe enchantments onto books.");
e.getWhoClicked().closeInventory();
}
}
@EventHandler
public void onEnchantItemEvent(EnchantItemEvent e) {
if (e.getItem().getType() == Material.BOOK || e.getItem().getType() == Material.ENCHANTED_BOOK) {
e.getEnchanter().sendMessage(ChatColor.RED + "You cannot currently inscribe enchantments onto books.");
e.getEnchanter().closeInventory();
e.setCancelled(true);
}
}
}
@@ -0,0 +1,18 @@
package net.crankedpvp.crankedcore.listeners;
import org.bukkit.Material;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
public class AntiBrewingStandListener implements Listener {
@EventHandler
public void onInteractWithBrewingStand(PlayerInteractEvent event) {
if (event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
if (event.getClickedBlock() == null) return;
if (event.getClickedBlock().getType() != Material.BREWING_STAND) return;
event.setCancelled(true);
}
}
@@ -0,0 +1,46 @@
package net.crankedpvp.crankedcore.listeners;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public class AntiDoorHitListener implements Listener {
private final Map<UUID, Long> doorHits;
public AntiDoorHitListener() {
this.doorHits = new HashMap<>();
}
@EventHandler
public void openDoor(PlayerInteractEvent e) {
if (e.getClickedBlock() == null) return;
if (e.getClickedBlock().getType().name().endsWith("_DOOR")) {
doorHits.put(e.getPlayer().getUniqueId(), System.currentTimeMillis());
}
}
@EventHandler(priority = EventPriority.LOWEST)
public void onHit(EntityDamageByEntityEvent e) {
if (e.getDamager() instanceof Player) {
if (!canHit((Player) e.getDamager())) {
e.setCancelled(true);
}
}
}
public boolean canHit(Player player) {
if (doorHits.containsKey(player.getUniqueId())) {
long lastOpened = doorHits.get(player.getUniqueId());
int timeBetweenDoorHit = 700;
return System.currentTimeMillis() >= lastOpened + timeBetweenDoorHit;
}
return true;
}
}
@@ -0,0 +1,14 @@
package net.crankedpvp.crankedcore.listeners;
import org.bukkit.entity.EntityType;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageEvent;
public class AntiDroppedItemRemoveListener implements Listener {
@EventHandler
public void onEntityDamage(EntityDamageEvent e) {
if (e.getEntity().getType() == EntityType.DROPPED_ITEM)
e.setCancelled(true);
}
}
@@ -0,0 +1,16 @@
package net.crankedpvp.crankedcore.listeners;
import org.bukkit.entity.Entity;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageEvent;
public class AntiDrownListener implements Listener {
@EventHandler
public void onDrown(EntityDamageEvent e) {
Entity ent = e.getEntity();
if (ent instanceof org.bukkit.entity.Blaze &&
e.getCause() == EntityDamageEvent.DamageCause.DROWNING)
e.setCancelled(true);
}
}
@@ -0,0 +1,16 @@
package net.crankedpvp.crankedcore.listeners;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageEvent;
public class AntiFallDamageListener implements Listener {
@EventHandler
public void onPlayerFall(EntityDamageEvent e) {
if (e.getEntity() instanceof Player) {
if (e.getCause() == EntityDamageEvent.DamageCause.FALL)
e.setCancelled(true);
}
}
}
@@ -0,0 +1,29 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.Material;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.inventory.InventoryPickupItemEvent;
import org.bukkit.event.inventory.InventoryType;
public class AntiHopperListener implements Listener {
@EventHandler
public void onBlockPlace(BlockPlaceEvent e) {
if(e.getBlock().getType() == Material.HOPPER) {
e.getPlayer().sendMessage(CC.Red + "You cannot place hoppers!");
e.setCancelled(true);
}
}
@EventHandler
public void disablePickup(InventoryPickupItemEvent e) {
if (e.getInventory().getType() != InventoryType.HOPPER) {
return;
}
if (e.getInventory().getType() == InventoryType.HOPPER) {
e.setCancelled(true);
}
}
}
@@ -0,0 +1,84 @@
package net.crankedpvp.crankedcore.listeners;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.inventory.CraftItemEvent;
import org.bukkit.event.inventory.PrepareItemCraftEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerPickupItemEvent;
import org.bukkit.event.world.ChunkLoadEvent;
import org.bukkit.event.world.ChunkUnloadEvent;
import org.bukkit.inventory.ItemStack;
public class AntiMinecartListener implements Listener {
@EventHandler(priority = EventPriority.LOWEST)
public void onLoad(ChunkLoadEvent event) {
for (Entity entity : event.getChunk().getEntities()) {
if (entity.getType() != EntityType.MINECART && entity.getType() != EntityType.MINECART_CHEST && entity.getType() != EntityType.MINECART_COMMAND && entity.getType() != EntityType.MINECART_FURNACE && entity.getType() != EntityType.MINECART_HOPPER && entity.getType() != EntityType.MINECART_MOB_SPAWNER && entity.getType() != EntityType.MINECART_TNT)
continue;
entity.remove();
}
}
@EventHandler(priority = EventPriority.LOWEST)
public void onUnload(ChunkUnloadEvent event) {
for (Entity entity : event.getChunk().getEntities()) {
if (entity.getType() != EntityType.MINECART && entity.getType() != EntityType.MINECART_CHEST && entity.getType() != EntityType.MINECART_COMMAND && entity.getType() != EntityType.MINECART_FURNACE && entity.getType() != EntityType.MINECART_HOPPER && entity.getType() != EntityType.MINECART_MOB_SPAWNER && entity.getType() != EntityType.MINECART_TNT)
continue;
entity.remove();
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlace(BlockPlaceEvent event) {
Block block = event.getBlock();
if (block.getType() == Material.MINECART || block.getType() == Material.POWERED_MINECART || block.getType() == Material.POWERED_RAIL || block.getType() == Material.RAILS || block.getType() == Material.DETECTOR_RAIL) {
event.setCancelled(true);
event.getPlayer().sendMessage(ChatColor.RED + "You " + ChatColor.UNDERLINE + "cannot" + ChatColor.RESET + "" + ChatColor.RED + " place minecarts or rails.");
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlace(PlayerInteractEvent event) {
if (!event.hasItem() || event.getItem().getType() == null) {
return;
}
ItemStack block = event.getItem();
if (block.getType() == Material.MINECART || block.getType() == Material.POWERED_MINECART || block.getType() == Material.POWERED_RAIL || block.getType() == Material.RAILS || block.getType() == Material.DETECTOR_RAIL) {
event.setCancelled(true);
event.getPlayer().sendMessage(ChatColor.RED + "You " + ChatColor.UNDERLINE + "cannot" + ChatColor.RESET + "" + ChatColor.RED + " place minecarts or rails.");
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onDrop(PlayerDropItemEvent event) {
ItemStack block = event.getItemDrop().getItemStack();
if (block != null && (block.getType() == Material.MINECART || block.getType() == Material.POWERED_MINECART || block.getType() == Material.POWERED_RAIL || block.getType() == Material.RAILS || block.getType() == Material.DETECTOR_RAIL)) {
event.setCancelled(true);
event.getPlayer().updateInventory();
event.getItemDrop().remove();
event.getPlayer().sendMessage(ChatColor.RED + "You " + ChatColor.UNDERLINE + "cannot" + ChatColor.RESET + "" + ChatColor.RED + " drop minecarts or rails.");
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPickup(PlayerPickupItemEvent event) {
ItemStack block = event.getItem().getItemStack();
if (block != null && (block.getType() == Material.MINECART || block.getType() == Material.POWERED_MINECART || block.getType() == Material.POWERED_RAIL || block.getType() == Material.RAILS || block.getType() == Material.DETECTOR_RAIL)) {
event.setCancelled(true);
event.getPlayer().updateInventory();
event.getItem().remove();
event.getPlayer().sendMessage(ChatColor.RED + "You " + ChatColor.UNDERLINE + "cannot" + ChatColor.RESET + "" + ChatColor.RED + " pickup minecarts or rails.");
}
}
}
@@ -0,0 +1,12 @@
package net.crankedpvp.crankedcore.listeners;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.SlimeSplitEvent;
public class AntiSlimeSplitListener implements Listener {
@EventHandler
public void slimeSplit(SlimeSplitEvent e) {
e.setCancelled(true);
}
}
@@ -0,0 +1,18 @@
package net.crankedpvp.crankedcore.listeners;
import com.golfing8.winespigot.event.PlayerUpdateSpeedEvent;
import net.crankedpvp.crankedutils.utils.EssentialsUtils;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
public class AntiSlowInVanishListener implements Listener {
@EventHandler
public void walkSpeedChange(PlayerUpdateSpeedEvent event) {
if(event.getPlayer() == null) return;
if(!EssentialsUtils.isVanished(event.getPlayer())) return;
if(event.getNewSpeed() != 0.2F) {
event.setCancelled(true);
}
}
}
@@ -0,0 +1,10 @@
package net.crankedpvp.crankedcore.listeners;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
public class AutoFlyListener implements Listener {
public void playerJoin(PlayerJoinEvent e) {
e.getPlayer().setAllowFlight(true);
}
}
@@ -0,0 +1,32 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedcore.managers.CommandBlockerManager;
import net.crankedpvp.crankedutils.utils.CC;
import org.apache.commons.codec.language.bm.Lang;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
public class BlockCommandListener implements Listener {
private final CommandBlockerManager commandBlockerManager;
public BlockCommandListener() {
this.commandBlockerManager = CrankedCore.getInstance().getCommandBlockerManager();
}
@EventHandler
public void onCommand(PlayerCommandPreprocessEvent event) {
if (event.isCancelled()) return;
if (commandBlockerManager.isBlocked(event.getMessage().replace("/", "").split(" ")[0])) {
if (event.getPlayer().hasPermission("cranked.admin")) {
event.getPlayer().sendMessage(CC.translate("&c&l(!)&c &7&n" + event.getMessage() + "&c is a blocked command but since you are &7OP'ed&c you have bypassed the blocker! "));
return;
}
event.getPlayer().sendMessage(CC.translate(Language.BLOCKED_COMMAND.getMessage().replace("%command%", event.getMessage())));
event.setCancelled(true);
}
}
}
@@ -0,0 +1,225 @@
package net.crankedpvp.crankedcore.listeners;
import com.earth2me.essentials.utils.DateUtil;
import com.golfing8.kore.FactionsKore;
import com.golfing8.kore.feature.ShieldFeature;
import com.lunarclient.bukkitapi.LunarClientAPI;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import com.massivecraft.factions.Faction;
import com.massivecraft.factions.struct.ChatMode;
import net.crankedpvp.chattitles.ChatTitlesAPI;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.cooldowns.ChatCooldown;
import net.crankedpvp.crankedcore.data.CrankedUserManager;
import net.crankedpvp.crankedcore.managers.StaffChatManager;
import net.crankedpvp.crankedutils.utils.*;
import net.crankedpvp.spawners.SpawnerPlugin;
import net.crankedpvp.staff.StaffPlugin;
import net.crankedpvp.staff.managers.GhostMuteManager;
import net.luckperms.api.LuckPermsProvider;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.inventory.ItemStack;
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ChatListener implements Listener {
private final Pattern ipPattern = Pattern.compile("((?<![0-9])(?:(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[ ]?[.,-:; ][ ]?(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[ ]?[., ][ ]?(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[ ]?[., ][ ]?(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2}))(?![0-9]))", Pattern.CASE_INSENSITIVE);
private final Pattern webpattern = Pattern.compile("[-a-zA-Z0-9@:%_\\+.~#?&//=]{2,256}\\.[a-z]{2,4}\\b(\\/[-a-zA-Z0-9@:%_\\+.~#?&//=]*)?");
private final ShieldFeature shieldFeature;
private final StaffChatManager staffChatManager;
private final GhostMuteManager ghostMuteManager;
private final CrankedUserManager crankedUserManager;
public ChatListener(CrankedCore plugin) {
this.shieldFeature = FactionsKore.get().getFeature(ShieldFeature.class);
this.staffChatManager = plugin.getStaffChatManager();
this.ghostMuteManager = StaffPlugin.getInstance().getGhostMuteManager();
this.crankedUserManager = plugin.getCrankedUserManager();
}
private Set<Player> getRecepients(AsyncPlayerChatEvent event) {
Set<Player> recipients = new HashSet<>();
if(StaffPlugin.getInstance().getGhostMuteManager().isPlayerInGhostMute(event.getPlayer())) {
recipients.add(event.getPlayer());
for(Player recipient : event.getRecipients()) {
if(recipient.hasPermission("ghostmute.see")) {
recipients.add(recipient);
}
}
return recipients;
}
return event.getRecipients();
}
// Chat Filter
@EventHandler(priority = EventPriority.HIGH)
public void playerChat(AsyncPlayerChatEvent event) {
if (event.isCancelled()) return;
event.setCancelled(true);
Set<Player> recipients = getRecepients(event);
Player player = event.getPlayer();
FPlayer fPlayer = FPlayers.getInstance().getByPlayer(player);
if (fPlayer.getChatMode() != ChatMode.PUBLIC) return;
if (staffChatManager.getInStaffChat().contains(event.getPlayer())) {
staffChatManager.sendStaffMessage(event.getPlayer(), event.getMessage());
return;
}
if (CooldownUtils.isCooldownActive(player, "chatCooldown")) {
player.sendMessage(CC.translate("&c&l(!)&c You cannot send messages for another " + CooldownUtils.getFormattedCooldown(player, "chatCooldown") + "."));
return;
}
if (!player.isOp()) {
CooldownUtils.registerCooldown(player, new ChatCooldown("chatCooldown", 1));
}
Faction faction = fPlayer.getFaction();
//Check if chat is disable
/* if (ChatFilter.isChatHalted() && !player.isOp()) {
event.getPlayer().sendMessage(CC.translate("&c&l(!)&c You cannot use chat while chat is halted."));
return;
}*/
if (event.getMessage().contains("[item]") && event.getMessage().contains("[brag]")) return;
Matcher ipMatcher = ipPattern.matcher(event.getMessage());
if (ipMatcher.find() && !player.isOp()) {
player.sendMessage(CC.translate("&c&l(!)&c You are not allowed to send ip's in chat!"));
staffChatManager.sendStaffMessage(CC.translate("&c" + player.getName() + " &ctried sending an ip in chat &7(" + event.getMessage() + "&7)"));
return;
}
Matcher webMatcher = webpattern.matcher(event.getMessage());
if (webMatcher.find() && !player.isOp()) {
player.sendMessage(CC.translate("&c&l(!)&c You are not allowed to send links in chat!"));
staffChatManager.sendStaffMessage(CC.translate("&c" + player.getName() + " &ctried sending a link in chat &7(" + event.getMessage() + "&7)"));
return;
}
String message = event.getMessage();
for (Player recipient : recipients) {
message = event.getMessage();
FPlayer fRecipient = FPlayers.getInstance().getByPlayer(recipient);
Faction recipientFaction = fRecipient.getFaction();
Clickable clickable = new Clickable("");
if(ghostMuteManager != null && ghostMuteManager.isPlayerInGhostMute(player) && !player.getUniqueId().equals(recipient.getUniqueId())) {
clickable.add("&b&l[GM] ");
}
String nitroLeader = getNitroLeader(player);
clickable.add(nitroLeader);
if (!faction.isWilderness()) {
String shieldStatus;
if (shieldFeature.isShieldActive(faction.getId()) && shieldFeature.isSetup(faction.getId()) && shieldFeature.isTimeConfigured(faction.getId())) {
shieldStatus = "&aON &7(" + ChatColor.stripColor(shieldFeature.getShieldData(faction.getId(), true)) + "&7)";
} else {
shieldStatus = "&cOFF";
}
clickable.add( "&8[" + faction.getRelationTo(recipientFaction).getColor() + fPlayer.getChatTag() + "&8]&r ",
"&4&lFaction Info: &f" + faction.getTag() + " \n" +
"&8 • &cPower: &a" + (int) faction.getPower() + "&8/&a" + (int) faction.getPowerMax() + " \n" +
"&8 • &cShield: &f" + shieldStatus + "\n" +
"&8 • &cOnline: &f" + faction.getOnlinePlayers().size() + " \n" +
"&8 • &cFtop: &f#" + SpawnerPlugin.getInstance().getFactionsTopManager().getFactionTop(faction) + " \n" + " \n" +
"&7&oClick to view this faction",
"/f who " + player.getName()
);
}
clickable.add(Objects.requireNonNull(LuckPermsProvider.get().getUserManager().getUser(player.getUniqueId())).getCachedData().getMetaData().getPrefix() + " " + player.getName(),
"&4&lUser: &f" + player.getName() + " \n" +
"&8 • &cNick: &f" + player.getDisplayName() + " \n" +
"&8 • &cFaction: &f" +faction.getTag() + " \n" +
"&8 • &cLunar Client: &f" + (LunarClientAPI.getInstance().isRunningLunarClient(player) ? ChatColor.GREEN.toString() + ChatColor.BOLD + "✓" : ChatColor.RED.toString() + ChatColor.BOLD + "✗") + " \n" +
"&8 • &cBalance: &a$" + NumberUtils.formatMoney(EconomyUtils.getBalance(player)) + " \n" +
"&8 • &cLogged in: &f" + DateUtil.formatDateDiff(EssentialsUtils.getEssentials().getUser(player).getLastLogin()) + " ago" + " \n" + " \n" +
"&7&oClick to see when the player logged online",
"/stats " + player.getName()
);
if(ChatTitlesAPI.playerHasTitleEquipped(player)) {
clickable.add(" &8[" + ChatTitlesAPI.getEquippedTitle(player) + "&r&8]");
}
ChatColor chatcolor = crankedUserManager.getCrankedUser(player.getUniqueId()).getChatColor();
clickable.add("&8 » ");
if (message.contains("[item]") || message.contains("[ITEM]")) {
ItemStack itemStack = event.getPlayer().getItemInHand();
if (itemStack == null || !itemStack.hasItemMeta() || itemStack.getType() == Material.AIR) {
player.sendMessage(CC.translate("&c&l(!)&c Please hold an item when using [item]"));
return;
} else {
String name = itemStack.getItemMeta().getDisplayName();
int amount = itemStack.getAmount();
clickable.addItem(CC.translate("&f» " + name + " &7(" + amount + "x) &f« "), itemStack);
}
message = message.replace("[item]", "").replace("[ITEM]", "");
}
if (message.contains("[brag]") || message.contains("[BRAG]")) {
String playerName = event.getPlayer().getName();
clickable.add(String.format("&d&o%s's Inventory", playerName), String.format("&7View %s's Inventory", playerName), "/invsee " + playerName);
message = message.replace("[brag]", "").replace("[BRAG]", "");
}
clickable.add(chatcolor + message);
clickable.sendToPlayer(recipient);
}
Bukkit.getServer().getConsoleSender().sendMessage(CC.translate("&8[&a" + fPlayer.getChatTag() + "&8]&r " + Objects.requireNonNull(LuckPermsProvider.get().getUserManager().getUser(player.getUniqueId())).getCachedData().getMetaData().getPrefix() + " " + player.getName() + " " + message));
}
public String getNitroLeader(Player player) {
String prefix = "";
if (net.crankedpvp.discordsync.listeners.ChatListener.isNitroBooster(player)) {
prefix += net.crankedpvp.discordsync.listeners.ChatListener.BOOSTER_BADGE;
}
if (net.crankedpvp.discordsync.listeners.ChatListener.isFactionLeader(player)) {
prefix += net.crankedpvp.discordsync.listeners.ChatListener.LEADER_BADGE;
}
if (!prefix.equals("")) {
prefix = "&8<" + prefix + "&8> ";
}
return prefix;
}
}
@@ -0,0 +1,62 @@
package net.crankedpvp.crankedcore.listeners;
import de.tr7zw.nbtapi.NBTItem;
import org.bukkit.Material;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
public class CrystalListener implements Listener {
public boolean isCrystal(ItemStack itemStack) {
if (itemStack.getType() != Material.PRISMARINE_CRYSTALS) return false;
NBTItem nbtItem = new NBTItem(itemStack);
if (!nbtItem.hasNBTData()) return false;
return nbtItem.getString("extinctCustomItem").equals("enchantShard");
}
public Enchantment getCrystalEnchant(ItemStack crystal) {
if (!isCrystal(crystal)) return null;
NBTItem nbtItem = new NBTItem(crystal);
return Enchantment.getByName(nbtItem.getString("shardEnchant"));
}
public int getCrystalEnchantLevel(ItemStack crystal) {
if (!isCrystal(crystal)) return -1;
NBTItem nbtItem = new NBTItem(crystal);
return nbtItem.getInteger("shardLevel");
}
public ItemStack applyCrystalEnchant(ItemStack crystal, ItemStack itemStack) {
if (!isCrystal(crystal)) return null;
Enchantment enchantment = getCrystalEnchant(crystal);
int enchantmentLevel = getCrystalEnchantLevel(crystal);
if (enchantment == null || enchantmentLevel == -1) return null;
if (!enchantment.canEnchantItem(itemStack)) return null;
itemStack.addUnsafeEnchantment(enchantment, enchantmentLevel);
return itemStack;
}
@SuppressWarnings("Deprecated")
@EventHandler
public void onShardApply(InventoryClickEvent e) {
if (e.getCurrentItem() == null || e.getCurrentItem().getType() == Material.AIR) return;
if (!isCrystal(e.getCursor())) return;
ItemStack crystal = e.getCursor();
ItemStack itemStack = e.getCurrentItem();
int crystalAmount = crystal.getAmount();
if (itemStack.getAmount() > 1) return;
ItemStack enchantedItemStack = applyCrystalEnchant(crystal, itemStack);
if (enchantedItemStack == null) return;
e.setCancelled(true);
e.setCurrentItem(enchantedItemStack);
if (crystalAmount > 1) {
crystal.setAmount(crystalAmount - 1);
e.setCursor(crystal);
return;
}
e.setCursor(null);
}
}
@@ -0,0 +1,38 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedcore.cooldowns.EnderPearlCooldown;
import net.crankedpvp.crankedutils.events.EnderPearlThrowEvent;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
public class EnderPearlCooldownListener implements Listener {
@EventHandler(priority = EventPriority.HIGHEST)
public void onEnderpearlThrow(PlayerInteractEvent event) {
if (event.getAction() != Action.RIGHT_CLICK_AIR && event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
if (ItemUtils.isAirOrNull(event.getItem())) return;
if (event.getItem().getType() != Material.ENDER_PEARL) return;
if (event.getPlayer() == null) return;
Player player = event.getPlayer();
EnderPearlThrowEvent enderPearlThrowEvent = new EnderPearlThrowEvent(player, 15);
Bukkit.getPluginManager().callEvent(enderPearlThrowEvent);
if (CooldownUtils.isCooldownActive(player, EnderPearlCooldown.ENDERPEARL_COOLDOWN_KEY)) {
event.setCancelled(true);
player.setItemInHand(player.getItemInHand());
player.sendMessage(CC.translate("&b&lPearls &8➥ &7You can't use an enderpearl for another &f" + CooldownUtils.getFormattedCooldown(player, EnderPearlCooldown.ENDERPEARL_COOLDOWN_KEY) + "&7!"));
return;
}
CooldownUtils.registerCooldown(player, new EnderPearlCooldown(enderPearlThrowEvent.getCooldownInSeconds()));
}
}
@@ -0,0 +1,32 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import org.bukkit.Material;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
public class EnderpearlStackListener implements Listener {
@EventHandler
public void onInventoryClickWithEnderpearl(InventoryClickEvent event) {
if (ItemUtils.isAirOrNull(event.getCursor())) return;
if (ItemUtils.isAirOrNull(event.getCurrentItem())) return;
ItemStack cursor = event.getCursor();
ItemStack current = event.getCurrentItem();
if (current.hasItemMeta()) return;
if (cursor.hasItemMeta()) return;
if (cursor.getType() != Material.ENDER_PEARL) return;
if (current.getType() != Material.ENDER_PEARL) return;
event.setCancelled(true);
event.setCursor(null);
event.setCurrentItem(new ItemStack(Material.ENDER_PEARL, current.getAmount() + cursor.getAmount()));
}
}
@@ -0,0 +1,35 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedcore.utils.ExpBottleAPI;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.NumberUtils;
import net.crankedpvp.crankedutils.utils.XPUtils;
import org.bukkit.ChatColor;
import org.bukkit.GameMode;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
public class ExpBottleListener
implements Listener {
@EventHandler(priority = EventPriority.LOW)
public void onExpBottleUse(PlayerInteractEvent e) {
if (e.hasItem() && ExpBottleAPI.isXpBottle(e.getItem())) {
Player p = e.getPlayer();
int xpValue = ExpBottleAPI.getXpAmount(e.getItem()) * e.getItem().getAmount();
e.setCancelled(true);
p.setItemInHand(null);
XPUtils.addExperience(p, xpValue);
p.playSound(p.getLocation(), Sound.GLASS, 1.0f, 0.8f);
p.sendMessage(CC.translate(Language.EXP_BOTTLE_DEPOSIT.getMessage().replace("%amount%", NumberUtils.formatMoney(xpValue))));
}
}
}
@@ -0,0 +1,29 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedutils.utils.EssentialsUtils;
import net.crankedpvp.lootboxes.CrankedLootboxes;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
public class FirstJoinListener implements Listener {
private CrankedCore plugin;
public FirstJoinListener(CrankedCore plugin) {
this.plugin = plugin;
}
@EventHandler
public void onJoin(PlayerJoinEvent event) {
if(event.getPlayer() == null) return;
if(event.getPlayer().hasPlayedBefore()) return;
if(this.plugin.getCrankedUserManager().containsKey(event.getPlayer().getUniqueId().toString())) return;
CrankedLootboxes.getInstance().getLootboxManager().giveLootbox(event.getPlayer(), CrankedLootboxes.getInstance().getLootboxRegister().getLootbox("StarterBundle"), 1);
Bukkit.getScheduler().runTaskLater(CrankedCore.getInstance(), ()-> {
event.getPlayer().teleport(EssentialsUtils.getEssentials().getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
}, 3L);
}
}
@@ -0,0 +1,30 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedcore.struct.cooldowns.GoldenAppleCooldown;
import net.crankedpvp.crankedutils.utils.CooldownUtils;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerItemConsumeEvent;
public class GoldenAppleSicknessListener implements Listener {
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void onPlayerConsumeGoldenApple(PlayerItemConsumeEvent event) {
Player player = event.getPlayer();
if (event.getItem().getType() == Material.GOLDEN_APPLE || event.getItem().getTypeId() == 322) {
int cooldown = Integer.parseInt(Language.golden_apple_cooldown.getValue());
if (CooldownUtils.isCooldownActive(player, "goldenAppleSickness")) {
player.sendMessage(CC.translate(Language.GOLDEN_APPLE_COOLDOWN.getMessage().replace("%time%", CooldownUtils.getFormattedCooldown(player, "goldenAppleSickness"))));
event.setCancelled(true);
} else {
CooldownUtils.registerCooldown(player, new GoldenAppleCooldown("goldenAppleSickness", cooldown));
player.sendMessage(CC.translate(Language.GOLDEN_APPLE_ENTERED_COOLDOWN.getMessage().replace("%cooldown%", Integer.toString(cooldown))));
}
}
}
}
@@ -0,0 +1,78 @@
package net.crankedpvp.crankedcore.listeners;
import com.massivecraft.factions.FPlayer;
import com.massivecraft.factions.FPlayers;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedutils.HoverText;
import net.crankedpvp.crankedutils.utils.*;
import org.apache.commons.lang.StringUtils;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDeathEvent;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
public class KillTitleMessageListener implements Listener {
private List<UUID> killCooldown;
public KillTitleMessageListener() {
this.killCooldown = new ArrayList<>();
}
@EventHandler
public void killMsg(EntityDeathEvent e) throws NoSuchFieldException, IllegalAccessException {
if (e.getEntity() instanceof Player && e.getEntity().getKiller() != null) {
Player killer = e.getEntity().getKiller();
Player died = (Player) e.getEntity();
final UUID kuuid = killer.getUniqueId();
if (this.killCooldown.contains(kuuid)) return;
this.killCooldown.add(kuuid);
Bukkit.getScheduler().runTaskLaterAsynchronously(CrankedCore.getInstance(), () -> {
this.killCooldown.remove(kuuid);
}, 5 * 20L);
JSONMessage message = new JSONMessage("", ChatColor.GRAY);
FPlayer fkiller = FPlayers.getInstance().getByPlayer(killer);
FPlayer fdied = FPlayers.getInstance().getByPlayer(died);
message.addText(CC.translate("&c" + killer.getName() + "&4[" + fkiller.getKills() + "&4]&e killed &c" + died.getName() + "&4[" + fdied.getKills() + "&4]" + " &eusing "));
if (killer.getItemInHand() == null || killer.getItemInHand().getType() == Material.AIR) {
message.addText(this.getFormattedName(null));
} else {
message.addItem(killer.getItemInHand(), HoverText.formatColors(ChatColor.WHITE + this.getFormattedName(killer.getItemInHand())).getText());
}
for (Player player : Bukkit.getOnlinePlayers()) {
message.sendToPlayer(player);
}
AnimationUtils.sendDeathEffect(died);
AnimationUtils.sendLightning(killer, died.getLocation());
if (CrankedCore.getInstance().getCrankedUserManager().getCrankedUser(killer.getUniqueId()).isKillTitleEnabled()) {
TitleUtils.sendTitle(killer, CC.translate("&a&l+1 KILL"), LuckpermUtils.getDisplayName(died), 20, 50, 20);
}
}
}
private String getFormattedName(ItemStack hand) {
if (hand == null || hand.getType() == Material.AIR) {
return "their fists!";
}
if (hand.hasItemMeta() && hand.getItemMeta().hasDisplayName()) {
return hand.getItemMeta().getDisplayName();
}
if (hand.getType() == Material.TNT) {
return "TNT";
}
return StringUtils.capitaliseAllWords(hand.getType().name().toLowerCase().replace("_", " "));
}
}
@@ -0,0 +1,22 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedcore.data.LastHitCache;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class LastHitListener implements Listener {
@EventHandler
public void lastHitCacheUpdate(EntityDamageByEntityEvent event) {
if(event.getEntity() == null || event.getDamager() == null) return;
if(!(event.getEntity() instanceof Player)) return;
if(!(event.getDamager() instanceof Player)) return;
Player entity = (Player) event.getEntity();
Player damager = (Player) event.getDamager();
LastHitCache.lastHitMapVictimAttacker.put(entity, damager);
}
}
@@ -0,0 +1,47 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedutils.utils.LuckpermUtils;
import net.luckperms.api.model.user.User;
import net.luckperms.api.node.NodeType;
import net.luckperms.api.node.types.InheritanceNode;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import java.util.List;
import java.util.stream.Collectors;
public class LuckpermsRankFixListener implements Listener {
@EventHandler
public void onJoin(PlayerJoinEvent event) {
User user = LuckpermUtils.getLpUser(event.getPlayer());
List<String> ranks = user.getNodes(NodeType.INHERITANCE).stream()
.map(InheritanceNode::getGroupName)
.collect(Collectors.toList());
if (ranks.contains("member") && !event.getPlayer().hasPermission("crankedcore.staffchat")) {
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lp user " + user.getUniqueId() + " parent set explorer");
}
if (ranks.contains("gunner") && !event.getPlayer().hasPermission("crankedcore.staffchat")) {
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lp user " + user.getUniqueId() + " parent set corrupt");
}
if (ranks.contains("quartermaster") && !event.getPlayer().hasPermission("crankedcore.staffchat")) {
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lp user " + user.getUniqueId() + " parent set medusa");
}
if (ranks.contains("captain") && !event.getPlayer().hasPermission("crankedcore.staffchat")) {
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lp user " + user.getUniqueId() + " parent set dracula");
}
if (ranks.contains("kraken") && !event.getPlayer().hasPermission("crankedcore.staffchat")) {
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lp user " + user.getUniqueId() + " parent set satan");
}
if (ranks.contains("kraken+") && !event.getPlayer().hasPermission("crankedcore.staffchat")) {
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lp user " + user.getUniqueId() + " parent set satan");
}
if (ranks.contains("youtube") && !event.getPlayer().hasPermission("crankedcore.staffchat")) {
Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "lp user " + user.getUniqueId() + " parent set media");
}
}
}
@@ -0,0 +1,24 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
public class MOTDListener implements Listener {
@EventHandler
public void onJoin(PlayerJoinEvent event) {
Player player = event.getPlayer();
Bukkit.getScheduler().runTaskLaterAsynchronously(CrankedCore.getInstance(), ()-> {
for (String line : Language.MOTD.getValuesAsList()) {
line = line.replace("{player}", player.getDisplayName());
line = line.replace("{online}", String.valueOf(Bukkit.getOnlinePlayers().size()));
player.sendMessage(CC.translate(line));
}
}, 10L);
}
}
@@ -0,0 +1,39 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedcore.language.Language;
import net.crankedpvp.crankedcore.utils.MoneyNotesAPI;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.EconomyUtils;
import net.crankedpvp.crankedutils.utils.NumberUtils;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
public class MoneyNoteListener implements Listener {
@EventHandler(priority = EventPriority.LOW)
public void onMoneyNoteUse(PlayerInteractEvent e) {
if (e.hasItem() && MoneyNotesAPI.isMoneyNote(e.getItem())) {
Player p = e.getPlayer();
e.setCancelled(true);
ItemStack itemStack = e.getItem();
//double moneyValue = MoneyNotesAPI.getMoneyAmount(e.getItem()) * e.getItem().getAmount();
p.setItemInHand(null);
double worth = MoneyNotesAPI.getMoneyAmount(e.getItem());
for(int i = 0; i < itemStack.getAmount(); i++) {
EconomyUtils.depositBalance(p, worth);
}
p.playSound(p.getLocation(), Sound.ORB_PICKUP, 1.0f, 1.2f);
p.sendMessage(CC.translate(Language.NOTE_DEPOSIT.getMessage()
.replace("%money%", NumberUtils.formatMoney(worth))
.replace("%amount%", String.valueOf(itemStack.getAmount()))));
}
}
}
@@ -0,0 +1,23 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.utils.ConfigManager;
import net.crankedpvp.crankedutils.CrankedUtils;
import net.crankedpvp.crankedutils.utils.DamageHandler;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
public class NetherDamageListener implements Listener {
@EventHandler
public void increaseDamage(EntityDamageByEntityEvent event) {
if (event.isCancelled() || event.getDamage() <=0) return;
if (event.getDamager() instanceof Player && event.getEntity() instanceof Player) {
if (event.getDamager().getLocation().getWorld().getName().equals("world_nether")) {
double buff = CrankedCore.getInstance().getConfigManager().getConfig(ConfigManager.ConfigFile.SETTINGS).getDouble("nether-increase-amount-percent");
CrankedUtils.getInstance().getDamageHandler().increaseDamage(buff, event, "NetherBuff");
}
}
}
}
@@ -0,0 +1,19 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.WorldGuardUtils;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
public class NetherJoinListener implements Listener {
@EventHandler
public void onJoin(PlayerJoinEvent event) {
if (event.getPlayer().getWorld().getName().equals("world_nether") && WorldGuardUtils.canPvPInRegion(event.getPlayer()) && !event.getPlayer().hasPermission("cranked.staff")) {
event.getPlayer().teleport(Bukkit.getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
event.getPlayer().sendMessage(CC.translate("&c&l(!) &cYou have been force teleported to spawn due to logging out in the nether warzone."));
}
}
}
@@ -0,0 +1,104 @@
package net.crankedpvp.crankedcore.listeners;
import net.crankedpvp.collect.CollectPlugin;
import net.crankedpvp.collect.struct.CollectCategory;
import net.crankedpvp.collect.struct.CollectType;
import net.crankedpvp.crankedcore.CrankedCore;
import net.crankedpvp.crankedcore.struct.netherpvp.NetherPvPQueueManager;
import net.crankedpvp.crankedcore.utils.ConfigManager;
import net.crankedpvp.crankedutils.events.PlayerCombatEnterEvent;
import net.crankedpvp.crankedutils.utils.CC;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.player.*;
import org.bukkit.inventory.ItemStack;
import java.util.List;
public class NetherPvpListener implements Listener {
private final CrankedCore plugin;
private final NetherPvPQueueManager netherPvPQueueManager;
private final ConfigManager configManager;
public NetherPvpListener(CrankedCore plugin) {
this.plugin = plugin;
this.netherPvPQueueManager = this.plugin.getNetherPvPQueueManager();
this.configManager = this.plugin.getConfigManager();
}
@EventHandler
public void onCombatEnter(PlayerCombatEnterEvent event) {
if (!this.netherPvPQueueManager.isPlayerInPvPQueue(event.getPlayer())) return;
this.netherPvPQueueManager.removePlayerFromPvpQueue(event.getPlayer());
}
@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerCommand(PlayerCommandPreprocessEvent event) {
if (!this.netherPvPQueueManager.isPlayerInArena(event.getPlayer())) return;
FileConfiguration config = this.configManager.getAbstractConfig(ConfigManager.ConfigFile.SETTINGS).getConfig();
ConfigurationSection netherpvpConfigurationSection = config.getConfigurationSection("nether-pvp");
List<String> allowedCommands = netherpvpConfigurationSection.getStringList("allowed-commands");
String cmd = event.getMessage().toLowerCase().replace("/", "");
Player player = event.getPlayer();
if (!allowedCommands.contains(cmd)) {
player.sendMessage(CC.translate("&cYou cannot execute this command in a nether pvp duel"));
event.setCancelled(true);
}
}
@EventHandler
public void onDropItemInNetherPvP(PlayerDropItemEvent event) {
if (!this.netherPvPQueueManager.isPlayerInArena(event.getPlayer())) return;
event.setCancelled(true);
}
@EventHandler
public void onTeleport(PlayerTeleportEvent event) {
if (!this.netherPvPQueueManager.isPlayerInArena(event.getPlayer())) return;
if (event.getTo().getWorld().getName().equals("world_nether")) return;
event.getPlayer().sendMessage(CC.translate("&cYou cannot teleport during a pvp match"));
event.setCancelled(true);
}
@EventHandler(priority = EventPriority.HIGHEST)
public void onDeathInNetherPvp(PlayerDeathEvent event) {
if (!this.netherPvPQueueManager.isPlayerInArena(event.getEntity())) return;
Player killer = this.netherPvPQueueManager.getOposingPlayer(event.getEntity());
if (killer == null) return;
if (!event.getDrops().isEmpty()) {
CollectPlugin.getInstance().getCollectManager().getOrCreate(killer.getUniqueId().toString())
.add(new CollectCategory(CollectType.NETHER_PVP, event.getDrops().toArray(new ItemStack[event.getDrops().size() - 1]), CC.RedB + event.getEntity().getName() + "'s NetherPvP Items", System.currentTimeMillis()));
event.getDrops().clear();
}
this.netherPvPQueueManager.endMatch(killer, event.getEntity());
}
@EventHandler
public void onPlayerLeaveWhileWaiting(PlayerQuitEvent event) {
if (!this.netherPvPQueueManager.isPlayerInPvPQueue(event.getPlayer())) return;
this.netherPvPQueueManager.removePlayerFromPvpQueue(event.getPlayer());
}
@EventHandler
public void onPlayerKickedWhileWaiting(PlayerKickEvent event) {
if (!this.netherPvPQueueManager.isPlayerInPvPQueue(event.getPlayer())) return;
this.netherPvPQueueManager.removePlayerFromPvpQueue(event.getPlayer());
}
@EventHandler
public void onPlayerLeave(PlayerQuitEvent event) {
if (!this.netherPvPQueueManager.isPlayerInArena(event.getPlayer())) return;
event.getPlayer().setHealth(0);
}
@EventHandler
public void onPlayerKicked(PlayerKickEvent event) {
if (!this.netherPvPQueueManager.isPlayerInArena(event.getPlayer())) return;
event.getPlayer().setHealth(0);
}
}

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