Fixes & Mem improvements

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);
+	}
 }