AndEngine Simple Android Game Tutorial

WARNING: This is an outdated tutorial for the old AndEngine GLES1.0, if you want a tutorial for the new GLES2.0 then Check my Jimvaders tutorial ..

After playing around with the Android SDK , I thought that I should give game development a test drive. After giving Cocos2D a test, I faced the problem of online support, almost all the tutorials I found online were for the iOS version.. so I looked for other Engines made for Android.

AndEngine is an awesome game engine I found, but I couldn’t find a whole game tutorial.. so I thought that I’d port Dan’s simple Android Game tutorial (that’s actually ported from Ray’s iPhone cocos2D tutorial)

This tutorial will cover:
– Adding/Removing sprites
– Using timeHandlers
– Moving sprites
– Using Sound/Music
– Pausing/Resuming your game
– Simple collision detection

Preparing your tools

Before we start coding, we need to make sure that you have Eclipse and Android SDK installed, if not then use google’s guide for that. You should also give this Hello World example a go to make sure that the SDK installed correctly. You also need need a real Android device, the emulator is far too slow to test on .

Java is essential, if you don’t know Java you may get lost in the middle, also take a look at Android’s Activity life cycle just to have an idea about the order of stuff in there.

If you wanna make sure you are using the latest version of AndEngine, follow this tutorial to build your own jar file AndEngine has moved from Google Code, thus the tutorial linked won’t work anymore you can just download the one I’m using from here, or you can follow my tutorial of getting GLES2.0 but chose master instead [you won’t be using a jar file in that case though].

Let’s get started !

Create a new Android project, I chose Android 1.6 [SDK 4] but this should work on any version.
place the andengine.jar file inside the lib folder (if it doesn’t exist, then create it) and right click on it (from inside eclipse) and select build path -> add to build path.
create a new class, make it extends BaseGameActivity. [Eclipse hint: type BaseGame in the superclass field then ctrl+space for auto complete]

now you should have a class with 4 methods in it
declare those global variables

private Camera mCamera;
private Scene mMainScene;

and this is onLoadEngine()

public Engine onLoadEngine() {

final Display display = getWindowManager().getDefaultDisplay();
    int cameraWidth = display.getWidth();
    int cameraHeight = display.getHeight();

    mCamera = new Camera(0, 0, cameraWidth, cameraHeight);

    return new Engine(new EngineOptions(true, ScreenOrientation.LANDSCAPE,
        new RatioResolutionPolicy(cameraWidth, cameraHeight), mCamera));
}

what we did here is that we prepared the Engine by giving it the proper resolution for the device we are using, the camera represents the the rectangular viewable part of the scene, basically it’s what you see on the screen.

and onLoadScene()

public Scene onLoadScene() {
    mEngine.registerUpdateHandler(new FPSLogger());

    mMainScene = new Scene();
    mMainScene
        .setBackground(new ColorBackground(0.09804f, 0.6274f, 0.8784f));
    return mMainScene;
}

also add these permissions in the manifest

<uses-permission android:name="android.permission.WAKE_LOCK"/>
<uses-permission android:name="android.permission.CAMERA"/>

then run, you should see a blue screen like this

which means that the engine is working fine

Sprites ? we has them (Adding a sprite)

Sprites are 2D images that represents the stuff you see on the screen, they can be characters, bullets, or a background image.
in our game, we’ll need 3 main sprites: Player, target, projectiles(bullets). Aat first we’d need to have images for those, you can use your own images .. or use the ones provided by Ray’s wife Player, Projectile, Target. Go to your assets folder in the project , create a new folder and name it “gfx” and place them inside.

now let’s add the Player’s sprite, we will have it at the left side of the screen, in the middle .. let’s do that !

let’s declare those object :

private BitmapTextureAtlas mBitmapTextureAtlas;
private TextureRegion mPlayerTextureRegion;
private Sprite player;

and this will be our onLoadResources()

