Fix commands & support regeneration

pom.xml

@@ -4,7 +4,7 @@
 	<modelVersion>4.0.0</modelVersion>
 	<groupId>bytecode.ninja</groupId>
 	<artifactId>Iris</artifactId>
-	<version>1.0.6</version>
+	<version>1.0.9</version>
 	<name>Iris</name>
 	<properties>
 		<skip.copy>false</skip.copy>

src/main/java/com/volmit/iris/Iris.java

@@ -38,10 +38,13 @@ import com.volmit.iris.util.IO;
 import com.volmit.iris.util.IrisLock;
 import com.volmit.iris.util.J;
 import com.volmit.iris.util.KList;
+import com.volmit.iris.util.M;
 import com.volmit.iris.util.MortarPlugin;
 import com.volmit.iris.util.NastyRunnable;
 import com.volmit.iris.util.Permission;
+import com.volmit.iris.util.Queue;
 import com.volmit.iris.util.RNG;
+import com.volmit.iris.util.ShurikenQueue;
 
 public class Iris extends MortarPlugin
 {
@@ -57,6 +60,7 @@ public class Iris extends MortarPlugin
 	public static String nmsTag = findNMSTag();
 	public static MultiverseCoreLink linkMultiverseCore;
 	private static IrisLock lock = new IrisLock("Iris");
+	private static final Queue<Runnable> syncJobs = new ShurikenQueue<>();
 	public static boolean customModels = doesSupportCustomModels();
 	public static boolean awareEntities = doesSupportAwareness();
 	public static boolean biome3d = doesSupport3DBiomes();
@@ -156,9 +160,44 @@ public class Iris extends MortarPlugin
 		J.a(() -> IO.delete(getTemp()));
 		J.a(() -> bstats());
 		J.s(this::splash, 20);
+		J.sr(() -> tickQueue(syncJobs), 0);
 		super.onEnable();
 	}
 
+	public static void sq(Runnable r)
+	{
+		synchronized(syncJobs)
+		{
+			syncJobs.queue(r);
+		}
+	}
+
+	private void tickQueue(Queue<Runnable> q)
+	{
+		synchronized(q)
+		{
+			if(!q.hasNext())
+			{
+				return;
+			}
+
+			long ms = M.ms();
+
+			while(q.hasNext() && M.ms() - ms < 25)
+			{
+				try
+				{
+					q.next().run();
+				}
+
+				catch(Throwable e)
+				{
+					e.printStackTrace();
+				}
+			}
+		}
+	}
+
 	private void bstats()
 	{
 		new Metrics(this, 8757);
@@ -400,4 +439,17 @@ public class Iris extends MortarPlugin
 			}
 		}, RNG.r.i(100, 1200));
 	}
+
+	public static String jobCount()
+	{
+		return syncJobs.size() + "S";
+	}
+
+	public static void clearQueues()
+	{
+		synchronized(syncJobs)
+		{
+			syncJobs.clear();
+		}
+	}
 }

src/main/java/com/volmit/iris/IrisSettings.java

@@ -34,6 +34,10 @@ public class IrisSettings
 	@Desc("Compress parallax data in memory to reduce memory usage in exchange for more cpu usage.")
 	public boolean parallaxCompression = true;
 
+	@DontObfuscate
+	@Desc("Uses a lot of cpu and slows down hotloading")
+	public boolean regenerateLoadedChunksOnHotload = false;
+
 	@DontObfuscate
 	@Desc("Useful information when creating iris worlds. Shows object loads & more.")
 	public boolean verbose = false;

src/main/java/com/volmit/iris/command/CommandIris.java

@@ -34,6 +34,9 @@ public class CommandIris extends MortarCommand
 	@Command
 	private CommandIrisLMM lmm;
 
+	@Command
+	private CommandIrisRegen regen;
+
 	@Command
 	private CommandIrisPregen pregen;
 

src/main/java/com/volmit/iris/command/CommandIrisRegen.java

@@ -0,0 +1,72 @@
+package com.volmit.iris.command;
+
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.gen.provisions.ProvisionBukkit;
+import com.volmit.iris.gen.scaffold.Provisioned;
+import com.volmit.iris.util.MortarCommand;
+import com.volmit.iris.util.MortarSender;
+import com.volmit.iris.util.Spiraler;
+
+public class CommandIrisRegen extends MortarCommand
+{
+	public CommandIrisRegen()
+	{
+		super("regenerate", "regen", "rg");
+		setDescription("Regenerate chunks");
+		requiresPermission(Iris.perm.studio);
+		setCategory("Regen");
+	}
+
+	@Override
+	public boolean handle(MortarSender sender, String[] args)
+	{
+		if(sender.isPlayer())
+		{
+			Player p = sender.player();
+			World world = p.getWorld();
+			if(!(world.getGenerator() instanceof ProvisionBukkit))
+			{
+				sender.sendMessage("You must be in an iris world.");
+				return true;
+			}
+
+			Provisioned pr = (Provisioned) world.getGenerator();
+			pr.clearRegeneratedLists();
+			if(args.length == 0)
+			{
+				sender.sendMessage("Regenerating your chunk");
+				pr.regenerate(p.getLocation().getChunk().getX(), p.getLocation().getChunk().getZ());
+				return true;
+			}
+
+			try
+			{
+				int m = Integer.valueOf(args[0]);
+				sender.sendMessage("Regenerating " + (m * m) + " Chunks Surrounding you");
+				new Spiraler(m, m, (a, b) -> pr.regenerate(a + p.getLocation().getChunk().getX(), b + p.getLocation().getChunk().getZ())).drain();
+			}
+
+			catch(Throwable e)
+			{
+				sender.sendMessage("/iris regen [SIZE]");
+			}
+			return true;
+		}
+
+		else
+		{
+			sender.sendMessage("Players only.");
+		}
+
+		return true;
+	}
+
+	@Override
+	protected String getArgsUsage()
+	{
+		return "/iris regen [size]";
+	}
+}

src/main/java/com/volmit/iris/edit/BlockEditor.java

@@ -2,6 +2,7 @@ package com.volmit.iris.edit;
 
 import java.io.Closeable;
 
+import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
 
 public interface BlockEditor extends Closeable
@@ -11,7 +12,15 @@ public interface BlockEditor extends Closeable
 	public void set(int x, int y, int z, BlockData d);
 
 	public BlockData get(int x, int y, int z);
+	
+	public void setBiome(int x, int z, Biome b);
+
+	public void setBiome(int x, int y, int z, Biome b);
 
 	@Override
 	public void close();
+
+	public Biome getBiome(int x, int y, int z);
+
+	public Biome getBiome(int x, int z);
 }

src/main/java/com/volmit/iris/edit/BukkitBlockEditor.java

@@ -1,6 +1,7 @@
 package com.volmit.iris.edit;
 
 import org.bukkit.World;
+import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
 
 import com.volmit.iris.util.M;
@@ -37,4 +38,30 @@ public class BukkitBlockEditor implements BlockEditor
 	{
 		return M.ms();
 	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public void setBiome(int x, int z, Biome b)
+	{
+		world.setBiome(x, z, b);
+	}
+
+	@Override
+	public void setBiome(int x, int y, int z, Biome b)
+	{
+		world.setBiome(x, y, z, b);
+	}
+
+	@Override
+	public Biome getBiome(int x, int y, int z)
+	{
+		return world.getBiome(x, y, z);
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public Biome getBiome(int x, int z)
+	{
+		return world.getBiome(x, z);
+	}
 }

src/main/java/com/volmit/iris/edit/WEBlockEditor.java

@@ -1,12 +1,15 @@
 package com.volmit.iris.edit;
 
 import org.bukkit.World;
+import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
 
 import com.sk89q.worldedit.EditSession;
 import com.sk89q.worldedit.WorldEdit;
 import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.math.BlockVector2;
 import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.world.biome.BiomeTypes;
 import com.volmit.iris.util.M;
 
 public class WEBlockEditor implements BlockEditor
@@ -22,12 +25,21 @@ public class WEBlockEditor implements BlockEditor
 		es = WorldEdit.getInstance().newEditSessionBuilder().world(BukkitAdapter.adapt(world)).build();
 	}
 
+	@SuppressWarnings("deprecation")
+	public void setBiome(int x, int z, Biome b)
+	{
+		es.setBiome(BlockVector2.at(x, z), BiomeTypes.get("minecraft:" + b.name().toLowerCase()));
+	}
+
+	public void setBiome(int x, int y, int z, Biome b)
+	{
+		es.setBiome(BlockVector3.at(x, y, z), BiomeTypes.get("minecraft:" + b.name().toLowerCase()));
+	}
+
 	@Override
 	public void set(int x, int y, int z, BlockData d)
 	{
-		last = M.ms();
 		es.rawSetBlock(BlockVector3.at(x, y, z), BukkitAdapter.adapt(d));
-		world.getBlockAt(x, y, z).setBlockData(d, false);
 	}
 
 	@Override
@@ -48,4 +60,17 @@ public class WEBlockEditor implements BlockEditor
 	{
 		return last;
 	}
