JimVaders My Own Invaders Clone Thingie [Tutorial]

[Insert a Title Here]:

[UPDATE 29/05/2012: Added an extra Bonus chapter about creating explosions with particle system]

[UPDATE 24/05/2012: I changed some stuff in the EnemyLayer class and added a whole new section at the end of this tutorial, make sure you have those changes before submitting bug reports :P]

Well .. didn’t know what to call this title so yeah .. anyway, this project will be my own space invaders clone , it’s not the whole thing but I had some stuff in mind before doing it and they were accomplished here, so here they are.

• Make a game without using any external images [I do put weird challenges for myself I know]
• Make sure that the game code is neat and well written in OOP
• Include at least a full structure of the game , doesn’t have to have everything working though

Not using sprites got the advantage of reducing file size .. but I can assure you that the final project looks ugly :P.
I also used this project as an excuse to use AndEngine GLES2.0 and get used to it [I started with GLES1.0 then ported it to GLES2.0] so if you are just learning about andEngine you can start with this project directly with using AndEngine GLES2.0 [even though I do recommend going over my list of tutorials if you haven’t already].
I should also note that this tutorial could be kinda dull at the beginning [till the writing of this line , I’m not sure how I’m gonna organize the tutorial so let’s hope what I write would make sense].

Gearing up:

As with before , you should have AndEngine installed , we’ll be using AndEngine GLES2.0 for this [writing that name every time is not that fun >_>] so if you don’t have that installed you can follow any tutorials online , or use my tutorial for setting up AndEngine GLES2.0.

Just make sure that it’s all working before proceeding, my awesome space ship will wait for you.

Note that as that we’ll be having lots of classes, so I’ll try to finish each class and not come back to it .. this style might not be the same type as my previous tutorials but it’s an experiment and let’s hope [again] that it works :D.

Small Activity is small:

We’ll only be using one Activity and will be switching between scenes, so create a new Java class and call it “BaseActivity” [cause I said so] then make it extends “SimpleBaseGameActivity”, you’ll notice that the default methods are different from the old version of AndEngine.

Add those to the top of your class

static final int CAMERA_WIDTH = 800;
static final int CAMERA_HEIGHT = 480;

public Font mFont;
public Camera mCamera;

//A reference to the current scene
public Scene mCurrentScene;
public static BaseActivity instance;

Notice that I used static dimensions for the camera, this is better than the way I used before because this way will have openGL scale up/down everything depending on the screen size so you don’t really have to worry about screen sizes.

We’ll be using Font later on to write text, so we’ll add it here.
mCurrentScene is an object of type Scene that’ll be used to reference the top Scene , will prove to be useful later on.
This Activity will be a singleton [if you are not familiar with the concept you’ll probably understand it while we work on it].

Next, let’s get to the onCreateEngineOptions() method

public EngineOptions onCreateEngineOptions() {
    instance = this;
    mCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);

    return new EngineOptions(true, ScreenOrientation.LANDSCAPE_SENSOR, new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT), mCamera);
}

We let the instance object reference to this activity, the rest is straight forward.
For onCreateResources() method

protected void onCreateResources() {
    mFont = FontFactory.create(this.getFontManager(),this.getTextureManager(), 256, 256,Typeface.create(Typeface.DEFAULT, Typeface.BOLD), 32);
    mFont.load();
}

We don’t have any resources [no images , remember ? :P]
We’ll just have to create the mFont object and load it, I’ve decided to make it use the default font and bold it, text size is 32.

As for the onCreateScene:

protected Scene onCreateScene() {
    mEngine.registerUpdateHandler(new FPSLogger());
    mCurrentScene = new Scene();
    mCurrentScene.setBackground(new Background(0.09804f, 0.7274f, 0.8f));
    return mCurrentScene;
}

Completely self explanatory , we create a new scene and chose it’s background color [I put random numbers :P] and returned it.
with this, you should be able to run the code and get a colored background [not very interesting so far , ‘eh ?]

Before we are done with this class , let’s add 2 more methods:

public static BaseActivity getSharedInstance() {
    return instance;
}

// to change the current main scene
public void setCurrentScene(Scene scene) {
    mCurrentScene = scene;
    getEngine().setScene(mCurrentScene);
}

getSharedInstance() will return the current instance for BaseActivity so we can get access to it [the 2nd part of making this a singleton class] and the setCurrentScene() would replace the scene and update mCurrentScene to the new scene.

Splash all around the place:

Every game got a splash screen , why won’t ours have one too ? there is no reason not to so we’ll create a simple splash scene where we’ll have the game’s name animate coming from both sides.
It’s a bad idea/habit to have text strings hard-coded in the source code, so we’ll use strings.xml file, open it and add those 2 elements:

<string name="title_1">Jim</string>
<string name="title_2">Vaders</string>

Or you could chose your own name, whatever makes you happy and sleep at night like a baby :D.
Create a new Class, call it “SplashScene”, and make it extends Scene then add this line at top:

BaseActivity activity;

Then inside the constructor, we’ll have it like this:

setBackground(new Background(0.09804f, 0.6274f, 0));
activity = BaseActivity.getSharedInstance();
Text title1 = new Text(0, 0, activity.mFont, activity.getString(R.string.title_1), activity.getVertexBufferObjectManager());
Text title2 = new Text(0, 0, activity.mFont, activity.getString(R.string.title_2), activity.getVertexBufferObjectManager());

Now we have activity object reference our BaseActivity singleton class and then initialize the Text objects, each would use the strings we put in strings.xml.
We have both texts at position 0,0 at first , we’ll change them on this following part so add those next

title1.setPosition(-title1.getWidth(), activity.mCamera.getHeight() / 2);
title2.setPosition(activity.mCamera.getWidth(), activity.mCamera.getHeight() / 2);

