In the same way all units will be controlled in the same engine, the bullets fired by the units will be moved into their own engine and controlled from there. First let’s create a “blueprint” for the shots as well (yes an Interface).
package interfaces
{
import units.AUnit;
public interface IShot
{
// How will we check the collision? Is it a big radius or just a point check?
function checkUnitCollision():IUnit;
function checkStaticCollision():void;
// What happens if the shot hits something (damage? explosions?)
// returns TRUE if shot will be removed.
function onUnitCollision(unit:AUnit):Boolean;
// What happens if the shot hits something static in the world (like a wall or other obstacle)
// returns TRUE if shot will be removed.
function onStaticCollision():Boolean;
// update movement, rotation, scale, animation etc
function transform():void;
}
}
Now we’re getting used to the above view so with a little time looking at the code I believe that in the end you could tell me that the shots flying around (or behaving in other ways) will have a few basic functions that will be called apon. checkUnitCollision() checkStaticCollision() onUnitCollision() onStaticCollision() and transform(). Good. I don’t even care about creating a real implemented class of this interface, instead I want to start with the whole shotEngine that will control all shots.
I think we will take this class in parts as it might contain a few new things to the new actionscript coder. First you can start with creating a new folder besides the rest of the folders and name it “engine“. And then create a new class starting like this:
package engine
{
import interfaces.IShot;
import units.AUnit;
public class ShotEngine
{
static private var instance:ShotEngine
private var aShots:Array
// ************ SINGLETON CLASS *************
public function ShotEngine()
{
init()
}
public static function getInstance():ShotEngine
{
if (ShotEngine.instance == null)
{
ShotEngine.instance = new ShotEngine();
}
return ShotEngine.instance;
}
For you who are familiar with these kinds of Singleton-classes, skip this section. For you who is not: “WHOOOOAA!!” WTF was that??
Above is my favourite code experience of the year (yes I’m new to this as well). I’ve always had problems with the whole capsulating thing when it comes to OOP as I just don’t get how people work with global variables. I always found myself coding in a small component class deep down in a hierachy tree and suddenly need an instance of a class that’s in a toal other place, unreachable for me. The quick, dirty solution back then was to make more and more variables public and static so I could reach them from wherever I wanted to in the project. Not that OOP’ish… right.
The wonderful solution is a class called a Singleton-class. With this type of class, you can create one and only one single instance. Whenever you try to create another one you will only recieve the same instance you created from the start and it will contain the same variables and data as that first instance has. If you look at the code above you will see that it has a function called getInstance()
To use a singleton class, ALWAYS call the getInstance() function to get the instance of the class. Never ever create a new instance using the constructorname. Always call getInstance(). This way you assure yourself that you will have only one single instance of the class and in this way you can have access to the same data and methods wherever you need in a project.
Another very important thing is that a lot of classes in a gameproject can only have one single instance! You maybe want to have only one gameengines running at the same time.Noramlly you want to use only one keyboard. Only one HUD? One highscorelist, one onlineLobby etc etc. There are ways to control that the constructor cannot be directly called apon but I won’t bring that up here. Lets focus on our class instead. Continue….
private function init()
{
aShots = new Array()
}
public function addShot(shot:IShot)
{
//Add a new shot into the shotlist
aShots.push(shot);
// code to put shot in the 3D scene will be implanted here
}
public function updateShots():void
{
var tempShot:IShot
var tempUnit:AUnit
var flagDelete:Boolean
for (var i:int = aShots.length-1 ; i>-1 ; i--)
{
flagDelete = false // reseting deleteflag.
tempShot = aShots[i]
// first make the shot move/rotate/animate/beam...
tempShot.transform()
// is it hitting anyone or anything?
tempUnit = tempShot.checkUnitCollision()
if (tempUnit != null)
{
// returning 'TRUE' if that specific shot wants to remove itself on impact
flagDelete = tempShot.onUnitCollision(tempUnit);
}
if (tempShot.checkStaticCollision()==true)
{
// returning 'TRUE' if that specific shot wants to remove itself on impact
flagDelete = tempShot.onStaticCollision();
}
if (flagDelete == true)
{
// code will be implanted here to remove the visual shot from the 3D scene
aShots.splice(i,1) // removing shot from the shot list.
}
}
}
}
}
This “engine” will handle all shots that are flying around on stage, update them, check if they hit things and then remove them on collision if they are coded that way( some shots, a lightingcloud for example, may not want to be removed on impact but draw damage over time as the unit stays in the cloud).
So, here you go. Another post without anything happening on the scene ;) remember, the more boring code we get done underneath, the faster the progress will get later on. Next post I promise we must create something visual. Like.. hmm, a gun?
A Whiter Shade of Paper 
Looking good!