Fix coloring

Signed-off-by: Lixfel <git-5w3l@lixfel.de>

CommonCore

@@ -1 +1 @@
-Subproject commit 0c68dfd19dc32a848be2cf399e00bc2863739b57
+Subproject commit d000b8687d93eb43520bbf6685281099055eab9f

Persistent/build.gradle

@@ -0,0 +1,55 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+plugins {
+    id 'java'
+}
+
+group 'de.steamwar'
+version ''
+
+compileJava.options.encoding = 'UTF-8'
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+sourceSets {
+    main {
+        java {
+            srcDirs = ['src/']
+            include '**/*.java', '**/*.kt'
+        }
+        resources {
+            srcDirs = ['src/']
+            exclude '**/*.java', '**/*.kt'
+        }
+    }
+}
+
+dependencies {
+    compileOnly 'org.projectlombok:lombok:1.18.32'
+    testCompileOnly 'org.projectlombok:lombok:1.18.32'
+    annotationProcessor 'org.projectlombok:lombok:1.18.32'
+    testAnnotationProcessor 'org.projectlombok:lombok:1.18.32'
+
+    compileOnly 'de.steamwar:velocity:RELEASE'
+    annotationProcessor 'com.velocitypowered:velocity-api:3.3.0-SNAPSHOT'
+}

Persistent/src/de/steamwar/persistent/Arenaserver.java

@@ -0,0 +1,37 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.persistent;
+
+import lombok.Getter;
+
+@Getter
+public class Arenaserver extends Subserver {
+
+    private final String mode;
+    private final String map;
+    private final boolean allowMerge;
+
+    public Arenaserver(String serverName, String mode, String map, boolean allowMerge, int port, ProcessBuilder processBuilder, Runnable shutdownCallback) {
+        super(Servertype.ARENA, serverName, port, processBuilder, shutdownCallback, null);
+        this.mode = mode;
+        this.map = map;
+        this.allowMerge = allowMerge;
+    }
+}

Persistent/src/de/steamwar/persistent/Bauserver.java

@@ -0,0 +1,60 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.persistent;
+
+import lombok.Getter;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.Consumer;
+
+@Getter
+public class Bauserver extends Subserver {
+    private static final Map<UUID, Bauserver> servers = new HashMap<>();
+    public static Bauserver get(UUID owner) {
+        synchronized (servers) {
+            return servers.get(owner);
+        }
+    }
+
+    private final UUID owner;
+
+    public Bauserver(String serverName, UUID owner, int port, ProcessBuilder processBuilder, Runnable shutdownCallback){
+        this(serverName, owner, port, processBuilder, shutdownCallback, null);
+    }
+
+    public Bauserver(String serverName, UUID owner, int port, ProcessBuilder processBuilder, Runnable shutdownCallback, Consumer<Exception> failureCallback){
+        super(Servertype.BAUSERVER, serverName, port, processBuilder, shutdownCallback, failureCallback);
+        this.owner = owner;
+
+        synchronized (servers) {
+            servers.put(owner, this);
+        }
+    }
+
+    @Override
+    protected void unregister() {
+        synchronized (servers) {
+            servers.remove(owner);
+        }
+        super.unregister();
+    }
+}

Persistent/src/de/steamwar/persistent/Builderserver.java

@@ -0,0 +1,59 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.persistent;
+
+import lombok.Getter;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+
+@Getter
+public class Builderserver extends Subserver {
+
+    private static final Map<String, Builderserver> servers = new HashMap<>();
+    public static Builderserver get(String map) {
+        synchronized (servers) {
+            return servers.get(map);
+        }
+    }
+
+    private final String map;
+    public Builderserver(String serverName, String map, int port, ProcessBuilder processBuilder, Runnable shutdownCallback){
+        this(serverName, map, port, processBuilder, shutdownCallback, null);
+    }
+
+    public Builderserver(String serverName, String map, int port, ProcessBuilder processBuilder, Runnable shutdownCallback, Consumer<Exception> failureCallback){
+        super(Servertype.BUILDER, serverName, port, processBuilder, shutdownCallback, failureCallback);
+        this.map = map;
+
+        synchronized (servers) {
+            servers.put(map, this);
+        }
+    }
+
+    @Override
+    protected void unregister() {
+        synchronized (servers) {
+            servers.remove(map);
+        }
+        super.unregister();
+    }
+}

Persistent/src/de/steamwar/persistent/Persistent.java

@@ -0,0 +1,203 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.persistent;
+
+import com.google.inject.AbstractModule;
+import com.google.inject.Inject;
+import com.google.inject.Module;
+import com.google.inject.name.Names;
+import com.mojang.brigadier.Command;
+import com.velocitypowered.api.command.BrigadierCommand;
+import com.velocitypowered.api.command.CommandManager;
+import com.velocitypowered.api.command.CommandMeta;
+import com.velocitypowered.api.event.EventManager;
+import com.velocitypowered.api.event.Subscribe;
+import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
+import com.velocitypowered.api.event.proxy.ProxyShutdownEvent;
+import com.velocitypowered.api.plugin.Plugin;
+import com.velocitypowered.api.plugin.PluginContainer;
+import com.velocitypowered.api.plugin.PluginDescription;
+import com.velocitypowered.api.plugin.PluginManager;
+import com.velocitypowered.api.plugin.annotation.DataDirectory;
+import com.velocitypowered.api.proxy.ProxyServer;
+import com.velocitypowered.api.scheduler.ScheduledTask;
+import com.velocitypowered.proxy.plugin.PluginClassLoader;
+import com.velocitypowered.proxy.plugin.VelocityPluginManager;
+import com.velocitypowered.proxy.plugin.loader.VelocityPluginContainer;
+import com.velocitypowered.proxy.plugin.loader.java.JavaPluginLoader;
+import lombok.Getter;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.NoSuchElementException;
+import java.util.ResourceBundle;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+@Plugin(
+        id = "persistentvelocitycore",
+        name = "PersistentVelocityCore"
+)
+public class Persistent {
+
+    private static final Reflection.Method<VelocityPluginManager> registerPlugin = new Reflection.Method<>(VelocityPluginManager.class, "registerPlugin", PluginContainer.class);
+
+    @Getter
+    private static Persistent instance;
+
+    @Getter
+    private final ProxyServer proxy;
+    @Getter
+    private final Logger logger;
+    private final Path directory;
+
+    @Inject
+    public Persistent(ProxyServer proxy, Logger logger, @DataDirectory Path dataDirectory) {
+        instance = this;
+        this.proxy = proxy;
+        this.logger = logger;
+        this.directory = dataDirectory;
+    }
+
+    @Subscribe
+    public void onEnable(ProxyInitializeEvent event) {
+        proxy.getCommandManager().register(
+                new BrigadierCommand(
+                        BrigadierCommand.literalArgumentBuilder("softreload")
+                                .requires(commandSource -> commandSource.hasPermission("bungeecore.softreload"))
+                                .executes(commandContext -> softreload())
+                                .build()
+                )
+        );
+    }
+
+    @Subscribe
+    public void onDisable(ProxyShutdownEvent event) {
+        Subserver.shutdown();
+    }
+
+    public int softreload() {
+        PluginContainer container = null;
+        ReloadablePlugin plugin = null;
+        try {
+            container = proxy.getPluginManager().getPlugin("velocitycore").orElseThrow();
+            plugin = (ReloadablePlugin) container.getInstance().orElseThrow();
+        } catch (NoSuchElementException e) {
+            logger.log(Level.WARNING, "Could not find loaded VelocityCore, continuing without unloading.");
+        }
+
+        PluginContainer newContainer;
+        try {
+            newContainer = prepareLoad();
+        } catch (Exception e) {
+            logger.log(Level.SEVERE, "Could not instantiate new VelocityCore, aborting softreload.", e);
+            return Command.SINGLE_SUCCESS;
+        }
+
+        broadcast("§eNetwork update is starting§8.");
+        try {
+            if(container != null && plugin != null) {
+                plugin.onProxyShutdown(new ProxyShutdownEvent());
+                unload(container, plugin);
+            }
+
+            registerPlugin.invoke((VelocityPluginManager) proxy.getPluginManager(), newContainer);
+            ((ReloadablePlugin) newContainer.getInstance().orElseThrow()).onProxyInitialization(new ProxyInitializeEvent());
+        } catch (Throwable t) {
+            logger.log(Level.SEVERE, "Error during softreload", t);
+            broadcast("§cNetwork update failed§8, §cexpect network restart soon§8.");
+            return Command.SINGLE_SUCCESS;
+        }
+
+        broadcast("§eNetwork update complete§8.");
+        return Command.SINGLE_SUCCESS;
+    }
+
+    private void broadcast(String message) {
+        Component component = LegacyComponentSerializer.legacySection().deserialize("§eSteam§8War» " + message);
+        proxy.getAllPlayers().forEach(player -> player.sendMessage(component));
+        proxy.getConsoleCommandSource().sendMessage(component);
+    }
+
+    private PluginContainer prepareLoad() throws Exception {
+        Path plugins = directory.getParent();
+        JavaPluginLoader loader = new JavaPluginLoader(proxy, plugins);
+        PluginDescription description = loader.createPluginFromCandidate(loader.loadCandidate(plugins.resolve("VelocityCore.jar")));
+        PluginContainer container = new VelocityPluginContainer(description);
+
+        AbstractModule commonModule = new AbstractModule() {
+            @Override
+            protected void configure() {
+                this.bind(ProxyServer.class).toInstance(proxy);
+                this.bind(PluginManager.class).toInstance(proxy.getPluginManager());
+                this.bind(EventManager.class).toInstance(proxy.getEventManager());
+                this.bind(CommandManager.class).toInstance(proxy.getCommandManager());
+                this.bind(PluginContainer.class).annotatedWith(Names.named(container.getDescription().getId())).toInstance(container);
+            }
+        };
+
+        Module module = loader.createModule(container);
+        loader.createPlugin(container, module, commonModule);
+
+        return container;
+    }
+
+    private void unload(PluginContainer container, Object plugin) throws InterruptedException, IOException {
+        PluginClassLoader classLoader = ((PluginClassLoader) plugin.getClass().getClassLoader());
+
+        CommandManager commandManager = proxy.getCommandManager();
+        for(String alias : commandManager.getAliases()) {
+            CommandMeta meta = commandManager.getCommandMeta(alias);
+            if(meta != null && meta.getPlugin() == plugin)
+                commandManager.unregister(meta);
+        }
+
+        proxy.getEventManager().unregisterListeners(plugin);
+        proxy.getScheduler().tasksByPlugin(plugin).forEach(ScheduledTask::cancel);
+
+        container.getExecutorService().shutdown();
+        if(!container.getExecutorService().awaitTermination(100, TimeUnit.MILLISECONDS))
+            logger.log(Level.WARNING, "ExecutorService termination took longer than 100ms, continuing.");
+
+        for(Thread thread : Thread.getAllStackTraces().keySet()) {
+            if(thread.getClass().getClassLoader() != classLoader)
+                continue;
+
+            thread.interrupt();
+            thread.join(100);
+
+            if (thread.isAlive())
+                logger.log(Level.WARNING, "Could not stop thread %s of plugin %s. Still running".formatted(thread.getName(), container.getDescription().getId()));
+        }
+
+        //TODO close all log handlers
+        /*for (Handler handler : plugin.getLogger().getHandlers()) {
+            handler.close();
+        }*/
+
+
+        //Clear resource bundle cache
+        ResourceBundle.clearCache(classLoader);
+        classLoader.close();
+    }
+}

Persistent/src/de/steamwar/persistent/Reflection.java

@@ -0,0 +1,75 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.persistent;
+
+import lombok.experimental.UtilityClass;
+
+@UtilityClass
+public class Reflection {
+    public static class Field<C, T> {
+        private final java.lang.reflect.Field f;
+
+        public Field(Class<C> target, String name) {
+            try {
+                f = target.getDeclaredField(name);
+                f.setAccessible(true);
+            } catch (NoSuchFieldException e) {
+                throw new IllegalArgumentException("Cannot find field with name " + name, e);
+            }
+        }
+
+        public T get(C target) {
+            try {
+                return (T) f.get(target);
+            } catch (IllegalAccessException e) {
+                throw new IllegalArgumentException("Cannot access reflection.", e);
+            }
+        }
+
+        public void set(C target, T value) {
+            try {
+                f.set(target, value);
+            } catch (IllegalAccessException e) {
+                throw new IllegalArgumentException("Cannot access reflection.", e);
+            }
+        }
+    }
+
+    public static class Method<C> {
+        private final java.lang.reflect.Method m;
+
+        public Method(Class<C> clazz, String methodName, Class<?>... params) {
+            try {
+                m = clazz.getDeclaredMethod(methodName, params);
+                m.setAccessible(true);
+            } catch (NoSuchMethodException e) {
+                throw new IllegalArgumentException("Cannot find method with name " + methodName, e);
+            }
+        }
+
+        public Object invoke(C target, Object... arguments) {
+            try {
+                return m.invoke(target, arguments);
+            } catch (Exception e) {
+                throw new IllegalArgumentException("Cannot invoke method " + m, e);
+            }
+        }
+    }
+}

Persistent/src/de/steamwar/persistent/ReloadablePlugin.java

@@ -0,0 +1,28 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.persistent;
+
+import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
+import com.velocitypowered.api.event.proxy.ProxyShutdownEvent;
+
+public interface ReloadablePlugin {
+    void onProxyInitialization(ProxyInitializeEvent event);
+    default void onProxyShutdown(ProxyShutdownEvent event) {}
+}

Persistent/src/de/steamwar/persistent/Servertype.java

@@ -0,0 +1,26 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.persistent;
+
+public enum Servertype {
+    BAUSERVER,
+    ARENA,
+    BUILDER
+}

Persistent/src/de/steamwar/persistent/Storage.java

@@ -0,0 +1,52 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.persistent;
+
+import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.proxy.server.ServerInfo;
+import com.velocitypowered.proxy.protocol.packet.UpsertPlayerInfoPacket;
+import lombok.experimental.UtilityClass;
+
+import java.sql.Timestamp;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+@UtilityClass
+public class Storage {
+    public static final Map<Player, List<Player>> challenges = new HashMap<>();
+
+    public static final Map<Player, Player> lastChats = new HashMap<>();
+
+    public static final Map<Integer, List<Integer>> teamInvitations = new HashMap<>(); // UserID -> List<TeamIDs>
+
+    public static final Map<Player, Timestamp> sessions = new HashMap<>(); // Contains session start timestamp
+
+    public static final Map<Integer, Subserver> eventServer = new HashMap<>(); // TeamID -> Subserver map
+
+    public static final Map<Player, Integer> fabricCheckedPlayers = new HashMap<>();
+
+    public static final Map<Player, Long> fabricExpectPluginMessage = new HashMap<>();
+
+    public static final Map<Integer, ServerInfo> teamServers = new HashMap<>(); // TeamID -> ServerInfo map
+
+    public static final Map<Player, Map<UUID, UpsertPlayerInfoPacket.Entry>> directTabItems = new HashMap<>();
+}

Persistent/src/de/steamwar/persistent/Subserver.java

@@ -0,0 +1,263 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.persistent;
+
+import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.proxy.server.RegisteredServer;
+import com.velocitypowered.api.proxy.server.ServerInfo;
+import lombok.Getter;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+
+import java.io.*;
+import java.net.InetSocketAddress;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+@SuppressWarnings("unused")
+public class Subserver {
+
+    private static final Component PREFIX = Component
+            .text("Steam").color(NamedTextColor.YELLOW)
+            .append(Component.text("War» ").color(NamedTextColor.DARK_GRAY));
+
+    private static final Logger logger = Persistent.getInstance().getLogger();
+
+    @Getter
+    private static final List<Subserver> serverList = new LinkedList<>();
+    private static final Map<ServerInfo, Subserver> infoToServer = new HashMap<>();
+
+    public static Subserver getSubserver(Player p) {
+        synchronized (serverList) {
+            for (int i = serverList.size() - 1; i >= 0; i--) {
+                if (serverList.get(i).onServer(p))
+                    return serverList.get(i);
+            }
+        }
+        return null;
+    }
+
+    public static Subserver getSubserver(ServerInfo server) {
+        synchronized (serverList) {
+            return infoToServer.get(server);
+        }
+    }
+
+    static void shutdown() {
+        while (!serverList.isEmpty()) {
+            Subserver server = serverList.get(0);
+            server.stop();
+        }
+    }
+
+    private final String serverName;
+    private final boolean checkpoint;
+    private final Runnable shutdownCallback;
+    private final Consumer<Exception> failureCallback;
+    private final Process process;
+    private final PrintWriter writer;
+    @Getter
+    private final ServerInfo server;
+    @Getter
+    private RegisteredServer registeredServer;
+    @Getter
+    private final Servertype type;
+    private final Thread thread;
+    @Getter
+    private boolean started;
+
+    private final List<Player> cachedPlayers = new LinkedList<>();
+    @Getter
+    private final Map<Player, String> tablistNames = new HashMap<>();
+
+    protected Subserver(Servertype type, String serverName, int port, ProcessBuilder processBuilder, Runnable shutdownCallback, Consumer<Exception> failureCallback) {
+        this.started = false;
+        this.serverName = serverName;
+        this.type = type;
+        this.shutdownCallback = shutdownCallback;
+        this.failureCallback = failureCallback == null ? this::fatalError : failureCallback;
+        this.checkpoint = processBuilder.command().contains("criu");
+
+        try {
+            this.process = processBuilder.start();
+        } catch (IOException e) {
+            throw new SecurityException("Server could not be started", e);
+        }
+
+        InetSocketAddress address = new InetSocketAddress("127.0.0.1", port);
+        this.server = new ServerInfo(serverName, address);
+        this.writer = new PrintWriter(process.getOutputStream(), true);
+
+        this.thread = new Thread(this::run, "Subserver " + serverName);
+        this.thread.start();
+    }
+
+    public void sendPlayer(Player p) {
+        if (!started) {
+            p.sendActionBar(generateBar(0));
+            cachedPlayers.add(p);
+        } else {
+            p.createConnectionRequest(registeredServer).connect();
+        }
+    }
+
+    public void execute(String command) {
+        writer.println(command);
+    }
+
+    public void stop() {
+        try {
+            long pid = process.pid();
+            if (checkpoint)
+                pid = process.children().findAny().map(ProcessHandle::pid).orElse(pid);
+
+            Runtime.getRuntime().exec(new String[]{"kill", "-SIGUSR1", Long.toString(pid)});
+        } catch (IOException e) {
+            logger.log(Level.SEVERE, "Failed to send SIGUSR1 to subserver.", e);
+        }
+
+        try {
+            if (!process.waitFor(1, TimeUnit.MINUTES)) {
+                logger.log(Level.SEVERE, () -> serverName + " did not stop correctly, forcibly stopping!");
+                process.destroyForcibly();
+            }
+
+            thread.join();
+        } catch (InterruptedException e) {
+            logger.log(Level.SEVERE, "Subserver stop interrupted!", e);
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    private boolean onServer(Player p) {
+        return cachedPlayers.contains(p) || (registeredServer != null && registeredServer.getPlayersConnected().contains(p));
+    }
+
+    private void fatalError(Exception e) {
+        logger.log(Level.SEVERE, e, () -> serverName + " did not run correctly!");
+
+        for (Player cached : cachedPlayers)
+            cached.sendMessage(PREFIX.append(Component.text("Unexpected error during server startup.").color(NamedTextColor.RED)));
+        if (registeredServer != null) {
+            for (Player player : registeredServer.getPlayersConnected())
+                player.sendMessage(PREFIX.append(Component.text("Lost connection to server.").color(NamedTextColor.RED)));
+        }
+    }
+
+    private void start(InputStream stream, Predicate<String> test) throws IOException {
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream))) {
+            String line = "";
+            while (!started && (line = reader.readLine()) != null) {
+                started = test.test(line);
+            }
+
+            if (line == null)
+                throw new IOException(serverName + " did not start correctly!");
+        }
+    }
+
+    protected void register() {
+        if (Persistent.getInstance().getProxy().getServer(serverName).isPresent()) {
+            SecurityException e = new SecurityException("Server already registered: " + serverName);
+            stop();
+            failureCallback.accept(e);
+            throw e;
+        }
+
+        synchronized (serverList) {
+            registeredServer = Persistent.getInstance().getProxy().registerServer(server);
+            serverList.add(this);
+            infoToServer.put(server, this);
+        }
+    }
+
+    protected void unregister() {
+        synchronized (serverList) {
+            infoToServer.remove(server);
+            serverList.remove(this);
+            Persistent.getInstance().getProxy().unregisterServer(server);
+            registeredServer = null;
+        }
+    }
+
+    private void run() {
+        register();
+
+        Exception ex = null;
+        try {
+            if (checkpoint) {
+                start(process.getErrorStream(), line -> line.contains("Restore finished successfully."));
+            } else {
+                start(process.getInputStream(), line -> {
+                    if (line.contains("Loading libraries, please wait"))
+                        sendProgress(2);
+                    else if (line.contains("Starting Minecraft server on"))
+                        sendProgress(4);
+                    else if (line.contains("Preparing start region"))
+                        sendProgress(6);
+                    return line.contains("Finished mapping loading");
+                });
+            }
+
+            if (!started)
+                return;
+
+            sendProgress(8);
+
+            Thread.sleep(300);
+
+            sendProgress(10);
+            for (Player cachedPlayer : cachedPlayers) {
+                sendPlayer(cachedPlayer);
+            }
+            cachedPlayers.clear();
+
+            process.waitFor();
+        } catch (IOException e) {
+            ex = e;
+        } catch (InterruptedException e) {
+            ex = e;
+            Thread.currentThread().interrupt();
+        } finally {
+            unregister();
+            shutdownCallback.run();
+            if (ex != null)
+                failureCallback.accept(ex);
+        }
+    }
+
+    private Component generateBar(int progress) {
+        return Component.text("⬛".repeat(Math.max(0, progress))).color(NamedTextColor.YELLOW)
+                .append(Component.text("⬛".repeat(Math.max(0, 10 - progress))).color(NamedTextColor.DARK_GRAY));
+    }
+
+    private void sendProgress(int progress) {
+        Component tc = generateBar(progress);
+        for (Player cached : cachedPlayers)
+            cached.sendActionBar(tc);
+    }
+}

build.gradle

@@ -17,52 +17,24 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-
-
-import org.apache.tools.ant.taskdefs.condition.Os
-
 plugins {
-    // Adding the base plugin fixes the following gradle warnings in IntelliJ:
-    //
-    // Warning: root project 'module-work-multi': Unable to resolve all content root directories
-    // Details: java.lang.IllegalStateException: No value has been specified for this provider.
-    //
-    // Warning: root project 'module-work-multi': Unable to resolve additional project configuration.
-    // Details: java.lang.IllegalStateException: No value has been specified for this provider.
     id 'base'
     id 'java'
     id 'application'
 
-    id 'com.github.johnrengelman.shadow' version '5.0.0'
+    id 'com.github.johnrengelman.shadow' version '8.1.1'
+    id 'de.steamwar.gradle' version 'RELEASE'
 }
 
 group 'de.steamwar'
 version ''
 
-Properties steamwarProperties = new Properties()
-if (file("steamwar.properties").exists()) {
-    steamwarProperties.load(file("steamwar.properties").newDataInputStream())
-}
-
-ext {
-    buildName = 'BungeeCore'
-    artifactName = 'bungeecore'
-
-    uberJarName = "${buildName}-all.jar"
-    jarName = "${artifactName}.jar"
-    libs = "${buildDir}/libs"
-
-    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
-        operatingSystem = "windows"
-    } else {
-        operatingSystem = "unix"
-    }
-}
-
 compileJava.options.encoding = 'UTF-8'
 
-sourceCompatibility = 1.8
-targetCompatibility = 1.8
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
 
 mainClassName = ''
 
@@ -78,176 +50,64 @@ sourceSets {
     }
 }
 
-repositories {
-    mavenCentral()
-    maven {
-        url 'https://m2.dv8tion.net/releases'
-    }
-
-    maven {
-        url = uri('https://steamwar.de/maven')
+allprojects {
+    repositories {
+        mavenCentral()
+        maven {
+            url 'https://repo.papermc.io/repository/maven-public/'
+            content {
+                includeGroup 'com.velocitypowered'
+            }
+        }
+        maven {
+            url 'https://m2.dv8tion.net/releases'
+            content {
+                includeGroup 'net.dv8tion'
+            }
+        }
+        maven {
+            url 'https://repo.lunarclient.dev'
+            content {
+                includeGroup 'com.lunarclient'
+            }
+        }
     }
 }
 
-dependencies {
-    compileOnly 'org.projectlombok:lombok:1.18.22'
-    testCompileOnly 'org.projectlombok:lombok:1.18.22'
-    annotationProcessor 'org.projectlombok:lombok:1.18.22'
-    testAnnotationProcessor 'org.projectlombok:lombok:1.18.22'
+shadowJar {
+    exclude 'META-INF/*'
+    exclude 'org/sqlite/native/FreeBSD/**', 'org/sqlite/native/Mac/**', 'org/sqlite/native/Windows/**', 'org/sqlite/native/Linux-Android/**', 'org/sqlite/native/Linux-Musl/**'
+    exclude 'org/sqlite/native/Linux/aarch64/**', 'org/sqlite/native/Linux/arm/**', 'org/sqlite/native/Linux/armv6/**', 'org/sqlite/native/Linux/armv7/**', 'org/sqlite/native/Linux/ppc64/**', 'org/sqlite/native/Linux/x86/**'
+    exclude 'org/slf4j/**'
+    //https://imperceptiblethoughts.com/shadow/configuration/minimizing/
+    minimize {
+        exclude project(':')
+        exclude dependency('mysql:mysql-connector-java:.*')
+    }
+    duplicatesStrategy DuplicatesStrategy.INCLUDE
+}
+
+dependencies {
+    compileOnly 'org.projectlombok:lombok:1.18.32'
+    testCompileOnly 'org.projectlombok:lombok:1.18.32'
+    annotationProcessor 'org.projectlombok:lombok:1.18.32'
+    testAnnotationProcessor 'org.projectlombok:lombok:1.18.32'
+
+    annotationProcessor 'com.velocitypowered:velocity-api:3.3.0-SNAPSHOT'
+    compileOnly 'de.steamwar:velocity:RELEASE'
+
+    compileOnly project(":Persistent")
+    implementation project(":CommonCore")
+
+    implementation 'org.xerial:sqlite-jdbc:3.46.0.0'
+    implementation 'mysql:mysql-connector-java:8.0.33'
 
-    compileOnly 'de.steamwar:waterfall:RELEASE'
-    compileOnly 'de.steamwar:persistentbungeecore:RELEASE'
     implementation("net.dv8tion:JDA:4.4.0_352") {
         exclude module: 'opus-java'
     }
 
-    implementation project(":CommonCore")
-}
+    implementation 'org.msgpack:msgpack-core:0.9.8' //AlpineClient
 
-task buildProject {
-    description 'Build this project'
-    group "Steamwar"
-
-    dependsOn build
-}
-
-task finalizeProject {
-    description 'Finalize this project'
-    group "Steamwar"
-
-    doLast {
-        if ("${buildDir}" == null) {
-            return
-        }
-        delete fileTree("${libs}").matching {
-            exclude("${uberJarName}")
-        }
-        file(libs + "/" + uberJarName).renameTo(file(libs + "/" + jarName))
-    }
-}
-build.finalizedBy(finalizeProject)
-
-if (steamwarProperties.containsKey("hostname")) {
-    String hostname = steamwarProperties.get("hostname")
-    String uploadPath = steamwarProperties.getOrDefault("uploadPath", "~")
-
-    String server = steamwarProperties.getOrDefault("server", "DevBungee")
-    String serverStartFlags = steamwarProperties.getOrDefault("serverStartFlags", "")
-
-    task uploadProject {
-        description 'Upload this project'
-        group "Steamwar"
-
-        doLast {
-            await(shell("scp ${libs}/${jarName} ${hostname}:${uploadPath}/${server}/plugins"))
-            if (steamwarProperties.getOrDefault("directStart", "false") == "false" && !answer("Start ${server} server?")) {
-                return
-            }
-            serverStart(server, serverStartFlags, hostname)
-        }
-    }
-    uploadProject.dependsOn(buildProject)
-
-    task startDevServer {
-        description 'Start the DevBungee'
-        group "Steamwar"
-
-        doLast {
-            serverStart(server, serverStartFlags, hostname)
-        }
-    }
-}
-
-private def await(Process proc) {
-    def out = new StringBuilder()
-    def err = new StringBuilder()
-    proc.waitForProcessOutput(out, err)
-    return [out, err, proc.exitValue()]
-}
-
-private def shell(String command) {
-    if (operatingSystem == "unix") {
-        return ['bash', '-c', command].execute()
-    } else {
-        return ["cmd", "/c", command].execute()
-    }
-}
-
-private def serverStart(String serverName, String serverFlags, String hostname) {
-    def proc = shell("ssh -t ${hostname} \"./mc ${serverFlags} ${serverName}\"")
-
-    Set<String> strings = new HashSet<>()
-    File file = new File("${projectDir}/ignoredlog");
-    if (file.exists()) {
-        new BufferedReader(new InputStreamReader(new FileInputStream(file))).readLines().forEach({ s ->
-            strings.add(s)
-        })
-    }
-
-    Thread outputThread = new Thread({
-        Reader reader = proc.getInputStream().newReader();
-        Writer writer = System.out.newWriter();
-        try {
-            while (proc.alive) {
-                String s = reader.readLine()
-                if (s == null) {
-                    return
-                }
-                if (strings.stream().anyMatch({check -> s.contains(check)})) {
-                    continue
-                }
-                writer.write(s + "\n")
-                writer.flush()
-            }
-        } catch (IOException e) {
-            // Ignored
-        }
-    })
-    outputThread.setName("${serverName} - OutputThread")
-    outputThread.start()
-
-    Writer writer
-    Thread inputThread = new Thread({
-        Reader reader = System.in.newReader()
-        writer = proc.getOutputStream().newWriter()
-        try {
-            while (proc.alive) {
-                String s = reader.readLine()
-                writer.write(s + "\n")
-                writer.flush()
-            }
-        } catch (IOException e) {
-            // Ignored
-        }
-    })
-    inputThread.setName("${serverName} - InputThread")
-    inputThread.start()
-
-    gradle.buildFinished { buildResult ->
-        if (!proc.alive) {
-            return
-        }
-        writer = proc.getOutputStream().newWriter()
-        writer.write("stop\n")
-        writer.flush()
-        awaitClose(proc, outputThread, inputThread)
-    }
-    awaitClose(proc, outputThread, inputThread)
-};
-
-private static def awaitClose(Process proc, Thread outputThread, Thread inputThread) {
-    while (proc.alive) {
-        Thread.sleep(10)
-    }
-    proc.closeStreams()
-    outputThread.interrupt()
-    inputThread.interrupt()
-}
-
-private def answer(String question) {
-    while (System.in.available() > 0) System.in.read()
-    println(question)
-    boolean valid = "Yy".contains(((char) System.in.read()).toString())
-    while (System.in.available() > 0) System.in.read()
-    return valid
+    implementation 'com.lunarclient:apollo-api:1.1.0'
+    implementation 'com.lunarclient:apollo-common:1.1.0'
 }

deployarena.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+import datetime
+import os
+import shutil
+import sys
+import tarfile
+from os import path
+
+# Non stdlib
+from nbt import nbt
+from ruamel.yaml import YAML
+yaml = YAML()
+
+if __name__ == "__main__":
+    configfile = f'/configs/GameModes/{sys.argv[1]}'
+    version = int(sys.argv[2])
+    worldname = sys.argv[3]
+
+    with open(configfile, 'r') as file:
+        gamemode = yaml.load(file)
+
+    builderworld = path.expanduser(f'~/builder{version}/{worldname}')
+    arenaworld = f'/servers/{gamemode["Server"]["Folder"]}/arenas/{worldname}'
+
+    if path.exists(arenaworld):
+        backupworld = path.expanduser(f'~/backup/arenas/{datetime.datetime.now()}-{worldname}-{version}.tar.xz')
+        with tarfile.open(backupworld, 'w:xz') as tar:
+            tar.add(arenaworld, arcname=worldname)
+
+        shutil.rmtree(arenaworld)
+    else:
+        gamemode['Server']['Maps'].append(worldname)
+
+        with open(configfile, 'w') as file:
+            yaml.dump(gamemode, file)
+
+
+    level = nbt.NBTFile(f'{builderworld}/level.dat')
+    level['Data']['Difficulty'] = nbt.TAG_Byte(2)
+    gameRules = level['Data']['GameRules']
+    gameRules['announceAdvancements'] = nbt.TAG_String('false')
+    gameRules['disableRaids'] = nbt.TAG_String('true')
+    gameRules['doDaylightCycle'] = nbt.TAG_String('false')
+    gameRules['doEntityDrops'] = nbt.TAG_String('false')
+    gameRules['doFireTick'] = nbt.TAG_String('true')
+    gameRules['doImmediateRespawn'] = nbt.TAG_String('true')
+    gameRules['doInsomnia'] = nbt.TAG_String('false')
+    gameRules['doLimitedCrafting'] = nbt.TAG_String('false')
+    gameRules['doMobLoot'] = nbt.TAG_String('false')
+    gameRules['doMobSpawning'] = nbt.TAG_String('false')
+    gameRules['doPatrolSpawning'] = nbt.TAG_String('false')
+    gameRules['doTileDrops'] = nbt.TAG_String('true')
+    gameRules['doTraderSpawning'] = nbt.TAG_String('false')
+    gameRules['doWardenSpawning'] = nbt.TAG_String('false')
+    gameRules['doWeatherCycle'] = nbt.TAG_String('false')
+    gameRules['drowningDamage'] = nbt.TAG_String('true')
+    gameRules['fallDamage'] = nbt.TAG_String('true')
+    gameRules['fireDamage'] = nbt.TAG_String('true')
+    gameRules['freezeDamage'] = nbt.TAG_String('true')
+    gameRules['keepInventory'] = nbt.TAG_String('true')
+    gameRules['lavaSourceConversion'] = nbt.TAG_String('false')
+    gameRules['maxEntityCramming'] = nbt.TAG_String('24')
+    gameRules['mobGriefing'] = nbt.TAG_String('false')
+    gameRules['naturalRegeneration'] = nbt.TAG_String('false')
+    gameRules['randomTickSpeed'] = nbt.TAG_String('3')
+    gameRules['reducedDebugInfo'] = nbt.TAG_String('true')
+    gameRules['snowAccumulationHeight'] = nbt.TAG_String('1')
+    gameRules['spawnRadius'] = nbt.TAG_String('0')
+    gameRules['spectatorsGenerateChunks'] = nbt.TAG_String('true')
+    gameRules['waterSourceConversion'] = nbt.TAG_String('true')
+    level.write_file()
+
+    if path.exists(arenaworld):
+        shutil.rmtree(arenaworld)
+
+    os.makedirs(f'{arenaworld}/backup')
+    shutil.copy2(f'{builderworld}/level.dat', f'{arenaworld}/backup/level.dat')
+    shutil.copytree(f'{builderworld}/region', f'{arenaworld}/backup/region')
+
+    shutil.copy2(f'{builderworld}/level.dat', f'{arenaworld}/level.dat')
+    shutil.copytree(f'{builderworld}/region', f'{arenaworld}/region')
+    shutil.copy2(f'{builderworld}/config.yml', f'{arenaworld}/config.yml')
+
+    if path.exists(f'{builderworld}/paper-world.yml'):
+        shutil.copy2(f'{builderworld}/paper-world.yml', f'{arenaworld}/backup/paper-world.yml')
+        shutil.copy2(f'{builderworld}/paper-world.yml', f'{arenaworld}/paper-world.yml')

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 #Sat Apr 10 23:34:12 CEST 2021
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.1-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists

settings.gradle

@@ -17,6 +17,16 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-rootProject.name = 'BungeeCore'
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        maven {
+            url = uri("https://steamwar.de/maven/")
+        }
+    }
+}
 
-include 'CommonCore'
+rootProject.name = 'VelocityCore'
+
+include 'CommonCore'
+include 'Persistent'

src/de/steamwar/bungeecore/ArenaMode.java

@@ -1,187 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore;
-
-import de.steamwar.bungeecore.sql.SchematicType;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.config.Configuration;
-import net.md_5.bungee.config.ConfigurationProvider;
-import net.md_5.bungee.config.YamlConfiguration;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.*;
-import java.util.stream.Collectors;
-
-public class ArenaMode {
-
-    private static final Map<String, ArenaMode> byChat = new HashMap<>();
-    private static final Map<String, ArenaMode> byInternal = new HashMap<>();
-    private static final Map<SchematicType, ArenaMode> bySchemType = new HashMap<>();
-    private static final List<ArenaMode> allModes = new LinkedList<>();
-    private static final Random random = new Random();
-
-    static {
-        File folder = new File(ProxyServer.getInstance().getPluginsFolder(), "FightSystem");
-
-        for(File configFile : Arrays.stream(folder.listFiles((file, name) -> name.endsWith(".yml") && !name.endsWith(".kits.yml"))).sorted().collect(Collectors.toList())) {
-            Configuration config;
-            try {
-                config = ConfigurationProvider.getProvider(YamlConfiguration.class).load(configFile);
-            } catch (IOException e) {
-                throw new SecurityException("Could not load SchematicTypes", e);
-            }
-
-            if(config.contains("Server"))
-                new ArenaMode(configFile.getName().replace(".yml", ""), config);
-        }
-    }
-
-    public static ArenaMode getByChat(String name){
-        return byChat.get(name.toLowerCase());
-    }
-
-    public static ArenaMode getByInternal(String name){
-        return byInternal.get(name);
-    }
-
-    public static List<String> getAllChatNames(boolean historic) {
-        List<String> chatNames = new LinkedList<>();
-        for(ArenaMode mode : byInternal.values()){
-            if(historic == mode.historic)
-                chatNames.addAll(mode.chatNames);
-        }
-        return chatNames;
-    }
-
-    public static List<String> getAllRankedChatNames(){
-        List<String> chatNames = new LinkedList<>();
-        for(ArenaMode mode : byInternal.values()){
-            if(mode.isRanked())
-                chatNames.addAll(mode.chatNames);
-        }
-        return chatNames;
-    }
-
-    public static ArenaMode getBySchemType(SchematicType schemType){
-        return bySchemType.get(schemType);
-    }
-
-    public static List<ArenaMode> getAllModes(){
-        return allModes;
-    }
-
-    private final String displayName;
-    private final String folder;
-    private final List<String> chatNames;
-    private final String serverJar;
-    private final String config;
-    private final List<String> maps;
-    private final Map<String, String> lowerToRealMapNames = new HashMap<>();
-    private final boolean historic;
-    private final String internalName;
-
-    private final boolean ranked;
-    private final String schemType;
-
-    private ArenaMode(String internalName, Configuration config){
-        this.internalName = internalName;
-        this.folder = config.getString("Server.Folder");
-        this.serverJar = config.getString("Server.ServerJar");
-        this.config = internalName + ".yml";
-        this.maps = config.getStringList("Server.Maps");
-        maps.forEach(map -> lowerToRealMapNames.put(map.toLowerCase(), map));
-        this.displayName = config.getString("GameName", internalName);
-        this.chatNames = config.getStringList("Server.ChatNames");
-        this.schemType = config.getString("Schematic.Type", "").toLowerCase();
-
-        this.ranked = config.getBoolean("Server.Ranked", false);
-        this.historic = config.getBoolean("Server.Historic", false);
-
-        allModes.add(this);
-        byInternal.put(internalName, this);
-        for(String name : chatNames){
-            byChat.put(name.toLowerCase(), this);
-        }
-
-        if(!this.schemType.equals(""))
-            bySchemType.put(SchematicType.fromDB(this.schemType), this);
-    }
-
-    public String getDisplayName() {
-        return displayName;
-    }
-
-    public String serverJar() {
-        return serverJar;
-    }
-
-    public String getConfig(){
-        return config;
-    }
-
-    public String hasMap(String map){
-        for(String m : maps){
-            if(m.equalsIgnoreCase(map))
-                return m;
-        }
-        return null;
-    }
-
-    public String getFolder() {
-        return folder;
-    }
-
-    public String getRandomMap(){
-        return maps.get(random.nextInt(maps.size()));
-    }
-
-    public List<String> getMaps() {
-        return maps;
-    }
-
-    public String convertToRealMapName(String map){
-        return lowerToRealMapNames.get(map.toLowerCase());
-    }
-
-    public String getChatName(){
-        return chatNames.get(0);
-    }
-
-    public boolean withoutChatName(){
-        return chatNames.isEmpty();
-    }
-
-    public boolean isHistoric(){
-        return historic;
-    }
-
-    public boolean isRanked() {
-        return ranked;
-    }
-
-    public String getSchemType() {
-        return schemType;
-    }
-
-    public String getInternalName() {
-        return internalName;
-    }
-}

src/de/steamwar/bungeecore/BungeeCore.java

@@ -1,341 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore;
-
-import de.steamwar.bungeecore.bot.SteamwarDiscordBot;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import de.steamwar.bungeecore.commands.*;
-import de.steamwar.bungeecore.listeners.*;
-import de.steamwar.bungeecore.listeners.mods.*;
-import de.steamwar.bungeecore.listeners.ping.PingListener;
-import de.steamwar.bungeecore.network.BungeeNetworkHandler;
-import de.steamwar.bungeecore.network.NetworkReceiver;
-import de.steamwar.bungeecore.sql.*;
-import de.steamwar.bungeecore.tablist.TablistManager;
-import de.steamwar.command.SWCommandUtils;
-import de.steamwar.command.SWTypeMapperCreator;
-import de.steamwar.command.TabCompletionCache;
-import de.steamwar.command.TypeMapper;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.ChatMessageType;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.chat.HoverEvent;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.config.ServerInfo;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.plugin.Plugin;
-import net.md_5.bungee.config.Configuration;
-import net.md_5.bungee.config.ConfigurationProvider;
-import net.md_5.bungee.config.YamlConfiguration;
-
-import java.io.File;
-import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-
-public class BungeeCore extends Plugin {
-
-    public static boolean MAIN_SERVER;
-
-    public static String CHAT_PREFIX;
-    public static String LOBBY_SERVER;
-    public static boolean EVENT_MODE;
-
-    private static BungeeCore instance;
-
-    public static final Map<String, String> serverPermissions = new HashMap<>();
-    public static final Map<String, String> commands = new HashMap<>();
-
-    public static Node local;
-    private ErrorLogger errorLogger;
-    private TablistManager tablistManager;
-
-    @Override
-    public void onEnable(){
-        getProxy().registerChannel("sw:bridge");
-        getProxy().registerChannel("fabricmodsender:mods");
-        getProxy().registerChannel("nochatreports:sync");
-
-        setInstance(this);
-        MAIN_SERVER = ProxyServer.getInstance().getConfig().getListeners().stream().anyMatch(info -> ((InetSocketAddress) info.getSocketAddress()).getPort() == 25565);
-        loadConfig();
-
-        errorLogger = new ErrorLogger();
-
-        SWCommandUtils.init((SWTypeMapperCreator<TypeMapper<Object>, CommandSender, Object>) (mapper, tabCompleter) -> new TypeMapper<Object>() {
-            @Override
-            public Object map(CommandSender commandSender, String[] previousArguments, String s) {
-                return mapper.apply(s);
-            }
-
-            @Override
-            public Collection<String> tabCompletes(CommandSender sender, String[] previousArguments, String s) {
-                return tabCompleter.apply(sender, s);
-            }
-        });
-        BungeeCord.getInstance().getScheduler().schedule(this, TabCompletionCache::invalidateOldEntries, 1, 1, TimeUnit.SECONDS);
-
-        new ConnectionListener();
-        new Forge();
-        new Forge12();
-        new LabyMod();
-        new Badlion();
-        new ChatListener();
-        new BanListener();
-        new CheckListener();
-        new ModLoaderBlocker();
-        new WorldDownloader();
-        new BrandListener();
-        new Fabric();
-        new SubserverProtocolFixer();
-        new PingListener();
-
-        local = new Node.LocalNode();
-        if(MAIN_SERVER) {
-            new Node.RemoteNode("lx");
-        }
-
-        commands.put("/tp", null);
-        commands.put("/bc", null);
-        commands.put("/bauchat", null);
-        commands.put("/local", null);
-
-        new TeamchatCommand();
-        new MsgCommand();
-        new RCommand();
-        new PingCommand();
-        new AlertCommand();
-        new KickCommand();
-        new JoinmeCommand();
-        new TpCommand();
-        new HelpCommand();
-        new TeamCommand();
-        new ServerTeamchatCommand();
-        new DevCommand();
-        new EventCommand();
-        new EventreloadCommand();
-        new EventRescheduleCommand();
-        new PollCommand();
-        new BugCommand();
-        new WhoisCommand();
-        new RegelnCommand();
-        new IgnoreCommand();
-        new UnIgnoreCommand();
-        new PollresultCommand();
-        new ListCommand();
-        new StatCommand();
-        new VerifyCommand();
-        new GDPRQuery();
-        new PlaytimeCommand();
-        new ArenaCommand();
-        new RankCommand();
-        new LocalCommand();
-        new SetLocaleCommand();
-        new BuilderCloudCommand();
-
-        // Punishment Commands:
-        new PunishmentCommand("ban", Punishment.PunishmentType.Ban);
-        new PunishmentCommand("mute", Punishment.PunishmentType.Mute);
-        new PunishmentCommand("noschemreceiving", Punishment.PunishmentType.NoSchemReceiving);
-        new PunishmentCommand("noschemsharing", Punishment.PunishmentType.NoSchemSharing);
-        new PunishmentCommand("noschemsubmitting", Punishment.PunishmentType.NoSchemSubmitting);
-        new PunishmentCommand("nodev", Punishment.PunishmentType.NoDevServer);
-        new PunishmentCommand("nofight", Punishment.PunishmentType.NoFightServer);
-        new PunishmentCommand("noteamserver", Punishment.PunishmentType.NoTeamServer);
-        new PunishmentCommand("note", Punishment.PunishmentType.Note);
-
-        if(!EVENT_MODE){
-            new BauCommand();
-            new WebpasswordCommand();
-            new FightCommand();
-            new ChallengeCommand();
-            new HistoricCommand();
-            new CheckCommand();
-            new ReplayCommand();
-            new TutorialCommand();
-
-            new Broadcaster();
-        }else{
-            new EventModeListener();
-        }
-
-        new EventStarter();
-        new SessionManager();
-        new NetworkReceiver();
-        BungeeNetworkHandler.register();
-        tablistManager = new TablistManager();
-        new SettingsChangedListener();
-
-        getProxy().getScheduler().schedule(this, () -> {
-            SteamwarUser.clearCache();
-            UserElo.clearCache();
-            Team.clearCache();
-        }, 1, 1, TimeUnit.HOURS);
-
-        if (SteamwarDiscordBotConfig.loaded) {
-            try {
-                new SteamwarDiscordBot();
-            } catch (Throwable e) {
-                getLogger().log(Level.SEVERE, "Could not initialize discord bot", e);
-            }
-        }
-    }
-
-    @Override
-    public void onDisable(){
-        if (SteamwarDiscordBotConfig.loaded) {
-            try {
-                SteamwarDiscordBot.instance().getJda().shutdown();
-            } catch (Throwable e) {
-                getLogger().log(Level.SEVERE, "Could not shutdown discord bot", e);
-            }
-        }
-
-        if(tablistManager != null)
-            tablistManager.disable();
-        errorLogger.unregister();
-        Statement.closeAll();
-    }
-
-    public static BungeeCore get() {
-        return instance;
-    }
-
-    public static TextComponent stringToText(String msg){
-        return new TextComponent(TextComponent.fromLegacyText(msg));
-    }
-    public static void send(ProxiedPlayer player, String msg){
-        send(player, msg, null, null);
-    }
-    public static void send(CommandSender sender, String msg){
-        sender.sendMessage(stringToText(msg));
-    }
-    public static void send(ProxiedPlayer player, ChatMessageType type, String msg){
-        send(player, type, msg, null, null);
-    }
-    public static void send(ProxiedPlayer player, String msg, String onHover, ClickEvent onClick){
-        send(player, ChatMessageType.SYSTEM, msg, onHover, onClick);
-    }
-    public static void send(ProxiedPlayer player, ChatMessageType type, String msg, String onHover, ClickEvent onClick){
-        if(type == ChatMessageType.CHAT && player.getChatMode() != ProxiedPlayer.ChatMode.SHOWN)
-            return;
-        TextComponent message = stringToText(msg);
-        if(onHover != null)
-            message.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextComponent.fromLegacyText(onHover)));
-        if(onClick != null)
-            message.setClickEvent(onClick);
-        player.sendMessage(type, message);
-    }
-    public static void broadcast(String msg){
-        ProxyServer.getInstance().broadcast(stringToText(msg));
-    }
-    public static void broadcast(String msg, String onHover, ClickEvent onClick){
-        TextComponent message = stringToText(msg);
-        if(onHover != null)
-            message.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, TextComponent.fromLegacyText(onHover)));
-        if(onClick != null)
-            message.setClickEvent(onClick);
-        ProxyServer.getInstance().broadcast(message);
-    }
-
-    public static void log(final ServerInfo server, final String msg){
-        log(server.getName() + ": " + msg);
-    }
-    public static void log(final ProxiedPlayer player, final String msg){
-        log(player.getName() + ": " + msg);
-    }
-    public static void log(final String msg){
-        log(Level.INFO, msg);
-    }
-    public static void log(final Level logLevel, final String msg){
-        get().getLogger().log(logLevel, msg);
-    }
-    public static void log(final String msg, final Throwable e){
-        get().getLogger().log(Level.SEVERE, msg, e);
-    }
-
-
-    private static void loadConfig(){
-        Configuration config;
-        try{
-            if(!get().getDataFolder().exists() && !get().getDataFolder().mkdir())
-                throw new IOException();
-            File configFile = new File(get().getDataFolder().getPath(), "config.yml");
-            if(!configFile.exists()){
-                boolean created = configFile.createNewFile();
-                if(created)
-                    ProxyServer.getInstance().stop("Config file not initialized");
-                else
-                    ProxyServer.getInstance().stop("Could not save conig file");
-                return;
-            }
-            config = ConfigurationProvider.getProvider(YamlConfiguration.class).load(configFile);
-        }catch(Exception e){
-            log("Could not save/load config.yml", e);
-            ProxyServer.getInstance().stop();
-            return;
-        }
-
-        CHAT_PREFIX = config.getString("prefix");
-        LOBBY_SERVER = config.getString("lobbyserver");
-        EVENT_MODE = config.getBoolean("eventmode");
-        Broadcaster.setBroadCastMsgs(config.getStringList("broadcasts").toArray(new String[1]));
-        PollSystem.init(config.getString("poll.question"), config.getStringList("poll.answers"));
-        Persistent.setChatPrefix(CHAT_PREFIX);
-        Persistent.setLobbyServer(LOBBY_SERVER);
-
-        final Configuration servers = config.getSection("servers");
-        for(final String serverName : servers.getKeys()){
-            final Configuration server = servers.getSection(serverName);
-            List<String> cmds = server.getStringList("commands");
-            serverPermissions.put(serverName, "bungeecore.server." + server.getString("permission"));
-            String cmd = cmds.remove(0);
-            new ServerSwitchCommand(
-                    cmd,
-                    serverName,
-                    serverPermissions.get(serverName),
-                    cmds.toArray(new String[0])
-            );
-            if(server.getBoolean("modchecked", false)) {
-                ModLoaderBlocker.addServer(serverName);
-            }
-        }
-
-        File discordFile = new File(System.getProperty("user.home"), "discord.yml");
-        if(discordFile.exists()) {
-            try {
-                SteamwarDiscordBotConfig.loadConfig(ConfigurationProvider.getProvider(YamlConfiguration.class).load(discordFile));
-            } catch (IOException e) {
-                get().getLogger().log(Level.SEVERE, "Could not load discord bot configuration", e);
-            }
-        }
-    }
-
-    private static void setInstance(BungeeCore core){
-        instance = core;
-    }
-}

src/de/steamwar/bungeecore/ErrorLogger.java

@@ -1,92 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore;
-
-import de.steamwar.bungeecore.sql.SWException;
-
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
-import java.text.MessageFormat;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.logging.Handler;
-import java.util.logging.Level;
-import java.util.logging.LogRecord;
-import java.util.logging.Logger;
-
-public class ErrorLogger extends Handler {
-
-    ErrorLogger(){
-        Logger.getLogger("").addHandler(this);
-    }
-
-    void unregister(){
-        Logger.getLogger("").removeHandler(this);
-    }
-
-    @Override
-    public void publish(LogRecord logRecord) {
-        if(logRecord.getLevel().intValue() < Level.WARNING.intValue())
-            return;
-
-        String message = MessageFormat.format(logRecord.getMessage(), logRecord.getParameters());
-        for(String reason : ignoreContains)
-            if(message.contains(reason))
-                return;
-
-        ByteArrayOutputStream stacktraceOutput = new ByteArrayOutputStream();
-        if(logRecord.getThrown() != null)
-            logRecord.getThrown().printStackTrace(new PrintStream(stacktraceOutput));
-        String stacktrace = stacktraceOutput.toString();
-        if (stacktrace.contains("ErrorLogger")) {
-            return;
-        }
-
-
-        SWException.log("Bungee", message, stacktrace);
-    }
-
-    @Override
-    public void flush() {
-        //ignored
-    }
-
-    @Override
-    public void close() {
-        //ignored
-    }
-
-    private static final List<String> ignoreContains;
-
-    static {
-        List<String> contains = new ArrayList<>();
-        contains.add("Error authenticating ");
-        contains.add("read timed out");
-        contains.add("could not decode packet");
-        contains.add("Connection reset by peer");
-        contains.add("No client connected for pending server");
-        contains.add("Error occurred processing connection for");
-        contains.add("Server is online mode!");
-        contains.add(" took ");
-        contains.add("Could not translate packet ");
-        ignoreContains = Collections.unmodifiableList(contains);
-    }
-}

src/de/steamwar/bungeecore/EventStarter.java

@@ -1,96 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore;
-
-import de.steamwar.bungeecore.sql.Event;
-import de.steamwar.bungeecore.sql.EventFight;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.bungeecore.sql.Team;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.scheduler.ScheduledTask;
-
-import java.sql.Timestamp;
-import java.util.Map;
-import java.util.Queue;
-import java.util.concurrent.TimeUnit;
-
-import static de.steamwar.bungeecore.Storage.eventServer;
-
-public class EventStarter implements Runnable {
-
-    private static ScheduledTask task = null;
-
-    EventStarter(){
-        EventFight.loadAllComingFights();
-
-        if(task != null)
-            task.cancel();
-
-        ProxyServer.getInstance().getScheduler().schedule(BungeeCore.get(), this, 1, 10, TimeUnit.SECONDS);
-    }
-
-    public static Map<Integer, Subserver> getEventServer() {
-        return eventServer;
-    }
-
-    @Override
-    public void run() {
-        eventServer.entrySet().removeIf(entry -> !Subserver.getServerList().contains(entry.getValue()));
-        Queue<EventFight> fights = EventFight.getFights();
-
-        EventFight next;
-        while((next = nextFight(fights)) != null){
-            Team blue = Team.get(next.getTeamBlue());
-            Team red = Team.get(next.getTeamRed());
-
-            //Don't start EventServer if not the event bungee
-            if(BungeeCore.EVENT_MODE || !Event.get(next.getEventID()).spectateSystem()) {
-                ServerStarter starter = new ServerStarter().event(next);
-
-                ProxiedPlayer leiter = ProxyServer.getInstance().getPlayer(SteamwarUser.get(next.getKampfleiter()).getUuid());
-                if(leiter != null)
-                    starter.send(leiter);
-
-                Subserver subserver = starter.start();
-
-                eventServer.put(blue.getTeamId(), subserver);
-                eventServer.put(red.getTeamId(), subserver);
-                Message.broadcast("EVENT_FIGHT_BROADCAST", "EVENT_FIGHT_BROADCAST_HOVER",
-                        new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/event " + blue.getTeamKuerzel()), blue.getTeamColor(), blue.getTeamName(), red.getTeamColor(), red.getTeamName());
-            } else {
-                Message.broadcast("EVENT_FIGHT_BROADCAST", "EVENT_FIGHT_BROADCAST_HOVER",
-                        new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/spectate"), blue.getTeamColor(), blue.getTeamName(), red.getTeamColor(), red.getTeamName());
-            }
-        }
-    }
-
-    private EventFight nextFight(Queue<EventFight> fights){
-        EventFight next = fights.peek();
-        if(next == null)
-            return null;
-
-        if(!next.getStartTime().before(new Timestamp(System.currentTimeMillis())))
-            return null;
-
-        return fights.poll();
-    }
-}

src/de/steamwar/bungeecore/Message.java

@@ -1,145 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore;
-
-import de.steamwar.messages.ChatSender;
-import de.steamwar.messages.SteamwarResourceBundle;
-import net.md_5.bungee.api.ChatMessageType;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.chat.TextComponent;
-
-import java.text.DateFormat;
-import java.text.MessageFormat;
-import java.util.Date;
-import java.util.Locale;
-import java.util.ResourceBundle;
-
-public class Message {
-
-    @Deprecated
-    public static TextComponent parseToComponent(String message, boolean prefixed, CommandSender sender, Object... params){
-        return new TextComponent(TextComponent.fromLegacyText(parse(message, prefixed, locale(sender), params)));
-    }
-
-    @Deprecated
-    public static String parsePrefixed(String message, CommandSender sender, Object... params){
-        return parse(message, true, locale(sender), params);
-    }
-
-    @Deprecated
-    public static String parse(String message, CommandSender sender, Object... params){
-        return parse(message, false, locale(sender), params);
-    }
-
-    @Deprecated
-    public static String parse(String message, Locale locale, Object... params){
-        return parse(message, false, locale, params);
-    }
-
-    @Deprecated
-    private static Locale locale(CommandSender sender) {
-        return ChatSender.of(sender).getLocale();
-    }
-
-    @Deprecated
-    private static String parse(String message, boolean prefixed, Locale locale, Object... params){
-        if(locale == null)
-            locale = Locale.getDefault();
-        ResourceBundle resourceBundle = SteamwarResourceBundle.getResourceBundle(locale);
-        String pattern = "";
-        if(prefixed)
-            pattern = resourceBundle.getObject("PREFIX") + " ";
-        pattern += (String)resourceBundle.getObject(message);
-
-        MessageFormat format = new MessageFormat(pattern, locale);
-        for (int i = 0; i < params.length; i++) {
-            if(params[i] instanceof Message) {
-                Message msg = (Message) params[i];
-                params[i] = parse(msg.getFormat(), false, locale, msg.getParams());
-            } else if(params[i] instanceof Date) {
-                params[i] = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, locale).format((Date) params[i]);
-            }
-        }
-        return format.format(params);
-    }
-
-    @Deprecated
-    public static void send(String message, CommandSender sender, Object... params){
-        send(message, true, sender, ChatMessageType.SYSTEM, null, null, params);
-    }
-
-    @Deprecated
-    public static void sendPrefixless(String message, CommandSender sender, Object... params){
-        send(message, false, sender, ChatMessageType.SYSTEM, null, null, params);
-    }
-
-    @Deprecated
-    public static void send(String message, CommandSender sender, String onHover, ClickEvent onClick, Object... params){
-        send(message, true, sender, ChatMessageType.SYSTEM, onHover, onClick, params);
-    }
-
-    @Deprecated
-    public static void sendPrefixless(String message, CommandSender sender, String onHover, ClickEvent onClick, Object... params){
-        send(message, false, sender, ChatMessageType.SYSTEM, onHover, onClick, params);
-    }
-
-    @Deprecated
-    private static void send(String message, boolean prefixed, CommandSender s, ChatMessageType type, String onHover, ClickEvent onClick, Object... params){
-        ChatSender sender = ChatSender.of(s);
-        if(type == ChatMessageType.CHAT && !sender.chatShown())
-            return;
-
-        sender.send(prefixed, type, onHover != null ? new Message("PLAIN_STRING", onHover) : null, onClick, new Message(message, params));
-    }
-
-    public static void broadcast(String message, Object... params) {
-        broadcast(message, null, null, params);
-    }
-
-    public static void broadcast(String message, String onHover, ClickEvent onClick, Object... params) {
-        ChatSender.allReceivers().forEach(player -> player.system(message, onHover != null ? new Message(onHover, params) : null, onClick, params));
-    }
-
-    public static void team(String message, Object... params) {
-        team(message, null, null, params);
-    }
-
-    public static void team(String message, String onHover, ClickEvent onClick, Object... params) {
-        ChatSender.serverteamReceivers().filter(player -> player.user().getUserGroup().isTeamGroup()).forEach(player -> player.prefixless(message, onHover != null ? new Message(onHover, params) : null, onClick, params));
-    }
-
-    private final String format;
-    private final Object[] params;
-
-    public Message(String format, Object... params) {
-        this.format = format;
-        this.params = params;
-    }
-
-    public String getFormat() {
-        return format;
-    }
-
-    public Object[] getParams() {
-        return params;
-    }
-
-}

src/de/steamwar/bungeecore/bot/AuthManager.java

@@ -1,81 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot;
-
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import net.dv8tion.jda.api.MessageBuilder;
-import net.dv8tion.jda.api.entities.Emoji;
-import net.dv8tion.jda.api.entities.Member;
-import net.dv8tion.jda.api.interactions.components.ActionRow;
-import net.dv8tion.jda.api.interactions.components.Button;
-
-import java.util.*;
-import java.util.concurrent.TimeUnit;
-
-public class AuthManager {
-
-    private static final Map<String, Long> TOKENS = new HashMap<>();
-    private static final Random rand = new Random();
-
-    public static String createDiscordAuthToken(Member member) {
-        if(TOKENS.containsValue(member.getIdLong())) return null;
-
-        byte[] randBytes = new byte[16];
-        rand.nextBytes(randBytes);
-        randBytes[0] = 'D';
-        randBytes[1] = 'C';
-        String code = Base64.getEncoder().encodeToString(randBytes);
-
-        TOKENS.put(code, member.getIdLong());
-        BungeeCore.log("Created Discord Auth-Token: " + code + " for: " + member.getUser().getAsTag());
-        BungeeCore.get().getProxy().getScheduler().schedule(BungeeCore.get(), () -> TOKENS.remove(code), 10, TimeUnit.MINUTES);
-        return code;
-    }
-
-    public static Member connectAuth(SteamwarUser user, String code) {
-        if (TOKENS.containsKey(code)) {
-            Member member = SteamwarDiscordBot.instance().getJda().getGuildById(SteamwarDiscordBotConfig.GUILD).retrieveMemberById(TOKENS.get(code).longValue()).complete();
-            if(member == null) return null;
-            user.setDiscordId(member.getIdLong());
-            MessageBuilder builder = new MessageBuilder();
-            builder.setContent(":white_check_mark: Dein Discord Konto wurde mit **" + user.getUserName() + "** verknüpft");
-            builder.setActionRows(ActionRow.of(Button.success("tada", Emoji.fromUnicode("U+1F389")), Button.danger("invalid", "Ich war das nicht")));
-
-            try {
-                member.getUser().openPrivateChannel().queue(privateChannel -> privateChannel.sendMessage(builder.build()).queue());
-                if (member.getNickname() == null) {
-                    try {
-                        member.getGuild().modifyNickname(member, user.getUserName()).queue();
-                    } catch (Exception e) {
-                        // Ignored
-                    }
-                }
-                TOKENS.remove(code);
-                return member;
-            } catch (Exception e) {
-                return null;
-            }
-        } else {
-            return null;
-        }
-    }
-}

src/de/steamwar/bungeecore/bot/SteamwarDiscordBot.java

@@ -1,166 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot;
-
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.bot.commands.*;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import de.steamwar.bungeecore.bot.events.EventManager;
-import de.steamwar.bungeecore.bot.events.SchematicsManager;
-import de.steamwar.bungeecore.bot.listeners.*;
-import de.steamwar.bungeecore.bot.util.DiscordRolesMessage;
-import de.steamwar.bungeecore.bot.util.DiscordRulesMessage;
-import de.steamwar.bungeecore.bot.util.DiscordTicketMessage;
-import de.steamwar.bungeecore.sql.Event;
-import de.steamwar.messages.ChatSender;
-import lombok.Getter;
-import net.dv8tion.jda.api.JDA;
-import net.dv8tion.jda.api.JDABuilder;
-import net.dv8tion.jda.api.OnlineStatus;
-import net.dv8tion.jda.api.entities.Activity;
-import net.dv8tion.jda.api.entities.Guild;
-import net.dv8tion.jda.api.exceptions.ErrorResponseException;
-import net.dv8tion.jda.api.hooks.ListenerAdapter;
-import net.dv8tion.jda.api.requests.restaction.CommandListUpdateAction;
-import net.dv8tion.jda.api.utils.MemberCachePolicy;
-import net.md_5.bungee.api.ProxyServer;
-
-import javax.security.auth.login.LoginException;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-
-public class SteamwarDiscordBot {
-
-    private static SteamwarDiscordBot INSTANCE;
-
-    public static SteamwarDiscordBot instance() {
-        return INSTANCE;
-    }
-
-    @Getter
-    private volatile AnnouncementListener announcementListener;
-
-    @Getter
-    private volatile DiscordChatListener ingameChatListener;
-
-    @Getter
-    private volatile DiscordChatListener serverTeamChatListener;
-
-    @Getter
-    private final JDA jda;
-
-    @Getter
-    private static Map<String, BasicDiscordCommand> discordCommandMap = new HashMap<>();
-
-    public SteamwarDiscordBot() {
-        INSTANCE = this;
-        JDABuilder builder = JDABuilder.createDefault(SteamwarDiscordBotConfig.TOKEN);
-        builder.setStatus(OnlineStatus.ONLINE);
-        builder.setMemberCachePolicy(MemberCachePolicy.ONLINE);
-        try {
-            jda = builder.build();
-        } catch (LoginException e) {
-            throw new SecurityException("Could not Login: " + SteamwarDiscordBotConfig.TOKEN, e);
-        }
-        ProxyServer.getInstance().getScheduler().runAsync(BungeeCore.get(), () -> {
-            try {
-                jda.awaitReady();
-            } catch (InterruptedException e) {
-                e.printStackTrace();
-            }
-            try {
-                activity();
-            } catch (Exception e) {
-                BungeeCore.get().getLogger().log(Level.SEVERE, "Could not set initial activity to discord", e);
-            }
-            EventManager.update();
-            SchematicsManager.update();
-            ProxyServer.getInstance().getScheduler().schedule(BungeeCore.get(), () -> {
-                try {
-                    activity();
-                    EventManager.update();
-                    SchematicsManager.update();
-                } catch (ErrorResponseException e) {
-                    //ignored
-                }
-            }, 30, 30, TimeUnit.SECONDS);
-            DiscordRolesMessage.sendMessage();
-            DiscordRulesMessage.sendMessage();
-            DiscordTicketMessage.sendMessage();
-            new RolesInteractionButtonListener();
-            new DiscordTicketListener();
-            new DiscordAuthListener();
-            new DiscordEventListener();
-            new PrivateMessageListener();
-            announcementListener = new AnnouncementListener();
-            ingameChatListener = new DiscordChatListener(SteamwarDiscordBotConfig.INGAME_CHANNEL, "CHAT_DISCORD_GLOBAL", ChatSender::globalReceivers);
-            serverTeamChatListener = new DiscordChatListener(SteamwarDiscordBotConfig.SERVER_TEAM_CHANNEL, "CHAT_SERVERTEAM", ChatSender::serverteamReceivers);
-            new SlashCommandListener();
-            jda.retrieveCommands().complete().forEach(command -> jda.deleteCommandById(command.getId()).queue());
-
-            Guild guild = jda.getGuildById(SteamwarDiscordBotConfig.GUILD);
-            guild.retrieveCommands().complete().forEach(command -> guild.deleteCommandById(command.getId()).complete());
-            CommandListUpdateAction commands = jda.getGuildById(SteamwarDiscordBotConfig.GUILD).updateCommands();
-            addCommand(commands, new MuteCommand());
-            addCommand(commands, new BanCommand());
-            addCommand(commands, new WhoisCommand());
-            addCommand(commands, new TeamCommand());
-            addCommand(commands, new ListCommand());
-            addCommand(commands, new UnbanCommand());
-            commands.complete();
-        });
-    }
-
-    private void addCommand(CommandListUpdateAction commands, BasicDiscordCommand basicDiscordCommand) {
-        commands.addCommands(basicDiscordCommand);
-        discordCommandMap.put(basicDiscordCommand.getName(), basicDiscordCommand);
-    }
-
-    private int index = 0;
-
-    private void activity() {
-        switch (index) {
-            case 0:
-                Event event = Event.get();
-                if (event != null) {
-                    jda.getPresence().setActivity(Activity.competing("dem Event " + event.getEventName()));
-                } else {
-                    jda.getPresence().setActivity(Activity.playing("auf SteamWar.de"));
-                }
-                break;
-            case 1:
-                int count = BungeeCore.get().getProxy().getOnlineCount();
-                if (count == 1) {
-                    jda.getPresence().setActivity(Activity.playing("mit 1 Spieler"));
-                } else {
-                    jda.getPresence().setActivity(Activity.playing("mit " + count + " Spielern"));
-                }
-                index = 0;
-                return;
-        }
-        index++;
-    }
-
-    public void addListener(ListenerAdapter listenerAdapter) {
-        jda.addEventListener(listenerAdapter);
-    }
-}

src/de/steamwar/bungeecore/bot/commands/BanCommand.java

@@ -1,67 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.commands;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.commands.PunishmentCommand;
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
-import net.dv8tion.jda.api.interactions.commands.OptionType;
-
-import java.sql.Timestamp;
-
-public class BanCommand extends BasicDiscordCommand {
-
-    public BanCommand() {
-        super("ban", "Banne einen Nutzer, wenn du die Rechte hast.");
-
-        addOption(OptionType.STRING, "user", "Der Benutzer", true);
-        addOption(OptionType.STRING, "time", "Bis Wann", true);
-        addOption(OptionType.STRING, "reason", "Warum", true);
-    }
-
-    @Override
-    public void run(SlashCommandEvent event) {
-        if (!testPermission(event)) {
-            return;
-        }
-
-        SteamwarUser sender = SteamwarUser.get(event.getMember().getIdLong());
-        SteamwarUser target = SteamwarUser.getOrCreateOfflinePlayer(event.getOption("user").getAsString());
-        if (target == null) {
-            event.reply("Angegebener User invalide").setEphemeral(true).queue();
-            return;
-        }
-
-        Timestamp time = PunishmentCommand.parseTime(null, event.getOption("time").getAsString());
-        if (time == null) {
-            event.reply("Angegebene Zeit invalide").setEphemeral(true).queue();
-            return;
-        }
-
-        String msg = event.getOption("reason").getAsString();
-        boolean isPerma = event.getOption("time").getAsString().equals("perma");
-
-        target.punish(Punishment.PunishmentType.Ban, time, msg, sender.getId(), isPerma);
-        Message.team("BAN_TEAM", new Message("PREFIX"), target.getUserName(), sender.getUserName(), new Message((isPerma ? "BAN_PERMA" : "BAN_UNTIL"), time), msg);
-        event.reply("Erfolgreich " + target.getUserName() + (isPerma ? " permanent" : " bis " + time) + " gebannt").setEphemeral(true).queue();
-    }
-}

src/de/steamwar/bungeecore/bot/commands/BasicDiscordCommand.java

@@ -1,54 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.commands;
-
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.bungeecore.sql.UserGroup;
-import net.dv8tion.jda.api.entities.Member;
-import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
-import net.dv8tion.jda.api.interactions.commands.build.CommandData;
-
-public abstract class BasicDiscordCommand extends CommandData {
-
-    protected BasicDiscordCommand(String name, String description) {
-        super(name, description);
-    }
-
-    public abstract void run(SlashCommandEvent event);
-
-    protected SteamwarUser getSteamwarUser(SlashCommandEvent event) {
-        Member member = event.getMember();
-        SteamwarUser steamwarUser = SteamwarUser.get(member.getIdLong());
-        if (steamwarUser == null) {
-            return null;
-        }
-        return steamwarUser;
-    }
-
-    protected boolean testPermission(SlashCommandEvent event) {
-        Member member = event.getMember();
-        SteamwarUser steamwarUser = SteamwarUser.get(member.getIdLong());
-        if (steamwarUser == null || (!steamwarUser.getUserGroup().isTeamGroup() && steamwarUser.getUserGroup() != UserGroup.Builder)) {
-            event.reply("Du hast für " + event.getName() + " keine Rechte oder es existiert keine Verknüpfung für dich.").setEphemeral(true).queue();
-            return false;
-        }
-        return true;
-    }
-}

src/de/steamwar/bungeecore/bot/commands/ListCommand.java

@@ -1,43 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.commands;
-
-import net.dv8tion.jda.api.EmbedBuilder;
-import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
-
-import java.util.stream.Collectors;
-
-public class ListCommand extends BasicDiscordCommand {
-
-    public ListCommand() {
-        super("list", "Gebe eine Liste aller online Spieler");
-    }
-
-    @Override
-    public void run(SlashCommandEvent event) {
-        de.steamwar.bungeecore.commands.ListCommand.getCustomTablist();
-        EmbedBuilder embedBuilder = new EmbedBuilder();
-        embedBuilder.setTitle("List");
-        de.steamwar.bungeecore.commands.ListCommand.getCustomTablist().forEach((s, proxiedPlayers) -> {
-            embedBuilder.addField(s, proxiedPlayers.stream().map(player -> "`" + player.getName() + "`").collect(Collectors.joining(", ")), true);
-        });
-        event.replyEmbeds(embedBuilder.build()).setEphemeral(true).queue();
-    }
-}

src/de/steamwar/bungeecore/bot/commands/MuteCommand.java

@@ -1,67 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.commands;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.commands.PunishmentCommand;
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
-import net.dv8tion.jda.api.interactions.commands.OptionType;
-
-import java.sql.Timestamp;
-
-public class MuteCommand extends BasicDiscordCommand {
-
-    public MuteCommand() {
-        super("mute", "Mute einen Nutzer, wenn du die Rechte hast.");
-
-        addOption(OptionType.STRING, "user", "Der Benutzer", true);
-        addOption(OptionType.STRING, "time", "Bis Wann", true);
-        addOption(OptionType.STRING, "reason", "Warum", true);
-    }
-
-    @Override
-    public void run(SlashCommandEvent event) {
-        if (!testPermission(event)) {
-            return;
-        }
-
-        SteamwarUser sender = SteamwarUser.get(event.getMember().getIdLong());
-        SteamwarUser target = SteamwarUser.getOrCreateOfflinePlayer(event.getOption("user").getAsString());
-        if (target == null) {
-            event.reply("Angegebener User invalide").setEphemeral(true).complete();
-            return;
-        }
-
-        Timestamp time = PunishmentCommand.parseTime(null, event.getOption("time").getAsString());
-        if (time == null) {
-            event.reply("Angegebene Zeit invalide").setEphemeral(true).complete();
-            return;
-        }
-
-        String msg = event.getOption("reason").getAsString();
-        boolean isPerma = event.getOption("time").getAsString().equals("perma");
-
-        target.punish(Punishment.PunishmentType.Mute, time, msg, sender.getId(), isPerma);
-        Message.team("MUTE_TEAM", new Message("PREFIX"), target.getUserName(), sender.getUserName(), new Message((isPerma ? "BAN_PERMA" : "BAN_UNTIL"), time), msg);
-        event.reply("Erfolgreich " + target.getUserName() + (isPerma ? " permanent" : " bis " + time) + " gemutet").setEphemeral(true).queue();
-    }
-}

src/de/steamwar/bungeecore/bot/commands/TeamCommand.java

@@ -1,96 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.commands;
-
-import de.steamwar.bungeecore.sql.Event;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.bungeecore.sql.Team;
-import de.steamwar.bungeecore.sql.TeamTeilnahme;
-import net.dv8tion.jda.api.EmbedBuilder;
-import net.dv8tion.jda.api.entities.Emoji;
-import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
-import net.dv8tion.jda.api.interactions.commands.OptionMapping;
-import net.dv8tion.jda.api.interactions.commands.OptionType;
-import net.dv8tion.jda.api.interactions.commands.build.SubcommandData;
-import net.md_5.bungee.api.ProxyServer;
-
-import java.awt.*;
-import java.util.List;
-import java.util.stream.Collectors;
-
-public class TeamCommand extends BasicDiscordCommand {
-
-    public TeamCommand() {
-        super("team", "Alle Team bezogenen Befehle");
-
-        addSubcommands(new SubcommandData("info", "Infos über das Team oder deins")
-                .addOption(OptionType.STRING, "team", "Name oder Kuerzel", false)
-        );
-    }
-
-    private Emoji emoji = Emoji.fromUnicode("U+1F7E2");
-
-    @Override
-    public void run(SlashCommandEvent event) {
-        SteamwarUser steamwarUser = getSteamwarUser(event);
-
-        if (event.getSubcommandName() != null) {
-            switch (event.getSubcommandName()) {
-                case "info":
-                    OptionMapping optionMapping = event.getOption("team");
-                    Team team;
-                    if (optionMapping == null) {
-                        if (steamwarUser == null) {
-                            event.reply("Dein Discord ist nicht verknüpft").setEphemeral(true).queue();
-                            return;
-                        }
-                        if (steamwarUser.getTeam() == 0) {
-                            event.reply("Du bist in keinem Team").setEphemeral(true).queue();
-                            return;
-                        }
-                        team = Team.get(steamwarUser.getTeam());
-                    } else {
-                        team = Team.get(optionMapping.getAsString());
-                    }
-                    if (team == null) {
-                        event.reply("Unbekanntes Team").setEphemeral(true).queue();
-                        return;
-                    }
-                    EmbedBuilder embedBuilder = new EmbedBuilder();
-                    embedBuilder.setTitle("Team: " + team.getTeamName() + " [" + team.getTeamKuerzel() + "]");
-                    embedBuilder.setColor(Color.GRAY);
-                    List<SteamwarUser> members = team.getMembers().stream().map(SteamwarUser::get).collect(Collectors.toList());
-
-                    embedBuilder.addField("Leader", members.stream().filter(SteamwarUser::isLeader).map(user -> "`" + (isOnline(user) ? emoji.getAsMention() : "") + user.getUserName() + "`").collect(Collectors.joining(" ")), false);
-                    embedBuilder.addField("Member", members.stream().filter(user -> !user.isLeader()).map(user -> "`" + (isOnline(user) ? emoji.getAsMention() : "") + user.getUserName() + "`").collect(Collectors.joining(" ")), false);
-                    embedBuilder.addField("Events", "`" + TeamTeilnahme.getEvents(team.getTeamId()).stream().map(Event::getEventName).collect(Collectors.joining("` `")) + "`", false);
-                    event.replyEmbeds(embedBuilder.build()).setEphemeral(true).queue();
-                    return;
-                default:
-                    event.reply("Unbekannter Befehl").setEphemeral(true).queue();
-                    return;
-            }
-        }
-    }
-
-    private boolean isOnline(SteamwarUser user) {
-        return ProxyServer.getInstance().getPlayer(user.getUuid()) != null;
-    }
-}

src/de/steamwar/bungeecore/bot/commands/UnbanCommand.java

@@ -1,59 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.commands;
-
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
-import net.dv8tion.jda.api.interactions.commands.OptionType;
-
-import java.sql.Timestamp;
-import java.util.Date;
-
-public class UnbanCommand extends BasicDiscordCommand {
-
-    public UnbanCommand() {
-        super("unban", "Entbannt einen Nutzer, wenn du die Rechte hast.");
-
-        addOption(OptionType.STRING, "user", "Der Benutzer", true);
-    }
-
-    @Override
-    public void run(SlashCommandEvent event) {
-        if (!testPermission(event)) {
-            return;
-        }
-
-        SteamwarUser sender = SteamwarUser.get(event.getMember().getIdLong());
-        SteamwarUser target = SteamwarUser.getOrCreateOfflinePlayer(event.getOption("user").getAsString());
-        if (target == null) {
-            event.reply("Angegebener User invalide").setEphemeral(true).queue();
-            return;
-        }
-
-        if (!target.isPunished(Punishment.PunishmentType.Ban)) {
-            event.reply("Angegebener User ist nicht gebannt").setEphemeral(true).queue();
-            return;
-        }
-
-        target.punish(Punishment.PunishmentType.Ban, Timestamp.from(new Date().toInstant()), "Unban", sender.getId(), false);
-        event.reply("Erfolgreich " + target.getUserName() + " entbannt").setEphemeral(true).queue();
-    }
-}

src/de/steamwar/bungeecore/bot/commands/WhoisCommand.java

@@ -1,94 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.commands;
-
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.bungeecore.sql.Team;
-import net.dv8tion.jda.api.EmbedBuilder;
-import net.dv8tion.jda.api.events.interaction.SlashCommandEvent;
-import net.dv8tion.jda.api.interactions.commands.OptionType;
-
-import java.sql.Timestamp;
-import java.text.DecimalFormat;
-import java.util.List;
-
-public class WhoisCommand extends BasicDiscordCommand {
-
-    public WhoisCommand() {
-        super("whois", "Der whois Befehl");
-
-        addOption(OptionType.STRING, "user", "Der Benutzer", true);
-    }
-
-    @Override
-    public void run(SlashCommandEvent event) {
-        if (!testPermission(event)) {
-            return;
-        }
-
-        String s = event.getOption("user").getAsString();
-
-        SteamwarUser user = SteamwarUser.get(s);
-        if (user == null) {
-            try {
-                int id = Integer.parseInt(s);
-                user = SteamwarUser.get(id);
-            } catch (NumberFormatException ignored) {
-                // Ignored
-            }
-        }
-        if (user == null) {
-            try {
-                long id = Long.parseLong(s);
-                user = SteamwarUser.get(id);
-            } catch (NumberFormatException ignored) {
-                // Ignored
-            }
-        }
-
-        if (user == null) {
-            event.reply("Der angegebene Spieler ist unbekannt").setEphemeral(true).complete();
-            return;
-        }
-
-        EmbedBuilder embedBuilder = new EmbedBuilder();
-        embedBuilder.setTitle("Whois: " + user.getUserName());
-        StringBuilder st = new StringBuilder();
-        st.append("UUID: ").append(user.getUuid()).append("\n");
-        st.append("ID: ").append(user.getId()).append("\n");
-        if (user.getDiscordId() != null) {
-            st.append("DiscordID: ").append(user.getDiscordId()).append("\n");
-        }
-        Timestamp timestamp = user.getFirstjoin();
-        st.append("Beigetreten am: ").append(timestamp == null ? "0000-00-00 00:00:00" : timestamp.toString()).append("\n");
-        st.append("Online Time: ").append(new DecimalFormat("###.##").format(user.getOnlinetime() / (double) 3600)).append("h\n");
-        Team team = Team.get(user.getTeam());
-        st.append("Team: [").append(team.getTeamKuerzel()).append("] ").append(team.getTeamName());
-        embedBuilder.addField("Daten:", st.toString(), false);
-
-        List<Punishment> punishmentList = Punishment.getAllPunishmentsOfPlayer(user.getId());
-        for (Punishment punishment : punishmentList) {
-            embedBuilder.addField(punishment.getType().name() + " von " + SteamwarUser.get(punishment.getPunisher()).getUserName(), "Von: " + punishment.getBantime(punishment.getStartTime(), false) + "\nBis: " + punishment.getBantime(punishment.getEndTime(), punishment.isPerma()) + "\nGrund: " + punishment.getReason(), true);
-        }
-
-        event.replyEmbeds(embedBuilder.build()).setEphemeral(true).queue();
-    }
-}

src/de/steamwar/bungeecore/bot/config/DiscordRole.java

@@ -1,39 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.config;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import net.dv8tion.jda.api.entities.Emoji;
-import net.dv8tion.jda.api.interactions.components.Button;
-import net.dv8tion.jda.api.interactions.components.ButtonStyle;
-
-@Data
-@AllArgsConstructor
-public class DiscordRole {
-
-    private String emoji;
-    private String label;
-    private String roleId;
-
-    public Button toButton() {
-        return Button.of(ButtonStyle.SECONDARY, roleId, label, Emoji.fromUnicode(emoji));
-    }
-}

src/de/steamwar/bungeecore/bot/config/DiscordRulesLink.java

@@ -1,36 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.config;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import net.dv8tion.jda.api.interactions.components.Button;
-
-@Data
-@AllArgsConstructor
-public class DiscordRulesLink {
-
-    private String label;
-    private String link;
-
-    public Button toButton() {
-        return Button.link(link, label);
-    }
-}

src/de/steamwar/bungeecore/bot/config/DiscordTicketType.java

@@ -1,41 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.config;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import net.dv8tion.jda.api.entities.Emoji;
-import net.dv8tion.jda.api.interactions.components.Button;
-import net.dv8tion.jda.api.interactions.components.ButtonStyle;
-
-@Data
-@AllArgsConstructor
-public class DiscordTicketType {
-
-    private String key;
-    private String emoji;
-    private String label;
-    private String color;
-    private String preMessage;
-
-    public Button toButton() {
-        return Button.of(ButtonStyle.valueOf(color), key, Emoji.fromUnicode(emoji)).withLabel(label);
-    }
-}

src/de/steamwar/bungeecore/bot/config/SteamwarDiscordBotConfig.java

@@ -1,116 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.config;
-
-import de.steamwar.bungeecore.sql.UserGroup;
-import net.md_5.bungee.config.Configuration;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-public class SteamwarDiscordBotConfig {
-
-    public static boolean loaded = false;
-    public static String TOKEN;
-    public static String GUILD;
-    public static String ANNOUNCEMENTS_CHANNEL;
-    public static String EVENTS_CHANNEL;
-    public static String INGAME_CHANNEL;
-    public static String SERVER_TEAM_CHANNEL;
-    public static String SCHEMATICS_CHANNEL;
-    public static String ROLES_CHANNEL;
-    public static String ROLES_BASE_MESSAGE;
-    public static String ROLES_ADDED;
-    public static String ROLES_REMOVED;
-    public static List<DiscordRole> ROLES;
-    public static String RULES_CHANNEL;
-    public static String RULES_TITLE;
-    public static List<String> RULES_RULES;
-    public static List<DiscordRulesLink> RULES_LINKS;
-    public static String TICKET_CATEGORY;
-    public static String TICKET_CHANNEL;
-    public static String TICKET_MESSAGE;
-    public static String TICKET_CREATED;
-    public static String TICKET_LOG;
-    public static Map<String, DiscordTicketType> TICKET_TYPES;
-    public static Map<UserGroup, String> RANKS;
-
-    public static void loadConfig(Configuration config) {
-        TOKEN = config.getString("token");
-        GUILD = config.getString("guild");
-        ANNOUNCEMENTS_CHANNEL = config.getString("announcements-channel");
-        EVENTS_CHANNEL = config.getString("events-channel");
-        INGAME_CHANNEL = config.getString("ingame-channel");
-        SERVER_TEAM_CHANNEL = config.getString("server-team-channel");
-        SCHEMATICS_CHANNEL = config.getString("schematics-channel");
-        Configuration rolesSection = config.getSection("roles-claim");
-        ROLES_CHANNEL = rolesSection.getString("channel");
-        ROLES_BASE_MESSAGE = rolesSection.getString("base");
-        ROLES_ADDED = rolesSection.getString("added");
-        ROLES_REMOVED = rolesSection.getString("removed");
-        ROLES = new ArrayList<>();
-
-        for (String roles : rolesSection.getSection("roles").getKeys()) {
-            Configuration role = rolesSection.getSection("roles").getSection(roles);
-            ROLES.add(new DiscordRole(role.getString("emoji"),
-                    role.getString("label"),
-                    role.getString("roleId")));
-        }
-
-        Configuration rulesSection = config.getSection("rules");
-        RULES_CHANNEL = rulesSection.getString("channel");
-        RULES_TITLE = rulesSection.getString("title");
-        RULES_RULES = rulesSection.getStringList("rules");
-
-        RULES_LINKS = new ArrayList<>();
-
-        for (String links : rulesSection.getSection("links").getKeys()) {
-            Configuration link = rulesSection.getSection("links").getSection(links);
-            RULES_LINKS.add(new DiscordRulesLink(link.getString("label"),
-                    link.getString("url")));
-        }
-
-        Configuration ticketSection = config.getSection("tickets");
-        TICKET_CATEGORY = ticketSection.getString("category");
-        TICKET_CHANNEL = ticketSection.getString("channel");
-        TICKET_MESSAGE = ticketSection.getString("message");
-        TICKET_CREATED = ticketSection.getString("created");
-        TICKET_LOG = ticketSection.getString("log");
-        TICKET_TYPES = new HashMap<>();
-
-        for (String types : ticketSection.getSection("types").getKeys()) {
-            Configuration type = ticketSection.getSection("types").getSection(types);
-            TICKET_TYPES.put(types, new DiscordTicketType(types,
-                    type.getString("emoji"),
-                    type.getString("label"),
-                    type.getString("color"),
-                    type.getString("pre")));
-        }
-
-        RANKS = new HashMap<>();
-        Configuration ranksSections = config.getSection("ranks");
-        for (String type : ranksSections.getKeys()) {
-            RANKS.put(UserGroup.getUsergroup(type), ranksSections.getString(type));
-        }
-        loaded = true;
-    }
-}

src/de/steamwar/bungeecore/bot/events/SchematicsManager.java

@@ -1,73 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.events;
-
-import de.steamwar.bungeecore.bot.SteamwarDiscordBot;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import de.steamwar.bungeecore.commands.CheckCommand;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import lombok.experimental.UtilityClass;
-import net.dv8tion.jda.api.EmbedBuilder;
-import net.dv8tion.jda.api.MessageBuilder;
-import net.dv8tion.jda.api.entities.Message;
-import net.dv8tion.jda.api.entities.TextChannel;
-
-import java.awt.*;
-
-@UtilityClass
-public class SchematicsManager {
-
-    private Message message;
-    private TextChannel textChannel;
-
-    static {
-        textChannel = SteamwarDiscordBot.instance().getJda().getGuildById(SteamwarDiscordBotConfig.GUILD).getTextChannelById(SteamwarDiscordBotConfig.SCHEMATICS_CHANNEL);
-        assert textChannel != null;
-        if(textChannel.hasLatestMessage()) {
-            message = textChannel.getIterableHistory().complete().stream().filter(m -> m.getAuthor().isBot()).findFirst().orElse(null);
-        }
-    }
-
-    public void update() {
-        EmbedBuilder embedBuilder = new EmbedBuilder();
-        embedBuilder.setColor(Color.GRAY);
-        embedBuilder.setTitle("Check List");
-        embedBuilder.setAuthor("SteamWar", "https://www.steamwar.de");
-
-        CheckCommand.getSchemsToCheck().forEach(schematic -> {
-            StringBuilder st = new StringBuilder();
-            st.append("Typ: ").append(schematic.getSchemtype().getKuerzel());
-            st.append("\nVon: ").append(SteamwarUser.get(schematic.getOwner()).getUserName());
-            String checker = CheckCommand.getChecker(schematic);
-            if (checker != null) {
-                st.append("\nWird Geprüft von: ").append(checker);
-            }
-            embedBuilder.addField(schematic.getName(), st.toString(), true);
-        });
-
-        MessageBuilder messageBuilder = new MessageBuilder();
-        messageBuilder.setEmbeds(embedBuilder.build());
-        if (message == null) {
-            textChannel.sendMessage(messageBuilder.build()).queue(message1 -> message = message1);
-        } else {
-            message.editMessage(messageBuilder.build()).queue();
-        }
-    }
-}

src/de/steamwar/bungeecore/bot/listeners/AnnouncementListener.java

@@ -1,50 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.listeners;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.bot.SteamwarDiscordBot;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import net.dv8tion.jda.api.MessageBuilder;
-import net.dv8tion.jda.api.entities.TextChannel;
-import net.dv8tion.jda.api.events.message.guild.GuildMessageReceivedEvent;
-import org.jetbrains.annotations.NotNull;
-
-public class AnnouncementListener extends BasicDiscordListener {
-
-    @Override
-    public void onGuildMessageReceived(@NotNull GuildMessageReceivedEvent event) {
-        if (!event.getChannel().getId().equals(SteamwarDiscordBotConfig.ANNOUNCEMENTS_CHANNEL)) {
-            return;
-        }
-        if (event.getAuthor().isBot()) {
-            return;
-        }
-        Message.broadcast("ALERT", event.getMessage().getContentDisplay());
-    }
-
-    public void announce(String message) {
-        TextChannel textChannel = SteamwarDiscordBot.instance().getJda().getGuildById(SteamwarDiscordBotConfig.GUILD).getTextChannelById(SteamwarDiscordBotConfig.ANNOUNCEMENTS_CHANNEL);
-        assert textChannel != null;
-        MessageBuilder messageBuilder = new MessageBuilder();
-        messageBuilder.append(message.replace("&", ""));
-        textChannel.sendMessage(messageBuilder.build()).queue();
-    }
-}

src/de/steamwar/bungeecore/bot/listeners/DiscordAuthListener.java

@@ -1,59 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.listeners;
-
-import de.steamwar.bungeecore.bot.AuthManager;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import net.dv8tion.jda.api.entities.ChannelType;
-import net.dv8tion.jda.api.events.interaction.GenericComponentInteractionCreateEvent;
-import net.dv8tion.jda.api.interactions.InteractionType;
-import org.jetbrains.annotations.NotNull;
-
-public class DiscordAuthListener extends BasicDiscordListener {
-
-    @Override
-    public void onGenericComponentInteractionCreate(@NotNull GenericComponentInteractionCreateEvent event) {
-        if(event.getType() == InteractionType.COMPONENT) {
-            if(event.getChannel().getId().equals(SteamwarDiscordBotConfig.RULES_CHANNEL) && event.getComponentId().equals("auth")) {
-                String authMessage = AuthManager.createDiscordAuthToken(event.getMember());
-                if(authMessage != null) {
-                    event.reply("Gebe innerhalb der nächsten 10 Minuten ``/verify " + authMessage + "`` auf dem Minecraft Server ein").setEphemeral(true).queue();
-                } else {
-                    event.reply("Du hast bereits einen Code am laufen").setEphemeral(true).queue();
-                }
-            }
-
-            if(event.getComponentId().equals("tada") && event.getChannelType() == ChannelType.PRIVATE) {
-                event.reply(":tada:").setEphemeral(false).queue();
-            }
-
-            if(event.getComponentId().equals("invalid") && event.getChannelType() == ChannelType.PRIVATE) {
-                SteamwarUser user = SteamwarUser.get(event.getUser().getIdLong());
-                if(user == null) {
-                    event.reply(":question: Da ist keine verknüpfung?").setEphemeral(false).queue();
-                } else {
-                    user.setDiscordId(null);
-                    event.reply(":x: Die Verknüpfung wurde beendet").setEphemeral(false).queue();
-                }
-            }
-        }
-    }
-}

src/de/steamwar/bungeecore/bot/listeners/DiscordChatListener.java

@@ -1,71 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.listeners;
-
-import de.steamwar.bungeecore.bot.SteamwarDiscordBot;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import de.steamwar.bungeecore.listeners.ChatListener;
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.messages.ChatSender;
-import net.dv8tion.jda.api.MessageBuilder;
-import net.dv8tion.jda.api.entities.Member;
-import net.dv8tion.jda.api.entities.TextChannel;
-import net.dv8tion.jda.api.events.message.guild.GuildMessageReceivedEvent;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.function.Supplier;
-import java.util.stream.Stream;
-
-public class DiscordChatListener extends BasicDiscordListener {
-
-    private final String channel;
-    private final String format;
-
-    private final Supplier<Stream<ChatSender>> targets;
-
-    public DiscordChatListener(String channel, String format, Supplier<Stream<ChatSender>> targets) {
-        this.channel = channel;
-        this.format = format;
-        this.targets = targets;
-    }
-
-    @Override
-    public void onGuildMessageReceived(@NotNull GuildMessageReceivedEvent event) {
-        if (!event.getChannel().getId().equals(channel) || event.getAuthor().isBot())
-            return;
-
-        Member member = event.getMember();
-        SteamwarUser steamwarUser = SteamwarUser.get(member.getIdLong());
-        if (steamwarUser == null || event.getMessage().getContentRaw().length() > 250 || steamwarUser.isPunished(Punishment.PunishmentType.Ban)) {
-            event.getMessage().delete().queue();
-        } else {
-            ChatListener.sendChat(ChatSender.of(event.getMessage(), steamwarUser), targets.get(), format, null, event.getMessage().getContentDisplay().replace('§', '&').replace('\n', ' '));
-        }
-    }
-
-    public void send(String message) {
-        TextChannel textChannel = SteamwarDiscordBot.instance().getJda().getGuildById(SteamwarDiscordBotConfig.GUILD).getTextChannelById(channel);
-        assert textChannel != null;
-        MessageBuilder messageBuilder = new MessageBuilder();
-        messageBuilder.append(message.replace("&", "").replace("@everyone", "`@everyone`").replace("@here", "`@here`").replaceAll("<[@#]!?\\d+>", "`$0`"));
-        textChannel.sendMessage(messageBuilder.build()).queue();
-    }
-}

src/de/steamwar/bungeecore/bot/listeners/DiscordEventListener.java

@@ -1,93 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.listeners;
-
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import de.steamwar.bungeecore.bot.events.EventManager;
-import de.steamwar.bungeecore.sql.Event;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.bungeecore.sql.Team;
-import de.steamwar.bungeecore.sql.TeamTeilnahme;
-import net.dv8tion.jda.api.events.interaction.SelectionMenuEvent;
-import net.dv8tion.jda.api.interactions.components.Component;
-import org.jetbrains.annotations.NotNull;
-
-import java.time.Instant;
-
-public class DiscordEventListener extends BasicDiscordListener {
-
-
-    @Override
-    public void onSelectionMenu(@NotNull SelectionMenuEvent event) {
-        if(event.getChannel().getId().equals(SteamwarDiscordBotConfig.EVENTS_CHANNEL) && event.getComponentType() == Component.Type.SELECTION_MENU) {
-            if(event.getSelectedOptions().isEmpty()) {
-                event.deferReply(true).queue();
-                return;
-            }
-            if(event.getSelectedOptions().get(0).getValue().matches("([0-9]+)")) {
-                SteamwarUser user = SteamwarUser.get(event.getUser().getIdLong());
-                if(user == null) {
-                    event.reply("Du hast dein Minecraft nicht verknüpft").setEphemeral(true).queue();
-                    return;
-                }
-
-                if(user.getTeam() == 0) {
-                    event.reply("Du bist in keinem Team").setEphemeral(true).queue();
-                    return;
-                }
-
-                if(!user.isLeader()) {
-                    event.reply("Du bist kein Leader in deinem Team").setEphemeral(true).queue();
-                    return;
-                }
-
-                if(Event.get() != null) {
-                    event.reply("Du kannst dich nicht während einem Event an einem Event anmelden").setEphemeral(true).queue();
-                    return;
-                }
-
-                Event swEvent = Event.get(Integer.decode(event.getSelectedOptions().get(0).getValue()));
-                if(swEvent == null){
-                    event.reply("Das Event gibt es nicht").setEphemeral(true).queue();
-                    return;
-                }
-
-                if(Instant.now().isAfter(swEvent.getDeadline().toInstant())){
-                    event.reply("Du kannst dich nicht mehr an diesen Event anmelden").setEphemeral(true).queue();
-                    return;
-                }
-
-                Team team = Team.get(user.getTeam());
-
-                if(TeamTeilnahme.nimmtTeil(team.getTeamId(), swEvent.getEventID())){
-                    TeamTeilnahme.notTeilnehmen(team.getTeamId(), swEvent.getEventID());
-                    event.reply("Dein Team **" + team.getTeamName() + "** nimmt nun nicht mehr an **" + swEvent.getEventName() + "** teil!").setEphemeral(true).queue();
-                }else{
-                    TeamTeilnahme.teilnehmen(team.getTeamId(), swEvent.getEventID());
-                    event.reply("Dein Team **" + team.getTeamName() + "** nimmt nun an **" + swEvent.getEventName() + "** teil!").setEphemeral(true).queue();
-                }
-
-                EventManager.update();
-            } else {
-                event.reply("Lefuq?").setEphemeral(true).queue();
-            }
-        }
-    }
-}

src/de/steamwar/bungeecore/bot/listeners/DiscordTicketListener.java

@@ -1,156 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.listeners;
-
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.bot.config.DiscordTicketType;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import net.dv8tion.jda.api.EmbedBuilder;
-import net.dv8tion.jda.api.MessageBuilder;
-import net.dv8tion.jda.api.Permission;
-import net.dv8tion.jda.api.entities.*;
-import net.dv8tion.jda.api.events.interaction.GenericComponentInteractionCreateEvent;
-import net.dv8tion.jda.api.events.message.guild.GuildMessageReceivedEvent;
-import net.dv8tion.jda.api.interactions.InteractionType;
-import net.dv8tion.jda.api.interactions.components.ActionRow;
-import net.dv8tion.jda.api.interactions.components.Button;
-import net.md_5.bungee.api.chat.ClickEvent;
-import org.jetbrains.annotations.NotNull;
-
-import java.awt.*;
-import java.time.Instant;
-import java.util.LinkedList;
-
-public class DiscordTicketListener extends BasicDiscordListener {
-
-    @Override
-    public void onGenericComponentInteractionCreate(@NotNull GenericComponentInteractionCreateEvent event) {
-        if(event.getType() == InteractionType.COMPONENT && event.getChannelType() == ChannelType.TEXT && event.getTextChannel().getParent() != null && event.getTextChannel().getParent().getId().equals(SteamwarDiscordBotConfig.TICKET_CATEGORY)) {
-            if(event.getTextChannel().getId().equals(SteamwarDiscordBotConfig.TICKET_CHANNEL) && SteamwarDiscordBotConfig.TICKET_TYPES.containsKey(event.getComponentId())) {
-                DiscordTicketType ticketType = SteamwarDiscordBotConfig.TICKET_TYPES.get(event.getComponentId());
-                Category ct = event.getGuild().getCategoryById(SteamwarDiscordBotConfig.TICKET_CATEGORY);
-                SteamwarUser swUser = SteamwarUser.get(event.getUser().getIdLong());
-                TextChannel ticketChannel = ct.createTextChannel((swUser == null?event.getUser().getName():swUser.getUserName()) + "-" + event.getComponentId() + "-" + System.currentTimeMillis() % 1000).complete();
-                ticketChannel.createPermissionOverride(event.getMember()).setAllow(Permission.VIEW_CHANNEL,
-                        Permission.MESSAGE_WRITE,
-                        Permission.MESSAGE_ATTACH_FILES,
-                        Permission.MESSAGE_ADD_REACTION,
-                        Permission.MESSAGE_READ,
-                        Permission.MESSAGE_EMBED_LINKS,
-                        Permission.MESSAGE_HISTORY).complete();
-                ticketChannel.getManager().setTopic(event.getUser().getId()).complete();
-
-                MessageBuilder messageBuilder = new MessageBuilder();
-                EmbedBuilder builder = new EmbedBuilder();
-                builder.setDescription(ticketType.getPreMessage());
-                builder.setTitle("Steamwar Ticket");
-                builder.setColor(Color.GREEN);
-
-                Button closeButton = Button.danger("close-" + ticketChannel.getName(), "Schließen").withEmoji(Emoji.fromUnicode("U+26A0"));
-                messageBuilder.setEmbeds(builder.build());
-                messageBuilder.setActionRows(ActionRow.of(closeButton));
-
-                ticketChannel.sendMessage(messageBuilder.build()).complete();
-                event.reply(SteamwarDiscordBotConfig.TICKET_CREATED.replace("%channel%", ticketChannel.getAsMention())).setEphemeral(true).complete();
-                Message.team("DISCORD_TICKET_NEW", ticketChannel.getName());
-            } else if(event.getComponentId().startsWith("close-")) {
-                TextChannel logChannel = event.getGuild().getTextChannelById(SteamwarDiscordBotConfig.TICKET_LOG);
-
-                LinkedList<StringBuilder> stringBuilders = new LinkedList<>();
-                stringBuilders.add(new StringBuilder());
-
-                new LinkedList<>(event.getTextChannel().getIterableHistory().complete()).descendingIterator().forEachRemaining(message -> {
-                    if(message.getAuthor().isSystem() || message.getAuthor().isBot()) return;
-                    StringBuilder currentBuilder = new StringBuilder();
-                    currentBuilder.append("<t:").append(message.getTimeCreated().toInstant().getEpochSecond()).append("> ")
-                            .append("**")
-                            .append(message.getAuthor().getName())
-                            .append("**: ")
-                            .append(message.getContentRaw());
-                    if(!message.getAttachments().isEmpty()) {
-                        currentBuilder.append("\n")
-                                .append("Files: ").append("\n");
-                        message.getAttachments().forEach(attachment -> currentBuilder.append(attachment.getUrl()).append("\n"));
-                    }
-
-                    currentBuilder.append("\n");
-                    if(currentBuilder.length() >= 4096) {
-                        stringBuilders.getLast().append(currentBuilder.substring(0, 4090));
-                        stringBuilders.add(new StringBuilder(currentBuilder.substring(4090, currentBuilder.length() - 1)));
-                    } else if (currentBuilder.length() + stringBuilders.getLast().length() >= 4096) {
-                        stringBuilders.add(new StringBuilder(currentBuilder.toString()));
-                    } else {
-                        stringBuilders.getLast().append(currentBuilder);
-                    }
-                });
-
-                String footer = "<t:" + Instant.now().getEpochSecond() + "> **" + event.getUser().getName() + "**: Ticket geschlossen";
-                if(stringBuilders.getLast().length() + footer.length() > 4090) {
-                    stringBuilders.add(new StringBuilder(footer));
-                } else {
-                    stringBuilders.getLast().append(footer);
-                }
-
-                EmbedBuilder embedBuilder = new EmbedBuilder();
-                embedBuilder.setColor(Color.GREEN);
-                User user = event.getJDA().retrieveUserById(event.getTextChannel().getTopic()).complete();
-                SteamwarUser swuser = SteamwarUser.get(user.getIdLong());
-
-                embedBuilder.setAuthor(user.getName(), swuser==null?"https://steamwar.de/":("https://steamwar.de/users/" + swuser.getUserName().toLowerCase() + "/"), user.getAvatarUrl());
-                embedBuilder.setTimestamp(Instant.now());
-                embedBuilder.setTitle(event.getTextChannel().getName());
-                stringBuilders.forEach(stringBuilder -> {
-                    embedBuilder.setDescription(stringBuilder.toString());
-                    MessageBuilder builder = new MessageBuilder();
-                    builder.setEmbeds(embedBuilder.build());
-
-                    logChannel.sendMessage(builder.build()).queue();
-                });
-
-                Message.team("DISCORD_TICKET_CLOSED", event.getTextChannel().getName());
-                event.getTextChannel().delete().reason("Closed").queue();
-            }
-        }
-    }
-
-    @Override
-    public void onGuildMessageReceived(@NotNull GuildMessageReceivedEvent event) {
-        if(event.getChannel().getParent() != null && event.getChannel().getParent().getId().equals(SteamwarDiscordBotConfig.TICKET_CATEGORY)) {
-            if(!event.getChannel().getId().equals(SteamwarDiscordBotConfig.TICKET_CHANNEL) && !event.getChannel().getId().equals(SteamwarDiscordBotConfig.TICKET_LOG)) {
-                BungeeCore.get().getProxy().getPlayers().forEach(player -> {
-                    if(event.getAuthor().isBot() || event.getAuthor().isSystem()) return;
-                    SteamwarUser user = SteamwarUser.get(player);
-                    boolean sendMessage;
-                    if(user.getDiscordId() == null) {
-                            sendMessage = user.getUserGroup().isCheckSchematics();
-                    } else {
-                        if(event.getAuthor().getId().equals(user.getDiscordId())) return;
-                        sendMessage = user.getDiscordId().equals(event.getChannel().getTopic()) || user.getUserGroup().isCheckSchematics();
-                    }
-                    if(sendMessage) {
-                        Message.sendPrefixless("DISCORD_TICKET_MESSAGE", player, "Zur nachricht", new ClickEvent(ClickEvent.Action.OPEN_URL, event.getMessage().getJumpUrl()), event.getChannel().getName(), event.getAuthor().getName(), event.getMessage().getContentRaw());
-                    }
-                });
-            }
-        }
-    }
-}

src/de/steamwar/bungeecore/bot/listeners/PrivateMessageListener.java

@@ -1,80 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- * <p>
- * Copyright (C) 2021  SteamWar.de-Serverteam
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- * <p>
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- * <p>
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.listeners;
-
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.bungeecore.sql.SchematicNode;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import net.dv8tion.jda.api.entities.Message;
-import net.dv8tion.jda.api.events.message.priv.PrivateMessageReceivedEvent;
-
-import java.io.InputStream;
-import java.util.concurrent.CompletableFuture;
-
-public class PrivateMessageListener extends BasicDiscordListener {
-
-    @Override
-    public void onPrivateMessageReceived(PrivateMessageReceivedEvent event) {
-        if(!event.getMessage().getAttachments().isEmpty()) {
-            SteamwarUser user = SteamwarUser.get(event.getAuthor().getIdLong());
-            if (user == null) {
-                event.getMessage().reply("Du must dein Minecraft Account mit dem Bot verbinden, gehe dazu auf dem SteamWar Discord in den `regeln-infos` Channel und Klicke auf `Minecraft Verknüpfen`").complete();
-                return;
-            }
-
-            if(user.isPunished(Punishment.PunishmentType.NoSchemReceiving)) {
-                event.getMessage().reply("Du darfst keine Schematics hochladen").complete();
-                return;
-            }
-
-            for (Message.Attachment attachment : event.getMessage().getAttachments()) {
-                if(attachment.getFileExtension() == null ||
-                        (!attachment.getFileExtension().equalsIgnoreCase("schem") &&
-                        !attachment.getFileExtension().equalsIgnoreCase("schematic"))) {
-                    event.getMessage().reply("`" + attachment.getFileName() + "` wird ignoriert, da die Datei keine Schematic ist").queue();
-                    continue;
-                }
-
-                boolean newFormat = attachment.getFileExtension().equalsIgnoreCase("schem");
-                int dot = attachment.getFileName().lastIndexOf(".");
-                String name = attachment.getFileName().substring(0, dot);
-                if(SchematicNode.invalidSchemName(new String[] {name})) {
-                    event.getMessage().reply("`" + name + "` hat nicht zugelassene Zeichen im Namen").queue();
-                    continue;
-                }
-
-                SchematicNode node = SchematicNode.getSchematicNode(user.getId(), name, 0);
-                if(node == null) {
-                    node = SchematicNode.createSchematic(user.getId(), name, null);
-                }
-
-                try {
-                    InputStream in = attachment.retrieveInputStream().get();
-                    node.saveFromStream(in, newFormat);
-                    in.close();
-                    event.getMessage().reply("`" + name + "` wurde erfolgreich hochgeladen").queue();
-                } catch (Exception e) {
-                    event.getMessage().reply("`" + name + "` konnte nicht hochgeladen werden, bitte versuche es später nochmal oder wende dich an einen Developer").queue();
-                    BungeeCore.log("Could not Upload Schem \"" + name + "\" from User \"" + user.getUserName() + "\"" + e);
-                }
-            }
-        }
-    }
-}

src/de/steamwar/bungeecore/bot/listeners/RolesInteractionButtonListener.java

@@ -1,42 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.listeners;
-
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import net.dv8tion.jda.api.entities.ChannelType;
-import net.dv8tion.jda.api.events.interaction.GenericComponentInteractionCreateEvent;
-import net.dv8tion.jda.api.interactions.InteractionType;
-import org.jetbrains.annotations.NotNull;
-
-public class RolesInteractionButtonListener extends BasicDiscordListener {
-
-    @Override
-    public void onGenericComponentInteractionCreate(@NotNull GenericComponentInteractionCreateEvent event) {
-        if(event.getType() == InteractionType.COMPONENT && event.getChannelType() == ChannelType.TEXT && event.getTextChannel().getId().equals(SteamwarDiscordBotConfig.ROLES_CHANNEL) && SteamwarDiscordBotConfig.ROLES.stream().anyMatch(discordRole -> discordRole.getRoleId().equals(event.getComponentId()))) {
-            if (event.getMember().getRoles().stream().anyMatch(role -> role.getId().equals(event.getComponentId()))) {
-                event.getGuild().removeRoleFromMember(event.getMember(), event.getGuild().getRoleById(event.getComponentId())).complete();
-                event.reply(SteamwarDiscordBotConfig.ROLES_REMOVED.replace("%role%", event.getGuild().getRoleById(event.getComponentId()).getAsMention())).setEphemeral(true).queue();
-            } else {
-                event.getGuild().addRoleToMember(event.getMember(), event.getGuild().getRoleById(event.getComponentId())).complete();
-                event.reply(SteamwarDiscordBotConfig.ROLES_ADDED.replace("%role%", event.getGuild().getRoleById(event.getComponentId()).getAsMention())).setEphemeral(true).queue();
-            }
-        }
-    }
-}

src/de/steamwar/bungeecore/bot/util/DiscordRanks.java

@@ -1,69 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.util;
-
-import de.steamwar.bungeecore.bot.SteamwarDiscordBot;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import lombok.experimental.UtilityClass;
-import net.dv8tion.jda.api.entities.Guild;
-import net.dv8tion.jda.api.entities.Role;
-import net.dv8tion.jda.api.exceptions.ErrorResponseException;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-@UtilityClass
-public class DiscordRanks {
-
-    public void update(SteamwarUser steamwarUser) {
-        if (steamwarUser.getDiscordId() == null) {
-            return;
-        }
-        Guild guild = SteamwarDiscordBot.instance().getJda().getGuildById(SteamwarDiscordBotConfig.GUILD);
-        guild.retrieveMemberById(steamwarUser.getDiscordId()).queue(member -> {
-            List<Role> roleList = member.getRoles();
-            Set<String> strings = new HashSet<>(SteamwarDiscordBotConfig.RANKS.values());
-            String needed = SteamwarDiscordBotConfig.RANKS.get(steamwarUser.getUserGroup());
-            for (Role role : roleList) {
-                if (!strings.contains(role.getId())) {
-                    continue;
-                }
-                if (role.getId().equals(needed)) {
-                    needed = "";
-                    continue;
-                }
-                guild.removeRoleFromMember(member, role).complete();
-            }
-
-            if (needed != null && !needed.isEmpty()) {
-                guild.addRoleToMember(member, guild.getRoleById(needed)).complete();
-            }
-        }, throwable -> {
-            if(throwable instanceof ErrorResponseException) {
-                ErrorResponseException e = (ErrorResponseException) throwable;
-                if(e.getErrorCode() == 10007) {
-                    steamwarUser.setDiscordId(null);
-                }
-            }
-        });
-    }
-}

src/de/steamwar/bungeecore/bot/util/DiscordRolesMessage.java

@@ -1,61 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.util;
-
-import de.steamwar.bungeecore.bot.SteamwarDiscordBot;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import lombok.experimental.UtilityClass;
-import net.dv8tion.jda.api.MessageBuilder;
-import net.dv8tion.jda.api.entities.Message;
-import net.dv8tion.jda.api.entities.TextChannel;
-import net.dv8tion.jda.api.interactions.components.ActionRow;
-import net.dv8tion.jda.api.interactions.components.Button;
-
-import java.util.ArrayList;
-import java.util.List;
-
-@UtilityClass
-public class DiscordRolesMessage {
-
-
-    public void sendMessage() {
-        TextChannel channel = SteamwarDiscordBot.instance().getJda().getGuildById(SteamwarDiscordBotConfig.GUILD).getTextChannelById(SteamwarDiscordBotConfig.ROLES_CHANNEL);
-        assert channel != null;
-
-        MessageBuilder builder = new MessageBuilder();
-        builder.setContent(SteamwarDiscordBotConfig.ROLES_BASE_MESSAGE);
-        List<Button> buttons = new ArrayList<>();
-        SteamwarDiscordBotConfig.ROLES.forEach(discordRole -> buttons.add(discordRole.toButton()));
-        builder.setActionRows(ActionRow.of(buttons));
-
-        if(channel.hasLatestMessage()) {
-            channel.getIterableHistory().queue(messages -> {
-                Message message = messages.stream().filter(m -> m.getAuthor().isBot()).findFirst().orElse(null);
-                if (message != null) {
-                    message.editMessage(builder.build()).queue();
-                } else {
-                    channel.sendMessage(builder.build()).queue();
-                }
-            });
-        } else {
-            channel.sendMessage(builder.build()).queue();
-        }
-    }
-}

src/de/steamwar/bungeecore/bot/util/DiscordRulesMessage.java

@@ -1,68 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.util;
-
-import de.steamwar.bungeecore.bot.SteamwarDiscordBot;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import lombok.experimental.UtilityClass;
-import net.dv8tion.jda.api.EmbedBuilder;
-import net.dv8tion.jda.api.MessageBuilder;
-import net.dv8tion.jda.api.entities.Emoji;
-import net.dv8tion.jda.api.entities.Message;
-import net.dv8tion.jda.api.entities.TextChannel;
-import net.dv8tion.jda.api.interactions.components.ActionRow;
-import net.dv8tion.jda.api.interactions.components.Button;
-
-import java.awt.*;
-import java.util.ArrayList;
-import java.util.List;
-
-@UtilityClass
-public class DiscordRulesMessage {
-
-    public void sendMessage() {
-        TextChannel channel = SteamwarDiscordBot.instance().getJda().getGuildById(SteamwarDiscordBotConfig.GUILD).getTextChannelById(SteamwarDiscordBotConfig.RULES_CHANNEL);
-        assert channel != null;
-        Message message = null;
-        if(channel.hasLatestMessage()) {
-            message = channel.getIterableHistory().complete().stream().filter(m -> m.getAuthor().isBot()).findFirst().orElse(null);
-        }
-
-        EmbedBuilder builder = new EmbedBuilder();
-        builder.setDescription(SteamwarDiscordBotConfig.RULES_RULES.stream().reduce((s, s2) -> s + "\n" + s2).get());
-        builder.setColor(Color.GRAY);
-        builder.setAuthor("SteamWar", "https://www.steamwar.de");
-        builder.setTitle(SteamwarDiscordBotConfig.RULES_TITLE);
-
-        List<Button> buttons = new ArrayList<>();
-        SteamwarDiscordBotConfig.RULES_LINKS.forEach(discordRulesLink -> buttons.add(discordRulesLink.toButton()));
-
-        Button authButton = Button.primary("auth", Emoji.fromUnicode("U+2705")).withLabel("Minecraft verknüpfen");
-
-        MessageBuilder messageBuilder = new MessageBuilder();
-        messageBuilder.setEmbeds(builder.build());
-        messageBuilder.setActionRows(ActionRow.of(buttons), ActionRow.of(authButton));
-        if (message != null) {
-            message.editMessage(messageBuilder.build()).queue();
-        } else {
-            channel.sendMessage(messageBuilder.build()).queue();
-        }
-    }
-}

src/de/steamwar/bungeecore/bot/util/DiscordSchemAlert.java

@@ -1,79 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.util;
-
-import de.steamwar.bungeecore.bot.SteamwarDiscordBot;
-import de.steamwar.bungeecore.sql.SchematicNode;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import lombok.experimental.UtilityClass;
-import net.dv8tion.jda.api.EmbedBuilder;
-import net.dv8tion.jda.api.MessageBuilder;
-import net.dv8tion.jda.api.entities.Emoji;
-import net.dv8tion.jda.api.entities.User;
-import net.dv8tion.jda.api.interactions.components.ActionRow;
-import net.dv8tion.jda.api.interactions.components.Button;
-
-import java.awt.*;
-import java.time.Instant;
-
-@UtilityClass
-public class DiscordSchemAlert {
-
-    public void sendDecline(SchematicNode schematic, SteamwarUser user, String reason) {
-        if(user.getDiscordId() != null) {
-            User dcUser = SteamwarDiscordBot.instance().getJda().retrieveUserById(user.getDiscordId()).complete();
-            EmbedBuilder builder = new EmbedBuilder();
-            builder.setAuthor("SteamWar", "https://steamwar.de", "https://cdn.discordapp.com/app-icons/869606970099904562/60c884000407c02671d91d8e7182b8a1.png");
-            builder.setColor(Color.RED);
-            builder.setTitle("SteamWar-Schematic Info");
-            builder.setDescription("Deine Schematic **" + schematic.getName() + "** wurde abgelehnt. **Grund:** \n" + reason);
-            builder.setTimestamp(Instant.now());
-
-            MessageBuilder messageBuilder = new MessageBuilder();
-            messageBuilder.setEmbeds(builder.build());
-            try {
-                dcUser.openPrivateChannel().complete().sendMessage(messageBuilder.build()).queue();
-            } catch (Exception e) {
-                // Ignored
-            }
-        }
-    }
-
-    public void sendAccept(SchematicNode schematic, SteamwarUser user) {
-        if(user.getDiscordId() != null) {
-            User dcUser = SteamwarDiscordBot.instance().getJda().retrieveUserById(user.getDiscordId()).complete();
-            EmbedBuilder builder = new EmbedBuilder();
-            builder.setAuthor("SteamWar", "https://steamwar.de", "https://cdn.discordapp.com/app-icons/869606970099904562/60c884000407c02671d91d8e7182b8a1.png");
-            builder.setColor(Color.GREEN);
-            builder.setTitle("SteamWar-Schematic Info");
-            builder.setDescription("Deine Schematic **" + schematic.getName() + "** wurde angenommen.");
-            builder.setTimestamp(Instant.now());
-
-            MessageBuilder messageBuilder = new MessageBuilder();
-            messageBuilder.setEmbeds(builder.build());
-            messageBuilder.setActionRows(ActionRow.of(Button.success("tada", Emoji.fromUnicode("U+1F389"))));
-            try {
-                dcUser.openPrivateChannel().complete().sendMessage(messageBuilder.build()).queue();
-            } catch (Exception e) {
-                // Ignored
-            }
-        }
-    }
-}

src/de/steamwar/bungeecore/bot/util/DiscordTicketMessage.java

@@ -1,76 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.bot.util;
-
-import de.steamwar.bungeecore.bot.SteamwarDiscordBot;
-import de.steamwar.bungeecore.bot.config.DiscordTicketType;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import lombok.experimental.UtilityClass;
-import net.dv8tion.jda.api.EmbedBuilder;
-import net.dv8tion.jda.api.MessageBuilder;
-import net.dv8tion.jda.api.entities.Message;
-import net.dv8tion.jda.api.entities.TextChannel;
-import net.dv8tion.jda.api.interactions.components.ActionRow;
-import net.dv8tion.jda.api.interactions.components.Button;
-
-import java.awt.*;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-
-@UtilityClass
-public class DiscordTicketMessage {
-
-    public void sendMessage() {
-        TextChannel channel = SteamwarDiscordBot.instance().getJda().getGuildById(SteamwarDiscordBotConfig.GUILD).getTextChannelById(SteamwarDiscordBotConfig.TICKET_CHANNEL);
-        assert channel != null;
-        Message message = null;
-        if(channel.hasLatestMessage()) {
-            message = channel.getIterableHistory().complete().stream().filter(m -> m.getAuthor().isBot()).findFirst().orElse(null);
-        }
-
-        EmbedBuilder builder = new EmbedBuilder();
-        builder.setDescription(SteamwarDiscordBotConfig.TICKET_MESSAGE);
-        builder.setTitle("Steamwar-Tickets");
-        builder.setColor(Color.RED);
-
-        List<List<Button>> buttons = new ArrayList<>();
-        chunked(new ArrayList<>(SteamwarDiscordBotConfig.TICKET_TYPES.values()), 5).forEach(discordTicketTypes -> {
-            buttons.add(discordTicketTypes.stream().map(DiscordTicketType::toButton).collect(Collectors.toList()));
-        });
-
-        MessageBuilder messageBuilder = new MessageBuilder();
-        messageBuilder.setEmbeds(builder.build());
-        messageBuilder.setActionRows(buttons.stream().map(ActionRow::of).collect(Collectors.toList()));
-        if (message != null) {
-            message.editMessage(messageBuilder.build()).queue();
-        } else {
-            channel.sendMessage(messageBuilder.build()).queue();
-        }
-    }
-
-    private static <T> List<List<T>> chunked(List<T> list, int chunkSize) {
-        List<List<T>> chunks = new ArrayList<>();
-        for (int i = 0; i < list.size(); i += chunkSize) {
-            chunks.add(list.subList(i, Math.min(i + chunkSize, list.size())));
-        }
-        return chunks;
-    }
-}

src/de/steamwar/bungeecore/commands/BasicCommand.java

@@ -1,69 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.plugin.Command;
-import net.md_5.bungee.api.plugin.TabExecutor;
-
-import java.util.ArrayList;
-import java.util.List;
-
-abstract class BasicCommand extends Command implements TabExecutor {
-
-    public BasicCommand(String name, String permission, String... aliases) {
-        super(name, permission, aliases);
-        BungeeCore.commands.put("/" + name, permission);
-        ProxyServer.getInstance().getPluginManager().registerCommand(BungeeCore.get(), this);
-    }
-
-    Iterable<String> allPlayers(String begin) {
-        List<String> suggestions = new ArrayList<>();
-        for(ProxiedPlayer player : ProxyServer.getInstance().getPlayers()){
-            String playerName = player.getName();
-            if(playerName.startsWith(begin))
-                suggestions.add(playerName);
-        }
-        return suggestions;
-    }
-
-    public Iterable<String> onTabComplete(CommandSender commandSender, String[] args) {
-        return new ArrayList<>();
-    }
-
-    protected SteamwarUser existingUser(CommandSender sender, String arg){
-        SteamwarUser target = SteamwarUser.get(arg);
-        if(target == null)
-            Message.send("UNKNOWN_PLAYER", sender);
-        return target;
-    }
-
-    protected SteamwarUser unsafeUser(CommandSender sender, String arg){
-        SteamwarUser target = SteamwarUser.getOrCreateOfflinePlayer(arg);
-        if(target == null)
-            Message.send("UNKNOWN_PLAYER", sender);
-        return target;
-    }
-}

src/de/steamwar/bungeecore/commands/BauCommand.java

@@ -1,330 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.*;
-import de.steamwar.bungeecore.inventory.SWInventory;
-import de.steamwar.bungeecore.inventory.SWItem;
-import de.steamwar.bungeecore.network.NetworkSender;
-import de.steamwar.bungeecore.sql.*;
-import de.steamwar.bungeecore.util.Chat19;
-import de.steamwar.command.SWCommand;
-import de.steamwar.command.TypeMapper;
-import de.steamwar.command.TypeValidator;
-import de.steamwar.messages.ChatSender;
-import de.steamwar.network.packets.server.BaumemberUpdatePacket;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.config.ServerInfo;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-
-public class BauCommand extends SWCommand {
-
-    public BauCommand(){
-        super("bau", null, "b", "build", "gs");
-    }
-
-    @Register(help = true)
-    public void genericHelp(ProxiedPlayer p, String... args) {
-        HelpCommand.sendBauHelp(ChatSender.of(p));
-    }
-
-    @Register
-    public void toBau(ProxiedPlayer p, @Mapper("version") @OptionalValue(value = "", onlyUINIG = true) int version) {
-        versionSelector(version,
-                () -> new ServerStarter().build12(p.getUniqueId()).send(p).start(),
-                () -> new ServerStarter().build15(p.getUniqueId()).send(p).start(),
-                () -> new ServerStarter().build19(p.getUniqueId()).send(p).start()
-        );
-    }
-
-    public void versionSelector(int version, Runnable r12, Runnable r15, Runnable r19) {
-        switch (version) {
-            case 12:
-                r12.run();
-                break;
-            case 15:
-                r15.run();
-                break;
-            case 19:
-                r19.run();
-                break;
-        }
-    }
-
-    @Mapper(value = "version", local = true)
-    public TypeMapper<Integer> versionMapper() {
-        Map<String, Integer> versionMap = new HashMap<>();
-        versionMap.put("19", 19);
-        versionMap.put("1.19", 19);
-        versionMap.put("mwg", 19);
-        versionMap.put("miniwargear", 19);
-        versionMap.put("wg", 19);
-        versionMap.put("wargear", 19);
-        versionMap.put("ws", 15);
-
-        versionMap.put("15", 15);
-        versionMap.put("1.15", 15);
-        versionMap.put("warship", 15);
-        versionMap.put("as", 15);
-        versionMap.put("airship", 15);
-
-        versionMap.put("12", 12);
-        versionMap.put("1.12", 12);
-
-        return new TypeMapper<Integer>() {
-            @Override
-            public Integer map(CommandSender commandSender, String[] previousArguments, String s) {
-                if (commandSender == null) return null;
-                ProxiedPlayer player = (ProxiedPlayer) commandSender;
-                if (s.isEmpty()) {
-                    int version = player.getPendingConnection().getVersion();
-                    if (version > 578) { // Version > 1.15.2
-                        return 19;
-                    } else if (version > 340) { // Version > 1.12.2
-                        return 15;
-                    } else {
-                        return 12;
-                    }
-                }
-                return versionMap.get(s.toLowerCase());
-            }
-
-            @Override
-            public Collection<String> tabCompletes(CommandSender sender, String[] previousArguments, String s) {
-                return versionMap.keySet();
-            }
-        };
-    }
-
-    @Register(value = "addmember", description = "BAU_ADDMEMBER_USAGE")
-    public void addmember(ProxiedPlayer p, @Validator("addMemberTarget") SteamwarUser target) {
-        new BauweltMember(p.getUniqueId(), target.getUuid(), false, false);
-        Message.send("BAU_ADDMEMBER_ADDED", p);
-
-        ProxiedPlayer z = ProxyServer.getInstance().getPlayer(target.getUuid());
-        if(z != null)
-            Message.send("BAU_ADDMEMBER_ADDED_TARGET", z, p.getName());
-    }
-
-    @Validator(value = "addMemberTarget", local = true)
-    public TypeValidator<SteamwarUser> addMemberTargetValidator() {
-        return (sender, value, messageSender) -> {
-            if (value == null) {
-                messageSender.send("UNKNOWN_PLAYER");
-                return false;
-            }
-            if (((ProxiedPlayer) sender).getUniqueId().equals(value.getUuid())) {
-                messageSender.send("BAU_ADDMEMBER_SELFADD");
-                return false;
-            }
-            if (BauweltMember.getBauMember(((ProxiedPlayer) sender).getUniqueId(), value.getUuid()) != null) {
-                messageSender.send("BAU_ADDMEMBER_ISADDED");
-                return false;
-            }
-            return true;
-        };
-    }
-
-    @Register(value = "tp", description = "BAU_TP_USAGE")
-    @Register("teleport")
-    public void teleport(ProxiedPlayer p, @Validator("teleportTarget") SteamwarUser worldOwner, @Mapper("version") @OptionalValue(value = "", onlyUINIG = true) int version) {
-        versionSelector(version,
-                () -> new ServerStarter().build12(worldOwner.getUuid()).send(p).start(),
-                () -> new ServerStarter().build15(worldOwner.getUuid()).send(p).start(),
-                () -> new ServerStarter().build19(worldOwner.getUuid()).send(p).start()
-        );
-    }
-
-    @Validator(value = "teleportTarget", local = true)
-    public TypeValidator<SteamwarUser> teleportTargetValidator() {
-        return (sender, value, messageSender) -> {
-            if (value == null) {
-                messageSender.send("UNKNOWN_PLAYER");
-                return false;
-            }
-            ProxiedPlayer p = (ProxiedPlayer) sender;
-            if (!p.getUniqueId().equals(value.getUuid()) && BauweltMember.getBauMember(value.getUuid(), p.getUniqueId()) == null) {
-                SubserverSystem.sendDeniedMessage(p, value.getUuid());
-                messageSender.send("BAU_TP_NOALLOWED");
-                return false;
-            }
-            if(BauLock.isLocked(value, SteamwarUser.get(p))) {
-                messageSender.send("BAU_LOCKED_NOALLOWED");
-                return false;
-            }
-            return true;
-        };
-    }
-
-    @Register("info")
-    public void info(ProxiedPlayer p) {
-        Chat19.chat(p, "/bauinfo");
-    }
-
-    @Register("togglewe")
-    public void togglewe(ProxiedPlayer p, @AllowNull @OptionalValue("") SteamwarUser user) {
-        if (user == null) {
-            Message.send("BAU_MEMBER_TOGGLE_USAGE", p, "togglewe");
-            return;
-        }
-        BauweltMember target = member(p, user);
-        if (target == null)
-            return;
-
-        target.setWorldEdit(!target.isWorldEdit());
-        clearMembercache(p);
-        isAllowedTo(target.isWorldEdit(), p, target, "BAU_MEMBER_TOGGLE_WORLD_EDIT");
-    }
-
-    @Register("toggleworld")
-    public void toggleworld(ProxiedPlayer p, @AllowNull @OptionalValue("") SteamwarUser user) {
-        if (user == null) {
-            Message.send("BAU_MEMBER_TOGGLE_USAGE", p, "toggleworld");
-            return;
-        }
-        BauweltMember target = member(p, user);
-        if (target == null)
-            return;
-
-        target.setWorld(!target.isWorld());
-        clearMembercache(p);
-        isAllowedTo(target.isWorld(), p, target, "BAU_MEMBER_TOGGLE_WORLD");
-    }
-
-    private static void clearMembercache(ProxiedPlayer p){
-        for(ServerInfo info : ProxyServer.getInstance().getServers().values()){
-            Subserver server = Subserver.getSubserver(info);
-            if(server != null && server.getType() == Servertype.BAUSERVER && ((Bauserver)server).getOwner().equals(p.getUniqueId())){
-                info.getPlayers().stream().findAny().ifPresent(player -> NetworkSender.send(player, new BaumemberUpdatePacket()));
-                break;
-            }
-        }
-    }
-
-    @Register(value = "delmember", description = "BAU_DELMEMBER_USAGE")
-    public void delmember(ProxiedPlayer p, SteamwarUser user) {
-        BauweltMember target = member(p, user);
-        if (target == null)
-            return;
-
-        if(SteamwarUser.get(target.getMemberID()).getUuid().equals(p.getUniqueId())) {
-            Message.send("BAU_DELMEMBER_SELFDEL", p);
-            return;
-        }
-
-        target.remove();
-        ProxiedPlayer toRemove = ProxyServer.getInstance().getPlayer(SteamwarUser.get(target.getMemberID()).getUuid());
-        if(toRemove != null){
-            Message.send("BAU_DELMEMBER_DELETED_TARGET", toRemove, p.getName());
-            Subserver currentServer = Subserver.getSubserver(toRemove.getServer().getInfo());
-            if (currentServer != null && currentServer.getType() == Servertype.BAUSERVER && ((Bauserver) currentServer).getOwner().equals(p.getUniqueId())) {
-                toRemove.connect(ProxyServer.getInstance().getServerInfo(BungeeCore.LOBBY_SERVER));
-            }
-        }
-        Message.send("BAU_DELMEMBER_DELETED", p);
-    }
-
-    @Register("resetall")
-    @Register("delete")
-    public void delete(ProxiedPlayer p, @Mapper("version") @OptionalValue(value = "", onlyUINIG = true) int version) {
-        SteamwarUser user = SteamwarUser.get(p.getUniqueId());
-        versionSelector(version,
-                () -> deleteConfirmation(p, () -> deleteWorld(p, ServerStarter.WORLDS12_PATH + p.getUniqueId().toString())),
-                () -> deleteConfirmation(p, () -> deleteWorld(p, ServerStarter.WORLDS15_PATH + user.getId())),
-                () -> deleteConfirmation(p, () -> deleteWorld(p, ServerStarter.WORLDS19_PATH + user.getId()))
-        );
-    }
-
-    private static void deleteConfirmation(ProxiedPlayer p, Runnable worldDeletion) {
-        SWInventory inventory = new SWInventory(p, 9, Message.parse("BAU_DELETE_GUI_NAME", p));
-        inventory.addItem(8, new SWItem(Message.parse("BAU_DELETE_GUI_CANCEL", p), 1), click ->
-                inventory.close()
-        );
-        inventory.addItem(0, new SWItem(Message.parse("BAU_DELETE_GUI_DELETE", p), 10), click -> {
-                worldDeletion.run();
-                inventory.close();
-        });
-        inventory.open();
-    }
-
-    private static void deleteWorld(ProxiedPlayer player, String world) {
-        ProxyServer.getInstance().getScheduler().runAsync(BungeeCore.get(), () -> {
-            for (Subserver subserver : Subserver.getServerList()) {
-                if (subserver.getType() == Servertype.BAUSERVER && ((Bauserver) subserver).getOwner().equals(player.getUniqueId())) {
-                    subserver.stop();
-                    break;
-                }
-            }
-            SubserverSystem.deleteFolder(BungeeCore.local, world);
-            Message.send("BAU_DELETE_DELETED", player);
-        });
-    }
-
-    @Register("test")
-    @Register("testarena")
-    public void testarena(ProxiedPlayer p, @Mapper("nonHistoricArenaMode") @OptionalValue("") @AllowNull ArenaMode arenaMode, @Mapper("arenaMap") @OptionalValue("") @AllowNull String map) {
-        FightCommand.createArena(p, "/bau testarena ", false, arenaMode, map, false, (player, mode, m) -> {
-            ProxyServer.getInstance().getScheduler().runAsync(BungeeCore.get(), () -> new ServerStarter().test(mode, map, p).start());
-        });
-    }
-
-    @Register(value = "lock", description = "BAU_LOCKED_OPTIONS")
-    public void lock(ProxiedPlayer p, BauLockState bauLockState) {
-        BauLock.setLocked(p, bauLockState);
-    }
-
-    @Register("unlock")
-    public void unlock(ProxiedPlayer p) {
-        BauLock.setLocked(p, BauLockState.OPEN);
-    }
-
-    private static BauweltMember member(ProxiedPlayer p, SteamwarUser member){
-        if (member == null) {
-            Message.send("UNKNOWN_PLAYER", p);
-            return null;
-        }
-
-        BauweltMember target = BauweltMember.getBauMember(p.getUniqueId(), member.getUuid());
-        if (target == null) {
-            Message.send("BAU_MEMBER_NOMEMBER", p);
-            return null;
-        }
-        return target;
-    }
-
-    private static void isAllowedTo(boolean permission, ProxiedPlayer p, BauweltMember target, String what){
-        ProxiedPlayer player = ProxyServer.getInstance().getPlayer(SteamwarUser.get(target.getMemberID()).getUuid());
-
-        if(permission){
-            if(player != null)
-                Message.send("BAU_MEMBER_TOGGLE_TARGET", player, p.getName(), Message.parse(what, player));
-            Message.send("BAU_MEMBER_TOGGLE", p, Message.parse(what, p));
-        }else{
-            if(player != null)
-                Message.send("BAU_MEMBER_TOGGLE_TARGET_OFF", player, p.getName(), Message.parse(what, player));
-            Message.send("BAU_MEMBER_TOGGLE_OFF", p, Message.parse(what, p));
-        }
-    }
-}

src/de/steamwar/bungeecore/commands/BuilderCloudCommand.java

@@ -1,121 +0,0 @@
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.ServerStarter;
-import de.steamwar.command.SWCommand;
-import de.steamwar.command.TypeMapper;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.io.File;
-import java.util.*;
-import java.util.stream.Collectors;
-
-public class BuilderCloudCommand extends SWCommand {
-
-    private final Map<String, ServerStarter.Version> versionMap = new HashMap<>();
-
-    public BuilderCloudCommand() {
-        super("buildercloud", "bungeecore.server.team");
-
-        versionMap.put("15", ServerStarter.Version.SPIGOT_15);
-        versionMap.put("1.15", ServerStarter.Version.SPIGOT_15);
-        versionMap.put("1.15.2", ServerStarter.Version.SPIGOT_15);
-        versionMap.put("19", ServerStarter.Version.PAPER_19);
-        versionMap.put("1.19", ServerStarter.Version.PAPER_19);
-        versionMap.put("1.19.2", ServerStarter.Version.PAPER_19);
-    }
-
-    @Register(description = "BUILDERCLOUD_USAGE")
-    public void genericCommand(ProxiedPlayer player, @ErrorMessage("BUILDERCLOUD_VERSION") ServerStarter.Version version, @Mapper("map") String map, @OptionalValue("") @Mapper("generator") @AllowNull File generator) {
-        new ServerStarter().builder(version, map, generator).send(player).start();
-    }
-
-    @ClassMapper(value = ServerStarter.Version.class, local = true)
-    private TypeMapper<ServerStarter.Version> versionTypeMapper() {
-        return new TypeMapper<ServerStarter.Version>() {
-            @Override
-            public ServerStarter.Version map(CommandSender commandSender, String[] previousArguments, String s) {
-                return versionMap.get(s);
-            }
-
-            @Override
-            public Collection<String> tabCompletes(CommandSender sender, String[] previousArguments, String s) {
-                return versionMap.keySet();
-            }
-        };
-    }
-
-    @Cached(global = true)
-    @Mapper(value = "map", local = true)
-    private TypeMapper<String> mapTypeMapper() {
-
-        return new TypeMapper<String>() {
-            @Override
-            public String map(CommandSender commandSender, String[] previousArguments, String s) {
-                File folder = getWorldFolder(previousArguments, 1);
-
-                if(folder == null)
-                    return null;
-
-                File map = new File(folder, s);
-                if(!map.exists() && !map.mkdir())
-                    return null;
-
-                return map.getName();
-            }
-
-            @Override
-            public Collection<String> tabCompletes(CommandSender sender, String[] previousArguments, String s) {
-                File folder = getWorldFolder(previousArguments, 1);
-
-                String[] files;
-                if(folder == null || (files = folder.list()) == null)
-                    return Collections.emptyList();
-
-                return Arrays.stream(files).filter(file -> new File(folder, file).isDirectory()).collect(Collectors.toList());
-            }
-        };
-    }
-
-    @Cached(global = true)
-    @Mapper(value = "generator", local = true)
-    private TypeMapper<File> generatorTypeMapper() {
-
-        return new TypeMapper<File>() {
-            @Override
-            public File map(CommandSender commandSender, String[] previousArguments, String s) {
-                if(s.equals(""))
-                    return null;
-
-                File folder = getWorldFolder(previousArguments, 2);
-
-                if(folder == null)
-                    throw new SecurityException();
-
-                File generator = new File(folder, s + ".dat");
-                if(!generator.exists() || !generator.isFile())
-                    throw new SecurityException();
-
-                return generator;
-            }
-
-            @Override
-            public Collection<String> tabCompletes(CommandSender sender, String[] previousArguments, String s) {
-                File folder = getWorldFolder(previousArguments, 2);
-
-                String[] files;
-                if(folder == null || (files = folder.list()) == null)
-                    return Collections.emptyList();
-
-                return Arrays.stream(files).filter(file -> new File(folder, file).isFile()).filter(file -> file.endsWith(".dat")).map(file -> file.substring(0, file.length() - 4)).collect(Collectors.toList());
-            }
-        };
-    }
-
-    private File getWorldFolder(String[] previousArguments, int offset) {
-        ServerStarter.Version v = versionMap.get(previousArguments[previousArguments.length - offset]);
-        if(v == null)
-            return null;
-        return new File(v.getWorldFolder(ServerStarter.BUILDER_BASE_PATH));
-    }
-}

src/de/steamwar/bungeecore/commands/CheckCommand.java

@@ -1,326 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.*;
-import de.steamwar.bungeecore.bot.util.DiscordSchemAlert;
-import de.steamwar.bungeecore.listeners.ConnectionListener;
-import de.steamwar.bungeecore.sql.CheckedSchematic;
-import de.steamwar.bungeecore.sql.SchematicNode;
-import de.steamwar.bungeecore.sql.SchematicType;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.command.SWCommand;
-import net.md_5.bungee.api.ChatColor;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.config.Configuration;
-
-import java.sql.Timestamp;
-import java.time.Instant;
-import java.time.format.DateTimeFormatter;
-import java.util.*;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-
-public class CheckCommand extends SWCommand {
-    private static Map<SchematicType, List<String>> checkQuestions = new HashMap<>();
-    private static Map<SchematicType, List<String>> ranks = new HashMap<>();
-
-    private static Map<UUID, CheckSession> currentCheckers = new HashMap<>();
-    private static Map<Integer, CheckSession> currentSchems = new HashMap<>();
-
-    public static void setCheckQuestions(SchematicType checkType, Configuration config) {
-        checkQuestions.put(checkType, config.getStringList("CheckQuestions"));
-        if(!config.getStringList("Ranks").isEmpty())
-            ranks.put(checkType, config.getStringList("Ranks"));
-    }
-
-    public static boolean isChecking(ProxiedPlayer player){
-        return currentCheckers.containsKey(player.getUniqueId());
-    }
-
-    public static SchematicNode getCheckingSchem(ProxiedPlayer player) {
-        return currentCheckers.get(player.getUniqueId()).schematic;
-    }
-
-    public CheckCommand() {
-        super("check", ConnectionListener.CHECK_PERMISSION);
-
-        ProxyServer.getInstance().getScheduler().schedule(BungeeCore.get(), () -> {
-            List<SchematicNode> schematics = getSchemsToCheck();
-            if(schematics.size() != currentCheckers.size())
-                Message.team("CHECK_REMINDER", "CHECK_REMINDER_HOVER", new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/check list"), schematics.size() - currentCheckers.size());
-        }, 10, 10, TimeUnit.MINUTES);
-    }
-    public static void sendReminder(ProxiedPlayer player) {
-        List<SchematicNode> schematics = getSchemsToCheck();
-        if(schematics.size() != currentCheckers.size())
-            Message.send("CHECK_REMINDER", player, Message.parse("CHECK_REMINDER_HOVER", player), new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/check list"), schematics.size() - currentCheckers.size());
-    }
-
-    @Register(value = "list", description = "CHECK_HELP_LIST")
-    public void list(ProxiedPlayer player) {
-        List<SchematicNode> schematicList = getSchemsToCheck();
-
-        Message.sendPrefixless("CHECK_LIST_HEADER", player, schematicList.size());
-
-        for (SchematicNode schematic : schematicList) {
-            CheckSession current = currentSchems.get(schematic.getId());
-            long waitedMillis = Timestamp.from(Instant.now()).getTime() - schematic.getLastUpdate().getTime();
-            String color = waitedMillis > 14400000 ? (waitedMillis > 86400000 ? "§c" : "§e") : "§a";
-            long hours = waitedMillis / 3600000;
-            long minutes = (waitedMillis - hours * 3600000) / 60000;
-            String waitTime = color + Message.parse("CHECK_LIST_WAIT", player, hours, (minutes < 10) ? "0" + minutes : minutes);
-            if (current == null) {
-                Message.sendPrefixless("CHECK_LIST_TO_CHECK", player,
-                        Message.parse("CHECK_LIST_TO_CHECK_HOVER", player),
-                        new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/check schematic " + schematic.getId()),
-                        waitTime,
-                        schematic.getSchemtype().getKuerzel(), SteamwarUser.get(schematic.getOwner()).getUserName(), schematic.getName());
-            } else {
-                Message.sendPrefixless("CHECK_LIST_CHECKING", player,
-                        Message.parse("CHECK_LIST_CHECKING_HOVER", player),
-                        new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/join " + current.checker.getName()),
-                        waitTime,
-                        schematic.getSchemtype().getKuerzel(), SteamwarUser.get(schematic.getOwner()).getUserName(), schematic.getName(), current.checker.getName());
-            }
-        }
-    }
-
-    @Register(value = "schematic", noTabComplete = true)
-    public void schematic(ProxiedPlayer player, String schemID) {
-        if(isChecking(player)){
-            Message.send("CHECK_SCHEMATIC_ALREADY_CHECKING", player);
-            return;
-        }
-
-        SchematicNode schem = SchematicNode.getSchematicNode(Integer.parseInt(schemID));
-        if(!schem.getSchemtype().check()){
-            ProxyServer.getInstance().getLogger().log(Level.SEVERE, player.getName() + " tried to check an uncheckable schematic!");
-            return;
-        }else if(schem.getOwner() == SteamwarUser.get(player.getUniqueId()).getId()) {
-            Message.send("CHECK_SCHEMATIC_OWN", player);
-            return;
-        }
-
-        new CheckSession(player, schem);
-    }
-
-    @Register(value = "cancel", description = "CHECK_HELP_CANCEL")
-    @Register("abort")
-    public void abortCommand(ProxiedPlayer player) {
-        abort(player);
-    }
-
-    public static void abort(ProxiedPlayer player) {
-        if(notChecking(player))
-            return;
-
-        Message.send("CHECK_ABORT", player);
-        currentCheckers.get(player.getUniqueId()).abort();
-    }
-
-    @Register(value = "next", description = "CHECK_HELP_NEXT")
-    public void next(ProxiedPlayer player) {
-        next(player, new String[0]);
-    }
-
-    @Register(value = "accept")
-    public void accept(ProxiedPlayer player, @OptionalValue("") String rank) {
-        if (rank.equals("")) {
-            next(player, new String[0]);
-        } else {
-            next(player, new String[]{rank});
-        }
-    }
-
-    @Register(value = "decline", description = "CHECK_HELP_DECLINE")
-    public void decline(ProxiedPlayer player, String... message) {
-        if(notChecking(player))
-            return;
-
-        currentCheckers.get(player.getUniqueId()).decline(String.join(" ", message));
-    }
-
-    public static List<SchematicNode> getSchemsToCheck(){
-        List<SchematicNode> schematicList = new LinkedList<>();
-
-        for (SchematicType type : SchematicType.values()) {
-            if (type.check())
-                schematicList.addAll(SchematicNode.getAllSchematicsOfType(type.toDB()));
-        }
-        return schematicList;
-    }
-
-    public static String getChecker(SchematicNode schematic) {
-        if (currentSchems.get(schematic.getId()) == null) return null;
-        return currentSchems.get(schematic.getId()).checker.getName();
-    }
-
-    private static boolean notChecking(ProxiedPlayer player){
-        if(!isChecking(player)){
-            Message.send("CHECK_NOT_CHECKING", player);
-            return true;
-        }
-        return false;
-    }
-
-    private void next(ProxiedPlayer player, String[] args){
-        if(notChecking(player))
-            return;
-
-        int rank = 0;
-        if(args.length > 0){
-            try{
-                rank = Integer.parseInt(args[0]);
-            }catch(NumberFormatException e){
-                Message.send("CHECK_INVALID_RANK", player);
-                return;
-            }
-        }
-
-        currentCheckers.get(player.getUniqueId()).next(rank);
-    }
-
-    private static class CheckSession{
-        private final ProxiedPlayer checker;
-        private final SchematicNode schematic;
-        private final Timestamp startTime;
-        private final ListIterator<String> checkList;
-
-        private CheckSession(ProxiedPlayer checker, SchematicNode schematic){
-            this.checker = checker;
-            this.schematic = schematic;
-            this.startTime = Timestamp.from(Instant.now());
-            this.checkList = checkQuestions.get(schematic.getSchemtype()).listIterator();
-
-            ProxyServer.getInstance().getScheduler().runAsync(BungeeCore.get(), () -> {
-                ArenaMode mode = ArenaMode.getBySchemType(schematic.getSchemtype().fightType());
-                if(new ServerStarter().test(mode, mode.getRandomMap(), checker).check(schematic.getId()).start() == null) {
-                    remove();
-                    return;
-                }
-
-                currentCheckers.put(checker.getUniqueId(), this);
-                currentSchems.put(schematic.getId(), this);
-                for(CheckedSchematic previous : CheckedSchematic.previousChecks(schematic))
-                    Message.sendPrefixless("CHECK_SCHEMATIC_PREVIOUS", checker, previous.getEndTime(), SteamwarUser.get(previous.getValidator()).getUserName(), previous.getDeclineReason());
-                next(0);
-            });
-        }
-
-        private void next(int rank) {
-            if(!checkList.hasNext()){
-                accept(rank);
-                return;
-            }
-
-            checker.sendMessage(TextComponent.fromLegacyText(checkList.next()));
-
-            TextComponent next = new TextComponent();
-            next.setColor(ChatColor.GREEN);
-            if(checkList.hasNext()){
-                next.setText(Message.parse("CHECK_NEXT", checker));
-                next.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/check next"));
-            }else if(ranks.containsKey(schematic.getSchemtype())){
-                List<String> r = ranks.get(schematic.getSchemtype());
-                for(int i = 0; i < r.size(); i++){
-                    Message.sendPrefixless("CHECK_RANK", checker,
-                            Message.parse("CHECK_RANK_HOVER", checker),
-                            new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/check accept " + (i+1)),
-                            i+1, r.get(i));
-                    Message.sendPrefixless("SPACER", checker);
-                }
-            }else{
-                next.setText(Message.parse("CHECK_ACCEPT", checker));
-                next.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/check accept"));
-            }
-
-            TextComponent decline = new TextComponent("   " + Message.parse("CHECK_DECLINE", checker));
-            decline.setColor(ChatColor.RED);
-            decline.setClickEvent(new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, "/check decline "));
-
-            next.addExtra(decline);
-            checker.sendMessage(next);
-        }
-
-        private void accept(int rank){
-            if(ranks.containsKey(schematic.getSchemtype())){
-                if(rank <= 0 || ranks.get(schematic.getSchemtype()).size() < rank){
-                    Message.send("CHECK_INVALID_RANK", checker);
-                    return;
-                }
-                schematic.setRank(rank);
-            }
-
-            schematic.setType(schematic.getSchemtype().fightType().toDB());
-            CheckedSchematic.create(schematic, SteamwarUser.get(checker.getUniqueId()).getId(), startTime, Timestamp.from(Instant.now()), "freigegeben");
-            SteamwarUser user = SteamwarUser.get(schematic.getOwner());
-            ProxiedPlayer player = ProxyServer.getInstance().getPlayer(user.getUuid());
-            if(player != null) {
-                Message.send("CHECK_ACCEPTED", player, schematic.getSchemtype().name(), schematic.getName());
-            } else {
-                DiscordSchemAlert.sendAccept(schematic, user);
-            }
-            Message.team("CHECK_ACCEPTED_TEAM", schematic.getName(), user.getUserName());
-            stop();
-        }
-
-        private void decline(String reason){
-            CheckedSchematic.create(schematic, SteamwarUser.get(checker.getUniqueId()).getId(), startTime, Timestamp.from(Instant.now()), reason);
-            SteamwarUser user = SteamwarUser.get(schematic.getOwner());
-            ProxiedPlayer player = ProxyServer.getInstance().getPlayer(user.getUuid());
-            if(player != null) {
-                Message.send("CHECK_DECLINED", player, schematic.getSchemtype().name(), schematic.getName(), reason);
-            } else {
-                DiscordSchemAlert.sendDecline(schematic, user, reason);
-            }
-            Message.team("CHECK_DECLINED_TEAM", schematic.getName(), user.getUserName(), reason);
-            schematic.setType(SchematicType.Normal.toDB());
-            stop();
-        }
-
-        private void abort(){
-            CheckedSchematic.create(schematic, SteamwarUser.get(checker.getUniqueId()).getId(), startTime, Timestamp.from(Instant.now()), "Prüfvorgang abgebrochen");
-            stop();
-        }
-
-        private void stop(){
-            currentCheckers.remove(checker.getUniqueId());
-            currentSchems.remove(schematic.getId());
-            ProxyServer.getInstance().getScheduler().runAsync(BungeeCore.get(), () -> {
-                for (Subserver subserver : Subserver.getServerList()) {
-                    if (subserver.getType() == Servertype.BAUSERVER && ((Bauserver) subserver).getOwner().equals(checker.getUniqueId())) {
-                        subserver.stop();
-                        break;
-                    }
-                }
-            });
-        }
-
-        private void remove() {
-            currentCheckers.remove(checker.getUniqueId());
-            currentSchems.remove(schematic.getId());
-        }
-    }
-}

src/de/steamwar/bungeecore/commands/EventCommand.java

@@ -1,132 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.*;
-import de.steamwar.bungeecore.sql.*;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.time.Instant;
-import java.time.format.DateTimeFormatter;
-import java.util.List;
-import java.util.Set;
-
-public class EventCommand extends BasicCommand {
-
-    public EventCommand() {
-        super("event", "");
-    }
-
-    @Override
-    public void execute(CommandSender sender, String[] args) {
-        if(!(sender instanceof ProxiedPlayer))
-            return;
-        ProxiedPlayer player = (ProxiedPlayer) sender;
-
-        Event currentEvent = Event.get();
-
-        if(currentEvent == null) {
-            noCurrentEvent(player);
-            return;
-        }
-
-        if(args.length != 1){
-            eventOverview(player, currentEvent);
-            return;
-        }
-
-        Team team = Team.get(args[0]);
-        if(team == null){
-            Message.send("EVENT_NO_TEAM", player);
-            return;
-        }
-
-        Subserver eventArena = EventStarter.getEventServer().get(team.getTeamId());
-        if(eventArena == null || !Subserver.getServerList().contains(eventArena)){
-            Message.send("EVENT_NO_FIGHT_TEAM", player);
-            return;
-        }
-
-        SubserverSystem.sendPlayer(eventArena, player);
-    }
-
-    private void noCurrentEvent(ProxiedPlayer player){
-        Message.send("EVENT_NO_CURRENT", player);
-        List<Event> coming = Event.getComing();
-        Instant now = Instant.now();
-        if(!coming.isEmpty()){
-            DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern(Message.parse("EVENT_DATE_FORMAT", player));
-            Message.send("EVENT_COMING", player);
-            for(Event e : coming){
-                Message.send("EVENT_COMING_EVENT", player, e.getStart().toLocalDateTime().format(dateFormat), e.getEnd().toLocalDateTime().format(dateFormat), e.getEventName());
-                Set<Team> teams = TeamTeilnahme.getTeams(e.getEventID());
-                if(now.isBefore(e.getDeadline().toInstant())) {
-                    Message.send("EVENT_COMING_DEADLINE", player, e.getDeadline());
-                }
-                String schemType = e.getSchemType();
-                if (schemType != null) {
-                    SchematicType schematicType = SchematicType.fromDB(schemType);
-                    if (schematicType != null && schematicType.deadline() != null && now.isBefore(schematicType.deadline().toInstant())) {
-                        Message.send("EVENT_COMING_SCHEM_DEADLINE", player, e.getDeadline());
-                    }
-                }
-                if(!teams.isEmpty()){
-                    StringBuilder tline = new StringBuilder();
-                    for(Team t : teams){
-                        tline.append(' ').append(Message.parse("EVENT_COMING_TEAM", player, t.getTeamColor(), t.getTeamKuerzel()));
-                    }
-                    Message.send("EVENT_COMING_TEAMS", player, tline.toString());
-                }
-            }
-        }
-    }
-
-    private void eventOverview(ProxiedPlayer player, Event currentEvent){
-        Message.send("EVENT_USAGE", player);
-
-        List<EventFight> fights = EventFight.getEvent(currentEvent.getEventID());
-
-        Message.send("EVENT_CURRENT_EVENT", player, currentEvent.getEventName());
-
-        DateTimeFormatter timeFormat = DateTimeFormatter.ofPattern(Message.parse("EVENT_TIME_FORMAT", player));
-        for(EventFight fight : fights){
-            Team blue = Team.get(fight.getTeamBlue());
-            Team red = Team.get(fight.getTeamRed());
-            StringBuilder fline = new StringBuilder(Message.parse("EVENT_CURRENT_FIGHT", player, fight.getStartTime().toLocalDateTime().format(timeFormat), blue.getTeamColor(), blue.getTeamKuerzel(),
-                    red.getTeamColor(), red.getTeamKuerzel()));
-
-            if(fight.hasFinished()){
-                switch(fight.getErgebnis()){
-                    case 1:
-                        fline.append(Message.parse("EVENT_CURRENT_FIGHT_WIN", player, blue.getTeamColor(), blue.getTeamKuerzel()));
-                        break;
-                    case 2:
-                        fline.append(Message.parse("EVENT_CURRENT_FIGHT_WIN", player, red.getTeamColor(), red.getTeamKuerzel()));
-                        break;
-                    default:
-                        fline.append(Message.parse("EVENT_CURRENT_FIGHT_DRAW", player));
-                }
-            }
-
-            BungeeCore.send(player, fline.toString());
-        }
-    }
-}

src/de/steamwar/bungeecore/commands/FightCommand.java

@@ -1,216 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.*;
-import de.steamwar.bungeecore.inventory.SWInventory;
-import de.steamwar.bungeecore.inventory.SWItem;
-import de.steamwar.bungeecore.listeners.mods.ModLoaderBlocker;
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.command.SWCommand;
-import de.steamwar.messages.ChatSender;
-import net.md_5.bungee.api.ChatColor;
-import net.md_5.bungee.api.ChatMessageType;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.chat.HoverEvent;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.chat.hover.content.Text;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-/**
- * Jeder Fightcommand (auch bau testarena und challenge) haben folgende Optionskette:
- *
- * [ArenaMode] [Map]
- *
- * Sollte der ArenaMode fehlen, kann er mit getMode() bestimmt werden.
- * Sollte die Map fehlen, kann sie mit getMap() bestimmt werden.
- */
-
-public class FightCommand extends SWCommand {
-
-    public FightCommand() {
-        super("fight", "", "f");
-    }
-
-    private static ArenaMode getMode(ChatSender sender, String arg){
-        ArenaMode mode = ArenaMode.getByChat(arg);
-        if(mode != null)
-            return mode;
-
-        sender.system("FIGHT_UNKNOWN_GAMEMODE", arg);
-        return null;
-    }
-
-    private static String getMap(ChatSender sender, ArenaMode mode, String arg){
-        String realMap = mode.hasMap(arg.toLowerCase());
-        if(realMap != null)
-            return realMap;
-        if(arg.equalsIgnoreCase("Random"))
-            return mode.getRandomMap();
-
-        sender.system("FIGHT_UNKNOWN_ARENA");
-        return null;
-    }
-
-    private static void getModes(ChatSender sender, String precommand, boolean historic){
-        TextComponent start = new TextComponent();
-        TextComponent current = start;
-        for(ArenaMode mode : ArenaMode.getAllModes()){
-            if(mode.withoutChatName() || mode.isHistoric() != historic)
-                continue;
-            String command = precommand + mode.getChatName();
-            current.setBold(true);
-            current.setColor(ChatColor.GRAY);
-            current.setText(mode.getChatName() + " ");
-            current.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new Text("§e" + command)));
-            current.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, command));
-            if(current != start)
-                start.addExtra(current);
-            current = new TextComponent();
-        }
-
-        sender.sendMessage(ChatMessageType.SYSTEM, start);
-    }
-
-    private static void getMaps(ChatSender sender, String precommand, ArenaMode mode){
-        TextComponent start = new TextComponent();
-        TextComponent current = start;
-        if(mode.getMaps().size() > 1){
-            String command = precommand + mode.getChatName() + " Random";
-            start.setBold(true);
-            start.setColor(ChatColor.GRAY);
-            start.setText(sender.parseToPlain("FIGHT_ARENA_RANDOM") + " ");
-            start.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new Text("§e" + command)));
-            start.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, command));
-            current = new TextComponent();
-        }
-
-        for(String map : mode.getMaps()){
-            String command = precommand + mode.getChatName() + " " + map;
-            current.setBold(true);
-            current.setColor(ChatColor.GRAY);
-            current.setText(map + " ");
-            current.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new Text("§e" + command)));
-            current.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, command));
-            if(current != start)
-                start.addExtra(current);
-            current = new TextComponent();
-        }
-
-        sender.sendMessage(ChatMessageType.SYSTEM, start);
-    }
-
-    private static boolean alreadyInArena(ProxiedPlayer player){
-        Subserver subserver = Subserver.getSubserver(player);
-        if(subserver != null && subserver.getType() == Servertype.ARENA){
-            Message.send("FIGHT_IN_ARENA", player);
-            return true;
-        }
-
-        return false;
-    }
-
-    static void createArena(ProxiedPlayer player, String precommand, boolean allowMerging, ArenaMode arenaMode, String map, boolean historic, FightCallback callback) {
-        ChatSender sender = ChatSender.of(player);
-
-        if(alreadyInArena(player))
-            return;
-
-        if (arenaMode == null) {
-            getModes(sender, precommand, historic);
-            return;
-        }
-
-        if (map == null) {
-            if (arenaMode.getMaps().size() == 1) {
-                map = arenaMode.getRandomMap();
-            } else {
-                getMaps(sender, precommand, arenaMode);
-                return;
-            }
-        } else if (map.equalsIgnoreCase("random")) {
-            map = arenaMode.getRandomMap();
-        }
-
-        if (!allowMerging) {
-            callback.run(player, arenaMode, map);
-        } else {
-            suggestMerging(player, arenaMode, map, callback);
-        }
-    }
-
-    public static void suggestMerging(ProxiedPlayer player, ArenaMode mode, String map, FightCallback declineMerge) {
-        Arenaserver mergable = null;
-        synchronized (Subserver.getServerList()) {
-            for (Subserver subserver : Subserver.getServerList()) {
-                if(subserver instanceof Arenaserver) {
-                    Arenaserver arenaserver = (Arenaserver) subserver;
-                    if(mode.getInternalName().equals(arenaserver.getMode()) && map.equals(arenaserver.getMap()) && arenaserver.isAllowMerge() && arenaserver.getServer().getPlayers().size() == 1) {
-                        mergable = arenaserver;
-                        break;
-                    }
-                }
-            }
-        }
-
-        if(mergable == null) {
-            declineMerge.run(player, mode, map);
-            return;
-        }
-
-        SWInventory inventory = new SWInventory(player, 9, Message.parse("FIGHT_MERGE_TITLE", player));
-        inventory.addItem(0, new SWItem(Message.parse("FIGHT_MERGE_DECLINE", player), 1), click -> {
-            inventory.close();
-            declineMerge.run(player, mode, map);
-        });
-        Arenaserver finalMergable = mergable;
-        SWItem item = new SWItem(Message.parse("FIGHT_MERGE_INFO", player, mode.getDisplayName(), finalMergable.getMap()), 11);
-        item.addLore(Message.parse("FIGHT_MERGE_INFO_LORE_1", player, finalMergable.getServer().getPlayers().toArray(new ProxiedPlayer[1])[0].getName()));
-        inventory.addItem(4, item, click -> {});
-        inventory.addItem(8, new SWItem(Message.parse("FIGHT_MERGE_ACCEPT", player), 10), click -> {
-            if(Subserver.getServerList().contains(finalMergable)) {
-                finalMergable.sendPlayer(player);
-            } else {
-                Message.send("FIGHT_MERGE_OFFLINE", player);
-                declineMerge.run(player, mode, map);
-            }
-        });
-        inventory.open();
-    }
-
-    @Register
-    public void fight(@Validator("arenaPlayer") ProxiedPlayer player, @Mapper("nonHistoricArenaMode") @OptionalValue("") @AllowNull ArenaMode arenaMode, @Mapper("arenaMap") @OptionalValue("") @AllowNull String map) {
-        createArena(player, "/fight ", true, arenaMode, map, false, (p, mode, m) -> {
-            Subserver arena = new ServerStarter().arena(mode, m).blueLeader(p).start();
-            if(arena != null) {
-                Message.broadcast("FIGHT_BROADCAST", "FIGHT_BROADCAST_HOVER"
-                        , new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/arena " + arena.getServer().getName()), mode.getDisplayName(), p.getName());
-            }
-        });
-    }
-
-    /**
-     * Is called when arena parameters are clear.
-     */
-    interface FightCallback {
-        void run(ProxiedPlayer player, ArenaMode mode, String map);
-    }
-}

src/de/steamwar/bungeecore/commands/HelpCommand.java

@@ -1,125 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.messages.ChatSender;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.chat.ClickEvent;
-
-public class HelpCommand extends BasicCommand {
-
-    public HelpCommand() {
-        super("help", "", "?");
-    }
-
-    @Override
-    public void execute(CommandSender s, String[] args) {
-        ChatSender sender = ChatSender.of(s);
-        if (args.length < 1) {
-            printPage(sender, ClickEvent.Action.RUN_COMMAND,
-                    "HELP_LOBBY", "/l",
-                    "HELP_BAU", "/build",
-                    "HELP_BAUSERVER", "/help build",
-                    "HELP_FIGHT", "/fight",
-                    "HELP_CHALLENGE", "/challenge",
-                    "HELP_HISTORIC", "/historic",
-                    "HELP_TEAM", "/team",
-                    "HELP_JOIN", "/join",
-                    "HELP_LOCAL", "/local");
-        }else if (args[0].equalsIgnoreCase("buildserver")) {
-            sendBauHelp(sender);
-        }else if (args[0].equalsIgnoreCase("build")) {
-            bauHelpGroup(sender, args);
-        }
-    }
-
-    private static void bauHelpGroup(ChatSender sender, String[] args) {
-        if (args.length < 2) {
-            sendBauHelpGroup(sender);
-            return;
-        }
-
-        switch (args[1].toLowerCase()) {
-            case "admin":
-            case "owner":
-            case "bauwelt":
-                sender.system("HELP_BAU_GROUP_ADMIN_TITLE");
-                sendBauHelp(sender);
-                return;
-            case "world":
-                printPage(sender, "HELP_BAU_GROUP_WORLD_TITLE", "HELP_TNT", "HELP_FIRE", "HELP_FREEZE", "HELP_TPSLIMIT", "HELP_PROTECT", "HELP_RESET");
-                return;
-            case "player":
-                printPage(sender, "HELP_BAU_GROUP_PLAYER_TITLE", "HELP_SPEED", "HELP_NV", "HELP_WV", "HELP_DEBUGSTICK", "HELP_TRACE", "HELP_LOADER");
-                return;
-            case "worldedit":
-            case "we":
-            case "world-edit":
-            case "edit":
-                printPage(sender, "HELP_BAU_GROUP_WE_TITLE", "HELP_WE_POS1", "HELP_WE_POS2", "HELP_WE_COPY", "HELP_WE_PASTE", "HELP_WE_FLOPY", "HELP_WE_FLOPYP", "HELP_WE_ROTATE_90", "HELP_WE_ROTATE_180", "HELP_WE_ROTATE_N90");
-                return;
-            case "other":
-                printPage(sender, "HELP_BAU_GROUP_OTHER_TITLE", "HELP_TESTBLOCK", "HELP_SKULL", "HELP_BAUINFO");
-                return;
-            default:
-                sendBauHelpGroup(sender);
-        }
-    }
-
-    private static void sendBauHelpGroup(ChatSender sender) {
-        printPage(sender, ClickEvent.Action.RUN_COMMAND,
-                "HELP_BAU_GROUP_ADMIN", "/help build admin",
-                "HELP_BAU_GROUP_WORLD", "/help build world",
-                "HELP_BAU_GROUP_PLAYER", "/help build player",
-                "HELP_BAU_GROUP_WE", "/help build we",
-                "HELP_BAU_GROUP_OTHER", "/help build other");
-    }
-
-    static void sendBauHelp(ChatSender sender) {
-        printPage(sender, ClickEvent.Action.SUGGEST_COMMAND,
-                "HELP_BAU_TP", "/build tp ",
-                "HELP_BAU_ADDMEMBER", "/build addmember ",
-                "HELP_BAU_DELMEMBER", "/build delmember ",
-                "HELP_BAU_TOGGLEWE", "/build togglewe ",
-                "HELP_BAU_TOGGLEWORLD", "/build toggleworld ",
-                "HELP_BAU_DELETE", "/build delete ",
-                "HELP_BAU_TESTARENA", "/build testarena ",
-                "HELP_BAU_LOCK", "/build lock ",
-                "HELP_BAU_UNLOCK", "/build unlock");
-    }
-
-    private static void printPage(ChatSender sender, ClickEvent.Action action, String... args) {
-        for(int i = 0; i < args.length; i += 2) {
-            String message = args[i];
-            String hoverMessage = message + "_HOVER";
-            String command = args[i+1];
-
-            sender.system(message, new Message(hoverMessage), new ClickEvent(action, command));
-        }
-    }
-
-    private static void printPage(ChatSender sender, String title, String... messages) {
-        sender.system(title);
-        for (String message : messages) {
-            sender.prefixless(message);
-        }
-    }
-}

src/de/steamwar/bungeecore/commands/IgnoreCommand.java

@@ -1,66 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.sql.IgnoreSystem;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.command.SWCommand;
-import de.steamwar.command.SWCommandUtils;
-import de.steamwar.command.TypeMapper;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.stream.Collectors;
-
-public class IgnoreCommand extends SWCommand {
-
-    public IgnoreCommand() {
-        super("ignore", null);
-    }
-
-    @Register(description = "USAGE_IGNORE")
-    public void genericCommand(ProxiedPlayer p, @Mapper("player") String toIgnore) {
-        SteamwarUser user = SteamwarUser.get(p.getUniqueId());
-
-        SteamwarUser target = SteamwarUser.get(toIgnore);
-        if(target == null){
-            Message.send("UNKNOWN_PLAYER", p);
-            return;
-        }
-        if(target.equals(user)){
-            Message.send("IGNORE_YOURSELF", p);
-            return;
-        }
-        if(IgnoreSystem.isIgnored(user, target)){
-            Message.send("IGNORE_ALREADY", p);
-            return;
-        }
-
-        IgnoreSystem.ignore(user, target);
-        Message.send("IGNORE_MESSAGE", p, target.getUserName());
-    }
-
-    @Mapper(value = "player", local = true)
-    public TypeMapper<String> playerTypeMapper() {
-        return SWCommandUtils.createMapper(s -> s, s -> BungeeCord.getInstance().getPlayers().stream().map(ProxiedPlayer::getName).collect(Collectors.toList()));
-    }
-}

src/de/steamwar/bungeecore/commands/JoinmeCommand.java

@@ -1,97 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.*;
-import de.steamwar.bungeecore.sql.BauweltMember;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.config.ServerInfo;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.ArrayList;
-
-public class JoinmeCommand extends BasicCommand {
-
-    public JoinmeCommand() {
-        super("joinme", "");
-    }
-
-    @Override
-    public void execute(CommandSender sender, String[] args) {
-        if(sender instanceof ProxiedPlayer) {
-            ProxiedPlayer player = (ProxiedPlayer) sender;
-
-            if (args.length == 0 && player.hasPermission("bungeecore.joinme")) {
-                Message.broadcast("JOINME_BROADCAST", "JOINME_BROADCAST_HOVER"
-                        , new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/join " + player.getName()), player.getName(), player.getServer().getInfo().getName());
-            } else if (args.length == 1) {
-                ProxiedPlayer target = ProxyServer.getInstance().getPlayer(args[0]);
-                if(target == null || !target.isConnected()){
-                    Message.send("JOINME_PLAYER_OFFLINE", player);
-                    return;
-                }else if(target.equals(player)){
-                    Message.send("JOINME_PLAYER_SELF", player);
-                    return;
-                }
-                ServerInfo server = target.getServer().getInfo();
-                String serverPerm = BungeeCore.serverPermissions.get(server.getName());
-                Subserver subserver = Subserver.getSubserver(target);
-
-                if(subserver != null) {
-                    Servertype type = subserver.getType();
-                    if (type == Servertype.ARENA) {
-                        SubserverSystem.sendPlayer(subserver, player);
-                    } else if (type == Servertype.BAUSERVER) {
-                        Bauserver bauserver = (Bauserver) subserver;
-                        if (bauserver.getOwner().equals(player.getUniqueId()) ||
-                                BauweltMember.getBauMember(bauserver.getOwner(), player.getUniqueId()) != null) {
-                            SubserverSystem.sendPlayer(subserver, player);
-                        } else {
-                            SubserverSystem.sendDeniedMessage(player, bauserver.getOwner());
-                            Message.send("JOIN_PLAYER_BLOCK", player);
-                        }
-                    } else if(type == Servertype.BUILDER && !player.hasPermission("bungeecore.server.team")) {
-                        Message.send("JOIN_PLAYER_BLOCK", player);
-                    } else {
-                        SubserverSystem.sendPlayer(subserver, player);
-                    }
-                }else if(serverPerm != null && !player.hasPermission(serverPerm)){
-                    Message.send("JOIN_PLAYER_BLOCK", player);
-                }else if(serverPerm == null && !player.getGroups().contains("team")) {
-                    Message.send("JOIN_PLAYER_BLOCK", player);
-                }else{
-                    player.connect(server);
-                }
-            } else {
-                Message.send("JOINME_USAGE", player);
-            }
-        }
-    }
-
-    @Override
-    public Iterable<String> onTabComplete(CommandSender commandSender, String[] args) {
-        if(args.length == 1){
-            return allPlayers(args[0]);
-        }
-        return new ArrayList<>();
-    }
-}

src/de/steamwar/bungeecore/commands/KickCommand.java

@@ -1,60 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.Message;
-import de.steamwar.command.SWCommand;
-import de.steamwar.command.SWCommandUtils;
-import de.steamwar.command.TypeMapper;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.stream.Collectors;
-
-public class KickCommand extends SWCommand {
-
-    public KickCommand() {
-        super("kick", "bungeecore.kick");
-    }
-
-    @Register(description = "KICK_USAGE")
-    public void genericCommand(CommandSender sender, @Mapper("player") String player, String... message) {
-        ProxiedPlayer target = ProxyServer.getInstance().getPlayer(player);
-        if(target == null){
-            Message.send("KICK_OFFLINE", sender);
-            return;
-        }
-
-        if (message.length == 0) {
-            target.disconnect(Message.parseToComponent("KICK_NORMAL", true, target));
-        } else {
-            target.disconnect(BungeeCore.stringToText(BungeeCore.CHAT_PREFIX + "§c" + String.join(" ", message)));
-        }
-        Message.send("KICK_CONFIRM", sender, target.getName());
-    }
-
-    @Mapper(value = "player", local = true)
-    public TypeMapper<String> playerTypeMapper() {
-        return SWCommandUtils.createMapper(s -> s, s -> BungeeCord.getInstance().getPlayers().stream().map(ProxiedPlayer::getName).collect(Collectors.toList()));
-    }
-}

src/de/steamwar/bungeecore/commands/ListCommand.java

@@ -1,75 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.Servertype;
-import de.steamwar.bungeecore.Subserver;
-import de.steamwar.command.SWCommand;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.config.ServerInfo;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.connection.Server;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.TreeMap;
-import java.util.stream.Collectors;
-
-public class ListCommand extends SWCommand {
-
-    public ListCommand() {
-        super("list", "");
-    }
-
-    public static synchronized TreeMap<String, List<ProxiedPlayer>> getCustomTablist(){
-        TreeMap<String, List<ProxiedPlayer>> playerMap = new TreeMap<>();
-        for (ProxiedPlayer player : ProxyServer.getInstance().getPlayers()) {
-            Server pserver = player.getServer();
-            if (pserver == null) //Happens temporarily
-                continue;
-
-            ServerInfo server = pserver.getInfo();
-            String serverName = server.getName();
-
-            Subserver subserver = Subserver.getSubserver(server);
-            if (subserver != null && subserver.getType() == Servertype.BAUSERVER) {
-                playerMap.computeIfAbsent("Bau", s -> new ArrayList<>()).add(player);
-            } else {
-                playerMap.computeIfAbsent(serverName, s -> new ArrayList<>()).add(player);
-            }
-        }
-        playerMap.forEach((server, players) -> players.sort((proxiedPlayer, t1) -> proxiedPlayer.getName().compareToIgnoreCase(t1.getName())));
-        return playerMap;
-    }
-
-    @Register
-    public void genericCommand(CommandSender commandSender) {
-        TreeMap<String, List<ProxiedPlayer>> playerMap = getCustomTablist();
-        for (String server : playerMap.navigableKeySet()) {
-            String serverName = server;
-            if (server.equals("Bau")) {
-                serverName = Message.parse("TABLIST_BAU", commandSender);
-            }
-            Message.send("LIST_COMMAND", commandSender, serverName, playerMap.get(server).stream().map(CommandSender::getName).collect(Collectors.joining(", ")));
-        }
-    }
-}

src/de/steamwar/bungeecore/commands/PollresultCommand.java

@@ -1,56 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.listeners.PollSystem;
-import de.steamwar.bungeecore.sql.PollAnswer;
-import de.steamwar.command.SWCommand;
-import de.steamwar.command.TypeValidator;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.Map;
-
-public class PollresultCommand extends SWCommand {
-
-    public PollresultCommand() {
-        super("pollresult", "bungeecore.pollresults");
-    }
-
-    @Register
-    public void genericCommand(@Validator ProxiedPlayer player) {
-        Map<String, Integer> voted = PollAnswer.getCurrentResults();
-        Message.send("POLLRESULT_HEADER", player, voted.values().stream().reduce(Integer::sum).orElse(0), PollSystem.getQuestion());
-        for (Map.Entry<String, Integer> e: voted.entrySet()) {
-            Message.send("POLLRESULT_LIST", player, e.getKey(), e.getValue());
-        }
-    }
-
-    @ClassValidator(value = ProxiedPlayer.class, local = true)
-    public TypeValidator<ProxiedPlayer> noPoll() {
-        return (sender, value, messageSender) -> {
-            if (PollSystem.noCurrentPoll()) {
-                messageSender.send("POLL_NO_POLL");
-                return false;
-            }
-            return true;
-        };
-    }
-}

src/de/steamwar/bungeecore/commands/PunishmentCommand.java

@@ -1,159 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.command.SWCommand;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.sql.Timestamp;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.time.Duration;
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
-import java.util.Date;
-import java.util.regex.MatchResult;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-public class PunishmentCommand {
-
-    public PunishmentCommand(String command, Punishment.PunishmentType punishmentType) {
-        new SWCommand(command, "bungeecore.ban") {
-            @Register(description = "PUNISHMENT_USAGE")
-            public void genericCommand(ProxiedPlayer player, String toPunish, String date, String... message) {
-                if (punishmentType.isNeedsAdmin() && !SteamwarUser.get(player).getUserGroup().isAdminGroup()) {
-                    return;
-                }
-
-                SteamwarUser target = unsafeUser(player, toPunish);
-                if (target == null)
-                    return;
-
-                Timestamp banTime = parseTime(player, date);
-                if (banTime == null)
-                    return;
-
-                boolean isPerma = date.equalsIgnoreCase("perma");
-                String msg = String.join(" ", message);
-                target.punish(punishmentType, banTime, msg, SteamwarUser.get(player.getName()).getId(), isPerma);
-                Message.team(punishmentType.getTeamMessage(), new Message("PREFIX"), target.getUserName(), player.getName(), new Message((isPerma ? "PUNISHMENT_PERMA" : "PUNISHMENT_UNTIL"), banTime), msg);
-            }
-        };
-        if (punishmentType.getUnpunishmentMessage() == null) {
-            return;
-        }
-        String antiCommand = "un" + command;
-        new SWCommand(antiCommand, "bungeecore.ban") {
-            @Register(description = "PUNISHMENT_USAGE")
-            public void genericCommand(ProxiedPlayer player, String toUnpunish) {
-                if (punishmentType.isNeedsAdmin() && !SteamwarUser.get(player).getUserGroup().isAdminGroup()) {
-                    return;
-                }
-
-                SteamwarUser target = existingUser(player, toUnpunish);
-                if (target == null)
-                    return;
-
-                if (!target.isPunished(punishmentType)) {
-                    Message.send(punishmentType.getUsageNotPunished(), player);
-                    return;
-                }
-
-                Message.send(punishmentType.getUnpunishmentMessage(), player, target.getUserName());
-                target.punish(punishmentType, Timestamp.from(new Date().toInstant()), antiCommand, SteamwarUser.get(player.getName()).getId(), false);
-            }
-        };
-    }
-
-    protected SteamwarUser existingUser(CommandSender sender, String arg){
-        SteamwarUser target = SteamwarUser.get(arg);
-        if(target == null)
-            Message.send("UNKNOWN_PLAYER", sender);
-        return target;
-    }
-
-    protected SteamwarUser unsafeUser(CommandSender sender, String arg){
-        SteamwarUser target = SteamwarUser.getOrCreateOfflinePlayer(arg);
-        if(target == null)
-            Message.send("UNKNOWN_PLAYER", sender);
-        return target;
-    }
-
-    private static Pattern RELATIVE_PATTERN = Pattern.compile("([1-9]\\d*[hdwmy])+");
-
-    public static Timestamp parseTime(CommandSender sender, String arg) {
-        if (arg.equalsIgnoreCase("perma")) {
-            return Punishment.PERMA_TIME;
-        } else {
-            if (RELATIVE_PATTERN.matcher(arg).matches()) {
-                Instant instant = Instant.now();
-                StringBuilder st = new StringBuilder();
-                for (int i = 0; i < arg.length(); i++) {
-                    char c = arg.charAt(i);
-                    if (Character.isDigit(c)) {
-                        st.append(c);
-                        continue;
-                    }
-                    int amount = Integer.parseInt(st.toString());
-                    st = new StringBuilder();
-                    switch (c) {
-                        case 'h':
-                            instant = instant.plus(amount, ChronoUnit.HOURS);
-                            break;
-                        case 'd':
-                            instant = instant.plus(amount, ChronoUnit.DAYS);
-                            break;
-                        case 'w':
-                            instant = instant.plus(Duration.ofSeconds(amount * ChronoUnit.WEEKS.getDuration().getSeconds()));
-                            break;
-                        case 'm':
-                            instant = instant.plus(Duration.ofSeconds(amount * ChronoUnit.MONTHS.getDuration().getSeconds()));
-                            break;
-                        case 'y':
-                            instant = instant.plus(Duration.ofSeconds(amount * ChronoUnit.YEARS.getDuration().getSeconds()));
-                            break;
-                    }
-                }
-                return Timestamp.from(instant);
-            }
-            SimpleDateFormat dateFormat = new SimpleDateFormat("dd.MM.yyyy_HH:mm");
-            try {
-                Date parsedDate = dateFormat.parse(arg);
-                return new java.sql.Timestamp(parsedDate.getTime());
-            } catch (ParseException e) {
-                dateFormat = new SimpleDateFormat("dd.MM.yyyy");
-                try {
-                    Date parsedDate = dateFormat.parse(arg.split("_")[0]);
-                    return new java.sql.Timestamp(parsedDate.getTime());
-                } catch (ParseException exception) {
-                    if (sender != null) {
-                        Message.send("INVALID_TIME", sender);
-                    }
-                    return null;
-                }
-            }
-        }
-    }
-}

src/de/steamwar/bungeecore/commands/RankCommand.java

@@ -1,79 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.ArenaMode;
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.bungeecore.sql.UserElo;
-import de.steamwar.command.SWCommand;
-import de.steamwar.command.SWCommandUtils;
-import de.steamwar.command.TypeMapper;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-public class RankCommand extends SWCommand {
-
-    public RankCommand() {
-        super("rank");
-    }
-
-    @Register
-    public void ownRank(ProxiedPlayer player) {
-        rank(player, player.getName());
-    }
-
-    @Register
-    public void rank(ProxiedPlayer player, @Mapper("player") String s) {
-        SteamwarUser user = SteamwarUser.get(s);
-        if (user == null) {
-            Message.send("RANK_PLAYER_NOT_FOUND", player);
-            return;
-        }
-        if (!player.getName().equals(s)) {
-            Message.send("RANK_PLAYER_FOUND", player, user.getUserName());
-        }
-        for(ArenaMode mode : ArenaMode.getAllModes()) {
-            if (!mode.isRanked())
-                continue;
-
-            Message.send("RANK_HEADER", player, mode.getChatName());
-
-            Optional<Integer> elo = UserElo.getElo(user.getId(), mode.getSchemType());
-
-            if (elo.isPresent()) {
-                int placement = UserElo.getPlacement(elo.get(), mode.getSchemType());
-                Message.send("RANK_PLACED", player, placement, elo.get());
-            } else {
-                Message.send("RANK_UNPLACED", player);
-            }
-            Message.send("RANK_EMBLEM", player, UserElo.getEmblemProgression(player, mode.getChatName(), user.getId()));
-        }
-    }
-
-    @Mapper(value = "player", local = true)
-    public TypeMapper<String> playerTypeMapper() {
-        return SWCommandUtils.createMapper(s -> s, s -> BungeeCord.getInstance().getPlayers().stream().map(ProxiedPlayer::getName).collect(Collectors.toList()));
-    }
-}

src/de/steamwar/bungeecore/commands/RegelnCommand.java

@@ -1,40 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.command.SWCommand;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-public class RegelnCommand extends SWCommand {
-    public RegelnCommand() {
-        super("regeln", null, "rules");
-    }
-
-    @Register
-    public void genericCommand(ProxiedPlayer player) {
-        Message.send("REGELN_RULES", player);
-        Message.sendPrefixless("REGELN_AS", player, Message.parse("REGELN_AS_HOVER", player), new ClickEvent(ClickEvent.Action.OPEN_URL, Message.parse("REGELN_AS_URL", player)));
-        Message.sendPrefixless("REGELN_MWG", player, Message.parse("REGELN_MWG_HOVER", player), new ClickEvent(ClickEvent.Action.OPEN_URL, Message.parse("REGELN_MWG_URL", player)));
-        Message.sendPrefixless("REGELN_WG", player, Message.parse("REGELN_WG_HOVER", player), new ClickEvent(ClickEvent.Action.OPEN_URL, Message.parse("REGELN_WG_URL", player)));
-        Message.sendPrefixless("REGELN_WS", player, Message.parse("REGELN_WS_HOVER", player), new ClickEvent(ClickEvent.Action.OPEN_URL, Message.parse("REGELN_WS_URL", player)));
-    }
-}

src/de/steamwar/bungeecore/commands/ReplayCommand.java

@@ -1,94 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2022  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.*;
-import de.steamwar.bungeecore.inventory.SWItem;
-import de.steamwar.bungeecore.inventory.SWListInv;
-import de.steamwar.bungeecore.inventory.SWStreamInv;
-import de.steamwar.bungeecore.sql.Fight;
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.bungeecore.sql.SchematicType;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.command.SWCommand;
-import de.steamwar.messages.ChatSender;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-
-public class ReplayCommand extends SWCommand {
-
-    public ReplayCommand() {
-        super("replay");
-    }
-
-    @Register
-    public void genericCommand(ProxiedPlayer player, @OptionalValue("") String optionalMap) {
-        ChatSender sender = ChatSender.of(player);
-        if (sender.user().isPunishedWithMessage(sender, Punishment.PunishmentType.NoFightServer))
-            return;
-
-        new SWStreamInv<>(player, Message.parse("REPLAY_TITLE", player), (click, fight) -> {
-            SteamwarUser user = SteamwarUser.get(player.getUniqueId());
-            ArenaMode mode = fight.getGameMode();
-            ServerStarter starter = new ServerStarter().replay(fight.getFightID()).blueLeader(player);
-
-            String map = mode.getRandomMap();
-            if (!optionalMap.equals("")) {
-                String tMap = mode.hasMap(optionalMap);
-                if (tMap != null) map = tMap;
-            }
-
-            if (user.getUserGroup().isAdminGroup() && click.isShiftClick() && fight.replayExists()) {
-                starter.test(mode, map, player).start();
-            } else if(!fight.replayAllowed()) {
-                sender.system("REPLAY_UNAVAILABLE");
-            } else {
-                starter.arena(mode, map).start();
-            }
-        }, page -> Fight.getPage(page, 45).stream().map(fight -> new SWListInv.SWListEntry<>(getFightItem(sender, fight), fight)).collect(Collectors.toList())).open();
-    }
-
-    private SWItem getFightItem(ChatSender sender, Fight fight) {
-        SchematicType type = fight.getSchemType();
-        SWItem item = new SWItem(type != null ? type.getMaterial() : "BARRIER", parseLeader(sender, fight.getBlueLeader(), fight.getBluePlayers().size(), fight.getWin() == 1));
-
-        List<String> lore = new ArrayList<>();
-        lore.add(parseLeader(sender, fight.getRedLeader(), fight.getRedPlayers().size(), fight.getWin() == 2));
-        lore.add(sender.parseToLegacy("REPLAY_TIME", fight.getStartTime()));
-        lore.add("");
-        lore.add(sender.parseToLegacy("REPLAY_SERVER", fight.getServer()));
-        if(!fight.replayAllowed())
-            lore.add(sender.parseToLegacy("REPLAY_UNAVAILABLE"));
-        item.setLore(lore);
-
-        if(fight.replayAllowed())
-            item.setEnchanted(true);
-
-        return item;
-    }
-
-    private String parseLeader(ChatSender sender, SteamwarUser leader, int players, boolean winner) {
-        return sender.parseToLegacy(winner ? (players > 1 ? "REPLAY_WINNER" : "REPLAY_SOLO_WINNER") : (players > 1 ? "REPLAY_LOSER" : "REPLAY_SOLO_LOSER"), leader.getUserName(), players - 1);
-    }
-}

src/de/steamwar/bungeecore/commands/TeamCommand.java

@@ -1,796 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.Storage;
-import de.steamwar.bungeecore.inventory.SWItem;
-import de.steamwar.bungeecore.inventory.SWListInv;
-import de.steamwar.bungeecore.sql.*;
-import de.steamwar.messages.ChatSender;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.ChatColor;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.ServerConnectRequest;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.chat.ComponentBuilder;
-import net.md_5.bungee.api.chat.HoverEvent;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.config.ServerInfo;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.ServerConnectEvent;
-
-import java.net.*;
-import java.time.Instant;
-import java.time.format.DateTimeFormatter;
-import java.util.*;
-import java.util.stream.Collectors;
-
-import static de.steamwar.bungeecore.Storage.teamInvitations;
-
-public class TeamCommand extends BasicCommand {
-
-    private static final List<SWListInv.SWListEntry<String>> COLOR_CODES = new ArrayList<>();
-
-    static {
-        addColor("4", 1);
-        addColor("c", 15);
-        addColor("6", 14);
-        addColor("e", 11);
-        addColor("2", 2);
-        addColor("a", 10);
-        addColor("b", 12);
-        addColor("3", 6);
-        addColor("1", 4);
-        addColor("9", 6);
-        addColor("d", 9);
-        addColor("5", 5);
-        addColor("f", 15);
-        addColor("7", 7);
-        addColor("8", 8);
-        addColor("0", 16);
-    }
-
-    private static void addColor(String color, int colorCode) {
-        COLOR_CODES.add(new SWListInv.SWListEntry(new SWItem("§" + color, colorCode), color));
-    }
-
-    public TeamCommand() {
-        super("team", "");
-    }
-
-    private void help(CommandSender sender){
-        Message.send("TEAM_HELP_HEADER", sender);
-        Message.send("TEAM_HELP_LIST", sender);
-        Message.send("TEAM_HELP_INFO", sender);
-        Message.send("TEAM_HELP_TP", sender);
-        if(!(sender instanceof ProxiedPlayer))
-            return;
-
-        ProxiedPlayer player = (ProxiedPlayer) sender;
-        SteamwarUser user = SteamwarUser.get(player.getUniqueId());
-        if(user.getTeam() == 0) {
-            Message.send("TEAM_HELP_CREATE", sender);
-            Message.send("TEAM_HELP_JOIN", sender);
-        }else{
-            Message.send("TEAM_HELP_CHAT", sender);
-            Message.send("TEAM_HELP_EVENT", sender);
-            Message.send("TEAM_HELP_LEAVE", sender);
-
-            if(user.isLeader()){
-                Message.send("TEAM_HELP_INVITE", sender);
-                Message.send("TEAM_HELP_REMOVE", sender);
-                Message.send("TEAM_HELP_KUERZEL", sender);
-                Message.send("TEAM_HELP_NAME", sender);
-                Message.send("TEAM_HELP_COLOR", sender);
-                Message.send("TEAM_HELP_LEADER", sender);
-                Message.send("TEAM_HELP_STEP_BACK", sender);
-                Message.send("TEAM_HELP_SERVER", sender);
-            }
-        }
-    }
-
-    @Override
-    public void execute(CommandSender sender, String[] args){
-        if(args.length < 1){
-            help(sender);
-            return;
-        }
-
-        if(!(sender instanceof ProxiedPlayer))
-            return;
-
-        ProxiedPlayer player = (ProxiedPlayer) sender;
-        SteamwarUser user = SteamwarUser.get(player.getUniqueId());
-        Team team = Team.get(user.getTeam());
-
-        switch(args[0].toLowerCase()){
-            case "create":
-                create(player, user, team, args);
-                break;
-            case "join":
-                join(player, user, args);
-                break;
-            case "stepback":
-                stepBack(player,user,team);
-                break;
-            case "leave":
-                leave(player, user, team);
-                break;
-            case "invite":
-                invite(player, user, team, args);
-                break;
-            case "remove":
-                remove(player, user, team, args);
-                break;
-            case "changekuerzel":
-                changekuerzel(player, user, team, args);
-                break;
-            case "changename":
-                changename(player, user, team, args);
-                break;
-            case "promote":
-                promote(player, user, team, args);
-                break;
-            case "changecolor":
-                changeColor(player, user, team);
-                break;
-            case "info":
-                info(player, user, team, args);
-                break;
-            case "list":
-                list(player, args);
-                break;
-            case "event":
-                event(player, user, team, args);
-                break;
-            case "tp":
-                tp(player, user, team, args);
-                break;
-            case "server":
-                server(player, user, team, args);
-                break;
-            default:
-                help(player);
-        }
-    }
-
-    private void create(ProxiedPlayer player, SteamwarUser user, Team team, String[] args){
-        if(unwantedInTeam(player, user))
-            return;
-
-        if(args.length < 3){
-            Message.send("TEAM_CREATE_USAGE", player);
-            return;
-        }
-
-        if(checkTeamKuerzel(player, team, args[1]))
-            return;
-
-        if(checkTeamName(player, team, args[2]))
-            return;
-
-        Team.create(args[1], args[2]);
-        user.setTeam(Team.get(args[1]).getTeamId());
-        user.setLeader(true);
-        Message.send("TEAM_CREATE_CREATED", player, args[2]);
-    }
-
-    private void join(ProxiedPlayer player, SteamwarUser user, String[] args){
-        if(unwantedInTeam(player, user))
-            return;
-
-        if(notDuringEvent(player))
-            return;
-
-        if(!teamInvitations.containsKey(user.getId())){
-            Message.send("TEAM_JOIN_NO_INVITE", player);
-            return;
-        }
-
-        List<Integer> invs = teamInvitations.get(user.getId());
-        Integer t = null;
-
-        if(invs.size() == 1){
-            t = invs.get(0);
-        }else{
-            if(args.length != 2){
-                Message.send("TEAM_JOIN_USAGE", player);
-                StringBuilder sb = new StringBuilder();
-                for(int inv : invs){
-                    Team team = Team.get(inv);
-                    sb.append(team.getTeamName()).append(" ");
-                }
-                Message.send("TEAM_JOIN_INVITED", player, sb.toString());
-                return;
-            }
-
-            for(int inv : invs){
-                Team team = Team.get(inv);
-                if(team.getTeamName().equals(args[1])){
-                    t = inv;
-                    break;
-                }
-            }
-
-            if(t == null){
-                Message.send("TEAM_JOIN_NOT_BY_TEAM", player);
-                return;
-            }
-        }
-
-        user.setTeam(t);
-        teamInvitations.remove(user.getId());
-        Team team = Team.get(t);
-        Message.send("TEAM_JOIN_JOINED", player, team.getTeamName());
-        if (Punishment.getPunishmentOfPlayer(user.getId(), Punishment.PunishmentType.NoEvent) != null) {
-            Event.getComing().forEach(event -> {
-                if (TeamTeilnahme.nimmtTeil(team.getTeamId(), event.getEventID())) {
-                    TeamTeilnahme.notTeilnehmen(team.getTeamId(), event.getEventID());
-                }
-            });
-        }
-    }
-
-    private void stepBack(ProxiedPlayer player, SteamwarUser user, Team team) {
-        if(notLeader(player, user, team))
-            return;
-
-        if(team.size() > 1 && team.getMembers().stream().map(SteamwarUser::get).filter(member -> user != member).noneMatch(SteamwarUser::isLeader)){
-            Message.send("TEAM_OTHER_LEADER_REQUIRED", player);
-            return;
-        }
-
-        user.setLeader(false);
-        Message.send("TEAM_STEP_BACK", player);
-    }
-
-    private void leave(ProxiedPlayer player, SteamwarUser user, Team team){
-        if(notInTeam(player, user))
-            return;
-
-        int teamSize = team.size();
-        if(teamSize > 1 && user.isLeader() && team.getMembers().stream().map(SteamwarUser::get).filter(member -> user != member).noneMatch(SteamwarUser::isLeader)){
-            Message.send("TEAM_OTHER_LEADER_REQUIRED", player);
-            return;
-        }
-
-        user.setTeam(0);
-
-        if(teamSize == 1){
-            team.disband(user);
-        }
-
-        Message.send("TEAM_LEAVE_LEFT", player);
-    }
-
-
-    private void invite(ProxiedPlayer player, SteamwarUser user, Team team, String[] args){
-        if(notLeader(player, user, team))
-            return;
-
-        if(notDuringEvent(player))
-            return;
-
-        if(args.length != 2){
-            Message.send("TEAM_INVITE_USAGE", player);
-            return;
-        }
-
-        SteamwarUser target = SteamwarUser.get(args[1]);
-        if(target == null){
-            Message.send("TEAM_INVITE_NO_PLAYER", player);
-            return;
-        }else if(target.getTeam() != 0){
-            Message.send("TEAM_INVITE_IN_TEAM", player);
-            return;
-        }
-
-        if (Punishment.getPunishmentOfPlayer(target.getId(), Punishment.PunishmentType.NoEvent) != null) {
-            // TODO: Add warning message
-        }
-
-        if(!teamInvitations.containsKey(target.getId()))
-            teamInvitations.put(target.getId(), new LinkedList<>());
-
-        if(teamInvitations.get(target.getId()).contains(team.getTeamId())){
-            Message.send("TEAM_INVITE_ALREADY_INVITED", player);
-            return;
-        }
-
-        teamInvitations.get(target.getId()).add(team.getTeamId());
-
-        Message.send("TEAM_INVITE_INVITED", player, args[1]);
-        ProxiedPlayer p = ProxyServer.getInstance().getPlayer(target.getUuid());
-        if(p != null)
-            Message.send("TEAM_INVITE_INVITED_TARGET", p, team.getTeamColor(), team.getTeamName());
-    }
-
-    private void remove(ProxiedPlayer player, SteamwarUser user, Team team, String[] args){
-        if(notLeader(player, user, team))
-            return;
-
-        if(args.length != 2){
-            Message.send("TEAM_REMOVE_USAGE", player);
-            return;
-        }
-
-        SteamwarUser target = SteamwarUser.get(args[1]);
-        if(target == null){
-            Message.send("TEAM_REMOVE_NOT_PLAYER", player);
-            return;
-        }
-
-        if (target.isLeader()) {
-            Message.send("TEAM_REMOVE_NOT_LEADER", player);
-            return;
-        }
-
-        if(teamInvitations.containsKey(target.getId())){
-            if(teamInvitations.get(target.getId()).remove((Integer) team.getTeamId())){
-                Message.send("TEAM_REMOVE_INVITE", player);
-                if(teamInvitations.get(target.getId()).isEmpty())
-                    teamInvitations.remove(target.getId());
-            }else{
-                Message.send("TEAM_REMOVE_NO_INVITE", player);
-            }
-            return;
-        }
-
-        if(target.getTeam() != user.getTeam()){
-            Message.send("TEAM_REMOVE_NOT_IN_TEAM", player);
-            return;
-        }
-
-        target.setTeam(0);
-
-        Message.send("TEAM_REMOVE_REMOVED", player);
-        ProxiedPlayer p = ProxyServer.getInstance().getPlayer(target.getUuid());
-        if(p != null)
-            Message.send("TEAM_REMOVE_REMOVED_TARGET", player);
-    }
-
-    private void changekuerzel(ProxiedPlayer player, SteamwarUser user, Team team, String[] args){
-        if(notLeader(player, user, team))
-            return;
-
-        if(notDuringEvent(player))
-            return;
-
-        if(args.length < 2){
-            Message.send("TEAM_KUERZEL_USAGE", player);
-            return;
-        }
-
-        if(checkTeamKuerzel(player, team, args[1]))
-            return;
-
-        team.setTeamKuerzel(args[1]);
-        Message.send("TEAM_KUERZEL_CHANGED", player);
-    }
-
-    private void changename(ProxiedPlayer player, SteamwarUser user, Team team, String[] args){
-        if(notLeader(player, user, team))
-            return;
-
-        if(notDuringEvent(player))
-            return;
-
-        if(args.length < 2){
-            Message.send("TEAM_NAME_USAGE", player);
-            return;
-        }
-
-        if(checkTeamName(player, team, args[1]))
-            return;
-
-        team.setTeamName(args[1]);
-        Message.send("TEAM_NAME_CHANGED", player);
-    }
-
-    private void promote(ProxiedPlayer player, SteamwarUser user, Team team, String[] args){
-        if(notLeader(player, user, team))
-            return;
-
-        if(notDuringEvent(player))
-            return;
-
-        if(args.length < 2){
-            Message.send("TEAM_LEADER_USAGE", player);
-            return;
-        }
-
-        SteamwarUser target = SteamwarUser.get(args[1]);
-        if(target == null){
-            Message.send("TEAM_LEADER_NOT_USER", player, args[1]);
-            return;
-        }
-
-        if(target.getTeam() != user.getTeam()){
-            Message.send("TEAM_LEADER_NOT_MEMBER", player);
-            return;
-        }
-
-        target.setLeader(true);
-        Message.send("TEAM_LEADER_PROMOTED", player, args[1]);
-    }
-
-    private String playerName(SteamwarUser user){
-        return ProxyServer.getInstance().getPlayer(user.getUuid()) != null ? "§a" + user.getUserName() : "§e" + user.getUserName();
-    }
-
-    private void info(ProxiedPlayer player, SteamwarUser user, Team team, String[] args){
-        if(args.length == 1 && user.getTeam() == 0){
-            Message.send("TEAM_INFO_USAGE", player);
-            return;
-        }else if(user.getTeam() == 0 || args.length == 2){
-            team = Team.get(args[1]);
-        }
-
-        if(team == null){
-            Message.send("UNKNOWN_TEAM", player);
-            return;
-        }
-
-        Message.sendPrefixless("TEAM_INFO_TEAM", player, team.getTeamName(), team.getTeamColor(), team.getTeamKuerzel());
-
-        List<SteamwarUser> users = team.getMembers().stream().map(SteamwarUser::get).collect(Collectors.toList());
-
-        Message.sendPrefixless("TEAM_INFO_LEADER", player, getMemberList(users, true));
-
-        String members = getMemberList(users, false);
-
-        if(members.length() > 0) {
-            Message.sendPrefixless("TEAM_INFO_MEMBER", player, members);
-        }
-
-        Set<Event> events = TeamTeilnahme.getEvents(team.getTeamId());
-        if(!events.isEmpty()){
-            Message.sendPrefixless("TEAM_INFO_EVENTS", player, events.stream().map(Event::getEventName).collect(Collectors.joining(", ")));
-        }
-    }
-
-    private String getMemberList(List<SteamwarUser> users, boolean leaders) {
-        StringBuilder sb = new StringBuilder();
-        for(SteamwarUser user : users) {
-            if(user.isLeader() == leaders) {
-                sb.append(playerName(user)).append(" ");
-            }
-        }
-        return sb.toString();
-    }
-
-    private void list(ProxiedPlayer player, String[] args){
-
-        final int TEAMS_PER_PAGE = 10;
-
-        int page;
-        if(args.length > 1){
-            try{
-                page = Integer.parseInt(args[1]);
-            }catch(NumberFormatException e){
-                Message.send("TEAM_LIST_NOT_PAGE", player);
-                return;
-            }
-        }else
-            page = 1;
-
-        List<Team> all = Team.getAll();
-        final int lastPage = ((all.size() - 1) / 10) + 1;
-        if(page < 1 || page > lastPage){
-            Message.send("TEAM_LIST_UNKNOWN_PAGE", player);
-            return;
-        }
-
-        Message.sendPrefixless("TEAM_LIST_HEADER", player, page, lastPage);
-
-        for(int i = (page-1) * TEAMS_PER_PAGE; i < (page-1) * TEAMS_PER_PAGE + TEAMS_PER_PAGE && i < all.size(); i++){
-            Team tm = all.get(i);
-
-            Message.sendPrefixless("TEAM_LIST_TEAM", player, Message.parse("TEAM_LIST_TEAM_HOVER", player),
-                    new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/team info " + tm.getTeamKuerzel()), tm.getTeamColor(), tm.getTeamKuerzel(), tm.getTeamName());
-        }
-
-        TextComponent beforePage = new TextComponent("««");
-        if(page > 1){
-            beforePage.setColor(ChatColor.YELLOW);
-            beforePage.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new ComponentBuilder(Message.parse("TEAM_LIST_PREV", player)).create()));
-            beforePage.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/team list " + (page - 1)));
-        }else
-            beforePage.setColor(ChatColor.DARK_GRAY);
-
-        TextComponent nextPage = new TextComponent(" " + Message.parse("TEAM_LIST_PAGE", player) +" »»");
-        if(page < lastPage){
-            nextPage.setColor(ChatColor.YELLOW);
-            nextPage.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new ComponentBuilder(Message.parse("TEAM_LIST_NEXT", player)).create()));
-            nextPage.setClickEvent(new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/team list " + (page + 1)));
-        }else
-            nextPage.setColor(ChatColor.DARK_GRAY);
-
-        beforePage.addExtra(nextPage);
-        player.sendMessage(beforePage);
-    }
-
-    private void event(ProxiedPlayer player, SteamwarUser user, Team team, String[] args){
-        if(notInTeam(player, user))
-            return;
-
-        if(args.length < 2){
-            Message.send("TEAM_EVENT_USAGE", player);
-            Set<Event> events = TeamTeilnahme.getEvents(team.getTeamId());
-            if(!events.isEmpty()){
-                Message.send("TEAM_EVENT_HEADER", player);
-                DateTimeFormatter dateFormat = DateTimeFormatter.ofPattern(Message.parse("EVENT_DATE_FORMAT", player));
-                for(Event e : events)
-                    Message.sendPrefixless("TEAM_EVENT_EVENT", player, e.getStart().toLocalDateTime().format(dateFormat), e.getEventName());
-            }
-            return;
-        }
-
-        if(notLeader(player, user, team))
-            return;
-
-        if(notDuringEvent(player))
-            return;
-
-        Event event = Event.get(args[1]);
-        if(event == null){
-            Message.send("TEAM_EVENT_NO_EVENT", player);
-            return;
-        }
-
-        if(Instant.now().isAfter(event.getDeadline().toInstant())){
-            Message.send("TEAM_EVENT_OVER", player);
-            return;
-        }
-
-        boolean hasPunishedPlayer = team.getMembers().stream()
-                .map(id -> Punishment.getPunishmentOfPlayer(id, Punishment.PunishmentType.NoEvent))
-                .anyMatch(Objects::nonNull);
-        if (hasPunishedPlayer) {
-            // TODO: Add message
-        }
-
-        if(TeamTeilnahme.nimmtTeil(team.getTeamId(), event.getEventID())){
-            TeamTeilnahme.notTeilnehmen(team.getTeamId(), event.getEventID());
-            Message.send("TEAM_EVENT_LEFT", player);
-        }else{
-            TeamTeilnahme.teilnehmen(team.getTeamId(), event.getEventID());
-            Message.send("TEAM_EVENT_JOINED", player, event.getEventName());
-            Message.sendPrefixless("TEAM_EVENT_HOW_TO_LEAVE", player);
-        }
-    }
-
-    private void tp(ProxiedPlayer player, SteamwarUser user, Team team, String[] args){
-        if(args.length == 1){
-            if(notInTeam(player, user))
-                return;
-            tp(player, team);
-            return;
-        }
-        Team targetTeam = Team.get(args[1]);
-        if(targetTeam == null){
-            Message.send("TEAM_TP_NO_TEAM", player);
-            return;
-        }
-        tp(player, targetTeam);
-    }
-
-    private void tp(ProxiedPlayer player, Team targetTeam) {
-        if (targetTeam.getAddress() == null) {
-            Message.send("TEAM_NO_ADDRESS", player);
-            return;
-        }
-        ServerInfo serverInfo = Storage.teamServers.computeIfAbsent(targetTeam.getTeamId(), integer -> {
-            InetSocketAddress address = new InetSocketAddress(targetTeam.getAddress(), targetTeam.getPort());
-            ServerInfo info = ProxyServer.getInstance().constructServerInfo("Team " + targetTeam.getTeamKuerzel(), address, "SteamWar.de - Teamserver", false);
-            ProxyServer.getInstance().getServers().put(info.getName(), info);
-            return info;
-        });
-        player.connect(ServerConnectRequest.builder()
-                        .target(serverInfo)
-                        .connectTimeout(BungeeCord.getInstance().getConfig().getServerConnectTimeout())
-                        .retry(false)
-                        .reason(ServerConnectEvent.Reason.PLUGIN)
-                        .callback((success, error) -> {
-                            if (error != null) {
-                                Message.send("TEAM_OFFLINE", player);
-                            }
-                        })
-                .build());
-        /*
-        ((UserConnection) player).connect(serverInfo, (success, error) -> {
-            if (error != null) {
-                Message.send("TEAM_OFFLINE", player);
-            }
-        }, false, ServerConnectEvent.Reason.PLUGIN, BungeeCord.getInstance().getConfig().getServerConnectTimeout(), false);
-         */
-    }
-
-    private void server(ProxiedPlayer player, SteamwarUser user, Team team, String[] args){
-        if(notLeader(player, user, team))
-            return;
-        if (user.isPunishedWithMessage(ChatSender.of(player), Punishment.PunishmentType.NoTeamServer)) {
-            return;
-        }
-        if (args.length < 2) {
-            Message.send("TEAM_SERVER_USAGE", player);
-            return;
-        }
-        String server = args[1];
-        try {
-            if (isLocalhost(InetAddress.getByName(server))) {
-                Message.send("TEAM_SERVER_ADDRESS_INVALID", player);
-                return;
-            }
-        } catch (UnknownHostException e) {
-            Message.send("TEAM_SERVER_ADDRESS_INVALID", player);
-            return;
-        }
-        int port = 25565;
-        if (args.length == 3) {
-            try {
-                port = Integer.parseInt(args[2]);
-                if (port < 1 || port > 65535) {
-                    Message.send("TEAM_SERVER_PORT_INVALID", player);
-                    return;
-                }
-            } catch (NumberFormatException e) {
-                Message.send("TEAM_SERVER_PORT_INVALID", player);
-                return;
-            }
-        }
-        team.setAddress(server);
-        team.setPort(port);
-        Storage.teamServers.remove(team.getTeamId());
-        Message.send("TEAM_SERVER_SET", player);
-    }
-
-    public static boolean isLocalhost(InetAddress addr) {
-        // Check if the address is a valid special local or loop back
-        if (addr.isAnyLocalAddress() || addr.isLoopbackAddress())
-            return true;
-
-        // Check if the address is defined on any interface
-        try {
-            return NetworkInterface.getByInetAddress(addr) != null;
-        } catch (SocketException e) {
-            return false;
-        }
-    }
-
-    private void changeColor(ProxiedPlayer player, SteamwarUser user, Team team) {
-        if(notLeader(player, user, team))
-            return;
-
-        if(notDuringEvent(player))
-            return;
-
-        List<SWListInv.SWListEntry<String>> colors = new ArrayList<>();
-        COLOR_CODES.forEach(stringSWListEntry -> {
-            SWItem item = stringSWListEntry.getItem().clone();
-            item.setName(stringSWListEntry.getItem().getTitle() + Team.get(user.getTeam()).getTeamKuerzel());
-            colors.add(new SWListInv.SWListEntry<>(item, stringSWListEntry.getObject()));
-        });
-
-        SWListInv<String> inv = new SWListInv<>(player, Message.parse("TEAM_COLOR_TITLE", player), colors, (click, element) -> {});
-        inv.setCallback((click, element) -> {
-            inv.close();
-            team.setTeamColor(element);
-        });
-        inv.open();
-    }
-
-    private boolean checkTeamName(ProxiedPlayer player, Team team, String arg){
-        if(arg.length() < 4 || arg.length() > 15){
-            Message.send("TEAM_NAME_LENGHT", player);
-            return true;
-        }
-
-        Team t = Team.get(arg);
-        if(t != null && t.getTeamId() != team.getTeamId()){
-            Message.send("TEAM_NAME_TAKEN", player);
-            return true;
-        }
-        return false;
-    }
-
-    private boolean checkTeamKuerzel(ProxiedPlayer player, Team team, String arg){
-        if(arg.length() < 2 || arg.length() > 4){
-            Message.send("TEAM_KUERZEL_LENGHT", player);
-            return true;
-        }
-
-        Team t = Team.get(arg);
-        if(t != null && (team == null || t.getTeamId() != team.getTeamId())){
-            Message.send("TEAM_KUERZEL_TAKEN", player);
-            return true;
-        }
-        return false;
-    }
-
-    private boolean unwantedInTeam(ProxiedPlayer player, SteamwarUser user){
-        if(user.getTeam() != 0){
-            Message.send("TEAM_IN_TEAM", player);
-            return true;
-        }
-        return false;
-    }
-
-    private boolean notInTeam(ProxiedPlayer player, SteamwarUser user){
-        if(user.getTeam() == 0){
-            Message.send("TEAM_NOT_IN_TEAM", player);
-            return true;
-        }
-        return false;
-    }
-
-    private boolean notLeader(ProxiedPlayer player, SteamwarUser user, Team team){
-        if(notInTeam(player, user))
-            return true;
-        if(!user.isLeader()){
-            Message.send("TEAM_NOT_LEADER", player);
-            return true;
-        }
-        return false;
-    }
-
-    private boolean notDuringEvent(ProxiedPlayer player){
-        if(Event.get() != null){
-            Message.send("TEAM_NOT_IN_EVENT", player);
-            return true;
-        }
-        return false;
-    }
-
-    @Override
-    public Iterable<String> onTabComplete(CommandSender commandSender, String[] args){
-        List<String> tab = new ArrayList<>();
-        if(args.length == 1){
-            tab.add("create");
-            tab.add("join");
-            tab.add("invite");
-            tab.add("stepback");
-            tab.add("leave");
-            tab.add("info");
-            tab.add("remove");
-            tab.add("event");
-            tab.add("changekuerzel");
-            tab.add("changename");
-            tab.add("promote");
-            tab.add("changecolor");
-            tab.add("tp");
-            tab.add("server");
-        }else if(args.length == 2){
-            if(args[1].equalsIgnoreCase("event")){
-                List<Event> coming = Event.getComing();
-                coming.forEach(event -> tab.add(event.getEventName()));
-            }else if(args[1].equalsIgnoreCase("join") || args[1].equalsIgnoreCase("info") || args[1].equalsIgnoreCase("tp")){
-                List<Team> teams = Team.getAll();
-                teams.forEach(team -> {
-                    tab.add(team.getTeamName());
-                    tab.add(team.getTeamKuerzel());
-                });
-            }
-        }
-        return tab;
-    }
-}

src/de/steamwar/bungeecore/commands/TpCommand.java

@@ -1,138 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.*;
-import de.steamwar.bungeecore.sql.*;
-import de.steamwar.bungeecore.util.Chat19;
-import de.steamwar.messages.ChatSender;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.config.ServerInfo;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.ArrayList;
-
-public class TpCommand extends BasicCommand {
-
-    public TpCommand(){
-        super("join", null, "tp", "teleport");
-    }
-
-    @Override
-    public void execute(CommandSender s, String[] args) {
-        if(!(s instanceof ProxiedPlayer))
-            return;
-        ProxiedPlayer player = (ProxiedPlayer) s;
-
-        ChatSender sender = ChatSender.of(player);
-        if(args.length == 0){
-            if(Event.get() == null)
-                sender.system("TP_USAGE");
-            else
-                sender.system("TP_USAGE_EVENT");
-            return;
-        }
-
-        ServerInfo server = getTarget(args[0]);
-        boolean onTeamServer = Storage.teamServers.containsValue(player.getServer().getInfo());
-
-        //Give control of teleport command to server
-        if (server == player.getServer().getInfo() || onTeamServer || server == null) {
-            Chat19.chat(player, "/tp " + String.join(" ", args));
-            return;
-        }
-
-        teleport(player, server);
-    }
-
-    @Override
-    public Iterable<String> onTabComplete(CommandSender commandSender, String[] args) {
-        if(args.length > 0)
-            return allPlayers(args[args.length - 1]);
-        return new ArrayList<>();
-    }
-
-    public static void teleport(ProxiedPlayer player, ServerInfo server){
-        ChatSender sender = ChatSender.of(player);
-        if(CheckCommand.isChecking(player)){
-            sender.system("CHECK_CHECKING");
-            return;
-        }
-
-        String serverPerm = BungeeCore.serverPermissions.get(server.getName());
-        Subserver subserver = Subserver.getSubserver(server);
-
-        if (subserver != null && subserver.getType() == Servertype.ARENA) {
-            if (!sender.user().isPunishedWithMessage(sender, Punishment.PunishmentType.NoFightServer))
-                SubserverSystem.sendPlayer(subserver, player);
-
-        } else if(subserver instanceof Bauserver) {
-            Bauserver bauserver = (Bauserver) subserver;
-            ProxiedPlayer checker = BungeeCord.getInstance().getPlayer(bauserver.getOwner());
-            if (checker != null && CheckCommand.isChecking(checker)) {
-                SteamwarUser steamwarUser = SteamwarUser.get(player);
-                if (steamwarUser.getUserGroup().isCheckSchematics() || CheckCommand.getCheckingSchem(checker).getOwner() == steamwarUser.getId()) {
-                    SubserverSystem.sendPlayer(subserver, player);
-                } else {
-                    sender.system("JOIN_PLAYER_BLOCK");
-                }
-            }else if (BauLock.isLocked(SteamwarUser.get(bauserver.getOwner()), sender.user())) {
-                Message.send("BAU_LOCKED_NOALLOWED", player);
-            }else if (bauserver.getOwner().equals(player.getUniqueId()) || BauweltMember.getBauMember(bauserver.getOwner(), player.getUniqueId()) != null) {
-                SubserverSystem.sendPlayer(subserver, player);
-            } else {
-                SubserverSystem.sendDeniedMessage(player, bauserver.getOwner());
-                sender.system("JOIN_PLAYER_BLOCK");
-            }
-
-        } else if(subserver instanceof Builderserver && !player.hasPermission("bungeecore.server.team")) {
-            sender.system("JOIN_PLAYER_BLOCK");
-        } else if (serverPerm != null && !player.hasPermission(serverPerm)) {
-            sender.system("JOIN_PLAYER_BLOCK");
-        } else if (serverPerm == null && !player.getGroups().contains("team")) {
-            sender.system("JOIN_PLAYER_BLOCK");
-        } else {
-            player.connect(server);
-        }
-    }
-
-    private static ServerInfo getTarget(String arg) {
-        ServerInfo server = null;
-
-        //Get target player server
-        ProxiedPlayer target = ProxyServer.getInstance().getPlayer(arg);
-        if(target != null)
-            server = target.getServer().getInfo();
-
-        //Get target team event arena
-        if(server == null){
-            Team team = Team.get(arg);
-            if(team != null){
-                Subserver eventArena = EventStarter.getEventServer().get(team.getTeamId());
-                if(eventArena != null && Subserver.getServerList().contains(eventArena))
-                    server = eventArena.getServer();
-            }
-        }
-
-        return server;
-    }
-}

src/de/steamwar/bungeecore/commands/TutorialCommand.java

@@ -1,165 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2022  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.*;
-import de.steamwar.bungeecore.inventory.SWInventory;
-import de.steamwar.bungeecore.inventory.SWItem;
-import de.steamwar.bungeecore.inventory.SWListInv;
-import de.steamwar.bungeecore.inventory.SWStreamInv;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.bungeecore.sql.Tutorial;
-import de.steamwar.bungeecore.util.Chat19;
-import de.steamwar.command.SWCommand;
-import de.steamwar.command.TypeValidator;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-import java.util.stream.Collectors;
-
-public class TutorialCommand extends SWCommand {
-
-    public TutorialCommand() {
-        super("tutorial", null);
-    }
-
-    @Register
-    public void genericCommand(ProxiedPlayer player) {
-        openInventory(player, true, false);
-    }
-
-    @Register("rate")
-    public void rate(ProxiedPlayer player) {
-        Chat19.chat(player, "/tutorial rate");
-    }
-
-    @Register("rate")
-    public void rate(ProxiedPlayer player, int id) {
-        Tutorial tutorial = Tutorial.get(id);
-        if(tutorial == null) {
-            BungeeCore.get().getLogger().log(Level.SEVERE, "rate executed with nonexistent id: " + id);
-            return;
-        }
-
-        rate(player, tutorial);
-    }
-
-    @Register(value = "create", description = "TUTORIAL_CREATE_HELP")
-    public void create(ProxiedPlayer player, String material, String... name) {
-        create(player, String.join(" ", name), material.toUpperCase());
-    }
-
-    @Register("own")
-    public void own(ProxiedPlayer player) {
-        openInventory(player, false, true);
-    }
-
-    @Register("unreleased")
-    public void unreleased(@Validator("unreleased") ProxiedPlayer player) {
-        openInventory(player, false, false);
-    }
-
-    @Validator("unreleased")
-    public TypeValidator<ProxiedPlayer> unreleasedChecker() {
-        return (sender, value, messageSender) -> {
-            return (SteamwarUser.get((value).getUniqueId()).getUserGroup().isTeamGroup());
-        };
-    }
-
-    private void openInventory(ProxiedPlayer player, boolean released, boolean own) {
-        SteamwarUser user = SteamwarUser.get(player.getUniqueId());
-
-        new SWStreamInv<>(
-                player,
-                Message.parse("TUTORIAL_TITLE", player),
-                (click, tutorial) -> {
-                    if(!released && click.isShiftClick() && user.getUserGroup().isTeamGroup() && user != tutorial.creator()) {
-                        tutorial.release();
-                        openInventory(player, released, own);
-                        return;
-                    } else if(own && click.isShiftClick() && click.isRightClick()) {
-                        tutorial.delete();
-                        openInventory(player, released, own);
-                        return;
-                    }
-
-                    new ServerStarter().tutorial(player, tutorial).start();
-                },
-                page -> (own ? Tutorial.getOwn(user, page, 45) : Tutorial.getPage(page, 45, released)).stream().map(tutorial -> new SWListInv.SWListEntry<>(getTutorialItem(player, tutorial, own), tutorial)).collect(Collectors.toList())
-        ).open();
-    }
-
-    private SWItem getTutorialItem(ProxiedPlayer player, Tutorial tutorial, boolean personalHighlights) {
-        SWItem item = new SWItem(tutorial.item(), Message.parse("TUTORIAL_NAME", player, tutorial.name()));
-        item.setHideAttributes(true);
-
-        List<String> lore = new ArrayList<>();
-        lore.add(Message.parse("TUTORIAL_BY", player, tutorial.creator().getUserName()));
-        lore.add(Message.parse("TUTORIAL_STARS", player, String.format("%.1f", tutorial.stars())));
-
-        if (personalHighlights)
-            lore.add(Message.parse("TUTORIAL_DELETE", player));
-
-        item.setLore(lore);
-
-        if (personalHighlights && tutorial.released())
-            item.setEnchanted(true);
-
-        return item;
-    }
-
-    private void rate(ProxiedPlayer player, Tutorial tutorial) {
-        SteamwarUser user = SteamwarUser.get(player.getUniqueId());
-        int[] rates = new int[]{1, 2, 3, 4, 5};
-
-        new SWListInv<>(player, Message.parse("TUTORIAL_RATE_TITLE", player), Arrays.stream(rates).mapToObj(rate -> new SWListInv.SWListEntry<>(new SWItem("NETHER_STAR", Message.parse("TUTORIAL_RATE", player, rate)), rate)).collect(Collectors.toList()), (click, rate) -> {
-            tutorial.rate(user, rate);
-            SWInventory.close(player);
-        }).open();
-    }
-
-    private void create(ProxiedPlayer player, String name, String item) {
-        Subserver subserver = Subserver.getSubserver(player);
-        SteamwarUser user = SteamwarUser.get(player.getUniqueId());
-        File tempWorld = new File(ServerStarter.TEMP_WORLD_PATH, ServerStarter.serverToWorldName(ServerStarter.bauServerName(user)));
-
-        if(subserver == null || !subserver.hasStarted() || subserver.getType() != Servertype.BAUSERVER || !tempWorld.exists()) {
-            Message.send("TUTORIAL_CREATE_MISSING", player);
-            return;
-        }
-
-        subserver.execute("save-all");
-        ProxyServer.getInstance().getScheduler().schedule(BungeeCore.get(), () -> {
-            Tutorial tutorial = Tutorial.create(user, name, item);
-            File tutorialWorld = tutorial.world();
-
-            if (tutorialWorld.exists())
-                SubserverSystem.deleteFolder(BungeeCore.local, tutorialWorld.getPath());
-            ServerStarter.copyWorld(BungeeCore.local, tempWorld.getPath(), tutorialWorld.getPath());
-            Message.send("TUTORIAL_CREATED", player);
-        }, 1, TimeUnit.SECONDS);
-    }
-}

src/de/steamwar/bungeecore/commands/TypeMappers.java

@@ -1,97 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.ArenaMode;
-import de.steamwar.bungeecore.listeners.mods.ModLoaderBlocker;
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.command.SWCommandUtils;
-import de.steamwar.command.TypeMapper;
-import de.steamwar.command.TypeValidator;
-import de.steamwar.messages.ChatSender;
-import lombok.experimental.UtilityClass;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.stream.Collectors;
-
-@UtilityClass
-public class TypeMappers {
-
-    public static void init() {
-        SWCommandUtils.addValidator("arenaPlayer", arenaPlayer());
-        SWCommandUtils.addMapper("nonHistoricArenaMode", arenaModeTypeMapper(false));
-        SWCommandUtils.addMapper("historicArenaMode", arenaModeTypeMapper(true));
-        SWCommandUtils.addMapper("arenaMap", arenaMapTypeMapper());
-    }
-
-    private static TypeValidator<ProxiedPlayer> arenaPlayer() {
-        return (sender, value, messageSender) -> {
-            ChatSender player = ChatSender.of(value);
-            if (player.user().isPunishedWithMessage(player, Punishment.PunishmentType.NoFightServer)) {
-                return false;
-            }
-
-            if (ModLoaderBlocker.isFabric(value)) {
-                messageSender.send("MODLOADER_DENIED");
-                return false;
-            }
-            return true;
-        };
-    }
-
-    private static TypeMapper<ArenaMode> arenaModeTypeMapper(boolean historic) {
-        return new TypeMapper<ArenaMode>() {
-            @Override
-            public ArenaMode map(CommandSender commandSender, String[] previousArguments, String s) {
-                return ArenaMode.getByChat(s);
-            }
-
-            @Override
-            public Collection<String> tabCompletes(CommandSender sender, String[] previousArguments, String s) {
-                return ArenaMode.getAllChatNames(historic);
-            }
-        };
-    }
-
-    private static TypeMapper<String> arenaMapTypeMapper() {
-        return new TypeMapper<String>() {
-            @Override
-            public String map(CommandSender commandSender, String[] previousArguments, String s) {
-                if (previousArguments.length == 0) return null;
-                if (s.equalsIgnoreCase("random")) return "random";
-                return ArenaMode.getByChat(previousArguments[previousArguments.length - 1]).convertToRealMapName(s);
-            }
-
-            @Override
-            public Collection<String> tabCompletes(CommandSender sender, String[] previousArguments, String s) {
-                if (previousArguments.length == 0) return null;
-                ArenaMode arenaMode = ArenaMode.getByChat(previousArguments[previousArguments.length - 1]);
-                if (arenaMode == null) return null;
-                List<String> stringList = new ArrayList<>(arenaMode.getMaps());
-                stringList.add("random");
-                return stringList;
-            }
-        };
-    }
-}

src/de/steamwar/bungeecore/commands/WhoisCommand.java

@@ -1,124 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.commands;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.Storage;
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.bungeecore.sql.Team;
-import de.steamwar.command.SWCommand;
-import de.steamwar.command.SWCommandUtils;
-import de.steamwar.command.TypeMapper;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.net.InetSocketAddress;
-import java.sql.Timestamp;
-import java.text.DecimalFormat;
-import java.time.Instant;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-public class WhoisCommand extends SWCommand {
-    public WhoisCommand() {
-        super("whois", "bungeecore.teamchat");
-    }
-
-    @Register(description = "WHOIS_USAGE")
-    public void genericCommand(ProxiedPlayer player, @Mapper("player") String target, @OptionalValue("") @StaticValue(value = {"", "-all", "-a"}, allowISE = true) boolean all) {
-        SteamwarUser user = SteamwarUser.get(target);
-        if (user == null) {
-            try {
-                int id = Integer.parseInt(target);
-                user = SteamwarUser.get(id);
-            } catch (NumberFormatException ignored) {
-            }
-        }
-        if (user == null) {
-            try {
-                long id = Long.parseLong(target);
-                user = SteamwarUser.get(id);
-            } catch (NumberFormatException ignored) {
-                // Ignored
-            }
-        }
-
-        if (user == null) {
-            Message.send("UNKNOWN_PLAYER", player);
-        } else {
-            sendUserinfo(player, user, all);
-        }
-    }
-
-    @Mapper(value = "player", local = true)
-    public TypeMapper<String> playerTypeMapper() {
-        return SWCommandUtils.createMapper(s -> s, s -> BungeeCord.getInstance().getPlayers().stream().map(ProxiedPlayer::getName).collect(Collectors.toList()));
-    }
-
-    private static void sendUserinfo(ProxiedPlayer player, SteamwarUser user, boolean all) {
-        Message.send("WHOIS_USERNAME", player, user.getUserName());
-        Message.send("WHOIS_UUID", player, Message.parse("WHOIS_UUID_HOVER", player), new ClickEvent(ClickEvent.Action.COPY_TO_CLIPBOARD, user.getUuid().toString()), user.getUuid().toString());
-        Message.send("WHOIS_ID", player, user.getId());
-        Message.send("WHOIS_GROUP", player, user.getUserGroup().getColorCode(), user.getUserGroup().name());
-        if (user.getDiscordId() != null) {
-            Message.send("WHOIS_DISCORD_ID", player, user.getDiscordId());
-        }
-        Timestamp firstJoin = user.getFirstjoin();
-        if (firstJoin == null) {
-            Message.send("WHOIS_JOINED_FIRST", player, "0000-00-00 00:00:00");
-        } else {
-            Message.send("WHOIS_JOINED_FIRST", player, firstJoin.toString());
-        }
-        Message.send("WHOIS_HOURS_PLAYED", player, new DecimalFormat("###.##").format(user.getOnlinetime() / 3600d));
-
-        if(BungeeCord.getInstance().getPlayer(user.getUuid()) != null) {
-            ProxiedPlayer target = BungeeCord.getInstance().getPlayer(user.getUuid());
-            Message.send("WHOIS_CURRENT_PLAYED", player, new DecimalFormat("####.##").format((Instant.now().getEpochSecond() - Storage.sessions.get(target).toInstant().getEpochSecond()) / 60d));
-            Message.send("WHOIS_CURRENT_SERVER", player, target.getServer().getInfo().getName());
-            Message.send("WHOIS_CURRENT_PROTOCOL", player, target.getPendingConnection().getVersion());
-        }
-
-        Team team = Team.get(user.getTeam());
-        Message.send("WHOIS_TEAM", player, Message.parse("WHOIS_TEAM_HOVER", player, team.getTeamName()), new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/team info " + team.getTeamKuerzel()), team.getTeamColor(), team.getTeamKuerzel(), team.getTeamName());
-
-        Message.send("WHOIS_PUNISHMENTS", player);
-        List<Punishment> punishmentList = Punishment.getAllPunishmentsOfPlayer(user.getId());
-        Set<Punishment.PunishmentType> found = new HashSet<>();
-        boolean isPunished = false;
-        for (Punishment punishment : punishmentList) {
-            if (!all && !punishment.getType().isMulti() && !found.add(punishment.getType())) {
-                continue;
-            }
-            if (!all && !punishment.isCurrent()) {
-                continue;
-            }
-            Message.sendPrefixless("WHOIS_PUNISHMENT", player, SteamwarUser.get(punishment.getPunisher()).getUserName(), punishment.getType().name(), punishment.getBantime(punishment.getStartTime(), false), punishment.getBantime(punishment.getEndTime(), punishment.isPerma()), punishment.getReason());
-            isPunished = true;
-        }
-        if (!isPunished) {
-            Message.send(all ? "WHOIS_NO_ALL_PUNISHMENT" : "WHOIS_NO_PUNISHMENT", player);
-        }
-    }
-}

src/de/steamwar/bungeecore/inventory/SWItem.java

@@ -1,173 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.inventory;
-
-import com.google.gson.JsonArray;
-import com.google.gson.JsonObject;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class SWItem {
-
-    private String material, title, skullOwner;
-    private boolean enchanted, hideAttributes;
-    private List<String> lore;
-    private InvCallback callback;
-    private int color;
-
-    public SWItem(String material, String title) {
-        this.material = material.toUpperCase();
-        lore = new ArrayList<>();
-        this.title = title;
-        color = 0;
-    }
-
-    public SWItem(String title, int color) {
-        this.material = "DYE";
-        lore = new ArrayList<>();
-        this.title = title;
-        this.color = color;
-    }
-
-    public static SWItem getSkull(String skullOwner) {
-        SWItem item = new SWItem("SKULL", skullOwner);
-        item.setSkullOwner(skullOwner);
-        return item;
-    }
-
-    public void setCallback(InvCallback callback) {
-        this.callback = callback;
-    }
-
-    public void setColor(int color) {
-        this.color = color;
-    }
-
-    public InvCallback getCallback() {
-        return callback;
-    }
-
-    public String getMaterial() {
-        return material;
-    }
-
-    public void setMaterial(String material) {
-        this.material = material.toUpperCase();
-    }
-
-    public String getSkullOwner() {
-        return skullOwner;
-    }
-
-    public void setSkullOwner(String skullOwner) {
-        this.skullOwner = skullOwner;
-    }
-
-    public boolean isEnchanted() {
-        return enchanted;
-    }
-
-    public void setEnchanted(boolean enchanted) {
-        this.enchanted = enchanted;
-    }
-
-    public boolean isHideAttributes() {
-        return hideAttributes;
-    }
-
-    public void setHideAttributes(boolean hideAttributes) {
-        this.hideAttributes = hideAttributes;
-    }
-
-    public SWItem setName(String name) {
-        title = name;
-        return this;
-    }
-
-    public String getTitle() {
-        return title;
-    }
-
-    public void addLore(String lore) {
-        this.lore.add(lore);
-    }
-
-    public JsonObject writeToString(int position) {
-        JsonObject object = new JsonObject();
-        object.addProperty("material", material);
-        object.addProperty("position", position);
-        object.addProperty("title", title);
-        if(skullOwner != null)
-            object.addProperty("skullOwner", skullOwner);
-        if(enchanted)
-            object.addProperty("enchanted", true);
-        if(hideAttributes)
-            object.addProperty("hideAttributes", true);
-        if(color != 0)
-            object.addProperty("color", color);
-        if(lore != null) {
-            JsonArray array = new JsonArray();
-            for (String lores:
-                 lore) {
-                array.add(lores);
-            }
-            object.add("lore", array);
-        }
-
-        return object;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if(!(o instanceof SWItem))
-            return false;
-        SWItem item = (SWItem) o;
-        if(item.enchanted != enchanted)
-            return false;
-        if(item.hideAttributes != hideAttributes)
-            return false;
-        if(!item.material.equals(material))
-            return false;
-        if(!item.lore.equals(lore))
-            return false;
-        if(!item.skullOwner.equals(skullOwner))
-            return false;
-        return true;
-    }
-
-    public void setLore(List<String> lore) {
-        this.lore = lore;
-    }
-
-    public SWItem clone() {
-        SWItem item;
-        if(color != 0) {
-            item = new SWItem(title, color);
-        }else {
-            item = new SWItem(material, title);
-        }
-        item.setLore(lore);
-        item.setCallback(callback);
-        item.setEnchanted(enchanted);
-        item.setHideAttributes(hideAttributes);
-        return item;
-    }
-}

src/de/steamwar/bungeecore/inventory/SWListInv.java

@@ -1,121 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.inventory;
-
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.*;
-
-public class SWListInv<T> extends SWInventory {
-    private ListCallback<T> callback;
-    private List<SWListEntry<T>> elements;
-    private int page;
-
-    public SWListInv(ProxiedPlayer p, String t, List<SWListEntry<T>> l, ListCallback<T> c){
-        super(p, (l.size()>45) ? 54 : (l.size() + 9-l.size()%9), t);
-        callback = c;
-        elements = l;
-        page = 0;
-    }
-
-    @Override
-    public void open(){
-        if(elements.size() > 54){
-            if(page != 0)
-                addItem(45, new SWItem("§eSeite zurück", 10), (InvCallback.ClickType click) -> {
-                    page--;
-                    open();
-                });
-            else
-                addItem(45, new SWItem("§7Seite zurück", 8), (InvCallback.ClickType click) -> {});
-            if(page < elements.size()/45)
-                addItem(53, new SWItem("§eSeite vor", 10), "§eSeite vor", (InvCallback.ClickType click) -> {
-                    page++;
-                    open();
-                });
-            else
-                addItem(53, new SWItem("§eSeite vor", 8), (InvCallback.ClickType click) -> {});
-        }
-
-        int ipageLimit = elements.size() - page*45;
-        if(ipageLimit > 45 && elements.size() > 54){
-            ipageLimit = 45;
-        }
-        int i = page*45;
-        for(int ipage=0; ipage < ipageLimit; ipage++ ){
-            SWItem e = elements.get(i).getItem();
-
-            final int pos = i;
-            addItem(ipage, e);
-            setCallback(ipage, (InvCallback.ClickType click) -> callback.clicked(click, elements.get(pos).getObject()));
-            i++;
-        }
-        super.open();
-    }
-
-    public void setCallback(ListCallback<T> c){
-        callback = c;
-    }
-
-    public interface ListCallback<T>{
-        void clicked(InvCallback.ClickType click, T element);
-    }
-
-    public static List<SWListEntry<UUID>> createPlayerList(UUID without){
-        List<SWListEntry<UUID>> onlinePlayers = new ArrayList<>();
-        for(ProxiedPlayer player : BungeeCord.getInstance().getPlayer(without).getServer().getInfo().getPlayers()){
-            if(without != null && player.getUniqueId().equals(without))
-                continue;
-
-            onlinePlayers.add(new SWListEntry<>(SWItem.getSkull(player.getName()), player.getUniqueId()));
-        }
-        return onlinePlayers;
-    }
-
-    public static List<SWListEntry<UUID>> createGlobalPlayerList(UUID without){
-        List<SWListEntry<UUID>> onlinePlayers = new ArrayList<>();
-        for(ProxiedPlayer player : BungeeCord.getInstance().getPlayers()){
-            if(without != null && player.getUniqueId().equals(without))
-                continue;
-
-            onlinePlayers.add(new SWListEntry<>(SWItem.getSkull(player.getName()), player.getUniqueId()));
-        }
-        return onlinePlayers;
-    }
-
-    public static class SWListEntry<T>{
-        final SWItem item;
-        final T object;
-
-        public SWListEntry(SWItem item, T object){
-            this.item = item;
-            this.object = object;
-        }
-
-        public SWItem getItem(){
-            return item;
-        }
-
-        public T getObject(){
-            return object;
-        }
-    }
-}

src/de/steamwar/bungeecore/inventory/SWStreamInv.java

@@ -1,51 +0,0 @@
-package de.steamwar.bungeecore.inventory;
-
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.List;
-import java.util.function.Function;
-
-public class SWStreamInv<T> extends SWInventory {
-    private final SWListInv.ListCallback<T> callback;
-    private final Function<Integer, List<SWListInv.SWListEntry<T>>> constructor;
-    private int page;
-
-    public SWStreamInv(ProxiedPlayer proxiedPlayer, String title, SWListInv.ListCallback<T> callback, Function<Integer, List<SWListInv.SWListEntry<T>>> constructor) {
-        super(proxiedPlayer, 54, title);
-        this.callback = callback;
-        this.constructor = constructor;
-        page = 0;
-    }
-
-    @Override
-    public void open(){
-        List<SWListInv.SWListEntry<T>> entries = constructor.apply(page);
-
-        if(page != 0)
-            addItem(45, new SWItem("§eSeite zurück", 10), (InvCallback.ClickType click) -> {
-                page--;
-                open();
-            });
-        else
-            addItem(45, new SWItem("§7Seite zurück", 8), (InvCallback.ClickType click) -> {});
-
-        if(entries.size() == 45)
-            addItem(53, new SWItem("§eSeite vor", 10), (InvCallback.ClickType click) -> {
-                page++;
-                open();
-            });
-        else
-            addItem(53, new SWItem("§7Seite vor", 8), (InvCallback.ClickType click) -> {});
-
-        for(int i = 0; i < entries.size(); i++) {
-            SWListInv.SWListEntry<T> item = entries.get(i);
-            addItem(i, item.getItem());
-            setCallback(i, (InvCallback.ClickType click) -> {
-                close();
-                callback.clicked(click, item.getObject());
-            });
-        }
-
-        super.open();
-    }
-}

src/de/steamwar/bungeecore/listeners/BanListener.java

@@ -1,102 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.listeners;
-
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.listeners.mods.Forge;
-import de.steamwar.bungeecore.sql.BannedUserIPs;
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.messages.ChatSender;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.chat.ComponentBuilder;
-import net.md_5.bungee.api.chat.HoverEvent;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.LoginEvent;
-import net.md_5.bungee.event.EventHandler;
-
-import java.sql.Timestamp;
-import java.time.format.DateTimeFormatter;
-import java.util.List;
-
-public class BanListener extends BasicListener {
-
-    @EventHandler
-    public void onLogin(LoginEvent event) {
-        event.registerIntent(BungeeCore.get());
-        ProxyServer.getInstance().getScheduler().runAsync(BungeeCore.get(), () -> {
-            SteamwarUser user = SteamwarUser.getOrCreate(event.getConnection());
-            if (user.isPunished(Punishment.PunishmentType.Ban)) {
-                user.updateBanIP(event.getConnection().getAddress().getAddress().getHostAddress());
-                event.setCancelled(true);
-                ChatSender.of(event).system(user.punishmentMessage(Punishment.PunishmentType.Ban));
-                event.completeIntent(BungeeCore.get());
-                return;
-            }
-
-            List<BannedUserIPs> ips = BannedUserIPs.get(event.getConnection().getAddress().getAddress().getHostAddress());
-            if(!ips.isEmpty()){
-
-                Timestamp highestBan = ips.get(0).getTimestamp();
-                boolean perma = false;
-                for(BannedUserIPs banned : ips) {
-                    SteamwarUser bannedUser = SteamwarUser.get(banned.getUserID());
-                    if (bannedUser.isPunished(Punishment.PunishmentType.Ban)) {
-                        Punishment ban = bannedUser.getPunishment(Punishment.PunishmentType.Ban);
-                        if(ban.isPerma()) {
-                            perma = true;
-                            break;
-                        }
-                        if(ban.getEndTime().after(highestBan))
-                            highestBan = ban.getEndTime();
-                    }
-                }
-                ClickEvent clickEvent = new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/ban " + user.getUserName() + " "
-                        + (perma?"perma":highestBan.toLocalDateTime().format(DateTimeFormatter.ofPattern("dd.MM.yyyy_HH:mm")))
-                        + " Bannumgehung");
-
-                for (ProxiedPlayer target : ProxyServer.getInstance().getPlayers()){
-                    if ((target.hasPermission("bungeecore.teamchat"))
-                            && (target.getChatMode() == ProxiedPlayer.ChatMode.COMMANDS_ONLY
-                            || target.getChatMode() == ProxiedPlayer.ChatMode.SHOWN)){
-                        StringBuilder potentialBan = new StringBuilder();
-                        potentialBan.append(Message.parsePrefixed("BAN_AVOIDING_ALERT", target, user.getUserName()));
-
-                        for(BannedUserIPs banned : ips) {
-                            SteamwarUser bannedUser = SteamwarUser.get(banned.getUserID());
-                            potentialBan.append(Message.parse("BAN_AVOIDING_LIST", target, bannedUser.getUserName(),
-                                    banned.getTimestamp().toLocalDateTime().format(DateTimeFormatter.ofPattern(Message.parse("TIMEFORMAT", target)))));
-                        }
-
-                        TextComponent msg = new TextComponent(potentialBan.toString());
-                        msg.setHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, new ComponentBuilder(Message.parse("BAN_AVOIDING_BAN_HOVER", target)).create()));
-                        msg.setClickEvent(clickEvent);
-                        target.sendMessage(msg);
-                    }
-                }
-            }
-
-            Forge.onServerConnected(event);
-        });
-    }
-}

src/de/steamwar/bungeecore/listeners/BasicListener.java

@@ -1,31 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.listeners;
-
-import de.steamwar.bungeecore.BungeeCore;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.plugin.Listener;
-
-public abstract class BasicListener implements Listener {
-
-    public BasicListener(){
-        ProxyServer.getInstance().getPluginManager().registerListener(BungeeCore.get(), this);
-    }
-}

src/de/steamwar/bungeecore/listeners/BrandListener.java

@@ -1,71 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.listeners;
-
-import de.steamwar.messages.ChatSender;
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufAllocator;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.PluginMessageEvent;
-import net.md_5.bungee.event.EventHandler;
-import net.md_5.bungee.protocol.DefinedPacket;
-
-import java.net.InetAddress;
-import java.net.NetworkInterface;
-import java.net.SocketException;
-
-public class BrandListener extends BasicListener {
-
-    private static boolean isLocalHost(InetAddress addr) {
-        if (addr.isAnyLocalAddress() || addr.isLoopbackAddress()) {
-            return true;
-        }
-        try {
-            return NetworkInterface.getByInetAddress(addr) != null;
-        } catch (SocketException e) {
-            return false;
-        }
-    }
-
-    @EventHandler
-    public void onServerSwitch(PluginMessageEvent event) {
-        if(!event.getTag().equals("minecraft:brand") && !event.getTag().equals("MC|Brand")) {
-            return;
-        }
-
-        if (isLocalHost(event.getReceiver().getAddress().getAddress())) {
-            return;
-        }
-
-        if (!(event.getReceiver() instanceof ProxiedPlayer)) {
-            return;
-        }
-        event.setCancelled(true);
-
-        ProxiedPlayer player = (ProxiedPlayer) event.getReceiver();
-        String brandString = ChatSender.of(player).parseToLegacy("STEAMWAR_BRAND", ProxyServer.getInstance().getName(), player.getServer().getInfo().getName(), new String(event.getData(), 1, event.getData().length - 1));
-
-        ByteBuf brand = ByteBufAllocator.DEFAULT.heapBuffer();
-        DefinedPacket.writeString(brandString, brand);
-        player.sendData(event.getTag(), DefinedPacket.toArray(brand));
-        brand.release();
-    }
-}

src/de/steamwar/bungeecore/listeners/ChatListener.java

@@ -1,260 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2022  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.listeners;
-
-import de.steamwar.bungeecore.*;
-import de.steamwar.bungeecore.bot.SteamwarDiscordBot;
-import de.steamwar.bungeecore.network.NetworkSender;
-import de.steamwar.bungeecore.sql.*;
-import de.steamwar.bungeecore.util.Chat19;
-import de.steamwar.messages.ChatSender;
-import de.steamwar.network.packets.server.PingPacket;
-import net.md_5.bungee.api.*;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.ChatEvent;
-import net.md_5.bungee.api.event.TabCompleteEvent;
-import net.md_5.bungee.api.event.TabCompleteResponseEvent;
-import net.md_5.bungee.api.scheduler.TaskScheduler;
-import net.md_5.bungee.event.EventHandler;
-
-import java.util.*;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-public class ChatListener extends BasicListener {
-
-    private static final Set<Integer> coloredTeams = new HashSet<>();
-    static {
-        coloredTeams.add(12);
-        coloredTeams.add(54);
-        coloredTeams.add(285);
-    }
-
-    @EventHandler
-    public void onChatEvent(ChatEvent e) {
-        if(!(e.getSender() instanceof ProxiedPlayer))
-            return;
-        ProxiedPlayer player = (ProxiedPlayer) e.getSender();
-        String message = e.getMessage();
-
-        e.setCancelled(true);
-
-        if (message.contains("jndi:ldap")) {
-            SteamwarUser.get(player).punishPerma(Punishment.PunishmentType.Ban, "Versuchte Exploit-Ausnutzung", 0);
-            return;
-        }
-
-        if (isCommand(player, message))
-            return;
-
-        Subserver subserver = Subserver.getSubserver(player);
-        if(subserver != null && subserver.getType() == Servertype.ARENA && subserver.getServer() == player.getServer().getInfo()) {
-            localChat(player, message);
-        } else if (message.startsWith("+")) {
-            localChat(player, message.substring(1));
-        } else {
-            sendChat(ChatSender.of(player), ChatSender.globalReceivers(), "CHAT_GLOBAL", null, message);
-        }
-    }
-
-    private static boolean isCommand(ProxiedPlayer player, String message) {
-        String command = message.substring(1);
-        boolean isCommand = message.startsWith("/") || (message.startsWith("7") && command.split(" ", 2)[0].matches("[7/]?[A-Za-z]+"));
-        if(isCommand && !ProxyServer.getInstance().getPluginManager().dispatchCommand(player, command)) {
-            if(command.startsWith("7"))
-                command = "/" + command.substring(1);
-            message = "/" + command;
-
-            if(filteredCommand(player, message))
-                return true;
-
-            Chat19.chat(player, message);
-        }
-
-        return isCommand;
-    }
-
-    public static void sendChat(ChatSender sender, Stream<ChatSender> receivers, String format, ChatSender msgReceiver, String message) {
-        SteamwarUser user = sender.user();
-        final String coloredMessage = (user.getUserGroup() != UserGroup.Member || coloredTeams.contains(user.getTeam())) ? ChatColor.translateAlternateColorCodes('&', message) : message;
-        if(chatFilter(sender, coloredMessage))
-            return;
-
-        AtomicBoolean noReceiver = new AtomicBoolean(true);
-        receivers.filter(ChatSender::chatShown).forEach(player -> {
-            if(sender.user().getId() != player.user().getId())
-                noReceiver.set(false);
-            chatToReciever(player, msgReceiver, user, format, coloredMessage);
-        });
-
-        chatToReciever(ChatSender.console(), msgReceiver, user, format, coloredMessage);
-
-        if(format.equals("CHAT_GLOBAL")) {
-            if (SteamwarDiscordBot.instance() != null)
-                chatToReciever(ChatSender.discordChannel(SteamwarDiscordBot.instance().getIngameChatListener()), msgReceiver, user, format, coloredMessage);
-        } else if (format.equals("CHAT_SERVERTEAM")) {
-            if (SteamwarDiscordBot.instance() != null)
-                chatToReciever(ChatSender.discordChannel(SteamwarDiscordBot.instance().getServerTeamChatListener()), msgReceiver, user, format, coloredMessage);
-        } else if (noReceiver.get()) {
-            sender.system("CHAT_NO_RECEIVER");
-        }
-    }
-
-    public static void localChat(ProxiedPlayer player, String message) {
-        ChatSender sender = ChatSender.of(player);
-        if(message.length() == 0){
-            sender.system("CHAT_BC_USAGE");
-            return;
-        }
-
-        if(ChatListener.filteredCommand(player, message))
-            return;
-
-        if(!message.startsWith("/") && chatFilter(sender, message))
-            return;
-
-        Chat19.chat(player, message);
-    }
-
-    private static boolean chatFilter(ChatSender sender, String message) {
-        if(!sender.chatShown()) {
-            sender.system("CHAT_RECEIVE");
-            return true;
-        }
-
-        if(message.replace("§[a-f0-9klmno]", "").trim().isEmpty()) {
-            sender.system("CHAT_EMPTY");
-            return true;
-        }
-
-        SteamwarUser user = sender.user();
-        UserGroup group = user.getUserGroup();
-        if(!group.isTeamGroup() && (message.contains("http:") || message.contains("https:") || message.contains("www."))){
-            sender.system("CHAT_NO_LINKS");
-            return true;
-        }
-
-        if (user.isPunishedWithMessage(sender, Punishment.PunishmentType.Mute))
-            return true;
-
-        if (message.contains("LIXFEL"))
-            specialAlert(sender, "Lixfel", "CHAT_LIXFEL_", 3, 6, 11, 12, 15);
-        if (message.contains("YOYONOW"))
-            specialAlert(sender, "YoyoNow", "CHAT_YOYONOW_", 3, 6, 11, 12);
-
-        return false;
-    }
-
-    private static void chatToReciever(ChatSender receiver, ChatSender msgReceiver, SteamwarUser sender, String format, String message) {
-        UserGroup group = sender.getUserGroup();
-        receiver.chat(new Message(format,
-                sender,
-                msgReceiver == null ? receiver : msgReceiver,
-                highlightMentions(message, group.getChatColorCode(), receiver),
-                sender.getTeam() == 0 ? "" : "§" + Team.get(sender.getTeam()).getTeamColor() + Team.get(sender.getTeam()).getTeamKuerzel() + " ",
-                UserElo.getEmblem(sender),
-                group.getColorCode(),
-                group.getChatPrefix().length() == 0 ? "§f" : group.getChatPrefix() + " ",
-                group.getChatColorCode()));
-    }
-
-    private static boolean filteredCommand(CommandSender sender, String message) {
-        String command = message.split(" ", 2)[0];
-        if(command.startsWith("/") && command.contains(":")) {
-            Message.send("UNKNOWN_COMMAND", sender);
-            return true;
-        }
-        return false;
-    }
-
-    private static void specialAlert(ChatSender sender, String name, String baseMessage, int... delay) {
-        sender.system("CHAT_LIXFEL_ACTION_BAR");
-        TaskScheduler scheduler = ProxyServer.getInstance().getScheduler();
-        for(int i = 0; i < delay.length; i++) {
-            int finalI = i;
-            scheduler.schedule(BungeeCore.get(), () -> sender.prefixless("CHAT_MSG", name, sender.user(), new Message(baseMessage + (finalI+1))), delay[i], TimeUnit.SECONDS);
-        }
-    }
-
-    private static String highlightMentions(String message, String returnColor, ChatSender player) {
-        if(!message.contains("@"))
-            return message;
-
-        String mark = "@" + player.user().getUserName();
-        return Arrays.stream(message.split(" ")).map(cur -> {
-            if(cur.equalsIgnoreCase(mark)) {
-                NetworkSender.send(player.user().getPlayer(), new PingPacket(player.user().getId()));
-                return "§e" + cur + returnColor;
-            }
-            return cur;
-        }).collect(Collectors.joining(" "));
-    }
-
-    @EventHandler
-    public void onTabCompleteEvent(TabCompleteEvent e){
-        List<String> suggestions = e.getSuggestions();
-        String [] cursor = e.getCursor().split(" ");
-        String last;
-        if(cursor.length != 0)
-            last = cursor[cursor.length - 1];
-        else
-            last = "";
-        for(ProxiedPlayer player : ProxyServer.getInstance().getPlayers()){
-            String name = player.getName();
-            if (last.isEmpty() || name.startsWith(last)) {
-                suggestions.add(name);
-            }
-        }
-
-        if(last.startsWith("@")) {
-            String plrName = last.replace("@", "");
-            for(ProxiedPlayer player : ProxyServer.getInstance().getPlayers()){
-                String name = player.getName();
-                if ((plrName.isEmpty() || name.startsWith(plrName)) && !plrName.equalsIgnoreCase(name)) {
-                    suggestions.add("@" + name);
-                }
-            }
-        }
-
-        if(e.getSender() instanceof ProxiedPlayer && cursor.length == 1 && cursor[0].startsWith("/")){
-            ProxiedPlayer player = (ProxiedPlayer) e.getSender();
-            for(String cmd : BungeeCore.commands.keySet()){
-                if(cmd.startsWith(cursor[0]) && player.hasPermission(BungeeCore.commands.get(cmd))){
-                    suggestions.add(cmd);
-                }
-            }
-        }
-    }
-
-    @EventHandler
-    public void onTabCompleteResponseEvent(TabCompleteResponseEvent e){
-        List<String> suggestions = e.getSuggestions();
-        int i = 0;
-        while (i < suggestions.size()) {
-            String suggestion = suggestions.get(i);
-            if(suggestion.startsWith("/") && suggestion.contains(":"))
-                suggestions.remove(i);
-            else
-                i++;
-        }
-    }
-}

src/de/steamwar/bungeecore/listeners/ConnectionListener.java

@@ -1,152 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.listeners;
-
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.Servertype;
-import de.steamwar.bungeecore.Subserver;
-import de.steamwar.bungeecore.bot.config.SteamwarDiscordBotConfig;
-import de.steamwar.bungeecore.bot.util.DiscordRanks;
-import de.steamwar.bungeecore.commands.ChallengeCommand;
-import de.steamwar.bungeecore.commands.CheckCommand;
-import de.steamwar.bungeecore.commands.MsgCommand;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.bungeecore.sql.UserGroup;
-import net.md_5.bungee.api.AbstractReconnectHandler;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.config.ServerInfo;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.PlayerDisconnectEvent;
-import net.md_5.bungee.api.event.PostLoginEvent;
-import net.md_5.bungee.api.event.ServerDisconnectEvent;
-import net.md_5.bungee.api.event.ServerKickEvent;
-import net.md_5.bungee.event.EventHandler;
-
-import java.util.*;
-
-public class ConnectionListener extends BasicListener {
-
-    private static final String ADMIN_GROUP = "admin";
-    public static final String TEAM_GROUP = "team";
-    public static final String CHECK_PERMISSION = "bungeecore.check";
-    private static final String YOUTUBER_MODS = "bungeecore.youtubermods";
-
-    private static final Set<UUID> newPlayers = new HashSet<>();
-
-    public static void newPlayer(UUID player){
-        newPlayers.add(player);
-    }
-
-    @EventHandler
-    public void onPostLogin(PostLoginEvent event) {
-        ProxiedPlayer player = event.getPlayer();
-        SteamwarUser user = SteamwarUser.get(player.getUniqueId());
-
-        player.removeGroups("Admin", "team");
-
-        if(user.getUserGroup().isAdminGroup())
-            player.addGroups(ADMIN_GROUP);
-
-        if(user.getUserGroup().isTeamGroup()) {
-            player.addGroups(TEAM_GROUP);
-            CheckCommand.sendReminder(player);
-        }
-
-        if(user.getUserGroup().isCheckSchematics())
-            player.setPermission(CHECK_PERMISSION, true);
-
-        if(user.getUserGroup() != UserGroup.Member) {
-            player.setPermission(YOUTUBER_MODS, true);
-            player.setDisplayName(user.getUserGroup().getColorCode() + user.getUserGroup().getChatPrefix() + " " + player.getName() + "§r");
-            player.setPermission("bungeecore.group." + user.getUserGroup().name().toLowerCase(), true);
-        }else {
-            player.setDisplayName("§f" + player.getName());
-        }
-
-        for(Subserver subserver : Subserver.getServerList()){
-            if(subserver.getType() == Servertype.ARENA){
-                Iterator<ProxiedPlayer> it = subserver.getServer().getPlayers().iterator();
-                if(it.hasNext()){
-                    Message.send("JOIN_ARENA", player, Message.parse("JOIN_ARENA_HOVER", player),
-                            new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/join " + it.next().getName()), subserver.getServer().getName());
-                }
-            }
-        }
-
-        if(newPlayers.contains(player.getUniqueId())){
-            Message.broadcast("JOIN_FIRST", player.getName());
-            newPlayers.remove(player.getUniqueId());
-        }
-
-        if(SteamwarDiscordBotConfig.loaded)
-            DiscordRanks.update(user);
-    }
-
-    /** To redirect players to the lobby in case of server closure. */
-    @EventHandler
-    public void onServerKickEvent(ServerKickEvent ev)
-    {
-        if(!ev.getPlayer().isConnected())
-            return;
-
-        ServerInfo kickedFrom;
-
-        if (ev.getPlayer().getServer() != null){
-            kickedFrom = ev.getPlayer().getServer().getInfo();
-        }else if (ProxyServer.getInstance().getReconnectHandler() != null){
-            kickedFrom = ProxyServer.getInstance().getReconnectHandler().getServer(ev.getPlayer());
-        }else{
-            kickedFrom = AbstractReconnectHandler.getForcedHost(ev.getPlayer().getPendingConnection());
-            if (kickedFrom == null){
-                kickedFrom = ProxyServer.getInstance().getServerInfo(ev.getPlayer().getPendingConnection().getListener().getDefaultServer());
-            }
-        }
-
-        ServerInfo kickTo = ProxyServer.getInstance().getServerInfo(BungeeCore.LOBBY_SERVER);
-
-        if (kickedFrom != null && kickedFrom.equals(kickTo)) {
-            return;
-        }
-
-        ev.setCancelled(true);
-        ev.setCancelServer(kickTo);
-    }
-
-    @EventHandler
-    public void onDisconnect(PlayerDisconnectEvent e){
-        ChallengeCommand.remove(e.getPlayer());
-        MsgCommand.remove(e.getPlayer());
-    }
-
-    @EventHandler
-    public void onServerDisconnect(ServerDisconnectEvent e){
-        ServerInfo server = e.getTarget();
-        Subserver subserver = Subserver.getSubserver(server);
-        if(subserver == null)
-            return;
-
-        ProxiedPlayer player = e.getPlayer();
-        Collection<ProxiedPlayer> players = server.getPlayers();
-        if(players.isEmpty() || (players.size() == 1 && players.contains(player)))
-            ProxyServer.getInstance().getScheduler().runAsync(BungeeCore.get(), subserver::waitForTermination);
-    }
-}

src/de/steamwar/bungeecore/listeners/EventModeListener.java

@@ -1,34 +0,0 @@
-package de.steamwar.bungeecore.listeners;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.sql.Event;
-import de.steamwar.bungeecore.sql.EventFight;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.bungeecore.sql.TeamTeilnahme;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.event.PostLoginEvent;
-import net.md_5.bungee.event.EventHandler;
-
-public class EventModeListener extends BasicListener {
-
-    @EventHandler
-    public void onPostLogin(PostLoginEvent e) {
-        SteamwarUser user = SteamwarUser.get(e.getPlayer().getUniqueId());
-
-        Event event = Event.get();
-        if(event == null){
-            e.getPlayer().disconnect(TextComponent.fromLegacyText(Message.parse("EVENTMODE_KICK", e.getPlayer())));
-            return;
-        }
-
-        if(TeamTeilnahme.nimmtTeil(user.getTeam(), event.getEventID()))
-            return;
-
-        for(EventFight eventFight : EventFight.getEvent(event.getEventID())){
-            if(eventFight.getKampfleiter() == user.getId())
-                return;
-        }
-
-        e.getPlayer().disconnect(TextComponent.fromLegacyText(Message.parse("EVENTMODE_KICK", e.getPlayer())));
-    }
-}

src/de/steamwar/bungeecore/listeners/PollSystem.java

@@ -1,84 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.listeners;
-
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.sql.PollAnswer;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import net.md_5.bungee.api.chat.ClickEvent;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.PostLoginEvent;
-import net.md_5.bungee.event.EventHandler;
-
-import java.util.List;
-
-public class PollSystem extends BasicListener {
-
-    private static String question;
-    private static List<String> answers;
-
-    public static void init(String question, List<String> answers){
-        PollSystem.question = question;
-        PollSystem.answers = answers;
-
-        if(noCurrentPoll())
-            return;
-        new PollSystem();
-    }
-
-    @EventHandler
-    public void onPostLogin(PostLoginEvent event){
-        ProxiedPlayer player = event.getPlayer();
-        SteamwarUser user = SteamwarUser.get(player.getUniqueId());
-
-        PollAnswer answer = PollAnswer.get(user.getId());
-        if(answer.hasAnswered())
-            return;
-
-        sendPoll(player);
-    }
-
-    public static void sendPoll(ProxiedPlayer player){
-        Message.send("POLL_HEADER", player);
-        Message.sendPrefixless("POLL_HEADER2", player);
-        Message.sendPrefixless("POLL_QUESTION", player, question);
-
-        for(int i = 1; i <= answers.size(); i++){
-            Message.send("POLL_ANWSER", player, Message.parse("POLL_ANWSER_HOVER", player, answers.get(i-1)),
-                    new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/poll " + i), answers.get(i-1));
-        }
-    }
-
-    public static boolean noCurrentPoll(){
-        return question == null || question.equals("");
-    }
-
-    public static String getQuestion() {
-        return question;
-    }
-
-    public static int answers(){
-        return answers.size();
-    }
-
-    public static String getAnswer(int i) {
-        return answers.get(i);
-    }
-}

src/de/steamwar/bungeecore/listeners/SubserverProtocolFixer.java

@@ -1,70 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.listeners;
-
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.event.LoginEvent;
-import net.md_5.bungee.connection.InitialHandler;
-import net.md_5.bungee.connection.LoginResult;
-import net.md_5.bungee.event.EventHandler;
-import net.md_5.bungee.protocol.Property;
-import net.md_5.bungee.util.AddressUtil;
-
-import java.lang.reflect.Field;
-import java.net.InetSocketAddress;
-import java.util.logging.Level;
-
-public class SubserverProtocolFixer extends BasicListener {
-
-    private final InetSocketAddress inetSocketAddress = new InetSocketAddress("127.127.127.127", 25565);
-
-    private Field field;
-
-    {
-        try {
-            field = InitialHandler.class.getDeclaredField("extraDataInHandshake");
-            field.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            BungeeCord.getInstance().getLogger().log(Level.SEVERE, e.getMessage(), e);
-        }
-    }
-
-    @EventHandler
-    public void loginEvent(LoginEvent e) {
-        InitialHandler initialHandler = ((InitialHandler) e.getConnection());
-
-        String undashedUUID = initialHandler.getUniqueId().toString().replace("-", "");
-        String extraData = "\00" + AddressUtil.sanitizeAddress(inetSocketAddress) + "\00" + undashedUUID;
-
-        LoginResult result = initialHandler.getLoginProfile();
-        if (result != null) {
-            Property[] properties = result.getProperties();
-            if (properties.length > 0) {
-                extraData += "\00" + BungeeCord.getInstance().gson.toJson(properties);
-            }
-        }
-
-        try {
-            field.set(initialHandler, extraData);
-        } catch (IllegalAccessException ex) {
-            BungeeCord.getInstance().getLogger().log(Level.SEVERE, ex.getMessage(), ex);
-        }
-    }
-}

src/de/steamwar/bungeecore/listeners/mods/Badlion.java

@@ -1,32 +0,0 @@
-package de.steamwar.bungeecore.listeners.mods;
-
-import de.steamwar.bungeecore.listeners.BasicListener;
-import net.md_5.bungee.api.event.PostLoginEvent;
-import net.md_5.bungee.event.EventHandler;
-import net.md_5.bungee.protocol.packet.PluginMessage;
-
-public class Badlion extends BasicListener {
-
-    @EventHandler
-    public void onPostLogin(PostLoginEvent event) {
-        /*
-        {
-        "modsDisallowed": {
-        "Clear Glass":{"disabled":true},
-        "ClearWater":{"disabled":true},
-        "FOV Changer":{"disabled":true},
-        "Hitboxes":{"disabled":true},
-        "MiniMap":{"disabled":true},
-        "MLG Cobweb":{"disabled":true},
-        "Replay":{"disabled":true},
-        "Schematica":{"disabled":true},
-        "ToggleSneak":{"disabled":true},
-        "ToggleSprint":{"disabled":true},
-        "TNT Time":{"disabled":true}
-        }
-        }
-        */
-
-        event.getPlayer().unsafe().sendPacket(new PluginMessage("badlion:mods", ("{\"Clear Glass\":{\"disabled\":true},\"ClearWater\":{\"disabled\":true},\"FOV Changer\":{\"disabled\":true},\"Hitboxes\":{\"disabled\":true},\"MiniMap\":{\"disabled\":true},\"MLG Cobweb\":{\"disabled\":true},\"Replay\":{\"disabled\":true},\"Schematica\":{\"disabled\":true},\"ToggleSneak\":{\"disabled\":true},\"ToggleSprint\":{\"disabled\":true},\"TNT Time\":{\"disabled\":true}}").getBytes(), false));
-    }
-}

src/de/steamwar/bungeecore/listeners/mods/Fabric.java

@@ -1,190 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.listeners.mods;
-
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonParser;
-import com.google.gson.JsonSyntaxException;
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.Storage;
-import de.steamwar.bungeecore.listeners.BasicListener;
-import de.steamwar.bungeecore.sql.Mod;
-import de.steamwar.bungeecore.sql.SWException;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import net.md_5.bungee.BungeeCord;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.PluginMessageEvent;
-import net.md_5.bungee.api.event.ServerSwitchEvent;
-import net.md_5.bungee.event.EventHandler;
-
-import java.nio.charset.StandardCharsets;
-import java.nio.charset.UnsupportedCharsetException;
-import java.util.*;
-import java.util.concurrent.TimeUnit;
-
-public class Fabric extends BasicListener {
-
-    private final Set<String> neededMods = new HashSet<>();
-
-    {
-        neededMods.add("java");
-        neededMods.add("minecraft");
-        neededMods.add("fabricloader");
-        neededMods.add("steamwarmodsender");
-
-        BungeeCord.getInstance().getScheduler().schedule(BungeeCore.get(), () -> {
-            synchronized (Storage.fabricExpectPluginMessage) {
-                for (Map.Entry<ProxiedPlayer, Long> entry : Storage.fabricExpectPluginMessage.entrySet()) {
-                    if (!Storage.fabricCheckedPlayers.containsKey(entry.getKey())) {
-                        continue;
-                    }
-                    if (System.currentTimeMillis() - entry.getValue() > TimeUnit.SECONDS.toMillis(20)) {
-                        logMessage(SteamwarUser.get(entry.getKey()), "Expected message not received", String.valueOf(entry.getValue()));
-                        return;
-                    }
-                }
-            }
-        }, 0, 1, TimeUnit.SECONDS);
-    }
-
-    @EventHandler
-    public void onPluginMessageEvent(PluginMessageEvent e){
-        if(!e.getTag().equals("fabricmodsender:mods"))
-            return;
-
-        if (!(e.getSender() instanceof ProxiedPlayer)) {
-            return;
-        }
-
-        ProxiedPlayer player = (ProxiedPlayer) e.getSender();
-        SteamwarUser user = SteamwarUser.get(player.getUniqueId());
-        byte[] data = e.getData();
-
-        if (!Storage.fabricCheckedPlayers.containsKey(player)) {
-            synchronized (Storage.fabricExpectPluginMessage) {
-                if (Storage.fabricExpectPluginMessage.containsKey(player)) {
-                    logMessage(user, "Was not fabric checked but send message nonetheless", Arrays.toString(data));
-                    return;
-                }
-            }
-        }
-        Storage.fabricExpectPluginMessage.remove(player);
-
-        List<Mod> mods = new LinkedList<>();
-
-        Utils.VarInt varInt = Utils.readVarInt(data,0);
-
-        if(data.length != varInt.length + varInt.value) {
-            logMessage(user, "Invalid message length", Arrays.toString(data));
-            return;
-        }
-
-        data = Arrays.copyOfRange(data,varInt.length, data.length);
-
-        String dataString;
-
-        try{
-            dataString = new String(data, StandardCharsets.UTF_8);
-        }catch (UnsupportedCharsetException exception) {
-            logMessage(user, "Unsupported charset", Arrays.toString(data));
-            return;
-        }
-
-        JsonArray array;
-
-        try {
-            array = new JsonParser().parse(dataString).getAsJsonArray();
-        }catch (JsonSyntaxException exception) {
-            logMessage(user, "Invalid json", dataString);
-            return;
-        }
-
-        for(JsonElement mod : array) {
-            mods.add(Mod.get(mod.getAsString(), Mod.Platform.FABRIC));
-        }
-
-        /*
-        boolean isSorted = isSortedAlphabetically(mods);
-
-        if(!isSorted) {
-            banPlayer(user, player, "Mods are not sorted alphabetically: " + mods.stream().map(Mod::getModName).collect(Collectors.joining(", ")));
-            return;
-        }
-        */
-
-        if(!neededModsContained(mods)) {
-            logMessage(user, "Needed mods are not contained", dataString);
-            return;
-        }
-
-        if(Utils.handleMods(player,mods)) {
-            if (Storage.fabricCheckedPlayers.containsKey(player)) {
-                long current = Storage.fabricCheckedPlayers.get(player);
-                if (current != dataString.hashCode()) {
-                    logMessage(user, "Mods changed during runtime", dataString);
-                    return;
-                }
-            } else {
-                Message.send("MODIFICATION_CHECK_SUCCESS", player);
-                Storage.fabricCheckedPlayers.put(player, dataString.hashCode());
-            }
-            Storage.fabricPlayers.remove(player);
-        }
-    }
-
-    @EventHandler
-    public void onServerSwitchEvent(ServerSwitchEvent e) {
-        if (e.getFrom() == null) return;
-        synchronized (Storage.fabricExpectPluginMessage) {
-            Storage.fabricExpectPluginMessage.put(e.getPlayer(), System.currentTimeMillis());
-        }
-    }
-
-    private boolean isSortedAlphabetically(List<Mod> mods) {
-        boolean isSorted = true;
-        for(int i = 0; i < mods.size() - 1; i++) {
-            if(mods.get(i).getModName().compareToIgnoreCase(mods.get(i + 1).getModName()) > 0) {
-                isSorted = false;
-                break;
-            }
-        }
-        return isSorted;
-    }
-
-    private boolean neededModsContained(List<Mod> mods) {
-        return mods.stream()
-                .map(Mod::getModName)
-                .filter(neededMods::contains)
-                .count() == neededMods.size();
-    }
-
-    public void logMessage(SteamwarUser user, String reason, String data) {
-        SWException.log("Bungee", "FabricModSender " + user.getUserName() + ": " + reason, data);
-    }
-
-    public static void remove(ProxiedPlayer player) {
-        Storage.fabricCheckedPlayers.remove(player);
-        synchronized (Storage.fabricExpectPluginMessage) {
-            Storage.fabricExpectPluginMessage.remove(player);
-        }
-    }
-}

src/de/steamwar/bungeecore/listeners/mods/Forge.java

@@ -1,149 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.listeners.mods;
-
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.listeners.BasicListener;
-import de.steamwar.bungeecore.sql.Mod;
-import io.netty.channel.ChannelPipeline;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.connection.PendingConnection;
-import net.md_5.bungee.api.event.LoginEvent;
-import net.md_5.bungee.api.event.ProxyPingEvent;
-import net.md_5.bungee.connection.InitialHandler;
-import net.md_5.bungee.event.EventHandler;
-import net.md_5.bungee.netty.ChannelWrapper;
-import net.md_5.bungee.netty.HandlerBoss;
-import net.md_5.bungee.netty.PacketHandler;
-import net.md_5.bungee.protocol.packet.LoginPayloadRequest;
-import net.md_5.bungee.protocol.packet.LoginPayloadResponse;
-
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Locale;
-import java.util.logging.Level;
-
-public class Forge extends BasicListener {
-
-    private static final String WRAPPER = "fml:loginwrapper";
-
-    private static final Field initialHandlerCh;
-    static{
-        try {
-            initialHandlerCh = InitialHandler.class.getDeclaredField("ch");
-        } catch (NoSuchFieldException e) {
-            throw new SecurityException("Could not initialize Reflection", e);
-        }
-        initialHandlerCh.setAccessible(true);
-    }
-
-    public static void onServerConnected(LoginEvent event) {
-        if(event.getConnection().getVersion() < 341) { //1.13+
-            event.completeIntent(BungeeCore.get());
-            return;
-        }
-
-        //fml:handshake without mods, channels and registries
-        //for more information see https://wiki.vg/Minecraft_Forge_Handshake#FML2_protocol_.281.13_-_Current.29
-        event.getConnection().unsafe().sendPacket(new LoginPayloadRequest(1, WRAPPER, new byte[]{13,102,109,108,58,104,97,110,100,115,104,97,107,101,4,1,0,0,0}));
-
-        InitialHandler handler = (InitialHandler) event.getConnection();
-
-        ChannelWrapper wrapper;
-        try{
-            wrapper = (ChannelWrapper) initialHandlerCh.get(handler);
-        } catch (IllegalAccessException e) {
-            BungeeCore.get().getLogger().log(Level.SEVERE, "Could not get Channel", e);
-            event.completeIntent(BungeeCore.get());
-            return;
-        }
-
-        ChannelPipeline pipeline = wrapper.getHandle().pipeline();
-        if(pipeline != null) {
-            HandlerBoss handlerBoss = pipeline.get(HandlerBoss.class);
-            if(handlerBoss != null)
-                handlerBoss.setHandler(new CustomPacketHandler(event));
-        }
-    }
-
-    private static class CustomPacketHandler extends PacketHandler {
-        private final LoginEvent event;
-
-        public CustomPacketHandler(LoginEvent event) {
-            this.event = event;
-        }
-
-        @Override
-        public String toString() {
-            return "SteamWar Forge Handler";
-        }
-
-        @Override
-        public void handle(LoginPayloadResponse response){
-            byte[] data = response.getData();
-            if(data == null) {
-                event.completeIntent(BungeeCore.get());
-                return;
-            }
-
-            //for more information see https://wiki.vg/Minecraft_Forge_Handshake#FML2_protocol_.281.13_-_Current.29
-            Utils.VarInt channelLength = Utils.readVarInt(data, 0);
-            int pos = channelLength.length;
-            if(!new String(data, pos, channelLength.value).equals("fml:handshake")) {
-                event.getConnection().disconnect(TextComponent.fromLegacyText("Invalid forge registry response (0x00)"));
-                return;
-            }
-            pos += channelLength.value;
-
-            Utils.VarInt length = Utils.readVarInt(data, pos);
-            pos += length.length;
-            if(channelLength.length + channelLength.value + length.length + length.value != data.length) {
-                event.getConnection().disconnect(TextComponent.fromLegacyText("Invalid forge registry response (0x01)"));
-                return;
-            }
-
-            Utils.VarInt packetId = Utils.readVarInt(data, pos);
-            pos += packetId.length;
-            if(packetId.value != 2) {
-                event.getConnection().disconnect(TextComponent.fromLegacyText("Invalid forge registry response (0x02)"));
-                return;
-            }
-
-            Utils.VarInt modCount = Utils.readVarInt(data, pos);
-            pos += modCount.length;
-
-            List<Mod> mods = new ArrayList<>();
-            for(int i = 0; i < modCount.value; i++) {
-                Utils.VarInt nameLength = Utils.readVarInt(data, pos);
-                pos += nameLength.length;
-
-                mods.add(Mod.get(new String(data, pos, nameLength.value), Mod.Platform.FORGE));
-                pos += nameLength.value;
-            }
-
-            PendingConnection connection = event.getConnection();
-            if(!Utils.handleMods(connection.getUniqueId(), Locale.getDefault(), event::setCancelReason, mods)) {
-                event.setCancelled(true);
-            }
-            event.completeIntent(BungeeCore.get());
-        }
-    }
-}

src/de/steamwar/bungeecore/listeners/mods/Forge12.java

@@ -1,113 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2022  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.listeners.mods;
-
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.listeners.BasicListener;
-import de.steamwar.bungeecore.sql.Mod;
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.UnpooledByteBufAllocator;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.connection.Connection;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.PluginMessageEvent;
-import net.md_5.bungee.api.event.PostLoginEvent;
-import net.md_5.bungee.event.EventHandler;
-
-import java.nio.charset.StandardCharsets;
-import java.util.*;
-import java.util.concurrent.TimeUnit;
-
-public class Forge12 extends BasicListener {
-    private static final String FMLHS = "FML|HS";
-    private static final byte[] REGISTER;
-    private static final byte[] HELLO = new byte[]{0, 2, 0, 0, 0, 0};
-
-    private static final Set<UUID> unlocked = new HashSet<>();
-
-    static {
-        ByteBuf buf = UnpooledByteBufAllocator.DEFAULT.directBuffer(7);
-        buf.writeByte(6);
-        buf.writeCharSequence(FMLHS, StandardCharsets.UTF_8);
-        REGISTER = new byte[buf.readableBytes()];
-        buf.readBytes(REGISTER);
-    }
-
-
-    @EventHandler
-    public void onPostLogin(PostLoginEvent event) {
-        ProxiedPlayer player = event.getPlayer();
-
-        synchronized (unlocked) {
-            if(unlocked.contains(player.getUniqueId())){
-                unlocked.remove(player.getUniqueId());
-                return;
-            }
-        }
-
-        if(player.getPendingConnection().getVersion() <= 340) {
-            player.sendData("REGISTER", REGISTER); //1.12-
-            player.sendData(FMLHS, HELLO);
-        }
-    }
-
-    @EventHandler
-    public void onPluginMessageEvent(PluginMessageEvent e){
-        if(!e.getTag().equals(FMLHS))
-            return;
-
-        e.setCancelled(true);
-        byte[] data = e.getData();
-
-        Connection sender = e.getSender();
-        if(!(sender instanceof ProxiedPlayer))
-            return;
-        ProxiedPlayer p = (ProxiedPlayer) sender;
-
-        if (data[0] == 2) {
-            Utils.VarInt numMods = Utils.readVarInt(data, 1);
-            List<Mod> mods = new LinkedList<>();
-
-            int bytePos = 1 + numMods.length;
-            for (int i = 0; i < numMods.value; i++) {
-                byte[] name = Arrays.copyOfRange(data, bytePos + 1, bytePos + data[bytePos] + 1);
-                bytePos += 1 + data[bytePos];
-                //Version information is unused
-                bytePos += 1 + data[bytePos];
-
-                mods.add(Mod.get(new String(name), Mod.Platform.FORGE));
-            }
-
-            if (Utils.handleMods(p, mods)) {
-                synchronized (unlocked) {
-                    unlocked.add(p.getUniqueId());
-                }
-                ProxyServer.getInstance().getScheduler().schedule(BungeeCore.get(),
-                        () -> p.disconnect(BungeeCore.stringToText("§7Deine installierten Mods wurden überprüft\n§aDu kannst nun §eSteam§8War §abetreten")),
-                        2, TimeUnit.SECONDS);
-                ProxyServer.getInstance().getScheduler().schedule(BungeeCore.get(), () -> {
-                    synchronized (unlocked) {
-                        unlocked.remove(p.getUniqueId());
-                    }
-                }, 30, TimeUnit.SECONDS);
-            }
-        }
-    }
-}

src/de/steamwar/bungeecore/listeners/mods/LabyMod.java

@@ -1,184 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.listeners.mods;
-
-import com.google.gson.JsonObject;
-import com.google.gson.stream.JsonReader;
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.listeners.BasicListener;
-import de.steamwar.bungeecore.sql.Mod;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.connection.Connection;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.PluginMessageEvent;
-import net.md_5.bungee.event.EventHandler;
-
-import java.io.IOException;
-import java.io.StringReader;
-import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.UUID;
-
-public class LabyMod extends BasicListener {
-
-    @EventHandler
-    public void onPluginMessageEvent(PluginMessageEvent event){
-        if(!event.getTag().equals("LMC"))
-            return;
-
-        Connection sender = event.getSender();
-        if(!(sender instanceof ProxiedPlayer))
-            return;
-
-        event.setCancelled(true);
-        updateGameInfo((ProxiedPlayer) sender);
-        byte[] data = event.getData();
-
-        ProxyServer.getInstance().getScheduler().runAsync(BungeeCore.get(), () -> runAsync(data, (ProxiedPlayer) sender));
-    }
-
-    private void runAsync(byte[] data, ProxiedPlayer player) {
-        VarString purpose = readString(data, 0);
-        if(!"INFO".equals(purpose.value))
-            return;
-
-        VarString value = readString(data, purpose.length);
-        List<Mod> mods = new LinkedList<>();
-
-        try{
-            InfoPacket info = new InfoPacket(value.value);
-            for(InfoPacket.Addon addon : info.addons) {
-                mods.add(Mod.get(addon.name, Mod.Platform.LABYMOD));
-            }
-        }catch(IOException e){
-            BungeeCore.log("Could not read JSON", e);
-        }
-
-        Utils.handleMods(player, mods);
-    }
-
-    private VarString readString(byte[] array, int startPos){
-        Utils.VarInt varInt = Utils.readVarInt(array, startPos);
-        startPos += varInt.length;
-        return new VarString(varInt.value+varInt.length, new String(Arrays.copyOfRange(array, startPos, startPos + varInt.value), StandardCharsets.UTF_8));
-    }
-
-    private void updateGameInfo(ProxiedPlayer proxiedPlayer) {
-        JsonObject obj = new JsonObject();
-        obj.addProperty("hasGame", true);
-        obj.addProperty("game_mode", "steamwar.de");
-        obj.addProperty("game_startTime", 0);
-        obj.addProperty("game_endTime", 0);
-        String output = "{ \"hasGame\" : \"true\", \"game_mode\" : \"steamwar.de\", \"game_startTime\" : \"0\", \"game_endTime\" : \"0\" }";
-
-        proxiedPlayer.sendData("LMC", output.getBytes());
-    }
-
-    private static class VarString{
-        private final int length;
-        private final String value;
-
-        private VarString(int length, String value) {
-            this.length = length;
-            this.value = value;
-        }
-    }
-
-    private static class InfoPacket{
-        String version = null;
-        Feature ccp = null;
-        Feature shadow = null;
-        List<Addon> addons = new LinkedList<>();
-
-        InfoPacket(String input) throws IOException {
-            JsonReader reader = new JsonReader(new StringReader(input));
-            reader.beginObject();
-            while(reader.hasNext()){
-                String name = reader.nextName();
-                switch(name){
-                    case "version":
-                        version = reader.nextString();
-                        break;
-                    case "ccp":
-                        ccp = new Feature(reader);
-                        break;
-                    case "shadow":
-                        shadow = new Feature(reader);
-                        break;
-                    case "addons":
-                        reader.beginArray();
-                        while(reader.hasNext()){
-                            addons.add(new Addon(reader));
-                        }
-                        reader.endArray();
-                        break;
-                    default:
-                        reader.skipValue();
-                }
-            }
-            reader.endObject();
-            reader.close();
-        }
-
-        static class Addon{
-            UUID uuid = null;
-            String name = null;
-
-            Addon(JsonReader reader) throws IOException {
-                reader.beginObject();
-                while(reader.hasNext()){
-                    String n = reader.nextName();
-                    if(n.equals("uuid"))
-                        try{
-                            uuid = UUID.fromString(reader.nextString());
-                        }catch(IllegalArgumentException ignored){
-                            //ignored
-                        }
-                    else if(n.equals("name"))
-                        name = reader.nextString();
-                    else
-                        reader.skipValue();
-                }
-                reader.endObject();
-            }
-        }
-
-        static class Feature{
-            boolean enabled;
-            int version;
-
-            Feature(JsonReader reader) throws IOException {
-                reader.beginObject();
-                while(reader.hasNext()){
-                    String name = reader.nextName();
-                    if(name.equals("version"))
-                        version = reader.nextInt();
-                    else if(name.equals("enabled"))
-                        enabled = reader.nextBoolean();
-                    else
-                        reader.skipValue();
-                }
-                reader.endObject();
-            }
-        }
-    }
-}

src/de/steamwar/bungeecore/listeners/mods/ModLoaderBlocker.java

@@ -1,86 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.listeners.mods;
-
-import de.steamwar.bungeecore.*;
-import de.steamwar.bungeecore.listeners.BasicListener;
-import net.md_5.bungee.api.connection.Connection;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.PlayerDisconnectEvent;
-import net.md_5.bungee.api.event.PluginMessageEvent;
-import net.md_5.bungee.api.event.ServerSwitchEvent;
-import net.md_5.bungee.event.EventHandler;
-
-import java.util.HashSet;
-import java.util.Set;
-
-public class ModLoaderBlocker extends BasicListener {
-
-    private static final Set<String> BLOCKED_SERVER = new HashSet<>();
-
-    @EventHandler
-    public void onPluginMessageEvent(PluginMessageEvent e){
-        Connection sender = e.getSender();
-        if(!(sender instanceof ProxiedPlayer))
-            return;
-
-        if(!e.getTag().equals("minecraft:brand"))
-            return;
-
-        if(new String(e.getData()).contains("fabric")){
-            ProxiedPlayer p = (ProxiedPlayer) sender;
-            if (!Storage.fabricCheckedPlayers.containsKey(p) && !Storage.fabricPlayers.contains(p)) {
-                Storage.fabricPlayers.add(p);
-                Message.send("MODLOADER_INSTALLED_FABRIC", p, "Fabric");
-            }
-        }else if(new String(e.getData()).contains("LiteLoader")) {
-            ProxiedPlayer p = (ProxiedPlayer) sender;
-            if (!Storage.fabricPlayers.contains(p)) {
-                Storage.fabricPlayers.add(p);
-                Message.send("MODLOADER_INSTALLED", p, "LiteLoader");
-            }
-        }
-    }
-
-    @EventHandler
-    public void onDisconnect(PlayerDisconnectEvent e){
-        Fabric.remove(e.getPlayer());
-        Storage.fabricPlayers.remove(e.getPlayer());
-    }
-
-    @EventHandler
-    public void onServerSwitch(ServerSwitchEvent event) {
-        if(((Subserver.getSubserver(event.getPlayer()) != null
-                && Subserver.getSubserver(event.getPlayer()).getType() == Servertype.ARENA)
-                || BLOCKED_SERVER.contains(event.getPlayer().getServer().getInfo().getName()))
-                && isFabric(event.getPlayer())) {
-            event.getPlayer().connect(BungeeCore.get().getProxy().getServerInfo(BungeeCore.LOBBY_SERVER));
-            Message.send("MODLOADER_DENIED", event.getPlayer());
-        }
-    }
-
-    public static boolean isFabric(ProxiedPlayer player) {
-        return Storage.fabricPlayers.contains(player);
-    }
-
-    public static void addServer(String server) {
-        BLOCKED_SERVER.add(server);
-    }
-}

src/de/steamwar/bungeecore/listeners/mods/Utils.java

@@ -1,114 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.listeners.mods;
-
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.Message;
-import de.steamwar.bungeecore.sql.Mod;
-import de.steamwar.bungeecore.sql.Mod.ModType;
-import de.steamwar.bungeecore.sql.Punishment;
-import de.steamwar.bungeecore.sql.SteamwarUser;
-import de.steamwar.messages.ChatSender;
-import net.md_5.bungee.api.chat.BaseComponent;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.sql.Timestamp;
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Locale;
-import java.util.UUID;
-import java.util.function.Consumer;
-import java.util.logging.Level;
-import java.util.stream.Collectors;
-
-class Utils {
-    private Utils(){}
-
-    static VarInt readVarInt(byte[] array, int startPos) {
-        int numRead = 0;
-        int result = 0;
-        byte read;
-        do {
-            read = array[startPos + numRead];
-            int value = (read & 0b01111111);
-            result |= (value << (7 * numRead));
-
-            numRead++;
-            if (numRead > 5) {
-                break;
-            }
-        } while ((read & 0b10000000) != 0);
-
-        return new VarInt(numRead, result);
-    }
-
-    static boolean handleMods(ProxiedPlayer player, List<Mod> mods) {
-        return handleMods(player.getUniqueId(), ChatSender.of(player).getLocale(), player::disconnect, mods);
-    }
-
-    static boolean handleMods(UUID uuid, Locale locale, Consumer<BaseComponent[]> disconnect, List<Mod> mods){
-        SteamwarUser user = SteamwarUser.get(uuid);
-        boolean privileged = user.getUserGroup().privilegedMods();
-
-        ModType max = ModType.YELLOW;
-        Iterator<Mod> it = mods.iterator();
-        while(it.hasNext()){
-            Mod mod = it.next();
-            if(mod.getModType() == ModType.UNKLASSIFIED || mod.getModType() == ModType.GREEN || (mod.getModType() == ModType.YOUTUBER_ONLY && privileged))
-                it.remove();
-            else if(mod.getModType() == ModType.RED)
-                max = ModType.RED;
-        }
-
-        if(mods.isEmpty())
-            return true;
-
-        ModType finalMax = max;
-        String modList = mods.stream().filter(mod -> finalMax == ModType.YELLOW || mod.getModType() == ModType.RED).map(Mod::getModName).collect(Collectors.joining("\n"));
-        String message;
-
-        if(mods.size() == 1) {
-            message = Message.parse(max == ModType.RED ? "MOD_RED_SING" : "MOD_YELLOW_SING", locale, modList);
-        } else {
-            message = Message.parse(max == ModType.RED ? "MOD_RED_PLUR" : "MOD_YELLOW_PLUR", locale, modList);
-        }
-
-        if(max == ModType.RED) {
-            user.punish(Punishment.PunishmentType.Ban, Timestamp.from(Instant.now().plus(7, ChronoUnit.DAYS)), message, 0, false);
-            BungeeCore.log(Level.SEVERE, user.getUserName() + " " + user.getId() + " wurde automatisch wegen der Mods " + modList + " gebannt.");
-        }
-
-        disconnect.accept(TextComponent.fromLegacyText(message));
-        return false;
-    }
-
-    static class VarInt{
-        final int length;
-        final int value;
-
-        VarInt(int length, int value){
-            this.length = length;
-            this.value = value;
-        }
-    }
-}

src/de/steamwar/bungeecore/listeners/mods/WorldDownloader.java

@@ -1,33 +0,0 @@
-package de.steamwar.bungeecore.listeners.mods;
-
-import com.google.common.collect.Lists;
-import com.google.common.collect.Sets;
-import de.steamwar.bungeecore.listeners.BasicListener;
-import de.steamwar.bungeecore.sql.Mod;
-import net.md_5.bungee.api.connection.Connection;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.PluginMessageEvent;
-import net.md_5.bungee.event.EventHandler;
-
-import java.util.Collections;
-import java.util.Set;
-
-public class WorldDownloader extends BasicListener {
-
-    private static final Set<String> wdlTags = Collections.unmodifiableSet(
-            Sets.newHashSet("WDL|INIT", "wdl:init", "WDL|REQUEST", "wdl:request")
-    );
-
-    @EventHandler
-    public void onPluginMessageEvent(PluginMessageEvent event){
-        if(!wdlTags.contains(event.getTag()))
-            return;
-
-        Connection sender = event.getSender();
-        if(!(sender instanceof ProxiedPlayer))
-            return;
-
-        event.setCancelled(true);
-        Utils.handleMods((ProxiedPlayer) sender, Lists.newArrayList(Mod.get("wdl", Mod.Platform.FORGE)));
-    }
-}

src/de/steamwar/bungeecore/listeners/ping/PingListener.java

@@ -1,32 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2022  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.listeners.ping;
-
-import de.steamwar.bungeecore.listeners.BasicListener;
-import net.md_5.bungee.api.event.ProxyPingEvent;
-import net.md_5.bungee.event.EventHandler;
-
-public class PingListener extends BasicListener {
-
-    @EventHandler
-    public void onPing(ProxyPingEvent event) {
-        event.setResponse(new SteamWarServerPing(event.getResponse(), event.getConnection().getVersion()));
-    }
-}

src/de/steamwar/bungeecore/listeners/ping/SteamWarServerPing.java

@@ -1,90 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2022  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.listeners.ping;
-
-import net.md_5.bungee.api.ServerPing;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-
-public class SteamWarServerPing extends ServerPing {
-
-    private final boolean preventsChatReports = true;
-    private final ForgeData forgeData;
-
-    public SteamWarServerPing(ServerPing existing, int version) {
-        super(existing.getVersion(), existing.getPlayers(), existing.getDescriptionComponent(), existing.getFaviconObject());
-        forgeData = new ForgeData(version);
-    }
-
-    private static class ForgeData {
-        private final List<ForgeChannel> channels = new ArrayList<>();
-        private final List<ForgeMod>     mods     = new ArrayList<>();
-        private final int fmlNetworkVersion = 2;
-
-        public ForgeData(int versionNumber) {
-            channels.add(new ForgeChannel("minecraft:unregister"));
-            channels.add(new ForgeChannel("minecraft:register"));
-            channels.add(new ForgeChannel("fml:handshake"));
-            mods.add(new ForgeMod("minecraft", ProtocolVersion.getVersion(versionNumber)));
-            mods.add(new ForgeMod("forge", "ANY"));
-        }
-
-        public final static class ProtocolVersion {
-
-            private static final HashMap<Integer, String> versions;
-
-            static {
-                versions = new HashMap();
-                versions.put(757, "1.18");
-                versions.put(756, "1.17.1");
-                versions.put(754, "1.16.5");
-                versions.put(578, "1.15.2");
-                versions.put(498, "1.14.1");
-                versions.put(393, "1.13");
-            }
-
-            public static String getVersion(int version) {
-                return versions.get(version);
-            }
-        }
-
-        private static class ForgeChannel {
-            private final String res;
-            private final String version = "FML2";
-            private final boolean required = true;
-
-            private ForgeChannel(String res) {
-                this.res = res;
-            }
-        }
-
-        private static class ForgeMod {
-            private final String modId;
-            private final String modmarker;
-
-            private ForgeMod(String modId, String modmarker) {
-                this.modId = modId;
-                this.modmarker = modmarker;
-            }
-        }
-    }
-}

src/de/steamwar/bungeecore/network/BungeeNetworkHandler.java

@@ -1,35 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2022  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.network;
-
-import de.steamwar.bungeecore.network.handlers.*;
-import lombok.experimental.UtilityClass;
-
-@UtilityClass
-public class BungeeNetworkHandler {
-    public static void register() {
-        new ExecuteCommandHandler().register();
-        new FightEndsHandler().register();
-        new FightInfoHandler().register();
-        new ImALobbyHandler().register();
-        new InventoryCallbackHandler().register();
-        new PrepareSchemHandler().register();
-    }
-}

src/de/steamwar/bungeecore/network/NetworkReceiver.java

@@ -1,58 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2022  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.network;
-
-import de.steamwar.bungeecore.BungeeCore;
-import de.steamwar.bungeecore.commands.TeamCommand;
-import de.steamwar.bungeecore.listeners.BasicListener;
-import de.steamwar.bungeecore.sql.SWException;
-import de.steamwar.network.packets.NetworkPacket;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.connection.Server;
-import net.md_5.bungee.api.event.PluginMessageEvent;
-import net.md_5.bungee.event.EventHandler;
-import net.md_5.bungee.event.EventPriority;
-
-import java.net.InetSocketAddress;
-import java.util.Arrays;
-import java.util.Base64;
-import java.util.List;
-
-public class NetworkReceiver extends BasicListener {
-
-    private static final List<String> blockedTags = Arrays.asList("bungeecord:main", "BungeeCord", "sw:bridge");
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onPluginMessage(PluginMessageEvent event) {
-        if (blockedTags.contains(event.getTag()) && !TeamCommand.isLocalhost(((InetSocketAddress) event.getSender().getSocketAddress()).getAddress())) {
-            SWException.log("Bungee", ((InetSocketAddress) event.getSender().getSocketAddress()).getHostString() + " tried to send a plugin message with tag " + event.getTag(), Base64.getEncoder().encodeToString(event.getData()));
-            event.setCancelled(true);
-            return;
-        }
-        if(!event.getTag().equals("sw:bridge"))
-            return;
-
-        event.setCancelled(true);
-        if(!(event.getSender() instanceof Server))
-            return;
-
-        ProxyServer.getInstance().getScheduler().runAsync(BungeeCore.get(), () -> NetworkPacket.handle(new ServerMetaInfo(((Server) event.getSender()).getInfo()), event.getData()));
-    }
-}

src/de/steamwar/bungeecore/network/handlers/FightEndsHandler.java

@@ -1,155 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  SteamWar.de-Serverteam
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bungeecore.network.handlers;
-
-import de.steamwar.bungeecore.ArenaMode;
-import de.steamwar.bungeecore.sql.*;
-import de.steamwar.network.packets.PacketHandler;
-import de.steamwar.network.packets.common.FightEndsPacket;
-import lombok.RequiredArgsConstructor;
-
-import java.util.*;
-import java.util.stream.Collectors;
-
-public class FightEndsHandler extends PacketHandler {
-
-    private Map<String, LinkedList<Game>> gameModeGames = new HashMap<>();
-
-    private int K = 20;
-
-    private long defaultFightRange = 1000 /* Milliseconds */ * 60 /* Seconds */ * 15L /* Minutes */;
-    private Map<String, Long> fightRanges = new HashMap<>();
-    private long defaultFightCount = 1;
-    private Map<String, Long> fightCounts = new HashMap<>();
-
-    {
-        fightRanges.put("miniwargear", 1000 /* Milliseconds */ * 60 /* Seconds */ * 30L /* Minutes */);
-        fightCounts.put("miniwargear", 3L);
-    }
-
-    @Handler
-    public void handle(FightEndsPacket fightEndsPacket) {
-        if (!ArenaMode.getBySchemType(SchematicType.fromDB(fightEndsPacket.getGameMode())).isRanked()) {
-            return;
-        }
-
-        int bluePlayerSize = fightEndsPacket.getBluePlayers().size();
-        int redPlayerSize = fightEndsPacket.getRedPlayers().size();
-        double playerRatio = bluePlayerSize > redPlayerSize ? (double) redPlayerSize / bluePlayerSize : (double) bluePlayerSize / redPlayerSize;
-        if (playerRatio < 0.6) {
-            return;
-        }
-
-        boolean bluePublic = SchematicNode.getSchematicNode(fightEndsPacket.getBlueSchem()).getOwner() == 0;
-        boolean redPublic = SchematicNode.getSchematicNode(fightEndsPacket.getRedSchem()).getOwner() == 0;
-
-        if (bluePublic ^ redPublic) {
-            return;
-        }
-
-        double blueResult;
-        if (fightEndsPacket.getWin() == 0) {
-            blueResult = 0.5;
-        } else if (fightEndsPacket.getWin() == 1) {
-            blueResult = 1;
-        } else {
-            blueResult = 0;
-        }
-
-        // Die nächsten Zeilen filtern ein Fight innerhalb eines Teams nicht gewertet wird, bzw auch wenn nur Teile beider Teams im
-        // gleichen Team sind dieser ungewertet ist.
-        Set<Integer> teamsIds = fightEndsPacket.getBluePlayers().stream().map(SteamwarUser::get).map(SteamwarUser::getTeam).collect(Collectors.toSet());
-        for (int redPlayer : fightEndsPacket.getRedPlayers()) {
-            if (teamsIds.contains(SteamwarUser.get(redPlayer).getTeam())) {
-                return;
-            }
-        }
-
-        try {
-            if (teamComboExistedAlready(fightEndsPacket.getBluePlayers(), fightEndsPacket.getRedPlayers(), fightEndsPacket.getGameMode())) {
-                return;
-            }
-        } finally {
-            gameModeGames.computeIfAbsent(fightEndsPacket.getGameMode(), s -> new LinkedList<>()).add(new Game(fightEndsPacket.getBluePlayers(), fightEndsPacket.getRedPlayers()));
-        }
-
-        int blueSchemElo = SchemElo.getElo(fightEndsPacket.getBlueSchem());
-        int redSchemElo = SchemElo.getElo(fightEndsPacket.getRedSchem());
-
-        int blueTeamElo = fightEndsPacket.getBluePlayers().stream().mapToInt(player -> UserElo.getEloOrDefault(player, fightEndsPacket.getGameMode())).sum();
-        int redTeamElo = fightEndsPacket.getRedPlayers().stream().mapToInt(player -> UserElo.getEloOrDefault(player, fightEndsPacket.getGameMode())).sum();
-
-        calculateEloOfTeam(fightEndsPacket.getBlueSchem(), blueSchemElo, redSchemElo, blueTeamElo, redTeamElo, blueResult, fightEndsPacket.getBluePlayers(), fightEndsPacket.getGameMode(), bluePublic || redPublic);
-        calculateEloOfTeam(fightEndsPacket.getRedSchem(), redSchemElo, blueSchemElo, redTeamElo, blueTeamElo, 1 - blueResult, fightEndsPacket.getRedPlayers(), fightEndsPacket.getGameMode(), bluePublic || redPublic);
-    }
-
-    private void calculateEloOfTeam(int schemId, int eloSchemOwn, int eloSchemEnemy, int eloTeamOwn, int eloTeamEnemy, double result, List<Integer> players, String gameMode, boolean noPlayerRank) {
-        double winSchemExpectation = calsWinExpectation(eloSchemOwn, eloSchemEnemy);
-        SchemElo.setElo(schemId, (int) Math.round(eloSchemOwn + K * (result - winSchemExpectation)));
-
-        if (noPlayerRank) return;
-        double winTeamExpectation = calsWinExpectation(eloTeamOwn, eloTeamEnemy);
-        for (int player : players) {
-            int playerElo = UserElo.getEloOrDefault(player, gameMode);
-            int fights = UserElo.getFightsOfSeason(player, gameMode);
-            UserElo.setElo(player, gameMode, (int) Math.round(playerElo + getK(fights) * (result - winTeamExpectation)));
-        }
-    }
-
-    private double calsWinExpectation(int eloOwn, int eloEnemy) {
-        return 1 / (1 + Math.pow(10, (eloEnemy - eloOwn) / 600f));
-    }
-
-    private double getK(int fights) {
-        return K * Math.max(1.3 - (fights / 200.0), 0.8);
-    }
-
-    private boolean teamComboExistedAlready(List<Integer> bluePlayers, List<Integer> redPlayers, String gameMode) {
-        if (!gameModeGames.containsKey(gameMode)) {
-            return false;
-        }
-        LinkedList<Game> games = gameModeGames.get(gameMode);
-        long lifetime = fightRanges.getOrDefault(gameMode, defaultFightRange);
-        while (!games.isEmpty()) {
-            Game game = games.getFirst();
-            if (game.livedMillis() > lifetime) {
-                games.removeFirst();
-            } else {
-                break;
-            }
-        }
-        return games.stream().filter(game -> game.isSame(bluePlayers, redPlayers)).count() > fightCounts.getOrDefault(gameMode, defaultFightCount);
-    }
-
-    @RequiredArgsConstructor
-    private static class Game {
-        private long time = System.currentTimeMillis();
-        private final List<Integer> bluePlayers;
-        private final List<Integer> redPlayers;
-
-        public long livedMillis() {
-            return System.currentTimeMillis() - time;
-        }
-
-        public boolean isSame(List<Integer> bluePlayers, List<Integer> redPlayers) {
-            return bluePlayers.containsAll(this.bluePlayers) && redPlayers.containsAll(this.redPlayers);
-        }
-    }
-}

src/de/steamwar/bungeecore/network/handlers/FightInfoHandler.java

@@ -1,66 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.network.handlers;
-
-import de.steamwar.bungeecore.network.NetworkSender;
-import de.steamwar.bungeecore.network.ServerMetaInfo;
-import de.steamwar.bungeecore.tablist.TablistManager;
-import de.steamwar.network.packets.PacketHandler;
-import de.steamwar.network.packets.common.FightInfoPacket;
-import net.md_5.bungee.api.config.ServerInfo;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
-
-public class FightInfoHandler extends PacketHandler {
-
-    private static final Set<ServerInfo> lobbys = new HashSet<>();
-
-    public static void addLobby(ServerInfo lobby) {
-        lobbys.add(lobby);
-    }
-
-    public static boolean onLobby(ProxiedPlayer player) {
-        return lobbys.contains(player.getServer().getInfo());
-    }
-
-    @Handler
-    public void handle(FightInfoPacket packet) {
-        ServerInfo info = ((ServerMetaInfo) packet.getMetaInfos()).getSender();
-
-        FightInfoPacket lobbyPacket = packet.withServerName(info.getName());
-
-        TablistManager.newFightInfo(info, packet);
-
-        Iterator<ServerInfo> lobbyIt = lobbys.iterator();
-        while(lobbyIt.hasNext()) {
-            ServerInfo lobby = lobbyIt.next();
-            Iterator<ProxiedPlayer> it = lobby.getPlayers().iterator();
-            if(!it.hasNext()){
-                lobbyIt.remove();
-                continue;
-            }
-
-            NetworkSender.send(lobby, lobbyPacket);
-        }
-    }
-}

src/de/steamwar/bungeecore/sql/BannedUserIPs.java

@@ -1,75 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.sql;
-
-import java.sql.Timestamp;
-import java.util.ArrayList;
-import java.util.List;
-
-public class BannedUserIPs {
-
-    private static final Statement getByID = new Statement("SELECT * FROM BannedUserIPs WHERE UserID = ? ORDER BY Timestamp ASC");
-    private static final Statement getByIP = new Statement("SELECT * FROM BannedUserIPs WHERE IP = ? ORDER BY Timestamp DESC");
-    private static final Statement banIP = new Statement("INSERT INTO BannedUserIPs (UserID, Timestamp, IP) VALUES (?, NOW(), ?) ON DUPLICATE KEY UPDATE Timestamp=NOW()");
-
-    private final int userID;
-    private final Timestamp timestamp;
-
-    private BannedUserIPs(int userID, Timestamp timestamp){
-        this.userID = userID;
-        this.timestamp = timestamp;
-    }
-
-    public static List<BannedUserIPs> get(int userID){
-        return getByID.select(rs -> {
-            List<BannedUserIPs> userIPs = new ArrayList<>();
-            while(rs.next()) {
-                userIPs.add(new BannedUserIPs(
-                        userID,
-                        rs.getTimestamp("Timestamp")));
-            }
-            return userIPs;
-        }, userID);
-    }
-
-    public static List<BannedUserIPs> get(String ip){
-        return getByIP.select(rs -> {
-            List<BannedUserIPs> userIDs = new ArrayList<>();
-            while(rs.next()) {
-                userIDs.add(new BannedUserIPs(
-                        rs.getInt("UserID"),
-                        rs.getTimestamp("Timestamp")));
-            }
-            return userIDs;
-        }, ip);
-    }
-
-    static void banIP(SteamwarUser user, String ip){
-        banIP.update(user.getId(), ip);
-    }
-
-    public int getUserID() {
-        return userID;
-    }
-
-    public java.sql.Timestamp getTimestamp() {
-        return timestamp;
-    }
-}

src/de/steamwar/bungeecore/sql/BauLock.java

@@ -1,52 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.sql;
-
-import de.steamwar.bungeecore.Message;
-import lombok.experimental.UtilityClass;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-
-@UtilityClass
-public class BauLock {
-
-    private static final String BAU_LOCK_CONFIG_NAME = "baulockstate";
-    public static void setLocked(ProxiedPlayer p, BauLockState state) {
-        SteamwarUser owner = SteamwarUser.get(p.getUniqueId());
-        UserConfig.updateUserConfig(owner.getId(), BAU_LOCK_CONFIG_NAME, state == BauLockState.OPEN ? null : state.name());
-        Message.send("BAU_LOCKED_" + state.name(), owner.getPlayer());
-    }
-
-    public static boolean isLocked(SteamwarUser owner, SteamwarUser target) {
-        if (owner.getId() == target.getId())
-            return false;
-
-        String state = UserConfig.getConfig(owner.getId(), BAU_LOCK_CONFIG_NAME);
-        switch (state == null ? BauLockState.OPEN : BauLockState.valueOf(state)) {
-            case NOBODY:
-                return true;
-            case TEAM:
-                return owner.getTeam() != target.getTeam();
-            case OPEN:
-            default:
-                return false;
-        }
-    }
-
-}

src/de/steamwar/bungeecore/sql/BauLockState.java

@@ -1,27 +0,0 @@
-/*
-    This file is a part of the SteamWar software.
-
-    Copyright (C) 2022  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.sql;
-
-public enum BauLockState {
-
-    NOBODY, // Locks the build server for all users
-    TEAM, //opens the build server only for every added user which is in the same team as the buildOwner
-    OPEN  //unlocks the build server for all users
-}

src/de/steamwar/bungeecore/sql/BauweltMember.java

@@ -1,116 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.sql;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.UUID;
-
-public class BauweltMember{
-
-    private static final Statement delete = new Statement("DELETE FROM BauweltMember WHERE BauweltID = ? AND MemberID = ?");
-    private static final Statement update = new Statement("INSERT INTO BauweltMember (BauweltID, MemberID, WorldEdit, World) VALUES (?, ?, ?, ?) ON DUPLICATE KEY UPDATE WorldEdit = VALUES(WorldEdit), World = VALUES(World)");
-    private static final Statement getMember = new Statement("SELECT * FROM BauweltMember WHERE BauweltID = ? AND MemberID = ?");
-    private static final Statement getMembers = new Statement("SELECT * FROM BauweltMember WHERE BauweltID = ?");
-
-    private final int bauweltID;
-    private final int memberID;
-    private boolean worldEdit;
-    private boolean world;
-
-
-    private BauweltMember(int ownerID, int memberID, boolean worldEdit, boolean world, boolean updateDB){
-        bauweltID = ownerID;
-        this.memberID = memberID;
-        this.worldEdit = worldEdit;
-        this.world = world;
-        if(updateDB)
-            updateDB();
-    }
-
-    public BauweltMember(int ownerID, int memberID, boolean worldEdit, boolean world){
-        this(ownerID, memberID, worldEdit, world, true);
-    }
-
-    public BauweltMember(UUID ownerID, UUID memberID, boolean worldEdit, boolean world){
-        this(SteamwarUser.get(ownerID).getId(), SteamwarUser.get(memberID).getId(), worldEdit, world);
-    }
-
-    public void remove(){
-        delete.update(bauweltID, memberID);
-    }
-
-    private void updateDB(){
-        update.update(bauweltID, memberID, worldEdit, world);
-    }
-
-    public static BauweltMember getBauMember(UUID ownerID, UUID memberID){
-        return getBauMember(SteamwarUser.get(ownerID).getId(), SteamwarUser.get(memberID).getId());
-    }
-
-    public static BauweltMember getBauMember(int ownerID, int memberID){
-        return getMember.select(rs -> {
-            if(!rs.next())
-                return null;
-
-            return new BauweltMember(ownerID, memberID, rs.getBoolean("WorldEdit"), rs.getBoolean("World"), false);
-        }, ownerID, memberID);
-    }
-
-    public static List<BauweltMember> getMembers(UUID bauweltID){
-        return getMembers(SteamwarUser.get(bauweltID).getId());
-    }
-
-    public static List<BauweltMember> getMembers(int bauweltID){
-        return getMembers.select(rs -> {
-            List<BauweltMember> members = new ArrayList<>();
-            while(rs.next()){
-                members.add(new BauweltMember(bauweltID, rs.getInt("MemberID"), rs.getBoolean("WorldEdit"), rs.getBoolean("World"), false));
-            }
-            return members;
-        }, bauweltID);
-    }
-
-    public int getBauweltID() {
-        return bauweltID;
-    }
-
-    public int getMemberID() {
-        return memberID;
-    }
-
-    public boolean isWorldEdit() {
-        return worldEdit;
-    }
-
-    public void setWorldEdit(boolean worldEdit) {
-        this.worldEdit = worldEdit;
-        updateDB();
-    }
-
-    public boolean isWorld() {
-        return world;
-    }
-
-    public void setWorld(boolean world) {
-        this.world = world;
-        updateDB();
-    }
-}

src/de/steamwar/bungeecore/sql/CheckedSchematic.java

@@ -1,120 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.sql;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Timestamp;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.UUID;
-
-public class CheckedSchematic {
-
-    private static final Statement checkHistory = new Statement("SELECT * FROM CheckedSchematic WHERE NodeId IN (SELECT NodeId FROM SchematicNode WHERE NodeOwner = ?) AND DeclineReason != '' AND DeclineReason != 'Prüfvorgang abgebrochen' AND NodeId is not NULL ORDER BY EndTime DESC");
-    private static final Statement nodeHistory = new Statement("SELECT * FROM CheckedSchematic WHERE NodeId = ? AND DeclineReason != '' AND DeclineReason != 'Prüfvorgang abgebrochen' ORDER BY EndTime DESC");
-    private static final Statement insert = new Statement("INSERT INTO CheckedSchematic (NodeId, NodeName, NodeOwner, Validator, StartTime, EndTime, DeclineReason) VALUES (?, ?, ?, ?, ?, ?, ?)");
-
-    private final Integer node;
-    private final int validator;
-    private final Timestamp startTime;
-    private final Timestamp endTime;
-    private final String declineReason;
-
-    private CheckedSchematic(ResultSet rs) throws SQLException {
-        this.node = rs.getInt("NodeId");
-        this.validator = rs.getInt("Validator");
-        this.startTime = rs.getTimestamp("StartTime");
-        this.endTime = rs.getTimestamp("EndTime");
-        this.declineReason = rs.getString("DeclineReason");
-    }
-
-    public static void create(int nodeId, String name, int owner, int validator, Timestamp startTime, Timestamp endTime, String reason){
-        insert.update(nodeId, name, owner, validator, startTime, endTime, reason);
-    }
-
-    public static void create(SchematicNode node, int validator, Timestamp startTime, Timestamp endTime, String reason){
-        create(node.getId(), node.getName(), node.getOwner(), validator, startTime, endTime, reason);
-    }
-
-    public static List<CheckedSchematic> previousChecks(SchematicNode node){
-        return nodeHistory.select(rs -> {
-            List<CheckedSchematic> schematics = new ArrayList<>();
-            while(rs.next())
-                schematics.add(new CheckedSchematic(rs));
-            return schematics;
-        }, node.getId());
-    }
-
-    public static List<CheckedSchematic> getLastDeclinedOfNode(SchematicNode node){
-        return getLastDeclinedOfNode(node.getId());
-    }
-
-    public static List<CheckedSchematic> getLastDeclinedOfNode(int node){
-        return nodeHistory.select(rs -> {
-            List<CheckedSchematic> lastDeclined = new ArrayList<>();
-            while(rs.next()){
-                lastDeclined.add(new CheckedSchematic(rs));
-            }
-            return lastDeclined;
-        }, node);
-    }
-
-    public static List<CheckedSchematic> getLastDeclined(UUID uuid){
-        return getLastDelined(SteamwarUser.get(uuid).getId());
-    }
-
-    public static List<CheckedSchematic> getLastDelined(int schemOwner){
-        return checkHistory.select(rs -> {
-            List<CheckedSchematic> history = new ArrayList<>();
-            while(rs.next())
-                history.add(new CheckedSchematic(rs));
-            return history;
-        }, schemOwner);
-    }
-
-    public int getValidator() {
-        return validator;
-    }
-
-    public Timestamp getStartTime() {
-        return startTime;
-    }
-
-    public Timestamp getEndTime() {
-        return endTime;
-    }
-
-    public String getDeclineReason() {
-        return declineReason;
-    }
-
-    public int getNode() {
-        return node;
-    }
-
-    public String getSchemName() {
-        return SchematicNode.getSchematicNode(node).getName();
-    }
-
-    public int getSchemOwner() {
-        return SchematicNode.getSchematicNode(node).getId();
-    }
-}

src/de/steamwar/bungeecore/sql/Event.java

@@ -1,131 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.sql;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Timestamp;
-import java.time.Instant;
-import java.util.ArrayList;
-import java.util.List;
-
-public class Event {
-
-    private static final Statement byCurrent = new Statement("SELECT * FROM Event WHERE Start < now() AND End > now()");
-    private static final Statement byId = new Statement("SELECT * FROM Event WHERE EventID = ?");
-    private static final Statement byName = new Statement("SELECT * FROM Event WHERE lower(EventName) = ?");
-    private static final Statement byComing = new Statement("SELECT * FROM Event WHERE Start > now()");
-
-    private final int eventID;
-    private final String eventName;
-    private final Timestamp start;
-    private final Timestamp end;
-    private final int maximumTeamMembers;
-    private final boolean publicSchemsOnly;
-    private final boolean spectateSystem;
-    private final Timestamp deadline;
-    private final String schemType;
-
-    private static Event current = null;
-
-    private Event(ResultSet rs) throws SQLException{
-        this.eventID = rs.getInt("EventID");
-        this.eventName = rs.getString("EventName");
-        this.start = rs.getTimestamp("Start");
-        this.end = rs.getTimestamp("End");
-        this.maximumTeamMembers = rs.getInt("MaximumTeamMembers");
-        this.publicSchemsOnly = rs.getBoolean("PublicSchemsOnly");
-        this.spectateSystem = rs.getBoolean("SpectateSystem");
-        this.deadline = rs.getTimestamp("Deadline");
-        this.schemType = rs.getString("SchemType");
-    }
-
-    public static Event get(){
-        if(current != null && current.now())
-            return current;
-
-        return byCurrent.select(rs -> {
-            if(rs.next())
-                current = new Event(rs);
-            else
-                current = null;
-            return current;
-        });
-    }
-
-    public static Event get(int eventID){
-        return byId.select(rs -> {
-            if(!rs.next())
-                throw new SQLException("Couldn't find event " + eventID);
-            return new Event(rs);
-        }, eventID);
-    }
-
-    public static Event get(String eventName){
-        return byName.select(rs -> {
-            if(!rs.next())
-                return null;
-
-            return new Event(rs);
-        }, eventName.toLowerCase());
-    }
-
-    public static List<Event> getComing(){
-        return byComing.select(rs -> {
-            List<Event> events = new ArrayList<>();
-            while(rs.next())
-                events.add(new Event(rs));
-            return events;
-        });
-    }
-
-    private boolean now(){
-        Instant now = Instant.now();
-        return now.isAfter(start.toInstant()) && now.isBefore(end.toInstant());
-    }
-
-    public int getEventID() {
-        return eventID;
-    }
-    public String getEventName() {
-        return eventName;
-    }
-    public Timestamp getStart() {
-        return start;
-    }
-    public Timestamp getEnd() {
-        return end;
-    }
-    public int getMaximumTeamMembers() {
-        return maximumTeamMembers;
-    }
-    public boolean publicSchemsOnly() {
-        return publicSchemsOnly;
-    }
-    public boolean spectateSystem(){
-        return spectateSystem;
-    }
-    public Timestamp getDeadline() {
-        return deadline;
-    }
-    public String getSchemType() {
-        return schemType;
-    }
-}

src/de/steamwar/bungeecore/sql/EventFight.java

@@ -1,149 +0,0 @@
-/* 
-    This file is a part of the SteamWar software.
-    
-    Copyright (C) 2020  SteamWar.de-Serverteam
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package de.steamwar.bungeecore.sql;
-
-import de.steamwar.bungeecore.ArenaMode;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Timestamp;
-import java.util.*;
-
-import static java.time.temporal.ChronoUnit.SECONDS;
-
-public class EventFight implements Comparable<EventFight> {
-
-    private static final Statement reschedule = new Statement("UPDATE EventFight SET StartTime = ? WHERE EventID = ? AND FightID = ?");
-    private static final Statement allComing = new Statement("SELECT * FROM EventFight WHERE StartTime > now() ORDER BY `StartTime` ASC");
-    private static final Statement event = new Statement("SELECT * FROM EventFight WHERE EventID = ? ORDER BY `StartTime` ASC");
-
-    private static final Queue<EventFight> fights = new PriorityQueue<>();
-
-    private final int eventID;
-    private final int fightID;
-    private Timestamp startTime;
-    private final ArenaMode spielmodus;
-    private final String map;
-    private final int teamBlue;
-    private final int teamRed;
-    private final int kampfleiter;
-    private final int ergebnis;
-    private final int fight;
-
-    private EventFight(ResultSet rs) throws SQLException {
-        eventID = rs.getInt("EventID");
-        fightID = rs.getInt("FightID");
-        startTime = rs.getTimestamp("StartTime");
-        spielmodus = ArenaMode.getByInternal(rs.getString("Spielmodus"));
-        map = rs.getString("Map");
-        teamBlue = rs.getInt("TeamBlue");
-        teamRed = rs.getInt("TeamRed");
-        kampfleiter = rs.getInt("Kampfleiter");
-        ergebnis = rs.getInt("Ergebnis");
-        fight = rs.getInt("Fight");
-    }
-
-    public void reschedule(){
-        startTime = Timestamp.from(new Date().toInstant().plus(30, SECONDS));
-        reschedule.update(startTime, eventID, fightID);
-    }
-
-    public static void loadAllComingFights(){
-        allComing.select(rs -> {
-            fights.clear();
-            while(rs.next()){
-                fights.add(new EventFight(rs));
-            }
-            return null;
-        });
-    }
-
-    public static List<EventFight> getEvent(int eventID){
-        return event.select(rs -> {
-            List<EventFight> fights = new LinkedList<>();
-            while(rs.next())
-                fights.add(new EventFight(rs));
-            return fights;
-        }, eventID);
-    }
-
-    public static Queue<EventFight> getFights() {
-        return fights;
-    }
-
-    public Timestamp getStartTime() {
-        return startTime;
-    }
-
-    public ArenaMode getSpielmodus() {
-        return spielmodus;
-    }
-
-    public String getMap() {
-        return map;
-    }
-
-    public int getTeamBlue() {
-        return teamBlue;
-    }
-
-    public int getTeamRed() {
-        return teamRed;
-    }
-
-    public int getEventID() {
-        return eventID;
-    }
-
-    public int getFightID() {
-        return fightID;
-    }
-
-    public int getKampfleiter() {
-        return kampfleiter;
-    }
-
-    public int getErgebnis() {
-        return ergebnis;
-    }
-
-    public boolean hasFinished() {
-        return fight != 0;
-    }
-
-    @Override
-    public int hashCode(){
-        return fightID;
-    }
-
-    @Override
-    public boolean equals(Object o){
-        if(o == null)
-            return false;
-        if(!(o instanceof EventFight))
-            return false;
-        return fightID == ((EventFight) o).fightID;
-    }
-
-    @Override
-    public int compareTo(EventFight o) {
-        return startTime.compareTo(o.startTime);
-    }
-}

src/de/steamwar/bungeecore/sql/Fight.java

@@ -1,123 +0,0 @@
-package de.steamwar.bungeecore.sql;
-
-import de.steamwar.bungeecore.ArenaMode;
-
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Timestamp;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-
-public class Fight {
-
-    private static final Statement getPage = new Statement("SELECT f.FightID, f.GameMode, f.Server, f.StartTime, f.BlueLeader, f.RedLeader, (b.NodeId IS NULL OR b.AllowReplay) AND (r.NodeId IS NULL OR r.AllowReplay) AS ReplayAllowed, f.Win, (SELECT COUNT(1) FROM Replay WHERE Replay.FightID = f.FightID) as ReplayAvailable FROM Fight f LEFT OUTER JOIN SchematicNode b ON f.BlueSchem = b.NodeId LEFT OUTER JOIN SchematicNode r ON f.RedSchem = r.NodeId ORDER BY FightID DESC LIMIT ?, ?");
-
-    private final int fightID;
-    private final String gameMode;
-    private final String server;
-    private final Timestamp startTime;
-
-    private final int blueLeader;
-    private final int redLeader;
-    private final int win;
-
-    private final boolean replayAllowed;
-    private final boolean replayAvailable;
-
-    private final List<FightPlayer> bluePlayers = new ArrayList<>();
-    private final List<FightPlayer> redPlayers = new ArrayList<>();
-
-    private Fight(ResultSet rs) throws SQLException {
-        fightID = rs.getInt("FightID");
-        gameMode = rs.getString("GameMode");
-        server = rs.getString("Server");
-        startTime = rs.getTimestamp("StartTime");
-        blueLeader = rs.getInt("BlueLeader");
-        redLeader = rs.getInt("RedLeader");
-        replayAllowed = rs.getBoolean("ReplayAllowed");
-        replayAvailable = rs.getBoolean("ReplayAvailable");
-        win = rs.getInt("Win");
-    }
-
-    private void initPlayers(List<FightPlayer> fightPlayers) {
-        for(FightPlayer fp : fightPlayers) {
-            if(fp.getFightID() != fightID)
-                continue;
-
-            if(fp.getTeam() == 1)
-                bluePlayers.add(fp);
-            else
-                redPlayers.add(fp);
-        }
-    }
-
-    public static List<Fight> getPage(int page, int elementsPerPage) {
-        List<Fight> fights = getPage.select(rs -> {
-            List<Fight> f = new ArrayList<>();
-            while(rs.next()){
-                f.add(new Fight(rs));
-            }
-            return f;
-        }, page * elementsPerPage, elementsPerPage);
-
-        List<FightPlayer> fightPlayers = FightPlayer.batchGet(fights.stream().map(f -> f.fightID).collect(Collectors.toSet()));
-        for(Fight fight : fights) {
-            fight.initPlayers(fightPlayers);
-        }
-
-        SteamwarUser.batchCache(fightPlayers.stream().map(FightPlayer::getUserID).collect(Collectors.toSet()));
-        return fights;
-    }
-
-    public SchematicType getSchemType() {
-        return SchematicType.fromDB(gameMode);
-    }
-
-    public ArenaMode getGameMode() {
-        SchematicType schemType = getSchemType();
-        if(schemType == null)
-            return null;
-        return ArenaMode.getBySchemType(schemType);
-    }
-
-    public int getFightID() {
-        return fightID;
-    }
-
-    public Timestamp getStartTime() {
-        return startTime;
-    }
-
-    public SteamwarUser getBlueLeader() {
-        return SteamwarUser.get(blueLeader);
-    }
-
-    public SteamwarUser getRedLeader() {
-        return SteamwarUser.get(redLeader);
-    }
-
-    public int getWin() {
-        return win;
-    }
-
-    public String getServer() {
-        return server;
-    }
-
-    public List<FightPlayer> getBluePlayers() {
-        return bluePlayers;
-    }
-
-    public List<FightPlayer> getRedPlayers() {
-        return redPlayers;
-    }
-
-    public boolean replayAllowed() {
-        return replayExists() && replayAllowed;
-    }
-
-    public boolean replayExists() {
-        return getGameMode() != null && replayAvailable;
-    }
-}