Address deprecations in queue/generation code

Bukkit/src/main/java/com/plotsquared/bukkit/generator/BlockStatePopulator.java

@@ -31,7 +31,7 @@ import com.plotsquared.core.location.ChunkWrapper;
 import com.plotsquared.core.plot.PlotArea;
 import com.plotsquared.core.plot.world.PlotAreaManager;
 import com.plotsquared.core.queue.QueueCoordinator;
-import com.plotsquared.core.queue.ScopedQueueCoordinator;
+import com.plotsquared.core.queue.ZeroedDelegateScopedQueueCoordinator;
 import com.sk89q.worldedit.bukkit.BukkitWorld;
 import org.bukkit.Chunk;
 import org.bukkit.World;
@@ -65,7 +65,7 @@ final class BlockStatePopulator extends BlockPopulator {
             return;
         }
         final ChunkWrapper wrap = new ChunkWrapper(area.getWorldName(), source.getX(), source.getZ());
-        final ScopedQueueCoordinator chunk = this.queue.getForChunk(wrap.x, wrap.z,
+        final ZeroedDelegateScopedQueueCoordinator chunk = this.queue.getForChunk(wrap.x, wrap.z,
                 com.plotsquared.bukkit.util.BukkitWorld.getMinWorldHeight(world),
                 com.plotsquared.bukkit.util.BukkitWorld.getMaxWorldHeight(world) - 1
         );

Bukkit/src/main/java/com/plotsquared/bukkit/generator/BukkitPlotGenerator.java

@@ -35,7 +35,7 @@ import com.plotsquared.core.generator.SingleWorldGenerator;
 import com.plotsquared.core.location.ChunkWrapper;
 import com.plotsquared.core.plot.PlotArea;
 import com.plotsquared.core.plot.world.PlotAreaManager;
-import com.plotsquared.core.queue.ScopedQueueCoordinator;
+import com.plotsquared.core.queue.ZeroedDelegateScopedQueueCoordinator;
 import com.plotsquared.core.util.ChunkManager;
 import com.sk89q.worldedit.math.BlockVector2;
 import org.bukkit.World;
@@ -198,7 +198,7 @@ public class BukkitPlotGenerator extends ChunkGenerator
         return result.getChunkData();
     }
 
