Flappy Bird in Excel VBA - Using Class Modules

Useful Links

Return to the Flappy Bird in Excel VBA Tutorial index.

Download Flappy Owl Pt8a - Timer Class.

Download Flappy Owl Pt8b - Bird Class.

Introduction

Apart from a couple of event procedures for the button clicks, we've written every line of code in this project in normal modules. In this part of the tutorial we're going to reorganise things by converting some of the existing code into a set of class modules.

Writing a well-designed class module is a great way to encapsulate a set of related procedures in a single unit - after all, classes are what object-oriented programming is all about. The classes we'll create in this part of the tutorial will be quite simple, but it will set us up nicely for creating more complex classes later in the project.

Creating a Timer Class

We're going to start with one of the more common uses of class modules in VBA: encapsulating some Windows API functions to make them easier to use. Start by inserting a class module into the project. You do this in much the same way you insert a normal module:

Right-click anywhere in the project and choose to insert a class module.

Once the module has been created, change its name in the usual way.

Use the Properties window to rename the class module. I've called mine clsTimer.

Now we can start moving code from our normal modules into the class module. We'll start with the Windows API function declarations. It isn't necessary to move these declarations, they'll still work happily if we leave them in the normal module, but it makes sense from an organisational point of view to have all of the code concerning our timer in one place.

Cut the declarations for the SetTimer and KillTimer functions from the modPublicDeclarations module and paste them at the top of the clsTimer module, just below Option Explicit. Once you've done this you can also change the word Public to Private for each of the functions. The end result should look like this:

We can change these declarations to Private because they'll only ever be referenced within the class module. We also need to declare a couple of variables to hold the timer ID and the timer interval. Add these lines just after your function declarations:

Using the letter 'p' at the start of the variable names is a common way to indicate that the variables are private to the class and to distinguish them from their associated properties.

The Initialise Event of a Class

When we start using our timer class, the first thing we want to do is set its interval. Previously we did this by writing our own InitialiseTimer procedure. One of the useful features of class modules is that they have their own built-in initialise event. You can generate the code for this event using the drop down lists at the top of the class module's code window:

Click the drop down list at the top left of the code window and select Class.

This will automatically generate the procedure for the initialise event of the class. It should look like this:

This event is triggered automatically whenever we create a new instance of our timer class.

All we need to do now is add code to the initialise procedure to set the timer interval. Add a line of code so that the entire procedure looks like this:

Creating a Method in a Class Module

We could also add the code to start the timer to the initialise procedure but, for reasons that will become clear later, we're going to create a separate procedure for this. Add the following subroutine to the class module:

A subroutine stored in a class module is technically referred to as a method. It's important that this is a public procedure as we'll need to use our StartTimer method in the main game code later.

The Terminate Event of a Class

Now we have a way to start the timer we also need a way to stop it. We could do this by creating another method but for this example we'll use another event of the class module called Terminate. From the drop down lists at the top of the code page, make sure you've selected Class from the left hand side, then choose Terminate from the right hand side.

Select the Terminate event from the list on the right.

This generates the event procedure which is triggered whenever an instance of our timer class is destroyed. This type of procedure is known as a destructor and we're going to use ours to stop the game timer. Add code to the procedure so that it looks like this:

Creating Properties in a Class Module

The final thing that we're going to add to our timer class is a property which will allow other modules to see and change the timer interval value. It's unlikely that we'll need to change the speed that the game updates but this is a nice way to demonstrate how to write simple property procedures.

Because we want to be able to both change the interval and check what its value is we need to write two separate property procedures. We'll start with the one which lets us change the value. Add the following code to the bottom of the class module:

When we use this property later, whatever value we pass in via the Value parameter will be stored in the pGameTimerInterval variable in the instance of the class.

Now we need to create a procedure that will retrieve the value of the timer interval. Add this code to the bottom of the class module:

Using a Class Module in Other Code

That's it for our simple timer class, now we need to make use of it in our main game code. Head back to the modGameCode module and declare the following variable at the top, just below Option Explicit:

Now we need to create a new instance of the timer class in the InitialiseGame subroutine. Remove the line which says InitialiseTimer and replace it with the line shown below:

This line will automatically trigger the initialise event of the timer class, setting the timer interval to our default value of 50. If we want to do anything with our timer now we simply need to reference our variable and use its methods and properties. For instance, if we wanted to modify the timer interval we could use the property we created earlier:

The GameTimer variable behaves like a reference to any other object in VBA. Type in a full stop after its name to see a list of its methods and propeties.

We don't want to change the timer interval at this point, all we want to do is start the timer. Add a line of code to do this so that the complete subroutine looks like this:

We also need to add code to stop the timer. Go to the TerminateGame subroutine and replace the line which says TerminateTimer with this one:

This line will automatically trigger the terminate event of the timer class, stopping the timer. The complete subroutine should look like this:

We can now remove the original timer module as we don't need it any longer.

Right-click on the module and choose to remove it. Click No on the dialog box which appears as we don't want to export the module before it's deleted.

It's worth quickly testing the game to make sure that it behaves in the same way it did before we added the class module. Head back into Excel and make sure that when you click the Start and Stop buttons the game behaves normally. If not, check the code carefully or just download the working example from the top of the page.

A Quick Note on Auto-Instancing Variables

It's possible to declare the variable for our timer class so that we don't have to decide when to create a new instance. To do this we'd declare the variable like so:

This variable would automatically create a new instance of the timer class when it was required, meaning that we could remove the following line of code completely:

Auto-instancing variables sound like convenient time-savers but there are a couple of small drawbacks which need to be considered. Firstly, there's an (admittedly very small) overhead associated with testing whether an instance of the timer needs to be created (although there is some debate about whether this is really that important). Secondly, we lose the ability to test whether the variable has been set or not. The following logical test will never return True:

As soon as we invoke the GameTimer variable it will automatically be set to an instance of the timer class and so it can never be Nothing.

Again, it's unlikely to make a difference for our particular project but I think we'll all feel better if we retain control over when our object instances are created and destroyed.

Creating the Bird Class

The next job is to convert the module containing all of the bird code into a class module. Start by inserting and renaming another class module:

Insert and rename the module as normal.

We now need to begin the wholesale transfer of code from the original bird module into the new class module. Start by copying all of the variables declared at the top of modBirdCode and pasting them at the top of the class module. For reference, this is what you should see at the top of the class module:

Now create the constructor for the class by choosing the relevant option from the drop down list at the top of the code window:

Choose Class from the drop down list to generate the constructor.

Now return to the modBirdCode module and copy all of the code from within the InitialiseBird subroutine. Return to the class module and paste all of the code into the constructor. The end result should look like this:

The next step is to copy the five remaining subroutines from the modBirdCode module and paste them into the class module. For reference these subroutines are called UpdateBird, DrawBird, Flap, Dive and CheckKeys. Once you've pasted them, change the name of the UpdateBird and DrawBird subroutines to Update and Draw respectively.

We don't need to create any properties for the bird class yet so head back to the modGameCode module and add a variable declaration to the top of the module:

Now, in the InitialiseGame subroutine, change the line which says InitialiseBird with the following code:

Next, in the UpdateAndDrawGame subroutine, change the two lines which say UpdateBird and DrawBird with calls to the relevant methods from the bird class. We'll also update what happens if the user presses the TAB key to exit the game. The final subroutine should look like this:

We could also add code which disposes of the instance of the bird class when the game ends. In the TerminateGame subroutine add a line which does this after the line which ends the timer. The final result should look like this:

We didn't create a destructor for the bird class, so doing this won't trigger any code to run. As described earlier on this page, the additional line will simply release the reference to the object and free up any resources that it was using.

We can now delete the original modBirdCode module as it's no longer needed:

Right-click on the module and choose to remove it. Click No on the dialog box which appears.

All that we need to do now is test the game to ensure that it still behaves as expected. If it doesn't then check your code carefully or just download the working example from the top of this page.

What's Next?

At this stage it probably feels like we've made a lot of effort for not much reward but, as the rest of the game is going to be built on classes, it was important to do this now. In the next part of the tutorial we're going to continue this theme by creating a game class and upgrade our simple test worksheet at the same time.