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

Major Rework

Browse Source 
- GUI reworked so now there are less bugs when setting up a Minigame. Testing is still required.
- Force-Item Team variant is now in a working state but some features are still missing or simplified.
- Inventories etc. are now correctly restored after a minigame ends.
- Reconnection is now handled more robust meaning no data loss SHOULD occur.
- On-screen texts now look a bit more fancy, desing isnt complete yet tho.
- README updated
This commit is contained in:
jakob 2026-05-14 16:16:50 +02:00
parent 60b9d40468
commit ed8d52fe35
40 changed files with 970 additions and 941 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
.gitignore vendored
View File

@ -1,4 +1,17 @@
# Project exclude paths # Gradle
/.gradle/ /.gradle/
/build/ /build/
/build/classes/java/main/
# IntelliJ IDEA
/.idea/
# Eclipse
/.classpath
/.project
/.settings/
# Compiled output
/bin/
# macOS
.DS_Store

1
gradle.properties
View File

@ -0,0 +1 @@
org.gradle.java.home=/usr/lib/jvm/java-21-openjdk

7
src/main/java/de/ventority/randomizedminigames/Minigames/BlockRandomizer.java
View File

@ -1,6 +1,7 @@
package de.ventority.randomizedminigames.Minigames; package de.ventority.randomizedminigames.Minigames;
import de.ventority.randomizedminigames.misc.Timer.Timer; import de.ventority.randomizedminigames.misc.Timer.Timer;
import de.ventority.randomizedminigames.util.MinigameHandler;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.block.Block; import org.bukkit.block.Block;
import org.bukkit.entity.EnderDragon; import org.bukkit.entity.EnderDragon;
@ -70,12 +71,14 @@ public class BlockRandomizer implements MinigameBase {
@Override @Override
public void killGame() { public void killGame() {
timer.stopCounter();
MinigameHandler.resetSettings(owner);
MinigameHandler.deleteGame(this);
} }
@Override @Override
public void stopGame() { public void stopGame() {
killGame();
} }
@Override @Override

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

@ -1,17 +1,20 @@
package de.ventority.randomizedminigames.Minigames; package de.ventority.randomizedminigames.Minigames;
import de.ventority.randomizedminigames.RandomizedMinigames;
import de.ventority.randomizedminigames.gui.InGame.GamesScoreboardManager; import de.ventority.randomizedminigames.gui.InGame.GamesScoreboardManager;
import de.ventority.randomizedminigames.misc.ColorCycler;
import de.ventority.randomizedminigames.misc.Timer.Timer; import de.ventority.randomizedminigames.misc.Timer.Timer;
import de.ventority.randomizedminigames.util.MinigameHandler; import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.PlayerBackupHandler; import de.ventority.randomizedminigames.util.PlayerBackupHandler;
import de.ventority.randomizedminigames.util.Settings; import de.ventority.randomizedminigames.util.Settings;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.GameMode; import org.bukkit.GameMode;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.boss.BarColor; import org.bukkit.boss.BarColor;
import org.bukkit.boss.BarStyle; import org.bukkit.boss.BarStyle;
import org.bukkit.boss.BossBar; import org.bukkit.boss.BossBar;
import org.bukkit.scoreboard.Scoreboard;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler; import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener; import org.bukkit.event.Listener;
@ -25,10 +28,12 @@ import org.bukkit.event.player.PlayerRespawnEvent;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta; import org.bukkit.inventory.meta.ItemMeta;
import java.awt.Color;
import java.io.BufferedReader; import java.io.BufferedReader;
import java.io.IOException; import java.io.IOException;
import java.io.InputStreamReader; import java.io.InputStreamReader;
import java.util.*; import java.util.*;
import java.util.UUID;
public class ForceItemBattle implements MinigameBase, Listener { public class ForceItemBattle implements MinigameBase, Listener {
protected final HashMap<Player, ItemStack> currentItems; protected final HashMap<Player, ItemStack> currentItems;
@ -41,8 +46,24 @@ public class ForceItemBattle implements MinigameBase, Listener {
private final Player owner; private final Player owner;
protected Settings settings; protected Settings settings;
private final Timer timer; private final Timer timer;
private final List<Player> disconnected = new ArrayList<>(); private final HashMap<UUID, DisconnectedState> disconnectedStates = new HashMap<>();
private final HashMap<Player, Integer> skips = new HashMap<>(); private final HashMap<Player, Integer> skips = new HashMap<>();
private boolean isActive = true;
private static class DisconnectedState {
final ItemStack currentItem;
final int score;
final int skipsLeft;
DisconnectedState(ItemStack currentItem, int score, int skipsLeft) {
this.currentItem = currentItem;
this.score = score;
this.skipsLeft = skipsLeft;
}
}
private final ColorCycler bossBarColors = new ColorCycler(
new Color(130, 50, 170), new Color(160, 50, 190), 0.2);
private int bossBarTick = 0;
private org.bukkit.scheduler.BukkitTask bossBarTask;
private final List<Material> SURVIVAL_ITEMS = loadMaterials(); private final List<Material> SURVIVAL_ITEMS = loadMaterials();
@ -81,6 +102,20 @@ public class ForceItemBattle implements MinigameBase, Listener {
player.getInventory().addItem(skip); player.getInventory().addItem(skip);
} }
timer.startCounter(); timer.startCounter();
bossBarTask = Bukkit.getScheduler().runTaskTimer(
RandomizedMinigames.serverSettingsHandler.getPlugin(),
() -> {
String color = ChatColor.of(bossBarColors.getColor(bossBarTick++)).toString();
for (Map.Entry<Player, BossBar> entry : new HashMap<>(itemDisplays).entrySet()) {
ItemStack item = currentItems.get(entry.getKey());
if (item == null) continue;
String name = item.getType().getTranslationKey()
.replace("block.minecraft.", "")
.replace("_", " ")
.replace("item.minecraft.", "");
entry.getValue().setTitle(color + ChatColor.BOLD + name);
}
}, 0L, 1L);
} }
@Override @Override
@ -121,11 +156,6 @@ public class ForceItemBattle implements MinigameBase, Listener {
protected void updatePlayerItem(Player player, ItemStack item) { protected void updatePlayerItem(Player player, ItemStack item) {
currentItems.replace(player, item); currentItems.replace(player, item);
String key = currentItems.get(player).getType().getTranslationKey();
String displayName = key.replace("block.minecraft.", "")
.replace("_", " ")
.replace("item.minecraft.", "");
itemDisplays.get(player).setTitle(displayName);
ItemStack[] contents = player.getInventory().getContents(); ItemStack[] contents = player.getInventory().getContents();
for (ItemStack i : contents) for (ItemStack i : contents)
checkItem(player, i); checkItem(player, i);
@ -163,6 +193,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
timer.pauseCounter(); timer.pauseCounter();
Timer t = new Timer(contestants, this, this::killGame, "Resetting game in: "); Timer t = new Timer(contestants, this, this::killGame, "Resetting game in: ");
t.setStopTime(10); t.setStopTime(10);
t.setReversed(true);
t.startCounter(); t.startCounter();
} }
@ -181,22 +212,28 @@ public class ForceItemBattle implements MinigameBase, Listener {
} }
public void killGame() { public void killGame() {
backups.restoreAll(); isActive = false;
for (Player p : itemDisplays.keySet()) { timer.stopCounter();
itemDisplays.get(p).setVisible(false); if (bossBarTask != null) bossBarTask.cancel();
itemDisplays.get(p).removePlayer(p);
for (BossBar bar : itemDisplays.values()) {
bar.setVisible(false);
bar.removeAll();
} }
itemDisplays.clear(); itemDisplays.clear();
if (settings.getScoreboardStatus()) { if (scoreboardManager != null) {
scoreboardManager.removeScoreboard(); scoreboardManager.removeScoreboard();
scoreboardManager = null; scoreboardManager = null;
} }
if (settings.getScoreboardStatus()) Scoreboard main = Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard();
for (Player player : contestants) for (Player player : contestants) {
player.setScoreboard(Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard()); if (player.isOnline())
itemDisplays.clear(); player.setScoreboard(main);
}
backups.restoreAll();
MinigameHandler.resetSettings(owner); MinigameHandler.resetSettings(owner);
MinigameHandler.deleteGame(this); MinigameHandler.deleteGame(this);
} }
@ -261,16 +298,50 @@ public class ForceItemBattle implements MinigameBase, Listener {
@EventHandler @EventHandler
public void onPlayerLeave(PlayerQuitEvent e) { public void onPlayerLeave(PlayerQuitEvent e) {
if (contestants.contains(e.getPlayer())) { Player p = e.getPlayer();
disconnected.add(e.getPlayer()); if (!contestants.contains(p)) return;
removePlayer(e.getPlayer());
} disconnectedStates.put(p.getUniqueId(), new DisconnectedState(
currentItems.get(p),
currentScores.getOrDefault(p, 0),
skips.getOrDefault(p, 0)
));
currentItems.remove(p);
currentScores.remove(p);
skips.remove(p);
removePlayer(p);
} }
@EventHandler @EventHandler
public void onPlayerJoin(PlayerJoinEvent e) { public void onPlayerJoin(PlayerJoinEvent e) {
if (disconnected.contains(e.getPlayer())) { Player p = e.getPlayer();
UUID uuid = p.getUniqueId();
DisconnectedState state = disconnectedStates.remove(uuid);
if (state == null) return;
if (isActive) {
// Re-add player to the running game
contestants.add(p);
currentItems.put(p, state.currentItem);
currentScores.put(p, state.score);
skips.put(p, state.skipsLeft);
BossBar bar = Bukkit.createBossBar("", BarColor.PURPLE, BarStyle.SOLID);
bar.addPlayer(p);
bar.setVisible(true);
itemDisplays.put(p, bar);
if (settings.getScoreboardStatus() && scoreboardManager != null)
p.setScoreboard(scoreboardManager.getScoreboard());
p.getInventory().clear();
ItemStack skipItem = new ItemStack(Material.BARRIER, state.skipsLeft);
org.bukkit.inventory.meta.ItemMeta meta = skipItem.getItemMeta();
if (meta != null) { meta.setDisplayName(org.bukkit.ChatColor.RED + "Skip"); skipItem.setItemMeta(meta); }
if (state.skipsLeft > 0) p.getInventory().addItem(skipItem);
} else {
// Game already ended — restore their pre-game backup
PlayerBackupHandler.restoreIfPending(p);
} }
} }
@EventHandler @EventHandler

36
src/main/java/de/ventority/randomizedminigames/Minigames/ForceItemBattleTeams.java
View File

@ -1,16 +1,17 @@
package de.ventority.randomizedminigames.Minigames; package de.ventority.randomizedminigames.Minigames;
import de.ventority.randomizedminigames.util.Team; import de.ventority.randomizedminigames.util.Team;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.GameMode; import org.bukkit.GameMode;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
import java.util.List; import java.util.List;
public class ForceItemBattleTeams extends ForceItemBattle{ public class ForceItemBattleTeams extends ForceItemBattle {
private final List<Team> teams; private final List<Team> teams;
public ForceItemBattleTeams(List<Player> players, Player owner, List<Team> teams) { public ForceItemBattleTeams(List<Player> players, Player owner, List<Team> teams) {
super(players, owner); super(players, owner);
this.teams = teams; this.teams = teams;
@ -18,27 +19,40 @@ public class ForceItemBattleTeams extends ForceItemBattle{
@Override @Override
protected void updatePlayerItem(Player p, ItemStack item) { protected void updatePlayerItem(Player p, ItemStack item) {
// teams is null while super() is still running, fall back to per-player assignment
if (teams == null) {
super.updatePlayerItem(p, item);
return;
}
for (Team team : teams) { for (Team team : teams) {
for (Player curPlayer : team.getPlayers()) { if (team.getPlayers().contains(p)) {
super.updatePlayerItem(curPlayer, item); for (Player teammate : team.getPlayers()) {
super.updatePlayerItem(teammate, item);
}
return;
} }
} }
} }
@Override @Override
protected void showEndMessage(Player winner) { protected void showEndMessage(Player winner) {
Team winningTeam = null;
for (Team team : teams) {
if (team.getPlayers().contains(winner)) {
winningTeam = team;
break;
}
}
String title = winningTeam != null
? winningTeam.getColor() + winningTeam.getColor().name() + " Team" + ChatColor.RESET + " won!"
: winner.getName() + " won!";
for (Player player : contestants) { for (Player player : contestants) {
player.teleport(winner); player.teleport(winner);
if (player != winner) if (player != winner)
player.setGameMode(GameMode.SPECTATOR); player.setGameMode(GameMode.SPECTATOR);
Team winningTeam = new Team(null, null); player.sendTitle(title, "Resetting players...", 10, 70, 20);
for (Team team : teams)
if (team.getPlayers().contains(player)) winningTeam = team;
player.sendTitle(winningTeam.getColor() + winningTeam.getColor().name() + "Team " + ChatColor.RESET + " won!",
"Resetting players...", 10, 70, 20);
player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard()); player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
} }
} }
} }

12
src/main/java/de/ventority/randomizedminigames/Minigames/OnlyChests.java
View File

@ -1,6 +1,7 @@
package de.ventority.randomizedminigames.Minigames; package de.ventority.randomizedminigames.Minigames;
import de.ventority.randomizedminigames.misc.Timer.Timer; import de.ventority.randomizedminigames.misc.Timer.Timer;
import de.ventority.randomizedminigames.util.MinigameHandler;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.entity.EnderDragon; import org.bukkit.entity.EnderDragon;
import org.bukkit.entity.EntityType; import org.bukkit.entity.EntityType;
@ -47,17 +48,19 @@ public class OnlyChests implements MinigameBase{
@Override @Override
public void killGame() { public void killGame() {
timer.stopCounter();
MinigameHandler.resetSettings(owner);
MinigameHandler.deleteGame(this);
} }
@Override @Override
public void stopGame() { public void stopGame() {
killGame();
} }
@Override @Override
public Player getOwner() { public Player getOwner() {
return null; return owner;
} }
@EventHandler @EventHandler
@ -73,8 +76,7 @@ public class OnlyChests implements MinigameBase{
timer.pauseCounter(); timer.pauseCounter();
} }
if (event.getDamageSource().getCausingEntity() instanceof Player && contestants.contains((Player) event.getDamageSource().getCausingEntity())) if (event.getDamageSource().getCausingEntity() instanceof Player && contestants.contains((Player) event.getDamageSource().getCausingEntity()))
if (event.getEntity().getType() != EntityType.BLAZE) { if (event.getEntity().getType() != EntityType.BLAZE)
event.getDrops().clear(); event.getDrops().clear();
} }
}
} }

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

