Fix commands & support regeneration

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();