+
+	@Override
+	public Biome getBiome(int x, int y, int z)
+	{
+		return world.getBiome(x, y, z);
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public Biome getBiome(int x, int z)
+	{
+		return world.getBiome(x, z);
+	}
 }

src/main/java/com/volmit/iris/gen/ContextualTerrainProvider.java

@@ -26,6 +26,7 @@ import com.volmit.iris.gen.atomics.AtomicCache;
 import com.volmit.iris.gen.atomics.AtomicMulticache;
 import com.volmit.iris.gen.scaffold.IrisContext;
 import com.volmit.iris.gen.scaffold.IrisMetrics;
+import com.volmit.iris.gen.scaffold.Provisioned;
 import com.volmit.iris.gen.scaffold.TerrainChunk;
 import com.volmit.iris.gen.scaffold.TerrainProvider;
 import com.volmit.iris.gen.scaffold.TerrainTarget;
@@ -54,6 +55,7 @@ import lombok.EqualsAndHashCode;
 @EqualsAndHashCode(callSuper = false)
 public abstract class ContextualTerrainProvider implements TerrainProvider, Listener
 {
+	private Provisioned provisioner;
 	private KList<BlockPosition> noLoot;
 	private BlockPosition allowLoot;
 	private AtomicMulticache cache;

src/main/java/com/volmit/iris/gen/IrisTerrainProvider.java

@@ -3,6 +3,7 @@ package com.volmit.iris.gen;
 import java.awt.Color;
 import java.io.IOException;
 import java.util.Random;
+import java.util.function.Function;
 
 import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
@@ -12,6 +13,7 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.block.BlockDropItemEvent;
 import org.bukkit.event.entity.EntitySpawnEvent;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.BlockVector;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.IrisSettings;
@@ -442,6 +444,32 @@ public class IrisTerrainProvider extends SkyTerrainProvider implements IrisConte
 		trySpawn(dim.getEntityInitialSpawns(), c, rng);
 	}
 
+	@Override
+	public BlockVector computeSpawn(Function<BlockVector, Boolean> allowed)
+	{
+		RNG r = new RNG(489886222).nextParallelRNG(-293667771);
+		int x = 0;
+		int y = 0;
+		int z = 0;
+
+		for(int i = 0; i < 64; i++)
+		{
+			x = r.i(-64 - (i * 2), 64 + (i * 2));
+			z = r.i(-64 - (i * 2), 64 + (i * 2));
+			y = (int) Math.round(getTerrainHeight(x, z));
+			BlockVector b = new BlockVector(x, y, z);
+
+			if(y <= getFluidHeight() || !allowed.apply(b))
+			{
+				continue;
+			}
+
+			return b;
+		}
+
+		return new BlockVector(x, y, z);
+	}
+
 	@Override
 	protected void onSpawn(EntitySpawnEvent e)
 	{
@@ -546,7 +574,7 @@ public class IrisTerrainProvider extends SkyTerrainProvider implements IrisConte
 		{
 			return false;
 		}
-		
+
 		return getDimension().isVanillaCaves();
 	}
 
@@ -557,21 +585,19 @@ public class IrisTerrainProvider extends SkyTerrainProvider implements IrisConte
 		{
 			return false;
 		}
-		
+
 		return getDimension().isVanillaStructures();
 	}
 
 	@Override
 	public boolean shouldGenerateMobs()
 	{
-		// TODO Auto-generated method stub
 		return false;
 	}
 
 	@Override
 	public boolean shouldGenerateDecorations()
 	{
-		// TODO Auto-generated method stub
-		return false;
+		return true;
 	}
 }

src/main/java/com/volmit/iris/gen/ParallaxTerrainProvider.java

@@ -3,9 +3,13 @@ package com.volmit.iris.gen;
 import java.io.IOException;
 import java.util.List;
 
+import org.bukkit.Chunk;
+import org.bukkit.World;
 import org.bukkit.block.data.BlockData;
+import org.bukkit.entity.Player;
 import org.bukkit.generator.BlockPopulator;
 
+import com.volmit.iris.IrisSettings;
 import com.volmit.iris.gen.atomics.AtomicSliver;
 import com.volmit.iris.gen.atomics.AtomicSliverMap;
 import com.volmit.iris.gen.atomics.AtomicWorldData;
@@ -33,6 +37,7 @@ import com.volmit.iris.util.KList;
 import com.volmit.iris.util.KMap;
 import com.volmit.iris.util.PrecisionStopwatch;
 import com.volmit.iris.util.RNG;
+import com.volmit.iris.util.Spiraler;
 
 import lombok.Data;
 import lombok.EqualsAndHashCode;