public void onLoadResources() {
    mBitmapTextureAtlas = new BitmapTextureAtlas(512, 512,
        TextureOptions.BILINEAR_PREMULTIPLYALPHA);

    BitmapTextureAtlasTextureRegionFactory.setAssetBasePath("gfx/");

    mPlayerTextureRegion = BitmapTextureAtlasTextureRegionFactory
        .createFromAsset(this.mBitmapTextureAtlas, this, "Player.png",
        0, 0);
    mEngine.getTextureManager().loadTexture(mBitmapTextureAtlas);

}

imagine the BitmapTextureAtlas as a board where you stick pictures on it, we defined it’s resolution to be 512 x 512 pixels and it needs to be a power of 2 (we will need those other areas later).We then set the assets path to be in “gfx/”, you can skip that line but when defining the mPlayerTextureRegion, you’d have to define a full path to the image.

we add more stuff to onLoadScene(), at first we calculate the position of the sprite and create a new player sprite

final int PlayerX = this.mPlayerTextureRegion.getWidth() / 2;
final int PlayerY = (int) ((mCamera.getHeight() - mPlayerTextureRegion
    .getHeight()) / 2);

player = new Sprite(PlayerX, PlayerY, mPlayerTextureRegion);

The Sprite looks kinda small on my screen, so I added this

player.setScale(2);

and then we attach the sprite to our main scene

mMainScene.attachChild(player);

And test it , w00t we have our mighty ninja waiting for stuff to kill [Ninjas are cool regardless of what they are doing]

Any challengers ? (Moving sprites)

Our ninja is bored, he needs some action and we are gonna provide that. we’ll have some moving targets coming from the right side to the left side of the screen.

we’ll need more objects, so declare those

private TextureRegion mTargetTextureRegion;
private LinkedList targetLL;
private LinkedList TargetsToBeAdded;

and add this to the onLoadResources()before loading texture in the engine

mTargetTextureRegion = BitmapTextureAtlasTextureRegionFactory
    .createFromAsset(this.mBitmapTextureAtlas, this, "Target.png",
    128, 0);

and inside onLoadScene(), append the following after mMainScene.attachChild(player)

targetLL = new LinkedList();
TargetsToBeAdded = new LinkedList();

then add this method to the class:

public void addTarget() {
    Random rand = new Random();

    int x = (int) mCamera.getWidth() + mTargetTextureRegion.getWidth();
    int minY = mTargetTextureRegion.getHeight();
    int maxY = (int) (mCamera.getHeight() - mTargetTextureRegion
        .getHeight());
    int rangeY = maxY - minY;
    int y = rand.nextInt(rangeY) + minY;

    Sprite target = new Sprite(x, y, mTargetTextureRegion.deepCopy());
    mMainScene.attachChild(target);

    int minDuration = 2;
    int maxDuration = 4;
    int rangeDuration = maxDuration - minDuration;
    int actualDuration = rand.nextInt(rangeDuration) + minDuration;

    MoveXModifier mod = new MoveXModifier(actualDuration, target.getX(),
        -target.getWidth());
    target.registerEntityModifier(mod.deepCopy());

    TargetsToBeAdded.add(target);

}

I kind of copied this method from Dan’s tutorial and modified it a li’l bit, so basically we are determining the minimum and maximum y position for the targets to appear at then use the Random() class to generate a random number so the value of y is still on the screen while the x value places the sprite just before the right side of the screen.

The targets also have a random speed between 2 to 4 seconds to cross the screen, so this won’t be affected by the size of the screen to make the game easier.

MoveXModifier is a modifier that makes the targets move horizontally (across the x-axis). [note: if eclipse complained about deepCopy(), change it to clone() .. deepCopy() was introduced later in AndEngine]

we’ll talk about those linked lists later on.

Now we need to periodically call the addTarget() function, we do this by using this TimeHandler

private void createSpriteSpawnTimeHandler() {
    TimerHandler spriteTimerHandler;
    float mEffectSpawnDelay = 1f;

    spriteTimerHandler = new TimerHandler(mEffectSpawnDelay, true,
    new ITimerCallback() {

        @Override
        public void onTimePassed(TimerHandler pTimerHandler) {
            addTarget();
        }
    });

    getEngine().registerUpdateHandler(spriteTimerHandler);
}