-    private void generate(BlockVector2 loc, World world, ScopedQueueCoordinator result) {
+    private void generate(BlockVector2 loc, World world, ZeroedDelegateScopedQueueCoordinator result) {
         // Load if improperly loaded
         if (!this.loaded) {
             String name = world.getName();

Bukkit/src/main/java/com/plotsquared/bukkit/generator/DelegatePlotGenerator.java

@@ -31,7 +31,7 @@ import com.plotsquared.core.generator.IndependentPlotGenerator;
 import com.plotsquared.core.location.Location;
 import com.plotsquared.core.plot.PlotArea;
 import com.plotsquared.core.plot.PlotId;
-import com.plotsquared.core.queue.ScopedQueueCoordinator;
+import com.plotsquared.core.queue.ZeroedDelegateScopedQueueCoordinator;
 import com.plotsquared.core.util.MathMan;
 import com.sk89q.worldedit.bukkit.BukkitAdapter;
 import org.bukkit.World;
@@ -67,7 +67,7 @@ final class DelegatePlotGenerator extends IndependentPlotGenerator {
     }
 
     @Override
-    public void generateChunk(final ScopedQueueCoordinator result, PlotArea settings) {
+    public void generateChunk(final ZeroedDelegateScopedQueueCoordinator result, PlotArea settings) {
         World world = BukkitUtil.getWorld(this.world);
         Location min = result.getMin();
         int chunkX = min.getX() >> 4;

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

@@ -30,7 +30,7 @@ import com.plotsquared.bukkit.util.BukkitBlockUtil;
 import com.plotsquared.bukkit.util.BukkitUtil;
 import com.plotsquared.core.location.ChunkWrapper;
 import com.plotsquared.core.location.Location;
-import com.plotsquared.core.queue.ScopedQueueCoordinator;
+import com.plotsquared.core.queue.ZeroedDelegateScopedQueueCoordinator;
 import com.plotsquared.core.util.AnnotationHelper;
 import com.plotsquared.core.util.ChunkUtil;
 import com.plotsquared.core.util.PatternUtil;
@@ -52,7 +52,7 @@ import org.checkerframework.checker.nullness.qual.Nullable;
 import java.util.Arrays;
 
 @AnnotationHelper.ApiDescription(info = "Internal use only. Subject to changes at any time.")
-public class GenChunk extends ScopedQueueCoordinator {
+public class GenChunk extends ZeroedDelegateScopedQueueCoordinator {
 
     public final Biome[] biomes;
     public BlockState[][] result;

Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitRegionManager.java

@@ -37,7 +37,7 @@ 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.queue.ScopedQueueCoordinator;
+import com.plotsquared.core.queue.ZeroedDelegateScopedQueueCoordinator;
 import com.plotsquared.core.util.ChunkManager;
 import com.plotsquared.core.util.RegionManager;
 import com.plotsquared.core.util.WorldUtil;
@@ -264,9 +264,9 @@ public class BukkitRegionManager extends RegionManager {
             map.saveEntitiesOut(Bukkit.getWorld(world.getName()).getChunkAt(x, z), currentPlotClear);
             AugmentedUtils.bypass(
                     ignoreAugment,
-                    () -> ChunkManager.setChunkInPlotArea(null, new RunnableVal<ScopedQueueCoordinator>() {
+                    () -> ChunkManager.setChunkInPlotArea(null, new RunnableVal<ZeroedDelegateScopedQueueCoordinator>() {
                         @Override
-                        public void run(ScopedQueueCoordinator value) {
+                        public void run(ZeroedDelegateScopedQueueCoordinator value) {
                             Location min = value.getMin();
                             int bx = min.getX();
                             int bz = min.getZ();

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

@@ -430,8 +430,7 @@ public class Area extends SubCommand {
                                         player.sendMessage(TranslatableCaption.of("setup.setup_finished"));
                                         if (area.getTerrain() != PlotAreaTerrainType.ALL) {
                                             QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(world));
-                                            queue.setChunkConsumer(chunk -> AugmentedUtils.generate(
+                                            queue.setChunkConsumer(chunk -> AugmentedUtils.generateChunk(
-                                                    null,
                                                     world,
                                                     chunk.getX(),
                                                     chunk.getZ(),
@@ -803,8 +802,7 @@ public class Area extends SubCommand {
                     return false;
                 }
                 QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(area.getWorldName()));
-                queue.setChunkConsumer(chunk -> AugmentedUtils.generate(
+                queue.setChunkConsumer(chunk -> AugmentedUtils.generateChunk(
-                        null,
                         area.getWorldName(),
                         chunk.getX(),
                         chunk.getZ(),

Core/src/main/java/com/plotsquared/core/generator/AugmentedUtils.java

@@ -34,7 +34,7 @@ import com.plotsquared.core.plot.PlotManager;
 import com.plotsquared.core.queue.AreaBoundDelegateQueueCoordinator;
 import com.plotsquared.core.queue.LocationOffsetDelegateQueueCoordinator;
 import com.plotsquared.core.queue.QueueCoordinator;
-import com.plotsquared.core.queue.ScopedQueueCoordinator;
+import com.plotsquared.core.queue.ZeroedDelegateScopedQueueCoordinator;
 import com.plotsquared.core.util.RegionUtil;
 import com.sk89q.worldedit.regions.CuboidRegion;
 import com.sk89q.worldedit.world.block.BlockState;
@@ -168,8 +168,8 @@ public class AugmentedUtils {
 
             // This queue should not be enqueued as it is simply used to restrict block setting, and then delegate to the
             // actual queue
-            ScopedQueueCoordinator scoped =
+            ZeroedDelegateScopedQueueCoordinator scoped =
-                    new ScopedQueueCoordinator(
+                    new ZeroedDelegateScopedQueueCoordinator(
                             secondaryMask,
                             Location.at(world, blockX, area.getMinGenHeight(), blockZ),
                             Location.at(world, blockX + 15, area.getMaxGenHeight(), blockZ + 15)
@@ -183,19 +183,4 @@ public class AugmentedUtils {
         return generationResult;
     }
 
-    /**
-     * @deprecated Use {@link AugmentedUtils#generateChunk(String, int, int, QueueCoordinator)} as chunkObject is not required
-     * in the above method
-     */
-    @Deprecated(forRemoval = true, since = "6.8.0")
-    public static boolean generate(
-            @Nullable Object chunkObject,
-            final @NonNull String world,
-            final int chunkX,
-            final int chunkZ,
-            QueueCoordinator queue
-    ) {
-        return generateChunk(world, chunkX, chunkZ, queue);
-    }
-
 }

Core/src/main/java/com/plotsquared/core/generator/HybridGen.java

@@ -33,7 +33,7 @@ import com.plotsquared.core.inject.factory.HybridPlotWorldFactory;
 import com.plotsquared.core.location.Location;
 import com.plotsquared.core.plot.PlotArea;
 import com.plotsquared.core.plot.PlotId;
-import com.plotsquared.core.queue.ScopedQueueCoordinator;
+import com.plotsquared.core.queue.ZeroedDelegateScopedQueueCoordinator;
 import com.plotsquared.core.util.MathMan;
 import com.sk89q.worldedit.world.biome.BiomeType;
 import com.sk89q.worldedit.world.block.BaseBlock;
@@ -55,12 +55,16 @@ public class HybridGen extends IndependentPlotGenerator {
     }
 
     private void placeSchem(
-            HybridPlotWorld world, ScopedQueueCoordinator result, short relativeX,
+            HybridPlotWorld world,
-            short relativeZ, int x, int z, boolean isRoad
+            ZeroedDelegateScopedQueueCoordinator result,
+            short relativeX,
+            short relativeZ,
+            int x,
+            int z,
+            boolean isRoad
     ) {
         int minY; // Math.min(world.PLOT_HEIGHT, world.ROAD_HEIGHT);
-        if ((isRoad && Settings.Schematics.PASTE_ROAD_ON_TOP) || (!isRoad
+        if ((isRoad && Settings.Schematics.PASTE_ROAD_ON_TOP) || (!isRoad && Settings.Schematics.PASTE_ON_TOP)) {
-                && Settings.Schematics.PASTE_ON_TOP)) {
             minY = world.SCHEM_Y;
         } else {
             minY = world.getMinBuildHeight();
@@ -80,7 +84,7 @@ public class HybridGen extends IndependentPlotGenerator {
     }
 
     @Override
-    public void generateChunk(@NonNull ScopedQueueCoordinator result, @NonNull PlotArea settings) {
+    public void generateChunk(@NonNull ZeroedDelegateScopedQueueCoordinator result, @NonNull PlotArea settings) {
         Preconditions.checkNotNull(result, "result cannot be null");
         Preconditions.checkNotNull(settings, "settings cannot be null");
 

Core/src/main/java/com/plotsquared/core/generator/HybridUtils.java

@@ -594,20 +594,6 @@ public class HybridUtils {
         return ey;
     }
 
-    /**
-     * Regenerate the road in a chunk in a plot area.
-     *
-     * @param area   Plot area to regenerate road for
-     * @param chunk  Chunk location to regenerate
-     * @param extend How far to extend setting air above the road
-     * @return if successful
-     * @deprecated use {@link HybridUtils#regenerateRoad(PlotArea, BlockVector2, int, QueueCoordinator)}
-     */
-    @Deprecated(forRemoval = true, since = "6.6.0")
-    public boolean regenerateRoad(final PlotArea area, final BlockVector2 chunk, int extend) {
-        return regenerateRoad(area, chunk, extend, null);
-    }
-
     /**
      * Regenerate the road in a chunk in a plot area.
      *

Core/src/main/java/com/plotsquared/core/generator/IndependentPlotGenerator.java

@@ -28,7 +28,7 @@ package com.plotsquared.core.generator;
 import com.plotsquared.core.PlotSquared;
 import com.plotsquared.core.plot.PlotArea;
 import com.plotsquared.core.plot.PlotId;
-import com.plotsquared.core.queue.ScopedQueueCoordinator;
+import com.plotsquared.core.queue.ZeroedDelegateScopedQueueCoordinator;
 import com.plotsquared.core.setup.PlotAreaBuilder;
 import org.checkerframework.checker.nullness.qual.NonNull;
 
@@ -54,9 +54,9 @@ public abstract class IndependentPlotGenerator {
      * @param result   queue
      * @param settings PlotArea (settings)
      */
-    public abstract void generateChunk(ScopedQueueCoordinator result, PlotArea settings);
+    public abstract void generateChunk(ZeroedDelegateScopedQueueCoordinator result, PlotArea settings);
 
-    public boolean populateChunk(ScopedQueueCoordinator result, PlotArea setting) {
+    public boolean populateChunk(ZeroedDelegateScopedQueueCoordinator result, PlotArea setting) {
         return false;
     }
 

Core/src/main/java/com/plotsquared/core/generator/SingleWorldGenerator.java

@@ -32,7 +32,7 @@ import com.plotsquared.core.plot.PlotId;
 import com.plotsquared.core.plot.world.PlotAreaManager;
 import com.plotsquared.core.plot.world.SinglePlotArea;
 import com.plotsquared.core.plot.world.SinglePlotAreaManager;
-import com.plotsquared.core.queue.ScopedQueueCoordinator;
+import com.plotsquared.core.queue.ZeroedDelegateScopedQueueCoordinator;
 import com.sk89q.worldedit.world.biome.BiomeTypes;
 import com.sk89q.worldedit.world.block.BlockTypes;
 import org.checkerframework.checker.nullness.qual.NonNull;
@@ -59,7 +59,7 @@ public class SingleWorldGenerator extends IndependentPlotGenerator {
     }
 
     @Override
-    public void generateChunk(ScopedQueueCoordinator result, PlotArea settings) {
+    public void generateChunk(ZeroedDelegateScopedQueueCoordinator result, PlotArea settings) {
         SinglePlotArea area = (SinglePlotArea) settings;
         if (area.VOID) {
             Location min = result.getMin();

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

@@ -45,7 +45,7 @@ import org.checkerframework.checker.nullness.qual.Nullable;
  * {@link BlockArrayCacheScopedQueueCoordinator#setOffsetZ(int)}
  */
 @AnnotationHelper.ApiDescription(info = "Internal use only. Subject to change at any time and created for specific use cases.")
-public class BlockArrayCacheScopedQueueCoordinator extends ScopedQueueCoordinator {
+public class BlockArrayCacheScopedQueueCoordinator extends ZeroedDelegateScopedQueueCoordinator {
 
     private final BlockState[][][] blockStates;
     private final int height;

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

@@ -1,170 +0,0 @@
-/*
- *       _____  _       _    _____                                _
- *      |  __ \| |     | |  / ____|                              | |
- *      | |__) | | ___ | |_| (___   __ _ _   _  __ _ _ __ ___  __| |
- *      |  ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
- *      | |    | | (_) | |_ ____) | (_| | |_| | (_| | | |  __/ (_| |
- *      |_|    |_|\___/ \__|_____/ \__, |\__,_|\__,_|_|  \___|\__,_|
- *                                    | |
- *                                    |_|
- *            PlotSquared plot management system for Minecraft
- *               Copyright (C) 2014 - 2022 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 <https://www.gnu.org/licenses/>.
- */
-package com.plotsquared.core.queue;
-
-import com.plotsquared.core.location.Location;
-import com.sk89q.worldedit.function.pattern.Pattern;
-import com.sk89q.worldedit.math.BlockVector3;
-import com.sk89q.worldedit.world.World;
-import com.sk89q.worldedit.world.biome.BiomeType;
-import com.sk89q.worldedit.world.block.BaseBlock;
-import com.sk89q.worldedit.world.block.BlockState;
-import org.checkerframework.checker.nullness.qual.NonNull;
-import org.checkerframework.checker.nullness.qual.Nullable;
-
-/**
- * Queue that is limited to a single chunk. It does not allow a delegate queue and should be treated as a cache for changes to
- * be set to. Does not support tile entities or entities.
- *
- * @deprecated This class is poorly designed and will no longer be used in P2
- */
-@Deprecated(forRemoval = true, since = "6.8.0")
-public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
-
-    public final BiomeType[][][] biomeResult;
-    public final BlockState[][][] result;
-    private final int width;
-    private final int length;
-    private final BlockVector3 bot;
-    private final BlockVector3 top;
-    private final World weWorld;
-
-    public ChunkQueueCoordinator(
-            final @NonNull World weWorld,
-            @NonNull BlockVector3 bot,
-            @NonNull BlockVector3 top,
-            boolean biomes
-    ) {
-        super(null, Location.at("", 0, weWorld.getMinY(), 0), Location.at("", 15, weWorld.getMaxY(), 15));
-        this.weWorld = weWorld;
-        this.width = top.getX() - bot.getX() + 1;
-        this.length = top.getZ() - bot.getZ() + 1;
-        this.result = new BlockState[weWorld.getMaxY() - weWorld.getMinY() + 1][width][length];
-        this.biomeResult = biomes ? new BiomeType[weWorld.getMaxY() - weWorld.getMinY() + 1][width][length] : null;
-        this.bot = bot;
-        this.top = top;
-    }
-
-    public @NonNull BlockState[][][] getBlocks() {
-        return result;
-    }
-
-    @Override
-    public boolean setBiome(int x, int z, @NonNull BiomeType biomeType) {
-        if (this.biomeResult != null) {
-            for (int y = weWorld.getMinY(); y <= weWorld.getMaxY(); y++) {
-                this.storeCacheBiome(x, y, z, biomeType);
-            }
-            return true;
-        }
-        return false;
-    }
-
-    @Override
-    public boolean setBiome(int x, int y, int z, @NonNull BiomeType biomeType) {
-        if (this.biomeResult != null) {
-            this.storeCacheBiome(x, y, z, biomeType);
-            return true;
-        }
-        return false;
-    }
-
-    @Override
-    public boolean setBlock(int x, int y, int z, @NonNull BlockState id) {
-        this.storeCache(x, y, z, id);
-        return true;
-    }
-
-    @Override
-    public boolean setBlock(int x, int y, int z, @NonNull Pattern pattern) {
-        this.storeCache(x, y, z, pattern.applyBlock(BlockVector3.at(x, y, z)).toImmutableState());
-        return true;
-    }
-
-    private void storeCache(final int x, final int y, final int z, final @NonNull BlockState id) {
-        int yIndex = getYIndex(y);
-        BlockState[][] resultY = result[yIndex];
-        if (resultY == null) {
-            result[yIndex] = resultY = new BlockState[length][];
-        }
-        BlockState[] resultYZ = resultY[z];
-        if (resultYZ == null) {
-            resultY[z] = resultYZ = new BlockState[width];
-        }
-        resultYZ[x] = id;
-    }
-
-    private void storeCacheBiome(final int x, final int y, final int z, final @NonNull BiomeType id) {
-        int yIndex = getYIndex(y);
-        BiomeType[][] resultY = biomeResult[yIndex];
-        if (resultY == null) {
-            biomeResult[yIndex] = resultY = new BiomeType[length][];
-        }
-        BiomeType[] resultYZ = resultY[z];
-        if (resultYZ == null) {
-            resultY[z] = resultYZ = new BiomeType[width];
-        }
-        resultYZ[x] = id;
-    }
-
-    @Override
-    public boolean setBlock(int x, int y, int z, final @NonNull BaseBlock id) {
-        this.storeCache(x, y, z, id.toImmutableState());
-        return true;
-    }
-
-    @Override
-    public @Nullable BlockState getBlock(int x, int y, int z) {
-        BlockState[][] blocksY = result[getYIndex(y)];
-        if (blocksY != null) {
-            BlockState[] blocksYZ = blocksY[z];
-            if (blocksYZ != null) {
-                return blocksYZ[x];
-            }
-        }
-        return null;
-    }
-
-    @Override
-    public @Nullable World getWorld() {
-        return weWorld;
-    }
-
-    @Override
-    public @NonNull Location getMax() {
-        return Location.at(getWorld().getName(), top.getX(), top.getY(), top.getZ());
-    }
-
-    @Override
-    public @NonNull Location getMin() {
-        return Location.at(getWorld().getName(), bot.getX(), bot.getY(), bot.getZ());
-    }
-
-    private int getYIndex(int y) {
-        return y - weWorld.getMinY();
-    }
-
-}

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

@@ -71,15 +71,15 @@ public abstract class QueueCoordinator {
     }
 
     /**
-     * Get a {@link ScopedQueueCoordinator} limited to the chunk at the specific chunk Coordinates
+     * Get a {@link ZeroedDelegateScopedQueueCoordinator} limited to the chunk at the specific chunk Coordinates
      *
      * @param x chunk x coordinate
      * @param z chunk z coordinate
-     * @return a new {@link ScopedQueueCoordinator}
+     * @return a new {@link ZeroedDelegateScopedQueueCoordinator}
-     * @deprecated Use {@link ScopedQueueCoordinator#getForChunk(int, int, int, int)}
+     * @deprecated Use {@link ZeroedDelegateScopedQueueCoordinator#getForChunk(int, int, int, int)}
      */
     @Deprecated(forRemoval = true, since = "6.6.0")
-    public ScopedQueueCoordinator getForChunk(int x, int z) {
+    public ZeroedDelegateScopedQueueCoordinator getForChunk(int x, int z) {
         if (getWorld() == null) {
             return getForChunk(x, z, PlotSquared.platform().versionMinHeight(), PlotSquared.platform().versionMaxHeight());
         }
@@ -87,17 +87,17 @@ public abstract class QueueCoordinator {
     }
 
     /**
-     * Get a {@link ScopedQueueCoordinator} limited to the chunk at the specific chunk Coordinates
+     * Get a {@link ZeroedDelegateScopedQueueCoordinator} limited to the chunk at the specific chunk Coordinates
      *
      * @param x chunk x coordinate
      * @param z chunk z coordinate
-     * @return a new {@link ScopedQueueCoordinator}
+     * @return a new {@link ZeroedDelegateScopedQueueCoordinator}
      * @since 6.6.0
      */
-    public ScopedQueueCoordinator getForChunk(int x, int z, int minY, int maxY) {
+    public ZeroedDelegateScopedQueueCoordinator getForChunk(int x, int z, int minY, int maxY) {
         int bx = x << 4;
         int bz = z << 4;
-        return new ScopedQueueCoordinator(this, Location.at(getWorld().getName(), bx, minY, bz),
+        return new ZeroedDelegateScopedQueueCoordinator(this, Location.at(getWorld().getName(), bx, minY, bz),
                 Location.at(getWorld().getName(), bx + 15, maxY, bz + 15)
         );
     }

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

@@ -35,13 +35,11 @@ import org.checkerframework.checker.nullness.qual.NonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 /**
- * Queue that only sets blocks with a designated X-Z area, will accept any Y values. Requires all blocks be set normalized in
+ * Queue that only sets blocks with a designated X-Z area, will accept any Y values. Requires all blocks be set normalized to
- * the x and z directions, i.e. starting from 0,0. An offset of the minimum point of the region will then be applied to x and z.
+ * zero in the x and z directions, i.e. starting from 0,0. An offset of the minimum point of the region will then be applied to
- *
+ * x and z.
- * @deprecated This should be renamed to NormalizedScopedQueueCoordinator or something.
  */
-@Deprecated(forRemoval = true, since = "6.8.0")
+public class ZeroedDelegateScopedQueueCoordinator extends DelegateQueueCoordinator {
-public class ScopedQueueCoordinator extends DelegateQueueCoordinator {
 
     private final Location min;
     private final Location max;
@@ -57,7 +55,7 @@ public class ScopedQueueCoordinator extends DelegateQueueCoordinator {
     /**
      * Create a new ScopedQueueCoordinator instance that delegates to a given QueueCoordinator. Locations are inclusive.
      */
-    public ScopedQueueCoordinator(@Nullable QueueCoordinator parent, @NonNull Location min, @NonNull Location max) {
+    public ZeroedDelegateScopedQueueCoordinator(@Nullable QueueCoordinator parent, @NonNull Location min, @NonNull Location max) {
         super(parent);
         this.min = min;
         this.max = max;

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

@@ -28,7 +28,7 @@ package com.plotsquared.core.util;
 import com.plotsquared.core.PlotSquared;
 import com.plotsquared.core.location.Location;
 import com.plotsquared.core.queue.QueueCoordinator;
-import com.plotsquared.core.queue.ScopedQueueCoordinator;
+import com.plotsquared.core.queue.ZeroedDelegateScopedQueueCoordinator;
 import com.plotsquared.core.util.task.RunnableVal;
 import com.sk89q.worldedit.math.BlockVector2;
 import com.sk89q.worldedit.world.World;
@@ -39,12 +39,12 @@ import java.util.concurrent.ConcurrentHashMap;
 
 public abstract class ChunkManager {
 
-    private static final Map<BlockVector2, RunnableVal<ScopedQueueCoordinator>> forceChunks = new ConcurrentHashMap<>();
+    private static final Map<BlockVector2, RunnableVal<ZeroedDelegateScopedQueueCoordinator>> forceChunks = new ConcurrentHashMap<>();
-    private static final Map<BlockVector2, RunnableVal<ScopedQueueCoordinator>> addChunks = new ConcurrentHashMap<>();
+    private static final Map<BlockVector2, RunnableVal<ZeroedDelegateScopedQueueCoordinator>> addChunks = new ConcurrentHashMap<>();
 
     public static void setChunkInPlotArea(
-            RunnableVal<ScopedQueueCoordinator> force,
+            RunnableVal<ZeroedDelegateScopedQueueCoordinator> force,
-            RunnableVal<ScopedQueueCoordinator> add,
+            RunnableVal<ZeroedDelegateScopedQueueCoordinator> add,
             String world,
             BlockVector2 loc
     ) {
@@ -53,8 +53,8 @@ public abstract class ChunkManager {
         if (PlotSquared.get().getPlotAreaManager().isAugmented(world) && PlotSquared.get().isNonStandardGeneration(world, loc)) {
             int blockX = loc.getX() << 4;
             int blockZ = loc.getZ() << 4;
-            ScopedQueueCoordinator scoped =
+            ZeroedDelegateScopedQueueCoordinator scoped =
-                    new ScopedQueueCoordinator(
+                    new ZeroedDelegateScopedQueueCoordinator(
                             queue,
                             Location.at(world, blockX, weWorld.getMinY(), blockZ),
                             Location.at(world, blockX + 15, weWorld.getMaxY(), blockZ + 15)
@@ -79,8 +79,8 @@ public abstract class ChunkManager {
         }
     }
 
-    public static boolean preProcessChunk(BlockVector2 loc, ScopedQueueCoordinator queue) {
+    public static boolean preProcessChunk(BlockVector2 loc, ZeroedDelegateScopedQueueCoordinator queue) {
-        final RunnableVal<ScopedQueueCoordinator> forceChunk = forceChunks.get(loc);
+        final RunnableVal<ZeroedDelegateScopedQueueCoordinator> forceChunk = forceChunks.get(loc);
         if (forceChunk != null) {
             forceChunk.run(queue);
             forceChunks.remove(loc);
@@ -89,8 +89,8 @@ public abstract class ChunkManager {
         return false;
     }
 
-    public static boolean postProcessChunk(BlockVector2 loc, ScopedQueueCoordinator queue) {
+    public static boolean postProcessChunk(BlockVector2 loc, ZeroedDelegateScopedQueueCoordinator queue) {
-        final RunnableVal<ScopedQueueCoordinator> addChunk = forceChunks.get(loc);
+        final RunnableVal<ZeroedDelegateScopedQueueCoordinator> addChunk = forceChunks.get(loc);
         if (addChunk != null) {
             addChunk.run(queue);
             addChunks.remove(loc);