Epic Gens

src/main/java/ninja/bytecode/iris/generator/IrisGenerator.java

@@ -15,6 +15,12 @@ import ninja.bytecode.iris.generator.layer.GenLayerBase;
 import ninja.bytecode.iris.generator.layer.GenLayerBiome;
 import ninja.bytecode.iris.generator.layer.GenLayerCaves;
 import ninja.bytecode.iris.generator.layer.GenLayerLayeredNoise;
+import ninja.bytecode.iris.generator.layer.GenLayerOreCoal;
+import ninja.bytecode.iris.generator.layer.GenLayerOreDiamond;
+import ninja.bytecode.iris.generator.layer.GenLayerOreEmerald;
+import ninja.bytecode.iris.generator.layer.GenLayerOreGold;
+import ninja.bytecode.iris.generator.layer.GenLayerOreIron;
+import ninja.bytecode.iris.generator.layer.GenLayerOreLapis;
 import ninja.bytecode.iris.generator.layer.GenLayerRidge;
 import ninja.bytecode.iris.generator.populator.BiomeBiasSchematicPopulator;
 import ninja.bytecode.iris.schematic.Schematic;
@@ -31,6 +37,24 @@ import ninja.bytecode.shuriken.math.RNG;
 
 public class IrisGenerator extends ParallelChunkGenerator
 {
+	//@builder
+	public static final GList<MB> ROCK = new GList<MB>().add(new MB[] {
+			MB.of(Material.STONE),
+			MB.of(Material.STONE),
+			MB.of(Material.STONE),
+			MB.of(Material.STONE),
+			MB.of(Material.STONE),
+			MB.of(Material.STONE),
+			MB.of(Material.STONE, 5),
+			MB.of(Material.STONE, 5),
+			MB.of(Material.COBBLESTONE),
+			MB.of(Material.COBBLESTONE),
+			MB.of(Material.SMOOTH_BRICK),
+			MB.of(Material.SMOOTH_BRICK, 1),
+			MB.of(Material.SMOOTH_BRICK, 2),
+			MB.of(Material.SMOOTH_BRICK, 3),
+	});
+	//@done
 	private MB WATER = new MB(Material.STATIONARY_WATER);
 	private MB BEDROCK = new MB(Material.BEDROCK);
 	private GenLayerBase glBase;
@@ -38,6 +62,12 @@ public class IrisGenerator extends ParallelChunkGenerator
 	private GenLayerRidge glRidge;
 	private GenLayerBiome glBiome;
 	private GenLayerCaves glCaves;
+	private GenLayerOreIron glOreIron;
+	private GenLayerOreCoal glOreCoal;
+	private GenLayerOreLapis glOreLapis;
+	private GenLayerOreGold glOreGold;
+	private GenLayerOreEmerald glOreEmerald;
+	private GenLayerOreDiamond glOreDiamond;
 	private RNG rTerrain;
 	private World world;
 
@@ -51,6 +81,12 @@ public class IrisGenerator extends ParallelChunkGenerator
 		glRidge = new GenLayerRidge(this, world, random, rTerrain.nextParallelRNG(3));
 		glBiome = new GenLayerBiome(this, world, random, rTerrain.nextParallelRNG(4));
 		glCaves = new GenLayerCaves(this, world, random, rTerrain.nextParallelRNG(-1));
+		glOreIron = new GenLayerOreIron(this, world, random, rTerrain.nextParallelRNG(-500), 10);
+		glOreLapis = new GenLayerOreLapis(this, world, random, rTerrain.nextParallelRNG(-501), 15);
+		glOreCoal = new GenLayerOreCoal(this, world, random, rTerrain.nextParallelRNG(-502), 20);
+		glOreGold = new GenLayerOreGold(this, world, random, rTerrain.nextParallelRNG(-503), 25);
+		glOreEmerald = new GenLayerOreEmerald(this, world, random, rTerrain.nextParallelRNG(-504), 30);
+		glOreDiamond = new GenLayerOreDiamond(this, world, random, rTerrain.nextParallelRNG(-505), 35);
 	}
 
 	@Override
@@ -75,7 +111,7 @@ public class IrisGenerator extends ParallelChunkGenerator
 
 		for(int i = 0; i < max; i++)
 		{
-			MB mb = new MB(Material.STONE);
+			MB mb = ROCK.get(glBase.scatterInt(wzx, i, wxx, ROCK.size()));
 			boolean underwater = i >= height && i < seaLevel;
 			boolean underground = i < height;
 
@@ -120,6 +156,12 @@ public class IrisGenerator extends ParallelChunkGenerator
 				}
 
 				mb = biome.getSurface(wx, wz, rTerrain);