attachChild(title1);
attachChild(title2);

title1.registerEntityModifier(new MoveXModifier(1, title1.getX(), activity.mCamera.getWidth() / 2 - title1.getWidth()));
title2.registerEntityModifier(new MoveXModifier(1, title2.getX(), activity.mCamera.getWidth() / 2));

Here we changed the positions of each text object to be aligned on the center and placed right outside the screen on both side then we attached both texts and added a MoveXModifier so it moves horizontally from both sides meeting at the center, not so flashy but it does the job and make you feel it’s from outerspace and stuff [not really ..].
Okay , let’s make this work .. go back into BaseActivity [this is the last changes in it , I promise] and change your onCreateScene() to this

mEngine.registerUpdateHandler(new FPSLogger());
mCurrentScene = new SplashScene();
return mCurrentScene;

We simply used the SplashScene as the starting scene here , and we got our awesome moving splash scene thingie and you can close this class for good.
Test and see what you get, it should be something like this:

Main Menu:

Main menu comes after the splash screen , right ?
Let’s create our main menu then .. no fancy effects or options , it’ll just have one option that says “start” and when clicked the game starts .. good enough if you ask me [yeah I’m that lazy].
Create a new class called MainMenuScene that extends MenuScene and implements IOnMenuItemClickListener then add those 2 lines at top:

BaseActivity activity;
final int MENU_START = 0;

The MENU_START int variable is a flag for our start button , if you add some other button then you’ll need to add some other flag.
Now let’s go to the constructor and write this in it:

super(BaseActivity.getSharedInstance().mCamera);
activity = BaseActivity.getSharedInstance();

setBackground(new Background(0.09804f, 0.6274f, 0.8784f));
IMenuItem startButton = new TextMenuItem(MENU_START, activity.mFont, activity.getString(R.string.start), activity.getVertexBufferObjectManager());
startButton.setPosition(mCamera.getWidth() / 2 - startButton.getWidth() / 2, mCamera.getHeight() / 2 - startButton.getHeight() / 2);
addMenuItem(startButton);

setOnMenuItemClickListener(this);

You should send the current camera to the super class for it to work.
Rremember to add an item in strings.xml for the text written on the start [mine is start , you could put “start!” or “kill all aliens !” or whatever ]
Background colors are random numbers [not really , this was taken from the AndEngine examples ], the startButton is an IMenuItem with MENU_START as it’s flag , using our same font we created and the text from strings.xml.
Position it at the center, add it as a menu item , and then we just register the current scene as a MenuItemClickListener.

The class should have an overridden method called onMenuItemClicked(), have it look like this for now:

public boolean onMenuItemClicked(MenuScene arg0, IMenuItem arg1, float arg2, float arg3) {
    switch (arg1.getID()) {
        case MENU_START:
            return true;
        default:
            break;
    }
    return false;
}

We just swallow the touch when the button is clicked , this would get changed later on to have the game start, now to test our main menu we have to open the SplashScene [again :D] and make some changes.
Before we do that, lemme explain a good habit with splash screens, usually splash screens are used to load the resources [if any] so that the user doesn’t have to wait a lot to launch the app/game , but instead he gets a splash screen while a background thread loads the resources, we’ll just put a place holder for that and you can play around with it later on if you want to load any resources for your game.
Fire up your SplashScene class and add a new method and call it loadResources() , put the following code in it [copy or type it , I prefer that you type it so you get an idea of what you are doing].

DelayModifier dMod = new DelayModifier(2, new IEntityModifierListener() {
    @Override
    public void onModifierStarted(IModifier arg0, IEntity arg1) {
    }
    public void onModifierFinished(IModifier arg0, IEntity arg1) {
        activity.setCurrentScene(new MainMenuScene());
    }
});
registerEntityModifier(dMod);

EDIT: if the above code doesn’t work with you for some reason [I got no idea why it doesn’t work in some cases] use this one and build on it

DelayModifier dMod = new DelayModifier(2){
    @Override
    protected void onModifierFinished(IEntity pItem) {
        activity.setCurrentScene(new MainMenuScene());
    }
};
registerEntityModifier(dMod);

This is just a place holder, it just waits for 2 seconds and then tells the activity to change the scene to the MainMenuScene [yay we finally used setCurrentScene() :D] simple ‘eh ?
Call that method at the end of the constructor of SplashScene, test now and you should get the splash animation then the scene will change to the main menu scene with your start button.

Ships to Docks:

Let’s make our ship now, since we are being more OO .. the ship will have it’s own separate class, so let’s do this.
As that there should be only one ship on the screen at a time, and since that we’ll be accessing it a lot , we’ll make it a singleton class too.
Create a new class and call it “Ship”, make your class look like this:

public class Ship {
    public Rectangle sprite;
    public static Ship instance;
    Camera mCamera;

    public static Ship getSharedInstance() {
        if (instance == null)
            instance = new Ship();
        return instance;
    }

    private Ship() {
        sprite = new Rectangle(0, 0, 70, 30, BaseActivity.getSharedInstance()
            .getVertexBufferObjectManager());

        mCamera = BaseActivity.getSharedInstance().mCamera;
        sprite.setPosition(mCamera.getWidth() / 2 - sprite.getWidth() / 2,
            mCamera.getHeight() - sprite.getHeight() - 10);
    }
}

The ship’s sprite will be a rectangle [too lazy to make a new shape ? :P] and I decided that it should have width of 70 pixels and height of 30 pixels .. you may have your rectangle err .. your awesome space ship look however you want though!
The initial position of the sprite is at the bottom center of the camera that we got from BaseActivity [notice that we didn’t attach it anywhere yet], the rest should be easy to understand.
We’ll come back to this class later on..
[WARNING: we will be jumping back and forth between classes a lot from now on, so you should pay attention and concentrate which is which]

