Merge branch 'features/v5/placeholders' into v5

Bukkit/build.gradle

@@ -14,6 +14,7 @@ repositories {
     maven { url = "https://ci.ender.zone/plugin/repository/everything/" }
     maven { url = "https://mvn.intellectualsites.com/content/repositories/snapshots" }
     maven { url = "https://repo.wea-ondara.net/repository/public/" }
+    maven { url = "http://repo.mvdw-software.be/content/groups/public/" }
     mavenLocal()
 }
 
@@ -41,6 +42,7 @@ dependencies {
     implementation("net.alpenblock:BungeePerms:4.0-dev-106")
     compile("se.hyperver.hyperverse:Core:0.6.0-SNAPSHOT"){ transitive = false }
     compile('com.sk89q:squirrelid:1.0.0-SNAPSHOT'){ transitive = false }
+    compile('be.maximvdw:MVdWPlaceholderAPI:3.1.1-SNAPSHOT'){ transitive = false }
 }
 
 sourceCompatibility = 1.8

Bukkit/pom.xml

@@ -21,7 +21,7 @@
     <dependency>
       <groupId>com.plotsquared</groupId>
       <artifactId>PlotSquared-Core</artifactId>
-      <version>5.12.5</version>
+      <version>5.13.0</version>
       <scope>compile</scope>
     </dependency>
     <dependency>
@@ -84,6 +84,18 @@
         </exclusion>
       </exclusions>
     </dependency>
+    <dependency>
+      <groupId>be.maximvdw</groupId>
+      <artifactId>MVdWPlaceholderAPI</artifactId>
+      <version>3.1.1-SNAPSHOT</version>
+      <scope>compile</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>*</artifactId>
+          <groupId>*</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
     <dependency>
       <groupId>com.sk89q.worldedit</groupId>
       <artifactId>worldedit-core</artifactId>

Bukkit/src/main/java/com/plotsquared/bukkit/BukkitMain.java

@@ -34,13 +34,14 @@ import com.plotsquared.bukkit.listener.EntitySpawnListener;
 import com.plotsquared.bukkit.listener.PaperListener;
 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.managers.BukkitWorldManager;
 import com.plotsquared.bukkit.managers.HyperverseWorldManager;
 import com.plotsquared.bukkit.managers.MultiverseWorldManager;
 import com.plotsquared.bukkit.placeholder.PlaceholderFormatter;
-import com.plotsquared.bukkit.placeholder.Placeholders;
+import com.plotsquared.bukkit.placeholder.PAPIPlaceholders;
 import com.plotsquared.bukkit.player.BukkitPlayerManager;
 import com.plotsquared.bukkit.queue.BukkitLocalQueue;
 import com.plotsquared.bukkit.schematic.BukkitSchematicHandler;
@@ -366,14 +367,11 @@ public final class BukkitMain extends JavaPlugin implements Listener, IPlotMain<
         }
 
         if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) {
-            new Placeholders().register();
+            new PAPIPlaceholders().register();
             if (Settings.Enabled_Components.EXTERNAL_PLACEHOLDERS) {
                 ChatFormatter.formatters.add(new PlaceholderFormatter());
             }
             PlotSquared.log(Captions.PREFIX + "&6PlotSquared hooked into PlaceholderAPI");
-        } else {
-            PlotSquared
-                .debug(Captions.PREFIX + "&6PlaceholderAPI is not in use. Hook deactivated.");
         }
 
         this.startMetrics();
@@ -1054,6 +1052,11 @@ public final class BukkitMain extends JavaPlugin implements Listener, IPlotMain<
         getServer().getPluginManager().registerEvents(new WorldEvents(), this);
     }
 
+    @Override
+    public void registerServerEvents() {
+        getServer().getPluginManager().registerEvents(new ServerListener(this), this);
+    }
+
     @NotNull @Override public IndependentPlotGenerator getDefaultGenerator() {
         return new HybridGen();
     }

Bukkit/src/main/java/com/plotsquared/bukkit/listener/ServerListener.java

