AnarchyExploitFixesLegacy/src/main/java/me/xginko/aef/AnarchyExploitFixes.java - master - minecraftbackup/AnarchyExploitFixes

AnarchyExploitFixesLegacy/src/main/java/me/xginko/aef/AnarchyExploitFixes.java
302 строки12 KB
Ginko
2.7.2 release (#233)
13 авг 2024, 08:21
13 авг 2024, 08:21d20da6e
package me.xginko.aef;

import com.github.retrooper.packetevents.PacketEvents;
import io.github.retrooper.packetevents.factory.spigot.SpigotPacketEventsBuilder;
import me.xginko.aef.commands.AEFCommand;
import me.xginko.aef.config.Config;
import me.xginko.aef.config.Datastore;
import me.xginko.aef.config.LanguageCache;
import me.xginko.aef.enums.AEFPermission;
import me.xginko.aef.modules.AEFModule;
import me.xginko.aef.utils.CachingPermTool;
import me.xginko.aef.utils.PlatformUtil;
import me.xginko.aef.utils.tickdata.TickReporter;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.config.Configurator;
import org.bstats.bukkit.Metrics;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.Files;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.jar.JarFile;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.zip.ZipEntry;

public final class AnarchyExploitFixes extends JavaPlugin {

    private static AnarchyExploitFixes instance;
    private static Map<String, LanguageCache> languageCacheMap;
    private static Config config;
    private static Datastore datastore;
    private static TickReporter tickReporter;
    private static CachingPermTool cachingPermTool;
    private static Logger prefixedLogger, unPrefixedLogger;
    private static Metrics metrics;
    private static boolean isPacketEventsInstalled;

    @Override
    public void onLoad() {
        PlatformUtil.load();
        prefixedLogger = LoggerFactory.getLogger(getLogger().getName());
        unPrefixedLogger = LoggerFactory.getLogger("");
        // Disable logging for some shaded libraries as those can get very verbose
        String shadedLibs = getClass().getPackage().getName() + ".libs";
        Configurator.setLevel(shadedLibs + ".reflections.Reflections", Level.OFF);
        Configurator.setLevel(shadedLibs + ".zaxxer.hikari.pool.PoolBase", Level.OFF);
        Configurator.setLevel(shadedLibs + ".zaxxer.hikari.pool.HikariPool", Level.OFF);
        Configurator.setLevel(shadedLibs + ".zaxxer.hikari.HikariDataSource", Level.OFF);
        Configurator.setLevel(shadedLibs + ".zaxxer.hikari.HikariConfig", Level.OFF);
        Configurator.setLevel(shadedLibs + ".zaxxer.hikari.util.DriverDataSource", Level.OFF);
        isPacketEventsInstalled = getServer().getPluginManager().getPlugin("packetevents") != null;
        if (isPacketEventsInstalled) {
            // Configure and load packetevents
            PacketEvents.setAPI(SpigotPacketEventsBuilder.build(this));
            PacketEvents.getAPI().getSettings().kickOnPacketException(true).reEncodeByDefault(false).checkForUpdates(false);
            PacketEvents.getAPI().load();
        }
    }

    @Override
    public void onEnable() {
        if (!isPacketEventsInstalled) {
            Stream.of("                                                               ",
                    "       _   _   _             _   _                             ",
                    "      / \\ | |_| |_ ___ _ __ | |_(_) ___  _ __                 ",
                    "     / _ \\| __| __/ _ \\ '_ \\| __| |/ _ \\| '_ \\            ",
                    "    / ___ \\ |_| ||  __/ | | | |_| | (_) | | | |               ",
                    "   /_/   \\_\\__|\\__\\___|_| |_|\\__|_|\\___/|_| |_|          ",
                    "                                                               ",
                    "   AEF depends on PacketEvents to function!                    ",
                    "   You can either download the latest release on modrinth:     ",
                    "   https://modrinth.com/plugin/packetevents/                   ",
                    "   or choose a dev build on their jenkins:                     ",
                    "   https://ci.codemc.io/job/retrooper/job/packetevents/        ",
                    "                                                               "
            ).forEach(prefixedLogger::error);
            getServer().getPluginManager().disablePlugin(this);
            return;
        }

        instance = this;
        cachingPermTool = CachingPermTool.enable(this);
        metrics = new Metrics(this, 8700);

        Stream.of("                                                          ",
                "                                                          ",
                "     █████  ███████ ███████                               ",
                "    ██   ██ ██      ██             AnarchyExploitFixes    ",
                "    ███████ █████   █████            Made by moom0o       ",
                "    ██   ██ ██      ██             Rewritten by xGinko    ",
                "    ██   ██ ███████ ██                                    ",
                "                                                          ",
                "                                                          "
        ).forEach(prefixedLogger::info);

        if (!PlatformUtil.isPaper()) {
            prefixedLogger.error("This plugin depends on Paper's API, which is not present on your server.");
            getServer().getPluginManager().disablePlugin(this);
            return;
        }

        prefixedLogger.info("Detected Version 1.{}.{}", PlatformUtil.getMinecraftVersion(), PlatformUtil.getMinecraftPatchVersion());

        if (PlatformUtil.getMinecraftVersion() < 12) {
            prefixedLogger.warn("This version is unsupported. Expect issues.");
        } else if (PlatformUtil.getMinecraftVersion() > 19) {
            prefixedLogger.warn("Legacy is intended for Paper server versions 1.12 - 1.19.4.");
            prefixedLogger.warn("Its highly recommended to use the Folia jar for your server.");
        }

        try {
            createDirectory(getDataFolder());
        } catch (IOException e) {
            prefixedLogger.error("Unable to create plugin folder!", e);
            getServer().getPluginManager().disablePlugin(this);
        }

        prefixedLogger.info("Loading Datastore");
        datastore = new Datastore();

        prefixedLogger.info("Loading Config");
        reloadConfiguration();

        prefixedLogger.info("Loading Translations");
        reloadLang();

        prefixedLogger.info("Registering Commands");
        AEFCommand.registerCommands();

        prefixedLogger.info("Registering Permissions");
        AEFPermission.registerPermissions();

        prefixedLogger.info("Initializing PacketEvents");
        PacketEvents.getAPI().init();

        prefixedLogger.info("Ready.");
    }

    @Override
    public void onDisable() {
        if (isPacketEventsInstalled) {
            AEFModule.ENABLED_MODULES.forEach(AEFModule::disable);
            AEFModule.ENABLED_MODULES.clear();
            PacketEvents.getAPI().terminate();
        }
        if (languageCacheMap != null) {
            languageCacheMap.clear();
            languageCacheMap = null;
        }
        if (cachingPermTool != null) {
            cachingPermTool.disable();
            cachingPermTool = null;
        }
        if (tickReporter != null) {
            tickReporter.disable();
            tickReporter = null;
        }
        if (datastore != null) {
            datastore.disable();
            datastore = null;
        }
        if (metrics != null) {
            metrics.shutdown();
            metrics = null;
        }
        unPrefixedLogger = null;
        prefixedLogger = null;
        instance = null;
        config = null;
    }

    public static AnarchyExploitFixes getInstance()  {
        return instance;
    }

    public static Config config() {
        return config;
    }

    public static Datastore getDatastore() {
        return datastore;
    }

    public static TickReporter getTickReporter() {
        return tickReporter;
    }

    public static Logger prefixedLogger() {
        return prefixedLogger;
    }

    public static Logger unprefixedLogger() {
        return unPrefixedLogger;
    }

    public static LanguageCache getLang(Locale locale) {
        return getLang(locale.toString().toLowerCase());
    }

    public static LanguageCache getLang(CommandSender commandSender) {
        return commandSender instanceof Player ? getLang(((Player) commandSender).getLocale()) : getLang(config.default_lang);
    }

    public static LanguageCache getLang(String lang) {
        if (!config.auto_lang) return languageCacheMap.get(config.default_lang.toString().toLowerCase());
        return languageCacheMap.getOrDefault(lang.replace("-", "_"), languageCacheMap.get(config.default_lang.toString().toLowerCase()));
    }

    public void createDirectory(File dir) throws IOException {
        try {
            Files.createDirectories(dir.toPath());
        } catch (FileAlreadyExistsException e) { // Thrown if dir exists but is not a directory
            if (dir.delete()) createDirectory(dir);
        }
    }

    public void reloadPlugin() {
        reloadConfiguration();
        reloadLang();
    }

    private void reloadConfiguration() {
        try {
            createDirectory(getDataFolder());
            config = new Config();
            if (tickReporter != null) tickReporter.disable();
            tickReporter = TickReporter.create(this, config.tps_cache_duration);
            AEFModule.reloadModules();
            config.saveConfig();
        } catch (Throwable t) {
            prefixedLogger.error("Failed while loading config!", t);
        }
    }

    public void reloadLang() {
        languageCacheMap = new HashMap<>();
        try {
            final List<String> availableLocales = getAvailableTranslations();
            if (!config.auto_lang) {
                final String defaultLang = config.default_lang.toString().replace("-", "_").toLowerCase();
                if (!availableLocales.contains(defaultLang))
                    throw new FileNotFoundException("Could not find any translation file for language '" + config.default_lang + "'");
                availableLocales.removeIf(localeString -> !localeString.equalsIgnoreCase(defaultLang));
            }
            StringBuilder friendlyLog = new StringBuilder();
            for (int i = 0; i < availableLocales.size(); i++) {
                final String localeStr = availableLocales.get(i);
                friendlyLog.append(localeStr);
                if (i < availableLocales.size() - 1)
                    friendlyLog.append(", ");
                if ((i + 1) % 4 == 0 || i == availableLocales.size() - 1) {
                    prefixedLogger.info(friendlyLog.toString());
                    friendlyLog = new StringBuilder();
                }
                languageCacheMap.put(localeStr, new LanguageCache(localeStr));
            }
        } catch (Throwable t) {
            prefixedLogger.error("Error loading translations!", t);
        } finally {
            if (languageCacheMap.isEmpty()) {
                prefixedLogger.error("Unable to load translations. Disabling.");
                getServer().getPluginManager().disablePlugin(this);
            } else {
                prefixedLogger.info("Loaded {} translation(s)", languageCacheMap.size());
            }
        }
    }

    private @NotNull List<String> getAvailableTranslations() {
        try (final JarFile pluginJar = new JarFile(getFile())) {
            createDirectory(new File(getDataFolder(), "/lang"));
            final Pattern langPattern = Pattern.compile("([a-z]{1,3}_[a-z]{1,3})(\\.yml)", Pattern.CASE_INSENSITIVE);
            final File[] langDirFiles = new File(getDataFolder() + "/lang").listFiles();
            return Stream.concat(pluginJar.stream().map(ZipEntry::getName), Arrays.stream(langDirFiles).map(File::getName))
                    .map(langPattern::matcher)
                    .filter(Matcher::find)
                    .map(matcher -> matcher.group(1))
                    .distinct()
                    .sorted()
                    .collect(Collectors.toList());
        } catch (Throwable t) {
            prefixedLogger.error("Failed while searching for available translations!", t);
            return Collections.emptyList();
        }
    }
}