Initial Commit

.gitea/workflows/build.yml

@@ -0,0 +1,67 @@
+name: Build Plugin
+run-name: Build Plugin with maven
+on:
+  push:
+    branches:
+      - '*'
+    tags:
+      - 'v*'
+
+jobs:
+  build-test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Install Tools
+        run: apt update -y && apt install -y maven
+      - name: Build
+        run: mvn clean package
+      - name: Upload
+        uses: actions/upload-artifact@v3
+        with:
+          name: LSServerManager
+          path: target/LSServerManager*.jar
+      - name: Create Pre Release
+        run: |
+          FILES=./target/LSServerManager*.jar
+          USER=LagacySurvival
+          REPO=ServerManager
+          # Set up variables
+          AUTH_HEADER="Authorization: token ${{ secrets.TOKEN }}"
+          CONTENT_TYPE="Content-Type: application/json"
+          API_URL="https://dev.npid7.de/api/v1/repos/$USER/$REPO/releases"
+          COMMIT_HASH=$(git rev-parse --short HEAD)
+          AUTHOR_NAME=$(git log -1 --pretty=format:'%an')
+          COMMIT_SUBJECT=$(git log -1 --pretty=format:'%s')
+          COMMIT_MESSAGE=$(git log -1 --pretty=format:'%b')
+          DATETIME=$(date +'%Y%m%d_%H%M')
+          echo "Create Release"
+          RELEASE_INFO="{\"tag_name\": \"p$DATETIME\", \"name\": \"Test | $COMMIT_HASH\", \"body\": \"$AUTHOR_NAME - $COMMIT_SUBJECT\\n\\n$COMMIT_MESSAGE\", \"prerelease\": true}"
+          RESPONSE=$(curl -s -X POST -H "$AUTH_HEADER" -H "$CONTENT_TYPE" -d "$RELEASE_INFO" "$API_URL")
+          RELEASE_ID=$(echo $RESPONSE | jq --raw-output '.id')
+          echo "Release created with ID: $RELEASE_ID"
+          if [ "$RELEASE_ID" == "null" ]; then
+            echo "Failed to create release."
+            exit 1
+          fi
+          echo "Upload File/s"
+          for file in $FILES; do
+            if [ -f "$file" ]; then
+              FILE_NAME=$(basename "$file")
+              FILE_PATH="$file"
+              FILE_SIZE=$(stat -c%s "$FILE_PATH")
+              UPLOAD_URL="https://dev.npid7.de/api/v1/repos/$USER/$REPO/releases/$RELEASE_ID/assets?name=$FILE_NAME"
+              CONTENT_LENGTH="Content-Length: $FILE_SIZE"
+              CONTENT_TYPE="Content-Type: application/7z-x-compressed"
+              echo "Uploading asset: $FILE_NAME"
+              RESPONSE=$(curl -s -X POST -H "Authorization: token ${{ secrets.TOKEN }}" \
+                -H "$CONTENT_LENGTH" -H "$CONTENT_TYPE" \
+                --upload-file "$FILE_PATH" "$UPLOAD_URL")
+              if echo "$RESPONSE" | jq -e '.message' >/dev/null; then
+                echo "Error uploading $FILE_NAME: $(echo "$RESPONSE" | jq -r .message)"
+                exit 1
+              fi
+              echo "Successfully uploaded $FILE_NAME"
+            fi
+          done          

.gitignore

@@ -0,0 +1,113 @@
+# User-specific stuff
+.idea/
+
+*.iml
+*.ipr
+*.iws
+
+# IntelliJ
+out/
+
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+target/
+
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+.mvn/wrapper/maven-wrapper.jar
+.flattened-pom.xml
+
+# Common working directory
+run/

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "java.compile.nullAnalysis.mode": "automatic",
+    "java.configuration.updateBuildConfiguration": "interactive"
+}

pom.xml

@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://www.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>de.survivalprojekt</groupId>
+    <artifactId>LSServerManager</artifactId>
+    <version>1.0</version>
+    <packaging>jar</packaging>
+
+    <name>LSServerManager</name>
+
+    <properties>
+        <java.version>17</java.version>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <repositories>
+        <!-- Spigot Repository -->
+        <repository>
+            <id>spigotmc-repo</id>
+            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
+        </repository>
+
+        <!-- Adventure Releases -->
+        <repository>
+            <id>kyori</id>
+            <url>https://s01.oss.sonatype.org/content/repositories/releases/</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <!-- Spigot-API für die Bukkit-Integration -->
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-api</artifactId>
+            <version>1.21.1-R0.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <!-- Adventure API (für MiniMessage und Adventure-Integration) -->
+        <dependency>
+            <groupId>net.kyori</groupId>
+            <artifactId>adventure-api</artifactId>
+            <version>4.14.0</version>
+        </dependency>
+
+        <!-- MiniMessage Unterstützung -->
+        <dependency>
+            <groupId>net.kyori</groupId>
+            <artifactId>adventure-text-minimessage</artifactId>
+            <version>4.14.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>net.kyori</groupId>
+            <artifactId>adventure-text-serializer-legacy</artifactId>
+            <version>4.14.0</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <defaultGoal>clean package</defaultGoal>
+        <plugins>
+            <!-- Compiler Plugin für Java -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.10.1</version>
+                <configuration>
+                    <source>${java.version}</source>
+                    <target>${java.version}</target>
+                </configuration>
+            </plugin>
+
+            <!-- Shade Plugin für Abhängigkeiten -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.4.1</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

src/main/java/de/survivalprojekt/LS/Commands/MotdCommand.java

@@ -0,0 +1,31 @@
+package de.survivalprojekt.LS.Commands;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import de.survivalprojekt.LS.ServerManager;
+
+public class MotdCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (args.length == 1) {
+            if (args[0].equals("reload")) {
+                if (!sender.hasPermission("lss.motd.reload")) {
+                    sender.sendMessage("§cDu hast keine Berechtigung dafür!");
+                    return false;
+                }
+
+                ServerManager.getInst().getMotdManager().reloadMotd();
+                sender.sendMessage("§aMOTD erfolgreich neu geladen.");
+                return true;
+            }
+
+            sender.sendMessage("§cUnbekanter Sub Command!");
+            return false;
+        } else {
+            sender.sendMessage("§cZu viele oder zu wenige argumente!");
+        }
+        return false;
+    }
+}

src/main/java/de/survivalprojekt/LS/Commands/WartungsCommand.java

@@ -0,0 +1,54 @@
+package de.survivalprojekt.LS.Commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import de.survivalprojekt.LS.ServerManager;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+
+public class WartungsCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        ServerManager inst = ServerManager.getInst();
+        if (args.length == 1) {
+            if (args[0].equals("an")) {
+                inst.getWartungsManager().setIsWartung(true);
+                inst.getWartungsManager().save();
+                for (Player pl : Bukkit.getOnlinePlayers()) {
+                    if (!pl.hasPermission("lss.wartung.bypass")) {
+                        String kickMessage = inst.getWartungsManager().getKickMsg();
+                        MiniMessage miniMessage = MiniMessage.miniMessage();
+                        Component kickComponent = miniMessage.deserialize(kickMessage);
+
+                        pl.kickPlayer(LegacyComponentSerializer.legacySection().serialize(kickComponent));
+                    } else {
+                        pl.sendMessage("§aDer Wartungsmodus wurde aktiviert.");
+                    }
+                }
+            } else if (args[0].equals("aus")) {
+                inst.getWartungsManager().setIsWartung(false);
+                inst.getWartungsManager().save();
+                for (Player pl : Bukkit.getOnlinePlayers()) {
+                    if (pl.hasPermission("lss.wartung.bypass")) {
+                        pl.sendMessage("§cDer Wartungsmodus wurde deaktiviert.");
+                    }
+                }
+            } else if (args[0].equals("reload")) {
+                inst.getWartungsManager().reloadWartung();
+                sender.sendMessage("§aWartungskonfiguration wurde neu geladen.");
+            } else {
+                sender.sendMessage("§cUngültiges argument: " + args[0]);
+                return false;
+            }
+        } else {
+            sender.sendMessage("§cZu viele oder zu wenige argumente!");
+            return false;
+        }
+        return true;
+    }
+}

