Tutorial 9 : Multiple Waves

In this tutorial we are going to create the class that will handle the creation of our waves, update our waves, and then move the player onto the next wave when the previous one has finished.

This will be one of the most important classes in our game. We are going to store all our waves in one big queue, and just move through them one by one with a short period of time in-between waves so the player has time to breath and make new towers. This class will also determine how many enemies we create per wave, so we can make the waves harder as time progresses.

So, let’s get started, start off by creating a new class called “WaveManager.cs” and add the following fields and properties :

private int numberOfWaves; // How many waves the game will have

private float timeSinceLastWave; // How long since the last wave ended

private Queue<Wave> waves = new Queue<Wave>(); // A queue of all our waves

private Texture2D enemyTexture; // The texture used to draw the enemies

private bool waveFinished = false; // Is the current wave over?

private Level level; // A reference to our level class

public Wave CurrentWave // Get the wave at the front of the queue

{

    get { return waves.Peek(); }

}

public List<Enemy> Enemies // Get a list of the current enemeies

{

    get { return CurrentWave.Enemies; }

}

public int Round // Returns the wave number

{

    get { return CurrentWave.RoundNumber + 1; }

}

As I explained earlier we are going to store our waves in a queue so we can access our waves in the order they were added. Next we are going to add in a constructor for the class :

public WaveManager(Level level, int numberOfWaves, Texture2D enemyTexture)

{

    this.numberOfWaves = numberOfWaves;

    this.enemyTexture = enemyTexture;

    this.level = level;

    for (int i = 0; i < numberOfWaves; i++)

    {

        int initialNumerOfEnemies = 6;

        int numberModifier = (i / 6) + 1;

        Wave wave = new Wave(i, initialNumerOfEnemies * 

            numberModifier, level, enemyTexture);

        waves.Enqueue(wave);

    }

}

This is where we are going to create all of the waves for the game. As you can see we progressively add wave after wave with the use of a for loop. The only interesting part of this method are the first two lines in the for loop.

These two lines alter the number of enemies each wave has, basically what these two lines do is every six waves, six extra enemies are produced. So for example the 1st, 2nd, 3rd, 4th and 5th waves will have 6 enemies, the 6th, 7th, 8th, 9th, 10th and 11th waves will have 12 enemies, and the 12th 13th… wave will have 18 enemies.

Of course the mechanism is extremely boring and in your own games you are probably going to want to add in boss levels, or fast levels etc, but for simplicity, this is all we are going to do.

Now we are going to add a method that will start the next wave :

private void StartNextWave()

{

    if (waves.Count > 0) // If there are still waves left

    {

        waves.Peek().Start(); // Start the next one

        timeSinceLastWave = 0; // Reset timer

        waveFinished = false;

    }

}

Here we just check if there is a wave to start, and if there is we start it, and reset our timer. We need to add a call to this method in our constructor otherwise our waves will never start! At the bottom of the constructor add this :

StartNextWave();

All that is left to do now is to update our waves and then draw them, let’s start by updating them :

public void Update(GameTime gameTime)

{

    CurrentWave.Update(gameTime); // Update the wave

    if (CurrentWave.RoundOver) // Check if it has finished

    {

        waveFinished = true;

    }

    if (waveFinished) // If it has finished

    {

        timeSinceLastWave += (float)gameTime.ElapsedGameTime.TotalSeconds; // Start the timer

    }

    if (timeSinceLastWave > 30.0f) // If 30 seconds has passed

    {

        waves.Dequeue(); // Remove the finished wave

        StartNextWave(); // Start the next wave

    }

}

As you can see there is nothing complicated happening here, we just update the wave we are on, and when it has finished, we wait 30 seconds, and then move onto the next wave. Simples!

Lastly, we just need to add a way to draw our current wave :

public void Draw(SpriteBatch spriteBatch)

{

    CurrentWave.Draw(spriteBatch);

}

And there we have it, an easy way of handling multiple waves! All that’s left to do now is to update “Game1.cs” to use our new WaveManager.

Go to “Game1.cs” and at the top of the class replace where we created our wave with this :

//Wave wave;

WaveManager waveManager;

Then in our LoadContent() method instead of initializing a single wave, initialize our wave manager :

//wave = new Wave(0, 10, level, enemyTexture);

//wave.Start();

waveManager = new WaveManager(level, 24, enemyTexture);

Update our WaveManager in the Update() method and make sure to pass in the list of enemies from our current wave to the player :

protected override void Update(GameTime gameTime)

{

    waveManager.Update(gameTime);

    player.Update(gameTime, waveManager.Enemies);

    base.Update(gameTime);

}

Finally in the draw method, draw our WaveManager instead of the single Wave :

//wave.Draw(spriteBatch);

waveManager.Draw(spriteBatch);

And we are finished, we now have multiple waves!!

Here is the source code for this tutorial.