+				MB mbx = biome.getScatterChanceSingle();
+				
+				if(!mbx.material.equals(Material.AIR))
+				{
+					setBlock(x, i + 1, z, mbx.material, mbx.data);
+				}
 			}
 
 			if(i == 0)
@@ -136,6 +178,12 @@ public class IrisGenerator extends ParallelChunkGenerator
 		}
 
 		glCaves.genCaves(wxx, wzx, x, z, height, this);
+		glOreIron.genOre(wxx, wzx, x, z, height, this, biome);
+		glOreLapis.genOre(wxx, wzx, x, z, height, this, biome);
+		glOreCoal.genOre(wxx, wzx, x, z, height, this, biome);
+		glOreGold.genOre(wxx, wzx, x, z, height, this, biome);
+		glOreEmerald.genOre(wxx, wzx, x, z, height, this, biome);
+		glOreDiamond.genOre(wxx, wzx, x, z, height, this, biome);
 
 		if(override != null)
 		{
@@ -162,7 +210,7 @@ public class IrisGenerator extends ParallelChunkGenerator
 	{
 		GList<BlockPopulator> p = new GList<>();
 		int b = 0;
-		for(IrisBiome i : IrisBiome.getBiomes())
+		for(IrisBiome i : IrisBiome.getAllBiomes())
 		{
 			b++;
 			L.i("Processing Populators for Biome " + i.getName());
@@ -172,9 +220,7 @@ public class IrisGenerator extends ParallelChunkGenerator
 				p.add(new BiomeBiasSchematicPopulator(i.getSchematicGroups().get(j), i, loadSchematics(j)));
 			}
 		}
-		
-		J.attempt(() -> p.add(new BiomeBiasSchematicPopulator(5, IrisBiome.JUNGLE, loadSchematics(""))));
-		
+				
 		L.i("Initialized " + b + " Biomes and " + p.size() + " Populators");
 		L.flush();
 		
@@ -186,25 +232,18 @@ public class IrisGenerator extends ParallelChunkGenerator
 		File f = new File(Iris.instance.getDataFolder(), "objects/" + folder);
 		GList<Schematic> s = new GList<>();
 		
-		try
+		if(f.exists() && f.isDirectory())
 		{
-			if(f.exists() && f.isDirectory())
+			for(File i : f.listFiles())
 			{
-				for(File i : f.listFiles())
+				if(i.isFile() && i.getName().endsWith(".ish"))
 				{
-					if(i.isFile() && i.getName().endsWith(".ish"))
-					{
-						s.add(Schematic.load(i));
-					}
+					J.attempt(()-> s.add(Schematic.load(i)));
 				}
 			}
 		}
 		
-		catch(Throwable e)
-		{
-			
-		}
-		
+		L.i("Loaded " + s.size() + " Schematics in " + folder);
 		return s.toArray(new Schematic[s.size()]);
 	}
 

src/main/java/ninja/bytecode/iris/generator/biome/IrisBiome.java

@@ -3,8 +3,10 @@ package ninja.bytecode.iris.generator.biome;
 import java.lang.reflect.Field;
 
 import org.bukkit.Material;
-import org.bukkit.TreeType;
 import org.bukkit.block.Biome;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
 
 import ninja.bytecode.iris.util.MB;
 import ninja.bytecode.iris.util.PolygonGenerator;
@@ -21,7 +23,9 @@ public class IrisBiome
 	public static final IrisBiome RIVER = new IrisBiome("River", Biome.RIVER)
 			.surface(MB.of(Material.SAND));
 	public static final IrisBiome BEACH = new IrisBiome("Beach", Biome.BEACHES)
-			.surface(MB.of(Material.SAND));
+			.surface(MB.of(Material.SAND))
+			.height(0.12)
+			.schematic("palm", 0.83);
 	public static final IrisBiome ROAD_GRAVEL = new IrisBiome("Gravel Road", Biome.PLAINS)
 			.surface(MB.of(Material.GRAVEL), MB.of(Material.COBBLESTONE))
 			.scatter(MB.of(Material.TORCH), 0.05);
@@ -42,127 +46,181 @@ public class IrisBiome
 			.height(-0.07);
 	public static final IrisBiome DESERT = new IrisBiome("Desert", Biome.DESERT)
 			.surface(MB.of(Material.SAND))
+			.schematic("deadwood", 0.03)
 			.scatter(MB.of(Material.DEAD_BUSH, 0), 0.008)
 			.dirt(MB.of(Material.SANDSTONE));
 	public static final IrisBiome DESERT_RED = new IrisBiome("Red Desert", Biome.DESERT)
 			.surface(MB.of(Material.SAND, 1))
