EpicKnarvik97/PlotSquared
EpicKnarvik97/PlotSquared
1
0
Fork 0
mirror of https://github.com/IntellectualSites/PlotSquared.git synced 2024-11-22 05:06:44 +01:00
Code Issues Projects Releases Wiki Activity

Merge branch 'v6' into features/v6/permissions

Browse Source 
# 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
This commit is contained in:
Alexander Söderberg 2020-07-24 12:20:45 +02:00
commit 5608c5a901
34 changed files with 1413 additions and 541 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

157
Bukkit/src/main/java/com/plotsquared/bukkit/listener/PlayerEvents.java
View File

@ -38,6 +38,8 @@ import com.plotsquared.core.database.DBFunc;
import com.plotsquared.core.listener.PlayerBlockEventType; import com.plotsquared.core.listener.PlayerBlockEventType;
import com.plotsquared.core.listener.PlotListener; import com.plotsquared.core.listener.PlotListener;
import com.plotsquared.core.location.Location; 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.player.PlotPlayer;
import com.plotsquared.core.plot.Plot; import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea; import com.plotsquared.core.plot.PlotArea;
@ -216,13 +218,14 @@ import org.bukkit.plugin.Plugin;
import org.bukkit.projectiles.BlockProjectileSource; import org.bukkit.projectiles.BlockProjectileSource;
import org.bukkit.projectiles.ProjectileSource; import org.bukkit.projectiles.ProjectileSource;
import org.bukkit.util.Vector; import org.bukkit.util.Vector;
import javax.annotation.Nonnull;
import javax.annotation.Nonnull;
import java.lang.reflect.Field; import java.lang.reflect.Field;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashSet; import java.util.HashSet;
import java.util.Iterator; import java.util.Iterator;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Objects; import java.util.Objects;
import java.util.Set; import java.util.Set;
import java.util.UUID; import java.util.UUID;
@ -731,32 +734,36 @@ import java.util.regex.Pattern;
public void onTeleport(PlayerTeleportEvent event) { public void onTeleport(PlayerTeleportEvent event) {
Player player = event.getPlayer(); Player player = event.getPlayer();
BukkitPlayer pp = BukkitUtil.adapt(player); BukkitPlayer pp = BukkitUtil.adapt(player);
Plot lastPlot = pp.getMeta(PlotPlayer.META_LAST_PLOT); try (final MetaDataAccess<Plot> lastPlotAccess =
org.bukkit.Location to = event.getTo(); pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
//noinspection ConstantConditions Plot lastPlot = lastPlotAccess.get().orElse(null);
if (to != null) { org.bukkit.Location to = event.getTo();
Location location = BukkitUtil.adapt(to); //noinspection ConstantConditions
PlotArea area = location.getPlotArea(); if (to != null) {
if (area == null) { Location location = BukkitUtil.adapt(to);
if (lastPlot != null) { PlotArea area = location.getPlotArea();
plotExit(pp, lastPlot); if (area == null) {
pp.deleteMeta(PlotPlayer.META_LAST_PLOT); if (lastPlot != null) {
plotExit(pp, lastPlot);
lastPlotAccess.remove();
}
try (final MetaDataAccess<Location> lastLocationAccess =
pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
lastLocationAccess.remove();
}
return;
} }
pp.deleteMeta(PlotPlayer.META_LOCATION); Plot plot = area.getPlot(location);
return; if (plot != null) {
} final boolean result = DenyTeleportFlag.allowsTeleport(pp, plot);
Plot plot = area.getPlot(location); // there is one possibility to still allow teleportation:
if (plot != null) { // to is identical to the plot's home location, and untrusted-visit is true
final boolean result = DenyTeleportFlag.allowsTeleport(pp, plot); // i.e. untrusted-visit can override deny-teleport
// there is one possibility to still allow teleportation: // this is acceptable, because otherwise it wouldn't make sense to have both flags set
// to is identical to the plot's home location, and untrusted-visit is true if (!result && !(plot.getFlag(UntrustedVisitFlag.class) && plot.getHomeSynchronous().equals(BukkitUtil.adaptComplete(to)))) {
// i.e. untrusted-visit can override deny-teleport MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_ENTRY_DENIED);
// this is acceptable, because otherwise it wouldn't make sense to have both flags set event.setCancelled(true);
if (!result && !(plot.getFlag(UntrustedVisitFlag.class) && plot.getHomeSynchronous() }
.equals(BukkitUtil.adaptComplete(to)))) {
MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
Captions.PERMISSION_ADMIN_ENTRY_DENIED);
event.setCancelled(true);
} }
} }
} }
@ -847,28 +854,39 @@ import java.util.regex.Pattern;
} }
// Set last location // Set last location
Location location = BukkitUtil.adapt(to); 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(); PlotArea area = location.getPlotArea();
if (area == null) { if (area == null) {
pp.deleteMeta(PlotPlayer.META_LAST_PLOT); try (final MetaDataAccess<Plot> lastPlotAccess =
pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
lastPlotAccess.remove();
}
return; return;
} }
Plot now = area.getPlot(location); 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 (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; this.tmpTeleport = false;
if (lastPlot.equals(BukkitUtil.adapt(from).getPlot())) { if (lastPlot.equals(BukkitUtil.adapt(from).getPlot())) {
player.teleport(from); player.teleport(from);
} else { } else {
player.teleport(player.getWorld().getSpawnLocation()); player.teleport(player.getWorld().getSpawnLocation());
}
this.tmpTeleport = true;
event.setCancelled(true);
return;
} }
this.tmpTeleport = true;
event.setCancelled(true);
return;
} }
} else if (now.equals(lastPlot)) { } else if (now.equals(lastPlot)) {
ForceFieldListener.handleForcefield(player, pp, now); ForceFieldListener.handleForcefield(player, pp, now);
@ -909,28 +927,39 @@ import java.util.regex.Pattern;
} }
// Set last location // Set last location
Location location = BukkitUtil.adapt(to); 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(); PlotArea area = location.getPlotArea();
if (area == null) { if (area == null) {
pp.deleteMeta(PlotPlayer.META_LAST_PLOT); try (final MetaDataAccess<Plot> lastPlotAccess =
pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
lastPlotAccess.remove();
}
return; return;
} }
Plot now = area.getPlot(location); 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 (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; this.tmpTeleport = false;
if (lastPlot.equals(BukkitUtil.adapt(from).getPlot())) { if (lastPlot.equals(BukkitUtil.adapt(from).getPlot())) {
player.teleport(from); player.teleport(from);
} else { } else {
player.teleport(player.getWorld().getSpawnLocation()); player.teleport(player.getWorld().getSpawnLocation());
}
this.tmpTeleport = true;
event.setCancelled(true);
return;
} }
this.tmpTeleport = true;
event.setCancelled(true);
return;
} }
} else if (now.equals(lastPlot)) { } else if (now.equals(lastPlot)) {
ForceFieldListener.handleForcefield(player, pp, now); ForceFieldListener.handleForcefield(player, pp, now);
@ -1155,8 +1184,15 @@ import java.util.regex.Pattern;
Player player = event.getPlayer(); Player player = event.getPlayer();
BukkitPlayer pp = BukkitUtil.adapt(player); BukkitPlayer pp = BukkitUtil.adapt(player);
// Delete last location // 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) { if (plot != null) {
plotExit(pp, plot); plotExit(pp, plot);
} }
@ -1168,7 +1204,10 @@ import java.util.regex.Pattern;
} }
} }
if (Settings.Enabled_Components.PERMISSION_CACHE) { 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(); Location location = pp.getLocation();
PlotArea area = location.getPlotArea(); PlotArea area = location.getPlotArea();

14
Bukkit/src/main/java/com/plotsquared/bukkit/player/BukkitPlayer.java
View File

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

10
Bukkit/src/main/java/com/plotsquared/bukkit/queue/BukkitLocalQueue.java
View File

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

24
Core/src/main/java/com/plotsquared/core/command/Area.java
View File

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

55
Core/src/main/java/com/plotsquared/core/command/Auto.java
View File

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

86
Core/src/main/java/com/plotsquared/core/command/Claim.java
View File

@ -25,7 +25,6 @@
*/ */
package com.plotsquared.core.command; package com.plotsquared.core.command;
import com.google.common.primitives.Ints;
import com.google.inject.Inject; import com.google.inject.Inject;
import com.plotsquared.core.configuration.CaptionUtility; import com.plotsquared.core.configuration.CaptionUtility;
import com.plotsquared.core.configuration.Captions; 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.events.Result;
import com.plotsquared.core.location.Direction; import com.plotsquared.core.location.Direction;
import com.plotsquared.core.location.Location; 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.player.PlotPlayer;
import com.plotsquared.core.plot.Plot; import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea; import com.plotsquared.core.plot.PlotArea;
@ -85,54 +86,57 @@ public class Claim extends SubCommand {
int currentPlots = Settings.Limit.GLOBAL ? int currentPlots = Settings.Limit.GLOBAL ?
player.getPlotCount() : player.getPlotCount() :
player.getPlotCount(location.getWorldName()); player.getPlotCount(location.getWorldName());
int grants = 0;
if (currentPlots >= player.getAllowedPlots() && !force) { final PlotArea area = plot.getArea();
if (player.hasPersistentMeta("grantedPlots")) {
grants = Ints.fromByteArray(player.getPersistentMeta("grantedPlots")); try (final MetaDataAccess<Integer> metaDataAccess = player.accessPersistentMetaData(PlayerMetaDataKeys.PERSISTENT_GRANTED_PLOTS)) {
if (grants <= 0) { int grants = 0;
player.removePersistentMeta("grantedPlots"); if (currentPlots >= player.getAllowedPlots() && !force) {
if (metaDataAccess.isPresent()) {
grants = metaDataAccess.get().orElse(0);
if (grants <= 0) {
metaDataAccess.remove();
return sendMessage(player, Captions.CANT_CLAIM_MORE_PLOTS);
}
} else {
return sendMessage(player, Captions.CANT_CLAIM_MORE_PLOTS); return sendMessage(player, Captions.CANT_CLAIM_MORE_PLOTS);
} }
} else {
return sendMessage(player, Captions.CANT_CLAIM_MORE_PLOTS);
} }
}
if (!plot.canClaim(player)) { if (!plot.canClaim(player)) {
return sendMessage(player, Captions.PLOT_IS_CLAIMED); return sendMessage(player, Captions.PLOT_IS_CLAIMED);
} }
final PlotArea area = plot.getArea(); if (schematic != null && !schematic.isEmpty()) {
if (schematic != null && !schematic.isEmpty()) { if (area.isSchematicClaimSpecify()) {
if (area.isSchematicClaimSpecify()) { if (!area.hasSchematic(schematic)) {
if (!area.hasSchematic(schematic)) { return sendMessage(player, Captions.SCHEMATIC_INVALID, "non-existent: " + schematic);
return sendMessage(player, Captions.SCHEMATIC_INVALID, }
"non-existent: " + schematic); if (!Permissions.hasPermission(player, CaptionUtility.format(player, Captions.PERMISSION_CLAIM_SCHEMATIC.getTranslated(),
} schematic)) && !Permissions.hasPermission(player, Captions.PERMISSION_ADMIN_COMMAND_SCHEMATIC)
if (!Permissions.hasPermission(player, CaptionUtility && !force) {
.format(player, Captions.PERMISSION_CLAIM_SCHEMATIC.getTranslated(), schematic)) return sendMessage(player, Captions.NO_SCHEMATIC_PERMISSION, schematic);
&& !Permissions }
.hasPermission(player, Captions.PERMISSION_ADMIN_COMMAND_SCHEMATIC) && !force) {
return sendMessage(player, Captions.NO_SCHEMATIC_PERMISSION, schematic);
} }
} }
} if ((this.econHandler != null) && area.useEconomy() && !force) {
if ((this.econHandler != null) && area.useEconomy() && !force) { Expression<Double> costExr = area.getPrices().get("claim");
Expression<Double> costExr = area.getPrices().get("claim"); double cost = costExr.evaluate((double) currentPlots);
double cost = costExr.evaluate((double) currentPlots); if (cost > 0d) {
if (cost > 0d) { if (this.econHandler.getMoney(player) < cost) {
if (this.econHandler.getMoney(player) < cost) { return sendMessage(player, Captions.CANNOT_AFFORD_PLOT, "" + cost);
return sendMessage(player, Captions.CANNOT_AFFORD_PLOT, "" + cost); }
this.econHandler.withdrawMoney(player, cost);
sendMessage(player, Captions.REMOVED_BALANCE, cost + "");
} }
this.econHandler.withdrawMoney(player, cost);
sendMessage(player, Captions.REMOVED_BALANCE, cost + "");
} }
} if (grants > 0) {
if (grants > 0) { if (grants == 1) {
if (grants == 1) { metaDataAccess.remove();
player.removePersistentMeta("grantedPlots"); } else {
} else { metaDataAccess.set(grants - 1);
player.setPersistentMeta("grantedPlots", Ints.toByteArray(grants - 1)); }
sendMessage(player, Captions.REMOVED_GRANTED_PLOT, "1", (grants - 1));
} }
sendMessage(player, Captions.REMOVED_GRANTED_PLOT, "1", (grants - 1));
} }
int border = area.getBorder(); int border = area.getBorder();
if (border != Integer.MAX_VALUE && plot.getDistanceFromOrigin() > border && !force) { if (border != Integer.MAX_VALUE && plot.getDistanceFromOrigin() > border && !force) {

21
Core/src/main/java/com/plotsquared/core/command/CmdConfirm.java
View File

@ -26,19 +26,29 @@
package com.plotsquared.core.command; package com.plotsquared.core.command;
import com.plotsquared.core.configuration.Captions; 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.player.PlotPlayer;
import com.plotsquared.core.util.MainUtil; import com.plotsquared.core.util.MainUtil;
import com.plotsquared.core.util.task.TaskManager; import com.plotsquared.core.util.task.TaskManager;
import com.plotsquared.core.util.task.TaskTime; import com.plotsquared.core.util.task.TaskTime;
import javax.annotation.Nullable;
public class CmdConfirm { 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) { 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, public static void addPending(final PlotPlayer<?> player, String commandStr,
@ -49,7 +59,10 @@ public class CmdConfirm {
} }
TaskManager.runTaskLater(() -> { TaskManager.runTaskLater(() -> {
CmdInstance cmd = new CmdInstance(runnable); 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)); }, TaskTime.ticks(1L));
} }
} }

40
Core/src/main/java/com/plotsquared/core/command/DebugExec.java
View File

@ -409,46 +409,6 @@ public class DebugExec extends SubCommand {
} }
}, "/plot debugexec list-scripts", "List of scripts"); }, "/plot debugexec list-scripts", "List of scripts");
return true; 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": case "all":
if (args.length < 3) { if (args.length < 3) {
Captions.COMMAND_SYNTAX Captions.COMMAND_SYNTAX

62
Core/src/main/java/com/plotsquared/core/command/Grant.java
View File

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

8
Core/src/main/java/com/plotsquared/core/command/Inbox.java
View File

@ -25,7 +25,9 @@
*/ */
package com.plotsquared.core.command; package com.plotsquared.core.command;
import com.google.inject.TypeLiteral;
import com.plotsquared.core.configuration.Captions; import com.plotsquared.core.configuration.Captions;
import com.plotsquared.core.player.MetaDataAccess;
import com.plotsquared.core.player.PlotPlayer; import com.plotsquared.core.player.PlotPlayer;
import com.plotsquared.core.plot.Plot; import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.comment.CommentInbox; 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.MainUtil;
import com.plotsquared.core.util.StringMan; import com.plotsquared.core.util.StringMan;
import com.plotsquared.core.util.task.RunnableVal; import com.plotsquared.core.util.task.RunnableVal;
import com.plotsquared.core.player.MetaDataKey;
import java.util.List; import java.util.List;
@ -140,7 +143,10 @@ public class Inbox extends SubCommand {
StringMan.join(CommentManager.inboxes.keySet(), ", ")); StringMan.join(CommentManager.inboxes.keySet(), ", "));
return false; 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; final int page;
if (args.length > 1) { if (args.length > 1) {
switch (args[1].toLowerCase()) { switch (args[1].toLowerCase()) {

166
Core/src/main/java/com/plotsquared/core/command/Load.java
View File

@ -28,6 +28,8 @@ package com.plotsquared.core.command;
import com.google.inject.Inject; import com.google.inject.Inject;
import com.plotsquared.core.configuration.Captions; import com.plotsquared.core.configuration.Captions;
import com.plotsquared.core.configuration.Settings; 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.player.PlotPlayer;
import com.plotsquared.core.plot.Plot; import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea; import com.plotsquared.core.plot.PlotArea;
@ -43,6 +45,7 @@ import javax.annotation.Nonnull;
import java.net.MalformedURLException; import java.net.MalformedURLException;
import java.net.URL; import java.net.URL;
import java.util.Collections;
import java.util.List; import java.util.List;
@CommandDeclaration(command = "load", @CommandDeclaration(command = "load",
@ -86,44 +89,46 @@ public class Load extends SubCommand {
return false; return false;
} }
if (args.length != 0) { try (final MetaDataAccess<List<String>> metaDataAccess =
if (args.length == 1) { player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_SCHEMATICS)) {
List<String> schematics = player.getMeta("plot_schematics"); if (args.length != 0) {
if (schematics == null) { if (args.length == 1) {
// No schematics found: List<String> schematics = metaDataAccess.get().orElse(null);
MainUtil.sendMessage(player, Captions.LOAD_NULL); if (schematics == null) {
return false; // No schematics found:
} MainUtil.sendMessage(player, Captions.LOAD_NULL);
String schematic; return false;
try {
schematic = schematics.get(Integer.parseInt(args[0]) - 1);
} catch (Exception ignored) {
// use /plot load <index>
MainUtil.sendMessage(player, Captions.NOT_VALID_NUMBER,
"(1, " + schematics.size() + ')');
return false;
}
final URL url;
try {
url = new URL(Settings.Web.URL + "saves/" + player.getUUID() + '/' + schematic);
} catch (MalformedURLException e) {
e.printStackTrace();
MainUtil.sendMessage(player, Captions.LOAD_FAILED);
return false;
}
plot.addRunning();
MainUtil.sendMessage(player, Captions.GENERATING_COMPONENT);
TaskManager.runTaskAsync(() -> {
Schematic taskSchematic = this.schematicHandler.getSchematic(url);
if (taskSchematic == null) {
plot.removeRunning();
sendMessage(player, Captions.SCHEMATIC_INVALID,
"non-existent or not in gzip format");
return;
} }
PlotArea area = plot.getArea(); String schematic;
this.schematicHandler.paste(taskSchematic, plot, 0, area.getMinBuildHeight(), 0, false, try {
new RunnableVal<Boolean>() { schematic = schematics.get(Integer.parseInt(args[0]) - 1);
} catch (Exception ignored) {
// use /plot load <index>
MainUtil.sendMessage(player, Captions.NOT_VALID_NUMBER,
"(1, " + schematics.size() + ')');
return false;
}
final URL url;
try {
url = new URL(Settings.Web.URL + "saves/" + player.getUUID() + '/' + schematic);
} catch (MalformedURLException e) {
e.printStackTrace();
MainUtil.sendMessage(player, Captions.LOAD_FAILED);
return false;
}
plot.addRunning();
MainUtil.sendMessage(player, Captions.GENERATING_COMPONENT);
TaskManager.runTaskAsync(() -> {
Schematic taskSchematic = this.schematicHandler.getSchematic(url);
if (taskSchematic == null) {
plot.removeRunning();
sendMessage(player, Captions.SCHEMATIC_INVALID,
"non-existent or not in gzip format");
return;
}
PlotArea area = plot.getArea();
this.schematicHandler
.paste(taskSchematic, plot, 0, area.getMinBuildHeight(), 0, false, new RunnableVal<Boolean>() {
@Override public void run(Boolean value) { @Override public void run(Boolean value) {
plot.removeRunning(); plot.removeRunning();
if (value) { if (value) {
@ -133,58 +138,61 @@ public class Load extends SubCommand {
} }
} }
}); });
}); });
return true; return true;
}
plot.removeRunning();
MainUtil.sendMessage(player, Captions.COMMAND_SYNTAX, "/plot load <index>");
return false;
}
// list schematics
List<String> schematics = player.getMeta("plot_schematics");
if (schematics == null) {
plot.addRunning();
TaskManager.runTaskAsync(() -> {
List<String> schematics1 = this.schematicHandler.getSaves(player.getUUID());
plot.removeRunning();
if ((schematics1 == null) || schematics1.isEmpty()) {
MainUtil.sendMessage(player, Captions.LOAD_FAILED);
return;
} }
player.setMeta("plot_schematics", schematics1); plot.removeRunning();
MainUtil.sendMessage(player, Captions.COMMAND_SYNTAX, "/plot load <index>");
return false;
}
// list schematics
List<String> schematics = metaDataAccess.get().orElse(null);
if (schematics == null) {
plot.addRunning();
TaskManager.runTaskAsync(() -> {
List<String> schematics1 = this.schematicHandler.getSaves(player.getUUID());
plot.removeRunning();
if ((schematics1 == null) || schematics1.isEmpty()) {
MainUtil.sendMessage(player, Captions.LOAD_FAILED);
return;
}
metaDataAccess.set(schematics1);
displaySaves(player);
});
} else {
displaySaves(player); displaySaves(player);
}); }
} else {
displaySaves(player);
} }
return true; return true;
} }
public void displaySaves(PlotPlayer<?> player) { public void displaySaves(PlotPlayer<?> player) {
List<String> schematics = player.getMeta("plot_schematics"); try (final MetaDataAccess<List<String>> metaDataAccess =
for (int i = 0; i < Math.min(schematics.size(), 32); i++) { player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_SCHEMATICS)) {
try { List<String> schematics = metaDataAccess.get().orElse(Collections.emptyList());
String schematic = schematics.get(i).split("\\.")[0]; for (int i = 0; i < Math.min(schematics.size(), 32); i++) {
String[] split = schematic.split("_"); try {
if (split.length < 5) { String schematic = schematics.get(i).split("\\.")[0];
continue; String[] split = schematic.split("_");
if (split.length < 5) {
continue;
}
String time = secToTime((System.currentTimeMillis() / 1000) - Long.parseLong(split[0]));
String world = split[1];
PlotId id = PlotId.fromString(split[2] + ';' + split[3]);
String size = split[4];
String color = "$4";
MainUtil.sendMessage(player,
"$3[$2" + (i + 1) + "$3] " + color + time + "$3 | " + color + world + ';' + id
+ "$3 | " + color + size + 'x' + size);
} catch (Exception e) {
e.printStackTrace();
} }
String time =
secToTime((System.currentTimeMillis() / 1000) - Long.parseLong(split[0]));
String world = split[1];
PlotId id = PlotId.fromString(split[2] + ';' + split[3]);
String size = split[4];
String color = "$4";
MainUtil.sendMessage(player,
"$3[$2" + (i + 1) + "$3] " + color + time + "$3 | " + color + world + ';' + id
+ "$3 | " + color + size + 'x' + size);
} catch (Exception e) {
e.printStackTrace();
} }
MainUtil.sendMessage(player, Captions.LOAD_LIST);
} }
MainUtil.sendMessage(player, Captions.LOAD_LIST);
} }
public String secToTime(long time) { public String secToTime(long time) {

46
Core/src/main/java/com/plotsquared/core/command/MainCommand.java
View File

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

8
Core/src/main/java/com/plotsquared/core/command/Save.java
View File

@ -28,6 +28,8 @@ package com.plotsquared.core.command;
import com.google.inject.Inject; import com.google.inject.Inject;
import com.plotsquared.core.configuration.Captions; import com.plotsquared.core.configuration.Captions;
import com.plotsquared.core.location.Location; 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.player.PlotPlayer;
import com.plotsquared.core.plot.Plot; import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotId; import com.plotsquared.core.plot.PlotId;
@ -104,9 +106,9 @@ public class Save extends SubCommand {
return; return;
} }
MainUtil.sendMessage(player, Captions.SAVE_SUCCESS); 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"));
} }
} }
}); });

