Develop Reference

Andegine error load map when output have :horizontal stripes

Andegine error load map when output have :horizontal stripes
i have load map, but have horizontal stripes in maps. i dont know. please help me.i am new developer,i use andegine. Can anyone help me with this problem? Any idea?
the image :
the code
public class TileActivity
extends SimpleBaseGameActivity {
private TMXTiledMap mTMXTiledMap;
private BoundCamera mBoundChaseCamera;
private static final int CAMERA_WIDTH = 480;
private static final int CAMERA_HEIGHT = 320;
private Scene mScene;
private static final long[] ANIMATE_DURATION = new long[] { 200, 200, 200 };
private static final int PLAYER_VELOCITY = 2;
private BitmapTextureAtlas mTexturePlayer;
private Body mPlayerBody;
private TiledTextureRegion mPlayerTextureRegion;
private BitmapTextureAtlas mOnScreenControlTexture;
private TextureRegion mOnScreenControlBaseTextureRegion;
private TextureRegion mOnScreenControlKnobTextureRegion;
private DigitalOnScreenControl mDigitalOnScreenControl;
private PhysicsWorld mPhysicsWorld;
private TMXLayer layer;
#Override
protected void onCreateResources() {
BitmapTextureAtlasTextureRegionFactory.setAssetBasePath("gfx/");
// Control texture
this.mOnScreenControlTexture = new BitmapTextureAtlas(getTextureManager(), 256, 128, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
this.mOnScreenControlBaseTextureRegion = BitmapTextureAtlasTextureRegionFactory.createFromAsset(this.mOnScreenControlTexture, this, "onscreen_control_base.png", 0, 0);
this.mOnScreenControlKnobTextureRegion = BitmapTextureAtlasTextureRegionFactory.createFromAsset(this.mOnScreenControlTexture, this, "onscreen_control_knob.png", 128, 0);
// Player sprite texture
this.mTexturePlayer = new BitmapTextureAtlas(getTextureManager(), 96, 128, TextureOptions.DEFAULT);
this.mPlayerTextureRegion = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(this.mTexturePlayer, this, "hero.png", 0, 0, 3, 4);
// Load the textures
this.mTexturePlayer.load();
this.mOnScreenControlTexture.load();
}
#Override
protected Scene onCreateScene() {
this.mEngine.registerUpdateHandler(new FPSLogger());
// Create physics world
this.mPhysicsWorld = new FixedStepPhysicsWorld(30, new Vector2(0, 0), false, 8, 1);
// Create the scene and register the physics world
mScene = new Scene();
mScene.registerUpdateHandler(this.mPhysicsWorld);
// Load the TMX map
try {
final TMXLoader tmxLoader = new TMXLoader(this.getAssets(),
this.mEngine.getTextureManager(),
TextureOptions.BILINEAR_PREMULTIPLYALPHA,
getVertexBufferObjectManager(),
new TMXLoader.ITMXTilePropertiesListener() {
#Override
public void onTMXTileWithPropertiesCreated(final TMXTiledMap pTMXTiledMap, final TMXLayer pTMXLayer, final TMXTile pTMXTile, final TMXProperties<TMXTileProperty> pTMXTileProperties) {}
});
this.mTMXTiledMap = tmxLoader.loadFromAsset("test.tmx");
} catch (final TMXLoadException tmxle) {
Debug.e(tmxle);
}
// Add the non-object layers to the scene
for (int i = 0; i < this.mTMXTiledMap.getTMXLayers().size(); i++) {
layer = this.mTMXTiledMap.getTMXLayers().get(i);
if (!layer.getTMXLayerProperties().containsTMXProperty("wall", "true")) {
mScene.attachChild(layer);
}
}
// Read in the unwalkable blocks from the object layer and create boxes for each
this.createUnwalkableObjects(mTMXTiledMap);
// Add outer walls
this.addBounds(layer.getWidth(), layer.getHeight());
this.mBoundChaseCamera.setBounds(0, layer.getWidth(), 0, layer.getHeight());
// Calculate the coordinates for the player, so it's centred on the camera.
final int centerX = (int) (CAMERA_WIDTH - this.mPlayerTextureRegion.getWidth()) / 2;
final int centerY = (int) (CAMERA_HEIGHT - this.mPlayerTextureRegion.getHeight()) / 2;
// Create the player sprite and add it to the scene.
final AnimatedSprite player = new AnimatedSprite(centerX, centerY, this.mPlayerTextureRegion, getVertexBufferObjectManager());
this.mBoundChaseCamera.setChaseEntity(player);
final FixtureDef playerFixtureDef = PhysicsFactory.createFixtureDef(0, 0, 0.5f);
mPlayerBody = PhysicsFactory.createBoxBody(this.mPhysicsWorld, player, BodyDef.BodyType.DynamicBody, playerFixtureDef);
this.mPhysicsWorld.registerPhysicsConnector(new PhysicsConnector(player, mPlayerBody, true, false) {
#Override
public void onUpdate(float pSecondsElapsed) {
super.onUpdate(pSecondsElapsed);
mBoundChaseCamera.updateChaseEntity();
}
});
mScene.attachChild(player);
// Add the control
this.mDigitalOnScreenControl = new DigitalOnScreenControl(0, CAMERA_HEIGHT - this.mOnScreenControlBaseTextureRegion.getHeight(), this.mBoundChaseCamera, this.mOnScreenControlBaseTextureRegion, this.mOnScreenControlKnobTextureRegion, 0.1f, getVertexBufferObjectManager(),
new BaseOnScreenControl.IOnScreenControlListener() {
#Override
public void onControlChange(final BaseOnScreenControl pBaseOnScreenControl, final float pValueX, final float pValueY) {
// Set the correct walking animation
if (pValueY == 1) {
// Up
if (playerDirection != PlayerDirection.UP) {
player.animate(ANIMATE_DURATION, 0, 2, true);
playerDirection = PlayerDirection.UP;
}
} else if (pValueY == -1) {
// Down
if (playerDirection != PlayerDirection.DOWN) {
player.animate(ANIMATE_DURATION, 9, 11, true);
playerDirection = PlayerDirection.DOWN;
}
} else if (pValueX == -1) {
// Left
if (playerDirection != PlayerDirection.LEFT) {
player.animate(ANIMATE_DURATION, 3, 5, true);
playerDirection = PlayerDirection.LEFT;
}
} else if (pValueX == 1) {
// Right
if (playerDirection != PlayerDirection.RIGHT) {
player.animate(ANIMATE_DURATION, 6, 8, true);
playerDirection = PlayerDirection.RIGHT;
}
} else {
if (player.isAnimationRunning()) {
player.stopAnimation();
playerDirection = PlayerDirection.NONE;
}
}
// Set the player's velocity
mPlayerBody.setLinearVelocity(pValueX * PLAYER_VELOCITY, pValueY * PLAYER_VELOCITY);
}
});
this.mDigitalOnScreenControl.getControlBase().setBlendFunction(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
this.mDigitalOnScreenControl.getControlBase().setAlpha(0.5f);
this.mDigitalOnScreenControl.getControlBase().setScaleCenter(0, 128);
this.mDigitalOnScreenControl.getControlBase().setScale(1.25f);
this.mDigitalOnScreenControl.getControlKnob().setScale(1.25f);
this.mDigitalOnScreenControl.getControlKnob().setAlpha(0.5f);
this.mDigitalOnScreenControl.refreshControlKnobPosition();
mScene.setChildScene(this.mDigitalOnScreenControl);
return mScene;
}
#Override
public EngineOptions onCreateEngineOptions() {
this.mBoundChaseCamera = new BoundCamera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);
return new EngineOptions(true, ScreenOrientation.LANDSCAPE_FIXED, new FillResolutionPolicy(), this.mBoundChaseCamera);
}
private enum PlayerDirection {
NONE,
UP,
DOWN,
LEFT,
RIGHT
}
private PlayerDirection playerDirection = PlayerDirection.NONE;
private void createUnwalkableObjects(TMXTiledMap map) {
// Loop through the object groups
for (final TMXObjectGroup group : this.mTMXTiledMap.getTMXObjectGroups()) {
if (group.getTMXObjectGroupProperties().containsTMXProperty("wall", "true")) {
// This is our "wall" layer. Create the boxes from it
for (final TMXObject object : group.getTMXObjects()) {
final Rectangle rect = new Rectangle(object.getX(), object.getY(), object.getWidth(), object.getHeight(), getVertexBufferObjectManager());
final FixtureDef boxFixtureDef = PhysicsFactory.createFixtureDef(0, 0, 1f);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, rect, BodyDef.BodyType.StaticBody, boxFixtureDef);
rect.setVisible(false);
mScene.attachChild(rect);
}
}
}
}
private void addBounds(float width, float height) {
final Rectangle bottom = new Rectangle(0, height - 2, width, 2, getVertexBufferObjectManager());
bottom.setVisible(false);
final Rectangle top = new Rectangle(0, 0, width, 2, getVertexBufferObjectManager());
top.setVisible(false);
final Rectangle left = new Rectangle(0, 0, 2, height, getVertexBufferObjectManager());
left.setVisible(false);
final Rectangle right = new Rectangle(width - 2, 0, 2, height, getVertexBufferObjectManager());
right.setVisible(false);
final FixtureDef wallFixtureDef = PhysicsFactory.createFixtureDef(0, 0, 1f);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, bottom, BodyDef.BodyType.StaticBody, wallFixtureDef);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, top, BodyDef.BodyType.StaticBody, wallFixtureDef);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, left, BodyDef.BodyType.StaticBody, wallFixtureDef);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, right, BodyDef.BodyType.StaticBody, wallFixtureDef);
this.mScene.attachChild(bottom);
this.mScene.attachChild(top);
this.mScene.attachChild(left);
this.mScene.attachChild(right);
}
}

This is generally caused by pixel blending, which happens in the following situations:
If the texture is rendered smaller than native size, the pixels are averaged and values from neighboring pixels affect the edges of the tiles.
If the texture is rendered larger than native size, pixel values are interpolated, which also causes values from neighboring pixels to affect the edges of the tiles.
If the texture is not rendered exactly aligned to a pixel, interpolation also occurs.
So to avoid it, either make sure none of the above happens or disable texture filtering (putting it on nearest neighbor).
Nearest neighbor filtering of course doesn't look nice when the map gets scaled, so if you want to support this case you can alternatively make sure that each tile is surrounded by pixels that match the color of its edge pixels. This avoids colors from other tiles affecting its borders.

How to move a player sprite By onScreenDigitalControl on autoparallexbackground in andengine

I am developing a game in andengine.i want to move a player sprite by onScreenDigitalControl on an autoparallex background.Can anyone tell me how to do that ???? thanks

Using this code you can make player sprite moving by DigitalOnScreenControl. Also you can find many tutorials on this at http://www.andengine.org/forums/tutorials/
public class TileActivity extends BaseGameActivity {
private TMXTiledMap mTMXTiledMap;
private BoundCamera mBoundChaseCamera;
private static final int CAMERA_WIDTH = 480;
private static final int CAMERA_HEIGHT = 320;
private Scene mScene;
private static final long[] ANIMATE_DURATION = new long[]{200, 200, 200};
private static final int PLAYER_VELOCITY = 2;
private BitmapTextureAtlas mTexturePlayer;
private Body mPlayerBody;
private TiledTextureRegion mPlayerTextureRegion;
private BitmapTextureAtlas mOnScreenControlTexture;
private TextureRegion mOnScreenControlBaseTextureRegion;
private TextureRegion mOnScreenControlKnobTextureRegion;
private DigitalOnScreenControl mDigitalOnScreenControl;
private PhysicsWorld mPhysicsWorld;
private enum PlayerDirection{
NONE,
UP,
DOWN,
LEFT,
RIGHT
}
private PlayerDirection playerDirection = PlayerDirection.NONE;
#Override
public Engine onLoadEngine() {
this.mBoundChaseCamera = new BoundCamera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);
return new Engine(new EngineOptions(true, ScreenOrientation.LANDSCAPE, new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT), this.mBoundChaseCamera));
}
#Override
public void onLoadResources() {
BitmapTextureAtlasTextureRegionFactory.setAssetBasePath("gfx/");
// Control texture
this.mOnScreenControlTexture = new BitmapTextureAtlas(256, 128, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
this.mOnScreenControlBaseTextureRegion = BitmapTextureAtlasTextureRegionFactory.createFromAsset(this.mOnScreenControlTexture, this, "onscreen_control_base.png", 0, 0);
this.mOnScreenControlKnobTextureRegion = BitmapTextureAtlasTextureRegionFactory.createFromAsset(this.mOnScreenControlTexture, this, "onscreen_control_knob.png", 128, 0);
// Player sprite texture
this.mTexturePlayer = new BitmapTextureAtlas(128, 128, TextureOptions.DEFAULT);
this.mPlayerTextureRegion = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(this.mTexturePlayer, this, "hero.png", 0, 0, 3, 4);
// Load the textures
this.mEngine.getTextureManager().loadTextures(this.mTexturePlayer, this.mOnScreenControlTexture);
}
#Override
public Scene onLoadScene() {
this.mEngine.registerUpdateHandler(new FPSLogger());
// Create physics world
this.mPhysicsWorld = new FixedStepPhysicsWorld(30, new Vector2(0, 0), false, 8, 1);
// Create the scene and register the physics world
mScene = new Scene();
mScene.registerUpdateHandler(this.mPhysicsWorld);
// Load the TMX map
try {
final TMXLoader tmxLoader = new TMXLoader(this, this.mEngine.getTextureManager(), TextureOptions.NEAREST, null);
this.mTMXTiledMap = tmxLoader.loadFromAsset(this, "test.tmx");
} catch (final TMXLoadException tmxle) {
Debug.e(tmxle);
}
// Add the non-object layers to the scene
for (int i = 0; i < this.mTMXTiledMap.getTMXLayers().size(); i++){
TMXLayer layer = this.mTMXTiledMap.getTMXLayers().get(i);
if (!layer.getTMXLayerProperties().containsTMXProperty("wall", "true"))
mScene.attachChild(layer);
}
// Read in the unwalkable blocks from the object layer and create boxes for each
this.createUnwalkableObjects(mTMXTiledMap);
// Make the camera not exceed the bounds of the TMXEntity.
final TMXLayer tmxLayer = this.mTMXTiledMap.getTMXLayers().get(0);
this.mBoundChaseCamera.setBounds(0, tmxLayer.getWidth(), 0, tmxLayer.getHeight());
this.mBoundChaseCamera.setBoundsEnabled(true);
// Add outer walls
this.addBounds(tmxLayer.getWidth(), tmxLayer.getHeight());
// Calculate the coordinates for the player, so it's centred on the camera.
final int centerX = (CAMERA_WIDTH - this.mPlayerTextureRegion.getTileWidth()) / 2;
final int centerY = (CAMERA_HEIGHT - this.mPlayerTextureRegion.getTileHeight()) / 2;
// Create the player sprite and add it to the scene.
final AnimatedSprite player = new AnimatedSprite(centerX, centerY, this.mPlayerTextureRegion);
this.mBoundChaseCamera.setChaseEntity(player);
final FixtureDef playerFixtureDef = PhysicsFactory.createFixtureDef(0, 0, 0.5f);
mPlayerBody = PhysicsFactory.createBoxBody(this.mPhysicsWorld, player, BodyType.DynamicBody, playerFixtureDef);
this.mPhysicsWorld.registerPhysicsConnector(new PhysicsConnector(player, mPlayerBody, true, false){
#Override
public void onUpdate(float pSecondsElapsed){
super.onUpdate(pSecondsElapsed);
mBoundChaseCamera.updateChaseEntity();
}
});
mScene.attachChild(player);
// Add the control
this.mDigitalOnScreenControl = new DigitalOnScreenControl(0, CAMERA_HEIGHT - this.mOnScreenControlBaseTextureRegion.getHeight(), this.mBoundChaseCamera, this.mOnScreenControlBaseTextureRegion, this.mOnScreenControlKnobTextureRegion, 0.1f, new IOnScreenControlListener() {
#Override
public void onControlChange(final BaseOnScreenControl pBaseOnScreenControl, final float pValueX, final float pValueY) {
// Set the correct walking animation
if (pValueY == 1){
// Up
if (playerDirection != PlayerDirection.UP){
player.animate(ANIMATE_DURATION, 0, 2, true);
playerDirection = PlayerDirection.UP;
}
}else if (pValueY == -1){
// Down
if (playerDirection != PlayerDirection.DOWN){
player.animate(ANIMATE_DURATION, 9, 11, true);
playerDirection = PlayerDirection.DOWN;
}
}else if (pValueX == -1){
// Left
if (playerDirection != PlayerDirection.LEFT){
player.animate(ANIMATE_DURATION, 3, 5, true);
playerDirection = PlayerDirection.LEFT;
}
}else if (pValueX == 1){
// Right
if (playerDirection != PlayerDirection.RIGHT){
player.animate(ANIMATE_DURATION, 6, 8, true);
playerDirection = PlayerDirection.RIGHT;
}
}else{
if (player.isAnimationRunning()){
player.stopAnimation();
playerDirection = PlayerDirection.NONE;
}
}
// Set the player's velocity
mPlayerBody.setLinearVelocity(pValueX * PLAYER_VELOCITY, pValueY * PLAYER_VELOCITY);
}
});
this.mDigitalOnScreenControl.getControlBase().setBlendFunction(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
this.mDigitalOnScreenControl.getControlBase().setAlpha(0.5f);
this.mDigitalOnScreenControl.getControlBase().setScaleCenter(0, 128);
this.mDigitalOnScreenControl.getControlBase().setScale(1.25f);
this.mDigitalOnScreenControl.getControlKnob().setScale(1.25f);
this.mDigitalOnScreenControl.getControlKnob().setAlpha(0.5f);
this.mDigitalOnScreenControl.refreshControlKnobPosition();
mScene.setChildScene(this.mDigitalOnScreenControl);
return mScene;
}
#Override
public void onLoadComplete() {
// TODO Auto-generated method stub
}
private void createUnwalkableObjects(TMXTiledMap map){
// Loop through the object groups
for(final TMXObjectGroup group: this.mTMXTiledMap.getTMXObjectGroups()) {
if(group.getTMXObjectGroupProperties().containsTMXProperty("wall", "true")){
// This is our "wall" layer. Create the boxes from it
for(final TMXObject object : group.getTMXObjects()) {
final Rectangle rect = new Rectangle(object.getX(), object.getY(),object.getWidth(), object.getHeight());
final FixtureDef boxFixtureDef = PhysicsFactory.createFixtureDef(0, 0, 1f);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, rect, BodyType.StaticBody, boxFixtureDef);
rect.setVisible(false);
mScene.attachChild(rect);
}
}
}
}
private void addBounds(float width, float height){
final Shape bottom = new Rectangle(0, height - 2, width, 2);
bottom.setVisible(false);
final Shape top = new Rectangle(0, 0, width, 2);
top.setVisible(false);
final Shape left = new Rectangle(0, 0, 2, height);
left.setVisible(false);
final Shape right = new Rectangle(width - 2, 0, 2, height);
right.setVisible(false);
final FixtureDef wallFixtureDef = PhysicsFactory.createFixtureDef(0, 0, 1f);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, bottom, BodyType.StaticBody, wallFixtureDef);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, top, BodyType.StaticBody, wallFixtureDef);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, left, BodyType.StaticBody, wallFixtureDef);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, right, BodyType.StaticBody, wallFixtureDef);
this.mScene.attachChild(bottom);
this.mScene.attachChild(top);
this.mScene.attachChild(left);
this.mScene.attachChild(right);
}
}