Now we’ll need to have a scene for the actual game, we’ll call it something totally unrelated like … “GameScene” !
Sorry sorry .. lame joke I know ..
Anyway , create a new class called “GameScene” and make it extend Scene then add those 2 lines to the top:

public Ship ship;
Camera mCamera;

The GameScene constructor should look like this:

public GameScene() {
    setBackground(new Background(0.09804f, 0.6274f, 0.8784f));
    mCamera = BaseActivity.getSharedInstance().mCamera;
    ship = Ship.getSharedInstance();
    attachChild(ship.sprite);
}

We are using the same lame blue background for the GameScene [cause I’m too lazy to change that] and then create a new Ship object [we call the getSharedInstance() method which figures if we have an object or not, power of singleton !!] and attach the ship’s sprite to the scene [NOT the ship object , the sprite !].
Go back to MainMenuScene and modify your onMenuItemClicked() under the first case, it should be like this:

case MENU_START:
    activity.setCurrentScene(new GameScene());
    return true;

You may run and see what you’ve done, you should navigate to the GameScene when you touch “start” and see your epic ship in all of it’s glory [just the looks]:

I Like To Move It Move It:

It’s been so boring and lame so far , right ? I mean the only thing that moved was the text .. and touching the start button [text thingie] is not that interactive , it shouldn’t be called interactive in the first place!!
Anyway .. let’s have the ship [aka white rectangular shape thingie] move with tilt action , using the device’s accelerometer.
We’ll keep the accelerometer’s speed data saved in the GameScene class, so add a new float to the GameScene class and call it “accelerometerSpeedX”, we’ll get back to this float later on.
Create a new class and call it “SensorListener”, make it implements “SensorEventListener” and add the unimplemented methods, then add those fields .. it should look like this:

static SensorListener instance;
GameScene scene;

public static SensorListener getSharedInstance() {
    if (instance == null)
        instance = new SensorListener();
    return instance;
}

public SensorListener() {
    instance = this;
    scene = (GameScene) BaseActivity.getSharedInstance().mCurrentScene;
}

@Override
public void onAccuracyChanged(Sensor sensor, int accuracy) {
}

@Override
public void onSensorChanged(SensorEvent event) {
}

The GameScene object scene is used to reference our GameScene, the rest doesn’t need to be explained.
Now go to onSensorChanged() and put this in:

synchronized (this) {
    switch (event.sensor.getType()) {
        case Sensor.TYPE_ACCELEROMETER:
            scene.accelerometerSpeedX = event.values[1];
            break;
        default:
            break;
    }
}

We used the synchronized block to make sure that we don’t get a concurrentModificationException .. as in make it thread safe in a way.
This should make accelerometerSpeedX in GameScene contain the value of the accelerometer X Speed which we will be using to determine how much to move the ship.

Now let’s create a method to move the ship .. open the Ship class and put this method in:

public void moveShip(float accelerometerSpeedX) {
    if (!moveable)
        return;

    if (accelerometerSpeedX != 0) {
        int lL = 0;
        int rL = (int) (mCamera.getWidth() - (int) sprite.getWidth());
        float newX;

        // Calculate New X,Y Coordinates within Limits
        if (sprite.getX() >= lL)
            newX = sprite.getX() + accelerometerSpeedX;
        else
            newX = lL;
        if (newX <= rL)
            newX = sprite.getX() + accelerometerSpeedX;
        else
            newX = rL;

        // Double Check That New X,Y Coordinates are within Limits
        if (newX < lL)
            newX = lL;
        else if (newX > rL)
newX = rL;
        sprite.setPosition(newX, sprite.getY());
    }
}

While we are at it , add a boolean variable called moveable and set it to true in the constructor, this flag is used to know if we wanna disable the movement of the ship without pausing the whole thing.. we will use it later on.
Regarding moveShip() method, it should basically get the accelerometer data when changed and it moves the ship according to the data you get, to be honest I didn’t write this part of the code ..
I got the one in this thread and modified it to work only on the x-axis, basically it computes where the sprite should go to then checks if it’s within the boundries or not [so it doesn’t leave the screeen], no big deal [The code on the first page doesn’t exactly work, I posted a modified code that works on the same thread in the 2nd page].

As that this method requires the data of accelerometerSpeedX we’ll call it from GameScene , open that class and add this method to it:

public void moveShip() {
    ship.moveShip(accelerometerSpeedX);
}

Before we can have our white brick [aka ship] move around, we need to be able to call this method every frame so we’ll need an IUpdateHandler so create a new class and name it GameLoopUpdateHandler , make it implement IUpdateHandler then add the missing methods.
onUpdate will have one line which looks looks like this:

public void onUpdate(float pSecondsElapsed) {
    ((GameScene)BaseActivity.getSharedInstance().mCurrentScene).moveShip();
}

That’s a very bad practice, but I was kinda lazy to do it in any better way, basically I’m getting the mCurrentScene from BaseActivity and cast it to GameScene, [I know that at this point of the game the currentScene will be an instance of GameScene] and then call the moveShip() method inside the scene 😀

We still have to do some more preparations , go into GameScene and add those lines to the end of the constructor:

BaseActivity.getSharedInstance().setCurrentScene(this);
sensorManager = (SensorManager) BaseActivity.getSharedInstance()
    .getSystemService(BaseGameActivity.SENSOR_SERVICE);
SensorListener.getSharedInstance();
sensorManager.registerListener(SensorListener.getSharedInstance(),
sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
SensorManager.SENSOR_DELAY_GAME);

