From 604402d2df806b8f57a76c79acf1bfd19726a989 Mon Sep 17 00:00:00 2001 From: tobid7 Date: Sat, 14 Dec 2024 22:18:57 +0100 Subject: [PATCH] Initial Commit --- .gitea/workflows/build.yml | 67 +++++++++ .gitignore | 113 +++++++++++++++ .vscode/settings.json | 4 + pom.xml | 93 +++++++++++++ .../LS/Commands/MotdCommand.java | 31 +++++ .../LS/Commands/WartungsCommand.java | 54 ++++++++ .../LS/Commands/WhitelistCommand.java | 55 ++++++++ .../LS/Listeners/PlayerListener.java | 48 +++++++ .../LS/Listeners/ServerListListener.java | 59 ++++++++ .../LS/Managers/MotdManager.java | 87 ++++++++++++ .../LS/Managers/WartungsManager.java | 76 +++++++++++ .../LS/Managers/WhitelistManager.java | 129 ++++++++++++++++++ .../de/survivalprojekt/LS/ServerManager.java | 83 +++++++++++ .../LS/TabCompleters/MotdCompleter.java | 22 +++ .../LS/TabCompleters/WartungsCompleter.java | 24 ++++ .../LS/TabCompleters/WhitelistCompleter.java | 40 ++++++ src/main/resources/motd.yml | 3 + src/main/resources/plugin.yml | 23 ++++ src/main/resources/server-icon.png | Bin 0 -> 8120 bytes src/main/resources/wartung.yml | 9 ++ src/main/resources/whitelist.yml | 10 ++ 21 files changed, 1030 insertions(+) create mode 100644 .gitea/workflows/build.yml create mode 100644 .gitignore create mode 100644 .vscode/settings.json create mode 100644 pom.xml create mode 100644 src/main/java/de/survivalprojekt/LS/Commands/MotdCommand.java create mode 100644 src/main/java/de/survivalprojekt/LS/Commands/WartungsCommand.java create mode 100644 src/main/java/de/survivalprojekt/LS/Commands/WhitelistCommand.java create mode 100644 src/main/java/de/survivalprojekt/LS/Listeners/PlayerListener.java create mode 100644 src/main/java/de/survivalprojekt/LS/Listeners/ServerListListener.java create mode 100644 src/main/java/de/survivalprojekt/LS/Managers/MotdManager.java create mode 100644 src/main/java/de/survivalprojekt/LS/Managers/WartungsManager.java create mode 100644 src/main/java/de/survivalprojekt/LS/Managers/WhitelistManager.java create mode 100644 src/main/java/de/survivalprojekt/LS/ServerManager.java create mode 100644 src/main/java/de/survivalprojekt/LS/TabCompleters/MotdCompleter.java create mode 100644 src/main/java/de/survivalprojekt/LS/TabCompleters/WartungsCompleter.java create mode 100644 src/main/java/de/survivalprojekt/LS/TabCompleters/WhitelistCompleter.java create mode 100644 src/main/resources/motd.yml create mode 100644 src/main/resources/plugin.yml create mode 100644 src/main/resources/server-icon.png create mode 100644 src/main/resources/wartung.yml create mode 100644 src/main/resources/whitelist.yml diff --git a/.gitea/workflows/build.yml b/.gitea/workflows/build.yml new file mode 100644 index 0000000..178566c --- /dev/null +++ b/.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 \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4788b4b --- /dev/null +++ b/.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/ diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..e012065 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,4 @@ +{ + "java.compile.nullAnalysis.mode": "automatic", + "java.configuration.updateBuildConfiguration": "interactive" +} \ No newline at end of file diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..4628c21 --- /dev/null +++ b/pom.xml @@ -0,0 +1,93 @@ + + + 4.0.0 + + de.survivalprojekt + LSServerManager + 1.0 + jar + + LSServerManager + + + 17 + UTF-8 + + + + + + spigotmc-repo + https://hub.spigotmc.org/nexus/content/repositories/snapshots/ + + + + + kyori + https://s01.oss.sonatype.org/content/repositories/releases/ + + + + + + + org.spigotmc + spigot-api + 1.21.1-R0.1-SNAPSHOT + provided + + + + + net.kyori + adventure-api + 4.14.0 + + + + + net.kyori + adventure-text-minimessage + 4.14.0 + + + + net.kyori + adventure-text-serializer-legacy + 4.14.0 + + + + + clean package + + + + org.apache.maven.plugins + maven-compiler-plugin + 3.10.1 + + ${java.version} + ${java.version} + + + + + + org.apache.maven.plugins + maven-shade-plugin + 3.4.1 + + + package + + shade + + + + + + + diff --git a/src/main/java/de/survivalprojekt/LS/Commands/MotdCommand.java b/src/main/java/de/survivalprojekt/LS/Commands/MotdCommand.java new file mode 100644 index 0000000..e5419fb --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/de/survivalprojekt/LS/Commands/WartungsCommand.java b/src/main/java/de/survivalprojekt/LS/Commands/WartungsCommand.java new file mode 100644 index 0000000..0303b2b --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/de/survivalprojekt/LS/Commands/WhitelistCommand.java b/src/main/java/de/survivalprojekt/LS/Commands/WhitelistCommand.java new file mode 100644 index 0000000..0a57471 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/de/survivalprojekt/LS/Listeners/PlayerListener.java b/src/main/java/de/survivalprojekt/LS/Listeners/PlayerListener.java new file mode 100644 index 0000000..3d95783 --- /dev/null +++ b/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)); + } + } + + } +} diff --git a/src/main/java/de/survivalprojekt/LS/Listeners/ServerListListener.java b/src/main/java/de/survivalprojekt/LS/Listeners/ServerListListener.java new file mode 100644 index 0000000..1b73080 --- /dev/null +++ b/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."); + } + } +} diff --git a/src/main/java/de/survivalprojekt/LS/Managers/MotdManager.java b/src/main/java/de/survivalprojekt/LS/Managers/MotdManager.java new file mode 100644 index 0000000..5b542ec --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/de/survivalprojekt/LS/Managers/WartungsManager.java b/src/main/java/de/survivalprojekt/LS/Managers/WartungsManager.java new file mode 100644 index 0000000..1b499db --- /dev/null +++ b/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 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; + } +} diff --git a/src/main/java/de/survivalprojekt/LS/Managers/WhitelistManager.java b/src/main/java/de/survivalprojekt/LS/Managers/WhitelistManager.java new file mode 100644 index 0000000..471916d --- /dev/null +++ b/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 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 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; + } +} diff --git a/src/main/java/de/survivalprojekt/LS/ServerManager.java b/src/main/java/de/survivalprojekt/LS/ServerManager.java new file mode 100644 index 0000000..fddc627 --- /dev/null +++ b/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; + } +} diff --git a/src/main/java/de/survivalprojekt/LS/TabCompleters/MotdCompleter.java b/src/main/java/de/survivalprojekt/LS/TabCompleters/MotdCompleter.java new file mode 100644 index 0000000..45d594d --- /dev/null +++ b/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 onTabComplete( + CommandSender sender, Command command, String alias, String[] args) { + List completions = new ArrayList<>(); + if (command.getName().equalsIgnoreCase("motd")) { + if (args.length == 1) { + completions.add("reload"); + } + } + return completions; + } +} diff --git a/src/main/java/de/survivalprojekt/LS/TabCompleters/WartungsCompleter.java b/src/main/java/de/survivalprojekt/LS/TabCompleters/WartungsCompleter.java new file mode 100644 index 0000000..0047a09 --- /dev/null +++ b/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 onTabComplete( + CommandSender sender, Command command, String alias, String[] args) { + List completions = new ArrayList<>(); + if (command.getName().equalsIgnoreCase("wartung")) { + if (args.length == 1) { + completions.add("an"); + completions.add("aus"); + completions.add("reload"); + } + } + return completions; + } +} diff --git a/src/main/java/de/survivalprojekt/LS/TabCompleters/WhitelistCompleter.java b/src/main/java/de/survivalprojekt/LS/TabCompleters/WhitelistCompleter.java new file mode 100644 index 0000000..e005c3d --- /dev/null +++ b/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 onTabComplete( + CommandSender sender, Command command, String alias, String[] args) { + List 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; + } +} diff --git a/src/main/resources/motd.yml b/src/main/resources/motd.yml new file mode 100644 index 0000000..573567d --- /dev/null +++ b/src/main/resources/motd.yml @@ -0,0 +1,3 @@ +motd: | + ʟᴇɢᴀᴄʏ ѕᴜʀᴠɪᴠᴀʟ + ѕᴇᴀѕᴏɴ ᴏɴᴇ \ No newline at end of file diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml new file mode 100644 index 0000000..68dc2c2 --- /dev/null +++ b/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 + permission: lss.motd.reload + permission-message: Du hast keine Berechtigung für diesen Befehl. + wartung: + description: Verwaltung Wartungsmodus. + usage: /wartung + permission: lss.wartung + permission-message: Du hast keine Berechtigung für diesen Befehl. + whitelist: + description: Verwaltung Whitelist. + usage: /whitelist + permission: lss.whitelist + permission-message: Du hast keine Berechtigung für diesen Befehl. \ No newline at end of file diff --git a/src/main/resources/server-icon.png b/src/main/resources/server-icon.png new file mode 100644 index 0000000000000000000000000000000000000000..b6aa7a5245847f2457fd4382b11b07adaabd9626 GIT binary patch literal 8120 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 ʟᴇɢᴀᴄʏ ѕᴜʀᴠɪᴠᴀʟ + ᴡᴀʀᴛᴜɴɢѕᴀʀʙᴇɪᴛᴇɴ! +kickMessage: | + ʟᴇɢᴀᴄʏ ѕᴜʀᴠɪᴠᴀʟ + + Der Server befindet sich gerade in Wartungen! + Wir bitten um Verständnis. +wartungsModus: false \ No newline at end of file diff --git a/src/main/resources/whitelist.yml b/src/main/resources/whitelist.yml new file mode 100644 index 0000000..d4f3668 --- /dev/null +++ b/src/main/resources/whitelist.yml @@ -0,0 +1,10 @@ +whitelist: + +# Nachricht, die angezeigt wird, wenn ein Spieler nicht auf der Whitelist ist +message: | + ʟᴇɢᴀᴄʏ ѕᴜʀᴠɪᴠᴀʟ + + Du bist nicht auf der Teilnehmerliste! + Um dich auf die Whitelist setzen zu lassen, besuche unseren Discord: + + https://discord.gg/ZdbRUR34E7 \ No newline at end of file