In this article we will learn how to develop a catching game using
andEngine. There are following steps :

Step :1 Create a project using motodev.

Step :2 Integrate andengine.jar in the library(Please check our previous article if you are facing any problem to integrate it.)

Step :3: Create the MainGame.java activity file and put following code in it :

package com.MangoCatcher;

import java.util.ArrayList;

import org.anddev.andengine.engine.Engine;
import org.anddev.andengine.engine.camera.Camera;
import org.anddev.andengine.engine.handler.IUpdateHandler;
import org.anddev.andengine.engine.options.EngineOptions;
import org.anddev.andengine.engine.options.EngineOptions.ScreenOrientation;
import org.anddev.andengine.engine.options.resolutionpolicy.RatioResolutionPolicy;
import org.anddev.andengine.entity.scene.Scene;
import org.anddev.andengine.entity.scene.Scene.IOnSceneTouchListener;
import org.anddev.andengine.entity.sprite.Sprite;
import org.anddev.andengine.entity.util.FPSLogger;
import org.anddev.andengine.input.touch.TouchEvent;
import org.anddev.andengine.opengl.texture.Texture;
import org.anddev.andengine.opengl.texture.region.TextureRegion;
import org.anddev.andengine.opengl.texture.region.TextureRegionFactory;
import java.util.Random;
import org.anddev.andengine.ui.activity.BaseGameActivity;

public class MainGame extends BaseGameActivity implements IOnSceneTouchListener {
	public static MainGame _main;
    public static final int CAMERA_WIDTH = 480;
    public static final int CAMERA_HEIGHT = 800;
    private static Camera _camera;
	private TextureRegion _basketTextureRegion;
	private TextureRegion _mangoTextureRegion;
	private Sprite _basketSprite;
	private ArrayList _mangoesArray = new ArrayList();
	private int _score = 0;