66
Core/src/main/java/com/plotsquared/core/command/Setup.java
View File

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

225
Core/src/main/java/com/plotsquared/core/listener/PlotListener.java
View File

@ -26,12 +26,14 @@
package com.plotsquared.core.listener; package com.plotsquared.core.listener;
import com.plotsquared.core.PlotSquared; import com.plotsquared.core.PlotSquared;
import com.plotsquared.core.collection.ByteArrayUtilities;
import com.plotsquared.core.configuration.Captions; import com.plotsquared.core.configuration.Captions;
import com.plotsquared.core.configuration.Settings; import com.plotsquared.core.configuration.Settings;
import com.plotsquared.core.events.PlotFlagRemoveEvent; import com.plotsquared.core.events.PlotFlagRemoveEvent;
import com.plotsquared.core.events.Result; import com.plotsquared.core.events.Result;
import com.plotsquared.core.location.Location; 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.player.PlotPlayer;
import com.plotsquared.core.plot.Plot; import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea; import com.plotsquared.core.plot.PlotArea;
@ -71,6 +73,7 @@ import javax.annotation.Nullable;
import java.util.HashMap; import java.util.HashMap;
import java.util.Iterator; import java.util.Iterator;
import java.util.Map; import java.util.Map;
import java.util.Optional;
import java.util.UUID; import java.util.UUID;
public class PlotListener { public class PlotListener {
@ -134,14 +137,16 @@ public class PlotListener {
.hasPermission(player, "plots.admin.entry.denied")) { .hasPermission(player, "plots.admin.entry.denied")) {
return false; return false;
} }
Plot last = player.getMeta(PlotPlayer.META_LAST_PLOT); try (final MetaDataAccess<Plot> lastPlot = player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
if ((last != null) && !last.getId().equals(plot.getId())) { Plot last = lastPlot.get().orElse(null);
plotExit(player, last); if ((last != null) && !last.getId().equals(plot.getId())) {
plotExit(player, last);
}
if (ExpireManager.IMP != null) {
ExpireManager.IMP.handleEntry(player, plot);
}
lastPlot.set(plot);
} }
if (ExpireManager.IMP != null) {
ExpireManager.IMP.handleEntry(player, plot);
}
player.setMeta(PlotPlayer.META_LAST_PLOT, plot);
this.eventDispatcher.callEntry(player, plot); this.eventDispatcher.callEntry(player, plot);
if (plot.hasOwner()) { if (plot.hasOwner()) {
// This will inherit values from PlotArea // This will inherit values from PlotArea
@ -177,8 +182,9 @@ public class PlotListener {
boolean flight = player.getFlight(); boolean flight = player.getFlight();
GameMode gamemode = player.getGameMode(); GameMode gamemode = player.getGameMode();
if (flight != (gamemode == GameModes.CREATIVE || gamemode == GameModes.SPECTATOR)) { 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); player.setFlight(flyStatus == FlyFlag.FlyStatus.ENABLED);
} }
@ -227,39 +233,47 @@ public class PlotListener {
player.setWeather(plot.getFlag(WeatherFlag.class)); player.setWeather(plot.getFlag(WeatherFlag.class));
ItemType musicFlag = plot.getFlag(MusicFlag.class); ItemType musicFlag = plot.getFlag(MusicFlag.class);
if (musicFlag != null) {
final String rawId = musicFlag.getId(); try (final MetaDataAccess<Location> musicMeta =
if (rawId.contains("disc") || musicFlag == ItemTypes.AIR) { player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_MUSIC)) {
Location location = player.getLocation(); if (musicFlag != null) {
Location lastLocation = player.getMeta("music"); final String rawId = musicFlag.getId();
if (lastLocation != null) { if (rawId.contains("disc") || musicFlag == ItemTypes.AIR) {
player.playMusic(lastLocation, musicFlag); Location location = player.getLocation();
if (musicFlag == ItemTypes.AIR) { Location lastLocation = musicMeta.get().orElse(null);
player.deleteMeta("music"); if (lastLocation != null) {
player.playMusic(lastLocation, musicFlag);
if (musicFlag == ItemTypes.AIR) {
musicMeta.remove();
}
}
if (musicFlag != ItemTypes.AIR) {
try {
musicMeta.set(location);
player.playMusic(location, musicFlag);
} catch (Exception ignored) {
}
} }
} }
if (musicFlag != ItemTypes.AIR) { } else {
try { musicMeta.get().ifPresent(lastLoc -> {
player.setMeta("music", location); musicMeta.remove();
player.playMusic(location, musicFlag); player.playMusic(lastLoc, ItemTypes.AIR);
} catch (Exception ignored) { });
}
}
}
} else {
Location lastLoc = player.getMeta("music");
if (lastLoc != null) {
player.deleteMeta("music");
player.playMusic(lastLoc, ItemTypes.AIR);
} }
} }
CommentManager.sendTitle(player, plot); CommentManager.sendTitle(player, plot);
if (titles && !player.getAttribute("disabletitles")) { if (titles && !player.getAttribute("disabletitles")) {
if (!Captions.TITLE_ENTERED_PLOT.getTranslated().isEmpty() if (!Captions.TITLE_ENTERED_PLOT.getTranslated().isEmpty()
|| !Captions.TITLE_ENTERED_PLOT_SUB.getTranslated().isEmpty()) { || !Captions.TITLE_ENTERED_PLOT_SUB.getTranslated().isEmpty()) {
TaskManager.runTaskLaterAsync(() -> { 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())) { if ((lastPlot != null) && plot.getId().equals(lastPlot.getId())) {
Map<String, String> replacements = new HashMap<>(); Map<String, String> replacements = new HashMap<>();
replacements.put("%x%", String.valueOf(lastPlot.getId().getX())); replacements.put("%x%", String.valueOf(lastPlot.getId().getX()));
@ -296,87 +310,96 @@ public class PlotListener {
} }
public boolean plotExit(final PlotPlayer<?> player, Plot plot) { 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)) {
this.eventDispatcher.callLeave(player, plot); final Plot previous = lastPlot.remove();
if (plot.hasOwner()) { this.eventDispatcher.callLeave(player, plot);
PlotArea pw = plot.getArea(); if (plot.hasOwner()) {
if (pw == null) { PlotArea pw = plot.getArea();
return true; if (pw == null) {
} return true;
if (plot.getFlag(DenyExitFlag.class) && !Permissions
.hasPermission(player, Captions.PERMISSION_ADMIN_EXIT_DENIED) && !player
.getMeta("kick", false)) {
if (previous != null) {
player.setMeta(PlotPlayer.META_LAST_PLOT, previous);
} }
return false; try (final MetaDataAccess<Boolean> kickAccess =
} player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_KICK)) {
if (!plot.getFlag(GamemodeFlag.class).equals(GamemodeFlag.DEFAULT) || !plot if (plot.getFlag(DenyExitFlag.class) && !Permissions
.getFlag(GuestGamemodeFlag.class).equals(GamemodeFlag.DEFAULT)) { .hasPermission(player, Captions.PERMISSION_ADMIN_EXIT_DENIED) &&
if (player.getGameMode() != pw.getGameMode()) { !kickAccess.get().orElse(false)) {
if (!Permissions.hasPermission(player, "plots.gamemode.bypass")) { if (previous != null) {
player.setGameMode(pw.getGameMode()); lastPlot.set(previous);
} else { }
MainUtil.sendMessage(player, StringMan return false;
.replaceAll(Captions.GAMEMODE_WAS_BYPASSED.getTranslated(), "{plot}",
plot.toString(), "{gamemode}",
pw.getGameMode().getName().toLowerCase()));
} }
} }
} if (!plot.getFlag(GamemodeFlag.class).equals(GamemodeFlag.DEFAULT) || !plot
.getFlag(GuestGamemodeFlag.class).equals(GamemodeFlag.DEFAULT)) {
final String farewell = plot.getFlag(FarewellFlag.class); if (player.getGameMode() != pw.getGameMode()) {
if (!farewell.isEmpty()) { if (!Permissions.hasPermission(player, "plots.gamemode.bypass")) {
plot.format(Captions.PREFIX_FAREWELL.getTranslated() + farewell, player, false) player.setGameMode(pw.getGameMode());
.thenAcceptAsync(player::sendMessage); } else {
} MainUtil.sendMessage(player, StringMan
.replaceAll(Captions.GAMEMODE_WAS_BYPASSED.getTranslated(), "{plot}",
if (plot.getFlag(NotifyLeaveFlag.class)) { plot.toString(), "{gamemode}",
if (!Permissions.hasPermission(player, "plots.flag.notify-enter.bypass")) { pw.getGameMode().getName().toLowerCase()));
for (UUID uuid : plot.getOwners()) {
final PlotPlayer owner = PlotSquared.platform().getPlayerManager().getPlayerIfExists(uuid);
if ((owner != null) && !owner.getUUID().equals(player.getUUID())) {
MainUtil.sendMessage(owner, Captions.NOTIFY_LEAVE.getTranslated()
.replace("%player", player.getName())
.replace("%plot", plot.getId().toString()));
} }
} }
} }
}
final FlyFlag.FlyStatus flyStatus = plot.getFlag(FlyFlag.class); final String farewell = plot.getFlag(FarewellFlag.class);
if (flyStatus != FlyFlag.FlyStatus.DEFAULT) { if (!farewell.isEmpty()) {
if (player.hasPersistentMeta("flight")) { plot.format(Captions.PREFIX_FAREWELL.getTranslated() + farewell, player, false)
player.setFlight( .thenAcceptAsync(player::sendMessage);
ByteArrayUtilities.bytesToBoolean(player.getPersistentMeta("flight"))); }
player.removePersistentMeta("flight");
} else { if (plot.getFlag(NotifyLeaveFlag.class)) {
GameMode gameMode = player.getGameMode(); if (!Permissions.hasPermission(player, "plots.flag.notify-enter.bypass")) {
if (gameMode == GameModes.SURVIVAL || gameMode == GameModes.ADVENTURE) { for (UUID uuid : plot.getOwners()) {
player.setFlight(false); final PlotPlayer owner = PlotSquared.platform().getPlayerManager().getPlayerIfExists(uuid);
} else if (!player.getFlight()) { if ((owner != null) && !owner.getUUID().equals(player.getUUID())) {
player.setFlight(true); MainUtil.sendMessage(owner, Captions.NOTIFY_LEAVE.getTranslated()
.replace("%player", player.getName())
.replace("%plot", plot.getId().toString()));
}
}
} }
} }
}
if (plot.getFlag(TimeFlag.class) != TimeFlag.TIME_DISABLED.getValue().longValue()) { final FlyFlag.FlyStatus flyStatus = plot.getFlag(FlyFlag.class);
player.setTime(Long.MAX_VALUE); if (flyStatus != FlyFlag.FlyStatus.DEFAULT) {
} try (final MetaDataAccess<Boolean> metaDataAccess = player.accessPersistentMetaData(PlayerMetaDataKeys.PERSISTENT_FLIGHT)) {
final Optional<Boolean> value = metaDataAccess.get();
if (value.isPresent()) {
player.setFlight(value.get());
metaDataAccess.remove();
} else {
GameMode gameMode = player.getGameMode();
if (gameMode == GameModes.SURVIVAL || gameMode == GameModes.ADVENTURE) {
player.setFlight(false);
} else if (!player.getFlight()) {
player.setFlight(true);
}
}
}
}
final PlotWeather plotWeather = plot.getFlag(WeatherFlag.class); if (plot.getFlag(TimeFlag.class) != TimeFlag.TIME_DISABLED.getValue().longValue()) {
if (plotWeather != PlotWeather.CLEAR) { player.setTime(Long.MAX_VALUE);
player.setWeather(PlotWeather.RESET); }
}
Location lastLoc = player.getMeta("music"); final PlotWeather plotWeather = plot.getFlag(WeatherFlag.class);
if (lastLoc != null) { if (plotWeather != PlotWeather.CLEAR) {
player.deleteMeta("music"); player.setWeather(PlotWeather.RESET);
player.playMusic(lastLoc, ItemTypes.AIR); }
}
feedRunnable.remove(player.getUUID()); try (final MetaDataAccess<Location> musicAccess =
healRunnable.remove(player.getUUID()); player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_MUSIC)) {
musicAccess.get().ifPresent(lastLoc -> {
musicAccess.remove();
player.playMusic(lastLoc, ItemTypes.AIR);
});
}
feedRunnable.remove(player.getUUID());
healRunnable.remove(player.getUUID());
}
} }
return true; return true;
} }

15
Core/src/main/java/com/plotsquared/core/player/ConsolePlayer.java
View File

@ -33,6 +33,7 @@ import com.plotsquared.core.events.TeleportCause;
import com.plotsquared.core.inject.annotations.ConsoleActor; import com.plotsquared.core.inject.annotations.ConsoleActor;
import com.plotsquared.core.location.Location; import com.plotsquared.core.location.Location;
import com.plotsquared.core.permissions.PermissionHandler; import com.plotsquared.core.permissions.PermissionHandler;
import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea; import com.plotsquared.core.plot.PlotArea;
import com.plotsquared.core.plot.PlotWeather; import com.plotsquared.core.plot.PlotWeather;
import com.plotsquared.core.plot.world.PlotAreaManager; 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.GameMode;
import com.sk89q.worldedit.world.gamemode.GameModes; import com.sk89q.worldedit.world.gamemode.GameModes;
import com.sk89q.worldedit.world.item.ItemType; import com.sk89q.worldedit.world.item.ItemType;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
@ -128,8 +131,16 @@ public class ConsolePlayer extends PlotPlayer<Actor> {
} }
@Override public void teleport(Location location, TeleportCause cause) { @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() { @Override public String getName() {

129
Core/src/main/java/com/plotsquared/core/player/MetaDataAccess.java Normal file
View File

@ -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;
}
}

108
Core/src/main/java/com/plotsquared/core/player/MetaDataKey.java Normal file
View File

@ -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;
}
}