+			.schematic("deadwood", 0.03)
 			.scatter(MB.of(Material.DEAD_BUSH, 0), 0.008)
 			.dirt(MB.of(Material.RED_SANDSTONE));
 	public static final IrisBiome DESERT_COMBINED = new IrisBiome("Combined Desert", Biome.DESERT)
 			.surface(MB.of(Material.SAND), MB.of(Material.SAND, 1))
 			.scatter(MB.of(Material.DEAD_BUSH, 0), 0.008)
+			.schematic("deadwood", 0.05)
 			.dirt(MB.of(Material.SANDSTONE), MB.of(Material.RED_SANDSTONE))
 			.simplexSurface();
 	public static final IrisBiome DESERT_HILLS = new IrisBiome("Desert Hills", Biome.DESERT_HILLS)
 			.surface(MB.of(Material.SAND))
 			.amp(0.75)
+			.height(0.137)
+			.schematic("deadwood", 0.03)
 			.scatter(MB.of(Material.DEAD_BUSH, 0), 0.08)
 			.dirt(MB.of(Material.SANDSTONE));
 	public static final IrisBiome MESA = new IrisBiome("Mesa", Biome.MESA)
 			.surface(MB.of(Material.HARD_CLAY), MB.of(Material.STAINED_CLAY, 1), MB.of(Material.STAINED_CLAY, 8), MB.of(Material.STAINED_CLAY, 12))
 			.dirt(MB.of(Material.CLAY), MB.of(Material.SAND), MB.of(Material.SAND, 1))
+			.schematic("boulder", 0.02)
 			.simplexSurface();
 	public static final IrisBiome SAVANNA = new IrisBiome("Savanna", Biome.SAVANNA)
-			.tree(TreeType.ACACIA, 0.102)
+			.schematic("deadwood", 0.03)
+			.schematic("boulder", 0.02)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.18);
 	public static final IrisBiome SAVANNA_HILLS = new IrisBiome("Savanna Hills", Biome.SAVANNA_ROCK)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.18)
-			.tree(TreeType.ACACIA, 0.102)
+			.schematic("deadwood", 0.01)
+			.schematic("boulder", 0.02)
+			.height(0.13)
 			.amp(0.75);
+	public static final IrisBiome OCEAN_2 = new IrisBiome("Ocean 2", Biome.OCEAN)
+			.surface(MB.of(Material.SAND), MB.of(Material.SAND), MB.of(Material.SAND), MB.of(Material.CLAY), MB.of(Material.GRAVEL))
+			.simplexSurface()
+			.height(-0.03);
 	public static final IrisBiome JUNGLE = new IrisBiome("Jungle", Biome.JUNGLE)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.058)
-			.tree(TreeType.JUNGLE, 0.9)
-			.tree(TreeType.JUNGLE_BUSH, 0.3)
-			.tree(TreeType.SMALL_JUNGLE, 0.1)
+			.schematic("boulder", 0.02)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.013);
 	public static final IrisBiome JUNGLE_HILLS = new IrisBiome("Jungle Hills", Biome.JUNGLE_HILLS)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.081)
-			.tree(TreeType.JUNGLE, 0.9)
-			.tree(TreeType.JUNGLE_BUSH, 0.3)
-			.tree(TreeType.SMALL_JUNGLE, 0.1)
+			.schematic("boulder", 0.02)
 			.amp(1.75)
-			.height(0.166)
+			.height(0.13)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.02);
 	public static final IrisBiome SWAMP = new IrisBiome("Swamp", Biome.SWAMPLAND)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.04)
-			.tree(TreeType.SWAMP, 0.25)
+			.schematic("willow", 2.5)
+			.schematic("boulder", 0.02)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.03);
 	public static final IrisBiome PLAINS = new IrisBiome("Plains", Biome.PLAINS)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.38)
+			.schematic("oak_bush", 0.25)
+			.schematic("boulder", 0.02)
 			.amp(0.4)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.03);
+	public static final IrisBiome OCEAN_3 = new IrisBiome("Ocean 3", Biome.OCEAN)
+			.surface(MB.of(Material.SAND), MB.of(Material.SAND), MB.of(Material.SAND), MB.of(Material.CLAY), MB.of(Material.GRAVEL))
+			.simplexSurface()
+			.height(-0.03);
 	public static final IrisBiome DECAYING_PLAINS = new IrisBiome("Decaying Plains", Biome.PLAINS)
 			.surface(MB.of(Material.GRASS_PATH), MB.of(Material.GRASS))
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.04)
+			.schematic("deadwood", 0.03)
 			.simplexSurface();
 	public static final IrisBiome FOREST = new IrisBiome("Forest", Biome.FOREST)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.23)
