///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static void CubeOutOfPool(Transform thisTransform, int numberCubeOutOfPool, float cubeOutOfPoolScale, Vector2 uvOffset)
{
//--------------
for (int z = 0; z < numberCubeOutOfPool; z++)
{
for (int y = 0; y < numberCubeOutOfPool; y++)
{
for (int x = 0; x < numberCubeOutOfPool; x++)
{
GameObject cubeOutOfPool = ChunkCubesPool.GiveCube();
if (cubeOutOfPool != null)
{
Transform cubeOutOfPoolTransform = cubeOutOfPool.transform;
cubeOutOfPoolTransform.rotation = thisTransform.rotation;
cubeOutOfPoolTransform.parent = thisTransform;
cubeOutOfPoolTransform.localScale = Vector3.one * cubeOutOfPoolScale;
float xt = (cubeOutOfPoolScale * 0.5f - 0.5f) + (x * cubeOutOfPoolScale);
float yt = (cubeOutOfPoolScale * 0.5f - 0.5f) + (y * cubeOutOfPoolScale);
float zt = (cubeOutOfPoolScale * 0.5f - 0.5f) + (z * cubeOutOfPoolScale);
cubeOutOfPoolTransform.localPosition = new Vector3(xt, yt, zt);
cubeOutOfPool.GetComponent <ChunkCube>().uvOffset = uvOffset;
cubeOutOfPool.SetActive(true);
}
}
}
}
//--------------
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static IEnumerator CheckChildCount(Transform thisTransform, GameObject gameObject)
{
//--------------
int counter0 = 0;
while (true)
{
yield return(delay0);
if (thisTransform.childCount == 0)
{
ChunkCubesPool.TakeCube(gameObject);
}
else if (thisTransform.childCount > 0 && thisTransform.childCount <= 2)
{
if (counter0++ >= 75)
{
counter0 = 0;
if (Class_Controller.SqrMagnitudeToPlayer(thisTransform) > 250000)
{
ChunkCubesPool.TakeCube(gameObject);
}
}
}
}
//--------------
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Start()
{
//--------------
Class_AdditionalTools.RandomName(gameObject, "Moon");
sqrtDistanceLod = Mathf.Pow(Class_Interface.distanceLod, 2);
scaleMoon = Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, 0.112f));
thisTransform.localScale = Vector3.one * (1 + (scaleMoon * 2));
randomRotationUp = Class_AdditionalTools.PositionSeed(thisTransform, 0.179f) * 0.03f;
randomRotationLeft = Class_AdditionalTools.PositionSeed(thisTransform, 0.813f) * 0.03f;
float uvOffsetX = Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, 0.123f));
landscape.GetComponent <Landscape>().uvOffset = new Vector2(uvOffsetX, 0.5f);
//--------------
moonCube = ChunkCubesPool.GiveCube();
moonCubeTransform = moonCube.transform;
moonCube.GetComponent <ChunkCube>().uvOffset = new Vector2(uvOffsetX, 0.5f);
moonCubeTransform.parent = thisTransform;
moonCubeTransform.localScale = Vector3.one * 10;
moonCubeTransform.SetPositionAndRotation(thisTransform.position, thisTransform.rotation);
moonCube.SetActive(true);
//--------------
if (Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, 0.151f)) < 0.6f)
{
atmosphere.SetActive(false);
}
else
{
atmosphere.transform.localRotation = Quaternion.Euler(Mathf.Cos(uvOffsetX * 1.1f) * 16, Mathf.Cos(uvOffsetX * 2.2f) * 16, Mathf.Cos(uvOffsetX * 3.3f) * 16);
}
if (Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, 125.15f)) < 0.5f)
{
satellitesOrbit.SetActive(false);
noSatellites = true;
}
else
{
StartCoroutine(Class_Moon.GenSatellites(thisTransform, satellitesOrbitTransform, scaleMoon, uvOffsetX));
}
//--------------
StartCoroutine(Optimization());
StartCoroutine(FakeFixedUpdate());
//--------------
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static IEnumerator GenSatellites(Transform thisTransform, Transform satellitesOrbitTransform, float scaleMoon, float uvOffsetX)
{
//--------------
satellitesOrbitTransform.localRotation = Quaternion.Euler(Class_AdditionalTools.PositionSeed(thisTransform, 1.1f) * 15, Class_AdditionalTools.PositionSeed(thisTransform, 2.2f) * 15, Class_AdditionalTools.PositionSeed(thisTransform, 3.3f) * 15);
float systemSize = 9 - (1 + (scaleMoon * 2.25f));
int systemDensity = 5;
Vector3 center = Vector3.zero;
for (int x = -systemDensity; x < systemDensity; x++)
{
for (int z = -systemDensity; z < systemDensity; z++)
{
yield return(delay0);
Vector3 position = new Vector3(x, 0, z);
float distance = Vector3.Distance(position, center);
if (distance < systemDensity && distance > systemDensity * 0.6f)
{
float xt = (systemSize * 0.5f - 0.5f) + (x * systemSize);
float zt = (systemSize * 0.5f - 0.5f) + (z * systemSize);
float cosQtObj = Mathf.Cos((11.1f + xt + z) * (10.3f + x + zt) * Class_StarSystem.seed * 0.033f);
float lperlinf = Mathf.PerlinNoise(cosQtObj, cosQtObj);
if (lperlinf > 0.1f && lperlinf < 0.75f)
{
for (int i = 0; i < 2; i++)
{
GameObject obj = ChunkCubesPool.GiveCube();
obj.GetComponent <ChunkCube>().uvOffset = new Vector2(uvOffsetX, 0.5f);
Transform tr = obj.transform;
tr.rotation = Random.rotation;
tr.localScale = Vector3.one * (1 + (lperlinf * scaleMoon * 8));
tr.parent = satellitesOrbitTransform;
float scaleMoonM = scaleMoon * 10;
float yt = Mathf.Cos(lperlinf * (lperlinf + xt + zt)) * scaleMoonM;
tr.localPosition = new Vector3(xt + (Mathf.Cos(lperlinf * zt) * scaleMoonM), yt, zt + (Mathf.Cos(lperlinf * xt) * scaleMoonM));
obj.SetActive(true);
yield return(null);
}
}
}
}
}
//--------------
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Start()
{
//--------------
Class_AdditionalTools.RandomName(gameObject, "Planet");
sqrtDistanceLod = Mathf.Pow(Class_Interface.distanceLod, 2);
Class_PlanetarySystem.listPlanets.Add(gameObject);
randomRotationUp = Class_AdditionalTools.PositionSeed(thisTransform, 0.39f) * 0.025f;
randomRotationLeft = Class_AdditionalTools.PositionSeed(thisTransform, 0.719f) * 0.025f;
float uvOffsetX = Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, 0.115f));
landscape.GetComponent <Landscape>().uvOffset = new Vector2(uvOffsetX, 0.5f);
//--------------
planetCube = ChunkCubesPool.GiveCube();
planetCubeTransform = planetCube.transform;
planetCube.GetComponent <ChunkCube>().uvOffset = new Vector2(uvOffsetX, 0.5f);
planetCubeTransform.parent = thisTransform;
planetCubeTransform.localScale = Vector3.one * 10;
planetCubeTransform.SetPositionAndRotation(thisTransform.position, thisTransform.rotation);
planetCube.SetActive(true);
//--------------
if (Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, 0.15f)) < 0.3f)
{
atmosphere.SetActive(false);
forest.SetActive(false);
}
else
{
atmosphereTransform.localRotation = Quaternion.Euler(Mathf.Cos(uvOffsetX * 1.1f) * 10, Mathf.Cos(uvOffsetX * 2.2f) * 10, Mathf.Cos(uvOffsetX * 3.3f) * 10);
atmosphereTransform.localScale = Vector3.one * (18 + Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, 9.39f) * 4));
}
//--------------
StartCoroutine(Optimization());
StartCoroutine(FakeFixedUpdate());
//--------------
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static IEnumerator GenChunkLandscape(Transform thisTransform)
{
//--------------
Vector2 uvOffset = new Vector2(Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, 0.41f)), 0.5f);
int numberCubeOutOfPool = Mathf.FloorToInt(Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, 7.18f)) * 3) + 2;
float cycleOffset = 1;
//--------------
for (int i = 0; i < numberCubeOutOfPool; i++)
{
yield return(delay0);
GameObject cubeOutOfPool = ChunkCubesPool.GiveCube();
Transform cubeTransform = cubeOutOfPool.transform;
cubeTransform.parent = thisTransform;
cycleOffset += i * 1.33f;
float cubeScale = Mathf.Abs(Mathf.Cos(numberCubeOutOfPool * cycleOffset)) * 0.7f + 0.05f;
float xs = 1 - (Mathf.Cos(cubeScale * cycleOffset) * 0.2f);
float ys = 1 - (Mathf.Cos(cubeScale * cycleOffset * 1.35f) * 0.2f);
float zs = 1 - (Mathf.Cos(cubeScale * cycleOffset * 0.76f) * 0.2f);
cubeTransform.localScale = new Vector3(cubeScale * xs, cubeScale * ys, cubeScale * zs);
float localVar0 = Mathf.Cos(cycleOffset * cubeScale) * 0.5f;
float xt = localVar0 - (localVar0 * cubeScale);
float localVar1 = Mathf.Cos((1.78f + cycleOffset * 1.14f) * cubeScale) * 0.5f;
float yt = localVar1 - (localVar1 * cubeScale);
float localVar2 = Mathf.Cos((5.78f + cycleOffset * 1.64f) * cubeScale) * 0.5f;
float zt = localVar2 - (localVar2 * cubeScale);
cubeTransform.localPosition = new Vector3(xt, yt, zt);
float rt = Mathf.Cos(cubeScale * numberCubeOutOfPool * cycleOffset) * 15;
cubeTransform.localRotation = Quaternion.Euler(rt, -rt, rt);
cubeOutOfPool.GetComponent <ChunkCube>().uvOffset = uvOffset;
cubeOutOfPool.SetActive(true);
}
//--------------
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
IEnumerator SplitСube()
{
//--------------
amountDamage += currentDamage;
if (amountDamage >= 10.0f + (faultSize * 0.5f) && brokenStage0 == false)
{
brokenStage0 = true;
StartCoroutine(Class_ChunkCube.CheckChildCount(thisTransform, gameObject));
if (thisScaleX > faultSize * faultSizeOptimize)
{
Class_ChunkCube.CubeOutOfPool(thisTransform, numberCubeOutOfPool, cubeOutOfPoolScale, uvOffset);
thisRenderer.enabled = false;
thisBoxCollider.enabled = false;
}
else
{
outPool = false;
if (visible == true)
{
Class_ChunkCube.ParticlesOutOfPool(thisTransform, ExplosionParticlesPool.GiveExplosionParticle(0), Random.Range(0.75f, 1.25f));
Class_ChunkCube.ParticlesOutOfPool(thisTransform, ExplosionParticlesPool.GiveExplosionParticle(1), Random.Range(0.75f, 1.25f));
for (int i = 0; i < numberDebris; i++)
{
Class_ChunkCube.DebrisOutOfPool(thisTransform, thisRenderer, DebrisesPool.GiveDebris(Random.Range(0, 2)), numberDebris, Random.Range(0.4f, 0.9f), uvOffset);
}
}
Class_Mineral.RandomMinerals(thisTransform);
yield return(delay0);
ChunkCubesPool.TakeCube(gameObject);
}
}
//--------------
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static IEnumerator GenLandscape(Transform thisTransform, GameObject chunkLandscape, Vector2 uvOffset)
{
//--------------
float seedGeneration = Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, 0.22f));
int numberCubeOutOfPool = Mathf.FloorToInt(Mathf.Abs(Mathf.Cos(seedGeneration * Class_StarSystem.seed)) * 11) + 9;
int cubeOutOfPoolSeedPosition = 1;
float cycleOffset = 1;
GameObject cubeOutOfPool;
//--------------
for (int i = 0; i < numberCubeOutOfPool; i++)
{
yield return(delay0);
if (seedGeneration > 0.5f)
{
cubeOutOfPool = ChunkCubesPool.GiveCube();
cubeOutOfPool.GetComponent <ChunkCube>().uvOffset = uvOffset;
}
else
{
cubeOutOfPool = GameObject.Instantiate(chunkLandscape);
}
Transform cubeTransform = cubeOutOfPool.transform;
cubeTransform.parent = thisTransform;
cycleOffset += i * 1.33f;
float cubeScale = Mathf.Abs(Mathf.Cos(numberCubeOutOfPool * cycleOffset * seedGeneration)) * 0.25f + 0.05f;
float xs = 1 - (Mathf.Cos((cubeScale + seedGeneration) * cycleOffset) * 0.1f);
float ys = 1 - (Mathf.Cos((cubeScale + seedGeneration) * cycleOffset * 1.35f) * 0.1f);
float zs = 1 - (Mathf.Cos((cubeScale + seedGeneration) * cycleOffset * 0.76f) * 0.1f);
cubeTransform.localScale = new Vector3(cubeScale * xs, cubeScale * ys, cubeScale * zs);
cubeOutOfPoolSeedPosition = Mathf.FloorToInt(Mathf.Abs(Mathf.Cos((1.3f + seedGeneration) * cycleOffset + cubeOutOfPoolSeedPosition + cubeScale)) * 6) + 1;
float localVar0 = Mathf.Cos((cubeOutOfPoolSeedPosition + cycleOffset) * (cubeScale + seedGeneration)) * 0.46f;
float localVar1 = localVar0 - (localVar0 * cubeScale);
float localVar2 = Mathf.Cos((cubeOutOfPoolSeedPosition * 1.78f + cycleOffset * 1.14f) * (cubeScale + seedGeneration)) * 0.46f;
float localVar3 = localVar2 - (localVar2 * cubeScale);
if (cubeOutOfPoolSeedPosition == 1)
{
cubeTransform.localPosition = new Vector3(localVar1, 0.5f, localVar3);
}
if (cubeOutOfPoolSeedPosition == 2)
{
cubeTransform.localPosition = new Vector3(localVar1, -0.5f, localVar3);
}
if (cubeOutOfPoolSeedPosition == 3)
{
cubeTransform.localPosition = new Vector3(0.5f, localVar1, localVar3);
}
if (cubeOutOfPoolSeedPosition == 4)
{
cubeTransform.localPosition = new Vector3(-0.5f, localVar1, localVar3);
}
if (cubeOutOfPoolSeedPosition == 5)
{
cubeTransform.localPosition = new Vector3(localVar3, localVar1, 0.5f);
}
if (cubeOutOfPoolSeedPosition == 6)
{
cubeTransform.localPosition = new Vector3(localVar3, localVar1, -0.5f);
}
float rt = Mathf.Cos((cubeScale + seedGeneration) * numberCubeOutOfPool * cycleOffset) * 20;
cubeTransform.localRotation = Quaternion.Euler(rt, -rt, rt);
if (cubeOutOfPool.activeSelf == false)
{
cubeOutOfPool.SetActive(true);
}
}
//--------------
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static IEnumerator GenAsteroid(Transform thisTransform, Transform asteroidCubesTransform, float distanceLod, GameObject asteroidCubes, GameObject lod, int amountAsteroids)
{
//--------------
for (int i = 0; i < amountAsteroids; i++)
{
yield return(null);
GameObject cubeOutOfPool = ChunkCubesPool.GiveCube();
if (cubeOutOfPool != null)
{
cubeOutOfPool.layer = 30;
Transform cubeOutOfPoolTransform = cubeOutOfPool.transform;
cubeOutOfPoolTransform.parent = asteroidCubesTransform;
float uvOffsetX = Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, amountAsteroids + i + 1.27f));
cubeOutOfPool.GetComponent <ChunkCube>().uvOffset = new Vector2(uvOffsetX, 0.025f);
float cubeOutOfPoolScaleXZ = 0.15f + Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, uvOffsetX + i + 4.13f) * 0.7f);
float cubeOutOfPoolY = 0.15f + Mathf.Abs(Class_AdditionalTools.PositionSeed(thisTransform, cubeOutOfPoolScaleXZ + uvOffsetX + i + 1.9f) * 0.7f);
cubeOutOfPoolTransform.localScale = new Vector3(cubeOutOfPoolScaleXZ, cubeOutOfPoolY, cubeOutOfPoolScaleXZ);
float xt = Class_AdditionalTools.PositionSeed(thisTransform, i + cubeOutOfPoolScaleXZ * 1.241f) * (0.6f - (0.6f * cubeOutOfPoolScaleXZ));
float yt = Class_AdditionalTools.PositionSeed(thisTransform, i + cubeOutOfPoolY * 8.83f) * (0.6f - (0.6f * cubeOutOfPoolY));
float zt = Class_AdditionalTools.PositionSeed(thisTransform, i + cubeOutOfPoolScaleXZ * 3.31f) * (0.6f - (0.6f * cubeOutOfPoolScaleXZ));
cubeOutOfPoolTransform.localPosition = new Vector3(xt, yt, zt);
float xr = Class_AdditionalTools.PositionSeed(thisTransform, xt + cubeOutOfPoolScaleXZ * 7.13f) * 20;
float yr = Class_AdditionalTools.PositionSeed(thisTransform, yt + cubeOutOfPoolY * 6.93f) * 20;
float zr = Class_AdditionalTools.PositionSeed(thisTransform, zt + cubeOutOfPoolScaleXZ * 1.13f) * 20;
cubeOutOfPoolTransform.localRotation = Quaternion.Euler(xr, yr, zr);
cubeOutOfPool.SetActive(true);
}
}
//--------------
Class_AdditionalTools.UvMesh(lod.GetComponent <MeshFilter>().mesh, 0.4f, 0.025f);
while (true)
{
yield return(delay0);
if (asteroidCubes.transform.childCount > 0)
{
if (Class_Controller.SqrMagnitudeToPlayer(thisTransform) < distanceLod)
{
asteroidCubes.SetActive(true);
lod.SetActive(false);
}
else
{
asteroidCubes.SetActive(false);
lod.SetActive(true);
}
}
else
{
thisTransform.gameObject.SetActive(false);
}
}
//--------------
}
