private static void ReadObjects(DS1 ds1, BinaryReader reader, int act) { if (ds1.version < 2) { return; } int objectCount = reader.ReadInt32(); //Debug.Log("Objects " + objectCount); ds1.objects = new ObjectSpawnInfo[objectCount]; for (int i = 0; i < objectCount; i++) { var info = new ObjectSpawnInfo(); int type = reader.ReadInt32(); int id = reader.ReadInt32(); info.x = reader.ReadInt32(); info.y = reader.ReadInt32(); if (ds1.version > 5) { reader.ReadInt32(); // flags } info.preset = SpawnPreset.Find(act, type, id); ds1.objects[i] = info; } }
public List <GameObject> initialPathSpawn(Transform pathContainer, ObjectSpawnInfo spawnObject) { CheckCollisions template = spawnObject.gameObject.AddComponent <CheckCollisions>(); List <GameObject> toBePlaced = new List <GameObject>(); for (int i = 0; i < spawnObject.count; i++) { int index = spawnType == PathSpawnType.Cylinderical ? PositionInCylinder(template) : PositionInRectangle(template); if (index >= 0) { GameObject prop = Instantiate(template.gameObject, template.transform.position, template.transform.rotation, ContainerFromSegmentNumber(pathContainer, index)); ScaleRotateProp(prop, spawnObject); prop.transform.localScale = new Vector3(prop.transform.localScale.x / prop.transform.parent.localScale.x, prop.transform.localScale.y / prop.transform.parent.localScale.y, prop.transform.localScale.z / prop.transform.parent.localScale.z); prop.name = template.gameObject.name + " " + i; prop.GetComponent <CheckCollisions>().ignoreEnvironmentCollisions = true; toBePlaced.Add(prop); } else { Debug.Log("Missing path, you need to have one generated before placing path objects."); break; } } return(toBePlaced); }
IEnumerator SpawnStaticObject(GameObject[] spawnSurfaces, ObjectSpawnInfo spawnObject) { foreach (GameObject go in spawnSurfaces) { if (go.GetComponent <Collider>()) { go.GetComponent <Collider>().enabled = false; } } List <GameObject> toBePlaced = initialStaticSpawn(spawnSurfaces, spawnObject); yield return(StartCoroutine(RepositionCollidingStaticObjects(spawnSurfaces, spawnObject, toBePlaced, spawnObject.attempts))); foreach (GameObject go in spawnSurfaces) { if (go.GetComponent <Collider>()) { go.GetComponent <Collider>().enabled = true; } } foreach (GameObject go in toBePlaced) { DestroyImmediate(go); } totalPlaced += spawnObject.count - toBePlaced.Count; Debug.Log((spawnObject.count - toBePlaced.Count) + " / " + spawnObject.count + " " + spawnObject.gameObject.name + " were sucessfully placed, the remainder were destroyed."); yield break; }
private Vector3 GetSpawnCoords(ObjectSpawnInfo item) { var yOffset = UnityEngine.Random.Range(-1f, 1f) * volumeHalfHeight; var xOffset = UnityEngine.Random.Range(-1f, 1f) * volumeHalfWidth; var worldCoords = solipsist.transform.position + new Vector3(xOffset, yOffset, 0); worldCoords.z = item.atZ; return(worldCoords); }
private void DoSpawnObject(ObjectSpawnInfo info) { var spawnedObject = Instantiate(info.prefab) as GameObject; spawnedObject.transform.position = info.coords; spawnedObject.transform.localScale *= UnityEngine.Random.Range(1f - scaleVariance, 1f + scaleVariance); spawnedObject.transform.localRotation = Utility.GetRandomRotation(); ObjectGenerated?.Invoke(spawnedObject); maintainedObjects.Add(spawnedObject); }
private bool CanSpawn(ObjectSpawnInfo item) { return(true); var coord = GetSpawnCoords(item); var sphereCollider = item.prefab.GetComponent <SphereCollider>(); if (sphereCollider != null) { var radius = sphereCollider.radius * MaxDimensionOf(item.prefab.transform.localScale); return(Physics.OverlapSphere(coord, radius).Length == 0); } return(true); }
static int SortByVolume(ObjectSpawnInfo info1, ObjectSpawnInfo info2) { Collider[] colliders1 = info1.gameObject.GetComponentsInChildren <Collider>(); float go1SumVolume = VolumeOfColliders(colliders1); go1SumVolume *= Mathf.Pow(Mathf.Max(info1.staticScale, info1.maxConsistantScale, info1.maxIndependentScale.magnitude), 3); Collider[] colliders2 = info2.gameObject.GetComponentsInChildren <Collider>(); float go2SumVolume = VolumeOfColliders(colliders2); go2SumVolume *= Mathf.Pow(Mathf.Max(info2.staticScale, info2.maxConsistantScale, info2.maxIndependentScale.magnitude), 3); return(go2SumVolume.CompareTo(go1SumVolume)); }
IEnumerator SpawnPathObject(Transform pathContainer, ObjectSpawnInfo spawnObject) { List <GameObject> toBePlaced = initialPathSpawn(pathContainer, spawnObject); yield return(StartCoroutine(RepositionCollidingPathObjects(toBePlaced, spawnObject.attempts, pathContainer))); totalPlaced += spawnObject.count - toBePlaced.Count; Debug.Log((spawnObject.count - toBePlaced.Count) + " / " + spawnObject.count + " " + spawnObject.gameObject.name + " were sucessfully placed, the remainder were destroyed."); foreach (GameObject go in toBePlaced) { DestroyImmediate(go); } yield break; }
public GameObject spawnObject(ObjectSpawnInfo osi, Vector2 pos, Vector2 dir, float addSpawnBuffer = 0) { if (PV.IsMine) { //Make sure dir is a unit vector if (!Mathf.Approximately(dir.sqrMagnitude, 1)) { throw new System.ArgumentException( $"dir needs to be a unit vector! dir: {dir}, " + $"sqrMagnitude: {dir.sqrMagnitude}" ); } //Initialize arguments string pathName = Path.Combine("PhotonPrefabs", folderName, osi.objectName); Vector2 position = pos + (dir * (osi.spawnBuffer + addSpawnBuffer)); position += osi.spawnOffset; Quaternion rotation = (osi.rotateShot) ? Quaternion.Euler(0, 0, Vector2.SignedAngle(Vector2.up, dir)) : Quaternion.Euler(0, 0, 0); //Instantiate GameObject go = (SpawnMaster) //Spawn as scene object (doesn't disappear when player disconnects) ? PhotonNetwork.InstantiateRoomObject(pathName, position, rotation) //Spawn as player object (disappears when player disconnects) : PhotonNetwork.Instantiate(pathName, position, rotation) ; //Team Token if (osi.inheritTeamToken) { TeamToken.seeRecruiter(go, teamToken.owner, true); } //Color if (osi.inheritColor) { ColorInitializer colorInit = go.FindComponent <ColorInitializer>(); if (colorInit) { colorInit.setColor(PlayerColor); } } //Delegate onObjectSpawned?.Invoke(go, position, dir); //Return return(go); } return(null); }
public void ScaleRotateProp(GameObject obj, ObjectSpawnInfo info) { obj.transform.localScale = new Vector3(info.gameObject.transform.localScale.x / obj.transform.parent.transform.localScale.x, info.gameObject.transform.localScale.y / obj.transform.parent.transform.localScale.y, info.gameObject.transform.localScale.z / obj.transform.parent.transform.localScale.z); if (info.scaleType == ScaleType.Static) { ScaleObject(obj.transform, info.staticScale); } else if (info.scaleType == ScaleType.ConsistantAxis) { ScaleObject(obj.transform, info.minConsistantScale, info.maxConsistantScale); } else { ScaleObject(obj.transform, info.minIndependentScale, info.maxIndependentScale); } }
public IEnumerator RepositionCollidingStaticObjects(GameObject[] spawnSurfaces, ObjectSpawnInfo info, List <GameObject> toBePlaced, int maxAttempts) { int currentAttempts = 0; while (toBePlaced.Count > 0 && currentAttempts < maxAttempts) { yield return(StartCoroutine(RemoveValid(toBePlaced))); currentAttempts++; for (int i = toBePlaced.Count - 1; i >= 0; i--) { int index = PositionOnMeshRandomizer(spawnSurfaces, toBePlaced[i].GetComponent <CheckCollisions>(), info); if (index >= 0) { toBePlaced[i].transform.parent = spawnSurfaces[index].transform; ScaleRotateProp(toBePlaced[i], info); } } } }
public List <GameObject> initialStaticSpawn(GameObject[] spawnSurfaces, ObjectSpawnInfo spawnObject) { List <GameObject> toBePlaced = new List <GameObject>(); for (int i = 0; i < spawnObject.count; i++) { if (spawnSurfaces.Length > 0) { GameObject prop = Instantiate(spawnObject.gameObject, spawnObject.gameObject.transform); CheckCollisions collisionScript = prop.GetComponent <CheckCollisions>() ? prop.GetComponent <CheckCollisions>() : prop.AddComponent <CheckCollisions>(); int index = PositionOnMeshRandomizer(spawnSurfaces, collisionScript, spawnObject); if (index >= 0) { prop.transform.parent = spawnSurfaces[index].transform; collisionScript.order = order; order++; prop.transform.localScale = new Vector3(spawnObject.gameObject.transform.localScale.x / spawnSurfaces[index].transform.localScale.x, spawnObject.gameObject.transform.localScale.y / spawnSurfaces[index].transform.localScale.y, spawnObject.gameObject.transform.localScale.z / spawnSurfaces[index].transform.localScale.z); ScaleRotateProp(prop, spawnObject); prop.name = spawnObject.gameObject.name + " " + i; prop.tag = "Environmental"; toBePlaced.Add(prop); } else { DestroyImmediate(prop); } } else { Debug.Log("There are no current spawn surfaces, must be created before object placement."); } } return(toBePlaced); }
private void EnqueueSpawnObject(ObjectSpawnInfo info) { spawnQueue.Enqueue(info); }
private int PositionOnMeshRandomizer(GameObject[] spawnSurfaces, CheckCollisions position, ObjectSpawnInfo info) { if (spawnSurfaces.Length == 0) { return(-1); } int randomMeshIndex = Random.Range(0, spawnSurfaces.Length); if (spawnSurfaces[randomMeshIndex].GetComponent <MeshFilter>()) { int[] tris = spawnSurfaces[randomMeshIndex].GetComponent <MeshFilter>().sharedMesh.triangles; Vector3[] verts = spawnSurfaces[randomMeshIndex].GetComponent <MeshFilter>().sharedMesh.vertices; int randomTris = Random.Range(0, Mathf.RoundToInt(tris.Length / 3f)); Bounds bounds = spawnSurfaces[randomMeshIndex].GetComponent <MeshFilter>().sharedMesh.bounds; Vector3 a = spawnSurfaces[randomMeshIndex].transform.TransformPoint(verts[tris[randomTris * 3]]); Vector3 b = spawnSurfaces[randomMeshIndex].transform.TransformPoint(verts[tris[(randomTris * 3) + 1]]); Vector3 c = spawnSurfaces[randomMeshIndex].transform.TransformPoint(verts[tris[(randomTris * 3) + 2]]); Vector3 side1 = b - a; Vector3 side2 = c - a; Vector3 normal = Vector3.Cross(side1, side2); float randX = Random.value; float randY = Random.value; float randZ = Random.value; Vector3 randPointOnTri = (randX * a + randY * b + randZ * c) / (randX + randY + randZ); Quaternion rotation = Quaternion.FromToRotation(Vector3.up, normal.normalized); position.SetNewLocation(randPointOnTri, rotation); position.transform.RotateAround(position.transform.position, position.transform.up, Random.Range(0, 360)); return(randomMeshIndex); } else { return(-1); } }