-			.tree(TreeType.TREE, 0.7)
+			.schematic("oak", 2.31)
+			.schematic("boulder", 0.02)
+			.schematic("cracked_oak", 0.03)
+			.schematic("oak_large", 1.41)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.13);
 	public static final IrisBiome FOREST_HILLS = new IrisBiome("Forest Hills", Biome.FOREST_HILLS)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.23)
+			.schematic("oak", 2.31)
+			.schematic("boulder", 0.02)
+			.schematic("cracked_oak", 0.03)
+			.schematic("oak_large", 0.31)
 			.amp(0.75)
-			.tree(TreeType.TREE, 0.7)
+			.height(0.13)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.13);
 	public static final IrisBiome FOREST_MOUNTAINS = new IrisBiome("Forest Mountains", Biome.MUTATED_EXTREME_HILLS_WITH_TREES)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.13)
 			.amp(2.25)
-			.height(0.265)
-			.tree(TreeType.MEGA_REDWOOD, 0.5)
-			.tree(TreeType.TALL_REDWOOD, 0.7)
+			.schematic("pine", 2.31)
+			.schematic("boulder", 0.04)
+			.schematic("redwood", 1.11)
+			.schematic("redwood_tall", 2.51)
+			.height(0.165)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.13);
 	public static final IrisBiome HAUNTED_FOREST = new IrisBiome("Haunted Forest", Biome.MUTATED_SWAMPLAND)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.13)
-			.tree(TreeType.JUNGLE_BUSH, 0.5)
-			.tree(TreeType.BIG_TREE, 0.4)
-			.tree(TreeType.SWAMP, 0.4)
-			.tree(TreeType.JUNGLE, 0.4)
-			.tree(TreeType.SMALL_JUNGLE, 0.4)
-			.tree(TreeType.JUNGLE_BUSH, 0.5)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.13)
-			.surface(MB.of(Material.GRASS), MB.of(Material.GRASS), MB.of(Material.GRASS), MB.of(Material.GRASS), MB.of(Material.DIRT), MB.of(Material.DIRT, 1), MB.of(Material.DIRT, 2))
+			.schematic("willow", 2.31)
+			.schematic("oak", 1.31)
+			.schematic("boulder", 0.01)
+			.schematic("cracked_oak", 0.03)
+			.schematic("oak_bush", 1.83)
+			.addEffect(new PotionEffect(PotionEffectType.SLOW_DIGGING, 100, 0))
+			.addEffect(new PotionEffect(PotionEffectType.SLOW, 100, 0))
+			.addEffect(new PotionEffect(PotionEffectType.HUNGER, 100, 0))
+			.surface(MB.of(Material.GRASS), MB.of(Material.GRASS), MB.of(Material.GRASS), MB.of(Material.GRASS), MB.of(Material.SOUL_SAND), MB.of(Material.DIRT), MB.of(Material.DIRT, 1), MB.of(Material.DIRT, 2))
 			.scatterSurface();
 	public static final IrisBiome BIRCH_FOREST = new IrisBiome("Birch Forest", Biome.BIRCH_FOREST)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.23)
-			.tree(TreeType.BIRCH, 0.7)
+			.schematic("birch", 2.51)
+			.schematic("boulder", 0.02)
+			.schematic("birch_small", 3.25)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.13);
 	public static final IrisBiome BIRCH_FOREST_HILLS = new IrisBiome("Birch Forest Hills", Biome.BIRCH_FOREST_HILLS)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.23)
-			.tree(TreeType.BIRCH, 0.7)
+			.schematic("birch", 2.51)
+			.schematic("boulder", 0.02)
+			.schematic("birch_small", 3.25)
 			.amp(0.75)
+			.height(0.13)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.13);
+	public static final IrisBiome OCEAN_4 = new IrisBiome("Ocean 4", Biome.OCEAN)
+			.surface(MB.of(Material.SAND), MB.of(Material.SAND), MB.of(Material.SAND), MB.of(Material.CLAY), MB.of(Material.GRAVEL))
+			.simplexSurface()
+			.height(-0.03);
 	public static final IrisBiome ROOFED_FOREST = new IrisBiome("Roofed Forest", Biome.ROOFED_FOREST)
 			.scatter(MB.of(Material.LONG_GRASS, 1), 0.23)
-			.tree(TreeType.DARK_OAK, 0.9)
+			.schematic("boulder", 0.02)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.13);
 	public static final IrisBiome TAIGA = new IrisBiome("Taiga", Biome.TAIGA)
