Ravines

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

@@ -31,6 +31,10 @@ public class IrisDecorator
 	@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("Forcefully place this decorant anywhere it is supposed to go even if it should not go on a specific surface block. For example, you could force tallgrass to place on top of stone by using this.")
+	private boolean forcePlace = false;
+
 	@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 style = NoiseStyle.STATIC.style();

src/main/java/com/volmit/iris/v2/generator/IrisEngine.java

@@ -41,12 +41,13 @@ public class IrisEngine implements Engine
             () -> getFramework().getEngineParallax().generateParallaxArea(x, z),
             () -> Hunk.computeDual2D(getParallelism(), blocks, biomes, (xx,yy,zz,ha,hb) -> {
                 getFramework().getTerrainActuator().actuate(x+xx, z+zz, ha);
-                getFramework().getDecorantActuator().actuate(x+xx, z+zz, ha);
                 getFramework().getBiomeActuator().actuate(x+xx, z+zz, hb);
             })
         );
-
+        getFramework().getRavineModifier().modify(x, z, blocks);
+        getFramework().getDepositModifier().modify(x, z, blocks);
         blocks.compute2D(getParallelism(), (xx,yy,zz,ha) -> {
+            getFramework().getDecorantActuator().actuate(x+xx, z+zz, ha);
             getFramework().getEngineParallax().insertParallax(x, z, ha);
         });
 

src/main/java/com/volmit/iris/v2/generator/IrisEngineFramework.java

@@ -7,14 +7,9 @@ import com.volmit.iris.object.IrisObjectPlacement;
 import com.volmit.iris.util.B;
 import com.volmit.iris.util.IObjectPlacer;
 import com.volmit.iris.util.RNG;
-import com.volmit.iris.v2.generator.actuator.IrisBiomeActuator;
-import com.volmit.iris.v2.generator.actuator.IrisDecorantActuator;
-import com.volmit.iris.v2.generator.actuator.IrisTerrainActuator;
+import com.volmit.iris.v2.generator.actuator.*;
 import com.volmit.iris.v2.generator.modifier.IrisCaveModifier;
-import com.volmit.iris.v2.scaffold.engine.Engine;
-import com.volmit.iris.v2.scaffold.engine.EngineActuator;
-import com.volmit.iris.v2.scaffold.engine.EngineFramework;
-import com.volmit.iris.v2.scaffold.engine.EngineParallax;
+import com.volmit.iris.v2.scaffold.engine.*;
 import lombok.Getter;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
@@ -39,6 +34,12 @@ public class IrisEngineFramework implements EngineFramework {
     @Getter
     private final EngineActuator<BlockData> decorantActuator;
 
+    @Getter
+    private final EngineModifier<BlockData> depositModifier;
+
+    @Getter
+    private final EngineModifier<BlockData> ravineModifier;
+
     @Getter
     private final EngineActuator<Biome> biomeActuator;
 
@@ -51,5 +52,7 @@ public class IrisEngineFramework implements EngineFramework {
         this.terrainActuator = new IrisTerrainActuator(getEngine());
         this.decorantActuator = new IrisDecorantActuator(getEngine());
         this.biomeActuator = new IrisBiomeActuator(getEngine());
+        this.depositModifier = new IrisDepositModifier(getEngine());
+        this.ravineModifier = new IrisRavineModifier(getEngine());
     }
 }

src/main/java/com/volmit/iris/v2/generator/actuator/IrisDecorantActuator.java

@@ -1,5 +1,6 @@
 package com.volmit.iris.v2.generator.actuator;
 
+import com.volmit.iris.util.B;
 import com.volmit.iris.util.KList;
 import com.volmit.iris.v2.scaffold.engine.Engine;
 import com.volmit.iris.v2.scaffold.engine.EngineAssignedActuator;