@ -2,7 +2,10 @@ package de.ventority.randomizedminigames;
import de.ventority.randomizedminigames.gui.GUIClickEvent; import de.ventority.randomizedminigames.gui.GUIClickEvent;
import de.ventority.randomizedminigames.util.MinigameHandler; import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.PlayerBackupHandler;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener; import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.plugin.java.JavaPlugin; import org.bukkit.plugin.java.JavaPlugin;
public final class RandomizedMinigames extends JavaPlugin implements Listener { public final class RandomizedMinigames extends JavaPlugin implements Listener {
@ -21,6 +24,11 @@ public final class RandomizedMinigames extends JavaPlugin implements Listener {
MinigameHandler.killAll(); MinigameHandler.killAll();
} }
@EventHandler
public void onPlayerJoin(PlayerJoinEvent e) {
PlayerBackupHandler.restoreIfPending(e.getPlayer());
}
private void init() { private void init() {
serverSettingsHandler.setPlugin(this); serverSettingsHandler.setPlugin(this);
} }

84
src/main/java/de/ventority/randomizedminigames/gui/BaseWindow.java
View File

@ -4,101 +4,73 @@ import de.ventority.randomizedminigames.RandomizedMinigames;
import net.md_5.bungee.api.ChatColor; import net.md_5.bungee.api.ChatColor;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.Material; import org.bukkit.Material;
import org.bukkit.NamespacedKey;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.Inventory; import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta; import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.persistence.PersistentDataContainer;
import org.bukkit.persistence.PersistentDataType;
import java.util.Objects;
public abstract class BaseWindow { public abstract class BaseWindow {
protected final Player p; protected final Player p;
protected final Inventory gui; protected final Inventory gui;
public BaseWindow(Player p) { protected BaseWindow(Player p) {
this.p = p; this.p = p;
gui = Bukkit.createInventory(p, 54, RandomizedMinigames.serverSettingsHandler.getServerName() gui = Bukkit.createInventory(null, 54,
+ ChatColor.RESET + ChatColor.DARK_GRAY); RandomizedMinigames.serverSettingsHandler.getServerName() + ChatColor.RESET + ChatColor.DARK_GRAY);
} }
protected void fillBorder() { protected void fillBorder() {
ItemStack stack; for (int i = 0; i < 9; i++) placeBorderPane(i);
for (int i = 0; i < 9; i++) { for (int row = 1; row < 5; row++) {
stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1); placeBorderPane(9 * row);
addNBT(stack, "Action", "none"); placeBorderPane(8 + 9 * row);
setItemName(stack, " ");
addItemToGUI(i, stack);
} }
for (int i = 1; i < 5; i++) { for (int i = 0; i < 9; i++) placeBorderPane(45 + i);
stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
addNBT(stack, "Action", "none");
setItemName(stack, " ");
addItemToGUI(9 * i, stack);
stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
addNBT(stack, "Action", "none");
setItemName(stack, " ");
addItemToGUI(8 + 9 * i, stack);
}
for (int i = 0; i < 9; i++) {
stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
setItemName(stack, " ");
addNBT(stack, "Action", "none");
addItemToGUI(i + 5 * 9, stack);
} }
private void placeBorderPane(int slot) {
ItemStack pane = new ItemStack(Material.BLACK_STAINED_GLASS_PANE);
setName(pane, " ");
NBTHelper.set(pane, "Action", "none");
gui.setItem(slot, pane);
} }
protected abstract void fillGUI(); protected abstract void fillGUI();
public abstract void handleClick(String action, InventoryClickEvent event);
public void buildWindow() { public void buildWindow() {
fillBorder(); fillBorder();
fillGUI(); fillGUI();
addNBT(Objects.requireNonNull(gui.getItem(0)), "ItemMiniGame", "true"); GUIClickEvent.register(p, this);
p.openInventory(gui); p.openInventory(gui);
} }
protected void addNBT(ItemStack item, String key, String value) { protected ItemStack makeItem(Material material, String name) {
ItemMeta meta = item.getItemMeta(); ItemStack item = new ItemStack(material);
NamespacedKey key1 = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), key); setName(item, name);
if (meta == null) return; return item;
PersistentDataContainer data = meta.getPersistentDataContainer();
data.set(key1, PersistentDataType.STRING, value);
item.setItemMeta(meta);
} }
protected void setItemName(ItemStack item, String name) { protected void setName(ItemStack item, String name) {
ItemMeta meta = item.getItemMeta(); ItemMeta meta = item.getItemMeta();
if (meta == null) return; if (meta == null) return;
meta.setDisplayName(name); meta.setDisplayName(name);
item.setItemMeta(meta); item.setItemMeta(meta);
} }
protected void addItemToGUI(int index, ItemStack item) { // Place an item at a specific slot, overwriting whatever is there (including border).
addNBT(item, "ItemMiniGame", "true"); protected void place(int slot, ItemStack item) {
gui.setItem(index, item); gui.setItem(slot, item);
} }
protected void addItemToGUI(ItemStack item) { // Add an item to the next available inner slot.
addNBT(item, "ItemMiniGame", "true"); protected void add(ItemStack item) {
gui.addItem(item); gui.addItem(item);
} }
public Inventory getGUI() { public Inventory getGUI() {
return gui; return gui;
} }
private Player getPlayer() {
return p;
}
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);
}
} }

