Fixes

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

@@ -26,7 +26,8 @@ import lombok.EqualsAndHashCode;
 @Desc("Represents a biome in iris. Biomes are placed inside of regions and hold objects.")
 @Data
 @EqualsAndHashCode(callSuper = false)
-public class IrisBiome extends IrisRegistrant implements IRare {
+public class IrisBiome extends IrisRegistrant implements IRare
+{
 	@MinNumber(2)
 	@Required
 	@DontObfuscate
@@ -39,13 +40,13 @@ public class IrisBiome extends IrisRegistrant implements IRare {
 	private KList<IrisEffect> effects = new KList<>();
 
 	@DontObfuscate
-	@DependsOn({ "biomeStyle", "biomeZoom", "biomeScatter" })
+	@DependsOn({"biomeStyle", "biomeZoom", "biomeScatter"})
 	@Desc("This changes the dispersion of the biome colors if multiple derivatives are chosen.")
 	private IrisGeneratorStyle biomeStyle = NoiseStyle.SIMPLEX.style();
 
 	@MinNumber(0.0001)
 	@DontObfuscate
-	@DependsOn({ "biomeStyle", "biomeZoom", "biomeScatter" })
+	@DependsOn({"biomeStyle", "biomeZoom", "biomeScatter"})
 	@Desc("This zooms in the biome colors if multiple derivatives are chosen")
 	private double biomeZoom = 1;
 
@@ -75,12 +76,12 @@ public class IrisBiome extends IrisRegistrant implements IRare {
 	private KList<Biome> biomeSkyScatter = new KList<>();
 
 	@DontObfuscate
-	@DependsOn({ "children" })
+	@DependsOn({"children"})
 	@Desc("If this biome has children biomes, and the gen layer chooses one of this biomes children, how much smaller will it be (inside of this biome). Higher values means a smaller biome relative to this biome's size. Set higher than 1.0 and below 3.0 for best results.")
 	private double childShrinkFactor = 1.5;
 
 	@DontObfuscate
-	@DependsOn({ "children" })
+	@DependsOn({"children"})
 	@Desc("If this biome has children biomes, and the gen layer chooses one of this biomes children, How will it be shaped?")
 	private IrisGeneratorStyle childStyle = NoiseStyle.CELLULAR_IRIS_DOUBLE.style();
 
@@ -122,8 +123,7 @@ public class IrisBiome extends IrisRegistrant implements IRare {
 	@ArrayType(min = 1, type = IrisBiomeGeneratorLink.class)
 	@DontObfuscate
 	@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());
+	private KList<IrisBiomeGeneratorLink> generators = new KList<IrisBiomeGeneratorLink>().qadd(new IrisBiomeGeneratorLink());
 
 	@ArrayType(min = 1, type = IrisStructurePlacement.class)
 	@DontObfuscate
@@ -143,67 +143,80 @@ public class IrisBiome extends IrisRegistrant implements IRare {
 	private transient AtomicCache<KList<CNG>> layerHeightGenerators = new AtomicCache<>();
 	private transient AtomicCache<KList<CNG>> layerSeaHeightGenerators = new AtomicCache<>();
 
-	public IrisBiome() {
+	public IrisBiome()
+	{
 
 	}
 
-	public double getHeight(ContextualChunkGenerator xg, double x, double z, long seed) {
+	public double getHeight(ContextualChunkGenerator xg, double x, double z, long seed)
+	{
 		double height = 0;
 
-		for (IrisBiomeGeneratorLink i : generators) {
+		for(IrisBiomeGeneratorLink i : generators)
+		{
 			height += i.getHeight(xg, x, z, seed);
 		}
 
 		return Math.max(0, Math.min(height, 255));
 	}
 
-	public CNG getBiomeGenerator(RNG random) {
-		return biomeGenerator.aquire(() -> {
+	public CNG getBiomeGenerator(RNG random)
+	{
+		return biomeGenerator.aquire(() ->
+		{
 			return biomeStyle.create(random.nextParallelRNG(213949 + 228888 + getRarity() + getName().length()));
 		});
 	}
 
-	public CNG getChildrenGenerator(RNG random, int sig, double scale) {
-		return childrenCell
-				.aquire(() -> getChildStyle().create(random.nextParallelRNG(sig * 2137)).bake().scale(scale).bake());
+	public CNG getChildrenGenerator(RNG random, int sig, double scale)
+	{
+		return childrenCell.aquire(() -> getChildStyle().create(random.nextParallelRNG(sig * 2137)).bake().scale(scale).bake());
 	}
 
-	public KList<BlockData> generateLayers(double wx, double wz, RNG random, int maxDepth, int height) {
-		if (isLockLayers()) {
+	public KList<BlockData> generateLayers(double wx, double wz, RNG random, int maxDepth, int height)
+	{
+		if(isLockLayers())
+		{
 			return generateLockedLayers(wx, wz, random, maxDepth, height);
 		}
 
 		KList<BlockData> data = new KList<>();
 
-		if (maxDepth <= 0) {
+		if(maxDepth <= 0)
+		{
 			return data;
 		}
 
-		for (int i = 0; i < layers.size(); i++) {
+		for(int i = 0; i < layers.size(); i++)
+		{
 			CNG hgen = getLayerHeightGenerators(random).get(i);
-			int d = hgen.fit(layers.get(i).getMinHeight(), layers.get(i).getMaxHeight(), wx / layers.get(i).getZoom(),
-					wz / layers.get(i).getZoom());
+			int d = hgen.fit(layers.get(i).getMinHeight(), layers.get(i).getMaxHeight(), wx / layers.get(i).getZoom(), wz / layers.get(i).getZoom());
 
-			if (d < 0) {
+			if(d < 0)
+			{
 				continue;
 			}
 
-			for (int j = 0; j < d; j++) {
-				if (data.size() >= maxDepth) {
+			for(int j = 0; j < d; j++)
+			{
+				if(data.size() >= maxDepth)
+				{
 					break;
 				}
 
-				try {
-					data.add(getLayers().get(i).get(random.nextParallelRNG(i + j), (wx + j) / layers.get(i).getZoom(),
-							j, (wz - j) / layers.get(i).getZoom()));
+				try
+				{
+					data.add(getLayers().get(i).get(random.nextParallelRNG(i + j), (wx + j) / layers.get(i).getZoom(), j, (wz - j) / layers.get(i).getZoom()));
 				}
 
-				catch (Throwable e) {
+				catch(Throwable e)
+				{
 					e.printStackTrace();
 				}
 			}
 
-			if (data.size() >= maxDepth) {
+			if(data.size() >= maxDepth)
+			{
 				break;
 			}
 		}
@@ -211,40 +224,47 @@ public class IrisBiome extends IrisRegistrant implements IRare {
 		return data;
 	}
 
-	public KList<BlockData> generateLockedLayers(double wx, double wz, RNG random, int maxDepth, int height) {
+	public KList<BlockData> generateLockedLayers(double wx, double wz, RNG random, int maxDepth, int height)
+	{
 		KList<BlockData> data = new KList<>();
 		KList<BlockData> real = new KList<>();
 
-		if (maxDepth <= 0) {
+		if(maxDepth <= 0)
+		{
 			return data;
 		}
 
-		for (int i = 0; i < layers.size(); i++) {
+		for(int i = 0; i < layers.size(); i++)
+		{
 			CNG hgen = getLayerHeightGenerators(random).get(i);
-			int d = hgen.fit(layers.get(i).getMinHeight(), layers.get(i).getMaxHeight(), wx / layers.get(i).getZoom(),
-					wz / layers.get(i).getZoom());
+			int d = hgen.fit(layers.get(i).getMinHeight(), layers.get(i).getMaxHeight(), wx / layers.get(i).getZoom(), wz / layers.get(i).getZoom());
 
-			if (d < 0) {
+			if(d < 0)
+			{
 				continue;
 			}
 
-			for (int j = 0; j < d; j++) {
-				try {
-					data.add(getLayers().get(i).get(random.nextParallelRNG(i + j), (wx + j) / layers.get(i).getZoom(),
-							j, (wz - j) / layers.get(i).getZoom()));
+			for(int j = 0; j < d; j++)
+			{
+				try
+				{
+					data.add(getLayers().get(i).get(random.nextParallelRNG(i + j), (wx + j) / layers.get(i).getZoom(), j, (wz - j) / layers.get(i).getZoom()));
 				}
 
-				catch (Throwable e) {
+				catch(Throwable e)
+				{
 					e.printStackTrace();
 				}
 			}
 		}
 
-		if (data.isEmpty()) {
+		if(data.isEmpty())
+		{
 			return real;
 		}
 
-		for (int i = 0; i < maxDepth; i++) {
+		for(int i = 0; i < maxDepth; i++)
+		{
 			int offset = (getMaxHeight() - height) - i;
 			int index = offset % data.size();
 			real.add(data.get(index < 0 ? 0 : index));
@@ -253,11 +273,14 @@ public class IrisBiome extends IrisRegistrant implements IRare {
 		return real;
 	}
 
-	private int getMaxHeight() {
-		return maxHeight.aquire(() -> {
+	private int getMaxHeight()
+	{
+		return maxHeight.aquire(() ->
+		{
 			int maxHeight = 0;
 
-			for (IrisBiomeGeneratorLink i : getGenerators()) {
+			for(IrisBiomeGeneratorLink i : getGenerators())
+			{
 				maxHeight += i.getMax();
 			}
 
@@ -265,39 +288,46 @@ public class IrisBiome extends IrisRegistrant implements IRare {
 		});
 	}
 
-	public IrisBiome infer(InferredType t, InferredType type) {
+	public IrisBiome infer(InferredType t, InferredType type)
+	{
 		setInferredType(t.equals(InferredType.DEFER) ? type : t);
 		return this;
 	}
 
-	public KList<BlockData> generateSeaLayers(double wx, double wz, RNG random, int maxDepth) {
+	public KList<BlockData> generateSeaLayers(double wx, double wz, RNG random, int maxDepth)
+	{
 		KList<BlockData> data = new KList<>();
 
-		for (int i = 0; i < seaLayers.size(); i++) {
+		for(int i = 0; i < seaLayers.size(); i++)
+		{
 			CNG hgen = getLayerSeaHeightGenerators(random).get(i);
-			int d = hgen.fit(seaLayers.get(i).getMinHeight(), seaLayers.get(i).getMaxHeight(),
-					wx / seaLayers.get(i).getZoom(), wz / seaLayers.get(i).getZoom());
+			int d = hgen.fit(seaLayers.get(i).getMinHeight(), seaLayers.get(i).getMaxHeight(), wx / seaLayers.get(i).getZoom(), wz / seaLayers.get(i).getZoom());
 
-			if (d < 0) {
+			if(d < 0)
+			{
 				continue;
 			}
 
-			for (int j = 0; j < d; j++) {
-				if (data.size() >= maxDepth) {
+			for(int j = 0; j < d; j++)
+			{
+				if(data.size() >= maxDepth)
+				{
 					break;
 				}
 
-				try {
-					data.add(getSeaLayers().get(i).get(random.nextParallelRNG(i + j),
-							(wx + j) / seaLayers.get(i).getZoom(), j, (wz - j) / seaLayers.get(i).getZoom()));
+				try
+				{
+					data.add(getSeaLayers().get(i).get(random.nextParallelRNG(i + j), (wx + j) / seaLayers.get(i).getZoom(), j, (wz - j) / seaLayers.get(i).getZoom()));
 				}
 
-				catch (Throwable e) {
+				catch(Throwable e)
+				{
 					e.printStackTrace();
 				}
 			}
 
-			if (data.size() >= maxDepth) {
+			if(data.size() >= maxDepth)
+			{
 				break;
 			}
 		}
@@ -305,13 +335,16 @@ public class IrisBiome extends IrisRegistrant implements IRare {
 		return data;
 	}
 
-	public KList<CNG> getLayerHeightGenerators(RNG rng) {
-		return layerHeightGenerators.aquire(() -> {
+	public KList<CNG> getLayerHeightGenerators(RNG rng)
+	{
+		return layerHeightGenerators.aquire(() ->
+		{
 			KList<CNG> layerHeightGenerators = new KList<>();
 
 			int m = 7235;
 
-			for (IrisBiomePaletteLayer i : getLayers()) {
+			for(IrisBiomePaletteLayer i : getLayers())
+			{
 				layerHeightGenerators.add(i.getHeightGenerator(rng.nextParallelRNG((m++) * m * m * m)));
 			}
 
@@ -319,13 +352,16 @@ public class IrisBiome extends IrisRegistrant implements IRare {
 		});
 	}
 
-	public KList<CNG> getLayerSeaHeightGenerators(RNG rng) {
-		return layerSeaHeightGenerators.aquire(() -> {
+	public KList<CNG> getLayerSeaHeightGenerators(RNG rng)
+	{
+		return layerSeaHeightGenerators.aquire(() ->
+		{
 			KList<CNG> layerSeaHeightGenerators = new KList<>();
 
 			int m = 7735;
 
-			for (IrisBiomePaletteLayer i : getSeaLayers()) {
+			for(IrisBiomePaletteLayer i : getSeaLayers())
+			{
 				layerSeaHeightGenerators.add(i.getHeightGenerator(rng.nextParallelRNG((m++) * m * m * m)));
 			}
 
@@ -333,45 +369,57 @@ public class IrisBiome extends IrisRegistrant implements IRare {
 		});
 	}
 
-	public boolean isLand() {
-		if (inferredType == null) {
+	public boolean isLand()
+	{
+		if(inferredType == null)
+		{
 			return true;
 		}
 
 		return inferredType.equals(InferredType.LAND);
 	}
 
-	public boolean isSea() {
-		if (inferredType == null) {
+	public boolean isSea()
+	{
+		if(inferredType == null)
+		{
 			return false;
 		}
 		return inferredType.equals(InferredType.SEA);
 	}
 
-	public boolean isShore() {
-		if (inferredType == null) {
+	public boolean isShore()
+	{
+		if(inferredType == null)
+		{
 			return false;
 		}
 		return inferredType.equals(InferredType.SHORE);
 	}
 
-	public Biome getSkyBiome(RNG rng, double x, double y, double z) {
-		if (biomeSkyScatter.size() == 1) {
+	public Biome getSkyBiome(RNG rng, double x, double y, double z)
+	{
+		if(biomeSkyScatter.size() == 1)
+		{
 			return biomeSkyScatter.get(0);
 		}
 
-		if (biomeSkyScatter.isEmpty()) {
+		if(biomeSkyScatter.isEmpty())
+		{
 			return getGroundBiome(rng, x, y, z);
 		}
 
 		return biomeSkyScatter.get(getBiomeGenerator(rng).fit(0, biomeSkyScatter.size() - 1, x, y, z));
 	}
 
-	public KList<IrisBiome> getRealChildren(ContextualChunkGenerator g) {
-		return realChildren.aquire(() -> {
+	public KList<IrisBiome> getRealChildren(ContextualChunkGenerator g)
+	{
+		return realChildren.aquire(() ->
+		{
 			KList<IrisBiome> realChildren = new KList<>();
 
-			for (String i : getChildren()) {
+			for(String i : getChildren())
+			{
 				realChildren.add(g != null ? g.loadBiome(i) : Iris.globaldata.getBiomeLoader().load(i));
 			}
 
@@ -379,13 +427,16 @@ public class IrisBiome extends IrisRegistrant implements IRare {
 		});
 	}
 
-	public KList<String> getAllChildren(ContextualChunkGenerator g, int limit) {
+	public KList<String> getAllChildren(ContextualChunkGenerator g, int limit)
+	{
 		KSet<String> m = new KSet<>();
 		m.addAll(getChildren());
 		limit--;
 
-		if (limit > 0) {
-			for (String i : getChildren()) {
+		if(limit > 0)
+		{
+			for(String i : getChildren())
+			{
 				IrisBiome b = g != null ? g.loadBiome(i) : Iris.globaldata.getBiomeLoader().load(i);
 				int l = limit;
 				m.addAll(b.getAllChildren(g, l));
@@ -395,12 +446,15 @@ public class IrisBiome extends IrisRegistrant implements IRare {
 		return new KList<String>(m);
 	}
 
-	public Biome getGroundBiome(RNG rng, double x, double y, double z) {
-		if (biomeSkyScatter.isEmpty()) {
+	public Biome getGroundBiome(RNG rng, double x, double y, double z)
+	{
+		if(biomeSkyScatter.isEmpty())
+		{
 			return getDerivative();
 		}
 
-		if (biomeScatter.size() == 1) {
+		if(biomeScatter.size() == 1)
+		{
 			return biomeScatter.get(0);
 		}
 

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

@@ -20,14 +20,15 @@ import lombok.Data;
 
 @Desc("A biome decorator is used for placing flowers, grass, cacti and so on")
 @Data
-public class IrisBiomeDecorator {
+public class IrisBiomeDecorator
+{
 	@DontObfuscate
 	@Desc("The varience dispersion is used when multiple blocks are put in the palette. Scatter scrambles them, Wispy shows streak-looking varience")
 	private IrisGeneratorStyle variance = NoiseStyle.STATIC.style();
 
 	@DontObfuscate
 	@Desc("Dispersion is used to pick places to spawn. Scatter randomly places them (vanilla) or Wispy for a streak like patch system.")
-	private IrisGeneratorStyle dispersion = NoiseStyle.STATIC.style();
+	private IrisGeneratorStyle style = NoiseStyle.STATIC.style();
 
 	@DependsOn({"stackMin", "stackMax"})
 	@DontObfuscate
@@ -86,64 +87,78 @@ public class IrisBiomeDecorator {
 	private transient AtomicCache<CNG> heightGenerator = new AtomicCache<>();
 	private transient AtomicCache<KList<BlockData>> blockData = new AtomicCache<>();
 
-	public int getHeight(RNG rng, double x, double z) {
-		if (stackMin == stackMax) {
+	public int getHeight(RNG rng, double x, double z)
+	{
+		if(stackMin == stackMax)
+		{
 			return stackMin;
 		}
 
 		return getHeightGenerator(rng).fit(stackMin, stackMax, x / verticalZoom, z / verticalZoom);
 	}
 
-	public CNG getHeightGenerator(RNG rng) {
-		return heightGenerator.aquire(() -> {
+	public CNG getHeightGenerator(RNG rng)
+	{
+		return heightGenerator.aquire(() ->
+		{
 			return heightVariance.create(rng.nextParallelRNG(getBlockData().size() + stackMax + stackMin));
 		});
 	}
 
-	public CNG getGenerator(RNG rng) {
+	public CNG getGenerator(RNG rng)
+	{
 		long key = rng.nextParallelRNG(1).nextLong();
 
-		if (layerGenerators == null) {
+		if(layerGenerators == null)
+		{
 			layerGenerators = new KMap<>();
 		}
 
-		if (!layerGenerators.containsKey(key)) {
-			layerGenerators.put(key, dispersion.create(rng.nextParallelRNG((int) (getBlockData().size() + key))));
+		if(!layerGenerators.containsKey(key))
+		{
+			layerGenerators.put(key, style.create(rng.nextParallelRNG((int) (getBlockData().size() + key))));
 		}
 
 		return layerGenerators.get(key);
 	}
 
-	public CNG getVarianceGenerator(RNG rng) {
+	public CNG getVarianceGenerator(RNG rng)
+	{
 		long key = rng.nextParallelRNG(4).nextLong();
 
-		if (layerVarianceGenerators == null) {
+		if(layerVarianceGenerators == null)
+		{
 			layerVarianceGenerators = new KMap<>();
 		}
 
-		if (!layerVarianceGenerators.containsKey(key)) {
-			layerVarianceGenerators.put(key,
-					variance.create(rng.nextParallelRNG((int) (getBlockData().size() + key))).scale(1D / varianceZoom));
+		if(!layerVarianceGenerators.containsKey(key))
+		{
+			layerVarianceGenerators.put(key, variance.create(rng.nextParallelRNG((int) (getBlockData().size() + key))).scale(1D / varianceZoom));
 		}
 
 		return layerVarianceGenerators.get(key);
 	}
 
-	public KList<String> add(String b) {
+	public KList<String> add(String b)
+	{
 		palette.add(b);
 		return palette;
 	}
 
-	public BlockData getBlockData(RNG rng, double x, double z) {
-		if (getGenerator(rng) == null) {
+	public BlockData getBlockData(RNG rng, double x, double z)
+	{
+		if(getGenerator(rng) == null)
+		{
 			return null;
 		}
 
-		if (getBlockData() == null) {
+		if(getBlockData() == null)
+		{
 			return null;
 		}
 
-		if (getBlockData().isEmpty()) {
+		if(getBlockData().isEmpty())
+		{
 			return null;
 		}
 
@@ -152,8 +167,10 @@ public class IrisBiomeDecorator {
 		xx /= getZoom();
 		zz /= getZoom();
 
-		if (getGenerator(rng).fitDouble(0D, 1D, xx, zz) <= chance) {
-			if (getBlockData().size() == 1) {
+		if(getGenerator(rng).fitDouble(0D, 1D, xx, zz) <= chance)
+		{
+			if(getBlockData().size() == 1)
+			{
 				return getBlockData().get(0);
 			}
 
@@ -163,12 +180,16 @@ public class IrisBiomeDecorator {
 		return null;
 	}
 
-	public KList<BlockData> getBlockData() {
-		return blockData.aquire(() -> {
+	public KList<BlockData> getBlockData()
+	{
+		return blockData.aquire(() ->
+		{
 			KList<BlockData> blockData = new KList<>();
-			for (String i : palette) {
+			for(String i : palette)
+			{
 				BlockData bx = B.getBlockData(i);
-				if (bx != null) {
+				if(bx != null)
+				{
 					blockData.add(bx);
 				}
 			}

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

@@ -29,7 +29,8 @@ import lombok.EqualsAndHashCode;
 @Desc("Represents a dimension")
 @Data
 @EqualsAndHashCode(callSuper = false)
-public class IrisDimension extends IrisRegistrant {
+public class IrisDimension extends IrisRegistrant
+{
 	public static final BlockData STONE = Material.STONE.createBlockData();
 	public static final BlockData WATER = Material.WATER.createBlockData();
 
@@ -66,8 +67,28 @@ public class IrisDimension extends IrisRegistrant {
 	private IrisGeneratorStyle continentalStyle = NoiseStyle.CELLULAR_IRIS_DOUBLE.style();
 
 	@DontObfuscate
-	@Desc("The placement style of land/sea")
-	private IrisGeneratorStyle coordinateFracture = NoiseStyle.FLAT.style();
+	@Desc("The placement style of biomes")
+	private IrisGeneratorStyle landBiomeStyle = NoiseStyle.CELLULAR_IRIS_DOUBLE.style();
+
+	@DontObfuscate
+	@Desc("The placement style of biomes")
+	private IrisGeneratorStyle shoreBiomeStyle = NoiseStyle.CELLULAR_IRIS_DOUBLE.style();
+
+	@DontObfuscate
+	@Desc("The placement style of biomes")
+	private IrisGeneratorStyle seaBiomeStyle = NoiseStyle.CELLULAR_IRIS_DOUBLE.style();
+
+	@DontObfuscate
+	@Desc("The placement style of biomes")
+	private IrisGeneratorStyle caveBiomeStyle = NoiseStyle.CELLULAR_IRIS_DOUBLE.style();
+
+	@DontObfuscate
+	@Desc("The placement style of biomes")
+	private IrisGeneratorStyle islandBiomeStyle = NoiseStyle.CELLULAR_IRIS_DOUBLE.style();
+
+	@DontObfuscate
+	@Desc("The placement style of biomes")
+	private IrisGeneratorStyle skylandBiomeStyle = NoiseStyle.CELLULAR_IRIS_DOUBLE.style();
 
 	@MinNumber(-256)
 	@MaxNumber(256)
@@ -277,29 +298,33 @@ public class IrisDimension extends IrisRegistrant {
 	private transient AtomicCache<Double> rad = new AtomicCache<>();
 	private transient boolean inverted = false;
 
-	public KList<IrisPostBlockFilter> getPostBlockProcessors(PostBlockChunkGenerator g) {
-		return cacheFilters.aquire(() -> {
+	public KList<IrisPostBlockFilter> getPostBlockProcessors(PostBlockChunkGenerator g)
+	{
+		return cacheFilters.aquire(() ->
+		{
 			KList<IrisPostBlockFilter> cacheFilters = new KList<>();
 
-			for (IrisPostProcessor i : getPostProcessors()) {
+			for(IrisPostProcessor i : getPostProcessors())
+			{
 				cacheFilters.add(g.createProcessor(i.getProcessor(), i.getPhase()));
 			}
 
 			g.setMinPhase(0);
 			g.setMaxPhase(0);
 
-			for (IrisPostBlockFilter i : cacheFilters) {
+			for(IrisPostBlockFilter i : cacheFilters)
+			{
 				g.setMinPhase(Math.min(g.getMinPhase(), i.getPhase()));
 				g.setMaxPhase(Math.max(g.getMaxPhase(), i.getPhase()));
 			}
 
-			Iris.info("Post Processing: " + cacheFilters.size() + " filters. Phases: " + g.getMinPhase() + " - "
-					+ g.getMaxPhase());
+			Iris.info("Post Processing: " + cacheFilters.size() + " filters. Phases: " + g.getMinPhase() + " - " + g.getMaxPhase());
 			return cacheFilters;
 		});
 	}
 
-	public static KList<IrisCompatabilityFilter> getDefaultCompatability() {
+	public static KList<IrisCompatabilityFilter> getDefaultCompatability()
+	{
 		KList<IrisCompatabilityFilter> filters = new KList<>();
 
 		// Below 1.16
@@ -438,15 +463,18 @@ public class IrisDimension extends IrisRegistrant {
 		return filters;
 	}
 
-	public CNG getCoordFracture(RNG rng, int signature) {
-		return coordFracture.aquire(() -> {
+	public CNG getCoordFracture(RNG rng, int signature)
+	{
+		return coordFracture.aquire(() ->
+		{
 			CNG coordFracture = CNG.signature(rng.nextParallelRNG(signature));
 			coordFracture.scale(0.012 / coordFractureZoom);
 			return coordFracture;
 		});
 	}
 
-	private KList<IrisPostProcessor> getDefaultPostProcessors() {
+	private KList<IrisPostProcessor> getDefaultPostProcessors()
+	{
 		KList<IrisPostProcessor> p = new KList<IrisPostProcessor>();
 
 		p.add(new IrisPostProcessor("wall-painter"));
@@ -456,32 +484,40 @@ public class IrisDimension extends IrisRegistrant {
 		return p;
 	}
 
-	public BlockData getRock(RNG rng, double x, double y, double z) {
-		if (getRockData().isEmpty()) {
+	public BlockData getRock(RNG rng, double x, double y, double z)
+	{
+		if(getRockData().isEmpty())
+		{
 			return STONE;
 		}
 
-		if (getRockData().size() == 1) {
+		if(getRockData().size() == 1)
+		{
 			return getRockData().get(0);
 		}
 
 		return getRockGenerator(rng).fit(getRockData(), x, y, z);
 	}
 
-	public CNG getRockGenerator(RNG rng) {
-		return rockLayerGenerator.aquire(() -> {
-			RNG rngx = rng.nextParallelRNG(
-					(int) (getRockData().size() * getRegions().size() * getCaveScale() * getLandZoom() * 10357));
+	public CNG getRockGenerator(RNG rng)
+	{
+		return rockLayerGenerator.aquire(() ->
+		{
+			RNG rngx = rng.nextParallelRNG((int) (getRockData().size() * getRegions().size() * getCaveScale() * getLandZoom() * 10357));
 			return rockStyle.create(rngx);
 		});
 	}
 
-	public KList<BlockData> getRockData() {
-		return rockData.aquire(() -> {
+	public KList<BlockData> getRockData()
+	{
+		return rockData.aquire(() ->
+		{
 			KList<BlockData> rockData = new KList<>();
-			for (String ix : rockPalette) {
+			for(String ix : rockPalette)
+			{
 				BlockData bx = B.getBlockData(ix);
-				if (bx != null) {
+				if(bx != null)
+				{
 					rockData.add(bx);
 				}
 			}
@@ -490,32 +526,40 @@ public class IrisDimension extends IrisRegistrant {
 		});
 	}
 
-	public BlockData getFluid(RNG rng, double x, double y, double z) {
-		if (getFluidData().isEmpty()) {
+	public BlockData getFluid(RNG rng, double x, double y, double z)
+	{
+		if(getFluidData().isEmpty())
+		{
 			return WATER;
 		}
 
-		if (getFluidData().size() == 1) {
+		if(getFluidData().size() == 1)
+		{
 			return getFluidData().get(0);
 		}
 
 		return getFluidGenerator(rng).fit(getFluidData(), x, y, z);
 	}
 
-	public CNG getFluidGenerator(RNG rng) {
-		return fluidLayerGenerator.aquire(() -> {
-			RNG rngx = rng.nextParallelRNG(getFluidData().size()
-					* (int) (getRockData().size() * getRegions().size() * getCaveScale() * getLandZoom() * 10357));
+	public CNG getFluidGenerator(RNG rng)
+	{
+		return fluidLayerGenerator.aquire(() ->
+		{
+			RNG rngx = rng.nextParallelRNG(getFluidData().size() * (int) (getRockData().size() * getRegions().size() * getCaveScale() * getLandZoom() * 10357));
 			return fluidStyle.create(rngx);
 		});
 	}
 
-	public KList<BlockData> getFluidData() {
-		return fluidData.aquire(() -> {
+	public KList<BlockData> getFluidData()
+	{
+		return fluidData.aquire(() ->
+		{
 			KList<BlockData> fluidData = new KList<>();
-			for (String ix : fluidPalette) {
+			for(String ix : fluidPalette)
+			{
 				BlockData bx = B.getBlockData(ix);
-				if (bx != null) {
+				if(bx != null)
+				{
 					fluidData.add(bx);
 				}
 			}
@@ -524,40 +568,49 @@ public class IrisDimension extends IrisRegistrant {
 		});
 	}
 
-	public double getDimensionAngle() {
+	public double getDimensionAngle()
+	{
 		return rad.aquire(() -> Math.toRadians(dimensionAngleDeg));
 	}
 
-	public double sinRotate() {
+	public double sinRotate()
+	{
 		return sinr.aquire(() -> Math.sin(getDimensionAngle()));
 	}
 
-	public double cosRotate() {
+	public double cosRotate()
+	{
 		return cosr.aquire(() -> Math.cos(getDimensionAngle()));
 	}
 
-	public KList<IrisRegion> getAllRegions(ContextualChunkGenerator g) {
+	public KList<IrisRegion> getAllRegions(ContextualChunkGenerator g)
+	{
 		KList<IrisRegion> r = new KList<>();
 
-		for (String i : getRegions()) {
+		for(String i : getRegions())
+		{
 			r.add(g != null ? g.loadRegion(i) : Iris.globaldata.getRegionLoader().load(i));
 		}
 
 		return r;
 	}
 
-	public KList<IrisBiome> getAllBiomes(ContextualChunkGenerator g) {
+	public KList<IrisBiome> getAllBiomes(ContextualChunkGenerator g)
+	{
 		KList<IrisBiome> r = new KList<>();
 
-		for (IrisRegion i : getAllRegions(g)) {
+		for(IrisRegion i : getAllRegions(g))
+		{
 			r.addAll(i.getAllBiomes(g));
 		}
 
 		return r;
 	}
 
-	public ChunkPosition getParallaxSize(ContextualChunkGenerator g) {
-		return parallaxSize.aquire(() -> {
+	public ChunkPosition getParallaxSize(ContextualChunkGenerator g)
+	{
+		return parallaxSize.aquire(() ->
+		{
 			int x = 0;
 			int z = 0;
 
@@ -565,40 +618,50 @@ public class IrisDimension extends IrisRegistrant {
 			KList<IrisRegion> r = getAllRegions(g);
 			KList<IrisBiome> b = getAllBiomes(g);
 
-			for (IrisBiome i : b) {
-				for (IrisObjectPlacement j : i.getObjects()) {
+			for(IrisBiome i : b)
+			{
+				for(IrisObjectPlacement j : i.getObjects())
+				{
 					objects.addAll(j.getPlace());
 				}
 			}
 
-			for (String i : objects) {
-				try {
+			for(String i : objects)
+			{
+				try
+				{
 					BlockVector bv = IrisObject.sampleSize(g.getData().getObjectLoader().findFile(i));
 					x = bv.getBlockX() > x ? bv.getBlockX() : x;
 					z = bv.getBlockZ() > z ? bv.getBlockZ() : z;
 				}
 
-				catch (Throwable e) {
+				catch(Throwable e)
+				{
 
 				}
 			}
 
-			for (IrisDepositGenerator i : getDeposits()) {
+			for(IrisDepositGenerator i : getDeposits())
+			{
 				int max = i.getMaxDimension();
 				x = max > x ? max : x;
 				z = max > z ? max : z;
 			}
 
-			for (IrisRegion v : r) {
-				for (IrisDepositGenerator i : v.getDeposits()) {
+			for(IrisRegion v : r)
+			{
+				for(IrisDepositGenerator i : v.getDeposits())
+				{
 					int max = i.getMaxDimension();
 					x = max > x ? max : x;
 					z = max > z ? max : z;
 				}
 			}
 
-			for (IrisBiome v : b) {
-				for (IrisDepositGenerator i : v.getDeposits()) {
+			for(IrisBiome v : b)
+			{
+				for(IrisDepositGenerator i : v.getDeposits())
+				{
 					int max = i.getMaxDimension();
 					x = max > x ? max : x;
 					z = max > z ? max : z;
@@ -614,13 +677,39 @@ public class IrisDimension extends IrisRegistrant {
 		});
 	}
 
-	public BlockData resolve(String bd) {
-		for (IrisCompatabilityFilter i : getCompatability()) {
-			if (i.getWhen().equalsIgnoreCase(bd)) {
+	public BlockData resolve(String bd)
+	{
+		for(IrisCompatabilityFilter i : getCompatability())
+		{
+			if(i.getWhen().equalsIgnoreCase(bd))
+			{
 				return i.getReplace();
 			}
 		}
 
 		return null;
 	}
+
+	public IrisGeneratorStyle getBiomeStyle(InferredType type)
+	{
+		switch(type)
+		{
+			case CAVE:
+				return caveBiomeStyle;
+			case ISLAND:
+				return islandBiomeStyle;
+			case LAND:
+				return landBiomeStyle;
+			case SEA:
+				return seaBiomeStyle;
+			case SHORE:
+				return shoreBiomeStyle;
+			case SKYLAND:
+				return skylandBiomeStyle;
+			default:
+				break;
+		}
+
+		return landBiomeStyle;
+	}
 }