From bd5ca76ef464443e7296492b918b3b9609125124 Mon Sep 17 00:00:00 2001 From: Daniel Mills Date: Mon, 2 Nov 2020 11:23:33 -0500 Subject: [PATCH] Ravines --- .../com/volmit/iris/object/IrisDecorator.java | 4 + .../volmit/iris/v2/generator/IrisEngine.java | 5 +- .../v2/generator/IrisEngineFramework.java | 17 +- .../actuator/IrisDecorantActuator.java | 52 +++- .../actuator/IrisDepositModifier.java | 137 ++++++++ .../actuator/IrisRavineModifier.java | 293 ++++++++++++++++++ .../actuator/IrisTerrainActuator.java | 53 +--- .../v2/scaffold/engine/EngineFramework.java | 5 + 8 files changed, 502 insertions(+), 64 deletions(-) create mode 100644 src/main/java/com/volmit/iris/v2/generator/actuator/IrisDepositModifier.java create mode 100644 src/main/java/com/volmit/iris/v2/generator/actuator/IrisRavineModifier.java diff --git a/src/main/java/com/volmit/iris/object/IrisDecorator.java b/src/main/java/com/volmit/iris/object/IrisDecorator.java index de670328c..d7819bc8c 100644 --- a/src/main/java/com/volmit/iris/object/IrisDecorator.java +++ b/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(); diff --git a/src/main/java/com/volmit/iris/v2/generator/IrisEngine.java b/src/main/java/com/volmit/iris/v2/generator/IrisEngine.java index 5e0f3a11c..8750a787a 100644 --- a/src/main/java/com/volmit/iris/v2/generator/IrisEngine.java +++ b/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); }); diff --git a/src/main/java/com/volmit/iris/v2/generator/IrisEngineFramework.java b/src/main/java/com/volmit/iris/v2/generator/IrisEngineFramework.java index 1f0c0a176..a65a2b435 100644 --- a/src/main/java/com/volmit/iris/v2/generator/IrisEngineFramework.java +++ b/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 decorantActuator; + @Getter + private final EngineModifier depositModifier; + + @Getter + private final EngineModifier ravineModifier; + @Getter private final EngineActuator 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()); } } diff --git a/src/main/java/com/volmit/iris/v2/generator/actuator/IrisDecorantActuator.java b/src/main/java/com/volmit/iris/v2/generator/actuator/IrisDecorantActuator.java index c1d3deb26..552e93273 100644 --- a/src/main/java/com/volmit/iris/v2/generator/actuator/IrisDecorantActuator.java +++ b/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 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 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 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 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 } } } + + private boolean canGoOn(BlockData decorant, BlockData atop) + { + return B.canPlaceOnto(decorant.getMaterial(), atop.getMaterial()); + } } diff --git a/src/main/java/com/volmit/iris/v2/generator/actuator/IrisDepositModifier.java b/src/main/java/com/volmit/iris/v2/generator/actuator/IrisDepositModifier.java new file mode 100644 index 000000000..60cf170f8 --- /dev/null +++ b/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 { + 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 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 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 data, RNG rng, int cx, int cz, boolean safe) + { + generate(k, data, rng, cx, cz, safe, null); + } + + public void generate(IrisDepositGenerator k, Hunk 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)); + } + } + } + } +} diff --git a/src/main/java/com/volmit/iris/v2/generator/actuator/IrisRavineModifier.java b/src/main/java/com/volmit/iris/v2/generator/actuator/IrisRavineModifier.java new file mode 100644 index 000000000..ac86f6082 --- /dev/null +++ b/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 { + 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 output) { + generateRavines(rng, Math.floorDiv(x, 16), Math.floorDiv(z, 16), output); + } + + private void set(Hunk pos, int x, int y, int z, BlockData b) + { + pos.set(x, y, z, b); + } + + private BlockData get(Hunk 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 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 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 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 terrain) + { + genRavines(x, z, new ChunkPosition(x, z), nextParallelRNG.nextParallelRNG(x).nextParallelRNG(z), terrain); + } +} diff --git a/src/main/java/com/volmit/iris/v2/generator/actuator/IrisTerrainActuator.java b/src/main/java/com/volmit/iris/v2/generator/actuator/IrisTerrainActuator.java index 1b03b5c2e..6f5cefcbd 100644 --- a/src/main/java/com/volmit/iris/v2/generator/actuator/IrisTerrainActuator.java +++ b/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 @Override public void onActuate(int x, int z, Hunk 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 blocks; - KList 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 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 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 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 floor = cave.generateLayers(realX, realZ, rng, cl.getFloor(), cl.getFloor(), getData()); - KList 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)); - } - } - } } } } diff --git a/src/main/java/com/volmit/iris/v2/scaffold/engine/EngineFramework.java b/src/main/java/com/volmit/iris/v2/scaffold/engine/EngineFramework.java index baec77a4e..daa782a81 100644 --- a/src/main/java/com/volmit/iris/v2/scaffold/engine/EngineFramework.java +++ b/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 getBiomeActuator(); public IrisCaveModifier getCaveModifier(); + + public EngineModifier getRavineModifier(); + + public EngineModifier getDepositModifier(); }