Shooting a bullet from wrong starting point

I created a racing game in andengine.There is a player which is size 100x30px,like a rectangle.And there is fire() function to shoot bullet, code is below.It works fine.but problem is when player is rotating.player is a car image.so they rotating by directionButton().When I shoot a bullet,it starting 0x0px of car.But i want it must be start to move in front of car like 100x15px of car.How can I do?
public void fire() {
float startBulletX=player.getX();
float startBulletY=player.getY();
Sprite bullet=new Sprite(startBulletX,startBulletY,bulletRegion);
final float xComp = (float) Math.cos(MathUtils.degToRad(this.player.getRotation() + 90));
final float yComp = (float) Math.sin(MathUtils.degToRad(this.player.getRotation() + 90));
final Vector2 velocity = Vector2Pool.obtain(xComp * 10, yComp * 10);
bullet.setRotation(this.player.getRotation());
final FixtureDef bulletFixtureDef1 = PhysicsFactory.createFixtureDef(0, 0, 0);
this.mBulletBody = PhysicsFactory.createBoxBody(this.mPhysicsWorld, bullet, BodyType.KinematicBody, bulletFixtureDef1);
this.mBulletBody.setLinearVelocity(velocity);
Vector2Pool.recycle(velocity);
this.mPhysicsWorld.registerPhysicsConnector(new PhysicsConnector(bullet, this.mBulletBody, true, false));
this.scene.attachChild(bullet);
}
//on screen control button
public void addDirectionButton() {
player = new AnimatedSprite(centerX, centerY, this.playerTextureRegion);
final AnalogOnScreenControl analogOnScreenControl = new AnalogOnScreenControl(0, CAMERA_HEIGHT - this.mOnScreenControlBaseTextureRegion.getHeight(), this.mBoundChaseCamera, this.mOnScreenControlBaseTextureRegion, this.mOnScreenControlKnobTextureRegion, 0.1f, 200, new IAnalogOnScreenControlListener() {
public void onControlChange(final BaseOnScreenControl pBaseOnScreenControl, final float pValueX, final float pValueY) {
final Body carBody = DeffenseActivity.this.mCarBody;
final Vector2 velocity = Vector2Pool.obtain(pValueX * 5, pValueY * 5);
carBody.setLinearVelocity(velocity);
Vector2Pool.recycle(velocity);
final float rotationInRad = (float)Math.atan2(-pValueX, pValueY);
player.setRotation(MathUtils.radToDeg(rotationInRad));
}
public void onControlClick(final AnalogOnScreenControl pAnalogOnScreenControl) {
}
});
analogOnScreenControl.getControlBase().setBlendFunction(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);
analogOnScreenControl.getControlBase().setAlpha(0.5f);
analogOnScreenControl.getControlBase().setScaleCenter(0, 128);
analogOnScreenControl.getControlBase().setScale(1.25f);
analogOnScreenControl.getControlKnob().setScale(1.25f);
analogOnScreenControl.refreshControlKnobPosition();
this.scene.setChildScene(analogOnScreenControl);
this.mBoundChaseCamera.setChaseEntity(player);
a=new Sprite(0,0,bulletRegion);
player.attachChild(a);
final FixtureDef carFixtureDef = PhysicsFactory.createFixtureDef(1, 0.5f, 0.5f);
this.mCarBody = PhysicsFactory.createBoxBody(this.mPhysicsWorld, player, BodyType.DynamicBody, carFixtureDef);
this.mPhysicsWorld.registerPhysicsConnector(new PhysicsConnector(player, this.mCarBody, true, false));
this.scene.attachChild(player);
}

