Merge branch 'v6' into features/v6/permissions

# Conflicts:
#	Bukkit/src/main/java/com/plotsquared/bukkit/player/BukkitPlayer.java
#	Core/src/main/java/com/plotsquared/core/command/Auto.java
#	Core/src/main/java/com/plotsquared/core/player/ConsolePlayer.java
#	Core/src/main/java/com/plotsquared/core/util/Permissions.java

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

@@ -38,6 +38,8 @@ import com.plotsquared.core.database.DBFunc;
 import com.plotsquared.core.listener.PlayerBlockEventType;
 import com.plotsquared.core.listener.PlotListener;
 import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.PlotArea;
@@ -216,13 +218,14 @@ import org.bukkit.plugin.Plugin;
 import org.bukkit.projectiles.BlockProjectileSource;
 import org.bukkit.projectiles.ProjectileSource;
 import org.bukkit.util.Vector;
-import javax.annotation.Nonnull;
 
+import javax.annotation.Nonnull;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.UUID;
@@ -731,7 +734,9 @@ import java.util.regex.Pattern;
     public void onTeleport(PlayerTeleportEvent event) {
         Player player = event.getPlayer();
         BukkitPlayer pp = BukkitUtil.adapt(player);
-        Plot lastPlot = pp.getMeta(PlotPlayer.META_LAST_PLOT);
+        try (final MetaDataAccess<Plot> lastPlotAccess =
+            pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+            Plot lastPlot = lastPlotAccess.get().orElse(null);
             org.bukkit.Location to = event.getTo();
             //noinspection ConstantConditions
             if (to != null) {
@@ -740,9 +745,12 @@ import java.util.regex.Pattern;
                 if (area == null) {
                     if (lastPlot != null) {
                         plotExit(pp, lastPlot);
-                    pp.deleteMeta(PlotPlayer.META_LAST_PLOT);
+                        lastPlotAccess.remove();
+                    }
+                    try (final MetaDataAccess<Location> lastLocationAccess =
+                        pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
+                        lastLocationAccess.remove();
                     }
-                pp.deleteMeta(PlotPlayer.META_LOCATION);
                     return;
                 }
                 Plot plot = area.getPlot(location);
@@ -752,14 +760,13 @@ import java.util.regex.Pattern;
                     // to is identical to the plot's home location, and untrusted-visit is true
                     // i.e. untrusted-visit can override deny-teleport
                     // this is acceptable, because otherwise it wouldn't make sense to have both flags set
-                if (!result && !(plot.getFlag(UntrustedVisitFlag.class) && plot.getHomeSynchronous()
+                    if (!result && !(plot.getFlag(UntrustedVisitFlag.class) && plot.getHomeSynchronous().equals(BukkitUtil.adaptComplete(to)))) {
-                    .equals(BukkitUtil.adaptComplete(to)))) {
+                        MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_ENTRY_DENIED);
-                    MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
-                        Captions.PERMISSION_ADMIN_ENTRY_DENIED);
                         event.setCancelled(true);
                     }
                 }
             }
+        }
         playerMove(event);
     }
 
@@ -847,19 +854,29 @@ import java.util.regex.Pattern;
             }
             // Set last location
             Location location = BukkitUtil.adapt(to);
-            pp.setMeta(PlotPlayer.META_LOCATION, location);
+            try (final MetaDataAccess<Location> lastLocationAccess =
+                pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
+                lastLocationAccess.remove();
+            }
             PlotArea area = location.getPlotArea();
             if (area == null) {
-                pp.deleteMeta(PlotPlayer.META_LAST_PLOT);
+                try (final MetaDataAccess<Plot> lastPlotAccess =
+                    pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+                    lastPlotAccess.remove();
+                }
                 return;
             }
             Plot now = area.getPlot(location);
-            Plot lastPlot = pp.getMeta(PlotPlayer.META_LAST_PLOT);
+            Plot lastPlot;
+            try (final MetaDataAccess<Plot> lastPlotAccess =
+                pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+                lastPlot = lastPlotAccess.get().orElse(null);
+            }
             if (now == null) {
-                if (lastPlot != null && !plotExit(pp, lastPlot) && this.tmpTeleport && !pp
+                try (final MetaDataAccess<Boolean> kickAccess =
-                    .getMeta("kick", false)) {
+                    pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_KICK)) {
-                    MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
+                    if (lastPlot != null && !plotExit(pp, lastPlot) && this.tmpTeleport && !kickAccess.get().orElse(false)) {
-                        Captions.PERMISSION_ADMIN_EXIT_DENIED);
+                        MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_EXIT_DENIED);
                         this.tmpTeleport = false;
                         if (lastPlot.equals(BukkitUtil.adapt(from).getPlot())) {
                             player.teleport(from);
@@ -870,6 +887,7 @@ import java.util.regex.Pattern;
                         event.setCancelled(true);
                         return;
                     }
+                }
             } else if (now.equals(lastPlot)) {
                 ForceFieldListener.handleForcefield(player, pp, now);
             } else if (!plotEntry(pp, now) && this.tmpTeleport) {
@@ -909,19 +927,29 @@ import java.util.regex.Pattern;
             }
             // Set last location
             Location location = BukkitUtil.adapt(to);
-            pp.setMeta(PlotPlayer.META_LOCATION, location);
+            try (final MetaDataAccess<Location> lastLocationAccess =
+                pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
+                lastLocationAccess.set(location);
+            }
             PlotArea area = location.getPlotArea();
             if (area == null) {
-                pp.deleteMeta(PlotPlayer.META_LAST_PLOT);
+                try (final MetaDataAccess<Plot> lastPlotAccess =
+                    pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+                    lastPlotAccess.remove();
+                }
                 return;
             }
             Plot now = area.getPlot(location);
-            Plot lastPlot = pp.getMeta(PlotPlayer.META_LAST_PLOT);
+            Plot lastPlot;
+            try (final MetaDataAccess<Plot> lastPlotAccess =
+                pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+                lastPlot = lastPlotAccess.get().orElse(null);
+            }
             if (now == null) {
-                if (lastPlot != null && !plotExit(pp, lastPlot) && this.tmpTeleport && !pp
+                try (final MetaDataAccess<Boolean> kickAccess =
-                    .getMeta("kick", false)) {
+                    pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_KICK)) {
-                    MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
+                    if (lastPlot != null && !plotExit(pp, lastPlot) && this.tmpTeleport && !kickAccess.get().orElse(false)) {
-                        Captions.PERMISSION_ADMIN_EXIT_DENIED);
+                        MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_EXIT_DENIED);
                         this.tmpTeleport = false;
                         if (lastPlot.equals(BukkitUtil.adapt(from).getPlot())) {
                             player.teleport(from);
@@ -932,6 +960,7 @@ import java.util.regex.Pattern;
                         event.setCancelled(true);
                         return;
                     }
+                }
             } else if (now.equals(lastPlot)) {
                 ForceFieldListener.handleForcefield(player, pp, now);
             } else if (!plotEntry(pp, now) && this.tmpTeleport) {
@@ -1155,8 +1184,15 @@ import java.util.regex.Pattern;
         Player player = event.getPlayer();
         BukkitPlayer pp = BukkitUtil.adapt(player);
         // Delete last location
-        Plot plot = (Plot) pp.deleteMeta(PlotPlayer.META_LAST_PLOT);
+        Plot plot;
-        pp.deleteMeta(PlotPlayer.META_LOCATION);
+        try (final MetaDataAccess<Plot> lastPlotAccess =
+            pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+            plot = lastPlotAccess.remove();
+        }
+        try (final MetaDataAccess<Location> lastLocationAccess =
+            pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
+            lastLocationAccess.remove();
+        }
         if (plot != null) {
             plotExit(pp, plot);
         }
@@ -1168,7 +1204,10 @@ import java.util.regex.Pattern;
             }
         }
         if (Settings.Enabled_Components.PERMISSION_CACHE) {
-            pp.deleteMeta("perm");
+            try (final MetaDataAccess<Map<String, Boolean>> metaDataAccess =
+                pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_PERMISSIONS)) {
+                metaDataAccess.remove();
+            }
         }
         Location location = pp.getLocation();
         PlotArea area = location.getPlotArea();

Bukkit/src/main/java/com/plotsquared/bukkit/player/BukkitPlayer.java

