Fixes & Mem improvements

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

@@ -50,6 +50,7 @@ import com.volmit.iris.util.BoardManager;
 import com.volmit.iris.util.BoardProvider;
 import com.volmit.iris.util.BoardSettings;
 import com.volmit.iris.util.CNG;
+import com.volmit.iris.util.ChronoLatch;
 import com.volmit.iris.util.Cuboid;
 import com.volmit.iris.util.Cuboid.CuboidDirection;
 import com.volmit.iris.util.Desc;
@@ -80,6 +81,8 @@ public class Iris extends JavaPlugin implements BoardProvider
 	public static WandController wand;
 	private static String last = "";
 	private BoardManager manager;
+	private String mem = "...";
+	private ChronoLatch cl = new ChronoLatch(1000);
 	public RollingSequence hits = new RollingSequence(20);
 	public RollingSequence tp = new RollingSequence(100);
 	public static KList<Class<? extends IrisPostBlockFilter>> postProcessors;
@@ -127,6 +130,12 @@ public class Iris extends JavaPlugin implements BoardProvider
 		if(world.getGenerator() instanceof IrisChunkGenerator)
 		{
 			IrisChunkGenerator g = (IrisChunkGenerator) world.getGenerator();
+
+			if(cl.flip())
+			{
+				mem = Form.memSize(g.guessMemoryUsage(), 2);
+			}
+
 			int x = player.getLocation().getBlockX();
 			int y = player.getLocation().getBlockY();
 			int z = player.getLocation().getBlockZ();
@@ -139,11 +148,10 @@ public class Iris extends JavaPlugin implements BoardProvider
 			lines.add(ChatColor.GREEN + "Generators" + ChatColor.GRAY + ": " + Form.f(CNG.creates));
 			lines.add(ChatColor.GREEN + "Noise" + ChatColor.GRAY + ": " + Form.f((int) hits.getAverage()));
 			lines.add(ChatColor.GREEN + "Parallax Chunks" + ChatColor.GRAY + ": " + Form.f((int) g.getParallaxMap().getLoadedChunks().size()));
-			lines.add(ChatColor.GREEN + "Objects" + ChatColor.GRAY + ": " + Form.f(Iris.data.getObjectLoader().count()) + " (~" + Form.memSize(752 * Iris.data.getObjectLoader().getTotalStorage(), 0) + ")");
+			lines.add(ChatColor.GREEN + "Objects" + ChatColor.GRAY + ": " + Form.f(Iris.data.getObjectLoader().count()));
 			lines.add(ChatColor.GREEN + "Biomes" + ChatColor.GRAY + ": " + Form.f(Iris.data.getBiomeLoader().count()));
 			lines.add(ChatColor.GREEN + "Regions" + ChatColor.GRAY + ": " + Form.f(Iris.data.getRegionLoader().count()));
-			lines.add(ChatColor.GREEN + "Height" + ChatColor.GRAY + ": " + (int) g.getTerrainHeight(x, z) + " (" + (int) g.getTerrainWaterHeight(x, z) + ")");
-			lines.add(ChatColor.GREEN + "Height" + ChatColor.GRAY + ": " + (int) g.getTerrainHeight(x, z) + " (" + (int) g.getTerrainWaterHeight(x, z) + ")");
+			lines.add(ChatColor.GREEN + "Memory" + ChatColor.GRAY + ": " + mem);
 
 			if(er != null && b != null)
 			{
@@ -796,13 +804,24 @@ public class Iris extends JavaPlugin implements BoardProvider
 				{
 					String dim = "overworld";
 
-					if(args.length > 1)
+					boolean fast = false;
+
+					for(String i : args)
 					{
-						dim = args[1];
+						if(i.equals("--fast") || i.equals("-f"))
+						{
+							fast = true;
+						}
+
+						else
+						{
+							dim = args[1];
+						}
 					}
 
 					String dimm = dim;
 
+					boolean ff = fast;
 					Bukkit.getScheduler().scheduleSyncDelayedTask(this, () ->
 					{
 						for(World i : Bukkit.getWorlds())
@@ -831,8 +850,10 @@ public class Iris extends JavaPlugin implements BoardProvider
 							imsg(i, "Creating Iris " + dimm + "...");
 						}
 
-						int tc = Math.max(Runtime.getRuntime().availableProcessors() * 4, 4);
+						int tc = (int) Math.max(Runtime.getRuntime().availableProcessors() * IrisSettings.get().threadAggression, 4);
 						IrisChunkGenerator gx = new IrisChunkGenerator(dimm, tc);
+						gx.setFastPregen(ff);
+
 						info("Generating with " + tc + " threads per chunk");
 						O<Boolean> done = new O<Boolean>();
 						done.set(false);
@@ -874,7 +895,7 @@ public class Iris extends JavaPlugin implements BoardProvider
 
 						for(Player i : Bukkit.getOnlinePlayers())
 						{
-							i.teleport(new Location(world, 0, 100, 0));
+							i.teleport(new Location(world, 150, 150, 275));
 
 							Bukkit.getScheduler().scheduleSyncDelayedTask(this, () ->
 							{

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

@@ -0,0 +1,32 @@
+package com.volmit.iris;
+
+import com.volmit.iris.util.Desc;
+import com.volmit.iris.util.DontObfuscate;
+
+public class IrisSettings
+{
+	public static transient IrisSettings settings;
+
+	@DontObfuscate
+	@Desc("Iris creates (aggression X CPU threads) generator threads.")
+	public double threadAggression = 2;
+
+	@DontObfuscate
+	@Desc("Compress parallax data in memory to reduce memory usage in exchange for more cpu usage.")
+	public boolean parallaxCompression = true;
+
+	@DontObfuscate
+	@Desc("Compression level (0-9) lower is faster, but is not as good compression. Best results around 3-5")
+	public int parallaxCompressionLevel = 9;
+
+	public static IrisSettings get()
+	{
+		if(settings == null)
+		{
+			settings = new IrisSettings();
+			// TODO LOAD
+		}
+
+		return settings;
+	}
+}

src/main/java/com/volmit/iris/generator/ContextualChunkGenerator.java

@@ -49,6 +49,7 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements
 	protected World world;
 	protected int generated;
 	protected int ticks;
+	private boolean fastPregen = false;
 	protected boolean pregenDone;
 
 	public ContextualChunkGenerator()
@@ -103,7 +104,7 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements
 	{
 		if(perSecond.flip())
 		{
-			if(generated > 770)
+			if(generated > (fastPregen ? 1950 : 770))
 			{
 				pregenDone = true;
 			}
@@ -221,6 +222,31 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements
 		return c;
 	}
 
+	protected ChunkData generateChunkFastPregen(World world, Random no, int x, int z, BiomeGrid biomeGrid)
+	{
+		ChunkData c = Bukkit.createChunkData(world);
+
+		for(int i = 0; i < 16; i++)
+		{
+			for(int j = 0; j < 16; j++)
+			{
+				int h = 0;
+
+				if(j == i || j + i == 16)
+				{
+					c.setBlock(i, h, j, BlockDataTools.getBlockData("BLUE_TERRACOTTA"));
+				}
+
+				else
+				{
+					c.setBlock(i, h, j, BlockDataTools.getBlockData("WHITE_TERRACOTTA"));
+				}
+			}
+		}
+
+		return c;
+	}
+
 	@Override
 	public ChunkData generateChunkData(World world, Random no, int x, int z, BiomeGrid biomeGrid)
 	{
@@ -251,8 +277,19 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements
 			PrecisionStopwatch s = PrecisionStopwatch.start();
 			RNG random = new RNG(world.getSeed());
 			init(world, random.nextParallelRNG(0));
+
 			ChunkData c = Bukkit.createChunkData(world);
-			onGenerate(random, x, z, c, biomeGrid);
+
+			if(!pregenDone && fastPregen)
+			{
+				c = generateChunkFastPregen(world, no, x, z, biomeGrid);
+			}
+
+			else
+			{
+				onGenerate(random, x, z, c, biomeGrid);
+			}
+
 			metrics.getTotal().put(s.getMilliseconds());
 			generated++;
 			long hits = CNG.hits;

src/main/java/com/volmit/iris/generator/IrisChunkGenerator.java

@@ -12,6 +12,7 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.IrisContext;
 import com.volmit.iris.object.IrisBiome;
 import com.volmit.iris.object.IrisRegion;
+import com.volmit.iris.object.atomics.AtomicRegionData;
 import com.volmit.iris.util.BiomeResult;
 import com.volmit.iris.util.CNG;
 import com.volmit.iris.util.KMap;
@@ -145,4 +146,26 @@ public class IrisChunkGenerator extends CeilingChunkGenerator implements IrisCon
 		CNG.creates = 0;
 		onHotload();
 	}
+
+	public long guessMemoryUsage()
+	{
+		long bytes = 1024 * 1024 * (8 + (getThreads() / 4));
+
+		for(AtomicRegionData i : parallaxMap.getLoadedRegions().values())
+		{
+			bytes += i.guessMemoryUsage();
+		}
+
+		for(AtomicRegionData i : ceilingParallaxMap.getLoadedRegions().values())
+		{
+			bytes += i.guessMemoryUsage();
+		}
+
+		bytes += parallaxMap.getLoadedChunks().size() * 256 * 4 * 460;
+		bytes += ceilingParallaxMap.getLoadedChunks().size() * 256 * 4 * 460;
+		bytes += getSliverBuffer() * 220;
+		bytes += 752 * Iris.data.getObjectLoader().getTotalStorage();
+
+		return bytes;
+	}
 }

src/main/java/com/volmit/iris/generator/ParallaxChunkGenerator.java

@@ -34,9 +34,9 @@ import lombok.EqualsAndHashCode;
 @EqualsAndHashCode(callSuper = false)
 public abstract class ParallaxChunkGenerator extends TerrainChunkGenerator implements IObjectPlacer
 {
-	private KMap<ChunkPosition, AtomicSliver> sliverCache;
+	protected KMap<ChunkPosition, AtomicSliver> sliverCache;
 	protected AtomicWorldData parallaxMap;
-	private KMap<ChunkPosition, AtomicSliver> ceilingSliverCache;
+	protected KMap<ChunkPosition, AtomicSliver> ceilingSliverCache;
 	protected AtomicWorldData ceilingParallaxMap;
 	private MasterLock masterLock;
 	private ReentrantLock lock = new ReentrantLock();

src/main/java/com/volmit/iris/generator/TerrainChunkGenerator.java

@@ -266,6 +266,14 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
 			}
 		}
 
+		if(onto.equals(Material.STONE) || onto.equals(Material.ANDESITE) || onto.equals(Material.GRANITE) || onto.equals(Material.DIORITE) || onto.equals(Material.BLACKSTONE) || onto.equals(Material.BASALT))
+		{
+			if(mat.equals(Material.POPPY) || mat.equals(Material.DANDELION) || mat.equals(Material.CORNFLOWER) || mat.equals(Material.ORANGE_TULIP) || mat.equals(Material.PINK_TULIP) || mat.equals(Material.RED_TULIP) || mat.equals(Material.WHITE_TULIP) || mat.equals(Material.FERN) || mat.equals(Material.LARGE_FERN) || mat.equals(Material.GRASS) || mat.equals(Material.TALL_GRASS))
+			{
+				return false;
+			}
+		}
+
 		if(onto.equals(Material.ACACIA_LEAVES) || onto.equals(Material.BIRCH_LEAVES) || onto.equals(Material.DARK_OAK_LEAVES) || onto.equals(Material.JUNGLE_LEAVES) || onto.equals(Material.OAK_LEAVES) || onto.equals(Material.SPRUCE_LEAVES))
 		{
 			if(!mat.isSolid())
@@ -293,7 +301,7 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
 				continue;
 			}
 
-			BlockData d = i.getBlockData(getMasterRandom().nextParallelRNG((int) (wx + wz + 38888 + biome.getRarity() + biome.getName().length() + j++)), wx, wz);
+			BlockData d = i.getBlockData(getMasterRandom().nextParallelRNG((int) (38888 + biome.getRarity() + biome.getName().length() + j++)), wx, wz);
 
 			if(d != null)
 			{

src/main/java/com/volmit/iris/layer/GenLayerBiome.java

@@ -47,6 +47,12 @@ public class GenLayerBiome extends GenLayer
 
 	public IrisRegion getRegion(double bx, double bz)
 	{
+		if(iris.getDimension().getRegions().isEmpty())
+		{
+			Iris.error("NO REGIONS!");
+			return null;
+		}
+
 		regionGenerator.setShuffle(8);
 		regionGenerator.setCellScale(0.33 / iris.getDimension().getRegionZoom());
 		double x = bx / iris.getDimension().getBiomeZoom();

src/main/java/com/volmit/iris/object/IrisBiomeDecorator.java

@@ -91,7 +91,7 @@ public class IrisBiomeDecorator
 
 		if(!layerGenerators.containsKey(key))
 		{
-			layerGenerators.put(key, CNG.signature(rng.nextParallelRNG(getBlockData().size())).scale(1D / zoom));
+			layerGenerators.put(key, CNG.signature(rng.nextParallelRNG((int) (getBlockData().size() + key))).scale(1D / zoom));
 		}
 
 		return layerGenerators.get(key);
@@ -121,8 +121,8 @@ public class IrisBiomeDecorator
 		}
 
 		RNG nrng = rng.nextParallelRNG((int) (z - (int) ((x + 34856) * (int) (x + z + (int) (28835521 + (getChance() * 1000) + getStackMin() + getStackMax() + (getZoom() * 556))))));
-		double xx = dispersion.equals(Dispersion.SCATTER) ? nrng.i(-100000, 100000) : x;
-		double zz = dispersion.equals(Dispersion.SCATTER) ? nrng.i(-100000, 100000) : z;
+		double xx = dispersion.equals(Dispersion.SCATTER) ? nrng.i(-1000000, 1000000) : x;
+		double zz = dispersion.equals(Dispersion.SCATTER) ? nrng.i(-1000000, 1000000) : z;
 
 		if(getGenerator(rng).fitDoubleD(0D, 1D, xx, zz) <= chance)
 		{

src/main/java/com/volmit/iris/object/atomics/AtomicRegionData.java

@@ -5,11 +5,14 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.util.zip.GZIPInputStream;
 
 import org.bukkit.World;
 
+import com.volmit.iris.IrisSettings;
 import com.volmit.iris.util.ByteArrayTag;
 import com.volmit.iris.util.CompoundTag;
+import com.volmit.iris.util.CustomOutputStream;
 import com.volmit.iris.util.KMap;
 import com.volmit.iris.util.NBTInputStream;
 import com.volmit.iris.util.NBTOutputStream;
@@ -18,42 +21,64 @@ import com.volmit.iris.util.Tag;
 public class AtomicRegionData
 {
 	private final World world;
-	private KMap<String, Tag> tag;
+	private Tag[] tag;
 
 	public AtomicRegionData(World world)
 	{
 		this.world = world;
-		tag = new KMap<>();
+		tag = new Tag[1024];
 	}
 
 	public int size()
 	{
-		return tag.size();
+		return tag.length;
 	}
 
 	public void read(InputStream in) throws IOException
 	{
 		NBTInputStream nin = new NBTInputStream(in);
-		tag = new KMap<>();
-		tag.putAll(((CompoundTag) nin.readTag()).getValue());
+		KMap<String, Tag> tags = new KMap<>();
+		tags.putAll(((CompoundTag) nin.readTag()).getValue());
+
+		for(String i : tags.keySet())
+		{
+			int x = Integer.valueOf(i.split("\\Q.\\E")[0]);
+			int z = Integer.valueOf(i.split("\\Q.\\E")[1]);
+			tag[(z << 5) | x] = tags.get(i);
+		}
+
 		nin.close();
 	}
 
 	public void write(OutputStream out) throws IOException
 	{
 		NBTOutputStream nos = new NBTOutputStream(out);
-		nos.writeTag(new CompoundTag("imca", tag));
+
+		KMap<String, Tag> tags = new KMap<>();
+
+		for(int i = 0; i < 32; i++)
+		{
+			for(int j = 0; j < 32; j++)
+			{
+				if(tag[(j << 5) | i] != null)
+				{
+					tags.put(i + "." + j, tag[(j << 5) | i]);
+				}
+			}
+		}
+
+		nos.writeTag(new CompoundTag("imca", tags));
 		nos.close();
 	}
 
 	public boolean contains(int rx, int rz)
 	{
-		return tag.containsKey(rx + "." + rz);
+		return tag[(rz << 5) | rx] != null;
 	}
 
 	public void delete(int rx, int rz)
 	{
-		tag.remove(rx + "." + rz);
+		tag[(rz << 5) | rx] = null;
 	}
 
 	public void set(int rx, int rz, AtomicSliverMap data) throws IOException
@@ -63,9 +88,19 @@ public class AtomicRegionData
 			return;
 		}
 
+		OutputStream out;
 		ByteArrayOutputStream boas = new ByteArrayOutputStream();
-		data.write(boas);
-		tag.put(rx + "." + rz, new ByteArrayTag(rx + "." + rz, boas.toByteArray()));
+		out = boas;
+
+		if(IrisSettings.get().parallaxCompression)
+		{
+			out = new CustomOutputStream(boas, IrisSettings.get().parallaxCompressionLevel);
+		}
+
+		data.write(out);
+		out.flush();
+		out.close();
+		tag[(rz << 5) | rx] = new ByteArrayTag(rx + "." + rz, boas.toByteArray());
 	}
 
 	public AtomicSliverMap get(int rx, int rz) throws IOException
@@ -79,8 +114,20 @@ public class AtomicRegionData
 
 		try
 		{
-			ByteArrayTag btag = (ByteArrayTag) tag.get(rx + "." + rz);
-			ByteArrayInputStream in = new ByteArrayInputStream(btag.getValue());
+			ByteArrayTag btag = (ByteArrayTag) tag[(rz << 5) | rx];
+
+			InputStream in;
+
+			if(IrisSettings.get().parallaxCompression)
+			{
+				in = new GZIPInputStream(new ByteArrayInputStream(btag.getValue()));
+			}
+
+			else
+			{
+				in = new ByteArrayInputStream(btag.getValue());
+			}
+
 			data.read(in);
 		}
 
@@ -96,4 +143,20 @@ public class AtomicRegionData
 	{
 		return world;
 	}
+
+	public long guessMemoryUsage()
+	{
+		long bytes = 0;
+
+		for(int i = 0; i < 1024; i++)
+		{
+			if(tag[i] != null && tag[i] instanceof ByteArrayTag)
+			{
+				bytes += 122;
+				bytes += ((ByteArrayTag) tag[i]).getValue().length;
+			}
+		}
+
+		return bytes;
+	}
 }

src/main/java/com/volmit/iris/object/atomics/AtomicSliver.java

@@ -32,6 +32,7 @@ public class AtomicSliver
 	private long last = M.ms();
 	private int x;
 	private int z;
+	boolean modified = false;
 
 	public AtomicSliver(int x, int z)
 	{
@@ -69,7 +70,8 @@ public class AtomicSliver
 
 		lock.lock();
 		block.put(h, d);
-
+		modified = true;
+		
 		if(d.getMaterial().equals(Material.AIR) || d.getMaterial().equals(Material.CAVE_AIR))
 		{
 			lock.unlock();
@@ -88,6 +90,7 @@ public class AtomicSliver
 		}
 
 		lock.lock();
+		modified = true;
 		block.put(h, d);
 		lock.unlock();
 	}
@@ -113,6 +116,7 @@ public class AtomicSliver
 	{
 		lock.lock();
 		biome.put(h, d);
+		modified = true;
 		highestBiome = h > highestBiome ? h : highestBiome;
 		lock.unlock();
 	}
@@ -120,6 +124,7 @@ public class AtomicSliver
 	public void set(int h, IrisBiome d)
 	{
 		lock.lock();
+		modified = true;
 		truebiome.put(h, d);
 		lock.unlock();
 	}
@@ -173,6 +178,7 @@ public class AtomicSliver
 		{
 			block.put(i, BlockDataTools.getBlockData(din.readUTF()));
 		}
+		modified = false;
 		lock.unlock();
 	}
 

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

@@ -93,4 +93,17 @@ public class AtomicSliverMap
 			i.inject(currentData);
 		}
 	}
+	
+	public boolean isModified()
+	{
+		for(AtomicSliver i : slivers)
+		{
+			if(i.isModified())
+			{
+				return true;
+			}
+		}
+		
+		return false;
+	}
 }

src/main/java/com/volmit/iris/object/atomics/AtomicWorldData.java

@@ -10,6 +10,7 @@ import org.bukkit.World;
 import com.volmit.iris.Iris;
 import com.volmit.iris.util.ChronoLatch;
 import com.volmit.iris.util.ChunkPosition;
+import com.volmit.iris.util.KList;
 import com.volmit.iris.util.KMap;
 import com.volmit.iris.util.M;
 
@@ -20,8 +21,10 @@ public class AtomicWorldData
 	private KMap<ChunkPosition, AtomicRegionData> loadedSections;
 	private KMap<ChunkPosition, Long> lastRegion;
 	private KMap<ChunkPosition, Long> lastChunk;
+	private KList<ChunkPosition> unloadRegions;
+	private KList<ChunkPosition> unloadChunks;
 	private String prefix;
-	private ChronoLatch cl = new ChronoLatch(3000);
+	private ChronoLatch cl = new ChronoLatch(333);
 
 	public AtomicWorldData(World world, String prefix)
 	{
@@ -30,6 +33,8 @@ public class AtomicWorldData
 		loadedChunks = new KMap<>();
 		lastRegion = new KMap<>();
 		lastChunk = new KMap<>();
+		unloadRegions = new KList<>();
+		unloadChunks = new KList<>();
 		this.prefix = prefix;
 		getSubregionFolder().mkdirs();
 	}
@@ -162,10 +167,16 @@ public class AtomicWorldData
 
 	public void saveChunk(ChunkPosition i) throws IOException
 	{
-		int x = i.getX();
-		int z = i.getZ();
-		AtomicRegionData dat = loadSection(x >> 5, z >> 5, true);
-		dat.set(x & 31, z & 31, loadedChunks.get(i));
+		AtomicSliverMap m = loadedChunks.get(i);
+
+		if(m.isModified())
+		{
+			int x = i.getX();
+			int z = i.getZ();
+			AtomicRegionData dat = loadSection(x >> 5, z >> 5, true);
+			dat.set(x & 31, z & 31, m);
+		}
+
 		loadedChunks.remove(i);
 		lastChunk.remove(i);
 	}
@@ -261,38 +272,68 @@ public class AtomicWorldData
 			return;
 		}
 
-		for(ChunkPosition i : lastRegion.k())
+		int m = 0;
+
+		for(ChunkPosition i : lastRegion.keySet())
 		{
+			if(m > 1)
+			{
+				break;
+			}
+
 			if(M.ms() - lastRegion.get(i) > 60000)
 			{
-				lastRegion.remove(i);
-
-				try
-				{
-					unloadSection(i, true);
-				}
-
-				catch(IOException e)
-				{
-					e.printStackTrace();
-				}
+				unloadRegions.add(i);
+				m++;
 			}
 		}
 
-		for(ChunkPosition i : lastChunk.k())
+		m = 0;
+
+		for(ChunkPosition i : unloadRegions)
 		{
-			if(M.ms() - lastChunk.get(i) > 60000)
-			{
-				try
-				{
-					saveChunk(i);
-				}
+			lastRegion.remove(i);
 
-				catch(IOException e)
-				{
-					Iris.warn("Failed to save chunk");
-				}
+			try
+			{
+				unloadSection(i, true);
+			}
+
+			catch(IOException e)
+			{
+				e.printStackTrace();
 			}
 		}
+
+		unloadRegions.clear();
+
+		for(ChunkPosition i : lastChunk.keySet())
+		{
+			if(m > 7)
+			{
+				break;
+			}
+
+			if(M.ms() - lastChunk.get(i) > 15000)
+			{
+				m++;
+				unloadChunks.add(i);
+			}
+		}
+
+		for(ChunkPosition i : unloadChunks)
+		{
+			try
+			{
+				saveChunk(i);
+			}
+
+			catch(IOException e)
+			{
+				Iris.warn("Failed to save chunk");
+			}
+		}
+
+		unloadChunks.clear();
 	}
 }

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