AndEngine import GLES2 project not running

I'm trying to update my project to run with AndEngine GLES2, but I have some problems. I find an article which shows what to change, but it's still not working. Here is exactly what I'm doing :
onCreateEngineOptions()
#Override
public EngineOptions onCreateEngineOptions() {
Toast.makeText(this, "Touch the screen to add Logo.", Toast.LENGTH_LONG).show();
CAMERA_WIDTH = getWindow().getWindowManager().getDefaultDisplay().getWidth();
CAMERA_HEIGHT = getWindow().getWindowManager().getDefaultDisplay().getHeight();
final Camera camera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);
final EngineOptions engineOptions = new EngineOptions(true, ScreenOrientation.PORTRAIT_FIXED, new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT), camera);
engineOptions.getTouchOptions().setNeedsMultiTouch(false);
return engineOptions;
}
onCreateResources()
public void onCreateResources() {
this.mBitmapTextureAtlas = new BitmapTextureAtlas(4096, 4096, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
this.mFont = new Font(this.mBitmapTextureAtlas, Typeface.create(Typeface.DEFAULT, Typeface.NORMAL), 25, true, Color.BLACK);
this.mEngine.getTextureManager().loadTexture(this.mBitmapTextureAtlas);
this.mEngine.getFontManager().loadFont(this.mFont);
this.firstSprite = BitmapTextureAtlasTextureRegionFactory.createFromAsset(this.mBitmapTextureAtlas, this, "1.png", 0, 113); // 113x100
// 36 other sprites, that's why I'm creating BitmapTextureAtlas with these size
this.mEngine.getTextureManager().loadTexture(this.mBitmapTextureAtlas);
}
onCreateScene()
#Override
public Scene onCreateScene() {
this.mEngine.registerUpdateHandler(new FPSLogger());
this.mScene = new Scene();
this.mScene.setBackground(new Background(4, 4, 4));
this.mScene.setOnSceneTouchListener(this);
this.mPhysicsWorld = new PhysicsWorld(new Vector2(0, SensorManager.GRAVITY_EARTH), false);
CAMERA_WIDTH = getWindow().getWindowManager().getDefaultDisplay().getWidth();
CAMERA_HEIGHT = getWindow().getWindowManager().getDefaultDisplay().getHeight();
final IAreaShape ground = new Rectangle(0, CAMERA_HEIGHT - 2, CAMERA_WIDTH, 2);
final IAreaShape roof = new Rectangle(0, 0, CAMERA_WIDTH, 2);
final IAreaShape left = new Rectangle(0, 0, 2, CAMERA_HEIGHT);
final IAreaShape right = new Rectangle(CAMERA_WIDTH - 2, 0, 2, CAMERA_HEIGHT);
final FixtureDef wallFixtureDef = PhysicsFactory.createFixtureDef(0, 0.5f, 0.5f);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, ground, BodyType.KinematicBody, wallFixtureDef);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, roof, BodyType.KinematicBody, wallFixtureDef);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, left, BodyType.KinematicBody, wallFixtureDef);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, right, BodyType.KinematicBody, wallFixtureDef);
this.mScene.attachChild(ground);
this.mScene.attachChild(roof);
this.mScene.attachChild(left);
this.mScene.attachChild(right);
this.mScene.registerUpdateHandler(this.mPhysicsWorld);
this.mScene.setOnAreaTouchListener(this);
final FixtureDef objectFixtureDef = PhysicsFactory.createFixtureDef(1, 0.5f, 1);
//Sprite 1
Sprite face = new Sprite(CAMERA_WIDTH/2, 50, this.firstSprite);
face.setUserData("petrol");
Body body = PhysicsFactory.createCircleBody(this.mPhysicsWorld, face, BodyType.DynamicBody, objectFixtureDef);
this.mScene.registerTouchArea(face);
this.mScene.attachChild(face);
this.mPhysicsWorld.registerPhysicsConnector(new PhysicsConnector(face, body, true, true));
// 36 sprites....
return this.mScene;
}
And the problem is that when I start this activity it's not showing non of the sprites and the screen remains black even if I change it to white color.
So any ideas where is my mistake and what I'm doing wrong. (Before moving to AndEngine GLES2 everything was working except on Android Honeycomb and now I'm testing this project on HTC EVO 3d which is running with Android 2.3.4).
Thanks in advance!