registerUpdateHandler(new GameLoopUpdateHandler());

We set the current scene to be the current GameScene [I know that we were doing that when we clicked on the start button, but that only sets it up AFTER this class is created as in after the constructor finishes being called , we need to change it in the middle] and then have our game listens to accelerometer sensor changes [and create a new SensorListener object so our accelerometerSpeedX gets updated].
At the end of this we register our GameLoopUpdateHandler() as an UpdateHandler.
It’s worth it now, you can move the ship around with tilting the device .. try it ! try it now .. I insist !

Pew Pew:

Let’s start shooting stuff now , shall we ?
We’ll need bullets , so let’s create bullets … create a new class and call it “Bullet” , your class will look like this:

public class Bullet {
    public Rectangle sprite;
    public Bullet() {
        sprite = new Rectangle(0, 0, 10, 10, BaseActivity.getSharedInstance()
            .getVertexBufferObjectManager());

        sprite.setColor(0.09904f, 0f, 0.1786f);
    }
}

Each bullet will be a 10×10 square, and I decided to change it’s color .. change the numbers for the color if you wanna mess with that.
Again, if you wanna use images instead, you could do so by just changing the type of sprite to Sprite and making adjustments inside this class, everything else should work fine regardless.
We’ll be using pools to reuse bullets .. you may wanna read my blog post about pools if you haven’t already.
Even though the post is a part of my old tutorial, it’d give you an idea of what pools are and what they are useful for.
Make a new class called BulletPool that extends GenericPool here’s my full class for you

public class BulletPool extends GenericPool {

    public static BulletPool instance;

    public static BulletPool sharedBulletPool() {
        if (instance == null)
            instance = new BulletPool();
        return instance;
    }

    private BulletPool() {
        super();
    }

    @Override
    protected Bullet onAllocatePoolItem() {
        return new Bullet();
    }

    protected void onHandleRecycleItem(final Bullet b) {
        b.sprite.clearEntityModifiers();
        b.sprite.clearUpdateHandlers();
        b.sprite.setVisible(false);
        b.sprite.detachSelf();
    }
}

I won’t explain this, so if you don’t know what it is then please take a look at my post that I linked previously to get an idea of what pooling is [it’s almost the same code used in there].
First we’ll need to keep track of the bullets we shoot so we know when to remove them and when any bullet hits something [after we create some stuff to shoot].
[Note: if you already did my previous tutorials then this is similar, but I chose to have shooting before creating targets so that I’ll be done with the ship class faster].

So let’s go to GameScene and create a new linked list of Bullets and a count of them:

public LinkedList bulletList;

Then inside the constructor have this line:

bulletList = new LinkedList();

Which does it for this class for now , head back to your Ship class and add a new method called shoot():

// shoots bullets
public void shoot() {
    if (!moveable)
        return;
    GameScene scene = (GameScene) BaseActivity.getSharedInstance().mCurrentScene;

    Bullet b = BulletPool.sharedBulletPool().obtainPoolItem();
    b.sprite.setPosition(sprite.getX() + sprite.getWidth() / 2,
        sprite.getY());
    MoveYModifier mod = new MoveYModifier(1.5f, b.sprite.getY(),
        -b.sprite.getHeight());

    b.sprite.setVisible(true);
    b.sprite.detachSelf();
    scene.attachChild(b.sprite);
    scene.bulletList.add(b);
    b.sprite.registerEntityModifier(mod);
    scene.bulletCount++;
}

Check if the ship is not moveable then skip [it’s not moveable and shouldn’t be shooting anything too], we get the reference to the current scene [which is our GameScene] and obtain a bullet from the pool.
Set the bullet’s position to be on top of ship’s sprite position [and in the middle].
We create a new MoveYModifier, an entity modifier is a something that you register on entities [sprites/shapes/etc] and when you register them they do some modifications, there are modifiers that rotates and others moves entities in certain ways.
Our Modifier moves an entity along the Y axis by providing the duration it should move across between the initial and final positions you provide.
In our case we move the bullet’s sprite from it’s current position till it’s completely out of the screen.
The bullet is set to be visible and make it detach itself [I know this is already done in the pool , but for some reason it was nagging me sometimes about it having a parent when I attach it, so detaching again won’t hurt].
Attach the bullet to the scene and add it to the linked list, register the modifier [if we didn’t do this part the bullet won’t move, the modifier needs to be registered for it to work], and then incerement the bulletCount.

Before we can use this, we need to do some configurations [it’ll be short I promise].
Go to GameScene again, and make it implements IOnSceneTouchListener then add the missing methods, add this line to the constructor:

setOnSceneTouchListener(this);

And the new method would look like this:

public boolean onSceneTouchEvent(Scene pScene, TouchEvent pSceneTouchEvent) {
    synchronized (this) {
        ship.shoot();
    }
    return true;
}

This just calls shoot() from here and returns true , telling the engine that we handled the touch event here and no need to send it to another place to be handled.
Okay .. I kinda lied .. there is a li’l bit more
Actually , if you fire up the game now it’ll work fine , but we didn’t clean up after the bullets [didn’t return them to the pool] defeating the purpose of having pools for reusability, so let’s do that before we end this section/chapter/finger .. whatever you wanna call it.
Add a new method in GameScene that would look like this

public void cleaner() {
    synchronized (this) {
        Iterator it = bulletList.iterator();
        while (it.hasNext()) {
            Bullet b = it.next();
            if (b.sprite.getY() <= -b.sprite.getHeight()) {
                BulletPool.sharedBulletPool().recyclePoolItem(b);
                it.remove();
                continue;
            }
        }
    }
}