-			.tree(TreeType.REDWOOD, 0.4)
+			.schematic("cracked_pine", 0.03)
+			.schematic("pine", 2.51)
+			.schematic("boulder", 0.08)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.07);
 	public static final IrisBiome EXTREME_HILLS = new IrisBiome("Extreme Hills", Biome.EXTREME_HILLS)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.04)
 			.amp(1.565)
-			.height(0.22);
+			.height(0.142);
 	public static final IrisBiome EXTREME_HILLS_TREES = new IrisBiome("Extreme Hills +", Biome.EXTREME_HILLS_WITH_TREES)
 			.scatter(MB.of(Material.LONG_GRASS, 2), 0.09)
-			.tree(TreeType.REDWOOD, 0.1)
+			.schematic("boulder", 0.02)
+			.schematic("pine", 1.02)
+			.schematic("redwood_tall", 3.02)
 			.amp(1.525)
-			.height(0.22);
+			.height(0.152);
 	public static final IrisBiome TAIGA_COLD = new IrisBiome("Taiga Cold", Biome.TAIGA_COLD)
-			.tree(TreeType.REDWOOD, 0.3)
-			.scatter(MB.of(Material.LONG_GRASS, 2), 0.04);
+			.scatter(MB.of(Material.LONG_GRASS, 2), 0.04)
+			.schematic("pine", 2.51)
+			.schematic("boulder", 0.02)
+			.schematic("cracked_pine", 0.03);
 	public static final IrisBiome TAIGA_COLD_HILLS = new IrisBiome("Taiga Cold Hills", Biome.TAIGA_COLD_HILLS)
-			.tree(TreeType.REDWOOD, 0.15).amp(0.75);
+			.schematic("pine", 2.51)
+			.schematic("boulder", 0.02)
+			.schematic("cracked_pine", 0.03);
 	public static final IrisBiome ICE_FLATS = new IrisBiome("Ice Flats", Biome.ICE_FLATS);
 	public static final IrisBiome ICE_MOUNTAINS = new IrisBiome("Ice Mountains", Biome.ICE_MOUNTAINS)
 			.amp(1.45);
+	public static final IrisBiome OCEAN_5 = new IrisBiome("Ocean 5", Biome.OCEAN)
+			.surface(MB.of(Material.SAND), MB.of(Material.SAND), MB.of(Material.SAND), MB.of(Material.CLAY), MB.of(Material.GRAVEL))
+			.simplexSurface()
+			.height(-0.03);
 	public static final IrisBiome REDWOOD_TAIGA = new IrisBiome("Redwood Taiga", Biome.REDWOOD_TAIGA)
 			.surface(MB.of(Material.DIRT, 2), MB.of(Material.DIRT, 1))
-			.tree(TreeType.TALL_REDWOOD, 0.7)
-			.tree(TreeType.MEGA_REDWOOD, 0.6)
-			.tree(TreeType.REDWOOD, 0.3)
+			.schematic("redwood_large", 0.87)
+			.schematic("cracked_pine", 0.03)
+			.schematic("boulder", 0.02)
+			.schematic("redwood", 3.5)
 			.simplexSurface();
 	public static final IrisBiome REDWOOD_TAIGA_HILLS = new IrisBiome("Redwood Taiga Hills", Biome.REDWOOD_TAIGA_HILLS)
 			.surface(MB.of(Material.DIRT, 2), MB.of(Material.DIRT, 1))
+			.schematic("redwood_large", 0.87)
+			.schematic("cracked_pine", 0.03)
+			.schematic("boulder", 0.02)
+			.schematic("redwood", 3.5)
 			.amp(0.75)
 			.simplexSurface();
 	
@@ -172,7 +230,7 @@ public class IrisBiome
 	private Biome realBiome;
 	private double height;
 	private double amp;
-	private GMap<TreeType, Double> treeChance;
+	private GList<PotionEffect> effects;
 	private GList<MB> surface;
 	private GList<MB> dirt;
 	private GMap<MB, Double> scatterChance;
@@ -184,12 +242,12 @@ public class IrisBiome
 	public IrisBiome(String name, Biome realBiome)
 	{
 		this.name = name;
+		effects = new GList<>();
 		this.realBiome = realBiome;
 		this.height = 0.125;
 		this.amp = 0.5;
 		scatterChance = new GMap<>();
 		schematicGroups = new GMap<>();
-		treeChance = new GMap<>();
 		surface(new MB(Material.GRASS)).dirt(new MB(Material.DIRT), new MB(Material.DIRT, 1));
 	}
 
@@ -221,15 +279,8 @@ public class IrisBiome
 
 		return this;
 	}
