diff --git a/src/main/java/ninja/bytecode/iris/Iris.java b/src/main/java/ninja/bytecode/iris/Iris.java index 8c3c47242..2227ed74b 100644 --- a/src/main/java/ninja/bytecode/iris/Iris.java +++ b/src/main/java/ninja/bytecode/iris/Iris.java @@ -94,12 +94,12 @@ public class Iris extends MortarPlugin r.setPhysicsThrottle(5); r.setMonsterActivationRange(5); r.setArrowDespawnRate(1); - r.setForcedGameMode(GameMode.CREATIVE); r.load(); for(Player i : Bukkit.getOnlinePlayers()) { i.teleport(r.getSpawn()); + i.setGameMode(GameMode.CREATIVE); } } diff --git a/src/main/java/ninja/bytecode/iris/Settings.java b/src/main/java/ninja/bytecode/iris/Settings.java index 1c8a4f08a..0f3a81a20 100644 --- a/src/main/java/ninja/bytecode/iris/Settings.java +++ b/src/main/java/ninja/bytecode/iris/Settings.java @@ -8,6 +8,7 @@ public class Settings { public PerformanceSettings performance = new PerformanceSettings(); public GeneratorSettings gen = new GeneratorSettings(); + public OreSettings ore = new OreSettings(); public static class PerformanceSettings { @@ -45,4 +46,42 @@ public class Settings public double biomeScale = 0.75; public boolean flatBedrock = false; } + + public static class OreSettings + { + public int ironMinHeight = 5; + public int ironMaxHeight = 65; + public double ironMaxDispersion = 0.02; + public double ironMinDispersion = 0.26; + + public int coalMinHeight = 5; + public int coalMaxHeight = 100; + public double coalMaxDispersion = 0.02; + public double coalMinDispersion = 0.29; + + public int goldMinHeight = 5; + public int goldMaxHeight = 34; + public double goldMaxDispersion = 0.01; + public double goldMinDispersion = 0.13; + + public int redstoneMinHeight = 5; + public int redstoneMaxHeight = 15; + public double redstoneMaxDispersion = 0.05; + public double redstoneMinDispersion = 0.17; + + public int lapisMinHeight = 13; + public int lapisMaxHeight = 33; + public double lapisMaxDispersion = 0.05; + public double lapisMinDispersion = 0.12; + + public int diamondMinHeight = 5; + public int diamondMaxHeight = 16; + public double diamondMaxDispersion = 0.05; + public double diamondMinDispersion = 0.1; + + public int emeraldMinHeight = 5; + public int emeraldMaxHeight = 16; + public double emeraldMaxDispersion = 0.005; + public double emeraldMinDispersion = 0.07; + } } diff --git a/src/main/java/ninja/bytecode/iris/generator/IrisGenerator.java b/src/main/java/ninja/bytecode/iris/generator/IrisGenerator.java index c6e02b7a4..a8e05b450 100644 --- a/src/main/java/ninja/bytecode/iris/generator/IrisGenerator.java +++ b/src/main/java/ninja/bytecode/iris/generator/IrisGenerator.java @@ -22,6 +22,7 @@ import ninja.bytecode.iris.generator.layer.GenLayerBiome; import ninja.bytecode.iris.generator.layer.GenLayerCaves; import ninja.bytecode.iris.generator.layer.GenLayerCliffs; import ninja.bytecode.iris.generator.layer.GenLayerLayeredNoise; +import ninja.bytecode.iris.generator.layer.GenLayerOres; import ninja.bytecode.iris.generator.layer.GenLayerSnow; import ninja.bytecode.iris.generator.parallax.ParallaxWorldGenerator; import ninja.bytecode.iris.pack.BiomeType; @@ -74,6 +75,7 @@ public class IrisGenerator extends ParallaxWorldGenerator private GenLayerSnow glSnow; private GenLayerCliffs glCliffs; private GenLayerCaves glCaves; + private GenLayerOres glOres; private RNG rTerrain; private CompiledDimension dim; private IrisMetrics metrics = new IrisMetrics(0, 512); @@ -130,6 +132,7 @@ public class IrisGenerator extends ParallaxWorldGenerator glSnow = new GenLayerSnow(this, world, random, rTerrain.nextParallelRNG(5)); glCliffs = new GenLayerCliffs(this, world, random, rTerrain.nextParallelRNG(9)); glCaves = new GenLayerCaves(this, world, random, rTerrain.nextParallelRNG(10)); + glOres = new GenLayerOres(this, world, random, rTerrain.nextParallelRNG(11)); scatter = new CNG(rTerrain.nextParallelRNG(52), 1, 1).scale(10); if(Iris.settings.performance.objectMode.equals(ObjectMode.PARALLAX)) @@ -390,6 +393,7 @@ public class IrisGenerator extends ParallaxWorldGenerator if(!surfaceOnly) { glCaves.genCaves(wxxf, wzxf, x, z, data, plan); + glOres.genOres(wxxf, wzxf, x, z, hl, data, plan); } plan.setRealHeight(x, z, hl); diff --git a/src/main/java/ninja/bytecode/iris/generator/layer/GenLayerCaves.java b/src/main/java/ninja/bytecode/iris/generator/layer/GenLayerCaves.java index e0ccbb17b..39ab83fec 100644 --- a/src/main/java/ninja/bytecode/iris/generator/layer/GenLayerCaves.java +++ b/src/main/java/ninja/bytecode/iris/generator/layer/GenLayerCaves.java @@ -25,9 +25,9 @@ public class GenLayerCaves extends GenLayer { //@builder super(iris, world, random, rng); - g = new PolygonGenerator(RNG.r, 3, 0.014, 1, (c) -> c); - gincline = new CNG(RNG.r, 1D, 3).scale(0.00652); - gfract = new CNG(RNG.r, 24D, 1).scale(0.0152); + g = new PolygonGenerator(rng.nextParallelRNG(1111), 3, 0.014, 1, (c) -> c); + gincline = new CNG(rng.nextParallelRNG(1112), 1D, 3).scale(0.00652); + gfract = new CNG(rng.nextParallelRNG(1113), 24D, 1).scale(0.0152); //@done } @@ -110,11 +110,11 @@ public class GenLayerCaves extends GenLayer public boolean cann(Material m) { - return m.isSolid() || m.equals(Material.AIR); + return m.isSolid() || m.equals(Material.AIR) && !m.equals(Material.BEDROCK); } public boolean can(Material m) { - return m.isSolid(); + return m.isSolid() && !m.equals(Material.BEDROCK); } } diff --git a/src/main/java/ninja/bytecode/iris/generator/layer/GenLayerOres.java b/src/main/java/ninja/bytecode/iris/generator/layer/GenLayerOres.java new file mode 100644 index 000000000..9abb49421 --- /dev/null +++ b/src/main/java/ninja/bytecode/iris/generator/layer/GenLayerOres.java @@ -0,0 +1,145 @@ +package ninja.bytecode.iris.generator.layer; + +import java.util.Random; + +import org.bukkit.Material; +import org.bukkit.World; + +import ninja.bytecode.iris.Iris; +import ninja.bytecode.iris.Settings.OreSettings; +import ninja.bytecode.iris.generator.IrisGenerator; +import ninja.bytecode.iris.generator.atomics.AtomicChunkData; +import ninja.bytecode.iris.util.ChunkPlan; +import ninja.bytecode.iris.util.GenLayer; +import ninja.bytecode.iris.util.IrisInterpolation; +import ninja.bytecode.shuriken.bench.PrecisionStopwatch; +import ninja.bytecode.shuriken.math.CNG; +import ninja.bytecode.shuriken.math.M; +import ninja.bytecode.shuriken.math.RNG; + +public class GenLayerOres extends GenLayer +{ + private CNG ore; + + public GenLayerOres(IrisGenerator iris, World world, Random random, RNG rng) + { + //@builder + super(iris, world, random, rng); + ore = new CNG(rng.nextParallelRNG(12944), 1D, 1).scale(0.1); + //@done + } + + @Override + public double generateLayer(double gnoise, double dx, double dz) + { + return gnoise; + } + + public void genOres(double xxf, double zzf, int x, int z, int h, AtomicChunkData data, ChunkPlan plan) + { + PrecisionStopwatch s = PrecisionStopwatch.start(); + OreSettings o = Iris.settings.ore; + + for(int i = 0; i < h; i++) + { + if(i >= o.ironMinHeight && i <= o.ironMaxHeight && + ore.noise(xxf + 64, i, zzf - 64) < IrisInterpolation.lerpCenterSinBezier( + o.ironMinDispersion, + Iris.settings.ore.ironMaxDispersion, + M.lerpInverse(o.ironMinHeight, o.ironMaxHeight, i))) + { + if(!can(data.getType(x, i, z))) + { + continue; + } + + data.setBlock(x, i, z, Material.IRON_ORE); + } + + if(i >= o.coalMinHeight && i <= o.coalMaxHeight && + ore.noise(xxf + 128, i, zzf - 128) < IrisInterpolation.lerpCenterSinBezier( + o.coalMinDispersion, + Iris.settings.ore.coalMaxDispersion, + M.lerpInverse(o.coalMinHeight, o.coalMaxHeight, i))) + { + if(!can(data.getType(x, i, z))) + { + continue; + } + data.setBlock(x, i, z, Material.COAL_ORE); + } + + if(i >= o.goldMinHeight && i <= o.goldMaxHeight && + ore.noise(xxf + 64, i, zzf - 128) < IrisInterpolation.lerpCenterSinBezier( + o.goldMinDispersion, + Iris.settings.ore.goldMaxDispersion, + M.lerpInverse(o.goldMinHeight, o.goldMaxHeight, i))) + { + if(!can(data.getType(x, i, z))) + { + continue; + } + data.setBlock(x, i, z, Material.GOLD_ORE); + } + + if(i >= o.redstoneMinHeight && i <= o.redstoneMaxHeight && + ore.noise(xxf + 128, i, zzf - 64) < IrisInterpolation.lerpCenterSinBezier( + o.redstoneMinDispersion, + Iris.settings.ore.redstoneMaxDispersion, + M.lerpInverse(o.redstoneMinHeight, o.redstoneMaxHeight, i))) + { + if(!can(data.getType(x, i, z))) + { + continue; + } + data.setBlock(x, i, z, Material.REDSTONE_ORE); + } + + if(i >= o.lapisMinHeight && i <= o.lapisMaxHeight && + ore.noise(xxf + 256, i, zzf - 64) < IrisInterpolation.lerpCenterSinBezier( + o.lapisMinDispersion, + Iris.settings.ore.lapisMaxDispersion, + M.lerpInverse(o.lapisMinHeight, o.lapisMaxHeight, i))) + { + if(!can(data.getType(x, i, z))) + { + continue; + } + data.setBlock(x, i, z, Material.LAPIS_ORE); + } + + if(i >= o.diamondMinHeight && i <= o.diamondMaxHeight && + ore.noise(xxf + 64, i, zzf - 256) < IrisInterpolation.lerpCenterSinBezier( + o.diamondMinDispersion, + Iris.settings.ore.diamondMaxDispersion, + M.lerpInverse(o.diamondMinHeight, o.diamondMaxHeight, i))) + { + if(!can(data.getType(x, i, z))) + { + continue; + } + data.setBlock(x, i, z, Material.DIAMOND_ORE); + } + + if(i >= o.emeraldMinHeight && i <= o.emeraldMaxHeight && + ore.noise(xxf + 128, i, zzf - 256) < IrisInterpolation.lerpCenterSinBezier( + o.emeraldMinDispersion, + Iris.settings.ore.emeraldMaxDispersion, + M.lerpInverse(o.emeraldMinHeight, o.emeraldMaxHeight, i))) + { + if(!can(data.getType(x, i, z))) + { + continue; + } + data.setBlock(x, i, z, Material.EMERALD_ORE); + } + } + + iris.getMetrics().stop("ores:ms:x256:/chunk:..", s); + } + + public boolean can(Material m) + { + return m.equals(Material.STONE) || m.name().endsWith("_ORE"); + } +} diff --git a/src/main/java/ninja/bytecode/iris/util/IrisInterpolation.java b/src/main/java/ninja/bytecode/iris/util/IrisInterpolation.java index dde503807..f343bd2b7 100644 --- a/src/main/java/ninja/bytecode/iris/util/IrisInterpolation.java +++ b/src/main/java/ninja/bytecode/iris/util/IrisInterpolation.java @@ -25,6 +25,16 @@ public class IrisInterpolation return a + (bezier(f) * (b - a)); } + public static double sinCenter(double f) + { + return (M.sin((float) ((f * Math.PI * 2D) + 4.745555D)) + 1D) / 2D; + } + + public static double lerpCenterSinBezier(double a, double b, double f) + { + return lerpBezier(a, b, sinCenter(f)); + } + public static double lerpParametric(double a, double b, double f, double v) { return a + (parametric(f, v) * (b - a));