Iterate over the linked list [using an iterator] and if the bullet went past the screen, return it to the pool [recycle it because we are enviromentalists and stuff] and then remove it from the linked list and continue [this continue will make sense later , I felt too lazy to remove it now and re-add it later on].
Now we just need to call this method, we’ll do that through GameLoopUpdateHandler just add this line inside the onUpdate method:

((GameScene)BaseActivity.getSharedInstance().mCurrentScene).cleaner();

You are ready to go , fire up the game and start shooting bullets into void preparing for the enemy strike !

Calm Down:

As you can see, the bullets shooting are happening too fast .. we need to have some sort of a cool down mechanism so there would be some minimum time between shooting bullets, let’s do this !
I’ll copy this part from my old tutorial , as that it’s the exact same class [and there is no need for me to write again , right ? :P].
So create a new class and call it CoolDown, this is the whole class for you

public class CoolDown {
    private boolean valid;
    private Timer timer;
    private long delay = 400;
    private static CoolDown instance = null;

    public static CoolDown getSharedInstance() {
        if (instance == null) {
            instance = new CoolDown();
        }
        return instance;
    }

    private CoolDown() {
        timer = new Timer();
        valid = true;
    }

    public boolean checkValidity() {
        if (valid) {
            valid = false;
            timer.schedule(new Task(), delay);
            return true;
        }
        return false;
    }

    class Task extends TimerTask {

        public void run() {
            valid = true;
        }

    }
}

Even though this is a java thingie and not quite related to AndEngine directly, I’ll still explain it though.

I wanted to create a singleton class, so you only have one instance of this type in your whole program [special thanks to Mazyod, check out his blog, he blabbers about lots of useless stuff] thus it explains the getSharedInstance() method behavior [and why the constructor is private].

You call checkValidity() it should return to you true if you can have a bullet and false if you can’t, the valid flag is the one that decides it, if it’s true then it gets toggled and a timer gets a new Task that runs after a certain delay , 400ms in our case here [you can change that if you want] and then returns true telling you that you can have a bullet.

Task is a class that extends TimerTask, it just makes valid true again when called [will be called by the timer after 400ms].

Now just head to the onSceneTouchEvent method inside GameScene and add those 2 lines at the top:

if (!CoolDown.getSharedInstance().checkValidity())
    return false;

This will make sure that you don’t shoot bullets to often , so spamming bullets would look like this

Layering Our Enemies:

Even though shooting bullets like this is fun [if you are not having fun so far then you should go and eat a potato] we still need to have something to it .. but let’s organize that first.
If you have ever played any invaders game, you’d notice that the enemies move together, to achieve that we’ll put some kind of Layer on Scene and have all the enemies added to it, so that when we move the layer all of the enemies move together ! [think of it as putting a table and placing everything on top of a table, if you move the table everything on the table moves too].
We got that figured out , let’s start making stuff!
I decided that each Enemy would have a health value of 2 [HP = 2], so you’d need to hit it twice for it to die, it’ll also be a square [what a surprise !] that rotates at all time [it’ll also have a random color I generated].

Anyway , let’s create a new class and call it Enemy, it has those lines at top:

public Rectangle sprite;
public int hp;
//the max health for each enemy
protected final int MAX_HEALTH = 2;

MAX_HEALTH determines how many hits it needs to die , you can change this if you want.
Here’s the constructor and the initialization methods:

public Enemy() {
    sprite = new Rectangle(0, 0, 30, 30,BaseActivity.getSharedInstance().getVertexBufferObjectManager());
    sprite.setColor(0.09904f, 0.8574f, 0.1786f);
    init();
}

// method for initializing the Enemy object , used by the constructor and
// the EnemyPool class
public void init() {
    hp = MAX_HEALTH;
    sprite.registerEntityModifier(new LoopEntityModifier(
        new RotationModifier(5, 0, 360)));
}

I’ll only explain the last line, we are registering a new Entity modifier [something like the MoveYModifier we used for bullets] that’s called LoopEntityModifier, this one takes other Modifiers as arguments and loops over them for a certain count number, and if not specified it’d loop forever.
We are giving the LoopEntityModifier a RotationModifier , telling it to rotate the sprite from 0′ to 360′ with a duration value of 5.

Add 2 more methods to your class:

public void clean() {
    sprite.clearEntityModifiers();
    sprite.clearUpdateHandlers();
}

// method for applying hit and checking if enemy died or not
// returns false if enemy died
public boolean gotHit() {
    synchronized (this) {
        hp--;
        if (hp <= 0)
            return false;
        else
            return true;
   }
}

The clean() method just cleans the sprites, we’ll use that before we return enemies to the pool [yes we’ll have an EnemyPool class too] which will explain why we have this init() method too.
The gotHit() method gets called when you hit an Enemy with a bullet, it reduces it’s health and if the enemy dies then it returns false to the caller [which will take care of removing the enemy … we’ll get back to that later on].
Now we have our enemies created, let’s create that EnemyLayer class and make it extends Entity.

Add those lines to the top of the class:

private LinkedList enemies;
public static EnemyLayer instance;
public int enemyCount;

public static EnemyLayer getSharedInstance() {
    return instance;
}

I’m not explaining that [you should already know that by now] we’ll add some methods before we get into the real thing, let’s add an isEmpty method that tells us if the enemy layer is empty or not [if all enemies are killed or not].

public static boolean isEmpty() {
    if (instance.enemies.size() == 0)
        return true;
    return false;
}

And another one that returns an iterator for the enemies linked list:

public static Iterator getIterator() {
return instance.enemies.iterator();
}

Notice that both of them are static methods so you should expect that we’d use them from somewhere else.

Let’s get to the main thing now starting with the constructor