71
src/main/java/de/ventority/randomizedminigames/gui/GUIClickEvent.java
View File

@ -1,49 +1,54 @@
package de.ventority.randomizedminigames.gui; package de.ventority.randomizedminigames.gui;
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.Material; import org.bukkit.Material;
import org.bukkit.NamespacedKey; import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler; import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener; import org.bukkit.event.Listener;
import org.bukkit.event.inventory.InventoryClickEvent; import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.Inventory; import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.persistence.PersistentDataContainer; import java.util.HashMap;
import org.bukkit.persistence.PersistentDataType; import java.util.Map;
import java.util.UUID;
public class GUIClickEvent implements Listener { public class GUIClickEvent implements Listener {
private static final Map<UUID, BaseWindow> openWindows = new HashMap<>();
public static void register(Player p, BaseWindow window) {
openWindows.put(p.getUniqueId(), window);
}
@EventHandler
public void onClose(InventoryCloseEvent event) {
if (!(event.getPlayer() instanceof Player)) return;
Player p = (Player) event.getPlayer();
BaseWindow window = openWindows.get(p.getUniqueId());
// Only unregister if the closing inventory is the one we track.
// When a new window opens, register() is called before p.openInventory() fires this
// event, so the map already holds the new window and won't be removed here.
if (window != null && window.getGUI().equals(event.getInventory())) {
openWindows.remove(p.getUniqueId());
}
}
@EventHandler @EventHandler
public void onClickEvent(InventoryClickEvent event) { public void onClickEvent(InventoryClickEvent event) {
Inventory inventory = event.getClickedInventory(); if (!(event.getWhoClicked() instanceof Player)) return;
if (event.getCurrentItem() == null) return; Player p = (Player) event.getWhoClicked();
if (inventory == null) return; BaseWindow window = openWindows.get(p.getUniqueId());
if (inventory.getItem(0) == null) return; if (window == null) return;
if (isMinigamePlugin(inventory.getItem(0))) { if (!window.getGUI().equals(event.getClickedInventory())) return;
event.setCancelled(true); event.setCancelled(true);
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();
}
}
}
private String getNBT(ItemStack item, String key) { ItemStack item = event.getCurrentItem();
if (item == null) return "ItemIsNull"; if (item == null || item.getType() == Material.AIR) return;
ItemMeta meta = item.getItemMeta(); if (item.getType() == Material.BLACK_STAINED_GLASS_PANE) return;
NamespacedKey nsKey = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), key);
if (meta == null) return "NoItemMeta";
PersistentDataContainer data = meta.getPersistentDataContainer();
return data.get(nsKey, PersistentDataType.STRING);
}
private boolean isMinigamePlugin(ItemStack item) { String action = NBTHelper.get(item, "Action");
return getNBT(item, "ItemMiniGame") != null && getNBT(item, "ItemMiniGame").equals("true"); if (action == null || action.equals("none")) return;
window.handleClick(action, event);
} }
} }

89
src/main/java/de/ventority/randomizedminigames/gui/GUICreator.java
View File

@ -1,89 +0,0 @@
package de.ventority.randomizedminigames.gui;
import com.google.gson.Gson;
import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.Settings;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
import java.util.Objects;
public class GUICreator extends BaseWindow {
private final String path;
// DTOs als statische Klassen
private static class GUIItem {
int slot;
String material;
String name;
Map<String, String> nbt;
}
private static class GUIConfig {
String title;
int rows;
List<GUIItem> items;
}
public GUICreator(Player p, String path) {
super(p);
this.path = path;
}
@Override
protected void fillGUI() {
Settings playerSettings = MinigameHandler.getSettings(p);
Gson gson = new Gson();
GUIConfig config;
try (InputStream in = Objects.requireNonNull(
getClass().getClassLoader().getResourceAsStream(path),
"Resource not found: " + path
);
Reader reader = new InputStreamReader(in, StandardCharsets.UTF_8)) {
config = gson.fromJson(reader, GUIConfig.class);
if (config == null) {
throw new IllegalStateException("Parsed GUI config is null; is the file empty? Path: " + path);
}
if (config.items == null) {
throw new IllegalStateException("'items' is null in GUI config. Path: " + path);
}
} catch (Exception e) {
System.out.println("Error loading " + path + ". Check that the file is packaged under src/main/resources and not empty.");
return;
}
for (GUIItem guiItem : config.items) {
Material mat = Material.valueOf(guiItem.material.toUpperCase());
ItemStack item = new ItemStack(mat);
if (guiItem.nbt != null) {
for (Map.Entry<String, String> entry : guiItem.nbt.entrySet()) {
addNBT(item, entry.getKey(), entry.getValue());
}
}
String displayName = guiItem.name
.replace("%scoreboard%", playerSettings.getScoreboardStatus() ? ChatColor.GREEN + "On" : ChatColor.RED + "Off")
.replace("%scoreboardState%", playerSettings.getScoreboardStatus() ? ChatColor.GREEN + "On" : ChatColor.RED + "Off")
.replace("%timer%", playerSettings.isTimed ? ChatColor.GREEN + "On" : ChatColor.RED + "Off");
setItemName(item, displayName);
if (guiItem.slot == -1) {
addItemToGUI(item);
} else {
addItemToGUI(guiItem.slot, item);
}
}
}
}

62
src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/MinigameSetup.java
View File

@ -1,62 +0,0 @@
package de.ventority.randomizedminigames.gui.MinigameSetups;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.Settings;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class MinigameSetup extends BaseWindow {
public MinigameSetup(Player p) {
super(p);
}
@Override
protected void fillGUI() {
ItemStack playerSelect = new ItemStack(Material.PLAYER_HEAD);
addNBT(playerSelect, "Type", "MinigameSetup");
addNBT(playerSelect, "Action", "startPlayerSelection");
setItemName(playerSelect, "Select Players");
addItemToGUI(playerSelect);
ItemStack setLimit = new ItemStack(Material.BOOK);
addNBT(setLimit, "Type", "MinigameSetup");
addNBT(setLimit, "Action", "startLimitSelection");
setItemName(setLimit, "Set win limit");
addItemToGUI(setLimit);
Settings playerSettings = MinigameHandler.getSettings(p);
ItemStack scoreboard = new ItemStack(Material.EMERALD);
addNBT(scoreboard, "Type", "MinigameSetup");
addNBT(scoreboard, "Action", "switchScoreboard");
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");
setItemName(start, "Start");
addItemToGUI(50, start);
ItemStack timer = new ItemStack(Material.CLOCK);
addNBT(timer, "Type", "MinigameSetup");
addNBT(timer, "Action", "startTimerSetup");
setItemName(timer, "Set Timer");
addItemToGUI(timer);
ItemStack enableTimer = new ItemStack(Material.TARGET);
addNBT(enableTimer, "Type", "MinigameSetup");
addNBT(enableTimer, "Action", "toggleTimer");
setItemName(enableTimer, "Timer: " + (playerSettings.isTimed ? (ChatColor.GREEN + "On") : ChatColor.RED + "Off"));
addItemToGUI(enableTimer);
ItemStack back = new ItemStack(Material.ARROW);
addNBT(back, "Type", "MinigameSelect");
addNBT(back, "Action", "homeMenu");
setItemName(back, "Back");
addItemToGUI(49, back);
}
}

48
src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/PlayerSelection.java
View File

@ -1,48 +0,0 @@
package de.ventority.randomizedminigames.gui.MinigameSetups;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.util.MinigameHandler;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.SkullMeta;
public class PlayerSelection extends BaseWindow {
public PlayerSelection(Player p) {
super(p);
}
@Override
protected void fillGUI() {
for (Player player : Bukkit.getOnlinePlayers()) {
if (!MinigameHandler.getOccupiedPlayers().contains(player)) {
ItemStack item = getPlayerHead(player);
addNBT(item, "Type", "MinigameSetup");
addNBT(item, "Action", "clickedPlayer");
addNBT(item, "Player", player.getDisplayName());
addItemToGUI(item);
}
}
ItemStack back = new ItemStack(Material.ARROW);
addNBT(back, "Type", "MinigameSetup");
addNBT(back, "Action", "homeMenu");
setItemName(back, "Back");
addItemToGUI(49, back);
}
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((MinigameHandler.getSettings(p).getSelectedPlayers().contains(player) ?
ChatColor.GREEN : ChatColor.RED) + player.getName());
head.setItemMeta(meta);
}
return head;
}
}

40
src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/SetLimit.java
View File

@ -1,40 +0,0 @@
package de.ventority.randomizedminigames.gui.MinigameSetups;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.util.MinigameHandler;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class SetLimit extends BaseWindow {
public SetLimit(Player p) {
super(p);
}
@Override
protected void fillGUI() {
ItemStack add = new ItemStack(Material.RED_DYE);
addNBT(add, "Type", "MinigameSetup");
addNBT(add, "Action", "addToLimit");
setItemName(add, "Add");
addItemToGUI(14, add);
ItemStack sub = new ItemStack(Material.GREEN_DYE);
addNBT(sub, "Type", "MinigameSetup");
addNBT(sub, "Action", "subFromLimit");
setItemName(sub, "Sub");
addItemToGUI(12, sub);
ItemStack display = new ItemStack(Material.PAPER);
addNBT(display, "Type", "MinigameSetup");
addNBT(display, "Action", "none");
setItemName(display, "" + MinigameHandler.getSettings(p).getSelectedLimit());
addItemToGUI(13, display);
ItemStack back = new ItemStack(Material.ARROW);
addNBT(back, "Type", "MinigameSetup");
addNBT(back, "Action", "homeMenu");
setItemName(back, "Back");
addItemToGUI(49, back);
}
}

