Join the social network of Tech Nerds, increase skill rank, get work, manage projects...
  • Implement AndEngine for Game Development in Android App - 5 Cool Steps to Know

    • 0
    • 0
    • 0
    • 0
    • 0
    • 0
    • 2
    • 0
    • 3.43k
    Comment on it

    AndEngine is a free and and open source game development engine for android platform, we can say that it is a 2D OpenGL Game Engine which uses OpenGL ES technology having features like to provide gravity effect for object which shows a quick graphic output.

    You can find more on andengine from


    Hence, if you are Looking for game development in android, this is a cool game engine with which you can develop your dream game.



    Let's  start with the basics of integration.

    In order to integrate it in your app follow these steps:


    Step 1: Create an android project with an activity, add jnilib and lib folder under your project directory.


    Step 2: Add jar files from following link to your  app.


    Step 3: Copy the jni files from the following link to your app’s jni folder.


    Step 4: Inside your build.gradle folder add these lines to complie the library you added in step 2.


     compile files('libs/andengine.jar')
       compile files('libs/andengine_box2d.jar')


    Step 5: You are ready to go now, Now create your activity and extend it from BaseGameActivity

       Implements its various listeners for sensors and other effects. Customize it in your way.


    I am providing you  my activity here you can go through it.


    package com.example.amitrai.gamedemo;
    import com.badlogic.gdx.math.Vector2;
    import com.badlogic.gdx.physics.box2d.Body;
    import com.badlogic.gdx.physics.box2d.BodyDef.BodyType;
    import com.badlogic.gdx.physics.box2d.FixtureDef;
    import org.anddev.andengine.engine.Engine;
    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.primitive.Rectangle;
    import org.anddev.andengine.entity.scene.Scene;
    import org.anddev.andengine.entity.scene.background.ColorBackground;
    import org.anddev.andengine.entity.shape.Shape;
    import org.anddev.andengine.entity.sprite.Sprite;
    import org.anddev.andengine.entity.util.FPSLogger;
    import org.anddev.andengine.extension.physics.box2d.PhysicsConnector;
    import org.anddev.andengine.extension.physics.box2d.PhysicsFactory;
    import org.anddev.andengine.extension.physics.box2d.PhysicsWorld;
    import org.anddev.andengine.extension.physics.box2d.util.Vector2Pool;
    import org.anddev.andengine.opengl.texture.TextureOptions;
    import org.anddev.andengine.opengl.texture.atlas.bitmap.BitmapTextureAtlas;
    import org.anddev.andengine.opengl.texture.atlas.bitmap.source.AssetBitmapTextureAtlasSource;
    import org.anddev.andengine.opengl.texture.atlas.bitmap.source.IBitmapTextureAtlasSource;
    import org.anddev.andengine.opengl.texture.region.TextureRegion;
    import org.anddev.andengine.opengl.texture.region.TextureRegionFactory;
    import org.anddev.andengine.sensor.accelerometer.AccelerometerData;
    import org.anddev.andengine.sensor.accelerometer.IAccelerometerListener;
    import org.anddev.andengine.ui.activity.BaseGameActivity;
    public class AndEngineSimplePhysicsExampleActivity extends BaseGameActivity implements IAccelerometerListener {
    	private static final int CAMERA_WIDTH = 800;
    	private static final int CAMERA_HEIGHT = 480;
    	private static final FixtureDef FIXTURE_DEF = PhysicsFactory.createFixtureDef(1, 0.5f, 0.5f);
    	private Scene mScene;
    	private Camera mCamera;
    	private PhysicsWorld physicsWorld;
    	private BitmapTextureAtlas mBitmapTextureAtlas;
    	private TextureRegion mBitmapTextureRegion;
    	public void onLoadComplete() {
    		// TODO Auto-generated method stub
    	public Engine onLoadEngine() {
    		this.mCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);
    		EngineOptions options = new EngineOptions(true, ScreenOrientation.LANDSCAPE, new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT), this.mCamera);
    		return new Engine(options);
    	public void onLoadResources() { 
    		// Create a new texture
    		this.mBitmapTextureAtlas = new BitmapTextureAtlas(128, 128, TextureOptions.BILINEAR);
    		// Create texture source
    		final IBitmapTextureAtlasSource faceTextureSource = new AssetBitmapTextureAtlasSource(this, "gfx/icon.png");//(this, "gfx/sprite.png");
    		// Create texture region
    		this.mBitmapTextureRegion = TextureRegionFactory.createFromSource(this.mBitmapTextureAtlas,
    			faceTextureSource, 0, 0, true);
    		// Load the texture into memory
    	public Scene onLoadScene() {
    		this.mEngine.registerUpdateHandler(new FPSLogger());
    		// Create our scene
    		this.mScene = new Scene();
    //		this.mScene.setBackground(new ColorBackground(1f, 1f, 1f));
    		this.mScene.setBackground(new ColorBackground(0.09804f, 0.6274f, 0.8784f));
    		// Create our physics world
    		this.physicsWorld = new PhysicsWorld(new Vector2(0, 80), false);
    		// Register our physics world to update our scene
    		// Enable the accelerometer and bind our own onAccelerometerChanged() method as listener for events
    		this.mEngine.enableAccelerometerSensor(this, this);
    		// Create walls around our scene
    		// Create the moving body
    		return this.mScene;
    	private void createWalls() {
    		final Shape ground = new Rectangle(0, CAMERA_HEIGHT - 2, CAMERA_WIDTH, 2);
    		final Shape roof = new Rectangle(0, 0, CAMERA_WIDTH, 2);
    		final Shape left = new Rectangle(0, 0, 2, CAMERA_HEIGHT);
    		final Shape right = new Rectangle(CAMERA_WIDTH - 2, 0, 2, CAMERA_HEIGHT);
    		final FixtureDef wallFixtureDef = PhysicsFactory.createFixtureDef(0, 0.5f, 0.5f);
    		PhysicsFactory.createBoxBody(this.physicsWorld, ground, BodyType.StaticBody, wallFixtureDef);
    		PhysicsFactory.createBoxBody(this.physicsWorld, roof, BodyType.StaticBody, wallFixtureDef);
    		PhysicsFactory.createBoxBody(this.physicsWorld, left, BodyType.StaticBody, wallFixtureDef);
    		PhysicsFactory.createBoxBody(this.physicsWorld, right, BodyType.StaticBody, wallFixtureDef);
    	private void createPhysicsBody() {
    		// Create the sprite
    		final Sprite physicsSprite = new Sprite(CAMERA_WIDTH / 2, CAMERA_HEIGHT / 2, this.mBitmapTextureRegion);
    		// Create the physics body
    		final Body body = PhysicsFactory.createBoxBody(this.physicsWorld, physicsSprite,
    			BodyType.DynamicBody, FIXTURE_DEF);
    		// Add the sprite to the scene 
    		// Link the sprite and the body
    		this.physicsWorld.registerPhysicsConnector(new PhysicsConnector(physicsSprite, body, true, true));
    	public void onAccelerometerChanged(final AccelerometerData pAccelerometerData) {
    		final Vector2 gravity = Vector2Pool.obtain(pAccelerometerData.getX(),


    The working demo you can take from the here: and below is a output of above code, for any query or  feedback, please feel free to write in comments.



    Happy coding :)

    Implement AndEngine for Game Development in Android App - 5 Cool Steps to Know

 0 Comment(s)

Sign In

Sign up using

Forgot Password
Fill out the form below and instructions to reset your password will be emailed to you:
Reset Password
Fill out the form below and reset your password: