diff --git a/bukkit0/build.gradle b/bukkit0/build.gradle index 79befbb2..86b47256 100644 --- a/bukkit0/build.gradle +++ b/bukkit0/build.gradle @@ -13,4 +13,5 @@ dependencies { compile 'com.worldcretornica:plotme_core:0.16.3' compile 'junit:junit:4.11' compile 'com.sk89q.worldedit:worldedit-bukkit:6.1.1-SNAPSHOT' + compile 'com.thevoxelbox.voxelsniper:voxelsniper:5.171.0' } \ No newline at end of file diff --git a/bukkit0/src/main/java/com/boydti/fawe/bukkit/ABukkitMain.java b/bukkit0/src/main/java/com/boydti/fawe/bukkit/ABukkitMain.java index e708b0e2..5c42e3e6 100644 --- a/bukkit0/src/main/java/com/boydti/fawe/bukkit/ABukkitMain.java +++ b/bukkit0/src/main/java/com/boydti/fawe/bukkit/ABukkitMain.java @@ -1,8 +1,11 @@ package com.boydti.fawe.bukkit; +import com.boydti.fawe.Fawe; import com.boydti.fawe.object.EditSessionWrapper; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.sk89q.worldedit.EditSession; +import com.thevoxelbox.voxelsniper.SnipeData; +import com.thevoxelbox.voxelsniper.Sniper; import org.bukkit.plugin.java.JavaPlugin; public abstract class ABukkitMain extends JavaPlugin { @@ -10,6 +13,12 @@ public abstract class ABukkitMain extends JavaPlugin { @Override public void onEnable() { new FaweBukkit(this); + + try { + SnipeData.inject(); + Sniper.inject(); + Fawe.debug("Injected VoxelSniper classes"); + } catch (Throwable ignore) {} } public abstract FaweQueue getQueue(String world); diff --git a/bukkit0/src/main/java/com/boydti/fawe/bukkit/FaweBukkit.java b/bukkit0/src/main/java/com/boydti/fawe/bukkit/FaweBukkit.java index 96ec50d2..dd1ab796 100644 --- a/bukkit0/src/main/java/com/boydti/fawe/bukkit/FaweBukkit.java +++ b/bukkit0/src/main/java/com/boydti/fawe/bukkit/FaweBukkit.java @@ -19,7 +19,7 @@ import com.boydti.fawe.object.EditSessionWrapper; import com.boydti.fawe.object.FaweCommand; import com.boydti.fawe.object.FawePlayer; import com.boydti.fawe.regions.FaweMaskManager; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.ReflectionUtils; import com.boydti.fawe.util.StringMan; diff --git a/bukkit0/src/main/java/com/boydti/fawe/bukkit/logging/BlocksHubHook.java b/bukkit0/src/main/java/com/boydti/fawe/bukkit/logging/BlocksHubHook.java index f0819945..75aa0462 100644 --- a/bukkit0/src/main/java/com/boydti/fawe/bukkit/logging/BlocksHubHook.java +++ b/bukkit0/src/main/java/com/boydti/fawe/bukkit/logging/BlocksHubHook.java @@ -3,7 +3,7 @@ package com.boydti.fawe.bukkit.logging; import com.boydti.fawe.object.FaweLimit; import com.boydti.fawe.object.FawePlayer; import com.boydti.fawe.object.changeset.FaweChangeSet; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.sk89q.worldedit.EditSession; import com.sk89q.worldedit.extent.Extent; import org.PrimeSoft.blocksHub.BlocksHub; diff --git a/bukkit0/src/main/java/com/boydti/fawe/bukkit/v0/BukkitEditSessionWrapper_0.java b/bukkit0/src/main/java/com/boydti/fawe/bukkit/v0/BukkitEditSessionWrapper_0.java index f4c85b15..83a9a5a7 100644 --- a/bukkit0/src/main/java/com/boydti/fawe/bukkit/v0/BukkitEditSessionWrapper_0.java +++ b/bukkit0/src/main/java/com/boydti/fawe/bukkit/v0/BukkitEditSessionWrapper_0.java @@ -5,7 +5,7 @@ import com.boydti.fawe.object.EditSessionWrapper; import com.boydti.fawe.object.FaweLimit; import com.boydti.fawe.object.FawePlayer; import com.boydti.fawe.object.changeset.FaweChangeSet; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.sk89q.worldedit.EditSession; import com.sk89q.worldedit.extent.Extent; diff --git a/bukkit0/src/main/java/com/boydti/fawe/bukkit/wrapper/AsyncBlock.java b/bukkit0/src/main/java/com/boydti/fawe/bukkit/wrapper/AsyncBlock.java new file mode 100644 index 00000000..6891514e --- /dev/null +++ b/bukkit0/src/main/java/com/boydti/fawe/bukkit/wrapper/AsyncBlock.java @@ -0,0 +1,277 @@ +package com.boydti.fawe.bukkit.wrapper; + +import com.boydti.fawe.object.FaweQueue; +import java.util.Collection; +import java.util.List; +import org.bukkit.Chunk; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.World; +import org.bukkit.block.Biome; +import org.bukkit.block.Block; +import org.bukkit.block.BlockFace; +import org.bukkit.block.BlockState; +import org.bukkit.block.PistonMoveReaction; +import org.bukkit.inventory.ItemStack; +import org.bukkit.metadata.MetadataValue; +import org.bukkit.plugin.Plugin; + +public class AsyncBlock implements Block { + + public final int z; + public final int y; + public final int x; + public final FaweQueue queue; + public final World world; + + public AsyncBlock(World world, FaweQueue queue, int x, int y, int z) { + this.world = world; + this.queue = queue; + this.x = x; + this.y = y; + this.z = z; + } + + @Override + public byte getData() { + return (byte) (queue.getCombinedId4Data(x, y, z) & 0xF); + } + + @Override + public Block getRelative(int modX, int modY, int modZ) { + return new AsyncBlock(world, queue, x + modX, y + modY, z + modZ); + } + + @Override + public Block getRelative(BlockFace face) { + return this.getRelative(face.getModX(), face.getModY(), face.getModZ()); + } + + @Override + public Block getRelative(BlockFace face, int distance) { + return this.getRelative(face.getModX() * distance, face.getModY() * distance, face.getModZ() * distance); + } + + @Override + public Material getType() { + return Material.getMaterial(queue.getCombinedId4Data(x, y, z) >> 4); + } + + @Override + public int getTypeId() { + return queue.getCombinedId4Data(x, y, z) >> 4; + } + + @Override + public byte getLightLevel() { + throw new UnsupportedOperationException("Not implemented yet"); + } + + @Override + public byte getLightFromSky() { + throw new UnsupportedOperationException("Not implemented yet"); + } + + @Override + public byte getLightFromBlocks() { + throw new UnsupportedOperationException("Not implemented yet"); + } + + @Override + public World getWorld() { + return world; + } + + @Override + public int getX() { + return x; + } + + @Override + public int getY() { + return y; + } + + @Override + public int getZ() { + return z; + } + + @Override + public Location getLocation() { + return new Location(world, x, y, z); + } + + @Override + public Location getLocation(Location loc) { + if(loc != null) { + loc.setWorld(this.getWorld()); + loc.setX((double)this.x); + loc.setY((double)this.y); + loc.setZ((double)this.z); + } + return loc; + } + + @Override + public Chunk getChunk() { + return world.getChunkAt(x >> 4, z >> 4); + } + + @Override + public void setData(byte data) { + setTypeIdAndData(getTypeId(), data, true); + } + + @Override + public void setData(byte data, boolean applyPhysics) { + setTypeIdAndData(getTypeId(), data, applyPhysics); + } + + @Override + public void setType(Material type) { + setTypeIdAndData(type.getId(), (byte) 0, true); + } + + @Override + public void setType(Material type, boolean applyPhysics) { + setTypeIdAndData(type.getId(), (byte) 0, applyPhysics); + } + + @Override + public boolean setTypeId(int type) { + return setTypeIdAndData(type, (byte) 0, true); + } + + @Override + public boolean setTypeId(int type, boolean applyPhysics) { + return setTypeIdAndData(type, (byte) 0, applyPhysics); + } + + @Override + public boolean setTypeIdAndData(int type, byte data, boolean applyPhysics) { + return queue.setBlock(x, y, z, (short) type, data); + } + + @Override + public BlockFace getFace(Block block) { + BlockFace[] directions = BlockFace.values(); + for(int i = 0; i < directions.length; ++i) { + BlockFace face = directions[i]; + if(this.getX() + face.getModX() == block.getX() && this.getY() + face.getModY() == block.getY() && this.getZ() + face.getModZ() == block.getZ()) { + return face; + } + } + return null; + } + + @Override + public BlockState getState() { + return new AsyncBlockState(this); + } + + @Override + public Biome getBiome() { + throw new UnsupportedOperationException("NOT IMPLEMENTED"); + } + + @Override + public void setBiome(Biome bio) { + + } + + @Override + public boolean isBlockPowered() { + return false; + } + + @Override + public boolean isBlockIndirectlyPowered() { + return false; + } + + @Override + public boolean isBlockFacePowered(BlockFace face) { + return false; + } + + @Override + public boolean isBlockFaceIndirectlyPowered(BlockFace face) { + return false; + } + + @Override + public int getBlockPower(BlockFace face) { + return 0; + } + + @Override + public int getBlockPower() { + return 0; + } + + @Override + public boolean isEmpty() { + return false; + } + + @Override + public boolean isLiquid() { + return false; + } + + @Override + public double getTemperature() { + return 0; + } + + @Override + public double getHumidity() { + return 0; + } + + @Override + public PistonMoveReaction getPistonMoveReaction() { + return null; + } + + @Override + public boolean breakNaturally() { + return false; + } + + @Override + public boolean breakNaturally(ItemStack tool) { + return false; + } + + @Override + public Collection getDrops() { + return null; + } + + @Override + public Collection getDrops(ItemStack tool) { + return null; + } + + @Override + public void setMetadata(String metadataKey, MetadataValue newMetadataValue) { + + } + + @Override + public List getMetadata(String metadataKey) { + return null; + } + + @Override + public boolean hasMetadata(String metadataKey) { + return false; + } + + @Override + public void removeMetadata(String metadataKey, Plugin owningPlugin) { + + } +} diff --git a/bukkit0/src/main/java/com/boydti/fawe/bukkit/wrapper/AsyncBlockState.java b/bukkit0/src/main/java/com/boydti/fawe/bukkit/wrapper/AsyncBlockState.java new file mode 100644 index 00000000..97b07366 --- /dev/null +++ b/bukkit0/src/main/java/com/boydti/fawe/bukkit/wrapper/AsyncBlockState.java @@ -0,0 +1,168 @@ +package com.boydti.fawe.bukkit.wrapper; + +import com.boydti.fawe.FaweCache; +import com.sk89q.jnbt.CompoundTag; +import java.util.List; +import org.bukkit.Chunk; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.World; +import org.bukkit.block.Block; +import org.bukkit.block.BlockState; +import org.bukkit.material.MaterialData; +import org.bukkit.metadata.MetadataValue; +import org.bukkit.plugin.Plugin; + +public class AsyncBlockState implements BlockState { + + private byte data; + private short id; + private CompoundTag nbt; + private final AsyncBlock block; + + public AsyncBlockState(AsyncBlock block) { + this.block = block; + int combined = block.queue.getCombinedId4Data(block.x, block.y, block.z); + this.id = (short) (combined >> 4); + this.data = (byte) (combined & 0xF); + if (FaweCache.hasNBT(id)) { + this.nbt = block.queue.getTileEntity(block.x, block.y, block.z); + } else { + this.nbt = null; + } + } + + @Override + public Block getBlock() { + return block; + } + + @Override + public MaterialData getData() { + return new MaterialData(id, data); + } + + @Override + public Material getType() { + return Material.getMaterial(id); + } + + @Override + public int getTypeId() { + return id; + } + + @Override + public byte getLightLevel() { + throw new UnsupportedOperationException("Not implemented"); + } + + @Override + public World getWorld() { + return block.world; + } + + @Override + public int getX() { + return block.x; + } + + @Override + public int getY() { + return block.y; + } + + @Override + public int getZ() { + return block.z; + } + + @Override + public Location getLocation() { + return block.getLocation(); + } + + @Override + public Location getLocation(Location loc) { + return block.getLocation(loc); + } + + @Override + public Chunk getChunk() { + return block.getChunk(); + } + + @Override + public void setData(MaterialData data) { + setTypeId(data.getItemTypeId()); + setRawData(data.getData()); + } + + @Override + public void setType(Material type) { + setTypeId(type.getId()); + } + + @Override + public boolean setTypeId(int type) { + if (id != type) { + this.id = (short) type; + return true; + } + return false; + } + + @Override + public boolean update() { + return update(false); + } + + @Override + public boolean update(boolean force) { + return update(force, true); + } + + @Override + public boolean update(boolean force, boolean applyPhysics) { + boolean result = block.queue.setBlock(block.x, block.y, block.z, id, data); + if (nbt != null) { + block.queue.setTile(block.x, block.y, block.z, nbt); + } + return result; + } + + @Override + public byte getRawData() { + return data; + } + + @Override + public void setRawData(byte data) { + this.data = data; + } + + @Override + public boolean isPlaced() { + return false; + } + + @Override + public void setMetadata(String key, MetadataValue value) { + block.setMetadata(key, value); + } + + @Override + public List getMetadata(String key) { + return block.getMetadata(key); + } + + @Override + public boolean hasMetadata(String key) { + return block.hasMetadata(key); + } + + @Override + public void removeMetadata(String key, Plugin plugin) { + block.removeMetadata(key, plugin); + } +} diff --git a/bukkit0/src/main/java/com/boydti/fawe/bukkit/wrapper/AsyncChunk.java b/bukkit0/src/main/java/com/boydti/fawe/bukkit/wrapper/AsyncChunk.java new file mode 100644 index 00000000..014f65b8 --- /dev/null +++ b/bukkit0/src/main/java/com/boydti/fawe/bukkit/wrapper/AsyncChunk.java @@ -0,0 +1,101 @@ +package com.boydti.fawe.bukkit.wrapper; + +import com.boydti.fawe.object.RunnableVal; +import com.boydti.fawe.object.FaweQueue; +import com.boydti.fawe.util.TaskManager; +import org.bukkit.Chunk; +import org.bukkit.ChunkSnapshot; +import org.bukkit.World; +import org.bukkit.block.Block; +import org.bukkit.block.BlockState; +import org.bukkit.entity.Entity; + +public class AsyncChunk implements Chunk { + + private final World world; + private final int z; + private final int x; + private final FaweQueue queue; + + public AsyncChunk(World world, FaweQueue queue, int x, int z) { + this.world = world instanceof AsyncWorld ? world : new AsyncWorld(world, true); + this.queue = queue; + this.x = x; + this.z = z; + } + + @Override + public int getX() { + return x; + } + + @Override + public int getZ() { + return z; + } + + @Override + public World getWorld() { + return world; + } + + @Override + public Block getBlock(int x, int y, int z) { + return new AsyncBlock(world, queue, (this.x << 4) + x, y, (this.z << 4) + z); + } + + @Override + public ChunkSnapshot getChunkSnapshot() { + throw new UnsupportedOperationException("NOT IMPLEMENTED"); + } + + @Override + public ChunkSnapshot getChunkSnapshot(boolean includeMaxblocky, boolean includeBiome, boolean includeBiomeTempRain) { + throw new UnsupportedOperationException("NOT IMPLEMENTED"); + } + + @Override + public Entity[] getEntities() { + throw new UnsupportedOperationException("NOT IMPLEMENTED"); + } + + @Override + public BlockState[] getTileEntities() { + throw new UnsupportedOperationException("NOT IMPLEMENTED"); + } + + @Override + public boolean isLoaded() { + return world.isChunkLoaded(x, z); + } + + @Override + public boolean load(boolean generate) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Boolean value) { + this.value = world.loadChunk(x, z, generate); + } + }); + } + + @Override + public boolean load() { + return load(false); + } + + @Override + public boolean unload(boolean save, boolean safe) { + return world.unloadChunk(x, z, save, safe); + } + + @Override + public boolean unload(boolean save) { + return unload(true, false); + } + + @Override + public boolean unload() { + return unload(true); + } +} diff --git a/bukkit0/src/main/java/com/boydti/fawe/bukkit/wrapper/AsyncWorld.java b/bukkit0/src/main/java/com/boydti/fawe/bukkit/wrapper/AsyncWorld.java new file mode 100644 index 00000000..c62070e5 --- /dev/null +++ b/bukkit0/src/main/java/com/boydti/fawe/bukkit/wrapper/AsyncWorld.java @@ -0,0 +1,868 @@ +package com.boydti.fawe.bukkit.wrapper; + +import com.boydti.fawe.FaweAPI; +import com.boydti.fawe.bukkit.v0.BukkitQueue_0; +import com.boydti.fawe.object.FaweQueue; +import com.boydti.fawe.object.RunnableVal; +import com.boydti.fawe.util.TaskManager; +import com.sk89q.worldedit.bukkit.WorldEditPlugin; +import com.sk89q.worldedit.bukkit.adapter.BukkitImplAdapter; +import com.sk89q.worldedit.world.biome.BaseBiome; +import java.io.File; +import java.lang.reflect.Field; +import java.util.Collection; +import java.util.List; +import java.util.Set; +import java.util.UUID; +import org.bukkit.BlockChangeDelegate; +import org.bukkit.Bukkit; +import org.bukkit.Chunk; +import org.bukkit.ChunkSnapshot; +import org.bukkit.Difficulty; +import org.bukkit.Effect; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.Sound; +import org.bukkit.TreeType; +import org.bukkit.World; +import org.bukkit.WorldBorder; +import org.bukkit.WorldType; +import org.bukkit.block.Biome; +import org.bukkit.block.Block; +import org.bukkit.entity.Arrow; +import org.bukkit.entity.CreatureType; +import org.bukkit.entity.Entity; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.FallingBlock; +import org.bukkit.entity.Item; +import org.bukkit.entity.LightningStrike; +import org.bukkit.entity.LivingEntity; +import org.bukkit.entity.Player; +import org.bukkit.generator.BlockPopulator; +import org.bukkit.generator.ChunkGenerator; +import org.bukkit.inventory.ItemStack; +import org.bukkit.metadata.MetadataValue; +import org.bukkit.plugin.Plugin; +import org.bukkit.util.Vector; + +/** + * Modify the world from an async thread
+ * - Any Chunk/Block/BlockState objects returned should also be thread safe
+ * - Use world.commit() to execute the changes
+ * - Don't rely on autoQueue as behavior is determined by the settings.yml
+ */ +public class AsyncWorld implements World { + + public final World parent; + public final FaweQueue queue; + private BukkitImplAdapter adapter; + + public AsyncWorld(World parent, boolean autoQueue) { + this(parent, FaweAPI.createQueue(parent.getName(), autoQueue)); + } + + public AsyncWorld(World parent, FaweQueue queue) { + this.parent = parent; + this.queue = queue; + if (queue instanceof BukkitQueue_0) { + this.adapter = (BukkitImplAdapter) ((BukkitQueue_0) queue).adapter; + } else { + try { + WorldEditPlugin instance = (WorldEditPlugin) Bukkit.getPluginManager().getPlugin("WorldEdit"); + Field fieldAdapter = WorldEditPlugin.class.getDeclaredField("bukkitAdapter"); + fieldAdapter.setAccessible(true); + this.adapter = (BukkitImplAdapter) fieldAdapter.get(instance); + } catch (Throwable e) { + e.printStackTrace(); + } + } + } + + public void commit() { + queue.enqueue(); + } + + @Override + public WorldBorder getWorldBorder() { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(WorldBorder value) { + this.value = parent.getWorldBorder(); + } + }); + } + + @Override + public Block getBlockAt(int x, int y, int z) { + return new AsyncBlock(this, queue, x, y, z); + } + + @Override + public Block getBlockAt(Location loc) { + return getBlockAt(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()); + } + + @Override + @Deprecated + public int getBlockTypeIdAt(int x, int y, int z) { + return queue.getCombinedId4Data(x, y, z) >> 4; + } + + @Override + @Deprecated + public int getBlockTypeIdAt(Location loc) { + return getBlockTypeIdAt(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ()); + } + + @Override + public int getHighestBlockYAt(int x, int z) { + for (int y = 255; y >= 0; y--) { + if (queue.getCombinedId4Data(x, y, z) != 0) { + return y; + } + } + return 0; + } + + @Override + public int getHighestBlockYAt(Location loc) { + return getHighestBlockYAt(loc.getBlockX(), loc.getBlockZ()); + } + + @Override + public Block getHighestBlockAt(int x, int z) { + int y = getHighestBlockYAt(x, z); + return getBlockAt(x, y, z); + } + + @Override + public Block getHighestBlockAt(Location loc) { + return getHighestBlockAt(loc.getBlockX(), loc.getBlockZ()); + } + + @Override + public Chunk getChunkAt(int x, int z) { + return new AsyncChunk(this, queue, x, z); + } + + @Override + public Chunk getChunkAt(Location location) { + return getChunkAt(location.getBlockX(), location.getBlockZ()); + } + + @Override + public Chunk getChunkAt(Block block) { + return getChunkAt(block.getX(), block.getZ()); + } + + @Override + public boolean isChunkLoaded(Chunk chunk) { + return chunk.isLoaded(); + } + + @Override + public Chunk[] getLoadedChunks() { + return parent.getLoadedChunks(); + } + + @Override + public void loadChunk(final Chunk chunk) { + if (!chunk.isLoaded()) { + TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Object value) { + parent.loadChunk(chunk); + } + }); + } + } + + @Override + public boolean isChunkLoaded(int x, int z) { + return parent.isChunkLoaded(x, z); + } + + @Override + public boolean isChunkInUse(int x, int z) { + return parent.isChunkInUse(x, z); + } + + @Override + public void loadChunk(int x, int z) { + if (!isChunkLoaded(x, z)) { + TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Object value) { + parent.loadChunk(x, z); + } + }); + } + } + + @Override + public boolean loadChunk(int x, int z, boolean generate) { + if (!isChunkLoaded(x, z)) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Boolean value) { + this.value = parent.loadChunk(x, z, generate); + } + }); + } + return true; + } + + @Override + public boolean unloadChunk(Chunk chunk) { + if (chunk.isLoaded()) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Boolean value) { + this.value = parent.unloadChunk(chunk); + } + }); + } + return true; + } + + @Override + public boolean unloadChunk(int x, int z) { + return unloadChunk(x, z, true); + } + + @Override + public boolean unloadChunk(int x, int z, boolean save) { + return unloadChunk(x, z, save, false); + } + + @Override + public boolean unloadChunk(int x, int z, boolean save, boolean safe) { + if (isChunkLoaded(x, z)) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Boolean value) { + this.value = parent.unloadChunk(x, z, save, safe); + } + }); + } + return true; + } + + @Override + public boolean unloadChunkRequest(int x, int z) { + return unloadChunk(x, z); + } + + @Override + public boolean unloadChunkRequest(int x, int z, boolean safe) { + return unloadChunk(x, z, safe); + } + + @Override + public boolean regenerateChunk(int x, int z) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Boolean value) { + this.value = parent.regenerateChunk(x, z); + } + }); + } + + @Override + @Deprecated + public boolean refreshChunk(int x, int z) { + queue.sendChunk(queue.getFaweChunk(x, z), FaweQueue.RelightMode.NONE); + return true; + } + + @Override + public Item dropItem(Location location, ItemStack item) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Item value) { + this.value = parent.dropItem(location, item); + } + }); + } + + @Override + public Item dropItemNaturally(Location location, ItemStack item) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Item value) { + this.value = parent.dropItemNaturally(location, item); + } + }); + } + + @Override + public Arrow spawnArrow(Location location, Vector direction, float speed, float spread) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Arrow value) { + this.value = parent.spawnArrow(location, direction, speed, spread); + } + }); + } + + @Override + public boolean generateTree(Location location, TreeType type) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Boolean value) { + this.value = parent.generateTree(location, type); + } + }); + } + + @Override + public boolean generateTree(Location loc, TreeType type, BlockChangeDelegate delegate) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Boolean value) { + this.value = parent.generateTree(loc, type, delegate); + } + }); + } + + @Override + public Entity spawnEntity(Location loc, EntityType type) { + return spawn(loc, type.getEntityClass()); + } + + @Override + @Deprecated + public LivingEntity spawnCreature(Location loc, EntityType type) { + return (LivingEntity)this.spawnEntity(loc, type); + } + + @Override + @Deprecated + public LivingEntity spawnCreature(Location loc, CreatureType type) { + return this.spawnCreature(loc, type.toEntityType()); + } + + @Override + public LightningStrike strikeLightning(Location loc) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(LightningStrike value) { + this.value = parent.strikeLightning(loc); + } + }); + } + + @Override + public LightningStrike strikeLightningEffect(Location loc) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(LightningStrike value) { + this.value = parent.strikeLightningEffect(loc); + } + }); + } + + @Override + public List getEntities() { + return TaskManager.IMP.sync(new RunnableVal>() { + @Override + public void run(List value) { + this.value = parent.getEntities(); + } + }); + } + + @Override + public List getLivingEntities() { + return TaskManager.IMP.sync(new RunnableVal>() { + @Override + public void run(List value) { + this.value = parent.getLivingEntities(); + } + }); + } + + @Override + @Deprecated + public Collection getEntitiesByClass(Class... classes) { + return TaskManager.IMP.sync(new RunnableVal>() { + @Override + public void run(Collection value) { + this.value = (Collection) parent.getEntitiesByClass(classes); + } + }); + } + + @Override + public Collection getEntitiesByClass(Class cls) { + return TaskManager.IMP.sync(new RunnableVal>() { + @Override + public void run(Collection value) { + this.value = (Collection) parent.getEntitiesByClass(cls); + } + }); + } + + @Override + public Collection getEntitiesByClasses(Class... classes) { + return TaskManager.IMP.sync(new RunnableVal>() { + @Override + public void run(Collection value) { + this.value = parent.getEntitiesByClasses(classes); + } + }); + } + + @Override + public List getPlayers() { + return TaskManager.IMP.sync(new RunnableVal>() { + @Override + public void run(List value) { + this.value = parent.getPlayers(); + } + }); + } + + @Override + public Collection getNearbyEntities(Location location, double x, double y, double z) { + return TaskManager.IMP.sync(new RunnableVal>() { + @Override + public void run(Collection value) { + this.value = parent.getNearbyEntities(location, x, y, z); + } + }); + } + + @Override + public String getName() { + return parent.getName(); + } + + @Override + public UUID getUID() { + return parent.getUID(); + } + + @Override + public Location getSpawnLocation() { + return parent.getSpawnLocation(); + } + + @Override + public boolean setSpawnLocation(int x, int y, int z) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Boolean value) { + this.value = parent.setSpawnLocation(x, y, z); + } + }); + } + + @Override + public long getTime() { + return parent.getTime(); + } + + @Override + public void setTime(long time) { + parent.setTime(time); + } + + @Override + public long getFullTime() { + return parent.getFullTime(); + } + + @Override + public void setFullTime(long time) { + parent.setFullTime(time); + } + + @Override + public boolean hasStorm() { + return parent.hasStorm(); + } + + @Override + public void setStorm(boolean hasStorm) { + parent.setStorm(hasStorm); + } + + @Override + public int getWeatherDuration() { + return parent.getWeatherDuration(); + } + + @Override + public void setWeatherDuration(int duration) { + parent.setWeatherDuration(duration); + } + + @Override + public boolean isThundering() { + return parent.isThundering(); + } + + @Override + public void setThundering(boolean thundering) { + parent.setThundering(thundering); + } + + @Override + public int getThunderDuration() { + return parent.getThunderDuration(); + } + + @Override + public void setThunderDuration(int duration) { + parent.setThunderDuration(duration); + } + + public boolean createExplosion(double x, double y, double z, float power) { + return this.createExplosion(x, y, z, power, false, true); + } + + public boolean createExplosion(double x, double y, double z, float power, boolean setFire) { + return this.createExplosion(x, y, z, power, setFire, true); + } + + public boolean createExplosion(double x, double y, double z, float power, boolean setFire, boolean breakBlocks) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Boolean value) { + this.value = parent.createExplosion(x, y, z, power, setFire, breakBlocks); + } + }); + } + + public boolean createExplosion(Location loc, float power) { + return this.createExplosion(loc, power, false); + } + + public boolean createExplosion(Location loc, float power, boolean setFire) { + return this.createExplosion(loc.getX(), loc.getY(), loc.getZ(), power, setFire); + } + + @Override + public Environment getEnvironment() { + return parent.getEnvironment(); + } + + @Override + public long getSeed() { + return parent.getSeed(); + } + + @Override + public boolean getPVP() { + return parent.getPVP(); + } + + @Override + public void setPVP(boolean pvp) { + parent.setPVP(pvp); + } + + @Override + public ChunkGenerator getGenerator() { + return parent.getGenerator(); + } + + @Override + public void save() { + TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Object value) { + parent.save(); + } + }); + } + + @Override + public List getPopulators() { + return parent.getPopulators(); + } + + @Override + public T spawn(Location location, Class clazz) throws IllegalArgumentException { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(T value) { + this.value = parent.spawn(location, clazz); + } + }); + } + + @Override + @Deprecated + public FallingBlock spawnFallingBlock(Location location, Material material, byte data) throws IllegalArgumentException { + return this.spawnFallingBlock(location, material.getId(), data); + } + + @Override + @Deprecated + public FallingBlock spawnFallingBlock(Location location, int blockId, byte blockData) throws IllegalArgumentException { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(FallingBlock value) { + this.value = parent.spawnFallingBlock(location, blockId, blockData); + } + }); + } + + @Override + public void playEffect(Location location, Effect effect, int data) { + this.playEffect(location, effect, data, 64); + } + + @Override + public void playEffect(Location location, Effect effect, int data, int radius) { + TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Object value) { + parent.playEffect(location, effect, data, radius); + } + }); + } + + @Override + public void playEffect(Location loc, Effect effect, T data) { + this.playEffect(loc, effect, data, 64); + } + + @Override + public void playEffect(Location location, Effect effect, T data, int radius) { + TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Object value) { + parent.playEffect(location, effect, data, radius); + } + }); + } + + @Override + public ChunkSnapshot getEmptyChunkSnapshot(int x, int z, boolean includeBiome, boolean includeBiomeTempRain) { + return TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(ChunkSnapshot value) { + this.value = parent.getEmptyChunkSnapshot(x, z, includeBiome, includeBiomeTempRain); + } + }); + } + + @Override + public void setSpawnFlags(boolean allowMonsters, boolean allowAnimals) { + parent.setSpawnFlags(allowMonsters, allowAnimals); + } + + @Override + public boolean getAllowAnimals() { + return parent.getAllowAnimals(); + } + + @Override + public boolean getAllowMonsters() { + return parent.getAllowMonsters(); + } + + @Override + public Biome getBiome(int x, int z) { + throw new UnsupportedOperationException("NOT IMPLEMENTED"); + } + + @Override + public void setBiome(int x, int z, Biome bio) { + int id = adapter.getBiomeId(bio); + queue.setBiome(x, z, new BaseBiome(id)); + } + + @Override + public double getTemperature(int x, int z) { + return parent.getTemperature(x, z); + } + + @Override + public double getHumidity(int x, int z) { + return parent.getHumidity(x, z); + } + + @Override + public int getMaxHeight() { + return parent.getMaxHeight(); + } + + @Override + public int getSeaLevel() { + return parent.getSeaLevel(); + } + + @Override + public boolean getKeepSpawnInMemory() { + return parent.getKeepSpawnInMemory(); + } + + @Override + public void setKeepSpawnInMemory(boolean keepLoaded) { + TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Object value) { + parent.setKeepSpawnInMemory(keepLoaded); + } + }); + } + + @Override + public boolean isAutoSave() { + return parent.isAutoSave(); + } + + @Override + public void setAutoSave(boolean value) { + parent.setAutoSave(value); + } + + @Override + public void setDifficulty(Difficulty difficulty) { + parent.setDifficulty(difficulty); + } + + @Override + public Difficulty getDifficulty() { + return parent.getDifficulty(); + } + + @Override + public File getWorldFolder() { + return parent.getWorldFolder(); + } + + @Override + public WorldType getWorldType() { + return parent.getWorldType(); + } + + @Override + public boolean canGenerateStructures() { + return parent.canGenerateStructures(); + } + + @Override + public long getTicksPerAnimalSpawns() { + return parent.getTicksPerAnimalSpawns(); + } + + @Override + public void setTicksPerAnimalSpawns(int ticksPerAnimalSpawns) { + parent.setTicksPerAnimalSpawns(ticksPerAnimalSpawns); + } + + @Override + public long getTicksPerMonsterSpawns() { + return parent.getTicksPerMonsterSpawns(); + } + + @Override + public void setTicksPerMonsterSpawns(int ticksPerMonsterSpawns) { + parent.setTicksPerMonsterSpawns(ticksPerMonsterSpawns); + } + + @Override + public int getMonsterSpawnLimit() { + return parent.getMonsterSpawnLimit(); + } + + @Override + public void setMonsterSpawnLimit(int limit) { + parent.setMonsterSpawnLimit(limit); + } + + @Override + public int getAnimalSpawnLimit() { + return parent.getAnimalSpawnLimit(); + } + + @Override + public void setAnimalSpawnLimit(int limit) { + parent.setAnimalSpawnLimit(limit); + } + + @Override + public int getWaterAnimalSpawnLimit() { + return parent.getWaterAnimalSpawnLimit(); + } + + @Override + public void setWaterAnimalSpawnLimit(int limit) { + parent.setWaterAnimalSpawnLimit(limit); + } + + @Override + public int getAmbientSpawnLimit() { + return parent.getAmbientSpawnLimit(); + } + + @Override + public void setAmbientSpawnLimit(int limit) { + parent.setAmbientSpawnLimit(limit); + } + + @Override + public void playSound(Location location, Sound sound, float volume, float pitch) { + TaskManager.IMP.sync(new RunnableVal() { + @Override + public void run(Object value) { + parent.playSound(location, sound, volume, pitch); + } + }); + } + + @Override + public String[] getGameRules() { + return parent.getGameRules(); + } + + @Override + public String getGameRuleValue(String rule) { + return parent.getGameRuleValue(rule); + } + + @Override + public boolean setGameRuleValue(String rule, String value) { + return parent.setGameRuleValue(rule, value); + } + + @Override + public boolean isGameRule(String rule) { + return parent.isGameRule(rule); + } + + @Override + public void setMetadata(String key, MetadataValue value) { + parent.setMetadata(key, value); + } + + @Override + public List getMetadata(String key) { + return parent.getMetadata(key); + } + + @Override + public boolean hasMetadata(String key) { + return parent.hasMetadata(key); + } + + @Override + public void removeMetadata(String key, Plugin plugin) { + parent.removeMetadata(key, plugin); + } + + @Override + public void sendPluginMessage(Plugin source, String channel, byte[] message) { + parent.sendPluginMessage(source, channel, message); + } + + @Override + public Set getListeningPluginChannels() { + return parent.getListeningPluginChannels(); + } +} diff --git a/bukkit0/src/main/java/com/thevoxelbox/voxelsniper/SnipeData.java b/bukkit0/src/main/java/com/thevoxelbox/voxelsniper/SnipeData.java new file mode 100644 index 00000000..4d7defbc --- /dev/null +++ b/bukkit0/src/main/java/com/thevoxelbox/voxelsniper/SnipeData.java @@ -0,0 +1,252 @@ +package com.thevoxelbox.voxelsniper; + +import com.thevoxelbox.voxelsniper.util.VoxelList; +import org.bukkit.World; + +/** + * @author Piotr + */ +public class SnipeData { + + public static final int DEFAULT_REPLACE_DATA_VALUE = 0; + public static final int DEFAULT_CYLINDER_CENTER = 0; + public static final int DEFAULT_VOXEL_HEIGHT = 1; + public static final int DEFAULT_BRUSH_SIZE = 3; + public static final int DEFAULT_DATA_VALUE = 0; + public static final int DEFAULT_REPLACE_ID = 0; + public static final int DEFAULT_VOXEL_ID = 0; + + private final Sniper owner; + private Message voxelMessage; + /** + * Brush size -- set blockPositionY /b #. + */ + private int brushSize = SnipeData.DEFAULT_BRUSH_SIZE; + /** + * Voxel Id -- set blockPositionY /v (#,name). + */ + private int voxelId = SnipeData.DEFAULT_VOXEL_ID; + /** + * Voxel Replace Id -- set blockPositionY /vr #. + */ + private int replaceId = SnipeData.DEFAULT_REPLACE_ID; + /** + * Voxel 'ink' -- set blockPositionY /vi #. + */ + private byte data = SnipeData.DEFAULT_DATA_VALUE; + /** + * Voxel 'ink' Replace -- set blockPositionY /vir #. + */ + private byte replaceData = SnipeData.DEFAULT_REPLACE_DATA_VALUE; + /** + * Voxel List of ID's -- set blockPositionY /vl # # # -#. + */ + private VoxelList voxelList = new VoxelList(); + /** + * Voxel 'heigth' -- set blockPositionY /vh #. + */ + private int voxelHeight = SnipeData.DEFAULT_VOXEL_HEIGHT; + /** + * Voxel centroid -- set Cylynder center /vc #. + */ + private int cCen = SnipeData.DEFAULT_CYLINDER_CENTER; + private int range = 0; + private boolean ranged = false; + private boolean lightning = false; + + /** + * @param vs + */ + public SnipeData(final Sniper vs) { + this.owner = vs; + } + + /** + * @return the brushSize + */ + public final int getBrushSize() { + return this.brushSize; + } + + /** + * @return the cCen + */ + public final int getcCen() { + return this.cCen; + } + + /** + * @return the data + */ + public final byte getData() { + return this.data; + } + + /** + * @return the replaceData + */ + public final byte getReplaceData() { + return this.replaceData; + } + + /** + * @return the replaceId + */ + public final int getReplaceId() { + return this.replaceId; + } + + /** + * @return the voxelHeight + */ + public final int getVoxelHeight() { + return this.voxelHeight; + } + + /** + * @return the voxelId + */ + public final int getVoxelId() { + return this.voxelId; + } + + /** + * @return the voxelList + */ + public final VoxelList getVoxelList() { + return this.voxelList; + } + + /** + * @return the voxelMessage + */ + public final Message getVoxelMessage() { + return this.voxelMessage; + } + + /** + * @return World + */ + public final World getWorld() { + return this.owner.getWorld(); // Changed + } + + /** + * @return Sniper + */ + public final Sniper owner() { + return this.owner; + } + + /** + * Reset to default values. + */ + public final void reset() { + this.voxelId = SnipeData.DEFAULT_VOXEL_ID; + this.replaceId = SnipeData.DEFAULT_REPLACE_ID; + this.data = SnipeData.DEFAULT_DATA_VALUE; + this.brushSize = SnipeData.DEFAULT_BRUSH_SIZE; + this.voxelHeight = SnipeData.DEFAULT_VOXEL_HEIGHT; + this.cCen = SnipeData.DEFAULT_CYLINDER_CENTER; + this.replaceData = SnipeData.DEFAULT_REPLACE_DATA_VALUE; + this.voxelList = new VoxelList(); + } + + /** + * @param message + */ + public final void sendMessage(final String message) { + this.owner.getPlayer().sendMessage(message); + } + + /** + * @param brushSize the brushSize to set + */ + public final void setBrushSize(final int brushSize) { + this.brushSize = brushSize; + } + + /** + * @param cCen the cCen to set + */ + public final void setcCen(final int cCen) { + this.cCen = cCen; + } + + /** + * @param data the data to set + */ + public final void setData(final byte data) { + this.data = data; + } + + /** + * @param replaceData the replaceData to set + */ + public final void setReplaceData(final byte replaceData) { + this.replaceData = replaceData; + } + + /** + * @param replaceId the replaceId to set + */ + public final void setReplaceId(final int replaceId) { + this.replaceId = replaceId; + } + + /** + * @param voxelHeight the voxelHeight to set + */ + public final void setVoxelHeight(final int voxelHeight) { + this.voxelHeight = voxelHeight; + } + + /** + * @param voxelId the voxelId to set + */ + public final void setVoxelId(final int voxelId) { + this.voxelId = voxelId; + } + + /** + * @param voxelList the voxelList to set + */ + public final void setVoxelList(final VoxelList voxelList) { + this.voxelList = voxelList; + } + + /** + * @param voxelMessage the voxelMessage to set + */ + public final void setVoxelMessage(final Message voxelMessage) { + this.voxelMessage = voxelMessage; + } + + public int getRange() { + return range; + } + + public void setRange(int range) { + this.range = range; + } + + public boolean isRanged() { + return ranged; + } + + public void setRanged(boolean ranged) { + this.ranged = ranged; + } + + public boolean isLightningEnabled() { + return lightning; + } + + public void setLightningEnabled(boolean lightning) { + this.lightning = lightning; + } + + public static Class inject() { + return SnipeData.class; + } +} \ No newline at end of file diff --git a/bukkit0/src/main/java/com/thevoxelbox/voxelsniper/Sniper.java b/bukkit0/src/main/java/com/thevoxelbox/voxelsniper/Sniper.java new file mode 100644 index 00000000..c30b19be --- /dev/null +++ b/bukkit0/src/main/java/com/thevoxelbox/voxelsniper/Sniper.java @@ -0,0 +1,546 @@ +package com.thevoxelbox.voxelsniper; + +import com.boydti.fawe.FaweAPI; +import com.boydti.fawe.bukkit.wrapper.AsyncWorld; +import com.boydti.fawe.object.FawePlayer; +import com.boydti.fawe.object.FaweQueue; +import com.boydti.fawe.object.MaskedFaweQueue; +import com.boydti.fawe.object.RegionWrapper; +import com.boydti.fawe.util.TaskManager; +import com.boydti.fawe.util.WEManager; +import com.google.common.base.Preconditions; +import com.google.common.collect.BiMap; +import com.google.common.collect.ClassToInstanceMap; +import com.google.common.collect.HashBiMap; +import com.google.common.collect.ImmutableBiMap; +import com.google.common.collect.Maps; +import com.google.common.collect.MutableClassToInstanceMap; +import com.thevoxelbox.voxelsniper.brush.IBrush; +import com.thevoxelbox.voxelsniper.brush.SnipeBrush; +import com.thevoxelbox.voxelsniper.brush.perform.PerformBrush; +import com.thevoxelbox.voxelsniper.brush.perform.Performer; +import com.thevoxelbox.voxelsniper.event.SniperMaterialChangedEvent; +import com.thevoxelbox.voxelsniper.event.SniperReplaceMaterialChangedEvent; +import java.util.LinkedList; +import java.util.Map; +import java.util.UUID; +import org.bukkit.Bukkit; +import org.bukkit.ChatColor; +import org.bukkit.Material; +import org.bukkit.World; +import org.bukkit.block.Block; +import org.bukkit.block.BlockFace; +import org.bukkit.entity.Player; +import org.bukkit.event.block.Action; +import org.bukkit.material.MaterialData; + +/** + * + */ +public class Sniper { + private VoxelSniper plugin; + private final UUID player; + private boolean enabled = true; + private LinkedList undoList = new LinkedList(); + private Map tools = Maps.newHashMap(); + + public Sniper(VoxelSniper plugin, Player player) { + this.plugin = plugin; + this.player = player.getUniqueId(); + SniperTool sniperTool = new SniperTool(this); + sniperTool.assignAction(SnipeAction.ARROW, Material.ARROW); + sniperTool.assignAction(SnipeAction.GUNPOWDER, Material.SULPHUR); + tools.put(null, sniperTool); + } + + public String getCurrentToolId() { + return getToolId((getPlayer().getItemInHand() != null) ? getPlayer().getItemInHand().getType() : null); + } + + public String getToolId(Material itemInHand) { + if (itemInHand == null) { + return null; + } + + for (Map.Entry entry : tools.entrySet()) { + if (entry.getValue().hasToolAssigned(itemInHand)) { + return entry.getKey(); + } + } + return null; + } + + // Added + public AsyncWorld tmpWorld; + + // Added + public World getWorld() { + if (this.tmpWorld == null) { + return new AsyncWorld(getPlayer().getWorld(), false); + } + return tmpWorld; + } + + public Player getPlayer() { + return Bukkit.getPlayer(player); + } + + /** + * Sniper execution call. + * + * @param action Action player performed + * @param itemInHand Item in hand of player + * @param clickedBlock Block that the player targeted/interacted with + * @param clickedFace Face of that targeted Block + * @return true if command visibly processed, false otherwise. + */ + public boolean snipe(Action action, Material itemInHand, Block clickedBlock, BlockFace clickedFace) { + try { + // Added + FaweQueue queue; + { + Player player = getPlayer(); + if (tmpWorld == null || !player.getWorld().getName().equals(tmpWorld.getName())) { + FawePlayer fp = FawePlayer.wrap(player); + RegionWrapper[] mask = WEManager.IMP.getMask(fp).toArray(new RegionWrapper[0]); + queue = FaweAPI.createQueue(fp.getLocation().world, true); + queue = new MaskedFaweQueue(queue, mask); + tmpWorld = new AsyncWorld(player.getWorld(), queue); + } + if (clickedBlock != null) { + clickedBlock = tmpWorld.getBlockAt(clickedBlock.getX(), clickedBlock.getY(), clickedBlock.getZ()); + } + } + return snipe(action, itemInHand, tmpWorld, clickedBlock, clickedFace); + } catch (Throwable e) { + e.printStackTrace(); + } + return false; + } + + // Old method (plus world arg) + public boolean snipe(Action action, Material itemInHand, AsyncWorld world, Block clickedBlock, BlockFace clickedFace) { + String toolId = getToolId(itemInHand); + SniperTool sniperTool = tools.get(toolId); + + switch (action) { + case LEFT_CLICK_AIR: + case LEFT_CLICK_BLOCK: + case RIGHT_CLICK_AIR: + case RIGHT_CLICK_BLOCK: + break; + default: + return false; + } + + if (sniperTool.hasToolAssigned(itemInHand)) { + if (sniperTool.getCurrentBrush() == null) { + getPlayer().sendMessage("No Brush selected."); + return true; + } + + if (!getPlayer().hasPermission(sniperTool.getCurrentBrush().getPermissionNode())) { + getPlayer().sendMessage("You are not allowed to use this brush. You're missing the permission node '" + sniperTool.getCurrentBrush().getPermissionNode() + "'"); + return true; + } + + SnipeData snipeData = sniperTool.getSnipeData(); + if (getPlayer().isSneaking()) { + Block targetBlock; + SnipeAction snipeAction = sniperTool.getActionAssigned(itemInHand); + + switch (action) { + case LEFT_CLICK_BLOCK: + case LEFT_CLICK_AIR: + if (clickedBlock != null) { + targetBlock = clickedBlock; + } else { + RangeBlockHelper rangeBlockHelper = snipeData.isRanged() ? new RangeBlockHelper(getPlayer(), world, snipeData.getRange()) : new RangeBlockHelper(getPlayer(), world); + targetBlock = snipeData.isRanged() ? rangeBlockHelper.getRangeBlock() : rangeBlockHelper.getTargetBlock(); + } + + switch (snipeAction) { + case ARROW: + if (targetBlock != null) { + int originalVoxel = snipeData.getVoxelId(); + snipeData.setVoxelId(targetBlock.getTypeId()); + SniperMaterialChangedEvent event = new SniperMaterialChangedEvent(this, toolId, new MaterialData(originalVoxel, snipeData.getData()), new MaterialData(snipeData.getVoxelId(), snipeData.getData())); + Bukkit.getPluginManager().callEvent(event); + snipeData.getVoxelMessage().voxel(); + return true; + } else { + int originalVoxel = snipeData.getVoxelId(); + snipeData.setVoxelId(0); + SniperMaterialChangedEvent event = new SniperMaterialChangedEvent(this, toolId, new MaterialData(originalVoxel, snipeData.getData()), new MaterialData(snipeData.getVoxelId(), snipeData.getData())); + Bukkit.getPluginManager().callEvent(event); + snipeData.getVoxelMessage().voxel(); + return true; + } + case GUNPOWDER: + if (targetBlock != null) { + byte originalData = snipeData.getData(); + snipeData.setData(targetBlock.getData()); + SniperMaterialChangedEvent event = new SniperMaterialChangedEvent(this, toolId, new MaterialData(snipeData.getVoxelId(), originalData), new MaterialData(snipeData.getVoxelId(), snipeData.getData())); + Bukkit.getPluginManager().callEvent(event); + snipeData.getVoxelMessage().data(); + return true; + } else { + byte originalData = snipeData.getData(); + snipeData.setData((byte) 0); + SniperMaterialChangedEvent event = new SniperMaterialChangedEvent(this, toolId, new MaterialData(snipeData.getVoxelId(), originalData), new MaterialData(snipeData.getVoxelId(), snipeData.getData())); + Bukkit.getPluginManager().callEvent(event); + snipeData.getVoxelMessage().data(); + return true; + } + default: + break; + } + break; + case RIGHT_CLICK_AIR: + case RIGHT_CLICK_BLOCK: + if (clickedBlock != null) { + targetBlock = clickedBlock; + } else { + RangeBlockHelper rangeBlockHelper = snipeData.isRanged() ? new RangeBlockHelper(getPlayer(), world, snipeData.getRange()) : new RangeBlockHelper(getPlayer(), world); + targetBlock = snipeData.isRanged() ? rangeBlockHelper.getRangeBlock() : rangeBlockHelper.getTargetBlock(); + } + + switch (snipeAction) { + case ARROW: + if (targetBlock != null) { + int originalId = snipeData.getReplaceId(); + snipeData.setReplaceId(targetBlock.getTypeId()); + SniperReplaceMaterialChangedEvent event = new SniperReplaceMaterialChangedEvent(this, toolId, new MaterialData(originalId, snipeData.getReplaceData()), new MaterialData(snipeData.getReplaceId(), snipeData.getReplaceData())); + Bukkit.getPluginManager().callEvent(event); + snipeData.getVoxelMessage().replace(); + return true; + } else { + int originalId = snipeData.getReplaceId(); + snipeData.setReplaceId(0); + SniperReplaceMaterialChangedEvent event = new SniperReplaceMaterialChangedEvent(this, toolId, new MaterialData(originalId, snipeData.getReplaceData()), new MaterialData(snipeData.getReplaceId(), snipeData.getReplaceData())); + Bukkit.getPluginManager().callEvent(event); + snipeData.getVoxelMessage().replace(); + return true; + } + case GUNPOWDER: + if (targetBlock != null) { + byte originalData = snipeData.getReplaceData(); + snipeData.setReplaceData(targetBlock.getData()); + SniperReplaceMaterialChangedEvent event = new SniperReplaceMaterialChangedEvent(this, toolId, new MaterialData(snipeData.getReplaceId(), originalData), new MaterialData(snipeData.getReplaceId(), snipeData.getReplaceData())); + Bukkit.getPluginManager().callEvent(event); + snipeData.getVoxelMessage().replaceData(); + return true; + } else { + byte originalData = snipeData.getReplaceData(); + snipeData.setReplaceData((byte) 0); + SniperReplaceMaterialChangedEvent event = new SniperReplaceMaterialChangedEvent(this, toolId, new MaterialData(snipeData.getReplaceId(), originalData), new MaterialData(snipeData.getReplaceId(), snipeData.getReplaceData())); + Bukkit.getPluginManager().callEvent(event); + snipeData.getVoxelMessage().replaceData(); + return true; + } + default: + break; + } + break; + default: + return false; + } + } else { + Block targetBlock; + Block lastBlock; + SnipeAction snipeAction = sniperTool.getActionAssigned(itemInHand); + + switch (action) { + case RIGHT_CLICK_AIR: + case RIGHT_CLICK_BLOCK: + break; + default: + return false; + } + + if (clickedBlock != null) { + targetBlock = clickedBlock; + lastBlock = clickedBlock.getRelative(clickedFace); + if (lastBlock == null) { + getPlayer().sendMessage(ChatColor.RED + "Snipe target block must be visible."); + return true; + } + } else { + RangeBlockHelper rangeBlockHelper = snipeData.isRanged() ? new RangeBlockHelper(getPlayer(), world, snipeData.getRange()) : new RangeBlockHelper(getPlayer(), world); + targetBlock = snipeData.isRanged() ? rangeBlockHelper.getRangeBlock() : rangeBlockHelper.getTargetBlock(); + lastBlock = rangeBlockHelper.getLastBlock(); + + if (targetBlock == null || lastBlock == null) { + getPlayer().sendMessage(ChatColor.RED + "Snipe target block must be visible."); + return true; + } + } + +// if (sniperTool.getCurrentBrush() instanceof PerformBrush) { +// PerformBrush performerBrush = (PerformBrush) sniperTool.getCurrentBrush(); +// performerBrush.initP(snipeData); +// } +// +// boolean result = sniperTool.getCurrentBrush().perform(snipeAction, snipeData, targetBlock, lastBlock); +// if (result) { +// MetricsManager.increaseBrushUsage(sniperTool.getCurrentBrush().getName()); +// } +// return result; + TaskManager.IMP.async(new Runnable() { + @Override + public void run() { + if (sniperTool.getCurrentBrush() instanceof PerformBrush) { + PerformBrush performerBrush = (PerformBrush) sniperTool.getCurrentBrush(); + performerBrush.initP(snipeData); + world.commit(); + } + boolean result = sniperTool.getCurrentBrush().perform(snipeAction, snipeData, targetBlock, lastBlock); + if (result) { + MetricsManager.increaseBrushUsage(sniperTool.getCurrentBrush().getName()); + } + world.commit(); + } + }); + return true; + } + } + return false; + } + + public IBrush setBrush(String toolId, Class brush) { + if (!tools.containsKey(toolId)) { + return null; + } + + return tools.get(toolId).setCurrentBrush(brush); + } + + public IBrush getBrush(String toolId) { + if (!tools.containsKey(toolId)) { + return null; + } + + return tools.get(toolId).getCurrentBrush(); + } + + public IBrush previousBrush(String toolId) { + if (!tools.containsKey(toolId)) { + return null; + } + + return tools.get(toolId).previousBrush(); + } + + public boolean setTool(String toolId, SnipeAction action, Material itemInHand) { + for (Map.Entry entry : tools.entrySet()) { + if (entry.getKey() != toolId && entry.getValue().hasToolAssigned(itemInHand)) { + return false; + } + } + + if (!tools.containsKey(toolId)) { + SniperTool tool = new SniperTool(this); + tools.put(toolId, tool); + } + tools.get(toolId).assignAction(action, itemInHand); + return true; + } + + public void removeTool(String toolId, Material itemInHand) { + if (!tools.containsKey(toolId)) { + SniperTool tool = new SniperTool(this); + tools.put(toolId, tool); + } + tools.get(toolId).unassignAction(itemInHand); + } + + public void removeTool(String toolId) { + if (toolId == null) { + return; + } + tools.remove(toolId); + } + + public boolean isEnabled() { + return enabled; + } + + public void setEnabled(boolean enabled) { + this.enabled = enabled; + } + + public void storeUndo(Undo undo) { + if (VoxelSniper.getInstance().getVoxelSniperConfiguration().getUndoCacheSize() <= 0) { + return; + } + if (undo != null && undo.getSize() > 0) { + while (undoList.size() >= plugin.getVoxelSniperConfiguration().getUndoCacheSize()) { + this.undoList.pollLast(); + } + undoList.push(undo); + } + } + + public void undo() { + undo(1); + } + + public void undo(int amount) { + int sum = 0; + if (this.undoList.isEmpty()) { + getPlayer().sendMessage(ChatColor.GREEN + "There's nothing to undo."); + } else { + for (int x = 0; x < amount && !undoList.isEmpty(); x++) { + Undo undo = this.undoList.pop(); + if (undo != null) { + undo.undo(); + sum += undo.getSize(); + } else { + break; + } + } + getPlayer().sendMessage(ChatColor.GREEN + "Undo successful: " + ChatColor.RED + sum + ChatColor.GREEN + " blocks have been replaced."); + } + } + + public void reset(String toolId) { + SniperTool backup = tools.remove(toolId); + SniperTool newTool = new SniperTool(this); + + for (Map.Entry entry : backup.getActionTools().entrySet()) { + newTool.assignAction(entry.getKey(), entry.getValue()); + } + tools.put(toolId, newTool); + } + + public SnipeData getSnipeData(String toolId) { + return tools.containsKey(toolId) ? tools.get(toolId).getSnipeData() : null; + } + + public void displayInfo() { + String currentToolId = getCurrentToolId(); + SniperTool sniperTool = tools.get(currentToolId); + IBrush brush = sniperTool.getCurrentBrush(); + getPlayer().sendMessage("Current Tool: " + ((currentToolId != null) ? currentToolId : "Default Tool")); + if (brush == null) { + getPlayer().sendMessage("No brush selected."); + return; + } + brush.info(sniperTool.getMessageHelper()); + if (brush instanceof Performer) { + ((Performer) brush).showInfo(sniperTool.getMessageHelper()); + } + } + + public SniperTool getSniperTool(String toolId) { + return tools.get(toolId); + } + + public class SniperTool { + private BiMap actionTools = HashBiMap.create(); + private ClassToInstanceMap brushes = MutableClassToInstanceMap.create(); + private Class currentBrush; + private Class previousBrush; + private SnipeData snipeData; + private Message messageHelper; + + private SniperTool(Sniper owner) { + this(SnipeBrush.class, new SnipeData(owner)); + } + + private SniperTool(Class currentBrush, SnipeData snipeData) { + this.snipeData = snipeData; + messageHelper = new Message(snipeData); + snipeData.setVoxelMessage(messageHelper); + + IBrush newBrushInstance = instanciateBrush(currentBrush); + if (snipeData.owner().getPlayer().hasPermission(newBrushInstance.getPermissionNode())) { + brushes.put(currentBrush, newBrushInstance); + this.currentBrush = currentBrush; + } + } + + public boolean hasToolAssigned(Material material) { + return actionTools.containsValue(material); + } + + public SnipeAction getActionAssigned(Material itemInHand) { + return actionTools.inverse().get(itemInHand); + } + + public Material getToolAssigned(SnipeAction action) { + return actionTools.get(action); + } + + public void assignAction(SnipeAction action, Material itemInHand) { + actionTools.forcePut(action, itemInHand); + } + + public void unassignAction(Material itemInHand) { + actionTools.inverse().remove(itemInHand); + } + + public BiMap getActionTools() { + return ImmutableBiMap.copyOf(actionTools); + } + + public SnipeData getSnipeData() { + return snipeData; + } + + public Message getMessageHelper() { + return messageHelper; + } + + public IBrush getCurrentBrush() { + if (currentBrush == null) { + return null; + } + return brushes.getInstance(currentBrush); + } + + public IBrush setCurrentBrush(Class brush) { + Preconditions.checkNotNull(brush, "Can't set brush to null."); + IBrush brushInstance = brushes.get(brush); + if (brushInstance == null) { + brushInstance = instanciateBrush(brush); + Preconditions.checkNotNull(brushInstance, "Could not instanciate brush class."); + if (snipeData.owner().getPlayer().hasPermission(brushInstance.getPermissionNode())) { + brushes.put(brush, brushInstance); + previousBrush = currentBrush; + currentBrush = brush; + return brushInstance; + } + } + + if (snipeData.owner().getPlayer().hasPermission(brushInstance.getPermissionNode())) { + previousBrush = currentBrush; + currentBrush = brush; + return brushInstance; + } + + return null; + } + + public IBrush previousBrush() { + if (previousBrush == null) { + return null; + } + return setCurrentBrush(previousBrush); + } + + private IBrush instanciateBrush(Class brush) { + try { + return brush.newInstance(); + } catch (InstantiationException e) { + return null; + } catch (IllegalAccessException e) { + return null; + } + } + } + + public static Class inject() { + return Sniper.class; + } +} \ No newline at end of file diff --git a/bukkit0/src/main/java/com/thevoxelbox/voxelsniper/Undo.java b/bukkit0/src/main/java/com/thevoxelbox/voxelsniper/Undo.java new file mode 100644 index 00000000..c7b0178a --- /dev/null +++ b/bukkit0/src/main/java/com/thevoxelbox/voxelsniper/Undo.java @@ -0,0 +1,68 @@ +package com.thevoxelbox.voxelsniper; + +import com.boydti.fawe.bukkit.wrapper.AsyncWorld; +import com.google.common.collect.Sets; +import java.util.ArrayDeque; +import java.util.Set; +import org.bukkit.World; +import org.bukkit.block.Block; +import org.bukkit.block.BlockState; +import org.bukkit.util.Vector; + +/** + * Holds {@link BlockState}s that can be later on used to reset those block + * locations back to the recorded states. + */ +public class Undo { + + private final Set containing = Sets.newHashSet(); + private final ArrayDeque all; + + private World world; + + /** + * Default constructor of a Undo container. + */ + public Undo() { + all = new ArrayDeque(); + } + + /** + * Get the number of blocks in the collection. + * + * @return size of the Undo collection + */ + public int getSize() { + return containing.size(); + } + + /** + * Adds a Block to the collection. + * + * @param block Block to be added + */ + public void put(Block block) { + if (world == null) { + world = block.getWorld(); + } + Vector pos = block.getLocation().toVector(); + if (this.containing.contains(pos)) { + return; + } + this.containing.add(pos); + all.add(block.getState()); + } + + /** + * Set the blockstates of all recorded blocks back to the state when they + * were inserted. + */ + public void undo() { + for (BlockState blockState : all) { + blockState.update(true, false); + } + if (world instanceof AsyncWorld) { + ((AsyncWorld) world).commit(); + } + } +} \ No newline at end of file diff --git a/bukkit18/src/main/java/com/boydti/fawe/bukkit/v1_8/BukkitChunk_1_8.java b/bukkit18/src/main/java/com/boydti/fawe/bukkit/v1_8/BukkitChunk_1_8.java index 409cd0be..d52133a3 100644 --- a/bukkit18/src/main/java/com/boydti/fawe/bukkit/v1_8/BukkitChunk_1_8.java +++ b/bukkit18/src/main/java/com/boydti/fawe/bukkit/v1_8/BukkitChunk_1_8.java @@ -1,7 +1,7 @@ package com.boydti.fawe.bukkit.v1_8; import com.boydti.fawe.example.CharFaweChunk; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import org.bukkit.Bukkit; import org.bukkit.Chunk; @@ -19,6 +19,6 @@ public class BukkitChunk_1_8 extends CharFaweChunk { @Override public Chunk getNewChunk() { - return Bukkit.getWorld(getParent().world).getChunkAt(getX(), getZ()); + return Bukkit.getWorld(getParent().getWorld()).getChunkAt(getX(), getZ()); } } diff --git a/bukkit19/src/main/java/com/boydti/fawe/bukkit/v1_9/BukkitChunk_1_9.java b/bukkit19/src/main/java/com/boydti/fawe/bukkit/v1_9/BukkitChunk_1_9.java index e00cdeb1..2552fae2 100644 --- a/bukkit19/src/main/java/com/boydti/fawe/bukkit/v1_9/BukkitChunk_1_9.java +++ b/bukkit19/src/main/java/com/boydti/fawe/bukkit/v1_9/BukkitChunk_1_9.java @@ -2,7 +2,7 @@ package com.boydti.fawe.bukkit.v1_9; import com.boydti.fawe.FaweCache; import com.boydti.fawe.example.CharFaweChunk; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import java.lang.reflect.Constructor; import java.lang.reflect.Field; diff --git a/core/src/main/java/com/boydti/fawe/FaweAPI.java b/core/src/main/java/com/boydti/fawe/FaweAPI.java index 372434a5..1d128454 100644 --- a/core/src/main/java/com/boydti/fawe/FaweAPI.java +++ b/core/src/main/java/com/boydti/fawe/FaweAPI.java @@ -8,7 +8,7 @@ import com.boydti.fawe.object.PseudoRandom; import com.boydti.fawe.object.RegionWrapper; import com.boydti.fawe.object.changeset.DiskStorageHistory; import com.boydti.fawe.regions.FaweMaskManager; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.MemUtil; import com.boydti.fawe.util.SetQueue; @@ -106,7 +106,7 @@ public class FaweAPI { * - The FaweQueue skips a bit of overhead so it's faster
* - The WorldEdit EditSession can do a lot more
* Remember to enqueue it when you're done!
- * @see com.boydti.fawe.util.FaweQueue#enqueue() + * @see com.boydti.fawe.object.FaweQueue#enqueue() * @param worldName The name of the world * @param autoqueue If it should start dispatching before you enqueue it. * @return diff --git a/core/src/main/java/com/boydti/fawe/IFawe.java b/core/src/main/java/com/boydti/fawe/IFawe.java index 07a8c0a4..8f9517ac 100644 --- a/core/src/main/java/com/boydti/fawe/IFawe.java +++ b/core/src/main/java/com/boydti/fawe/IFawe.java @@ -4,7 +4,7 @@ import com.boydti.fawe.object.EditSessionWrapper; import com.boydti.fawe.object.FaweCommand; import com.boydti.fawe.object.FawePlayer; import com.boydti.fawe.regions.FaweMaskManager; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.TaskManager; import com.sk89q.worldedit.EditSession; import com.sk89q.worldedit.world.World; diff --git a/core/src/main/java/com/boydti/fawe/command/Cancel.java b/core/src/main/java/com/boydti/fawe/command/Cancel.java index 217c34e4..25ec15d1 100644 --- a/core/src/main/java/com/boydti/fawe/command/Cancel.java +++ b/core/src/main/java/com/boydti/fawe/command/Cancel.java @@ -3,7 +3,7 @@ package com.boydti.fawe.command; import com.boydti.fawe.config.BBC; import com.boydti.fawe.object.FaweCommand; import com.boydti.fawe.object.FawePlayer; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.SetQueue; import com.sk89q.worldedit.EditSession; import com.sk89q.worldedit.extension.platform.Actor; diff --git a/core/src/main/java/com/boydti/fawe/command/FixLighting.java b/core/src/main/java/com/boydti/fawe/command/FixLighting.java index df9cec60..07c55f96 100644 --- a/core/src/main/java/com/boydti/fawe/command/FixLighting.java +++ b/core/src/main/java/com/boydti/fawe/command/FixLighting.java @@ -4,7 +4,7 @@ import com.boydti.fawe.config.BBC; import com.boydti.fawe.object.FaweCommand; import com.boydti.fawe.object.FaweLocation; import com.boydti.fawe.object.FawePlayer; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.SetQueue; import com.sk89q.worldedit.Vector; import com.sk89q.worldedit.regions.CuboidRegion; diff --git a/core/src/main/java/com/boydti/fawe/example/CharFaweChunk.java b/core/src/main/java/com/boydti/fawe/example/CharFaweChunk.java index edde0c80..385cc413 100644 --- a/core/src/main/java/com/boydti/fawe/example/CharFaweChunk.java +++ b/core/src/main/java/com/boydti/fawe/example/CharFaweChunk.java @@ -3,7 +3,7 @@ package com.boydti.fawe.example; import com.boydti.fawe.FaweCache; import com.boydti.fawe.object.BytePair; import com.boydti.fawe.object.FaweChunk; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.MathMan; import com.sk89q.jnbt.CompoundTag; diff --git a/core/src/main/java/com/boydti/fawe/example/MappedFaweQueue.java b/core/src/main/java/com/boydti/fawe/example/MappedFaweQueue.java index de8424e1..495e29a4 100644 --- a/core/src/main/java/com/boydti/fawe/example/MappedFaweQueue.java +++ b/core/src/main/java/com/boydti/fawe/example/MappedFaweQueue.java @@ -6,7 +6,7 @@ import com.boydti.fawe.object.FaweChunk; import com.boydti.fawe.object.IntegerPair; import com.boydti.fawe.object.RunnableVal; import com.boydti.fawe.object.exception.FaweException; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.SetQueue; import com.boydti.fawe.util.TaskManager; @@ -29,8 +29,8 @@ public abstract class MappedFaweQueue extends FaweQueue { private LinkedBlockingDeque chunks = new LinkedBlockingDeque() { @Override public boolean add(FaweChunk o) { - if (progressTask != null) { - progressTask.run(ProgressType.QUEUE, size() + 1); + if (getProgressTask() != null) { + getProgressTask().run(ProgressType.QUEUE, size() + 1); } return super.add(o); } @@ -93,7 +93,7 @@ public abstract class MappedFaweQueue extends FaweQueue { if (impWorld != null) { return impWorld; } - return impWorld = getWorld(world); + return impWorld = getWorld(super.getWorldName()); } @Override @@ -275,8 +275,8 @@ public abstract class MappedFaweQueue extends FaweQueue { } public void runTasks() { - if (progressTask != null) { - progressTask.run(ProgressType.DONE, 1); + if (getProgressTask() != null) { + getProgressTask().run(ProgressType.DONE, 1); } ArrayDeque tmp = new ArrayDeque<>(tasks); tasks.clear(); @@ -306,9 +306,9 @@ public abstract class MappedFaweQueue extends FaweQueue { return false; } // Set blocks / entities / biome - if (progressTask != null) { - progressTask.run(ProgressType.QUEUE, chunks.size()); - progressTask.run(ProgressType.DISPATCH, ++dispatched); + if (getProgressTask() != null) { + getProgressTask().run(ProgressType.QUEUE, chunks.size()); + getProgressTask().run(ProgressType.DISPATCH, ++dispatched); } if (getChangeTask() != null) { if (!this.setComponents(fc, new RunnableVal() { diff --git a/core/src/main/java/com/boydti/fawe/example/NMSMappedFaweQueue.java b/core/src/main/java/com/boydti/fawe/example/NMSMappedFaweQueue.java index e44d1970..70906290 100644 --- a/core/src/main/java/com/boydti/fawe/example/NMSMappedFaweQueue.java +++ b/core/src/main/java/com/boydti/fawe/example/NMSMappedFaweQueue.java @@ -3,7 +3,7 @@ package com.boydti.fawe.example; import com.boydti.fawe.config.Settings; import com.boydti.fawe.object.FaweChunk; import com.boydti.fawe.object.exception.FaweException; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.TaskManager; import com.sk89q.jnbt.CompoundTag; import java.util.Collection; diff --git a/core/src/main/java/com/boydti/fawe/object/EditSessionWrapper.java b/core/src/main/java/com/boydti/fawe/object/EditSessionWrapper.java index a8ca64a2..63d7b2a3 100644 --- a/core/src/main/java/com/boydti/fawe/object/EditSessionWrapper.java +++ b/core/src/main/java/com/boydti/fawe/object/EditSessionWrapper.java @@ -1,7 +1,6 @@ package com.boydti.fawe.object; import com.boydti.fawe.object.changeset.FaweChangeSet; -import com.boydti.fawe.util.FaweQueue; import com.sk89q.worldedit.EditSession; import com.sk89q.worldedit.Vector; import com.sk89q.worldedit.blocks.BaseBlock; diff --git a/core/src/main/java/com/boydti/fawe/object/FaweChunk.java b/core/src/main/java/com/boydti/fawe/object/FaweChunk.java index d4bb21e5..80155f31 100644 --- a/core/src/main/java/com/boydti/fawe/object/FaweChunk.java +++ b/core/src/main/java/com/boydti/fawe/object/FaweChunk.java @@ -2,7 +2,6 @@ package com.boydti.fawe.object; import com.boydti.fawe.FaweCache; import com.boydti.fawe.config.Settings; -import com.boydti.fawe.util.FaweQueue; import com.sk89q.jnbt.CompoundTag; import com.sk89q.worldedit.world.biome.BaseBiome; import java.util.ArrayDeque; diff --git a/core/src/main/java/com/boydti/fawe/util/FaweQueue.java b/core/src/main/java/com/boydti/fawe/object/FaweQueue.java similarity index 74% rename from core/src/main/java/com/boydti/fawe/util/FaweQueue.java rename to core/src/main/java/com/boydti/fawe/object/FaweQueue.java index 4e452777..dcfac3bf 100644 --- a/core/src/main/java/com/boydti/fawe/util/FaweQueue.java +++ b/core/src/main/java/com/boydti/fawe/object/FaweQueue.java @@ -1,10 +1,11 @@ -package com.boydti.fawe.util; +package com.boydti.fawe.object; import com.boydti.fawe.Fawe; import com.boydti.fawe.config.BBC; -import com.boydti.fawe.object.FaweChunk; -import com.boydti.fawe.object.RunnableVal2; import com.boydti.fawe.object.exception.FaweException; +import com.boydti.fawe.util.MainUtil; +import com.boydti.fawe.util.MemUtil; +import com.boydti.fawe.util.SetQueue; import com.sk89q.jnbt.CompoundTag; import com.sk89q.worldedit.EditSession; import com.sk89q.worldedit.world.biome.BaseBiome; @@ -15,7 +16,17 @@ import java.util.concurrent.LinkedBlockingDeque; public abstract class FaweQueue { - public static enum ProgressType { + private final String world; + private LinkedBlockingDeque sessions; + private long modified = System.currentTimeMillis(); + private RunnableVal2 changeTask; + private RunnableVal2 progressTask; + + public FaweQueue(String world) { + this.world = world; + } + + public enum ProgressType { QUEUE, DISPATCH, DONE, @@ -28,24 +39,18 @@ public abstract class FaweQueue { ALL, } - public final String world; - public LinkedBlockingDeque sessions; - public long modified = System.currentTimeMillis(); - public RunnableVal2 changeTask; - public RunnableVal2 progressTask; - - public FaweQueue(String world) { - this.world = world; - } - public void addEditSession(EditSession session) { if (session == null) { return; } - if (this.sessions == null) { - sessions = new LinkedBlockingDeque<>(); + if (this.getSessions() == null) { + setSessions(new LinkedBlockingDeque()); } - sessions.add(session); + getSessions().add(session); + } + + public String getWorldName() { + return world; } /** @@ -55,11 +60,35 @@ public abstract class FaweQueue { * @param progressTask */ public void setProgressTracker(RunnableVal2 progressTask) { - this.progressTask = progressTask; + this.setProgressTask(progressTask); } public Set getEditSessions() { - return sessions == null ? new HashSet() : new HashSet<>(sessions); + return getSessions() == null ? new HashSet() : new HashSet<>(getSessions()); + } + + public LinkedBlockingDeque getSessions() { + return sessions; + } + + public void setSessions(LinkedBlockingDeque sessions) { + this.sessions = sessions; + } + + public long getModified() { + return modified; + } + + public void setModified(long modified) { + this.modified = modified; + } + + public RunnableVal2 getProgressTask() { + return progressTask; + } + + public void setProgressTask(RunnableVal2 progressTask) { + this.progressTask = progressTask; } public void setChangeTask(RunnableVal2 changeTask) { @@ -99,7 +128,7 @@ public abstract class FaweQueue { public int cancel() { clear(); int count = 0; - for (EditSession session : sessions) { + for (EditSession session : getSessions()) { if (session.cancel()) { count++; } diff --git a/core/src/main/java/com/boydti/fawe/object/HistoryExtent.java b/core/src/main/java/com/boydti/fawe/object/HistoryExtent.java index 67aefd6e..afee1fc5 100644 --- a/core/src/main/java/com/boydti/fawe/object/HistoryExtent.java +++ b/core/src/main/java/com/boydti/fawe/object/HistoryExtent.java @@ -2,7 +2,6 @@ package com.boydti.fawe.object; import com.boydti.fawe.FaweCache; import com.boydti.fawe.object.changeset.FaweChangeSet; -import com.boydti.fawe.util.FaweQueue; import com.sk89q.jnbt.CompoundTag; import com.sk89q.worldedit.EditSession; import com.sk89q.worldedit.Vector; diff --git a/core/src/main/java/com/boydti/fawe/object/MaskedFaweQueue.java b/core/src/main/java/com/boydti/fawe/object/MaskedFaweQueue.java new file mode 100644 index 00000000..2fb4cc4d --- /dev/null +++ b/core/src/main/java/com/boydti/fawe/object/MaskedFaweQueue.java @@ -0,0 +1,45 @@ +package com.boydti.fawe.object; + +import com.boydti.fawe.util.DelegateFaweQueue; +import com.boydti.fawe.util.WEManager; +import com.sk89q.jnbt.CompoundTag; +import com.sk89q.worldedit.world.biome.BaseBiome; + +public class MaskedFaweQueue extends DelegateFaweQueue { + private final RegionWrapper[] mask; + + public MaskedFaweQueue(FaweQueue parent, RegionWrapper[] mask) { + super(parent); + this.mask = mask; + } + + @Override + public void setTile(int x, int y, int z, CompoundTag tag) { + if (WEManager.IMP.maskContains(mask, x, z)) { + super.setTile(x, y, z, tag); + } + } + + @Override + public void setEntity(int x, int y, int z, CompoundTag tag) { + if (WEManager.IMP.maskContains(mask, x, z)) { + super.setEntity(x, y, z, tag); + } + } + + @Override + public boolean setBlock(int x, int y, int z, short id, byte data) { + if (WEManager.IMP.maskContains(mask, x, z)) { + return super.setBlock(x, y, z, id, data); + } + return false; + } + + @Override + public boolean setBiome(int x, int z, BaseBiome biome) { + if (WEManager.IMP.maskContains(mask, x, z)) { + return super.setBiome(x, z, biome); + } + return false; + } +} diff --git a/core/src/main/java/com/boydti/fawe/object/changeset/CPUOptimizedChangeSet.java b/core/src/main/java/com/boydti/fawe/object/changeset/CPUOptimizedChangeSet.java index 84916278..f7186546 100644 --- a/core/src/main/java/com/boydti/fawe/object/changeset/CPUOptimizedChangeSet.java +++ b/core/src/main/java/com/boydti/fawe/object/changeset/CPUOptimizedChangeSet.java @@ -3,7 +3,7 @@ package com.boydti.fawe.object.changeset; import com.boydti.fawe.object.FaweChunk; import com.boydti.fawe.object.RunnableVal2; import com.boydti.fawe.object.change.MutableChunkChange; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.sk89q.jnbt.CompoundTag; import com.sk89q.worldedit.history.change.Change; import com.sk89q.worldedit.world.World; diff --git a/core/src/main/java/com/boydti/fawe/object/changeset/FaweChangeSet.java b/core/src/main/java/com/boydti/fawe/object/changeset/FaweChangeSet.java index d520edfc..25e23be5 100644 --- a/core/src/main/java/com/boydti/fawe/object/changeset/FaweChangeSet.java +++ b/core/src/main/java/com/boydti/fawe/object/changeset/FaweChangeSet.java @@ -5,7 +5,7 @@ import com.boydti.fawe.FaweCache; import com.boydti.fawe.object.BytePair; import com.boydti.fawe.object.FaweChunk; import com.boydti.fawe.object.RunnableVal2; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.TaskManager; import com.sk89q.jnbt.CompoundTag; diff --git a/core/src/main/java/com/boydti/fawe/object/extent/FastWorldEditExtent.java b/core/src/main/java/com/boydti/fawe/object/extent/FastWorldEditExtent.java index 1e4fa0fc..7a57632a 100644 --- a/core/src/main/java/com/boydti/fawe/object/extent/FastWorldEditExtent.java +++ b/core/src/main/java/com/boydti/fawe/object/extent/FastWorldEditExtent.java @@ -1,7 +1,7 @@ package com.boydti.fawe.object.extent; import com.boydti.fawe.FaweCache; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.ReflectionUtils; import com.sk89q.jnbt.CompoundTag; diff --git a/core/src/main/java/com/boydti/fawe/object/progress/DefaultProgressTracker.java b/core/src/main/java/com/boydti/fawe/object/progress/DefaultProgressTracker.java index 854b70f1..885ab7bf 100644 --- a/core/src/main/java/com/boydti/fawe/object/progress/DefaultProgressTracker.java +++ b/core/src/main/java/com/boydti/fawe/object/progress/DefaultProgressTracker.java @@ -4,7 +4,7 @@ import com.boydti.fawe.config.BBC; import com.boydti.fawe.config.Settings; import com.boydti.fawe.object.FawePlayer; import com.boydti.fawe.object.RunnableVal2; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.StringMan; import com.boydti.fawe.util.TaskManager; diff --git a/core/src/main/java/com/boydti/fawe/util/DelegateFaweQueue.java b/core/src/main/java/com/boydti/fawe/util/DelegateFaweQueue.java new file mode 100644 index 00000000..40589414 --- /dev/null +++ b/core/src/main/java/com/boydti/fawe/util/DelegateFaweQueue.java @@ -0,0 +1,211 @@ +package com.boydti.fawe.util; + +import com.boydti.fawe.object.FaweChunk; +import com.boydti.fawe.object.FaweQueue; +import com.boydti.fawe.object.RunnableVal2; +import com.boydti.fawe.object.exception.FaweException; +import com.sk89q.jnbt.CompoundTag; +import com.sk89q.worldedit.EditSession; +import com.sk89q.worldedit.world.biome.BaseBiome; +import java.util.Set; +import java.util.UUID; +import java.util.concurrent.LinkedBlockingDeque; + +public class DelegateFaweQueue extends FaweQueue { + private final FaweQueue parent; + + public DelegateFaweQueue(FaweQueue parent) { + super(parent.getWorldName()); + this.parent = parent; + } + + @Override + public String getWorldName() { + return parent.getWorldName(); + } + + @Override + public void addEditSession(EditSession session) { + parent.addEditSession(session); + } + + @Override + public void setProgressTracker(RunnableVal2 progressTask) { + parent.setProgressTracker(progressTask); + } + + @Override + public Set getEditSessions() { + return parent.getEditSessions(); + } + + @Override + public LinkedBlockingDeque getSessions() { + return parent.getSessions(); + } + + @Override + public void setSessions(LinkedBlockingDeque sessions) { + parent.setSessions(sessions); + } + + @Override + public long getModified() { + return parent.getModified(); + } + + @Override + public void setModified(long modified) { + parent.setModified(modified); + } + + @Override + public RunnableVal2 getProgressTask() { + return parent.getProgressTask(); + } + + @Override + public void setProgressTask(RunnableVal2 progressTask) { + parent.setProgressTask(progressTask); + } + + @Override + public void setChangeTask(RunnableVal2 changeTask) { + parent.setChangeTask(changeTask); + } + + @Override + public RunnableVal2 getChangeTask() { + return parent.getChangeTask(); + } + + @Override + public void optimize() { + parent.optimize(); + } + + @Override + public boolean setBlock(int x, int y, int z, short id, byte data) { + return parent.setBlock(x, y, z, id, data); + } + + @Override + public void setTile(int x, int y, int z, CompoundTag tag) { + parent.setTile(x, y, z, tag); + } + + @Override + public void setEntity(int x, int y, int z, CompoundTag tag) { + parent.setEntity(x, y, z, tag); + } + + @Override + public void removeEntity(int x, int y, int z, UUID uuid) { + parent.removeEntity(x, y, z, uuid); + } + + @Override + public boolean setBiome(int x, int z, BaseBiome biome) { + return parent.setBiome(x, z, biome); + } + + @Override + public FaweChunk getFaweChunk(int x, int z) { + return parent.getFaweChunk(x, z); + } + + @Override + public void setChunk(FaweChunk chunk) { + parent.setChunk(chunk); + } + + @Override + public boolean fixLighting(FaweChunk chunk, RelightMode mode) { + return parent.fixLighting(chunk, mode); + } + + @Override + public boolean isChunkLoaded(int x, int z) { + return parent.isChunkLoaded(x, z); + } + + @Override + public boolean regenerateChunk(int x, int z) { + return parent.regenerateChunk(x, z); + } + + @Override + public void startSet(boolean parallel) { + parent.startSet(parallel); + } + + @Override + public void endSet(boolean parallel) { + parent.endSet(parallel); + } + + @Override + public int cancel() { + return parent.cancel(); + } + + @Override + public FaweChunk next() { + return parent.next(); + } + + @Override + public void saveMemory() { + parent.saveMemory(); + } + + @Override + public void sendChunk(FaweChunk chunk, RelightMode mode) { + parent.sendChunk(chunk, mode); + } + + @Override + public void clear() { + parent.clear(); + } + + @Override + public void addNotifyTask(int x, int z, Runnable runnable) { + parent.addNotifyTask(x, z, runnable); + } + + @Override + public void addNotifyTask(Runnable runnable) { + parent.addNotifyTask(runnable); + } + + @Override + public int getCombinedId4Data(int x, int y, int z) throws FaweException.FaweChunkLoadException { + return parent.getCombinedId4Data(x, y, z); + } + + @Override + public CompoundTag getTileEntity(int x, int y, int z) throws FaweException.FaweChunkLoadException { + return parent.getTileEntity(x, y, z); + } + + @Override + public int getCombinedId4Data(int x, int y, int z, int def) { + return parent.getCombinedId4Data(x, y, z, def); + } + + @Override + public int getCombinedId4DataDebug(int x, int y, int z, int def, EditSession session) { + return parent.getCombinedId4DataDebug(x, y, z, def, session); + } + + @Override + public int size() { + return parent.size(); + } + + @Override + public void enqueue() { + parent.enqueue(); + } +} diff --git a/core/src/main/java/com/boydti/fawe/util/SetQueue.java b/core/src/main/java/com/boydti/fawe/util/SetQueue.java index 77c3fc00..eb5e281a 100644 --- a/core/src/main/java/com/boydti/fawe/util/SetQueue.java +++ b/core/src/main/java/com/boydti/fawe/util/SetQueue.java @@ -3,6 +3,7 @@ package com.boydti.fawe.util; import com.boydti.fawe.Fawe; import com.boydti.fawe.config.Settings; import com.boydti.fawe.object.FaweChunk; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.object.RunnableVal2; import java.util.ArrayList; import java.util.List; @@ -178,7 +179,7 @@ public class SetQueue { while (activeQueues.size() > 0) { FaweQueue queue = activeQueues.peek(); if (queue != null && queue.size() > 0) { - queue.modified = System.currentTimeMillis(); + queue.setModified(System.currentTimeMillis()); return queue; } else { activeQueues.poll(); @@ -190,10 +191,10 @@ public class SetQueue { long now = System.currentTimeMillis(); if (lastSuccess != 0) { for (FaweQueue queue : tmp) { - if (queue != null && queue.size() > 0 && now - queue.modified > Settings.QUEUE_MAX_WAIT) { - queue.modified = now; + if (queue != null && queue.size() > 0 && now - queue.getModified() > Settings.QUEUE_MAX_WAIT) { + queue.setModified(now); return queue; - } else if (now - queue.modified > Settings.QUEUE_DISCARD_AFTER) { + } else if (now - queue.getModified() > Settings.QUEUE_DISCARD_AFTER) { inactiveQueues.remove(queue); } } @@ -207,7 +208,7 @@ public class SetQueue { if (total > Settings.QUEUE_SIZE) { for (FaweQueue queue : tmp) { if (queue != null && queue.size() > 0) { - queue.modified = System.currentTimeMillis(); + queue.setModified(System.currentTimeMillis()); return queue; } } diff --git a/core/src/main/java/com/boydti/fawe/wrappers/WorldWrapper.java b/core/src/main/java/com/boydti/fawe/wrappers/WorldWrapper.java index ad7c3d5c..57218340 100644 --- a/core/src/main/java/com/boydti/fawe/wrappers/WorldWrapper.java +++ b/core/src/main/java/com/boydti/fawe/wrappers/WorldWrapper.java @@ -4,7 +4,7 @@ import com.boydti.fawe.FaweCache; import com.boydti.fawe.object.RunnableVal; import com.boydti.fawe.object.changeset.FaweChangeSet; import com.boydti.fawe.object.extent.FaweRegionExtent; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.TaskManager; import com.sk89q.worldedit.BlockVector2D; diff --git a/core/src/main/java/com/sk89q/worldedit/EditSession.java b/core/src/main/java/com/sk89q/worldedit/EditSession.java index b4cc2490..b09a1621 100644 --- a/core/src/main/java/com/sk89q/worldedit/EditSession.java +++ b/core/src/main/java/com/sk89q/worldedit/EditSession.java @@ -41,7 +41,7 @@ import com.boydti.fawe.object.extent.MemoryCheckingExtent; import com.boydti.fawe.object.extent.NullExtent; import com.boydti.fawe.object.extent.ProcessedWEExtent; import com.boydti.fawe.object.progress.DefaultProgressTracker; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.MemUtil; import com.boydti.fawe.util.Perm; diff --git a/core/src/main/java/com/sk89q/worldedit/LocalSession.java b/core/src/main/java/com/sk89q/worldedit/LocalSession.java index 6b7fbe2f..492c2df2 100644 --- a/core/src/main/java/com/sk89q/worldedit/LocalSession.java +++ b/core/src/main/java/com/sk89q/worldedit/LocalSession.java @@ -23,7 +23,7 @@ import com.boydti.fawe.config.Settings; import com.boydti.fawe.object.changeset.FaweChangeSet; import com.boydti.fawe.object.changeset.FaweStreamChangeSet; import com.boydti.fawe.object.clipboard.DiskOptimizedClipboard; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.SetQueue; import com.boydti.fawe.util.TaskManager; diff --git a/core/src/main/java/com/sk89q/worldedit/command/composition/SelectionCommand.java b/core/src/main/java/com/sk89q/worldedit/command/composition/SelectionCommand.java index 61301f9b..0046e763 100644 --- a/core/src/main/java/com/sk89q/worldedit/command/composition/SelectionCommand.java +++ b/core/src/main/java/com/sk89q/worldedit/command/composition/SelectionCommand.java @@ -25,7 +25,7 @@ import com.boydti.fawe.object.FawePlayer; import com.boydti.fawe.object.NullChangeSet; import com.boydti.fawe.object.RegionWrapper; import com.boydti.fawe.object.RunnableVal; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.WEManager; import com.google.common.base.Joiner; diff --git a/forge1710/src/main/java/com/boydti/fawe/forge/FaweForge.java b/forge1710/src/main/java/com/boydti/fawe/forge/FaweForge.java index 51a339b9..2c418c70 100644 --- a/forge1710/src/main/java/com/boydti/fawe/forge/FaweForge.java +++ b/forge1710/src/main/java/com/boydti/fawe/forge/FaweForge.java @@ -8,7 +8,7 @@ import com.boydti.fawe.object.EditSessionWrapper; import com.boydti.fawe.object.FaweCommand; import com.boydti.fawe.object.FawePlayer; import com.boydti.fawe.regions.FaweMaskManager; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.TaskManager; import com.boydti.fawe.wrappers.WorldWrapper; diff --git a/forge1710/src/main/java/com/boydti/fawe/forge/v0/ForgeChunk_All.java b/forge1710/src/main/java/com/boydti/fawe/forge/v0/ForgeChunk_All.java index bba53893..9f1a86a9 100644 --- a/forge1710/src/main/java/com/boydti/fawe/forge/v0/ForgeChunk_All.java +++ b/forge1710/src/main/java/com/boydti/fawe/forge/v0/ForgeChunk_All.java @@ -2,7 +2,7 @@ package com.boydti.fawe.forge.v0; import com.boydti.fawe.FaweCache; import com.boydti.fawe.example.CharFaweChunk; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import net.minecraft.world.World; import net.minecraft.world.chunk.Chunk; diff --git a/forge189/src/main/java/com/boydti/fawe/forge/FaweForge.java b/forge189/src/main/java/com/boydti/fawe/forge/FaweForge.java index d1a31210..380860aa 100644 --- a/forge189/src/main/java/com/boydti/fawe/forge/FaweForge.java +++ b/forge189/src/main/java/com/boydti/fawe/forge/FaweForge.java @@ -8,7 +8,7 @@ import com.boydti.fawe.object.EditSessionWrapper; import com.boydti.fawe.object.FaweCommand; import com.boydti.fawe.object.FawePlayer; import com.boydti.fawe.regions.FaweMaskManager; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.TaskManager; import com.boydti.fawe.wrappers.WorldWrapper; diff --git a/forge189/src/main/java/com/boydti/fawe/forge/v0/ForgeChunk_All.java b/forge189/src/main/java/com/boydti/fawe/forge/v0/ForgeChunk_All.java index b9b0a64a..c80186b6 100644 --- a/forge189/src/main/java/com/boydti/fawe/forge/v0/ForgeChunk_All.java +++ b/forge189/src/main/java/com/boydti/fawe/forge/v0/ForgeChunk_All.java @@ -1,7 +1,7 @@ package com.boydti.fawe.forge.v0; import com.boydti.fawe.example.CharFaweChunk; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import net.minecraft.world.World; import net.minecraft.world.chunk.Chunk; diff --git a/sponge/src/main/java/com/boydti/fawe/sponge/FaweSponge.java b/sponge/src/main/java/com/boydti/fawe/sponge/FaweSponge.java index 97534372..3aa3cf1a 100644 --- a/sponge/src/main/java/com/boydti/fawe/sponge/FaweSponge.java +++ b/sponge/src/main/java/com/boydti/fawe/sponge/FaweSponge.java @@ -11,7 +11,7 @@ import com.boydti.fawe.object.FawePlayer; import com.boydti.fawe.regions.FaweMaskManager; import com.boydti.fawe.sponge.v1_8.SpongeQueue_1_8; import com.boydti.fawe.sponge.v1_8.SpongeQueue_ALL; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import com.boydti.fawe.util.MainUtil; import com.boydti.fawe.util.TaskManager; import com.sk89q.worldedit.EditSession; diff --git a/sponge/src/main/java/com/boydti/fawe/sponge/v1_8/SpongeChunk_1_8.java b/sponge/src/main/java/com/boydti/fawe/sponge/v1_8/SpongeChunk_1_8.java index 07b7355d..53ce5703 100644 --- a/sponge/src/main/java/com/boydti/fawe/sponge/v1_8/SpongeChunk_1_8.java +++ b/sponge/src/main/java/com/boydti/fawe/sponge/v1_8/SpongeChunk_1_8.java @@ -1,7 +1,7 @@ package com.boydti.fawe.sponge.v1_8; import com.boydti.fawe.example.CharFaweChunk; -import com.boydti.fawe.util.FaweQueue; +import com.boydti.fawe.object.FaweQueue; import org.spongepowered.api.Sponge; import org.spongepowered.api.world.World; @@ -13,7 +13,7 @@ public class SpongeChunk_1_8 extends CharFaweChunk