Initial commit

.gitignore

@@ -0,0 +1,4 @@
+# Project exclude paths
+/.gradle/
+/build/
+/build/classes/java/main/

build.gradle

@@ -0,0 +1,49 @@
+plugins {
+    id 'java'
+}
+
+group = 'de.ventority'
+version = '1.0-SNAPSHOT'
+
+repositories {
+    mavenCentral()
+    maven {
+        name = "spigotmc-repo"
+        url = "https://hub.spigotmc.org/nexus/content/repositories/snapshots/"
+    }
+    maven {
+        name = "sonatype"
+        url = "https://oss.sonatype.org/content/groups/public/"
+    }
+}
+
+dependencies {
+compileOnly "org.spigotmc:spigot-api:1.21-R0.1-SNAPSHOT"
+}
+
+def targetJavaVersion = 21
+java {
+    def javaVersion = JavaVersion.toVersion(targetJavaVersion)
+    sourceCompatibility = javaVersion
+    targetCompatibility = javaVersion
+    if (JavaVersion.current() < javaVersion) {
+        toolchain.languageVersion = JavaLanguageVersion.of(targetJavaVersion)
+    }
+}
+
+tasks.withType(JavaCompile).configureEach {
+    options.encoding = 'UTF-8'
+
+    if (targetJavaVersion >= 10 || JavaVersion.current().isJava10Compatible()) {
+        options.release.set(targetJavaVersion)
+    }
+}
+
+processResources {
+    def props = [version: version]
+    inputs.properties props
+    filteringCharset 'UTF-8'
+    filesMatching('plugin.yml') {
+        expand props
+    }
+}

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,249 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,92 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

@@ -0,0 +1 @@
+rootProject.name = 'RandomizedMinigames'

src/main/java/de/ventority/randomizedminigames/GUI/BossBarCreator.java

@@ -0,0 +1,81 @@
+package de.ventority.randomizedminigames.GUI;
+
+import org.bukkit.Bukkit;
+import org.bukkit.boss.*;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+public class BossBarCreator {
+
+    private final Player player;
+    private final BossBar bossBar;
+
+    public BossBarCreator(Player player, String initialTitle) {
+        this.player = player;
+        this.bossBar = Bukkit.createBossBar(
+                initialTitle,
+                BarColor.PURPLE,
+                BarStyle.SOLID
+        );
+
+        bossBar.setProgress(1.0);
+        bossBar.setVisible(true);
+        bossBar.addPlayer(player);
+    }
+
+    /**
+     * Setzt den Titel der BossBar.
+     *
+     * @param title Neuer Titel (Farbcodes mit & erlaubt)
+     */
+    public void setTitle(String title) {
+        bossBar.setTitle(ChatColor.translateAlternateColorCodes('&', title));
+    }
+
+    /**
+     * Setzt den Fortschritt der BossBar (0.0 bis 1.0).
+     */
+    public void setProgress(double progress) {
+        bossBar.setProgress(Math.max(0.0, Math.min(1.0, progress)));
+    }
+
+    /**
+     * Blendet die BossBar ein.
+     */
+    public void show() {
+        bossBar.setVisible(true);
+        if (!bossBar.getPlayers().contains(player)) {
+            bossBar.addPlayer(player);
+        }
+    }
+
+    /**
+     * Blendet die BossBar aus.
+     */
+    public void hide() {
+        bossBar.setVisible(false);
+        bossBar.removePlayer(player);
+    }
+
+    /**
+     * Entfernt die BossBar vollständig.
+     */
+    public void destroy() {
+        hide();
+        bossBar.removeAll();
+    }
+
+    /**
+     * Ändert die Farbe der BossBar.
+     */
+    public void setColor(BarColor color) {
+        bossBar.setColor(color);
+    }
+
+    /**
+     * Ändert den Stil der BossBar.
+     */
+    public void setStyle(BarStyle style) {
+        bossBar.setStyle(style);
+    }
+}

src/main/java/de/ventority/randomizedminigames/GUI/GUIClickEvent.java