-
-	public IrisBiome tree(TreeType t, Double chance)
-	{
-		treeChance.put(t, chance);
-
-		return this;
-	}
-
-	public IrisBiome schematic(String t, Double chance)
+	
+	public IrisBiome schematic(String t, double chance)
 	{
 		schematicGroups.put(t, chance);
 
@@ -344,6 +395,12 @@ public class IrisBiome
 	{
 		return scatterChance;
 	}
+	
+	public IrisBiome addEffect(PotionEffect effect)
+	{
+		effects.add(effect);
+		return this;
+	}
 
 	public MB getScatterChanceSingle()
 	{
@@ -358,41 +415,15 @@ public class IrisBiome
 		return MB.of(Material.AIR);
 	}
 
-	public GMap<TreeType, Double> getTreeChance()
-	{
-		return treeChance;
-	}
-
-	public TreeType getTreeChanceSingle()
-	{
-		for(TreeType i : getTreeChance().keySet())
-		{
-			if(M.r(getTreeChance().get(i)))
-			{
-				return i;
-			}
-		}
-
-		return null;
-	}
-
-	public String getSchematicChanceSingle()
-	{
-		for(String i : schematicGroups.keySet())
-		{
-			if(M.r(schematicGroups.get(i)))
-			{
-				return i;
-			}
-		}
-
-		return null;
-	}
-
 	public static GList<IrisBiome> getBiomes()
 	{
 		return map.v().remove(IrisBiome.ROAD_GRASSY, IrisBiome.ROAD_GRAVEL, IrisBiome.BEACH, IrisBiome.LAKE, IrisBiome.RIVER);
 	}
+	
+	public static GList<IrisBiome> getAllBiomes()
+	{
+		return map.v();
+	}
 
 	public static IrisBiome findByBiome(Biome biome)
 	{
@@ -408,4 +439,18 @@ public class IrisBiome
 	{
 		return schematicGroups;
 	}
+
+	public void applyEffects(Player j)
+	{
+		if(j.getLocation().getY() < 63)
+		{
+			return;
+		}
+		
+		for(PotionEffect i : effects)
+		{
+			j.getPlayer().removePotionEffect(i.getType());
+			j.addPotionEffect(i);
+		}
+	}
 }

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerCaves.java

@@ -30,7 +30,7 @@ public class GenLayerCaves extends GenLayer
 	
 	public void genCaves(double wxx, double wzx, int x, int z, int s, IrisGenerator g)
 	{
-		for(double itr = 0; itr < 0.2; itr += 0.1)
+		for(double itr = 0; itr < 0.4; itr += 0.1)
 		{
 			double thickness = 0.25 + itr + (0.5 * caveClamp.noise(wxx, wzx));
 			double size = 3.88D * thickness;

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerOreCoal.java

@@ -0,0 +1,45 @@
+package ninja.bytecode.iris.generator.layer;
+
+import java.util.Random;
+
+import org.bukkit.Material;
+import org.bukkit.World;
+
+import ninja.bytecode.iris.generator.IrisGenerator;
+import ninja.bytecode.iris.generator.biome.IrisBiome;
+import ninja.bytecode.iris.util.GenLayer;
+import ninja.bytecode.iris.util.MB;
+import ninja.bytecode.shuriken.math.CNG;
+import ninja.bytecode.shuriken.math.RNG;
+
+public class GenLayerOreCoal extends GenLayer
+{
+	private CNG ore;
+
+	public GenLayerOreCoal(IrisGenerator iris, World world, Random random, RNG rng, int shift)
+	{
+		//@builder
+		super(iris, world, random, rng);
+		ore = new CNG(rng.nextParallelRNG(281 + shift), 1D, 1).scale(0.1125).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+				.scale(0.015).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+						.scale(0.03), 33), 592);
+		
+		//@done
+	}
+
+	public void genOre(double wxx, double wzx, int x, int z, int s, IrisGenerator g, IrisBiome b)
+	{
+		double orenoise = ore.noise(wxx, wzx);
+
+		if(IrisGenerator.ROCK.contains(MB.of(g.getType(x, (int) (orenoise * 200D) - 15, z))))
+		{
+			g.setBlock(x, (int) (orenoise * 200D) - 15, z, Material.COAL_ORE);
+		}
+	}
+
+	@Override
+	public double generateLayer(double noise, double dx, double dz)
+	{
+		return noise;
+	}
+}

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerOreDiamond.java

@@ -0,0 +1,49 @@
+package ninja.bytecode.iris.generator.layer;
+
+import java.util.Random;
+
+import org.bukkit.Material;
+import org.bukkit.World;
+
+import ninja.bytecode.iris.generator.IrisGenerator;
+import ninja.bytecode.iris.generator.biome.IrisBiome;
+import ninja.bytecode.iris.util.GenLayer;
+import ninja.bytecode.iris.util.MB;
+import ninja.bytecode.shuriken.math.CNG;
+import ninja.bytecode.shuriken.math.RNG;
+
+public class GenLayerOreDiamond extends GenLayer
+{
+	private CNG ore;
+	private CNG clamp;
+
+	public GenLayerOreDiamond(IrisGenerator iris, World world, Random random, RNG rng, int shift)
+	{
+		//@builder
+		super(iris, world, random, rng);
+		ore = new CNG(rng.nextParallelRNG(281 + shift), 1D, 1).scale(0.08725).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+				.scale(0.015).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+						.scale(0.03), 33), 592);
+		clamp = new CNG(rng.nextParallelRNG(299 + shift), 1D, 1).scale(0.0325).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+				.scale(0.015).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+						.scale(0.03), 33), 592);
+		
+		//@done
+	}
+	
+	public void genOre(double wxx, double wzx, int x, int z, int s, IrisGenerator g, IrisBiome b)
+	{
+		double orenoise = ore.noise(wxx, wzx);		
+		
+		if(clamp.noise(wxx, wzx) > 0.77 && IrisGenerator.ROCK.contains(MB.of(g.getType(x, (int) (orenoise * 12D), z))))
+		{
+			g.setBlock(x, (int) (orenoise * 12D), z, Material.DIAMOND_ORE);
+		}
+	}
+
+	@Override
+	public double generateLayer(double noise, double dx, double dz)
+	{
+		return noise;
+	}
+}

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerOreEmerald.java