75
src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/SetTimeLimit.java
View File

@ -1,75 +0,0 @@
package de.ventority.randomizedminigames.gui.MinigameSetups;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.util.MinigameHandler;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class SetTimeLimit extends BaseWindow {
public SetTimeLimit(Player p) {
super(p);
}
@Override
protected void fillGUI() {
ItemStack add30 = new ItemStack(Material.RED_DYE);
addNBT(add30, "Type", "MinigameSetup");
addNBT(add30, "Action", "add30ToTimeLimit");
setItemName(add30, "+30min");
addItemToGUI(16, add30);
ItemStack add10 = new ItemStack(Material.RED_DYE);
addNBT(add10, "Type", "MinigameSetup");
addNBT(add10, "Action", "add10ToTimeLimit");
setItemName(add10, "+10min");
addItemToGUI(15, add10);
ItemStack add1 = new ItemStack(Material.RED_DYE);
addNBT(add1, "Type", "MinigameSetup");
addNBT(add1, "Action", "add1ToTimeLimit");
setItemName(add1, "+1min");
addItemToGUI(14, add1);
ItemStack sub30 = new ItemStack(Material.GREEN_DYE);
addNBT(sub30, "Type", "MinigameSetup");
addNBT(sub30, "Action", "sub30FromTimeLimit");
setItemName(sub30, "-30min");
addItemToGUI(10, sub30);
ItemStack sub10 = new ItemStack(Material.GREEN_DYE);
addNBT(sub10, "Type", "MinigameSetup");
addNBT(sub10, "Action", "sub10FromTimeLimit");
setItemName(sub10, "-10min");
addItemToGUI(11, sub10);
ItemStack sub1 = new ItemStack(Material.GREEN_DYE);
addNBT(sub1, "Type", "MinigameSetup");
addNBT(sub1, "Action", "sub1FromTimeLimit");
setItemName(sub1, "-1min");
addItemToGUI(12, sub1);
ItemStack display = new ItemStack(Material.PAPER);
addNBT(display, "Type", "MinigameSetup");
addNBT(display, "Action", "none");
setItemName(display, formattedTime(MinigameHandler.getSettings(p).getTimeLimit()));
addItemToGUI(13, display);
ItemStack back = new ItemStack(Material.ARROW);
addNBT(back, "Type", "MinigameSetup");
addNBT(back, "Action", "homeMenu");
setItemName(back, "Back");
addItemToGUI(49, back);
}
private String formattedTime(int time) {
int minutes = (int)Math.floor((double) time / 60);
int seconds = time % 60;
StringBuilder sb = new StringBuilder();
if (minutes != 0) {
sb.append(minutes).append(":");
}
sb.append(seconds);
return sb.toString();
}
}

41
src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/TeamCountSelection.java
View File

@ -1,41 +0,0 @@
package de.ventority.randomizedminigames.gui.MinigameSetups;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.util.MinigameHandler;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class TeamCountSelection extends BaseWindow {
public TeamCountSelection(Player p) {
super(p);
}
@Override
protected void fillGUI() {
ItemStack add = new ItemStack(Material.RED_DYE);
addNBT(add, "Type", "MinigameSetup");
addNBT(add, "Action", "addTeamCount");
setItemName(add, "Add");
addItemToGUI(14, add);
ItemStack sub = new ItemStack(Material.GREEN_DYE);
addNBT(sub, "Type", "MinigameSetup");
addNBT(sub, "Action", "subTeamCount");
setItemName(sub, "Sub");
addItemToGUI(12, sub);
ItemStack display = new ItemStack(Material.PAPER);
addNBT(display, "Type", "MinigameSetup");
addNBT(display, "Action", "none");
setItemName(display, "" + MinigameHandler.getSettings(p).getTeamCount());
addItemToGUI(13, display);
ItemStack next = new ItemStack(Material.ARROW);
addNBT(next, "Type", "MinigameSetup");
addNBT(next, "Action", "TeamSetupSelection");
setItemName(next, "Next");
addItemToGUI(49, next);
}
}

16
src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/TeamOverview.java
View File

@ -1,16 +0,0 @@
package de.ventority.randomizedminigames.gui.MinigameSetups;
import de.ventority.randomizedminigames.gui.BaseWindow;
import org.bukkit.entity.Player;
public class TeamOverview extends BaseWindow {
public TeamOverview(Player p) {
super(p);
}
@Override
protected void fillGUI() {
}
}

58
src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/TeamPlayerSelection.java
View File

@ -1,58 +0,0 @@
package de.ventority.randomizedminigames.gui.MinigameSetups;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.util.MinigameHandler;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.SkullMeta;
public class TeamPlayerSelection extends BaseWindow {
public TeamPlayerSelection(Player p) {
super(p);
}
@Override
protected void fillGUI() {
for (Player player : Bukkit.getOnlinePlayers()) {
if (!MinigameHandler.getOccupiedPlayers().contains(player)) {
ItemStack item = getPlayerHead(player);
addNBT(item, "Type", "MinigameSetup");
addNBT(item, "Action", "clickedPlayerInTeams");
addNBT(item, "Player", player.getDisplayName());
addItemToGUI(item);
}
}
final ChatColor[] colors = new ChatColor[]{ChatColor.GREEN,
ChatColor.RED, ChatColor.BLUE, ChatColor.DARK_PURPLE,
ChatColor.BLACK, ChatColor.DARK_GREEN};
final Material[] material = new Material[]{Material.GREEN_WOOL, Material.RED_WOOL,
Material.BLUE_WOOL, Material.PURPLE_WOOL, Material.BLACK_WOOL, Material.GREEN_WOOL};
ItemStack selectedTeam = new ItemStack(material[MinigameHandler.getSettings(p).getSelectedTeamIndex()], 1);
setItemName(selectedTeam, colors[MinigameHandler.getSettings(p).getSelectedTeamIndex()] + "Team #" + (MinigameHandler.getSettings(p).getSelectedTeamIndex() + 1));
addNBT(selectedTeam, "Team", Integer.toString(MinigameHandler.getSettings(p).getSelectedTeamIndex()));
addItemToGUI(4, selectedTeam);
ItemStack back = new ItemStack(Material.ARROW);
addNBT(back, "Type", "MinigameSetup");
addNBT(back, "Action", "homeMenu");
setItemName(back, "Back");
addItemToGUI(49, back);
}
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((MinigameHandler.getSettings(p).getSelectedPlayers().contains(player) ?
ChatColor.GREEN : ChatColor.RED) + player.getName());
head.setItemMeta(meta);
}
return head;
}
}

30
src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/TeamSetupSelection.java
View File

@ -1,30 +0,0 @@
package de.ventority.randomizedminigames.gui.MinigameSetups;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.util.MinigameHandler;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class TeamSetupSelection extends BaseWindow {
private final ChatColor[] colors = new ChatColor[]{ChatColor.GREEN, ChatColor.RED, ChatColor.BLUE, ChatColor.DARK_PURPLE, ChatColor.BLACK, ChatColor.DARK_GREEN};
private final Material[] material = new Material[]{Material.GREEN_WOOL, Material.RED_WOOL, Material.BLUE_WOOL, Material.PURPLE_WOOL, Material.BLACK_WOOL, Material.GREEN_WOOL};
public TeamSetupSelection(Player p) {
super(p);
}
@Override
protected void fillGUI() {
for (int i = 0; i < MinigameHandler.getSettings(p).getTeamCount(); i++) {
ItemStack item = new ItemStack(material[i], 1);
setItemName(item, colors[i] + "Team #" + (i + 1));
addNBT(item, "Type", "MinigameSetup");
addNBT(item, "Action", "selectTeam");
addNBT(item, "selectedTeam", Integer.toString(i));
addItemToGUI(item);
}
}
}

27
src/main/java/de/ventority/randomizedminigames/gui/NBTHelper.java Normal file
View File

@ -0,0 +1,27 @@
package de.ventority.randomizedminigames.gui;
import de.ventority.randomizedminigames.RandomizedMinigames;
import org.bukkit.NamespacedKey;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.persistence.PersistentDataType;
public final class NBTHelper {
private NBTHelper() {}
public static void set(ItemStack item, String key, String value) {
ItemMeta meta = item.getItemMeta();
if (meta == null) return;
NamespacedKey nsKey = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), key);
meta.getPersistentDataContainer().set(nsKey, PersistentDataType.STRING, value);
item.setItemMeta(meta);
}
public static String get(ItemStack item, String key) {
if (item == null) return null;
ItemMeta meta = item.getItemMeta();
if (meta == null) return null;
NamespacedKey nsKey = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), key);
return meta.getPersistentDataContainer().get(nsKey, PersistentDataType.STRING);
}
}

20
src/main/java/de/ventority/randomizedminigames/gui/SettingsWindow.java
View File

@ -1,20 +0,0 @@
package de.ventority.randomizedminigames.gui;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class SettingsWindow extends BaseWindow{
public SettingsWindow(Player p) {
super(p);
}
@Override
public void fillGUI() {
ItemStack setContestants = new ItemStack(Material.ZOMBIE_HEAD, 1);
setItemName(setContestants, "Add Contestants");
addNBT(setContestants, "Status", "addContestants");
gui.addItem(setContestants);
}
}

30
src/main/java/de/ventority/randomizedminigames/gui/handlers/GUIHandler.java
View File