@@ -0,0 +1,75 @@
+package com.volmit.iris.util;
+
+import org.bukkit.block.Biome;
+import org.bukkit.generator.ChunkGenerator.BiomeGrid;
+
+public class BiomeStorage
+{
+	private static final int e;
+	private static final int f;
+	public static final int a;
+	public static final int b;
+	public static final int c;
+	private final Biome[] g;
+
+	static
+	{
+		e = (int) Math.round(Math.log(16.0) / Math.log(2.0)) - 2;
+		f = (int) Math.round(Math.log(256.0) / Math.log(2.0)) - 2;
+		a = 1 << BiomeStorage.e + BiomeStorage.e + BiomeStorage.f;
+		b = (1 << BiomeStorage.e) - 1;
+		c = (1 << BiomeStorage.f) - 1;
+	}
+
+	public BiomeStorage(final Biome[] aBiome)
+	{
+		this.g = aBiome;
+	}
+
+	public BiomeStorage()
+	{
+		this(new Biome[BiomeStorage.a]);
+	}
+
+	public BiomeStorage b()
+	{
+		return new BiomeStorage(this.g.clone());
+	}
+
+	public void inject(BiomeGrid grid)
+	{
+		for(int i = 0; i < 256; i++)
+		{
+			for(int j = 0; j < 16; j++)
+			{
+				for(int k = 0; k < 16; k++)
+				{
+					Biome b = getBiome(j, i, k);
+
+					if(b == null || b.equals(Biome.THE_VOID))
+					{
+						continue;
+					}
+
+					grid.setBiome(j, i, k, b);
+				}
+			}
+		}
+	}
+
+	public Biome getBiome(final int i, final int j, final int k)
+	{
+		final int l = i & BiomeStorage.b;
+		final int i2 = MathHelper.clamp(j, 0, BiomeStorage.c);
+		final int j2 = k & BiomeStorage.b;
+		return this.g[i2 << BiomeStorage.e + BiomeStorage.e | j2 << BiomeStorage.e | l];
+	}
+
+	public void setBiome(final int i, final int j, final int k, final Biome biome)
+	{
+		final int l = i & BiomeStorage.b;
+		final int i2 = MathHelper.clamp(j, 0, BiomeStorage.c);
+		final int j2 = k & BiomeStorage.b;
+		this.g[i2 << BiomeStorage.e + BiomeStorage.e | j2 << BiomeStorage.e | l] = biome;
+	}
+}

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