    public Engine onLoadEngine() {
    	_main = this;
    	MainGame._camera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);
        Engine _engine = new Engine(new EngineOptions(true, ScreenOrientation.PORTRAIT,new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT),MainGame._camera));
        return _engine;
    }

    /*
     * loading the resources.
     * @see org.anddev.andengine.ui.IGameInterface#onLoadResources()
     */

    public void onLoadResources() {
    	Texture texture = new Texture(256, 128);
    	_basketTextureRegion   = TextureRegionFactory.createFromAsset(texture, this, "gfx/basket.png", 0, 0);
    	_mangoTextureRegion = TextureRegionFactory.createFromAsset(texture, this, "gfx/mango.png", 125, 0);
    	this.mEngine.getTextureManager().loadTexture(texture);
    	this.onLoadSprites();
    }

    /*
     * Loading Sprites of textures
     */
    public void onLoadSprites() {
    	_basketSprite = new Sprite(getScreenCenterX(_basketTextureRegion.getWidth()), CAMERA_HEIGHT - _basketTextureRegion.getHeight(), _basketTextureRegion);
    }

    /*
     * Updating the mangoes positions.
     * Adding mangoes in the scene
     * @see org.anddev.andengine.ui.IGameInterface#onLoadScene()
     */
	@Override
    public Scene onLoadScene() {
        this.mEngine.registerUpdateHandler(new FPSLogger());
        final Scene scene = new Scene(1);
        scene.getTopLayer().addEntity(_basketSprite);
        scene.registerUpdateHandler(new IUpdateHandler() {
        	private long lastRaindropAdd = 0;
			@Override
        	public void onUpdate(final float pSecondsElapsed) {
				upDateMangoPoistion(scene);
        		if (System.currentTimeMillis() - lastRaindropAdd  > 3000) {
        			lastRaindropAdd = System.currentTimeMillis();
        			addMangoes(scene);
        		}
            }

			@Override
			public void reset() {

			}
        });

        scene.setOnSceneTouchListener(this);
        return scene;
    }
	/*
     * Updating the mangoes positions.
     */
	private void upDateMangoPoistion(Scene scene){
		int size = _mangoesArray.size();
		for (int i = 0; i < size; i++)
		{
			Sprite raindrop = _mangoesArray.get(i);
			raindrop.setPosition(raindrop.getX(), raindrop.getY() + 5);
			if (raindrop.collidesWith(_basketSprite)) {
				_score++;
				System.out.println("Score: " + _score);
				synchronized(raindrop) {
					size--;
					_mangoesArray.remove(i);
					scene.getTopLayer().removeEntity(raindrop);
				}
			}

			else if (raindrop.getY() > CAMERA_HEIGHT) {
				_score--;
				System.out.println("Score: " + _score);
				synchronized(raindrop) {
					size--;
					_mangoesArray.remove(i);
					scene.getTopLayer().removeEntity(raindrop);
				}
			}
		}
	}

	/*
     * Adding mangoes in the scene
     */
	public void addMangoes(Scene scene){
		 int START = 1;
		 int END = 300;
		 Random random = new Random();
		 int randomInt = showRandomInteger(START, END, random);
		Sprite raindrop = getMango(randomInt, 0);
		_mangoesArray.add(raindrop);
		scene.getTopLayer().addEntity(raindrop);
	}

	/*
     * Getting the random x position for mangoes.
     */

	public int  showRandomInteger(int aStart, int aEnd, Random aRandom){
	    if ( aStart > aEnd ) {
	      throw new IllegalArgumentException("Start cannot exceed End.");
	    }
	    //get the range, casting to long to avoid overflow problems
	    long range = (long)aEnd - (long)aStart + 1;
	    // compute a fraction of the range, 0 <= frac < range
	    long fraction = (long)(range * aRandom.nextDouble());
	    int randomNumber =  (int)(fraction + aStart);
	     return randomNumber;
	  }

	/*
     * Getting the Sprite for mangoes.
     */

	public Sprite getMango(float x, float y) {
		return (new Sprite(x, y, _mangoTextureRegion.clone()));
	}

	/*
	 * (non-Javadoc)
	 * @see org.anddev.andengine.ui.IGameInterface#onLoadComplete()
	 */
	@Override
	public void onLoadComplete() {

	}

	/*
	 * On touch moving the basket
	 * @see org.anddev.andengine.entity.scene.Scene.IOnSceneTouchListener#onSceneTouchEvent(org.anddev.andengine.entity.scene.Scene, org.anddev.andengine.input.touch.TouchEvent)
	 */
	@Override
	public boolean onSceneTouchEvent(final Scene pScene, final TouchEvent pSceneTouchEvent) {
		this.runOnUpdateThread(new Runnable() {
			@Override
			public void run() {
				float touchX = pSceneTouchEvent.getX();
				_basketSprite.setPosition(touchX - _basketSprite.getWidth()/2, _basketSprite.getY());
			}
		});
		return true;
	}
	/*
     * Getting the Screens CenterX.
     */
	public float getScreenCenterX(float width) {
		return (CAMERA_WIDTH / 2) - width / 2;
	}
	/*
     * Getting the Screens CenterY.
     */
	public float getScreenCenterY(float height) {
		return (CAMERA_HEIGHT / 2) - height / 2;
	}
}

Step :4 put two png for Mango and the basket into assets/gfx folder.

Step :5 Run your app.

Attached is the source code of file.

Tags: alpha effect, An Android application, AndEngine, AndEngineGame, Android components, Android Game, animation in Android, Apple, Blinking effect, Game Programming, Key Event, Key Event handler, Movement, Splash screen, Timer, Touch, TouchEvent, Transition

In this article we are going to learn how to create a basic architecture of a game. I am using the flow :
1. Splash Screen : which will contain
a) Play Button
b) Quit Button

2. Level Selection Screen :
On touching play button , it will take player to the level
slection screen, where we have to show number of levels ,locked and unlocked levels etc.. In this screen I am showing following buttons
a) Level 1 Button
b) Level locked button
c) Back Button : to swich on previous levels screen
d) Up Button : to swich splash screen
e) Next Button : to swich on nextlevels screen

Use following steps to create the Game architecture using AndEngine :

Step :1 Create a motoDev Project.

Step : 2 Include the AndEngine in the project. Here is example how we import andengine in project.

Srep : 3 Create the GameController.java as the activity class.
put following code there :