@@ -0,0 +1,45 @@
+package ninja.bytecode.iris.generator.layer;
+
+import java.util.Random;
+
+import org.bukkit.Material;
+import org.bukkit.World;
+
+import ninja.bytecode.iris.generator.IrisGenerator;
+import ninja.bytecode.iris.generator.biome.IrisBiome;
+import ninja.bytecode.iris.util.GenLayer;
+import ninja.bytecode.iris.util.MB;
+import ninja.bytecode.shuriken.math.CNG;
+import ninja.bytecode.shuriken.math.RNG;
+
+public class GenLayerOreEmerald extends GenLayer
+{
+	private CNG ore;
+
+	public GenLayerOreEmerald(IrisGenerator iris, World world, Random random, RNG rng, int shift)
+	{
+		//@builder
+		super(iris, world, random, rng);
+		ore = new CNG(rng.nextParallelRNG(281 + shift), 1D, 1).scale(0.1125).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+				.scale(0.015).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+						.scale(0.03), 33), 592);
+		
+		//@done
+	}
+	
+	public void genOre(double wxx, double wzx, int x, int z, int s, IrisGenerator g, IrisBiome b)
+	{
+		double orenoise = ore.noise(wxx, wzx);		
+		
+		if(b.getScatterChanceSingle().material.equals(Material.LONG_GRASS) && b.getScatterChanceSingle().material.equals(Material.LONG_GRASS) && b.getScatterChanceSingle().material.equals(Material.LONG_GRASS) && IrisGenerator.ROCK.contains(MB.of(g.getType(x, (int) (orenoise * 32D), z))))
+		{
+			g.setBlock(x, (int) (orenoise * 32D), z, Material.EMERALD_ORE);
+		}
+	}
+
+	@Override
+	public double generateLayer(double noise, double dx, double dz)
+	{
+		return noise;
+	}
+}

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerOreGold.java

@@ -0,0 +1,48 @@
+package ninja.bytecode.iris.generator.layer;
+
+import java.util.Random;
+
+import org.bukkit.Material;
+import org.bukkit.World;
+
+import ninja.bytecode.iris.generator.IrisGenerator;
+import ninja.bytecode.iris.generator.biome.IrisBiome;
+import ninja.bytecode.iris.util.GenLayer;
+import ninja.bytecode.iris.util.MB;
+import ninja.bytecode.shuriken.math.CNG;
+import ninja.bytecode.shuriken.math.RNG;
+
+public class GenLayerOreGold extends GenLayer
+{
+	private CNG ore;
+	private CNG clamp;
+
+	public GenLayerOreGold(IrisGenerator iris, World world, Random random, RNG rng, int shift)
+	{
+		//@builder
+		super(iris, world, random, rng);
+		ore = new CNG(rng.nextParallelRNG(281 + shift), 1D, 3).scale(0.0925).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+				.scale(0.0015).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+						.scale(0.03), 33), 592);
+		clamp = new CNG(rng.nextParallelRNG(299 + shift), 1D, 1).scale(0.0325).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+				.scale(0.015).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+						.scale(0.03), 33), 592);
+		//@done
+	}
+	
+	public void genOre(double wxx, double wzx, int x, int z, int s, IrisGenerator g, IrisBiome b)
+	{
+		double orenoise = ore.noise(wxx, wzx);		
+		
+		if(clamp.noise(wxx, wzx) < 0.4 && (int) (orenoise * 200D) - 42 < 45 && b.getSurface().contains(new MB(Material.GRASS)) && IrisGenerator.ROCK.contains(MB.of(g.getType(x, (int) (orenoise * 200D) - 42, z))))
+		{
+			g.setBlock(x, (int) (orenoise * 200D) - 42, z, Material.GOLD_ORE);
+		}
+	}
+
+	@Override
+	public double generateLayer(double noise, double dx, double dz)
+	{
+		return noise;
+	}
+}

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerOreIron.java

