mirror of
https://github.com/IntellectualSites/PlotSquared.git
synced 2025-04-02 09:46:23 +02:00
233 lines
10 KiB
Java
233 lines
10 KiB
Java
package com.intellectualcrafters.plot.util;
|
|
|
|
import com.intellectualcrafters.plot.PS;
|
|
import com.intellectualcrafters.plot.config.C;
|
|
import com.intellectualcrafters.plot.config.Settings;
|
|
import com.intellectualcrafters.plot.flag.Flag;
|
|
import com.intellectualcrafters.plot.flag.FlagManager;
|
|
import com.intellectualcrafters.plot.generator.HybridUtils;
|
|
import com.intellectualcrafters.plot.object.OfflinePlotPlayer;
|
|
import com.intellectualcrafters.plot.object.Plot;
|
|
import com.intellectualcrafters.plot.object.PlotAnalysis;
|
|
import com.intellectualcrafters.plot.object.PlotArea;
|
|
import com.intellectualcrafters.plot.object.PlotHandler;
|
|
import com.intellectualcrafters.plot.object.PlotPlayer;
|
|
import com.intellectualcrafters.plot.object.RunnableVal;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
|
|
public class ExpireManager {
|
|
public static ConcurrentHashMap<String, List<Plot>> expiredPlots = new ConcurrentHashMap<>();
|
|
public static ConcurrentHashMap<String, Boolean> updatingPlots = new ConcurrentHashMap<>();
|
|
public static ConcurrentHashMap<String, Long> timestamp = new ConcurrentHashMap<>();
|
|
public static ConcurrentHashMap<UUID, Long> dates = new ConcurrentHashMap<>();
|
|
public static int task;
|
|
|
|
public static long getTimeStamp(PlotArea area) {
|
|
Long timestamp = (Long) area.getMeta("expiredTimestamp");
|
|
return timestamp != null ? timestamp : 0;
|
|
}
|
|
|
|
public static boolean updateExpired(final PlotArea area) {
|
|
area.setMeta("updatingExpired", true);
|
|
final long now = System.currentTimeMillis();
|
|
if (now > getTimeStamp(area)) {
|
|
area.setMeta("expiredTimestamp", now + 86400000l);
|
|
TaskManager.runTaskAsync(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
final List<Plot> plots = getOldPlots(area);
|
|
PS.debug("$2[&5Expire&dManager$2] $4Found " + plots.size() + " expired plots for " + area + "!");
|
|
area.setMeta("expiredPlots", plots);
|
|
area.setMeta("updatingExpired", false);
|
|
} catch (final Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
});
|
|
return true;
|
|
} else {
|
|
area.setMeta("updatingExpired", false);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static void runTask() {
|
|
ExpireManager.task = TaskManager.runTaskRepeatAsync(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
try {
|
|
for (final PlotArea area : PS.get().getPlotAreas()) {
|
|
Boolean updating = (Boolean) area.getMeta("updatingExpired");
|
|
if (updating == null) {
|
|
updating = false;
|
|
area.setMeta("updatingExpired", false);
|
|
}
|
|
if (updating) {
|
|
PS.debug("$2[&5Expire&dManager$2] $4Waiting on fetch...");
|
|
return;
|
|
}
|
|
List<Plot> plots = (List<Plot>) area.getMeta("expiredPlots");
|
|
if (plots == null) {
|
|
PS.debug("$2[&5Expire&dManager$2] $4Updating expired plots for: " + area);
|
|
updateExpired(area);
|
|
return;
|
|
}
|
|
if ((plots.size() == 0)) {
|
|
if (updateExpired(area)) {
|
|
PS.debug("$2[&5Expire&dManager$2] $4Re-evaluating expired plots for: " + area);
|
|
return;
|
|
}
|
|
continue;
|
|
}
|
|
final Iterator<Plot> iter = plots.iterator();
|
|
final Plot plot = iter.next();
|
|
if (!isExpired(plot)) {
|
|
iter.remove();
|
|
PS.debug("$2[&5Expire&dManager$2] &bSkipping no longer expired: " + plot);
|
|
return;
|
|
}
|
|
for (final UUID helper : plot.getTrusted()) {
|
|
final PlotPlayer player = UUIDHandler.getPlayer(helper);
|
|
if (player != null) {
|
|
MainUtil.sendMessage(player, C.PLOT_REMOVED_USER, plot.getId().toString());
|
|
}
|
|
}
|
|
for (final UUID helper : plot.getMembers()) {
|
|
final PlotPlayer player = UUIDHandler.getPlayer(helper);
|
|
if (player != null) {
|
|
MainUtil.sendMessage(player, C.PLOT_REMOVED_USER, plot.getId().toString());
|
|
}
|
|
}
|
|
final RunnableVal<PlotAnalysis> run = new RunnableVal<PlotAnalysis>() {
|
|
@Override
|
|
public void run(PlotAnalysis changed) {
|
|
if ((Settings.CLEAR_THRESHOLD != -1) && (area.TYPE == 0) && (changed != null)) {
|
|
if ((changed.changes != 0) && (changed.getComplexity() > Settings.CLEAR_THRESHOLD)) {
|
|
PS.debug("$2[&5Expire&dManager$2] &bIgnoring modified plot: " + plot + " : " + changed.getComplexity() + " - " + changed.changes);
|
|
iter.remove();
|
|
FlagManager.addPlotFlag(plot, new Flag(FlagManager.getFlag("analysis"), changed.asList()));
|
|
return;
|
|
}
|
|
}
|
|
if (plot.isMerged()) {
|
|
plot.unlinkPlot(true, false);
|
|
}
|
|
plot.deletePlot(null);
|
|
iter.remove();
|
|
final int complexity = changed == null ? 0 : changed.getComplexity();
|
|
final int modified = changed == null ? 0 : changed.changes;
|
|
PS.debug("$2[&5Expire&dManager$2] &cDeleted expired plot: " + plot + " : " + complexity + " - " + modified);
|
|
PS.debug("$4 - Area: " + plot.getArea());
|
|
if (plot.hasOwner()) {
|
|
PS.debug("$4 - Owner: " + UUIDHandler.getName(plot.owner));
|
|
} else {
|
|
PS.debug("$4 - Owner: Unowned");
|
|
}
|
|
}
|
|
};
|
|
if (plot.getRunning() > 0) {
|
|
PS.debug("$2[&5Expire&dManager$2] &bSkipping plot in use: " + plot);
|
|
iter.remove();
|
|
run();
|
|
return;
|
|
}
|
|
if ((Settings.CLEAR_THRESHOLD != -1) && (area.TYPE == 0)) {
|
|
final PlotAnalysis analysis = plot.getComplexity();
|
|
if (analysis != null) {
|
|
if (analysis.getComplexity() > Settings.CLEAR_THRESHOLD) {
|
|
PS.debug("$2[&5Expire&dManager$2] &bSkipping modified: " + plot);
|
|
iter.remove();
|
|
run();
|
|
return;
|
|
}
|
|
}
|
|
HybridUtils.manager.analyzePlot(plot, run);
|
|
} else {
|
|
run.value = null;
|
|
run.run();
|
|
}
|
|
return;
|
|
}
|
|
} catch (final Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}, Settings.CLEAR_INTERVAL * 20);
|
|
}
|
|
|
|
public static boolean isExpired(final UUID uuid) {
|
|
if (UUIDHandler.getPlayer(uuid) != null) {
|
|
return false;
|
|
}
|
|
final String name = UUIDHandler.getName(uuid);
|
|
if (name != null) {
|
|
long last;
|
|
if (dates.contains(uuid)) {
|
|
last = dates.get(uuid);
|
|
} else {
|
|
OfflinePlotPlayer opp;
|
|
if (Settings.TWIN_MODE_UUID) {
|
|
opp = UUIDHandler.getUUIDWrapper().getOfflinePlayer(uuid);
|
|
} else {
|
|
opp = UUIDHandler.getUUIDWrapper().getOfflinePlayer(name);
|
|
}
|
|
last = opp.getLastPlayed();
|
|
if (last != 0) {
|
|
dates.put(uuid, last);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
if (last == 0) {
|
|
return false;
|
|
}
|
|
final long compared = System.currentTimeMillis() - last;
|
|
if (compared >= (86400000l * Settings.AUTO_CLEAR_DAYS)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static boolean isExpired(final Plot plot) {
|
|
for (final UUID owner : PlotHandler.getOwners(plot)) {
|
|
if (!isExpired(owner)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static List<Plot> getOldPlots(final PlotArea area) {
|
|
final ArrayList<Plot> plots = new ArrayList<>(area.getPlots());
|
|
final List<Plot> toRemove = new ArrayList<>();
|
|
final Iterator<Plot> iter = plots.iterator();
|
|
while (iter.hasNext()) {
|
|
final Plot plot = iter.next();
|
|
final Flag keepFlag = FlagManager.getPlotFlagRaw(plot, "keep");
|
|
if ((keepFlag != null) && (Boolean) keepFlag.getValue()) {
|
|
continue;
|
|
}
|
|
final UUID uuid = plot.owner;
|
|
if (uuid == null) {
|
|
toRemove.add(plot);
|
|
continue;
|
|
}
|
|
final PlotPlayer player = UUIDHandler.getPlayer(uuid);
|
|
if (player != null) {
|
|
continue;
|
|
}
|
|
if (isExpired(plot)) {
|
|
toRemove.add(plot);
|
|
}
|
|
}
|
|
return toRemove;
|
|
}
|
|
}
|