package com.thegame;
import java.util.Date;
import javax.microedition.khronos.opengles.GL10;
import org.anddev.andengine.engine.Engine;
import org.anddev.andengine.engine.camera.Camera;
import org.anddev.andengine.engine.options.EngineOptions;
import org.anddev.andengine.engine.options.EngineOptions.ScreenOrientation;
import org.anddev.andengine.engine.options.resolutionpolicy.RatioResolutionPolicy;
import org.anddev.andengine.entity.scene.Scene;
import org.anddev.andengine.entity.sprite.Sprite;
import org.anddev.andengine.entity.util.FPSLogger;
import org.anddev.andengine.extension.physics.box2d.FixedStepPhysicsWorld;
import org.anddev.andengine.extension.physics.box2d.PhysicsWorld;
import org.anddev.andengine.input.touch.TouchEvent;
import org.anddev.andengine.opengl.texture.Texture;
import org.anddev.andengine.opengl.texture.TextureOptions;
import org.anddev.andengine.opengl.texture.region.TextureRegion;
import org.anddev.andengine.opengl.texture.region.TextureRegionFactory;
import org.anddev.andengine.ui.activity.BaseGameActivity;
import com.badlogic.gdx.math.Vector2;

public class GameController extends BaseGameActivity{

/*
* In this class we are going to handle the GameLogic.
* @param LevelController : This class is going to Manage the Levels.
*/
public LevelController _levelManager;
private Camera _camera;
protected PhysicsWorld _physicsWorld;
public Texture _texture;
public Texture _levelBtnTexture;
public TextureRegion _levelBtnTextureRegion;
static GameController _gameController;
public static GameController getInstance(){return _gameController;}

/*
* Here we are defining the texture and its region for various buttons.
* @param _backBtnTexture : Defing BACK button texture.
* @param _backBtnTextureRegion : Defing BACK button texture region.
* @param _upBtnTexture : Defing UP button texture.
* @param _upBtnTextureRegion : Defing UP button texture region.
*/

public Texture _backBtnTexture;
public TextureRegion _backBtnTextureRegion;
public Texture _upBtnTexture;
public TextureRegion _upBtnTextureRegion;
public Texture _nextBtnTexture;
public TextureRegion _nextBtnTextureRegion;
public Texture _navigationDisabledTexure;
public TextureRegion _btnNextDisableRegion;
public TextureRegion _btnBackDisableRegion;

/*
* Here we are defining the texture and its region for various level buttons.
* @param _level1Texture : Defing level 1 button texture.
* @param TextureRegion : Defing level 1 button texture region.
*
*/

public Texture _level1Texture;
public TextureRegion _levelBtnTextureRegion1;
public TextureRegion _levelBtnTextureRegionLocked;

public Texture mLevelSignTextures;
public TextureRegion mLevelCompletedRegion;
public TextureRegion mLevelUnCompletedRegion;

long lDateTime = -1;
int currentPage;

/*
* Here we areLoading the engine.
*
*
*/

@Override
public Engine onLoadEngine() {
currentPage = 0;
_gameController = this;
_levelManager = new LevelController(this);
_levelManager._cameraWidth = 460;
_levelManager._cameraHeight = 320;
_camera = new Camera(0, 0, _levelManager._cameraWidth, _levelManager._cameraHeight);
return new Engine(new EngineOptions(true, ScreenOrientation.LANDSCAPE, new RatioResolutionPolicy(_levelManager._cameraWidth, _levelManager._cameraHeight), _camera).setNeedsSound(true));
}

/*
* Here we areLoading the assets.
*
*
*/
@Override
public void onLoadResources() {
loadSplashButtonsTextures();
loadLevelSelectionScreenButtonsTexture();
this.mEngine.registerUpdateHandler(new FPSLogger());
this.mEngine.getTextureManager().loadTextures(this._navigationDisabledTexure, this._splashBtnTexture,this._levelBtnTexture
, this._backBtnTexture, this._upBtnTexture, this._nextBtnTexture, this._level1Texture);

}
/*
* Here we areLoading the assets for Splash Screen.
*
*
*/
public void loadSplashButtonsTextures(){
this._splashBtnTexture = new Texture(256, 256, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
this._playButtonTextureRegion = TextureRegionFactory.createFromAsset(this._splashBtnTexture, this, "gfx/playbtn.png", 0, 0);
this._quitBtnTextureRegion = TextureRegionFactory.createFromAsset(this._splashBtnTexture, this, "gfx/quitbtn.png", 0, 50);
}
/*
* Here we areLoading the assets for Level Selection Screen.
*
*
*/
public void loadLevelSelectionScreenButtonsTexture(){
loadLevelButton();
loadNavigationLevelSecelectionButtons();
}

/*
* Here we areLoading the assets for level Buttons.
*
*
*/
public void loadLevelButton(){
this._levelBtnTexture  = new Texture(128, 128, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
_levelBtnTextureRegion = TextureRegionFactory.createFromAsset(this._levelBtnTexture, this, "gfx/level1_btn.png", 0, 0);
_level1Texture = new Texture(512, 512, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
_levelBtnTextureRegion1 = TextureRegionFactory.createFromAsset(this._level1Texture, this, "gfx/level1_btn.png", 0, 0);
_levelBtnTextureRegionLocked = TextureRegionFactory.createFromAsset(this._level1Texture, this, "gfx/level_locked.png", 0, 128);
}

/*
* Here we areLoading the assets for navigation  Buttons.
*
*
*/

public void loadNavigationLevelSecelectionButtons(){
_backBtnTexture = new Texture(64, 64, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
_backBtnTextureRegion = TextureRegionFactory.createFromAsset(this._backBtnTexture, this, "gfx/back_btn.png", 0, 0);
_upBtnTexture = new Texture(64, 64, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
_upBtnTextureRegion = TextureRegionFactory.createFromAsset(this._upBtnTexture, this, "gfx/up_btn.png", 0, 0);
_nextBtnTexture = new Texture(64, 64, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
_nextBtnTextureRegion = TextureRegionFactory.createFromAsset(this._nextBtnTexture, this, "gfx/next_btn.png", 0, 0);
_navigationDisabledTexure = new Texture(256, 256, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
_btnBackDisableRegion = TextureRegionFactory.createFromAsset(this._navigationDisabledTexure, this, "gfx/back_disable_btn.png", 0, 0);
_btnNextDisableRegion = TextureRegionFactory.createFromAsset(this._navigationDisabledTexure, this, "gfx/next_disable_btn.png", 0, 64);

}
/*
* Here we areLoading the Level on touching level 1 button.
* It is the entry point of your game
*
*/

public Scene newGameLevelScene(int levelId){
Scene scene = new Scene(2);
this._physicsWorld = new FixedStepPhysicsWorld(60, new Vector2(0, 0), false);
_levelManager.loadLevel(levelId);
scene.registerUpdateHandler(this._physicsWorld);
return scene;
}

@Override
public Scene onLoadScene() {
return onLoadSplashScene();
}

@Override
public void onLoadComplete() {
// TODO Auto-generated method stub

}

final int con = 10;	//MENU
protected static final int MENU_PLAY = 0;
protected static final int MENU_QUIT = MENU_PLAY + 1;

private Texture _splashBtnTexture;
protected TextureRegion _playButtonTextureRegion;
protected TextureRegion _quitBtnTextureRegion;

public Scene onLoadSplashScene() {
return createSplashScene();

}

public boolean checkTouchTime(){

if(lDateTime == -1)
{
lDateTime = new Date().getTime();
return true;
}

long lDateCurrentTime = new Date().getTime();
if(lDateCurrentTime - lDateTime > 500)
{
lDateTime = lDateCurrentTime;
return true;
}
return false;
}
/*
* Here we are Createing assets for the quit screen .
*
*
*/
protected Scene createQuitScene() {

Scene scene = new Scene(2);
Sprite _buttonRef = new Sprite(100, 100, 150, 70, this.mMenuOkTextureRegion)
{
@Override
public boolean onAreaTouched(TouchEvent pSceneTouchEvent,float pTouchAreaLocalX, float pTouchAreaLocalY)
{
if(checkTouchTime())
GameController.getInstance().finish();

return true;
}
};

scene.registerTouchArea(_buttonRef);
scene.getTopLayer().addEntity(_buttonRef);

_buttonRef = new Sprite(100, 170, 150, 70, this.mMenuBackTextureRegion)
{
@Override
public boolean onAreaTouched(TouchEvent pSceneTouchEvent,float pTouchAreaLocalX, float pTouchAreaLocalY)
{
if(checkTouchTime())
GameController.getInstance().mEngine.setScene(GameController.getInstance().createSplashScene());
return true;
}
};
scene.registerTouchArea(_buttonRef);
scene.getTopLayer().addEntity(_buttonRef);
return scene;
}

/*
* Here we are Createing assets for the splash screen .
*
*
*/
protected Scene createSplashScene() {
Scene scene = new Scene(2);
addPlayButton(scene);
addQuitButton(scene);
return scene;
}

public void addPlayButton(Scene scene){
Sprite _buttonRef = new Sprite(100, 50, 100, 70, this._playButtonTextureRegion)
{
@Override
public boolean onAreaTouched(TouchEvent pSceneTouchEvent,float pTouchAreaLocalX, float pTouchAreaLocalY)
{
if(checkTouchTime())
GameController.getInstance().mEngine.setScene(GameController.getInstance().createLevelSubmenu(currentPage));
return true;
}
};
_buttonRef.setBlendFunction(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
scene.registerTouchArea(_buttonRef);
scene.getTopLayer().addEntity(_buttonRef);
}

public void addQuitButton(Scene scene){
Sprite _buttonRef = new Sprite(100, 130, 100, 70, this._quitBtnTextureRegion)
{
@Override
public boolean onAreaTouched(TouchEvent pSceneTouchEvent,float pTouchAreaLocalX, float pTouchAreaLocalY)
{
if(checkTouchTime())
{
GameController.getInstance().finish();
}
return true;
}
};
_buttonRef.setBlendFunction(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
scene.registerTouchArea(_buttonRef);
scene.getTopLayer().addEntity(_buttonRef);
}

public void createLevelMenuButtonLayout(Scene scene, boolean backButton){
int height = 50;
int weight = 50;
int x = 200;
int y = 200;
Sprite _buttonRef = new Sprite(x, y, height, weight, _backBtnTextureRegion)
{
@Override
public boolean onAreaTouched(TouchEvent pSceneTouchEvent,float pTouchAreaLocalX, float pTouchAreaLocalY)
{
if(checkTouchTime())
GameController.getInstance().mEngine.setScene(newGameLevelScene(1));
return true;
}
};
scene.registerTouchArea(_buttonRef);
scene.getTopLayer().addEntity(_buttonRef);
}

public Scene createLevelSubmenu(int id){
Scene scene = new Scene(2);
addMenuLevelItemsPage1(scene);
return scene;
}

private TextureRegion mMenuOkTextureRegion;
private TextureRegion mMenuBackTextureRegion;

protected void onLoadSubMenuResources(){

}

//set up all menu level items
public void addMenuLevelItemsPage1(Scene scene){

int height = 60;
int weight = 60;
int x = 10;
int y = 10;
Sprite _buttonRef;
_buttonRef = new Sprite(x, y, height, weight, _levelBtnTextureRegion1)
{
@Override
public boolean onAreaTouched(TouchEvent pSceneTouchEvent,float pTouchAreaLocalX, float pTouchAreaLocalY)
{
if(checkTouchTime())
GameController.getInstance().mEngine.setScene(newGameLevelScene(1));
return true;
}
};
scene.registerTouchArea(_buttonRef);
scene.getTopLayer().addEntity(_buttonRef);

x += weight + 10;
addLockedbutton(_buttonRef,scene, x , y,height,weight);
x += weight + 10;
addLockedbutton(_buttonRef,scene, x , y,height,weight);
x += weight + 10;
addLockedbutton(_buttonRef,scene, x , y,height,weight);
y += height + 150;
x = 100;
height = 60;
weight = 60;
addPrevBtton(_buttonRef,scene, x , y,height,weight);
x += weight + 30;
addUpBtton(_buttonRef,scene, x , y,height,weight);
x += weight + 30;
addNextBtton(_buttonRef,scene, x , y,height,weight);

}

public void addLockedbutton(Sprite _buttonRef,Scene scene,int x , int y, int height, int width ){
_buttonRef = new Sprite(x, y, height, width, _levelBtnTextureRegionLocked);
scene.getTopLayer().addEntity(_buttonRef);
}

public void addUpBtton(Sprite _buttonRef,Scene scene,int x , int y, int height, int width ){
_buttonRef = new Sprite(x, y, height, width, _upBtnTextureRegion)
{
@Override
public boolean onAreaTouched(TouchEvent pSceneTouchEvent,float pTouchAreaLocalX, float pTouchAreaLocalY)
{
if(checkTouchTime())
GameController.getInstance().mEngine.setScene(GameController.getInstance().createSplashScene());
return true;
}
};
scene.registerTouchArea(_buttonRef);
scene.getTopLayer().addEntity(_buttonRef);
}
public void addPrevBtton(Sprite _buttonRef,Scene scene,int x , int y, int height, int width ){
_buttonRef = new Sprite(x, y, height, width, _btnBackDisableRegion);
scene.getTopLayer().addEntity(_buttonRef);

}

public void addNextBtton(Sprite _buttonRef,Scene scene,int x , int y, int height, int width ){

_buttonRef = new Sprite(x, y, height, width, _nextBtnTextureRegion)
{
@Override
public boolean onAreaTouched(TouchEvent pSceneTouchEvent,float pTouchAreaLocalX, float pTouchAreaLocalY)
{
if(checkTouchTime())
{
currentPage++;
GameController.getInstance().getEngine().setScene(createLevelSubmenu(currentPage));
}
return true;
}
};
scene.registerTouchArea(_buttonRef);
scene.getTopLayer().addEntity(_buttonRef);
}

}

Step 4: Create the LevelController.java class and put following code :

package com.thegame;

import org.anddev.andengine.entity.scene.Scene;
import org.anddev.andengine.entity.shape.Shape;
import org.anddev.andengine.entity.sprite.Sprite;
import org.anddev.andengine.input.touch.TouchEvent;

public class LevelController   {
public Scene scene;
private GameController _gameController;
public GameController get_gameController() {
return _gameController;
}
int levelId;
boolean isGameFinished = false;
protected int _cameraWidth;
public int getCameraWidth() {
return _cameraWidth;
}
public int getCameraHeight() {
return _cameraHeight;
}
protected int _cameraHeight;
public LevelController(GameController _gameController) {
levelId = 0;
this._gameController = _gameController;
}
public void setCurrentLevel(int levelId){
this.levelId = levelId;
}

/*
* Here we are defining Level complete image.
* Use this if level is completed.
*/
public void showSignCompleted(){
Shape box = new Sprite(160, 120, 100,100, _gameController.mLevelCompletedRegion)
{
@Override
public boolean onAreaTouched(TouchEvent pSceneTouchEvent,float pTouchAreaLocalX, float pTouchAreaLocalY)
{
if(GameController.getInstance().checkTouchTime()){
GameController.getInstance().getEngine().setScene(_gameController.createLevelSubmenu(_gameController.currentPage));
}
return true;
}
};
scene.registerTouchArea(box);
scene.getTopLayer().addEntity(box);
}
/*
* Here we are defining Level Uncomplete image.

*/
public void showSignUncompleted(){
Shape box = new Sprite(160, 120, 100, 100, _gameController.mLevelUnCompletedRegion)
{
@Override
public boolean onAreaTouched(TouchEvent pSceneTouchEvent,float pTouchAreaLocalX, float pTouchAreaLocalY)
{
if(GameController.getInstance().checkTouchTime())
{
_gameController.getEngine().setScene(_gameController.newGameLevelScene(levelId));
}
return true;
}
};
scene.registerTouchArea(box);
scene.getTopLayer().addEntity(box);
}
public void createBackground(){

}
/*
* Here we are defining Level.
* Use this function to create your level for the game  according to selected level.
* For Example first create the Background etc.
*/
public void loadLevel(int levelId){
isGameFinished = false;
this.setCurrentLevel(levelId);
if(levelId == 1)
loadLevel1();

}
/*
* Here we are defining Level.
* Use this function to create your level for the game .
* For Example first create the Background etc.
*/

public void loadLevel1(){
createBackground();
}

}

Step 5: Run your app . Here is source

Tags: alpha effect, An Android application, AndEngine, AndEngineGame, Android components, Android Game, animation in Android, Apple, Blinking effect, Game Programming, Key Event, Key Event handler, Movement, Splash screen, Timer, Touch, TouchEvent, Transition

We will learn how to develop a game using AndEngine which is a openSource, free game engine for android.
Step :1. Download the AndEngine from here :

AndEngine.jar

Step :2. Create a new project using motodev.

Step :3. Create a new folder ‘lib’ and paste AndEngine.jar file there.

Paste the AndEngine.jar file

Step :4. Go to project properyies and add AndEngine.jar file in the build path.

Step :5. Open MainActivity.java file and extend it to the BaseActivity

Step :6 You will get an error thrown. Now import the default methods of AndEngine.

Step :7. Your Main activity will look like this. These four are the default method of AndEngine

a)onLoadEngine()
a)onLoadResources()
a)onLoadScene()
a)onLoadComplete()

package com.andenginedemo;

import org.anddev.andengine.engine.Engine;
import org.anddev.andengine.entity.scene.Scene;
import org.anddev.andengine.ui.activity.BaseGameActivity;

public class MainActivity  extends BaseGameActivity {

@Override
public Engine onLoadEngine() {
// TODO Auto-generated method stub
return null;
}

@Override
public void onLoadResources() {
// TODO Auto-generated method stub

}

@Override
public Scene onLoadScene() {
// TODO Auto-generated method stub
return null;
}

@Override
public void onLoadComplete() {
// TODO Auto-generated method stub

}
/** Called when the activity is first created. */

}

Step :7. Open the assets folder and create a folder gfx and put the ball.png file there.

Step :8. Now put following code in your MainActivity.java class

package com.andenginedemo;

import org.anddev.andengine.engine.Engine;
import org.anddev.andengine.entity.scene.Scene;
import org.anddev.andengine.ui.activity.BaseGameActivity;

import org.anddev.andengine.engine.camera.Camera;
import org.anddev.andengine.engine.options.EngineOptions;
import org.anddev.andengine.engine.options.EngineOptions.ScreenOrientation;
import org.anddev.andengine.engine.options.resolutionpolicy.RatioResolutionPolicy;

import org.anddev.andengine.entity.scene.background.ColorBackground;
import org.anddev.andengine.entity.sprite.Sprite;
import org.anddev.andengine.entity.util.FPSLogger;
import org.anddev.andengine.opengl.texture.TextureOptions;
import org.anddev.andengine.opengl.texture.Texture;
import org.anddev.andengine.opengl.texture.region.TextureRegion;
import org.anddev.andengine.opengl.texture.region.TextureRegionFactory;

public class MainActivity  extends BaseGameActivity {

private static final int CAMERA_WIDTH = 720;
private static final int CAMERA_HEIGHT = 480;

private Camera _refCamera;
private Texture _ballBitmapTexture;
private TextureRegion _ballTextureRegion;

@Override
public Engine onLoadEngine() {
this._refCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);
return new Engine(new EngineOptions(true, ScreenOrientation.LANDSCAPE, new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT), this._refCamera));
}

@Override
public void onLoadResources() {
this._ballBitmapTexture =  new Texture(256,256, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
this._ballTextureRegion= TextureRegionFactory.createFromAsset(this._ballBitmapTexture, this, "gfx/ball.png", 0, 0); // 64x32
this.mEngine.getTextureManager().loadTexture(this._ballBitmapTexture);
}

@Override
public Scene onLoadScene() {
this.mEngine.registerUpdateHandler(new FPSLogger());
Scene scene = new Scene(2);
scene.setBackground(new ColorBackground(0.0000f, 0.0000f, 0.0000f));
/* Calculate the coordinates for the face, so its centered on the camera. */
final int centerX = (CAMERA_WIDTH - this._ballTextureRegion.getWidth()) / 2;
final int centerY = (CAMERA_HEIGHT - this._ballTextureRegion.getHeight()) / 2;

/* Create the face and add it to the scene. */
final Sprite face = new Sprite(centerX, centerY, this._ballTextureRegion);
scene.getTopLayer().addEntity(face);
return scene;
}

@Override
public void onLoadComplete() {

}

}

Step :9. Run your app it will look like this. Enjoy

Tags: alpha effect, An Android application, AndEngine, AndEngineGame, Android components, Android Game, animation in Android, Apple, Blinking effect, Game Programming, Key Event, Key Event handler, Movement, Splash screen, Timer, Touch, TouchEvent, Transition