@@ -0,0 +1,45 @@
+package ninja.bytecode.iris.generator.layer;
+
+import java.util.Random;
+
+import org.bukkit.Material;
+import org.bukkit.World;
+
+import ninja.bytecode.iris.generator.IrisGenerator;
+import ninja.bytecode.iris.generator.biome.IrisBiome;
+import ninja.bytecode.iris.util.GenLayer;
+import ninja.bytecode.iris.util.MB;
+import ninja.bytecode.shuriken.math.CNG;
+import ninja.bytecode.shuriken.math.RNG;
+
+public class GenLayerOreIron extends GenLayer
+{
+	private CNG ore;
+
+	public GenLayerOreIron(IrisGenerator iris, World world, Random random, RNG rng, int shift)
+	{
+		//@builder
+		super(iris, world, random, rng);
+		ore = new CNG(rng.nextParallelRNG(281 + shift), 1D, 1).scale(0.1125).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+				.scale(0.015).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+						.scale(0.03), 33), 592);
+		
+		//@done
+	}
+	
+	public void genOre(double wxx, double wzx, int x, int z, int s, IrisGenerator g, IrisBiome b)
+	{
+		double orenoise = ore.noise(wxx, wzx);		
+		
+		if(IrisGenerator.ROCK.contains(MB.of(g.getType(x, (int) (orenoise * 200D), z))))
+		{
+			g.setBlock(x, (int) (orenoise * 200D), z, Material.IRON_ORE);
+		}
+	}
+
+	@Override
+	public double generateLayer(double noise, double dx, double dz)
+	{
+		return noise;
+	}
+}

src/main/java/ninja/bytecode/iris/generator/layer/GenLayerOreLapis.java

@@ -0,0 +1,45 @@
+package ninja.bytecode.iris.generator.layer;
+
+import java.util.Random;
+
+import org.bukkit.Material;
+import org.bukkit.World;
+
+import ninja.bytecode.iris.generator.IrisGenerator;
+import ninja.bytecode.iris.generator.biome.IrisBiome;
+import ninja.bytecode.iris.util.GenLayer;
+import ninja.bytecode.iris.util.MB;
+import ninja.bytecode.shuriken.math.CNG;
+import ninja.bytecode.shuriken.math.RNG;
+
+public class GenLayerOreLapis extends GenLayer
+{
+	private CNG ore;
+
+	public GenLayerOreLapis(IrisGenerator iris, World world, Random random, RNG rng, int shift)
+	{
+		//@builder
+		super(iris, world, random, rng);
+		ore = new CNG(rng.nextParallelRNG(281 + shift), 1D, 3).scale(0.4125).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+				.scale(0.0015).fractureWith(new CNG(rng.nextParallelRNG(412 + shift), 1D, 1)
+						.scale(0.03), 33), 592);
+		
+		//@done
+	}
+	
+	public void genOre(double wxx, double wzx, int x, int z, int s, IrisGenerator g, IrisBiome b)
+	{
+		double orenoise = ore.noise(wxx, wzx);		
+		
+		if(b.getSurface().contains(new MB(Material.SAND)) && IrisGenerator.ROCK.contains(MB.of(g.getType(x, (int) (orenoise * 200D), z))))
+		{
+			g.setBlock(x, (int) (orenoise * 200D), z, Material.LAPIS_ORE);
+		}
+	}
+
+	@Override
+	public double generateLayer(double noise, double dx, double dz)
+	{
+		return noise;
+	}
+}

src/main/java/ninja/bytecode/iris/generator/populator/SurfaceBiasSchematicPopulator.java

@@ -30,6 +30,11 @@ public class SurfaceBiasSchematicPopulator extends SchematicPopulator
 	@Override
 	public void doPopulate(World world, Random random, Chunk source, int wx, int wz)
 	{
+		if(schematics.length == 0)
+		{
+			return;
+		}
+		
 		Block b = world.getHighestBlockAt(wx, wz);
 		
 		for(Material i : bias)