Upstream
/
PlotSquared
mirror of https://github.com/IntellectualSites/PlotSquared.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Allow forcing of queues down pipelines to ensure whenDone runnables are called correctly 

Also remove autoQueue since it's never used and would be a bad idea
This commit is contained in:
dordsor21 2020-07-18 13:55:54 +01:00
parent 57af50ed49
commit 03983e8886
No known key found for this signature in database
GPG Key ID: 1E53E88969FFCF0B
20 changed files with 468 additions and 272 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Bukkit/src/main/java/com/plotsquared/bukkit/generator/BlockStatePopulator.java
View File

@ -57,7 +57,7 @@ final class BlockStatePopulator extends BlockPopulator {
@Nonnull final Chunk source) {
if (this.queue == null) {
this.queue = PlotSquared.platform().getGlobalBlockQueue()
.getNewQueue(world.getName(), false);
.getNewQueue(world.getName());
}
final PlotArea area = this.plotAreaManager.getPlotArea(world.getName(), null);
if (area == null) {

9
Bukkit/src/main/java/com/plotsquared/bukkit/queue/BukkitChunkCoordinator.java
View File

@ -46,6 +46,15 @@ import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
/**
* Utility that allows for the loading and coordination of chunk actions
* <p>
* The coordinator takes in collection of chunk coordinates, loads them
* and allows the caller to specify a sink for the loaded chunks. The
* coordinator will prevent the chunks from being unloaded until the sink
* has fully consumed the chunk
* <p>
**/
public final class BukkitChunkCoordinator extends ChunkCoordinator {
private final List<ProgressSubscriber> progressSubscribers = new LinkedList<>();

4
Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitChunkManager.java
View File

@ -78,9 +78,9 @@ public class BukkitChunkManager extends ChunkManager {
BukkitWorld bukkitWorld2 = new BukkitWorld(world2);
QueueCoordinator queue1 =
PlotSquared.platform().getGlobalBlockQueue().getNewQueue(bukkitWorld1, false);
PlotSquared.platform().getGlobalBlockQueue().getNewQueue(bukkitWorld1);
QueueCoordinator queue2 =
PlotSquared.platform().getGlobalBlockQueue().getNewQueue(bukkitWorld2, false);
PlotSquared.platform().getGlobalBlockQueue().getNewQueue(bukkitWorld2);
for (int x = Math.max(r1.getMinimumPoint().getX(), sx);
x <= Math.min(r1.getMaximumPoint().getX(), sx + 15); x++) {

6
Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitRegionManager.java
View File

@ -220,7 +220,7 @@ public class BukkitRegionManager extends RegionManager {
assert oldWorld.equals(newWorld);
final ContentMap map = new ContentMap();
final QueueCoordinator queue =
PlotSquared.platform().getGlobalBlockQueue().getNewQueue(newWorld, false);
PlotSquared.platform().getGlobalBlockQueue().getNewQueue(newWorld);
chunkCoordinatorBuilderFactory.create(chunkCoordinatorFactory).inWorld(newWorld)
.withRegion(pos1, pos2).withThrowableConsumer(Throwable::printStackTrace)
.withRegion(pos1, pos2).withInitialBatchSize(4).withMaxIterationTime(45)
@ -279,7 +279,7 @@ public class BukkitRegionManager extends RegionManager {
}
final QueueCoordinator queue =
PlotSquared.platform().getGlobalBlockQueue().getNewQueue(world, false);
PlotSquared.platform().getGlobalBlockQueue().getNewQueue(world);
chunkCoordinatorBuilderFactory.create(chunkCoordinatorFactory).inWorld(world)
.withRegion(pos1, pos2).withThrowableConsumer(Throwable::printStackTrace)
.withRegion(pos1, pos2).withInitialBatchSize(4).withMaxIterationTime(45)
@ -457,7 +457,7 @@ public class BukkitRegionManager extends RegionManager {
Location pos2 = Location.at(world, region.getMaximumPoint().getX() + extendBiome,
region.getMaximumPoint().getY(), region.getMaximumPoint().getZ() + extendBiome);
final QueueCoordinator queue = PlotSquared.platform().getGlobalBlockQueue()
.getNewQueue(worldUtil.getWeWorld(world), false);
.getNewQueue(worldUtil.getWeWorld(world));
final int minX = pos1.getX();
final int minZ = pos1.getZ();

7
Core/src/main/java/com/plotsquared/core/command/Set.java
View File

@ -35,6 +35,7 @@ import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea;
import com.plotsquared.core.plot.PlotManager;
import com.plotsquared.core.queue.GlobalBlockQueue;
import com.plotsquared.core.queue.QueueCoordinator;
import com.plotsquared.core.util.MainUtil;
import com.plotsquared.core.util.PatternUtil;
import com.plotsquared.core.util.Permissions;
@ -157,11 +158,13 @@ public class Set extends SubCommand {
BackupManager.backup(player, plot, () -> {
plot.addRunning();
QueueCoordinator queue = plotArea.getQueue();
for (Plot current : plot.getConnectedPlots()) {
current.setComponent(component, pattern);
current.setComponent(component, pattern, queue);
}
queue.setCompleteTask(plot::removeRunning);
queue.enqueue();
MainUtil.sendMessage(player, Captions.GENERATING_COMPONENT);
blockQueue.addEmptyTask(plot::removeRunning);
});
return true;
}

2
Core/src/main/java/com/plotsquared/core/command/Trim.java
View File

@ -190,7 +190,7 @@ public class Trim extends SubCommand {
}
}
}
final QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(world), false);
final QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(world));
TaskManager.getPlatformImplementation().objectTask(chunks, new RunnableVal<BlockVector2>() {
@Override public void run(BlockVector2 value) {
queue.regenChunk(value.getX(), value.getZ());

138
Core/src/main/java/com/plotsquared/core/components/ComponentPresetManager.java
View File

@ -37,6 +37,7 @@ import com.plotsquared.core.player.PlotPlayer;
import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotInventory;
import com.plotsquared.core.plot.PlotItemStack;
import com.plotsquared.core.queue.QueueCoordinator;
import com.plotsquared.core.util.EconHandler;
import com.plotsquared.core.util.InventoryUtil;
import com.plotsquared.core.util.MainUtil;
@ -44,11 +45,11 @@ import com.plotsquared.core.util.PatternUtil;
import com.plotsquared.core.util.Permissions;
import com.sk89q.worldedit.function.pattern.Pattern;
import com.sk89q.worldedit.world.item.ItemTypes;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
@ -61,18 +62,20 @@ import java.util.stream.Collectors;
public class ComponentPresetManager {
private static final Logger logger = LoggerFactory.getLogger("P2/" + ComponentPresetManager.class.getSimpleName());
private static final Logger logger =
LoggerFactory.getLogger("P2/" + ComponentPresetManager.class.getSimpleName());
private final List<ComponentPreset> presets;
private final String guiName;
private final EconHandler econHandler;
private final InventoryUtil inventoryUtil;
@Inject public ComponentPresetManager(@Nullable final EconHandler econHandler, @Nonnull final
InventoryUtil inventoryUtil) {
@Inject public ComponentPresetManager(@Nullable final EconHandler econHandler,
@Nonnull final InventoryUtil inventoryUtil) {
this.econHandler = econHandler;
this.inventoryUtil = inventoryUtil;
final File file = new File(Objects.requireNonNull(PlotSquared.platform()).getDirectory(), "components.yml");
final File file = new File(Objects.requireNonNull(PlotSquared.platform()).getDirectory(),
"components.yml");
if (!file.exists()) {
boolean created = false;
try {
@ -103,13 +106,14 @@ public class ComponentPresetManager {
this.guiName = yamlConfiguration.getString("title", "&6Plot Components");
if (yamlConfiguration.contains("presets")) {
this.presets = yamlConfiguration.getMapList("presets").stream().map(o -> (Map<String, Object>) o)
.map(ComponentPreset::deserialize).collect(Collectors.toList());
this.presets =
yamlConfiguration.getMapList("presets").stream().map(o -> (Map<String, Object>) o)
.map(ComponentPreset::deserialize).collect(Collectors.toList());
} else {
final List<ComponentPreset> defaultPreset =
Collections.singletonList(new ComponentPreset(ClassicPlotManagerComponent.FLOOR,
"##wool", 0, "", "&6D&ai&cs&ec&bo &2F&3l&do&9o&4r",
Arrays.asList("&6Spice up your plot floor"), ItemTypes.YELLOW_WOOL));
final List<ComponentPreset> defaultPreset = Collections.singletonList(
new ComponentPreset(ClassicPlotManagerComponent.FLOOR, "##wool", 0, "",
"&6D&ai&cs&ec&bo &2F&3l&do&9o&4r", Arrays.asList("&6Spice up your plot floor"),
ItemTypes.YELLOW_WOOL));
yamlConfiguration.set("presets", defaultPreset.stream().map(ComponentPreset::serialize)
.collect(Collectors.toList()));
try {
@ -139,7 +143,8 @@ public class ComponentPresetManager {
} else if (!plot.hasOwner()) {
Captions.PLOT_UNOWNED.send(player);
return null;
} else if (!plot.isOwner(player.getUUID()) && !plot.getTrusted().contains(player.getUUID())) {
} else if (!plot.isOwner(player.getUUID()) && !plot.getTrusted()
.contains(player.getUUID())) {
Captions.NO_PLOT_PERMS.send(player);
return null;
}
@ -153,71 +158,78 @@ public class ComponentPresetManager {
allowedPresets.add(componentPreset);
}
final int size = (int) Math.ceil((double) allowedPresets.size() / 9.0D);
final PlotInventory plotInventory = new PlotInventory(this.inventoryUtil, player, size, this.guiName) {
@Override public boolean onClick(final int index) {
if (!player.getCurrentPlot().equals(plot)) {
return false;
}
if (index < 0 || index >= allowedPresets.size()) {
return false;
}
final ComponentPreset componentPreset = allowedPresets.get(index);
if (componentPreset == null) {
return false;
}
if (plot.getRunning() > 0) {
Captions.WAIT_FOR_TIMER.send(player);
return false;
}
final Pattern pattern = PatternUtil.parse(null, componentPreset.getPattern(), false);
if (pattern == null) {
Captions.PRESET_INVALID.send(player);
return false;
}
if (componentPreset.getCost() > 0.0D && econHandler != null && plot.getArea().useEconomy()) {
if (econHandler.getMoney(player) < componentPreset.getCost()) {
Captions.PRESET_CANNOT_AFFORD.send(player);
final PlotInventory plotInventory =
new PlotInventory(this.inventoryUtil, player, size, this.guiName) {
@Override public boolean onClick(final int index) {
if (!player.getCurrentPlot().equals(plot)) {
return false;
} else {
econHandler.withdrawMoney(player, componentPreset.getCost());
Captions.REMOVED_BALANCE.send(player, componentPreset.getCost() + "");
}
}
BackupManager.backup(player, plot, () -> {
plot.addRunning();
for (Plot current : plot.getConnectedPlots()) {
current.setComponent(componentPreset.getComponent().name(), pattern);
if (index < 0 || index >= allowedPresets.size()) {
return false;
}
MainUtil.sendMessage(player, Captions.GENERATING_COMPONENT);
PlotSquared.platform().getGlobalBlockQueue().addEmptyTask(plot::removeRunning);
});
return false;
}
};
final ComponentPreset componentPreset = allowedPresets.get(index);
if (componentPreset == null) {
return false;
}
if (plot.getRunning() > 0) {
Captions.WAIT_FOR_TIMER.send(player);
return false;
}
final Pattern pattern =
PatternUtil.parse(null, componentPreset.getPattern(), false);
if (pattern == null) {
Captions.PRESET_INVALID.send(player);
return false;
}
if (componentPreset.getCost() > 0.0D && econHandler != null && plot.getArea()
.useEconomy()) {
if (econHandler.getMoney(player) < componentPreset.getCost()) {
Captions.PRESET_CANNOT_AFFORD.send(player);
return false;
} else {
econHandler.withdrawMoney(player, componentPreset.getCost());
Captions.REMOVED_BALANCE.send(player, componentPreset.getCost() + "");
}
}
BackupManager.backup(player, plot, () -> {
plot.addRunning();
QueueCoordinator queue = plot.getArea().getQueue();
for (Plot current : plot.getConnectedPlots()) {
current.setComponent(componentPreset.getComponent().name(), pattern,
queue);
}
queue.setCompleteTask(plot::removeRunning);
queue.enqueue();
MainUtil.sendMessage(player, Captions.GENERATING_COMPONENT);
});
return false;
}
};
for (int i = 0; i < allowedPresets.size(); i++) {
final ComponentPreset preset = allowedPresets.get(i);
final List<String> lore = new ArrayList<>();
if (preset.getCost() > 0 && this.econHandler != null && plot.getArea().useEconomy()){
lore.add(Captions.PRESET_LORE_COST.getTranslated().replace("%cost%",
String.format("%.2f", preset.getCost())));
if (preset.getCost() > 0 && this.econHandler != null && plot.getArea().useEconomy()) {
lore.add(Captions.PRESET_LORE_COST.getTranslated()
.replace("%cost%", String.format("%.2f", preset.getCost())));
}
lore.add(Captions.PRESET_LORE_COMPONENT.getTranslated().replace("%component%",
preset.getComponent().name().toLowerCase()));
lore.add(Captions.PRESET_LORE_COMPONENT.getTranslated()
.replace("%component%", preset.getComponent().name().toLowerCase()));
lore.removeIf(String::isEmpty);
if (!lore.isEmpty()) {
lore.add("&6");
}
lore.addAll(preset.getDescription());
plotInventory.setItem(i, new PlotItemStack(preset.getIcon().getId().replace("minecraft:", ""),
1, preset.getDisplayName(), lore.toArray(new String[0])));
plotInventory.setItem(i,
new PlotItemStack(preset.getIcon().getId().replace("minecraft:", ""), 1,
preset.getDisplayName(), lore.toArray(new String[0])));
}
return plotInventory;

2
Core/src/main/java/com/plotsquared/core/generator/AugmentedUtils.java
View File

@ -87,7 +87,7 @@ public class AugmentedUtils {
IndependentPlotGenerator generator = area.getGenerator();
// Mask
if (queue == null) {
queue = PlotSquared.platform().getGlobalBlockQueue().getNewQueue(PlotSquared.platform().getWorldUtil().getWeWorld(world), false);
queue = PlotSquared.platform().getGlobalBlockQueue().getNewQueue(PlotSquared.platform().getWorldUtil().getWeWorld(world));
queue.setChunkObject(chunkObject);
}
QueueCoordinator primaryMask;

330
Core/src/main/java/com/plotsquared/core/generator/ClassicPlotManager.java
View File

@ -40,8 +40,9 @@ import com.plotsquared.core.util.task.TaskManager;
import com.sk89q.worldedit.function.pattern.Pattern;
import com.sk89q.worldedit.regions.CuboidRegion;
import com.sk89q.worldedit.world.block.BlockTypes;
import javax.annotation.Nonnull;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.List;
import java.util.Optional;
@ -54,98 +55,107 @@ public class ClassicPlotManager extends SquarePlotManager {
private final RegionManager regionManager;
public ClassicPlotManager(@Nonnull final ClassicPlotWorld classicPlotWorld,
@Nonnull final RegionManager regionManager) {
@Nonnull final RegionManager regionManager) {
super(classicPlotWorld, regionManager);
this.classicPlotWorld = classicPlotWorld;
this.regionManager = regionManager;
}
@Override public boolean setComponent(PlotId plotId, String component, Pattern blocks) {
@Override public boolean setComponent(PlotId plotId, String component, Pattern blocks,
@Nullable QueueCoordinator queue) {
final Optional<ClassicPlotManagerComponent> componentOptional =
ClassicPlotManagerComponent.fromString(component);
if (componentOptional.isPresent()) {
switch (componentOptional.get()) {
case FLOOR:
return setFloor(plotId, blocks);
return setFloor(plotId, blocks, queue);
case WALL:
return setWallFilling(plotId, blocks);
return setWallFilling(plotId, blocks, queue);
case AIR:
return setAir(plotId, blocks);
return setAir(plotId, blocks, queue);
case MAIN:
return setMain(plotId, blocks);
return setMain(plotId, blocks, queue);
case MIDDLE:
return setMiddle(plotId, blocks);
return setMiddle(plotId, blocks, queue);
case OUTLINE:
return setOutline(plotId, blocks);
return setOutline(plotId, blocks, queue);
case BORDER:
return setWall(plotId, blocks);
return setWall(plotId, blocks, queue);
case ALL:
return setAll(plotId, blocks);
return setAll(plotId, blocks, queue);
}
}
return false;
}
@Override public boolean unClaimPlot(Plot plot, Runnable whenDone) {
setWallFilling(plot.getId(), classicPlotWorld.WALL_FILLING.toPattern());
@Override public boolean unClaimPlot(Plot plot, @Nullable Runnable whenDone,
@Nullable QueueCoordinator queue) {
setWallFilling(plot.getId(), classicPlotWorld.WALL_FILLING.toPattern(), queue);
if (!classicPlotWorld.WALL_BLOCK.isAir() || !classicPlotWorld.WALL_BLOCK
.equals(classicPlotWorld.CLAIMED_WALL_BLOCK)) {
setWall(plot.getId(), classicPlotWorld.WALL_BLOCK.toPattern());
setWall(plot.getId(), classicPlotWorld.WALL_BLOCK.toPattern(), queue);
}
TaskManager.runTask(whenDone);
return true;
}
public boolean setFloor(PlotId plotId, Pattern blocks) {
public boolean setFloor(PlotId plotId, Pattern blocks, @Nullable QueueCoordinator queue) {
Plot plot = classicPlotWorld.getPlotAbs(plotId);
if (plot.isBasePlot()) {
if (plot != null && plot.isBasePlot()) {
return this.regionManager.setCuboids(classicPlotWorld, plot.getRegions(), blocks,
classicPlotWorld.PLOT_HEIGHT, classicPlotWorld.PLOT_HEIGHT);
classicPlotWorld.PLOT_HEIGHT, classicPlotWorld.PLOT_HEIGHT, queue);
}
return false;
}
public boolean setAll(PlotId plotId, Pattern blocks) {
public boolean setAll(PlotId plotId, Pattern blocks, @Nullable QueueCoordinator queue) {
Plot plot = classicPlotWorld.getPlotAbs(plotId);
if (plot.isBasePlot()) {
return this.regionManager.setCuboids(classicPlotWorld, plot.getRegions(), blocks, 1, getWorldHeight());
if (plot != null && plot.isBasePlot()) {
return this.regionManager
.setCuboids(classicPlotWorld, plot.getRegions(), blocks, 1, getWorldHeight(),
queue);
}
return false;
}
public boolean setAir(PlotId plotId, Pattern blocks) {
public boolean setAir(PlotId plotId, Pattern blocks, @Nullable QueueCoordinator queue) {
Plot plot = classicPlotWorld.getPlotAbs(plotId);
if (plot.isBasePlot()) {
if (plot != null && plot.isBasePlot()) {
return this.regionManager.setCuboids(classicPlotWorld, plot.getRegions(), blocks,
classicPlotWorld.PLOT_HEIGHT + 1, getWorldHeight());
classicPlotWorld.PLOT_HEIGHT + 1, getWorldHeight(), queue);
}
return false;
}
public boolean setMain(PlotId plotId, Pattern blocks) {
public boolean setMain(PlotId plotId, Pattern blocks, @Nullable QueueCoordinator queue) {
Plot plot = classicPlotWorld.getPlotAbs(plotId);
if (plot.isBasePlot()) {
if (plot == null || plot.isBasePlot()) {
return this.regionManager.setCuboids(classicPlotWorld, plot.getRegions(), blocks, 1,
classicPlotWorld.PLOT_HEIGHT - 1);
classicPlotWorld.PLOT_HEIGHT - 1, queue);
}
return false;
}
public boolean setMiddle(PlotId plotId, Pattern blocks) {
public boolean setMiddle(PlotId plotId, Pattern blocks, @Nullable QueueCoordinator queue) {
Plot plot = classicPlotWorld.getPlotAbs(plotId);
if (!plot.isBasePlot()) {
if (plot == null || !plot.isBasePlot()) {
return false;
}
Location[] corners = plot.getCorners();
QueueCoordinator queue = classicPlotWorld.getQueue(false);
boolean enqueue = false;
if (queue == null) {
queue = classicPlotWorld.getQueue();
enqueue = true;
}
int x = MathMan.average(corners[0].getX(), corners[1].getX());
int z = MathMan.average(corners[0].getZ(), corners[1].getZ());
queue.setBlock(x, classicPlotWorld.PLOT_HEIGHT, z, blocks);
return queue.enqueue();
return !enqueue || queue.enqueue();
}
public boolean setOutline(PlotId plotId, Pattern blocks) {
public boolean setOutline(PlotId plotId, Pattern blocks, @Nullable QueueCoordinator queue) {
if (classicPlotWorld.ROAD_WIDTH == 0) {
return false;
}
@ -156,9 +166,18 @@ public class ClassicPlotManager extends SquarePlotManager {
return true;
}
Plot plot = classicPlotWorld.getPlotAbs(plotId);
if (plot == null) {
return false;
}
Location bottom = plot.getBottomAbs();
Location top = plot.getExtendedTopAbs();
QueueCoordinator queue = classicPlotWorld.getQueue(false);
boolean enqueue = false;
if (queue == null) {
queue = classicPlotWorld.getQueue();
enqueue = true;
}
int maxY = classicPlotWorld.getPlotManager().getWorldHeight();
if (!plot.getMerged(Direction.NORTH)) {
int z = bottom.getZ();
@ -195,19 +214,19 @@ public class ClassicPlotManager extends SquarePlotManager {
}
if (plot.isBasePlot()) {
for (CuboidRegion region : plot.getRegions()) {
Location pos1 =
Location.at(classicPlotWorld.getWorldName(), region.getMinimumPoint().getX(),
maxY, region.getMinimumPoint().getZ());
Location pos2 =
Location.at(classicPlotWorld.getWorldName(), region.getMaximumPoint().getX(),
maxY, region.getMaximumPoint().getZ());
Location pos1 = Location
.at(classicPlotWorld.getWorldName(), region.getMinimumPoint().getX(), maxY,
region.getMinimumPoint().getZ());
Location pos2 = Location
.at(classicPlotWorld.getWorldName(), region.getMaximumPoint().getX(), maxY,
region.getMaximumPoint().getZ());
queue.setCuboid(pos1, pos2, blocks);
}
}
return queue.enqueue();
return !enqueue || queue.enqueue();
}
public boolean setWallFilling(PlotId plotId, Pattern blocks) {
public boolean setWallFilling(PlotId plotId, Pattern blocks, @Nullable QueueCoordinator queue) {
if (classicPlotWorld.ROAD_WIDTH == 0) {
return false;
}
@ -218,11 +237,20 @@ public class ClassicPlotManager extends SquarePlotManager {
return true;
}
Plot plot = classicPlotWorld.getPlotAbs(plotId);
if (plot == null) {
return false;
}
Location bot = plot.getExtendedBottomAbs()
.subtract(plot.getMerged(Direction.WEST) ? 0 : 1, 0,
plot.getMerged(Direction.NORTH) ? 0 : 1);
Location top = plot.getExtendedTopAbs().add(1, 0, 1);
QueueCoordinator queue = classicPlotWorld.getQueue(false);
boolean enqueue = false;
if (queue == null) {
queue = classicPlotWorld.getQueue();
enqueue = true;
}
if (!plot.getMerged(Direction.NORTH)) {
int z = bot.getZ();
for (int x = bot.getX(); x < top.getX(); x++) {
@ -257,10 +285,10 @@ public class ClassicPlotManager extends SquarePlotManager {
}
}
}
return queue.enqueue();
return !enqueue || queue.enqueue();
}
public boolean setWall(PlotId plotId, Pattern blocks) {
public boolean setWall(PlotId plotId, Pattern blocks, @Nullable QueueCoordinator queue) {
if (classicPlotWorld.ROAD_WIDTH == 0) {
return false;
}
@ -271,11 +299,20 @@ public class ClassicPlotManager extends SquarePlotManager {
return true;
}
Plot plot = classicPlotWorld.getPlotAbs(plotId);
if (plot == null) {
return false;
}
Location bot = plot.getExtendedBottomAbs()
.subtract(plot.getMerged(Direction.WEST) ? 0 : 1, 0,
plot.getMerged(Direction.NORTH) ? 0 : 1);
Location top = plot.getExtendedTopAbs().add(1, 0, 1);
QueueCoordinator queue = classicPlotWorld.getQueue(false);
boolean enqueue = false;
if (queue == null) {
enqueue = true;
queue = classicPlotWorld.getQueue();
}
int y = classicPlotWorld.WALL_HEIGHT + 1;
if (!plot.getMerged(Direction.NORTH)) {
int z = bot.getZ();
@ -303,23 +340,29 @@ public class ClassicPlotManager extends SquarePlotManager {
queue.setBlock(x, y, z, blocks);
}
}
return queue.enqueue();
return !enqueue || queue.enqueue();
}
/**
* PLOT MERGING.
*/
@Override public boolean createRoadEast(Plot plot) {
@Override public boolean createRoadEast(Plot plot, @Nullable QueueCoordinator queue) {
Location pos1 = getPlotBottomLocAbs(plot.getId());
Location pos2 = getPlotTopLocAbs(plot.getId());
int sx = pos2.getX() + 1;
int ex = sx + classicPlotWorld.ROAD_WIDTH - 1;
int sz = pos1.getZ() - 2;
int ez = pos2.getZ() + 2;
QueueCoordinator queue = classicPlotWorld.getQueue(false);
boolean enqueue = false;
if (queue == null) {
queue = classicPlotWorld.getQueue();
enqueue = true;
}
int maxY = getWorldHeight();
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx,
Math.min(classicPlotWorld.WALL_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, sz + 1),
Math.min(classicPlotWorld.WALL_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex, maxY, ez - 1),
BlockTypes.AIR.getDefaultState());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx, 0, sz + 1),
@ -328,37 +371,43 @@ public class ClassicPlotManager extends SquarePlotManager {
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx, 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT, ez - 1),
classicPlotWorld.WALL_FILLING.toPattern());
queue.setCuboid(
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT + 1,
sz + 1),
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT + 1,
ez - 1), classicPlotWorld.WALL_BLOCK.toPattern());
queue.setCuboid(Location
.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT + 1, sz + 1),
Location
.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT + 1, ez - 1),
classicPlotWorld.WALL_BLOCK.toPattern());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), ex, 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT, ez - 1),
classicPlotWorld.WALL_FILLING.toPattern());
queue.setCuboid(
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT + 1,
sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT + 1,
ez - 1), classicPlotWorld.WALL_BLOCK.toPattern());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT,
ez - 1), classicPlotWorld.ROAD_BLOCK.toPattern());
return queue.enqueue();
queue.setCuboid(Location
.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT + 1, sz + 1),
Location
.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT + 1, ez - 1),
classicPlotWorld.WALL_BLOCK.toPattern());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz + 1), Location
.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT, ez - 1),
classicPlotWorld.ROAD_BLOCK.toPattern());
return !enqueue || queue.enqueue();
}
@Override public boolean createRoadSouth(Plot plot) {
@Override public boolean createRoadSouth(Plot plot, @Nullable QueueCoordinator queue) {
Location pos1 = getPlotBottomLocAbs(plot.getId());
Location pos2 = getPlotTopLocAbs(plot.getId());
int sz = pos2.getZ() + 1;
int ez = sz + classicPlotWorld.ROAD_WIDTH - 1;
int sx = pos1.getX() - 2;
int ex = pos2.getX() + 2;
QueueCoordinator queue = classicPlotWorld.getQueue(false);
boolean enqueue = false;
if (queue == null) {
queue = classicPlotWorld.getQueue();
enqueue = true;
}
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1,
Math.min(classicPlotWorld.WALL_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, sz),
Location.at(classicPlotWorld.getWorldName(), ex - 1,
classicPlotWorld.getPlotManager().getWorldHeight(), ez),
Math.min(classicPlotWorld.WALL_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, sz), Location
.at(classicPlotWorld.getWorldName(), ex - 1,
classicPlotWorld.getPlotManager().getWorldHeight(), ez),
BlockTypes.AIR.getDefaultState());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 0, sz),
Location.at(classicPlotWorld.getWorldName(), ex - 1, 0, ez),
@ -366,104 +415,128 @@ public class ClassicPlotManager extends SquarePlotManager {
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT, sz),
classicPlotWorld.WALL_FILLING.toPattern());
queue.setCuboid(
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.WALL_HEIGHT + 1,
sz),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT + 1,
sz), classicPlotWorld.WALL_BLOCK.toPattern());
queue.setCuboid(Location
.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.WALL_HEIGHT + 1, sz),
Location
.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT + 1, sz),
classicPlotWorld.WALL_BLOCK.toPattern());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, ez),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT, ez),
classicPlotWorld.WALL_FILLING.toPattern());
queue.setCuboid(
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.WALL_HEIGHT + 1,
ez),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT + 1,
ez), classicPlotWorld.WALL_BLOCK.toPattern());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT,
ez - 1), classicPlotWorld.ROAD_BLOCK.toPattern());
return queue.enqueue();
queue.setCuboid(Location
.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.WALL_HEIGHT + 1, ez),
Location
.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT + 1, ez),
classicPlotWorld.WALL_BLOCK.toPattern());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz + 1), Location
.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT, ez - 1),
classicPlotWorld.ROAD_BLOCK.toPattern());
return !enqueue || queue.enqueue();
}
@Override public boolean createRoadSouthEast(Plot plot) {
@Override public boolean createRoadSouthEast(Plot plot, @Nullable QueueCoordinator queue) {
Location pos2 = getPlotTopLocAbs(plot.getId());
int sx = pos2.getX() + 1;
int ex = sx + classicPlotWorld.ROAD_WIDTH - 1;
int sz = pos2.getZ() + 1;
int ez = sz + classicPlotWorld.ROAD_WIDTH - 1;
QueueCoordinator queue = classicPlotWorld.getQueue(false);
queue.setCuboid(
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.ROAD_HEIGHT + 1,
sz + 1), Location.at(classicPlotWorld.getWorldName(), ex - 1,
boolean enqueue = false;
if (queue == null) {
queue = classicPlotWorld.getQueue();
enqueue = true;
}
queue.setCuboid(Location
.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.ROAD_HEIGHT + 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex - 1,
classicPlotWorld.getPlotManager().getWorldHeight(), ez - 1),
BlockTypes.AIR.getDefaultState());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 0, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex - 1, 0, ez - 1),
BlockUtil.get((short) 7, (byte) 0));
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT,
ez - 1), classicPlotWorld.ROAD_BLOCK.toPattern());
return queue.enqueue();
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz + 1), Location
.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT, ez - 1),
classicPlotWorld.ROAD_BLOCK.toPattern());
return !enqueue || queue.enqueue();
}
@Override public boolean removeRoadEast(Plot plot) {
@Override public boolean removeRoadEast(Plot plot, @Nullable QueueCoordinator queue) {
Location pos1 = getPlotBottomLocAbs(plot.getId());
Location pos2 = getPlotTopLocAbs(plot.getId());
int sx = pos2.getX() + 1;
int ex = sx + classicPlotWorld.ROAD_WIDTH - 1;
int sz = pos1.getZ() - 1;
int ez = pos2.getZ() + 1;
QueueCoordinator queue = classicPlotWorld.getQueue(false);
boolean enqueue = false;
if (queue == null) {
queue = classicPlotWorld.getQueue();
enqueue = true;
}
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx,
Math.min(classicPlotWorld.PLOT_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, sz),
Location.at(classicPlotWorld.getWorldName(), ex,
classicPlotWorld.getPlotManager().getWorldHeight(), ez),
Math.min(classicPlotWorld.PLOT_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, sz), Location
.at(classicPlotWorld.getWorldName(), ex,
classicPlotWorld.getPlotManager().getWorldHeight(), ez),
BlockTypes.AIR.getDefaultState());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx, 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.PLOT_HEIGHT - 1,
ez - 1), classicPlotWorld.MAIN_BLOCK.toPattern());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx, 1, sz + 1), Location
.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.PLOT_HEIGHT - 1, ez - 1),
classicPlotWorld.MAIN_BLOCK.toPattern());
queue.setCuboid(
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.PLOT_HEIGHT, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.PLOT_HEIGHT, ez - 1),
classicPlotWorld.TOP_BLOCK.toPattern());
return queue.enqueue();
return !enqueue || queue.enqueue();
}
@Override public boolean removeRoadSouth(Plot plot) {
@Override public boolean removeRoadSouth(Plot plot, @Nullable QueueCoordinator queue) {
Location pos1 = getPlotBottomLocAbs(plot.getId());
Location pos2 = getPlotTopLocAbs(plot.getId());
int sz = pos2.getZ() + 1;
int ez = sz + classicPlotWorld.ROAD_WIDTH - 1;
int sx = pos1.getX() - 1;
int ex = pos2.getX() + 1;
QueueCoordinator queue = classicPlotWorld.getQueue(false);
boolean enqueue = false;
if (queue == null) {
queue = classicPlotWorld.getQueue();
enqueue = true;
}
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx,
Math.min(classicPlotWorld.PLOT_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, sz),
Location.at(classicPlotWorld.getWorldName(), ex,
classicPlotWorld.getPlotManager().getWorldHeight(), ez),
Math.min(classicPlotWorld.PLOT_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, sz), Location
.at(classicPlotWorld.getWorldName(), ex,
classicPlotWorld.getPlotManager().getWorldHeight(), ez),
BlockTypes.AIR.getDefaultState());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.PLOT_HEIGHT - 1,
ez), classicPlotWorld.MAIN_BLOCK.toPattern());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz), Location
.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.PLOT_HEIGHT - 1, ez),
classicPlotWorld.MAIN_BLOCK.toPattern());
queue.setCuboid(
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.PLOT_HEIGHT, sz),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.PLOT_HEIGHT, ez),
classicPlotWorld.TOP_BLOCK.toPattern());
return queue.enqueue();
return !enqueue || queue.enqueue();
}
@Override public boolean removeRoadSouthEast(Plot plot) {
@Override public boolean removeRoadSouthEast(Plot plot, @Nullable QueueCoordinator queue) {
Location location = getPlotTopLocAbs(plot.getId());
int sx = location.getX() + 1;
int ex = sx + classicPlotWorld.ROAD_WIDTH - 1;
int sz = location.getZ() + 1;
int ez = sz + classicPlotWorld.ROAD_WIDTH - 1;
QueueCoordinator queue = classicPlotWorld.getQueue(false);
boolean enqueue = false;
if (queue == null) {
queue = classicPlotWorld.getQueue();
enqueue = true;
}
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx,
Math.min(classicPlotWorld.PLOT_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, sz),
Location.at(classicPlotWorld.getWorldName(), ex,
classicPlotWorld.getPlotManager().getWorldHeight(), ez),
BlockTypes.AIR.getDefaultState());
Math.min(classicPlotWorld.PLOT_HEIGHT, classicPlotWorld.ROAD_HEIGHT) + 1, sz), Location
.at(classicPlotWorld.getWorldName(), ex,
classicPlotWorld.getPlotManager().getWorldHeight(), ez),
BlockTypes.AIR.getDefaultState());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx, 1, sz),
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.PLOT_HEIGHT - 1, ez),
classicPlotWorld.MAIN_BLOCK.toPattern());
@ -471,7 +544,7 @@ public class ClassicPlotManager extends SquarePlotManager {
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.PLOT_HEIGHT, sz),
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.PLOT_HEIGHT, ez),
classicPlotWorld.TOP_BLOCK.toPattern());
return queue.enqueue();
return !enqueue || queue.enqueue();
}
/**
@ -479,44 +552,48 @@ public class ClassicPlotManager extends SquarePlotManager {
*
* @return false if part of the merge failed, otherwise true if successful.
*/
@Override public boolean finishPlotMerge(List<PlotId> plotIds) {
@Override public boolean finishPlotMerge(List<PlotId> plotIds,
@Nullable QueueCoordinator queue) {
final BlockBucket claim = classicPlotWorld.CLAIMED_WALL_BLOCK;
if (!claim.isAir() || !claim.equals(classicPlotWorld.WALL_BLOCK)) {
for (PlotId plotId : plotIds) {
setWall(plotId, claim.toPattern());
setWall(plotId, claim.toPattern(), queue);
}
}
if (Settings.General.MERGE_REPLACE_WALL) {
final BlockBucket wallBlock = classicPlotWorld.WALL_FILLING;
for (PlotId id : plotIds) {
setWallFilling(id, wallBlock.toPattern());
setWallFilling(id, wallBlock.toPattern(), queue);
}
}
return true;
}
@Override public boolean finishPlotUnlink(List<PlotId> plotIds) {
@Override
public boolean finishPlotUnlink(List<PlotId> plotIds, @Nullable QueueCoordinator queue) {
final BlockBucket claim = classicPlotWorld.CLAIMED_WALL_BLOCK;
if (!claim.isAir() || !claim.equals(classicPlotWorld.WALL_BLOCK)) {
for (PlotId id : plotIds) {
setWall(id, claim.toPattern());
setWall(id, claim.toPattern(), queue);
}
}
return true; // return false if unlink has been denied
}
@Override public boolean startPlotMerge(List<PlotId> plotIds) {
@Override
public boolean startPlotMerge(List<PlotId> plotIds, @Nullable QueueCoordinator queue) {
return true;
}
@Override public boolean startPlotUnlink(List<PlotId> plotIds) {
@Override
public boolean startPlotUnlink(List<PlotId> plotIds, @Nullable QueueCoordinator queue) {
return true;
}
@Override public boolean claimPlot(Plot plot) {
@Override public boolean claimPlot(Plot plot, @Nullable QueueCoordinator queue) {
final BlockBucket claim = classicPlotWorld.CLAIMED_WALL_BLOCK;
if (!claim.isAir() || !claim.equals(classicPlotWorld.WALL_BLOCK)) {
return setWall(plot.getId(), claim.toPattern());
return setWall(plot.getId(), claim.toPattern(), queue);
}
return true;
}
@ -534,8 +611,9 @@ public class ClassicPlotManager extends SquarePlotManager {
@Override public Location getSignLoc(Plot plot) {
plot = plot.getBasePlot(false);
final Location bot = plot.getBottomAbs();
return Location.at(classicPlotWorld.getWorldName(), bot.getX() - 1,
classicPlotWorld.ROAD_HEIGHT + 1, bot.getZ() - 2);
return Location
.at(classicPlotWorld.getWorldName(), bot.getX() - 1, classicPlotWorld.ROAD_HEIGHT + 1,
bot.getZ() - 2);
}
}

8
Core/src/main/java/com/plotsquared/core/generator/HybridPlotManager.java
View File

@ -115,7 +115,7 @@ public class HybridPlotManager extends ClassicPlotManager {
if (!hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
return true;
}
QueueCoordinator queue = hybridPlotWorld.getQueue(false);
QueueCoordinator queue = hybridPlotWorld.getQueue();
createSchemAbs(queue, pos1, pos2, true);
queue.enqueue();
return true;
@ -178,7 +178,7 @@ public class HybridPlotManager extends ClassicPlotManager {
if (!hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
return true;
}
QueueCoordinator queue = hybridPlotWorld.getQueue(false);
QueueCoordinator queue = hybridPlotWorld.getQueue();
createSchemAbs(queue, pos1, pos2, true);
queue.enqueue();
return true;
@ -190,7 +190,7 @@ public class HybridPlotManager extends ClassicPlotManager {
PlotId id2 = new PlotId(id.x + 1, id.y + 1);
Location pos1 = getPlotTopLocAbs(id).add(1, 0, 1).withY(0);
Location pos2 = getPlotBottomLocAbs(id2).withY(Math.min(getWorldHeight(), 255));
QueueCoordinator queue = hybridPlotWorld.getQueue(false);
QueueCoordinator queue = hybridPlotWorld.getQueue();
createSchemAbs(queue, pos1, pos2, true);
if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
createSchemAbs(queue, pos1, pos2, true);
@ -232,7 +232,7 @@ public class HybridPlotManager extends ClassicPlotManager {
}
final BiomeType biome = hybridPlotWorld.getPlotBiome();
final QueueCoordinator queue = hybridPlotWorld.getQueue(false);
final QueueCoordinator queue = hybridPlotWorld.getQueue();
ChunkManager.chunkTask(pos1, pos2, new RunnableVal<int[]>() {
@Override public void run(int[] value) {
// If the chunk isn't near the edge and it isn't an augmented world we can just regen the whole chunk

6
Core/src/main/java/com/plotsquared/core/generator/HybridUtils.java
View File

@ -128,7 +128,7 @@ public class HybridUtils {
*
*/
TaskManager.runTaskAsync(() -> {
final QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(world), false);
final QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(world));
final BlockVector3 bot = region.getMinimumPoint();
final BlockVector3 top = region.getMaximumPoint();
@ -520,7 +520,7 @@ public class HybridUtils {
public boolean setupRoadSchematic(Plot plot) {
final String world = plot.getWorldName();
final QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(world), false);
final QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(world));
Location bot = plot.getBottomAbs().subtract(1, 0, 1);
Location top = plot.getTopAbs();
final HybridPlotWorld plotworld = (HybridPlotWorld) plot.getArea();
@ -607,7 +607,7 @@ public class HybridUtils {
z -= plotWorld.ROAD_OFFSET_Z;
final int finalX = x;
final int finalZ = z;
QueueCoordinator queue = this.blockQueue.getNewQueue(worldUtil.getWeWorld(plotWorld.getWorldName()), false);
QueueCoordinator queue = this.blockQueue.getNewQueue(worldUtil.getWeWorld(plotWorld.getWorldName()));
if (id1 == null || id2 == null || id1 != id2) {
this.chunkManager.loadChunk(area.getWorldName(), chunk, false).thenRun(() -> {
if (id1 != null) {

20
Core/src/main/java/com/plotsquared/core/generator/SquarePlotManager.java
View File

@ -30,13 +30,15 @@ import com.plotsquared.core.location.Location;
import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea;
import com.plotsquared.core.plot.PlotId;
import com.plotsquared.core.queue.QueueCoordinator;
import com.plotsquared.core.util.MainUtil;
import com.plotsquared.core.util.RegionManager;
import com.sk89q.worldedit.regions.CuboidRegion;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nonnull;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.Iterator;
import java.util.Set;
@ -45,18 +47,21 @@ import java.util.Set;
*/
public abstract class SquarePlotManager extends GridPlotManager {
private static final Logger logger = LoggerFactory.getLogger("P2/" + SquarePlotManager.class.getSimpleName());
private static final Logger logger =
LoggerFactory.getLogger("P2/" + SquarePlotManager.class.getSimpleName());
private final SquarePlotWorld squarePlotWorld;
private final RegionManager regionManager;
public SquarePlotManager(@Nonnull final SquarePlotWorld squarePlotWorld, @Nonnull final RegionManager regionManager) {
public SquarePlotManager(@Nonnull final SquarePlotWorld squarePlotWorld,
@Nonnull final RegionManager regionManager) {
super(squarePlotWorld);
this.squarePlotWorld = squarePlotWorld;
this.regionManager = regionManager;
}
@Override public boolean clearPlot(final Plot plot, final Runnable whenDone) {
@Override public boolean clearPlot(final Plot plot, final Runnable whenDone,
@Nullable QueueCoordinator queue) {
final Set<CuboidRegion> regions = plot.getRegions();
Runnable run = new Runnable() {
@Override public void run() {
@ -230,8 +235,8 @@ public abstract class SquarePlotManager extends GridPlotManager {
return plot.getMerged(Direction.NORTHWEST) ? id : null;
}
} catch (Exception ignored) {
logger.error( "Invalid plot / road width in settings.yml for world: {}", squarePlotWorld
.getWorldName());
logger.error("Invalid plot / road width in settings.yml for world: {}",
squarePlotWorld.getWorldName());
}
return null;
}
@ -248,6 +253,7 @@ public abstract class SquarePlotManager extends GridPlotManager {
int z = (squarePlotWorld.ROAD_OFFSET_Z + (pz * (squarePlotWorld.ROAD_WIDTH
+ squarePlotWorld.PLOT_WIDTH))) - squarePlotWorld.PLOT_WIDTH - (int) Math
.floor(squarePlotWorld.ROAD_WIDTH / 2);
return Location.at(squarePlotWorld.getWorldName(), x, squarePlotWorld.getMinBuildHeight(), z);
return Location
.at(squarePlotWorld.getWorldName(), x, squarePlotWorld.getMinBuildHeight(), z);
}
}

33
Core/src/main/java/com/plotsquared/core/plot/Plot.java
View File

@ -1033,26 +1033,28 @@ public class Plot {
ids.add(current.getId());
}
this.clearRatings();
QueueCoordinator queue = null;
if (createSign) {
this.removeSign();
queue = getArea().getQueue();
}
PlotManager manager = this.area.getPlotManager();
if (createRoad) {
manager.startPlotUnlink(ids);
manager.startPlotUnlink(ids, queue);
}
if (this.area.getTerrain() != PlotAreaTerrainType.ALL && createRoad) {
for (Plot current : plots) {
if (current.getMerged(Direction.EAST)) {
manager.createRoadEast(current);
manager.createRoadEast(current, queue);
if (current.getMerged(Direction.SOUTH)) {
manager.createRoadSouth(current);
manager.createRoadSouth(current, queue);
if (current.getMerged(Direction.SOUTHEAST)) {
manager.createRoadSouthEast(current);
manager.createRoadSouthEast(current, queue);
}
}
}
if (current.getMerged(Direction.SOUTH)) {
manager.createRoadSouth(current);
manager.createRoadSouth(current, queue);
}
}
}
@ -1061,14 +1063,14 @@ public class Plot {
current.setMerged(merged);
}
if (createSign) {
TaskManager.runTaskAsync(() -> {
queue.setCompleteTask(() -> TaskManager.runTaskAsync(() -> {
for (Plot current : plots) {
current.setSign(MainUtil.getName(current.getOwnerAbs()));
}
});
}));
}
if (createRoad) {
manager.finishPlotUnlink(ids);
manager.finishPlotUnlink(ids, queue);
}
return true;
}
@ -1686,7 +1688,7 @@ public class Plot {
*/
public void refreshChunks() {
QueueCoordinator queue = this.blockQueue
.getNewQueue(PlotSquared.platform().getWorldUtil().getWeWorld(getWorldName()), false);
.getNewQueue(PlotSquared.platform().getWorldUtil().getWeWorld(getWorldName()));
HashSet<BlockVector2> chunks = new HashSet<>();
for (CuboidRegion region : Plot.this.getRegions()) {
for (int x = region.getMinimumPoint().getX() >> 4;
@ -1710,8 +1712,7 @@ public class Plot {
return;
}
Location location = manager.getSignLoc(this);
QueueCoordinator queue =
this.blockQueue.getNewQueue(worldUtil.getWeWorld(getWorldName()), false);
QueueCoordinator queue = this.blockQueue.getNewQueue(worldUtil.getWeWorld(getWorldName()));
queue.setBlock(location.getX(), location.getY(), location.getZ(),
BlockTypes.AIR.getDefaultState());
queue.enqueue();
@ -1852,12 +1853,13 @@ public class Plot {
* Sets components such as border, wall, floor.
* (components are generator specific)
*/
@Deprecated public boolean setComponent(String component, String blocks) {
@Deprecated public boolean setComponent(String component, String blocks,
QueueCoordinator queue) {
BlockBucket parsed = ConfigurationUtil.BLOCK_BUCKET.parseString(blocks);
if (parsed != null && parsed.isEmpty()) {
return false;
}
return this.setComponent(component, parsed.toPattern());
return this.setComponent(component, parsed.toPattern(), queue);
}
/**
@ -3052,12 +3054,13 @@ public class Plot {
* @param blocks Pattern to use the generation
* @return True if the component was set successfully
*/
public boolean setComponent(String component, Pattern blocks) {
public boolean setComponent(String component, Pattern blocks,
@Nullable QueueCoordinator queue) {
PlotComponentSetEvent event =
this.eventDispatcher.callComponentSet(this, component, blocks);
component = event.getComponent();
blocks = event.getPattern();
return this.getManager().setComponent(this.getId(), component, blocks);
return this.getManager().setComponent(this.getId(), component, blocks, queue);
}
public int getDistanceFromOrigin() {

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

@ -172,8 +172,8 @@ public abstract class PlotArea {
@Nonnull protected abstract PlotManager createManager();
public QueueCoordinator getQueue(final boolean autoQueue) {
return this.globalBlockQueue.getNewQueue(PlotSquared.platform().getWorldUtil().getWeWorld(worldName), autoQueue);
public QueueCoordinator getQueue() {
return this.globalBlockQueue.getNewQueue(PlotSquared.platform().getWorldUtil().getWeWorld(worldName));
}
/**

100
Core/src/main/java/com/plotsquared/core/plot/PlotManager.java
View File

@ -28,9 +28,11 @@ package com.plotsquared.core.plot;
import com.plotsquared.core.command.Template;
import com.plotsquared.core.configuration.Settings;
import com.plotsquared.core.location.Location;
import com.plotsquared.core.queue.QueueCoordinator;
import com.plotsquared.core.util.FileBytes;
import com.sk89q.worldedit.function.pattern.Pattern;
import javax.annotation.Nullable;
import java.io.IOException;
import java.util.Collections;
import java.util.HashSet;
@ -61,11 +63,27 @@ public abstract class PlotManager {
/*
* Plot clearing (return false if you do not support some method)
*/
public abstract boolean clearPlot(Plot plot, Runnable whenDone);
public boolean clearPlot(Plot plot, Runnable whenDone) {
return clearPlot(plot, whenDone, null);
}
public abstract boolean claimPlot(Plot plot);
public boolean claimPlot(Plot plot) {
return claimPlot(plot, null);
public abstract boolean unClaimPlot(Plot plot, Runnable whenDone);
}
public boolean unClaimPlot(Plot plot, Runnable whenDone) {
return unClaimPlot(plot, whenDone, null);
}
public abstract boolean clearPlot(Plot plot, Runnable whenDone,
@Nullable QueueCoordinator queue);
public abstract boolean claimPlot(Plot plot, @Nullable QueueCoordinator queue);
public abstract boolean unClaimPlot(Plot plot, Runnable whenDone,
@Nullable QueueCoordinator queue);
/**
* Retrieves the location of where a sign should be for a plot.
@ -81,31 +99,77 @@ public abstract class PlotManager {
*/
public abstract String[] getPlotComponents(PlotId plotId);
public abstract boolean setComponent(PlotId plotId, String component, Pattern blocks);
public boolean setComponent(PlotId plotId, String component, Pattern blocks) {
return setComponent(plotId, component, blocks, null);
}
public abstract boolean setComponent(PlotId plotId, String component, Pattern blocks,
@Nullable QueueCoordinator queue);
/*
* PLOT MERGING (return false if your generator does not support plot
* merging).
*/
public abstract boolean createRoadEast(Plot plot);
public boolean createRoadEast(Plot plot) {
return createRoadEast(plot, null);
}
public abstract boolean createRoadSouth(Plot plot);
public boolean createRoadSouth(Plot plot) {
return createRoadSouth(plot, null);
}
public abstract boolean createRoadSouthEast(Plot plot);
public boolean createRoadSouthEast(Plot plot) {
return createRoadSouthEast(plot, null);
}
public abstract boolean removeRoadEast(Plot plot);
public boolean removeRoadEast(Plot plot) {
return removeRoadEast(plot, null);
}
public abstract boolean removeRoadSouth(Plot plot);
public boolean removeRoadSouth(Plot plot) {
return removeRoadSouth(plot, null);
}
public abstract boolean removeRoadSouthEast(Plot plot);
public boolean removeRoadSouthEast(Plot plot) {
return removeRoadSouthEast(plot, null);
}
public abstract boolean startPlotMerge(List<PlotId> plotIds);
public boolean startPlotMerge(List<PlotId> plotIds) {
return startPlotMerge(plotIds, null);
}
public abstract boolean startPlotUnlink(List<PlotId> plotIds);
public boolean startPlotUnlink(List<PlotId> plotIds) {
return startPlotUnlink(plotIds, null);
}
public abstract boolean finishPlotMerge(List<PlotId> plotIds);
public boolean finishPlotMerge(List<PlotId> plotIds) {
return finishPlotMerge(plotIds, null);
}
public abstract boolean finishPlotUnlink(List<PlotId> plotIds);
public boolean finishPlotUnlink(List<PlotId> plotIds) {
return finishPlotUnlink(plotIds, null);
}
public abstract boolean createRoadEast(Plot plot, @Nullable QueueCoordinator queue);
public abstract boolean createRoadSouth(Plot plot, @Nullable QueueCoordinator queue);
public abstract boolean createRoadSouthEast(Plot plot, @Nullable QueueCoordinator queue);
public abstract boolean removeRoadEast(Plot plot, @Nullable QueueCoordinator queue);
public abstract boolean removeRoadSouth(Plot plot, @Nullable QueueCoordinator queue);
public abstract boolean removeRoadSouthEast(Plot plot, @Nullable QueueCoordinator queue);
public abstract boolean startPlotMerge(List<PlotId> plotIds, @Nullable QueueCoordinator queue);
public abstract boolean startPlotUnlink(List<PlotId> plotIds, @Nullable QueueCoordinator queue);
public abstract boolean finishPlotMerge(List<PlotId> plotIds, @Nullable QueueCoordinator queue);
public abstract boolean finishPlotUnlink(List<PlotId> plotIds,
@Nullable QueueCoordinator queue);
public void exportTemplate() throws IOException {
HashSet<FileBytes> files = new HashSet<>(Collections.singletonList(
@ -124,12 +188,16 @@ public abstract class PlotManager {
* @return true if the wall blocks were successfully set
*/
public boolean regenerateAllPlotWalls() {
return regenerateAllPlotWalls(null);
}
public boolean regenerateAllPlotWalls(@Nullable QueueCoordinator queue) {
boolean success = true;
for (Plot plot : plotArea.getPlots()) {
if (plot.hasOwner()) {
success &= claimPlot(plot);
success &= claimPlot(plot, queue);
} else {
success &= unClaimPlot(plot, null);
success &= unClaimPlot(plot, null, queue);
}
}
return success;

44
Core/src/main/java/com/plotsquared/core/plot/world/SinglePlotManager.java
View File

@ -31,11 +31,13 @@ import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea;
import com.plotsquared.core.plot.PlotId;
import com.plotsquared.core.plot.PlotManager;
import com.plotsquared.core.queue.QueueCoordinator;
import com.plotsquared.core.util.MainUtil;
import com.plotsquared.core.util.task.TaskManager;
import com.sk89q.worldedit.function.pattern.Pattern;
import javax.annotation.Nonnull;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.File;
import java.util.List;
@ -61,9 +63,11 @@ public class SinglePlotManager extends PlotManager {
return Location.at(plotId.toCommaSeparatedString(), 30000000, 0, 30000000);
}
@Override public boolean clearPlot(Plot plot, final Runnable whenDone) {
@Override
public boolean clearPlot(Plot plot, final Runnable whenDone, @Nullable QueueCoordinator queue) {
PlotSquared.platform().getSetupUtils().unload(plot.getWorldName(), false);
final File worldFolder = new File(PlotSquared.platform().getWorldContainer(), plot.getWorldName());
final File worldFolder =
new File(PlotSquared.platform().getWorldContainer(), plot.getWorldName());
TaskManager.getPlatformImplementation().taskAsync(() -> {
MainUtil.deleteDirectory(worldFolder);
if (whenDone != null) {
@ -73,12 +77,13 @@ public class SinglePlotManager extends PlotManager {
return true;
}
@Override public boolean claimPlot(Plot plot) {
@Override public boolean claimPlot(Plot plot, @Nullable QueueCoordinator queue) {
// TODO
return true;
}
@Override public boolean unClaimPlot(Plot plot, Runnable whenDone) {
@Override
public boolean unClaimPlot(Plot plot, Runnable whenDone, @Nullable QueueCoordinator queue) {
if (whenDone != null) {
whenDone.run();
}
@ -93,51 +98,56 @@ public class SinglePlotManager extends PlotManager {
return new String[0];
}
@Override public boolean setComponent(PlotId plotId, String component, Pattern blocks) {
@Override public boolean setComponent(PlotId plotId, String component, Pattern blocks,
@Nullable QueueCoordinator queue) {
return false;
}
@Override public boolean createRoadEast(Plot plot) {
@Override public boolean createRoadEast(Plot plot, @Nullable QueueCoordinator queue) {
return false;
}
@Override public boolean createRoadSouth(Plot plot) {
@Override public boolean createRoadSouth(Plot plot, @Nullable QueueCoordinator queue) {
return false;
}
@Override public boolean createRoadSouthEast(Plot plot) {
@Override public boolean createRoadSouthEast(Plot plot, @Nullable QueueCoordinator queue) {
return false;
}
@Override public boolean removeRoadEast(Plot plot) {
@Override public boolean removeRoadEast(Plot plot, @Nullable QueueCoordinator queue) {
return false;
}
@Override public boolean removeRoadSouth(Plot plot) {
@Override public boolean removeRoadSouth(Plot plot, @Nullable QueueCoordinator queue) {
return false;
}
@Override public boolean removeRoadSouthEast(Plot plot) {
@Override public boolean removeRoadSouthEast(Plot plot, @Nullable QueueCoordinator queue) {
return false;
}
@Override public boolean startPlotMerge(List<PlotId> plotIds) {
@Override
public boolean startPlotMerge(List<PlotId> plotIds, @Nullable QueueCoordinator queue) {
return false;
}
@Override public boolean startPlotUnlink(List<PlotId> plotIds) {
@Override
public boolean startPlotUnlink(List<PlotId> plotIds, @Nullable QueueCoordinator queue) {
return false;
}
@Override public boolean finishPlotMerge(List<PlotId> plotIds) {
@Override
public boolean finishPlotMerge(List<PlotId> plotIds, @Nullable QueueCoordinator queue) {
return false;
}
@Override public boolean finishPlotUnlink(List<PlotId> plotIds) {
@Override
public boolean finishPlotUnlink(List<PlotId> plotIds, @Nullable QueueCoordinator queue) {
return false;
}
@Override public boolean regenerateAllPlotWalls() {
@Override public boolean regenerateAllPlotWalls(@Nullable QueueCoordinator queue) {
return false;
}
}

5
Core/src/main/java/com/plotsquared/core/queue/GlobalBlockQueue.java
View File

@ -42,13 +42,10 @@ public class GlobalBlockQueue {
this.activeQueues = new ConcurrentLinkedDeque<>();
}
public QueueCoordinator getNewQueue(World world, boolean autoQueue) {
public QueueCoordinator getNewQueue(World world) {
QueueCoordinator queue = provider.getNewQueue(world);
// Auto-inject into the queue
PlotSquared.platform().getInjector().injectMembers(queue);
if (autoQueue) {
queue.enqueue();
}
return queue;
}

2
Core/src/main/java/com/plotsquared/core/util/ChunkManager.java
View File

@ -51,7 +51,7 @@ public abstract class ChunkManager {
public static void setChunkInPlotArea(RunnableVal<ScopedQueueCoordinator> force,
RunnableVal<ScopedQueueCoordinator> add, String world, BlockVector2 loc) {
QueueCoordinator queue =
PlotSquared.platform().getGlobalBlockQueue().getNewQueue(PlotSquared.platform().getWorldUtil().getWeWorld(world), false);
PlotSquared.platform().getGlobalBlockQueue().getNewQueue(PlotSquared.platform().getWorldUtil().getWeWorld(world));
if (PlotSquared.get().getPlotAreaManager().isAugmented(world) && PlotSquared.get()
.isNonStandardGeneration(world, loc)) {
int blockX = loc.getX() << 4;

16
Core/src/main/java/com/plotsquared/core/util/RegionManager.java
View File

@ -31,7 +31,6 @@ import com.plotsquared.core.location.Location;
import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea;
import com.plotsquared.core.plot.PlotManager;
import com.plotsquared.core.queue.ChunkCoordinatorBuilder;
import com.plotsquared.core.queue.QueueCoordinator;
import com.plotsquared.core.util.task.RunnableVal;
import com.plotsquared.core.util.task.TaskManager;
@ -44,6 +43,7 @@ import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.io.File;
import java.util.Collection;
import java.util.HashSet;
@ -169,7 +169,17 @@ public abstract class RegionManager {
public boolean setCuboids(final PlotArea area, final Set<CuboidRegion> regions,
final Pattern blocks, int minY, int maxY) {
QueueCoordinator queue = area.getQueue(false);
return setCuboids(area, regions, blocks, minY, maxY, null);
}
public boolean setCuboids(final PlotArea area, final Set<CuboidRegion> regions,
final Pattern blocks, int minY, int maxY, @Nullable QueueCoordinator queue) {
boolean enqueue = false;
if(queue == null) {
queue = area.getQueue();
enqueue = true;
}
for (CuboidRegion region : regions) {
Location pos1 = Location.at(area.getWorldName(), region.getMinimumPoint().getX(), minY,
region.getMinimumPoint().getZ());
@ -177,7 +187,7 @@ public abstract class RegionManager {
region.getMaximumPoint().getZ());
queue.setCuboid(pos1, pos2, blocks);
}
return queue.enqueue();
return !enqueue || queue.enqueue();
}
/**

2
Core/src/main/java/com/plotsquared/core/util/SchematicHandler.java
View File

@ -194,7 +194,7 @@ public abstract class SchematicHandler {
return;
}
try {
final QueueCoordinator queue = plot.getArea().getQueue(false);
final QueueCoordinator queue = plot.getArea().getQueue();
BlockVector3 dimension = schematic.getClipboard().getDimensions();
final int WIDTH = dimension.getX();
final int LENGTH = dimension.getZ();