@@ -0,0 +1,51 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.listener;
+
+import com.plotsquared.bukkit.BukkitMain;
+import com.plotsquared.bukkit.placeholder.MVdWPlaceholders;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Captions;
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.server.ServerLoadEvent;
+
+public class ServerListener implements Listener {
+
+    private final BukkitMain plugin;
+
+    public ServerListener(BukkitMain plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler public void onServerLoad(ServerLoadEvent event) {
+        if (Bukkit.getPluginManager().getPlugin("MVdWPlaceholderAPI") != null) {
+            new MVdWPlaceholders(this.plugin, PlotSquared.get().getPlaceholderRegistry());
+            PlotSquared.log(Captions.PREFIX + "&6PlotSquared hooked into MVdWPlaceholderAPI");
+        }
+    }
+}

Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/MVdWPlaceholders.java

@@ -0,0 +1,78 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.placeholder;
+
+import be.maximvdw.placeholderapi.PlaceholderAPI;
+import com.google.common.eventbus.Subscribe;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.util.placeholders.Placeholder;
+import com.plotsquared.core.util.placeholders.PlaceholderRegistry;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Placeholder support for MVdWPlaceholderAPI
+ */
+public class MVdWPlaceholders {
+
+    private static final String PREFIX = "plotsquared_";
+    private final Plugin plugin;
+    private final PlaceholderRegistry registry;
+
+    public MVdWPlaceholders(@NotNull final Plugin plugin,
+                            @NotNull final PlaceholderRegistry registry) {
+        this.plugin = plugin;
+        this.registry = registry;
+        for (final Placeholder placeholder : registry.getPlaceholders()) {
+            this.addPlaceholder(placeholder);
+        }
+        PlotSquared.get().getEventDispatcher().registerListener(this);
+    }
+
+    @Subscribe public void onNewPlaceholder(@NotNull final
+        PlaceholderRegistry.PlaceholderAddedEvent event) {
+        this.addPlaceholder(event.getPlaceholder());
+    }
+
+    private void addPlaceholder(@NotNull final Placeholder placeholder) {
+        PlaceholderAPI.registerPlaceholder(plugin, PREFIX + String.format("%s", placeholder.getKey()),
+            placeholderReplaceEvent -> {
+                if (!placeholderReplaceEvent.isOnline() || placeholderReplaceEvent.getPlayer() == null) {
+                    return "";
+                }
+                final PlotPlayer<Player> player = BukkitUtil.getPlayer(placeholderReplaceEvent.getPlayer());
+                if (player == null) {
+                    return "";
+                }
+                String key = placeholderReplaceEvent.getPlaceholder().substring(PREFIX.length());
+                return registry.getPlaceholderValue(key, player);
+            });
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/PAPIPlaceholders.java

@@ -0,0 +1,89 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.placeholder;
+
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.player.PlotPlayer;
+import me.clip.placeholderapi.PlaceholderAPIPlugin;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import org.bukkit.entity.Player;
+
+public class PAPIPlaceholders extends PlaceholderExpansion {
+
+    public PAPIPlaceholders() {
+    }
+
+    @Override public boolean persist() {
+        return true;
+    }
+
+    @Override public boolean canRegister() {
+        return true;
+    }
+
+    @Override public String getAuthor() {
+        return "IntellectualSites";
+    }
+
+    @Override public String getIdentifier() {
+        return "plotsquared";
+    }
+
+    @Override public String getVersion() {
+        return "3";
+    }
+
+    @Override public String onPlaceholderRequest(Player p, String identifier) {
+        final PlotPlayer<?> pl = PlotSquared.imp().getPlayerManager().getPlayerIfExists(p.getUniqueId());
+
+        if (pl == null) {
+            return "";
+        }
+
+        // PAPI specific ones that don't translate well over into other placeholder APIs
+        if (identifier.startsWith("has_plot_")) {
+            identifier = identifier.substring("has_plot_".length());
+            if (identifier.isEmpty())
+                return "";
+
+            return pl.getPlotCount(identifier) > 0 ?
+                PlaceholderAPIPlugin.booleanTrue() :
+                PlaceholderAPIPlugin.booleanFalse();
+        }
+
+        if (identifier.startsWith("plot_count_")) {
+            identifier = identifier.substring("plot_count_".length());
+            if (identifier.isEmpty())
+                return "";
+
+            return String.valueOf(pl.getPlotCount(identifier));
+        }
+
+        // PlotSquared placeholders
+        return PlotSquared.get().getPlaceholderRegistry().getPlaceholderValue(identifier, pl);
+    }
+
+}

Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/Placeholders.java

@@ -1,213 +0,0 @@
-/*
- *       _____  _       _    _____                                _
- *      |  __ \| |     | |  / ____|                              | |
- *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
- *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
- *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
- *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
- *                                    | |
- *                                    |_|
- *            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.placeholder;
-
-import com.plotsquared.core.PlotSquared;
-import com.plotsquared.core.player.PlotPlayer;
-import com.plotsquared.core.plot.Plot;
-import com.plotsquared.core.plot.flag.GlobalFlagContainer;
-import com.plotsquared.core.plot.flag.PlotFlag;
-import com.plotsquared.core.util.MainUtil;
-import me.clip.placeholderapi.PlaceholderAPIPlugin;
-import me.clip.placeholderapi.expansion.PlaceholderExpansion;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-
-import java.util.UUID;
-
-public class Placeholders extends PlaceholderExpansion {
-
-    public Placeholders() {
-    }
-
-    @Override public boolean persist() {
-        return true;
-    }
-
-    @Override public boolean canRegister() {
-        return true;
-    }
-
-    @Override public String getAuthor() {
-        return "NotMyFault";
-    }
-
-    @Override public String getIdentifier() {
-        return "plotsquared";
-    }
-
-    @Override public String getVersion() {
-        return "2.5";
-    }
-
-    @Override public String onPlaceholderRequest(Player p, String identifier) {
-        final PlotPlayer pl = PlotSquared.imp().getPlayerManager().getPlayerIfExists(p.getUniqueId());
-
-        if (pl == null) {
-            return "";
-        }
-
-        if (identifier.startsWith("has_plot_")) {
-            identifier = identifier.substring("has_plot_".length());
-            if (identifier.isEmpty())
-                return "";
-
-            return pl.getPlotCount(identifier) > 0 ?
-                PlaceholderAPIPlugin.booleanTrue() :
-                PlaceholderAPIPlugin.booleanFalse();
-        }
-
-        if (identifier.startsWith("plot_count_")) {
-            identifier = identifier.substring("plot_count_".length());
-            if (identifier.isEmpty())
-                return "";
-
-            return String.valueOf(pl.getPlotCount(identifier));
-        }
-
-        switch (identifier) {
-            case "currentplot_world": {
-                return p.getWorld().getName();
-            }
-            case "has_plot": {
-                return (pl.getPlotCount() > 0) ?
-                    PlaceholderAPIPlugin.booleanTrue() :
-                    PlaceholderAPIPlugin.booleanFalse();
-            }
-            case "allowed_plot_count": {
-                return String.valueOf(pl.getAllowedPlots());
-            }
-            case "plot_count": {
-                return String.valueOf(pl.getPlotCount());
-            }
-        }
-
-        Plot plot = pl.getCurrentPlot();
-
-        if (plot == null) {
-            return "";
-        }
-
-        switch (identifier) {
-            case "currentplot_alias": {
-                return plot.getAlias();
-            }
-            case "currentplot_owner": {
-                final UUID plotOwner = plot.getOwnerAbs();
-                if (plotOwner == null) {
-                    return "";
-                }
-
-                try {
-                    return MainUtil.getName(plotOwner, false);
-                } catch (final Exception ignored) {}
-
-                final String name = Bukkit.getOfflinePlayer(plotOwner).getName();
-                return name != null ? name : "unknown";
-            }
-            case "currentplot_members": {
-                if (plot.getMembers() == null && plot.getTrusted() == null) {
-                    return "0";
-                }
-                return String.valueOf(plot.getMembers().size() + plot.getTrusted().size());
-            }
-            case "currentplot_members_added": {
-                if (plot.getMembers() == null) {
-                    return "0";
-                }
-                return String.valueOf(plot.getMembers().size());
-            }
-            case "currentplot_members_trusted": {
-                if (plot.getTrusted() == null) {
-                    return "0";
-                }
-                return String.valueOf(plot.getTrusted().size());
-            }
-            case "currentplot_members_denied": {
-                if (plot.getDenied() == null) {
-                    return "0";
-                }
-                return String.valueOf(plot.getDenied().size());
-            }
-            case "has_build_rights": {
-                return plot.isAdded(pl.getUUID()) ?
-                    PlaceholderAPIPlugin.booleanTrue() :
-                    PlaceholderAPIPlugin.booleanFalse();
-            }
-            case "currentplot_x": {
-                return String.valueOf(plot.getId().getX());
-            }
-            case "currentplot_y": {
-                return String.valueOf(plot.getId().getY());
-            }
-            case "currentplot_xy": {
-                return plot.getId().getX() + ";" + plot.getId().getY();
-            }
-            case "currentplot_rating": {
-                return String.valueOf(plot.getAverageRating());
-            }
-            case "currentplot_biome": {
-                return plot.getBiomeSynchronous() + "";
-            }
-            default:
-                break;
-        }
-        if (identifier.startsWith("currentplot_localflag_")) {
-            return getFlagValue(plot, identifier.substring("currentplot_localflag_".length()),
-                false);
-        }
-        if (identifier.startsWith("currentplot_flag_")) {
-            return getFlagValue(plot, identifier.substring("currentplot_flag_".length()), true);
-        }
-        return "";
-    }
-
-    /**
-     * Return the flag value from its name on the current plot.
-     * If the flag doesn't exist it returns an empty string.
-     * If the flag exists but it is not set on current plot and the parameter inherit is set to true,
-     * it returns the default value.
-     *
-     * @param plot     Current plot where the player is
-     * @param flagName Name of flag to get from current plot
-     * @param inherit  Define if it returns only the flag set on currentplot or also inherited flag
-     * @return The value of flag serialized in string
-     */
-    private String getFlagValue(final Plot plot, final String flagName, final boolean inherit) {
-        if (flagName.isEmpty())
-            return "";
-        final PlotFlag<?, ?> flag = GlobalFlagContainer.getInstance().getFlagFromString(flagName);
-        if (flag == null)
-            return "";
-
-        if (inherit) {
-            return plot.getFlag(flag).toString();
-        } else {
-            final PlotFlag<?, ?> plotFlag = plot.getFlagContainer().queryLocal(flag.getClass());
-            return (plotFlag != null) ? plotFlag.getValue().toString() : "";
-        }
-    }
-}

Bukkit/src/main/resources/plugin.yml

@@ -6,7 +6,7 @@ load: STARTUP
 description: "Easy, yet powerful Plot World generation and management."
 authors: [Citymonstret, Empire92, MattBDev, dordsor21, NotMyFault, SirYwell]
 website: https://www.spigotmc.org/resources/77506/
-softdepend: [Vault, PlaceholderAPI, Essentials, LuckPerms, BungeePerms]
+softdepend: [Vault, PlaceholderAPI, Essentials, LuckPerms, BungeePerms, MVdWPlaceholderAPI]
 loadbefore: [MultiWorld, Multiverse-Core]
 depend: [WorldEdit]
 database: false

Core/src/main/java/com/plotsquared/core/IPlotMain.java

@@ -270,6 +270,11 @@ public interface IPlotMain<P> extends ILogger {
      */
     void registerWorldEvents();
 
+    /**
+     * Register events related to the server
+     */
+    void registerServerEvents();
+
     /**
      * Usually HybridGen
      *

Core/src/main/java/com/plotsquared/core/PlotSquared.java

@@ -62,6 +62,7 @@ import com.plotsquared.core.plot.PlotManager;
 import com.plotsquared.core.plot.comment.CommentManager;
 import com.plotsquared.core.plot.expiration.ExpireManager;
 import com.plotsquared.core.plot.expiration.ExpiryTask;
+import com.plotsquared.core.plot.flag.GlobalFlagContainer;
 import com.plotsquared.core.plot.world.DefaultPlotAreaManager;
 import com.plotsquared.core.plot.world.PlotAreaManager;
 import com.plotsquared.core.plot.world.SinglePlotArea;
@@ -82,6 +83,7 @@ import com.plotsquared.core.util.SetupUtils;
 import com.plotsquared.core.util.StringMan;
 import com.plotsquared.core.util.WorldUtil;
 import com.plotsquared.core.util.logger.ILogger;
+import com.plotsquared.core.util.placeholders.PlaceholderRegistry;
 import com.plotsquared.core.util.query.PlotQuery;
 import com.plotsquared.core.util.task.TaskManager;
 import com.plotsquared.core.uuid.UUIDPipeline;
@@ -171,6 +173,7 @@ public class PlotSquared {
     private File storageFile;
     @Getter private PlotAreaManager plotAreaManager;
     @Getter private EventDispatcher eventDispatcher;
+    @Getter private PlaceholderRegistry placeholderRegistry;
 
     /**
      * Initialize PlotSquared with the desired Implementation class.
@@ -194,6 +197,9 @@ public class PlotSquared {
         //
         ConfigurationSerialization.registerClass(BlockBucket.class, "BlockBucket");
 
+        // Setup the global flag container
+        GlobalFlagContainer.setup();
+
         try {
             new ReflectionUtils(this.IMP.getNMSPackage());
             try {
@@ -209,6 +215,7 @@ public class PlotSquared {
                         "PlotSquared-" + platform + ".jar");
                 }
             }
+
             TaskManager.IMP = this.IMP.getTaskManager();
 
             // World Util. Has to be done before config files are loaded
@@ -255,6 +262,7 @@ public class PlotSquared {
                 this.IMP.registerEvents();
             }
             // Required
+            this.IMP.registerServerEvents();
             this.IMP.registerWorldEvents();
             if (Settings.Enabled_Components.CHUNK_PROCESSOR) {
                 this.IMP.registerChunkProcessor();
@@ -262,6 +270,8 @@ public class PlotSquared {
             startExpiryTasks();
             // Create Event utility class
             eventDispatcher = new EventDispatcher();
+            // Create placeholder registry
+            placeholderRegistry = new PlaceholderRegistry(eventDispatcher);
             // create Hybrid utility class
             HybridUtils.manager = this.IMP.initHybridUtils();
             // Inventory utility class

Core/src/main/java/com/plotsquared/core/plot/Plot.java

@@ -2256,7 +2256,7 @@ public class Plot {
      *
      * @return The plot alias
      */
-    public String getAlias() {
+    @NotNull public String getAlias() {
         if (this.settings == null) {
             return "";
         }

Core/src/main/java/com/plotsquared/core/plot/flag/GlobalFlagContainer.java

@@ -25,6 +25,7 @@
  */
 package com.plotsquared.core.plot.flag;
 
+import com.google.common.base.Preconditions;
 import com.plotsquared.core.plot.flag.implementations.AnalysisFlag;
 import com.plotsquared.core.plot.flag.implementations.AnimalAttackFlag;
 import com.plotsquared.core.plot.flag.implementations.AnimalCapFlag;
@@ -114,7 +115,13 @@ import java.util.Map;
 
 public final class GlobalFlagContainer extends FlagContainer {
 
-    @Getter private static final GlobalFlagContainer instance = new GlobalFlagContainer();
+    @Getter private static GlobalFlagContainer instance;
+
+    public static void setup() {
+        Preconditions.checkState(instance == null, "Cannot setup the container twice");
+        instance = new GlobalFlagContainer();
+    }
+
     private static Map<String, Class<?>> stringClassMap;
 
     private GlobalFlagContainer() {
@@ -124,6 +131,7 @@ public final class GlobalFlagContainer extends FlagContainer {
             }
         });
         stringClassMap = new HashMap<>();
+
         // Register all default flags here
         // Boolean flags
         this.addFlag(ExplosionFlag.EXPLOSION_FALSE);

Core/src/main/java/com/plotsquared/core/util/EventDispatcher.java

@@ -80,9 +80,9 @@ import java.util.UUID;
 
 public class EventDispatcher {
 
-    private EventBus eventBus = new EventBus("PlotSquaredEvents");
+    private final EventBus eventBus = new EventBus("PlotSquaredEvents");
 
-    private List<Object> listeners = new ArrayList<>();
+    private final List<Object> listeners = new ArrayList<>();
 
     public void registerListener(Object listener) {
         eventBus.register(listener);
@@ -100,6 +100,10 @@ public class EventDispatcher {
         }
     }
 
+    public void callGenericEvent(@NotNull final Object event) {
+        eventBus.post(event);
+    }
+
     public void callEvent(@NotNull final PlotEvent event) {
         eventBus.post(event);
     }

Core/src/main/java/com/plotsquared/core/util/placeholders/Placeholder.java

@@ -0,0 +1,63 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.core.util.placeholders;
+
+import com.google.common.base.Preconditions;
+import com.plotsquared.core.player.PlotPlayer;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A placeholder is a keyed value that gets replaced by a {@link PlotPlayer player}-specific value at runtime
+ */
+@EqualsAndHashCode(of = "key") @ToString(of = "key")
+public abstract class Placeholder {
+
+    private final String key;
+
+    public Placeholder(@NotNull final String key) {
+        this.key = Preconditions.checkNotNull(key, "Key may not be null");
+    }
+
+    /**
+     * Get the value of the placeholder for a particular player
+     *
+     * @param player Player
+     * @return Placeholder value. Return {@code ""} if no placeholder value can be returned
+     */
+    @NotNull public abstract String getValue(@NotNull final PlotPlayer<?> player);
+
+    /**
+     * Get the placeholder key
+     *
+     * @return Placeholder key
+     */
+    @NotNull public final String getKey() {
+        return this.key;
+    }
+
+}

Core/src/main/java/com/plotsquared/core/util/placeholders/PlaceholderRegistry.java

@@ -0,0 +1,230 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.core.util.placeholders;
+
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.flag.GlobalFlagContainer;
+import com.plotsquared.core.plot.flag.PlotFlag;
+import com.plotsquared.core.util.EventDispatcher;
+import com.plotsquared.core.util.MainUtil;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Locale;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.BiFunction;
+
+/**
+ * Registry that contains {@link Placeholder placeholders}
+ */
+public final class PlaceholderRegistry {
+
+    private final Map<String, Placeholder> placeholders;
+    private final EventDispatcher eventDispatcher;
+
+    public PlaceholderRegistry(@NotNull final EventDispatcher eventDispatcher) {
+        this.placeholders = Maps.newHashMap();
+        this.eventDispatcher = eventDispatcher;
+        this.registerDefault();
+    }
+
+    private void registerDefault() {
+        final GlobalFlagContainer globalFlagContainer = GlobalFlagContainer.getInstance();
+        for (final PlotFlag<?, ?> flag : globalFlagContainer.getRecognizedPlotFlags()) {
+            this.registerPlaceholder(new PlotFlagPlaceholder(flag, true));
+            this.registerPlaceholder(new PlotFlagPlaceholder(flag, false));
+        }
+        GlobalFlagContainer.getInstance().subscribe((flag, type) -> {
+            this.registerPlaceholder(new PlotFlagPlaceholder(flag, true));
+            this.registerPlaceholder(new PlotFlagPlaceholder(flag, false));
+        });
+        this.createPlaceholder("currentplot_world", player -> player.getLocation().getWorld());
+        this.createPlaceholder("has_plot", player -> player.getPlotCount() > 0 ? "true" : "false");
+        this.createPlaceholder("allowed_plot_count", player -> Integer.toString(player.getAllowedPlots()));
+        this.createPlaceholder("plot_count", player -> Integer.toString(player.getPlotCount()));
+        this.createPlaceholder("currentplot_alias", (player, plot) -> plot.getAlias());
+        this.createPlaceholder("currentplot_owner", (player, plot) -> {
+            final UUID plotOwner = plot.getOwnerAbs();
+            if (plotOwner == null) {
+                return "";
+            }
+
+            try {
+                return MainUtil.getName(plotOwner, false);
+            } catch (final Exception ignored) {}
+
+            return "unknown";
+        });
+        this.createPlaceholder("currentplot_members", (player, plot) -> {
+            if (plot.getMembers() == null && plot.getTrusted() == null) {
+                return "0";
+            }
+            return String.valueOf(plot.getMembers().size() + plot.getTrusted().size());
+        });
+        this.createPlaceholder("currentplot_members_added", (player, plot) -> {
+            if (plot.getMembers() == null) {
+                return "0";
+            }
+            return String.valueOf(plot.getMembers().size());
+        });
+        this.createPlaceholder("currentplot_members_trusted", (player, plot) -> {
+            if (plot.getTrusted() == null) {
+                return "0";
+            }
+            return String.valueOf(plot.getTrusted().size());
+        });
+        this.createPlaceholder("currentplot_members_denied", (player, plot) -> {
+            if (plot.getDenied() == null) {
+                return "0";
+            }
+            return String.valueOf(plot.getDenied().size());
+        });
+        this.createPlaceholder("has_build_rights", (player, plot) ->
+            plot.isAdded(player.getUUID()) ? "true" : "false");
+        this.createPlaceholder("currentplot_x", (player, plot) -> Integer.toString(plot.getId().getX()));
+        this.createPlaceholder("currentplot_y", (player, plot) -> Integer.toString(plot.getId().getY()));
+        this.createPlaceholder("currentplot_xy", (player, plot) -> plot.getId().toString());
+        this.createPlaceholder("currentplot_rating", (player, plot) -> Double.toString(plot.getAverageRating()));
+        this.createPlaceholder("currentplot_biome", (player, plot) -> plot.getBiomeSynchronous().toString());
+    }
+
+    /**
+     * Create a functional placeholder
+     *
+     * @param key                 Placeholder key
+     * @param placeholderFunction Placeholder generator. Cannot return null
+     */
+    @SuppressWarnings("ALL") public void createPlaceholder(@NotNull final String key,
+        @NotNull final Function<PlotPlayer<?>, String> placeholderFunction) {
+        this.registerPlaceholder(new Placeholder(key) {
+            @Override @NotNull public String getValue(@NotNull final PlotPlayer<?> player) {
+                return placeholderFunction.apply(player);
+            }
+        });
+    }
+
+    /**
+     * Create a functional placeholder
+     *
+     * @param key                 Placeholder key
+     * @param placeholderFunction Placeholder generator. Cannot return null
+     */
+    public void createPlaceholder(@NotNull final String key,
+        @NotNull final BiFunction<PlotPlayer<?>, Plot, String> placeholderFunction) {
+        this.registerPlaceholder(new PlotSpecificPlaceholder(key) {
+            @Override @NotNull public String getValue(@NotNull final PlotPlayer<?> player, @NotNull final Plot plot) {
+                return placeholderFunction.apply(player, plot);
+            }
+        });
+    }
+
+    /**
+     * Register a placeholder
+     *
+     * @param placeholder Placeholder instance
+     */
+    public void registerPlaceholder(@NotNull final Placeholder placeholder) {
+        final Placeholder previous = this.placeholders
+            .put(placeholder.getKey().toLowerCase(Locale.ENGLISH),
+                Preconditions.checkNotNull(placeholder, "Placeholder may not be null"));
+        if (previous == null) {
+            this.eventDispatcher.callGenericEvent(new PlaceholderAddedEvent(placeholder));
+        }
+    }
+
+    /**
+     * Get a placeholder instance from its key
+     *
+     * @param key Placeholder key
+     * @return Placeholder value
+     */
+    @Nullable public Placeholder getPlaceholder(@NotNull final String key) {
+        return this.placeholders.get(
+            Preconditions.checkNotNull(key, "Key may not be null").toLowerCase(Locale.ENGLISH));
+    }
+
+    /**
+     * Get the placeholder value evaluated for a player, and catch and deal with any problems
+     * occurring while doing so
+     *
+     * @param key    Placeholder key
+     * @param player Player to evaluate for
+     * @return Replacement value
+     */
+    @NotNull public String getPlaceholderValue(@NotNull final String key,
+        @NotNull final PlotPlayer<?> player) {
+        final Placeholder placeholder = getPlaceholder(key);
+        if (placeholder == null) {
+            return "";
+        }
+        String placeholderValue = "";
+        try {
+            placeholderValue = placeholder.getValue(player);
+            // If a placeholder for some reason decides to be disobedient, we catch it here
+            if (placeholderValue == null) {
+                new RuntimeException(String
+                    .format("Placeholder '%s' returned null for player '%s'", placeholder.getKey(),
+                        player.getName())).printStackTrace();
+            }
+        } catch (final Exception exception) {
+            new RuntimeException(String
+                .format("Placeholder '%s' failed to evalulate for player '%s'",
+                    placeholder.getKey(), player.getName()), exception).printStackTrace();
+        }
+        return placeholderValue;
+    }
+
+    /**
+     * Get all placeholders
+     *
+     * @return Unmodifiable collection of placeholders
+     */
+    @NotNull public Collection<Placeholder> getPlaceholders() {
+        return Collections.unmodifiableCollection(this.placeholders.values());
+    }
+
+
+    /**
+     * Event called when a new {@link Placeholder} has been added
+     */
+    @RequiredArgsConstructor
+    @Getter
+    public static class PlaceholderAddedEvent {
+
+        private final Placeholder placeholder;
+
+    }
+
+}

Core/src/main/java/com/plotsquared/core/util/placeholders/PlotFlagPlaceholder.java

@@ -0,0 +1,76 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.core.util.placeholders;
+
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.flag.GlobalFlagContainer;
+import com.plotsquared.core.plot.flag.PlotFlag;
+import org.jetbrains.annotations.NotNull;
+
+public final class PlotFlagPlaceholder extends PlotSpecificPlaceholder {
+
+    private final PlotFlag<?, ?> flag;
+    private final boolean local;
+
+    public PlotFlagPlaceholder(@NotNull final PlotFlag<?, ?> flag, final boolean local) {
+        super(String.format("currentplot_%sflag_%s", local ? "local": "", flag.getName()));
+        this.flag = flag;
+        this.local = local;
+    }
+
+    @Override @NotNull public String getValue(@NotNull final PlotPlayer<?> player, @NotNull final Plot plot) {
+        return this.getFlagValue(plot, this.flag.getName(), !this.local);
+    }
+
+    /**
+     * Return the flag value from its name on the current plot.
+     * If the flag doesn't exist it returns an empty string.
+     * If the flag exists but it is not set on current plot and the parameter inherit is set to true,
+     * it returns the default value.
+     *
+     * @param plot     Current plot where the player is
+     * @param flagName Name of flag to get from current plot
+     * @param inherit  Define if it returns only the flag set on the current plot or also inherited flags
+     * @return The value of flag serialized in string
+     */
+    @NotNull private String getFlagValue(@NotNull final Plot plot, @NotNull final String flagName, final boolean inherit) {
+        if (flagName.isEmpty()) {
+            return "";
+        }
+        final PlotFlag<?, ?> flag = GlobalFlagContainer.getInstance().getFlagFromString(flagName);
+        if (flag == null) {
+            return "";
+        }
+        if (inherit) {
+            return plot.getFlag(flag).toString();
+        } else {
+            final PlotFlag<?, ?> plotFlag = plot.getFlagContainer().queryLocal(flag.getClass());
+            return (plotFlag != null) ? plotFlag.getValue().toString() : "";
+        }
+    }
+
+}

Core/src/main/java/com/plotsquared/core/util/placeholders/PlotSpecificPlaceholder.java

@@ -0,0 +1,59 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.core.util.placeholders;
+
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A {@link Placeholder placeholder} that requires a {@link com.plotsquared.core.plot.Plot plot}
+ */
+public abstract class PlotSpecificPlaceholder extends Placeholder {
+
+    public PlotSpecificPlaceholder(@NotNull final String key) {
+        super(key);
+    }
+
+    @Override @NotNull public final String getValue(@NotNull final PlotPlayer<?> player) {
+        final Plot plot = player.getCurrentPlot();
+        if (plot == null) {
+            return "";
+        }
+        return this.getValue(player, plot);
+    }
+
+    /**
+     * Get the value of the placeholder for the {@link PlotPlayer player} in a specific {@link Plot plot}
+     *
+     * @param player Player that the placeholder is evaluated for
+     * @param plot   Plot that the player is in
+     * @return Placeholder value, or {@code ""} if the placeholder does not apply
+     */
+    @NotNull public abstract String getValue(@NotNull final PlotPlayer<?> player,
+        @NotNull final Plot plot);
+
+}

build.gradle

@@ -30,7 +30,7 @@ ext {
     git = Grgit.open(dir: new File(rootDir.toString() + "/.git"))
 }
 
-def ver = "5.12.5"
+def ver = "5.13.0"
 def versuffix = ""
 ext {
     if (project.hasProperty("versionsuffix")) {