@@ -96,6 +101,24 @@ public abstract class ParallaxTerrainProvider extends TopographicTerrainProvider
 		getData().preferFolder(getDimension().getLoadFile().getParentFile().getParentFile().getName());
 		super.onHotload();
 		setCacheID(RNG.r.simax());
+
+		if(IrisSettings.get().isRegenerateLoadedChunksOnHotload())
+		{
+			World w = getTarget().getRealWorld();
+
+			if(w != null)
+			{
+				for(Player i : w.getPlayers())
+				{
+					new Spiraler(10, 10, (a, b) -> getProvisioner().regenerate(i.getLocation().getChunk().getX() + a, i.getLocation().getChunk().getZ() + b)).drain();
+				}
+
+				for(Chunk i : w.getLoadedChunks())
+				{
+					getProvisioner().regenerate(i.getX(), i.getZ());
+				}
+			}
+		}
 	}
 
 	@Override
@@ -174,6 +197,27 @@ public abstract class ParallaxTerrainProvider extends TopographicTerrainProvider
 		return g;
 	}
 
+	public void forgetThisParallaxChunk(int x, int z)
+	{
+		getParallaxChunk(x, z).reset();
+		getSliverCache().clear();
+		getCache().drop();
+	}
+
+	public void forgetParallaxChunksNear(int x, int z)
+	{
+		getSliverCache().clear();
+		getCache().drop();
+		ChunkPosition rad = getDimension().getParallaxSize(this);
+		for(int ii = x - (rad.getX() / 2); ii <= x + (rad.getX() / 2); ii++)
+		{
+			for(int jj = z - (rad.getZ() / 2); jj <= z + (rad.getZ() / 2); jj++)
+			{
+				getParallaxChunk(ii, jj).reset();
+			}
+		}
+	}
+
 	@Override
 	protected void onPostGenerate(RNG random, int x, int z, TerrainChunk terrain, HeightMap height, BiomeMap biomeMap, AtomicSliverMap map)
 	{
@@ -219,8 +263,8 @@ public abstract class ParallaxTerrainProvider extends TopographicTerrainProvider
 			for(int jj = z - (rad.getZ() / 2); jj <= z + (rad.getZ() / 2); jj++)
 			{
 				int j = jj;
-
-				RNG random = getMasterRandom().nextParallelRNG(i).nextParallelRNG(j);
+				RNG salt = new RNG(2922 + i + j).nextParallelRNG(i - 293938).nextParallelRNG(j + 294416);
+				RNG random = getMasterRandom().nextParallelRNG(i + salt.imax()).nextParallelRNG(j + salt.imax());
 
 				if(isParallaxGenerated(ii, jj))
 				{
@@ -236,7 +280,7 @@ public abstract class ParallaxTerrainProvider extends TopographicTerrainProvider
 				{
 					IrisBiome b = sampleTrueBiome((i * 16) + 7, (j * 16) + 7);
 					IrisRegion r = sampleRegion((i * 16) + 7, (j * 16) + 7);
-					RNG ro = getMasterRandom().nextParallelRNG(496888 + i + j);
+					RNG ro = getMasterRandom().nextParallelRNG(196888 + i + j + 2225).nextParallelRNG(salt.i(-i, i)).nextParallelRNG(salt.i(-j, j));
 					int g = 1;
 					g = placeMutations(ro, random, i, j, g);
 					g = placeText(random, r, b, i, j, g);

src/main/java/com/volmit/iris/gen/atomics/AtomicSliverMap.java

@@ -210,4 +210,19 @@ public class AtomicSliverMap
 			}
 		}
 	}
+
+	public void reset()
+	{
+		setParallaxGenerated(false);
+		setWorldGenerated(false);
+		getStructures().clear();
+
+		for(int i = 0; i < 16; i++)
+		{
+			for(int j = 0; j < 16; j++)
+			{
+				slivers[i * 16 + j] = new AtomicSliver(i, j);
+			}
+		}
+	}
 }

src/main/java/com/volmit/iris/gen/provisions/ProvisionBukkit.java

@@ -2,18 +2,27 @@ package com.volmit.iris.gen.provisions;
 
 import java.util.List;
 import java.util.Random;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
 import java.util.function.Consumer;
 
+import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.block.data.BlockData;
 import org.bukkit.generator.BlockPopulator;
 import org.bukkit.generator.ChunkGenerator;
 