@@ -0,0 +1,40 @@
+package de.ventority.randomizedminigames.GUI;
+
+
+import de.ventority.randomizedminigames.MinigameHandler;
+import de.ventority.randomizedminigames.RandomizedMinigames;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+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 GUIClickEvent implements Listener {
+    @EventHandler
+    public void onClickEvent(InventoryClickEvent event) {
+        Inventory inventory = event.getInventory();
+        if (inventory.getItem(0) == null) return;
+        if (hasNBTData(inventory.getItem(0))) {
+            if (event.getCurrentItem() == null) return;
+            if (event.getCurrentItem().getType() == Material.DIAMOND_SWORD) {
+                MinigameHandler.createMinigame(0);
+            }
+        }
+    }
+
+    private boolean hasNBTData(ItemStack item) {
+        if (item == null || !item.hasItemMeta()) return false;
+
+        ItemMeta meta = item.getItemMeta();
+        NamespacedKey key = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), "IsMinigamePlugin");
+        if (meta == null) return false;
+        PersistentDataContainer data = meta.getPersistentDataContainer();
+        return "1".equals(data.get(key, PersistentDataType.STRING));
+    }
+}

src/main/java/de/ventority/randomizedminigames/GUI/GamesScoreboardManager.java

@@ -0,0 +1,75 @@
+package de.ventority.randomizedminigames.GUI;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.scoreboard.*;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class GamesScoreboardManager {
+
+    private final Map<String, Integer> punkteMap = new HashMap<>();
+    private final Scoreboard scoreboard;
+    private final Objective objective;
+
+    public GamesScoreboardManager(List<Player> spielerListe, String gameName) {
+        // Neues Scoreboard erstellen
+        org.bukkit.scoreboard.ScoreboardManager manager = Bukkit.getScoreboardManager();
+        scoreboard = manager.getNewScoreboard();
+
+        // Objective erstellen (Sidebar)
+        objective = scoreboard.registerNewObjective("punkteboard", Criteria.DUMMY, "§6" + gameName);
+        objective.setDisplaySlot(DisplaySlot.SIDEBAR);
+
+        // Alle Spieler hinzufügen und Punktzahl setzen
+        for (Player spieler : spielerListe) {
+            punkteMap.put(spieler.getName(), 0);
+            aktualisiereScore(spieler.getName());
+            spieler.setScoreboard(scoreboard);
+        }
+    }
+
+    /**
+     * Setzt die Punktzahl eines Spielers neu.
+     * Wenn der Spieler noch nicht vorhanden ist, wird er hinzugefügt.
+     */
+    public void setPunkte(String spielerName, int punkte) {
+        punkteMap.put(spielerName, punkte);
+        aktualisiereScore(spielerName);
+    }
+
+    /**
+     * Holt die aktuelle Punktzahl eines Spielers.
+     */
+    public int getPunkte(String spielerName) {
+        return punkteMap.getOrDefault(spielerName, 0);
+    }
+
+    /**
+     * Interne Methode zum Aktualisieren des Scores im Scoreboard.
+     */
+    private void aktualisiereScore(String spielerName) {
+        Score score = objective.getScore(spielerName);
+        score.setScore(punkteMap.get(spielerName));
+    }
+
+    /**
+     * Gibt Zugriff auf das Scoreboard.
+     */
+    public Scoreboard getScoreboard() {
+        return scoreboard;
+    }
+    public void removeScoreboard() {
+        org.bukkit.scoreboard.Scoreboard leeresScoreboard = Bukkit.getScoreboardManager().getNewScoreboard();
+        for (String spielerName : punkteMap.keySet()) {
+            Player spieler = Bukkit.getPlayerExact(spielerName);
+            if (spieler != null && spieler.isOnline()) {
+                spieler.setScoreboard(leeresScoreboard);
+            }
+        }
+        objective.unregister();
+        punkteMap.clear();
+    }
+}

src/main/java/de/ventority/randomizedminigames/GUI/MinigamesDisplayWindow.java

