Add BauSystem module

Fix ci java version Fix LinkageProcessor
2024-08-05 13:28:50 +02:00
parent 41d31e6c9c
commit 3366a30b0c
526 changed files with 43550 additions and 149479 deletions
@@ -0,0 +1,182 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * 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.
+ *
+ * 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.bausystem;
+
+import com.comphenix.tinyprotocol.TinyProtocol;
+import de.steamwar.bausystem.configplayer.Config;
+import de.steamwar.bausystem.features.tpslimit.TPSFreezeUtils;
+import de.steamwar.bausystem.linkage.LinkageUtils;
+import de.steamwar.bausystem.region.loader.PrototypeLoader;
+import de.steamwar.bausystem.region.loader.RegionLoader;
+import de.steamwar.bausystem.region.loader.Updater;
+import de.steamwar.bausystem.utils.TickListener;
+import de.steamwar.bausystem.worlddata.WorldData;
+import de.steamwar.command.AbstractValidator;
+import de.steamwar.command.SWCommandUtils;
+import de.steamwar.message.Message;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+import java.util.logging.Level;
+
+public class BauSystem extends JavaPlugin implements Listener {
+
+    // This should be treated as final!
+    public static Message MESSAGE;
+    public static final boolean DEV_SERVER = !System.getProperty("user.home").endsWith("minecraft");
+
+    @Getter
+    private static BauSystem instance;
+
+    @Override
+    public void onEnable() {
+        // LOGGER
+        fixLogging();
+
+        MESSAGE = new Message("BauSystem", getClassLoader());
+
+        instance = this;
+        SWUtils.setBausystem(instance);
+
+        try {
+            PrototypeLoader.load();
+            RegionLoader.load();
+        } catch (SecurityException e) {
+            Bukkit.getLogger().log(Level.SEVERE, e.getMessage(), e);
+            Bukkit.shutdown();
+            System.exit(1);
+            return;
+        }
+
+        new Updater(PrototypeLoader.file, PrototypeLoader::load);
+        new Updater(RegionLoader.file, RegionLoader::load);
+
+        SWCommandUtils.addValidator(Player.class, validator(Permission.BUILD));
+        SWCommandUtils.addValidator(CommandSender.class, validator(Permission.BUILD));
+        SWCommandUtils.addValidator("supervisor", validator(Permission.SUPERVISOR));
+        SWCommandUtils.addValidator("owner", validator(Permission.OWNER));
+
+        try {
+            LinkageUtils.link();
+        } catch (Exception e) {
+            Bukkit.getLogger().log(Level.SEVERE, e.getMessage(), e);
+            Bukkit.shutdown();
+            System.exit(1);
+            return;
+        }
+        TickListener.impl.init();
+    }
+
+    private <T extends CommandSender> AbstractValidator<T, ?> validator(Permission permission) {
+        return (commandSender, object, messageSender) -> {
+            if (commandSender instanceof Player) {
+                if (permission.hasPermission((Player) commandSender)) {
+                    return true;
+                }
+                messageSender.send("NO_PERMISSION");
+                return false;
+            }
+            return true;
+        };
+    }
+
+    @Override
+    public void onDisable() {
+        LinkageUtils.unlink();
+
+        WorldData.write();
+        Config.getInstance().saveAll();
+        TinyProtocol.instance.close();
+    }
+
+    private void fixLogging() {
+        System.setErr(new PrintStream(new OutputStream() {
+            private StringBuilder current = new StringBuilder();
+
+            @Override
+            public void write(int b) throws IOException {
+                if (b == '\n') {
+                    String logging = current.toString();
+                    if (logging.contains("SLF4J")) {
+                        Bukkit.getLogger().info(logging);
+                    } else {
+                        Bukkit.getLogger().warning(logging);
+                    }
+                    current = new StringBuilder();
+                } else {
+                    current.append((char) b);
+                }
+            }
+        }));
+    }
+
+    public static BukkitTask runTaskLater(Plugin plugin, Runnable runnable, long delay) {
+        return new BukkitRunnable() {
+            private int counter = 1;
+
+            @Override
+            public void run() {
+                if (TPSFreezeUtils.isFrozen()) return;
+                if (counter >= delay) {
+                    runnable.run();
+                    cancel();
+                    return;
+                }
+                counter++;
+            }
+        }.runTaskTimer(plugin, 0, 1);
+    }
+
+    public static BukkitTask runTaskTimer(Plugin plugin, Runnable runnable, long delay, long period) {
+        return new BukkitRunnable() {
+            private int counter = 1;
+            private boolean first = true;
+
+            @Override
+            public void run() {
+                if (TPSFreezeUtils.isFrozen()) return;
+                if (counter >= (first ? delay : period)) {
+                    first = false;
+                    runnable.run();
+                    counter = 1;
+                    return;
+                }
+                counter++;
+            }
+        }.runTaskTimer(plugin, 0, 1);
+    }
+
+    public static void runTaskTimer(Plugin plugin, Consumer<BukkitTask> consumer, long delay, long period) {
+        AtomicReference<BukkitTask> task = new AtomicReference<>();
+        task.set(runTaskTimer(plugin, () -> consumer.accept(task.get()), delay, period));
+    }
+}