This will be recalled every 1 second.

Call it at the end of onLoadScene()

createSpriteSpawnTimeHandler();

Test, you’ll have targets coming from the right side of the screen and disappearing in the left side .. our Ninja got company!

Can I kill them now ? (removing sprites)

Not quite yet, we are missing something. The targets move from the right side to the left side, but when they leave the screen [the camera] they stop just outside, they still exist [in the scene] but just outside .. we gotta fix that.

At first, let’s create a new method to delete a sprite safely

public void removeSprite(final Sprite _sprite, Iterator it) {
    runOnUpdateThread(new Runnable() {

        @Override
        public void run() {
            mMainScene.detachChild(_sprite);
        }
    });
    it.remove();
}

That way, we won’t interrupt the work of the engine drawing when we remove the sprites

Now let’s check all targets every frame, we’ll use this

IUpdateHandler detect = new IUpdateHandler() {
    @Override
    public void reset() {
    }

    @Override
    public void onUpdate(float pSecondsElapsed) {

        Iterator<Sprite> targets = targetLL.iterator();
        Sprite _target;

        while (targets.hasNext()) {
            _target = targets.next();
            if (_target.getX() <= -_target.getWidth()) {
                removeSprite(_target, targets);
            }
        }
        targetLL.addAll(TargetsToBeAdded);
        TargetsToBeAdded.clear();
    }
};

We used an iterator as it seems the safest way to modify a linked list using the remove() method, and if the target left the screen , we simply call removeSprite to delete it. We iterate over targetLL, and then we add everything from the TargetsToBeAdded and clear it, I did this as a workaround cause I was getting ConcurrentModificationException, this way we won’t interrupt the work of spawning targets.

Now let’s register the update handler, append this to the end of onLoadScene()

mMainScene.registerUpdateHandler(detect);

What about now ? (handling touch input)

We first gotta equip our ninja with a weapon, did I hear shurikens ?
add this to our objects

private LinkedList projectileLL;
private LinkedList projectilesToBeAdded;
private TextureRegion mProjectileTextureRegion;

And in onLoadResources()

mProjectileTextureRegion = BitmapTextureAtlasTextureRegionFactory
    .createFromAsset(this.mBitmapTextureAtlas, this,
    "Projectile.png", 64, 0);

onLoadScene

projectileLL = new LinkedList();
projectilesToBeAdded = new LinkedList();

Then we’ll need this method to shoot targets

private void shootProjectile(final float pX, final float pY) {

    int offX = (int) (pX - player.getX());
    int offY = (int) (pY - player.getY());
    if (offX <= 0)
        return;

    final Sprite projectile;
    projectile = new Sprite(player.getX(), player.getY(),
    mProjectileTextureRegion.deepCopy());
    mMainScene.attachChild(projectile, 1);

    int realX = (int) (mCamera.getWidth() + projectile.getWidth() / 2.0f);
    float ratio = (float) offY / (float) offX;
    int realY = (int) ((realX * ratio) + projectile.getY());

    int offRealX = (int) (realX - projectile.getX());
    int offRealY = (int) (realY - projectile.getY());
    float length = (float) Math.sqrt((offRealX * offRealX)
        + (offRealY * offRealY));
    float velocity = 480.0f / 1.0f; // 480 pixels / 1 sec
    float realMoveDuration = length / velocity;

    MoveModifier mod = new MoveModifier(realMoveDuration,
    projectile.getX(), realX, projectile.getY(), realY);
    projectile.registerEntityModifier(mod.deepCopy());

    projectilesToBeAdded.add(projectile);
}

The method would bail out if we shot backward..

Am kinda too lazy to explain this , so I’ll just “borrow” [read:steal] from Dan’s tutorial

This should look familiar to anyone who didn’t fall asleep in maths class – Pythagoras! Now before we fall asleep with yet more theory, let’s start coding. In the constructor add the following line:

We create the sprite and position it over the ninja. We then work out where the projectile should move to by extending the tap off the screen. This is done by getting the X and Y offset of the tap to the projectile’s starting position. We then get the ratio of Y to X, and simply scale the touch Y coordinate to match the scaled up X coordinate (which is just off the screen).

After working out the destination, we need to work out the duration of the movement – we can’t have projectiles taking different amounts of time just because of the angle they’re shot at. To solve this problem we use Pythagoras to work out the distance the projectile needs to travel, then divide that by the velocity we want. This is because velocity = distance over time, or by re-arranging: time = distance over velocity.

Got it ? 😛

Now we’ll need to receive touch events, that will be done by having our main class implement IOnSceneTouchListener
Assuming your activity is called AndEngineSimpleGame, it should be like this

public class AndEngineSimpleGame extends BaseGameActivity implements
    IOnSceneTouchListener {

Which will add the method onSceneTouchEvent, that goes like

public boolean onSceneTouchEvent(Scene pScene, TouchEvent pSceneTouchEvent) {

    if (pSceneTouchEvent.getAction() == TouchEvent.ACTION_DOWN) {
        final float touchX = pSceneTouchEvent.getX();
        final float touchY = pSceneTouchEvent.getY();
        shootProjectile(touchX, touchY);
        return true;
    }
    return false;
}

We are only tracking tapping events. Next we put this at the end of onLoadScene()

mMainScene.setOnSceneTouchListener(this);

Run and tap on the screen, our Ninja is a shuriken master !

But .. But .. They are not dying ! (collision detection)

Oh right ! about that  we’ll get to that now..
As you should’ve already noticed , we didn’t clean up after the projectiles , they are just leaving the screen and staying there .. we’ll do that with our basic collision detection.

Just update your detect IUpdateHandler to this one:

IUpdateHandler detect = new IUpdateHandler() {
    @Override
    public void reset() {
    }

    @Override
    public void onUpdate(float pSecondsElapsed) {

        Iterator<Sprite> targets = targetLL.iterator();
        Sprite _target;
        boolean hit = false;

        while (targets.hasNext()) {
            _target = targets.next();

            if (_target.getX() <= -_target.getWidth()) {
                removeSprite(_target, targets);
                break;
            }
            Iterator<Sprite> projectiles = projectileLL.iterator();
            Sprite _projectile;
            while (projectiles.hasNext()) {
                _projectile = projectiles.next();

                if (_projectile.getX() >= mCamera.getWidth()
                    || _projectile.getY() >= mCamera.getHeight()
                    + _projectile.getHeight()
                    || _projectile.getY() <= -_projectile.getHeight()) {
                        removeSprite(_projectile, projectiles);
                        continue;
                }

                if (_target.collidesWith(_projectile)) {
                    removeSprite(_projectile, projectiles);
                    hit = true;
                    break;
                }
            }

            if (hit) {
                removeSprite(_target, targets);
                hit = false;
            }

        }
        projectileLL.addAll(projectilesToBeAdded);
        projectilesToBeAdded.clear();

        targetLL.addAll(TargetsToBeAdded);
        TargetsToBeAdded.clear();
    }
};

We Loop over all projectiles for every loop over targets, at first we check if the projectile left the screen , if it did then we remove it and continue to the next projectile, if not then we check if they collide or not.

We are assuming here that if a projectile did hit a target, it’d hit one and only one target that’s why we break out of the loop after the collision, we remove the target after the loop.

Using the same technique we used for targets, we avoided the exception [and used more resources]

Give it a test now and let our Ninja enjoy killing those ghosts thingies.

I Have Ears ! (Sound/Music)

Oh, you want some sounds ? ok then .. you shall be given.

We’ll add two sounds, an effect for shooting and a background music, you can use your own audio files or use the ones provided by Ray [and taken from Dan’s site] background music, , pew pew sound effect [note: apparently AndEngine better uses .ogg files, but those wav files worked fine for me].

Place those files in “assets/mfx/” after extracting them , and let’s start editing our code ! [I renamed the “background_music_aac.wav” file to “background_music.wav” do so or make sure you fix that in the code unless you like clicking the famous Force Close button]

In onLoadEngine(), replace the return statement with this one

return new Engine(new EngineOptions(true, ScreenOrientation.LANDSCAPE,
    new RatioResolutionPolicy(cameraWidth, cameraHeight), mCamera)
    .setNeedsMusic(true).setNeedsSound(true));

Declare those

private Sound shootingSound;
private Music backgroundMusic;

Then add this to onLoadResources()

SoundFactory.setAssetBasePath("mfx/");
try {
    shootingSound = SoundFactory.createSoundFromAsset(mEngine
        .getSoundManager(), this, "pew_pew_lei.wav");
} catch (IllegalStateException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

MusicFactory.setAssetBasePath("mfx/");

try {
    backgroundMusic = MusicFactory.createMusicFromAsset(mEngine
        .getMusicManager(), this, "background_music.wav");
    backgroundMusic.setLooping(true);
} catch (IllegalStateException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

Notice that backgroundMusic is set to be looping

Add backgroundMusic.play() before the return statement of onLoadScene() and shootingSound.play() at the end of shootProjectile(), test and hear the wrath of the ninja .. or the pew pew of the ninja.

Hold on a sec ! (Pausing)

Before you continue, let’s pause the game first .. umm .. guess we need to implement that, here goes nothing.

[note: pausing the game is entirely copied from the AndEngine Eamples].

First , let’s download the pause image from the AndEngine Example and place it in the “assets/gfx/”  then declare those

private TextureRegion mPausedTextureRegion;
private CameraScene mPauseScene;

A CameraScene from my understanding is a scene that only appears on the current camera, imagine it as a layer above the current scene.

Add this to onLoadResources()

mPausedTextureRegion = BitmapTextureAtlasTextureRegionFactory
    .createFromAsset(this.mBitmapTextureAtlas, this, "paused.png",
    0, 64);

onLoadScene() now have this

mPauseScene = new CameraScene(mCamera);
final int x = (int) (mCamera.getWidth() / 2 - mPausedTextureRegion
    .getWidth() / 2);
final int y = (int) (mCamera.getHeight() / 2 - mPausedTextureRegion
    .getHeight() / 2);
final Sprite pausedSprite = new Sprite(x, y, mPausedTextureRegion);
mPauseScene.attachChild(pausedSprite);
mPauseScene.setBackgroundEnabled(false);

We initialized the mPauseScene by having a sprite that says “paused” in the middle, and made it transparent by disabling the background

Create a new methods

public void pauseGame() {
    mMainScene.setChildScene(mPauseScene, false, true, true);
    mEngine.stop();
}

public void unPauseGame() {
    mMainScene.clearChildScene();
    mEngine.start();
}

public void pauseMusic() {
    if (backgroundMusic.isPlaying())
        backgroundMusic.pause();
}

public void resumeMusic() {
    if (!backgroundMusic.isPlaying())
        backgroundMusic.resume();
}

Having these as a methods would come in handy later on, they are self explanatory you can figure out what they do yourself.

Then add this method overriding

@Override
public boolean onKeyDown(final int pKeyCode, final KeyEvent pEvent) {
    if (pKeyCode == KeyEvent.KEYCODE_MENU
        && pEvent.getAction() == KeyEvent.ACTION_DOWN) {
        if (mEngine.isRunning()) {
            pauseMusic();
            pauseGame();
            Toast.makeText(this, "Menu button to resume",
                Toast.LENGTH_SHORT).show();
        } else {
            unPauseGame();
            resumeMusic();
        }
        return true;
    }
    return super.onKeyDown(pKeyCode, pEvent);
}

If the Menu button is clicked while the engine is running, pause the game [and show that toast] , else resume the game .. give it a try

PWND ! (Win/Fail and Finishing touches)

Game is boring if you can’t win (or lose) , let’s add those aspects to our li’l game, first download those images for Win/Fail that my friend Mazyod created [and place them in “assets/gfx/”] , then declare those

private CameraScene mResultScene;
private boolean runningFlag = false;
private boolean pauseFlag = false;
private BitmapTextureAtlas mFontTexture;
private Font mFont;
private ChangeableText score;
private int hitCount;
private final int maxScore = 10;
private Sprite winSprite;
private Sprite failSprite;
private TextureRegion mWinTextureRegion;
private TextureRegion mFailTextureRegion;

Changeabletext and Font are used to display your current score, you already know the rest.

Inside onLoadResources(), let’s add this

mWinTextureRegion = BitmapTextureAtlasTextureRegionFactory
    .createFromAsset(this.mBitmapTextureAtlas, this, "win.png", 0,
    128);
mFailTextureRegion = BitmapTextureAtlasTextureRegionFactory
    .createFromAsset(this.mBitmapTextureAtlas, this, "fail.png", 0,
    256);

mEngine.getTextureManager().loadTexture(mBitmapTextureAtlas);
mFontTexture = new BitmapTextureAtlas(256, 256,
    TextureOptions.BILINEAR_PREMULTIPLYALPHA);
mFont = new Font(mFontTexture, Typeface.create(Typeface.DEFAULT,
    Typeface.BOLD), 40, true, Color.BLACK);
mEngine.getTextureManager().loadTexture(mFontTexture);
mEngine.getFontManager().loadFont(mFont);

onLoadScene() gets this

mResultScene = new CameraScene(mCamera);
winSprite = new Sprite(x, y, mWinTextureRegion);
failSprite = new Sprite(x, y, mFailTextureRegion);
mResultScene.attachChild(winSprite);
mResultScene.attachChild(failSprite);
mResultScene.setBackgroundEnabled(false);

winSprite.setVisible(false);
failSprite.setVisible(false);
score = new ChangeableText(0, 0, mFont, String.valueOf(maxScore));
score.setPosition(mCamera.getWidth() - score.getWidth() - 5, 5);

Add this method to reset everything to default

public void restart() {

    runOnUpdateThread(new Runnable() {

        @Override
        public void run() {
            mMainScene.detachChildren();
            mMainScene.attachChild(player, 0);
            mMainScene.attachChild(score);
        }
    });

    hitCount = 0;
    score.setText(String.valueOf(hitCount));
    projectileLL.clear();
    projectilesToBeAdded.clear();
    TargetsToBeAdded.clear();
    targetLL.clear();
}

Make sure you call it before the return statement of onLoadScene() so the score shows.

Your win/fail methods would be something like this

public void fail() {
   if (mEngine.isRunning()) {
        winSprite.setVisible(false);
        failSprite.setVisible(true);
        mMainScene.setChildScene(mResultScene, false, true, true);
        mEngine.stop();
    }
}

public void win() {
    if (mEngine.isRunning()) {
        failSprite.setVisible(false);
        winSprite.setVisible(true);
        mMainScene.setChildScene(mResultScene, false, true, true);
        mEngine.stop();
    }
}

In the detect updateHandler add this inside the if(hit)

hitCount++;
score.setText(String.valueOf(hitCount));

And this at the end of the while loop

if (hitCount >= maxScore) {
    win();
}

Make sure you also call fail() in the “if (_target.getX() <= -_target.getWidth())” method before the break

Check for runningFlag when pausing and resuming music

public void pauseMusic() {
    if (runningFlag)
        if (backgroundMusic.isPlaying())
            backgroundMusic.pause();
}

public void resumeMusic() {
    if (runningFlag)
        if (!backgroundMusic.isPlaying())
            backgroundMusic.resume();
}

Your onKeyDown override should be changed to this

@Override
public boolean onKeyDown(final int pKeyCode, final KeyEvent pEvent) {
    if (pKeyCode == KeyEvent.KEYCODE_MENU
        && pEvent.getAction() == KeyEvent.ACTION_DOWN) {
        if (mEngine.isRunning() && backgroundMusic.isPlaying()) {
            pauseMusic();
            pauseGame();
            Toast.makeText(this, "Menu button to resume",
                Toast.LENGTH_SHORT).show();
        } else {
             if (!backgroundMusic.isPlaying()) {
             resumeMusic();
             mEngine.start();
        }
        return true;
    }
} else if (pKeyCode == KeyEvent.KEYCODE_BACK
        && pEvent.getAction() == KeyEvent.ACTION_DOWN) {

        if (!mEngine.isRunning() && backgroundMusic.isPlaying()) {
            mMainScene.clearChildScene();
            mEngine.start();
            restart();
            return true;
        }
        return super.onKeyDown(pKeyCode, pEvent);
    }
    return super.onKeyDown(pKeyCode, pEvent);
}

Notice we are changing the function of the back key to resume game you get a win/fail scene.

Now you should be able to win/fail the game and make your ninja happy [not really for the happy part]

After Finishing Touches

Well .. I noticed that the game was behaving weird when you click on the home button .. so here’s some stuff regarding AndEngine’s lifecycle taken from the forums

launch game
1) onLoadEngine()
2) onResume()
3) onLoadResources()
4) onLoadScene()
5) onLoadComplete()
6) onResumeGame()