@@ -95,13 +96,27 @@ public class IrisDecorantActuator extends EngineAssignedActuator<BlockData>
                 if(deco.isStacking())
                 {
                     int stack = Math.min(g.i(deco.getStackMin(), deco.getStackMax()), height);
+                    boolean fail = false;
 
                     for(int i = 0; i < stack; i++)
                     {
-                        h.set(hunkRelativeX, i + floor, hunkRelativeZ, deco.getBlockData100(b, rng, realX - i, realZ + i, getData()));
+                        BlockData v = deco.getBlockData100(b, rng, realX - i, realZ + i, getData());
+                        if(i == 0 && (deco.isForcePlace() || canGoOn(h.get(hunkRelativeX, i+floor-1, hunkRelativeZ), v)))
+                        {
+                            h.set(hunkRelativeX, i+floor, hunkRelativeZ, v);
+                            continue;
+                        }
+
+                        else if(i == 0)
+                        {
+                            fail = true;
+                            break;
+                        }
+
+                        h.set(hunkRelativeX, i + floor, hunkRelativeZ, v);
                     }
 
-                    if(deco.getTopPalette().isNotEmpty())
+                    if(!fail && deco.getTopPalette().isNotEmpty())
                     {
                         h.set(hunkRelativeX, stack + floor - 1, hunkRelativeZ, deco.getBlockDataForTop(b, rng, realX - stack, realZ + stack, getData()));
                     }
@@ -109,7 +124,11 @@ public class IrisDecorantActuator extends EngineAssignedActuator<BlockData>
 
                 else
                 {
-                    h.set(hunkRelativeX, floor, hunkRelativeZ, deco.getBlockData100(b, rng, realX, realZ, getData()));
+                    BlockData v = deco.getBlockData100(b, rng, realX, realZ, getData());
+                    if(deco.isForcePlace() || canGoOn(h.get(hunkRelativeX, floor-1, hunkRelativeZ), v))
+                    {
+                        h.set(hunkRelativeX, floor, hunkRelativeZ, v);
+                    }
                 }
             }
         }
@@ -124,10 +143,24 @@ public class IrisDecorantActuator extends EngineAssignedActuator<BlockData>
                 if(deco.isStacking())
                 {
                     int stack = Math.min(g.i(deco.getStackMin(), deco.getStackMax()), height);
+                    boolean fail = false;
 
                     for(int i = 0; i < stack; i++)
                     {
-                        h.set(hunkRelativeX, i + floor, hunkRelativeZ, deco.getBlockData100(b, rng, realX - i, realZ + i, getData()));
+                        BlockData v = deco.getBlockData100(b, rng, realX - i, realZ + i, getData());
+                        if(i == 0 && (deco.isForcePlace() || canGoOn(h.get(hunkRelativeX, i+floor-1, hunkRelativeZ), v)))
+                        {
+                            h.set(hunkRelativeX, i+floor, hunkRelativeZ, v);
+                            continue;
+                        }
+
+                        else if(i == 0)
+                        {
+                            fail = true;
+                            break;
+                        }
+
+                        h.set(hunkRelativeX, i + floor, hunkRelativeZ, v);
                     }
 
                     if(deco.getTopPalette().isNotEmpty())
@@ -138,7 +171,11 @@ public class IrisDecorantActuator extends EngineAssignedActuator<BlockData>
 
                 else
                 {
-                    h.set(hunkRelativeX, floor, hunkRelativeZ, deco.getBlockData100(b, rng, realX, realZ, getData()));
+                    BlockData v = deco.getBlockData100(b, rng, realX, realZ, getData());
+                    if(deco.isForcePlace() || canGoOn(h.get(hunkRelativeX, floor-1, hunkRelativeZ), v))
+                    {
+                        h.set(hunkRelativeX, floor, hunkRelativeZ, v);
+                    }
                 }
             }
 
@@ -210,4 +247,9 @@ public class IrisDecorantActuator extends EngineAssignedActuator<BlockData>
             }
         }
     }
+
+    private boolean canGoOn(BlockData decorant, BlockData atop)
+    {
+        return B.canPlaceOnto(decorant.getMaterial(), atop.getMaterial());
+    }
 }

src/main/java/com/volmit/iris/v2/generator/actuator/IrisDepositModifier.java