@@ -0,0 +1,14 @@
+package com.volmit.iris.util;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.zip.GZIPOutputStream;
+
+public class CustomOutputStream extends GZIPOutputStream
+{
+	public CustomOutputStream(OutputStream out, int level) throws IOException
+	{
+		super(out);
+		def.setLevel(level);
+	}
+}

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

@@ -21,7 +21,7 @@ public class J
 		{
 			tid++;
 			Thread t = new Thread(r);
-			t.setName("Actuator " + tid);
+			t.setName("Iris Preemptive Generator " + tid);
 			t.setPriority(Thread.MIN_PRIORITY);
 			t.setUncaughtExceptionHandler((et, e) ->
 			{

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

@@ -0,0 +1,551 @@
+package com.volmit.iris.util;
+
+import java.util.Random;
+import java.util.UUID;
+import java.util.function.IntPredicate;
+
+public class MathHelper
+{
+	public static final float a;
+	private static final Random c;
+	private static final int[] d;
+	private static final double e;
+	private static final double[] f;
+	private static final double[] g;
+
+	public static float c(final float var0)
+	{
+		return (float) Math.sqrt(var0);
+	}
+
+	public static float sqrt(final double var0)
+	{
+		return (float) Math.sqrt(var0);
+	}
+
+	public static int d(final float var0)
+	{
+		final int var = (int) var0;
+		return (var0 < var) ? (var - 1) : var;
+	}
+
+	public static int floor(final double var0)
+	{
+		final int var = (int) var0;
+		return (var0 < var) ? (var - 1) : var;
+	}
+
+	public static long d(final double var0)
+	{
+		final long var = (long) var0;
+		return (var0 < var) ? (var - 1L) : var;
+	}
+
+	public static float e(final float var0)
+	{
+		return Math.abs(var0);
+	}
+
+	public static int a(final int var0)
+	{
+		return Math.abs(var0);
+	}
+
+	public static int f(final float var0)
+	{
+		final int var = (int) var0;
+		return (var0 > var) ? (var + 1) : var;
+	}
+
+	public static int f(final double var0)
+	{
+		final int var = (int) var0;
+		return (var0 > var) ? (var + 1) : var;
+	}
+
+	public static int clamp(final int var0, final int var1, final int var2)
+	{
+		if(var0 < var1)
+		{
+			return var1;
+		}
+		if(var0 > var2)
+		{
+			return var2;
+		}
+		return var0;
+	}
+
+	public static float a(final float var0, final float var1, final float var2)
+	{
+		if(var0 < var1)
+		{
+			return var1;
+		}
+		if(var0 > var2)
+		{
+			return var2;
+		}
+		return var0;
+	}
+
+	public static double a(final double var0, final double var2, final double var4)
+	{
+		if(var0 < var2)
+		{
+			return var2;
+		}
+		if(var0 > var4)
+		{
+			return var4;
+		}
+		return var0;
+	}
+
+	public static double b(final double var0, final double var2, final double var4)
+	{
+		if(var4 < 0.0)
+		{
+			return var0;
+		}
+		if(var4 > 1.0)
+		{
+			return var2;
+		}
+		return d(var4, var0, var2);
+	}
+
+	public static double a(double var0, double var2)
+	{
+		if(var0 < 0.0)
+		{
+			var0 = -var0;
+		}
+		if(var2 < 0.0)
+		{
+			var2 = -var2;
+		}
+		return (var0 > var2) ? var0 : var2;
+	}
+
+	public static int a(final int var0, final int var1)
+	{
+		return Math.floorDiv(var0, var1);
+	}
+
+	public static int nextInt(final Random var0, final int var1, final int var2)
+	{
+		if(var1 >= var2)
+		{
+			return var1;
+		}
+		return var0.nextInt(var2 - var1 + 1) + var1;
+	}
+
+	public static float a(final Random var0, final float var1, final float var2)
+	{
+		if(var1 >= var2)
+		{
+			return var1;
+		}
+		return var0.nextFloat() * (var2 - var1) + var1;
+	}
+
+	public static double a(final Random var0, final double var1, final double var3)
+	{
+		if(var1 >= var3)
+		{
+			return var1;
+		}
+		return var0.nextDouble() * (var3 - var1) + var1;
+	}
+
+	public static double a(final long[] var0)
+	{
+		long var = 0L;
+		for(final long var2 : var0)
+		{
+			var += var2;
+		}
+		return var / (double) var0.length;
+	}
+
+	public static boolean b(final double var0, final double var2)
+	{
+		return Math.abs(var2 - var0) < 9.999999747378752E-6;
+	}
+
+	public static int b(final int var0, final int var1)
+	{
+		return Math.floorMod(var0, var1);
+	}
+
+	public static float g(final float var0)
+	{
+		float var = var0 % 360.0f;
+		if(var >= 180.0f)
+		{
+			var -= 360.0f;
+		}
+		if(var < -180.0f)
+		{
+			var += 360.0f;
+		}
+		return var;
+	}
+
+	public static double g(final double var0)
+	{
+		double var = var0 % 360.0;
+		if(var >= 180.0)
+		{
+			var -= 360.0;
+		}
+		if(var < -180.0)
+		{
+			var += 360.0;
+		}
+		return var;
+	}
+
+	public static float c(final float var0, final float var1)
+	{
+		return g(var1 - var0);
+	}
+
+	public static float d(final float var0, final float var1)
+	{
+		return e(c(var0, var1));
+	}
+
+	public static float b(final float var0, final float var1, final float var2)
+	{
+		final float var3 = c(var0, var1);
+		final float var4 = a(var3, -var2, var2);
+		return var1 - var4;
+	}
+
+	public static float c(final float var0, final float var1, float var2)
+	{
+		var2 = e(var2);
+		if(var0 < var1)
+		{
+			return a(var0 + var2, var0, var1);
+		}
+		return a(var0 - var2, var1, var0);
+	}
+
+	public static float d(final float var0, final float var1, final float var2)
+	{
+		final float var3 = c(var0, var1);
+		return c(var0, var0 + var3, var2);
+	}
+
+	public static int c(final int var0)
+	{
+		int var = var0 - 1;
+		var |= var >> 1;
+		var |= var >> 2;
+		var |= var >> 4;
+		var |= var >> 8;
+		var |= var >> 16;
+		return var + 1;
+	}
+
+	public static boolean d(final int var0)
+	{
+		return var0 != 0 && (var0 & var0 - 1) == 0x0;
+	}
+
+	public static int e(int var0)
+	{
+		var0 = (d(var0) ? var0 : c(var0));
+		return MathHelper.d[(int) (var0 * 125613361L >> 27) & 0x1F];
+	}
+
+	public static int f(final int var0)
+	{
+		return e(var0) - (d(var0) ? 0 : 1);
+	}
+
+	public static int c(final int var0, int var1)
+	{
+		if(var1 == 0)
+		{
+			return 0;
+		}
+		if(var0 == 0)
+		{
+			return var1;
+		}
+		if(var0 < 0)
+		{
+			var1 *= -1;
+		}
+		final int var2 = var0 % var1;
+		if(var2 == 0)
+		{
+			return var0;
+		}
+		return var0 + var1 - var2;
+	}
+
+	public static float h(final float var0)
+	{
+		return var0 - d(var0);
+	}
+
+	public static double h(final double var0)
+	{
+		return var0 - d(var0);
+	}
+
+	public static long c(final int var0, final int var1, final int var2)
+	{
+		long var3 = (long) (var0 * 3129871) ^ var2 * 116129781L ^ (long) var1;
+		var3 = var3 * var3 * 42317861L + var3 * 11L;
+		return var3 >> 16;
+	}
+
+	public static UUID a(final Random var0)
+	{
+		final long var = (var0.nextLong() & 0xFFFFFFFFFFFF0FFFL) | 0x4000L;
+		final long var2 = (var0.nextLong() & 0x3FFFFFFFFFFFFFFFL) | Long.MIN_VALUE;
+		return new UUID(var, var2);
+	}
+
+	public static UUID a()
+	{
+		return a(MathHelper.c);
+	}
+
+	public static double c(final double var0, final double var2, final double var4)
+	{
+		return (var0 - var2) / (var4 - var2);
+	}
+
+	public static double d(double var0, double var2)
+	{
+		final double var3 = var2 * var2 + var0 * var0;
+		if(Double.isNaN(var3))
+		{
+			return Double.NaN;
+		}
+		final boolean var4 = var0 < 0.0;
+		if(var4)
+		{
+			var0 = -var0;
+		}
+		final boolean var5 = var2 < 0.0;
+		if(var5)
+		{
+			var2 = -var2;
+		}
+		final boolean var6 = var0 > var2;
+		if(var6)
+		{
+			final double var7 = var2;
+			var2 = var0;
+			var0 = var7;
+		}
+		final double var7 = i(var3);
+		var2 *= var7;
+		var0 *= var7;
+		final double var8 = MathHelper.e + var0;
+		final int var9 = (int) Double.doubleToRawLongBits(var8);
+		final double var10 = MathHelper.f[var9];
+		final double var11 = MathHelper.g[var9];
+		final double var12 = var8 - MathHelper.e;
+		final double var13 = var0 * var11 - var2 * var12;
+		final double var14 = (6.0 + var13 * var13) * var13 * 0.16666666666666666;
+		double var15 = var10 + var14;
+		if(var6)
+		{
+			var15 = 1.5707963267948966 - var15;
+		}
+		if(var5)
+		{
+			var15 = 3.141592653589793 - var15;
+		}
+		if(var4)
+		{
+			var15 = -var15;
+		}
+		return var15;
+	}
+
+	public static double i(double var0)
+	{
+		final double var = 0.5 * var0;
+		long var2 = Double.doubleToRawLongBits(var0);
+		var2 = 6910469410427058090L - (var2 >> 1);
+		var0 = Double.longBitsToDouble(var2);
+		var0 *= 1.5 - var * var0 * var0;
+		return var0;
+	}
+
+	public static int f(final float var0, final float var1, final float var2)
+	{
+		final int var3 = (int) (var0 * 6.0f) % 6;
+		final float var4 = var0 * 6.0f - var3;
+		final float var5 = var2 * (1.0f - var1);
+		final float var6 = var2 * (1.0f - var4 * var1);
+		final float var7 = var2 * (1.0f - (1.0f - var4) * var1);
+		float var8 = 0.0f;
+		float var9 = 0.0f;
+		float var10 = 0.0f;
+		switch(var3)
+		{
+			case 0:
+			{
+				var8 = var2;
+				var9 = var7;
+				var10 = var5;
+				break;
+			}
+			case 1:
+			{
+				var8 = var6;
+				var9 = var2;
+				var10 = var5;
+				break;
+			}
+			case 2:
+			{
+				var8 = var5;
+				var9 = var2;
+				var10 = var7;
+				break;
+			}
+			case 3:
+			{
+				var8 = var5;
+				var9 = var6;
+				var10 = var2;
+				break;
+			}
+			case 4:
+			{
+				var8 = var7;
+				var9 = var5;
+				var10 = var2;
+				break;
+			}
+			case 5:
+			{
+				var8 = var2;
+				var9 = var5;
+				var10 = var6;
+				break;
+			}
+			default:
+			{
+				throw new RuntimeException("Something went wrong when converting from HSV to RGB. Input was " + var0 + ", " + var1 + ", " + var2);
+			}
+		}
+		final int var11 = clamp((int) (var8 * 255.0f), 0, 255);
+		final int var12 = clamp((int) (var9 * 255.0f), 0, 255);
+		final int var13 = clamp((int) (var10 * 255.0f), 0, 255);
+		return var11 << 16 | var12 << 8 | var13;
+	}
+
+	public static int g(int var0)
+	{
+		var0 ^= var0 >>> 16;
+		var0 *= -2048144789;
+		var0 ^= var0 >>> 13;
+		var0 *= -1028477387;
+		var0 ^= var0 >>> 16;
+		return var0;
+	}
+
+	public static int a(int var0, final int var1, final IntPredicate var2)
+	{
+		int var3 = var1 - var0;
+		while(var3 > 0)
+		{
+			final int var4 = var3 / 2;
+			final int var5 = var0 + var4;
+			if(var2.test(var5))
+			{
+				var3 = var4;
+			}
+			else
+			{
+				var0 = var5 + 1;
+				var3 -= var4 + 1;
+			}
+		}
+		return var0;
+	}
+
+	public static float g(final float var0, final float var1, final float var2)
+	{
+		return var1 + var0 * (var2 - var1);
+	}
+
+	public static double d(final double var0, final double var2, final double var4)
+	{
+		return var2 + var0 * (var4 - var2);
+	}
+
+	public static double a(final double var0, final double var2, final double var4, final double var6, final double var8, final double var10)
+	{
+		return d(var2, d(var0, var4, var6), d(var0, var8, var10));
+	}
+
+	public static double a(final double var0, final double var2, final double var4, final double var6, final double var8, final double var10, final double var12, final double var14, final double var16, final double var18, final double var20)
+	{
+		return d(var4, a(var0, var2, var6, var8, var10, var12), a(var0, var2, var14, var16, var18, var20));
+	}
+
+	public static double j(final double var0)
+	{
+		return var0 * var0 * var0 * (var0 * (var0 * 6.0 - 15.0) + 10.0);
+	}
+
+	public static int k(final double var0)
+	{
+		if(var0 == 0.0)
+		{
+			return 0;
+		}
+		return (var0 > 0.0) ? 1 : -1;
+	}
+
+	@Deprecated
+	public static float j(final float var0, final float var1, final float var2)
+	{
+		float var3;
+		for(var3 = var1 - var0; var3 < -180.0f; var3 += 360.0f)
+		{
+		}
+		while(var3 >= 180.0f)
+		{
+			var3 -= 360.0f;
+		}
+		return var0 + var2 * var3;
+	}
+
+	public static float k(final float var0)
+	{
+		return var0 * var0;
+	}
+
+	static
+	{
+		a = c(2.0f);
+		c = new Random();
+		d = new int[] {0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9};
+		e = Double.longBitsToDouble(4805340802404319232L);
+		f = new double[257];
+		g = new double[257];
+		for(int var2 = 0; var2 < 257; ++var2)
+		{
+			final double var3 = var2 / 256.0;
+			final double var4 = Math.asin(var3);
+			MathHelper.g[var2] = Math.cos(var4);
+			MathHelper.f[var2] = var4;
+		}
+	}
+}

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

@@ -31,10 +31,7 @@ public class ObjectResourceLoader extends ResourceLoader<IrisObject>
 	{
 		if(useFlip.flip())
 		{
-			if(loadCache.size() > 15 && getTotalStorage() > 20000)
-			{
-				unloadLast(30000);
-			}
+			unloadLast(60000);
 		}
 	}
 

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

@@ -0,0 +1,137 @@
+package com.volmit.iris.util;
+
+import org.bukkit.Material;
+import org.bukkit.block.Biome;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.generator.ChunkGenerator.BiomeGrid;
+import org.bukkit.generator.ChunkGenerator.ChunkData;
+import org.bukkit.material.MaterialData;
+
+@SuppressWarnings("deprecation")
+public class PreemptiveChunk implements BiomeGrid, ChunkData
+{
+	private ChunkData c;
+	private BiomeStorage b;
+
+	public PreemptiveChunk(ChunkData c)
+	{
+		this.c = c;
+		this.b = new BiomeStorage();
+	}
+
+	public void inject(ChunkData ic, BiomeGrid ib)
+	{
+		for(int i = 0; i < 16; i++)
+		{
+			for(int j = 0; j < 256; j++)
+			{
+				for(int k = 0; k < 16; k++)
+				{
+					if(!getType(i, j, k).equals(Material.AIR))
+					{
+						ic.setBlock(i, j, k, getBlockData(i, j, k));
+					}
+				}
+			}
+		}
+
+		b.inject(ib);
+	}
+
+	@Override
+	public Biome getBiome(int arg0, int arg1)
+	{
+		throw new UnsupportedOperationException("Not Supported. Use x y z");
+	}
+
+	@Override
+	public Biome getBiome(int x, int y, int z)
+	{
+		return b.getBiome(x, y, z);
+	}
+
+	@Override
+	public void setBiome(int x, int z, Biome arg2)
+	{
+		for(int i = 0; i < 256; i++)
+		{
+			b.setBiome(x, i, z, arg2);
+		}
+	}
+
+	@Override
+	public void setBiome(int arg0, int arg1, int arg2, Biome arg3)
+	{
+		b.setBiome(arg0, arg1, arg2, arg3);
+	}
+
+	@Override
+	public BlockData getBlockData(int arg0, int arg1, int arg2)
+	{
+		return c.getBlockData(arg0, arg1, arg2);
+	}
+
+	@Deprecated
+	@Override
+	public byte getData(int arg0, int arg1, int arg2)
+	{
+		return c.getData(arg0, arg1, arg2);
+	}
+
+	@Override
+	public int getMaxHeight()
+	{
+		return c.getMaxHeight();
+	}
+
+	@Override
+	public Material getType(int arg0, int arg1, int arg2)
+	{
+		return c.getType(arg0, arg1, arg2);
+	}
+
+	@Deprecated
+	@Override
+	public MaterialData getTypeAndData(int arg0, int arg1, int arg2)
+	{
+		return c.getTypeAndData(arg0, arg1, arg2);
+	}
+
+	@Override
+	public void setBlock(int arg0, int arg1, int arg2, Material arg3)
+	{
+		c.setBlock(arg0, arg1, arg2, arg3);
+	}
+
+	@Deprecated
+	@Override
+	public void setBlock(int arg0, int arg1, int arg2, MaterialData arg3)
+	{
+		c.setBlock(arg0, arg1, arg2, arg3);
+	}
+
+	@Override
+	public void setBlock(int arg0, int arg1, int arg2, BlockData arg3)
+	{
+		c.setBlock(arg0, arg1, arg2, arg3);
+	}
+
+	@Override
+	public void setRegion(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, Material arg6)
+	{
+		c.setRegion(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+	}
+
+	@Deprecated
+	@Override
+	public void setRegion(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, MaterialData arg6)
+	{
+		c.setRegion(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+	}
+
+	@Override
+	public void setRegion(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, BlockData arg6)
+	{
+		c.setRegion(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+	}
+}

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

@@ -28,4 +28,6 @@ public interface Queue<T>
 	{
 		return new ShurikenQueue<T>().queue(new KList<T>().add(t));
 	}
+
+	public boolean contains(T p);
 }

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

@@ -85,4 +85,10 @@ public class ShurikenQueue<T> implements Queue<T>
 	{
 		return queue.size();
 	}
+
+	@Override
+	public boolean contains(T p)
+	{
+		return queue.contains(p);
+	}
 }