src/main/java/de/survivalprojekt/LS/Commands/WhitelistCommand.java

@@ -0,0 +1,55 @@
+package de.survivalprojekt.LS.Commands;
+
+import de.survivalprojekt.LS.ServerManager;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class WhitelistCommand implements CommandExecutor {
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        ServerManager inst = ServerManager.getInst();
+        if (args.length > 0) {
+            if (args[0].equals("add")) {
+                if (args.length == 2) {
+                    if (!inst.getWhitelistManager().addPlayer(args[1])) {
+                        sender.sendMessage("§cSpeiler " + args[1] + " konnte nicht hinzugefügt werden!");
+                    } else {
+                        sender.sendMessage("§aSpeiler " + args[1] + " wurde hinzugefügt!");
+                    }
+                    return true;
+                }
+            } else if (args[0].equals("remove")) {
+                if (args.length == 2) {
+                    if (!inst.getWhitelistManager().removePlayer(args[1])) {
+                        sender.sendMessage("§cSpeiler " + args[1] + " konnte nicht entfernt!");
+                    } else {
+                        sender.sendMessage("§aSpeiler " + args[1] + " wurde entfernt!");
+                    }
+                    return true;
+                }
+            } else if (args[0].equals("enable")) {
+                inst.getWhitelistManager().setWhitelistEnabled(true);
+                sender.sendMessage("§cWhitelist wurde deaktiviert.");
+            } else if (args[0].equals("disable")) {
+                inst.getWhitelistManager().setWhitelistEnabled(false);
+                sender.sendMessage("§aWhitelist wurde aktiviert.");
+            } else if (args[0].equals("reload")) {
+                inst.getWhitelistManager().reload();
+                sender.sendMessage("§aWartungskonfiguration wurde neu geladen.");
+            } else {
+                sender.sendMessage("§cUngültiges argument: " + args[0]);
+                return false;
+            }
+        } else {
+            sender.sendMessage("§cZu viele oder zu wenige argumente!");
+            return false;
+        }
+        return true;
+    }
+}

src/main/java/de/survivalprojekt/LS/Listeners/PlayerListener.java

@@ -0,0 +1,48 @@
+package de.survivalprojekt.LS.Listeners;
+
+import java.util.UUID;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.bukkit.event.player.PlayerLoginEvent;
+
+import de.survivalprojekt.LS.ServerManager;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+
+public class PlayerListener implements Listener {
+    @EventHandler
+    public void onPlayerLogin(PlayerLoginEvent e) {
+        Player pl = e.getPlayer();
+        ServerManager inst = ServerManager.getInst();
+        if (inst.getWartungsManager().getIsWartung()) {
+            if (pl.hasPermission("lss.wartung.bypass")) {
+                inst.getLogger().info(pl.getName() + " hat die Berechtigung 'lss.wartung.bypass' und darf joinen.");
+                e.allow();
+                return;
+            }
+            String kickMsg = inst.getWartungsManager().getKickMsg();
+            MiniMessage miniMessage = MiniMessage.miniMessage();
+            Component kickComponent = miniMessage.deserialize(kickMsg);
+
+            // Spieler wird sauber gekickt ??? DEUTSCHKURS DF ?????
+            e.disallow(PlayerLoginEvent.Result.KICK_OTHER,
+                    LegacyComponentSerializer.legacySection().serialize(kickComponent));
+            return;
+        }
+        if (inst.getWhitelistManager().getWhitelistEnabled()) {
+            String uuid = pl.getUniqueId().toString();
+            if (!inst.getWhitelistManager().isWhitelisted(UUID.fromString(uuid))) {
+                String rawMessage = inst.getWhitelistManager().getMessage();
+                MiniMessage miniMessage = MiniMessage.miniMessage();
+                Component messageComponent = miniMessage.deserialize(rawMessage);
+                e.disallow(PlayerLoginEvent.Result.KICK_OTHER,
+                        LegacyComponentSerializer.legacySection().serialize(messageComponent));
+            }
+        }
+
+    }
+}