@ -1,30 +0,0 @@
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);
}
}

30
src/main/java/de/ventority/randomizedminigames/gui/handlers/MinigameSelectHandler.java
View File

@ -1,30 +0,0 @@
package de.ventority.randomizedminigames.gui.handlers;
import de.ventority.randomizedminigames.gui.MinigameSetups.MinigameSetup;
import de.ventority.randomizedminigames.gui.MinigameSetups.TeamCountSelection;
import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.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("startForceItem") || action.equals("startForceItemSameItem") || action.equals("startBlockRandomizer") || action.equals("startOnlyChests")) {
settings.selectMinigame(Integer.parseInt(getNBT(event.getCurrentItem(), "selectedMinigame")));
new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
}
if (action.equals("startForceItemTeams")) {
settings.selectMinigame(Integer.parseInt(getNBT(event.getCurrentItem(), "selectedMinigame")));
new TeamCountSelection((Player)event.getWhoClicked()).buildWindow();
}
if (action.equals("homeMenu")) {
new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
}
}
}

116
src/main/java/de/ventority/randomizedminigames/gui/handlers/MinigameSetupHandler.java
View File

@ -1,116 +0,0 @@
package de.ventority.randomizedminigames.gui.handlers;
import de.ventority.randomizedminigames.gui.MinigameSetups.*;
import de.ventority.randomizedminigames.util.Team;
import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.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.subFromWinLimit();
new SetLimit((Player)event.getWhoClicked()).buildWindow();
}
if (action.equals("addToLimit")) {
playerSettings.addToWinLimit();
new SetLimit((Player)event.getWhoClicked()).buildWindow();
}
if (action.equals("addTeamCount")) {
playerSettings.addTeamCount();
new TeamCountSelection((Player)event.getWhoClicked()).buildWindow();
}
if (action.equals("subTeamCount")) {
playerSettings.subTeamCount();
new TeamCountSelection((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("toggleTimer")) {
playerSettings.isTimed = !playerSettings.isTimed;
new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
}
if (action.equals("startGame")) {
MinigameHandler.createMinigame(playerSettings.getSelectedMinigame(), (Player) event.getWhoClicked());
event.getWhoClicked().closeInventory();
}
if (action.equals("TeamSetupSelection")) {
new TeamSetupSelection((Player)event.getWhoClicked()).buildWindow();
}
if (action.equals("selectTeam")) {
MinigameHandler.getSettings(((Player) event.getWhoClicked()).getPlayer()).setSelectedTeamIndex(Integer.parseInt(getNBT(event.getCurrentItem(), "selectedTeam")));
new TeamPlayerSelection((Player)event.getWhoClicked()).buildWindow();
}
if (action.equals("clickedPlayerInTeams")) {
Player toWork = Bukkit.getPlayer(getNBT(event.getCurrentItem(), "Player"));
int teamNumber = Integer.parseInt(getNBT(event.getClickedInventory().getItem(4), "Team"));
Team team = playerSettings.getTeam(teamNumber - 1);
if (playerSettings.getSelectedPlayers().contains(toWork)) {
team.removePlayer(toWork);
playerSettings.removePlayersFromSelection(toWork);
} else {
team.addPlayer(toWork);
playerSettings.addPlayersToSelection(toWork);
}
return;
}
if (action.equals("startTimerSetup")) {
new SetTimeLimit((Player)event.getWhoClicked()).buildWindow();
}
if (action.contains("FromTimeLimit") || action.contains("ToTimeLimit")) {
switch (action) {
case "add30ToTimeLimit": playerSettings.setTimeLimit(playerSettings.getTimeLimit() + 30*60); break;
case "add10ToTimeLimit": playerSettings.setTimeLimit(playerSettings.getTimeLimit() + 10*60); break;
case "add1ToTimeLimit": playerSettings.setTimeLimit(playerSettings.getTimeLimit() + 60); break;
case "sub30FromTimeLimit": playerSettings.setTimeLimit(playerSettings.getTimeLimit() - 30*60); break;
case "sub10FromTimeLimit": playerSettings.setTimeLimit(playerSettings.getTimeLimit() - 10*60); break;
case "sub1FromTimeLimit": playerSettings.setTimeLimit(playerSettings.getTimeLimit() - 60); break;
}
new SetTimeLimit((Player)event.getWhoClicked()).buildWindow();
}
}
}

18
src/main/java/de/ventority/randomizedminigames/gui/handlers/SettingsHandler.java
View File

@ -1,18 +0,0 @@
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());
}
}
}

88
src/main/java/de/ventority/randomizedminigames/gui/windows/MinigameSetupWindow.java Normal file
View File

@ -0,0 +1,88 @@
package de.ventority.randomizedminigames.gui.windows;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.gui.NBTHelper;
import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.Settings;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
public class MinigameSetupWindow extends BaseWindow {
public MinigameSetupWindow(Player p) {
super(p);
}
@Override
protected void fillGUI() {
Settings settings = MinigameHandler.getSettings(p);
ItemStack playerSelect = makeItem(Material.PLAYER_HEAD, "Select Players");
NBTHelper.set(playerSelect, "Action", "startPlayerSelection");
add(playerSelect);
String limitLabel = !settings.isTimed
? ChatColor.GREEN + String.valueOf(settings.getSelectedLimit())
: ChatColor.RED + "Off";
ItemStack setLimit = makeItem(Material.BOOK, "Win Limit: " + limitLabel);
NBTHelper.set(setLimit, "Action", "startLimitSelection");
add(setLimit);
ItemStack scoreboard = makeItem(Material.EMERALD,
"Scoreboard: " + (settings.getScoreboardStatus() ? ChatColor.GREEN + "On" : ChatColor.RED + "Off"));
NBTHelper.set(scoreboard, "Action", "switchScoreboard");
add(scoreboard);
String timerLabel = settings.isTimed
? ChatColor.GREEN + formatTime(settings.getTimeLimit())
: ChatColor.RED + "Off";
ItemStack timer = makeItem(Material.CLOCK, "Timer: " + timerLabel);
NBTHelper.set(timer, "Action", "startTimerSetup");
add(timer);
ItemStack start = makeItem(Material.GREEN_DYE, "Start");
NBTHelper.set(start, "Action", "startGame");
place(50, start);
ItemStack back = makeItem(Material.ARROW, "Back");
NBTHelper.set(back, "Action", "back");
place(49, back);
}
private String formatTime(int totalSeconds) {
int minutes = totalSeconds / 60;
int seconds = totalSeconds % 60;
if (minutes == 0) return String.valueOf(seconds);
return minutes + ":" + String.format("%02d", seconds);
}
@Override
public void handleClick(String action, InventoryClickEvent event) {
Settings settings = MinigameHandler.getSettings(p);
switch (action) {
case "startPlayerSelection":
new PlayerSelectionWindow(p).buildWindow();
break;
case "startLimitSelection":
new SetLimitWindow(p).buildWindow();
break;
case "switchScoreboard":
settings.switchScoreboard();
new MinigameSetupWindow(p).buildWindow();
break;
case "startTimerSetup":
new SetTimeLimitWindow(p).buildWindow();
break;
case "startGame":
MinigameHandler.createMinigame(settings.getSelectedMinigame(), p);
p.closeInventory();
break;
case "back":
new MinigamesDisplayWindow(p).buildWindow();
break;
}
}
}

28
src/main/java/de/ventority/randomizedminigames/gui/windows/MinigamesDisplayWindow.java
View File

