Loads of fixes

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

@@ -13,6 +13,7 @@ import com.volmit.iris.object.IrisGenerator;
 import com.volmit.iris.object.IrisNoiseGenerator;
 import com.volmit.iris.object.IrisObjectPlacement;
 import com.volmit.iris.object.IrisRegion;
+import com.volmit.iris.object.IrisStructure;
 import com.volmit.iris.util.IO;
 import com.volmit.iris.util.JSONObject;
 import com.volmit.iris.util.ObjectResourceLoader;
@@ -29,6 +30,7 @@ public class IrisDataManager
 	private ResourceLoader<IrisRegion> regionLoader;
 	private ResourceLoader<IrisDimension> dimensionLoader;
 	private ResourceLoader<IrisGenerator> generatorLoader;
+	private ResourceLoader<IrisStructure> structureLoader;
 	private ObjectResourceLoader objectLoader;
 
 	public void hotloaded()
@@ -37,6 +39,7 @@ public class IrisDataManager
 		this.regionLoader = new ResourceLoader<>(packs, "regions", "Region", IrisRegion.class);
 		this.biomeLoader = new ResourceLoader<>(packs, "biomes", "Biome", IrisBiome.class);
 		this.dimensionLoader = new ResourceLoader<>(packs, "dimensions", "Dimension", IrisDimension.class);
+		this.structureLoader = new ResourceLoader<>(packs, "structures", "Structure", IrisStructure.class);
 		this.generatorLoader = new ResourceLoader<>(packs, "generators", "Generator", IrisGenerator.class);
 		this.objectLoader = new ObjectResourceLoader(packs, "objects", "Object");
 		writeExamples();

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

@@ -52,7 +52,7 @@ public class CommandIrisObjectPaste extends MortarCommand
 			sender.sendMessage("Can't find " + "objects/" + args[0] + ".iob");
 		}
 
-		ItemStack wand = ((Player) sender).getInventory().getItemInMainHand();
+		ItemStack wand = sender.player().getInventory().getItemInMainHand();
 		IrisObject o = new IrisObject(0, 0, 0);
 
 		try
@@ -60,8 +60,8 @@ public class CommandIrisObjectPaste extends MortarCommand
 			o.read(new File(Iris.instance.getDataFolder(), "objects/" + args[0] + ".iob"));
 			sender.sendMessage("Loaded " + "objects/" + args[0] + ".iob");
 
