Introduction to Game Design, Prototyping, and Development (2015)

A Generic Dictionary for WeaponDefinitions

Now, open the Main script in MonoDevelop and enter the following bold code. This code uses a Dictionary, which is another type of generic collection like List. Dictionaries have a key type and value type, and the key is used to retrieve the value. Here, the Dictionary has the enumWeaponType as the key and the class WeaponDefinition as the value. We will create the static public W_DEFS dictionary to hold the WeaponDefinition information that we just entered into the array in the Main (Script) Inspector. Unfortunately, Dictionaries do not appear in the Inspector, or we would have just used one from the start. Instead, the W_DEFS Dictionary is defined in the Awake() method of Main and then used by the static function Main.GetWeaponDefinition().

public class Main : MonoBehaviour {
static public Main S;
static public Dictionary<WeaponType, WeaponDefinition> W_DEFS;
...
void Awake() {
...
Invoke( "SpawnEnemy", enemySpawnRate );

// A generic Dictionary with WeaponType as the key
W_DEFS = new Dictionary<WeaponType, WeaponDefinition>();
foreach( WeaponDefinition def in weaponDefinitions ) {
W_DEFS[def.type] = def;
}
}

static public WeaponDefinition GetWeaponDefinition( WeaponType wt ) {
// Check to make sure that the key exists in the Dictionary
// Attempting to retrieve a key that didn't exist, would throw an error,
// so the following if statement is important.
if (W_DEFS.ContainsKey(wt)) {
return( W_DEFS[wt]);
}
// This will return a definition for WeaponType.none,
// which means it has failed to find the WeaponDefinition
return( new WeaponDefinition() );
}

void Start() {...}
}

Now, open the Projectile class in MonoDevelop and enter this code:

using UnityEngine;
using System.Collections;

public class Projectile : MonoBehaviour {
[SerializeField)
private WeaponType _type;

// This public property masks the field _type & takes action when it is set
public WeaponType type {
get {
return( _type );
}
set {
SetType( value );
}
}

void Awake() {
// Test to see whether this has passed off screen every 2 seconds
InvokeRepeating( "CheckOffscreen", 2f, 2f );
}

public void SetType( WeaponType eType ) {
// Set the _type
_type = eType;
WeaponDefinition def = Main.GetWeaponDefinition( _type );
renderer.material.color = def.projectileColor;
}

void CheckOffscreen() {
if ( Utils.ScreenBoundsCheck( collider.bounds, BoundsTest.offScreen ) != Vector3.zero ) {
Destroy( this.gameObject );
}
}

}

Whenever the type property of this Projectile is set, SetType() will be called, and the Projectile will automatically set its own color based on the WeaponDefinitions in Main.

Using a Function Delegate to Fire

Before continuing, read the “Function Delegates” section of Appendix B.

In this game prototype, the Hero class will have a function delegate fireDelegate that is called to fire all weapons, and each Weapon attached to it will add its individual Fire() target method to fireDelegate.

Add the following bold code to the Hero class:

public class Hero : MonoBehaviour {
...
public Bounds bounds;

// Declare a new delegate type WeaponFireDelegate
public delegate void WeaponFireDelegate();
// Create a WeaponFireDelegate field named fireDelegate.
public WeaponFireDelegate fireDelegate;

void Awake() {
...
}

void Update () {
...
// Rotate the ship to make it feel more dynamic
transform.rotation = Quaternion.Euler(yAxis*pitchMult,xAxis*rollMult,0);

// Use the fireDelegate to fire Weapons
// First, make sure the Axis("Jump") button is pressed
// Then ensure that fireDelegate isn't null to avoid an error
if (Input.GetAxis("Jump") == 1 && fireDelegate != null) { // 1
fireDelegate();
}
}
...
}

1. If fireDelegate is called when it has no methods assigned to it, it will throw an error. To avoid this, fireDelegate != null is tested to see whether it is null before calling it.

Open the Weapon C# script in MonoDevelop and add the following code:

public class Weapon : MonoBehaviour {
static public Transform PROJECTILE_ANCHOR;

public bool ____________________;
[SerializeField]
private WeaponType _type = WeaponType.none;
public WeaponDefinition def;
public GameObject collar;
public float lastShot; // Time last shot was fired

void Start() {
collar = transform.Find("Collar").gameObject;
// Call SetType() properly for the default _type
SetType( _type );

if (PROJECTILE_ANCHOR == null) {
GameObject go = new GameObject("_Projectile_Anchor");
PROJECTILE_ANCHOR = go.transform;
}
// Find the fireDelegate of the parent
GameObject parentGO = transform.parent.gameObject;
if (parentGO.tag == "Hero") {
Hero.S.fireDelegate += Fire;
}
}

public WeaponType type {
get { return( _type ); }
set { SetType( value ); }
}

public void SetType( WeaponType wt ) {
_type = wt;
if (type == WeaponType.none) {
this.gameObject.SetActive(false);
return;
} else {
this.gameObject.SetActive(true);
}
def = Main.GetWeaponDefinition(_type);
collar.renderer.material.color = def.color;
lastShot = 0; // You can always fire immediately after _type is set.
}

public void Fire() {
// If this.gameObject is inactive, return
if (!gameObject.activeInHierarchy) return;
// If it hasn't been enough time between shots, return
if (Time.time - lastShot < def.delayBetweenShots) {
return;
}
Projectile p;
switch (type) {
case WeaponType.blaster:
p = MakeProjectile();
p.rigidbody.velocity = Vector3.up * def.velocity;
break;

case WeaponType.spread:
p = MakeProjectile();
p.rigidbody.velocity = Vector3.up * def.velocity;
p = MakeProjectile();
p.rigidbody.velocity = new Vector3( -.2f, 0.9f, 0 ) * def.velocity;
p = MakeProjectile();
p.rigidbody.velocity = new Vector3( .2f, 0.9f, 0 ) * def.velocity;
break;

}
}

public Projectile MakeProjectile() {
GameObject go = Instantiate( def.projectilePrefab ) as GameObject;
if ( transform.parent.gameObject.tag == "Hero" ) {
go.tag = "ProjectileHero";
go.layer = LayerMask.NameToLayer("ProjectileHero");
} else {
go.tag = "ProjectileEnemy";
go.layer = LayerMask.NameToLayer("ProjectileEnemy");
}
go.transform.position = collar.transform.position;
go.transform.parent = PROJECTILE_ANCHOR;
Projectile p = go.GetComponent<Projectile>();
p.type = type;
lastShot = Time.time;
return( p );

}
}

Most of this code should make sense to you. Note that the various kinds of projectiles and weapons are handled with a switch statement inside of the Fire() method.

Now, it’s important to make projectiles actually damage enemies. Open the Enemy C# script in MonoDevelop and add the following OnCollisionEnter() method:

public class Enemy : MonoBehaviour {
...
void CheckOffscreen() {
...
}

void OnCollisionEnter( Collision coll ) {
GameObject other = coll.gameObject;
switch (other.tag) {
case "ProjectileHero":
Projectile p = other.GetComponent<Projectile>();
// Enemies don't take damage unless they're onscreen
// This stops the player from shooting them before they are visible
bounds.center = transform.position + boundsCenterOffset;
if (bounds.extents == Vector3.zero || Utils.ScreenBoundsCheck(bounds, BoundsTest.offScreen) != Vector3.zero) {
Destroy(other);
break;
}
// Hurt this Enemy
// Get the damage amount from the Projectile.type & Main.W_DEFS
health -= Main.W_DEFS[p.type].damageOnHit;
if (health <= 0) {
// Destroy this Enemy
Destroy(this.gameObject);
}
Destroy(other);
break;
}
}
}