@@ -0,0 +1,70 @@
+package de.ventority.randomizedminigames.GUI;
+
+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 {
+    private final Player p;
+    private final Inventory gui;
+    private String status;
+
+    public MinigamesDisplayWindow(Player p, String status) {
+        this.p = p;
+        gui = Bukkit.createInventory(p, 54, RandomizedMinigames.serverSettingsHandler.getServerName()
+                + ChatColor.RESET + ChatColor.DARK_GRAY + " Minigames");
+        this.status = status;
+    }
+
+    public void buildWindow() {
+        fillBorder();
+        fillGUI();
+        addNBT();
+        p.openInventory(gui);
+    }
+
+    private void fillGUI() {
+        gui.addItem(new ItemStack(Material.DIAMOND_SWORD));
+    }
+
+    private void fillBorder() {
+        ItemStack stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
+        ItemMeta meta = stack.getItemMeta();
+        meta.setDisplayName(" ");
+        for (int i = 0; i < 9; i++) {
+            gui.setItem(i, new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1));
+            gui.getItem(i).setItemMeta(meta);
+        }
+        for (int i = 1; i < 5; i++) {
+            gui.setItem(9 * i, new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1));
+            gui.getItem(9 * i).setItemMeta(meta);
+            gui.setItem(8 + 9 * i, new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1));
+            gui.getItem(8 + 9 * i).setItemMeta(meta);
+        }
+        for (int i = 0; i < 9; i++) {
+            gui.setItem(i + 5 * 9, new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1));
+            gui.getItem(i + 5 * 9).setItemMeta(meta);
+        }
+    }
+
+    private void addNBT() {
+        ItemStack item = gui.getItem(0);
+        assert item != null;
+        ItemMeta meta = item.getItemMeta();
+        NamespacedKey key1 = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), "Status");
+        NamespacedKey key2 = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), "IsMinigamePlugin");
+        assert meta != null;
+        PersistentDataContainer data = meta.getPersistentDataContainer();
+        data.set(key1, PersistentDataType.STRING, status);
+        data.set(key2, PersistentDataType.STRING, "1");
+        item.setItemMeta(meta);
+    }
+}

src/main/java/de/ventority/randomizedminigames/MinigameHandler.java

@@ -0,0 +1,25 @@
+package de.ventority.randomizedminigames;
+
+import de.ventority.randomizedminigames.GUI.GUIClickEvent;
+import de.ventority.randomizedminigames.Minigames.ItemForceBattle;
+import de.ventority.randomizedminigames.Minigames.Minigame;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.bukkit.Bukkit.getServer;
+
+public class MinigameHandler {
+    private static List<Minigame> minigames = new ArrayList<>();
+
+    public static void createMinigame(int gameNumber) {
+        List<Player> players = Bukkit.getOnlinePlayers().stream().map(p -> ((Player) p)).toList();
+        minigames.add(new ItemForceBattle(players));
+        getServer().getPluginManager().registerEvents(minigames.getFirst(), RandomizedMinigames.serverSettingsHandler.getPlugin());
+    }
+
+    public static void deleteGame(Minigame minigame) {
+        minigames.remove(minigame);
+    }
+}

src/main/java/de/ventority/randomizedminigames/Minigames/ItemForceBattle.java

@@ -0,0 +1,157 @@
+package de.ventority.randomizedminigames.Minigames;
+
+import de.ventority.randomizedminigames.GUI.GamesScoreboardManager;
+import de.ventority.randomizedminigames.MinigameHandler;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Material;
+import org.bukkit.boss.BarColor;
+import org.bukkit.boss.BarStyle;
+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.EntityPickupItemEvent;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Random;
+
+public class ItemForceBattle implements Minigame, Listener {
+    private final HashMap<Player, ItemStack> currentItems;
+    private final HashMap<Player, Integer> currentScores;
+    private final HashMap<Player, BossBar> itemDisplays;
+    private final int id;
+    private GamesScoreboardManager scoreboardManager;
+    private final List<Player> contestants;
+
+
+    public ItemForceBattle(List<Player> players) {
+        id = new Random().nextInt(1024);
+        currentItems = new HashMap<>();
+        currentScores = new HashMap<>();
+        itemDisplays = new HashMap<>();
+        contestants = players;
+        for (Player player : players) {
+            currentItems.put(player, null);
+            currentScores.put(player, 0);
+            BossBar bar = Bukkit.createBossBar("Hallo", BarColor.PURPLE, BarStyle.SOLID);
+            bar.addPlayer(player);
+            bar.setVisible(true);
+            bar.setTitle("Das ist ein Test");
+            itemDisplays.put(player, bar);
+            System.out.println(itemDisplays.get(player).getTitle());
+            updatePlayerItem(player);
+        }
+        scoreboardManager = new GamesScoreboardManager(players, getName());
+    }
+
+    @Override
+    public int getID() {
+        return id;
+    }
+
+    @Override
+    public String getName() {
+        return "Force Item Battle";
+    }
+
+    @Override
+    public int getPlayerIntervals() {
+        return 0;
+    }
+
+    @Override
+    public int getMinPlayers() {
+        return 2;
+    }
+
+    @Override
+    public int getMaxPlayers() {
+        return -1;
+    }
+
+    @Override
+    public ItemStack getSymbol() {
+        return new ItemStack(Material.DIAMOND_SWORD, 1);
+    }
+
+    @Override
+    public void addPlayers(List<Player> players) {
+
+    }
+
+    private 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);
+    }
+
+    private void checkItem(Player p, ItemStack i) {
+        if (i == null) return;
+        if (currentItems.get(p).getType() == i.getType()) {
+            currentScores.replace(p, currentScores.get(p) + 1);
+            scoreboardManager.setPunkte(p.getName(), scoreboardManager.getPunkte(p.getName()) + 1);
+            if (checkWin(p)) {
+                stopGame(p);
+            }
+            updatePlayerItem(p);
+        }
+    }
+
+    private void updatePlayerItem(Player player) {
+        currentItems.replace(player, getRandomItem());
+        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);
+    }
+
+    private boolean checkWin(Player p) {
+        if (currentScores.get(p) == 3) {
+            System.out.println(currentScores.get(p) + ", " + p.getName() + " wins");
+            return true;
+        }
+        return false;
+    }
+
+    private void stopGame(Player winner) {
+        for (Player player : contestants) {
+            if (player != winner) {
+                player.teleport(winner);
+                player.setGameMode(GameMode.SPECTATOR);
+                
+            }
+        }
+        for (Player p : itemDisplays.keySet()) {
+            itemDisplays.get(p).setVisible(false);
+            itemDisplays.get(p).removePlayer(p);
+        }
+        itemDisplays.clear();
+
+        scoreboardManager.removeScoreboard();
+        scoreboardManager = null;
+        MinigameHandler.deleteGame(this);
+    }
+
+    @EventHandler
+    public void onItemPickup(EntityPickupItemEvent e) {
+        Player eventPlayer;
+        if (e.getEntity() instanceof Player)
+            eventPlayer = (Player) e.getEntity();
+        else
+            return;
+        if (currentItems.containsKey(eventPlayer))
+            if (e.getItem().getItemStack().getType() == currentItems.get(eventPlayer).getType())
+                checkItem(eventPlayer, e.getItem().getItemStack());
+    }
+}

