Repo-Mirror/Iris-World-Engine
9
0
Fork 0
mirror of https://github.com/VolmitSoftware/Iris.git synced 2025-12-30 04:29:05 +00:00
Code Issues Releases Activity

Noise fix

Browse Source
This commit is contained in:
Dan Macbook
2020-08-13 02:49:35 -04:00
parent 1f63b47500
commit b1663c040f
8 changed files with 339 additions and 446 deletions
Download Patch File Download Diff File Expand all files Collapse all files

370
src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java
View File

@@ -31,8 +31,7 @@ import lombok.EqualsAndHashCode;
@Data
@EqualsAndHashCode(callSuper = false)
public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
{
public abstract class TerrainChunkGenerator extends ParallelChunkGenerator {
private long lastUpdateRequest = M.ms();
private long lastChunkLoad = M.ms();
private GenLayerCave glCave;
@@ -42,8 +41,7 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
private BiomeResult[] cacheTrueBiome;
private IrisLock cacheLock;
public TerrainChunkGenerator(String dimensionName, int threads)
{
public TerrainChunkGenerator(String dimensionName, int threads) {
super(dimensionName, threads);
cacheHeightMap = new int[256];
cacheTrueBiome = new BiomeResult[256];
@@ -51,29 +49,25 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
cacheLock = new IrisLock("TerrainCacheLock");
}
public void onInit(World world, RNG rng)
{
public void onInit(World world, RNG rng) {
super.onInit(world, rng);
rockRandom = getMasterRandom().nextParallelRNG(2858678);
glCave = new GenLayerCave(this, rng.nextParallelRNG(238948));
glCarve = new GenLayerCarve(this, rng.nextParallelRNG(968346576));
}
public KList<CaveResult> getCaves(int x, int z)
{
public KList<CaveResult> getCaves(int x, int z) {
return glCave.genCaves(x, z, x & 15, z & 15, null);
}
@Override
protected void onGenerateColumn(int cx, int cz, int rx, int rz, int x, int z, AtomicSliver sliver, BiomeMap biomeMap, boolean sampled)
{
if(x > 15 || x < 0 || z > 15 || z < 0)
{
protected void onGenerateColumn(int cx, int cz, int rx, int rz, int x, int z, AtomicSliver sliver,
BiomeMap biomeMap, boolean sampled) {
if (x > 15 || x < 0 || z > 15 || z < 0) {
throw new RuntimeException("Invalid OnGenerate call: x:" + x + " z:" + z);
}
try
{
try {
int highestPlaced = 0;
BlockData block;
int fluidHeight = getDimension().getFluidHeight();
@@ -89,29 +83,27 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
BiomeResult biomeResult = sampleTrueBiome(rx, rz, noise);
IrisBiome biome = biomeResult.getBiome();
if(biome == null)
{
if (biome == null) {
throw new RuntimeException("Null Biome!");
}
cacheBiome(cachingAllowed && !sampled, x, z, biomeResult, height);
cacheInternalBiome(cachingAllowed && !sampled, x, z, biome);
KList<BlockData> layers = biome.generateLayers(wx, wz, masterRandom, height, height - getFluidHeight());
KList<BlockData> seaLayers = biome.isSea() ? biome.generateSeaLayers(wx, wz, masterRandom, fluidHeight - height) : new KList<>();
KList<BlockData> layers = biome.generateLayers(rx, rz, masterRandom, height, height - getFluidHeight());
KList<BlockData> seaLayers = biome.isSea()
? biome.generateSeaLayers(rx, rz, masterRandom, fluidHeight - height)
: new KList<>();
boolean caverning = false;
KList<Integer> cavernHeights = new KList<>();
int lastCavernHeight = -1;
// From Height to Bedrock
for(int k = Math.max(height, fluidHeight); k >= 0; k--)
{
for (int k = Math.max(height, fluidHeight); k >= 0; k--) {
boolean cavernSurface = false;
// Bedrock
if(k == 0)
{
if(biomeMap != null)
{
if (k == 0) {
if (biomeMap != null) {
sliver.set(k, biome.getDerivative());
biomeMap.setBiome(x, z, biome);
}
@@ -121,10 +113,8 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
}
// Carving
if(carvable && glCarve.isCarved(rx, k, rz))
{
if(biomeMap != null)
{
if (carvable && glCarve.isCarved(rx, k, rz)) {
if (biomeMap != null) {
sliver.set(k, biome.getDerivative());
biomeMap.setBiome(x, z, biome);
}
@@ -134,8 +124,7 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
continue;
}
else if(carvable && caverning)
{
else if (carvable && caverning) {
lastCavernHeight = k;
cavernSurface = true;
cavernHeights.add(k);
@@ -145,27 +134,24 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
boolean underwater = k > height && k <= fluidHeight;
// Set Biome
if(biomeMap != null)
{
if (biomeMap != null) {
sliver.set(k, biome.getGroundBiome(masterRandom, rz, k, rx));
biomeMap.setBiome(x, z, biome);
}
// Set Sea Material (water/lava)
if(underwater)
{
block = seaLayers.hasIndex(fluidHeight - k) ? layers.get(depth) : getDimension().getFluid(rockRandom, wx, k, wz);
if (underwater) {
block = seaLayers.hasIndex(fluidHeight - k) ? layers.get(depth)
: getDimension().getFluid(rockRandom, wx, k, wz);
}
// Set Surface Material for cavern layer surfaces
else if(layers.hasIndex(lastCavernHeight - k))
{
else if (layers.hasIndex(lastCavernHeight - k)) {
block = layers.get(lastCavernHeight - k);
}
// Set Surface Material for true surface
else
{
else {
block = layers.hasIndex(depth) ? layers.get(depth) : getDimension().getRock(rockRandom, wx, k, wz);
depth++;
}
@@ -175,14 +161,13 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
highestPlaced = Math.max(highestPlaced, k);
// Decorate underwater surface
if(!cavernSurface && (k == height && block.getMaterial().isSolid() && k < fluidHeight))
{
if (!cavernSurface && (k == height && block.getMaterial().isSolid() && k < fluidHeight)) {
decorateUnderwater(biome, sliver, wx, k, wz, rx, rz, block);
}
// Decorate Cavern surfaces, but not the true surface
if((carvable && cavernSurface) && !(k == Math.max(height, fluidHeight) && block.getMaterial().isSolid() && k < 255 && k >= fluidHeight))
{
if ((carvable && cavernSurface) && !(k == Math.max(height, fluidHeight) && block.getMaterial().isSolid()
&& k < 255 && k >= fluidHeight)) {
decorateLand(biome, sliver, wx, k, wz, rx, rz, block);
}
}
@@ -192,36 +177,31 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
IrisBiome caveBiome = glBiome.generateData(InferredType.CAVE, wx, wz, rx, rz, region).getBiome();
// Decorate Cave Biome Height Sections
if(caveBiome != null)
{
for(CaveResult i : caveResults)
{
for(int j = i.getFloor(); j <= i.getCeiling(); j++)
{
if (caveBiome != null) {
for (CaveResult i : caveResults) {
for (int j = i.getFloor(); j <= i.getCeiling(); j++) {
sliver.set(j, caveBiome);
sliver.set(j, caveBiome.getGroundBiome(masterRandom, rz, j, rx));
}
KList<BlockData> floor = caveBiome.generateLayers(wx, wz, rockRandom, i.getFloor() - 2, i.getFloor() - 2);
KList<BlockData> ceiling = caveBiome.generateLayers(wx + 256, wz + 256, rockRandom, height - i.getCeiling() - 2, height - i.getCeiling() - 2);
KList<BlockData> floor = caveBiome.generateLayers(wx, wz, rockRandom, i.getFloor() - 2,
i.getFloor() - 2);
KList<BlockData> ceiling = caveBiome.generateLayers(wx + 256, wz + 256, rockRandom,
height - i.getCeiling() - 2, height - i.getCeiling() - 2);
BlockData blockc = null;
for(int j = 0; j < floor.size(); j++)
{
if(j == 0)
{
for (int j = 0; j < floor.size(); j++) {
if (j == 0) {
blockc = floor.get(j);
}
sliver.set(i.getFloor() - j, floor.get(j));
}
for(int j = ceiling.size() - 1; j > 0; j--)
{
for (int j = ceiling.size() - 1; j > 0; j--) {
sliver.set(i.getCeiling() + j, ceiling.get(j));
}
if(blockc != null && !sliver.isSolid(i.getFloor() + 1))
{
if (blockc != null && !sliver.isSolid(i.getFloor() + 1)) {
decorateCave(caveBiome, sliver, wx, i.getFloor(), wz, rx, rz, blockc);
}
}
@@ -230,122 +210,100 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
block = sliver.get(Math.max(height, fluidHeight));
// Decorate True Surface
if(block.getMaterial().isSolid())
{
if (block.getMaterial().isSolid()) {
decorateLand(biome, sliver, wx, Math.max(height, fluidHeight), wz, rx, rz, block);
}
// Update Height Map
if(!sampled && cachingAllowed && highestPlaced < height)
{
if (!sampled && cachingAllowed && highestPlaced < height) {
cacheHeightMap[(z << 4) | x] = highestPlaced;
}
}
catch(Throwable e)
{
catch (Throwable e) {
fail(e);
}
}
protected void cacheInternalBiome(boolean b, int x, int z, IrisBiome bv)
{
if(b)
{
protected void cacheInternalBiome(boolean b, int x, int z, IrisBiome bv) {
if (b) {
cacheInternalBiome(x, z, bv);
}
}
private void cacheBiome(boolean b, int x, int z, BiomeResult biomeResult, int height)
{
if(b)
{
try
{
private void cacheBiome(boolean b, int x, int z, BiomeResult biomeResult, int height) {
if (b) {
try {
cacheTrueBiome[(z << 4) | x] = biomeResult;
cacheHeightMap[(z << 4) | x] = height;
}
catch(Throwable e)
{
catch (Throwable e) {
Iris.error("Failed to write cache at " + x + " " + z);
}
}
}
@Override
protected void onGenerate(RNG random, int x, int z, ChunkData data, BiomeGrid grid)
{
protected void onGenerate(RNG random, int x, int z, ChunkData data, BiomeGrid grid) {
super.onGenerate(random, x, z, data, grid);
RNG ro = random.nextParallelRNG((x * x * x) - z);
IrisRegion region = sampleRegion((x * 16) + 7, (z * 16) + 7);
IrisBiome biome = sampleTrueBiome((x * 16) + 7, (z * 16) + 7).getBiome();
for(IrisDepositGenerator k : getDimension().getDeposits())
{
for (IrisDepositGenerator k : getDimension().getDeposits()) {
k.generate(data, ro, this);
}
for(IrisDepositGenerator k : region.getDeposits())
{
for(int l = 0; l < ro.i(k.getMinPerChunk(), k.getMaxPerChunk()); l++)
{
for (IrisDepositGenerator k : region.getDeposits()) {
for (int l = 0; l < ro.i(k.getMinPerChunk(), k.getMaxPerChunk()); l++) {
k.generate(data, ro, this);
}
}
for(IrisDepositGenerator k : biome.getDeposits())
{
for(int l = 0; l < ro.i(k.getMinPerChunk(), k.getMaxPerChunk()); l++)
{
for (IrisDepositGenerator k : biome.getDeposits()) {
for (int l = 0; l < ro.i(k.getMinPerChunk(), k.getMaxPerChunk()); l++) {
k.generate(data, ro, this);
}
}
}
private void decorateLand(IrisBiome biome, AtomicSliver sliver, double wx, int k, double wz, int rx, int rz, BlockData block)
{
if(!getDimension().isDecorate())
{
private void decorateLand(IrisBiome biome, AtomicSliver sliver, double wx, int k, double wz, int rx, int rz,
BlockData block) {
if (!getDimension().isDecorate()) {
return;
}
int j = 0;
for(IrisBiomeDecorator i : biome.getDecorators())
{
if(i.getPartOf().equals(DecorationPart.SHORE_LINE) && (!touchesSea(rx, rz) || k != getFluidHeight()))
{
for (IrisBiomeDecorator i : biome.getDecorators()) {
if (i.getPartOf().equals(DecorationPart.SHORE_LINE) && (!touchesSea(rx, rz) || k != getFluidHeight())) {
continue;
}
BlockData d = i.getBlockData(getMasterRandom().nextParallelRNG((int) (38888 + biome.getRarity() + biome.getName().length() + j++)), wx, wz);
BlockData d = i.getBlockData(getMasterRandom()
.nextParallelRNG((int) (38888 + biome.getRarity() + biome.getName().length() + j++)), rx, rz);
if(d != null)
{
if(!B.canPlaceOnto(d.getMaterial(), block.getMaterial()))
{
if (d != null) {
if (!B.canPlaceOnto(d.getMaterial(), block.getMaterial())) {
continue;
}
if(d.getMaterial().equals(Material.CACTUS))
{
if(!block.getMaterial().equals(Material.SAND) && !block.getMaterial().equals(Material.RED_SAND))
{
if (d.getMaterial().equals(Material.CACTUS)) {
if (!block.getMaterial().equals(Material.SAND) && !block.getMaterial().equals(Material.RED_SAND)) {
sliver.set(k, B.getBlockData("RED_SAND"));
}
}
if(d.getMaterial().equals(Material.WHEAT) || d.getMaterial().equals(Material.CARROTS) || d.getMaterial().equals(Material.POTATOES) || d.getMaterial().equals(Material.MELON_STEM) || d.getMaterial().equals(Material.PUMPKIN_STEM))
{
if(!block.getMaterial().equals(Material.FARMLAND))
{
if (d.getMaterial().equals(Material.WHEAT) || d.getMaterial().equals(Material.CARROTS)
|| d.getMaterial().equals(Material.POTATOES) || d.getMaterial().equals(Material.MELON_STEM)
|| d.getMaterial().equals(Material.PUMPKIN_STEM)) {
if (!block.getMaterial().equals(Material.FARMLAND)) {
sliver.set(k, B.getBlockData("FARMLAND"));
}
}
if(d instanceof Bisected && k < 254)
{
if (d instanceof Bisected && k < 254) {
Bisected t = ((Bisected) d.clone());
t.setHalf(Half.TOP);
Bisected b = ((Bisected) d.clone());
@@ -354,19 +312,17 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
sliver.set(k + 2, t);
}
else
{
int stack = i.getHeight(getMasterRandom().nextParallelRNG((int) (39456 + (10000 * i.getChance()) + i.getStackMax() + i.getStackMin() + i.getZoom())), wx, wz);
else {
int stack = i.getHeight(getMasterRandom().nextParallelRNG(
(int) (39456 + (10000 * i.getChance()) + i.getStackMax() + i.getStackMin() + i.getZoom())),
rx, rz);
if(stack == 1)
{
if (stack == 1) {
sliver.set(k + 1, d);
}
else if(k < 255 - stack)
{
for(int l = 0; l < stack; l++)
{
else if (k < 255 - stack) {
for (int l = 0; l < stack; l++) {
sliver.set(k + l + 1, d);
}
}
@@ -377,36 +333,31 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
}
}
private void decorateCave(IrisBiome biome, AtomicSliver sliver, double wx, int k, double wz, int rx, int rz, BlockData block)
{
if(!getDimension().isDecorate())
{
private void decorateCave(IrisBiome biome, AtomicSliver sliver, double wx, int k, double wz, int rx, int rz,
BlockData block) {
if (!getDimension().isDecorate()) {
return;
}
int j = 0;
for(IrisBiomeDecorator i : biome.getDecorators())
{
BlockData d = i.getBlockData(getMasterRandom().nextParallelRNG(2333877 + biome.getRarity() + biome.getName().length() + +j++), wx, wz);
for (IrisBiomeDecorator i : biome.getDecorators()) {
BlockData d = i.getBlockData(
getMasterRandom().nextParallelRNG(2333877 + biome.getRarity() + biome.getName().length() + +j++),
rx, rz);
if(d != null)
{
if(!B.canPlaceOnto(d.getMaterial(), block.getMaterial()))
{
if (d != null) {
if (!B.canPlaceOnto(d.getMaterial(), block.getMaterial())) {
continue;
}
if(d.getMaterial().equals(Material.CACTUS))
{
if(!block.getMaterial().equals(Material.SAND) && !block.getMaterial().equals(Material.RED_SAND))
{
if (d.getMaterial().equals(Material.CACTUS)) {
if (!block.getMaterial().equals(Material.SAND) && !block.getMaterial().equals(Material.RED_SAND)) {
sliver.set(k, B.getBlockData("SAND"));
}
}
if(d instanceof Bisected && k < 254)
{
if (d instanceof Bisected && k < 254) {
Bisected t = ((Bisected) d.clone());
t.setHalf(Half.TOP);
Bisected b = ((Bisected) d.clone());
@@ -415,21 +366,17 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
sliver.set(k + 2, t);
}
else
{
int stack = i.getHeight(getMasterRandom().nextParallelRNG((int) (39456 + (1000 * i.getChance()) + i.getZoom() * 10)), wx, wz);
else {
int stack = i.getHeight(getMasterRandom()
.nextParallelRNG((int) (39456 + (1000 * i.getChance()) + i.getZoom() * 10)), rx, rz);
if(stack == 1)
{
if (stack == 1) {
sliver.set(k + 1, d);
}
else if(k < 255 - stack)
{
for(int l = 0; l < stack; l++)
{
if(sliver.isSolid(k + l + 1))
{
else if (k < 255 - stack) {
for (int l = 0; l < stack; l++) {
if (sliver.isSolid(k + l + 1)) {
break;
}
@@ -443,38 +390,35 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
}
}
private void decorateUnderwater(IrisBiome biome, AtomicSliver sliver, double wx, int y, double wz, int rx, int rz, BlockData block)
{
if(!getDimension().isDecorate())
{
private void decorateUnderwater(IrisBiome biome, AtomicSliver sliver, double wx, int y, double wz, int rx, int rz,
BlockData block) {
if (!getDimension().isDecorate()) {
return;
}
int j = 0;
for(IrisBiomeDecorator i : biome.getDecorators())
{
if(biome.getInferredType().equals(InferredType.SHORE))
{
for (IrisBiomeDecorator i : biome.getDecorators()) {
if (biome.getInferredType().equals(InferredType.SHORE)) {
continue;
}
BlockData d = i.getBlockData(getMasterRandom().nextParallelRNG(2555 + biome.getRarity() + biome.getName().length() + j++), wx, wz);
BlockData d = i.getBlockData(
getMasterRandom().nextParallelRNG(2555 + biome.getRarity() + biome.getName().length() + j++), rx,
rz);
if(d != null)
{
int stack = i.getHeight(getMasterRandom().nextParallelRNG((int) (239456 + i.getStackMax() + i.getStackMin() + i.getVerticalZoom() + i.getZoom() + i.getBlockData().size() + j)), wx, wz);
if (d != null) {
int stack = i.getHeight(getMasterRandom().nextParallelRNG((int) (239456 + i.getStackMax()
+ i.getStackMin() + i.getVerticalZoom() + i.getZoom() + i.getBlockData().size() + j)), rx, rz);
if(stack == 1)
{
if (stack == 1) {
sliver.set(i.getPartOf().equals(DecorationPart.SEA_SURFACE) ? (getFluidHeight() + 1) : (y + 1), d);
}
else if(y < getFluidHeight() - stack)
{
for(int l = 0; l < stack; l++)
{
sliver.set(i.getPartOf().equals(DecorationPart.SEA_SURFACE) ? (getFluidHeight() + 1 + l) : (y + l + 1), d);
else if (y < getFluidHeight() - stack) {
for (int l = 0; l < stack; l++) {
sliver.set(i.getPartOf().equals(DecorationPart.SEA_SURFACE) ? (getFluidHeight() + 1 + l)
: (y + l + 1), d);
}
}
@@ -484,33 +428,30 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
}
@Override
protected void onPostGenerate(RNG random, int x, int z, ChunkData data, BiomeGrid grid, HeightMap height, BiomeMap biomeMap)
{
protected void onPostGenerate(RNG random, int x, int z, ChunkData data, BiomeGrid grid, HeightMap height,
BiomeMap biomeMap) {
onPreParallaxPostGenerate(random, x, z, data, grid, height, biomeMap);
}
protected void onPreParallaxPostGenerate(RNG random, int x, int z, ChunkData data, BiomeGrid grid, HeightMap height, BiomeMap biomeMap)
{
protected void onPreParallaxPostGenerate(RNG random, int x, int z, ChunkData data, BiomeGrid grid, HeightMap height,
BiomeMap biomeMap) {
}
protected void onPostParallaxPostGenerate(RNG random, int x, int z, ChunkData data, BiomeGrid grid, HeightMap height, BiomeMap biomeMap)
{
protected void onPostParallaxPostGenerate(RNG random, int x, int z, ChunkData data, BiomeGrid grid,
HeightMap height, BiomeMap biomeMap) {
}
protected double getNoiseHeight(int rx, int rz)
{
protected double getNoiseHeight(int rx, int rz) {
double wx = getZoomed(rx);
double wz = getZoomed(rz);
return getBiomeHeight(wx, wz, rx, rz);
}
public BiomeResult sampleTrueBiomeBase(int x, int z, int height)
{
if(!getDimension().getFocus().equals(""))
{
public BiomeResult sampleTrueBiomeBase(int x, int z, int height) {
if (!getDimension().getFocus().equals("")) {
return focus();
}
@@ -520,51 +461,42 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
double sh = region.getShoreHeight(wx, wz);
IrisBiome current = sampleBiome(x, z).getBiome();
if(current.isShore() && height > sh)
{
if (current.isShore() && height > sh) {
return glBiome.generateData(InferredType.LAND, wx, wz, x, z, region);
}
if(current.isShore() || current.isLand() && height <= getDimension().getFluidHeight())
{
if (current.isShore() || current.isLand() && height <= getDimension().getFluidHeight()) {
return glBiome.generateData(InferredType.SEA, wx, wz, x, z, region);
}
if(current.isSea() && height > getDimension().getFluidHeight())
{
if (current.isSea() && height > getDimension().getFluidHeight()) {
return glBiome.generateData(InferredType.LAND, wx, wz, x, z, region);
}
if(height <= getDimension().getFluidHeight())
{
if (height <= getDimension().getFluidHeight()) {
return glBiome.generateData(InferredType.SEA, wx, wz, x, z, region);
}
if(height <= getDimension().getFluidHeight() + sh)
{
if (height <= getDimension().getFluidHeight() + sh) {
return glBiome.generateData(InferredType.SHORE, wx, wz, x, z, region);
}
return glBiome.generateRegionData(wx, wz, x, z, region);
}
public BiomeResult sampleCaveBiome(int x, int z)
{
public BiomeResult sampleCaveBiome(int x, int z) {
double wx = getModifiedX(x, z);
double wz = getModifiedZ(x, z);
return glBiome.generateData(InferredType.CAVE, wx, wz, x, z, sampleRegion(x, z));
}
public BiomeResult sampleTrueBiome(int x, int y, int z)
{
if(y < getTerrainHeight(x, z))
{
public BiomeResult sampleTrueBiome(int x, int y, int z) {
if (y < getTerrainHeight(x, z)) {
double wx = getModifiedX(x, z);
double wz = getModifiedZ(x, z);
BiomeResult r = glBiome.generateData(InferredType.CAVE, wx, wz, x, z, sampleRegion(x, z));
if(r.getBiome() != null)
{
if (r.getBiome() != null) {
return r;
}
}
@@ -572,20 +504,16 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
return sampleTrueBiome(x, z);
}
public BiomeResult sampleTrueBiome(int x, int z)
{
public BiomeResult sampleTrueBiome(int x, int z) {
return sampleTrueBiome(x, z, getTerrainHeight(x, z));
}
public BiomeResult sampleTrueBiome(int x, int z, double noise)
{
if(!getDimension().getFocus().equals(""))
{
public BiomeResult sampleTrueBiome(int x, int z, double noise) {
if (!getDimension().getFocus().equals("")) {
return focus();
}
if(isSafe() && x >> 4 == cacheX && z >> 4 == cacheZ)
{
if (isSafe() && x >> 4 == cacheX && z >> 4 == cacheZ) {
return cacheTrueBiome[((z & 15) << 4) | (x & 15)];
}
@@ -597,8 +525,7 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
BiomeResult res = sampleTrueBiomeBase(x, z, height);
IrisBiome current = res.getBiome();
if(current.isSea() && height > getDimension().getFluidHeight() - sh)
{
if (current.isSea() && height > getDimension().getFluidHeight() - sh) {
return glBiome.generateData(InferredType.SHORE, wx, wz, x, z, region);
}
@@ -606,46 +533,39 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator
}
@Override
protected int onSampleColumnHeight(int cx, int cz, int rx, int rz, int x, int z)
{
protected int onSampleColumnHeight(int cx, int cz, int rx, int rz, int x, int z) {
int fluidHeight = getDimension().getFluidHeight();
double noise = getNoiseHeight(rx, rz);
return (int) Math.round(noise) + fluidHeight;
}
private boolean touchesSea(int rx, int rz)
{
return isFluidAtHeight(rx + 1, rz) || isFluidAtHeight(rx - 1, rz) || isFluidAtHeight(rx, rz - 1) || isFluidAtHeight(rx, rz + 1);
private boolean touchesSea(int rx, int rz) {
return isFluidAtHeight(rx + 1, rz) || isFluidAtHeight(rx - 1, rz) || isFluidAtHeight(rx, rz - 1)
|| isFluidAtHeight(rx, rz + 1);
}
public boolean isUnderwater(int x, int z)
{
public boolean isUnderwater(int x, int z) {
return isFluidAtHeight(x, z);
}
public boolean isFluidAtHeight(int x, int z)
{
public boolean isFluidAtHeight(int x, int z) {
return Math.round(getTerrainHeight(x, z)) < getFluidHeight();
}
public int getFluidHeight()
{
public int getFluidHeight() {
return getDimension().getFluidHeight();
}
public double getTerrainHeight(int x, int z)
{
if(isSafe() && x >> 4 == cacheX && z >> 4 == cacheZ)
{
public double getTerrainHeight(int x, int z) {
if (isSafe() && x >> 4 == cacheX && z >> 4 == cacheZ) {
return cacheHeightMap[((z & 15) << 4) | (x & 15)];
}
return getNoiseHeight(x, z) + getFluidHeight();
}
public double getTerrainWaterHeight(int x, int z)
{
public double getTerrainWaterHeight(int x, int z) {
return Math.max(getTerrainHeight(x, z), getFluidHeight());
}
}