@@ -0,0 +1,137 @@
+package com.volmit.iris.v2.generator.actuator;
+
+import com.volmit.iris.gen.TopographicTerrainProvider;
+import com.volmit.iris.gen.scaffold.TerrainChunk;
+import com.volmit.iris.object.IrisBiome;
+import com.volmit.iris.object.IrisDepositGenerator;
+import com.volmit.iris.object.IrisObject;
+import com.volmit.iris.object.IrisRegion;
+import com.volmit.iris.util.B;
+import com.volmit.iris.util.HeightMap;
+import com.volmit.iris.util.PrecisionStopwatch;
+import com.volmit.iris.util.RNG;
+import com.volmit.iris.v2.scaffold.engine.Engine;
+import com.volmit.iris.v2.scaffold.engine.EngineAssignedModifier;
+import com.volmit.iris.v2.scaffold.hunk.Hunk;
+import org.bukkit.Material;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.util.BlockVector;
+
+public class IrisDepositModifier extends EngineAssignedModifier<BlockData> {
+    private final RNG rng;
+    public IrisDepositModifier(Engine engine) {
+        super(engine, "Deposit");
+        rng = new RNG(getEngine().getWorld().getSeed()+12938).nextParallelRNG(28348777);
+    }
+
+    @Override
+    public void onModify(int x, int z, Hunk<BlockData> output) {
+        IrisBiome biome = getComplex().getTrueBiomeStream().get(x, z);
+        generateDeposits(rng, output, Math.floorDiv(x, 16), Math.floorDiv(z, 16));
+    }
+
+    public void generateDeposits(RNG rx, Hunk<BlockData> terrain, int x, int z)
+    {
+        RNG ro = rx.nextParallelRNG(x * x).nextParallelRNG(z * z);
+        IrisRegion region = getComplex().getRegionStream().get((x * 16) + 7, (z * 16) + 7);
+        IrisBiome biome = getComplex().getTrueBiomeStream().get((x * 16) + 7, (z * 16) + 7);
+
+        for(IrisDepositGenerator k : getDimension().getDeposits())
+        {
+            generate(k, terrain, ro, x, z, false);
+        }
+
+        for(IrisDepositGenerator k : region.getDeposits())
+        {
+            for(int l = 0; l < ro.i(k.getMinPerChunk(), k.getMaxPerChunk()); l++)
+            {
+                generate(k, terrain, ro, x, z, false);
+            }
+        }
+
+        for(IrisDepositGenerator k : biome.getDeposits())
+        {
+            for(int l = 0; l < ro.i(k.getMinPerChunk(), k.getMaxPerChunk()); l++)
+            {
+                generate(k, terrain, ro, x, z, false);
+            }
+        }
+    }
+
+    public void generate(IrisDepositGenerator k, Hunk<BlockData> data, RNG rng, int cx, int cz, boolean safe)
+    {
+        generate(k, data, rng, cx, cz, safe, null);
+    }
+
+    public void generate(IrisDepositGenerator k, Hunk<BlockData> data, RNG rng, int cx, int cz, boolean safe, HeightMap he)
+    {
+        for(int l = 0; l < rng.i(k.getMinPerChunk(), k.getMaxPerChunk()); l++)
+        {
+            IrisObject clump = k.getClump(rng, getData());
+
+            int af = (int) Math.ceil(clump.getW() / 2D);
+            int bf = (int) Math.floor(16D - (clump.getW() / 2D));
+
+            if(af > bf || af < 0 || bf > 15 || af > 15 || bf < 0)
+            {
+                af = 6;
+                bf = 9;
+            }
+
+            int x = rng.i(af, bf);
+            int z = rng.i(af, bf);
+            int height = (he != null ? he.getHeight((cx << 4) + x, (cz << 4) + z) : (int) (Math.round(
+                    getComplex().getHeightStream().get((cx << 4) + x, (cz << 4) + z)
+            ))) - 7;
+
+            if(height <= 0)
+            {
+                return;
+            }
+
+            int i = Math.max(0, k.getMinHeight());
+            int a = Math.min(height, Math.min(256, k.getMaxHeight()));
+
+            if(i >= a)
+            {
+                return;
+            }
+
+            int h = rng.i(i, a);
+
+            if(h > k.getMaxHeight() || h < k.getMinHeight() || h > height - 2)
+            {
+                return;
+            }
+
+            for(BlockVector j : clump.getBlocks().keySet())
+            {
+                int nx = j.getBlockX() + x;
+                int ny = j.getBlockY() + h;
+                int nz = j.getBlockZ() + z;
+
+                if(ny > height || nx > 15 || nx < 0 || ny > 255 || ny < 0 || nz < 0 || nz > 15)
+                {
+                    continue;
+                }
+
+                boolean allow = false;
+
+                BlockData b = data.get(nx, ny, nz);
+                if(b != null) {
+                    for (BlockData f : getDimension().getRockPalette().getBlockData(getData())) {
+                        if (f.getMaterial().equals(b.getMaterial())) {
+                            allow = true;
+                            break;
+                        }
+                    }
+                }
+
+                if(allow)
+                {
+                    data.set(nx, ny, nz, clump.getBlocks().get(j));
+                }
+            }
+        }
+    }
+}

