public static GreebleDefinition ProceduralGreebleType(GreebleDefinition[] greebleDefinitions, float timeSinceDespawn = 0f)
{
if (greebleDefinitions == null)
{
return(null);
}
int num = 0;
for (int i = 0; i < greebleDefinitions.Length; i++)
{
GreebleDefinition greebleDefinition = greebleDefinitions[i];
num += greebleDefinition.Chance;
}
int num2 = GreebleUtility_Networked.ProceduralValue(0, num);
num = 0;
for (int j = 0; j < greebleDefinitions.Length; j++)
{
GreebleDefinition greebleDefinition2 = greebleDefinitions[j];
num += greebleDefinition2.Chance;
if (num2 < num)
{
return(greebleDefinition2);
}
}
return(null);
}
private void InstantiateGreeble(int localX, int localY, int localZ)
{
int seed = UnityEngine.Random.Range(0, 6060842);
int worldX = localX + this.worldOffsetX;
int worldY = localY + this.worldOffsetY;
int worldZ = localZ + this.worldOffsetZ;
this.ProceduralSeed(worldX, worldY, worldZ);
GreebleDefinition greebleDefinition = GreebleUtility.ProceduralGreebleType(this.GreebleDefinitions, false, 0f);
if (greebleDefinition == null)
{
UnityEngine.Random.seed = seed;
return;
}
Vector3 world = this.GetWorld(worldX, worldY, worldZ);
Vector3 b = this.ProceduralPositionOffset();
b.y = 0f;
Quaternion rotation = (!greebleDefinition.RandomizeRotation) ? Quaternion.identity : GreebleUtility.ProceduralRotation();
this.greebles[localX, localY, localZ].Instance = GreebleUtility.Spawn(greebleDefinition, new Ray(world + b + new Vector3(0f, this.Dimensions.y * 0.5f, 0f), Vector3.down), this.Dimensions.y, rotation, 0.5f);
this.greebles[localX, localY, localZ].IsSpawning = false;
UnityEngine.Random.seed = seed;
}
private void Start()
{
switch (this.RandomSelection)
{
case GreebleSelection.RandomizeChances:
{
GreebleDefinition[] greebleDefinitions = this.GreebleDefinitions;
for (int i = 0; i < greebleDefinitions.Length; i++)
{
GreebleDefinition greebleDefinition = greebleDefinitions[i];
greebleDefinition.Chance = GreebleUtility.ProceduralValue(1, 100);
}
break;
}
case GreebleSelection.SelectOne:
{
int num = GreebleUtility.ProceduralValue(0, this.GreebleDefinitions.Length);
for (int j = 0; j < this.GreebleDefinitions.Length; j++)
{
this.GreebleDefinitions[j].Chance = ((j != num) ? 0 : 1);
}
break;
}
}
}
public static GreebleDefinition ProceduralGreebleType(GreebleDefinition[] greebleDefinitions, float ageInMinutes = 0f)
{
if (greebleDefinitions == null)
{
return(null);
}
int num = 0;
for (int i = 0; i < greebleDefinitions.Length; i++)
{
GreebleDefinition greebleDefinition = greebleDefinitions[i];
if (greebleDefinition.Prefab && greebleDefinition.IsAgeAppropriate(ageInMinutes))
{
num += greebleDefinition.Chance;
}
}
int num2 = GreebleUtility.ProceduralValue(0, num);
num = 0;
for (int j = 0; j < greebleDefinitions.Length; j++)
{
GreebleDefinition greebleDefinition2 = greebleDefinitions[j];
if (greebleDefinition2.Prefab && greebleDefinition2.IsAgeAppropriate(ageInMinutes))
{
num += greebleDefinition2.Chance;
if (num2 < num)
{
return(greebleDefinition2);
}
}
}
return(null);
}
public static GameObject Spawn(GreebleDefinition greebleDefinition, Ray ray, float distance, Quaternion rotation, float maxSlope = 0.5f)
{
if (distance <= 0f)
{
return(null);
}
Vector3 vector = ray.origin;
RaycastHit raycastHit;
if (!Physics.Raycast(ray, out raycastHit, distance, greebleDefinition.SurfaceMask | greebleDefinition.KillMask))
{
return(null);
}
if ((greebleDefinition.KillMask.value & 1 << raycastHit.collider.gameObject.layer) > 0)
{
return(null);
}
if (Vector3.Dot(ray.direction, raycastHit.normal) > -maxSlope)
{
return(null);
}
bool flag = greebleDefinition.TerrainTextureMask != null && greebleDefinition.TerrainTextureMask.Length > 0;
if (flag)
{
Terrain component = raycastHit.collider.GetComponent <Terrain>();
if (component)
{
Debug.Log("We have terrain");
Vector3 position = component.GetPosition();
TerrainData terrainData = component.terrainData;
int alphamapResolution = terrainData.alphamapResolution;
int num = (int)((raycastHit.point.x - position.x) / terrainData.size.x * (float)alphamapResolution);
int num2 = (int)((raycastHit.point.z - position.z) / terrainData.size.z * (float)alphamapResolution);
bool flag2 = false;
if (num >= 0 && num2 >= 0 && num < alphamapResolution && num2 < alphamapResolution)
{
float[,,] alphamaps = component.terrainData.GetAlphamaps(num, num2, 1, 1);
float num3 = 0f;
int num4 = -1;
for (int i = terrainData.alphamapLayers - 1; i >= 0; i--)
{
if (alphamaps[0, 0, i] > num3)
{
num3 = alphamaps[0, 0, i];
num4 = i;
}
}
if (num4 >= 0)
{
int[] terrainTextureMask = greebleDefinition.TerrainTextureMask;
for (int j = 0; j < terrainTextureMask.Length; j++)
{
int num5 = terrainTextureMask[j];
if (num5 == num4)
{
flag2 = true;
break;
}
}
}
}
if (!flag2)
{
return(null);
}
}
}
vector = raycastHit.point;
if (greebleDefinition.MatchSurfaceNormal)
{
Vector3 lhs = Vector3.Cross(Vector3.forward, raycastHit.normal);
Vector3 forward = Vector3.Cross(lhs, raycastHit.normal);
Quaternion quaternion = Quaternion.LookRotation(forward, raycastHit.normal);
if (greebleDefinition.RandomizeRotation)
{
rotation = quaternion * rotation;
}
else
{
rotation = quaternion;
}
}
vector += rotation * greebleDefinition.Prefab.transform.position;
rotation *= greebleDefinition.Prefab.transform.rotation;
return(GreeblePlugin.Instantiate(greebleDefinition.Prefab, vector, rotation));
}
private void SpawnIndex(int index)
{
if (this.InstanceData[index].Destroyed)
{
return;
}
UnityEngine.Random.seed = this.GetRandomSeed() + index;
GreebleDefinition greebleDefinition = GreebleUtility.ProceduralGreebleType(this.GreebleDefinitions, (Time.timeSinceLevelLoad - this.InstanceData[index].CreationTime) / 60f);
if (greebleDefinition == null)
{
UnityEngine.Random.seed = this.GetRandomSeed();
return;
}
Vector3 vector = Vector3.zero;
Vector3 vector2 = Vector3.down;
float distance = this.Radius;
GreebleShape shape = this.Shape;
if (shape != GreebleShape.Sphere)
{
if (shape == GreebleShape.Box)
{
Vector3 vector3 = this.Size * 0.5f;
Vector3 b = new Vector3(GreebleUtility.ProceduralValue(-vector3.x, vector3.x), GreebleUtility.ProceduralValue(-vector3.y, vector3.y), GreebleUtility.ProceduralValue(-vector3.z, vector3.z));
int num = 0;
switch (this.Direction)
{
case GreebleRayDirection.Floor:
num = 4;
break;
case GreebleRayDirection.Ceiling:
num = 5;
break;
case GreebleRayDirection.Walls:
num = GreebleUtility.ProceduralValue(0, 4);
break;
case GreebleRayDirection.AllDirections:
num = GreebleUtility.ProceduralValue(0, 6);
break;
}
switch (num)
{
case 0:
vector2 = Vector3.left;
b.x = vector3.x;
distance = this.Size.x;
break;
case 1:
vector2 = Vector3.right;
b.x = -vector3.x;
distance = this.Size.x;
break;
case 2:
vector2 = Vector3.back;
b.z = vector3.z;
distance = this.Size.z;
break;
case 3:
vector2 = Vector3.forward;
b.z = -vector3.z;
distance = this.Size.z;
break;
case 4:
vector2 = Vector3.down;
b.y = vector3.y;
distance = this.Size.y;
break;
case 5:
vector2 = Vector3.up;
b.y = -vector3.y;
distance = this.Size.y;
break;
}
vector += b;
}
}
else
{
distance = this.Radius;
Vector3 zero = Vector3.zero;
do
{
zero = new Vector3(GreebleUtility.ProceduralValue(-this.Radius, this.Radius), GreebleUtility.ProceduralValue(-this.Radius, this.Radius), GreebleUtility.ProceduralValue(-this.Radius, this.Radius));
}while (zero.magnitude > this.Radius);
switch (this.Direction)
{
case GreebleRayDirection.Floor:
vector += new Vector3(zero.x, 0f, zero.y);
vector2 = Vector3.down;
break;
case GreebleRayDirection.Ceiling:
vector += new Vector3(zero.x, 0f, zero.y);
vector2 = Vector3.up;
break;
case GreebleRayDirection.Walls:
vector2 = GreebleUtility.ProceduralDirectionFast();
vector2.y = 0f;
vector2.Normalize();
vector += zero - Vector3.Project(zero, vector2);
break;
case GreebleRayDirection.AllDirections:
vector2 = GreebleUtility.ProceduralDirection();
break;
}
}
Quaternion rotation = Quaternion.identity;
if (greebleDefinition.RandomizeRotation)
{
rotation = Quaternion.Euler((!greebleDefinition.AllowRotationX) ? 0f : GreebleUtility.ProceduralAngle(), (!greebleDefinition.AllowRotationY) ? 0f : GreebleUtility.ProceduralAngle(), (!greebleDefinition.AllowRotationZ) ? 0f : GreebleUtility.ProceduralAngle());
}
this.instances[index] = GreebleUtility.Spawn(greebleDefinition, new Ray(base.transform.TransformPoint(vector), base.transform.TransformDirection(vector2)), distance, rotation, 0.5f);
if (this.Data != null && this.instances[index] != null && Application.isPlaying)
{
try
{
if (greebleDefinition.HasCustomActiveValue)
{
CustomActiveValueGreeble component = this.instances[index].GetComponent <CustomActiveValueGreeble>();
component.Data = this.Data;
component.Index = index;
if (this.Data._instancesState[index] > 252)
{
this.Data._instancesState[index] = 252;
}
}
else
{
this.Data._instancesState[index] = 253;
}
}
catch (Exception message)
{
Debug.Log(message);
}
}
if (this.instances[index])
{
if (this.MpSync && BoltNetwork.isServer)
{
BoltNetwork.Attach(this.instances[index]);
}
this.InstanceData[index].Spawned = true;
if (this.OnSpawned != null)
{
this.OnSpawned(index, this.instances[index]);
}
}
UnityEngine.Random.seed = this.GetRandomSeed();
}
