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

Working Limit selection

Browse Source 
Scoreboard toggleable
Started implemention of Teambased games
Minor changes
This commit is contained in:
Jakob Hansen 2025-04-20 10:35:25 +02:00
parent 79b878327f
commit 1f1738eabd
13 changed files with 339 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -30,20 +30,24 @@ public abstract class BaseWindow {
ItemStack stack;
for (int i = 0; i < 9; i++) {
stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
addNBT(stack, "Action", "none");
setItemName(stack, " ");
addItemToGUI(i, stack);
}
for (int i = 1; i < 5; 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);
}
}

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

@ -3,6 +3,7 @@ package de.ventority.randomizedminigames.GUI;
import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigameSetup;
import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigamesDisplayWindow;
import de.ventority.randomizedminigames.GUI.MinigameSetups.PlayerSelection;
import de.ventority.randomizedminigames.GUI.MinigameSetups.SetLimit;
import de.ventority.randomizedminigames.SelectMinigame;
import de.ventority.randomizedminigames.misc.DataInputHandler;
import de.ventority.randomizedminigames.misc.MinigameHandler;
@ -24,14 +25,14 @@ 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.getWhoClicked().closeInventory();
event.setCancelled(true);
if (getNBT(event.getCurrentItem(), "Action").equals("none"))
return;
if (getNBT(event.getCurrentItem(), "Type").equals("MinigameSelect")) {
handleMinigame(event, getNBT(event.getCurrentItem(), "Action"));
}
@ -58,6 +59,7 @@ public class GUIClickEvent implements Listener {
}
private void handleMinigame(InventoryClickEvent event, String action) {
event.getWhoClicked().closeInventory();
if (action.equals("openMinigameSetup")) {
RandomizedMinigames.dataInputHandler.setSelectedMinigame((Player) event.getWhoClicked(), Integer.parseInt(getNBT(event.getCurrentItem(), "selectedMinigame")));
new MinigameSetup((Player) event.getWhoClicked(), action).buildWindow();
@ -68,6 +70,7 @@ public class GUIClickEvent implements Listener {
}
private void handleSettings(InventoryClickEvent event, String action) {
event.getWhoClicked().closeInventory();
if (action.equals("selectSettings")) {
new SettingsWindow((Player)event.getWhoClicked(), "Settings");
}
@ -76,10 +79,12 @@ public class GUIClickEvent implements Listener {
private void handleMinigameSetup(InventoryClickEvent event, String action) {
if (action.equals("homeMenu")) {
new MinigamesDisplayWindow((Player) event.getWhoClicked(), "Minigame").buildWindow();
event.getWhoClicked().closeInventory();
new MinigameSetup((Player) event.getWhoClicked(), "Minigame").buildWindow();
}
if (action.equals("clickedPlayer")) {
DataInputHandler data = RandomizedMinigames.dataInputHandler;
if (action.equals("clickedPlayer")) {
Player toWork = Bukkit.getPlayer(getNBT(event.getCurrentItem(), "Player"));
if (data.getSelectedPlayers((Player) event.getWhoClicked()).contains(toWork)) {
data.removePlayersFromSelection((Player) event.getWhoClicked(), toWork);
@ -88,10 +93,34 @@ public class GUIClickEvent implements Listener {
}
new PlayerSelection((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
}
if (action.equals("subFromLimit")) {
data.subFromSelectedLimit((Player) event.getWhoClicked());
new SetLimit((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
}
if (action.equals("addToLimit")) {
data.addToSelectedLimit((Player) event.getWhoClicked());
new SetLimit((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
}
if (action.equals("startPlayerSelection")) {
event.getWhoClicked().closeInventory();
new PlayerSelection((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
}
if (action.equals("startLimitSelection")) {
event.getWhoClicked().closeInventory();
new SetLimit((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
}
if (action.equals("switchScoreboard")) {
data.switchScoreboard();
new MinigameSetup((Player) event.getWhoClicked(), "Minigame").buildWindow();
}
if (action.equals("startGame")) {
event.getWhoClicked().closeInventory();
MinigameHandler.createMinigame(RandomizedMinigames.dataInputHandler.getSelectedMinigame((Player) event.getWhoClicked()), (Player) event.getWhoClicked());
}
}

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

@ -1,6 +1,9 @@
package de.ventority.randomizedminigames.GUI.MinigameSetups;
import de.ventority.randomizedminigames.GUI.BaseWindow;
import de.ventority.randomizedminigames.RandomizedMinigames;
import de.ventority.randomizedminigames.misc.DataInputHandler;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
@ -13,13 +16,28 @@ public class MinigameSetup extends BaseWindow {
@Override
protected void fillGUI() {
ItemStack playerSelect = new ItemStack(Material.GOLD_INGOT);
ItemStack playerSelect = new ItemStack(Material.PLAYER_HEAD);
addNBT(playerSelect, "Type", "MinigameSetup");
addNBT(playerSelect, "Action", "startPlayerSelection");
addNBT(playerSelect, "selectedMinigame", status);
setItemName(playerSelect, "Select Players");
addItemToGUI(playerSelect);
ItemStack setLimit = new ItemStack(Material.BOOK);
addNBT(setLimit, "Type", "MinigameSetup");
addNBT(setLimit, "Action", "startLimitSelection");
addNBT(setLimit, "selectedMinigame", status);
setItemName(setLimit, "Set win limit");
addItemToGUI(setLimit);
DataInputHandler data = RandomizedMinigames.dataInputHandler;
ItemStack scoreboard = new ItemStack(Material.EMERALD);
addNBT(scoreboard, "Type", "MinigameSetup");
addNBT(scoreboard, "Action", "switchScoreboard");
addNBT(scoreboard, "selectedMinigame", status);
setItemName(scoreboard, "Scoreboard: " + (data.getScoreboardStatus() ? (ChatColor.GREEN + "On") : ChatColor.RED + "Off"));
addItemToGUI(scoreboard);
ItemStack start = new ItemStack(Material.GREEN_DYE);
addNBT(start, "Type", "MinigameSetup");
addNBT(start, "Action", "startGame");
@ -27,6 +45,7 @@ public class MinigameSetup extends BaseWindow {
setItemName(start, "Start");
addItemToGUI(50, start);
ItemStack back = new ItemStack(Material.ARROW);
addNBT(back, "Type", "MinigameSelect");
addNBT(back, "Action", "homeMenu");

44
src/main/java/de/ventority/randomizedminigames/GUI/MinigameSetups/SetLimit.java Normal file
View File

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

16
src/main/java/de/ventority/randomizedminigames/GUI/MinigameSetups/TeamOverview.java Normal file
View File

@ -0,0 +1,16 @@
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, String status) {
super(p, status);
}
@Override
protected void fillGUI() {
}
}

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

@ -5,6 +5,7 @@ import de.ventority.randomizedminigames.RandomizedMinigames;
import de.ventority.randomizedminigames.misc.MinigameHandler;
import de.ventority.randomizedminigames.misc.PlayerBackup;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.boss.BarColor;
@ -17,10 +18,13 @@ import org.bukkit.event.entity.EntityPickupItemEvent;
import org.bukkit.event.inventory.CraftItemEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
public class ForceItemBattle implements MinigameBase, Listener {
protected final HashMap<Player, ItemStack> currentItems;
@ -28,12 +32,37 @@ public class ForceItemBattle implements MinigameBase, Listener {
protected final HashMap<Player, BossBar> itemDisplays;
private final int id;
private GamesScoreboardManager scoreboardManager;
private final List<Player> contestants;
protected final List<Player> contestants;
private final HashMap<Player, PlayerBackup> backups;
private final Player owner;
protected final int limit;
private final List<Material> SURVIVAL_ITEMS = Arrays.stream(Material.values())
.filter(Material::isItem)
.filter(m -> {
String name = m.name();
return !name.contains("SPAWN_EGG") &&
!name.contains("COMMAND") &&
!name.contains("STRUCTURE") &&
!name.contains("JIGSAW") &&
!name.contains("DEBUG") &&
!name.contains("BARRIER") &&
!name.contains("KNOWLEDGE_BOOK") &&
!name.contains("LIGHT") &&
!name.contains("INFESTED") &&
!name.contains("BEDROCK") &&
!name.contains("VOID") &&
!name.contains("REINFORCED_DEEPSLATE") &&
!name.contains("END_PORTAL") &&
!name.contains("END_GATEWAY") &&
!name.contains("NETHER_PORTAL") &&
!name.contains("POTTED_") &&
!name.contains("MUSIC");
})
.toList();
public ForceItemBattle(List<Player> players, Player owner) {
limit = RandomizedMinigames.dataInputHandler.getSelectedLimit(owner);
id = new Random().nextInt(1024);
currentItems = new HashMap<>();
currentScores = new HashMap<>();
@ -41,6 +70,8 @@ public class ForceItemBattle implements MinigameBase, Listener {
backups = new HashMap<>();
contestants = players;
this.owner = owner;
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
scoreboardManager = new GamesScoreboardManager(players, getName());
for (Player player : players) {
currentItems.put(player, null);
currentScores.put(player, 0);
@ -48,10 +79,14 @@ public class ForceItemBattle implements MinigameBase, Listener {
bar.addPlayer(player);
bar.setVisible(true);
itemDisplays.put(player, bar);
updatePlayerItem(player);
updatePlayerItem(player, getRandomItem());
backups.put(player, new PlayerBackup(player.getInventory().getContents(), player.getInventory().getArmorContents(), player.getExp(), player.getLocation()));
ItemStack skip = new ItemStack(Material.BARRIER, 3);
ItemMeta meta = skip.getItemMeta();
meta.setDisplayName(ChatColor.RED + "Skip");
skip.setItemMeta(meta);
player.getInventory().addItem(skip);
}
scoreboardManager = new GamesScoreboardManager(players, getName());
}
@Override
@ -75,47 +110,40 @@ public class ForceItemBattle implements MinigameBase, Listener {
}
protected ItemStack getRandomItem() {
Material m;
do {
int i = new Random().nextInt(0, Material.values().length);
m = Material.values()[i];
} while (!m.isItem());
return new ItemStack(m);
return new ItemStack(SURVIVAL_ITEMS.get(new Random().nextInt(0, SURVIVAL_ITEMS.size())));
}
protected void checkItem(Player p, ItemStack i) {
if (i == null) return;
if (currentItems.get(p).getType() == i.getType()) {
currentScores.replace(p, currentScores.get(p) + 1);
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
scoreboardManager.setPunkte(p.getName(), scoreboardManager.getPunkte(p.getName()) + 1);
if (checkWin(p)) {
stopGame(p);
return;
}
updatePlayerItem(p);
updatePlayerItem(p, getRandomItem());
}
}
protected void updatePlayerItem(Player player) {
currentItems.replace(player, getRandomItem());
protected void updatePlayerItem(Player player, ItemStack 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();
for (ItemStack item : contents)
checkItem(player, item);
for (ItemStack i : contents)
checkItem(player, i);
}
private boolean checkWin(Player p) {
if (currentScores.get(p) == 3) {
return true;
}
return false;
protected boolean checkWin(Player p) {
return currentScores.get(p) == limit;
}
private void stopGame(Player winner) {
protected void showEndMessage(Player winner) {
for (Player player : contestants) {
if (player != winner) {
player.teleport(winner);
@ -123,23 +151,30 @@ public class ForceItemBattle implements MinigameBase, Listener {
player.sendTitle(winner.getDisplayName() + " won!", "Resetting players...", 10, 70, 20);
//restorePlayer(player);
}
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
}
}
private void stopGame(Player winner) {
showEndMessage(winner);
for (Player p : itemDisplays.keySet()) {
itemDisplays.get(p).setVisible(false);
itemDisplays.get(p).removePlayer(p);
}
itemDisplays.clear();
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus()) {
scoreboardManager.removeScoreboard();
scoreboardManager = null;
RandomizedMinigames.dataInputHandler.removeEntry(owner);
}
RandomizedMinigames.dataInputHandler.removeSelectionEntry(owner);
MinigameHandler.deleteGame(this);
}
private void removePlayer(Player p) {
itemDisplays.get(p).setVisible(false);
itemDisplays.get(p).removePlayer(p);
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
p.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
if (contestants.isEmpty())
stopGame(owner);
@ -147,13 +182,16 @@ public class ForceItemBattle implements MinigameBase, Listener {
public void killGame() {
for (Player player : contestants) {
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
}
itemDisplays.clear();
if (RandomizedMinigames.dataInputHandler.getScoreboardStatus()) {
scoreboardManager.removeScoreboard();
scoreboardManager = null;
RandomizedMinigames.dataInputHandler.removeEntry(owner);
}
RandomizedMinigames.dataInputHandler.removeSelectionEntry(owner);
MinigameHandler.deleteGame(this);
}
@ -170,6 +208,12 @@ public class ForceItemBattle implements MinigameBase, Listener {
return contestants;
}
public void skipItem(Player p) {
ItemStack curItem = currentItems.get(p);
p.getInventory().addItem(curItem);
checkItem(p, curItem);
}
@EventHandler
public void onItemPickup(EntityPickupItemEvent e) {
Player eventPlayer;
@ -189,6 +233,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
if (currentItems.containsKey(p))
checkItem(p, e.getCurrentItem());
}
@EventHandler
public void onPlayerLeave(PlayerQuitEvent e) {
if (contestants.contains(e.getPlayer())) {

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

@ -15,20 +15,20 @@ public class ForceItemBattleSameItems extends ForceItemBattle {
}
@Override
protected void updatePlayerItem(Player player) {
protected void updatePlayerItem(Player player, ItemStack item) {
if (this.items == null || this.items.isEmpty()) {
items = new ArrayList<>();
items.add(getRandomItem());
items.add(item);
}
if (currentScores.get(player) == items.size()) {
items.add(getRandomItem());
items.add(item);
}
currentItems.replace(player, items.get(currentScores.get(player)));
String key = currentItems.get(player).getType().getTranslationKey();
itemDisplays.get(player).setTitle(key.replace("block.minecraft.", "")
.replace("_", " ")
.replace("item.minecraft.", ""));
for (ItemStack item : player.getInventory().getContents())
checkItem(player, item);
for (ItemStack i : player.getInventory().getContents())
checkItem(player, i);
}
}

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

@ -1,13 +1,44 @@
package de.ventority.randomizedminigames.Minigames;
import net.md_5.bungee.api.ChatColor;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import java.util.List;
public class ForceItemBattleTeams extends ForceItemBattle{
private List<Team> teams;
private final List<Team> teams;
public ForceItemBattleTeams(List<Player> players, Player owner, List<Team> teams) {
super(players, owner);
this.teams = teams;
}
@Override
protected void updatePlayerItem(Player p, ItemStack item) {
for (Team team : teams) {
for (Player curPlayer : team.getPlayers()) {
super.updatePlayerItem(curPlayer, item);
}
}
}
@Override
protected void showEndMessage(Player winner) {
for (Player player : contestants) {
player.teleport(winner);
if (player != winner)
player.setGameMode(GameMode.SPECTATOR);
Team winningTeam = new Team(null, null);
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);
//restorePlayer(player);
player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
}
}
}

37
src/main/java/de/ventority/randomizedminigames/Minigames/Team.java
View File

@ -9,36 +9,23 @@ 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;
private final List<Player> players;
private final ChatColor color;
public Team(List<Player> members, ChatColor color) {
players = members;
this.color = color;
}
public List<Player> getPlayersOf(String team) {
return teams.get(team);
public List<Player> getPlayers() {
return players;
}
public void addPlayer(String team, Player p) {
teams.get(team).add(p);
public void addPlayer(Player p) {
players.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);
public ChatColor getColor() {
return color;
}
}

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

@ -1,18 +1,33 @@
package de.ventority.randomizedminigames;
import de.ventority.randomizedminigames.GUI.GUIClickEvent;
import de.ventority.randomizedminigames.Minigames.ForceItemBattle;
import de.ventority.randomizedminigames.Minigames.Minigame;
import de.ventority.randomizedminigames.Minigames.MinigameBase;
import de.ventority.randomizedminigames.misc.DataInputHandler;
import de.ventority.randomizedminigames.misc.MinigameHandler;
import org.bukkit.*;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.java.JavaPlugin;
public final class RandomizedMinigames extends JavaPlugin {
public final class RandomizedMinigames extends JavaPlugin implements Listener {
public static final ServerSettingsHandler serverSettingsHandler = new ServerSettingsHandler();
public static DataInputHandler dataInputHandler = new DataInputHandler();
@Override
public void onEnable() {
init();
getServer().getPluginManager().registerEvents(new GUIClickEvent(), this);
getServer().getPluginManager().registerEvents(this, this);
this.getCommand("minigames").setExecutor(new SelectMinigame());
for (World world : Bukkit.getWorlds()) {
world.setGameRule(GameRule.ANNOUNCE_ADVANCEMENTS, false);
}
}
@Override
@ -23,4 +38,28 @@ public final class RandomizedMinigames extends JavaPlugin {
private void init() {
serverSettingsHandler.setPlugin(this);
}
@EventHandler
public void onPlayerInteract(PlayerInteractEvent event) {
if (event.getAction() != Action.RIGHT_CLICK_AIR &&
event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
ItemStack item = event.getItem();
if (item == null || item.getType() != Material.BARRIER) return;
Player p = event.getPlayer();
try {
if (MinigameHandler.getMinigames().isEmpty()) return;
for (MinigameBase minigame : MinigameHandler.getMinigames()) {
if ((minigame instanceof ForceItemBattle) && minigame.getPlayers().contains(p)) {
((ForceItemBattle) minigame).skipItem(p);
}
}
} catch (Exception ignored) {
}
p.sendMessage(ChatColor.GREEN + "Skipped Item.");
if (item.getAmount() > 1)
item.setAmount(item.getAmount() - 1);
else
p.getInventory().remove(item);
event.setCancelled(true);
}
}

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

@ -1,14 +1,30 @@
package de.ventority.randomizedminigames;
import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigamesDisplayWindow;
import de.ventority.randomizedminigames.misc.MinigameHandler;
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");
window.buildWindow();
if (!(commandSender instanceof Player)) {
commandSender.sendMessage("Dieser Befehl kann nur von einem Spieler ausgeführt werden.");
return true;
}
Player player = (Player) commandSender;
if (args.length > 0 && args[0].equalsIgnoreCase("killall")) {
player.sendMessage("Alle Minigame-Instanzen werden beendet!");
MinigameHandler.killAll();
return true;
}
if (MinigameHandler.getOccupiedPlayers().contains(player)) {
return true;
}
new MinigamesDisplayWindow(player, "MinigameSelect").buildWindow();
return true;
}

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

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

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

@ -24,6 +24,13 @@ public class MinigameHandler {
getServer().getPluginManager().registerEvents(minigames.getFirst(), RandomizedMinigames.serverSettingsHandler.getPlugin());
}
public static List<MinigameBase> getMinigames() {
if (minigames.isEmpty()) {
return null;
}
return minigames;
}
public static void deleteGame(MinigameBase minigame) {
minigames.remove(minigame);
}