Now when you play the scene, it is possible to destroy an Enemy, but each one takes 10 shots to take down, and it’s difficult to tell that they’re being damaged. We will add code that makes an Enemy blink red for a couple of frames every time it is hit, but to do so, we’re going to need to have access to all the materials of all the children of each Enemy. This sounds like something that may be useful in later prototypes, so we will add it to the Utils script. Open the Utils script in MonoDevelop and add the following static method to achieve this:

public class Utils : MonoBehaviour {

//============================ Bounds Functions ==============================\\
...

//============================ Transform Functions ===========================\\

...
public static GameObject FindTaggedParent(Transform t) {
return( FindTaggedParent( t.gameObject ) );
}

}


//=========================== Materials Functions ============================\\

// Returns a list of all Materials on this GameObject or its children
static public Material[] GetAllMaterials( GameObject go ) {
List<Material> mats = new List<Material>();
if (go.renderer != null) {
mats.Add(go.renderer.material);
}
foreach( Transform t in go.transform ) {
mats.AddRange( GetAllMaterials( t.gameObject ) );
}
return( mats.ToArray() );
}
}

Now, add the following bold code to the Enemy class:

public class Enemy : MonoBehaviour {
...
public int score = 100; // Points earned for destroying this

public int showDamageForFrames = 2; // # frames to show damage

public bool ________________;

public Color[] originalColors;
public Material[] materials;// All the Materials of this & its children
public int remainingDamageFrames = 0; // Damage frames left

public Bounds bounds; // The Bounds of this and its children


void Awake() {
materials = Utils.GetAllMaterials( gameObject );
originalColors = new Color[materials.Length];
for (int i=0; i<materials.Length; i++) {
originalColors[i] = materials[i].color;
}
InvokeRepeating( "CheckOffscreen", 0f, 2f );
}

// Update is called once per frame
void Update() {
Move();
if (remainingDamageFrames>0) {
remainingDamageFrames--;
if (remainingDamageFrames == 0) {
UnShowDamage();
}
}
}

void OnCollisionEnter( Collision coll ) {
GameObject other = coll.gameObject;
switch (other.tag) {
case "ProjectileHero":
...
// Hurt this Enemy
ShowDamage();
// Get the damage amount from the Projectile.type & Main.W_DEFS
...
break;
}
}

void ShowDamage() {
foreach (Material m in materials) {
m.color = Color.red;
}
remainingDamageFrames = showDamageForFrames;
}
void UnShowDamage() {
for ( int i=0; i<materials.Length; i++ ) {
materials[i].color = originalColors[i];
}
}

}

Now, when an Enemy is struck by a projectile from the _Hero, it will turn entirely red for showDamageForFrames frames by setting the color of all materials to red and setting remainingDamageFrames to showDamageForFrames. Each update, if remainingDamageFramesis greater than 0, it is decremented until it reaches 0, at which time, the enemy ship and children revert to their original colors.

Now it’s possible to see that the player is damaging the ship, but it still takes many hits to destroy one. Let’s make some power-ups that will increase the power and number of the player’s weapons.

Adding Power-Ups

At this point, there will be three power-ups in the game:

blaster [B]: If the player weapon type is not blaster, switches to blaster and resets to 1 gun. If the player weapon type is already blaster, increases the number of guns.

spread [S]: If the player weapon type is not spread, switches to spread and resets to 1 gun. If the player weapon type is already spread, increases the number of guns.

shield [O]: Increases the player’s shieldLevel by 1.

Artwork for Power-Ups

The power-ups will be made of a letter rendered as 3D text with a spinning cube behind it. (You can see some of them in Figure 30.1 at the beginning of the chapter.) To make the power-ups, complete these steps:

1. Create a new 3D text (GameObject > Create Other > 3D Text from the menu bar). Name it PowerUp and give it the following settings:

2. Create a cube that is a child of PowerUp as described in the preceding settings.

3. Select the PowerUp.

4. Set the Text Mesh component properties of PowerUp to those shown in Figure 30.12.

5. Add a Rigidbody component to PowerUp (Component > Physics > Rigidbody) and set it as shown in Figure 30.12.

6. Set both the tag and the layer of PowerUp to PowerUp. When asked, click Yes, change children.