src/main/java/de/survivalprojekt/LS/Listeners/ServerListListener.java

@@ -0,0 +1,59 @@
+package de.survivalprojekt.LS.Listeners;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.server.ServerListPingEvent;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+
+import de.survivalprojekt.LS.ServerManager;
+
+public class ServerListListener implements Listener {
+    @EventHandler
+    public void onServerListPing(ServerListPingEvent event) {
+        ServerManager inst = ServerManager.getInst();
+
+        if(inst.getWartungsManager().getIsWartung()) {
+            String wartung = inst.getWartungsManager().getMotd();
+            MiniMessage miniMessage = MiniMessage.miniMessage();
+            Component motdComponent = miniMessage.deserialize(wartung);
+            event.setMotd(LegacyComponentSerializer.legacySection().serialize(motdComponent));
+            event.setMaxPlayers(0);
+            try {
+                event.setServerIcon(null); // Zeigt kein Server-Icon
+            } catch (Exception e) {
+                inst.getLogger().warning("Konnte das Server-Icon nicht setzen: " + e.getMessage());
+            }
+            return;
+        }
+        
+        String motd = inst.getMotdManager().getMotd();
+        if (motd != null) {
+            MiniMessage miniMessage = MiniMessage.miniMessage();
+            Component motdComponent = miniMessage.deserialize(motd);
+            event.setMotd(LegacyComponentSerializer.legacySection().serialize(motdComponent));
+        }
+
+        // Lade das Logo aus dem Logos-Ordner
+        File logoFile = new File(inst.getDataFolder() + "/" + inst.getMotdManager().getFolderName() + "/"
+                + inst.getMotdManager().getIconName());
+        if (logoFile.exists()) {
+            try {
+                event.setServerIcon(Bukkit.loadServerIcon(logoFile));
+            } catch (IOException e) {
+                inst.getLogger().severe("Fehler beim Laden des Server-Icons: " + e.getMessage());
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        } else {
+            inst.getLogger()
+                    .warning("Das Logo 'server-icon.png' wurde im Logos-Ordner nicht gefunden.");
+        }
+    }
+}

src/main/java/de/survivalprojekt/LS/Managers/MotdManager.java

@@ -0,0 +1,87 @@
+package de.survivalprojekt.LS.Managers;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import de.survivalprojekt.LS.ServerManager;
+
+public class MotdManager {
+    final String folderName = "serevricon";
+    final String iconName = "server-icon.png";
+    File motdFile;
+
+    public MotdManager() {
+        initFiles();
+    }
+
+    private void initFiles() {
+        ServerManager inst = ServerManager.getInst();
+        /////// SETUP CONFIG ///////
+        motdFile = new File(inst.getDataFolder(), "motd.yml");
+        if (!motdFile.exists()) {
+            try (InputStream inputStream = inst.getResource("motd.yml")) {
+                if (inputStream != null) {
+                    Files.copy(inputStream, motdFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
+                    inst.getLogger().info("Die Standard-MOTD-Konfigurationsdatei wurde erstellt.");
+                } else {
+                    inst.getLogger().warning("Standart MOTD-Konfigurationsdatei konnte nicht gefunden werden.");
+                }
+            } catch (IOException e) {
+                inst.getLogger().severe("Fehler beim erstellen der MOTD-Konfigurationsdatei: " + e.getMessage());
+            }
+        }
+        /////// SETUP LOGO ///////
+        // Erstelle ordner, falss noch nicht vorhanden
+        File logoFolder = new File(inst.getDataFolder() + "/" + folderName);
+        if (!logoFolder.exists()) {
+            logoFolder.mkdirs();
+            inst.getLogger().info("Der Ordner " + folderName + " wurde erstellt.");
+        }
+        File logoFile = new File(logoFolder, iconName);
+        // Kopiere das Standardlogo, falls nicht vorhanden
+        if (!logoFile.exists()) {
+            try (InputStream inputStream = inst.getResource(iconName)) {
+                if (inputStream != null) {
+                    Files.copy(inputStream, logoFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
+                    inst.getLogger().info("Das Standard-Server-Icon wurde im " + folderName + " Ordner erstellt.");
+                } else {
+                    inst.getLogger().warning("Standard-Logo " + iconName + " konnte nicht gefunden werden.");
+                }
+            } catch (IOException e) {
+                inst.getLogger().severe("Fehler beim Einrichten des Standard-Server-Icons: " + e.getMessage());
+            }
+        }
+    }
+
+    public void reloadMotd() {
+        ServerManager inst = ServerManager.getInst();
+        motdFile = new File(inst.getDataFolder(), "motd.yml");
+        if (!motdFile.exists()) {
+            initFiles();
+        }
+        inst.getLogger().info("MOTD-Konfiguration wurde neu geladen.");
+    }
+
+    public String getMotd() {
+        FileConfiguration motdConfig = YamlConfiguration.loadConfiguration(motdFile);
+
+        if (motdConfig.contains("motd")) {
+            return motdConfig.getString("motd");
+        }
+        return null;
+    }
+
+    public String getFolderName() {
+      return this.folderName;
+    }
+
+    public String getIconName() {
+      return this.iconName;
+    }
+}

src/main/java/de/survivalprojekt/LS/Managers/WartungsManager.java

@@ -0,0 +1,76 @@
+package de.survivalprojekt.LS.Managers;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import de.survivalprojekt.LS.ServerManager;
+
+public class WartungsManager {
+
+    File wartungsFile;
+    FileConfiguration wartungsConfig;
+    boolean isWartung;
+
+    public WartungsManager() {
+        initFile();
+    }
+
+    private void initFile() {
+        ServerManager inst = ServerManager.getInst();
+        /////// SETUP CONFIG ///////
+        wartungsFile = new File(inst.getDataFolder(), "wartung.yml");
+        if (!wartungsFile.exists()) {
+            try (InputStream inputStream = inst.getResource("wartung.yml")) {
+                if (inputStream != null) {
+                    Files.copy(inputStream, wartungsFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
+                    inst.getLogger().info("Die Standard-Wartungs-Konfigurationsdatei wurde erstellt.");
+                } else {
+                    inst.getLogger().warning("Standart Wartungs-Konfigurationsdatei konnte nicht gefunden werden.");
+                }
+            } catch (IOException e) {
+                inst.getLogger().severe("Fehler beim erstellen der Wartungs-Konfigurationsdatei: " + e.getMessage());
+            }
+        }
+        wartungsConfig = YamlConfiguration.loadConfiguration(wartungsFile);
+        isWartung = wartungsConfig.getBoolean("wartungsModus", false);
+        ///// GIBT KEINEN GRUND JEDEN SCHEISS ZU LOGGEN /////
+        /// DAFÜR GIBT ES FUCKING ERROR MESSAGES /////
+        inst.getLogger().info("Wartungs-Konfiguration wurde <neu> geladen.");
+    }
+
+    public void reloadWartung() {
+        initFile();
+    }
+
+    public void save() {
+        wartungsConfig.set("wartungsModus", isWartung);
+        try {
+            wartungsConfig.save(wartungsFile);
+        } catch (IOException e) {
+            ServerManager.getInst().getLogger()
+                    .severe("Fehler beim speichern der Wartungskonfigurationsdatei: " + e.getMessage());
+        }
+    }
+
+    public String getMotd() {
+        return wartungsConfig.getString("wartungsMotd");
+    }
+
+    public String getKickMsg() {
+        return wartungsConfig.getString("kickMessage");
+    }
+
+    public boolean getIsWartung() {
+        return this.isWartung;
+    }
+
+    public void setIsWartung(boolean value) {
+        this.isWartung = value;
+    }
+}

src/main/java/de/survivalprojekt/LS/Managers/WhitelistManager.java

@@ -0,0 +1,129 @@
+package de.survivalprojekt.LS.Managers;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.Set;
+import java.util.UUID;
+
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+
+import de.survivalprojekt.LS.ServerManager;
+
+public class WhitelistManager {
+    private File whitelistFile;
+    private FileConfiguration whitelistConfig;
+    private boolean whitelistEnabled = true; // Standardmäßig aktiviert
+
+    public WhitelistManager() {
+        initFile();
+    }
+
+    private void initFile() {
+        ServerManager inst = ServerManager.getInst();
+        /////// SETUP CONFIG ///////
+        whitelistFile = new File(inst.getDataFolder(), "whitelist.yml");
+        if (!whitelistFile.exists()) {
+            try (InputStream inputStream = inst.getResource("whitelist.yml")) {
+                if (inputStream != null) {
+                    Files.copy(inputStream, whitelistFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
+                    inst.getLogger().info("Die Standard-Whitelist-Konfigurationsdatei wurde erstellt.");
+                } else {
+                    inst.getLogger().warning("Standart Whitelist-Konfigurationsdatei konnte nicht gefunden werden.");
+                }
+            } catch (IOException e) {
+                inst.getLogger().severe("Fehler beim erstellen der Whitelist-Konfigurationsdatei: " + e.getMessage());
+            }
+        }
+        whitelistConfig = YamlConfiguration.loadConfiguration(whitelistFile);
+        ///// GIBT KEINEN GRUND JEDEN SCHEISS ZU LOGGEN /////
+        /// DAFÜR GIBT ES FUCKING ERROR MESSAGES /////
+        inst.getLogger().info("Whitelist-Konfiguration wurde <neu> geladen.");
+    }
+
+    public void reload() {
+        initFile();
+    }
+
+    public void save() {
+        ServerManager inst = ServerManager.getInst();
+        try {
+            whitelistConfig.save(whitelistFile);
+        } catch (IOException e) {
+            inst.getLogger().info("Fehler beim Speichern der Whitelist: " + e.getMessage());
+        }
+    }
+
+    public boolean addPlayer(String name) {
+        ServerManager inst = ServerManager.getInst();
+        OfflinePlayer pl = Bukkit.getOfflinePlayer(name);
+        UUID id = null;
+        String rname = null;
+        if (pl != null) {
+            rname = pl.getName();
+            id = pl.getUniqueId();
+        }
+        if (id == null || rname == null || rname.isEmpty()) {
+            inst.getLogger().info("Spieler " + name + " konnte nicht gefunden werden!");
+            return false;
+        }
+        if (whitelistConfig.getConfigurationSection("whitelist") == null) {
+            whitelistConfig.createSection("whitelist");
+        }
+        whitelistConfig.set("whitelist." + id.toString() + ".name", rname);
+        save();
+        inst.getLogger().info("Spieler " + rname + "wurde zur Whitelist hinzugefügt");
+        return true;
+    }
+
+    public boolean removePlayer(String name) {
+        ServerManager inst = ServerManager.getInst();
+        if (whitelistConfig.getConfigurationSection("whitelist") != null) {
+            for (String uuid : whitelistConfig.getConfigurationSection("whitelist").getKeys(false)) {
+                String lname = whitelistConfig.getString("whitelist." + uuid + ".name");
+                if (lname != null && lname.equalsIgnoreCase(name)) {
+                    whitelistConfig.set("whitelist." + uuid, null);
+                    save();
+                    inst.getLogger().info("Spieler " + lname + " wurde von der Whitelist entfernt.");
+                    return true;
+                }
+            }
+        }
+        inst.getLogger().info("Spieler " + name + " ist nicht auf der Whitelist.");
+        return false;
+    }
+
+    public Set<String> getWhitelistedPlayers() {
+        if (whitelistConfig.getConfigurationSection("whitelist") == null) {
+            return null;
+        }
+        return whitelistConfig.getConfigurationSection("whitelist").getKeys(false);
+    }
+
+    public String getWhitelistedPlayerName(String uuid) {
+        return whitelistConfig.getString("whitelist." + uuid + ".name");
+    }
+
+    public boolean isWhitelisted(UUID uuid) {
+        return whitelistConfig.getConfigurationSection("whitelist") != null &&
+                whitelistConfig.getConfigurationSection("whitelist").contains(uuid.toString());
+    }
+
+    public String getMessage() {
+        return whitelistConfig.getString("message");
+    }
+
+    public boolean getWhitelistEnabled() {
+        return this.whitelistEnabled;
+    }
+
+    public void setWhitelistEnabled(boolean value) {
+        this.whitelistEnabled = value;
+    }
+}

src/main/java/de/survivalprojekt/LS/ServerManager.java

@@ -0,0 +1,83 @@
+package de.survivalprojekt.LS;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import de.survivalprojekt.LS.Commands.MotdCommand;
+import de.survivalprojekt.LS.Commands.WartungsCommand;
+import de.survivalprojekt.LS.Commands.WhitelistCommand;
+import de.survivalprojekt.LS.Listeners.PlayerListener;
+import de.survivalprojekt.LS.Listeners.ServerListListener;
+import de.survivalprojekt.LS.Managers.MotdManager;
+import de.survivalprojekt.LS.Managers.WartungsManager;
+import de.survivalprojekt.LS.Managers.WhitelistManager;
+import de.survivalprojekt.LS.TabCompleters.MotdCompleter;
+import de.survivalprojekt.LS.TabCompleters.WartungsCompleter;
+import de.survivalprojekt.LS.TabCompleters.WhitelistCompleter;
+
+/// Default CMD to Override
+/// whitelist
+
+public class ServerManager extends JavaPlugin {
+    static ServerManager inst;
+
+    MotdManager motdManager;
+    WartungsManager wartungsManager;
+    WhitelistManager whitelistManager;
+
+    @Override
+    public void onLoad() {
+        inst = this;
+    }
+
+    @Override
+    public void onEnable() {
+        // Setup Data Folder
+        if (!getDataFolder().exists()) {
+            getDataFolder().mkdirs();
+        }
+        // Create Managers
+        motdManager = new MotdManager();
+        wartungsManager = new WartungsManager();
+        whitelistManager = new WhitelistManager();
+        // Declare Events
+        Bukkit.getPluginManager().registerEvents(new ServerListListener(), inst);
+        Bukkit.getPluginManager().registerEvents(new PlayerListener(), inst);
+
+        // Declare Commands [not the ovrride one]
+        setUpCommand("motd", new MotdCommand(), new MotdCompleter());
+        setUpCommand("wartung", new WartungsCommand(), new WartungsCompleter());
+        setUpCommand("whitelist", new WhitelistCommand(), new WhitelistCompleter());
+    }
+
+    private void setUpCommand(final String command, CommandExecutor exec, TabCompleter tc) {
+        PluginCommand cmd = getCommand(command);
+        if (cmd != null) {
+            cmd.setExecutor(exec);
+            if (tc != null) {
+                cmd.setTabCompleter(tc);
+            }
+        } else {
+            getLogger().info("Error: Command " + command + " nicht gefunden!");
+        }
+    }
+
+    public static ServerManager getInst() {
+        return inst;
+    }
+
+    public MotdManager getMotdManager() {
+        return motdManager;
+    }
+
+    public WartungsManager getWartungsManager() {
+        return this.wartungsManager;
+    }
+
+    public WhitelistManager getWhitelistManager() {
+      return this.whitelistManager;
+    }
+}

src/main/java/de/survivalprojekt/LS/TabCompleters/MotdCompleter.java

@@ -0,0 +1,22 @@
+package de.survivalprojekt.LS.TabCompleters;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+
+public class MotdCompleter implements TabCompleter {
+    @Override
+    public List<String> onTabComplete(
+            CommandSender sender, Command command, String alias, String[] args) {
+        List<String> completions = new ArrayList<>();
+        if (command.getName().equalsIgnoreCase("motd")) {
+            if (args.length == 1) {
+                completions.add("reload");
+            }
+        }
+        return completions;
+    }
+}

src/main/java/de/survivalprojekt/LS/TabCompleters/WartungsCompleter.java

@@ -0,0 +1,24 @@
+package de.survivalprojekt.LS.TabCompleters;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+
+public class WartungsCompleter implements TabCompleter {
+    @Override
+    public List<String> onTabComplete(
+            CommandSender sender, Command command, String alias, String[] args) {
+        List<String> completions = new ArrayList<>();
+        if (command.getName().equalsIgnoreCase("wartung")) {
+            if (args.length == 1) {
+                completions.add("an");
+                completions.add("aus");
+                completions.add("reload");
+            }
+        }
+        return completions;
+    }
+}

src/main/java/de/survivalprojekt/LS/TabCompleters/WhitelistCompleter.java

@@ -0,0 +1,40 @@
+package de.survivalprojekt.LS.TabCompleters;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+
+import de.survivalprojekt.LS.ServerManager;
+
+public class WhitelistCompleter implements TabCompleter {
+    @Override
+    public List<String> onTabComplete(
+            CommandSender sender, Command command, String alias, String[] args) {
+        List<String> completions = new ArrayList<>();
+        ServerManager inst = ServerManager.getInst();
+        if (command.getName().equalsIgnoreCase("whitelist")) {
+            if (args.length == 1) {
+                completions.add("add");
+                completions.add("remove");
+                completions.add("reload");
+                completions.add("enable");
+                completions.add("disable");
+            } else if (args.length == 2) {
+                if (args[0].equals("remove")) {
+                    if (inst.getWhitelistManager().getWhitelistedPlayers() != null) {
+                        for (String uuid : inst.getWhitelistManager().getWhitelistedPlayers()) {
+                            String name = inst.getWhitelistManager().getWhitelistedPlayerName(uuid);
+                            if (name != null) {
+                                completions.add(name);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return completions;
+    }
+}

src/main/resources/motd.yml

@@ -0,0 +1,3 @@
+motd: |
+  <b><gradient:#B19169:#7E6D5A>             ʟᴇɢᴀᴄʏ ѕᴜʀᴠɪᴠᴀʟ</gradient></b>
+  <gradient:#B7B7B7:#7A7A7A>                     ѕᴇᴀѕᴏɴ ᴏɴᴇ</gradient>

src/main/resources/plugin.yml

@@ -0,0 +1,23 @@
+name: LSServerManager
+version: 1.2
+main: de.survivalprojekt.LS.ServerManager
+api-version: 1.21
+author: zD3nnis - Dennis, tobid7 - René Amthor
+description: Server-Manager Plugin für Legacy Survival
+
+commands:
+  motd:
+    description: MOTD Verwaltung.
+    usage: /motd <command>
+    permission: lss.motd.reload
+    permission-message: Du hast keine Berechtigung für diesen Befehl.
+  wartung:
+    description: Verwaltung Wartungsmodus.
+    usage: /wartung <command>
+    permission: lss.wartung
+    permission-message: Du hast keine Berechtigung für diesen Befehl.
+  whitelist:
+    description: Verwaltung Whitelist.
+    usage: /whitelist <command>
+    permission: lss.whitelist
+    permission-message: Du hast keine Berechtigung für diesen Befehl.

src/main/resources/wartung.yml

@@ -0,0 +1,9 @@
+wartungsMotd: |
+  <b><gradient:#B19169:#7E6D5A>             ʟᴇɢᴀᴄʏ ѕᴜʀᴠɪᴠᴀʟ</gradient></b>
+  <b><dark_red>            ᴡᴀʀᴛᴜɴɢѕᴀʀʙᴇɪᴛᴇɴ!<dark_red><b>
+kickMessage: |
+  <b><gradient:#B19169:#7E6D5A>ʟᴇɢᴀᴄʏ ѕᴜʀᴠɪᴠᴀʟ</gradient></b>
+
+  <red>Der Server befindet sich gerade in Wartungen!</red>
+  <red>Wir bitten um Verständnis.<red>
+wartungsModus: false

src/main/resources/whitelist.yml

@@ -0,0 +1,10 @@
+whitelist:
+
+# Nachricht, die angezeigt wird, wenn ein Spieler nicht auf der Whitelist ist
+message: |
+  <b><gradient:#B19169:#7E6D5A>ʟᴇɢᴀᴄʏ ѕᴜʀᴠɪᴠᴀʟ</gradient></b>
+
+  <red>Du bist nicht auf der Teilnehmerliste!<red>
+  <red>Um dich auf die Whitelist setzen zu lassen, besuche unseren Discord:</red>
+
+  <green><underlined>https://discord.gg/ZdbRUR34E7</underlined></green>