src/main/java/com/volmit/iris/v2/generator/actuator/IrisRavineModifier.java

@@ -0,0 +1,293 @@
+package com.volmit.iris.v2.generator.actuator;
+
+import com.volmit.iris.gen.atomics.AtomicSliverMap;
+import com.volmit.iris.gen.scaffold.TerrainChunk;
+import com.volmit.iris.noise.CNG;
+import com.volmit.iris.object.IrisBiome;
+import com.volmit.iris.object.NoiseStyle;
+import com.volmit.iris.util.*;
+import com.volmit.iris.v2.scaffold.engine.Engine;
+import com.volmit.iris.v2.scaffold.engine.EngineAssignedModifier;
+import com.volmit.iris.v2.scaffold.hunk.Hunk;
+import org.bukkit.Material;
+import org.bukkit.block.data.BlockData;
+
+public class IrisRavineModifier extends EngineAssignedModifier<BlockData> {
+    private static final BlockData CAVE_AIR = B.get("CAVE_AIR");
+    private static final BlockData LAVA = B.get("LAVA");
+    private CNG cng;
+    private RNG rng;
+
+    public IrisRavineModifier(Engine engine) {
+        super(engine, "Ravine");
+        rng = new RNG(getEngine().getWorld().getSeed()).nextParallelRNG(29596878);
+        cng = NoiseStyle.IRIS_THICK.create(rng);
+    }
+
+    @Override
+    public void onModify(int x, int z, Hunk<BlockData> output) {
+        generateRavines(rng, Math.floorDiv(x, 16), Math.floorDiv(z, 16), output);
+    }
+
+    private void set(Hunk<BlockData> pos, int x, int y, int z, BlockData b)
+    {
+        pos.set(x, y, z, b);
+    }
+
+    private BlockData get(Hunk<BlockData> pos, int x, int y, int z)
+    {
+        BlockData  bb = pos.get(x, y, z);
+
+        if(bb == null)
+        {
+            bb =  CAVE_AIR;
+        }
+
+        return bb;
+    }
+
+    private BlockData getSurfaceBlock(int n6, int i, RNG rmg)
+    {
+        return getComplex().getTrueBiomeStream().get(n6,i).getSurfaceBlock(n6, i, rmg, getData());
+    }
+
+    private float[] ravineCache = new float[1024];
+
+    private void doRavine(long seed, int tx, int tz, ChunkPosition pos, double sx, double sy, double sz, float f, float f2, float f3, int n3, int n4, double d4, RNG bbx, Hunk<BlockData> terrain)
+    {
+        int n5;
+        RNG random = new RNG(seed);
+        double x = tx * 16 + 8;
+        double z = tz * 16 + 8;
+        float f4 = 0.0f;
+        float f5 = 0.0f;
+        if(n4 <= 0)
+        {
+            n5 = 8 * 16 - 16;
+            n4 = n5 - random.nextInt(n5 / 4);
+        }
+        n5 = 0;
+        if(n3 == -1)
+        {
+            n3 = n4 / 2;
+            n5 = 1;
+        }
+        float f6 = 1.0f;
+        for(int i = 0; i < 256; ++i)
+        {
+            if(i == 0 || random.nextInt(getDimension().getRavineRibRarity()) == 0)
+            {
+                f6 = 1.0f + random.nextFloat() * random.nextFloat() * 1.0f;
+            }
+            this.ravineCache[i] = f6 * f6;
+        }
+        while(n3 < n4)
+        {
+            double d7 = 1.5 + (double) (MathHelper.sin((float) n3 * 3.1415927f / (float) n4) * f * 1.0f);
+            double d8 = d7 * d4;
+            d7 *= (double) random.nextFloat() * 0.25 + 0.75;
+            d8 *= (double) random.nextFloat() * 0.25 + 0.75;
+            float f7 = MathHelper.cos(f3);
+            float f8 = MathHelper.sin(f3);
+            sx = sx + (double) (MathHelper.cos(f2) * f7);
+            sy += f8;
+            sz += MathHelper.sin(f2) * f7;
+            f3 *= 0.7f;
+            f3 += f5 * 0.05f;
+            f2 += f4 * 0.05f;
+            f5 *= 0.8f;
+            f4 *= 0.5f;
+            f5 += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 2.0f;
+            f4 += (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 4.0f;
+            if(n5 != 0 || random.nextInt(4) != 0)
+            {
+                double d9 = sx - x;
+                double d10 = sz - z;
+                double d11 = n4 - n3;
+                double d12 = f + 2.0f + 16.0f;
+                if(d9 * d9 + d10 * d10 - d11 * d11 > d12 * d12)
+                {
+                    return;
+                }
+                if(sx >= x - 16.0 - d7 * 2.0 && sz >= z - 16.0 - d7 * 2.0 && sx <= x + 16.0 + d7 * 2.0 && sz <= z + 16.0 + d7 * 2.0)
+                {
+                    int n6;
+                    int n7 = MathHelper.floor(sx - d7) - tx * 16 - 1;
+                    int n8 = MathHelper.floor(sx + d7) - tx * 16 + 1;
+                    int n9 = MathHelper.floor(sy - d8) - 1;
+                    int n10 = MathHelper.floor(sy + d8) + 1;
+                    int n11 = MathHelper.floor(sz - d7) - tz * 16 - 1;
+                    int n12 = MathHelper.floor(sz + d7) - tz * 16 + 1;
+                    if(n7 < 0)
+                    {
+                        n7 = 0;
+                    }
+                    if(n8 > 16)
+                    {
+                        n8 = 16;
+                    }
+                    if(n9 < 1)
+                    {
+                        n9 = 1;
+                    }
+                    if(n10 > 248)
+                    {
+                        n10 = 248;
+                    }
+                    if(n11 < 0)
+                    {
+                        n11 = 0;
+                    }
+                    if(n12 > 16)
+                    {
+                        n12 = 16;
+                    }
+                    boolean bl = false;
+                    for(int i = n7; !bl && i < n8; ++i)
+                    {
+                        for(n6 = n11; !bl && n6 < n12; ++n6)
+                        {
+                            for(int j = n10 + 1; !bl && j >= n9 - 1; --j)
+                            {
+                                if(j < 0 || j >= 256)
+                                {
+                                    continue;
+                                }
+
+                                BlockData bb = get(terrain, i, j, n6);
+
+                                if(B.isWater(bb))
+                                {
+                                    bl = true;
+                                }
+
+                                if(j == n9 - 1 || i == n7 || i == n8 - 1 || n6 == n11 || n6 == n12 - 1)
+                                {
+                                    continue;
+                                }
+                                j = n9;
+                            }
+                        }
+                    }
+                    if(!bl) {
+                        BlockPosition bps = new BlockPosition(0, 0, 0);
+                        for (n6 = n7; n6 < n8; ++n6) {
+                            double d13 = ((double) (n6 + tx * 16) + 0.5 - sx) / d7;
+                            for (int i = n11; i < n12; ++i) {
+                                double d14 = ((double) (i + tz * 16) + 0.5 - sz) / d7;
+                                boolean bl2 = false;
+                                if (d13 * d13 + d14 * d14 >= 1.0) {
+                                    continue;
+                                }
+                                for (int j = n10; j > n9; --j) {
+                                    double d15 = ((double) (j - 1) + 0.5 - sy) / d8;
+                                    if ((d13 * d13 + d14 * d14) * (double) this.ravineCache[j - 1] + d15 * d15 / 6.0 >= 1.0) {
+                                        continue;
+                                    }
+
+                                    BlockData blockData = get(terrain, n6, j, i);
+
+                                    if (isSurface(blockData)) {
+                                        bl2 = true;
+                                    }
+
+                                    if (j - 1 < 10) {
+                                        set(terrain, n6, j, i, LAVA);
+                                        continue;
+                                    }
+
+                                    set(terrain, n6, j, i, CAVE_AIR);
+                                    if (!bl2 || !isDirt(get(terrain, n6, j - 1, i))) {
+                                        continue;
+                                    }
+
+                                    cSet(bps, n6 + tx * 16, 0, i + tz * 16);
+                                    set(terrain, n6, j - 1, i, getSurfaceBlock(n6, i, rng));
+                                }
+                            }
+                        }
+                        if (n5 != 0)
+                        {
+                            break;
+                        }
+                    }
+                }
+            }
+            ++n3;
+        }
+    }
+
+    private BlockPosition cSet(BlockPosition bb, double var0, double var2, double var4)
+    {
+        bb.setX(MathHelper.floor((double) var0));
+        bb.setY(MathHelper.floor((double) var2));
+        bb.setZ(MathHelper.floor((double) var4));
+
+        return bb;
+    }
+
+    private boolean isDirt(BlockData d)
+    {
+        //@builder
+        Material m = d.getMaterial();
+        return m.equals(Material.DIRT) ||
+                m.equals(Material.COARSE_DIRT) ||
+                m.equals(Material.SAND);
+        //@done
+    }
+
+    private boolean isSurface(BlockData d)
+    {
+        //@builder
+        Material m = d.getMaterial();
+        return m.equals(Material.GRASS_BLOCK) ||
+                m.equals(Material.DIRT) ||
+                m.equals(Material.COARSE_DIRT) ||
+                m.equals(Material.PODZOL) ||
+                m.equals(Material.SAND);
+        //@done
+    }
+
+    public void genRavines(int n, int n2, ChunkPosition chunkSnapshot, RNG bbb, Hunk<BlockData> terrain)
+    {
+        RNG b = this.rng.nextParallelRNG(21949666);
+        RNG bx = this.rng.nextParallelRNG(6676121);
+        long l = b.nextLong();
+        long l2 = b.nextLong();
+        for(int i = n - 8; i <= n + 8; ++i)
+        {
+            for(int j = n2 - 8; j <= n2 + 8; ++j)
+            {
+                long l3 = (long) i * l;
+                long l4 = (long) j * l2;
+                bx = this.rng.nextParallelRNG((int) (l3 ^ l4 ^ 6676121));
+                doRavines(i, j, n, n2, chunkSnapshot, bx, terrain);
+            }
+        }
+    }
+
+    private void doRavines(int tx, int tz, int sx, int sz, ChunkPosition chunkSnapshot, RNG b, Hunk<BlockData> terrain)
+    {
+        if(b.nextInt(getDimension().getRavineRarity()) != 0)
+        {
+            return;
+        }
+
+        double x = tx * 16 + b.nextInt(16);
+        double d2 = b.nextInt(b.nextInt(40) + 8) + 20;
+        double z = tz * 16 + b.nextInt(16);
+        int n5 = 1;
+        for(int i = 0; i < n5; ++i)
+        {
+            float f = b.nextFloat() * 3.1415927f * 2.0f;
+            float f2 = (b.nextFloat() - 0.5f) * 2.0f / 8.0f;
+            float f3 = (b.nextFloat() * 2.0f + b.nextFloat()) * 2.0f;
+            this.doRavine(b.nextLong(), sx, sz, chunkSnapshot, x, d2, z, f3, f, f2, 0, 0, 3.0, b, terrain);
+        }
+    }
+
+    public void generateRavines(RNG nextParallelRNG, int x, int z, Hunk<BlockData> terrain)
+    {
+        genRavines(x, z, new ChunkPosition(x, z), nextParallelRNG.nextParallelRNG(x).nextParallelRNG(z), terrain);
+    }
+}

src/main/java/com/volmit/iris/v2/generator/actuator/IrisTerrainActuator.java

@@ -1,10 +1,12 @@
 package com.volmit.iris.v2.generator.actuator;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.gen.scaffold.TerrainChunk;
 import com.volmit.iris.noise.CNG;
 import com.volmit.iris.object.*;
 import com.volmit.iris.util.CaveResult;
 import com.volmit.iris.util.KList;
+import com.volmit.iris.util.PrecisionStopwatch;
 import com.volmit.iris.util.RNG;
 import com.volmit.iris.v2.scaffold.engine.Engine;
 import com.volmit.iris.v2.scaffold.engine.EngineAssignedActuator;
@@ -28,17 +30,14 @@ public class IrisTerrainActuator extends EngineAssignedActuator<BlockData>
 
     @Override
     public void onActuate(int x, int z, Hunk<BlockData> h) {
-        int i,zf, depth, realX, realZ,hf, he, b, ch;
+        int i, zf, depth, realX, realZ, hf, he, b;
         IrisBiome biome;
-        boolean firstCarve;
         KList<BlockData> blocks;
-        KList<CaveResult> caves;
 
         for(int xf = 0; xf < h.getWidth(); xf++)
         {
             for(zf = 0; zf < h.getDepth(); zf++)
             {
-                firstCarve = true;
                 realX = xf + x;
                 realZ = zf + z;
                 b = hasUnder ? (int) Math.round(getDimension().getUndercarriage().get(rng, realX, realZ)) : 0;
@@ -46,7 +45,6 @@ public class IrisTerrainActuator extends EngineAssignedActuator<BlockData>
                 hf = (int) Math.round(Math.max(Math.min(h.getHeight(), getDimension().getFluidHeight()), he));
                 biome = getComplex().getTrueBiomeStream().get(realX, realZ);
                 blocks = null;
-                ch = he;
 
                 if(hf < b)
                 {
@@ -63,19 +61,9 @@ public class IrisTerrainActuator extends EngineAssignedActuator<BlockData>
 
                     if(getDimension().isCarved(realX, i, realZ, rng, he))
                     {
-                        if(firstCarve)
-                        {
-                            ch = i - 1;
-                        }
-
                         continue;
                     }
 
-                    else
-                    {
-                        firstCarve = false;
-                    }
-
                     if(i > he  && i <= hf)
                     {
                         h.set(xf, i, zf, getComplex().getFluidStream().get(realX, +realZ));
@@ -99,41 +87,6 @@ public class IrisTerrainActuator extends EngineAssignedActuator<BlockData>
                         h.set(xf, i, zf, getComplex().getRockStream().get(realX, realZ));
                     }
                 }
-
-                caves = getDimension().isCaves() ? getFramework().getCaveModifier().genCaves(realX, realZ, realX & 15, realZ & 15, h) : null;
-
-                if(caves != null && caves.isNotEmpty())
-                {
-                    IrisBiome cave = getComplex().getCaveBiomeStream().get(realX, realZ);
-
-                    if(cave == null)
-                    {
-                        continue;
-                    }
-
-                    for(CaveResult cl : caves)
-                    {
-                        if(cl.getFloor() < 0 || cl.getFloor() > getEngine().getHeight() || cl.getCeiling() > getEngine().getHeight() || cl.getCeiling() < 0)
-                        {
-                            continue;
-                        }
-
-                        KList<BlockData> floor = cave.generateLayers(realX, realZ, rng, cl.getFloor(), cl.getFloor(), getData());
-                        KList<BlockData> ceiling = cave.generateLayers(realX + 656, realZ - 656, rng,
-                                (he) - cl.getCeiling(),
-                                (he) - cl.getCeiling(), getData());
-
-                        for(int j = 0; j < floor.size(); j++)
-                        {
-                            h.set(xf, cl.getFloor() - j, zf, floor.get(j));
-                        }
-
-                        for(int j = ceiling.size() - 1; j > 0; j--)
-                        {
-                            h.set(xf, cl.getCeiling() + j, zf, ceiling.get(j));
-                        }
-                    }
-                }
             }
         }
     }

src/main/java/com/volmit/iris/v2/scaffold/engine/EngineFramework.java

@@ -1,6 +1,7 @@
 package com.volmit.iris.v2.scaffold.engine;
 
 import com.volmit.iris.v2.generator.IrisEngine;
+import com.volmit.iris.v2.generator.actuator.IrisRavineModifier;
 import com.volmit.iris.v2.generator.modifier.IrisCaveModifier;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
@@ -28,4 +29,8 @@ public interface EngineFramework extends DataProvider
     public EngineActuator<Biome> getBiomeActuator();
 
     public IrisCaveModifier getCaveModifier();
+
+    public EngineModifier<BlockData> getRavineModifier();
+
+    public EngineModifier<BlockData> getDepositModifier();
 }