Many of you have been waiting patiently for this post, and let me say that I have worked many hours to get this where it is today. I wanted to get my code to the point where it was solid enough that I would actually publish something with it, and I believe it is there. Thanks to those who have encouraged me to finish this post, and I look forward to seeing how it is used!

In introduction, let me say a few things about this post: first, I have tried to alter my scope slightly in order to be more accessible to readers who may not have access to a full licensed copy of Flash. So, to help with that and make these lessons more accessible, I have decided to write them in such a way as to be compiled by the Flex SDK, a fully open source framework to allow anyone to build robust Flash applications. I prefer to use the full Flex Developer 3 for development and release, but even without it, you can compile full AS3 or Flex applications using only the SDK from the command line. One other major benefit to doing my development with Flex Builder is the ability to publish my source code for all to view online as well as download.

Obviously, this opens up the accessibility to a much broader range of individuals looking to learn Actionscript 3 or Flex. So, all this to say that the code in this post, while doing practically the same thing as the previous posts (and keeping the majority of the same logic), cleans up a ton of structural issues to lend itself more cleanly towards a completed project. That being said, we are simply focusing on the Tower object itself this time. I will leave it to your imagination and time to read through the rest of the cleaned – and fully documented, I might add – code. I may find time to write some more generalized posts on the Flex framework itself in days to come, but for now, suffice to say that the main file that is compiled as the application (in our case, called “MagicTD.as”) will be instantiated as the main() function and will serve as our entire platform base. You will notice on line 12 of this file all the variables needed to set up our SWF with the desired dimensions, background color and framerate.

So, without further ado, let’s jump right into our Tower class.

The Tower Class

Click on the circles in the top right to build three different types of towers.

Many of you have been waiting for an extended length of time for this post, so I hope it does not disappoint. There are so many things to touch on, I will most likely only scratch the surface of the underlying logic and leave the bulk of the understanding for your reading of the code. There are some very significant issues I do want to touch on and overview, though, mainly because I have restructured the handling of some of the movie clips (or Sprites, as the case may be). First off, you will notice that our MagicTD class (base application) houses and manages all the different MovieClip Objects and Sprites itself. This allows for very precise control of the layering of all our objects. So, be sure to take a moment and familiarize yourself with the structure of the class before you proceed any further, or you may find yourself at a loss.

One other thing of which you may need to be aware is the effect of bubbling in handling events in AS3. I have taken advantage of bubbling controls to set up click event handlers for the individual elements (both Creeps and Towers). If you click anywhere else on the SWF, the general MagicTD::clearSelections() method is used as a failsafe. Go ahead, click on Creeps to see their health, and click on Towers to see their range. You can easily add custom click events or additional functionality than I currently have in there by modifying those handlers within each object.

As we look at the Tower class, you should first familiarize yourself with the member variables and what they will do:

• game :MagicTD – A reference to the base game itself. This is what we will use to acquire our targets.
• timer :Timer – A timer to execute our fire() method based upon the fire rate of this tower
• type :String – A literal descriptive term for the type of tower created (used to distinguish between base tower objects and children)
• power :int – The base strength of this tower’s shots (without modifiers)
• range :int – The range at which this tower can see and shoot at a target
• rate :int – The fire rate of this tower (shots per second)
• level :int – The current tower level (not used in this lesson)
• is_set :Boolean – Whether or not this tower has been set to the map (not used in this lesson)
• rangeMC :Sprite – The holder for the range Sprite
• towerMC :Sprite – The holder for the tower Sprite.

Keep in mind this is just for the base Tower class. Within the constructor, you can see that we set default values for these variables if they are not set by a child constructor first. So, when you look at the code base, you will notice a FireTower and IceTower class that each extend and alter some of the default values for these variables, and that causes the difference in behavior of the tower types: simple as that. Were we to be using animations or images for our bullets, this is also where we would override the bullet creation within each child class.

Now for a quick summary of how our Towers and Bullets are behaving. First, the towers themselves simply are on a timer set to fire x number of times per second. When the timer triggers, we call the base MagicTD::fire() method, passing in this Tower object as the parameter. This is because each tower is then handled identically, and it is up to the getNewBullet() method of the Tower to determine the differences between them. You will see this clearly by examining the fire() method of the base MagicTD class (fired whenever a timer event is triggered within a tower):

public function fire(t :Tower) :void
{
    try {
        var c :Creep  = this.obtainTarget(t.x, t.y, t.getRange());
        var b :Bullet = t.getNewBullet(c);

        this.bullets.push(b);
        this.bulletMC.addChild(b);
    } catch (e :Error) {
        // Do nothing, since we have no targets in range
    }
}

Notice that the Tower is what provides the new bullet object to the main MagicTD application to be added to the bullets array and the bulletMC. This allows each Tower to define not only the details of the Bullet to return but also whether or not to use a child class of the Bullet object, had we created any. For simplicity, we will just use the standard bullet object and just assign the power to it based one the power of the Tower object that creates it.

You will notice that the first thing this method does when we attempt to fire is to calculate whether or not we have any creeps in range. If so, we exit out of our loop on the first match to save resources, but if not, we send back an error to keep the SWF from complaining about an invalid return type. If we find a target, we simply create a bullet and assign it a target (by passing in the creep as you can see). The behavior of our bullets is slightly different than that of many TD games out there: rather than doing a collision detection on every enemy and allowing enemies to “intercept” a bullet from its intended target, I have chosen to make more “smart” bullets like the fireballs used by mages in Protector and its sequel Protector: Reclaiming the Throne. In short, the bullets are assigned a target and, once launched, will proceed after that target until it hits or the target is destroyed.

If you do not like this bullet behavior, feel free to modify the code to your liking, but I tend to like this type of predictable, smart behavior, since it allows for more planned placement of my individual towers. A quick review of the Bullet code will let you easily see exactly how we detect, trace and hit a target with our bullets. Notice, too, that bullets and creeps need to be marked as destroyed so that we can do some garbage collection from time to time, too (look at the cleanup_timer and handler code in the MagicTD class).

So, for the most part, this covers the overview of the Tower class and paves the way for full understanding of extending this class into your own custom Tower types. A cursory glance at the FireTower and IceTower classes should answer any questions you have or issues that may arise with handling child constructor methods and overloading parent methods (such as the draw() method).

I hope that my explanation isn’t too much of an overview that it keeps anyone from getting the full benefit of the code, but if you’re anything like me, you will get a much deeper understanding of it by reading the code rather than my feeble attempt at verbalization. So, with that being said, please feel free to bump me with questions, clarifications, bugs or any other relevant comments. After this lesson, you have all the individual pieces needed to create a full Tower Defense style game. If I can muster the time at some point, I will try to complete my own full game and post it for people to see what I came up with. In the meantime, I have to complete development on it first.

As always, I’m providing the source for you to download and modify for your own application. Here you will be able to view and download the entire source for the application seen in this post:
Tower Defense in AS3 – Lesson 4

Please contact me if you have used this to develop a game or application of your own. I’m very interested to see how this is used!