How to spawn 2 smaller instances of a prefab from a script on the prefab.

alienbaby · December 6, 2013, 7:20pm

So, in an asteroids style game. I have a prefab that is the asteroid, on it it has a script that is triggered oncollisionenter. When it collides with a bullet, it takes damage until it is time to explode and turn into two smaller asteroids.

I have tried a couple of variations to get the respawning part to work. The initial spawning of roids, and managing of the roids on the field overall is done by this script;

var prefabRoid:GameObject;
var boundingBoxSize:float = 1000;
var diffMult:float = 1.0;
var diffStep:int = 1;

private var currentDifficulty:float = 1.0;
private var minX:float;
private var minY:float;
private var minZ:float;
private var maxX:float;
private var maxY:float;
private var maxZ:float;

function Start () {
	var boundLengthFromOrigin:float = boundingBoxSize/2.0;
	minX=-boundLengthFromOrigin;
	minY=-boundLengthFromOrigin;
	minZ=-boundLengthFromOrigin;
	maxX=boundLengthFromOrigin;
	maxY=boundLengthFromOrigin;
	maxZ=boundLengthFromOrigin;
	SpawnRoids();
}

function Update () {
	//get all the roids
	var roids=GameObject.FindGameObjectsWithTag("asteroid");
	
	//if there are none left, spawn new set based on increasing difficulty
	if (len(roids)==0)
	{
		currentDifficulty+=diffStep;
		SpawnRoids();
	}
		
	//check for out of bounds, and wraparound if needed
	//co-routine to check every .25 / sec
	DoCheckRoids(roids);
		

}

//from http://docs.unity3d.com/Documentation/Manual/Coroutines.html
private function DoCheckRoids(roids : Array) {
	CheckRoids(roids);
	yield WaitForSeconds(.25f);
}

private function CheckRoids(roids : Array) {
	for (var i = 0; i < roids.length; i++)
	{
		var roid:GameObject = roids*;*

```
 if (roid.transform.position.x<minX)*
```
```
 {*
```
```
 	roid.transform.position.x=maxX;*
```
```
 }*
```

 else if (roid.transform.position.x>maxX)*

```
 {*
```
```
 	roid.transform.position.x=minX;*
```
```
 }*
```
```
 if (roid.transform.position.y<minY)*
```
```
 {*
```
```
 	roid.transform.position.y=maxY;*
```
```
 }*
```

 else if (roid.transform.position.y>maxY)*

```
 {*
```
```
 	roid.transform.position.y=minY;*
```
```
 }*
```
```
 if (roid.transform.position.z<minZ)*
```
```
 {*
```
```
 	roid.transform.position.z=maxZ;*
```
```
 }*
```

 else if (roid.transform.position.z>maxZ)*

```
 {*
```
```
 	roid.transform.position.z=minZ;*
```
```
 }*
```
}*
}

private function SpawnRoids() {

//pick a face, pick an XY and plop it there*
_ var numroids:int = Mathf.Round(currentDifficulty*diffMult);_
for(var i=0;i<numroids;i++)*
{*

 var face:int = Mathf.Round(Random.Range(1.0,6.0));*

```
 //u,d,f,b,l,r 1..6*
```

 var offset:float = boundingBoxSize/2.0;*

 var cA:float = Random.Range(0.0,boundingBoxSize) - offset;*

 var cB:float = Random.Range(0.0,boundingBoxSize) - offset;*

```
 var cloneRoid:GameObject;*
```
```
 if (face==1)*
```
```
 {*
```

 	cloneRoid = Instantiate(prefabRoid, Vector3(cA,maxY,cB), Quaternion.identity);*

```
 }*
```
```
 else if (face==2)*
```
```
 {*
```

 	cloneRoid = Instantiate(prefabRoid, Vector3(cA,minY,cB), Quaternion.identity);*

```
 }*
```
```
 else if (face==3)*
```
```
 {*
```

 	cloneRoid = Instantiate(prefabRoid, Vector3(cA,cB,maxZ), Quaternion.identity);*

```
 }*
```
```
 else if (face==4)*
```
```
 {*
```

 	cloneRoid = Instantiate(prefabRoid, Vector3(cA,cB,minZ), Quaternion.identity);*

```
 }*
```
```
 else if (face==5)*
```
```
 {*
```

 	cloneRoid = Instantiate(prefabRoid, Vector3(minX,cA,cB), Quaternion.identity);*

```
 }*
```
```
 else*
```
```
 {*
```

 	cloneRoid = Instantiate(prefabRoid, Vector3(maxX,cA,cB), Quaternion.identity);*

```
 }*
```

 var scaleVal:float =Random.Range(0.3,15);*

_ cloneRoid.transform.localScale *= scaleVal;_

 var cloneRoidAsteroidController =cloneRoid.GetComponent(AsteroidControl);*

_ cloneRoidAsteroidController.roidNormalHealth*=scaleVal;_

} *
}
And this script sits on the asteroid prefab;
#pragma strict