Next, you will create a custom material for the PowerUp cube, as follows:

1. Create a new Material named Mat PowerUp.

2. Drag it on to the cube that is a child of PowerUp.

3. Select the cube that is a child of PowerUp.

4. Set the Shader of Mat PowerUp to ProtoTools > UnlitAlpha.

5. Click the Select button at the bottom right of the texture for Mat PowerUp and choose the texture named PowerUp from the Assets tab.

6. Set the main color of Mat PowerUp to cyan (a light blue that is RGBA:[ 0,255,255,255 ]), and you can see how the PowerUp will look when colored.

7. Set the Box Collider of cube to be a trigger (check the box next to Is Trigger).

Double-check that all the settings for PowerUp and its child Cube match those in Figure 30.12 and save your scene.

Figure 30.12 Settings for PowerUp and its child Cube prior to attaching any scripts

PowerUp Code

Now create a new C# script named PowerUp and assign it to the PowerUp GameObject in the Hierarchy. Open the PowerUp script in MonoDevelop and enter the following code:

using UnityEngine;
using System.Collections;

public class PowerUp : MonoBehaviour {
// This is an unusual but handy use of Vector2s. x holds a min value
// and y a max value for a Random.Range() that will be called later
public Vector2 rotMinMax = new Vector2(15,90);
public Vector2 driftMinMax = new Vector2(.25f,2);
public float lifeTime = 6f; // Seconds the PowerUp exists
public float fadeTime = 4f; // Seconds it will then fade
public bool ________________;
public WeaponType type; // The type of the PowerUp
public GameObject cube; // Reference to the Cube child
public TextMesh letter; // Reference to the TextMesh
public Vector3 rotPerSecond; // Euler rotation speed
public float birthTime;

void Awake() {
// Find the Cube reference
cube = transform.Find("Cube").gameObject;
// Find the TextMesh
letter = GetComponent<TextMesh>();

// Set a random velocity
Vector3 vel = Random.onUnitSphere; // Get Random XYZ velocity
// Random.onUnitSphere gives you a vector point that is somewhere on
// the surface of the sphere with a radius of 1m around the origin
vel.z = 0; // Flatten the vel to the XY plane
vel.Normalize(); // Make the length of the vel 1
// Normalizing a Vector3 makes it length 1m
vel *= Random.Range(driftMinMax.x, driftMinMax.y);
// Above sets the velocity length to something between the x and y
// values of driftMinMax
rigidbody.velocity = vel;

// Set the rotation of this GameObject to R:[0,0,0]
transform.rotation = Quaternion.identity;
// Quaternion.identity is equal to no rotation.

// Set up the rotPerSecond for the Cube child using rotMinMax x & y
rotPerSecond = new Vector3( Random.Range(rotMinMax.x,rotMinMax.y),
Random.Range(rotMinMax.x,rotMinMax.y),
Random.Range(rotMinMax.x,rotMinMax.y) );

// CheckOffscreen() every 2 seconds
InvokeRepeating( "CheckOffscreen", 2f, 2f );

birthTime = Time.time;
}

void Update () {
// Manually rotate the Cube child every Update()
// Multiplying it by Time.time causes the rotation to be time-based
cube.transform.rotation = Quaternion.Euler( rotPerSecond*Time.time );

// Fade out the PowerUp over time
// Given the default values, a PowerUp will exist for 10 seconds
// and then fade out over 4 seconds.
float u = (Time.time - (birthTime+lifeTime)) / fadeTime;
// For lifeTime seconds, u will be <= 0. Then it will transition to 1
// over fadeTime seconds.
// If u >= 1, destroy this PowerUp
if (u >= 1) {
Destroy( this.gameObject );
return;
}
// Use u to determine the alpha value of the Cube & Letter
if (u>0) {
Color c = cube.renderer.material.color;
c.a = 1f-u;
cube.renderer.material.color = c;
// Fade the Letter too, just not as much
c = letter.color;
c.a = 1f - (u*0.5f);
letter.color = c;
}
}

// This SetType() differs from those on Weapon and Projectile
public void SetType( WeaponType wt ) {
// Grab the WeaponDefinition from Main
WeaponDefinition def = Main.GetWeaponDefinition( wt );
// Set the color of the Cube child
cube.renderer.material.color = def.color;
//letter.color = def.color; // We could colorize the letter too
letter.text = def.letter; // Set the letter that is shown
type = wt; // Finally actually set the type
}

public void AbsorbedBy( GameObject target ) {
// This function is called by the Hero class when a PowerUp is collected
// We could tween into the target and shrink in size,
// but for now, just destroy this.gameObject
Destroy( this.gameObject );
}

void CheckOffscreen() {
// If the PowerUp has drifted entirely off screen...
if ( Utils.ScreenBoundsCheck( cube.collider.bounds, BoundsTest.offScreen) != Vector3.zero ) {
// ...then destroy this GameObject
Destroy( this.gameObject );
}
}
}

