Jakob/RandomizedMinigames
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Split GUI-events into handlers

Browse Source 
Rewritten personal Settings handling
Simplified GUI-implementation
Further worked on Teams
This commit is contained in:
Jakob Hansen 2025-04-21 21:27:18 +02:00
parent 1f1738eabd
commit b2ef6e4246
19 changed files with 273 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/main/java/de/ventority/randomizedminigames/GUI/BaseWindow.java
View File

@ -17,13 +17,11 @@ import java.util.Objects;
public abstract class BaseWindow {
protected final Player p;
protected final Inventory gui;
protected String status;
public BaseWindow(Player p, String status) {
public BaseWindow(Player p) {
this.p = p;
gui = Bukkit.createInventory(p, 54, RandomizedMinigames.serverSettingsHandler.getServerName()
+ ChatColor.RESET + ChatColor.DARK_GRAY);
this.status = status;
}
protected void fillBorder() {
@ -95,7 +93,4 @@ public abstract class BaseWindow {
return p;
}
private String getStatus() {
return status;
}
}

96
src/main/java/de/ventority/randomizedminigames/GUI/GUIClickEvent.java
View File

@ -1,18 +1,11 @@
package de.ventority.randomizedminigames.GUI;
import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigameSetup;
import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigamesDisplayWindow;
import de.ventority.randomizedminigames.GUI.MinigameSetups.PlayerSelection;
import de.ventority.randomizedminigames.GUI.MinigameSetups.SetLimit;
import de.ventority.randomizedminigames.SelectMinigame;
import de.ventority.randomizedminigames.misc.DataInputHandler;
import de.ventority.randomizedminigames.misc.MinigameHandler;
import de.ventority.randomizedminigames.Minigames.Minigame;
import de.ventority.randomizedminigames.GUI.handlers.MinigameSelectHandler;
import de.ventority.randomizedminigames.GUI.handlers.MinigameSetupHandler;
import de.ventority.randomizedminigames.GUI.handlers.SettingsHandler;
import de.ventority.randomizedminigames.RandomizedMinigames;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.NamespacedKey;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent;
@ -31,16 +24,12 @@ public class GUIClickEvent implements Listener {
if (inventory.getItem(0) == null) return;
if (isMinigamePlugin(inventory.getItem(0))) {
event.setCancelled(true);
if (getNBT(event.getCurrentItem(), "Action").equals("none"))
return;
if (getNBT(event.getCurrentItem(), "Type").equals("MinigameSelect")) {
handleMinigame(event, getNBT(event.getCurrentItem(), "Action"));
}
if (getNBT(event.getCurrentItem(), "Type").equals("Misc")) {
handleSettings(event, getNBT(event.getCurrentItem(), "Action"));
}
if (getNBT(event.getCurrentItem(), "Type").equals("MinigameSetup")) {
handleMinigameSetup(event, getNBT(event.getCurrentItem(), "Action"));
if (event.getCurrentItem().getType() == (Material.BLACK_STAINED_GLASS_PANE)) return;
switch (getNBT(event.getCurrentItem(), "Type")) {
case "none": return;
case "MinigameSelect": new MinigameSelectHandler(event, getNBT(event.getCurrentItem(), "Action")).handle();
case "MinigameSetup": new MinigameSetupHandler(event, getNBT(event.getCurrentItem(), "Action")).handle();
case "Misc": new SettingsHandler(event, getNBT(event.getCurrentItem(), "Action")).handle();
}
}
}
@ -57,71 +46,4 @@ public class GUIClickEvent implements Listener {
private boolean isMinigamePlugin(ItemStack item) {
return getNBT(item, "ItemMiniGame") != null && getNBT(item, "ItemMiniGame").equals("true");
}
private void handleMinigame(InventoryClickEvent event, String action) {
event.getWhoClicked().closeInventory();
if (action.equals("openMinigameSetup")) {
RandomizedMinigames.dataInputHandler.setSelectedMinigame((Player) event.getWhoClicked(), Integer.parseInt(getNBT(event.getCurrentItem(), "selectedMinigame")));
new MinigameSetup((Player) event.getWhoClicked(), action).buildWindow();
}
if (action.equals("homeMenu")) {
new MinigameSetup((Player) event.getWhoClicked(), action).buildWindow();
}
}
private void handleSettings(InventoryClickEvent event, String action) {
event.getWhoClicked().closeInventory();
if (action.equals("selectSettings")) {
new SettingsWindow((Player)event.getWhoClicked(), "Settings");
}
}
private void handleMinigameSetup(InventoryClickEvent event, String action) {
if (action.equals("homeMenu")) {
event.getWhoClicked().closeInventory();
new MinigameSetup((Player) event.getWhoClicked(), "Minigame").buildWindow();
}
DataInputHandler data = RandomizedMinigames.dataInputHandler;
if (action.equals("clickedPlayer")) {
Player toWork = Bukkit.getPlayer(getNBT(event.getCurrentItem(), "Player"));
if (data.getSelectedPlayers((Player) event.getWhoClicked()).contains(toWork)) {
data.removePlayersFromSelection((Player) event.getWhoClicked(), toWork);
} else {
data.addPlayersToSelection((Player) event.getWhoClicked(), toWork);
}
new PlayerSelection((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
}
if (action.equals("subFromLimit")) {
data.subFromSelectedLimit((Player) event.getWhoClicked());
new SetLimit((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
}
if (action.equals("addToLimit")) {
data.addToSelectedLimit((Player) event.getWhoClicked());
new SetLimit((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
}
if (action.equals("startPlayerSelection")) {
event.getWhoClicked().closeInventory();
new PlayerSelection((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
}
if (action.equals("startLimitSelection")) {
event.getWhoClicked().closeInventory();
new SetLimit((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
}
if (action.equals("switchScoreboard")) {
data.switchScoreboard();
new MinigameSetup((Player) event.getWhoClicked(), "Minigame").buildWindow();
}
if (action.equals("startGame")) {
event.getWhoClicked().closeInventory();
MinigameHandler.createMinigame(RandomizedMinigames.dataInputHandler.getSelectedMinigame((Player) event.getWhoClicked()), (Player) event.getWhoClicked());
}
}
}

17
src/main/java/de/ventority/randomizedminigames/GUI/MinigameSetups/MinigameSetup.java
View File

@ -1,8 +1,8 @@
package de.ventority.randomizedminigames.GUI.MinigameSetups;
import de.ventority.randomizedminigames.GUI.BaseWindow;
import de.ventority.randomizedminigames.RandomizedMinigames;
import de.ventority.randomizedminigames.misc.DataInputHandler;
import de.ventority.randomizedminigames.misc.MinigameHandler;
import de.ventority.randomizedminigames.misc.Settings;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
@ -10,38 +10,35 @@ import org.bukkit.inventory.ItemStack;
public class MinigameSetup extends BaseWindow {
public MinigameSetup(Player p, String status) {
super(p, status);
public MinigameSetup(Player p) {
super(p);
}
@Override
protected void fillGUI() {
System.out.println("Hallo");
ItemStack playerSelect = new ItemStack(Material.PLAYER_HEAD);
addNBT(playerSelect, "Type", "MinigameSetup");
addNBT(playerSelect, "Action", "startPlayerSelection");
addNBT(playerSelect, "selectedMinigame", status);
setItemName(playerSelect, "Select Players");
addItemToGUI(playerSelect);
ItemStack setLimit = new ItemStack(Material.BOOK);
addNBT(setLimit, "Type", "MinigameSetup");
addNBT(setLimit, "Action", "startLimitSelection");
addNBT(setLimit, "selectedMinigame", status);
setItemName(setLimit, "Set win limit");
addItemToGUI(setLimit);
DataInputHandler data = RandomizedMinigames.dataInputHandler;
Settings playerSettings = MinigameHandler.getSettings(p);
ItemStack scoreboard = new ItemStack(Material.EMERALD);
addNBT(scoreboard, "Type", "MinigameSetup");
addNBT(scoreboard, "Action", "switchScoreboard");
addNBT(scoreboard, "selectedMinigame", status);
setItemName(scoreboard, "Scoreboard: " + (data.getScoreboardStatus() ? (ChatColor.GREEN + "On") : ChatColor.RED + "Off"));
setItemName(scoreboard, "Scoreboard: " + (playerSettings.getScoreboardStatus() ? (ChatColor.GREEN + "On") : ChatColor.RED + "Off"));
addItemToGUI(scoreboard);
ItemStack start = new ItemStack(Material.GREEN_DYE);
addNBT(start, "Type", "MinigameSetup");
addNBT(start, "Action", "startGame");
addNBT(start, "selectedMinigame", status);
setItemName(start, "Start");
addItemToGUI(50, start);

4
src/main/java/de/ventority/randomizedminigames/GUI/MinigameSetups/MinigamesDisplayWindow.java
View File

@ -9,8 +9,8 @@ import org.bukkit.inventory.meta.ItemMeta;
public class MinigamesDisplayWindow extends BaseWindow {
public MinigamesDisplayWindow(Player p, String status) {
super(p, status);
public MinigamesDisplayWindow(Player p) {
super(p);
}
@Override

13
src/main/java/de/ventority/randomizedminigames/GUI/MinigameSetups/PlayerSelection.java
View File

@ -11,18 +11,17 @@ import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.SkullMeta;
public class PlayerSelection extends BaseWindow {
public PlayerSelection(Player p, String status) {
super(p, status);
public PlayerSelection(Player p) {
super(p);
}
@Override
protected void fillGUI() {
for (Player player : Bukkit.getOnlinePlayers()) {
if (!MinigameHandler.getOccupiedPlayers().contains(player)) {
ItemStack item = getPlayerHead(player, RandomizedMinigames.dataInputHandler.getSelectedPlayers(p).contains(player));
ItemStack item = getPlayerHead(player);
addNBT(item, "Type", "MinigameSetup");
addNBT(item, "Action", "clickedPlayer");
addNBT(item, "selectedMinigame", status);
addNBT(item, "Player", player.getDisplayName());
addItemToGUI(item);
}
@ -31,17 +30,17 @@ public class PlayerSelection extends BaseWindow {
ItemStack back = new ItemStack(Material.ARROW);
addNBT(back, "Type", "MinigameSetup");
addNBT(back, "Action", "homeMenu");
addNBT(back, "selectedMinigame", status);
setItemName(back, "Back");
addItemToGUI(49, back);
}
private ItemStack getPlayerHead(Player player, boolean selected) {
private ItemStack getPlayerHead(Player player) {
ItemStack head = new ItemStack(Material.PLAYER_HEAD);
SkullMeta meta = (SkullMeta) head.getItemMeta();
if (meta != null) {
meta.setOwningPlayer(player);
meta.setDisplayName((selected ? ChatColor.GREEN : ChatColor.RED) + player.getName());
meta.setDisplayName((MinigameHandler.getSettings(player).getSelectedPlayers().contains(player) ?
ChatColor.GREEN : ChatColor.RED) + player.getName());
head.setItemMeta(meta);
}
return head;

11
src/main/java/de/ventority/randomizedminigames/GUI/MinigameSetups/SetLimit.java
View File

@ -2,13 +2,14 @@ package de.ventority.randomizedminigames.GUI.MinigameSetups;
import de.ventority.randomizedminigames.GUI.BaseWindow;
import de.ventority.randomizedminigames.RandomizedMinigames;
import de.ventority.randomizedminigames.misc.MinigameHandler;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class SetLimit extends BaseWindow {
public SetLimit(Player p, String status) {
super(p, status);
public SetLimit(Player p) {
super(p);
}
@Override
@ -16,28 +17,24 @@ public class SetLimit extends BaseWindow {
ItemStack add = new ItemStack(Material.RED_DYE);
addNBT(add, "Type", "MinigameSetup");
addNBT(add, "Action", "addToLimit");
addNBT(add, "selectedMinigame", status);
setItemName(add, "Add");
addItemToGUI(14, add);
ItemStack sub = new ItemStack(Material.GREEN_DYE);
addNBT(sub, "Type", "MinigameSetup");
addNBT(sub, "Action", "subFromLimit");
addNBT(sub, "selectedMinigame", status);
setItemName(sub, "Sub");
addItemToGUI(12, sub);
ItemStack display = new ItemStack(Material.PAPER);
addNBT(display, "Type", "MinigameSetup");
addNBT(display, "Action", "none");
addNBT(display, "selectedMinigame", status);
setItemName(display, RandomizedMinigames.dataInputHandler.getSelectedLimit(p).toString());
setItemName(display, "" + MinigameHandler.getSettings(p).getSelectedLimit());
addItemToGUI(13, display);
ItemStack back = new ItemStack(Material.ARROW);
addNBT(back, "Type", "MinigameSetup");
addNBT(back, "Action", "homeMenu");
addNBT(back, "selectedMinigame", status);
setItemName(back, "Back");
addItemToGUI(49, back);
}

4
src/main/java/de/ventority/randomizedminigames/GUI/MinigameSetups/TeamOverview.java
View File

@ -5,8 +5,8 @@ import org.bukkit.entity.Player;
public class TeamOverview extends BaseWindow {
public TeamOverview(Player p, String status) {
super(p, status);
public TeamOverview(Player p) {
super(p);
}
@Override

4
src/main/java/de/ventority/randomizedminigames/GUI/SettingsWindow.java
View File

@ -6,8 +6,8 @@ import org.bukkit.inventory.ItemStack;
public class SettingsWindow extends BaseWindow{
public SettingsWindow(Player p, String status) {
super(p, status);
public SettingsWindow(Player p) {
super(p);
}
@Override

30
src/main/java/de/ventority/randomizedminigames/GUI/handlers/GUIHandler.java Normal file
View File

@ -0,0 +1,30 @@
package de.ventority.randomizedminigames.GUI.handlers;
import de.ventority.randomizedminigames.RandomizedMinigames;
import org.bukkit.NamespacedKey;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.persistence.PersistentDataContainer;
import org.bukkit.persistence.PersistentDataType;
public abstract class GUIHandler {
protected final InventoryClickEvent event;
protected final String action;
public GUIHandler(InventoryClickEvent event, String action) {
this.event = event;
this.action = action;
}
public abstract void handle();
protected String getNBT(ItemStack item, String key) {
if (item == null) return "ItemIsNull";
ItemMeta meta = item.getItemMeta();
NamespacedKey nsKey = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), key);
if (meta == null) return "NoItemMeta";
PersistentDataContainer data = meta.getPersistentDataContainer();
return data.get(nsKey, PersistentDataType.STRING);
}
}

26
src/main/java/de/ventority/randomizedminigames/GUI/handlers/MinigameSelectHandler.java Normal file
View File

@ -0,0 +1,26 @@
package de.ventority.randomizedminigames.GUI.handlers;
import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigameSetup;
import de.ventority.randomizedminigames.RandomizedMinigames;
import de.ventority.randomizedminigames.misc.MinigameHandler;
import de.ventority.randomizedminigames.misc.Settings;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
public class MinigameSelectHandler extends GUIHandler{
public MinigameSelectHandler(InventoryClickEvent event, String action) {
super(event, action);
}
@Override
public void handle() {
Settings settings = MinigameHandler.getSettings((Player) event.getWhoClicked());
if (action.equals("openMinigameSetup")) {
settings.selectMinigame(Integer.parseInt(getNBT(event.getCurrentItem(), "selectedMinigame")));
new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
}
if (action.equals("homeMenu")) {
new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
}
}
}

62
src/main/java/de/ventority/randomizedminigames/GUI/handlers/MinigameSetupHandler.java Normal file
View File

@ -0,0 +1,62 @@
package de.ventority.randomizedminigames.GUI.handlers;
import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigameSetup;
import de.ventority.randomizedminigames.GUI.MinigameSetups.PlayerSelection;
import de.ventority.randomizedminigames.GUI.MinigameSetups.SetLimit;
import de.ventority.randomizedminigames.misc.MinigameHandler;
import de.ventority.randomizedminigames.misc.Settings;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
public class MinigameSetupHandler extends GUIHandler {
public MinigameSetupHandler(InventoryClickEvent event, String action) {
super(event, action);
}
@Override
public void handle() {
if (action.equals("homeMenu")) {
new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
}
Settings playerSettings = MinigameHandler.getSettings(((Player) event.getWhoClicked()).getPlayer());
if (action.equals("clickedPlayer")) {
Player toWork = Bukkit.getPlayer(getNBT(event.getCurrentItem(), "Player"));
if (playerSettings.getSelectedPlayers().contains(toWork)) {
playerSettings.removePlayersFromSelection(toWork);
} else {
playerSettings.addPlayersToSelection(toWork);
}
new PlayerSelection((Player)event.getWhoClicked()).buildWindow();
}
if (action.equals("subFromLimit")) {
playerSettings.subFromSelectedLimit();
new SetLimit((Player)event.getWhoClicked()).buildWindow();
}
if (action.equals("addToLimit")) {
playerSettings.addToSelectedLimit();
new SetLimit((Player)event.getWhoClicked()).buildWindow();
}
if (action.equals("startPlayerSelection")) {
new PlayerSelection((Player)event.getWhoClicked()).buildWindow();
}
if (action.equals("startLimitSelection")) {
new SetLimit((Player)event.getWhoClicked()).buildWindow();
}
if (action.equals("switchScoreboard")) {
playerSettings.switchScoreboard();
new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
}
if (action.equals("startGame")) {
MinigameHandler.createMinigame(playerSettings.getSelectedMinigame(), (Player) event.getWhoClicked());
}
}
}

18
src/main/java/de/ventority/randomizedminigames/GUI/handlers/SettingsHandler.java Normal file
View File

@ -0,0 +1,18 @@
package de.ventority.randomizedminigames.GUI.handlers;
import de.ventority.randomizedminigames.GUI.SettingsWindow;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
public class SettingsHandler extends GUIHandler {
public SettingsHandler(InventoryClickEvent event, String action) {
super(event, action);
}
@Override
public void handle() {
if (action.equals("selectSettings")) {
new SettingsWindow((Player)event.getWhoClicked());
}
}
}

46
src/main/java/de/ventority/randomizedminigames/Minigames/ForceItemBattle.java
View File

@ -1,9 +1,9 @@
package de.ventority.randomizedminigames.Minigames;
import de.ventority.randomizedminigames.GUI.InGame.GamesScoreboardManager;
import de.ventority.randomizedminigames.RandomizedMinigames;
import de.ventority.randomizedminigames.misc.MinigameHandler;
import de.ventority.randomizedminigames.misc.PlayerBackup;
import de.ventority.randomizedminigames.misc.Settings;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.GameMode;
@ -20,11 +20,7 @@ import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
import java.util.*;
public class ForceItemBattle implements MinigameBase, Listener {
protected final HashMap<Player, ItemStack> currentItems;
@ -35,7 +31,8 @@ public class ForceItemBattle implements MinigameBase, Listener {
protected final List<Player> contestants;
private final HashMap<Player, PlayerBackup> backups;
private final Player owner;
protected final int limit;
protected Settings settings;
private final List<Material> SURVIVAL_ITEMS = Arrays.stream(Material.values())
.filter(Material::isItem)
.filter(m -> {
@ -62,7 +59,8 @@ public class ForceItemBattle implements MinigameBase, Listener {
public ForceItemBattle(List<Player> players, Player owner) {
limit = RandomizedMinigames.dataInputHandler.getSelectedLimit(owner);
settings = MinigameHandler.getSettings(owner);
id = new Random().nextInt(1024);
currentItems = new HashMap<>();
currentScores = new HashMap<>();
@ -70,19 +68,23 @@ public class ForceItemBattle implements MinigameBase, Listener {
backups = new HashMap<>();
contestants = players;
this.owner = owner;
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
if (MinigameHandler.getSettings(owner).getScoreboardStatus())
scoreboardManager = new GamesScoreboardManager(players, getName());
for (Player player : players) {
currentItems.put(player, null);
currentScores.put(player, 0);
BossBar bar = Bukkit.createBossBar("Hallo", BarColor.PURPLE, BarStyle.SOLID);
BossBar bar = Bukkit.createBossBar("Null", BarColor.PURPLE, BarStyle.SOLID);
bar.addPlayer(player);
bar.setVisible(true);
itemDisplays.put(player, bar);
updatePlayerItem(player, getRandomItem());
backups.put(player, new PlayerBackup(player.getInventory().getContents(), player.getInventory().getArmorContents(), player.getExp(), player.getLocation()));
ItemStack skip = new ItemStack(Material.BARRIER, 3);
ItemMeta meta = skip.getItemMeta();
assert meta != null;
meta.setDisplayName(ChatColor.RED + "Skip");
skip.setItemMeta(meta);
player.getInventory().addItem(skip);
@ -117,7 +119,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
if (i == null) return;
if (currentItems.get(p).getType() == i.getType()) {
currentScores.replace(p, currentScores.get(p) + 1);
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
if (settings.getScoreboardStatus())
scoreboardManager.setPunkte(p.getName(), scoreboardManager.getPunkte(p.getName()) + 1);
if (checkWin(p)) {
stopGame(p);
@ -140,7 +142,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
}
protected boolean checkWin(Player p) {
return currentScores.get(p) == limit;
return currentScores.get(p) == settings.getSelectedLimit();
}
protected void showEndMessage(Player winner) {
@ -151,8 +153,8 @@ public class ForceItemBattle implements MinigameBase, Listener {
player.sendTitle(winner.getDisplayName() + " won!", "Resetting players...", 10, 70, 20);
//restorePlayer(player);
}
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
if (settings.getScoreboardStatus())
player.setScoreboard(Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard());
}
}
@ -163,35 +165,35 @@ public class ForceItemBattle implements MinigameBase, Listener {
itemDisplays.get(p).removePlayer(p);
}
itemDisplays.clear();
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus()) {
if (settings.getScoreboardStatus()) {
scoreboardManager.removeScoreboard();
scoreboardManager = null;
}
RandomizedMinigames.dataInputHandler.removeSelectionEntry(owner);
MinigameHandler.resetSettings(owner);
MinigameHandler.deleteGame(this);
}
private void removePlayer(Player p) {
itemDisplays.get(p).setVisible(false);
itemDisplays.get(p).removePlayer(p);
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
p.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
if (settings.getScoreboardStatus())
p.setScoreboard(Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard());
if (contestants.isEmpty())
stopGame(owner);
}
public void killGame() {
for (Player player : contestants) {
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
if (settings.getScoreboardStatus())
player.setScoreboard(Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard());
}
itemDisplays.clear();
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus()) {
if (settings.getScoreboardStatus()) {
scoreboardManager.removeScoreboard();
scoreboardManager = null;
}
RandomizedMinigames.dataInputHandler.removeSelectionEntry(owner);
MinigameHandler.resetSettings(owner);
MinigameHandler.deleteGame(this);
}

5
src/main/java/de/ventority/randomizedminigames/RandomizedMinigames.java
View File

@ -2,9 +2,7 @@ package de.ventority.randomizedminigames;
import de.ventority.randomizedminigames.GUI.GUIClickEvent;
import de.ventority.randomizedminigames.Minigames.ForceItemBattle;
import de.ventority.randomizedminigames.Minigames.Minigame;
import de.ventority.randomizedminigames.Minigames.MinigameBase;
import de.ventority.randomizedminigames.misc.DataInputHandler;
import de.ventority.randomizedminigames.misc.MinigameHandler;
import org.bukkit.*;
import org.bukkit.entity.Player;
@ -17,14 +15,13 @@ import org.bukkit.plugin.java.JavaPlugin;
public final class RandomizedMinigames extends JavaPlugin implements Listener {
public static final ServerSettingsHandler serverSettingsHandler = new ServerSettingsHandler();
public static DataInputHandler dataInputHandler = new DataInputHandler();
@Override
public void onEnable() {
init();
getServer().getPluginManager().registerEvents(new GUIClickEvent(), this);
getServer().getPluginManager().registerEvents(this, this);
this.getCommand("minigames").setExecutor(new SelectMinigame());
this.getCommand("minigames").setExecutor(new executeMinigame());
for (World world : Bukkit.getWorlds()) {
world.setGameRule(GameRule.ANNOUNCE_ADVANCEMENTS, false);
}

8
src/main/java/de/ventority/randomizedminigames/SelectMinigame.java → src/main/java/de/ventority/randomizedminigames/executeMinigame.java
View File

@ -5,7 +5,7 @@ import de.ventority.randomizedminigames.misc.MinigameHandler;
import org.bukkit.command.*;
import org.bukkit.entity.Player;
public class SelectMinigame implements CommandExecutor {
public class executeMinigame implements CommandExecutor {
@Override
public boolean onCommand(CommandSender commandSender, Command command, String s, String[] args) {
if (!(commandSender instanceof Player)) {
@ -20,11 +20,11 @@ public class SelectMinigame implements CommandExecutor {
return true;
}
if (MinigameHandler.getOccupiedPlayers().contains(player)) {
if (MinigameHandler.getOccupiedPlayers().contains(player))
return true;
}
new MinigamesDisplayWindow(player, "MinigameSelect").buildWindow();
MinigameHandler.resetSettings(player);
new MinigamesDisplayWindow(player).buildWindow();
return true;
}

69
src/main/java/de/ventority/randomizedminigames/misc/DataInputHandler.java
View File

@ -1,69 +0,0 @@
package de.ventority.randomizedminigames.misc;
import de.ventority.randomizedminigames.Minigames.Team;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class DataInputHandler {
private final HashMap<Player, List<Player>> selectedPlayers = new HashMap<>();
private final HashMap<Player, Integer> selectedMinigame = new HashMap<>();
private final HashMap<Player, Integer> selectedLimit = new HashMap<>();
private final HashMap<Player, List<Team>> teams = new HashMap<>();
private boolean showScoreboard = true;
public void switchScoreboard() {
showScoreboard = !showScoreboard;
}
public boolean getScoreboardStatus() {
return showScoreboard;
}
public List<Player> getSelectedPlayers(Player p) {
if (!selectedPlayers.containsKey(p)) {
selectedPlayers.put(p, new ArrayList<>());
selectedPlayers.get(p).add(p);
}
return selectedPlayers.get(p);
}
public void addPlayersToSelection(Player owner, Player toAdd) {
selectedPlayers.get(owner).add(toAdd);
}
public void removePlayersFromSelection(Player owner, Player toRemove) {
selectedPlayers.get(owner).remove(toRemove);
}
public void removeSelectionEntry(Player player) {
selectedPlayers.remove(player);
}
public int getSelectedMinigame(Player player) {
return selectedMinigame.get(player);
}
public void setSelectedMinigame(Player player, int minigame) {
selectedMinigame.put(player, minigame);
}
public Integer getSelectedLimit(Player p) {
if (!selectedLimit.containsKey(p)) {
selectedLimit.put(p, 10);
}
return selectedLimit.get(p);
}
public void addToSelectedLimit(Player p) {
selectedLimit.put(p, selectedLimit.get(p) + 1);
}
public void subFromSelectedLimit(Player p) {
selectedLimit.put(p, selectedLimit.get(p) - 1);
}
}

5
src/main/java/de/ventority/randomizedminigames/misc/GeneralSettings.java
View File

@ -1,5 +0,0 @@
package de.ventority.randomizedminigames.misc;
public class GeneralSettings {
public String keyword;
}

15
src/main/java/de/ventority/randomizedminigames/misc/MinigameHandler.java
View File

@ -7,6 +7,7 @@ import de.ventority.randomizedminigames.RandomizedMinigames;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@ -15,8 +16,10 @@ import static org.bukkit.Bukkit.getServer;
public class MinigameHandler {
private static final List<MinigameBase> minigames = new ArrayList<>();
private static final HashMap<Player, Settings> settings = new HashMap<>();
public static void createMinigame(int gameNumber, Player caller) {
List<Player> players = RandomizedMinigames.dataInputHandler.getSelectedPlayers(caller);
List<Player> players = settings.get(caller).getSelectedPlayers();
switch (gameNumber) {
case 0: minigames.add(new ForceItemBattle(players, caller)); break;
case 1: minigames.add(new ForceItemBattleSameItems(players, caller)); break;
@ -47,4 +50,14 @@ public class MinigameHandler {
for (MinigameBase minigame : minigames)
minigame.killGame();
}
public static Settings getSettings(Player player) {
if (!settings.containsKey(player))
settings.put(player, new Settings(player));
return settings.get(player);
}
public static void resetSettings(Player player) {
settings.put(player, new Settings(player));
}
}

61
src/main/java/de/ventority/randomizedminigames/misc/Settings.java Normal file
View File

@ -0,0 +1,61 @@
package de.ventority.randomizedminigames.misc;
import de.ventority.randomizedminigames.Minigames.Team;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class Settings {
private Player owner;
private List<Player> selectedPlayers = new ArrayList<>();
int selectedMinigame;
int selectedLimit = 10;
List<Team> teams = new ArrayList<>();
boolean showScoreboard = true;
public Settings(Player owner) {
this.owner = owner;
}
public void switchScoreboard() {
showScoreboard = !showScoreboard;
}
public boolean getScoreboardStatus() {
return showScoreboard;
}
public List<Player> getSelectedPlayers() {
return selectedPlayers;
}
public void addPlayersToSelection(Player toAdd) {
System.out.println(toAdd.getName());
selectedPlayers.add(toAdd);
}
public void removePlayersFromSelection(Player toRemove) {
selectedPlayers.remove(toRemove);
}
public int getSelectedMinigame() {
return selectedMinigame;
}
public void selectMinigame(int minigame) {
selectedMinigame = minigame;
}
public int getSelectedLimit() {
return selectedLimit;
}
public void addToSelectedLimit() {
selectedLimit++;
}
public void subFromSelectedLimit() {
selectedLimit--;
}
}