public IEnumerator GenerateMap()
{
map = new int[World.currentWorld.chunkSize.x, World.currentWorld.chunkSize.z];
for (int x = 0; x < World.currentWorld.chunkSize.x; x++)
{
for (int z = 0; z < World.currentWorld.chunkSize.z; z++)
{
map[x, z] = -1; // initialize with empty block
float xCoord = (World.currentWorld.usePositionAsOffset ? transform.position.x : 0.0f) / World.currentWorld.noiseScale + (World.currentWorld.noiseOffset.x + x / World.currentWorld.noiseScale);
float zCoord = (World.currentWorld.usePositionAsOffset ? transform.position.z : 0.0f) / World.currentWorld.noiseScale + (World.currentWorld.noiseOffset.z + z / World.currentWorld.noiseScale);
float a = Perlin.Fbm(xCoord, zCoord, World.currentWorld.fractalLevel) / 1.4f + 0.5f;
float b = Perlin.Fbm(zCoord, xCoord, 3) / 1.4f + 0.5f;
if (Mathf.Lerp(a, b, 0.5f) < 1.0f - World.currentWorld.cloudsCoverage)
{
map[x, z] = World.airDef;
}
else
{
map[x, z] = 1;
}
}
yield return(null);
}
yield break;
}
// Update is called once per frame
void Update()
{
Random.InitState(seed);
mesh = GetComponent <MeshFilter> ().sharedMesh;
collider = GetComponent <EdgeCollider2D> ();
newPoints = collider.points;
for (int i = 0; i < collider.pointCount; i++)
{
newPoints[i] = new Vector2(i * scale.x,
//Random.Range(0,scale.y)
//Mathf.Sin(i*0.5f) + Mathf.Cos(i*0.4f)
Perlin.Fbm(i * 0.05f + seed * 90f, 5) * scale.y
);
//tempArray[i] = new Vector2 (i,Random.Range(0,10f));
}
//print (collider.points[0]);
collider.points = newPoints;
Generate();
}
private void AddNoise()
{
var vertices = _mesh.vertices.ToArray();
var octave = UnityEngine.Random.Range(1, 5);
var offset = UnityEngine.Random.Range(0, 1000);
for (int i = 0; i < FACES_AMOUNT; i++)
{
for (int x = 0; x < _resolution; x++)
{
for (int y = 0; y < _resolution; y++)
{
//var noise = Mathf.PerlinNoise((float)x / _resolution, (float)y / _resolution) * 2;
var indice = y + _resolution * x + _resolution * _resolution * i;
if (indice >= vertices.Length)
{
continue;
}
var noise = Perlin.Fbm(vertices[indice], octave, offset); //Perlin.Perlin3D(vertices[indice], offset);//Perlin.Fbm(vertices[indice], 100);
vertices[indice] += Vector3.one * noise * _noiseAmount; //* Perlin.Noise(vertices[indice]);
}
}
}
_mesh.vertices = vertices;
//_mesh.RecalculateNormals();
_meshCollider.sharedMesh = _mesh;
_meshFilter.sharedMesh = _mesh;
}
// Token: 0x06002E63 RID: 11875 RVA: 0x000E28AC File Offset: 0x000E0CAC
private void Update()
{
float deltaTime = Time.deltaTime;
if (this._enablePositionNoise)
{
for (int i = 0; i < 3; i++)
{
this._time[i] += this._positionFrequency * deltaTime;
}
Vector3 vector = new Vector3(Perlin.Fbm(this._time[0], this._positionFractalLevel), Perlin.Fbm(this._time[1], this._positionFractalLevel), Perlin.Fbm(this._time[2], this._positionFractalLevel));
vector = Vector3.Scale(vector, this._positionScale);
vector *= this._positionAmplitude * 1.33333337f;
base.transform.localPosition = this._initialPosition + vector;
}
if (this._enableRotationNoise)
{
for (int j = 0; j < 3; j++)
{
this._time[j + 3] += this._rotationFrequency * deltaTime;
}
Vector3 vector2 = new Vector3(Perlin.Fbm(this._time[3], this._rotationFractalLevel), Perlin.Fbm(this._time[4], this._rotationFractalLevel), Perlin.Fbm(this._time[5], this._rotationFractalLevel));
vector2 = Vector3.Scale(vector2, this._rotationScale);
vector2 *= this._rotationAmplitude * 1.33333337f;
base.transform.localRotation = Quaternion.Euler(vector2) * this._initialRotation;
}
}
public static float[,] CreateNoiseMap(int width, int height, float size, int seed, Vector2 offset, int fract)
{
var scale = 1.0f / size;
var noiseMap = new float[width, height];
var maxNoiseHeight = float.MinValue;
var minNoiseHeight = float.MaxValue;
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
var noiseValue = Perlin.Fbm(seed + (j + offset.x) * scale, seed + (i + offset.y) * scale, fract);
if (noiseValue < minNoiseHeight)
{
minNoiseHeight = noiseValue;
}
else if (noiseValue > maxNoiseHeight)
{
maxNoiseHeight = noiseValue;
}
noiseMap[j, i] = (noiseValue);
}
}
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
noiseMap[j, i] = Mathf.InverseLerp(minNoiseHeight, maxNoiseHeight, noiseMap[j, i]);
}
}
return(noiseMap);
}
public override void ProcessFrame(Playable playable, FrameData info, object playerData)
{
var target = playerData as Transform;
if (target == null)
{
return;
}
var t = (float)playable.GetTime() * frequency;
var w = info.weight / 0.75f; // normalized weight
var np = new Vector3(
Perlin.Fbm(_positionOffset.x + t, octaves),
Perlin.Fbm(_positionOffset.y + t, octaves),
Perlin.Fbm(_positionOffset.z + t, octaves)
);
var nr = new Vector3(
Perlin.Fbm(_rotationOffset.x + t, octaves),
Perlin.Fbm(_rotationOffset.y + t, octaves),
Perlin.Fbm(_rotationOffset.z + t, octaves)
);
np = Vector3.Scale(np, positionAmount) * w;
nr = Vector3.Scale(nr, rotationAmount) * w;
target.localPosition += np;
target.localRotation = Quaternion.Euler(nr) * target.localRotation;
}
public void Draw3DNosieTexture()
{
var scale = 1.0f / size;
var heightMap = new float[Width, Height];
var maxNoiseHeight = float.MinValue;
var minNoiseHeight = float.MaxValue;
for (int i = 0; i < Height; i++)
{
for (int j = 0; j < Width; j++)
{
var noiseValue = Perlin.Fbm((seed + j * scale), seed + i * scale, Time.time, _fractalLevel);
if (noiseValue < minNoiseHeight)
{
minNoiseHeight = noiseValue;
}
else if (noiseValue > maxNoiseHeight)
{
maxNoiseHeight = noiseValue;
}
heightMap[j, i] = (noiseValue);
}
}
for (int i = 0; i < Height; i++)
{
for (int j = 0; j < Width; j++)
{
heightMap[j, i] = Mathf.InverseLerp(minNoiseHeight, maxNoiseHeight, heightMap[j, i]);
}
}
var texture = TextureGenerator.GenerateTextureFromNoiseMap(heightMap);
textureRender.sharedMaterial.mainTexture = texture;
textureRender.transform.localScale = new Vector3(texture.width, 1, texture.height);
}
void Update()
{
var dx = Perlin.Fbm(seed1 * Time.time * speed, 3) * range.x;
var dy = Perlin.Fbm(seed2 * Time.time * speed, 3) * range.y;
var dz = Perlin.Fbm(seed3 * Time.time * speed, 3) * range.z;
transform.position = initialPosition + new Vector3(dx, dy, dz);
}
/// <summary>
/// Get the base height of the terrain at a specified point. Not very accurate, because the base height is affected by caves.
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public static float GetHeightAtPoint(Vector2 point)
{
float maxLocalHeight = Perlin.Fbm(point.x / 2f, Preferences.seed + 0.5f * Preferences.seed, point.x / 2f, 1) * Preferences.maxTerrainHeight;
float localFadeExponent = Mathf.Max(1, Perlin.Fbm(point.x / 2f, Preferences.seed + 1.5f, point.x / 2f, 1) * 5f);
float heightMap = Mathf.Clamp01(Mathf.Pow(Perlin.Fbm(point.x, Preferences.seed, point.x, 3), localFadeExponent) + Perlin.Fbm(point.x / 4f, Preferences.seed * 1.75f, point.x / 4f, 1) * 0.8f) * maxLocalHeight;
return(heightMap);
}
private Vector3 CalculateNoise(Vector3 position)
{
Vector3 noisePosition = (frequency * world.MultiplyPoint(position)) + seed;
return(new Vector3(
Perlin.Fbm(noisePosition + seedX, octaves),
Perlin.Fbm(noisePosition + seedY, octaves),
Perlin.Fbm(noisePosition, octaves)
));
}
public override void ProcessFrame(Playable playable, FrameData info, object playerData)
{
var target = playerData as Transform;
if (target == null)
{
return;
}
var time = (float)playable.GetTime();
var normalizedTime = time / (float)playable.GetDuration();
// Calculate amplitude. Break if it's nearly zero.
var amp = info.weight * amplitude * envelope.Evaluate(normalizedTime);
if (Mathf.Approximately(amp, 0))
{
return;
}
// Noise variables.
var hash = new XXHash(randomSeed);
var nt = time * noiseFrequency;
var norm = 1 / 0.75f;
// Calculate position offset.
var p = position;
if (noiseOctaves > 0)
{
var n = new Vector3(
Perlin.Fbm(hash.Range(-1e3f, 1e3f, 0) + nt, noiseOctaves),
Perlin.Fbm(hash.Range(-1e3f, 1e3f, 1) + nt, noiseOctaves),
Perlin.Fbm(hash.Range(-1e3f, 1e3f, 2) + nt, noiseOctaves)
);
p = Vector3.Scale(p, n) * norm;
}
target.localPosition += p * amp;
// Calculate rotation offset.
var r = rotation;
if (noiseOctaves > 0)
{
var n = new Vector3(
Perlin.Fbm(hash.Range(-1e3f, 1e3f, 3) + nt, noiseOctaves),
Perlin.Fbm(hash.Range(-1e3f, 1e3f, 4) + nt, noiseOctaves),
Perlin.Fbm(hash.Range(-1e3f, 1e3f, 5) + nt, noiseOctaves)
);
r = Vector3.Scale(r, n) * norm;
}
target.localRotation *= Quaternion.Euler(r * amp);
}
public Vector3 Vector(int seed2)
{
var i1 = _hash1.Range(-100.0f, 100.0f, seed2);
var i2 = _hash2.Range(-100.0f, 100.0f, seed2);
var i3 = _hash3.Range(-100.0f, 100.0f, seed2);
return(new Vector3(
Perlin.Fbm(_time + i1, _fractal) * _fbmNorm,
Perlin.Fbm(_time + i2, _fractal) * _fbmNorm,
Perlin.Fbm(_time + i3, _fractal) * _fbmNorm));
}
protected Vector3 WobblePosition(float dt)
{
timePosition += dt * positionFrequency;
var p = new Vector3(
Perlin.Fbm(noiseVectors[0] * timePosition, positionOctave),
Perlin.Fbm(noiseVectors[1] * timePosition, positionOctave),
Perlin.Fbm(noiseVectors[2] * timePosition, positionOctave)
);
return(Vector3.Scale(p, positionComponents) * (positionAmount * 2f));
}
public Quaternion Rotation(int seed2, float rx, float ry, float rz)
{
var i1 = _hash1.Range(-100.0f, 100.0f, seed2);
var i2 = _hash2.Range(-100.0f, 100.0f, seed2);
var i3 = _hash3.Range(-100.0f, 100.0f, seed2);
return(Quaternion.Euler(
Perlin.Fbm(_time + i1, _fractal) * _fbmNorm * rx,
Perlin.Fbm(_time + i2, _fractal) * _fbmNorm * ry,
Perlin.Fbm(_time + i3, _fractal) * _fbmNorm * rz));
}
void Update()
{
if (target == TestTarget.Noise2D)
{
UpdateTexture((x, y) => Perlin.Fbm(1.0f / size * x + Time.time, 1.0f / size * y, 3));
}
else
{
UpdateTexture((x, y) => Perlin.Fbm(1.0f / size * x, 1.0f / size * y, Time.time, 3));
}
}
protected override void OnUpdate(float time, float previousTime)
{
var pos = actor.transform.position;
pos.x = Perlin.Fbm(seed.x + time * frequency, octaves);
pos.y = Perlin.Fbm(seed.y + time * frequency, octaves);
pos.z = Perlin.Fbm(seed.z + time * frequency, octaves);
pos = Vector3.Scale(pos, amplitude) * _fbmNorm;
actor.transform.position = Vector3.Lerp(wasPosition, wasPosition + pos, GetClipWeight(time));
}
static private Color PosToColor(Vector3 pos)
{
pos = Vector3.Scale(pos, scale) * scaleMult + shift;
Color color = new Color();
color.r = Perlin.Fbm(pos.x, pos.y, pos.z, octave);
color.g = Perlin.Fbm(pos.x + 1.23434567f, 100f - pos.y + 0.11111f, pos.z + 91.2344f, octave);
color.b = Perlin.Fbm(100f - pos.x - 17.2793f, pos.y - 0.77777f, pos.z + 1237.23233f, octave);
color.a = 1f;
return(color);
}
protected Quaternion WobbleRotation(float dt)
{
timeRotation += dt * rotationFrequency;
var r = new Vector3(
Perlin.Fbm(noiseVectors[3] * timeRotation, rotationOctave),
Perlin.Fbm(noiseVectors[4] * timeRotation, rotationOctave),
Perlin.Fbm(noiseVectors[5] * timeRotation, rotationOctave)
);
r = Vector3.Scale(r, rotationComponents) * (rotationAmount * 2f);
return(Quaternion.Euler(r.x, r.y, r.z));
}
// Token: 0x06002ED5 RID: 11989 RVA: 0x000E4170 File Offset: 0x000E2570
private void Update()
{
this._time += Time.deltaTime * this._frequency;
if (this._octaves > 1)
{
this.InvokeEvent(Perlin.Fbm(this._time, this._octaves));
}
else
{
this.InvokeEvent(Perlin.Noise(this._time));
}
}
void UpdateVertices(Vector3[] profile, AnimationCurve[] path)
{
var index = 0;
for (var i = 0; i < pathDivision; i++)
{
var t1 = (float)(i + 0) / pathDivision;
var t2 = (float)(i + 1) / pathDivision;
var p1 = new Vector3(path [0].Evaluate(t1), path [1].Evaluate(t1), path [2].Evaluate(t1));
var p2 = new Vector3(path [0].Evaluate(t2), path [1].Evaluate(t2), path [2].Evaluate(t2));
var ny = new Vector3(path [3].Evaluate(t1), path [4].Evaluate(t1), path [5].Evaluate(t1)).normalized;
var nz = (p2 - p1).normalized;
var nx = Vector3.Cross(ny, nz);
foreach (var v in profile)
{
var t = profileScale;
if (noiseLevel > 0.0f)
{
t += Perlin.Fbm(p1 * noiseFreq, noiseFractal) * noiseLevel;
}
var p = p1 + nx * (v.x * t) + ny * (v.y * t);
vertices [index++] = p;
vertices [index++] = p;
}
}
// Head cap.
vertices [index++] = new Vector3(path [0].Evaluate(0), path [1].Evaluate(0), path [2].Evaluate(0));
for (var i = 0; i < profile.Length; i++)
{
vertices [index++] = vertices [i * 2];
}
// Tail cap.
var et = 1.0f - 1.0f / pathDivision;
vertices [index++] = new Vector3(path [0].Evaluate(et), path [1].Evaluate(et), path [2].Evaluate(et));
var ei = profile.Length * (pathDivision - 1) * 2;
for (var i = 0; i < profile.Length; i++)
{
vertices [index++] = vertices [ei + i * 2];
}
}
void Update()
{
_time += Time.deltaTime * _frequency;
if (_octaves > 1)
{
InvokeEvent(Perlin.Fbm(_time, _octaves));
}
else
{
InvokeEvent(Perlin.Noise(_time));
}
}
void Update()
{
if (_target == TestTarget.Noise1D)
{
UpdateTexture((x, y, t) => Perlin.Fbm(x + t, _fractalLevel));
}
else if (_target == TestTarget.Noise2D)
{
UpdateTexture((x, y, t) => Perlin.Fbm(x + t, y, _fractalLevel));
}
else
{
UpdateTexture((x, y, t) => Perlin.Fbm(x, y, t, _fractalLevel));
}
}
public void Update()
{
var dt = Time.deltaTime;
if (_enablePositionNoise)
{
for (var i = 0; i < 3; i++)
{
_time[i] += _positionFrequency * dt;
}
var prevBrownianPos = brownianPos;
brownianPos = new Vector3(
Perlin.Fbm(_time[0], _positionFractalLevel),
Perlin.Fbm(_time[1], _positionFractalLevel),
Perlin.Fbm(_time[2], _positionFractalLevel));
brownianPos = Vector3.Scale(brownianPos, _positionScale);
brownianPos *= _positionAmplitude * _fbmNorm;
transform.position -= prevBrownianPos;
transform.position += brownianPos;
}
if (_enableRotationNoise)
{
for (var i = 0; i < 3; i++)
{
_time[i + 3] += _rotationFrequency * dt;
}
var n = new Vector3(
Perlin.Fbm(_time[3], _rotationFractalLevel),
Perlin.Fbm(_time[4], _rotationFractalLevel),
Perlin.Fbm(_time[5], _rotationFractalLevel));
n = Vector3.Scale(n, _rotationScale);
n *= _rotationAmplitude * _fbmNorm;
var prevBrownianRot = brownianRot;
brownianRot = Quaternion.Euler(n);
transform.rotation = Quaternion.Inverse(prevBrownianRot) * transform.rotation;
transform.rotation = brownianRot * transform.rotation;
}
}
void Update()
{
if (GlobalVariables.Instance.demoEnabled)
{
return;
}
var dt = Time.unscaledDeltaTime;
if (_enablePositionNoise)
{
for (var i = 0; i < 3; i++)
{
_time[i] += _positionFrequency * dt;
}
var n = new Vector3(
Perlin.Fbm(_time[0], _positionFractalLevel),
Perlin.Fbm(_time[1], _positionFractalLevel),
Perlin.Fbm(_time[2], _positionFractalLevel));
n = Vector3.Scale(n, _positionScale);
n *= _positionAmplitude * _fbmNorm;
transform.localPosition = Vector3.Lerp(transform.localPosition, _initialPosition + n, 0.01f);
}
if (_enableRotationNoise)
{
for (var i = 0; i < 3; i++)
{
_time[i + 3] += _rotationFrequency * dt;
}
var n = new Vector3(
Perlin.Fbm(_time[3], _rotationFractalLevel),
Perlin.Fbm(_time[4], _rotationFractalLevel),
Perlin.Fbm(_time[5], _rotationFractalLevel));
n = Vector3.Scale(n, _rotationScale);
n *= _rotationAmplitude * _fbmNorm;
transform.localRotation =
Quaternion.Euler(n) * _initialRotation;
}
}
void Update()
{
var offset = noiseMove * Time.time;
var dx = Vector3.right * (noiseScale / division);
var dy = Vector3.up * (noiseScale / division);
var dz = Vector3.forward * (noiseScale / division);
for (var iz = 0; iz < division; iz++)
{
for (var iy = 0; iy < division; iy++)
{
for (var ix = 0; ix < division; ix++)
{
var pos = dx * ix + dy * iy + dz * iz + offset;
voxels [ix, iy, iz] = Perlin.Fbm(pos, octave) * noise + 1.0f * iz / division;
}
}
}
for (var iz = 1; iz < division - 1; iz++)
{
for (var iy = 1; iy < division - 1; iy++)
{
for (var ix = 1; ix < division - 1; ix++)
{
var gx = voxels[ix + 1, iy, iz] - voxels[ix - 1, iy, iz];
var gy = voxels[ix, iy + 1, iz] - voxels[ix, iy - 1, iz];
var gz = voxels[ix, iy, iz + 1] - voxels[ix, iy, iz - 1];
gradient[ix, iy, iz] = new Vector3(gx, gy, gz);
}
}
}
var oldMesh = meshFilter.sharedMesh;
MarchingCubes.SetTarget(target);
var mesh = MarchingCubes.CreateMesh(voxels, gradient);
meshFilter.sharedMesh = mesh;
if (oldMesh != null)
{
Destroy(oldMesh);
}
}
void Update()
{
var number = particleSystem.GetParticles(particles);
for (var i = 0; i < number; i++)
{
// var particle = particles[i];
var r1 = Time.deltaTime * omega * Perlin.Fbm(particles[i].position * freq + Vector3.right * offset * Time.time, octave);
var r2 = Time.deltaTime * omega * Perlin.Fbm(particles[i].position * freq + Vector3.right * offset * Time.time + Vector3.up * 19.333f, octave);
var r = Quaternion.AngleAxis(r1, Vector3.up) * Quaternion.AngleAxis(r2, Vector3.right);
particles[i].velocity = r * particles[i].velocity;
}
particleSystem.SetParticles(particles, number);
}
void Update()
{
var dt = Time.deltaTime;
if (_enablePositionNoise)
{
for (var i = 0; i < 3; i++)
{
_time[i] += _positionFrequency * dt;
}
var n = new Vector3(
Perlin.Fbm(_time[0], _positionFractalLevel),
Perlin.Fbm(_time[1], _positionFractalLevel),
Perlin.Fbm(_time[2], _positionFractalLevel));
n = Vector3.Scale(n, _positionScale);
n *= _positionAmplitude * _fbmNorm;
transform.localPosition = _initialPosition + n;
}
if (_enableRotationNoise)
{
for (var i = 0; i < 3; i++)
{
_time[i + 3] += _rotationFrequency * dt;
}
var n = new Vector3(
Perlin.Fbm(_time[3], _rotationFractalLevel),
Perlin.Fbm(_time[4], _rotationFractalLevel),
Perlin.Fbm(_time[5], _rotationFractalLevel));
n = Vector3.Scale(n, _rotationScale);
n *= _rotationAmplitude * _fbmNorm;
transform.localRotation =
Quaternion.Euler(n) * _initialRotation;
}
}
void Start()
{
string text = "1D Noise Test: ";
text += DoTest(() => Perlin.Noise(
Random.Range(-100.0f, 100.0f)));
text += "\n2D Noise Test: ";
text += DoTest(() => Perlin.Noise(
Random.Range(-100.0f, 100.0f),
Random.Range(-100.0f, 100.0f)));
text += "\n3D Noise Test: ";
text += DoTest(() => Perlin.Noise(
Random.Range(-100.0f, 100.0f),
Random.Range(-100.0f, 100.0f),
Random.Range(-100.0f, 100.0f)));
text += "\n1D fBm Test: ";
text += DoTest(() => Perlin.Fbm(
Random.Range(-100.0f, 100.0f), 5));
text += "\n2D fBm Test: ";
text += DoTest(() => Perlin.Fbm(
Random.Range(-100.0f, 100.0f),
Random.Range(-100.0f, 100.0f), 5));
text += "\n3D fBm Test: ";
text += DoTest(() => Perlin.Fbm(
Random.Range(-100.0f, 100.0f),
Random.Range(-100.0f, 100.0f),
Random.Range(-100.0f, 100.0f), 5));
Debug.Log(text);
}
/// <summary>
/// Uses layers Perlin noise to generate the density value at a specific point.
/// </summary>
/// <param name="point">
/// point.x, point.y, point.z represent the position of the point in multiples of <c>chunkSize</c>.
/// point.w represents the y value of the point in global coordinates.</param>
/// <returns></returns>
public static Vector2 GenerateValueAtPoint(Vector4 point)
{
// TODO Explain this code
float localScaler = 0.75f * Preferences.terrainScaler + 2f * Preferences.terrainScaler * Perlin.Fbm(point.x, Preferences.seed * 1.25f, point.z, 1);
point.x /= localScaler;
point.y /= localScaler;
point.z /= localScaler;
float baseNoise = 1;
float heightMap = GetHeightAtPoint(new Vector2(point.x, point.z));
baseNoise *= 1 - Mathf.Clamp01(point.w - heightMap);
baseNoise *= 1 - point.w / Preferences.maxTerrainHeight;
baseNoise = Mathf.Clamp01(baseNoise);
float overHang = Perlin.Fbm(point.x * 4f, point.y * 4f, point.z * 4f, 1);
float caveBiomeMap = Mathf.Abs(1 - Mathf.PerlinNoise(point.x, point.z));
float caveToSurfaceFalloff = Mathf.Pow(Mathf.Clamp(heightMap * 1.5f - (point.w - heightMap * 0.5f), 0, heightMap) / heightMap, 2);
float final = Mathf.Lerp(baseNoise, overHang, caveBiomeMap * caveToSurfaceFalloff);
return(new Vector2((1 - Mathf.Clamp01(final)) * 2 - 1f, 0));
}
public IEnumerator GenerateMap()
{
map = new int[World.currentWorld.chunkSize.x, World.currentWorld.chunkSize.y, World.currentWorld.chunkSize.z];
for (int x = 0; x < World.currentWorld.chunkSize.x; x++)
{
for (int y = 0; y < World.currentWorld.chunkSize.y; y++)
{
for (int z = 0; z < World.currentWorld.chunkSize.z; z++)
{
map[x, y, z] = -1; // initialize with empty block
float xCoord = (World.currentWorld.usePositionAsOffset ? transform.position.x : 0.0f) / World.currentWorld.noiseScale + (World.currentWorld.noiseOffset.x + x / World.currentWorld.noiseScale);
float yCoord = (World.currentWorld.usePositionAsOffset ? transform.position.y : 0.0f) / World.currentWorld.noiseScale + (World.currentWorld.noiseOffset.y + y / World.currentWorld.noiseScale);
float zCoord = (World.currentWorld.usePositionAsOffset ? transform.position.z : 0.0f) / World.currentWorld.noiseScale + (World.currentWorld.noiseOffset.z + z / World.currentWorld.noiseScale);
float sample = Perlin.Fbm(xCoord, yCoord, zCoord, World.currentWorld.fractalLevel) / 1.4f + 0.5f;
if (sample < 0.2f)
{
map[x, y, z] = World.airDef; // air
}
else
{
int heightmap = Mathf.RoundToInt(sample * World.currentWorld.chunkSize.y + (y / World.currentWorld.chunkSize.y));
if (y > heightmap)
{
map[x, y, z] = World.airDef; // air
}
if (y == heightmap)
{
if (sample <= 0.475f)
{
map[x, y, z] = World.sandDef; // sand
}
else
{
map[x, y, z] = World.dirtWithGrassDef; // dirt-with-grass
}
}
if (y < heightmap)
{
if (y == 0 || y <= Random.Range(0, 2))
{
map[x, y, z] = World.bedrockDef; // bedrock
}
if (y >= heightmap - Random.Range(1, 5) && y <= heightmap - 1)
{
if (sample <= 0.4f)
{
map[x, y, z] = World.sandDef; // sand
}
else
{
map[x, y, z] = World.dirtDef; // dirt
}
}
else
{
if (map[x, y, z] == -1)
{
map[x, y, z] = World.stoneDef; // stone
}
if (Random.Range(0, 100) == 21)
{
map[x, y, z] = World.diamondDef;
for (int a = 0; a < Random.Range(1, 2); a++)
{
for (int b = 0; b < Random.Range(1, 2); b++)
{
if (IndexExists(x + a, y + b, z + a + b))
{
map[x + a, y + b, z + a + b] = World.diamondDef;
}
}
}
}
}
}
}
}
}
yield return(null);
}
for (int x = 0; x < World.currentWorld.chunkSize.x; x++)
{
for (int y = 0; y < World.currentWorld.waterLevel; y++)
{
for (int z = 0; z < World.currentWorld.chunkSize.z; z++)
{
Vector3Int position = new Vector3Int(x, y, z);
if (IndexExists(position) && IsAirBlock(position))
{
map[x, y, z] = World.waterDef;
}
}
}
}
yield break;
}