66
Core/src/main/java/com/plotsquared/core/player/PersistentMetaDataAccess.java Normal file
View File

@ -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()));
}
}

62
Core/src/main/java/com/plotsquared/core/player/PlayerMetaDataKeys.java Normal file
View File

@ -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() {
}
}

112
Core/src/main/java/com/plotsquared/core/player/PlotPlayer.java
View File

@ -26,7 +26,9 @@
package com.plotsquared.core.player; package com.plotsquared.core.player;
import com.google.common.base.Preconditions; import com.google.common.base.Preconditions;
import com.google.common.primitives.Ints;
import com.plotsquared.core.PlotSquared; import com.plotsquared.core.PlotSquared;
import com.plotsquared.core.collection.ByteArrayUtilities;
import com.plotsquared.core.command.CommandCaller; import com.plotsquared.core.command.CommandCaller;
import com.plotsquared.core.command.RequiredType; import com.plotsquared.core.command.RequiredType;
import com.plotsquared.core.configuration.CaptionUtility; 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.PlotAreaManager;
import com.plotsquared.core.plot.world.SinglePlotArea; import com.plotsquared.core.plot.world.SinglePlotArea;
import com.plotsquared.core.plot.world.SinglePlotAreaManager; import com.plotsquared.core.plot.world.SinglePlotAreaManager;
import com.plotsquared.core.synchronization.LockRepository;
import com.plotsquared.core.util.EconHandler; import com.plotsquared.core.util.EconHandler;
import com.plotsquared.core.util.EventDispatcher; import com.plotsquared.core.util.EventDispatcher;
import com.plotsquared.core.util.Permissions; 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()); 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 // Used to track debug mode
private static final Set<PlotPlayer<?>> debugModeEnabled = Collections.synchronizedSet(new HashSet<>()); 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 ConcurrentHashMap<String, Object> meta;
private int hash; private int hash;
private final LockRepository lockRepository = new LockRepository();
private final PlotAreaManager plotAreaManager; private final PlotAreaManager plotAreaManager;
private final EventDispatcher eventDispatcher; private final EventDispatcher eventDispatcher;
private final EconHandler econHandler; private final EconHandler econHandler;
@ -155,7 +157,7 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer
* @param key * @param key
* @param value * @param value
*/ */
public void setMeta(String key, Object value) { void setMeta(String key, Object value) {
if (value == null) { if (value == null) {
deleteMeta(key); deleteMeta(key);
} else { } else {
@ -173,14 +175,14 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer
* @param <T> the object type to return * @param <T> the object type to return
* @return the value assigned to the key or null if it does not exist * @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) { if (this.meta != null) {
return (T) this.meta.get(key); return (T) this.meta.get(key);
} }
return null; return null;
} }
public <T> T getMeta(String key, T defaultValue) { <T> T getMeta(String key, T defaultValue) {
T meta = getMeta(key); T meta = getMeta(key);
if (meta == null) { if (meta == null) {
return defaultValue; return defaultValue;
@ -199,7 +201,7 @@ public abstract class PlotPlayer<P> implements CommandCaller, OfflinePlotPlayer
* *
* @param key * @param key
*/ */
public Object deleteMeta(String key) { Object deleteMeta(String key) {
return this.meta == null ? null : this.meta.remove(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} * @return the plot the player is standing on or null if standing on a road or not in a {@link PlotArea}
*/ */
public Plot getCurrentPlot() { 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); 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) { if (Settings.Enabled_Components.PERSISTENT_META) {
DBFunc.removePersistentMeta(getUUID(), key); 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); boolean delete = hasPersistentMeta(key);
this.metaMap.put(key, value); this.metaMap.put(key, value);
if (Settings.Enabled_Components.PERSISTENT_META) { 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); 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 @FunctionalInterface
public interface PlotPlayerConverter<BaseObject> { public interface PlotPlayerConverter<BaseObject> {
PlotPlayer<?> convert(BaseObject object); PlotPlayer<?> convert(BaseObject object);

66
Core/src/main/java/com/plotsquared/core/player/TemporaryMetaDataAccess.java Normal file
View File

@ -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()));
}
}

16
Core/src/main/java/com/plotsquared/core/plot/PlotArea.java
View File

@ -42,6 +42,8 @@ import com.plotsquared.core.inject.annotations.WorldConfig;
import com.plotsquared.core.location.Direction; import com.plotsquared.core.location.Direction;
import com.plotsquared.core.location.Location; import com.plotsquared.core.location.Location;
import com.plotsquared.core.location.PlotLoc; 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.player.PlotPlayer;
import com.plotsquared.core.plot.flag.FlagContainer; import com.plotsquared.core.plot.flag.FlagContainer;
import com.plotsquared.core.plot.flag.FlagParseException; import com.plotsquared.core.plot.flag.FlagParseException;
@ -787,8 +789,11 @@ public abstract class PlotArea {
} }
public boolean addPlot(@Nonnull final Plot plot) { 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; return this.plots.put(plot.getId(), plot) == null;
} }
@ -826,8 +831,11 @@ public abstract class PlotArea {
public boolean addPlotIfAbsent(@Nonnull final Plot plot) { public boolean addPlotIfAbsent(@Nonnull final Plot plot) {
if (this.plots.putIfAbsent(plot.getId(), plot) == null) { 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; return true;
} }

22
Core/src/main/java/com/plotsquared/core/plot/PlotInventory.java
View File

@ -25,18 +25,19 @@
*/ */
package com.plotsquared.core.plot; 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.player.PlotPlayer;
import com.plotsquared.core.util.InventoryUtil; import com.plotsquared.core.util.InventoryUtil;
import javax.annotation.Nonnull;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import javax.annotation.Nonnull;
public class PlotInventory { public class PlotInventory {
private static final Logger logger = LoggerFactory.getLogger("P2/" + PlotInventory.class.getSimpleName()); private static final Logger logger = LoggerFactory.getLogger("P2/" + PlotInventory.class.getSimpleName());
private static final String META_KEY = "inventory";
public final PlotPlayer<?> player; public final PlotPlayer<?> player;
public final int size; public final int size;
private final PlotItemStack[] items; private final PlotItemStack[] items;
@ -58,16 +59,25 @@ public class PlotInventory {
} }
public static PlotInventory getOpenPlotInventory(@Nonnull final PlotPlayer<?> plotPlayer) { 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, public static void setPlotInventoryOpen(@Nonnull final PlotPlayer<?> plotPlayer,
@Nonnull final PlotInventory plotInventory) { @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) { 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) { public boolean onClick(int index) {

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

@ -26,8 +26,11 @@
package com.plotsquared.core.plot.comment; package com.plotsquared.core.plot.comment;
import com.google.common.annotations.Beta; import com.google.common.annotations.Beta;
import com.google.inject.TypeLiteral;
import com.plotsquared.core.configuration.Captions; import com.plotsquared.core.configuration.Captions;
import com.plotsquared.core.configuration.Settings; 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.player.PlotPlayer;
import com.plotsquared.core.plot.Plot; import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.util.task.RunnableVal; 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) { 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) { public static void addInbox(CommentInbox inbox) {

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

@ -31,7 +31,9 @@ import com.plotsquared.core.database.DBFunc;
import com.plotsquared.core.events.PlotFlagAddEvent; import com.plotsquared.core.events.PlotFlagAddEvent;
import com.plotsquared.core.events.PlotUnlinkEvent; import com.plotsquared.core.events.PlotUnlinkEvent;
import com.plotsquared.core.events.Result; import com.plotsquared.core.events.Result;
import com.plotsquared.core.player.MetaDataAccess;
import com.plotsquared.core.player.OfflinePlotPlayer; import com.plotsquared.core.player.OfflinePlotPlayer;
import com.plotsquared.core.player.PlayerMetaDataKeys;
import com.plotsquared.core.player.PlotPlayer; import com.plotsquared.core.player.PlotPlayer;
import com.plotsquared.core.plot.Plot; import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea; import com.plotsquared.core.plot.PlotArea;
@ -137,44 +139,42 @@ 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(
return; PlayerMetaDataKeys.TEMPORARY_IGNORE_EXPIRE_TASK)) {
} if (metaDataAccess.isPresent()) {
if (plotsToDelete != null && !plotsToDelete.isEmpty() && pp return;
.hasPermission("plots.admin.command.autoclear")) { }
final int num = plotsToDelete.size(); if (plotsToDelete != null && !plotsToDelete.isEmpty() && pp.hasPermission("plots.admin.command.autoclear")) {
while (!plotsToDelete.isEmpty()) { final int num = plotsToDelete.size();
Iterator<Plot> iter = plotsToDelete.iterator(); while (!plotsToDelete.isEmpty()) {
final Plot current = iter.next(); Iterator<Plot> iter = plotsToDelete.iterator();
if (!isExpired(new ArrayDeque<>(tasks), current).isEmpty()) { final Plot current = iter.next();
TaskManager.runTask(() -> { if (!isExpired(new ArrayDeque<>(tasks), current).isEmpty()) {
pp.setMeta("ignoreExpireTask", true); TaskManager.runTask(() -> {
current.getCenter(pp::teleport); metaDataAccess.set(true);
pp.deleteMeta("ignoreExpireTask"); current.getCenter(pp::teleport);
PlotMessage msg = new PlotMessage() metaDataAccess.remove();
.text(num + " " + (num > 1 ? "plots are" : "plot is") + " expired: ") PlotMessage msg = new PlotMessage().text(
.color("$1").text(current.toString()).color("$2") num + " " + (num > 1 ? "plots are" : "plot is") + " expired: ").color("$1").text(current.toString()).color("$2")
.command("/plot list expired").tooltip("/plot list expired") .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 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") .tooltip("/plot toggle clear-confirmation");
.text("Don't show me this").color("$2") msg.send(pp);
.command("/plot toggle clear-confirmation") });
.tooltip("/plot toggle clear-confirmation"); return;
msg.send(pp); } else {
}); iter.remove();
return; }
} else { }
iter.remove(); plotsToDelete.clear();
}
} }
plotsToDelete.clear();
} }
} }

6
Core/src/main/java/com/plotsquared/core/queue/BasicLocalBlockQueue.java
View File

@ -25,7 +25,7 @@
*/ */
package com.plotsquared.core.queue; 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.MathMan;
import com.plotsquared.core.util.PatternUtil; import com.plotsquared.core.util.PatternUtil;
import com.plotsquared.core.util.task.TaskManager; 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) { 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]; BaseBlock[] array = baseblocks[i];
if (array == null) { if (array == null) {
array = (baseblocks[i] = new BaseBlock[4096]); array = (baseblocks[i] = new BaseBlock[4096]);

7
Core/src/main/java/com/plotsquared/core/setup/CommonSetupSteps.java
View File

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

92
Core/src/main/java/com/plotsquared/core/synchronization/LockKey.java Normal file
View File

@ -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);
}
}

116
Core/src/main/java/com/plotsquared/core/synchronization/LockRepository.java Normal file
View File

@ -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();
}
}
}

27
Core/src/main/java/com/plotsquared/core/util/Permissions.java
View File

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

29
Core/src/main/java/com/plotsquared/core/util/WEManager.java
View File

@ -28,6 +28,8 @@ package com.plotsquared.core.util;
import com.plotsquared.core.PlotSquared; import com.plotsquared.core.PlotSquared;
import com.plotsquared.core.configuration.Settings; import com.plotsquared.core.configuration.Settings;
import com.plotsquared.core.location.Location; 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.player.PlotPlayer;
import com.plotsquared.core.plot.Plot; import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea; import com.plotsquared.core.plot.PlotArea;
@ -100,19 +102,22 @@ public class WEManager {
} }
boolean allowMember = player.hasPermission("plots.worldedit.member"); boolean allowMember = player.hasPermission("plots.worldedit.member");
Plot plot = player.getCurrentPlot(); Plot plot = player.getCurrentPlot();
if (plot == null) { try (final MetaDataAccess<Plot> metaDataAccess =
plot = player.getMeta("WorldEditRegionPlot"); player.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_WORLD_EDIT_REGION_PLOT)) {
} if (plot == null) {
if (plot != null && (!Settings.Done.RESTRICT_BUILDING || !DoneFlag.isDone(plot)) && ( plot = metaDataAccess.get().orElse(null);
(allowMember && plot.isAdded(uuid)) || (!allowMember && (plot.isOwner(uuid)) || plot }
.getTrusted().contains(uuid))) && !plot.getFlag(NoWorldeditFlag.class)) { if (plot != null && (!Settings.Done.RESTRICT_BUILDING || !DoneFlag.isDone(plot)) && (
for (CuboidRegion region : plot.getRegions()) { (allowMember && plot.isAdded(uuid)) || (!allowMember && (plot.isOwner(uuid)) || plot
BlockVector3 pos1 = region.getMinimumPoint().withY(area.getMinBuildHeight()); .getTrusted().contains(uuid))) && !plot.getFlag(NoWorldeditFlag.class)) {
BlockVector3 pos2 = region.getMaximumPoint().withY(area.getMaxBuildHeight()); for (CuboidRegion region : plot.getRegions()) {
CuboidRegion copy = new CuboidRegion(pos1, pos2); BlockVector3 pos1 = region.getMinimumPoint().withY(area.getMinBuildHeight());
regions.add(copy); BlockVector3 pos2 = region.getMaximumPoint().withY(area.getMaxBuildHeight());
CuboidRegion copy = new CuboidRegion(pos1, pos2);
regions.add(copy);
}
metaDataAccess.set(plot);
} }
player.setMeta("WorldEditRegionPlot", plot);
} }
return regions; return regions;
} }

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

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

4
build.gradle
View File

@ -30,8 +30,8 @@ ext {
git = Grgit.open(dir: new File(rootDir.toString() + "/.git")) 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 { ext {
if (project.hasProperty("versionsuffix")) { if (project.hasProperty("versionsuffix")) {
versuffix = "-$versionsuffix" versuffix = "-$versionsuffix"