When you press Play, you should see the power-up drifting and rotating. If you fly _Hero into the power-up, you will get the console message “Triggered: Cube,” letting you know that the Trigger Collider on the PowerUp cube is working properly.

Drag the PowerUp GameObject from the Hierarchy into the _Prefabs folder in the Project pane to make it into a prefab. Delete the remaining PowerUp instance from the Hierarchy.

Now, make the following changes to the Hero C# script to enable the Hero to collide with and collect power-ups:

public class Hero : MonoBehaviour {
...
private float _shieldLevel = 1;

// Weapon fields
public Weapon[] weapons;

public bool ____________________________;

void Awake() {
S = this; // Set the Singleton
bounds = Utils.CombineBoundsOfChildren(this.gameObject);

// Reset the weapons to start _Hero with 1 blaster
ClearWeapons();
weapons[0].SetType(WeaponType.blaster);
}

void OnTriggerEnter(Collider other) {
...
if (go != null) {
...

if (go.tag == "Enemy") {
// If the shield was triggered by an enemy
// Decrease the level of the shield by 1
shieldLevel--;
// Destroy the enemy
Destroy(go);
} else if (go.tag == "PowerUp") {
// If the shield was triggerd by a PowerUp
AbsorbPowerUp(go);
} else {
print("Triggered: "+go.name); // Move this line here!
}
}
...
}

public void AbsorbPowerUp( GameObject go ) {
PowerUp pu = go.GetComponent<PowerUp>();
switch (pu.type) {
case WeaponType.shield: // If it's the shield
shieldLevel++;
break;

default: // If it's any Weapon PowerUp
// Check the current weapon type
if (pu.type == weapons[0].type) {
// then increase the number of weapons of this type
Weapon w = GetEmptyWeaponSlot(); // Find an available weapon
if (w != null) {
// Set it to pu.type
w.SetType(pu.type);
}
} else {
// If this is a different weapon
ClearWeapons();
weapons[0].SetType(pu.type);
}
break;
}
pu.AbsorbedBy( this.gameObject );
}

Weapon GetEmptyWeaponSlot() {
for (int i=0; i<weapons.Length; i++) {
if ( weapons[i].type == WeaponType.none ) {
return( weapons[i] );
}
}
return( null );
}

void ClearWeapons() {
foreach (Weapon w in weapons) {
w.SetType(WeaponType.none);
}
}

}

Now that the code is set up, you need to make a couple of changes to _Hero in Unity. Open the disclosure triangle next to the GameObject _Hero in the Hierarchy. Select the Weapon child of _Hero. Press Command-D (or Control+D on Windows) four times to make four duplicates of Weapon. These should all still be children of _Hero. Rename the five weapons Weapon_0 through Weapon_4 and configure their transforms as follows:

