mirror of
https://github.com/VolmitSoftware/Iris.git
synced 2025-07-18 10:12:53 +00:00
Ravines
This commit is contained in:
Daniel Mills
parent
c45044b5c2
commit
f3e7d188f9
@ -12,6 +12,7 @@ import com.volmit.iris.gen.atomics.AtomicSliverMap;
|
||||
import com.volmit.iris.gen.layer.GenLayerBiome;
|
||||
import com.volmit.iris.gen.layer.GenLayerCarve;
|
||||
import com.volmit.iris.gen.layer.GenLayerCave;
|
||||
import com.volmit.iris.gen.layer.GenLayerRavine;
|
||||
import com.volmit.iris.gen.scaffold.TerrainChunk;
|
||||
import com.volmit.iris.gen.scaffold.TerrainTarget;
|
||||
import com.volmit.iris.noise.CNG;
|
||||
@ -49,6 +50,7 @@ public abstract class TopographicTerrainProvider extends ParallelTerrainProvider
|
||||
private GenLayerCave glCave;
|
||||
private GenLayerCarve glCarve;
|
||||
private GenLayerBiome glBiome;
|
||||
private GenLayerRavine glRavine;
|
||||
private RNG rockRandom;
|
||||
private IrisLock regionLock;
|
||||
private KMap<String, IrisGenerator> generators;
|
||||
@ -78,6 +80,7 @@ public abstract class TopographicTerrainProvider extends ParallelTerrainProvider
|
||||
setRockRandom(getMasterRandom().nextParallelRNG(2858678));
|
||||
setGlCave(new GenLayerCave(this, rng.nextParallelRNG(238948)));
|
||||
setGlCarve(new GenLayerCarve(this, rng.nextParallelRNG(968346576)));
|
||||
setGlRavine(new GenLayerRavine(this, rng.nextParallelRNG(-229354923)));
|
||||
}
|
||||
|
||||
public int getCarvedHeight(int x, int z, boolean ignoreFluid)
|
||||
@ -533,7 +536,10 @@ public abstract class TopographicTerrainProvider extends ParallelTerrainProvider
|
||||
|
||||
protected void onPreParallaxPostGenerate(RNG random, int x, int z, TerrainChunk terrain, HeightMap height, BiomeMap biomeMap, AtomicSliverMap map)
|
||||
{
|
||||
|
||||
if(getDimension().isRavines())
|
||||
{
|
||||
getGlRavine().generateRavines(random.nextParallelRNG(x - 283845).nextParallelRNG(z + 23845868), x, z, terrain, height, biomeMap, map);
|
||||
}
|
||||
}
|
||||
|
||||
public void generateDeposits(RNG rx, TerrainChunk terrain, int x, int z)
|
||||
|
||||
304
src/main/java/com/volmit/iris/gen/layer/GenLayerRavine.java
Normal file
304
src/main/java/com/volmit/iris/gen/layer/GenLayerRavine.java
Normal file
@ -0,0 +1,304 @@
|
||||
package com.volmit.iris.gen.layer;
|
||||
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.block.data.BlockData;
|
||||
|
||||
import com.volmit.iris.gen.TopographicTerrainProvider;
|
||||
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.NoiseStyle;
|
||||
import com.volmit.iris.util.B;
|
||||
import com.volmit.iris.util.BiomeMap;
|
||||
import com.volmit.iris.util.BlockPosition;
|
||||
import com.volmit.iris.util.ChunkPosition;
|
||||
import com.volmit.iris.util.GenLayer;
|
||||
import com.volmit.iris.util.HeightMap;
|
||||
import com.volmit.iris.util.MathHelper;
|
||||
import com.volmit.iris.util.RNG;
|
||||
|
||||
import lombok.Data;
|
||||
import lombok.EqualsAndHashCode;
|
||||
|
||||
@Data
|
||||
@EqualsAndHashCode(callSuper = false)
|
||||
public class GenLayerRavine extends GenLayer
|
||||
{
|
||||
private static final BlockData CAVE_AIR = B.get("CAVE_AIR");
|
||||
private static final BlockData LAVA = B.get("LAVA");
|
||||
private CNG cng;
|
||||
|
||||
public GenLayerRavine(TopographicTerrainProvider iris, RNG rng)
|
||||
{
|
||||
super(iris, rng);
|
||||
cng = NoiseStyle.IRIS_THICK.create(rng.nextParallelRNG(29596878));
|
||||
}
|
||||
|
||||
@Override
|
||||
public double generate(double x, double z)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
private float[] d = new float[1024];
|
||||
|
||||
private void set(TerrainChunk pos, int x, int y, int z, BlockData b)
|
||||
{
|
||||
pos.setBlock(x, y, z, b);
|
||||
}
|
||||
|
||||
private BlockData get(TerrainChunk pos, int x, int y, int z)
|
||||
{
|
||||
return pos.getBlockData(x, y, z);
|
||||
}
|
||||
|
||||
private BlockData getSurfaceBlock(TerrainChunk pos, BiomeMap map, int n6, int i, RNG rmg)
|
||||
{
|
||||
return map.getBiome(n6, i).getSurfaceBlock(n6, i, rmg, iris.getData());
|
||||
}
|
||||
|
||||
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, TerrainChunk terrain, HeightMap height, BiomeMap biomeMap, AtomicSliverMap map)
|
||||
{
|
||||
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(iris.getDimension().getRavineRibRarity()) == 0)
|
||||
{
|
||||
f6 = 1.0f + random.nextFloat() * random.nextFloat() * 1.0f;
|
||||
}
|
||||
this.d[i] = f6 * f6;
|
||||
}
|
||||
while(n3 < n4)
|
||||
{
|
||||
double d7 = 1.5 + (double) (MathHelper.sin((float) ((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((float) f3);
|
||||
float f8 = MathHelper.sin((float) f3);
|
||||
sx += (double) (MathHelper.cos((float) f2) * f7);
|
||||
sy += (double) f8;
|
||||
sz += (double) (MathHelper.sin((float) 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((double) (sx - d7)) - tx * 16 - 1;
|
||||
int n8 = MathHelper.floor((double) (sx + d7)) - tx * 16 + 1;
|
||||
int n9 = MathHelper.floor((double) (sy - d8)) - 1;
|
||||
int n10 = MathHelper.floor((double) (sy + d8)) + 1;
|
||||
int n11 = MathHelper.floor((double) (sz - d7)) - tz * 16 - 1;
|
||||
int n12 = MathHelper.floor((double) (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.d[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(terrain, biomeMap, 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, TerrainChunk terrain, HeightMap height, BiomeMap biomeMap, AtomicSliverMap map)
|
||||
{
|
||||
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, height, biomeMap, map);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void doRavines(int tx, int tz, int sx, int sz, ChunkPosition chunkSnapshot, RNG b, TerrainChunk terrain, HeightMap height, BiomeMap biomeMap, AtomicSliverMap map)
|
||||
{
|
||||
if(b.nextInt(iris.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, height, biomeMap, map);
|
||||
}
|
||||
}
|
||||
|
||||
public void generateRavines(RNG nextParallelRNG, int x, int z, TerrainChunk terrain, HeightMap height, BiomeMap biomeMap, AtomicSliverMap map)
|
||||
{
|
||||
genRavines(x, z, new ChunkPosition(x, z), nextParallelRNG.nextParallelRNG(x).nextParallelRNG(z), terrain, height, biomeMap, map);
|
||||
}
|
||||
}
|
||||
@ -11,6 +11,7 @@ import com.volmit.iris.gen.atomics.AtomicCache;
|
||||
import com.volmit.iris.manager.IrisDataManager;
|
||||
import com.volmit.iris.noise.CNG;
|
||||
import com.volmit.iris.util.ArrayType;
|
||||
import com.volmit.iris.util.B;
|
||||
import com.volmit.iris.util.DependsOn;
|
||||
import com.volmit.iris.util.Desc;
|
||||
import com.volmit.iris.util.DontObfuscate;
|
||||
@ -609,4 +610,14 @@ public class IrisBiome extends IrisRegistrant implements IRare
|
||||
|
||||
return getBiomeGenerator(rng).fit(biomeScatter, x, y, z);
|
||||
}
|
||||
|
||||
public BlockData getSurfaceBlock(int x, int z, RNG rng, IrisDataManager idm)
|
||||
{
|
||||
if(getLayers().isEmpty())
|
||||
{
|
||||
return B.get("AIR");
|
||||
}
|
||||
|
||||
return getLayers().get(0).get(rng, x, 0, z, idm);
|
||||
}
|
||||
}
|
||||
|
||||
@ -167,6 +167,22 @@ public class IrisDimension extends IrisRegistrant
|
||||
@Desc("Generate decorations or not")
|
||||
private boolean decorate = true;
|
||||
|
||||
@DontObfuscate
|
||||
@Desc("Generate ravines or not")
|
||||
private boolean ravines = true;
|
||||
|
||||
@Required
|
||||
@MinNumber(1)
|
||||
@DontObfuscate
|
||||
@Desc("The rarity of a ravine layer having a lib (or rib) that sticks in or out by one block. Minecraft's default is 3.")
|
||||
private int ravineRibRarity = 2;
|
||||
|
||||
@Required
|
||||
@MinNumber(1)
|
||||
@DontObfuscate
|
||||
@Desc("The rarity of ravines. Each chunk has a 1 in X chance")
|
||||
private int ravineRarity = 50;
|
||||
|
||||
@DontObfuscate
|
||||
@Desc("Use post processing or not")
|
||||
private boolean postProcessing = true;
|
||||
|
||||
@ -31,6 +31,11 @@ public class B
|
||||
return getBlockData(bd);
|
||||
}
|
||||
|
||||
public static boolean isWater(BlockData b)
|
||||
{
|
||||
return b.getMaterial().equals(Material.WATER);
|
||||
}
|
||||
|
||||
public static Material getMaterial(String bdx)
|
||||
{
|
||||
String bd = bdx.trim().toUpperCase();
|
||||
|
||||
569
src/main/java/com/volmit/iris/util/MathHelper.java
Normal file
569
src/main/java/com/volmit/iris/util/MathHelper.java
Normal file
@ -0,0 +1,569 @@
|
||||
package com.volmit.iris.util;
|
||||
|
||||
import java.util.Random;
|
||||
import java.util.UUID;
|
||||
import java.util.function.IntPredicate;
|
||||
import net.minecraft.server.v1_16_R2.BaseBlockPosition;
|
||||
import net.minecraft.server.v1_16_R2.SystemUtils;
|
||||
|
||||
public class MathHelper
|
||||
{
|
||||
public static final float a = MathHelper.c(2.0f);
|
||||
private static final float[] b = (float[]) SystemUtils.a((Object) new float[65536], var0 ->
|
||||
{
|
||||
for(int var1 = 0; var1 < ((float[]) var0).length; ++var1)
|
||||
{
|
||||
((float[]) var0)[var1] = (float) Math.sin((double) var1 * 3.141592653589793 * 2.0 / 65536.0);
|
||||
}
|
||||
});
|
||||
private static final Random c = new Random();
|
||||
private static final int[] d = new int[] {0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8, 31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9};
|
||||
private static final double e = Double.longBitsToDouble(4805340802404319232L);
|
||||
private static final double[] f = new double[257];
|
||||
private static final double[] g = new double[257];
|
||||
|
||||
public static float sin(float var0)
|
||||
{
|
||||
return b[(int) (var0 * 10430.378f) & 65535];
|
||||
}
|
||||
|
||||
public static float cos(float var0)
|
||||
{
|
||||
return b[(int) (var0 * 10430.378f + 16384.0f) & 65535];
|
||||
}
|
||||
|
||||
public static float c(float var0)
|
||||
{
|
||||
return (float) Math.sqrt(var0);
|
||||
}
|
||||
|
||||
public static float sqrt(double var0)
|
||||
{
|
||||
return (float) Math.sqrt(var0);
|
||||
}
|
||||
|
||||
public static int d(float var0)
|
||||
{
|
||||
int var1 = (int) var0;
|
||||
return var0 < (float) var1 ? var1 - 1 : var1;
|
||||
}
|
||||
|
||||
public static int floor(double var0)
|
||||
{
|
||||
int var2 = (int) var0;
|
||||
return var0 < (double) var2 ? var2 - 1 : var2;
|
||||
}
|
||||
|
||||
public static long d(double var0)
|
||||
{
|
||||
long var2 = (long) var0;
|
||||
return var0 < (double) var2 ? var2 - 1L : var2;
|
||||
}
|
||||
|
||||
public static float e(float var0)
|
||||
{
|
||||
return Math.abs(var0);
|
||||
}
|
||||
|
||||
public static int a(int var0)
|
||||
{
|
||||
return Math.abs(var0);
|
||||
}
|
||||
|
||||
public static int f(float var0)
|
||||
{
|
||||
int var1 = (int) var0;
|
||||
return var0 > (float) var1 ? var1 + 1 : var1;
|
||||
}
|
||||
|
||||
public static int f(double var0)
|
||||
{
|
||||
int var2 = (int) var0;
|
||||
return var0 > (double) var2 ? var2 + 1 : var2;
|
||||
}
|
||||
|
||||
public static int clamp(int var0, int var1, int var2)
|
||||
{
|
||||
if(var0 < var1)
|
||||
{
|
||||
return var1;
|
||||
}
|
||||
if(var0 > var2)
|
||||
{
|
||||
return var2;
|
||||
}
|
||||
return var0;
|
||||
}
|
||||
|
||||
public static float a(float var0, float var1, float var2)
|
||||
{
|
||||
if(var0 < var1)
|
||||
{
|
||||
return var1;
|
||||
}
|
||||
if(var0 > var2)
|
||||
{
|
||||
return var2;
|
||||
}
|
||||
return var0;
|
||||
}
|
||||
|
||||
public static double a(double var0, double var2, double var4)
|
||||
{
|
||||
if(var0 < var2)
|
||||
{
|
||||
return var2;
|
||||
}
|
||||
if(var0 > var4)
|
||||
{
|
||||
return var4;
|
||||
}
|
||||
return var0;
|
||||
}
|
||||
|
||||
public static double b(double var0, double var2, double var4)
|
||||
{
|
||||
if(var4 < 0.0)
|
||||
{
|
||||
return var0;
|
||||
}
|
||||
if(var4 > 1.0)
|
||||
{
|
||||
return var2;
|
||||
}
|
||||
return MathHelper.d(var4, var0, var2);
|
||||
}
|
||||
|
||||
public static double a(double var0, double var2)
|
||||
{
|
||||
if(var0 < 0.0)
|
||||
{
|
||||
var0 = -var0;
|
||||
}
|
||||
if(var2 < 0.0)
|
||||
{
|
||||
var2 = -var2;
|
||||
}
|
||||
return var0 > var2 ? var0 : var2;
|
||||
}
|
||||
|
||||
public static int a(int var0, int var1)
|
||||
{
|
||||
return Math.floorDiv(var0, var1);
|
||||
}
|
||||
|
||||
public static int nextInt(Random var0, int var1, int var2)
|
||||
{
|
||||
if(var1 >= var2)
|
||||
{
|
||||
return var1;
|
||||
}
|
||||
return var0.nextInt(var2 - var1 + 1) + var1;
|
||||
}
|
||||
|
||||
public static float a(Random var0, float var1, float var2)
|
||||
{
|
||||
if(var1 >= var2)
|
||||
{
|
||||
return var1;
|
||||
}
|
||||
return var0.nextFloat() * (var2 - var1) + var1;
|
||||
}
|
||||
|
||||
public static double a(Random var0, double var1, double var3)
|
||||
{
|
||||
if(var1 >= var3)
|
||||
{
|
||||
return var1;
|
||||
}
|
||||
return var0.nextDouble() * (var3 - var1) + var1;
|
||||
}
|
||||
|
||||
public static double a(long[] var0)
|
||||
{
|
||||
long var1 = 0L;
|
||||
for(long var6 : var0)
|
||||
{
|
||||
var1 += var6;
|
||||
}
|
||||
return (double) var1 / (double) var0.length;
|
||||
}
|
||||
|
||||
public static boolean b(double var0, double var2)
|
||||
{
|
||||
return Math.abs(var2 - var0) < 9.999999747378752E-6;
|
||||
}
|
||||
|
||||
public static int b(int var0, int var1)
|
||||
{
|
||||
return Math.floorMod(var0, var1);
|
||||
}
|
||||
|
||||
public static float g(float var0)
|
||||
{
|
||||
float var1 = var0 % 360.0f;
|
||||
if(var1 >= 180.0f)
|
||||
{
|
||||
var1 -= 360.0f;
|
||||
}
|
||||
if(var1 < -180.0f)
|
||||
{
|
||||
var1 += 360.0f;
|
||||
}
|
||||
return var1;
|
||||
}
|
||||
|
||||
public static double g(double var0)
|
||||
{
|
||||
double var2 = var0 % 360.0;
|
||||
if(var2 >= 180.0)
|
||||
{
|
||||
var2 -= 360.0;
|
||||
}
|
||||
if(var2 < -180.0)
|
||||
{
|
||||
var2 += 360.0;
|
||||
}
|
||||
return var2;
|
||||
}
|
||||
|
||||
public static float c(float var0, float var1)
|
||||
{
|
||||
return MathHelper.g(var1 - var0);
|
||||
}
|
||||
|
||||
public static float d(float var0, float var1)
|
||||
{
|
||||
return MathHelper.e(MathHelper.c(var0, var1));
|
||||
}
|
||||
|
||||
public static float b(float var0, float var1, float var2)
|
||||
{
|
||||
float var3 = MathHelper.c(var0, var1);
|
||||
float var4 = MathHelper.a(var3, -var2, var2);
|
||||
return var1 - var4;
|
||||
}
|
||||
|
||||
public static float c(float var0, float var1, float var2)
|
||||
{
|
||||
var2 = MathHelper.e(var2);
|
||||
if(var0 < var1)
|
||||
{
|
||||
return MathHelper.a(var0 + var2, var0, var1);
|
||||
}
|
||||
return MathHelper.a(var0 - var2, var1, var0);
|
||||
}
|
||||
|
||||
public static float d(float var0, float var1, float var2)
|
||||
{
|
||||
float var3 = MathHelper.c(var0, var1);
|
||||
return MathHelper.c(var0, var0 + var3, var2);
|
||||
}
|
||||
|
||||
public static int c(int var0)
|
||||
{
|
||||
int var1 = var0 - 1;
|
||||
var1 |= var1 >> 1;
|
||||
var1 |= var1 >> 2;
|
||||
var1 |= var1 >> 4;
|
||||
var1 |= var1 >> 8;
|
||||
var1 |= var1 >> 16;
|
||||
return var1 + 1;
|
||||
}
|
||||
|
||||
public static boolean d(int var0)
|
||||
{
|
||||
return var0 != 0 && (var0 & var0 - 1) == 0;
|
||||
}
|
||||
|
||||
public static int e(int var0)
|
||||
{
|
||||
var0 = MathHelper.d(var0) ? var0 : MathHelper.c(var0);
|
||||
return d[(int) ((long) var0 * 125613361L >> 27) & 31];
|
||||
}
|
||||
|
||||
public static int f(int var0)
|
||||
{
|
||||
return MathHelper.e(var0) - (MathHelper.d(var0) ? 0 : 1);
|
||||
}
|
||||
|
||||
public static int c(int var0, int var1)
|
||||
{
|
||||
int var2;
|
||||
if(var1 == 0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
if(var0 == 0)
|
||||
{
|
||||
return var1;
|
||||
}
|
||||
if(var0 < 0)
|
||||
{
|
||||
var1 *= -1;
|
||||
}
|
||||
if((var2 = var0 % var1) == 0)
|
||||
{
|
||||
return var0;
|
||||
}
|
||||
return var0 + var1 - var2;
|
||||
}
|
||||
|
||||
public static float h(float var0)
|
||||
{
|
||||
return var0 - (float) MathHelper.d(var0);
|
||||
}
|
||||
|
||||
public static double h(double var0)
|
||||
{
|
||||
return var0 - (double) MathHelper.d(var0);
|
||||
}
|
||||
|
||||
public static long a(BaseBlockPosition var0)
|
||||
{
|
||||
return MathHelper.c(var0.getX(), var0.getY(), var0.getZ());
|
||||
}
|
||||
|
||||
public static long c(int var0, int var1, int var2)
|
||||
{
|
||||
long var3 = (long) (var0 * 3129871) ^ (long) var2 * 116129781L ^ (long) var1;
|
||||
var3 = var3 * var3 * 42317861L + var3 * 11L;
|
||||
return var3 >> 16;
|
||||
}
|
||||
|
||||
public static UUID a(Random var0)
|
||||
{
|
||||
long var1 = var0.nextLong() & -61441L | 16384L;
|
||||
long var3 = var0.nextLong() & 0x3FFFFFFFFFFFFFFFL | Long.MIN_VALUE;
|
||||
return new UUID(var1, var3);
|
||||
}
|
||||
|
||||
public static UUID a()
|
||||
{
|
||||
return MathHelper.a(c);
|
||||
}
|
||||
|
||||
public static double c(double var0, double var2, double var4)
|
||||
{
|
||||
return (var0 - var2) / (var4 - var2);
|
||||
}
|
||||
|
||||
public static double d(double var0, double var2)
|
||||
{
|
||||
double var9;
|
||||
boolean var6;
|
||||
boolean var7;
|
||||
boolean var8;
|
||||
double var4 = var2 * var2 + var0 * var0;
|
||||
if(Double.isNaN(var4))
|
||||
{
|
||||
return Double.NaN;
|
||||
}
|
||||
boolean bl = var6 = var0 < 0.0;
|
||||
if(var6)
|
||||
{
|
||||
var0 = -var0;
|
||||
}
|
||||
boolean bl2 = var7 = var2 < 0.0;
|
||||
if(var7)
|
||||
{
|
||||
var2 = -var2;
|
||||
}
|
||||
boolean bl3 = var8 = var0 > var2;
|
||||
if(var8)
|
||||
{
|
||||
var9 = var2;
|
||||
var2 = var0;
|
||||
var0 = var9;
|
||||
}
|
||||
var9 = MathHelper.i(var4);
|
||||
double var11 = e + (var0 *= var9);
|
||||
int var13 = (int) Double.doubleToRawLongBits(var11);
|
||||
double var14 = f[var13];
|
||||
double var16 = g[var13];
|
||||
double var18 = var11 - e;
|
||||
double var20 = var0 * var16 - (var2 *= var9) * var18;
|
||||
double var22 = (6.0 + var20 * var20) * var20 * 0.16666666666666666;
|
||||
double var24 = var14 + var22;
|
||||
if(var8)
|
||||
{
|
||||
var24 = 1.5707963267948966 - var24;
|
||||
}
|
||||
if(var7)
|
||||
{
|
||||
var24 = 3.141592653589793 - var24;
|
||||
}
|
||||
if(var6)
|
||||
{
|
||||
var24 = -var24;
|
||||
}
|
||||
return var24;
|
||||
}
|
||||
|
||||
public static double i(double var0)
|
||||
{
|
||||
double var2 = 0.5 * var0;
|
||||
long var4 = Double.doubleToRawLongBits(var0);
|
||||
var4 = 6910469410427058090L - (var4 >> 1);
|
||||
var0 = Double.longBitsToDouble(var4);
|
||||
var0 *= 1.5 - var2 * var0 * var0;
|
||||
return var0;
|
||||
}
|
||||
|
||||
public static int f(float var0, float var1, float var2)
|
||||
{
|
||||
float var9;
|
||||
float var8;
|
||||
float var10;
|
||||
int var3 = (int) (var0 * 6.0f) % 6;
|
||||
float var4 = var0 * 6.0f - (float) var3;
|
||||
float var5 = var2 * (1.0f - var1);
|
||||
float var6 = var2 * (1.0f - var4 * var1);
|
||||
float var7 = var2 * (1.0f - (1.0f - var4) * var1);
|
||||
switch(var3)
|
||||
{
|
||||
case 0:
|
||||
{
|
||||
var8 = var2;
|
||||
var9 = var7;
|
||||
var10 = var5;
|
||||
break;
|
||||
}
|
||||
case 1:
|
||||
{
|
||||
var8 = var6;
|
||||
var9 = var2;
|
||||
var10 = var5;
|
||||
break;
|
||||
}
|
||||
case 2:
|
||||
{
|
||||
var8 = var5;
|
||||
var9 = var2;
|
||||
var10 = var7;
|
||||
break;
|
||||
}
|
||||
case 3:
|
||||
{
|
||||
var8 = var5;
|
||||
var9 = var6;
|
||||
var10 = var2;
|
||||
break;
|
||||
}
|
||||
case 4:
|
||||
{
|
||||
var8 = var7;
|
||||
var9 = var5;
|
||||
var10 = var2;
|
||||
break;
|
||||
}
|
||||
case 5:
|
||||
{
|
||||
var8 = var2;
|
||||
var9 = var5;
|
||||
var10 = var6;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
throw new RuntimeException("Something went wrong when converting from HSV to RGB. Input was " + var0 + ", " + var1 + ", " + var2);
|
||||
}
|
||||
}
|
||||
int var11 = MathHelper.clamp((int) (var8 * 255.0f), 0, 255);
|
||||
int var12 = MathHelper.clamp((int) (var9 * 255.0f), 0, 255);
|
||||
int var13 = MathHelper.clamp((int) (var10 * 255.0f), 0, 255);
|
||||
return var11 << 16 | var12 << 8 | var13;
|
||||
}
|
||||
|
||||
public static int g(int var0)
|
||||
{
|
||||
var0 ^= var0 >>> 16;
|
||||
var0 *= -2048144789;
|
||||
var0 ^= var0 >>> 13;
|
||||
var0 *= -1028477387;
|
||||
var0 ^= var0 >>> 16;
|
||||
return var0;
|
||||
}
|
||||
|
||||
public static int a(int var0, int var1, IntPredicate var2)
|
||||
{
|
||||
int var3 = var1 - var0;
|
||||
while(var3 > 0)
|
||||
{
|
||||
int var4 = var3 / 2;
|
||||
int var5 = var0 + var4;
|
||||
if(var2.test(var5))
|
||||
{
|
||||
var3 = var4;
|
||||
continue;
|
||||
}
|
||||
var0 = var5 + 1;
|
||||
var3 -= var4 + 1;
|
||||
}
|
||||
return var0;
|
||||
}
|
||||
|
||||
public static float g(float var0, float var1, float var2)
|
||||
{
|
||||
return var1 + var0 * (var2 - var1);
|
||||
}
|
||||
|
||||
public static double d(double var0, double var2, double var4)
|
||||
{
|
||||
return var2 + var0 * (var4 - var2);
|
||||
}
|
||||
|
||||
public static double a(double var0, double var2, double var4, double var6, double var8, double var10)
|
||||
{
|
||||
return MathHelper.d(var2, MathHelper.d(var0, var4, var6), MathHelper.d(var0, var8, var10));
|
||||
}
|
||||
|
||||
public static double a(double var0, double var2, double var4, double var6, double var8, double var10, double var12, double var14, double var16, double var18, double var20)
|
||||
{
|
||||
return MathHelper.d(var4, MathHelper.a(var0, var2, var6, var8, var10, var12), MathHelper.a(var0, var2, var14, var16, var18, var20));
|
||||
}
|
||||
|
||||
public static double j(double var0)
|
||||
{
|
||||
return var0 * var0 * var0 * (var0 * (var0 * 6.0 - 15.0) + 10.0);
|
||||
}
|
||||
|
||||
public static int k(double var0)
|
||||
{
|
||||
if(var0 == 0.0)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
return var0 > 0.0 ? 1 : -1;
|
||||
}
|
||||
|
||||
@Deprecated
|
||||
public static float j(float var0, float var1, float var2)
|
||||
{
|
||||
float var3;
|
||||
for(var3 = var1 - var0; var3 < -180.0f; var3 += 360.0f)
|
||||
{
|
||||
}
|
||||
while(var3 >= 180.0f)
|
||||
{
|
||||
var3 -= 360.0f;
|
||||
}
|
||||
return var0 + var2 * var3;
|
||||
}
|
||||
|
||||
public static float k(float var0)
|
||||
{
|
||||
return var0 * var0;
|
||||
}
|
||||
|
||||
static
|
||||
{
|
||||
for(int var02 = 0; var02 < 257; ++var02)
|
||||
{
|
||||
double var1 = (double) var02 / 256.0;
|
||||
double var3 = Math.asin(var1);
|
||||
MathHelper.g[var02] = Math.cos(var3);
|
||||
MathHelper.f[var02] = var3;
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user