src/main/java/de/ventority/randomizedminigames/Minigames/Minigame.java

@@ -0,0 +1,17 @@
+package de.ventority.randomizedminigames.Minigames;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.List;
+
+public interface Minigame extends Listener {
+    int getID();
+    String getName();
+    int getPlayerIntervals();
+    int getMinPlayers();
+    int getMaxPlayers();
+    ItemStack getSymbol();
+    void addPlayers(List<Player> players);
+}

src/main/java/de/ventority/randomizedminigames/RandomizedMinigames.java

@@ -0,0 +1,28 @@
+package de.ventority.randomizedminigames;
+
+import de.ventority.randomizedminigames.GUI.GUIClickEvent;
+import de.ventority.randomizedminigames.Minigames.ItemForceBattle;
+import de.ventority.randomizedminigames.Minigames.Minigame;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class RandomizedMinigames extends JavaPlugin {
+    public static final ServerSettingsHandler serverSettingsHandler = new ServerSettingsHandler();
+    @Override
+    public void onEnable() {
+        init();
+        getServer().getPluginManager().registerEvents(new GUIClickEvent(), this);
+        this.getCommand("minigames").setExecutor(new SelectMinigame());
+    }
+
+    @Override
+    public void onDisable() {
+        // Plugin shutdown logic
+    }
+
+    private void init() {
+        serverSettingsHandler.setPlugin(this);
+    }
+}

src/main/java/de/ventority/randomizedminigames/SelectMinigame.java

@@ -0,0 +1,15 @@
+package de.ventority.randomizedminigames;
+
+import de.ventority.randomizedminigames.GUI.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");
+        window.buildWindow();
+        return true;
+    }
+
+}

src/main/java/de/ventority/randomizedminigames/ServerSettingsHandler.java

@@ -0,0 +1,36 @@
+package de.ventority.randomizedminigames;
+
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginManager;
+
+public class ServerSettingsHandler {
+    private PluginManager pm;
+    private Plugin plugin;
+
+    private String ServerName = "§lServerName§7";
+
+
+    public void setPluginManager(PluginManager pm) {
+        this.pm = pm;
+    }
+
+    public void setServerName(String ServerName) {
+        this.ServerName = ServerName;
+    }
+
+    public void setPlugin(Plugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public String getServerName() {
+        return ServerName;
+    }
+
+    public PluginManager getPluginManager() {
+        return pm;
+    }
+
+    public Plugin getPlugin() {
+        return plugin;
+    }
+}

src/main/resources/plugin.yml

@@ -0,0 +1,6 @@
+name: RandomizedMinigames
+version: '${version}'
+main: de.ventority.randomizedminigames.RandomizedMinigames
+api-version: '1.21'
+commands:
+  minigames: