/* * _____ _ _ _____ _ * | __ \| | | | / ____| | | * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| | * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` | * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| | * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_| * | | * |_| * PlotSquared plot management system for Minecraft * Copyright (C) 2020 IntellectualSites * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ package com.plotsquared.bukkit; import com.google.inject.Guice; import com.google.inject.Inject; import com.google.inject.Injector; import com.google.inject.Key; import com.google.inject.Singleton; import com.google.inject.Stage; import com.google.inject.TypeLiteral; import com.plotsquared.bukkit.generator.BukkitPlotGenerator; import com.plotsquared.bukkit.inject.BackupModule; import com.plotsquared.bukkit.inject.BukkitModule; import com.plotsquared.bukkit.inject.PermissionModule; import com.plotsquared.bukkit.inject.WorldManagerModule; import com.plotsquared.bukkit.listener.BlockEventListener; import com.plotsquared.bukkit.listener.ChunkListener; import com.plotsquared.bukkit.listener.EntityEventListener; import com.plotsquared.bukkit.listener.EntitySpawnListener; import com.plotsquared.bukkit.listener.PaperListener; import com.plotsquared.bukkit.listener.PaperListener113; import com.plotsquared.bukkit.listener.PlayerEventListener; import com.plotsquared.bukkit.listener.ProjectileEventListener; import com.plotsquared.bukkit.listener.ServerListener; import com.plotsquared.bukkit.listener.SingleWorldListener; import com.plotsquared.bukkit.listener.WorldEvents; import com.plotsquared.bukkit.placeholder.PAPIPlaceholders; import com.plotsquared.bukkit.placeholder.PlaceholderFormatter; import com.plotsquared.bukkit.player.BukkitPlayer; import com.plotsquared.bukkit.player.BukkitPlayerManager; import com.plotsquared.bukkit.util.BukkitUtil; import com.plotsquared.bukkit.util.BukkitWorld; import com.plotsquared.bukkit.util.SetGenCB; import com.plotsquared.bukkit.util.UpdateUtility; import com.plotsquared.bukkit.util.task.BukkitTaskManager; import com.plotsquared.bukkit.util.task.PaperTimeConverter; import com.plotsquared.bukkit.util.task.SpigotTimeConverter; import com.plotsquared.bukkit.uuid.BungeePermsUUIDService; import com.plotsquared.bukkit.uuid.EssentialsUUIDService; import com.plotsquared.bukkit.uuid.LuckPermsUUIDService; import com.plotsquared.bukkit.uuid.OfflinePlayerUUIDService; import com.plotsquared.bukkit.uuid.PaperUUIDService; import com.plotsquared.bukkit.uuid.SQLiteUUIDService; import com.plotsquared.bukkit.uuid.SquirrelIdUUIDService; import com.plotsquared.core.PlotPlatform; import com.plotsquared.core.PlotSquared; import com.plotsquared.core.backup.BackupManager; import com.plotsquared.core.command.WE_Anywhere; import com.plotsquared.core.components.ComponentPresetManager; import com.plotsquared.core.configuration.ConfigurationNode; import com.plotsquared.core.configuration.ConfigurationSection; import com.plotsquared.core.configuration.ConfigurationUtil; import com.plotsquared.core.configuration.Settings; import com.plotsquared.core.configuration.caption.ChatFormatter; import com.plotsquared.core.configuration.file.YamlConfiguration; import com.plotsquared.core.database.DBFunc; import com.plotsquared.core.generator.GeneratorWrapper; import com.plotsquared.core.generator.IndependentPlotGenerator; import com.plotsquared.core.generator.SingleWorldGenerator; import com.plotsquared.core.inject.annotations.BackgroundPipeline; import com.plotsquared.core.inject.annotations.DefaultGenerator; import com.plotsquared.core.inject.annotations.ImpromptuPipeline; import com.plotsquared.core.inject.annotations.WorldConfig; import com.plotsquared.core.inject.annotations.WorldFile; import com.plotsquared.core.inject.modules.PlotSquaredModule; import com.plotsquared.core.listener.PlotListener; import com.plotsquared.core.listener.WESubscriber; import com.plotsquared.core.player.PlotPlayer; import com.plotsquared.core.plot.Plot; import com.plotsquared.core.plot.PlotArea; import com.plotsquared.core.plot.PlotAreaTerrainType; import com.plotsquared.core.plot.PlotAreaType; import com.plotsquared.core.plot.PlotId; import com.plotsquared.core.plot.comment.CommentManager; import com.plotsquared.core.plot.flag.implementations.ServerPlotFlag; import com.plotsquared.core.plot.world.PlotAreaManager; import com.plotsquared.core.plot.world.SinglePlotArea; import com.plotsquared.core.plot.world.SinglePlotAreaManager; import com.plotsquared.core.setup.PlotAreaBuilder; import com.plotsquared.core.setup.SettingsNodesWrapper; import com.plotsquared.core.util.EconHandler; import com.plotsquared.core.util.EventDispatcher; import com.plotsquared.core.util.FileUtils; import com.plotsquared.core.util.PlatformWorldManager; import com.plotsquared.core.util.PlayerManager; import com.plotsquared.core.util.PremiumVerification; import com.plotsquared.core.util.ReflectionUtils; import com.plotsquared.core.util.SetupUtils; import com.plotsquared.core.util.WorldUtil; import com.plotsquared.core.util.task.TaskManager; import com.plotsquared.core.util.task.TaskTime; import com.plotsquared.core.uuid.CacheUUIDService; import com.plotsquared.core.uuid.UUIDPipeline; import com.plotsquared.core.uuid.offline.OfflineModeUUIDService; import com.sk89q.worldedit.WorldEdit; import io.papermc.lib.PaperLib; import net.kyori.adventure.audience.Audience; import org.bstats.bukkit.Metrics; import org.bukkit.Bukkit; import org.bukkit.Chunk; import org.bukkit.Location; import org.bukkit.World; import org.bukkit.command.PluginCommand; import org.bukkit.entity.Entity; import org.bukkit.entity.LivingEntity; import org.bukkit.entity.Player; import org.bukkit.event.Listener; import org.bukkit.generator.ChunkGenerator; import org.bukkit.metadata.FixedMetadataValue; import org.bukkit.metadata.MetadataValue; import org.bukkit.plugin.Plugin; import org.bukkit.plugin.java.JavaPlugin; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.annotation.Nonnull; import javax.annotation.Nullable; import java.io.File; import java.lang.reflect.Method; import java.util.AbstractMap; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Queue; import java.util.Set; import java.util.UUID; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executors; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.TimeUnit; import static com.plotsquared.core.util.PremiumVerification.getDownloadID; import static com.plotsquared.core.util.PremiumVerification.getResourceID; import static com.plotsquared.core.util.PremiumVerification.getUserID; import static com.plotsquared.core.util.ReflectionUtils.getRefClass; @SuppressWarnings("unused") @Singleton public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPlatform { private static final Logger logger = LoggerFactory.getLogger("P2/" + BukkitPlatform.class.getSimpleName()); private static final int BSTATS_ID = 1404; static { try { Settings.load(new File("plugins/PlotSquared/config/settings.yml")); } catch (Throwable ignored) { } } private int[] version; private String pluginName; private SingleWorldListener singleWorldListener; private Method methodUnloadChunk0; private boolean methodUnloadSetup = false; private boolean metricsStarted; private EconHandler econ; private Injector injector; @Inject private PlotAreaManager plotAreaManager; @Inject private EventDispatcher eventDispatcher; @Inject private PlotListener plotListener; @Inject @WorldConfig private YamlConfiguration worldConfiguration; @Inject @WorldFile private File worldfile; @Inject private BukkitPlayerManager playerManager; @Inject private BackupManager backupManager; @Inject @ImpromptuPipeline private UUIDPipeline impromptuPipeline; @Inject @BackgroundPipeline private UUIDPipeline backgroundPipeline; @Inject private PlatformWorldManager worldManager; private Locale serverLocale; @Override public int[] getServerVersion() { if (this.version == null) { try { this.version = new int[3]; String[] split = Bukkit.getBukkitVersion().split("-")[0].split("\\."); this.version[0] = Integer.parseInt(split[0]); this.version[1] = Integer.parseInt(split[1]); if (split.length == 3) { this.version[2] = Integer.parseInt(split[2]); } } catch (NumberFormatException e) { e.printStackTrace(); return new int[] {1, 13, 0}; } } return this.version; } @Override public String getServerImplementation() { return Bukkit.getVersion(); } @Override public void onEnable() { this.pluginName = getDescription().getName(); final TaskTime.TimeConverter timeConverter; if (PaperLib.isPaper()) { timeConverter = new PaperTimeConverter(); } else { timeConverter = new SpigotTimeConverter(); } // Stuff that needs to be created before the PlotSquared instance PlotPlayer.registerConverter(Player.class, BukkitUtil::adapt); TaskManager.setPlatformImplementation(new BukkitTaskManager(this, timeConverter)); final PlotSquared plotSquared = new PlotSquared(this, "Bukkit"); if (PlotSquared.platform().getServerVersion()[1] < 13) { System.out.println("You can't use this version of PlotSquared on a server less than Minecraft 1.13.2."); System.out.println("Please check the download page for the link to the legacy versions."); System.out.println("The server will now be shutdown to prevent any corruption."); Bukkit.shutdown(); return; } // We create the injector after PlotSquared has been initialized, so that we have access // to generated instances and settings this.injector = Guice .createInjector(Stage.PRODUCTION, new PermissionModule(), new WorldManagerModule(), new PlotSquaredModule(), new BukkitModule(this), new BackupModule()); this.injector.injectMembers(this); this.serverLocale = Locale.forLanguageTag(Settings.Enabled_Components.DEFAULT_LOCALE); if (PremiumVerification.isPremium() && Settings.Enabled_Components.UPDATE_NOTIFICATIONS) { injector.getInstance(UpdateUtility.class).updateChecker(); } if (PremiumVerification.isPremium()) { logger.info("PlotSquared version licensed to Spigot user {}", getUserID()); logger.info("https://www.spigotmc.org/resources/{}", getResourceID()); logger.info("Download ID: {}", getDownloadID()); logger.info("Thanks for supporting us :)"); } else { logger.info("Couldn't verify purchase :("); } // Database if (Settings.Enabled_Components.DATABASE) { plotSquared.setupDatabase(); } // Check if we need to convert old flag values, etc if (!plotSquared.getConfigurationVersion().equalsIgnoreCase("v5")) { // Perform upgrade if (DBFunc.dbManager.convertFlags()) { logger.info("Flags were converted successfully!"); // Update the config version try { plotSquared.setConfigurationVersion("v5"); } catch (final Exception e) { e.printStackTrace(); } } } // Comments CommentManager.registerDefaultInboxes(); plotSquared.startExpiryTasks(); // Do stuff that was previously done in PlotSquared // Kill entities if (Settings.Enabled_Components.KILL_ROAD_MOBS || Settings.Enabled_Components.KILL_ROAD_VEHICLES) { this.runEntityTask(); } // WorldEdit if (Settings.Enabled_Components.WORLDEDIT_RESTRICTIONS) { try { logger.info("{} hooked into WorldEdit", this.getPluginName()); WorldEdit.getInstance().getEventBus().register(this.getInjector().getInstance(WESubscriber.class)); if (Settings.Enabled_Components.COMMANDS) { new WE_Anywhere(); } } catch (Throwable e) { logger.error("Incompatible version of WorldEdit, please upgrade: https://builds.enginehub.org/job/worldedit?branch=master"); } } if (Settings.Enabled_Components.EVENTS) { getServer().getPluginManager().registerEvents(getInjector().getInstance(PlayerEventListener.class), this); getServer().getPluginManager().registerEvents(getInjector().getInstance(BlockEventListener.class), this); getServer().getPluginManager().registerEvents(getInjector().getInstance(EntityEventListener.class), this); getServer().getPluginManager().registerEvents(getInjector().getInstance(ProjectileEventListener.class), this); getServer().getPluginManager().registerEvents(getInjector().getInstance(ServerListener.class), this); getServer().getPluginManager().registerEvents(getInjector().getInstance(EntitySpawnListener.class), this); if (PaperLib.isPaper() && Settings.Paper_Components.PAPER_LISTENERS) { if (getServerVersion()[1] == 13) { getServer().getPluginManager().registerEvents(getInjector().getInstance(PaperListener113.class), this); } else { getServer().getPluginManager().registerEvents(getInjector().getInstance(PaperListener.class), this); } } this.plotListener.startRunnable(); } // Required getServer().getPluginManager().registerEvents(getInjector().getInstance(WorldEvents.class), this); if (Settings.Enabled_Components.CHUNK_PROCESSOR) { getServer().getPluginManager().registerEvents(getInjector().getInstance(ChunkListener.class), this); } // Commands if (Settings.Enabled_Components.COMMANDS) { this.registerCommands(); } // Economy if (Settings.Enabled_Components.ECONOMY) { TaskManager.runTask(() -> { this.getPermissionHandler().initialize(); final EconHandler econHandler = getInjector().getInstance(EconHandler.class); econHandler.init(); }); } if (Settings.Enabled_Components.COMPONENT_PRESETS) { try { getInjector().getInstance(ComponentPresetManager.class); } catch (final Exception e) { logger.error("Failed to initialize the preset system", e); } } // World generators: final ConfigurationSection section = this.worldConfiguration.getConfigurationSection("worlds"); final WorldUtil worldUtil = getInjector().getInstance(WorldUtil.class); if (section != null) { for (String world : section.getKeys(false)) { if (world.equals("CheckingPlotSquaredGenerator")) { continue; } if (worldUtil.isWorld(world)) { this.setGenerator(world); } } TaskManager.runTaskLater(() -> { for (String world : section.getKeys(false)) { if (world.equals("CheckingPlotSquaredGenerator")) { continue; } if (!worldUtil.isWorld(world) && !world.equals("*")) { logger.warn("`{}` was not properly loaded - {} will now try to load it properly", world, this.getPluginName()); logger.warn( " - Are you trying to delete this world? Remember to remove it from the worlds.yml, bukkit.yml and multiverse worlds.yml"); logger.warn(" - Your world management plugin may be faulty (or non existent)"); logger.warn(" This message may also be a false positive and could be ignored."); this.setGenerator(world); } } }, TaskTime.ticks(1L)); } // Services are accessed in order final CacheUUIDService cacheUUIDService = new CacheUUIDService(Settings.UUID.UUID_CACHE_SIZE); this.impromptuPipeline.registerService(cacheUUIDService); this.backgroundPipeline.registerService(cacheUUIDService); this.impromptuPipeline.registerConsumer(cacheUUIDService); this.backgroundPipeline.registerConsumer(cacheUUIDService); // Now, if the server is in offline mode we can only use profiles and direct UUID // access, and so we skip the player profile stuff as well as SquirrelID (Mojang lookups) if (Settings.UUID.OFFLINE) { final OfflineModeUUIDService offlineModeUUIDService = new OfflineModeUUIDService(); this.impromptuPipeline.registerService(offlineModeUUIDService); this.backgroundPipeline.registerService(offlineModeUUIDService); logger.info("(UUID) Using the offline mode UUID service"); } if (Settings.UUID.SERVICE_BUKKIT) { final OfflinePlayerUUIDService offlinePlayerUUIDService = new OfflinePlayerUUIDService(); this.impromptuPipeline.registerService(offlinePlayerUUIDService); this.backgroundPipeline.registerService(offlinePlayerUUIDService); } final SQLiteUUIDService sqLiteUUIDService = new SQLiteUUIDService("user_cache.db"); final SQLiteUUIDService legacyUUIDService; if (Settings.UUID.LEGACY_DATABASE_SUPPORT && FileUtils.getFile(PlotSquared.platform().getDirectory(), "usercache.db").exists()) { legacyUUIDService = new SQLiteUUIDService("usercache.db"); } else { legacyUUIDService = null; } final LuckPermsUUIDService luckPermsUUIDService; if (Settings.UUID.SERVICE_LUCKPERMS && Bukkit.getPluginManager().getPlugin("LuckPerms") != null) { luckPermsUUIDService = new LuckPermsUUIDService(); logger.info("(UUID) Using LuckPerms as a complementary UUID service"); } else { luckPermsUUIDService = null; } final BungeePermsUUIDService bungeePermsUUIDService; if (Settings.UUID.SERVICE_BUNGEE_PERMS && Bukkit.getPluginManager().getPlugin("BungeePerms") != null) { bungeePermsUUIDService = new BungeePermsUUIDService(); logger.info("(UUID) Using BungeePerms as a complementary UUID service"); } else { bungeePermsUUIDService = null; } final EssentialsUUIDService essentialsUUIDService; if (Settings.UUID.SERVICE_ESSENTIALSX && Bukkit.getPluginManager().getPlugin("Essentials") != null) { essentialsUUIDService = new EssentialsUUIDService(); logger.info("(UUID) Using EssentialsX as a complementary UUID service"); } else { essentialsUUIDService = null; } if (!Settings.UUID.OFFLINE) { // If running Paper we'll also try to use their profiles if (Bukkit.getOnlineMode() && PaperLib.isPaper() && Settings.UUID.SERVICE_PAPER) { final PaperUUIDService paperUUIDService = new PaperUUIDService(); this.impromptuPipeline.registerService(paperUUIDService); this.backgroundPipeline.registerService(paperUUIDService); logger.info("(UUID) Using Paper as a complementary UUID service"); } this.impromptuPipeline.registerService(sqLiteUUIDService); this.backgroundPipeline.registerService(sqLiteUUIDService); this.impromptuPipeline.registerConsumer(sqLiteUUIDService); this.backgroundPipeline.registerConsumer(sqLiteUUIDService); if (legacyUUIDService != null) { this.impromptuPipeline.registerService(legacyUUIDService); this.backgroundPipeline.registerService(legacyUUIDService); } // Plugin providers if (luckPermsUUIDService != null) { this.impromptuPipeline.registerService(luckPermsUUIDService); this.backgroundPipeline.registerService(luckPermsUUIDService); } if (bungeePermsUUIDService != null) { this.impromptuPipeline.registerService(bungeePermsUUIDService); this.backgroundPipeline.registerService(bungeePermsUUIDService); } if (essentialsUUIDService != null) { this.impromptuPipeline.registerService(essentialsUUIDService); this.backgroundPipeline.registerService(essentialsUUIDService); } final SquirrelIdUUIDService impromptuMojangService = new SquirrelIdUUIDService(Settings.UUID.IMPROMPTU_LIMIT); this.impromptuPipeline.registerService(impromptuMojangService); final SquirrelIdUUIDService backgroundMojangService = new SquirrelIdUUIDService(Settings.UUID.BACKGROUND_LIMIT); this.backgroundPipeline.registerService(backgroundMojangService); } else { this.impromptuPipeline.registerService(sqLiteUUIDService); this.backgroundPipeline.registerService(sqLiteUUIDService); this.impromptuPipeline.registerConsumer(sqLiteUUIDService); this.backgroundPipeline.registerConsumer(sqLiteUUIDService); if (legacyUUIDService != null) { this.impromptuPipeline.registerService(legacyUUIDService); this.backgroundPipeline.registerService(legacyUUIDService); } } this.impromptuPipeline.storeImmediately("*", DBFunc.EVERYONE); if (Settings.UUID.BACKGROUND_CACHING_ENABLED) { this.startUuidCaching(sqLiteUUIDService, cacheUUIDService); } if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) { injector.getInstance(PAPIPlaceholders.class).register(); if (Settings.Enabled_Components.EXTERNAL_PLACEHOLDERS) { ChatFormatter.formatters.add(getInjector().getInstance(PlaceholderFormatter.class)); } logger.info("PlotSquared hooked into PlaceholderAPI"); } else { logger.info("PlaceholderAPI is not in use. Hook deactivated"); } this.startMetrics(); if (Settings.Enabled_Components.WORLDS) { TaskManager.getPlatformImplementation().taskRepeat(this::unload, TaskTime.seconds(1L)); try { singleWorldListener = getInjector().getInstance(SingleWorldListener.class); } catch (Exception e) { e.printStackTrace(); } } // Clean up potential memory leak Bukkit.getScheduler().runTaskTimer(this, () -> { try { for (final PlotPlayer player : this.getPlayerManager().getPlayers()) { if (player.getPlatformPlayer() == null || !player.getPlatformPlayer().isOnline()) { this.getPlayerManager().removePlayer(player); } } } catch (final Exception e) { getLogger().warning("Failed to clean up players: " + e.getMessage()); } }, 100L, 100L); } private void unload() { if (!this.methodUnloadSetup) { this.methodUnloadSetup = true; try { ReflectionUtils.RefClass classCraftWorld = getRefClass("{cb}.CraftWorld"); this.methodUnloadChunk0 = classCraftWorld.getRealClass().getDeclaredMethod("unloadChunk0", int.class, int.class, boolean.class); this.methodUnloadChunk0.setAccessible(true); } catch (Throwable event) { event.printStackTrace(); } } if (this.plotAreaManager instanceof SinglePlotAreaManager) { long start = System.currentTimeMillis(); final SinglePlotArea area = ((SinglePlotAreaManager) this.plotAreaManager).getArea(); outer: for (final World world : Bukkit.getWorlds()) { final String name = world.getName(); final char char0 = name.charAt(0); if (!Character.isDigit(char0) && char0 != '-') { continue; } if (!world.getPlayers().isEmpty()) { continue; } PlotId id; try { id = PlotId.fromString(name); } catch (IllegalArgumentException ignored) { continue; } final Plot plot = area.getOwnedPlot(id); if (plot != null) { if (!plot.getFlag(ServerPlotFlag.class) || PlotSquared.platform().getPlayerManager().getPlayerIfExists(plot.getOwner()) == null) { if (world.getKeepSpawnInMemory()) { world.setKeepSpawnInMemory(false); return; } final Chunk[] chunks = world.getLoadedChunks(); if (chunks.length == 0) { if (!Bukkit.unloadWorld(world, true)) { logger.warn("Failed to unload {}", world.getName()); } return; } else { int index = 0; do { final Chunk chunkI = chunks[index++]; boolean result; if (methodUnloadChunk0 != null) { try { result = (boolean) methodUnloadChunk0.invoke(world, chunkI.getX(), chunkI.getZ(), true); } catch (Throwable e) { methodUnloadChunk0 = null; e.printStackTrace(); continue outer; } } else { result = world.unloadChunk(chunkI.getX(), chunkI.getZ(), true); } if (!result) { continue outer; } if (System.currentTimeMillis() - start > 5) { return; } } while (index < chunks.length); } } } } } } private void startUuidCaching(@Nonnull final SQLiteUUIDService sqLiteUUIDService, @Nonnull final CacheUUIDService cacheUUIDService) { // Load all uuids into a big chunky boi queue final Queue uuidQueue = new LinkedBlockingQueue<>(); PlotSquared.get().forEachPlotRaw(plot -> { final Set uuids = new HashSet<>(); uuids.add(plot.getOwnerAbs()); uuids.addAll(plot.getMembers()); uuids.addAll(plot.getTrusted()); uuids.addAll(plot.getDenied()); for (final UUID uuid : uuids) { if (!uuidQueue.contains(uuid)) { uuidQueue.add(uuid); } } }); logger.info("(UUID) {} UUIDs will be cached", uuidQueue.size()); Executors.newSingleThreadScheduledExecutor().schedule(() -> { // Begin by reading all the SQLite cache at once cacheUUIDService.accept(sqLiteUUIDService.getAll()); // Now fetch names for all known UUIDs final int totalSize = uuidQueue.size(); int read = 0; logger.info("(UUID) PlotSquared will fetch UUIDs in groups of {}", Settings.UUID.BACKGROUND_LIMIT); final List uuidList = new ArrayList<>(Settings.UUID.BACKGROUND_LIMIT); // Used to indicate that the second retrieval has been attempted boolean secondRun = false; while (!uuidQueue.isEmpty() || !uuidList.isEmpty()) { if (!uuidList.isEmpty() && secondRun) { logger.warn("(UUID) Giving up on last batch. Fetching new batch instead"); uuidList.clear(); } if (uuidList.isEmpty()) { // Retrieve the secondRun variable to indicate that we're retrieving a // fresh batch secondRun = false; // Populate the request list for (int i = 0; i < Settings.UUID.BACKGROUND_LIMIT && !uuidQueue.isEmpty(); i++) { uuidList.add(uuidQueue.poll()); read++; } } else { // If the list isn't empty then this is a second run for // an old batch, so we re-use the patch secondRun = true; } try { PlotSquared.get().getBackgroundUUIDPipeline().getNames(uuidList).get(); // Clear the list if we successfully index all the names uuidList.clear(); // Print progress final double percentage = ((double) read / (double) totalSize) * 100.0D; if (Settings.DEBUG) { logger.info("(UUID) PlotSquared has cached {} of UUIDs", String.format("%.1f%%", percentage)); } } catch (final InterruptedException | ExecutionException e) { logger.error("(UUID) Failed to retrieve last batch. Will try again", e); } } logger.info("(UUID) PlotSquared has cached all UUIDs"); }, 10, TimeUnit.SECONDS); } @Override public void onDisable() { PlotSquared.get().disable(); Bukkit.getScheduler().cancelTasks(this); } @Override public void shutdown() { this.getServer().getPluginManager().disablePlugin(this); } private void registerCommands() { final BukkitCommand bukkitCommand = new BukkitCommand(); final PluginCommand plotCommand = getCommand("plots"); if (plotCommand != null) { plotCommand.setExecutor(bukkitCommand); plotCommand.setAliases(Arrays.asList("p", "ps", "plotme", "plot")); plotCommand.setTabCompleter(bukkitCommand); } } @Override public File getDirectory() { return getDataFolder(); } @Override public File getWorldContainer() { return Bukkit.getWorldContainer(); } @SuppressWarnings("deprecation") private void runEntityTask() { logger.info("KillAllEntities started"); TaskManager.runTaskRepeat(() -> this.plotAreaManager.forEachPlotArea(plotArea -> { final World world = Bukkit.getWorld(plotArea.getWorldName()); try { if (world == null) { return; } List entities = world.getEntities(); Iterator iterator = entities.iterator(); while (iterator.hasNext()) { Entity entity = iterator.next(); switch (entity.getType().toString()) { case "EGG": case "FISHING_HOOK": case "ENDER_SIGNAL": case "AREA_EFFECT_CLOUD": case "EXPERIENCE_ORB": case "LEASH_HITCH": case "FIREWORK": case "LIGHTNING": case "WITHER_SKULL": case "UNKNOWN": case "PLAYER": // non moving / unmovable continue; case "THROWN_EXP_BOTTLE": case "SPLASH_POTION": case "SNOWBALL": case "SHULKER_BULLET": case "SPECTRAL_ARROW": case "ENDER_PEARL": case "ARROW": case "LLAMA_SPIT": case "TRIDENT": // managed elsewhere | projectile continue; case "ITEM_FRAME": case "PAINTING": // Not vehicles continue; case "ARMOR_STAND": // Temporarily classify as vehicle case "MINECART": case "MINECART_CHEST": case "MINECART_COMMAND": case "MINECART_FURNACE": case "MINECART_HOPPER": case "MINECART_MOB_SPAWNER": case "ENDER_CRYSTAL": case "MINECART_TNT": case "BOAT": if (Settings.Enabled_Components.KILL_ROAD_VEHICLES) { com.plotsquared.core.location.Location location = BukkitUtil.adapt(entity.getLocation()); Plot plot = location.getPlot(); if (plot == null) { if (location.isPlotArea()) { if (entity.hasMetadata("ps-tmp-teleport")) { continue; } iterator.remove(); entity.remove(); } continue; } List meta = entity.getMetadata("plot"); if (meta.isEmpty()) { continue; } Plot origin = (Plot) meta.get(0).value(); if (!plot.equals(origin.getBasePlot(false))) { if (entity.hasMetadata("ps-tmp-teleport")) { continue; } iterator.remove(); entity.remove(); } } continue; case "SMALL_FIREBALL": case "FIREBALL": case "DRAGON_FIREBALL": case "DROPPED_ITEM": if (Settings.Enabled_Components.KILL_ROAD_ITEMS && plotArea.getOwnedPlotAbs(BukkitUtil.adapt(entity.getLocation())) == null) { entity.remove(); } // dropped item continue; case "PRIMED_TNT": case "FALLING_BLOCK": // managed elsewhere continue; case "SHULKER": if (Settings.Enabled_Components.KILL_ROAD_MOBS) { LivingEntity livingEntity = (LivingEntity) entity; List meta = entity.getMetadata("shulkerPlot"); if (!meta.isEmpty()) { if (livingEntity.isLeashed()) { continue; } List keep = entity.getMetadata("keep"); if (!keep.isEmpty()) { continue; } PlotId originalPlotId = (PlotId) meta.get(0).value(); if (originalPlotId != null) { com.plotsquared.core.location.Location pLoc = BukkitUtil.adapt(entity.getLocation()); PlotArea area = pLoc.getPlotArea(); if (area != null) { PlotId currentPlotId = area.getPlotAbs(pLoc).getId(); if (!originalPlotId.equals(currentPlotId) && (currentPlotId == null || !area.getPlot(originalPlotId) .equals(area.getPlot(currentPlotId)))) { if (entity.hasMetadata("ps-tmp-teleport")) { continue; } iterator.remove(); entity.remove(); } } } } else { //This is to apply the metadata to already spawned shulkers (see EntitySpawnListener.java) com.plotsquared.core.location.Location pLoc = BukkitUtil.adapt(entity.getLocation()); PlotArea area = pLoc.getPlotArea(); if (area != null) { PlotId currentPlotId = area.getPlotAbs(pLoc).getId(); if (currentPlotId != null) { entity.setMetadata("shulkerPlot", new FixedMetadataValue((Plugin) PlotSquared.platform(), currentPlotId)); } } } } continue; case "ZOMBIFIED_PIGLIN": case "PIGLIN_BRUTE": case "LLAMA": case "DONKEY": case "MULE": case "ZOMBIE_HORSE": case "SKELETON_HORSE": case "HUSK": case "ELDER_GUARDIAN": case "WITHER_SKELETON": case "STRAY": case "ZOMBIE_VILLAGER": case "EVOKER": case "EVOKER_FANGS": case "VEX": case "VINDICATOR": case "POLAR_BEAR": case "BAT": case "BLAZE": case "CAVE_SPIDER": case "CHICKEN": case "COW": case "CREEPER": case "ENDERMAN": case "ENDERMITE": case "ENDER_DRAGON": case "GHAST": case "GIANT": case "GUARDIAN": case "HORSE": case "IRON_GOLEM": case "MAGMA_CUBE": case "MUSHROOM_COW": case "OCELOT": case "PIG": case "PIG_ZOMBIE": case "RABBIT": case "SHEEP": case "SILVERFISH": case "SKELETON": case "SLIME": case "SNOWMAN": case "SPIDER": case "SQUID": case "VILLAGER": case "WITCH": case "WITHER": case "WOLF": case "ZOMBIE": case "PARROT": case "SALMON": case "DOLPHIN": case "TROPICAL_FISH": case "DROWNED": case "COD": case "TURTLE": case "PUFFERFISH": case "PHANTOM": case "ILLUSIONER": case "CAT": case "PANDA": case "FOX": case "PILLAGER": case "TRADER_LLAMA": case "WANDERING_TRADER": case "RAVAGER": case "BEE": case "HOGLIN": case "PIGLIN": case "ZOGLIN": default: { if (Settings.Enabled_Components.KILL_ROAD_MOBS) { Location location = entity.getLocation(); if (BukkitUtil.adapt(location).isPlotRoad()) { if (entity instanceof LivingEntity) { LivingEntity livingEntity = (LivingEntity) entity; if (!livingEntity.isLeashed() || !entity.hasMetadata("keep")) { Entity passenger = entity.getPassenger(); if (!(passenger instanceof Player) && entity.getMetadata("keep").isEmpty()) { if (entity.hasMetadata("ps-tmp-teleport")) { continue; } iterator.remove(); entity.remove(); continue; } } } else { Entity passenger = entity.getPassenger(); if (!(passenger instanceof Player) && entity.getMetadata("keep").isEmpty()) { if (entity.hasMetadata("ps-tmp-teleport")) { continue; } iterator.remove(); entity.remove(); continue; } } } } continue; } } } } catch (Throwable e) { e.printStackTrace(); } }), TaskTime.seconds(1L)); } @Override @Nullable public final ChunkGenerator getDefaultWorldGenerator(@Nonnull final String worldName, final String id) { final IndependentPlotGenerator result; if (id != null && id.equalsIgnoreCase("single")) { result = getInjector().getInstance(SingleWorldGenerator.class); } else { result = getInjector().getInstance(Key.get(IndependentPlotGenerator.class, DefaultGenerator.class)); if (!PlotSquared.get().setupPlotWorld(worldName, id, result)) { return null; } } return (ChunkGenerator) result.specify(worldName); } @Override @Nullable public GeneratorWrapper getGenerator(@Nonnull final String world, @Nullable final String name) { if (name == null) { return null; } final Plugin genPlugin = Bukkit.getPluginManager().getPlugin(name); if (genPlugin != null && genPlugin.isEnabled()) { ChunkGenerator gen = genPlugin.getDefaultWorldGenerator(world, ""); if (gen instanceof GeneratorWrapper) { return (GeneratorWrapper) gen; } return new BukkitPlotGenerator(world, gen, this.plotAreaManager); } else { return new BukkitPlotGenerator(world, getInjector().getInstance(Key.get(IndependentPlotGenerator.class, DefaultGenerator.class)), this.plotAreaManager); } } @Override public void startMetrics() { if (this.metricsStarted) { return; } this.metricsStarted = true; Metrics metrics = new Metrics(this, BSTATS_ID); // bstats metrics.addCustomChart(new Metrics.DrilldownPie("area_types", () -> { final Map> map = new HashMap<>(); for (final PlotAreaType plotAreaType : PlotAreaType.values()) { final Map terrainTypes = new HashMap<>(); for (final PlotAreaTerrainType plotAreaTerrainType : PlotAreaTerrainType.values()) { terrainTypes.put(plotAreaTerrainType.name().toLowerCase(), 0); } map.put(plotAreaType.name().toLowerCase(), terrainTypes); } for (final PlotArea plotArea : this.plotAreaManager.getAllPlotAreas()) { final Map terrainTypeMap = map.get(plotArea.getType().name().toLowerCase()); terrainTypeMap.put(plotArea.getTerrain().name().toLowerCase(), terrainTypeMap.get(plotArea.getTerrain().name().toLowerCase()) + 1); } return map; })); metrics.addCustomChart(new Metrics.SimplePie("premium", () -> PremiumVerification.isPremium() ? "Premium" : "Non-Premium")); metrics.addCustomChart(new Metrics.SimplePie("worldedit_implementation", () -> Bukkit.getPluginManager().getPlugin("FastAsyncWorldEdit") != null ? "FastAsyncWorldEdit" : "WorldEdit")); } @Override public void unregister(@Nonnull final PlotPlayer player) { PlotSquared.platform().getPlayerManager().removePlayer(player.getUUID()); } @Override public void setGenerator(@Nonnull final String worldName) { World world = BukkitUtil.getWorld(worldName); if (world == null) { // create world ConfigurationSection worldConfig = this.worldConfiguration.getConfigurationSection("worlds." + worldName); String manager = worldConfig.getString("generator.plugin", getPluginName()); PlotAreaBuilder builder = PlotAreaBuilder.newBuilder().plotManager(manager).generatorName(worldConfig.getString("generator.init", manager)) .plotAreaType(ConfigurationUtil.getType(worldConfig)).terrainType(ConfigurationUtil.getTerrain(worldConfig)) .settingsNodesWrapper(new SettingsNodesWrapper(new ConfigurationNode[0], null)).worldName(worldName); getInjector().getInstance(SetupUtils.class).setupWorld(builder); world = Bukkit.getWorld(worldName); } else { try { if (!this.plotAreaManager.hasPlotArea(worldName)) { SetGenCB.setGenerator(BukkitUtil.getWorld(worldName)); } } catch (final Exception e) { logger.error("Failed to reload world: {} | {}", world, e.getMessage()); Bukkit.getServer().unloadWorld(world, false); return; } } assert world != null; ChunkGenerator gen = world.getGenerator(); if (gen instanceof BukkitPlotGenerator) { PlotSquared.get().loadWorld(worldName, (BukkitPlotGenerator) gen); } else if (gen != null) { PlotSquared.get().loadWorld(worldName, new BukkitPlotGenerator(worldName, gen, this.plotAreaManager)); } else if (this.worldConfiguration.contains("worlds." + worldName)) { PlotSquared.get().loadWorld(worldName, null); } } @Override public String getNMSPackage() { final String name = Bukkit.getServer().getClass().getPackage().getName(); return name.substring(name.lastIndexOf('.') + 1); } @Override public GeneratorWrapper wrapPlotGenerator(@Nullable final String world, @Nonnull final IndependentPlotGenerator generator) { return new BukkitPlotGenerator(world, generator, this.plotAreaManager); } @Override public List, Boolean>> getPluginIds() { List, Boolean>> names = new ArrayList<>(); for (final Plugin plugin : Bukkit.getPluginManager().getPlugins()) { Map.Entry id = new AbstractMap.SimpleEntry<>(plugin.getName(), plugin.getDescription().getVersion()); names.add(new AbstractMap.SimpleEntry<>(id, plugin.isEnabled())); } return names; } @Override @Nonnull public com.plotsquared.core.location.World getPlatformWorld(@Nonnull final String worldName) { return BukkitWorld.of(worldName); } @Override @Nonnull public Audience getConsoleAudience() { return BukkitUtil.BUKKIT_AUDIENCES.audience(Bukkit.getConsoleSender()); } @Override public String getPluginName() { return this.pluginName; } public SingleWorldListener getSingleWorldListener() { return this.singleWorldListener; } @Override public Injector getInjector() { return this.injector; } @Nonnull @Override public Locale getLocale() { return this.serverLocale; } @Override public void setLocale(@Nonnull final Locale locale) { throw new UnsupportedOperationException("Cannot replace server locale"); } @Override @Nonnull public PlatformWorldManager getWorldManager() { return getInjector().getInstance(Key.get(new TypeLiteral>() { })); } @Override @Nonnull @SuppressWarnings("ALL") public PlayerManager, ? extends Player> getPlayerManager() { return (PlayerManager) getInjector().getInstance(PlayerManager.class); } @Override public void copyCaptionMaps() { /* Make this prettier at some point */ final String[] languages = new String[] { "en" }; for (final String language : languages) { if (!new File(new File(this.getDataFolder(), "lang"), String.format("messages_%s.json", language)).exists()) { this.saveResource(String.format("lang/messages_%s.json", language), false); logger.info("Copied language file 'messages_{}.json'", language); } } } }