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

Fixed some bugs

Browse Source 
Started adding Team functionality
Some minor changes
This commit is contained in:
jakob 2025-04-18 15:20:45 +02:00
parent 72d45e9949
commit 79b878327f
19 changed files with 326 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -22,7 +22,7 @@ public abstract class BaseWindow {
public BaseWindow(Player p, String status) {
this.p = p;
gui = Bukkit.createInventory(p, 54, RandomizedMinigames.serverSettingsHandler.getServerName()
+ ChatColor.RESET + ChatColor.DARK_GRAY + status);
+ ChatColor.RESET + ChatColor.DARK_GRAY);
this.status = status;
}
@ -30,27 +30,27 @@ public abstract class BaseWindow {
ItemStack stack;
for (int i = 0; i < 9; i++) {
stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
gui.setItem(i, stack);
setItemName(stack, " " + i);
setItemName(stack, " ");
addItemToGUI(i, stack);
}
for (int i = 1; i < 5; i++) {
stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
gui.setItem(9 * i, stack);
setItemName(stack, " " + 9 * i);
setItemName(stack, " ");
addItemToGUI(9 * i, stack);
stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
gui.setItem(8 + 9 * i, stack);
setItemName(stack, " " + 8 + 9 * i);
setItemName(stack, " ");
addItemToGUI(8 + 9 * i, stack);
}
for (int i = 0; i < 9; i++) {
stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
gui.setItem(i + 5 * 9, stack);
setItemName(stack, " " + i + 5 * 9);
setItemName(stack, " ");
addItemToGUI(i + 5 * 9, stack);
}
}
protected abstract void fillGUI();
protected void buildWindow() {
public void buildWindow() {
fillBorder();
fillGUI();
addNBT(Objects.requireNonNull(gui.getItem(0)), "ItemMiniGame", "true");
@ -63,12 +63,24 @@ public abstract class BaseWindow {
if (meta == null) return;
PersistentDataContainer data = meta.getPersistentDataContainer();
data.set(key1, PersistentDataType.STRING, value);
item.setItemMeta(meta);
}
protected void setItemName(ItemStack item, String name) {
ItemMeta meta = item.getItemMeta();
if (meta == null) return;
meta.setDisplayName(name);
item.setItemMeta(meta);
}
protected void addItemToGUI(int index, ItemStack item) {
addNBT(item, "ItemMiniGame", "true");
gui.setItem(index, item);
}
protected void addItemToGUI(ItemStack item) {
addNBT(item, "ItemMiniGame", "true");
gui.addItem(item);
}
public Inventory getGUI() {

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

@ -1,8 +1,15 @@
package de.ventority.randomizedminigames.GUI;
import de.ventority.randomizedminigames.MinigameHandler;
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.SelectMinigame;
import de.ventority.randomizedminigames.misc.DataInputHandler;
import de.ventority.randomizedminigames.misc.MinigameHandler;
import de.ventority.randomizedminigames.Minigames.Minigame;
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;
@ -17,18 +24,23 @@ import org.bukkit.persistence.PersistentDataType;
public class GUIClickEvent implements Listener {
@EventHandler
public void onClickEvent(InventoryClickEvent event) {
event.setCancelled(true);
Inventory inventory = event.getClickedInventory();
if (event.getCurrentItem() == null) return;
if (event.getCurrentItem().getType() == Material.BLACK_STAINED_GLASS) return;
if (inventory == null) return;
if (inventory.getItem(0) == null) return;
if (isMinigamePlugin(inventory.getItem(0))) {
event.setCancelled(true);
event.getWhoClicked().closeInventory();
if (getNBT(event.getCurrentItem(), "Type").equals("Minigame")) {
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"));
}
}
}
@ -42,18 +54,16 @@ public class GUIClickEvent implements Listener {
}
private boolean isMinigamePlugin(ItemStack item) {
String s = getNBT(item, "ItemMiniGame");
System.out.println(s);
System.out.println(item.getItemMeta().getDisplayName());
System.out.println(s != null && s.equals("true"));
return s != null && s.equals("true");
return getNBT(item, "ItemMiniGame") != null && getNBT(item, "ItemMiniGame").equals("true");
}
private void handleMinigame(InventoryClickEvent event, String action) {
for (Minigame minigame : Minigame.values()) {
if (action.equals(minigame.getAction())) {
MinigameHandler.createMinigame(minigame.getNumber());
}
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();
}
}
@ -63,4 +73,26 @@ public class GUIClickEvent implements Listener {
}
}
private void handleMinigameSetup(InventoryClickEvent event, String action) {
if (action.equals("homeMenu")) {
new MinigamesDisplayWindow((Player) event.getWhoClicked(), "Minigame").buildWindow();
}
if (action.equals("clickedPlayer")) {
DataInputHandler data = RandomizedMinigames.dataInputHandler;
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("startPlayerSelection")) {
new PlayerSelection((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
}
if (action.equals("startGame")) {
MinigameHandler.createMinigame(RandomizedMinigames.dataInputHandler.getSelectedMinigame((Player) event.getWhoClicked()), (Player) event.getWhoClicked());
}
}
}

2
src/main/java/de/ventority/randomizedminigames/GUI/BossBarCreator.java → src/main/java/de/ventority/randomizedminigames/GUI/InGame/BossBarCreator.java
View File

@ -1,4 +1,4 @@
package de.ventority.randomizedminigames.GUI;
package de.ventority.randomizedminigames.GUI.InGame;
import org.bukkit.Bukkit;
import org.bukkit.boss.*;

2
src/main/java/de/ventority/randomizedminigames/GUI/GamesScoreboardManager.java → src/main/java/de/ventority/randomizedminigames/GUI/InGame/GamesScoreboardManager.java
View File

@ -1,4 +1,4 @@
package de.ventority.randomizedminigames.GUI;
package de.ventority.randomizedminigames.GUI.InGame;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;

36
src/main/java/de/ventority/randomizedminigames/GUI/MinigameSetups/MinigameSetup.java Normal file
View File

@ -0,0 +1,36 @@
package de.ventority.randomizedminigames.GUI.MinigameSetups;
import de.ventority.randomizedminigames.GUI.BaseWindow;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
public class MinigameSetup extends BaseWindow {
public MinigameSetup(Player p, String status) {
super(p, status);
}
@Override
protected void fillGUI() {
ItemStack playerSelect = new ItemStack(Material.GOLD_INGOT);
addNBT(playerSelect, "Type", "MinigameSetup");
addNBT(playerSelect, "Action", "startPlayerSelection");
addNBT(playerSelect, "selectedMinigame", status);
setItemName(playerSelect, "Select Players");
addItemToGUI(playerSelect);
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);
ItemStack back = new ItemStack(Material.ARROW);
addNBT(back, "Type", "MinigameSelect");
addNBT(back, "Action", "homeMenu");
setItemName(back, "Back");
addItemToGUI(49, back);
}
}

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

@ -1,42 +1,29 @@
package de.ventority.randomizedminigames.GUI;
package de.ventority.randomizedminigames.GUI.MinigameSetups;
import de.ventority.randomizedminigames.GUI.BaseWindow;
import de.ventority.randomizedminigames.Minigames.Minigame;
import de.ventority.randomizedminigames.RandomizedMinigames;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.NamespacedKey;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.persistence.PersistentDataContainer;
import org.bukkit.persistence.PersistentDataType;
public class MinigamesDisplayWindow extends BaseWindow{
public class MinigamesDisplayWindow extends BaseWindow {
public MinigamesDisplayWindow(Player p, String status) {
super(p, status);
}
public void buildWindow() {
fillBorder();
fillGUI();
p.openInventory(gui);
}
@Override
protected void fillGUI() {
for (Minigame minigame : Minigame.values()) {
ItemStack item = new ItemStack(minigame.getMaterial(), 1);
ItemMeta meta = item.getItemMeta();
setItemName(item, minigame.getName());
addNBT(item, "Type", "Minigame");
addNBT(item, "Action", minigame.getAction());
item.setItemMeta(meta);
gui.addItem(item);
addNBT(item, "Type", "MinigameSelect");
addNBT(item, "Action", "openMinigameSetup");
addNBT(item, "selectedMinigame", Integer.toString(minigame.getNumber()));
addItemToGUI(item);
}
addSettings();
//addSettings();
}
private void addSettings() {
@ -46,6 +33,6 @@ public class MinigamesDisplayWindow extends BaseWindow{
addNBT(settings, "Type", "Misc");
addNBT(settings, "Action", "selectSettings");
settings.setItemMeta(settingsMeta);
gui.setItem(45, settings);
addItemToGUI(45, settings);
}
}

49
src/main/java/de/ventority/randomizedminigames/GUI/MinigameSetups/PlayerSelection.java Normal file
View File

@ -0,0 +1,49 @@
package de.ventority.randomizedminigames.GUI.MinigameSetups;
import de.ventority.randomizedminigames.GUI.BaseWindow;
import de.ventority.randomizedminigames.RandomizedMinigames;
import de.ventority.randomizedminigames.misc.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, String status) {
super(p, status);
}
@Override
protected void fillGUI() {
for (Player player : Bukkit.getOnlinePlayers()) {
if (!MinigameHandler.getOccupiedPlayers().contains(player)) {
ItemStack item = getPlayerHead(player, RandomizedMinigames.dataInputHandler.getSelectedPlayers(p).contains(player));
addNBT(item, "Type", "MinigameSetup");
addNBT(item, "Action", "clickedPlayer");
addNBT(item, "selectedMinigame", status);
addNBT(item, "Player", player.getDisplayName());
addItemToGUI(item);
}
}
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) {
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());
head.setItemMeta(meta);
}
return head;
}
}

12
src/main/java/de/ventority/randomizedminigames/GeneralSettings.java
View File

@ -1,12 +0,0 @@
package de.ventority.randomizedminigames;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class GeneralSettings {
public List<Player> contestants = new ArrayList<>();
public String keyword;
}

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

@ -1,7 +1,8 @@
package de.ventority.randomizedminigames.Minigames;
import de.ventority.randomizedminigames.GUI.GamesScoreboardManager;
import de.ventority.randomizedminigames.MinigameHandler;
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 org.bukkit.Bukkit;
import org.bukkit.GameMode;
@ -12,7 +13,6 @@ import org.bukkit.boss.BossBar;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityPickupItemEvent;
import org.bukkit.event.inventory.CraftItemEvent;
import org.bukkit.event.player.PlayerQuitEvent;
@ -20,7 +20,6 @@ import org.bukkit.inventory.ItemStack;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
public class ForceItemBattle implements MinigameBase, Listener {
@ -31,15 +30,17 @@ public class ForceItemBattle implements MinigameBase, Listener {
private GamesScoreboardManager scoreboardManager;
private final List<Player> contestants;
private final HashMap<Player, PlayerBackup> backups;
private final Player owner;
public ForceItemBattle(List<Player> players) {
public ForceItemBattle(List<Player> players, Player owner) {
id = new Random().nextInt(1024);
currentItems = new HashMap<>();
currentScores = new HashMap<>();
itemDisplays = new HashMap<>();
backups = new HashMap<>();
contestants = players;
this.owner = owner;
for (Player player : players) {
currentItems.put(player, null);
currentScores.put(player, 0);
@ -47,7 +48,6 @@ public class ForceItemBattle implements MinigameBase, Listener {
bar.addPlayer(player);
bar.setVisible(true);
itemDisplays.put(player, bar);
System.out.println(itemDisplays.get(player).getTitle());
updatePlayerItem(player);
backups.put(player, new PlayerBackup(player.getInventory().getContents(), player.getInventory().getArmorContents(), player.getExp(), player.getLocation()));
}
@ -90,6 +90,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
scoreboardManager.setPunkte(p.getName(), scoreboardManager.getPunkte(p.getName()) + 1);
if (checkWin(p)) {
stopGame(p);
return;
}
updatePlayerItem(p);
}
@ -109,7 +110,6 @@ public class ForceItemBattle implements MinigameBase, Listener {
private boolean checkWin(Player p) {
if (currentScores.get(p) == 3) {
System.out.println(currentScores.get(p) + ", " + p.getName() + " wins");
return true;
}
return false;
@ -120,9 +120,10 @@ public class ForceItemBattle implements MinigameBase, Listener {
if (player != winner) {
player.teleport(winner);
player.setGameMode(GameMode.SPECTATOR);
player.sendTitle(winner.getDisplayName() + " hat gewonnen!", "Die Player werden jetzt zurückgesetzt.", 10, 70, 20);
restorePlayer(player);
player.sendTitle(winner.getDisplayName() + " won!", "Resetting players...", 10, 70, 20);
//restorePlayer(player);
}
player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
}
for (Player p : itemDisplays.keySet()) {
itemDisplays.get(p).setVisible(false);
@ -132,13 +133,28 @@ public class ForceItemBattle implements MinigameBase, Listener {
scoreboardManager.removeScoreboard();
scoreboardManager = null;
RandomizedMinigames.dataInputHandler.removeEntry(owner);
MinigameHandler.deleteGame(this);
}
private void removePlayer(Player p) {
itemDisplays.get(p).setVisible(false);
itemDisplays.get(p).removePlayer(p);
scoreboardManager.getScoreboard().getPlayers().remove(p);
p.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
if (contestants.isEmpty())
stopGame(owner);
}
public void killGame() {
for (Player player : contestants) {
player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
}
itemDisplays.clear();
scoreboardManager.removeScoreboard();
scoreboardManager = null;
RandomizedMinigames.dataInputHandler.removeEntry(owner);
MinigameHandler.deleteGame(this);
}
private void restorePlayer(Player p) {
@ -150,6 +166,10 @@ public class ForceItemBattle implements MinigameBase, Listener {
p.getInventory().setArmorContents(backup.getArmor());
}
public List<Player> getPlayers() {
return contestants;
}
@EventHandler
public void onItemPickup(EntityPickupItemEvent e) {
Player eventPlayer;

4
src/main/java/de/ventority/randomizedminigames/Minigames/ForceItemBattleSameItems.java
View File

@ -10,8 +10,8 @@ public class ForceItemBattleSameItems extends ForceItemBattle {
private List<ItemStack> items;
public ForceItemBattleSameItems(List<Player> players) {
super(players);
public ForceItemBattleSameItems(List<Player> players, Player owner) {
super(players, owner);
}
@Override

13
src/main/java/de/ventority/randomizedminigames/Minigames/ForceItemBattleTeams.java Normal file
View File

@ -0,0 +1,13 @@
package de.ventority.randomizedminigames.Minigames;
import org.bukkit.entity.Player;
import java.util.List;
public class ForceItemBattleTeams extends ForceItemBattle{
private List<Team> teams;
public ForceItemBattleTeams(List<Player> players, Player owner, List<Team> teams) {
super(players, owner);
this.teams = teams;
}
}

2
src/main/java/de/ventority/randomizedminigames/Minigames/MinigameBase.java
View File

@ -11,4 +11,6 @@ public interface MinigameBase extends Listener {
String getName();
ItemStack getSymbol();
void addPlayers(List<Player> players);
List<Player> getPlayers();
void killGame();
}

44
src/main/java/de/ventority/randomizedminigames/Minigames/Team.java Normal file
View File

@ -0,0 +1,44 @@
package de.ventority.randomizedminigames.Minigames;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Random;
public class Team {
private HashMap<String, List<Player>> teams;
private HashMap<String, ChatColor> colors;
public Team(HashMap<String, List<Player>> teams) {
this.teams = teams;
}
public List<Player> getPlayersOf(String team) {
return teams.get(team);
}
public void addPlayer(String team, Player p) {
teams.get(team).add(p);
}
public void createTeam(String team) {
teams.put(team, new ArrayList<>());
ChatColor[] colors = ChatColor.values();
ChatColor color;
Random rnd = new Random();
do color = colors[rnd.nextInt(colors.length)];
while (!color.isColor() || colorExists(color));
}
private boolean colorExists(ChatColor color) {
for (ChatColor c : colors.values())
if (c.equals(color)) return true;
return false;
}
public ChatColor getColor(String team) {
return colors.get(team);
}
}

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

@ -1,11 +1,13 @@
package de.ventority.randomizedminigames;
import de.ventority.randomizedminigames.GUI.GUIClickEvent;
import de.ventority.randomizedminigames.misc.DataInputHandler;
import de.ventority.randomizedminigames.misc.MinigameHandler;
import org.bukkit.plugin.java.JavaPlugin;
public final class RandomizedMinigames extends JavaPlugin {
public static final ServerSettingsHandler serverSettingsHandler = new ServerSettingsHandler();
public static String keyword = "";
public static DataInputHandler dataInputHandler = new DataInputHandler();
@Override
public void onEnable() {
init();
@ -15,7 +17,7 @@ public final class RandomizedMinigames extends JavaPlugin {
@Override
public void onDisable() {
// Plugin shutdown logic
MinigameHandler.killAll();
}
private void init() {

4
src/main/java/de/ventority/randomizedminigames/SelectMinigame.java
View File

@ -1,13 +1,13 @@
package de.ventority.randomizedminigames;
import de.ventority.randomizedminigames.GUI.MinigamesDisplayWindow;
import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigamesDisplayWindow;
import org.bukkit.command.*;
import org.bukkit.entity.Player;
public class SelectMinigame implements CommandExecutor {
@Override
public boolean onCommand(CommandSender commandSender, Command command, String s, String[] args) {
MinigamesDisplayWindow window = new MinigamesDisplayWindow((Player) commandSender, "minigameSelect");
MinigamesDisplayWindow window = new MinigamesDisplayWindow((Player) commandSender, "MinigameSelect");
window.buildWindow();
return true;
}

2
src/main/java/de/ventority/randomizedminigames/ServerSettingsHandler.java
View File

@ -33,4 +33,6 @@ public class ServerSettingsHandler {
public Plugin getPlugin() {
return plugin;
}
public String keyword;
}

41
src/main/java/de/ventority/randomizedminigames/misc/DataInputHandler.java Normal file
View File

@ -0,0 +1,41 @@
package de.ventority.randomizedminigames.misc;
import de.ventority.randomizedminigames.Minigames.MinigameBase;
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<>();
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 removeEntry(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);
}
}

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

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

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

@ -1,8 +1,9 @@
package de.ventority.randomizedminigames;
package de.ventority.randomizedminigames.misc;
import de.ventority.randomizedminigames.Minigames.ForceItemBattle;
import de.ventority.randomizedminigames.Minigames.ForceItemBattleSameItems;
import de.ventority.randomizedminigames.Minigames.MinigameBase;
import de.ventority.randomizedminigames.RandomizedMinigames;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.util.ArrayList;
@ -14,11 +15,11 @@ import static org.bukkit.Bukkit.getServer;
public class MinigameHandler {
private static final List<MinigameBase> minigames = new ArrayList<>();
public static void createMinigame(int gameNumber) {
List<Player> players = Bukkit.getOnlinePlayers().stream().map(p -> ((Player) p)).toList();
public static void createMinigame(int gameNumber, Player caller) {
List<Player> players = RandomizedMinigames.dataInputHandler.getSelectedPlayers(caller);
switch (gameNumber) {
case 0: minigames.add(new ForceItemBattle(players));
case 1: minigames.add(new ForceItemBattleSameItems(players));
case 0: minigames.add(new ForceItemBattle(players, caller)); break;
case 1: minigames.add(new ForceItemBattleSameItems(players, caller)); break;
}
getServer().getPluginManager().registerEvents(minigames.getFirst(), RandomizedMinigames.serverSettingsHandler.getPlugin());
}
@ -26,4 +27,17 @@ public class MinigameHandler {
public static void deleteGame(MinigameBase minigame) {
minigames.remove(minigame);
}
public static List<Player> getOccupiedPlayers() {
List<Player> lst = new ArrayList<>();
for (MinigameBase minigame : minigames) {
lst.addAll(minigame.getPlayers());
}
return lst;
}
public static void killAll() {
for (MinigameBase minigame : minigames)
minigame.killGame();
}
}