during game, go to homescreen
1) onPause()

return to game
1) onResume()
2) onResumeGame()

exit game with this.finish()
1) onPause()
2) onDestroy()

So we need to mess around with onResumeGame() and onPause()

onResumeGame() would be this

@Override
public void onResumeGame() {
    super.onResumeGame();
    if (runningFlag) {
        if (pauseFlag) {
            pauseFlag = false;
            Toast.makeText(this, "Menu button to resume",
            Toast.LENGTH_SHORT).show();
        } else {
            resumeMusic();
            mEngine.stop();
        }
    } else {
        runningFlag = true;
    }
}

Apparently , super.onResumeGame() changes the state of mEngine to running , so we had to stop it again in here

And onPause()

@Override
protected void onPause() {
    if (runningFlag) {
        pauseMusic();
        if (mEngine.isRunning()) {
            pauseGame();
            pauseFlag = true;
        }
    }
    super.onPause();
}

And onKeyDown gets changed a li’l bit again, set the pauseFlag to true after you call pauseGame(), and to false after you unPauseGame() it, which will be

@Override
public boolean onKeyDown(final int pKeyCode, final KeyEvent pEvent) {
    if (pKeyCode == KeyEvent.KEYCODE_MENU
        && pEvent.getAction() == KeyEvent.ACTION_DOWN) {
        if (mEngine.isRunning() && backgroundMusic.isPlaying()) {
            pauseMusic();
            pauseFlag = true;
            pauseGame();
            Toast.makeText(this, "Menu button to resume",
                Toast.LENGTH_SHORT).show();
        } else {
            if (!backgroundMusic.isPlaying()) {
                unPauseGame();
                pauseFlag = false;
                resumeMusic();
                mEngine.start();
            }
            return true;
        }
    } else if (pKeyCode == KeyEvent.KEYCODE_BACK
            && pEvent.getAction() == KeyEvent.ACTION_DOWN) {

        if (!mEngine.isRunning() && backgroundMusic.isPlaying()) {
            mMainScene.clearChildScene();
            mEngine.start();
            restart();
            return true;
        }
        return super.onKeyDown(pKeyCode, pEvent);
    }
    return super.onKeyDown(pKeyCode, pEvent);
}

That should clear it for you, everything should be working fine and your ninja should be happy [even if he doesn’t smile] killing those nasty ghosts.

tl;dr gimme the source code !

Ok fine >_> [even though I did spend quite a lot of time writing this ..]

here you go , the whole project with comments

Now what ?

Well .. you broke the barrier of creating games, that’s something [and you have a happy frowning ninja too] , check out the other examples by AndEngine and hit the forums for help.

This was my first tutorial and first blog post too [and was actually my first AndEngine project too XD], I hope you have enjoyed it. If you noticed any mistake or know of a way to do stuff in a better way leave a comment !

you can also follow up with the second post about using pools

Setting up AndEngine GLES2.0