@ -1,8 +1,11 @@
package de.ventority.randomizedminigames.gui.windows; package de.ventority.randomizedminigames.gui.windows;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.Minigames.Minigame; import de.ventority.randomizedminigames.Minigames.Minigame;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.gui.NBTHelper;
import de.ventority.randomizedminigames.util.MinigameHandler;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.ItemStack;
public class MinigamesDisplayWindow extends BaseWindow { public class MinigamesDisplayWindow extends BaseWindow {
@ -14,12 +17,23 @@ public class MinigamesDisplayWindow extends BaseWindow {
@Override @Override
protected void fillGUI() { protected void fillGUI() {
for (Minigame minigame : Minigame.values()) { for (Minigame minigame : Minigame.values()) {
ItemStack item = new ItemStack(minigame.getMaterial(), 1); ItemStack item = makeItem(minigame.getMaterial(), minigame.getName());
setItemName(item, minigame.getName()); NBTHelper.set(item, "Action", minigame.getAction());
addNBT(item, "Type", "MinigameSelect"); NBTHelper.set(item, "selectedMinigame", Integer.toString(minigame.getNumber()));
addNBT(item, "Action", minigame.getAction()); add(item);
addNBT(item, "selectedMinigame", Integer.toString(minigame.getNumber())); }
addItemToGUI(item); }
@Override
public void handleClick(String action, InventoryClickEvent event) {
String selectedMinigame = NBTHelper.get(event.getCurrentItem(), "selectedMinigame");
if (selectedMinigame != null) {
MinigameHandler.getSettings(p).selectMinigame(Integer.parseInt(selectedMinigame));
}
if (action.equals("startForceItemTeams")) {
new TeamCountSelectionWindow(p).buildWindow();
} else {
new MinigameSetupWindow(p).buildWindow();
} }
} }
} }

69
src/main/java/de/ventority/randomizedminigames/gui/windows/PlayerSelectionWindow.java Normal file
View File

@ -0,0 +1,69 @@
package de.ventority.randomizedminigames.gui.windows;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.gui.NBTHelper;
import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.Settings;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.SkullMeta;
public class PlayerSelectionWindow extends BaseWindow {
public PlayerSelectionWindow(Player p) {
super(p);
}
@Override
protected void fillGUI() {
Settings settings = MinigameHandler.getSettings(p);
for (Player online : Bukkit.getOnlinePlayers()) {
if (!MinigameHandler.getOccupiedPlayers().contains(online)) {
boolean selected = settings.getSelectedPlayers().contains(online);
ItemStack head = makePlayerHead(online, selected);
NBTHelper.set(head, "Action", "clickedPlayer");
NBTHelper.set(head, "Player", online.getName());
add(head);
}
}
ItemStack back = makeItem(Material.ARROW, "Back");
NBTHelper.set(back, "Action", "back");
place(49, back);
}
@Override
public void handleClick(String action, InventoryClickEvent event) {
if (action.equals("back")) {
new MinigameSetupWindow(p).buildWindow();
return;
}
if (action.equals("clickedPlayer")) {
String playerName = NBTHelper.get(event.getCurrentItem(), "Player");
Player target = Bukkit.getPlayer(playerName);
if (target == null) return;
Settings settings = MinigameHandler.getSettings(p);
if (settings.getSelectedPlayers().contains(target)) {
settings.removePlayersFromSelection(target);
} else {
settings.addPlayersToSelection(target);
}
new PlayerSelectionWindow(p).buildWindow();
}
}
private ItemStack makePlayerHead(Player target, boolean selected) {
ItemStack head = new ItemStack(Material.PLAYER_HEAD);
SkullMeta meta = (SkullMeta) head.getItemMeta();
if (meta != null) {
meta.setOwningPlayer(target);
meta.setDisplayName((selected ? ChatColor.GREEN : ChatColor.RED) + target.getName());
head.setItemMeta(meta);
}
return head;
}
}

67
src/main/java/de/ventority/randomizedminigames/gui/windows/SetLimitWindow.java Normal file
View File

@ -0,0 +1,67 @@
package de.ventority.randomizedminigames.gui.windows;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.gui.NBTHelper;
import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.Settings;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
public class SetLimitWindow extends BaseWindow {
public SetLimitWindow(Player p) {
super(p);
}
@Override
protected void fillGUI() {
Settings settings = MinigameHandler.getSettings(p);
ItemStack sub = makeItem(Material.GREEN_DYE, "Sub");
NBTHelper.set(sub, "Action", "subFromLimit");
place(12, sub);
ItemStack display = makeItem(Material.PAPER, String.valueOf(settings.getSelectedLimit()));
NBTHelper.set(display, "Action", "none");
place(13, display);
ItemStack add = makeItem(Material.RED_DYE, "Add");
NBTHelper.set(add, "Action", "addToLimit");
place(14, add);
ItemStack toggle = !settings.isTimed
? makeItem(Material.LIME_DYE, ChatColor.GREEN + "Enabled - click to disable")
: makeItem(Material.GRAY_DYE, ChatColor.RED + "Disabled - click to enable");
NBTHelper.set(toggle, "Action", "toggleWinLimit");
place(22, toggle);
ItemStack back = makeItem(Material.ARROW, "Back");
NBTHelper.set(back, "Action", "back");
place(49, back);
}
@Override
public void handleClick(String action, InventoryClickEvent event) {
Settings settings = MinigameHandler.getSettings(p);
switch (action) {
case "addToLimit":
settings.addToWinLimit();
new SetLimitWindow(p).buildWindow();
break;
case "subFromLimit":
settings.subFromWinLimit();
new SetLimitWindow(p).buildWindow();
break;
case "toggleWinLimit":
settings.isTimed = !settings.isTimed;
new SetLimitWindow(p).buildWindow();
break;
case "back":
new MinigameSetupWindow(p).buildWindow();
break;
}
}
}

84
src/main/java/de/ventority/randomizedminigames/gui/windows/SetTimeLimitWindow.java Normal file
View File

@ -0,0 +1,84 @@
package de.ventority.randomizedminigames.gui.windows;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.gui.NBTHelper;
import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.Settings;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
public class SetTimeLimitWindow extends BaseWindow {
public SetTimeLimitWindow(Player p) {
super(p);
}
@Override
protected void fillGUI() {
Settings settings = MinigameHandler.getSettings(p);
ItemStack sub30 = makeItem(Material.GREEN_DYE, "-30min");
NBTHelper.set(sub30, "Action", "sub30");
place(10, sub30);
ItemStack sub10 = makeItem(Material.GREEN_DYE, "-10min");
NBTHelper.set(sub10, "Action", "sub10");
place(11, sub10);
ItemStack sub1 = makeItem(Material.GREEN_DYE, "-1min");
NBTHelper.set(sub1, "Action", "sub1");
place(12, sub1);
ItemStack display = makeItem(Material.PAPER, formatTime(settings.getTimeLimit()));
NBTHelper.set(display, "Action", "none");
place(13, display);
ItemStack add1 = makeItem(Material.RED_DYE, "+1min");
NBTHelper.set(add1, "Action", "add1");
place(14, add1);
ItemStack add10 = makeItem(Material.RED_DYE, "+10min");
NBTHelper.set(add10, "Action", "add10");
place(15, add10);
ItemStack add30 = makeItem(Material.RED_DYE, "+30min");
NBTHelper.set(add30, "Action", "add30");
place(16, add30);
ItemStack toggle = settings.isTimed
? makeItem(Material.LIME_DYE, ChatColor.GREEN + "Enabled - click to disable")
: makeItem(Material.GRAY_DYE, ChatColor.RED + "Disabled - click to enable");
NBTHelper.set(toggle, "Action", "toggleTimer");
place(22, toggle);
ItemStack back = makeItem(Material.ARROW, "Back");
NBTHelper.set(back, "Action", "back");
place(49, back);
}
@Override
public void handleClick(String action, InventoryClickEvent event) {
Settings settings = MinigameHandler.getSettings(p);
switch (action) {
case "add30": settings.setTimeLimit(settings.getTimeLimit() + 30 * 60); break;
case "add10": settings.setTimeLimit(settings.getTimeLimit() + 10 * 60); break;
case "add1": settings.setTimeLimit(settings.getTimeLimit() + 60); break;
case "sub30": settings.setTimeLimit(settings.getTimeLimit() - 30 * 60); break;
case "sub10": settings.setTimeLimit(settings.getTimeLimit() - 10 * 60); break;
case "sub1": settings.setTimeLimit(settings.getTimeLimit() - 60); break;
case "toggleTimer": settings.isTimed = !settings.isTimed; break;
case "back": new MinigameSetupWindow(p).buildWindow(); return;
}
new SetTimeLimitWindow(p).buildWindow();
}
private String formatTime(int totalSeconds) {
int minutes = totalSeconds / 60;
int seconds = totalSeconds % 60;
if (minutes == 0) return String.valueOf(seconds);
return minutes + ":" + String.format("%02d", seconds);
}
}

27
src/main/java/de/ventority/randomizedminigames/gui/windows/SettingsWindow.java Normal file
View File

@ -0,0 +1,27 @@
package de.ventority.randomizedminigames.gui.windows;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.gui.NBTHelper;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
public class SettingsWindow extends BaseWindow {
public SettingsWindow(Player p) {
super(p);
}
@Override
protected void fillGUI() {
ItemStack setContestants = makeItem(Material.ZOMBIE_HEAD, "Add Contestants");
NBTHelper.set(setContestants, "Action", "addContestants");
add(setContestants);
}
@Override
public void handleClick(String action, InventoryClickEvent event) {
// Not yet implemented
}
}

57
src/main/java/de/ventority/randomizedminigames/gui/windows/TeamCountSelectionWindow.java Normal file
View File

@ -0,0 +1,57 @@
package de.ventority.randomizedminigames.gui.windows;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.gui.NBTHelper;
import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.Settings;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
public class TeamCountSelectionWindow extends BaseWindow {
public TeamCountSelectionWindow(Player p) {
super(p);
}
@Override
protected void fillGUI() {
Settings settings = MinigameHandler.getSettings(p);
ItemStack sub = makeItem(Material.GREEN_DYE, "Sub");
NBTHelper.set(sub, "Action", "subTeamCount");
place(12, sub);
ItemStack display = makeItem(Material.PAPER, String.valueOf(settings.getTeamCount()));
NBTHelper.set(display, "Action", "none");
place(13, display);
ItemStack add = makeItem(Material.RED_DYE, "Add");
NBTHelper.set(add, "Action", "addTeamCount");
place(14, add);
ItemStack next = makeItem(Material.ARROW, "Next");
NBTHelper.set(next, "Action", "next");
place(49, next);
}
@Override
public void handleClick(String action, InventoryClickEvent event) {
Settings settings = MinigameHandler.getSettings(p);
switch (action) {
case "addTeamCount":
settings.addTeamCount();
new TeamCountSelectionWindow(p).buildWindow();
break;
case "subTeamCount":
settings.subTeamCount();
new TeamCountSelectionWindow(p).buildWindow();
break;
case "next":
MinigameHandler.getSettings(p).initTeams();
new TeamSetupSelectionWindow(p).buildWindow();
break;
}
}
}

93
src/main/java/de/ventority/randomizedminigames/gui/windows/TeamPlayerSelectionWindow.java Normal file
View File

@ -0,0 +1,93 @@
package de.ventority.randomizedminigames.gui.windows;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.gui.NBTHelper;
import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.Settings;
import de.ventority.randomizedminigames.util.Team;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.SkullMeta;
public class TeamPlayerSelectionWindow extends BaseWindow {
private static final ChatColor[] TEAM_COLORS = {
ChatColor.GREEN, ChatColor.RED, ChatColor.BLUE,
ChatColor.DARK_PURPLE, ChatColor.BLACK, ChatColor.DARK_GREEN
};
private static final Material[] TEAM_MATERIALS = {
Material.GREEN_WOOL, Material.RED_WOOL, Material.BLUE_WOOL,
Material.PURPLE_WOOL, Material.BLACK_WOOL, Material.GREEN_WOOL
};
public TeamPlayerSelectionWindow(Player p) {
super(p);
}
@Override
protected void fillGUI() {
Settings settings = MinigameHandler.getSettings(p);
int teamIndex = settings.getSelectedTeamIndex();
Team currentTeam = settings.getTeam(teamIndex);
for (Player online : Bukkit.getOnlinePlayers()) {
if (MinigameHandler.getOccupiedPlayers().contains(online)) continue;
boolean inCurrentTeam = currentTeam.getPlayers().contains(online);
// Hide players already assigned to a different team
boolean inOtherTeam = settings.getSelectedPlayers().contains(online) && !inCurrentTeam;
if (inOtherTeam) continue;
ItemStack head = makePlayerHead(online, inCurrentTeam);
NBTHelper.set(head, "Action", "clickedPlayerInTeams");
NBTHelper.set(head, "Player", online.getName());
add(head);
}
ItemStack teamIndicator = makeItem(TEAM_MATERIALS[teamIndex],
TEAM_COLORS[teamIndex] + "Team #" + (teamIndex + 1));
NBTHelper.set(teamIndicator, "Action", "none");
place(4, teamIndicator);
ItemStack back = makeItem(Material.ARROW, "Back");
NBTHelper.set(back, "Action", "back");
place(49, back);
}
@Override
public void handleClick(String action, InventoryClickEvent event) {
if (action.equals("back")) {
new TeamSetupSelectionWindow(p).buildWindow();
return;
}
if (action.equals("clickedPlayerInTeams")) {
String playerName = NBTHelper.get(event.getCurrentItem(), "Player");
Player target = Bukkit.getPlayer(playerName);
if (target == null) return;
Settings settings = MinigameHandler.getSettings(p);
Team team = settings.getTeam(settings.getSelectedTeamIndex());
if (team.getPlayers().contains(target)) {
team.removePlayer(target);
settings.removePlayersFromSelection(target);
} else {
team.addPlayer(target);
settings.addPlayersToSelection(target);
}
new TeamPlayerSelectionWindow(p).buildWindow();
}
}
private ItemStack makePlayerHead(Player target, boolean inCurrentTeam) {
ItemStack head = new ItemStack(Material.PLAYER_HEAD);
SkullMeta meta = (SkullMeta) head.getItemMeta();
if (meta != null) {
meta.setOwningPlayer(target);
meta.setDisplayName((inCurrentTeam ? ChatColor.GREEN : ChatColor.RED) + target.getName());
head.setItemMeta(meta);
}
return head;
}
}

56
src/main/java/de/ventority/randomizedminigames/gui/windows/TeamSetupSelectionWindow.java Normal file
View File

@ -0,0 +1,56 @@
package de.ventority.randomizedminigames.gui.windows;
import de.ventority.randomizedminigames.gui.BaseWindow;
import de.ventority.randomizedminigames.gui.NBTHelper;
import de.ventority.randomizedminigames.util.MinigameHandler;
import de.ventority.randomizedminigames.util.Settings;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
public class TeamSetupSelectionWindow extends BaseWindow {
private static final ChatColor[] TEAM_COLORS = {
ChatColor.GREEN, ChatColor.RED, ChatColor.BLUE,
ChatColor.DARK_PURPLE, ChatColor.BLACK, ChatColor.DARK_GREEN
};
private static final Material[] TEAM_MATERIALS = {
Material.GREEN_WOOL, Material.RED_WOOL, Material.BLUE_WOOL,
Material.PURPLE_WOOL, Material.BLACK_WOOL, Material.GREEN_WOOL
};
public TeamSetupSelectionWindow(Player p) {
super(p);
}
@Override
protected void fillGUI() {
Settings settings = MinigameHandler.getSettings(p);
for (int i = 0; i < settings.getTeamCount(); i++) {
int playerCount = settings.getTeam(i).getPlayers().size();
String name = TEAM_COLORS[i] + "Team #" + (i + 1) + ChatColor.GRAY + " (" + playerCount + " players)";
ItemStack item = makeItem(TEAM_MATERIALS[i], name);
NBTHelper.set(item, "Action", "selectTeam");
NBTHelper.set(item, "selectedTeam", Integer.toString(i));
add(item);
}
ItemStack start = makeItem(Material.GREEN_DYE, "Start Game");
NBTHelper.set(start, "Action", "startGame");
place(50, start);
}
@Override
public void handleClick(String action, InventoryClickEvent event) {
if (action.equals("selectTeam")) {
String teamIndex = NBTHelper.get(event.getCurrentItem(), "selectedTeam");
if (teamIndex == null) return;
MinigameHandler.getSettings(p).setSelectedTeamIndex(Integer.parseInt(teamIndex));
new TeamPlayerSelectionWindow(p).buildWindow();
} else if (action.equals("startGame")) {
MinigameHandler.createMinigame(3, p);
p.closeInventory();
}
}
}

33
src/main/java/de/ventority/randomizedminigames/misc/ColorCycler.java
View File

@ -1,4 +1,37 @@
package de.ventority.randomizedminigames.misc; package de.ventority.randomizedminigames.misc;
import java.awt.Color;
public class ColorCycler { public class ColorCycler {
private final Color from;
private final Color to;
private final double cyclesPerSecond;
/**
* @param from start color of the pulse
* @param to end color of the pulse
* @param cyclesPerSecond how many full dark→light→dark cycles per second
*/
public ColorCycler(Color from, Color to, double cyclesPerSecond) {
this.from = from;
this.to = to;
this.cyclesPerSecond = cyclesPerSecond;
}
/**
* Returns the interpolated color for a given tick (20 ticks = 1 second).
* Uses a sine wave so the transition is smooth in both directions.
*/
public Color getColor(int tick) {
double t = (Math.sin(tick * (2 * Math.PI * cyclesPerSecond / 20.0)) + 1.0) / 2.0;
return new Color(
lerp(from.getRed(), to.getRed(), t),
lerp(from.getGreen(), to.getGreen(), t),
lerp(from.getBlue(), to.getBlue(), t)
);
}
private static int lerp(int a, int b, double t) {
return (int) Math.round(a + (b - a) * t);
}
} }

37
src/main/java/de/ventority/randomizedminigames/misc/Timer/Timer.java
View File

@ -2,13 +2,16 @@ package de.ventority.randomizedminigames.misc.Timer;
import de.ventority.randomizedminigames.Minigames.MinigameBase; import de.ventority.randomizedminigames.Minigames.MinigameBase;
import de.ventority.randomizedminigames.RandomizedMinigames; import de.ventority.randomizedminigames.RandomizedMinigames;
import de.ventority.randomizedminigames.misc.ColorCycler;
import de.ventority.randomizedminigames.util.MinigameHandler; import de.ventority.randomizedminigames.util.MinigameHandler;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.ChatMessageType; import net.md_5.bungee.api.ChatMessageType;
import net.md_5.bungee.api.chat.TextComponent; import net.md_5.bungee.api.chat.TextComponent;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitTask; import org.bukkit.scheduler.BukkitTask;
import java.awt.Color;
import java.util.List; import java.util.List;
@ -23,7 +26,11 @@ public class Timer {
private boolean isReversed = false; private boolean isReversed = false;
private String customText; private String customText;
private int countedSeconds = 0; private int countedSeconds = 0;
private String defaultText; private final ColorCycler colorCycler = new ColorCycler(
new Color(110, 0, 145),
new Color(130, 50, 170),
0.2
);
public Timer(List<Player> players, MinigameBase minigame, String text) { public Timer(List<Player> players, MinigameBase minigame, String text) {
this.players = players; this.players = players;
@ -49,14 +56,13 @@ public class Timer {
counterTask = Bukkit.getScheduler().runTaskTimer(RandomizedMinigames.serverSettingsHandler.getPlugin(), () -> { counterTask = Bukkit.getScheduler().runTaskTimer(RandomizedMinigames.serverSettingsHandler.getPlugin(), () -> {
countedSeconds = counter / 20; countedSeconds = counter / 20;
updateText();
updatePlayers(); updatePlayers();
if (!isPaused) { if (!isPaused) {
counter++; counter++;
if (countedSeconds == stopTime && MinigameHandler.getSettings(minigame.getOwner()).isTimed) { if (countedSeconds == stopTime) {
if (methodToCall != null) if (methodToCall != null)
methodToCall.run(); methodToCall.run();
else else if (MinigameHandler.getSettings(minigame.getOwner()).isTimed)
minigame.stopGame(); minigame.stopGame();
stopCounter(); stopCounter();
} }
@ -104,30 +110,11 @@ public class Timer {
} }
private void updatePlayers() { private void updatePlayers() {
// int amplitude = 40; TextComponent msg = new TextComponent("§l" + updateText());
// msg.setColor(ChatColor.of(colorCycler.getColor(counter)));
// int step = counter % (amplitude * 2);
// int brightness = step <= amplitude ? step : (amplitude * 2 - step);
//
// int baseRed = 125;
// int baseGreen = 0;
// int baseBlue = 130;
//
//
// Color c = new Color(
// baseRed + 2*brightness,
// baseGreen,
// baseBlue + 2*brightness
// );
//
TextComponent msg = new TextComponent(defaultText);
// msg.setColor(ChatColor.of(c));
msg.setBold(true);
for (Player player : players) { for (Player player : players) {
player.spigot().sendMessage(ChatMessageType.ACTION_BAR, msg); player.spigot().sendMessage(ChatMessageType.ACTION_BAR, msg);
} }
} }
public void setStopTime(int seconds) { public void setStopTime(int seconds) {

17
src/main/java/de/ventority/randomizedminigames/util/MinigameHandler.java
View File

@ -16,13 +16,18 @@ public class MinigameHandler {
public static void createMinigame(int gameNumber, Player caller) { public static void createMinigame(int gameNumber, Player caller) {
List<Player> players = settings.get(caller).getSelectedPlayers(); List<Player> players = settings.get(caller).getSelectedPlayers();
MinigameBase newGame = null;
switch (gameNumber) { switch (gameNumber) {
case 0: minigames.add(new ForceItemBattle(players, caller)); break; case 0: newGame = new ForceItemBattle(players, caller); break;
case 1: minigames.add(new ForceItemBattleSameItems(players, caller)); break; case 1: newGame = new ForceItemBattleSameItems(players, caller); break;
case 2: minigames.add(new BlockRandomizer(players, caller)); break; case 2: newGame = new BlockRandomizer(players, caller); break;
case 4: minigames.add(new OnlyChests(players, caller)); break; case 3: newGame = new ForceItemBattleTeams(players, caller, settings.get(caller).getTeams()); break;
case 4: newGame = new OnlyChests(players, caller); break;
}
if (newGame != null) {
minigames.add(newGame);
getServer().getPluginManager().registerEvents(newGame, RandomizedMinigames.serverSettingsHandler.getPlugin());
} }
getServer().getPluginManager().registerEvents(minigames.getFirst(), RandomizedMinigames.serverSettingsHandler.getPlugin());
} }
public static List<MinigameBase> getMinigames() { public static List<MinigameBase> getMinigames() {
@ -45,7 +50,7 @@ public class MinigameHandler {
} }
public static void killAll() { public static void killAll() {
for (MinigameBase minigame : minigames) for (MinigameBase minigame : new ArrayList<>(minigames))
minigame.killGame(); minigame.killGame();
} }

43
src/main/java/de/ventority/randomizedminigames/util/PlayerBackup.java
View File

@ -7,36 +7,35 @@ import org.bukkit.inventory.ItemStack;
public class PlayerBackup { public class PlayerBackup {
private final ItemStack[] inventory; private final ItemStack[] inventory;
private final ItemStack[] armor; private final ItemStack[] armor;
private final ItemStack offhand;
private final float exp; private final float exp;
private final int level;
private final Location location; private final Location location;
private GameMode gamemode; private final GameMode gamemode;
private final double health;
private final int foodLevel;
public PlayerBackup(ItemStack[] inventory, ItemStack[] armor, float exp, Location location, GameMode gamemode) { public PlayerBackup(ItemStack[] inventory, ItemStack[] armor, ItemStack offhand,
float exp, int level, Location location, GameMode gamemode,
double health, int foodLevel) {
this.inventory = inventory; this.inventory = inventory;
this.armor = armor; this.armor = armor;
this.offhand = offhand;
this.exp = exp; this.exp = exp;
this.level = level;
this.location = location; this.location = location;
this.gamemode = gamemode; this.gamemode = gamemode;
this.health = health;
this.foodLevel = foodLevel;
} }
public ItemStack[] getInventory() { public ItemStack[] getInventory() { return inventory; }
return inventory; public ItemStack[] getArmor() { return armor; }
} public ItemStack getOffhand() { return offhand; }
public float getExp() { return exp; }
public ItemStack[] getArmor() { public int getLevel() { return level; }
return armor; public Location getLocation() { return location; }
} public GameMode getGamemode() { return gamemode; }
public double getHealth() { return health; }
public float getExp() { public int getFoodLevel() { return foodLevel; }
return exp;
}
public Location getLocation() {
return location;
}
public GameMode getGamemode() {
return gamemode;
}
} }

73
src/main/java/de/ventority/randomizedminigames/util/PlayerBackupHandler.java
View File

@ -1,32 +1,91 @@
package de.ventority.randomizedminigames.util; package de.ventority.randomizedminigames.util;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffect;
import java.util.Collection;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.UUID;
public class PlayerBackupHandler { public class PlayerBackupHandler {
private HashMap<Player, PlayerBackup> playerBackups = new HashMap<>(); // Backups for players currently in a minigame, keyed by UUID so they survive reconnects.
private final HashMap<UUID, PlayerBackup> playerBackups = new HashMap<>();
// Players who were offline when killGame() ran — restored the next time they join.
private static final HashMap<UUID, PlayerBackup> pendingRestores = new HashMap<>();
public PlayerBackupHandler(List<Player> players) { public PlayerBackupHandler(List<Player> players) {
for (Player player : players) { for (Player player : players) {
PlayerBackup backup = new PlayerBackup(player.getInventory().getContents(), player.getInventory().getArmorContents(), player.getExp(), player.getLocation(), player.getGameMode()); playerBackups.put(player.getUniqueId(), new PlayerBackup(
playerBackups.put(player, backup); clone(player.getInventory().getContents()),
clone(player.getInventory().getArmorContents()),
cloneItem(player.getInventory().getItemInOffHand()),
player.getExp(),
player.getLevel(),
player.getLocation(),
player.getGameMode(),
player.getHealth(),
player.getFoodLevel()
));
} }
} }
public void restorePlayerBackup(Player player) { public void restorePlayerBackup(Player player) {
PlayerBackup backup = playerBackups.get(player); PlayerBackup backup = playerBackups.get(player.getUniqueId());
if (backup == null) return;
applyBackup(player, backup);
}
/**
* Restores online players immediately.
* Players who are currently offline are queued in pendingRestores
* and will be restored the next time they join.
*/
public void restoreAll() {
for (UUID uuid : playerBackups.keySet()) {
Player player = Bukkit.getPlayer(uuid);
if (player != null && player.isOnline()) {
applyBackup(player, playerBackups.get(uuid));
} else {
pendingRestores.put(uuid, playerBackups.get(uuid));
}
}
}
/** Called on every PlayerJoinEvent — restores any backup queued while the player was offline. */
public static void restoreIfPending(Player player) {
PlayerBackup backup = pendingRestores.remove(player.getUniqueId());
if (backup != null) applyBackup(player, backup);
}
private static void applyBackup(Player player, PlayerBackup backup) {
player.getInventory().clear();
player.getInventory().setArmorContents(null);
Collection<PotionEffect> effects = player.getActivePotionEffects();
for (PotionEffect effect : effects)
player.removePotionEffect(effect.getType());
player.getInventory().setContents(backup.getInventory()); player.getInventory().setContents(backup.getInventory());
player.getInventory().setArmorContents(backup.getArmor()); player.getInventory().setArmorContents(backup.getArmor());
player.getInventory().setItemInOffHand(backup.getOffhand());
player.setExp(backup.getExp()); player.setExp(backup.getExp());
player.setLevel(backup.getLevel());
player.setHealth(backup.getHealth());
player.setFoodLevel(backup.getFoodLevel());
player.teleport(backup.getLocation()); player.teleport(backup.getLocation());
player.setGameMode(backup.getGamemode()); player.setGameMode(backup.getGamemode());
} }
public void restoreAll() { private static org.bukkit.inventory.ItemStack[] clone(org.bukkit.inventory.ItemStack[] source) {
for (Player player : playerBackups.keySet()) { org.bukkit.inventory.ItemStack[] copy = new org.bukkit.inventory.ItemStack[source.length];
restorePlayerBackup(player); for (int i = 0; i < source.length; i++)
copy[i] = source[i] != null ? source[i].clone() : null;
return copy;
} }
private static org.bukkit.inventory.ItemStack cloneItem(org.bukkit.inventory.ItemStack item) {
return item != null ? item.clone() : null;
} }
} }

17
src/main/java/de/ventority/randomizedminigames/util/Settings.java
View File

@ -1,5 +1,6 @@
package de.ventority.randomizedminigames.util; package de.ventority.randomizedminigames.util;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import java.util.ArrayList; import java.util.ArrayList;
@ -88,6 +89,22 @@ public class Settings {
this.timeLimit = timeLimit; this.timeLimit = timeLimit;
} }
public void initTeams() {
teams.clear();
selectedPlayers.clear();
ChatColor[] colors = {
ChatColor.GREEN, ChatColor.RED, ChatColor.BLUE,
ChatColor.DARK_PURPLE, ChatColor.BLACK, ChatColor.DARK_GREEN
};
for (int i = 0; i < selectedTeamCount; i++) {
teams.add(new Team(new ArrayList<>(), colors[i]));
}
}
public List<Team> getTeams() {
return teams;
}
public Team getTeam(int i) { public Team getTeam(int i) {
return teams.get(i); return teams.get(i);
} }

69
src/main/resources/gui/MinigameSetup.json
View File

@ -1,69 +0,0 @@
{
"title": "Minigame Setup",
"rows": 6,
"items": [
{
"slot": -1,
"material": "PLAYER_HEAD",
"name": "Select Players",
"nbt": {
"Type": "MinigameSetup",
"Action": "startPlayerSelection"
}
},
{
"slot": -1,
"material": "BOOK",
"name": "Set win limit",
"nbt": {
"Type": "MinigameSetup",
"Action": "startLimitSelection"
}
},
{
"slot": -1,
"material": "EMERALD",
"name": "Scoreboard: %scoreboardState%",
"nbt": {
"Type": "MinigameSetup",
"Action": "switchScoreboard"
}
},
{
"slot": 50,
"material": "GREEN_DYE",
"name": "Start",
"nbt": {
"Type": "MinigameSetup",
"Action": "startGame"
}
},
{
"slot": -1,
"material": "CLOCK",
"name": "Set Timer",
"nbt": {
"Type": "MinigameSetup",
"Action": "startTimerSetup"
}
},
{
"slot": -1,
"material": "TARGET",
"name": "Timer: %timer%",
"nbt": {
"Type": "MinigameSetup",
"Action": "toggleTimer"
}
},
{
"slot": 49,
"material": "ARROW",
"name": "Back",
"nbt": {
"Type": "MinigameSelect",
"Action": "homeMenu"
}
}
]
}