public EnemyLayer(int x) {
    enemies = new LinkedList();
    instance = this;
    enemyCount = x;
    restart();
}

public void restart(){

}

I decided to design this layer in a way that you can specify how many enemies you want, when creating a new EnemyLayer you’d provide it with how many enemies should it have and it’d arrange them in a proper way [but don’t overdo it and put lots of enemies, they’d overflow out of the screen] so the x parameter in the constructor defines how many you need, and the enemyCount variable saves that number for future usage [inside the restart method].
Let’s get to the restart() method where all the main work is in.
As that we will be using restart() method later on [as the name suggests] when we wanna restart the game, we’ll have to clear stuff at first like this:

enemies.clear();
clearEntityModifiers();
clearUpdateHandlers();

———————————————————————————————————————————————————————-
[Annoying note: in the middle of writing this I realised that I didn’t talk about the enemy pool and we’ll need to do use it, so I’m putting this part here :D]
Note: you can skip this part if you know how to do it yourself [it’s a good practice to do something by yourself :P]
EnemyPool is like the rest of the pools we used, but the version I made got some small changes [other than changing the type to Enemy].
Basically it’s just using one extra overriden method that gets called before obtaining an item from the pool

@Override
protected void onHandleObtainItem(Enemy pItem) {
    pItem.init();
}

and changing the onHandleRecycleItem method to this one

/** Called when a projectile is sent to the pool */
protected void onHandleRecycleItem(final Enemy e) {
    e.sprite.setVisible(false);
    e.sprite.detachSelf();
    e.clean();
}

The rest is the same as the BulletPool
[Annoying note: this ends the annoying note, back to EnemyLayer class]
———————————————————————————————————————————————————————-

A random method here:

public void purge() {
    detachChildren();
    for (Enemy e : enemies) {
        EnemyPool.sharedEnemyPool().recyclePoolItem(e);
    }
    enemies.clear();
}

This would detach all children of the EnemyLayer , iterate over all enemies and recycle them all then clears the ArrayList.

I thought it’d be a good enterance effect to have the enemies [square thingies for now] move in the screen from random positions to their places [yes I’m that awesome, I think about awesome stuff like this when I’m not sleeping].
So in the restart() method we’ll iterate over the enemyCount variable, create new enemies, and place them at random spots outside the camera [so they are not viewable] then have them move to their correct places at once, let’s do that !

for (int i = 0; i < enemyCount; i++) {
    Enemy e = EnemyPool.sharedEnemyPool().obtainPoolItem();
    float finalPosX = (i % 6) * 4 * e.sprite.getWidth();
    float finalPosY = ((int) (i / 6)) * e.sprite.getHeight() * 2;

    Random r = new Random();
    e.sprite.setPosition(r.nextInt(2) == 0 ? -e.sprite.getWidth() * 3
        : BaseActivity.CAMERA_WIDTH + e.sprite.getWidth() * 3,
        (r.nextInt(5) + 1) * e.sprite.getHeight());
    e.sprite.setVisible(true);

    attachChild(e.sprite);
    e.sprite.registerEntityModifier(new MoveModifier(2,
        e.sprite.getX(), finalPosX, e.sprite.getY(), finalPosY));

    enemies.add(e);
}

I’ll try to explain this [urgh .. ain’t that easy to explain >_<] we obtain an Enemy object from the pool, then we decide where it should be when it finishes it’s “fabulous” enterance animation in x and y.
ok .. that didn’t make a lot of sense .. we calculate where it goes to like this
I wanted to have a maximum of 6 enemies on each row , so I take count mod 6 [if you don’t know what mod is then you might wanna read about that or just play around with it to see what it does] then multiply it by 4 to have some gap between the enemies, multiply by the sprite’s width and you get the x position.
The y position figures out which row you need to put the enemy on with the division operation then puts a smaller gap between rows than we had between columns.
[Note: Those calculations were done regarding the resolution we chose when we created this project, if you chose a different resolution it may not look right here]
The rest is randomly choosing somewhere to place the enemy at [outside the camera] and then set it visible, then make it move from it’s current position to the final position and add it to our linked list.

After we are done with configuring the enemies, let’s finish configuring the Layer itself:

setVisible(true);
setPosition(50, 30);

MoveXModifier movRight = new MoveXModifier(1, 50, 120);
MoveXModifier movLeft = new MoveXModifier(1, 120, 50);
MoveYModifier moveDown = new MoveYModifier(1, 30, 100);
MoveYModifier moveUp = new MoveYModifier(1, 100, 30);

registerEntityModifier(new LoopEntityModifier(
    new SequenceEntityModifier(movRight, moveDown, movLeft, moveUp)));

The numbers above were mainly generated by trial & error and some math [which I forgot how I did and don’t feel like thinking anymore about this], but I’ll explain what they do.
I wanted to have the whole layer move in a rectangular like motion, thus explains the movRight,moveLeft,..etc modifiers.
A SequenceEntityModifier modifier takes a bunch of modifiers as arguments and runs them one by one, since we want them to move forever, we’ll place the SequenceEntityModifier inside a LoopEntityModifier and register it for the layer.
Before we close this class and never open again, add this one last 2 methods to it

public static void purgeAndRestart() {
    instance.purge();
    instance.restart();
}

And override onDetach()

@Override
    public void onDetached() {
    purge();
    super.onDetached();
}

which will make sure we clean up when detaching the EnemyLayer [will do that later on]

And we are done !

