mirror of
https://github.com/IntellectualSites/PlotSquared.git
synced 2024-11-23 13:46:45 +01:00
1126 lines
52 KiB
Java
1126 lines
52 KiB
Java
/*
|
|
* _____ _ _ _____ _
|
|
* | __ \| | | | / ____| | |
|
|
* | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
|
|
* | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
|
|
* | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
|
|
* |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
|
|
* | |
|
|
* |_|
|
|
* 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 <http://www.gnu.org/licenses/>.
|
|
*/
|
|
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.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.ChunkListener;
|
|
import com.plotsquared.bukkit.listener.EntitySpawnListener;
|
|
import com.plotsquared.bukkit.listener.PaperListener;
|
|
import com.plotsquared.bukkit.listener.PlayerEvents;
|
|
import com.plotsquared.bukkit.listener.SingleWorldListener;
|
|
import com.plotsquared.bukkit.listener.WorldEvents;
|
|
import com.plotsquared.bukkit.placeholder.PlaceholderFormatter;
|
|
import com.plotsquared.bukkit.placeholder.Placeholders;
|
|
import com.plotsquared.bukkit.player.BukkitPlayer;
|
|
import com.plotsquared.bukkit.player.BukkitPlayerManager;
|
|
import com.plotsquared.bukkit.util.BukkitChatManager;
|
|
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.Captions;
|
|
import com.plotsquared.core.configuration.ChatFormatter;
|
|
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.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.message.PlainChatManager;
|
|
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.queue.GlobalBlockQueue;
|
|
import com.plotsquared.core.setup.PlotAreaBuilder;
|
|
import com.plotsquared.core.setup.SettingsNodesWrapper;
|
|
import com.plotsquared.core.util.ChatManager;
|
|
import com.plotsquared.core.util.ConsoleColors;
|
|
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 lombok.Getter;
|
|
import org.bstats.bukkit.Metrics;
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.ChatColor;
|
|
import org.bukkit.Chunk;
|
|
import org.bukkit.Location;
|
|
import org.bukkit.OfflinePlayer;
|
|
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.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") public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPlatform<Player> {
|
|
|
|
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;
|
|
@Getter private String pluginName;
|
|
@Getter private SingleWorldListener singleWorldListener;
|
|
private Method methodUnloadChunk0;
|
|
private boolean methodUnloadSetup = false;
|
|
private boolean metricsStarted;
|
|
private EconHandler econ;
|
|
|
|
@Getter 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<World> worldManager;
|
|
|
|
@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);
|
|
|
|
if (PremiumVerification.isPremium() && Settings.Enabled_Components.UPDATE_NOTIFICATIONS) {
|
|
injector.getInstance(UpdateUtility.class).updateChecker();
|
|
}
|
|
|
|
if (PremiumVerification.isPremium()) {
|
|
logger.info("[P2] PlotSquared version licensed to Spigot user {}", getUserID());
|
|
logger.info("[P2] https://www.spigotmc.org/resources/{}", getResourceID());
|
|
logger.info("[P2] Download ID: {}", getDownloadID());
|
|
logger.info("[P2] Thanks for supporting us :)");
|
|
} else {
|
|
logger.info("[P2] 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()) {
|
|
log(Captions.PREFIX.getTranslated() + "Flags were converted successfully!");
|
|
// Update the config version
|
|
try {
|
|
plotSquared.setConfigurationVersion("v5");
|
|
} catch (final Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Comments
|
|
CommentManager.registerDefaultInboxes();
|
|
|
|
plotSquared.startExpiryTasks();
|
|
|
|
// This is getting removed so I won't even bother migrating it
|
|
ChatManager.manager = this.initChatManager();
|
|
|
|
// 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("[P2] {} 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("[P2] Incompatible version of WorldEdit, please upgrade: http://builds.enginehub.org/job/worldedit?branch=master");
|
|
}
|
|
}
|
|
|
|
if (Settings.Enabled_Components.EVENTS) {
|
|
getServer().getPluginManager().registerEvents(getInjector().getInstance(PlayerEvents.class), this);
|
|
getServer().getPluginManager().registerEvents(getInjector().getInstance(EntitySpawnListener.class), this);
|
|
if (PaperLib.isPaper() && Settings.Paper_Components.PAPER_LISTENERS) {
|
|
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);
|
|
}
|
|
|
|
// Start the global block queue
|
|
final GlobalBlockQueue globalBlockQueue = this.injector.getInstance(GlobalBlockQueue.class);
|
|
globalBlockQueue.runTask();
|
|
|
|
// 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);
|
|
if (econHandler != null) {
|
|
econHandler.init();
|
|
}
|
|
});
|
|
}
|
|
|
|
if (Settings.Enabled_Components.COMPONENT_PRESETS) {
|
|
try {
|
|
getInjector().getInstance(ComponentPresetManager.class);
|
|
} catch (final Exception e) {
|
|
logger.error("[P2] 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("[P2] `{}` was not properly loaded - {} will now try to load it properly",
|
|
world, this.getPluginName());
|
|
logger.warn("[P2] - Are you trying to delete this world? Remember to remove it from the worlds.yml, bukkit.yml and multiverse worlds.yml");
|
|
logger.warn("[P2] - Your world management plugin may be faulty (or non existent)");
|
|
logger.warn("[P2] 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("[P2] (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("[P2] (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("[P2] (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("[P2] (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("[P2] (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(Placeholders.class).register();
|
|
if (Settings.Enabled_Components.EXTERNAL_PLACEHOLDERS) {
|
|
ChatFormatter.formatters.add(getInjector().getInstance(PlaceholderFormatter.class));
|
|
}
|
|
logger.info("[P2] PlotSquared hooked into PlaceholderAPI");
|
|
} else {
|
|
logger.info("[P2] 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<? extends Player> 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("[P2] 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<UUID> uuidQueue = new LinkedBlockingQueue<>();
|
|
PlotSquared.get().forEachPlotRaw(plot -> {
|
|
final Set<UUID> 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("[P2] (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("[P2] (UUID) PlotSquared will fetch UUIDs in groups of {}", Settings.UUID.BACKGROUND_LIMIT);
|
|
final List<UUID> 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("[P2] (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("[P2] (UUID) PlotSquared has cached {} of UUIDs", String.format("%.1f%%", percentage));
|
|
}
|
|
} catch (final InterruptedException | ExecutionException e) {
|
|
logger.error("[P2] (UUID) Failed to retrieve last batch. Will try again", e);
|
|
}
|
|
}
|
|
logger.info("[P2] (UUID) PlotSquared has cached all UUIDs");
|
|
}, 10, TimeUnit.SECONDS);
|
|
}
|
|
|
|
@Override public void onDisable() {
|
|
PlotSquared.get().disable();
|
|
Bukkit.getScheduler().cancelTasks(this);
|
|
}
|
|
|
|
@Override public void log(@Nonnull String message) {
|
|
try {
|
|
message = Captions.color(message);
|
|
if (!Settings.Chat.CONSOLE_COLOR) {
|
|
message = ChatColor.stripColor(message);
|
|
}
|
|
this.getServer().getConsoleSender().sendMessage(message);
|
|
} catch (final Throwable ignored) {
|
|
System.out.println(ConsoleColors.fromString(message));
|
|
}
|
|
}
|
|
|
|
@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("[P2] KillAllEntities started");
|
|
TaskManager.runTaskRepeat(() -> this.plotAreaManager.forEachPlotArea(plotArea -> {
|
|
final World world = Bukkit.getWorld(plotArea.getWorldName());
|
|
try {
|
|
if (world == null) {
|
|
return;
|
|
}
|
|
List<Entity> entities = world.getEntities();
|
|
Iterator<Entity> 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<MetadataValue> 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<MetadataValue> meta = entity.getMetadata("shulkerPlot");
|
|
if (!meta.isEmpty()) {
|
|
if (livingEntity.isLeashed()) {
|
|
continue;
|
|
}
|
|
List<MetadataValue> 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 "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<String, Map<String, Integer>> map = new HashMap<>();
|
|
for (final PlotAreaType plotAreaType : PlotAreaType.values()) {
|
|
final Map<String, Integer> 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<String, Integer> 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("[P2] 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 ChatManager<?> initChatManager() {
|
|
if (Settings.Chat.INTERACTIVE) {
|
|
return new BukkitChatManager();
|
|
} else {
|
|
return new PlainChatManager();
|
|
}
|
|
}
|
|
|
|
@Override public GeneratorWrapper<?> wrapPlotGenerator(@Nullable final String world,
|
|
@Nonnull final IndependentPlotGenerator generator) {
|
|
return new BukkitPlotGenerator(world, generator, this.plotAreaManager);
|
|
}
|
|
|
|
@Override public List<Map.Entry<Map.Entry<String, String>, Boolean>> getPluginIds() {
|
|
List<Map.Entry<Map.Entry<String, String>, Boolean>> names = new ArrayList<>();
|
|
for (final Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
|
|
Map.Entry<String, String> 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 PlatformWorldManager<?> getWorldManager() {
|
|
return getInjector().getInstance(Key.get(new TypeLiteral<PlatformWorldManager<World>>() {}));
|
|
}
|
|
|
|
@Override @Nonnull public PlayerManager<? extends PlotPlayer<Player>, ? extends Player> getPlayerManager() {
|
|
return getInjector().getInstance(Key.get(new TypeLiteral<PlayerManager<BukkitPlayer, Player>>() {}));
|
|
}
|
|
|
|
}
|