+import com.volmit.iris.Iris;
+import com.volmit.iris.IrisSettings;
+import com.volmit.iris.gen.IrisTerrainProvider;
 import com.volmit.iris.gen.scaffold.HeightedFakeWorld;
 import com.volmit.iris.gen.scaffold.Provisioned;
 import com.volmit.iris.gen.scaffold.TerrainChunk;
 import com.volmit.iris.gen.scaffold.TerrainProvider;
 import com.volmit.iris.util.ChunkPosition;
+import com.volmit.iris.util.KList;
 import com.volmit.iris.util.KMap;
 import com.volmit.iris.util.RNG;
 
@@ -28,21 +37,107 @@ public class ProvisionBukkit extends ChunkGenerator implements Provisioned
 	private boolean worldSet = false;
 	private final TerrainProvider provider;
 	private final KMap<ChunkPosition, TerrainChunk> precache;
+	private KList<ChunkPosition> regenerated = new KList<ChunkPosition>();
+	private Executor e = Executors.newFixedThreadPool(IrisSettings.get().getThreads());
+	private World cachedWorld;
 
 	public ProvisionBukkit(TerrainProvider provider)
 	{
 		this.provider = provider;
+		provider.setProvisioner(this);
 		precache = new KMap<>();
 	}
 
+	public void clearRegeneratedLists()
+	{
+		regenerated.clear();
+		Iris.clearQueues();
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public void regenerate(int x, int z)
+	{
+		boolean exists = cachedWorld.loadChunk(x, z, false);
+
+		if(!exists)
+		{
+			return;
+		}
+
+		ChunkPosition ccp = new ChunkPosition(x, z);
+
+		if(regenerated.contains(ccp))
+		{
+			return;
+		}
+
+		regenerated.add(ccp);
+		e.execute(() ->
+		{
+			((IrisTerrainProvider) getProvider()).forgetParallaxChunksNear(x, z);
+			TerrainChunk snapshot = TerrainChunk.create(cachedWorld);
+			snapshot.setRaw(generateChunkData(cachedWorld, getRNG(cachedWorld, x, z), x, z, snapshot));
+
+			int cx = x * 16;
+			int cz = z * 16;
+			Iris.sq(() ->
+			{
+				for(int hh = 0; hh < 16; hh++)
+				{
+					int h = hh;
+
+					for(int i = 0; i < 16; i++)
+					{
+						for(int j = 0; j < 16; j++)
+						{
+							for(int k = 0; k < 16; k++)
+							{
+								BlockData b = snapshot.getBlockData(i, (h * 16) + j, k);
+
+								if(!Iris.edit.get(cachedWorld, i + cx, (h * 16) + j, k + cz).equals(b))
+								{
+									Iris.edit.set(cachedWorld, i + cx, (h * 16) + j, k + cz, b);
+								}
+
+								if(Iris.biome3d)
+								{
+									Biome bo = snapshot.getBiome(i, (h * 16) + j, k);
+
+									if(!Iris.edit.getBiome(cachedWorld, i, (h * 16) + j, k).equals(bo))
+									{
+										Iris.edit.setBiome(cachedWorld, i + cx, (h * 16) + j, k + cz, bo);
+									}
+
+								}
+
+								else if(j == 0 && h == 0)
+								{
+									Biome bo = snapshot.getBiome(i, k);
+
+									if(!Iris.edit.getBiome(cachedWorld, i, k).equals(bo))
+									{
+										Iris.edit.setBiome(cachedWorld, i + cx, k + cz, bo);
+									}
+								}
+							}
+						}
+					}
+				}
+			});
+		});
+	}
+
 	public void generate(World world, int x, int z)
 	{
+		cachedWorld = world;
 		world.loadChunk(x, z, true);
 		world.unloadChunkRequest(x, z);
 	}
 
 	public void generateAsync(World world, int x, int z, Consumer<Boolean> onDone)
 	{
+		cachedWorld = world;
 		ChunkPosition c = new ChunkPosition(x, z);
 
 		if(!precache.containsKey(c))
@@ -59,13 +154,61 @@ public class ProvisionBukkit extends ChunkGenerator implements Provisioned
 		}
 	}
 