How do we test this ? easy go to the constructor of GameScene and add this line [I like to put it after setting the background color on top

// attaching an EnemyLayer entity with 12 enemies on it
attachChild(new EnemyLayer(12));

You can see that I put 12 enemies, you may play around with it and change the number to see how it works, run the game and celebrate your work !

Kill The Squares:

Let’s now kill some squares ..err I mean aliens , to do so we have to detect when a bullet would hit something and when the alien loses all it’s health , it should be gone !
We’ll do most of the work in the cleaner() method inside GameScene, replace your current cleaner() method with this one

public void cleaner() {
    synchronized (this) {
        Iterator eIt = EnemyLayer.getIterator();
            while (eIt.hasNext()) {
                Enemy e = eIt.next();
                Iterator it = bulletList.iterator();
                while (it.hasNext()) {
                    Bullet b = it.next();
                    if (b.sprite.getY()                         BulletPool.sharedBulletPool().recyclePoolItem(b);
                        it.remove();
                        continue;
                    }

                    if (b.sprite.collidesWith(e.sprite)) {
                        if (!e.gotHit()) {
                            EnemyPool.sharedEnemyPool().recyclePoolItem(e);
                            eIt.remove();
                        }
                    BulletPool.sharedBulletPool().recyclePoolItem(b);
                    it.remove();
                    break;
                }
            }
        }
    }
}

What that code does is , iterate over the enemies and for each enemy, you iterate over all the presented bullets, and as before, if the bullet left the screen then remove it and continue [that’s why we had a continue :D] if not then you check if this bullet collides with the enemy or not.
If the bullet collided, then you send a gotHit() method call for the enemy, if it returned false it means that the enemy’s hp went to 0 [or below] so we recycle it back to the pool and then we recycle the bullet and break out of the loop to go to the next enemy.

Simple ‘eh ? run it now and see what you did .. KILL THOSE ALINES NOW !! [remember, 2 hits to kill]

What’s My Purpose In Life ?:
The basic game mechanism is done, but let’s add some purpose to this game, we’ll calculate the accuracy of the player .. so the more misses he makes the lowest his accuracy is, and then you can restart the game to try again.

Add a new int to GameScene and call it missCount, then head to the Ship class and add a method called restart()

// resets the ship to the middle of the screen
public void restart() {
    moveable = false;
    Camera mCamera = BaseActivity.getSharedInstance().mCamera;
    MoveXModifier mod = new MoveXModifier(0.2f, sprite.getX(),
        mCamera.getWidth() / 2 - sprite.getWidth() / 2) {
        @Override
        protected void onModifierFinished(IEntity pItem) {
            super.onModifierFinished(pItem);
            moveable = true;
        }
    };
    sprite.registerEntityModifier(mod);
}

What this method does is that it disables the movement of the ship with the accelerometer, then move the ship to the middle of the screen and renable the movement of the ship.

Then add this method to the GameScene class.

// method to reset values and restart the game
public void resetValues() {
    missCount = 0;
    bulletCount = 0;
    ship.restart();
    EnemyLayer.purgeAndRestart();
    clearChildScene();
    registerUpdateHandler(new GameLoopUpdateHandler());
}

Call this method from the constructor and remove the line where you register the UpdateHandler from the constructor.
And now whenever a bullet misses, you should increment the missCount [if you don’t know which part is that then you may need to pay more attention to what you type and stop copy pasting the code :P].
And as that we are restarting the EnemyLayer here, you might wanna remove the call for the restart() method inside the EnemyLayer constructor as this will do it for you.
We’ll now need to add a new scene to present the results, and we’ll call it … ResultScene ?
This new Scene will not replace the old one, it’ll hover over the old scene as an overlay .. so your ResultScene should extend CameraScene and while you are at it , make it implements IOnSceneTouchListener and add the missing methods [only one actually].
The results will be a text that moves slowly from the bottom of the screen to the middle, and you can’t do anything till the text reaches it’s final position .. then if you touch the screen it gets dismissed.

Use the constructor that takes Camera as a parameter, but first add those 2 lines:

boolean done;
BaseActivity activity;

Let’s get back to the strings.xml file and add a new value that says “Accuracy” and with a tag of accuracy [or anything you want], The constructor would be like this:

public ResultScene(Camera mCamera) {
    super(mCamera);
    activity = BaseActivity.getSharedInstance();
    setBackgroundEnabled(false);
    GameScene scene = (GameScene) activity.mCurrentScene;
    float accuracy = 1 - (float) scene.missCount / scene.bulletCount;
    if (Float.isNaN(accuracy))
        accuracy = 0;
    accuracy *= 100;
    Text result = new Text(0, 0, activity.mFont,
        activity.getString(R.string.accureay) + ": "
        + String.format("%.2f", accuracy) + "%", BaseActivity
        .getSharedInstance().getVertexBufferObjectManager());

    final int x = (int) (mCamera.getWidth() / 2 - result.getWidth() / 2);
    final int y = (int) (mCamera.getHeight() / 2 - result.getHeight() / 2);

    done = false;
    result.setPosition(x, mCamera.getHeight() + result.getHeight());
    MoveYModifier mod = new MoveYModifier(5, result.getY(), y) {
        @Override
        protected void onModifierFinished(IEntity pItem) {
            done = true;
        }
    };
    attachChild(result);
    result.registerEntityModifier(mod);
    setOnSceneTouchListener(this);
}

You can see that we disabled the background making it as an overlay layer, the rest should be easy to understand, just notice that we have overridden a method inside the MoveYModifier to set the done flag to true when the movement is done, now the method onSceneTouchEvent would have those 4 lines:

if (!done)
    return true;
((GameScene) activity.mCurrentScene).resetValues();
return false;

Head back to the cleaner() method inside GameScene and add those lines on top inside of the synchronized block

// if all Enemies are killed
if (EnemyLayer.isEmpty()) {
    setChildScene(new ResultScene(mCamera));
    clearUpdateHandlers();
}

And we are done, run it and see the result of your work [also see how accurate you are at playing it :D]

Cleaning After Yourself:

Didn’t your mom teach you to clean after you are done working ? this is no exception !
we have to clean up when closing the game so the next time you run it it’ll work properly
[Thanks to BreakingFloor from the comments to notice a bug that caused this whole section thingie to be added]

GameScene again and add this detach() method:

public void detach() {
    Log.v("Jimvaders", "GameScene onDetached()");
    clearUpdateHandlers();
    for (Bullet b : bulletList) {
        BulletPool.sharedBulletPool().recyclePoolItem(b);
    }
    bulletList.clear();
    detachChildren();
    Ship.instance = null;
    EnemyPool.instance = null;
    BulletPool.instance = null;
}

And inside BaseActivity class [sorry I lied we opened this again :P] override onBackPressed() [this one gets called when back button is pressed] to be like this:

@Override
public void onBackPressed() {
    if (mCurrentScene instanceof GameScene)
        ((GameScene) mCurrentScene).detach();

    mCurrentScene = null;
    SensorListener.instance = null;
    super.onBackPressed();
}

This would call detach() method if you were on the GameScene which detaches all children including the EnemyLayer calling onDetach() inside it cleaning it up 😀

BONUS ! Explosion Effect Using Particle System

Explosions are always a good thing , no exceptions ! so I added this chapter because I thought that the game was missing explosion.
I wrote a method that would create an explosion effect on any coordinate you provide on any target [Scene for example] you specify.
It’s a general method, you can place it in any class [I didn’t really think about where to put it] so I placed it in GameScene, add the following there

private void createExplosion(final float posX, final float posY, final IEntity target, final SimpleBaseGameActivity activity) {

}

To create an explosion effect we would need 3 main things

1. Particle emitter
2. Particle system
3. timeHandler to remove the system

But in our case, we’ll need to create an IEntityFactory too for our Rectangular particles .. it’s basically something that would provide small green rectangles to give an effect that the enemy exploded! [little shards of the enemy]
[NOTE: you can use sprites instead of small rectangles, Check the AndEngine Simple particle example in the AndEngine Examples to get an idea of how to use sprites, should be easy when you are done with this].
The following code does that

int mNumPart = 15;
int mTimePart = 2;

PointParticleEmitter particleEmitter = new PointParticleEmitter(posX,posY);
IEntityFactory recFact = new IEntityFactory() {
    @Override
    public Rectangle create(float pX, float pY) {
        Rectangle rect = new Rectangle(posX, posY, 10, 10, activity.getVertexBufferObjectManager());
        rect.setColor(Color.GREEN);
        return rect;
    }
};
final ParticleSystem particleSystem = new ParticleSystem( recFact, particleEmitter, 500, 500, mNumPart);

We have 15 particles emitting at a rate of 500 [we set both the minimum and maximum rate to 500] you can mess around with those numbers to get different effects .. chose whatever you like [do that when we are done with this chapter so you can see the effect :P].

We’ll have our particles go into random directions while rotating and fade out [change Alpha value] at the same time, the particle system would last for a period of 2 seconds [the mTimePart] so we’ll have the particles fade out before the particle system gets removed so we don’t get a sudden disappearing effect.

particleSystem.addParticleInitializer(new VelocityParticleInitializer(-50, 50, -50, 50));

particleSystem.addParticleModifier(new AlphaParticleModifier(0,0.6f * mTimePart, 1, 0));
particleSystem.addParticleModifier(new RotationParticleModifier(0, mTimePart, 0, 360));

target.attachChild(particleSystem);

The velocity range is being set to -50 and 50 for x and y as max and min [it gets chosen by the system] for each particle so we may get any combination, that’s an Initializer so it modifies the particle before it gets emitted.
Next we have the the system change the Alpha value of each particle from visible 1 to invisible 0 , for a duration of 1.2 [0.6 * 2 = 1.2] seconds and have each particle rotate while moving too.
Even though this is happening very fast and people might not notice those stuff, but giving attention to small things makes a better product [says the guy who is using rectangles instead of image sprites :P]
Now we have to make sure we remove the particle system from the target [in our case we’ll be adding them to the EnemyLayer], we’ll do that using a timeHandler like we did with the CoolDown

target.registerUpdateHandler(new TimerHandler(mTimePart, new ITimerCallback() {
    @Override
    public void onTimePassed(final TimerHandler pTimerHandler) {
        particleSystem.detachSelf();
        target.sortChildren();
        target.unregisterUpdateHandler(pTimerHandler);
    }
}));

Lastly , go to the part where you remove and recycle the the enemies inside the cleaner() method and add this line at the top of the if statement [before you recycle it !]

createExplosion(e.sprite.getX(), e.sprite.getY(), e.sprite.getParent(), BaseActivity.getSharedInstance());

You might also wanna clearUpdateHandler() on your onDetach() method inside the EnemyLayer class just to be safe, enjoy explosions !

Final words (and full project source code):

The tutorial ends here, remember that the whole idea of this project was to create a game without using any sprites and to use OOP, then I decided to write a tutorial about it .. so it may not be THAT good cause it wasn’t a tutorial in the first place.
I do feel that I didn’t give this tutorial the attention it needed and that it’s not that clear [and feels kinda boring] but that’s the best I could do at the moment.

The full project is available here or on github.

And as always, if there was something wrong or something unclear [or missing] then don’t hesitate to drop a comment telling me about it [even for spelling errors !].
Good luck in your games development !

Note: sometimes when closing the game it crashes [about once in 10 times] from inside the Engine’s code, I’m not exactly sure why is that happening and don’t really have the time to look at it for now .. if you figured why is this happening drop a comment explaining it and I’ll update the post and credit you.