//RigidBody mass is 10000000 (10 million)
var minRotForce:float = -100000000.0;
var maxRotForce:float = 100000000.0;
var minMoveForce:float = -1000000000.0;
var maxMoveForce:float = 1000000000.0;
var roidToRoidSound: AudioClip;
var roidToBulletSound: AudioClip;
var roidDestroyedSound: AudioClip;

var roidNormalHealth:float = 1.0;
var detonatorPrefab:GameObject;
var asteroidPrefab:GameObject; //link to our own prefab

private var iAmAlive:boolean = true;
private var HUDScore:TextMesh;

function Start () {

var force:float=Random.Range(minRotForce,maxRotForce);*
var direction:Vector3=Random.onUnitSphere;*
_ rigidbody.AddTorque(direction*force);_
force=Random.Range(minMoveForce,maxMoveForce);*
direction=Random.onUnitSphere;*
_ rigidbody.AddForce(direction*force);_
var mainCamera:GameObject=GameObject.Find(“ShootingMovingCamera”);*
var scriptHUDManager:HUDManager=mainCamera.GetComponent(HUDManager);*
HUDScore=scriptHUDManager.HUDScoreCloneTextMesh;*
}

function OnCollisionEnter(colInfo : Collision) {
if(iAmAlive){

var colWith:String = colInfo.gameObject.name;*
if (colWith==“Asteroid(Clone)”)*
{*
```
 audio.PlayOneShot(roidToRoidSound);*
```
}*
else if (colWith==“Bullet(Clone)”)*
{*

 	//if transform.scale <1 then destroy else split into two of scale 1/2*

```
 //play explody noise*
```

 audio.PlayOneShot(roidToBulletSound);*

```
 //bullet damage*
```
```
 roidNormalHealth-=1.0;*
```

 //die and spawn smaller roids if required*

```
 if (roidNormalHealth<=0.0)*
```
```
 {*
```
```
 	//stop responding to things*
```
```
 	iAmAlive=false;*
```
```
 	//play boom*
```

 	audio.PlayOneShot(roidDestroyedSound);*

```
 	//Update score*
```

 	HUDScore.text=(parseInt(HUDScore.text)+10).ToString();*

```
 	//Explode*
```

 	Instantiate(detonatorPrefab,transform.position,transform.rotation);*

 	//Split:  spawn 2 smallers, or none if too small*

 	var origScale:Vector3=transform.localScale;*

```
 	Split(origScale);*
```
```
 	//destroy*
```

_ transform.localScale*=0;_

```
 	Destroy(gameObject,3.5);*
```
```
 }*
```
}*
}
}

function Split(origScale:Vector3){

if(origScale>1.0)*
{*
_ var posA:Vector3=transform.position+(Random.onUnitSphereorigScale.magnitude);_
_ var posB:Vector3=transform.position+(Random.onUnitSphereorigScale.magnitude);_
```
 var newScale:Vector3=origScale/3.0;*
```

 var cloneRoidA:GameObject = Instantiate(asteroidPrefab, posA, Quaternion.identity);*

 var cloneRoidB:GameObject = Instantiate(asteroidPrefab, posB, Quaternion.identity);*

_ cloneRoidA.transform.localScale *= newScale.magnitude;_

 var cloneRoidAsteroidController:AsteroidControl=cloneRoidA.GetComponent(AsteroidControl);*

_ cloneRoidAsteroidController.roidNormalHealth*=newScale.magnitude; _

_ cloneRoidB.transform.localScale *= newScale.magnitude;_

 cloneRoidAsteroidController=cloneRoidB.GetComponent(AsteroidControl);*

_ cloneRoidAsteroidController.roidNormalHealth*=newScale.magnitude;_

}*
}
The idea is, where the asteroid has a scale magnitude>1, to spawn two asteroids of scale 1/3 of the original, at a random point around the original asteroid (asteroids currently modelled as spheres…)
the script is on the original asteroid prefab.
asteroidPrefab is a slot on the asteroidControl script on the original prefab that holds a reference to itself, so the script can spawn instances of the original prefab (I tried various things like GetParentPrefab etc… but couldn’t figure out how to get a reference back to the prefab that created this instance)
What I end up spawning are instances called Asteroid(Clone)(Clone) instead of Asteroid(Clone), and the newly spawned roids overlap, dont appear to change in scale, and because they overlap things go bonkers with the oncollisionenter script?
Any hints or tips appreciated!

alienbaby · December 7, 2013, 1:13pm

I figured it out in the end.

I was seeing a host of wierd behaviour, and in the end it turned out to be caused by having the script on the prefab create a script slot that held a reference to it’s own prefab, and spawning from that.

Once I move the spawning code to a dedicated ‘spawner’ and got rid of the reference to the scripts own prefab, everything ‘just worked’

Don’t drag a scripts prefab onto a slot in the same script to create a reference to itself, and then try and spawn copies of yourself from within the script! Wierd stuff happens!