+	public void fixSpawn(World w)
+	{
+		cachedWorld = w;
+		if(w.getSpawnLocation().getY() == 0 && w.getSpawnLocation().getZ() == 0 && w.getSpawnLocation().getX() == 0)
+		{
+			w.setSpawnLocation(provider.computeSpawn((b) ->
+			{
+				Location at = b.toLocation(w);
+				Location ab = at.clone().add(0, 1, 0);
+				Location bl = at.clone().add(0, -1, 0);
+
+				if(!bl.getBlock().getType().isSolid())
+				{
+					return false;
+				}
+
+				if(ab.getBlock().getType().isSolid())
+				{
+					return false;
+				}
+
+				if(at.getBlock().getType().isSolid())
+				{
+					return false;
+				}
+
+				if(!ab.getBlock().getType().isAir())
+				{
+					return false;
+				}
+
+				if(!at.getBlock().getType().isAir())
+				{
+					return false;
+				}
+
+				return true;
+			}).toLocation(w));
+			Iris.info("Fixed " + w.getName() + " Spawn to " + w.getSpawnLocation().getBlockX() + ", " + w.getSpawnLocation().getBlockY() + ", " + w.getSpawnLocation().getBlockZ());
+		}
+	}
+
 	@Override
 	public ChunkData generateChunkData(World world, Random random, int x, int z, BiomeGrid biome)
 	{
+		cachedWorld = world;
 		if(!worldSet)
 		{
 			worldSet = true;
 			provider.getTarget().setRealWorld(world);
+
+			if(world.getSpawnLocation().getY() == 0 && world.getSpawnLocation().getZ() == 0 && world.getSpawnLocation().getX() == 0)
+			{
+				Bukkit.getScheduler().scheduleSyncDelayedTask(Iris.instance, () -> fixSpawn(world));
+			}
 		}
 
 		if(precache.size() > 0)
@@ -86,25 +229,28 @@ public class ProvisionBukkit extends ChunkGenerator implements Provisioned
 
 	private Random getRNG(World world, int x, int z)
 	{
+		cachedWorld = world;
 		return new RNG(world.getSeed()).nextParallelRNG(x).nextParallelRNG(z);
 	}
 
 	@Override
 	public boolean canSpawn(World world, int x, int z)
 	{
+		cachedWorld = world;
 		return provider.canSpawn(x, z);
 	}
 
 	@Override
 	public List<BlockPopulator> getDefaultPopulators(World world)
 	{
+		cachedWorld = world;
 		return provider.getPopulators();
 	}
 
 	@Override
 	public Location getFixedSpawnLocation(World world, Random random)
 	{
-		return super.getFixedSpawnLocation(world, random);
+		return null;
 	}
 
 	@Override

src/main/java/com/volmit/iris/gen/scaffold/Provisioned.java

@@ -2,5 +2,9 @@ package com.volmit.iris.gen.scaffold;
 
 public interface Provisioned
 {
+	public void clearRegeneratedLists();
+
 	public TerrainProvider getProvider();
+
+	public void regenerate(int x, int z);
 }

src/main/java/com/volmit/iris/gen/scaffold/TerrainProvider.java

@@ -2,12 +2,20 @@ package com.volmit.iris.gen.scaffold;
 
 import java.util.List;
 import java.util.Random;
+import java.util.function.Function;
 
 import org.bukkit.generator.BlockPopulator;
+import org.bukkit.util.BlockVector;
 
 public interface TerrainProvider
 {
 	public TerrainTarget getTarget();
+	
+	public Provisioned getProvisioner();
+	
+	public void setProvisioner(Provisioned p);
+
+	public BlockVector computeSpawn(Function<BlockVector, Boolean> allowed);
 
 	public void generate(Random random, int x, int z, TerrainChunk chunk);
 
@@ -18,9 +26,9 @@ public interface TerrainProvider
 	public boolean isParallelCapable();
 
 	public boolean shouldGenerateMobs();
-	
+
 	public boolean shouldGenerateCaves();
-	
+
 	public boolean shouldGenerateDecorations();
 
 	public boolean shouldGenerateVanillaStructures();

src/main/java/com/volmit/iris/manager/EditManager.java

@@ -2,6 +2,7 @@ package com.volmit.iris.manager;
 
 import org.bukkit.Bukkit;
 import org.bukkit.World;
+import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
@@ -22,7 +23,7 @@ public class EditManager implements Listener
 	{
 		this.editors = new KMap<>();
 		Iris.instance.registerListener(this);
-		Bukkit.getScheduler().scheduleSyncRepeatingTask(Iris.instance, this::update, 0, 20);
+		Bukkit.getScheduler().scheduleSyncRepeatingTask(Iris.instance, this::update, 0, 0);
 	}
 
 	public BlockData get(World world, int x, int y, int z)
@@ -35,6 +36,26 @@ public class EditManager implements Listener
 		open(world).set(x, y, z, d);
 	}
 
+	public void setBiome(World world, int x, int y, int z, Biome d)
+	{
+		open(world).setBiome(x, y, z, d);
+	}
+
+	public void setBiome(World world, int x, int z, Biome d)
+	{
+		open(world).setBiome(x, z, d);
+	}
+
+	public Biome getBiome(World world, int x, int y, int z)
+	{
+		return open(world).getBiome(x, y, z);
+	}
+
+	public Biome getBiome(World world, int x, int z)
+	{
+		return open(world).getBiome(x, z);
+	}
+
 	@EventHandler
 	public void on(WorldUnloadEvent e)
 	{

src/main/java/com/volmit/iris/manager/IrisBoardManager.java

@@ -110,6 +110,7 @@ public class IrisBoardManager implements BoardProvider, Listener
 		v.add(C.GREEN + "Parallax" + C.GRAY + ": " + Form.f((int) g.getParallaxMap().getLoadedChunks().size()));
 		v.add(C.GREEN + "Objects" + C.GRAY + ": " + Form.f(g.getData().getObjectLoader().count()));
 		v.add(C.GREEN + "Memory" + C.GRAY + ": " + mem);
+		v.add(C.GREEN + "Jobs" + C.GRAY + ": " + Iris.jobCount());
 		v.add("&7&m------------------");
 		v.add(C.GREEN + "Heightmap" + C.GRAY + ": " + (int) g.getTerrainHeight(x, z));
 

src/main/java/com/volmit/iris/manager/IrisProject.java

@@ -7,7 +7,6 @@ import java.util.UUID;
 
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
-import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.WorldCreator;
 import org.bukkit.WorldType;
@@ -207,7 +206,7 @@ public class IrisProject
 
 		if(sender.isPlayer())
 		{
-			sender.player().teleport(new Location(world, 0, 0, world.getHighestBlockYAt(0, 0)));
+			sender.player().teleport(world.getSpawnLocation());
 		}
 
 		Bukkit.getScheduler().scheduleSyncDelayedTask(Iris.instance, () ->

src/main/java/com/volmit/iris/manager/ProjectManager.java

@@ -12,14 +12,7 @@ import com.google.gson.Gson;
 import com.google.gson.JsonSyntaxException;
 import com.volmit.iris.Iris;
 import com.volmit.iris.IrisSettings;
-import com.volmit.iris.object.InterpolationMethod;
-import com.volmit.iris.object.IrisBiome;
-import com.volmit.iris.object.IrisBiomeGeneratorLink;
 import com.volmit.iris.object.IrisDimension;
-import com.volmit.iris.object.IrisGenerator;
-import com.volmit.iris.object.IrisInterpolator;
-import com.volmit.iris.object.IrisNoiseGenerator;
-import com.volmit.iris.object.IrisRegion;
 import com.volmit.iris.util.Form;
 import com.volmit.iris.util.IO;
 import com.volmit.iris.util.J;
@@ -448,101 +441,7 @@ public class ProjectManager
 
 	public void create(MortarSender sender, String s)
 	{
-		if(generate(sender, s))
-		{
-			Iris.proj.open(sender, s);
-		}
-	}
-
-	private boolean generate(MortarSender sender, String s)
-	{
-		IrisDimension dimension = new IrisDimension();
-		dimension.setLoadKey(s);
-		dimension.setName(Form.capitalizeWords(s.replaceAll("\\Q-\\E", " ")));
-
-		if(getWorkspaceFile(dimension.getLoadKey(), "dimensions", dimension.getLoadKey() + ".json").exists())
-		{
-			sender.sendMessage("Project Already Exists! Open it instead!");
-			return false;
-		}
-		sender.sendMessage("Creating New Project \"" + dimension.getName() + "\"...");
-		IrisRegion exampleRegion = new IrisRegion();
-		exampleRegion.setName("Example Region");
-		exampleRegion.setLoadKey("example-region");
-		IrisBiome exampleLand1 = new IrisBiome();
-		exampleLand1.setName("Example Land 1");
-		exampleLand1.setLoadKey("land-1");
-		IrisBiome exampleShore1 = new IrisBiome();
-		exampleShore1.setName("Example Shore");
-		exampleShore1.setLoadKey("shore");
-		IrisBiome exampleOcean1 = new IrisBiome();
-		exampleOcean1.setName("Example Sea");
-		exampleOcean1.setLoadKey("sea");
-		IrisBiome exampleLand2 = new IrisBiome();
-		exampleLand2.setName("Example Land 2");
-		exampleLand2.setLoadKey("land-2");
-		exampleLand2.setRarity(4);
-		dimension.setSeaZoom(1);
-		dimension.setLandZoom(1.5);
-		IrisGenerator gen = new IrisGenerator();
-		IrisNoiseGenerator gg = new IrisNoiseGenerator(true);
-		gen.getComposite().add(gg);
-		IrisInterpolator it = new IrisInterpolator();
-		it.setFunction(InterpolationMethod.BILINEAR_STARCAST_9);
-		it.setHorizontalScale(9);
-		gen.setInterpolator(it);
-		gen.setLoadKey("example-generator");
-		IrisBiomeGeneratorLink b1 = new IrisBiomeGeneratorLink();
-		b1.setGenerator(gen.getLoadKey());
-		b1.setMin(3);
-		b1.setMax(7);
-		IrisBiomeGeneratorLink b2 = new IrisBiomeGeneratorLink();
-		b2.setGenerator(gen.getLoadKey());
-		b2.setMin(12);
-		b2.setMax(35);
-		IrisBiomeGeneratorLink b3 = new IrisBiomeGeneratorLink();
-		b3.setGenerator(gen.getLoadKey());
-		b3.setMin(-1);
-		b3.setMax(1);
-		IrisBiomeGeneratorLink b4 = new IrisBiomeGeneratorLink();
-		b4.setGenerator(gen.getLoadKey());
-		b4.setMin(-5);
-		b4.setMax(-38);
-		exampleLand1.getGenerators().clear();
-		exampleLand1.getGenerators().add(b1);
-		exampleLand2.getGenerators().clear();
-		exampleLand2.getGenerators().add(b2);
-		exampleShore1.getGenerators().clear();
-		exampleShore1.getGenerators().add(b3);
-		exampleOcean1.getGenerators().clear();
-		exampleOcean1.getGenerators().add(b4);
-		exampleRegion.getLandBiomes().add(exampleLand1.getLoadKey());
-		exampleRegion.getLandBiomes().add(exampleLand2.getLoadKey());
-		exampleRegion.getShoreBiomes().add(exampleShore1.getLoadKey());
-		exampleRegion.getSeaBiomes().add(exampleOcean1.getLoadKey());
-		dimension.getRegions().add(exampleRegion.getLoadKey());
-		IrisProject project = new IrisProject(getWorkspaceFolder(dimension.getLoadKey()));
-		try
-		{
-			JSONObject ws = project.createCodeWorkspaceConfig();
-			IO.writeAll(getWorkspaceFile(dimension.getLoadKey(), "dimensions", dimension.getLoadKey() + ".json"), new JSONObject(new Gson().toJson(dimension)).toString(4));
-			IO.writeAll(getWorkspaceFile(dimension.getLoadKey(), "regions", exampleRegion.getLoadKey() + ".json"), new JSONObject(new Gson().toJson(exampleRegion)).toString(4));
-			IO.writeAll(getWorkspaceFile(dimension.getLoadKey(), "biomes", exampleLand1.getLoadKey() + ".json"), new JSONObject(new Gson().toJson(exampleLand1)).toString(4));
-			IO.writeAll(getWorkspaceFile(dimension.getLoadKey(), "biomes", exampleLand2.getLoadKey() + ".json"), new JSONObject(new Gson().toJson(exampleLand2)).toString(4));
-			IO.writeAll(getWorkspaceFile(dimension.getLoadKey(), "biomes", exampleShore1.getLoadKey() + ".json"), new JSONObject(new Gson().toJson(exampleShore1)).toString(4));
-			IO.writeAll(getWorkspaceFile(dimension.getLoadKey(), "biomes", exampleOcean1.getLoadKey() + ".json"), new JSONObject(new Gson().toJson(exampleOcean1)).toString(4));
-			IO.writeAll(getWorkspaceFile(dimension.getLoadKey(), "generators", gen.getLoadKey() + ".json"), new JSONObject(new Gson().toJson(gen)).toString(4));
-			IO.writeAll(getWorkspaceFile(dimension.getLoadKey(), dimension.getLoadKey() + ".code-workspace"), ws.toString(0));
-		}
-
-		catch(JSONException | IOException e)
-		{
-			sender.sendMessage("Failed! Check the console.");
-			e.printStackTrace();
-			return false;
-		}
-
-		return true;
+		create(sender, s, "example");
 	}
 
 	public void updateWorkspace()

src/main/java/com/volmit/iris/util/Spiraler.java

@@ -14,15 +14,24 @@ public class Spiraler
 		retarget(sizeX, sizeZ);
 	}
 
+	public void drain()
+	{
+		while(hasNext())
+		{
+			next();
+		}
+	}
+
 	static void Spiral(int X, int Y)
 	{
 
 	}
 
-	public void setOffset(int ox, int oz)
+	public Spiraler setOffset(int ox, int oz)
 	{
 		this.ox = ox;
 		this.oz = oz;
+		return this;
 	}
 
 	public void retarget(int sizeX, int sizeZ)