-			((Player) sender).getWorld().playSound(((Player) sender).getLocation(), Sound.BLOCK_ENCHANTMENT_TABLE_USE, 1f, 1.5f);
-			Location block = ((Player) sender).getTargetBlock((Set<Material>) null, 256).getLocation().clone().add(0, 1, 0);
+			sender.player().getWorld().playSound(sender.player().getLocation(), Sound.BLOCK_ENCHANTMENT_TABLE_USE, 1f, 1.5f);
+			Location block = sender.player().getTargetBlock((Set<Material>) null, 256).getLocation().clone().add(0, 1, 0);
 
 			if(intoWand && WandController.isWand(wand))
 			{

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

@@ -0,0 +1,60 @@
+package com.volmit.iris.command;
+
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.MortarCommand;
+import com.volmit.iris.util.MortarSender;
+import com.volmit.iris.util.PregenJob;
+
+public class CommandIrisPregen extends MortarCommand
+{
+	public CommandIrisPregen()
+	{
+		super("pregen");
+		setDescription("Pregen this world");
+		requiresPermission(Iris.perm.studio);
+		setCategory("Pregen");
+	}
+
+	@Override
+	public boolean handle(MortarSender sender, String[] args)
+	{
+		if(args[0].equalsIgnoreCase("stop"))
+		{
+			if(PregenJob.task == -1)
+			{
+				sender.sendMessage("No Active Pregens");
+			}
+			else
+			{
+				sender.sendMessage("Stopped all pregens.");
+			}
+			PregenJob.stop();
+			return true;
+		}
+
+		if(sender.isPlayer())
+		{
+			Player p = sender.player();
+			World world = p.getWorld();
+			new PregenJob(world, Integer.valueOf(args[0]));
+
+			return true;
+		}
+
+		else
+		{
+			sender.sendMessage("Players only.");
+		}
+
+		return true;
+	}
+
+	@Override
+	protected String getArgsUsage()
+	{
+		return "[width]";
+	}
+}

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

@@ -13,6 +13,9 @@ public class CommandIrisWorld extends MortarCommand
 	@Command
 	private CommandIrisMetrics metrics;
 
+	@Command
+	private CommandIrisPregen pregen;
+
 	public CommandIrisWorld()
 	{
 		super("world", "wrld");

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

@@ -13,6 +13,8 @@ import com.volmit.iris.gen.atomics.MasterLock;
 import com.volmit.iris.object.IrisBiome;
 import com.volmit.iris.object.IrisBiomeMutation;
 import com.volmit.iris.object.IrisObjectPlacement;
+import com.volmit.iris.object.IrisRegion;
+import com.volmit.iris.object.IrisStructurePlacement;
 import com.volmit.iris.util.BiomeMap;
 import com.volmit.iris.util.CaveResult;
 import com.volmit.iris.util.ChunkPosition;
@@ -220,6 +222,7 @@ public abstract class ParallaxChunkGenerator extends TerrainChunkGenerator imple
 				getAccelerant().queue(key, () ->
 				{
 					IrisBiome b = sampleTrueBiome((i * 16) + 7, (j * 16) + 7).getBiome();
+
 					RNG ro = random.nextParallelRNG(496888 + i + j);
 
 					int g = 1;
@@ -254,6 +257,18 @@ public abstract class ParallaxChunkGenerator extends TerrainChunkGenerator imple
 						}
 					}
 
+					IrisRegion r = sampleRegion((i * 16) + 7, (j * 16) + 7);
+
+					for(IrisStructurePlacement k : r.getStructures())
+					{
+						k.place(this, random, i, j);
+					}
+
+					for(IrisStructurePlacement k : b.getStructures())
+					{
+						k.place(this, random, i, j);
+					}
+
 					for(IrisObjectPlacement k : b.getObjects())
 					{
 						int gg = g++;

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

@@ -132,9 +132,9 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
 				}
 			}
 
-			for(int k = Math.max(height, fluidHeight); k < Math.max(height, fluidHeight) + 3 + Math.abs(airReversal); k++)
+			for(int k = Math.max(height, fluidHeight); k < Math.max(height, fluidHeight) + 12 + Math.abs(airReversal); k++)
 			{
-				if(k < Math.max(height, fluidHeight) + 3)
+				if(k < Math.max(height, fluidHeight) + 12)
 				{
 					if(biomeMap != null)
 					{

src/main/java/com/volmit/iris/gen/layer/BiomeDataProvider.java

@@ -2,7 +2,7 @@ package com.volmit.iris.gen.layer;
 
 import com.volmit.iris.object.InferredType;
 import com.volmit.iris.object.IrisRegion;
-import com.volmit.iris.util.BiomeRarityCellGenerator;
+import com.volmit.iris.util.RarityCellGenerator;
 import com.volmit.iris.util.BiomeResult;
 import com.volmit.iris.util.RNG;
 
@@ -12,14 +12,14 @@ import lombok.Data;
 public class BiomeDataProvider
 {
 	private InferredType type;
-	private BiomeRarityCellGenerator generator;
+	private RarityCellGenerator generator;
 	private GenLayerBiome layer;
 
 	public BiomeDataProvider(GenLayerBiome layer, InferredType type, RNG rng)
 	{
 		this.type = type;
 		this.layer = layer;
-		generator = new BiomeRarityCellGenerator(rng.nextParallelRNG(4645079 + (type.ordinal() * 23845)));
+		generator = new RarityCellGenerator(rng.nextParallelRNG(4645079 + (type.ordinal() * 23845)));
 	}
 
 	public BiomeResult generatePureData(double bx, double bz, int rawX, int rawZ, IrisRegion regionData)

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

@@ -7,7 +7,7 @@ import com.volmit.iris.object.IrisBiome;
 import com.volmit.iris.object.IrisRegion;
 import com.volmit.iris.object.IrisRegionRidge;
 import com.volmit.iris.object.IrisRegionSpot;
-import com.volmit.iris.util.BiomeRarityCellGenerator;
+import com.volmit.iris.util.RarityCellGenerator;
 import com.volmit.iris.util.BiomeResult;
 import com.volmit.iris.util.CellGenerator;
 import com.volmit.iris.util.GenLayer;
@@ -123,10 +123,10 @@ public class GenLayerBiome extends GenLayer
 		bridgeGenerator.setCellScale(0.33 / iris.getDimension().getContinentZoom());
 		double x = bx / iris.getDimension().getBiomeZoom();
 		double z = bz / iris.getDimension().getBiomeZoom();
-		return bridgeGenerator.getIndex(x, z, 5) == 1 ? InferredType.SEA : InferredType.LAND;
+		return bridgeGenerator.getIndex(x, z, 2) == 1 ? InferredType.SEA : InferredType.LAND;
 	}
 
-	public BiomeResult generateBiomeData(double bx, double bz, IrisRegion regionData, BiomeRarityCellGenerator cell, KList<IrisBiome> biomes, InferredType inferredType)
+	public BiomeResult generateBiomeData(double bx, double bz, IrisRegion regionData, RarityCellGenerator cell, KList<IrisBiome> biomes, InferredType inferredType)
 	{
 		if(biomes.isEmpty())
 		{
@@ -162,12 +162,12 @@ public class GenLayerBiome extends GenLayer
 		return pureResult;
 	}
 
-	public BiomeResult implode(double bx, double bz, IrisRegion regionData, BiomeRarityCellGenerator parentCell, BiomeResult parent)
+	public BiomeResult implode(double bx, double bz, IrisRegion regionData, RarityCellGenerator parentCell, BiomeResult parent)
 	{
 		return implode(bx, bz, regionData, parentCell, parent, 1);
 	}
 
-	public BiomeResult implode(double bx, double bz, IrisRegion regionData, BiomeRarityCellGenerator parentCell, BiomeResult parent, int hits)
+	public BiomeResult implode(double bx, double bz, IrisRegion regionData, RarityCellGenerator parentCell, BiomeResult parent, int hits)
 	{
 		if(hits > 9)
 		{
@@ -181,7 +181,7 @@ public class GenLayerBiome extends GenLayer
 		{
 			if(!parent.getBiome().getRealChildren().isEmpty())
 			{
-				BiomeRarityCellGenerator childCell = parent.getBiome().getChildrenGenerator(rng, 123, parentCell.getCellScale() * parent.getBiome().getChildShrinkFactor());
+				RarityCellGenerator childCell = parent.getBiome().getChildrenGenerator(rng, 123, parentCell.getCellScale() * parent.getBiome().getChildShrinkFactor());
 				KList<IrisBiome> chx = parent.getBiome().getRealChildren().copy();
 				chx.add(parent.getBiome());
 				IrisBiome biome = childCell.get(x, z, chx);

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

@@ -41,7 +41,7 @@ public class IrisAxisRotationClamp
 
 	public boolean isUnlimited()
 	{
-		return min == max;
+		return min == max && min == 0;
 	}
 
 	public double getRadians(int rng)
@@ -56,6 +56,11 @@ public class IrisAxisRotationClamp
 			return Math.toRadians(((double) interval * (Math.ceil(Math.abs((rng % 360D) / (double) interval)))) % 360D);
 		}
 
+		if(min == max && min != 0)
+		{
+			return Math.toRadians(max);
+		}
+
 		return Math.toRadians(M.clip(((double) interval * (Math.ceil(Math.abs((rng % 360D) / (double) interval)))) % 360D, Math.min(min, max), Math.max(min, max)));
 	}
 }

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

@@ -5,7 +5,7 @@ import org.bukkit.block.data.BlockData;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.gen.atomics.AtomicCache;
-import com.volmit.iris.util.BiomeRarityCellGenerator;
+import com.volmit.iris.util.RarityCellGenerator;
 import com.volmit.iris.util.CNG;
 import com.volmit.iris.util.Desc;
 import com.volmit.iris.util.DontObfuscate;
@@ -90,12 +90,16 @@ public class IrisBiome extends IrisRegistrant
 	@Desc("Generators for this biome. Multiple generators with different interpolation sizes will mix with other biomes how you would expect. This defines your biome height relative to the fluid height. Use negative for oceans.")
 	private KList<IrisBiomeGeneratorLink> generators = new KList<IrisBiomeGeneratorLink>().qadd(new IrisBiomeGeneratorLink());
 
+	@DontObfuscate
+	@Desc("A list of structure tilesets")
+	private KList<IrisStructurePlacement> structures = new KList<>();
+
 	@DontObfuscate
 	@Desc("Define biome deposit generators that add onto the existing regional and global deposit generators")
 	private KList<IrisDepositGenerator> deposits = new KList<>();
 
 	private transient InferredType inferredType;
-	private transient AtomicCache<BiomeRarityCellGenerator> childrenCell = new AtomicCache<>();
+	private transient AtomicCache<RarityCellGenerator> childrenCell = new AtomicCache<>();
 	private transient AtomicCache<CNG> biomeGenerator = new AtomicCache<>();
 	private transient AtomicCache<Integer> maxHeight = new AtomicCache<>();
 	private transient AtomicCache<KList<IrisBiome>> realChildren = new AtomicCache<>();
@@ -127,11 +131,11 @@ public class IrisBiome extends IrisRegistrant
 		});
 	}
 
-	public BiomeRarityCellGenerator getChildrenGenerator(RNG random, int sig, double scale)
+	public RarityCellGenerator getChildrenGenerator(RNG random, int sig, double scale)
 	{
 		return childrenCell.aquire(() ->
 		{
-			BiomeRarityCellGenerator childrenCell = new BiomeRarityCellGenerator(random.nextParallelRNG(sig * 2137));
+			RarityCellGenerator childrenCell = new RarityCellGenerator(random.nextParallelRNG(sig * 2137));
 			childrenCell.setCellScale(scale);
 			return childrenCell;
 		});

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

@@ -0,0 +1,54 @@
+package com.volmit.iris.object;
+
+import org.bukkit.block.data.BlockData;
+
+import com.volmit.iris.gen.atomics.AtomicCache;
+import com.volmit.iris.util.BlockDataTools;
+import com.volmit.iris.util.Desc;
+import com.volmit.iris.util.DontObfuscate;
+
+import lombok.Data;
+
+@Desc("Find and replace object materials for compatability")
+@Data
+public class IrisCompatabilityFilter
+{
+	@DontObfuscate
+	private String when;
+
+	@DontObfuscate
+	private String supplement;
+
+	@DontObfuscate
+	private boolean exact = false;
+
+	private transient AtomicCache<BlockData> findData = new AtomicCache<>();
+	private transient AtomicCache<BlockData> replaceData = new AtomicCache<>();
+
+	public IrisCompatabilityFilter(String when, String supplement)
+	{
+		this(when, supplement, false);
+	}
+
+	public IrisCompatabilityFilter(String when, String supplement, boolean exact)
+	{
+		this.when = when;
+		this.supplement = supplement;
+		this.exact = exact;
+	}
+
+	public IrisCompatabilityFilter()
+	{
+
+	}
+
+	public BlockData getFind()
+	{
+		return findData.aquire(() -> BlockDataTools.getBlockData(when));
+	}
+
+	public BlockData getReplace()
+	{
+		return replaceData.aquire(() -> BlockDataTools.getBlockData(supplement));
+	}
+}

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

@@ -101,6 +101,10 @@ public class IrisDimension extends IrisRegistrant
 	@Desc("Post Processors")
 	private KList<IrisPostProcessor> postProcessors = getDefaultPostProcessors();
 
+	@DontObfuscate
+	@Desc("Compatability filters")
+	private KList<IrisCompatabilityFilter> compatability = getDefaultCompatability();
+
 	@DontObfuscate
 	@Desc("The ceiling dimension. Leave blank for normal sky.")
 	private String ceiling = "";
@@ -246,6 +250,112 @@ public class IrisDimension extends IrisRegistrant
 		});
 	}
 
+	private KList<IrisCompatabilityFilter> getDefaultCompatability()
+	{
+		KList<IrisCompatabilityFilter> filters = new KList<>();
+
+		// Below 1.16
+		// TODO MORE
+		filters.add(new IrisCompatabilityFilter("CHISELED_NETHER_BRICKS", "NETHER_BRICKS"));
+		filters.add(new IrisCompatabilityFilter("NETHER_FENCE", "LEGACY_NETHER_FENCE"));
+		filters.add(new IrisCompatabilityFilter("CHAIN", "LEGACY_NETHER_FENCE"));
+		filters.add(new IrisCompatabilityFilter("NETHERITE_BLOCK", "QUARTZ_BLOCK"));
+		filters.add(new IrisCompatabilityFilter("BLACKSTONE", "COBBLESTONE"));
+		filters.add(new IrisCompatabilityFilter("BASALT", "STONE"));
+		filters.add(new IrisCompatabilityFilter("ANCIENT_DEBRIS", "NETHERRACK"));
+		filters.add(new IrisCompatabilityFilter("NETHERRACK", "LEGACY_NETHERRACK"));
+
+		// Below 1.15
+		filters.add(new IrisCompatabilityFilter("HONEY_BLOCK", "OAK_LEAVES"));
+		filters.add(new IrisCompatabilityFilter("BEEHIVE", "OAK_LEAVES"));
+		filters.add(new IrisCompatabilityFilter("BEE_NEST", "OAK_LEAVES"));
+
+		// Below 1.14
+		filters.add(new IrisCompatabilityFilter("GRANITE_WALL", "COBBLESTONE_WALL"));
+		filters.add(new IrisCompatabilityFilter("DIORITE_WALL", "COBBLESTONE_WALL"));
+		filters.add(new IrisCompatabilityFilter("ANDESITE_WALL", "COBBLESTONE_WALL"));
+		filters.add(new IrisCompatabilityFilter("SWEET_BERRY_BUSH", "GRASS"));
+		filters.add(new IrisCompatabilityFilter("STONECUTTER", "CRAFTING_TABLE"));
+		filters.add(new IrisCompatabilityFilter("SANDSTONE_STAIRS", "LEGACY_SANDSTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("SMOOTH_SANDSTONE_STAIRS", "LEGACY_SANDSTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("MOSSY_COBBLESTONE_STAIRS", "COBBLESTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("MOSSY_STONE_BRICK_STAIRS", "STONE_BRICK_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("POLISHED_GRANITE_STAIRS", "COBBLESTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("GRANITE_STAIRS", "COBBLESTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("POLISHED_DIORITE_STAIRS", "COBBLESTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("DIORITE_STAIRS", "COBBLESTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("POLISHED_ANDESITE_STAIRS", "COBBLESTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("ANDESITE_STAIRS", "COBBLESTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("STONE_STAIRS", "COBBLESTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("END_STONE_BRICK_STAIRS", "LEGACY_SANDSTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("NETHER_BRICK_STAIRS", "LEGACY_NETHER_BRICK_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("RED_NETHER_BRICK_STAIRS", "NETHER_BRICK_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("SMOOTH_QUARTZ_STAIRS", "LEGACY_QUARTZ_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("QUARTZ_STAIRS", "LEGACY_QUARTZ_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("RED_SANDSTONE_STAIRS", "LEGACY_RED_SANDSTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("SMOOTH_RED_SANDSTONE_STAIRS", "LEGACY_RED_SANDSTONE_STAIRS"));
+		filters.add(new IrisCompatabilityFilter("STONE_SLAB", "SMOOTH_STONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("SMOKER", "FURNACE"));
+		filters.add(new IrisCompatabilityFilter("SMITHING_TABLE", "CRAFTING_TABLE"));
+		filters.add(new IrisCompatabilityFilter("END_STONE_BRICK_SLAB", "SANDSTONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("RED_NETHER_BRICK_SLAB", "NETHER_BRICK_SLAB"));
+		filters.add(new IrisCompatabilityFilter("SMOOTH_QUARTZ_SLAB", "QUARTZ_SLAB"));
+		filters.add(new IrisCompatabilityFilter("CUT_SANDSTONE_SLAB", "SANDSTONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("CUT_RED_SANDSTONE_SLAB", "RED_SANDSTONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("SMOOTH_RED_SANDSTONE_SLAB", "RED_SANDSTONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("SMOOTH_SANDSTONE_SLAB", "SANDSTONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("MOSSY_COBBLESTONE_SLAB", "COBBLESTONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("MOSSY_STONE_BRICK_SLAB", "STONE_BRICK_SLAB"));
+		filters.add(new IrisCompatabilityFilter("STONE_SLAB", "SMOOTH_STONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("ANDESITE_SLAB", "COBBLESTONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("ANDESITE_SLAB", "COBBLESTONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("DIORITE_SLAB", "COBBLESTONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("GRANITE_SLAB", "COBBLESTONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("POLISHED_ANDESITE_SLAB", "SMOOTH_STONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("POLISHED_DIORITE_SLAB", "SMOOTH_STONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("POLISHED_GRANITE_SLAB", "SMOOTH_STONE_SLAB"));
+		filters.add(new IrisCompatabilityFilter("WARPED_WALL_SIGN", "LEGACY_WALL_SIGN"));
+		filters.add(new IrisCompatabilityFilter("WARPED_SIGN", "LEGACY_SIGN_POST"));
+		filters.add(new IrisCompatabilityFilter("SPRUCE_WALL_SIGN", "LEGACY_WALL_SIGN"));
+		filters.add(new IrisCompatabilityFilter("SPRUCE_SIGN", "LEGACY_SIGN_POST"));
+		filters.add(new IrisCompatabilityFilter("OAK_WALL_SIGN", "LEGACY_WALL_SIGN"));
+		filters.add(new IrisCompatabilityFilter("OAK_SIGN", "LEGACY_SIGN_POST"));
+		filters.add(new IrisCompatabilityFilter("JUNGLE_WALL_SIGN", "LEGACY_WALL_SIGN"));
+		filters.add(new IrisCompatabilityFilter("JUNGLE_SIGN", "LEGACY_SIGN_POST"));
+		filters.add(new IrisCompatabilityFilter("DARK_OAK_WALL_SIGN", "LEGACY_WALL_SIGN"));
+		filters.add(new IrisCompatabilityFilter("DARK_OAK_SIGN", "LEGACY_SIGN_POST"));
+		filters.add(new IrisCompatabilityFilter("CRIMSON_WALL_SIGN", "LEGACY_WALL_SIGN"));
+		filters.add(new IrisCompatabilityFilter("CRIMSON_SIGN", "LEGACY_SIGN_POST"));
+		filters.add(new IrisCompatabilityFilter("BIRCH_WALL_SIGN", "LEGACY_WALL_SIGN"));
+		filters.add(new IrisCompatabilityFilter("BIRCH_SIGN", "LEGACY_SIGN_POST"));
+		filters.add(new IrisCompatabilityFilter("ACACIA_WALL_SIGN", "LEGACY_WALL_SIGN"));
+		filters.add(new IrisCompatabilityFilter("ACACIA_SIGN", "LEGACY_SIGN_POST"));
+		filters.add(new IrisCompatabilityFilter("SCAFFOLDING", "BIRCH_FENCE"));
+		filters.add(new IrisCompatabilityFilter("LOOM", "LOOM"));
+		filters.add(new IrisCompatabilityFilter("LECTERN", "BOOKSHELF"));
+		filters.add(new IrisCompatabilityFilter("LANTERN", "REDSTONE_LAMP"));
+		filters.add(new IrisCompatabilityFilter("JIGSAW", "AIR"));
+		filters.add(new IrisCompatabilityFilter("GRINDSTONE", "COBBLESTONE"));
+		filters.add(new IrisCompatabilityFilter("FLETCHING_TABLE", "CRAFTING_TABLE"));
+		filters.add(new IrisCompatabilityFilter("COMPOSTER", "CHEST"));
+		filters.add(new IrisCompatabilityFilter("CARTOGRAPHY_TABLE", "CRAFTING_TABLE"));
+		filters.add(new IrisCompatabilityFilter("CAMPFIRE", "DARK_OAK_SLAB"));
+		filters.add(new IrisCompatabilityFilter("BLAST_FURNACE", "FURNACE"));
+		filters.add(new IrisCompatabilityFilter("BELL", "REDSTONE_LAMP"));
+		filters.add(new IrisCompatabilityFilter("minecraft:barrel[facing=south]", "minecraft:hay_bale[axis=z]", true));
+		filters.add(new IrisCompatabilityFilter("minecraft:barrel[facing=north]", "minecraft:hay_bale[axis=z]", true));
+		filters.add(new IrisCompatabilityFilter("minecraft:barrel[facing=east]", "minecraft:hay_bale[axis=x]", true));
+		filters.add(new IrisCompatabilityFilter("minecraft:barrel[facing=west]", "minecraft:hay_bale[axis=x]", true));
+		filters.add(new IrisCompatabilityFilter("minecraft:barrel[facing=up]", "minecraft:hay_bale[axis=y]", true));
+		filters.add(new IrisCompatabilityFilter("minecraft:barrel[facing=down]", "minecraft:hay_bale[axis=y]", true));
+		filters.add(new IrisCompatabilityFilter("BAMBOO", "BIRCH_FENCE"));
+		filters.add(new IrisCompatabilityFilter("BAMBOO_SAPLING", "BIRCH_SAPLING"));
+		filters.add(new IrisCompatabilityFilter("POTTED_BAMBOO", "POTTED_BIRCH_SAPLING"));
+		filters.add(new IrisCompatabilityFilter("*", "STONE"));
+
+		return filters;
+	}
+
 	public CNG getCoordFracture(RNG rng, int signature)
 	{
 		return coordFracture.aquire(() ->

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

@@ -29,6 +29,7 @@ import lombok.EqualsAndHashCode;
 public class IrisObject extends IrisRegistrant
 {
 	private static final Material SNOW = Material.SNOW;
+	private static final BlockData AIR = BlockDataTools.getBlockData("CAVE_AIR");
 	private static final BlockData[] SNOW_LAYERS = new BlockData[] {BlockDataTools.getBlockData("minecraft:snow[layers=1]"), BlockDataTools.getBlockData("minecraft:snow[layers=2]"), BlockDataTools.getBlockData("minecraft:snow[layers=3]"), BlockDataTools.getBlockData("minecraft:snow[layers=4]"), BlockDataTools.getBlockData("minecraft:snow[layers=5]"), BlockDataTools.getBlockData("minecraft:snow[layers=6]"), BlockDataTools.getBlockData("minecraft:snow[layers=7]"), BlockDataTools.getBlockData("minecraft:snow[layers=8]")};
 	private KMap<BlockVector, BlockData> blocks;
 	private int w;
@@ -131,6 +132,12 @@ public class IrisObject extends IrisRegistrant
 		int spiny = rng.imax() / 1000;
 		int spinz = rng.imax() / 1000;
 		int y = yv < 0 ? placer.getHighest(x, z, config.isUnderwater()) + config.getRotation().rotate(new BlockVector(0, getCenter().getBlockY(), 0), spinx, spiny, spinz).getBlockY() : yv;
+
+		if(yv >= 0 && config.isBottom())
+		{
+			y += Math.floorDiv(h, 2);
+		}
+
 		KMap<ChunkPosition, Integer> heightmap = config.getSnow() > 0 ? new KMap<>() : null;
 
 		if(yv < 0)
@@ -141,6 +148,20 @@ public class IrisObject extends IrisRegistrant
 			}
 		}
 
+		if(config.isBore())
+		{
+			for(int i = x - Math.floorDiv(w, 2); i <= x + Math.floorDiv(w, 2); i++)
+			{
+				for(int j = y - 1; j <= y + h - 2; j++)
+				{
+					for(int k = z - Math.floorDiv(d, 2); k <= z + Math.floorDiv(d, 2); k++)
+					{
+						placer.set(i, j, k, AIR);
+					}
+				}
+			}
+		}
+
 		for(BlockVector g : blocks.keySet())
 		{
 			BlockVector i = g.clone();

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

@@ -51,6 +51,14 @@ public class IrisObjectPlacement
 	@Desc("If set to true, this object will only place parts of itself where blocks already exist.")
 	private boolean meld = false;
 
+	@DontObfuscate
+	@Desc("If set to true, this object will place from the ground up instead of height checks when not y locked to the surface.")
+	private boolean bottom = false;
+
+	@DontObfuscate
+	@Desc("If set to true, air will be placed before the schematic places.")
+	private boolean bore = false;
+
 	public IrisObjectPlacement()
 	{
 

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

@@ -70,6 +70,10 @@ public class IrisRegion extends IrisRegistrant
 	@Desc("The biome implosion ratio, how much to implode biomes into children (chance)")
 	private double biomeImplosionRatio = 0.4;
 
+	@DontObfuscate
+	@Desc("A list of structure tilesets")
+	private KList<IrisStructurePlacement> structures = new KList<>();
+
 	@DontObfuscate
 	@Desc("A list of root-level biomes in this region. Don't specify child biomes of other biomes here. Just the root parents.")
 	private KList<String> landBiomes = new KList<>();

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

@@ -7,7 +7,7 @@ import lombok.Data;
 @Data
 public class IrisRegistrant
 {
-	private String loadKey;
+	private transient String loadKey;
 
-	private File loadFile;
+	private transient File loadFile;
 }

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

@@ -0,0 +1,163 @@
+package com.volmit.iris.object;
+
+import com.volmit.iris.gen.atomics.AtomicCache;
+import com.volmit.iris.util.CNG;
+import com.volmit.iris.util.Desc;
+import com.volmit.iris.util.DontObfuscate;
+import com.volmit.iris.util.KList;
+import com.volmit.iris.util.RNG;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@DontObfuscate
+@Desc("Represents a structure in iris.")
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class IrisStructure extends IrisRegistrant
+{
+	@DontObfuscate
+	@Desc("This is the human readable name for this structure. Such as Red Dungeon or Tropical Village.")
+	private String name = "A Structure Type";
+
+	@DontObfuscate
+	@Desc("This is the x and z size of each grid cell")
+	private int gridSize = 11;
+
+	@DontObfuscate
+	@Desc("This is the y size of each grid cell")
+	private int gridHeight = 5;
+
+	@DontObfuscate
+	@Desc("This is the maximum layers iris will generate for (height cells)")
+	private int maxLayers = 1;
+
+	@DontObfuscate
+	@Desc("This is the wall chance. Higher values makes more rooms and less open halls")
+	private double wallChance = 0.25;
+
+	@DontObfuscate
+	@Desc("Edges of tiles replace each other instead of having their own.")
+	private boolean mergeEdges = true;
+
+	@DontObfuscate
+	@Desc("The tiles")
+	private KList<IrisStructureTile> tiles = new KList<>();
+
+	@DontObfuscate
+	@Desc("This is the wall chance zoom")
+	private double wallChanceZoom = 1D;
+
+	@DontObfuscate
+	@Desc("The dispersion of walls")
+	private Dispersion dispersion = Dispersion.SCATTER;
+
+	private transient AtomicCache<CNG> wallGenerator = new AtomicCache<>();
+
+	public TileResult getTile(RNG rng, double x, double y, double z)
+	{
+		KList<StructureTileFace> walls = new KList<>();
+		boolean floor = isWall(rng, x, y, z, StructureTileFace.DOWN);
+		boolean ceiling = isWall(rng, x, y, z, StructureTileFace.UP);
+
+		if(isWall(rng, x, y, z, StructureTileFace.NORTH))
+		{
+			walls.add(StructureTileFace.NORTH);
+		}
+
+		if(isWall(rng, x, y, z, StructureTileFace.SOUTH))
+		{
+			walls.add(StructureTileFace.SOUTH);
+		}
+
+		if(isWall(rng, x, y, z, StructureTileFace.EAST))
+		{
+			walls.add(StructureTileFace.EAST);
+		}
+
+		if(isWall(rng, x, y, z, StructureTileFace.WEST))
+		{
+			walls.add(StructureTileFace.WEST);
+		}
+
+		int rt = 0;
+
+		for(int cx = 0; cx < 4; cx++)
+		{
+			for(IrisStructureTile i : tiles)
+			{
+				if(i.likeAGlove(floor, ceiling, walls))
+				{
+					return new TileResult(i, rt);
+				}
+			}
+
+			if(cx < 3)
+			{
+				rotate(walls);
+				rt += 90;
+			}
+		}
+
+		return null;
+	}
+
+	public void rotate(KList<StructureTileFace> faces)
+	{
+		for(int i = 0; i < faces.size(); i++)
+		{
+			faces.set(i, faces.get(i).rotate90CW());
+		}
+	}
+
+	public boolean isWall(RNG rng, double x, double y, double z, StructureTileFace face)
+	{
+		if(face == StructureTileFace.DOWN && maxLayers == 1)
+		{
+			return true;
+		}
+
+		return isWall(rng, x, y, z, (face.ordinal() + 12) * 3);
+	}
+
+	private boolean isWall(RNG rng, double x, double y, double z, int side)
+	{
+		return getWallGenerator(rng).fitDoubleD(0, 1, (getTileHorizon(x) + side) / wallChanceZoom, (getTileVertical(y) + side) / wallChanceZoom, (getTileHorizon(z) - side) / wallChanceZoom) < getWallChance();
+	}
+
+	public int getTileHorizon(double v)
+	{
+		return (int) Math.floor(v / gridSize);
+	}
+
+	public int getTileVertical(double v)
+	{
+		return (int) Math.floor(v / gridHeight);
+	}
+
+	public CNG getWallGenerator(RNG rng)
+	{
+		return wallGenerator.aquire(() ->
+		{
+			CNG wallGenerator = new CNG(rng);
+			RNG rngx = rng.nextParallelRNG((int) ((wallChance * 102005) + gridHeight - gridSize + maxLayers + tiles.size()));
+
+			switch(dispersion)
+			{
+				case SCATTER:
+					wallGenerator = CNG.signature(rngx).freq(1000000);
+					break;
+				case WISPY:
+					wallGenerator = CNG.signature(rngx);
+					break;
+			}
+
+			return wallGenerator;
+		});
+	}
+
+	public IrisStructure()
+	{
+
+	}
+}

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

@@ -0,0 +1,134 @@
+package com.volmit.iris.object;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.gen.ParallaxChunkGenerator;
+import com.volmit.iris.gen.atomics.AtomicCache;
+import com.volmit.iris.util.CellGenerator;
+import com.volmit.iris.util.Desc;
+import com.volmit.iris.util.DontObfuscate;
+import com.volmit.iris.util.RNG;
+
+import lombok.Data;
+
+@Data
+public class IrisStructurePlacement
+{
+	@DontObfuscate
+	@Desc("The structure tileset to use")
+	private String tileset = "";
+
+	@DontObfuscate
+	@Desc("The structure chance zoom. Higher = bigger cells, further away")
+	private double zoom = 1D;
+
+	@DontObfuscate
+	@Desc("The ratio. Lower values means cells can get closer to other cells. Negative values means make veins of structures")
+	private double ratio = 0.25D;
+
+	@DontObfuscate
+	@Desc("The rarity for this structure")
+	private int rarity = 4;
+
+	@DontObfuscate
+	@Desc("The height or -1 for surface")
+	private int height = -1;
+
+	@DontObfuscate
+	@Desc("The chance cell shuffle (rougher edges)")
+	private double shuffle = 22;
+
+	private transient AtomicCache<CellGenerator> chanceCell = new AtomicCache<>();
+	private transient AtomicCache<IrisStructure> structure = new AtomicCache<>();
+	private transient AtomicCache<IrisObjectPlacement> config = new AtomicCache<>();
+
+	public IrisStructurePlacement()
+	{
+
+	}
+
+	public void place(ParallaxChunkGenerator g, RNG rng, int cx, int cz)
+	{
+		try
+		{
+			TileResult t;
+			IrisObject o;
+			int h;
+			RNG rnp = rng.nextParallelRNG(cx - (cz * cz));
+			int s = gridSize() - (getStructure().isMergeEdges() ? 1 : 0);
+
+			for(int i = cx << 4; i < (cx << 4) + 15; i += Math.max(s / 2, 1))
+			{
+				for(int j = cz << 4; j < (cz << 4) + 15; j += Math.max(s / 2, 1))
+				{
+					for(int k = 0; k < s * getStructure().getMaxLayers(); k += Math.max(s, 1))
+					{
+						if(!hasStructure(rng, i, k, j))
+						{
+							continue;
+						}
+
+						h = (height == -1 ? 0 : height) + (Math.floorDiv(k, s) * s);
+						t = getStructure().getTile(rng, i / zoom, h / zoom, j / zoom);
+
+						if(t != null)
+						{
+							if(height >= 0)
+							{
+								t.getPlacement().setBore(true);
+							}
+
+							o = load(t.getTile().getObjects().get(rnp.nextInt(t.getTile().getObjects().size())));
+							o.place(Math.floorDiv(i, s) * s, height == -1 ? -1 : h, Math.floorDiv(j, s) * s, g, t.getPlacement(), rng);
+						}
+					}
+				}
+			}
+		}
+
+		catch(Throwable e)
+		{
+			e.printStackTrace();
+		}
+	}
+
+	private IrisObjectPlacement getConfig()
+	{
+		return config.aquire(() -> new IrisObjectPlacement());
+	}
+
+	public IrisObject load(String s)
+	{
+		return Iris.data.getObjectLoader().load(s);
+	}
+
+	public int gridSize()
+	{
+		return getStructure().getGridSize();
+	}
+
+	public IrisStructure getStructure()
+	{
+		return structure.aquire(() -> Iris.data.getStructureLoader().load(getTileset()));
+	}
+
+	public boolean hasStructure(RNG random, double x, double y, double z)
+	{
+		if(getChanceGenerator(random).getIndex(x, y, z, getRarity()) == getRarity() / 2)
+		{
+			return ratio > 0 ? getChanceGenerator(random).getDistance(x, z) > ratio : getChanceGenerator(random).getDistance(x, z) < Math.abs(ratio);
+		}
+
+		return false;
+	}
+
+	public CellGenerator getChanceGenerator(RNG random)
+	{
+		return chanceCell.aquire(() ->
+		{
+			CellGenerator chanceCell = new CellGenerator(random.nextParallelRNG(-72346));
+			chanceCell.setCellScale(1D);
+			chanceCell.setShuffle(getShuffle());
+			return chanceCell;
+		});
+	}
+}

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

@@ -0,0 +1,95 @@
+package com.volmit.iris.object;
+
+import com.volmit.iris.util.Desc;
+import com.volmit.iris.util.DontObfuscate;
+import com.volmit.iris.util.KList;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@DontObfuscate
+@Desc("Represents a structure tile")
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class IrisStructureTile
+{
+	@DontObfuscate
+	@Desc("Is this structure allowed to place if there is supposed to be a ceiling?")
+	private StructureTileCondition ceiling = StructureTileCondition.AGNOSTIC;
+
+	@DontObfuscate
+	@Desc("Is this structure allowed to place if there is supposed to be a floor?")
+	private StructureTileCondition floor = StructureTileCondition.REQUIRED;
+
+	@DontObfuscate
+	@Desc("Is this structure allowed to place if there is supposed to be a north wall?")
+	private StructureTileCondition north = StructureTileCondition.AGNOSTIC;
+
+	@DontObfuscate
+	@Desc("Is this structure allowed to place if there is supposed to be a south wall?")
+	private StructureTileCondition south = StructureTileCondition.AGNOSTIC;
+
+	@DontObfuscate
+	@Desc("Is this structure allowed to place if there is supposed to be a east wall?")
+	private StructureTileCondition east = StructureTileCondition.AGNOSTIC;
+
+	@DontObfuscate
+	@Desc("Is this structure allowed to place if there is supposed to be a west wall?")
+	private StructureTileCondition west = StructureTileCondition.AGNOSTIC;
+
+	@DontObfuscate
+	@Desc("List of objects to place centered in this tile")
+	private KList<String> objects = new KList<>();
+
+	public IrisStructureTile()
+	{
+
+	}
+
+	public boolean likeAGlove(boolean floor, boolean ceiling, KList<StructureTileFace> walls)
+	{
+		//@builder
+		
+		if((getFloor().required() && !floor) || (getCeiling().required() && !ceiling))
+		{
+			return false;
+		}
+		
+		if((!getFloor().supported() && floor) || (!getCeiling().supported() && ceiling))
+		{
+			return false;
+		}
+	
+		if(!fitsWalls(walls))
+		{
+			return false;
+		}
+				
+		//@done
+
+		return true;
+	}
+
+	private boolean fitsWalls(KList<StructureTileFace> walls)
+	{
+		//@builder
+		if((getNorth().required() && !walls.contains(StructureTileFace.NORTH)) 
+				|| (getSouth().required() && !walls.contains(StructureTileFace.SOUTH)) 
+				|| (getEast().required() && !walls.contains(StructureTileFace.EAST)) 
+				|| (getWest().required() && !walls.contains(StructureTileFace.WEST)))
+		{
+			return false;
+		}
+		
+		if((!getNorth().supported() && walls.contains(StructureTileFace.NORTH)) 
+				|| (!getSouth().supported() && walls.contains(StructureTileFace.SOUTH)) 
+				|| (!getEast().supported() && walls.contains(StructureTileFace.EAST)) 
+				|| (!getWest().supported() && walls.contains(StructureTileFace.WEST)))
+		{
+			return false;
+		}
+		//@done
+
+		return true;
+	}
+}

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

@@ -0,0 +1,25 @@
+package com.volmit.iris.object;
+
+import com.volmit.iris.util.DontObfuscate;
+
+public enum StructureTileCondition
+{
+	@DontObfuscate
+	REQUIRED,
+
+	@DontObfuscate
+	AGNOSTIC,
+
+	@DontObfuscate
+	NEVER;
+
+	public boolean supported()
+	{
+		return !this.equals(NEVER);
+	}
+
+	public boolean required()
+	{
+		return this.equals(REQUIRED);
+	}
+}

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

@@ -0,0 +1,28 @@
+package com.volmit.iris.object;
+
+public enum StructureTileFace
+{
+	UP,
+	DOWN,
+	NORTH,
+	SOUTH,
+	EAST,
+	WEST;
+
+	public StructureTileFace rotate90CW()
+	{
+		switch(this)
+		{
+			case EAST:
+				return SOUTH;
+			case NORTH:
+				return EAST;
+			case SOUTH:
+				return WEST;
+			case WEST:
+				return NORTH;
+			default:
+				return this;
+		}
+	}
+}

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

@@ -0,0 +1,21 @@
+package com.volmit.iris.object;
+
+import lombok.Data;
+
+@Data
+public class TileResult
+{
+	private IrisStructureTile tile;
+	private IrisObjectPlacement placement;
+
+	public TileResult(IrisStructureTile tile, int rot)
+	{
+		this.tile = tile;
+		IrisObjectPlacement p = new IrisObjectPlacement();
+		IrisObjectRotation rt = new IrisObjectRotation();
+		rt.setYAxis(new IrisAxisRotationClamp(rot != 0, rot, rot, 0));
+		p.setRotation(rt);
+		p.setBottom(true);
+		placement = p;
+	}
+}

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

@@ -58,6 +58,20 @@ public class CellGenerator
 		return ((fn.GetCellular((float) ((x * cellScale) + (cng.noise(x, z) * shuffle)), (float) ((z * cellScale) + (cng.noise(z, x) * shuffle))) + 1f) / 2f) * (possibilities - 1);
 	}
 
+	public float getValue(double x, double y, double z, int possibilities)
+	{
+		if(possibilities == 1)
+		{
+			return 0;
+		}
+
+		return ((fn.GetCellular((float) ((x * cellScale) + (cng.noise(x, z) * shuffle)),
+
+				(float) ((y * cellScale) + (cng.noise(x, y) * shuffle))
+
+				, (float) ((z * cellScale) + (cng.noise(z, x) * shuffle))) + 1f) / 2f) * (possibilities - 1);
+	}
+
 	public int getIndex(double x, double z, int possibilities)
 	{
 		if(possibilities == 1)
@@ -67,4 +81,14 @@ public class CellGenerator
 
 		return (int) Math.round(getValue(x, z, possibilities));
 	}
+
+	public int getIndex(double x, double y, double z, int possibilities)
+	{
+		if(possibilities == 1)
+		{
+			return 0;
+		}
+
+		return (int) Math.round(getValue(x, y, z, possibilities));
+	}
 }

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

@@ -0,0 +1,186 @@
+package com.volmit.iris.util;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+
+import com.volmit.iris.Iris;
+
+public class PregenJob
+{
+	private World world;
+	private int size;
+	private int mcaX;
+	private int mcaZ;
+	private int rcx;
+	private int rcz;
+	private int total;
+	private int genned;
+	private boolean completed;
+	public static int task = -1;
+	private PrecisionStopwatch s;
+	private ChronoLatch cl;
+
+	public PregenJob(World world, int size)
+	{
+		this.s = PrecisionStopwatch.start();
+		this.world = world;
+		this.size = size;
+		world.getWorldBorder().setCenter(0, 0);
+		world.getWorldBorder().setWarningDistance(64);
+		world.getWorldBorder().setSize(size);
+		mcaX = mca(min());
+		mcaZ = mca(min());
+		rcx = 0;
+		cl = new ChronoLatch(3000);
+		rcz = 0;
+		total = (size / 16) * (size / 16);
+		genned = 0;
+		completed = false;
+
+		if(task != -1)
+		{
+			stop();
+		}
+
+		task = Bukkit.getScheduler().scheduleSyncRepeatingTask(Iris.instance, this::onTick, 0, 0);
+	}
+
+	public static void stop()
+	{
+		try
+		{
+			Bukkit.getScheduler().cancelTask(task);
+		}
+
+		catch(Throwable e)
+		{
+
+		}
+		task = -1;
+	}
+
+	public void onTick()
+	{
+		if(completed)
+		{
+			return;
+		}
+
+		PrecisionStopwatch p = PrecisionStopwatch.start();
+
+		while(p.getMilliseconds() < 1500)
+		{
+			tick();
+		}
+
+		if(cl.flip())
+		{
+			tickMetrics();
+		}
+	}
+
+	private void tickMetrics()
+	{
+		long eta = (long) ((total - genned) * (s.getMilliseconds() / (double) genned));
+		Iris.info("Pregen: Generating: " + Form.pc(Math.min((double) genned / (double) total, 1.0), 0) + ", Elapsed: " + Form.duration((long) s.getMilliseconds()) + ", ETA: " + (genned >= total - 5 ? "Any second..." : s.getMilliseconds() < 25000 ? "Calculating..." : Form.duration(eta)) + " MS: " + Form.duration((s.getMilliseconds() / (double) genned), 2));
+	}
+
+	public void tick()
+	{
+		gen();
+		nextPosition();
+	}
+
+	public void nextPosition()
+	{
+		rcx++;
+
+		if(rcx > 31)
+		{
+			rcx = 0;
+			rcz++;
+
+			if(rcz > 31)
+			{
+				rcz = 0;
+				mcaX++;
+
+				if(mcaX > mca(max() / 16))
+				{
+					mcaX = mca(min() / 16);
+					mcaZ++;
+
+					if(mcaZ > mca(max() / 16))
+					{
+						mcaZ = mca(min() / 16);
+						completed = true;
+						stop();
+						Iris.info("Pregen Completed!");
+
+						for(Chunk i : world.getLoadedChunks())
+						{
+							i.unload(true);
+						}
+
+						world.save();
+						return;
+					}
+
+					world.save();
+				}
+			}
+		}
+	}
+
+	public void gen()
+	{
+		try
+		{
+			if(isChunkWithin(rcx + minMCA(mcaX), rcz + minMCA(mcaZ)))
+			{
+				Chunk c = world.getChunkAt(rcx + minMCA(mcaX), rcz + minMCA(mcaZ));
+				c.load(true);
+				world.unloadChunkRequest(rcx + minMCA(mcaX), rcz + minMCA(mcaZ));
+				genned++;
+			}
+		}
+
+		catch(Throwable e)
+		{
+			Iris.warn("Pregen Crash!");
+			e.printStackTrace();
+			stop();
+		}
+	}
+
+	public int minMCA(int v)
+	{
+		return v << 5;
+	}
+
+	public int maxMCA(int v)
+	{
+		return (v << 5) + 31;
+	}
+
+	public int mca(int v)
+	{
+		return v >> 5;
+	}
+
+	public int max()
+	{
+		return size / 2;
+	}
+
+	public int min()
+	{
+		return -max();
+	}
+
+	public boolean isChunkWithin(int x, int z)
+	{
+		return Math.abs(z * 16) <= size / 2 && Math.abs(z * 16) <= size / 2;
+	}
+}

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

@@ -2,9 +2,9 @@ package com.volmit.iris.util;
 
 import com.volmit.iris.object.IrisBiome;
 
-public class BiomeRarityCellGenerator extends CellGenerator
+public class RarityCellGenerator extends CellGenerator
 {
-	public BiomeRarityCellGenerator(RNG rng)
+	public RarityCellGenerator(RNG rng)
 	{
 		super(rng);
 	}