I'm not sure if this is your issue - I had similar problems before I added this
#Override
public void onPopulateScene(Scene pScene, OnPopulateSceneCallback pOnPopulateSceneCallback) throws Exception { //
// TODO Auto-generated method stub
pOnPopulateSceneCallback.onPopulateSceneFinished();
}

andengine apply force

does anyone know why applyforce only works on one of my sprites? Also when I press the other sprites it also applies force to the one individual sprite. The nextTile method works fine.
enter code herepackage com.martynnorman.jude;
/**
* #author Nicolas Gramlich
* #since 11:54:51 - 03.04.2010
*/
public class MainActivity extends BaseGameActivity implements IOnAreaTouchListener {
// ===========================================================
// Constants
// ===========================================================
private static final int CAMERA_WIDTH = 720;
private static final int CAMERA_HEIGHT = 480;
int centerX;
int centerY;
// ===========================================================
// Fields
// ===========================================================
private Camera mCamera;
private BitmapTextureAtlas mBitmapTextureAtlas;
private TiledTextureRegion mFaceTextureRegion;
private BitmapTextureAtlas mBitmapTextureAtlas2;
private TiledTextureRegion mFaceTextureRegion2;
Random random = new Random();
Ball sprite;
int scale;
Scene scene;
private BitmapTextureAtlas mFontTexture;
private Font mFont;
Text textcenter;
int t = 1;
Ball rgSprite[] = new Ball[10];
private PhysicsWorld mPhysicsWorld;
Body body;
int isTouched;
final Vector2 gravity2 = new Vector2(0, 20);
final Vector2 gravity = new Vector2(0, 0);
private static final FixtureDef FIXTURE_DEF = PhysicsFactory.createFixtureDef(1, 0.5f, 0.5f);
// ===========================================================
// Constructors
// ===========================================================
// ===========================================================
// Getter & Setter
// ===========================================================
// ===========================================================
// Methods for/from SuperClass/Interfaces
// ===========================================================
#Override
public Engine onLoadEngine() {
this.mCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);
return new Engine(new EngineOptions(true, ScreenOrientation.LANDSCAPE, new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT), this.mCamera));
}
#Override
public void onLoadResources() {
this.mBitmapTextureAtlas = new BitmapTextureAtlas(64, 32, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
this.mFaceTextureRegion = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(this.mBitmapTextureAtlas, this, "gfx/ball.png", 0, 0, 2, 1);
this.mBitmapTextureAtlas2 = new BitmapTextureAtlas(64, 32, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
this.mFaceTextureRegion2 = BitmapTextureAtlasTextureRegionFactory.createTiledFromAsset(this.mBitmapTextureAtlas2, this,"gfx/ball2.png", 0, 0, 2, 1);
this.mFontTexture = new BitmapTextureAtlas(256, 256, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
this.mFont = new Font(this.mFontTexture, Typeface.create(Typeface.DEFAULT, Typeface.BOLD), 32, true, Color.BLACK);
this.mEngine.getTextureManager().loadTextures(this.mBitmapTextureAtlas, mBitmapTextureAtlas2);
this.mEngine.getFontManager().loadFont(this.mFont);
this.mEngine.getTextureManager().loadTexture(this.mFontTexture);
}
#Override
public Scene onLoadScene() {
createAETimeHandler(2);
/* final Text textcenter = new Text(100, 60, this.mFont, "touched", HorizontalAlign.CENTER);
this.mFontTexture = new BitmapTextureAtlas(256, 256, TextureOptions.BILINEAR_PREMULTIPLYALPHA);
this.mFont = new Font(this.mFontTexture, Typeface.create(Typeface.DEFAULT, Typeface.BOLD), 32, true, Color.BLACK);*/
final Scene scene = new Scene();
scene.setOnAreaTouchListener(this);
scene.setBackground(new ColorBackground(0.6274f, 0.6274f, 0.8784f));
mPhysicsWorld = new PhysicsWorld(new Vector2(0, SensorManager.GRAVITY_EARTH), false);
scene.registerUpdateHandler(mPhysicsWorld);
mPhysicsWorld.setGravity(gravity);
final Shape ground = new Rectangle(0, CAMERA_HEIGHT - 2, CAMERA_WIDTH, 2);
final FixtureDef wallFixtureDef = PhysicsFactory.createFixtureDef(0, 0.5f, 0.5f);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, ground, BodyType.StaticBody, wallFixtureDef);
scene.attachChild(ground);
final Shape left = new Rectangle(0, 0, 2, CAMERA_HEIGHT);
final Shape right = new Rectangle(CAMERA_WIDTH - 2, 0, 2, CAMERA_HEIGHT);
final Shape roof = new Rectangle(0, 0, CAMERA_WIDTH, 2);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, left, BodyType.StaticBody, wallFixtureDef);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, right, BodyType.StaticBody, wallFixtureDef);
PhysicsFactory.createBoxBody(this.mPhysicsWorld, roof, BodyType.StaticBody, wallFixtureDef);
scene.attachChild(left);
scene.attachChild(right);
scene.attachChild(roof);
// scene.setOnSceneTouchListener((IOnSceneTouchListener) this);
//final Ball hit = new Ball(random.nextInt(600)+1, random.nextInt(400)+1, this.mFaceTextureRegion.clone());
//final Ball hit2 = new Ball(random.nextInt(600)+1, random.nextInt(400)+1, this.mFaceTextureRegion2.clone());
//body = PhysicsFactory.createBoxBody(this.mPhysicsWorld, hit2, BodyType.DynamicBody, FIXTURE_DEF);
//scene.attachChild(hit2);
//hit2.setScale(2);
//scene.registerTouchArea(hit2);
//this.mPhysicsWorld.registerPhysicsConnector(new PhysicsConnector(hit2, body, true, true));
for (int i = 0; i < rgSprite.length; i++) {
rgSprite[i] = new Ball(random.nextInt(600)+1, 200, this.mFaceTextureRegion.clone());
}
mPhysicsWorld.setGravity(gravity2);
for (Ball sprite : rgSprite) {
body = PhysicsFactory.createCircleBody(this.mPhysicsWorld, sprite, BodyType.DynamicBody, FIXTURE_DEF);
this.mPhysicsWorld.registerPhysicsConnector(new PhysicsConnector(sprite, body, true, true));
scene.registerTouchArea(sprite);
scene.attachChild(sprite);
sprite.setScale(2);
}
//scene.attachChild(hit);
//hit.setScale(2);
//scene.registerTouchArea(hit);
return scene;
}
#Override
public void onLoadComplete() {
}
private void createAETimeHandler(float mEffectSpawnDelay)
{ TimerHandler spriteTimerHandler2;
this.getEngine().registerUpdateHandler(spriteTimerHandler2 = new TimerHandler(mEffectSpawnDelay, true, new ITimerCallback()
{
#Override
public void onTimePassed(final TimerHandler pTimerHandler)
{
/*if (isTouched == 1){
mFaceTextureRegion.setCurrentTileIndex(0);
isTouched = 2;
} */
}
}));
}
// ===========================================================
// Methods
// ===========================================================
// ===========================================================
// Inner and Anonymous Classes
// ===========================================================
#Override
public boolean onAreaTouched(TouchEvent pSceneTouchEvent, ITouchArea pTouchArea, float pTouchAreaLocalX,float pTouchAreaLocalY) {
if(this.mPhysicsWorld != null) {
if (pSceneTouchEvent.getAction() == MotionEvent.ACTION_DOWN) {
this.onOff((AnimatedSprite)pTouchArea);
}
} return false;
}
private void onOff(final AnimatedSprite ball) {
ball.nextTile();
body.applyForce(new Vector2(200,-1500), new Vector2(body.getWorldCenter()));
}
}

It is because you only have one Body-variable, and it gets overwritten by the loop. When all sprites have been created you only know the body of the last sprite.
You must apply the force to the body associated with the sprite you click.