Next, select _Hero and open the disclosure triangle for the weapons field in the Hero (Script) component Inspector. Set the Size of weapons to 5 and assign Weapon_0 through Weapon_4 to the five Weapon slots in order (either by dragging them in from the Hierarchy or by clicking the target to the right of the Weapon slot and selecting each Weapon_# from the Scene tab). Figure 30.13 shows the final setup.

Figure 30.13 The _Hero ship showing five Weapons as children and assigned to the weapons field

Resolving Race Conditions in Code

Now, when you try to play the scene as we’ve created it, you may encounter an error message in the Console pane. It’s also possible that you will not get this error. In this code, I’ve tried to intentionally create a race condition to show you how to resolve them. A race condition occurs when one piece of code must be executed before another piece of code, but it’s possible that they will execute in the wrong order. The two pieces of code end up racing against each other. The thing about race conditions is that they’re unpredictable, so you might not get the error that I tried to create. Regardless, please read this section. Race conditions are an important kind of error that you should understand. The error you may encounter is as follows:

NullReferenceException: Object reference not set to an instance of an object Main.GetWeaponDefinition (WeaponType wt) (at Assets/__Scripts/Main.cs:38) Weapon.SetType (WeaponType wt) (at Assets/__Scripts/Weapon.cs:77) Hero.Awake () (at Assets/__Scripts/Hero.cs:35)

If you double-click the error message, it should take you to line 38 of Main.cs. (Your line number might differ slightly.) Line 38 is:

if (W_DEFS.ContainsKey(wt)) {

Let’s use the debugger to learn more about what’s causing the error. (Please do this even if you’re not getting the error.) Add a breakpoint next to this line in Main.cs and attach the debugger to Unity (by clicking the Play icon in the top-left corner of the MonoDevelop window or selecting Run > Attach to Process from the MonoDevelop menu bar). If you need a refresher on the debugger, reread Chapter 24. Unfortunately, in this case, you will need to have the debugger attached when the scene first starts playing, so the trick described in Chapter 24 where you start the game paused and then attach the debugger later won’t work for these bugs.

When you run the project (in Unity) with the debugger attached, it will freeze on your line 38 breakpoint immediately before executing that line. We know that something’s wrong with this line, and as a NullReferenceException, we know that the code is trying to access some variable that isn’t yet defined. Let’s look at each variable and see what’s happening.

1. Open the Watch panel in MonoDevelop ( View > Debug Windows > Watch from the menu bar; there should be already a check mark next to it, and selecting it again will bring the Watch panel to the front).

2. The two variables used in this line are W_DEFS (a static variable of the Main class) and wt (a local variable of the method GetWeaponDefinition()).

3. Type each of these into a line of the Watch window, and you’ll be able to see their individual values.

4. As expected, W_DEFS isn’t defined (its value is null). (That is, if you’re experiencing the race condition error on your machine.) But we know that W_DEFS is properly defined in Main.Awake(). You can see the code that does so just a few lines above. The only way that W_DEFScould not be defined is if Main.Awake() hasn’t run yet.

This is the race condition. Main.Awake() defines W_DEF, and Hero.Awake() is trying to use that value. We know that Awake() is called on each GameObject as it comes into being, but it is unclear in what order they are called. I believe that it probably happens in the order that the objects are listed in the Hierarchy, but I’m not certain of that. It’s possible that your Awake() methods may be called in a different order than mine.

This is the major problem with race conditions. The two Awake() functions are racing against each other. When one is called first, your code works fine, but when the other is called first, everything breaks. Regardless of whether your code happens to be working, this is an issue that you need to resolve, because even on the same computer, the two Awake() functions could be called in different orders from one time to the next..

This is one reason that there are both Awake() and Start() methods in Unity. Awake() is called immediately when a GameObject is instantiated, while Start() is called immediately before the first Update() that the GameObject ever receives. This can be a difference of several milliseconds, which for a computer program is a very long time. If you have a number of objects in your scene, you can be guaranteed that Awake() will be called on all of them before Start() is called on any of them. Awake() will always happen before Start().

Knowing this, take a look back at the original error. If you look at the Call Stack pane in MonoDevelop (View > Debug Windows > Call Stack from the menu bar), it looks like Hero.Awake() on line 35 called Weapon.SetType(), which in turn calledMain.GetWeaponDefinition(). To start fixing this issue, we will choose to delay the call from Hero.Awake() by moving it into Hero.Start(). Make the following changes to the Hero C# script. You should click the Stop sign in the MonoDevelop debugger (or select Run > Stop from the menu bar) as well as stop playback in Unity before changing the Hero script code:

public class Hero : MonoBehaviour {
...

void Awake() {
S = this; // Set the Singleton
bounds = Utils.CombineBoundsOfChildren(this.gameObject);
}

void Start() {
// Reset the weapons to start _Hero with 1 blaster
ClearWeapons();
weapons[0].SetType(WeaponType.blaster);
}

...
}

However after doing so, playing the project will expose yet another race condition error!

UnassignedReferenceException: The variable collar of Weapon has not been assigned. You probably need to assign the collar variable of the Weapon script in the Inspector. Weapon.SetType (WeaponType wt) (at Assets/__Scripts/Weapon.cs:78) Hero.Start () (at Assets/__Scripts/Hero.cs:38)

Attach the MonoDevelop debugger to the Unity process again to get more information on this error. Place a breakpoint on line 78 of Weapon.cs and then press Play in Unity. Because the Start() functions are called at different times, I sometimes saw the code first stop on line 38 of Hero.cs (where the breakpoint still remains from the previous debug) and sometimes saw it first stop on line 78 of Weapon. This is happening because both Hero.Start() and Weapon.Start() call Weapon.SetType(). If Weapon.Start() happens to be called before Hero.Start(), this is fine, but if Hero.Start() is called first, we get an error due to the race condition. The issue here is that all Weapons need to define Weapon.collar before Hero.Start() is run. To resolve this, move the definition of collar from the Start() method to an Awake() method in the the Weapon C# script.

void Awake() {
collar = transform.Find("Collar").gameObject;
}

void Start() {
// Call SetType() properly for the default _type
SetType( _type );

...
}

Now, the race conditions should finally be resolved. Weapon.Awake() will define collar before either Weapon.Start() or Hero.Start() are called. Also, Main.Awake() will set the value of Main.W_DEFS before Hero.Start() is called. Race conditions are a common error for new game developers to step into, and it’s important to be able to recognize when you may be encountering one. This is why I have lead you into this one and shown you how to discover and resolve the problem.

Making Enemies Drop Power-Ups

Getting back to the power-ups. Let’s make enemies have the potential to drop a random power-up when they are destroyed. This gives the player a lot more incentive to try to destroy enemies rather than just avoid them, and it gives the player a path to improving her ship.

Add the following code to the Enemy and Main C# scripts:

public class Enemy : MonoBehaviour {
...
public int showDamageForFrames = 2; // # frames to show damage
public float powerUpDropChance = 1f; // Chance to drop a power-up

public bool ________________;
...
void OnCollisionEnter( Collision coll ) {
...
case "ProjectileHero":
...
if (health <= 0) {
// Tell the Main singleton that this ship has been destroyed
Main.S.ShipDestroyed( this );
// Destroy this Enemy
Destroy(this.gameObject);
}
...
}
}
...
}


public class Main : MonoBehaviour {
...
public WeaponDefinition[] weaponDefinitions;
public GameObject prefabPowerUp;
public WeaponType[] powerUpFrequency = new WeaponType[] {
WeaponType.blaster, WeaponType.blaster,
WeaponType.spread,
WeaponType.shield };

public bool ________________;
...

public void ShipDestroyed( Enemy e ) {
// Potentially generate a PowerUp
if (Random.value <= e.powerUpDropChance) {
// Random.value generates a value between 0 & 1 (though never == 1)
// If the e.powerUpDropChance is 0.50f, a PowerUp will be generated
// 50% of the time. For testing, it's now set to 1f.

// Choose which PowerUp to pick
// Pick one from the possibilities in powerUpFrequency
int ndx = Random.Range(0,powerUpFrequency.Length);
WeaponType puType = powerUpFrequency[ndx];

// Spawn a PowerUp
GameObject go = Instantiate( prefabPowerUp ) as GameObject;
PowerUp pu = go.GetComponent<PowerUp>();
// Set it to the proper WeaponType
pu.SetType( puType );

// Set it to the position of the destroyed ship
pu.transform.position = e.transform.position;
}
}

}

Before this code will work, you need to select _MainCamera in the Unity Hierarchy and set the prefabPowerUp field of the Main Script component to be the PowerUp prefab in the _Prefabs folder of the Project pane. powerUpFrequency should already be set in the Inspector, but just in case, Figure 30.14 shows the correct settings. Note that enums appear in the Unity Inspector as pop-up menus.

Figure 30.14 prefabPowerUp and powerUpFrequency on the Main (Script) component of _MainCamera

Now play the scene and destroy some enemies. They should drop power-ups that will now improve your ship!

You should notice over time that the blaster [B] power-up is more common than spread [S] or shield [O]. This is because there are two occurrences of blaster in powerUpFrequency and only one each of spread and shield. By adjusting the relative numbers of occurrences of each of these in powerUpFrequency, you can determine the chance that each will be chosen relative to the others. This same trick could also be used to set the frequency of different types of enemies spawning by assigning some enemies to the prefabEnemies array more times than other enemy types.

Programming Other Enemies

Now that the core elements of the game are each working, it’s time to expand the different offerings of enemies. Create new C# scripts named Enemy_1, Enemy_2, Enemy_3, and Enemy_4 and assign them each to their respective Enemy_# prefab in the Project pane.

Enemy_1

Open Enemy_1 scripts in MonoDevelop and enter the following code:

using UnityEngine;
using System.Collections;

// Enemy_1 extends the Enemy class
public class Enemy_1 : Enemy {
// Because Enemy_1 extends Enemy, the _____ bool won't work // 1
// the same way in the Inspector pane. :/

// # seconds for a full sine wave
public float waveFrequency = 2;
// sine wave width in meters
public float waveWidth = 4;
public float waveRotY = 45;

private float x0 = -12345; // The initial x value of pos
private float birthTime;

void Start() {
// Set x0 to the initial x position of Enemy_1
// This works fine because the position will have already
// been set by Main.SpawnEnemy() before Start() runs
// (though Awake() would have been too early!).
// This is also good because there is no Start() method
// on Enemy.
x0 = pos.x;

birthTime = Time.time;
}

// Override the Move function on Enemy
public override void Move() { // 2
// Because pos is a property, you can't directly set pos.x
// so get the pos as an editable Vector3
Vector3 tempPos = pos;
// theta adjusts based on time
float age = Time.time - birthTime;
float theta = Mathf.PI * 2 * age / waveFrequency;
float sin = Mathf.Sin(theta);
tempPos.x = x0 + waveWidth * sin;
pos = tempPos;

// rotate a bit about y
Vector3 rot = new Vector3(0, sin*waveRotY, 0);
this.transform.rotation = Quaternion.Euler(rot);

// base.Move() still handles the movement down in y
base.Move(); // 3
}

}

1. The bool ________________ that is used to divide the elements you should set in the Inspector from those you should not won’t work that way in these subclasses of Enemy because when the Inspector sees a subclass like this, it will first list all the public fields of the superclass and then all the public fields of the subclass. This will place waveFrequency, waveWidth, and waveRotY below the line, even though you should feel free to manipulate them in the Inspector.

2. Because the method Move() is marked as a virtual method in the Enemy superclass, we are able to override it here and replace it with another function.

3. base.Move() calls the Move() function on the superclass Enemy.

Back in Unity, select _MainCamera in the Hierarchy and change Element 0 of prefabEnemies from Enemy_0 to Enemy_1 (which is the Enemy_1 prefab in the Project pane) in the Main (Script) component. Now, when you press Play, the Enemy_1 ship will appear instead of Enemy_0, and it will move in a wave.