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
+63
View File
@@ -0,0 +1,63 @@
<?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>TempTournament</artifactId>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<artifactId>Utils</artifactId>
<groupId>net.crankedpvp</groupId>
</dependency>
<dependency>
<artifactId>Teams</artifactId>
<groupId>net.crankedpvp</groupId>
<version>1.0</version>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Enchants</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>StarItems</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>AdminWeapons</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Masks</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Lootboxes</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>Armor</artifactId>
</dependency>
<dependency>
<groupId>net.crankedpvp</groupId>
<artifactId>StorageUtilsShaded</artifactId>
<version>1.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/../StorageUtils/target/StorageUtils-1.0-shaded.jar</systemPath>
</dependency>
</dependencies>
</project>
@@ -0,0 +1,45 @@
package net.crankedpvp.tournaments;
import com.google.common.collect.Maps;
import lombok.Getter;
import net.crankedpvp.tournaments.objects.Arena;
import net.crankedpvp.tournaments.utils.Pair;
import net.crankedpvp.tournaments.utils.Utils;
import org.bukkit.Location;
import java.util.Map;
public class ArenaRegister {
@Getter
public Map<String, Arena> arenas;
private final CrankedTournaments astroTournamentsPlugin;
public ArenaRegister(CrankedTournaments astroTournamentsPlugin) {
this.astroTournamentsPlugin = astroTournamentsPlugin;
this.arenas = Maps.newConcurrentMap();
}
public void registerArenas() {
for(String section : this.astroTournamentsPlugin.getConfig().getConfigurationSection("Tournament.Arenas").getKeys(false)) {
Location playerLocationOne = Utils.getLocationFromString(this.astroTournamentsPlugin.getConfig().getString("Tournament.Arenas." + section + ".PlayerOneSpawnPoint"));
Location playerLocationTwo = Utils.getLocationFromString(this.astroTournamentsPlugin.getConfig().getString("Tournament.Arenas." + section + ".PlayerTwoSpawnPoint"));
try {
Arena arena = new Arena(section, new Pair<>(playerLocationOne, playerLocationTwo), new Pair<>(null, null), 0, false);
register(arena);
} catch (NullPointerException exception) {
exception.printStackTrace();
}
}
}
public void register(Arena arena) {
try {
this.arenas.put(arena.getId(), arena);
this.astroTournamentsPlugin.getLogger().info("Successfully registered arena: " + arena.getId());
} catch (Exception var3) {
System.err.println("&8(&c!&8) Failed to register arena, " + arena.getId());
}
}
}
@@ -0,0 +1,70 @@
package net.crankedpvp.tournaments;
import lombok.Getter;
import net.crankedpvp.tournaments.listeners.PlayerJoinListener;
import net.crankedpvp.tournaments.listeners.PlayerQuitListener;
import net.crankedpvp.tournaments.listeners.TournamentDeathListener;
import net.crankedpvp.tournaments.listeners.TournamentLogicListener;
import net.crankedpvp.tournaments.managers.TournamentManager;
import net.crankedpvp.tournaments.utils.Queue;
import net.crankedpvp.tournaments.utils.Utils;
import me.mattstudios.mf.base.CommandManager;
import net.crankedpvp.tournaments.commands.TournamentCommand;
import org.bukkit.Bukkit;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;
public class CrankedTournaments extends JavaPlugin {
@Getter
public static CrankedTournaments instance;
@Getter
private TournamentManager tournamentManager;
@Getter
private ArenaRegister arenaRegister;
public void onEnable() {
instance = this;
this.tournamentManager = new TournamentManager(this);
this.tournamentManager.setPlayerQueue(new Queue<>());
this.tournamentManager.setWaitingRoomLocation(Utils.getLocationFromString(this.getConfig().getString("Tournament.WaitingRoom.Location")));
getTournamentManager().loadAll();
this.arenaRegister = new ArenaRegister(this);
this.arenaRegister.registerArenas();
CommandManager commandManager = new CommandManager(this);
commandManager.register(new TournamentCommand(this));
this.registerListeners();
Bukkit.getScheduler().scheduleAsyncRepeatingTask(this, ()-> {
getTournamentManager().saveAll();
},60L, 20L*10);
}
public void onDisable() {
if(getTournamentManager().isActive()) {
getTournamentManager().end();
System.out.println("[Tournaments] Force ended an active tournament");
}
getTournamentManager().saveAll();
}
public void registerListeners() {
PluginManager pluginManager = this.getServer().getPluginManager();
pluginManager.registerEvents(new TournamentDeathListener(this), this);
pluginManager.registerEvents(new PlayerQuitListener(this), this);
pluginManager.registerEvents(new TournamentLogicListener(), this);
pluginManager.registerEvents(new PlayerJoinListener(), this);
}
}
@@ -0,0 +1,174 @@
package net.crankedpvp.tournaments.commands;
import net.crankedpvp.tournaments.CrankedTournaments;
import net.crankedpvp.tournaments.inventory.TournamentInventory;
import net.crankedpvp.tournaments.managers.TournamentManager;
import net.crankedpvp.tournaments.tasks.TournamentStartTask;
import net.crankedpvp.tournaments.utils.Utils;
import me.mattstudios.mf.annotations.*;
import me.mattstudios.mf.base.CommandBase;
import org.bukkit.Bukkit;
import org.bukkit.Sound;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerTeleportEvent;
@Command("tournament")
@Alias({"tm", "crankedtournaments", "tournaments"})
public class TournamentCommand extends CommandBase {
private final CrankedTournaments astroTournamentsPlugin;
private final TournamentManager tournamentManager;
public TournamentCommand(CrankedTournaments astroTournamentsPlugin)
{
this.astroTournamentsPlugin = astroTournamentsPlugin;
this.tournamentManager = astroTournamentsPlugin.getTournamentManager();
}
@Default
public void defaultCommand(CommandSender commandSender) {
Player player = (Player)commandSender;
TournamentInventory tournamentInventory = new TournamentInventory(player);
tournamentInventory.getUI().open(player);
player.playSound(player.getLocation(), Sound.CHEST_OPEN, 2.0F, 2.0F);
}
@SubCommand("help")
public void helpCommand(CommandSender commandSender) {
if(commandSender.hasPermission("tournament.*")) {
sendAdminHelp(commandSender);
return;
}
sendUserHelp(commandSender);
}
@SubCommand("join")
public void joinCommand(CommandSender commandSender) {
Player player = (Player)commandSender;
if(!astroTournamentsPlugin.getTournamentManager().isActive()) {
player.sendMessage(Utils.fixColor("&cThere is no tournament currently active"));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
if(!astroTournamentsPlugin.getTournamentManager().isJoinable()) {
player.sendMessage(Utils.fixColor("&cYou can no longer join this tournament"));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
if(tournamentManager.getTournamentParticipants().contains(tournamentManager.getTournamentPlayer(player.getUniqueId()))) {
player.sendMessage(Utils.fixColor("&cYou are already in the tournament"));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
if(!Utils.isEmptyInventory(player)) {
player.sendMessage(Utils.fixColor("&cYou must have an empty inventory to join the tournament"));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
tournamentManager.getTournamentParticipants().add(tournamentManager.getTournamentPlayer(player.getUniqueId()));
tournamentManager.getTournamentPlayer(player.getUniqueId()).setInTournament(true);
player.playSound(player.getLocation(), Sound.ORB_PICKUP, 2.0F, 2.0F);
player.teleport(astroTournamentsPlugin.getTournamentManager().getWaitingRoomLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
player.sendMessage(Utils.fixColor("&aYou have successfully joined the tournament"));
player.setFlying(false);
player.setAllowFlight(false);
}
@SubCommand("leave")
public void leaveCommand(CommandSender commandSender) {
Player player = (Player) commandSender;
if(!astroTournamentsPlugin.getTournamentManager().isActive()) {
player.sendMessage(Utils.fixColor("&cThere is no tournament currently active"));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
if(!astroTournamentsPlugin.getTournamentManager().getTournamentPlayer(player.getUniqueId()).isInTournament()) {
player.sendMessage(Utils.fixColor("&cYou are not in a tournament"));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
CrankedTournaments.instance.getTournamentManager().getTournamentPlayer(player.getUniqueId()).leaveTournament();
player.playSound(player.getLocation(), Sound.CHICKEN_EGG_POP, 2.0F, 2.0F);
player.teleport(Bukkit.getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
player.sendMessage(Utils.fixColor("&aYou have successfully left the tournament"));
}
@SubCommand("info")
public void infoCommand(CommandSender commandSender) {
Player player = (Player) commandSender;
if(!astroTournamentsPlugin.getTournamentManager().isActive()) {
player.sendMessage(Utils.fixColor("&cThere is no tournament currently active"));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
player.sendMessage(Utils.fixColor("Players Remaining: " + astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().size()));
}
@SubCommand("start")
@Permission("tournaments.*")
@NoPermission("&cAn internal error occurred when executing this command.")
public void startCommand(CommandSender commandSender) {
Player player = (Player) commandSender;
if(astroTournamentsPlugin.getTournamentManager().isActive()) {
player.sendMessage(Utils.fixColor("&cThere is already an active tournament event"));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
player.sendMessage(Utils.fixColor("&aYou have successfully started a tournament"));
player.playSound(player.getLocation(), Sound.ORB_PICKUP, 2.0F, 2.0F);
astroTournamentsPlugin.getTournamentManager().setActive(true);
astroTournamentsPlugin.getTournamentManager().setJoinable(true);
new TournamentStartTask(astroTournamentsPlugin);
}
@SubCommand("end")
@Permission("tournaments.*")
@NoPermission("&cAn internal error occurred when executing this command.")
public void endCommand(CommandSender commandSender) {
Player player = (Player) commandSender;
if(!astroTournamentsPlugin.getTournamentManager().isActive()) {
player.sendMessage(Utils.fixColor("&cThere is not an active tournament event"));
player.playSound(player.getLocation(), Sound.ANVIL_LAND, 2.0F, 2.0F);
return;
}
astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().forEach(player1 -> {
player.teleport(Bukkit.getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
});
astroTournamentsPlugin.getTournamentManager().end();
player.sendMessage(Utils.fixColor("&aYou have successfully ended a tournament"));
player.playSound(player.getLocation(), Sound.BAT_TAKEOFF, 2.0F, 2.0F);
}
private void sendUserHelp(CommandSender commandSender) {
commandSender.sendMessage(Utils.fixColor("&a-------[ &2Tournaments &a]-------"));
commandSender.sendMessage(Utils.fixColor("&a[] &8- &7Optional argument"));
commandSender.sendMessage(Utils.fixColor("&2<> &8- &7Required argument"));
commandSender.sendMessage("");
commandSender.sendMessage(Utils.fixColor(" &2* &a/tournament join"));
commandSender.sendMessage(Utils.fixColor(" &2* &a/tournament leave"));
commandSender.sendMessage(Utils.fixColor(" &2* &a/tournament info"));
commandSender.sendMessage(Utils.fixColor("&a-------[ &2Tournaments &a]-------"));
}
private void sendAdminHelp(CommandSender commandSender) {
commandSender.sendMessage(Utils.fixColor("&a-------[ &2Tournaments &a]-------"));
commandSender.sendMessage(Utils.fixColor("&a[] &8- &7Optional argument"));
commandSender.sendMessage(Utils.fixColor("&2<> &8- &7Required argument"));
commandSender.sendMessage("");
commandSender.sendMessage(Utils.fixColor(" &2* &a/tournament join"));
commandSender.sendMessage(Utils.fixColor(" &2* &a/tournament leave"));
commandSender.sendMessage(Utils.fixColor(" &2* &a/tournament info"));
commandSender.sendMessage("");
commandSender.sendMessage(Utils.fixColor(" &2* &a/tournament start <time>"));
commandSender.sendMessage(Utils.fixColor(" &2* &a/tournament end"));
commandSender.sendMessage(Utils.fixColor(" &2* &a/tournament reload"));
commandSender.sendMessage(Utils.fixColor("&a-------[ &2Tournaments &a]-------"));
}
}
@@ -0,0 +1,35 @@
package net.crankedpvp.tournaments.inventory;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import net.crankedpvp.adminweapons.AdminWeaponsPlugin;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.tournaments.CrankedTournaments;
import org.bukkit.entity.Player;
public class AdminAdminWeaponPickerInventory {
private final Gui crankedTournamenmtsInventory;
public Gui getUI() {
return this.crankedTournamenmtsInventory;
}
public AdminAdminWeaponPickerInventory(Player player) {
this.crankedTournamenmtsInventory = new Gui(3, "Pick Admin Weapon to be used");
this.crankedTournamenmtsInventory.setDefaultClickAction(event -> event.setCancelled(true));
if(player.hasPermission("cranked.admin")) {
AdminWeaponsPlugin.getInstance().getAdminWeaponRegister().getAdminWeapons().forEach(adminWeapon -> {
this.crankedTournamenmtsInventory.addItem(new GuiItem(adminWeapon.buildItem(), event -> {
CrankedTournaments crankedTournaments = CrankedTournaments.instance;
crankedTournaments.getTournamentManager().setAdminWeapon(adminWeapon);
player.sendMessage(CC.translate("&aThe tournament will now use the " + adminWeapon.getName() + " admin weapon"));
player.closeInventory();
TournamentInventory tournamentInventory = new TournamentInventory(player);
tournamentInventory.getUI().open(player);
}));
});
}
}
}
@@ -0,0 +1,36 @@
package net.crankedpvp.tournaments.inventory;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import net.crankedpvp.crankedarmor.struct.ArmorSetRegister;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.tournaments.CrankedTournaments;
import org.bukkit.entity.Player;
public class AdminArmorSetPickerInventory {
private final Gui crankedTournamenmtsInventory;
public Gui getUI() {
return this.crankedTournamenmtsInventory;
}
public AdminArmorSetPickerInventory(Player player) {
this.crankedTournamenmtsInventory = new Gui(3, "Pick Armor Set to be used");
this.crankedTournamenmtsInventory.setDefaultClickAction(event -> event.setCancelled(true));
if(player.hasPermission("cranked.admin")) {
ArmorSetRegister.getInstance().getArmorSets().forEach(armorSet -> {
this.crankedTournamenmtsInventory.addItem(new GuiItem(armorSet.getDisplayItem(), event -> {
CrankedTournaments crankedTournaments = CrankedTournaments.getInstance();
crankedTournaments.getTournamentManager().setArmorSet(armorSet);
player.sendMessage(CC.translate("&aThe tournament will now use the " + armorSet.getName() + " armor set"));
player.closeInventory();
TournamentInventory tournamentInventory = new TournamentInventory(player);
tournamentInventory.getUI().open(player);
}));
});
}
}
}
@@ -0,0 +1,36 @@
package net.crankedpvp.tournaments.inventory;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import net.crankedpvp.crankedmasks.struct.MasksRegister;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.tournaments.CrankedTournaments;
import org.bukkit.entity.Player;
public class AdminMaskPickerInventory {
private final Gui crankedTournamenmtsInventory;
public Gui getUI() {
return this.crankedTournamenmtsInventory;
}
public AdminMaskPickerInventory(Player player) {
this.crankedTournamenmtsInventory = new Gui(3, "Pick Mask to be used");
this.crankedTournamenmtsInventory.setDefaultClickAction(event -> event.setCancelled(true));
if(player.hasPermission("cranked.admin")) {
MasksRegister.getInstance().getMasks().forEach(mask -> {
this.crankedTournamenmtsInventory.addItem(new GuiItem(mask.getItem(), event -> {
CrankedTournaments crankedTournaments = CrankedTournaments.getInstance();
crankedTournaments.getTournamentManager().setMask(mask);
player.sendMessage(CC.translate("&aThe tournament will now use the " + mask.getName() + " mask"));
player.closeInventory();
TournamentInventory tournamentInventory = new TournamentInventory(player);
tournamentInventory.getUI().open(player);
}));
});
}
}
}
@@ -0,0 +1,35 @@
package net.crankedpvp.tournaments.inventory;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.staritems.StarItemsPlugin;
import net.crankedpvp.tournaments.CrankedTournaments;
import org.bukkit.entity.Player;
public class AdminStarItemPickerInventory {
private final Gui crankedTournamenmtsInventory;
public Gui getUI() {
return this.crankedTournamenmtsInventory;
}
public AdminStarItemPickerInventory(Player player) {
this.crankedTournamenmtsInventory = new Gui(3, "Pick Star Item to be used");
this.crankedTournamenmtsInventory.setDefaultClickAction(event -> event.setCancelled(true));
if(player.hasPermission("cranked.admin")) {
StarItemsPlugin.getInstance().getStarItemManager().getStarItems().forEach(starItem -> {
this.crankedTournamenmtsInventory.addItem(new GuiItem(starItem.buildItem(), event -> {
CrankedTournaments crankedTournaments = CrankedTournaments.getInstance();
crankedTournaments.getTournamentManager().setStarItem(starItem);
player.sendMessage(CC.translate("&aThe tournament will now use the " + starItem.getName() + " star item"));
player.closeInventory();
TournamentInventory tournamentInventory = new TournamentInventory(player);
tournamentInventory.getUI().open(player);
}));
});
}
}
}
@@ -0,0 +1,146 @@
package net.crankedpvp.tournaments.inventory;
import dev.triumphteam.gui.guis.Gui;
import dev.triumphteam.gui.guis.GuiItem;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.tournaments.CrankedTournaments;
import net.crankedpvp.tournaments.objects.Arena;
import net.crankedpvp.tournaments.objects.TournamentPlayer;
import net.crankedpvp.tournaments.utils.Utils;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class TournamentInventory {
private boolean active;
private final Gui crankedTournamenmtsInventory;
public Gui getUI() {
return this.crankedTournamenmtsInventory;
}
public TournamentInventory(Player player) {
this.active = CrankedTournaments.getInstance().getTournamentManager().isActive();
this.crankedTournamenmtsInventory = new Gui(3, "Cranked Tournaments");
this.crankedTournamenmtsInventory.setDefaultClickAction(event -> event.setCancelled(true));
this.crankedTournamenmtsInventory.setItem(2, 5, new GuiItem(buildTournamentInfoItem(), event -> ((Player)event.getWhoClicked()).chat("/tm join")));
this.crankedTournamenmtsInventory.setItem(1, 1, new GuiItem(createProfile(CrankedTournaments.getInstance().getTournamentManager().getTournamentPlayer(player.getUniqueId()))));
if(player.hasPermission("cranked.admin")) {
CrankedTournaments crankedTournaments = CrankedTournaments.getInstance();
this.crankedTournamenmtsInventory.setItem(3, 9, new GuiItem(buildArmorSetPickerItem(), event -> {
player.closeInventory();
AdminArmorSetPickerInventory adminArmorSetPickerInventory = new AdminArmorSetPickerInventory(player);
adminArmorSetPickerInventory.getUI().open(player);
}));
this.crankedTournamenmtsInventory.setItem(3, 8, new GuiItem(buildMaskPickerItem(), event -> {
player.closeInventory();
AdminMaskPickerInventory adminMaskPickerInventory = new AdminMaskPickerInventory(player);
adminMaskPickerInventory.getUI().open(player);
}));
this.crankedTournamenmtsInventory.setItem(3, 7, new GuiItem(buildStarItemPickerItem(), event -> {
player.closeInventory();
AdminStarItemPickerInventory adminStarItemPickerInventory = new AdminStarItemPickerInventory(player);
adminStarItemPickerInventory.getUI().open(player);
}));
this.crankedTournamenmtsInventory.setItem(3, 6, new GuiItem(buildAdminWeaponPickerItem(), event -> {
player.closeInventory();
AdminAdminWeaponPickerInventory adminAdminWeaponPickerInventory = new AdminAdminWeaponPickerInventory(player);
adminAdminWeaponPickerInventory.getUI().open(player);
}));
}
}
private ItemStack buildArmorSetPickerItem() {
ItemBuilder itemBuilder = new ItemBuilder(Material.DIAMOND_CHESTPLATE, "&c&lArmor Set",
"&7Admins can click here to choose",
"&7which armor set should be used for",
"&7the tournament");
return itemBuilder.colorize().build();
}
private ItemStack buildStarItemPickerItem() {
ItemBuilder itemBuilder = new ItemBuilder(Material.SPONGE, 1, (short) 1, "&b&lStar Item",
"&7Admins can click here to choose",
"&7which star item should be used for",
"&7the tournament");
return itemBuilder.colorize().build();
}
private ItemStack buildMaskPickerItem() {
ItemBuilder itemBuilder = new ItemBuilder(Material.SKULL_ITEM, "&d&lMask",
"&7Admins can click here to choose",
"&7which mask should be used for",
"&7the tournament");
return itemBuilder.colorize().build();
}
private ItemStack buildAdminWeaponPickerItem() {
ItemBuilder itemBuilder = new ItemBuilder(Material.DIAMOND_SWORD, "&3&lAdmin Weapon",
"&7Admins can click here to choose",
"&7which admin weapon should be used",
"&7for the tournament");
return itemBuilder.colorize().build();
}
private ItemStack buildTournamentInfoItem() {
ItemBuilder itemBuilder = new ItemBuilder(Material.EYE_OF_ENDER, "&c&lCranked Tournaments &8(" + (this.active ? "&a&lACTIVE" : "&c&lINACTIVE") + "&8)",
"&7Tournaments are a series of duels until",
"&7one team or player is the only one",
"&7remaining.",
"",
"&7Compete for the best rewards in this",
"&7event and prove to the players that",
"&7you are the best.");
if(this.active) {
Map<String, Arena> arenaMap = CrankedTournaments.getInstance().getArenaRegister().getArenas();
arenaMap.values().forEach(arena -> {
if(arena.isInUse()) {
itemBuilder.addLoreLine("");
itemBuilder.addLoreLine("&c&l" + arena.getId());
itemBuilder.addLoreLine(" &f* &c" + arena.getCurrentlyFighting().getLeft().getPlayer().getName() + " &fvs &c" + arena.getCurrentlyFighting().getRight().getPlayer().getName());
}
});
itemBuilder.addLoreLine("");
itemBuilder.addLoreLine("&fPlayers Remaining: &c" + CrankedTournaments.getInstance().getTournamentManager().getTournamentParticipants().size());
} else {
itemBuilder.addLoreLine("");
itemBuilder.addLoreLine("&fStatus: &c&lINACTIVE");
}
return itemBuilder.setGlowing().colorize().build();
}
private ItemStack createProfile(TournamentPlayer player) {
List<String> lore = new ArrayList<>();
lore.add("");
lore.add("&c&lTournament W/L Ratio: &f" + player.getWLRatio());
lore.add("&c&l* &7Tournament Wins:&f " + player.getTournamenWins());
lore.add("&c&l* &7Tournament Losses:&f " + player.getTournamenLosses());
lore.add("");
lore.add("&c&lMatch W/L Ratio: &f" + player.getKDR());
lore.add("&c&l* &7Match Wins:&f " + player.getKills());
lore.add("&c&l* &7Match Losses:&f " + player.getDeaths());
lore.add("");
lore.add("&c&lK/D Ratio: &f" + player.getKDR());
lore.add("&c&l* &7Kills:&f " + player.getKills());
lore.add("&c&l* &7Deaths:&f " + player.getDeaths());
return Utils.createPlayerSkull(player.getPlayer().getName(), "&4&l" + player.getPlayer().getName() + "'s Tournament Stats", lore);
}
}
@@ -0,0 +1,25 @@
package net.crankedpvp.tournaments.listeners;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.InventoryUtils;
import net.crankedpvp.tournaments.CrankedTournaments;
import net.crankedpvp.tournaments.objects.TournamentPlayer;
import net.crankedpvp.tournaments.utils.Utils;
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 PlayerJoinListener implements Listener {
@EventHandler
public void onJoin(PlayerJoinEvent event) {
TournamentPlayer player = CrankedTournaments.instance.getTournamentManager().getTournamentPlayer(event.getPlayer().getUniqueId());
if (player.isInTournament()) {
InventoryUtils.clearInventory(player.getPlayer());
player.getPlayer().teleport(Bukkit.getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
player.getPlayer().sendMessage(CC.translate("&c&l(!)&c An error occured when leaving the tournament, your inventory has been cleared and you have been teleported to /spawn."));
player.setInTournament(false);
}
}
}
@@ -0,0 +1,158 @@
package net.crankedpvp.tournaments.listeners;
import net.crankedpvp.crankedutils.utils.InventoryUtils;
import net.crankedpvp.tournaments.CrankedTournaments;
import net.crankedpvp.tournaments.managers.TournamentManager;
import net.crankedpvp.tournaments.objects.TournamentMatch;
import net.crankedpvp.tournaments.objects.TournamentPlayer;
import net.crankedpvp.tournaments.utils.Utils;
import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerKickEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
public class PlayerQuitListener implements Listener {
private final CrankedTournaments astroTournamentsPlugin;
private final TournamentManager tournamentManager;
public PlayerQuitListener(CrankedTournaments astroTournamentsPlugin) {
this.astroTournamentsPlugin = astroTournamentsPlugin;
this.tournamentManager = astroTournamentsPlugin.getTournamentManager();
}
@EventHandler
public void playerQuitInTournament(PlayerQuitEvent event) {
if (event.getPlayer() == null) return;
TournamentPlayer player1 = tournamentManager.getTournamentPlayer(event.getPlayer().getUniqueId());
TournamentPlayer player2;
if (astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().size() < 1) return;
for (int i = 0; i < astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().size(); i++) {
TournamentMatch tournamentMatch = astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().get(i);
if (tournamentMatch.getPlayerOne() == player1 || tournamentMatch.getPlayerTwo() == player1) {
player1.getPlayer().teleport(Bukkit.getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
if (tournamentMatch.getPlayerOne() == player1) {
player2 = tournamentMatch.getPlayerTwo();
} else {
player1 = tournamentMatch.getPlayerTwo();
player2 = tournamentMatch.getPlayerOne();
}
for (TournamentPlayer player : astroTournamentsPlugin.getTournamentManager().getTournamentParticipants()) {
player.getPlayer().sendMessage(Utils.fixColor("&cTournaments &8| &7" + player2.getPlayer().getName() + " &ehas beaten the player &7" + player1.getPlayer().getName() + " &ein a tournament match"));
}
tournamentMatch.getArena().reset();
astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().remove(tournamentMatch);
if (astroTournamentsPlugin.getTournamentManager().getPlayerQueue().contains(player1))
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().removeFromQueue(player1);
astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().remove(player1);
player2.getPlayer().teleport(astroTournamentsPlugin.getTournamentManager().getWaitingRoomLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
player1.getPlayer().sendMessage(Utils.fixColor("&cYou have been eliminated from the tournament"));
if (astroTournamentsPlugin.getTournamentManager().getPlayerQueue().contains(player2))
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().removeFromQueue(player2);
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().enqueue(player2);
astroTournamentsPlugin.getServer().getScheduler().runTaskLater(astroTournamentsPlugin, () -> {
astroTournamentsPlugin.getTournamentManager().putNextPlayersInArenas();
}, 20L);
InventoryUtils.clearInventory(player1.getPlayer());
InventoryUtils.clearInventory(player2.getPlayer());
return;
}
}
if (astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().contains(player1)) {
player1.getPlayer().teleport(Bukkit.getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
if (astroTournamentsPlugin.getTournamentManager().getPlayerQueue().contains(player1))
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().removeFromQueue(player1);
astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().remove(player1);
}
}
@EventHandler
public void playerKickInTournament(PlayerKickEvent event) {
if (event.getPlayer() == null) return;
TournamentPlayer player1 = tournamentManager.getTournamentPlayer(event.getPlayer().getUniqueId());
TournamentPlayer player2;
if (astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().size() < 1) return;
for (TournamentMatch tournamentMatch : astroTournamentsPlugin.getTournamentManager().getTournamentMatchList()) {
if (tournamentMatch.getPlayerOne() == player1 || tournamentMatch.getPlayerTwo() == player1) {
player1.getPlayer().teleport(Bukkit.getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
if (tournamentMatch.getPlayerOne() == player1) {
player2 = tournamentMatch.getPlayerTwo();
} else {
player1 = tournamentMatch.getPlayerTwo();
player2 = tournamentMatch.getPlayerOne();
}
for (TournamentPlayer player : astroTournamentsPlugin.getTournamentManager().getTournamentParticipants()) {
player.getPlayer().sendMessage(Utils.fixColor("&c&lCrankedTournaments &8| &7" + player2.getPlayer().getName() + " &ehas beaten the player &7" + player1.getPlayer().getName() + " &ein a tournament match"));
}
tournamentMatch.getArena().reset();
astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().remove(tournamentMatch);
if (astroTournamentsPlugin.getTournamentManager().getPlayerQueue().contains(player1))
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().removeFromQueue(player1);
astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().remove(player1);
player2.getPlayer().teleport(astroTournamentsPlugin.getTournamentManager().getWaitingRoomLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
player1.getPlayer().sendMessage(Utils.fixColor("&cYou have been eliminated from the tournament"));
if (astroTournamentsPlugin.getTournamentManager().getPlayerQueue().contains(player2))
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().removeFromQueue(player2);
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().enqueue(player2);
astroTournamentsPlugin.getServer().getScheduler().runTaskLater(astroTournamentsPlugin, () -> {
astroTournamentsPlugin.getTournamentManager().putNextPlayersInArenas();
}, 20L);
InventoryUtils.clearInventory(player1.getPlayer());
InventoryUtils.clearInventory(player2.getPlayer());
return;
}
}
if (astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().contains(player1)) {
player1.getPlayer().teleport(Bukkit.getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
if (astroTournamentsPlugin.getTournamentManager().getPlayerQueue().contains(player1))
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().removeFromQueue(player1);
astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().remove(player1);
}
}
@EventHandler
public void onKickWaiting(PlayerKickEvent event) {
TournamentPlayer player = CrankedTournaments.instance.getTournamentManager().getTournamentPlayer(event.getPlayer().getUniqueId());
if (player.isInTournament()) {
player.leaveTournament();
}
}
@EventHandler
public void onQuitWaiting(PlayerQuitEvent event) {
TournamentPlayer player = CrankedTournaments.instance.getTournamentManager().getTournamentPlayer(event.getPlayer().getUniqueId());
if (player.isInTournament()) {
player.leaveTournament();
}
}
}
@@ -0,0 +1,139 @@
package net.crankedpvp.tournaments.listeners;
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
import net.crankedpvp.crankedutils.CrankedUtils;
import net.crankedpvp.crankedutils.enums.ArmorType;
import net.crankedpvp.crankedutils.events.ArmorEquipEvent;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import net.crankedpvp.crankedutils.utils.items.ItemUtils;
import net.crankedpvp.tournaments.CrankedTournaments;
import net.crankedpvp.tournaments.managers.TournamentManager;
import net.crankedpvp.tournaments.objects.TournamentMatch;
import net.crankedpvp.tournaments.objects.TournamentPlayer;
import net.crankedpvp.tournaments.utils.Utils;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.inventory.ItemStack;
public class TournamentDeathListener implements Listener {
private final CrankedTournaments astroTournamentsPlugin;
private final TournamentManager tournamentManager;
public TournamentDeathListener(CrankedTournaments astroTournamentsPlugin) {
this.astroTournamentsPlugin = astroTournamentsPlugin;
this.tournamentManager = astroTournamentsPlugin.getTournamentManager();
}
@EventHandler
public void tournamentDeathListener(PlayerDeathEvent event) {
if(event.getEntity() == null || event.getEntity().getKiller() == null) return;
TournamentPlayer victim = tournamentManager.getTournamentPlayer(event.getEntity().getUniqueId());
TournamentPlayer attacker;
if(astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().size() < 1) return;
for (int i = 0; i < astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().size(); i++) {
TournamentMatch tournamentMatch = astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().get(i);
if(tournamentMatch.getPlayerOne() == victim || tournamentMatch.getPlayerTwo() == victim) {
event.getDrops().clear();
if(tournamentMatch.getPlayerOne() == victim) {
attacker = tournamentMatch.getPlayerTwo();
} else {
victim = tournamentMatch.getPlayerTwo();
attacker = tournamentMatch.getPlayerOne();
}
for(TournamentPlayer player : astroTournamentsPlugin.getTournamentManager().getTournamentParticipants()) {
player.getPlayer().sendMessage(Utils.fixColor("&cTournaments &8| &7" + attacker.getPlayer().getName() + " &ehas beaten the player &7" + victim.getPlayer().getName() + " &ein a tournament match"));
};
tournamentMatch.getArena().reset();
astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().remove(tournamentMatch);
if(astroTournamentsPlugin.getTournamentManager().getPlayerQueue().contains(tournamentManager.getTournamentPlayer(victim.getUuid()))) {
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().removeFromQueue(victim);
}
astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().remove(victim);
victim.setInTournament(false);
victim.getPlayer().sendMessage(Utils.fixColor("&cYou have been eliminated from the tournament"));
attacker.getPlayer().teleport(astroTournamentsPlugin.getTournamentManager().getWaitingRoomLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
if(astroTournamentsPlugin.getTournamentManager().getPlayerQueue().contains(attacker)) {
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().removeFromQueue(attacker);
}
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().enqueue(attacker);
astroTournamentsPlugin.getServer().getScheduler().runTaskLater(astroTournamentsPlugin, () -> {
astroTournamentsPlugin.getTournamentManager().putNextPlayersInArenas();
}, 20L);
attacker.increaseKills();
victim.increaseDeaths();
victim.increaseLosses();
victim.getPlayer().setHealth(victim.getPlayer().getMaxHealth());
attacker.getPlayer().setHealth(attacker.getPlayer().getMaxHealth());
attacker.getPlayer().setFireTicks(0);
victim.getPlayer().setFireTicks(0);
TournamentPlayer finalVictim = victim;
TournamentPlayer finalAttacker = attacker;
Bukkit.getScheduler().runTaskLater(astroTournamentsPlugin, ()-> {
clearInventory(finalVictim.getPlayer());
clearInventory(finalAttacker.getPlayer());
}, 5L);
}
}
}
private void clearInventory(Player player) {
if (!ItemUtils.isAirOrNull(player.getInventory().getBoots())) {
ArmorEquipEvent bootsArmorUnEquipEvent = new ArmorEquipEvent(player, ArmorEquipEvent.EquipMethod.SHIFT_CLICK, ArmorType.BOOTS, player.getInventory().getBoots(), new ItemStack(Material.AIR));
Bukkit.getServer().getPluginManager().callEvent(bootsArmorUnEquipEvent);
}
if (!ItemUtils.isAirOrNull(player.getInventory().getLeggings())) {
ArmorEquipEvent leggingsArmorUnEquipEvent = new ArmorEquipEvent(player, ArmorEquipEvent.EquipMethod.SHIFT_CLICK, ArmorType.LEGGINGS, player.getInventory().getLeggings(), new ItemStack(Material.AIR));
Bukkit.getServer().getPluginManager().callEvent(leggingsArmorUnEquipEvent);
}
if (!ItemUtils.isAirOrNull(player.getInventory().getChestplate())) {
ArmorEquipEvent chestplateArmorUnEquipEvent = new ArmorEquipEvent(player, ArmorEquipEvent.EquipMethod.SHIFT_CLICK, ArmorType.CHESTPLATE, player.getInventory().getChestplate(), new ItemStack(Material.AIR));
Bukkit.getServer().getPluginManager().callEvent(chestplateArmorUnEquipEvent);
}
if (!ItemUtils.isAirOrNull(player.getInventory().getHelmet())) {
ArmorEquipEvent helmetArmorUnEquipEvent = new ArmorEquipEvent(player, ArmorEquipEvent.EquipMethod.SHIFT_CLICK, ArmorType.HELMET, player.getInventory().getHelmet(), new ItemStack(Material.AIR));
Bukkit.getServer().getPluginManager().callEvent(helmetArmorUnEquipEvent);
}
player.getInventory().clear();
player.getInventory().setArmorContents(new ItemStack[4]);
PotionEffectUtils.clearPlayerEffects(player);
CrankedUtils.getInstance().getPotionManager().getCrankedPotionPlayer(player.getUniqueId()).getPotionCacheMap().clear();
player.getActivePotionEffects().clear();
CrankedEnchantsAPI.clearEnchantsFromCache(player);
}
}
@@ -0,0 +1,86 @@
package net.crankedpvp.tournaments.listeners;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.tournaments.CrankedTournaments;
import net.crankedpvp.tournaments.managers.TournamentManager;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.inventory.InventoryOpenEvent;
import org.bukkit.event.inventory.InventoryType;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerToggleFlightEvent;
import java.util.Arrays;
import java.util.List;
public class TournamentLogicListener implements Listener {
public List<String> allowedCommands = Arrays.asList("/msg", "/r", "/message", "/reply", "/tournament", "/tm", "/tournaments", "/f c f", "/f c p", "/f c t", "/f c m", "/bless", "/apply");
private TournamentManager tournamentManager = CrankedTournaments.instance.getTournamentManager();
@EventHandler(priority = EventPriority.LOWEST)
public void onCommand(PlayerCommandPreprocessEvent e) {
if (tournamentManager.getTournamentPlayer(e.getPlayer().getUniqueId()).isInTournament() && !isAllowedCommand(e.getMessage())) {
e.getPlayer().sendMessage(CC.translate("&c&l(!)&c You cannot use this command in a tournament."));
e.getPlayer().sendMessage(CC.translate("&7You can leave the tournament with /tournament leave."));
e.setCancelled(true);
e.setMessage("/null");
}
}
@EventHandler
public void onItemDrop(PlayerDropItemEvent e) {
if (tournamentManager.getTournamentPlayer(e.getPlayer().getUniqueId()).isInTournament()) {
e.getPlayer().sendMessage(CC.translate("&c&l(!)&c You cannot drop items in a tournament."));
e.setCancelled(true);
}
}
@EventHandler
public void onBlockBreak(BlockBreakEvent e) {
if (tournamentManager.getTournamentPlayer(e.getPlayer().getUniqueId()).isInTournament()) {
e.getPlayer().sendMessage(CC.translate("&c&l(!)&c You cannot break blocks while in a tournament."));
e.setCancelled(true);
}
}
@EventHandler
public void onBlockPlace(BlockPlaceEvent e) {
if (tournamentManager.getTournamentPlayer(e.getPlayer().getUniqueId()).isInTournament()) {
e.getPlayer().sendMessage(CC.translate("&c&l(!)&c You cannot place blocks while in a tournament."));
e.setCancelled(true);
}
}
@EventHandler
public void onFly(PlayerToggleFlightEvent e) {
if (tournamentManager.getTournamentPlayer(e.getPlayer().getUniqueId()).isInTournament()) {
e.setCancelled(true);
}
}
@EventHandler
public void onInventoryOpen(InventoryOpenEvent e) {
if (e.getInventory().getType() != InventoryType.PLAYER && tournamentManager.getTournamentPlayer(e.getPlayer().getUniqueId()).isInTournament() && !(e.getInventory().getTitle()).equals("Cranked Tournaments")) {
e.getPlayer().sendMessage(CC.translate("&c&l(!)&c You cannot open inventories while in a tournament."));
e.setCancelled(true);
e.getPlayer().closeInventory();
}
}
public boolean isAllowedCommand(String message) {
for (String allowedCMD : allowedCommands) {
if (message.toLowerCase().startsWith(allowedCMD)) {
return true;
}
}
return false;
}
}
@@ -0,0 +1,220 @@
package net.crankedpvp.tournaments.managers;
import de.tr7zw.nbtapi.NBTCompound;
import de.tr7zw.nbtapi.NBTItem;
import lombok.Getter;
import lombok.Setter;
import net.crankedpvp.adminweapons.AdminWeaponsPlugin;
import net.crankedpvp.adminweapons.struct.AdminWeapon;
import net.crankedpvp.crankedarmor.struct.ArmorSet;
import net.crankedpvp.crankedarmor.struct.ArmorSetRegister;
import net.crankedpvp.crankedenchants.struct.EnchantRegister;
import net.crankedpvp.crankedenchants.struct.items.EnchantedItemBuilder;
import net.crankedpvp.crankedenchants.struct.items.SoulGemBuilder;
import net.crankedpvp.crankedmasks.struct.Mask;
import net.crankedpvp.crankedmasks.struct.MasksRegister;
import net.crankedpvp.crankedutils.enums.ArmorType;
import net.crankedpvp.crankedutils.events.ArmorEquipEvent;
import net.crankedpvp.crankedutils.utils.*;
import net.crankedpvp.crankedutils.utils.items.ItemBuilder;
import net.crankedpvp.lootboxes.CrankedLootboxes;
import net.crankedpvp.staritems.StarItemsPlugin;
import net.crankedpvp.staritems.struct.StarItem;
import net.crankedpvp.storageutils.StorageUtils;
import net.crankedpvp.storageutils.utils.SaveLoadManager;
import net.crankedpvp.tournaments.CrankedTournaments;
import net.crankedpvp.tournaments.objects.TournamentMatch;
import net.crankedpvp.tournaments.objects.TournamentPlayer;
import net.crankedpvp.tournaments.utils.*;
import net.crankedpvp.tournaments.utils.Queue;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.potion.Potion;
import org.bukkit.potion.PotionType;
import net.crankedpvp.tournaments.utils.Pair;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
@Getter
@Setter
public class TournamentManager extends SaveLoadManager<TournamentPlayer> {
private final CrankedTournaments astroTournamentsPlugin;
private final List<TournamentPlayer> tournamentParticipants;
private final List<TournamentMatch> tournamentMatchList;
public Queue<TournamentPlayer> playerQueue;
private StarItem starItem;
private Mask mask;
private AdminWeapon adminWeapon;
private ArmorSet armorSet;
private boolean active;
private boolean joinable;
private Location waitingRoomLocation;
public TournamentManager(CrankedTournaments astroTournamentsPlugin) {
super(astroTournamentsPlugin, StorageUtils.getInstance().getGson(), "data/", TournamentPlayer.class);
this.astroTournamentsPlugin = astroTournamentsPlugin;
this.tournamentMatchList = new ArrayList<>();
this.tournamentParticipants = new ArrayList<>();
}
public void setupQueue() {
tournamentParticipants.forEach(player -> {
playerQueue.enqueue(player);
});
}
public TournamentPlayer getTournamentPlayer(UUID uuid) {
if (!containsKey(uuid.toString())) {
TournamentPlayer tournamentPlayer = new TournamentPlayer(uuid);
addToCache(tournamentPlayer);
}
return getFromCache(uuid.toString());
}
public void putNextPlayersInArenas() {
Queue<TournamentPlayer> playersInTournament = getPlayerQueue();
this.astroTournamentsPlugin.getArenaRegister().getArenas().values().forEach(arena -> {
if (astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().size() == 1) {
TournamentPlayer winnerTournamentPlayer = astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().get(0);
Player winner = winnerTournamentPlayer.getPlayer();
Bukkit.broadcastMessage("");
Bukkit.broadcastMessage(Utils.fixColor("&c&lCranked&f&lPvP &c&lTournaments"));
Bukkit.broadcastMessage(Utils.fixColor(" &f&l* &fTournament Winner: &e" + winner.getName()));
Bukkit.broadcastMessage("");
astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().clear();
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().clear();
astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().clear();
astroTournamentsPlugin.getTournamentManager().setJoinable(false);
astroTournamentsPlugin.getTournamentManager().setActive(false);
winner.teleport(Bukkit.getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
winner.getInventory().addItem(CrankedLootboxes.getInstance().getLootboxRegister().getLootbox("TournamentLootbox").createLootbox(1));
winnerTournamentPlayer.increaseWins();
winnerTournamentPlayer.setInTournament(false);
return;
}
if (!arena.isInUse() && playersInTournament.size() >= 2) {
TournamentPlayer player1 = playersInTournament.dequeue();
TournamentPlayer player2 = playersInTournament.dequeue();
arena.setCurrentlyFighting(new Pair<>(player1, player2));
arena.setInUse(true);
this.astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().add(new TournamentMatch(player1, player2, arena));
Bukkit.getScheduler().runTaskLater(astroTournamentsPlugin, ()-> {
setupPlayer(player1, arena.getLocations().getLeft());
setupPlayer(player2, arena.getLocations().getRight());
}, 40L);
}
});
}
private void setupPlayer(TournamentPlayer tournamentPlayer, Location location) {
Player player = tournamentPlayer.getPlayer();
player.closeInventory();
InventoryUtils.clearInventory(tournamentPlayer.getPlayer());
player.teleport(location, PlayerTeleportEvent.TeleportCause.UNKNOWN);
player.setHealth(20);
player.setFlying(false);
player.setAllowFlight(false);
giveItems(tournamentPlayer);
Bukkit.getScheduler().runTaskLater(astroTournamentsPlugin, () -> {
PotionEffectUtils.bless(player);
}, 100L);
}
private void giveItems(TournamentPlayer tmPlayer) {
ArmorSet armorSet = this.armorSet == null ? ArmorSetRegister.getInstance().getArmorSetFromID("lucid") : this.armorSet;
StarItem starItem = this.starItem == null ? StarItemsPlugin.getInstance().getStarItemManager().getStarItemFromID("blurredsoaker") : this.starItem;
AdminWeapon adminWeapon = this.adminWeapon == null ? AdminWeaponsPlugin.getInstance().getAdminWeaponRegister().getAdminWeaponFromID("hofund") : this.adminWeapon;
Mask mask = this.mask == null ? MasksRegister.getInstance().getMaskFromID("reindeer") : this.mask;
List<ItemStack> finalItems = new ArrayList<>();
List<ItemStack> items = armorSet.getSetItemsWithData();
for(ItemStack itemStack : items) {
net.crankedpvp.crankedutils.utils.items.ItemBuilder itemBuilder = new net.crankedpvp.crankedutils.utils.items.ItemBuilder(itemStack);
itemBuilder.setName("&c&lTournament " + StringUtils.getProperCase(itemStack.getType().name().split("_")[1]));
ItemStack finalItemStack = itemBuilder.colorize().build();
EnchantedItemBuilder enchantedItemBuilder = new EnchantedItemBuilder(finalItemStack);
for(String enchantName : GodsetUtils.enchantments.get(finalItemStack.getType().name().split("_")[1].toLowerCase())) {
net.crankedpvp.crankedenchants.struct.enchantstruct.Enchantment enchantment = EnchantRegister.getInstance().getEnchantmentFromID(enchantName);
enchantedItemBuilder.addEnchantment(enchantment, enchantment.getMax());
}
enchantedItemBuilder.sortEnchantLore();
enchantedItemBuilder.setProtected(true);
ItemStack finalItem = enchantedItemBuilder.build();
if(itemStack.getType() == Material.DIAMOND_HELMET) {
net.crankedpvp.crankedutils.utils.items.ItemBuilder itemBuilder1 = new ItemBuilder(finalItem);
itemBuilder1.addLore("&f&lSTAR ITEM: " + starItem.getDisplayName());
itemBuilder1.addLore("&7&lATTACHED: " + mask.getDisplayName());
NBTItem nbtItem = new NBTItem(itemBuilder1.colorize().build());
nbtItem.setString("starItem", starItem.getID());
NBTCompound cosmicData = nbtItem.getOrCreateCompound("cosmicData");
cosmicData.setString("maskType", mask.getID());
finalItem = nbtItem.getItem();
}
finalItems.add(finalItem);
}
Player player = tmPlayer.getPlayer();
player.getInventory().addItem(adminWeapon.buildItem());
player.getInventory().setHelmet(finalItems.get(0));
player.getInventory().setChestplate(finalItems.get(1));
player.getInventory().setLeggings(finalItems.get(2));
player.getInventory().setBoots(finalItems.get(3));
player.getInventory().setItem(1, new ItemStack(Material.ENDER_PEARL, 16));
player.getInventory().setItem(2, new SoulGemBuilder(25000).build());
Potion splash = new Potion(PotionType.INSTANT_HEAL, 2);
splash.setSplash(true);
while(InventoryUtils.hasAvailableSlot(player)) {
player.getInventory().addItem(splash.toItemStack(1));
}
ArmorEquipEvent armorEquipEvent1 = new ArmorEquipEvent(player, ArmorEquipEvent.EquipMethod.SHIFT_CLICK, ArmorType.BOOTS, new ItemStack(Material.AIR), finalItems.get(0));
Bukkit.getServer().getPluginManager().callEvent(armorEquipEvent1);
ArmorEquipEvent armorEquipEvent2 = new ArmorEquipEvent(player, ArmorEquipEvent.EquipMethod.SHIFT_CLICK, ArmorType.LEGGINGS, new ItemStack(Material.AIR), finalItems.get(1));
Bukkit.getServer().getPluginManager().callEvent(armorEquipEvent2);
ArmorEquipEvent armorEquipEvent3 = new ArmorEquipEvent(player, ArmorEquipEvent.EquipMethod.SHIFT_CLICK, ArmorType.CHESTPLATE, new ItemStack(Material.AIR), finalItems.get(2));
Bukkit.getServer().getPluginManager().callEvent(armorEquipEvent3);
ArmorEquipEvent armorEquipEvent4 = new ArmorEquipEvent(player, ArmorEquipEvent.EquipMethod.SHIFT_CLICK, ArmorType.HELMET, new ItemStack(Material.AIR), finalItems.get(3));
Bukkit.getServer().getPluginManager().callEvent(armorEquipEvent4);
Bukkit.getServer().getScheduler().runTaskLater(CrankedTournaments.instance, () -> PotionEffectUtils.bless(player), 1L);
}
public void end() {
for (TournamentPlayer tournamentPlayer : getTournamentParticipants()) {
InventoryUtils.clearInventory(tournamentPlayer.getPlayer());
tournamentPlayer.setInTournament(false);
tournamentPlayer.getPlayer().teleport(Bukkit.getWorld("world").getSpawnLocation(), PlayerTeleportEvent.TeleportCause.UNKNOWN);
tournamentPlayer.getPlayer().sendMessage(CC.translate("&c&l(!)&c The tournament has been force ended and you have been teleported to spawn!"));
}
astroTournamentsPlugin.getTournamentManager().getTournamentParticipants().clear();
astroTournamentsPlugin.getTournamentManager().getTournamentMatchList().clear();
astroTournamentsPlugin.getTournamentManager().getPlayerQueue().clear();
astroTournamentsPlugin.getTournamentManager().setActive(false);
astroTournamentsPlugin.getTournamentManager().setJoinable(false);
}
}
@@ -0,0 +1,24 @@
package net.crankedpvp.tournaments.objects;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import net.crankedpvp.tournaments.utils.Pair;
import org.bukkit.Location;
@Getter @AllArgsConstructor @Setter
public class Arena {
private String id;
private Pair<Location, Location> locations;
private Pair<TournamentPlayer, TournamentPlayer> currentlyFighting;
private int currentTimeStamp;
private boolean inUse;
public void reset() {
this.currentlyFighting = new Pair<>(null, null);
this.inUse = false;
this.currentTimeStamp = 0;
}
}
@@ -0,0 +1,14 @@
package net.crankedpvp.tournaments.objects;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
@Getter @Setter @AllArgsConstructor
public class TournamentMatch {
private TournamentPlayer playerOne;
private TournamentPlayer playerTwo;
private Arena arena;
}
@@ -0,0 +1,114 @@
package net.crankedpvp.tournaments.objects;
import lombok.Getter;
import lombok.Setter;
import net.crankedpvp.storageutils.utils.KeyToSave;
import net.crankedpvp.tournaments.CrankedTournaments;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.UUID;
@Getter
@Setter
public class TournamentPlayer implements KeyToSave {
private UUID uuid;
private int kills;
private int deaths;
private int tournamenWins;
private int tournamenLosses;
private boolean inTournament;
private transient final ItemStack helmet;
private transient final ItemStack chestplate;
private transient final ItemStack leggings;
private transient final ItemStack boots;
private transient final ItemStack sword;
public TournamentPlayer(UUID uuid) {
this.uuid = uuid;
this.inTournament = false;
this.helmet = getHelmet();
this.chestplate = getChestplate();
this.leggings = getLeggings();
this.boots = getBoots();
this.sword = getSword();
}
public Player getPlayer() {
return Bukkit.getPlayer(uuid);
}
@Override
public String getKey() {
return uuid.toString();
}
@Override
public void setKey(String s) {
this.uuid = UUID.fromString(s);
}
public void leaveTournament() {
if (inTournament) {
if (CrankedTournaments.instance.getTournamentManager().getPlayerQueue().contains(this)) {
CrankedTournaments.instance.getTournamentManager().getPlayerQueue().removeFromQueue(this);
}
CrankedTournaments.instance.getTournamentManager().getTournamentParticipants().remove(this);
this.inTournament = false;
}
}
public void increaseKills() {
this.kills +=1;
}
public void increaseDeaths() {
this.deaths +=1;
}
public void increaseWins() {
this.tournamenWins +=1;
}
public void increaseLosses() {
this.tournamenLosses +=1;
}
public String getKDR() {
double kdr;
if (deaths == 0) {
kdr = kills;
} else {
kdr = (double) kills / deaths;
}
return String.format("%.1f", kdr);
}
public String getWLRatio() {
double kdr;
if (tournamenWins == 0) {
kdr = tournamenWins;
} else {
kdr = (double) tournamenWins / tournamenLosses;
}
return String.format("%.1f", kdr);
}
}
@@ -0,0 +1,81 @@
package net.crankedpvp.tournaments.tasks;
import net.crankedpvp.tournaments.CrankedTournaments;
import net.crankedpvp.tournaments.utils.Clickable;
import net.crankedpvp.tournaments.utils.Utils;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
public class TournamentStartTask extends BukkitRunnable {
private final CrankedTournaments astroTournamentsPlugin;
private int seconds;
public TournamentStartTask(CrankedTournaments astroTournamentsPlugin) {
this.astroTournamentsPlugin = astroTournamentsPlugin;
if(!astroTournamentsPlugin.getTournamentManager().isActive()) {
return;
}
this.seconds = 121;
this.runTaskTimer(astroTournamentsPlugin, 20L * 2, 20L);
}
@Override
public void run() {
this.seconds--;
if(this.seconds == 0) {
astroTournamentsPlugin.getTournamentManager().setupQueue();
astroTournamentsPlugin.getTournamentManager().setJoinable(false);
Bukkit.broadcastMessage("");
Bukkit.broadcastMessage(Utils.fixColor("&c&lCranked Tournaments &f(1v1 Tournament)"));
Bukkit.broadcastMessage(Utils.fixColor("&7&oThe tournament event is now starting..."));
Bukkit.broadcastMessage(Utils.fixColor("&7&oMay the best Cranker win :D"));
Bukkit.broadcastMessage("");
Bukkit.broadcastMessage(Utils.fixColor("&cTournament entry has now &c&nCLOSED"));
Bukkit.broadcastMessage("");
this.astroTournamentsPlugin.getTournamentManager().putNextPlayersInArenas();
return;
}
if(this.seconds == 120 || this.seconds == 100 || this.seconds == 80 || this.seconds == 60 || this.seconds == 45 || this.seconds == 30 || this.seconds == 15 || this.seconds == 10 || (this.seconds <= 5 && this.seconds > 0)) {
for(Player player : Bukkit.getOnlinePlayers()) {
sendJSONMessage(player);
}
}
}
private String getFormattedTime(int seconds) {
int minutes = seconds/60;
seconds %= 60;
StringBuilder builder = new StringBuilder();
if(minutes > 0) {
builder.append(minutes).append("m, ");
}
if(seconds > 0 || seconds == 0) {
builder.append(seconds).append("s, ");
}
return builder.substring(0, builder.toString().lastIndexOf(","));
}
private void sendJSONMessage(Player player) {
player.sendMessage("");
player.sendMessage(Utils.fixColor("&c&lCranked Tournaments &f(1v1 Tournament)"));
player.sendMessage(Utils.fixColor("&7&oTournaments are special events where players"));
player.sendMessage(Utils.fixColor("&7&ofight eachother until only one player remains"));
player.sendMessage("");
Clickable clickable = new Clickable("&7Click &nhere&r &7to join the tournament", "&7&oClick to join tournament", "/tournament join");
clickable.sendToPlayer(player);
player.sendMessage("");
player.sendMessage(Utils.fixColor("&cTournament entry will close in &f" + getFormattedTime(this.seconds)));
player.sendMessage("");
}
}
@@ -0,0 +1,59 @@
package net.crankedpvp.tournaments.utils;
import net.md_5.bungee.api.chat.*;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList;
import java.util.List;
public class Clickable {
private final List<TextComponent> components = new ArrayList<>();
public Clickable(String msg) {
TextComponent message = new TextComponent(msg);
this.components.add(message);
}
public Clickable(String msg, String hoverMsg) {
this(msg, hoverMsg, "");
}
public Clickable(String msg, String hoverMsg, String clickString) {
add(msg, hoverMsg, clickString);
}
public TextComponent add(String msg, String hoverMsg) {
return add(msg, hoverMsg, "");
}
public TextComponent add(String msg, String hoverMsg, String clickString) {
TextComponent message = new TextComponent(Utils.fixColor(msg));
if (hoverMsg != null && !hoverMsg.isEmpty())
message.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, (new ComponentBuilder(Utils.fixColor(hoverMsg))).create()));
if (clickString != null && !clickString.isEmpty())
message.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, clickString));
this.components.add(message);
return message;
}
public void addItem(String msg, ItemStack itemStack) {
TextComponent message = new TextComponent(Utils.fixColor(msg));
if (itemStack != null && itemStack.getType() != Material.AIR)
message.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_ITEM, new BaseComponent[]{new TextComponent(ItemUtil.convertItemStackToJson(itemStack))}));
this.components.add(message);
}
public void add(String message) {
this.components.add(new TextComponent(Utils.fixColor(message)));
}
public void sendToPlayer(Player player) {
player.spigot().sendMessage(this.asComponents());
}
public TextComponent[] asComponents() {
return this.components.toArray(new TextComponent[0]);
}
}
@@ -0,0 +1,245 @@
package net.crankedpvp.tournaments.utils;
import org.bukkit.Bukkit;
import org.bukkit.Color;
import org.bukkit.DyeColor;
import org.bukkit.Material;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.enchantments.Enchantment;
import org.bukkit.inventory.ItemFlag;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.inventory.meta.LeatherArmorMeta;
import org.bukkit.inventory.meta.SkullMeta;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
public class ItemBuilder {
private ItemMeta itemMeta;
private final ItemStack itemStack;
public ItemBuilder(String material) {
this(Material.valueOf(material));
}
public ItemBuilder(Material material) {
this(material,1);
}
public ItemBuilder(Material material, int amount) {
this(new ItemStack(material, amount));
}
public ItemBuilder(Material material, String name, String... lore) {
this(material, 1, (short) 0, name, lore);
}
public ItemBuilder(Material material, int amount, short durability) {
this(new ItemStack(material, amount, durability));
}
public ItemBuilder(Material material, int amount, short durability, String name, String... lore) {
this(new ItemStack(material, amount, durability));
setName(name);
setLore(lore);
}
public ItemBuilder(ItemBuilder itemBuilder) {
this.itemStack = itemBuilder.itemStack;
this.itemMeta = itemBuilder.itemMeta;
}
public ItemBuilder(ConfigurationSection section) {
this(new ItemBuilder(section.getString("name"))
.setLore(section.getStringList("lore"))
.setDurability((short) section.getInt("damage"))
.setUnbreakable(section.getBoolean("unbreakable"))
);
}
public ItemBuilder(ItemStack itemStack) {
this.itemStack = itemStack;
this.itemMeta = itemStack.getItemMeta();
}
public ItemBuilder clone() {
return new ItemBuilder(itemStack);
}
public ItemBuilder setMaterial(String material) {
itemStack.setType(Material.valueOf(material));
return this;
}
public ItemBuilder setMaterial(Material material) {
itemStack.setType(material);
return this;
}
public ItemBuilder setDurability(short durability) {
itemStack.setDurability(durability);
return this;
}
public ItemBuilder setName(String name) {
itemMeta.setDisplayName(name);
return this;
}
public ItemBuilder addUnsafeEnchantment(Enchantment enchantment, int level) {
itemStack.addUnsafeEnchantment(enchantment, level);
return this;
}
public ItemBuilder removeEnchantment(Enchantment enchantment) {
itemStack.removeEnchantment(enchantment);
return this;
}
public ItemBuilder addEnchantment(Enchantment enchantment, int level) {
itemMeta.addEnchant(enchantment, level,true);
return this;
}
public ItemBuilder addEnchantments(Map<Enchantment, Integer> enchantments) {
itemStack.addEnchantments(enchantments);
return this;
}
public ItemBuilder setGlowing() {
if (itemMeta.hasEnchants()) return this;
itemMeta.addEnchant(Enchantment.DURABILITY,1,true);
return addItemFlag(ItemFlag.HIDE_ENCHANTS);
}
public ItemBuilder colorize() {
colorizeName();
return colorizeLore();
}
public ItemBuilder colorizeLore() {
if (itemMeta.hasLore()) {
List<String> lore = getItemMeta().getLore();
lore.replaceAll(Utils::fixColor);
return setLore(lore);
}
return this;
}
public ItemBuilder colorizeName() {
if (itemMeta.hasDisplayName()) setName(Utils.fixColor(getItemMeta().getDisplayName()));
return this;
}
public ItemBuilder setUnbreakable(boolean unbreakable) {
itemMeta.spigot().setUnbreakable(unbreakable);
return this;
}
public List<String> getLore() {
return itemMeta.getLore();
}
public ItemBuilder setLore(String... lore) {
return setLore(Arrays.asList(lore));
}
public ItemBuilder setLore(List<String> lore) {
itemMeta.setLore(lore);
return this;
}
public ItemBuilder removeLoreLine(String line) {
List<String> lore = new ArrayList<>(itemMeta.getLore());
lore.remove(line);
itemMeta.setLore(lore);
return this;
}
public ItemBuilder removeLoreLine(int index) {
if (index < 0) return this;
List<String> lore = new ArrayList<>(itemMeta.getLore());
if (index > lore.size()) return this;
lore.remove(index);
itemMeta.setLore(lore);
return this;
}
public ItemBuilder addLoreLine(String line) {
List<String> lore = new ArrayList<>();
if(itemMeta.hasLore()) lore = new ArrayList<>(itemMeta.getLore());
lore.add(line);
itemMeta.setLore(lore);
return this;
}
public ItemBuilder addLoreLine(String line, int pos) {
List<String> lore = new ArrayList<>(itemMeta.getLore());
if (pos >= lore.size()) return this;
lore.set(pos, line);
itemMeta.setLore(lore);
return this;
}
public ItemBuilder addItemFlags(List<String> itemFlags) {
for (String itemFlagStr : itemFlags) {
try {
ItemFlag itemFlag = ItemFlag.valueOf(itemFlagStr);
addItemFlag(itemFlag);
} catch (IllegalArgumentException ignored) {}
}
return this;
}
public ItemBuilder setItemFlags(List<ItemFlag> itemFlags) {
itemMeta.addItemFlags(itemFlags.toArray(new ItemFlag[0]));
return this;
}
public ItemBuilder addItemFlag(ItemFlag itemFlag) {
itemMeta.addItemFlags(itemFlag);
return this;
}
@SuppressWarnings("deprecation")
public ItemBuilder setColor(DyeColor color) {
itemStack.setDurability(color.getData());
return this;
}
public ItemBuilder setLeatherArmorColor(Color color) {
LeatherArmorMeta leatherArmorMeta = (LeatherArmorMeta) itemMeta;
if (Bukkit.getItemFactory().isApplicable(leatherArmorMeta, itemStack)) {
leatherArmorMeta.setColor(color);
itemMeta = leatherArmorMeta;
}
return this;
}
public ItemBuilder setSkullOwner(String owner) {
SkullMeta skullMeta = (SkullMeta) itemMeta;
if (Bukkit.getItemFactory().isApplicable(skullMeta, itemStack)) {
skullMeta.setOwner(owner);
itemMeta = skullMeta;
}
return this;
}
public ItemMeta getItemMeta() {
return itemMeta;
}
public ItemStack build() {
itemStack.setItemMeta(itemMeta);
return itemStack;
}
}
@@ -0,0 +1,42 @@
package net.crankedpvp.tournaments.utils;
import org.apache.commons.lang.WordUtils;
import org.bukkit.inventory.ItemStack;
import java.lang.reflect.Method;
import java.util.List;
public class ItemUtil {
private static final Class<?> CraftItemStackClass = NMSUtil.getCraftClass("inventory.CraftItemStack");
private static final Class<?> ItemStackClass = NMSUtil.getNMSClass("ItemStack");
private static final Class<?> NBTTagCompoundClass = NMSUtil.getNMSClass("NBTTagCompound");
public static String getItemName(ItemStack is){
try {
Object NMSItemStack = CraftItemStackClass.getMethod("asNMSCopy", new Class[]{ItemStack.class}).invoke(null, is);
return (String) NMSItemStack.getClass().getMethod("getName", new Class[0]).invoke(NMSItemStack, new Object[0]);
} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | java.lang.reflect.InvocationTargetException e){
e.printStackTrace();
return WordUtils.capitalize(is.getType().name().replace("_", " ").toLowerCase());
}
}
public static String convertItemStackToJson(ItemStack itemStack){
try {
assert CraftItemStackClass != null;
Method asNMSCopyMethod = CraftItemStackClass.getMethod("asNMSCopy", ItemStack.class);
Method saveMethod = ItemStackClass.getMethod("save", NBTTagCompoundClass);
assert NBTTagCompoundClass != null;
Object NBTTagCompound = NBTTagCompoundClass.newInstance();
Object NMSItemStack = asNMSCopyMethod.invoke(null, itemStack);
Object Json = saveMethod.invoke(NMSItemStack, NBTTagCompound);
return Json.toString();
} catch (IllegalAccessException | IllegalArgumentException | java.lang.reflect.InvocationTargetException | NoSuchMethodException | SecurityException | InstantiationException e){
e.printStackTrace();
return null;
}
}
}
@@ -0,0 +1,95 @@
package net.crankedpvp.tournaments.utils;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.lang.reflect.Field;
public class NMSUtil {
public static String getVersion(){
String name = Bukkit.getServer().getClass().getPackage().getName();
return name.substring(name.lastIndexOf('.') + 1) + ".";
}
public static int getVersionNumber(){
String name = getVersion().substring(3);
return Integer.parseInt(name.substring(0, name.length() - 4));
}
public static int getVersionReleaseNumber(){
String NMSVersion = getVersion();
return Integer.parseInt(NMSVersion.substring(NMSVersion.length() - 2).replace(".", ""));
}
public static Class<?> getNMSClass(String className){
try {
String fullName = "net.minecraft.server." + getVersion() + className;
Class<?> clazz = Class.forName(fullName);
return clazz;
} catch (Exception e){
e.printStackTrace();
return null;
}
}
public static Class<?> getCraftClass(String className){
try {
String fullName = "org.bukkit.craftbukkit." + getVersion() + className;
Class<?> clazz = Class.forName(fullName);
return clazz;
} catch (Exception e){
e.printStackTrace();
return null;
}
}
public static Field getField(Class<?> clazz, String name, boolean declared){
try {
Field field;
if(declared) {
field = clazz.getDeclaredField(name);
} else{
field = clazz.getField(name);
}
field.setAccessible(true);
return field;
} catch (Exception e){
e.printStackTrace();
return null;
}
}
public static Object getFieldObject(Object object, Field field){
try {
return field.get(object);
} catch (Exception e){
e.printStackTrace();
return null;
}
}
public static void setField(Object object, String fieldName, Object fieldValue, boolean declared){
try {
Field field;
if(declared) {
field = object.getClass().getDeclaredField(fieldName);
} else{
field = object.getClass().getField(fieldName);
}
field.setAccessible(true);
field.set(object, fieldValue);
} catch (Exception e){
e.printStackTrace();
}
}
public static void sendPacket(Player player, Object packet){
try {
Object handle = player.getClass().getMethod("getHandle", new Class[0]).invoke(player);
Object playerConnection = handle.getClass().getField("playerConnection").get(handle);
playerConnection.getClass().getMethod("sendPacket", new Class[]{getNMSClass("Packet")}).invoke(playerConnection, packet);
} catch (Exception e){
e.printStackTrace();
}
}
}
@@ -0,0 +1,23 @@
package net.crankedpvp.tournaments.utils;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
@AllArgsConstructor
public class Pair<L, R> {
private L left;
private R right;
public boolean contains(L value) {
return left.equals(value) || right.equals(value);
}
public void clear() {
this.setLeft(null);
this.setRight(null);
}
}
@@ -0,0 +1,49 @@
package net.crankedpvp.tournaments.utils;
import java.util.LinkedList;
public class Queue<E> {
private final LinkedList<E> list = new LinkedList<E>();
public void enqueue(E item) {
list.addLast(item);
}
public E dequeue() {
return list.poll();
}
public boolean hasItems() {
return !list.isEmpty();
}
public int size() {
return list.size();
}
public void addItems(Queue<? extends E> q) {
while (q.hasItems()) list.addLast(q.dequeue());
}
public void removeFromQueue(E item) {
list.remove(item);
}
public boolean contains(E item) {
return list.contains(item);
}
public int getPosition(E item) {
for (int i = 0; i < this.size(); i++) {
if (list.get(i) == item) {
return i;
}
}
return -1;
}
public void clear() {
list.clear();
}
}
@@ -0,0 +1,86 @@
package net.crankedpvp.tournaments.utils;
import net.crankedpvp.crankedenchants.CrankedEnchantsAPI;
import net.crankedpvp.crankedutils.CrankedUtils;
import net.crankedpvp.crankedutils.utils.CC;
import net.crankedpvp.crankedutils.utils.PotionEffectUtils;
import net.crankedpvp.tournaments.CrankedTournaments;
import org.bukkit.*;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.SkullMeta;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Utils {
public static String fixColor(String string) {
return ChatColor.translateAlternateColorCodes('&', string);
}
public static String locationToString(Location location) {
return location.getWorld().getName() + "," + location.getX() + "," + location.getY() + "," + location.getZ() + "," + location.getYaw() + "," + location.getPitch();
}
public static Location getLocationFromString(String string) {
String[] arg = string.split(",");
double[] parsed = new double[5];
for (int a = 0; a < 5; a++) {
parsed[a] = Double.parseDouble(arg[a + 1]);
}
return new Location(Bukkit.getWorld(arg[0]), parsed[0], parsed[1], parsed[2], (float) parsed[3], (float) parsed[4]);
}
public static String getProperCase(String text) {
StringBuilder sb = new StringBuilder(text.length());
char[] charArray = text.toLowerCase().toCharArray();
charArray[0] = Character.toUpperCase(charArray[0]);
sb.append(new String(charArray));
return sb.toString().trim();
}
public static ItemStack createPlayerSkull(String owner, String name, List<String> lore) {
ItemStack item = new ItemStack(Material.SKULL_ITEM, 1, (short) 3);
SkullMeta meta = (SkullMeta) item.getItemMeta();
meta.setOwner(owner);
meta.setDisplayName(CC.translate(name));
meta.setLore(color(lore));
item.setItemMeta(meta);
return item;
}
public static List<String> color(List<String> messages) {
return messages.stream().map(CC::translate).collect(Collectors.toList());
}
public static boolean isEmptyInventory(Player player) {
return Stream.of(player.getInventory().getContents()).allMatch(itemStack -> itemStack == null || itemStack.getType() == Material.AIR) &&
Stream.of(player.getInventory().getArmorContents()).allMatch(itemStack -> itemStack == null || itemStack.getType() == Material.AIR);
}
public static boolean hasAvaliableSlot(Player player, int amount) {
int amountOpen = 0;
Inventory inv = player.getInventory();
for (ItemStack item : inv.getContents()) {
if (item == null) {
amountOpen += 1;
}
}
return amountOpen >= amount;
}
public static void playSound(Player player, Sound sound) {
player.playSound(player.getLocation(), sound, 2.0F, 2.0F);
}
public static double round(double value, int precision) {
int scale = (int) Math.pow(10, precision);
return (double) Math.round(value * scale) / scale;
}
}
@@ -0,0 +1,7 @@
name: CrankedTournaments
main: net.crankedpvp.tournaments.CrankedTournaments
version: ${git.total.commit.count}.0
description: "§fCommit ID: §a${git.commit.id.abbrev}"
website: https://crankedpvp.net/
depend: [ WorldGuard, CrankedUtils ]
softdepend: [ Essentials, Factions, Vault, ProtocolLib ]