@@ -72,11 +72,11 @@ import static com.sk89q.worldedit.world.gamemode.GameModes.SURVIVAL;
 public class BukkitPlayer extends PlotPlayer<Player> {
 
     private static boolean CHECK_EFFECTIVE = true;
-
-    private final EconHandler econHandler;
     public final Player player;
+    private final EconHandler econHandler;
     private String name;
-
+    private String lastMessage = "";
+    private long lastMessageTime = 0L;
     /**
      * <p>Please do not use this method. Instead use
      * BukkitUtil.getPlayer(Player), as it caches player objects.</p>
@@ -220,10 +220,10 @@ public class BukkitPlayer extends PlotPlayer<Player> {
 
     @Override public void sendMessage(String message) {
         message = message.replace('\u2010', '%').replace('\u2020', '&').replace('\u2030', '&');
-        if (!StringMan.isEqual(this.getMeta("lastMessage"), message) || (
+        if (!StringMan.isEqual(this.lastMessage, message) || (
-            System.currentTimeMillis() - this.<Long>getMeta("lastMessageTime") > 5000)) {
+            System.currentTimeMillis() - this.lastMessageTime > 5000)) {
-            setMeta("lastMessage", message);
+            this.lastMessage = message;
-            setMeta("lastMessageTime", System.currentTimeMillis());
+            this.lastMessageTime = System.currentTimeMillis();
             this.player.sendMessage(message);
         }
     }

Bukkit/src/main/java/com/plotsquared/bukkit/queue/BukkitLocalQueue.java

@@ -29,7 +29,7 @@ import com.plotsquared.bukkit.schematic.StateWrapper;
 import com.plotsquared.bukkit.util.BukkitBlockUtil;
 import com.plotsquared.core.queue.BasicLocalBlockQueue;
 import com.plotsquared.core.util.BlockUtil;
-import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.util.ChunkUtil;
 import com.sk89q.jnbt.CompoundTag;
 import com.sk89q.worldedit.EditSession;
 import com.sk89q.worldedit.WorldEdit;
@@ -48,8 +48,8 @@ import org.bukkit.block.Biome;
 import org.bukkit.block.Block;
 import org.bukkit.block.Container;
 import org.bukkit.block.data.BlockData;
-import javax.annotation.Nonnull;
 
+import javax.annotation.Nonnull;
 import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 
@@ -125,9 +125,9 @@ public class BukkitLocalQueue extends BasicLocalBlockQueue {
                     for (int j = 0; j < blocksLayer.length; j++) {
                         if (blocksLayer[j] != null) {
                             BaseBlock block = blocksLayer[j];
-                            int x = MainUtil.x_loc[layer][j];
+                            int x = ChunkUtil.getX(j);
-                            int y = MainUtil.y_loc[layer][j];
+                            int y = ChunkUtil.getY(layer, j);
-                            int z = MainUtil.z_loc[layer][j];
+                            int z = ChunkUtil.getZ(j);
 
                             BlockData blockData = BukkitAdapter.adapt(block);
 

Core/src/main/java/com/plotsquared/core/command/Area.java

@@ -27,8 +27,6 @@ package com.plotsquared.core.command;
 
 import com.google.inject.Inject;
 import com.plotsquared.core.PlotSquared;
-import com.plotsquared.core.inject.annotations.WorldConfig;
-import com.plotsquared.core.inject.annotations.WorldFile;
 import com.plotsquared.core.configuration.Captions;
 import com.plotsquared.core.configuration.ConfigurationSection;
 import com.plotsquared.core.configuration.ConfigurationUtil;
@@ -36,6 +34,8 @@ import com.plotsquared.core.configuration.file.YamlConfiguration;
 import com.plotsquared.core.events.TeleportCause;
 import com.plotsquared.core.generator.AugmentedUtils;
 import com.plotsquared.core.generator.HybridPlotWorld;
+import com.plotsquared.core.inject.annotations.WorldConfig;
+import com.plotsquared.core.inject.annotations.WorldFile;
 import com.plotsquared.core.inject.factory.HybridPlotWorldFactory;
 import com.plotsquared.core.location.Location;
 import com.plotsquared.core.player.ConsolePlayer;
@@ -72,16 +72,19 @@ import com.sk89q.worldedit.math.BlockVector2;
 import com.sk89q.worldedit.math.BlockVector3;
 import com.sk89q.worldedit.regions.CuboidRegion;
 import com.sk89q.worldedit.regions.Region;
-import javax.annotation.Nonnull;
 
+import javax.annotation.Nonnull;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.UUID;
 
 @CommandDeclaration(command = "area",
     permission = "plots.area",
@@ -101,6 +104,8 @@ public class Area extends SubCommand {
     private final WorldUtil worldUtil;
     private final RegionManager regionManager;
 
+    private final Map<UUID, Map<String, Object>> metaData = new HashMap<>();
+
     @Inject public Area(@Nonnull final PlotAreaManager plotAreaManager,
                         @WorldConfig @Nonnull final YamlConfiguration worldConfiguration,
                         @WorldFile @Nonnull final File worldFile,
@@ -264,14 +269,16 @@ public class Area extends SubCommand {
                     case 2:
                         switch (args[1].toLowerCase()) {
                             case "pos1": { // Set position 1
-                                HybridPlotWorld area = player.getMeta("area_create_area");
+                                HybridPlotWorld area = (HybridPlotWorld) metaData.computeIfAbsent(player.getUUID(), missingUUID -> new HashMap<>())
+                                    .get("area_create_area");
                                 if (area == null) {
                                     Captions.COMMAND_SYNTAX.send(player,
                                         "/plot area create [world[:id]] [<modifier>=<value>]...");
                                     return false;
                                 }
                                 Location location = player.getLocation();
-                                player.setMeta("area_pos1", location);
+                                metaData.computeIfAbsent(player.getUUID(), missingUUID -> new HashMap<>())
+                                    .put("area_pos1", location);
                                 Captions.SET_ATTRIBUTE.send(player, "area_pos1",
                                     location.getX() + "," + location.getZ());
                                 MainUtil.sendMessage(player,
@@ -280,14 +287,15 @@ public class Area extends SubCommand {
                                 return true;
                             }
                             case "pos2":  // Set position 2 and finish creation for type=2 (partial)
-                                final HybridPlotWorld area = player.getMeta("area_create_area");
+                                final HybridPlotWorld area = (HybridPlotWorld) metaData
+                                    .computeIfAbsent(player.getUUID(), missingUUID -> new HashMap<>()).get("area_create_area");
                                 if (area == null) {
                                     Captions.COMMAND_SYNTAX.send(player,
                                         "/plot area create [world[:id]] [<modifier>=<value>]...");
                                     return false;
                                 }
                                 Location pos1 = player.getLocation();
-                                Location pos2 = player.getMeta("area_pos1");
+                                Location pos2 = (Location) metaData.computeIfAbsent(player.getUUID(), missingUUID -> new HashMap<>()).get("area_pos1");
                                 int dx = Math.abs(pos1.getX() - pos2.getX());
                                 int dz = Math.abs(pos1.getZ() - pos2.getZ());
                                 int numX = Math.max(1,
@@ -500,7 +508,7 @@ public class Area extends SubCommand {
                             player.teleport(this.worldUtil.getSpawn(pa.getWorldName()),
                                 TeleportCause.COMMAND);
                         }
-                        player.setMeta("area_create_area", pa);
+                        metaData.computeIfAbsent(player.getUUID(), missingUUID -> new HashMap<>()).put("area_create_area", pa);
                         MainUtil.sendMessage(player,
                             "$1Go to the first corner and use: $2 " + getCommandString()
                                 + " create pos1");

Core/src/main/java/com/plotsquared/core/command/Auto.java

@@ -26,7 +26,6 @@
 package com.plotsquared.core.command;
 
 import com.google.common.collect.Lists;
-import com.google.common.primitives.Ints;
 import com.google.inject.Inject;
 import com.plotsquared.core.PlotSquared;
 import com.plotsquared.core.configuration.CaptionUtility;
@@ -37,6 +36,8 @@ import com.plotsquared.core.events.PlayerAutoPlotEvent;
 import com.plotsquared.core.events.PlotAutoMergeEvent;
 import com.plotsquared.core.events.Result;
 import com.plotsquared.core.events.TeleportCause;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.permissions.PermissionHandler;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
@@ -92,8 +93,10 @@ public class Auto extends SubCommand {
         }
         int diff = allowedPlots - currentPlots;
         if (diff - sizeX * sizeZ < 0) {
-            if (player.hasPersistentMeta("grantedPlots")) {
+            try (final MetaDataAccess<Integer> metaDataAccess = player.accessPersistentMetaData(
-                int grantedPlots = Ints.fromByteArray(player.getPersistentMeta("grantedPlots"));
+                PlayerMetaDataKeys.PERSISTENT_GRANTED_PLOTS)) {
+                if (metaDataAccess.isPresent()) {
+                    int grantedPlots = metaDataAccess.get().orElse(0);
                     if (diff < 0 && grantedPlots < sizeX * sizeZ) {
                         MainUtil.sendMessage(player, Captions.CANT_CLAIM_MORE_PLOTS);
                         return false;
@@ -103,18 +106,18 @@ public class Auto extends SubCommand {
                     } else {
                         int left = grantedPlots + diff < 0 ? 0 : diff - sizeX * sizeZ;
                         if (left == 0) {
-                        player.removePersistentMeta("grantedPlots");
+                            metaDataAccess.remove();
                         } else {
-                        player.setPersistentMeta("grantedPlots", Ints.toByteArray(left));
+                            metaDataAccess.set(left);
                         }
-                    MainUtil.sendMessage(player, Captions.REMOVED_GRANTED_PLOT,
+                        MainUtil.sendMessage(player, Captions.REMOVED_GRANTED_PLOT, "" + (grantedPlots - left), "" + left);
-                        "" + (grantedPlots - left), "" + left);
                     }
                 } else {
                     MainUtil.sendMessage(player, Captions.CANT_CLAIM_MORE_PLOTS);
                     return false;
                 }
             }
+        }
         return true;
     }
 
@@ -147,7 +150,10 @@ public class Auto extends SubCommand {
      */
     public static void autoClaimSafe(final PlotPlayer<?> player, final PlotArea area, PlotId start,
         final String schematic) {
-        player.setMeta(Auto.class.getName(), true);
+        try (final MetaDataAccess<Boolean> metaDataAccess =
+            player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_AUTO)) {
+            metaDataAccess.set(true);
+        }
         autoClaimFromDatabase(player, area, start, new RunnableVal<Plot>() {
             @Override public void run(final Plot plot) {
                 try {
@@ -253,10 +259,13 @@ public class Auto extends SubCommand {
             return false;
         }
         final int allowed_plots = player.getAllowedPlots();
-        if (!force && (player.getMeta(Auto.class.getName(), false) || !checkAllowedPlots(player,
+        try (final MetaDataAccess<Boolean> metaDataAccess =
+            player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_AUTO)) {
+            if (!force && (metaDataAccess.get().orElse(false) || !checkAllowedPlots(player,
                 plotarea, allowed_plots, size_x, size_z))) {
                 return false;
             }
+        }
 
         if (schematic != null && !schematic.isEmpty()) {
             if (!plotarea.hasSchematic(schematic)) {

Core/src/main/java/com/plotsquared/core/command/Claim.java

@@ -25,7 +25,6 @@
  */
 package com.plotsquared.core.command;
 
-import com.google.common.primitives.Ints;
 import com.google.inject.Inject;
 import com.plotsquared.core.configuration.CaptionUtility;
 import com.plotsquared.core.configuration.Captions;
@@ -36,6 +35,8 @@ import com.plotsquared.core.events.PlotMergeEvent;
 import com.plotsquared.core.events.Result;
 import com.plotsquared.core.location.Direction;
 import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.PlotArea;
@@ -85,32 +86,34 @@ public class Claim extends SubCommand {
         int currentPlots = Settings.Limit.GLOBAL ?
             player.getPlotCount() :
             player.getPlotCount(location.getWorldName());
+
+        final PlotArea area = plot.getArea();
+
+        try (final MetaDataAccess<Integer> metaDataAccess = player.accessPersistentMetaData(PlayerMetaDataKeys.PERSISTENT_GRANTED_PLOTS)) {
             int grants = 0;
             if (currentPlots >= player.getAllowedPlots() && !force) {
-            if (player.hasPersistentMeta("grantedPlots")) {
+                if (metaDataAccess.isPresent()) {
-                grants = Ints.fromByteArray(player.getPersistentMeta("grantedPlots"));
+                    grants = metaDataAccess.get().orElse(0);
                     if (grants <= 0) {
-                    player.removePersistentMeta("grantedPlots");
+                        metaDataAccess.remove();
                         return sendMessage(player, Captions.CANT_CLAIM_MORE_PLOTS);
                     }
                 } else {
                     return sendMessage(player, Captions.CANT_CLAIM_MORE_PLOTS);
                 }
             }
+
             if (!plot.canClaim(player)) {
                 return sendMessage(player, Captions.PLOT_IS_CLAIMED);
             }
-        final PlotArea area = plot.getArea();
             if (schematic != null && !schematic.isEmpty()) {
                 if (area.isSchematicClaimSpecify()) {
                     if (!area.hasSchematic(schematic)) {
-                    return sendMessage(player, Captions.SCHEMATIC_INVALID,
+                        return sendMessage(player, Captions.SCHEMATIC_INVALID, "non-existent: " + schematic);
-                        "non-existent: " + schematic);
                     }
-                if (!Permissions.hasPermission(player, CaptionUtility
+                    if (!Permissions.hasPermission(player, CaptionUtility.format(player, Captions.PERMISSION_CLAIM_SCHEMATIC.getTranslated(),
-                    .format(player, Captions.PERMISSION_CLAIM_SCHEMATIC.getTranslated(), schematic))
+                        schematic)) && !Permissions.hasPermission(player, Captions.PERMISSION_ADMIN_COMMAND_SCHEMATIC)
-                    && !Permissions
+                        && !force) {
-                    .hasPermission(player, Captions.PERMISSION_ADMIN_COMMAND_SCHEMATIC) && !force) {
                         return sendMessage(player, Captions.NO_SCHEMATIC_PERMISSION, schematic);
                     }
                 }
@@ -128,12 +131,13 @@ public class Claim extends SubCommand {
             }
             if (grants > 0) {
                 if (grants == 1) {
-                player.removePersistentMeta("grantedPlots");
+                    metaDataAccess.remove();
                 } else {
-                player.setPersistentMeta("grantedPlots", Ints.toByteArray(grants - 1));
+                    metaDataAccess.set(grants - 1);
                 }
                 sendMessage(player, Captions.REMOVED_GRANTED_PLOT, "1", (grants - 1));
             }
+        }
         int border = area.getBorder();
         if (border != Integer.MAX_VALUE && plot.getDistanceFromOrigin() > border && !force) {
             return !sendMessage(player, Captions.BORDER);

Core/src/main/java/com/plotsquared/core/command/CmdConfirm.java

@@ -26,19 +26,29 @@
 package com.plotsquared.core.command;
 
 import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.util.MainUtil;
 import com.plotsquared.core.util.task.TaskManager;
 import com.plotsquared.core.util.task.TaskTime;
 
+import javax.annotation.Nullable;
+
 public class CmdConfirm {
 
-    public static CmdInstance getPending(PlotPlayer<?> player) {
+    @Nullable public static CmdInstance getPending(PlotPlayer<?> player) {
-        return player.getMeta("cmdConfirm");
+        try (final MetaDataAccess<CmdInstance> metaDataAccess = player.accessTemporaryMetaData(
+            PlayerMetaDataKeys.TEMPORARY_CONFIRM)) {
+            return metaDataAccess.get().orElse(null);
+        }
     }
 
     public static void removePending(PlotPlayer<?> player) {
-        player.deleteMeta("cmdConfirm");
+        try (final MetaDataAccess<CmdInstance> metaDataAccess = player.accessTemporaryMetaData(
+            PlayerMetaDataKeys.TEMPORARY_CONFIRM)) {
+            metaDataAccess.remove();
+        }
     }
 
     public static void addPending(final PlotPlayer<?> player, String commandStr,
@@ -49,7 +59,10 @@ public class CmdConfirm {
         }
         TaskManager.runTaskLater(() -> {
             CmdInstance cmd = new CmdInstance(runnable);
-            player.setMeta("cmdConfirm", cmd);
+            try (final MetaDataAccess<CmdInstance> metaDataAccess = player.accessTemporaryMetaData(
+                PlayerMetaDataKeys.TEMPORARY_CONFIRM)) {
+                metaDataAccess.set(cmd);
+            }
         }, TaskTime.ticks(1L));
     }
 }

Core/src/main/java/com/plotsquared/core/command/DebugExec.java

@@ -409,46 +409,6 @@ public class DebugExec extends SubCommand {
                             }
                         }, "/plot debugexec list-scripts", "List of scripts");
                     return true;
-                case "allcmd":
-                    if (args.length < 3) {
-                        Captions.COMMAND_SYNTAX
-                            .send(player, "/plot debugexec allcmd <condition> <command>");
-                        return false;
-                    }
-                    long start = System.currentTimeMillis();
-                    Command cmd = MainCommand.getInstance().getCommand(args[3]);
-                    String[] params = Arrays.copyOfRange(args, 4, args.length);
-                    if ("true".equals(args[1])) {
-                        Location location = player.getMeta(PlotPlayer.META_LOCATION);
-                        Plot plot = player.getMeta(PlotPlayer.META_LAST_PLOT);
-                        for (Plot current : PlotSquared.get().getBasePlots()) {
-                            player.setMeta(PlotPlayer.META_LOCATION, current.getBottomAbs());
-                            player.setMeta(PlotPlayer.META_LAST_PLOT, current);
-                            cmd.execute(player, params, null, null);
-                        }
-                        if (location == null) {
-                            player.deleteMeta(PlotPlayer.META_LOCATION);
-                        } else {
-                            player.setMeta(PlotPlayer.META_LOCATION, location);
-                        }
-                        if (plot == null) {
-                            player.deleteMeta(PlotPlayer.META_LAST_PLOT);
-                        } else {
-                            player.setMeta(PlotPlayer.META_LAST_PLOT, plot);
-                        }
-                        player.sendMessage("&c> " + (System.currentTimeMillis() - start));
-                        return true;
-                    }
-                    init();
-                    this.scope.put("_2", params);
-                    this.scope.put("_3", cmd);
-                    script =
-                        "_1=PS.getBasePlots().iterator();while(_1.hasNext()){plot=_1.next();if("
-                            + args[1]
-                            + "){PlotPlayer.setMeta(\"location\",plot.getBottomAbs());PlotPlayer.setMeta(\"lastplot\",plot);_3.onCommand"
-                            + "(PlotPlayer,_2)}}";
-
-                    break;
                 case "all":
                     if (args.length < 3) {
                         Captions.COMMAND_SYNTAX

Core/src/main/java/com/plotsquared/core/command/Grant.java

@@ -30,6 +30,8 @@ import com.plotsquared.core.PlotSquared;
 import com.plotsquared.core.configuration.CaptionUtility;
 import com.plotsquared.core.configuration.Captions;
 import com.plotsquared.core.database.DBFunc;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.util.MainUtil;
 import com.plotsquared.core.util.Permissions;
@@ -42,7 +44,6 @@ import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.TimeoutException;
-import java.util.function.Consumer;
 
 @CommandDeclaration(command = "grant",
     category = CommandCategory.CLAIMING,
@@ -80,7 +81,20 @@ public class Grant extends Command {
                         MainUtil.sendMessage(player, Captions.INVALID_PLAYER);
                     } else {
                         final UUID uuid = uuids.toArray(new UUID[0])[0];
-                        final Consumer<byte[]> result = array -> {
+                        PlotPlayer<?> pp = PlotSquared.platform().getPlayerManager().getPlayerIfExists(uuid);
+                        if (pp != null) {
+                            try (final MetaDataAccess<Integer> access = pp.accessPersistentMetaData(
+                                PlayerMetaDataKeys.PERSISTENT_GRANTED_PLOTS)) {
+                                if (args[0].equalsIgnoreCase("check")) {
+                                    Captions.GRANTED_PLOTS.send(player, access.get().orElse(0));
+                                } else {
+                                    access.set(access.get().orElse(0) + 1);
+                                }
+                            }
+                        } else {
+                            DBFunc.getPersistentMeta(uuid, new RunnableVal<Map<String, byte[]>>() {
+                                @Override public void run(Map<String, byte[]> value) {
+                                    final byte[] array = value.get("grantedPlots");
                                     if (arg0.equals("check")) { // check
                                         int granted;
                                         if (array == null) {
@@ -99,23 +113,9 @@ public class Grant extends Command {
                                         boolean replace = array != null;
                                         String key = "grantedPlots";
                                         byte[] rawData = Ints.toByteArray(amount);
-
-                                PlotPlayer online = PlotSquared.platform().getPlayerManager().getPlayerIfExists(uuid);
-                                if (online != null) {
-                                    online.setPersistentMeta(key, rawData);
-                                } else {
                                         DBFunc.addPersistentMeta(uuid, key, rawData, replace);
                                     }
                                 }
-                        };
-                        PlotPlayer<?> pp = PlotSquared.platform().getPlayerManager().getPlayerIfExists(uuid);
-                        if (pp != null) {
-                            result.accept(player.getPersistentMeta("grantedPlots"));
-                        } else {
-                            DBFunc.getPersistentMeta(uuid, new RunnableVal<Map<String, byte[]>>() {
-                                @Override public void run(Map<String, byte[]> value) {
-                                    result.accept(value.get("grantedPlots"));
-                                }
                             });
                         }
                     }

Core/src/main/java/com/plotsquared/core/command/Inbox.java

@@ -25,7 +25,9 @@
  */
 package com.plotsquared.core.command;
 
+import com.google.inject.TypeLiteral;
 import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.player.MetaDataAccess;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.comment.CommentInbox;
@@ -34,6 +36,7 @@ import com.plotsquared.core.plot.comment.PlotComment;
 import com.plotsquared.core.util.MainUtil;
 import com.plotsquared.core.util.StringMan;
 import com.plotsquared.core.util.task.RunnableVal;
+import com.plotsquared.core.player.MetaDataKey;
 
 import java.util.List;
 
@@ -140,7 +143,10 @@ public class Inbox extends SubCommand {
                 StringMan.join(CommentManager.inboxes.keySet(), ", "));
             return false;
         }
-        player.setMeta("inbox:" + inbox.toString(), System.currentTimeMillis());
+        final MetaDataKey<Long> metaDataKey = MetaDataKey.of(String.format("inbox:%s", inbox.toString()), new TypeLiteral<Long>() {});
+        try (final MetaDataAccess<Long> metaDataAccess = player.accessTemporaryMetaData(metaDataKey)) {
+            metaDataAccess.set(System.currentTimeMillis());
+        }
         final int page;
         if (args.length > 1) {
             switch (args[1].toLowerCase()) {

Core/src/main/java/com/plotsquared/core/command/Load.java

@@ -28,6 +28,8 @@ package com.plotsquared.core.command;
 import com.google.inject.Inject;
 import com.plotsquared.core.configuration.Captions;
 import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.PlotArea;
@@ -43,6 +45,7 @@ import javax.annotation.Nonnull;
 
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.util.Collections;
 import java.util.List;
 
 @CommandDeclaration(command = "load",
@@ -86,9 +89,11 @@ public class Load extends SubCommand {
             return false;
         }
 
+        try (final MetaDataAccess<List<String>> metaDataAccess =
+            player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_SCHEMATICS)) {
             if (args.length != 0) {
                 if (args.length == 1) {
-                List<String> schematics = player.getMeta("plot_schematics");
+                    List<String> schematics = metaDataAccess.get().orElse(null);
                     if (schematics == null) {
                         // No schematics found:
                         MainUtil.sendMessage(player, Captions.LOAD_NULL);
@@ -122,8 +127,8 @@ public class Load extends SubCommand {
                             return;
                         }
                         PlotArea area = plot.getArea();
-                    this.schematicHandler.paste(taskSchematic, plot, 0, area.getMinBuildHeight(), 0, false,
+                        this.schematicHandler
-                            new RunnableVal<Boolean>() {
+                            .paste(taskSchematic, plot, 0, area.getMinBuildHeight(), 0, false, new RunnableVal<Boolean>() {
                                 @Override public void run(Boolean value) {
                                     plot.removeRunning();
                                     if (value) {
@@ -143,7 +148,7 @@ public class Load extends SubCommand {
 
             // list schematics
 
-        List<String> schematics = player.getMeta("plot_schematics");
+            List<String> schematics = metaDataAccess.get().orElse(null);
             if (schematics == null) {
                 plot.addRunning();
                 TaskManager.runTaskAsync(() -> {
@@ -153,17 +158,20 @@ public class Load extends SubCommand {
                         MainUtil.sendMessage(player, Captions.LOAD_FAILED);
                         return;
                     }
-                player.setMeta("plot_schematics", schematics1);
+                    metaDataAccess.set(schematics1);
                     displaySaves(player);
                 });
             } else {
                 displaySaves(player);
             }
+        }
         return true;
     }
 
     public void displaySaves(PlotPlayer<?> player) {
-        List<String> schematics = player.getMeta("plot_schematics");
+        try (final MetaDataAccess<List<String>> metaDataAccess =
+            player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_SCHEMATICS)) {
+            List<String> schematics = metaDataAccess.get().orElse(Collections.emptyList());
             for (int i = 0; i < Math.min(schematics.size(), 32); i++) {
                 try {
                     String schematic = schematics.get(i).split("\\.")[0];
@@ -171,8 +179,7 @@ public class Load extends SubCommand {
                     if (split.length < 5) {
                         continue;
                     }
-                String time =
+                    String time = secToTime((System.currentTimeMillis() / 1000) - Long.parseLong(split[0]));
-                    secToTime((System.currentTimeMillis() / 1000) - Long.parseLong(split[0]));
                     String world = split[1];
                     PlotId id = PlotId.fromString(split[2] + ';' + split[3]);
                     String size = split[4];
@@ -186,6 +193,7 @@ public class Load extends SubCommand {
             }
             MainUtil.sendMessage(player, Captions.LOAD_LIST);
         }
+    }
 
     public String secToTime(long time) {
         StringBuilder toreturn = new StringBuilder();

Core/src/main/java/com/plotsquared/core/command/MainCommand.java

@@ -31,6 +31,8 @@ import com.plotsquared.core.configuration.Captions;
 import com.plotsquared.core.configuration.Settings;
 import com.plotsquared.core.location.Location;
 import com.plotsquared.core.player.ConsolePlayer;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.PlotArea;
@@ -43,6 +45,7 @@ import com.plotsquared.core.util.task.RunnableVal3;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 
 /**
@@ -231,7 +234,11 @@ public class MainCommand extends Command {
         RunnableVal3<Command, Runnable, Runnable> confirm,
         RunnableVal2<Command, CommandResult> whenDone) {
         // Clear perm caching //
-        player.deleteMeta("perm");
+        try (final MetaDataAccess<Map<String, Boolean>> permAccess = player.accessTemporaryMetaData(
+            PlayerMetaDataKeys.TEMPORARY_PERMISSIONS)) {
+            permAccess.remove();
+        }
+
         // Optional command scope //
         Location location = null;
         Plot plot = null;
@@ -246,12 +253,17 @@ public class MainCommand extends Command {
                 Location newLoc = newPlot.getCenterSynchronous();
                 if (player.canTeleport(newLoc)) {
                     // Save meta
-                    location = player.getMeta(PlotPlayer.META_LOCATION);
+                    try (final MetaDataAccess<Location> locationMetaDataAccess
-                    plot = player.getMeta(PlotPlayer.META_LAST_PLOT);
+                        = player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
+                        location = locationMetaDataAccess.get().orElse(null);
+                        locationMetaDataAccess.set(newLoc);
+                    }
+                    try (final MetaDataAccess<Plot> plotMetaDataAccess
+                        = player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+                        plot = plotMetaDataAccess.get().orElse(null);
+                        plotMetaDataAccess.set(newPlot);
+                    }
                     tp = true;
-                    // Set loc
-                    player.setMeta(PlotPlayer.META_LOCATION, newLoc);
-                    player.setMeta(PlotPlayer.META_LAST_PLOT, newPlot);
                 } else {
                     Captions.BORDER.send(player);
                 }
@@ -304,15 +316,21 @@ public class MainCommand extends Command {
         }
         // Reset command scope //
         if (tp && !(player instanceof ConsolePlayer)) {
+            try (final MetaDataAccess<Location> locationMetaDataAccess
+                = player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
                 if (location == null) {
-                player.deleteMeta(PlotPlayer.META_LOCATION);
+                    locationMetaDataAccess.remove();
                 } else {
-                player.setMeta(PlotPlayer.META_LOCATION, location);
+                    locationMetaDataAccess.set(location);
                 }
+            }
+            try (final MetaDataAccess<Plot> plotMetaDataAccess
+                = player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
                 if (plot == null) {
-                player.deleteMeta(PlotPlayer.META_LAST_PLOT);
+                    plotMetaDataAccess.remove();
                 } else {
-                player.setMeta(PlotPlayer.META_LAST_PLOT, plot);
+                    plotMetaDataAccess.set(plot);
+                }
             }
         }
         return CompletableFuture.completedFuture(true);

Core/src/main/java/com/plotsquared/core/command/Save.java

@@ -28,6 +28,8 @@ package com.plotsquared.core.command;
 import com.google.inject.Inject;
 import com.plotsquared.core.configuration.Captions;
 import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.PlotId;
@@ -104,9 +106,9 @@ public class Save extends SubCommand {
                                 return;
                             }
                             MainUtil.sendMessage(player, Captions.SAVE_SUCCESS);
-                            List<String> schematics = player.getMeta("plot_schematics");
+                            try (final MetaDataAccess<List<String>> schematicAccess =
-                            if (schematics != null) {
+                                player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_SCHEMATICS)) {
-                                schematics.add(file + ".schem");
+                                schematicAccess.get().ifPresent(schematics -> schematics.add(file + ".schem"));
                             }
                         }
                     });

Core/src/main/java/com/plotsquared/core/command/Setup.java

@@ -29,6 +29,8 @@ import com.google.inject.Inject;
 import com.plotsquared.core.PlotSquared;
 import com.plotsquared.core.configuration.Captions;
 import com.plotsquared.core.generator.GeneratorWrapper;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.setup.SetupProcess;
 import com.plotsquared.core.setup.SetupStep;
@@ -72,14 +74,16 @@ public class Setup extends SubCommand {
     }
 
     @Override public boolean onCommand(PlotPlayer<?> player, String[] args) {
-        SetupProcess process = player.getMeta("setup");
+        try (final MetaDataAccess<SetupProcess> metaDataAccess =
+            player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_SETUP)) {
+            SetupProcess process = metaDataAccess.get().orElse(null);
             if (process == null) {
                 if (args.length > 0) {
                     MainUtil.sendMessage(player, Captions.SETUP_NOT_STARTED);
                     return true;
                 }
                 process = new SetupProcess();
-            player.setMeta("setup", process);
+                metaDataAccess.set(process);
                 this.setupUtils.updateGenerators();
                 SetupStep step = process.getCurrentStep();
                 step.announce(player);
@@ -91,7 +95,7 @@ public class Setup extends SubCommand {
                     process.back();
                     process.getCurrentStep().announce(player);
                 } else if ("cancel".equalsIgnoreCase(args[0])) {
-                player.deleteMeta("setup");
+                    metaDataAccess.remove();
                     MainUtil.sendMessage(player, Captions.SETUP_CANCELLED);
                 } else {
                     process.handleInput(player, args[0]);
@@ -103,11 +107,15 @@ public class Setup extends SubCommand {
                 process.getCurrentStep().announce(player);
             }
             return true;
-
+        }
     }
 
     @Override public Collection<Command> tab(PlotPlayer player, String[] args, boolean space) {
-        SetupProcess process = (SetupProcess) player.getMeta("setup"); // TODO use generics -> auto cast
+        SetupProcess process;
+        try (final MetaDataAccess<SetupProcess> metaDataAccess =
+            player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_SETUP)) {
+            process = metaDataAccess.get().orElse(null);
+        }
         if (process == null) {
             return Collections.emptyList();
         }

Core/src/main/java/com/plotsquared/core/listener/PlotListener.java

@@ -26,12 +26,14 @@
 package com.plotsquared.core.listener;
 
 import com.plotsquared.core.PlotSquared;
-import com.plotsquared.core.collection.ByteArrayUtilities;
 import com.plotsquared.core.configuration.Captions;
 import com.plotsquared.core.configuration.Settings;
 import com.plotsquared.core.events.PlotFlagRemoveEvent;
 import com.plotsquared.core.events.Result;
 import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.MetaDataKey;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.PlotArea;
@@ -71,6 +73,7 @@ import javax.annotation.Nullable;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.Optional;
 import java.util.UUID;
 
 public class PlotListener {
@@ -134,14 +137,16 @@ public class PlotListener {
             .hasPermission(player, "plots.admin.entry.denied")) {
             return false;
         }
-        Plot last = player.getMeta(PlotPlayer.META_LAST_PLOT);
+        try (final MetaDataAccess<Plot> lastPlot = player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+            Plot last = lastPlot.get().orElse(null);
             if ((last != null) && !last.getId().equals(plot.getId())) {
                 plotExit(player, last);
             }
             if (ExpireManager.IMP != null) {
                 ExpireManager.IMP.handleEntry(player, plot);
             }
-        player.setMeta(PlotPlayer.META_LAST_PLOT, plot);
+            lastPlot.set(plot);
+        }
         this.eventDispatcher.callEntry(player, plot);
         if (plot.hasOwner()) {
             // This will inherit values from PlotArea
@@ -177,8 +182,9 @@ public class PlotListener {
                 boolean flight = player.getFlight();
                 GameMode gamemode = player.getGameMode();
                 if (flight != (gamemode == GameModes.CREATIVE || gamemode == GameModes.SPECTATOR)) {
-                    player.setPersistentMeta("flight",
+                    try (final MetaDataAccess<Boolean> metaDataAccess = player.accessPersistentMetaData(PlayerMetaDataKeys.PERSISTENT_FLIGHT)) {
-                        ByteArrayUtilities.booleanToBytes(player.getFlight()));
+                        metaDataAccess.set(player.getFlight());
+                    }
                 }
                 player.setFlight(flyStatus == FlyFlag.FlyStatus.ENABLED);
             }
@@ -227,39 +233,47 @@ public class PlotListener {
             player.setWeather(plot.getFlag(WeatherFlag.class));
 
             ItemType musicFlag = plot.getFlag(MusicFlag.class);
+
+            try (final MetaDataAccess<Location> musicMeta =
+                player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_MUSIC)) {
                 if (musicFlag != null) {
                     final String rawId = musicFlag.getId();
                     if (rawId.contains("disc") || musicFlag == ItemTypes.AIR) {
                         Location location = player.getLocation();
-                    Location lastLocation = player.getMeta("music");
+                        Location lastLocation = musicMeta.get().orElse(null);
                         if (lastLocation != null) {
                             player.playMusic(lastLocation, musicFlag);
                             if (musicFlag == ItemTypes.AIR) {
-                            player.deleteMeta("music");
+                                musicMeta.remove();
                             }
                         }
                         if (musicFlag != ItemTypes.AIR) {
                             try {
-                            player.setMeta("music", location);
+                                musicMeta.set(location);
                                 player.playMusic(location, musicFlag);
                             } catch (Exception ignored) {
                             }
                         }
                     }
                 } else {
-                Location lastLoc = player.getMeta("music");
+                    musicMeta.get().ifPresent(lastLoc -> {
-                if (lastLoc != null) {
+                        musicMeta.remove();
-                    player.deleteMeta("music");
                         player.playMusic(lastLoc, ItemTypes.AIR);
+                    });
                 }
             }
+
             CommentManager.sendTitle(player, plot);
 
             if (titles && !player.getAttribute("disabletitles")) {
                 if (!Captions.TITLE_ENTERED_PLOT.getTranslated().isEmpty()
                     || !Captions.TITLE_ENTERED_PLOT_SUB.getTranslated().isEmpty()) {
                     TaskManager.runTaskLaterAsync(() -> {
-                        Plot lastPlot = player.getMeta(PlotPlayer.META_LAST_PLOT);
+                        Plot lastPlot = null;
+                        try (final MetaDataAccess<Plot> lastPlotAccess =
+                            player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+                            lastPlot = lastPlotAccess.get().orElse(null);
+                        }
                         if ((lastPlot != null) && plot.getId().equals(lastPlot.getId())) {
                             Map<String, String> replacements = new HashMap<>();
                             replacements.put("%x%", String.valueOf(lastPlot.getId().getX()));
@@ -296,21 +310,25 @@ public class PlotListener {
     }
 
     public boolean plotExit(final PlotPlayer<?> player, Plot plot) {
-        Object previous = player.deleteMeta(PlotPlayer.META_LAST_PLOT);
+        try (final MetaDataAccess<Plot> lastPlot = player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+            final Plot previous = lastPlot.remove();
             this.eventDispatcher.callLeave(player, plot);
             if (plot.hasOwner()) {
                 PlotArea pw = plot.getArea();
                 if (pw == null) {
                     return true;
                 }
+                try (final MetaDataAccess<Boolean> kickAccess =
+                    player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_KICK)) {
                     if (plot.getFlag(DenyExitFlag.class) && !Permissions
-                .hasPermission(player, Captions.PERMISSION_ADMIN_EXIT_DENIED) && !player
+                        .hasPermission(player, Captions.PERMISSION_ADMIN_EXIT_DENIED) &&
-                .getMeta("kick", false)) {
+                        !kickAccess.get().orElse(false)) {
                         if (previous != null) {
-                    player.setMeta(PlotPlayer.META_LAST_PLOT, previous);
+                            lastPlot.set(previous);
                         }
                         return false;
                     }
+                }
                 if (!plot.getFlag(GamemodeFlag.class).equals(GamemodeFlag.DEFAULT) || !plot
                     .getFlag(GuestGamemodeFlag.class).equals(GamemodeFlag.DEFAULT)) {
                     if (player.getGameMode() != pw.getGameMode()) {
@@ -346,10 +364,11 @@ public class PlotListener {
 
                 final FlyFlag.FlyStatus flyStatus = plot.getFlag(FlyFlag.class);
                 if (flyStatus != FlyFlag.FlyStatus.DEFAULT) {
-                if (player.hasPersistentMeta("flight")) {
+                    try (final MetaDataAccess<Boolean> metaDataAccess = player.accessPersistentMetaData(PlayerMetaDataKeys.PERSISTENT_FLIGHT)) {
-                    player.setFlight(
+                        final Optional<Boolean> value = metaDataAccess.get();
-                        ByteArrayUtilities.bytesToBoolean(player.getPersistentMeta("flight")));
+                        if (value.isPresent()) {
-                    player.removePersistentMeta("flight");
+                            player.setFlight(value.get());
+                            metaDataAccess.remove();
                         } else {
                             GameMode gameMode = player.getGameMode();
                             if (gameMode == GameModes.SURVIVAL || gameMode == GameModes.ADVENTURE) {
@@ -359,6 +378,7 @@ public class PlotListener {
                             }
                         }
                     }
+                }
 
                 if (plot.getFlag(TimeFlag.class) != TimeFlag.TIME_DISABLED.getValue().longValue()) {
                     player.setTime(Long.MAX_VALUE);
@@ -369,15 +389,18 @@ public class PlotListener {
                     player.setWeather(PlotWeather.RESET);
                 }
 
-            Location lastLoc = player.getMeta("music");
+                try (final MetaDataAccess<Location> musicAccess =
-            if (lastLoc != null) {
+                    player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_MUSIC)) {
-                player.deleteMeta("music");
+                    musicAccess.get().ifPresent(lastLoc -> {
+                        musicAccess.remove();
                         player.playMusic(lastLoc, ItemTypes.AIR);
+                    });
                 }
 
                 feedRunnable.remove(player.getUUID());
                 healRunnable.remove(player.getUUID());
             }
+        }
         return true;
     }
 

Core/src/main/java/com/plotsquared/core/player/ConsolePlayer.java

@@ -33,6 +33,7 @@ import com.plotsquared.core.events.TeleportCause;
 import com.plotsquared.core.inject.annotations.ConsoleActor;
 import com.plotsquared.core.location.Location;
 import com.plotsquared.core.permissions.PermissionHandler;
+import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.PlotArea;
 import com.plotsquared.core.plot.PlotWeather;
 import com.plotsquared.core.plot.world.PlotAreaManager;
@@ -43,6 +44,8 @@ import com.sk89q.worldedit.regions.CuboidRegion;
 import com.sk89q.worldedit.world.gamemode.GameMode;
 import com.sk89q.worldedit.world.gamemode.GameModes;
 import com.sk89q.worldedit.world.item.ItemType;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -128,8 +131,16 @@ public class ConsolePlayer extends PlotPlayer<Actor> {
     }
 
     @Override public void teleport(Location location, TeleportCause cause) {
-        setMeta(META_LAST_PLOT, location.getPlot());
+        try (final MetaDataAccess<Plot> lastPlot = accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
-        setMeta(META_LOCATION, location);
+            if (location.getPlot() == null) {
+                lastPlot.remove();
+            } else {
+                lastPlot.set(location.getPlot());
+            }
+        }
+        try (final MetaDataAccess<Location> locationMetaDataAccess = accessPersistentMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
+            locationMetaDataAccess.set(location);
+        }
     }
 
     @Override public String getName() {

Core/src/main/java/com/plotsquared/core/player/MetaDataAccess.java

@@ -0,0 +1,129 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.player;
+
+import com.plotsquared.core.synchronization.LockRepository;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Optional;
+
+/**
+ * Access to player meta data
+ *
+ * @param <T> Meta data type
+ */
+public abstract class MetaDataAccess<T> implements AutoCloseable {
+
+    private final PlotPlayer<?> player;
+    private final MetaDataKey<T> metaDataKey;
+    private final LockRepository.LockAccess lockAccess;
+    private boolean closed = false;
+
+    MetaDataAccess(@Nonnull final PlotPlayer<?> player, @Nonnull final MetaDataKey<T> metaDataKey,
+        @Nonnull final LockRepository.LockAccess lockAccess) {
+        this.player = player;
+        this.metaDataKey = metaDataKey;
+        this.lockAccess = lockAccess;
+    }
+
+    /**
+     * Check if the player has meta data stored with the given key
+     *
+     * @return {@code true} if player has meta data with this key, or
+     * {@code false}
+     */
+    public abstract boolean isPresent();
+
+    /**
+     * Remove the stored value meta data
+     *
+     * @return Old value, or {@code null}
+     */
+    @Nullable public abstract T remove();
+
+    /**
+     * Set the meta data value
+     *
+     * @param value New value
+     */
+    public abstract void set(@Nonnull final T value);
+
+    /**
+     * Get the stored meta data value
+     *
+     * @return Stored value, or {@link Optional#empty()}
+     */
+    @Nonnull public abstract Optional<T> get();
+
+    @Override public final void close() {
+        this.lockAccess.close();
+        this.closed = true;
+    }
+
+    /**
+     * Get the owner of the meta data
+     *
+     * @return Player
+     */
+    @Nonnull public PlotPlayer<?> getPlayer() {
+        return this.player;
+    }
+
+    /**
+     * Get the meta data key
+     *
+     * @return Meta data key
+     */
+    @Nonnull public MetaDataKey<T> getMetaDataKey() {
+        return this.metaDataKey;
+    }
+
+    /**
+     * Check whether or not the meta data access has been closed.
+     * After being closed, all attempts to access the meta data
+     * through the instance, will lead to {@link IllegalAccessException}
+     * being thrown
+     *
+     * @return {@code true} if the access has been closed
+     */
+    public boolean isClosed() {
+        return this.closed;
+    }
+
+    protected void checkClosed() {
+        if (this.closed) {
+            sneakyThrow(new IllegalAccessException("The meta data access instance has been closed"));
+        }
+    }
+
+    @SuppressWarnings("ALL")
+    private static <E extends Throwable> void sneakyThrow(final Throwable e) throws E {
+        throw (E) e;
+    }
+
+
+}

Core/src/main/java/com/plotsquared/core/player/MetaDataKey.java

@@ -0,0 +1,108 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.player;
+
+import com.google.common.base.Objects;
+import com.google.common.base.Preconditions;
+import com.google.inject.TypeLiteral;
+import com.plotsquared.core.synchronization.LockKey;
+
+import javax.annotation.Nonnull;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Key used to access meta data
+ *
+ * @param <T> Meta data type
+ */
+public final class MetaDataKey<T> {
+
+    private static final Map<String, MetaDataKey> keyMap = new HashMap<>();
+    private static final Object keyMetaData = new Object();
+
+    private final String key;
+    private final TypeLiteral<T> type;
+    private final LockKey lockKey;
+
+    private MetaDataKey(@Nonnull final String key, @Nonnull final TypeLiteral<T> type) {
+        this.key = Preconditions.checkNotNull(key, "Key may not be null");
+        this.type = Preconditions.checkNotNull(type, "Type may not be null");
+        this.lockKey = LockKey.of(this.key);
+    }
+
+    /**
+     * Get a new named lock key
+     *
+     * @param key Key name
+     * @param <T> Type
+     * @return MetaData key instance
+     */
+    @Nonnull public static <T> MetaDataKey<T> of(@Nonnull final String key, @Nonnull final TypeLiteral<T> type) {
+        synchronized (keyMetaData) {
+            return (MetaDataKey<T>)
+                keyMap.computeIfAbsent(key, missingKey -> new MetaDataKey<>(missingKey, type));
+        }
+    }
+
+    @Override public String toString() {
+        return this.key;
+    }
+
+    @Override public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        final MetaDataKey lockKey = (MetaDataKey) o;
+        return Objects.equal(this.key, lockKey.key);
+    }
+
+    @Override public int hashCode() {
+        return Objects.hashCode(this.key);
+    }
+
+    /**
+     * Get the {@link LockKey} associated with this key
+     *
+     * @return Lock key
+     */
+    @Nonnull public LockKey getLockKey() {
+        return this.lockKey;
+    }
+
+    /**
+     * Get the meta data type
+     *
+     * @return Meta data type
+     */
+    @Nonnull public TypeLiteral<T> getType() {
+        return this.type;
+    }
+
+}

Core/src/main/java/com/plotsquared/core/player/PersistentMetaDataAccess.java

@@ -0,0 +1,66 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.player;
+
+import com.plotsquared.core.synchronization.LockRepository;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Optional;
+
+final class PersistentMetaDataAccess<T> extends MetaDataAccess<T> {
+
+    PersistentMetaDataAccess(@Nonnull final PlotPlayer<?> player,
+                             @Nonnull final MetaDataKey<T> metaDataKey,
+                             @Nonnull final LockRepository.LockAccess lockAccess) {
+        super(player, metaDataKey, lockAccess);
+    }
+
+    @Override public boolean isPresent() {
+        this.checkClosed();
+        return this.getPlayer().hasPersistentMeta(getMetaDataKey().toString());
+    }
+
+    @Override @Nullable public T remove() {
+        this.checkClosed();
+        final Object old = this.getPlayer().removePersistentMeta(this.getMetaDataKey().toString());
+        if (old == null) {
+            return null;
+        }
+        return (T) old;
+    }
+
+    @Override public void set(@Nonnull T value) {
+        this.checkClosed();
+        this.getPlayer().setPersistentMeta(this.getMetaDataKey(), value);
+    }
+
+    @Nonnull @Override public Optional<T> get() {
+        this.checkClosed();
+        return Optional.ofNullable(this.getPlayer().getPersistentMeta(this.getMetaDataKey()));
+    }
+
+}

Core/src/main/java/com/plotsquared/core/player/PlayerMetaDataKeys.java

@@ -0,0 +1,62 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.player;
+
+import com.google.inject.TypeLiteral;
+import com.plotsquared.core.command.Auto;
+import com.plotsquared.core.command.CmdInstance;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotInventory;
+import com.plotsquared.core.setup.SetupProcess;
+
+import java.util.List;
+import java.util.Map;
+
+public final class PlayerMetaDataKeys {
+
+    //@formatter:off
+    public static final MetaDataKey<Boolean> PERSISTENT_FLIGHT = MetaDataKey.of("flight", new TypeLiteral<Boolean>() {});
+    public static final MetaDataKey<Integer> PERSISTENT_GRANTED_PLOTS = MetaDataKey.of("grantedPlots", new TypeLiteral<Integer>() {});
+
+    public static final MetaDataKey<Plot> TEMPORARY_LAST_PLOT = MetaDataKey.of("lastplot", new TypeLiteral<Plot>() {});
+    public static final MetaDataKey<Location> TEMPORARY_MUSIC = MetaDataKey.of("music", new TypeLiteral<Location>() {});
+    public static final MetaDataKey<Boolean> TEMPORARY_KICK = MetaDataKey.of("kick", new TypeLiteral<Boolean>() {});
+    public static final MetaDataKey<SetupProcess> TEMPORARY_SETUP = MetaDataKey.of("setup", new TypeLiteral<SetupProcess>() {});
+    public static final MetaDataKey<PlotInventory> TEMPORARY_INVENTORY = MetaDataKey.of("inventory", new TypeLiteral<PlotInventory>() {});
+    public static final MetaDataKey<Boolean> TEMPORARY_IGNORE_EXPIRE_TASK = MetaDataKey.of("ignoreExpireTask", new TypeLiteral<Boolean>() {});
+    public static final MetaDataKey<Plot> TEMPORARY_WORLD_EDIT_REGION_PLOT = MetaDataKey.of("WorldEditRegionPlot", new TypeLiteral<Plot>() {});
+    public static final MetaDataKey<Boolean> TEMPORARY_AUTO = MetaDataKey.of(Auto.class.getName(), new TypeLiteral<Boolean>() {});
+    public static final MetaDataKey<Map<String, Boolean>> TEMPORARY_PERMISSIONS = MetaDataKey.of("permissions", new TypeLiteral<Map<String, Boolean>>() {});
+    public static final MetaDataKey<List<String>> TEMPORARY_SCHEMATICS = MetaDataKey.of("plot_schematics", new TypeLiteral<List<String>>() {});
+    public static final MetaDataKey<Location> TEMPORARY_LOCATION = MetaDataKey.of("location", new TypeLiteral<Location>() {});
+    public static final MetaDataKey<CmdInstance> TEMPORARY_CONFIRM = MetaDataKey.of("cmdConfirm", new TypeLiteral<CmdInstance>() {});
+    //@formatter:on
+
+    private PlayerMetaDataKeys() {
+    }
+
+}

Core/src/main/java/com/plotsquared/core/player/PlotPlayer.java

@@ -26,7 +26,9 @@
 package com.plotsquared.core.player;
 
 import com.google.common.base.Preconditions;
+import com.google.common.primitives.Ints;
 import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.collection.ByteArrayUtilities;
 import com.plotsquared.core.command.CommandCaller;
 import com.plotsquared.core.command.RequiredType;
 import com.plotsquared.core.configuration.CaptionUtility;
@@ -48,6 +50,7 @@ import com.plotsquared.core.plot.flag.implementations.DoneFlag;
 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.synchronization.LockRepository;
 import com.plotsquared.core.util.EconHandler;
 import com.plotsquared.core.util.EventDispatcher;
 import com.plotsquared.core.util.Permissions;
@@ -81,9 +84,6 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer
 
     private static final Logger logger = LoggerFactory.getLogger("P2/" + PlotPlayer.class.getSimpleName());
 
-    public static final String META_LAST_PLOT = "lastplot";
-    public static final String META_LOCATION = "location";
-
     // Used to track debug mode
     private static final Set<PlotPlayer<?>> debugModeEnabled = Collections.synchronizedSet(new HashSet<>());
 
@@ -95,6 +95,8 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer
     private ConcurrentHashMap<String, Object> meta;
     private int hash;
 
+    private final LockRepository lockRepository = new LockRepository();
+
     private final PlotAreaManager plotAreaManager;
     private final EventDispatcher eventDispatcher;
     private final EconHandler econHandler;
@@ -155,7 +157,7 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer
      * @param key
      * @param value
      */
-    public void setMeta(String key, Object value) {
+    void setMeta(String key, Object value) {
         if (value == null) {
             deleteMeta(key);
         } else {
@@ -173,14 +175,14 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer
      * @param <T> the object type to return
      * @return the value assigned to the key or null if it does not exist
      */
-    public <T> T getMeta(String key) {
+    <T> T getMeta(String key) {
         if (this.meta != null) {
             return (T) this.meta.get(key);
         }
         return null;
     }
 
-    public <T> T getMeta(String key, T defaultValue) {
+    <T> T getMeta(String key, T defaultValue) {
         T meta = getMeta(key);
         if (meta == null) {
             return defaultValue;
@@ -199,7 +201,7 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer
      *
      * @param key
      */
-    public Object deleteMeta(String key) {
+    Object deleteMeta(String key) {
         return this.meta == null ? null : this.meta.remove(key);
     }
 
@@ -218,11 +220,13 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer
      * @return the plot the player is standing on or null if standing on a road or not in a {@link PlotArea}
      */
     public Plot getCurrentPlot() {
-        Plot value = getMeta(PlotPlayer.META_LAST_PLOT);
+        try (final MetaDataAccess<Plot> lastPlotAccess =
-        if (value == null && !Settings.Enabled_Components.EVENTS) {
+            this.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
-            return getLocation().getPlot();
+            if (lastPlotAccess.get().orElse(null) == null && !Settings.Enabled_Components.EVENTS) {
+                return this.getLocation().getPlot();
+            }
+            return lastPlotAccess.get().orElse(null);
         }
-        return value;
     }
 
     /**
@@ -694,18 +698,85 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer
         }
     }
 
-    public byte[] getPersistentMeta(String key) {
+    byte[] getPersistentMeta(String key) {
         return this.metaMap.get(key);
     }
 
-    public void removePersistentMeta(String key) {
+    Object removePersistentMeta(String key) {
-        this.metaMap.remove(key);
+        final Object old = this.metaMap.remove(key);
         if (Settings.Enabled_Components.PERSISTENT_META) {
             DBFunc.removePersistentMeta(getUUID(), key);
         }
+        return old;
     }
 
-    public void setPersistentMeta(String key, byte[] value) {
+    /**
+     * Access keyed persistent meta data for this player. This returns a meta data
+     * access instance, that MUST be closed. It is meant to be used with try-with-resources,
+     * like such:
+     * <pre>{@code
+     * try (final MetaDataAccess<Integer> access = player.accessPersistentMetaData(PlayerMetaKeys.GRANTS)) {
+     *     int grants = access.get();
+     *     access.set(grants + 1);
+     * }
+     * }</pre>
+     *
+     * @param key Meta data key
+     * @param <T> Meta data type
+     * @return Meta data access. MUST be closed after being used
+     */
+    @Nonnull public <T> MetaDataAccess<T> accessPersistentMetaData(@Nonnull final MetaDataKey<T> key) {
+        return new PersistentMetaDataAccess<>(this, key, this.lockRepository.lock(key.getLockKey()));
+    }
+
+    /**
+     * Access keyed temporary meta data for this player. This returns a meta data
+     * access instance, that MUST be closed. It is meant to be used with try-with-resources,
+     * like such:
+     * <pre>{@code
+     * try (final MetaDataAccess<Integer> access = player.accessTemporaryMetaData(PlayerMetaKeys.GRANTS)) {
+     *     int grants = access.get();
+     *     access.set(grants + 1);
+     * }
+     * }</pre>
+     *
+     * @param key Meta data key
+     * @param <T> Meta data type
+     * @return Meta data access. MUST be closed after being used
+     */
+    @Nonnull public <T> MetaDataAccess<T> accessTemporaryMetaData(@Nonnull final MetaDataKey<T> key) {
+        return new TemporaryMetaDataAccess<>(this, key, this.lockRepository.lock(key.getLockKey()));
+    }
+
+    <T> void setPersistentMeta(@Nonnull final MetaDataKey<T> key,
+                               @Nonnull final T value) {
+        final Object rawValue = value;
+        if (key.getType().getRawType().equals(Integer.class)) {
+            this.setPersistentMeta(key.toString(), Ints.toByteArray((int) rawValue));
+        } else if (key.getType().getRawType().equals(Boolean.class)) {
+            this.setPersistentMeta(key.toString(), ByteArrayUtilities.booleanToBytes((boolean) rawValue));
+        } else {
+            throw new IllegalArgumentException(String.format("Unknown meta data type '%s'", key.getType().toString()));
+        }
+    }
+
+    @Nullable <T> T getPersistentMeta(@Nonnull final MetaDataKey<T> key) {
+        final byte[] value = this.getPersistentMeta(key.toString());
+        if (value == null) {
+            return null;
+        }
+        final Object returnValue;
+        if (key.getType().getRawType().equals(Integer.class)) {
+            returnValue = Ints.fromByteArray(value);
+        } else if (key.getType().getRawType().equals(Boolean.class)) {
+            returnValue = ByteArrayUtilities.bytesToBoolean(value);
+        } else {
+            throw new IllegalArgumentException(String.format("Unknown meta data type '%s'", key.getType().toString()));
+        }
+        return (T) returnValue;
+    }
+
+    void setPersistentMeta(String key, byte[] value) {
         boolean delete = hasPersistentMeta(key);
         this.metaMap.put(key, value);
         if (Settings.Enabled_Components.PERSISTENT_META) {
@@ -713,7 +784,7 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer
         }
     }
 
-    public boolean hasPersistentMeta(String key) {
+    boolean hasPersistentMeta(String key) {
         return this.metaMap.containsKey(key);
     }
 
@@ -757,6 +828,15 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer
         }
     }
 
+    /**
+     * Get this player's {@link LockRepository}
+     *
+     * @return Lock repository instance
+     */
+    @Nonnull public LockRepository getLockRepository() {
+        return this.lockRepository;
+    }
+
     @FunctionalInterface
     public interface PlotPlayerConverter<BaseObject> {
         PlotPlayer<?> convert(BaseObject object);

Core/src/main/java/com/plotsquared/core/player/TemporaryMetaDataAccess.java

@@ -0,0 +1,66 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.player;
+
+import com.plotsquared.core.synchronization.LockRepository;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.Optional;
+
+final class TemporaryMetaDataAccess<T> extends MetaDataAccess<T> {
+
+    TemporaryMetaDataAccess(@Nonnull final PlotPlayer<?> player,
+                            @Nonnull final MetaDataKey<T> metaDataKey,
+                            @Nonnull final LockRepository.LockAccess lockAccess) {
+        super(player, metaDataKey, lockAccess);
+    }
+
+    @Override public boolean isPresent() {
+        this.checkClosed();
+        return this.getPlayer().getMeta(this.getMetaDataKey().toString()) != null;
+    }
+
+    @Override @Nullable public T remove() {
+        this.checkClosed();
+        final Object old = getPlayer().deleteMeta(this.getMetaDataKey().toString());
+        if (old == null) {
+            return null;
+        }
+        return (T) old;
+    }
+
+    @Override public void set(@Nonnull T value) {
+        this.checkClosed();
+        this.getPlayer().setMeta(this.getMetaDataKey().toString(), null);
+    }
+
+    @Nonnull @Override public Optional<T> get() {
+        this.checkClosed();
+        return Optional.ofNullable(this.getPlayer().getMeta(this.getMetaDataKey().toString()));
+    }
+
+}

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

@@ -42,6 +42,8 @@ import com.plotsquared.core.inject.annotations.WorldConfig;
 import com.plotsquared.core.location.Direction;
 import com.plotsquared.core.location.Location;
 import com.plotsquared.core.location.PlotLoc;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.flag.FlagContainer;
 import com.plotsquared.core.plot.flag.FlagParseException;
@@ -787,8 +789,11 @@ public abstract class PlotArea {
     }
 
     public boolean addPlot(@Nonnull final Plot plot) {
-        for (PlotPlayer pp : plot.getPlayersInPlot()) {
+        for (final PlotPlayer<?> pp : plot.getPlayersInPlot()) {
-            pp.setMeta(PlotPlayer.META_LAST_PLOT, plot);
+            try (final MetaDataAccess<Plot> metaDataAccess = pp.accessTemporaryMetaData(
+                PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+                metaDataAccess.set(plot);
+            }
         }
         return this.plots.put(plot.getId(), plot) == null;
     }
@@ -826,8 +831,11 @@ public abstract class PlotArea {
 
     public boolean addPlotIfAbsent(@Nonnull final Plot plot) {
         if (this.plots.putIfAbsent(plot.getId(), plot) == null) {
-            for (PlotPlayer pp : plot.getPlayersInPlot()) {
+            for (PlotPlayer<?> pp : plot.getPlayersInPlot()) {
-                pp.setMeta(PlotPlayer.META_LAST_PLOT, plot);
+                try (final MetaDataAccess<Plot> metaDataAccess = pp.accessTemporaryMetaData(
+                    PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+                    metaDataAccess.set(plot);
+                }
             }
             return true;
         }

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

@@ -25,18 +25,19 @@
  */
 package com.plotsquared.core.plot;
 
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.util.InventoryUtil;
-
-import javax.annotation.Nonnull;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import javax.annotation.Nonnull;
+
 public class PlotInventory {
 
     private static final Logger logger = LoggerFactory.getLogger("P2/" + PlotInventory.class.getSimpleName());
 
-    private static final String META_KEY = "inventory";
     public final PlotPlayer<?> player;
     public final int size;
     private final PlotItemStack[] items;
@@ -58,16 +59,25 @@ public class PlotInventory {
     }
 
     public static PlotInventory getOpenPlotInventory(@Nonnull final PlotPlayer<?> plotPlayer) {
-        return plotPlayer.getMeta(META_KEY, null);
+        try (final MetaDataAccess<PlotInventory> inventoryAccess = plotPlayer.accessTemporaryMetaData(
+            PlayerMetaDataKeys.TEMPORARY_INVENTORY)) {
+            return inventoryAccess.get().orElse(null);
+        }
     }
 
     public static void setPlotInventoryOpen(@Nonnull final PlotPlayer<?> plotPlayer,
         @Nonnull final PlotInventory plotInventory) {
-        plotPlayer.setMeta(META_KEY, plotInventory);
+        try (final MetaDataAccess<PlotInventory> inventoryAccess = plotPlayer.accessTemporaryMetaData(
+            PlayerMetaDataKeys.TEMPORARY_INVENTORY)) {
+            inventoryAccess.set(plotInventory);
+        }
     }
 
     public static void removePlotInventoryOpen(@Nonnull final PlotPlayer<?>plotPlayer) {
-        plotPlayer.deleteMeta(META_KEY);
+        try (final MetaDataAccess<PlotInventory> inventoryAccess = plotPlayer.accessTemporaryMetaData(
+            PlayerMetaDataKeys.TEMPORARY_INVENTORY)) {
+            inventoryAccess.remove();
+        }
     }
 
     public boolean onClick(int index) {

Core/src/main/java/com/plotsquared/core/plot/comment/CommentManager.java

@@ -26,8 +26,11 @@
 package com.plotsquared.core.plot.comment;
 
 import com.google.common.annotations.Beta;
+import com.google.inject.TypeLiteral;
 import com.plotsquared.core.configuration.Captions;
 import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.MetaDataKey;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.util.task.RunnableVal;
@@ -77,7 +80,10 @@ import java.util.concurrent.atomic.AtomicInteger;
     }
 
     public static long getTimestamp(PlotPlayer<?> player, String inbox) {
-        return player.getMeta("inbox:" + inbox, player.getLastPlayed());
+        final MetaDataKey<Long> inboxKey = MetaDataKey.of(String.format("inbox:%s", inbox), new TypeLiteral<Long>() {});
+        try (final MetaDataAccess<Long> inboxAccess = player.accessTemporaryMetaData(inboxKey)) {
+            return inboxAccess.get().orElse(player.getLastPlayed());
+        }
     }
 
     public static void addInbox(CommentInbox inbox) {

Core/src/main/java/com/plotsquared/core/plot/expiration/ExpireManager.java

@@ -31,7 +31,9 @@ import com.plotsquared.core.database.DBFunc;
 import com.plotsquared.core.events.PlotFlagAddEvent;
 import com.plotsquared.core.events.PlotUnlinkEvent;
 import com.plotsquared.core.events.Result;
+import com.plotsquared.core.player.MetaDataAccess;
 import com.plotsquared.core.player.OfflinePlotPlayer;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.PlotArea;
@@ -137,35 +139,32 @@ public class ExpireManager {
         }
     }
 
-    public void confirmExpiry(final PlotPlayer pp) {
+    public void confirmExpiry(final PlotPlayer<?> pp) {
-        if (pp.getMeta("ignoreExpireTask") != null) {
+        try (final MetaDataAccess<Boolean> metaDataAccess = pp.accessTemporaryMetaData(
+            PlayerMetaDataKeys.TEMPORARY_IGNORE_EXPIRE_TASK)) {
+            if (metaDataAccess.isPresent()) {
                 return;
             }
-        if (plotsToDelete != null && !plotsToDelete.isEmpty() && pp
+            if (plotsToDelete != null && !plotsToDelete.isEmpty() && pp.hasPermission("plots.admin.command.autoclear")) {
-            .hasPermission("plots.admin.command.autoclear")) {
                 final int num = plotsToDelete.size();
                 while (!plotsToDelete.isEmpty()) {
                     Iterator<Plot> iter = plotsToDelete.iterator();
                     final Plot current = iter.next();
                     if (!isExpired(new ArrayDeque<>(tasks), current).isEmpty()) {
                         TaskManager.runTask(() -> {
-                        pp.setMeta("ignoreExpireTask", true);
+                            metaDataAccess.set(true);
                             current.getCenter(pp::teleport);
-                        pp.deleteMeta("ignoreExpireTask");
+                            metaDataAccess.remove();
-                        PlotMessage msg = new PlotMessage()
+                            PlotMessage msg = new PlotMessage().text(
-                            .text(num + " " + (num > 1 ? "plots are" : "plot is") + " expired: ")
+                                num + " " + (num > 1 ? "plots are" : "plot is") + " expired: ").color("$1").text(current.toString()).color("$2")
-                            .color("$1").text(current.toString()).color("$2")
                                 .command("/plot list expired").tooltip("/plot list expired")
                                 //.text("\n - ").color("$3").text("Delete all (/plot delete expired)").color("$2").command("/plot delete expired")
-                            .text("\n - ").color("$3").text("Delete this (/plot delete)")
+                                .text("\n - ").color("$3").text("Delete this (/plot delete)").color("$2").command("/plot delete").tooltip("/plot delete")
-                            .color("$2").command("/plot delete").tooltip("/plot delete")
+                                .text("\n - ").color("$3").text("Remind later (/plot flag set keep 1d)").color("$2")
-                            .text("\n - ").color("$3").text("Remind later (/plot flag set keep 1d)")
+                                .command("/plot flag set keep 1d").tooltip("/plot flag set keep 1d")
-                            .color("$2").command("/plot flag set keep 1d").tooltip("/plot flag set keep 1d")
+                                .text("\n - ").color("$3").text("Keep this (/plot flag set keep true)").color("$2")
-                            .text("\n - ").color("$3").text("Keep this (/plot flag set keep true)")
+                                .command("/plot flag set keep true").tooltip("/plot flag set keep true").text("\n - ").color("$3")
-                            .color("$2").command("/plot flag set keep true")
+                                .text("Don't show me this").color("$2").command("/plot toggle clear-confirmation")
-                            .tooltip("/plot flag set keep true").text("\n - ").color("$3")
-                            .text("Don't show me this").color("$2")
-                            .command("/plot toggle clear-confirmation")
                                 .tooltip("/plot toggle clear-confirmation");
                             msg.send(pp);
                         });
@@ -177,6 +176,7 @@ public class ExpireManager {
                 plotsToDelete.clear();
             }
         }
+    }
 
 
     public boolean cancelTask() {

Core/src/main/java/com/plotsquared/core/queue/BasicLocalBlockQueue.java

@@ -25,7 +25,7 @@
  */
 package com.plotsquared.core.queue;
 
-import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.util.ChunkUtil;
 import com.plotsquared.core.util.MathMan;
 import com.plotsquared.core.util.PatternUtil;
 import com.plotsquared.core.util.task.TaskManager;
@@ -262,8 +262,8 @@ public abstract class BasicLocalBlockQueue extends LocalBlockQueue {
         }
 
         private void setInternal(final int x, final int y, final int z, final BaseBlock baseBlock) {
-            final int i = MainUtil.CACHE_I[y][x][z];
+            final int i = y >> 4;
-            final int j = MainUtil.CACHE_J[y][x][z];
+            final int j = ChunkUtil.getJ(x, y, z);
             BaseBlock[] array = baseblocks[i];
             if (array == null) {
                 array = (baseblocks[i] = new BaseBlock[4096]);

Core/src/main/java/com/plotsquared/core/setup/CommonSetupSteps.java

@@ -30,6 +30,8 @@ import com.plotsquared.core.configuration.Caption;
 import com.plotsquared.core.configuration.Captions;
 import com.plotsquared.core.events.TeleportCause;
 import com.plotsquared.core.generator.GeneratorWrapper;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.PlotArea;
 import com.plotsquared.core.plot.PlotAreaTerrainType;
@@ -221,7 +223,10 @@ public enum CommonSetupSteps implements SetupStep {
                 MainUtil.sendMessage(plotPlayer, Captions.SETUP_WORLD_APPLY_PLOTSQUARED);
             }
             builder.worldName(argument);
-            plotPlayer.deleteMeta("setup");
+            try (final MetaDataAccess<SetupProcess> setupAccess = plotPlayer.accessTemporaryMetaData(
+                PlayerMetaDataKeys.TEMPORARY_SETUP)) {
+                setupAccess.remove();
+            }
             String world;
             if (builder.setupManager() == null) {
                 world = PlotSquared.platform().getInjector().getInstance(SetupUtils.class).setupWorld(builder);

Core/src/main/java/com/plotsquared/core/synchronization/LockKey.java

@@ -0,0 +1,92 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.synchronization;
+
+import com.google.common.base.Objects;
+import com.google.common.base.Preconditions;
+
+import javax.annotation.Nonnull;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Key used to access {@link java.util.concurrent.locks.Lock locks}
+ * from a {@link LockRepository}
+ */
+public final class LockKey {
+
+    private static final Map<String, LockKey> keyMap = new HashMap<>();
+    private static final Object keyLock = new Object();
+
+    private final String key;
+
+    private LockKey(@Nonnull final String key) {
+        this.key = Preconditions.checkNotNull(key, "Key may not be null");
+    }
+
+    /**
+     * Get a new named lock key
+     *
+     * @param key Key name
+     * @return Lock key instance
+     */
+    @Nonnull public static LockKey of(@Nonnull final String key) {
+        synchronized (keyLock) {
+            return keyMap.computeIfAbsent(key, LockKey::new);
+        }
+    }
+
+    /**
+     * Get all currently recognized lock keys
+     *
+     * @return Currently recognized lock keys
+     */
+    @Nonnull static Collection<LockKey> recognizedKeys() {
+        return Collections.unmodifiableCollection(keyMap.values());
+    }
+
+    @Override public String toString() {
+        return "LockKey{" + "key='" + key + '\'' + '}';
+    }
+
+    @Override public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        final LockKey lockKey = (LockKey) o;
+        return Objects.equal(this.key, lockKey.key);
+    }
+
+    @Override public int hashCode() {
+        return Objects.hashCode(this.key);
+    }
+
+}

Core/src/main/java/com/plotsquared/core/synchronization/LockRepository.java

@@ -0,0 +1,116 @@
+/*
+ *       _____  _       _    _____                                _
+ *      |  __ \| |     | |  / ____|                              | |
+ *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
+ *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
+ *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
+ *                                    | |
+ *                                    |_|
+ *            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.synchronization;
+
+import com.google.common.util.concurrent.Striped;
+
+import javax.annotation.Nonnull;
+import java.util.concurrent.locks.Lock;
+import java.util.function.Consumer;
+
+/**
+ * A repository for keyed {@link java.util.concurrent.locks.Lock locks}
+ */
+public final class LockRepository {
+
+    private final Striped<Lock> striped;
+
+    public LockRepository() {
+        this.striped = Striped.lock(LockKey.recognizedKeys().size());
+    }
+
+    /**
+     * Get the lock corresponding to the given lock key
+     *
+     * @param key Lock key
+     * @return Lock
+     */
+    @Nonnull public Lock getLock(@Nonnull final LockKey key) {
+        return this.striped.get(key);
+    }
+
+    /**
+     * Consume a lock
+     *
+     * @param key      Lock key
+     * @param consumer Lock consumer
+     */
+    public void useLock(@Nonnull final LockKey key, @Nonnull final Consumer<Lock> consumer) {
+        consumer.accept(this.getLock(key));
+    }
+
+    /**
+     * Wait for the lock to become available, and run
+     * the given runnable, then unlock the lock. This is
+     * a blocking method.
+     *
+     * @param key      Lock key
+     * @param runnable Action to run when the lock is available
+     */
+    public void useLock(@Nonnull final LockKey key, @Nonnull final Runnable runnable) {
+        this.useLock(key, lock -> {
+            lock.lock();
+            runnable.run();
+            lock.unlock();
+        });
+    }
+
+    /**
+     * Wait for a lock to be available, lock it and return
+     * an {@link AutoCloseable} instance that locks the key.
+     * <p>
+     * This is meant to be used with try-with-resources, like such:
+     * <pre>{@code
+     * try (final LockAccess lockAccess = lockRepository.lock(LockKey.of("your.key"))) {
+     *      // use lock
+     * }
+     * }</pre>
+     *
+     * @param key Lock key
+     * @return Lock access. Must be closed.
+     */
+    @Nonnull public LockAccess lock(@Nonnull final LockKey key) {
+        final Lock lock = this.getLock(key);
+        lock.lock();
+        return new LockAccess(lock);
+    }
+
+
+    public static class LockAccess implements AutoCloseable {
+
+        private final Lock lock;
+
+        private LockAccess(@Nonnull final Lock lock) {
+            this.lock = lock;
+        }
+
+        @Override public void close() {
+            this.lock.unlock();
+        }
+
+    }
+
+}

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

@@ -28,10 +28,13 @@ package com.plotsquared.core.util;
 import com.plotsquared.core.command.CommandCaller;
 import com.plotsquared.core.configuration.Captions;
 import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.permissions.PermissionHolder;
 
 import java.util.HashMap;
+import java.util.Map;
 
 /**
  * The Permissions class handles checking user permissions.<br>
@@ -66,20 +69,22 @@ public class Permissions {
         if (!Settings.Enabled_Components.PERMISSION_CACHE) {
             return hasPermission((PermissionHolder) player, permission);
         }
-        HashMap<String, Boolean> map = player.getMeta("perm");
+        try (final MetaDataAccess<Map<String, Boolean>> mapAccess =
+            player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_PERMISSIONS)) {
+            Map<String, Boolean> map = mapAccess.get().orElse(null);
             if (map != null) {
-            Boolean result = map.get(permission);
+                final Boolean result = map.get(permission);
                 if (result != null) {
                     return result;
                 }
             } else {
-            map = new HashMap<>();
+                mapAccess.set((map = new HashMap<>()));
-            player.setMeta("perm", map);
             }
             boolean result = hasPermission((PermissionHolder) player, permission);
             map.put(permission, result);
             return result;
         }
+    }
 
     /**
      * Check if a {@code CommandCaller} has a permission.

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

@@ -28,6 +28,8 @@ package com.plotsquared.core.util;
 import com.plotsquared.core.PlotSquared;
 import com.plotsquared.core.configuration.Settings;
 import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.PlotArea;
@@ -100,8 +102,10 @@ public class WEManager {
         }
         boolean allowMember = player.hasPermission("plots.worldedit.member");
         Plot plot = player.getCurrentPlot();
+        try (final MetaDataAccess<Plot> metaDataAccess =
+            player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_WORLD_EDIT_REGION_PLOT)) {
             if (plot == null) {
-            plot = player.getMeta("WorldEditRegionPlot");
+                plot = metaDataAccess.get().orElse(null);
             }
             if (plot != null && (!Settings.Done.RESTRICT_BUILDING || !DoneFlag.isDone(plot)) && (
                 (allowMember && plot.isAdded(uuid)) || (!allowMember && (plot.isOwner(uuid)) || plot
@@ -112,7 +116,8 @@ public class WEManager {
                     CuboidRegion copy = new CuboidRegion(pos1, pos2);
                     regions.add(copy);
                 }
-            player.setMeta("WorldEditRegionPlot", plot);
+                metaDataAccess.set(plot);
+            }
         }
         return regions;
     }

Core/src/main/java/com/plotsquared/core/util/task/AutoClaimFinishTask.java

@@ -30,6 +30,8 @@ import com.plotsquared.core.configuration.Captions;
 import com.plotsquared.core.events.PlotMergeEvent;
 import com.plotsquared.core.events.Result;
 import com.plotsquared.core.location.Direction;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
 import com.plotsquared.core.player.PlotPlayer;
 import com.plotsquared.core.plot.Plot;
 import com.plotsquared.core.plot.PlotArea;
@@ -50,7 +52,10 @@ public final class AutoClaimFinishTask implements Callable<Boolean> {
     private final EventDispatcher eventDispatcher;
 
     @Override public Boolean call() {
-        player.deleteMeta(Auto.class.getName());
+        try (final MetaDataAccess<Boolean> autoAccess
+            = player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_AUTO)) {
+            autoAccess.remove();
+        }
         if (plot == null) {
             sendMessage(player, Captions.NO_FREE_PLOTS);
             return false;

build.gradle

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