Droideando: Introducción a AndEngine (Parte IV)

Anteriormente en Droideando

Objetivos de hoy

Crear el sprite del jugador
Crear un Detector de AndEngine para el efecto de catapulta en el jugador

Creamos el jugador

Para crear el jugador he decidido usar un AnimatedSprite, pero como seguro que le tengo que meter alguna cosa, heredo la clase y la uso.

Para crear la clase, vamos a la carpeta de nuestros fuentes en Eclipse. File New -> Class y le ponemos Name Player y SuperClass AnimatedSprite. Le añadimos un TAG para el debug y por ahora listo.Se nos queda algo así.

```
package com.pruebas.andengine;
```
```
 
```

import org.anddev.andengine.entity.sprite.AnimatedSprite;

import org.anddev.andengine.input.touch.detector.HoldDetector;

import org.anddev.andengine.input.touch.detector.HoldDetector.IHoldDetectorListener;

import org.anddev.andengine.opengl.texture.region.TiledTextureRegion;

```
 
```
```
import android.util.Log;
```
```
 
```

public class Player extends AnimatedSprite  {

```
 
```

private static final String TAG = "Player";

```
 
```

public Player(float pX, float pY, TiledTextureRegion pTiledTextureRegion) {

```
super(pX, pY, pTiledTextureRegion);  
```
```
}
```
```
 
```
```
 
```
```
}
```
```
 
```

Parsed in 0.077 seconds at 7.25 KB/s, using GeSHi 1.0.8.10

Ahora volvemos al Main.java y añadimos una variable para guardar el jugador activo y cambamos la variable mFaceTextureRegion por mBallTextureRegion para que el nombre coincida con lo que lleva dentro, y le cambiamos también el tipo a TiledTextureRegion. Se queda así.

// ===========================================================

```
// Fields
```

// ===========================================================

```
 
```
```
private ZoomCamera mCamera;
```
```
private Texture mTexture;
```

private TiledTextureRegion mBallTextureRegion;

private TiledTextureRegion mPlayerTextureRegion;

private SurfaceScrollDetector mScrollDetector;

```
private TMXTiledMap mTMXTiledMap;
```
```
private Player mActivePlayer;
```

Parsed in 0.106 seconds at 3.86 KB/s, using GeSHi 1.0.8.10

Aqui pongo el sprite del jugador para que lo bajeis a vuestro proyecto, en la carpeta assets/gfx como de costumbre

Pongo también el sprite de la pelota (provisional, necesito un balón de verdad para echarle fotos), al mismo sitio assets/gfx.

Ahora vamos a cambiar la carga de texturas para cargar estas dos nuevas textuas. La carga de texturas se hace en el objeto mTexture. El objeto mTexture debe ser por exigencias de AndEngine tanto en altura como longitud potencias de 2 en píxeles. Para las texturas que tenemos ahora mismo, lo mínimo sin despercidicar ni un pixel en memoria es 256X256 píxeles. La textura en memoria se quedaría algo como ésto:

Ahora vamos a cambiar en onLoadResources para cargar todo esto que hemos metido nuevo. Primero el tamaño de la textura pasa a ser 256X256 para poder albergar las texturas que hemos metido nuevas. A la hora de crear la textura de la pelota, usamos la funcion createTiledFromAsset(), que usa los siguientes parámetros:

this.mTexture: El primero parámetro es el objeto textura donde lo vamos a guardar. En el objeto mTexture de la clase.
this: La clase actual. Pocos comentarios al respecto.
"gfx/ui_ball.png": La ruta a la imagen.
0,0: los dos siguientes parámetros es donde vamos a colocar éste objeto dentro de mTexture, en este caso vamos a colocar la pelota en la parte de la izquierda y el jugador en la derecha, o sea, para la pelota le ponemos 0,0 y para el jugador 128,0.
2,4: Número de Filas y Columnas, en el caso tanto de la pelota como del jugador son 2,4.

Se queda una cosa así:

```
@Override
```
```
public void onLoadResources() {
```
```
this.mTexture = new Texture(256, 256,
```

TextureOptions.BILINEAR_PREMULTIPLYALPHA);

this.mBallTextureRegion = TextureRegionFactory.createTiledFromAsset(

this.mTexture, this, "gfx/ui_ball.png", 0, 0, 2, 4);

this.mPlayerTextureRegion = TextureRegionFactory.createTiledFromAsset(

this.mTexture, this, "gfx/ui_player.png", 128, 0, 2, 4);

```
 
```

this.mEngine.getTextureManager().loadTexture(this.mTexture);

```
 
```
```
}
```

Parsed in 0.074 seconds at 6.24 KB/s, using GeSHi 1.0.8.10

Ahora vamos a tocar el método onLoadScene(). Primero eliminamos el código que creaba la bola y desactivamos el Detector de Scroll. El final del procedimiento se me queda así.

scene.setOnAreaTouchTraversalFrontToBack();

```
 
```

this.mScrollDetector = new SurfaceScrollDetector(this);

this.mScrollDetector.setEnabled(false); //Hemos puesto esto a false

```
 
```
```
/*
```

  final int centerX = (CAMERA_WIDTH - this.mFaceTextureRegion.getWidth()) / 2;

  final int centerY = (CAMERA_HEIGHT - this.mFaceTextureRegion

```
    .getHeight()) / 2;
```
```
 
```

  final Sprite ball = new Sprite(centerX, centerY,

```
    this.mFaceTextureRegion);
```

  scene.getLastChild().attachChild(ball);

```
     */
```
```
scene.setOnSceneTouchListener(this);
```
```
scene.setTouchAreaBindingEnabled(true);
```
```
 
```
```
return scene;
```
```
}
```

Parsed in 0.077 seconds at 7.57 KB/s, using GeSHi 1.0.8.10

Ahora metemos el jugador en pantalla y ya podemos probar como se ve y eso. Para ello creamos un método createPlayer().

// ===========================================================

```
// Methods
```

// ===========================================================

```
 
```
```
private void createPlayer() {
```

final Scene scene = this.mEngine.getScene();

```
 
```

final Player sprite = new Player(200, 100, this.mPlayerTextureRegion);

```
// scene.registerTouchArea(sprite);
```
```
 
```

scene.getLastChild().attachChild(sprite);

```
this.mActivePlayer = sprite;
```
```
}
```

Parsed in 0.069 seconds at 5.99 KB/s, using GeSHi 1.0.8.10

Aqui lo que hacemos es para probar ponemos un jugador en la posicion 200,100. Ahora llamamos a este método desde onLoadComplete().

```
@Override
```

public void onLoadComplete() { // scene.set

```
createPlayer();
```
```
}
```

Parsed in 0.072 seconds at 1.08 KB/s, using GeSHi 1.0.8.10

En este punto ya podemos ejecutar el programa para ver como va la cosa. Se ve el cesped y el jugador, pero no responde al Scroll porque lo hemos desactivado. Por ahora todo va bien. Vamos a crear el Detector.

Creando un Detector

Mirando un poco los fuentes del ScrollDetector, que funciona de fábula y siendo el juego tipo catapultas bastante popular, porqué no hacer un Detector de catapultas?? Manos a la obra.

Creamos una nueva clase en nuestro proyecto. Nombre: CatapultDetector y SuperClass BaseDetector (org.anddev.andengine.input.touch.detector.BaseDetector)

```
package com.pruebas.andengine;
```
```
 
```

import org.anddev.andengine.input.touch.TouchEvent;

import org.anddev.andengine.input.touch.detector.BaseDetector;

```
 
```

public class CatapultDetector extends BaseDetector {

```
 
```
```
@Override
```

protected boolean onManagedTouchEvent(TouchEvent pSceneTouchEvent) {

```
// TODO Auto-generated method stub
```
```
return false;
```
```
}
```
```
 
```
```
}
```
```
 
```

Parsed in 0.091 seconds at 3.82 KB/s, using GeSHi 1.0.8.10

Un detector es un objeto para usarlo como hicimos con el ScrollDetector en el anterior tutorial. Necesitamos una interface listener. Vamos a ello.

public static interface ICatapultDetectorListener {

// ===========================================================

```
// Constants
```

// ===========================================================

```
 
```

// ===========================================================

```
// Methods
```

// ===========================================================

```
 
```

public void onCharge(final CatapultDetector pCatapultDetector,

final TouchEvent pTouchEvent, final float pDistance,

```
final float pAngle);
```
```
 
```

public void onShoot(final CatapultDetector pCatapultDetector,

final TouchEvent pTouchEvent, final float pDistance,

```
final float pAngle);
```
```
}
```
```
 
```

Parsed in 0.102 seconds at 6.30 KB/s, using GeSHi 1.0.8.10

Este es un listener básico para probar el funcionamiento. Al objeto que esté escuchando le pasamos un ángulo y una distancia. Esta clase la definimos dentro de la CatapultDetector al final como en los demás Detectors que he visto en los fuentes de AndEngine.

Vamos a meterle algunas variables al Detector que algunas las vamos a usar ya mismo y otras las usaremos después. No preocuparse por los warnings, ya nos encargaremos de eso más tarde

// ===========================================================

```
// Constants
```

// ===========================================================

private static final float TRIGGER_SCROLL_MINIMUM_DISTANCE_DEFAULT = 10;

private static final float ANGLE_CONSTANT = 10;

private static final int DEFAULT_STEPS = 6;

private float DEFAULT_MAX_DISTANCE = 100;

// ===========================================================

```
// Fields
```

// ===========================================================

```
 
```
```
//Minimum distance to execute 
```

private float mTriggerScrollMinimumDistance;

```
 
```
```
//Listener for the Detector
```

private final ICatapultDetectorListener mCatapultDetectorListener;

```
 
```
```
private boolean mTriggered;
```
```
 
```
```
//First Touch
```
```
private float mFirstX;
```
```
private float mFirstY;
```
```
 
```
```
//Last Touch
```
```
private float mLastX;
```
```
private float mLastY;
```
```
 
```
```
private int mSteps;
```
```
private float mMaxDistance;
```

Parsed in 0.088 seconds at 10.05 KB/s, using GeSHi 1.0.8.10

Creamos unos métodos que usaremos después y los Getter y Setter para mTriggerScrollMinimumDistance.

// ===========================================================

```
// Getter & Setter
```

// ===========================================================

```
 
```

public void setTriggerScrollMinimumDistance(

```
float mTriggerScrollMinimumDistance) {
```

this.mTriggerScrollMinimumDistance = mTriggerScrollMinimumDistance;

```
}
```
```
 
```

public float getTriggerScrollMinimumDistance() {

```
return mTriggerScrollMinimumDistance;
```
```
}
```
```
 
```

// ===========================================================

```
// Methods
```

// ===========================================================

```
 
```

protected float getX(final TouchEvent pTouchEvent) {

```
return pTouchEvent.getX();
```
```
}
```
```
 
```

protected float getY(final TouchEvent pTouchEvent) {

```
return pTouchEvent.getY();
```
```
}
```

Parsed in 0.098 seconds at 7.41 KB/s, using GeSHi 1.0.8.10

Tocamos un poco los constructores de la clase

// ===========================================================

```
// Constructors
```

// ===========================================================

```
 
```
```
public CatapultDetector(
```

final ICatapultDetectorListener pCatapultDetectorListener) {

this(TRIGGER_SCROLL_MINIMUM_DISTANCE_DEFAULT, pCatapultDetectorListener);

```
}
```
```
 
```

public CatapultDetector(final float pTriggerScrollMinimumDistance,

final ICatapultDetectorListener pCatapultDetectorListener) {

this.setTriggerScrollMinimumDistance(pTriggerScrollMinimumDistance);

this.mCatapultDetectorListener = pCatapultDetectorListener;

```
}
```

Parsed in 0.077 seconds at 7.53 KB/s, using GeSHi 1.0.8.10

Y ahora tocamos el método donde se va a llevar todo a cabo, para nuestra primera prueba nos vale algo sencillo como ésto

// ===========================================================

// Methods for/from SuperClass/Interfaces

// ===========================================================

```
 
```
```
@Override
```

protected boolean onManagedTouchEvent(TouchEvent pSceneTouchEvent) {

final float touchX = this.getX(pSceneTouchEvent);

final float touchY = this.getY(pSceneTouchEvent);

```
 
```
```
switch (pSceneTouchEvent.getAction()) {
```
```
case MotionEvent.ACTION_DOWN:
```
```
this.mFirstX = touchX;
```
```
this.mFirstY = touchY;
```
```
this.mLastX = touchX;
```
```
this.mLastY = touchY;
```
```
this.mTriggered = false;
```
```
return true;
```
```
case MotionEvent.ACTION_MOVE:
```
```
case MotionEvent.ACTION_UP:
```
```
case MotionEvent.ACTION_CANCEL:
```

final float distanceX = touchX - this.mLastX;

final float distanceY = touchY - this.mLastY;

if (pSceneTouchEvent.getAction() == MotionEvent.ACTION_MOVE) {

final float triggerScrollMinimumDistance = this.mTriggerScrollMinimumDistance;

```
if (this.mTriggered
```

|| Math.abs(distanceX) > triggerScrollMinimumDistance

|| Math.abs(distanceY) > triggerScrollMinimumDistance) {

final float distance = (float)Math.hypot((double)distanceX,(double)distanceY);

final double angleX = touchX - this.mFirstX;

final double angleY = touchY - this.mFirstY;

final float angle = (float)Math.toDegrees(Math.atan2(angleY, angleX))+ANGLE_CONSTANT;

this.mCatapultDetectorListener.onCharge(this, pSceneTouchEvent, distance, angle);

```
this.mLastX = touchX;
```
```
this.mLastY = touchY;
```
```
this.mTriggered = true;
```
```
}
```
```
else
```
```
{
```
```
 
```
```
 
```
```
}
```
```
}
```
```
return true;
```
```
default:
```
```
return false;
```
```
}
```
```
}
```
```
 
```

Parsed in 0.097 seconds at 16.70 KB/s, using GeSHi 1.0.8.10

Ya entraré mas a detalle en otro artículo de como funciona el Detector, pero mirando los fuentes puedes hacerte una idea bastante clara. Con esto ya tenemos el Detector en el punto para probarlo. Volvamos al Main.java. Creamos una variable privada para albergar el detector.

// ===========================================================

```
// Fields
```

// ===========================================================

```
 
```
```
private ZoomCamera mCamera;
```
```
private Texture mTexture;
```

private TiledTextureRegion mBallTextureRegion;

private TiledTextureRegion mPlayerTextureRegion;

private SurfaceScrollDetector mScrollDetector;

```
private TMXTiledMap mTMXTiledMap;
```
```
private Player mActivePlayer;
```

private CatapultDetector mCatapultDetector; //Nueva variable Creada

Parsed in 0.078 seconds at 6.09 KB/s, using GeSHi 1.0.8.10

Ahora necesitamos le decimos a nuestra Clase Main, que implemente la interface ICatapultDetectorListener.

public class Main extends BaseGameActivity implements IScrollDetectorListener,

IOnSceneTouchListener, ICatapultDetectorListener

Parsed in 0.082 seconds at 1.54 KB/s, using GeSHi 1.0.8.10

Ahora implementamos los métodos de ICatapultDetectorListener.

```
@Override
```

public void onCharge(CatapultDetector pCatapultDetector,

TouchEvent pTouchEvent, float pDistance, float pAngle) {

Log.d(TAG, "Cargando... {Distancia:" + pDistance + ", angulo: "

```
+ pAngle + "}");
```
```
this.mActivePlayer.setRotation(pAngle);
```
```
 
```
```
}
```
```
 
```
```
@Override
```

public void onShoot(CatapultDetector pCatapultDetector,

TouchEvent pTouchEvent, float pDistance, float pAngle) {

Log.d(TAG, "Disparo... {Distancia:" + pDistance + ", angulo: " + pAngle

```
+ "}");
```
```
}
```

Parsed in 0.084 seconds at 5.75 KB/s, using GeSHi 1.0.8.10

En el método onCharge() rotamos el jugador el ángulo que correspode, en el onShoot() un debug solamente, aunque realmente en el estado del detector no se va a disparar este evento aún. Lo siguiente es crear en el onLoadScene() el Scroll y asignarlo.

this.mScrollDetector = new SurfaceScrollDetector(this);

this.mScrollDetector.setEnabled(false);

```
 
```
```
//Creamos el detector de catapulta
```

this.mCatapultDetector = new CatapultDetector(this);

this.mCatapultDetector.setEnabled(true);

Parsed in 0.093 seconds at 2.55 KB/s, using GeSHi 1.0.8.10

Y en el onSceneTouchEvent le pasamos el evento al CatapultDetector.

```
@Override
```

public boolean onSceneTouchEvent(Scene pScene, TouchEvent pSceneTouchEvent) {

```
if (this.mActivePlayer != null) {
```

this.mCatapultDetector.onTouchEvent(pSceneTouchEvent);

```
}
```
```
return true;
```
```
}
```

Parsed in 0.079 seconds at 2.59 KB/s, using GeSHi 1.0.8.10

Ya tenemos el proyecto en otro momento para poder ejecutar y ver que está pasando por debajo de todo ésto. F11 y arranca splash... aparece el campo con el jugador, hacemos click en cualquier sitio, y al mover el dedo por la pantalla vemos como el jugador gira, aunque no lo hace en el ángulo correcto, pero es un principio. Ahora mismo mis archivos están asi:

Main.java

```
package com.pruebas.andengine;
```
```
 
```

import org.anddev.andengine.engine.Engine;

import org.anddev.andengine.engine.camera.ZoomCamera;

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.layer.tiled.tmx.TMXLayer;

import org.anddev.andengine.entity.layer.tiled.tmx.TMXLoader;

import org.anddev.andengine.entity.layer.tiled.tmx.TMXProperties;

import org.anddev.andengine.entity.layer.tiled.tmx.TMXTile;

import org.anddev.andengine.entity.layer.tiled.tmx.TMXTileProperty;

import org.anddev.andengine.entity.layer.tiled.tmx.TMXTiledMap;

import org.anddev.andengine.entity.layer.tiled.tmx.TMXLoader.ITMXTilePropertiesListener;

import org.anddev.andengine.entity.layer.tiled.tmx.util.exception.TMXLoadException;

import org.anddev.andengine.entity.scene.Scene;

import org.anddev.andengine.entity.scene.Scene.IOnSceneTouchListener;

import org.anddev.andengine.entity.sprite.AnimatedSprite;

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.input.touch.detector.ScrollDetector;

import org.anddev.andengine.input.touch.detector.SurfaceScrollDetector;

import org.anddev.andengine.input.touch.detector.ScrollDetector.IScrollDetectorListener;

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.opengl.texture.region.TiledTextureRegion;

import org.anddev.andengine.ui.activity.BaseGameActivity;

```
import org.anddev.andengine.util.Debug;
```
```
 
```
```
import android.util.Log;
```
```
 
```

import com.pruebas.andengine.CatapultDetector.ICatapultDetectorListener;

```
 
```

public class Main extends BaseGameActivity implements IScrollDetectorListener,

IOnSceneTouchListener, ICatapultDetectorListener {

// ===========================================================

```
// Constants
```

// ===========================================================

```
static final int CAMERA_WIDTH = 480;
```
```
static final int CAMERA_HEIGHT = 320;
```
```
 
```

private static final String TAG = "AndEngineTest";

```
 
```

// ===========================================================

```
// Fields
```

// ===========================================================

```
 
```
```
private ZoomCamera mCamera;
```
```
private Texture mTexture;
```

private TiledTextureRegion mBallTextureRegion;

private TiledTextureRegion mPlayerTextureRegion;

private SurfaceScrollDetector mScrollDetector;

```
private TMXTiledMap mTMXTiledMap;
```
```
private Player mActivePlayer;
```

private CatapultDetector mCatapultDetector; //Nueva variable Creada

```
 
```

// ===========================================================

```
// Constructors
```

// ===========================================================

```
 
```

// ===========================================================

```
// Getter & Setter
```

// ===========================================================

```
 
```

// ===========================================================

// Methods for/from SuperClass/Interfaces

// ===========================================================

```
 
```
```
@Override
```
```
public void onLoadComplete() {  
```
```
createPlayer();
```
```
}
```
```
 
```
```
@Override
```
```
public Engine onLoadEngine() {
```

this.mCamera = new ZoomCamera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);

final int alturaTotal = CAMERA_HEIGHT * 3;

this.mCamera.setBounds(0, CAMERA_WIDTH, 0, alturaTotal);

```
this.mCamera.setBoundsEnabled(true);
```

return new Engine(new EngineOptions(true, ScreenOrientation.LANDSCAPE,

new RatioResolutionPolicy(CAMERA_WIDTH, CAMERA_HEIGHT),

```
this.mCamera));
```
```
}
```
```
 
```
```
@Override
```
```
public void onLoadResources() {
```
```
this.mTexture = new Texture(256, 256,
```

TextureOptions.BILINEAR_PREMULTIPLYALPHA);

this.mBallTextureRegion = TextureRegionFactory.createTiledFromAsset(

this.mTexture, this, "gfx/ui_ball.png", 0, 0, 2, 4);

this.mPlayerTextureRegion = TextureRegionFactory.createTiledFromAsset(

this.mTexture, this, "gfx/ui_player.png", 128, 0, 2, 4);

```
 
```

this.mEngine.getTextureManager().loadTexture(this.mTexture);

```
 
```
```
}
```
```
 
```
```
@Override
```
```
public Scene onLoadScene() {
```

this.mEngine.registerUpdateHandler(new FPSLogger());

```
 
```
```
final Scene scene = new Scene(1);
```
```
 
```
```
try {
```

final TMXLoader tmxLoader = new TMXLoader(this, this.mEngine

.getTextureManager(), // TextureOptions.BILINEAR_PREMULTIPLYALPHA,

TextureOptions.NEAREST, new ITMXTilePropertiesListener() {

```
 
```
```
@Override
```

public void onTMXTileWithPropertiesCreated(

```
final TMXTiledMap pTMXTiledMap,
```
```
final TMXLayer pTMXLayer,
```
```
final TMXTile pTMXTile,
```

final TMXProperties<TMXTileProperty> pTMXTileProperties) {

```
 
```
```
}
```
```
 
```
```
});
```

this.mTMXTiledMap = tmxLoader.loadFromAsset(this, "tmx/field.tmx");

} catch (final TMXLoadException tmxle) {

```
Debug.e(tmxle);
```
```
}
```
```
 
```

final TMXLayer tmxLayer = this.mTMXTiledMap.getTMXLayers().get(0);

scene.getFirstChild().attachChild(tmxLayer);

```
 
```

scene.setOnAreaTouchTraversalFrontToBack();

```
 
```

this.mScrollDetector = new SurfaceScrollDetector(this);

this.mScrollDetector.setEnabled(false);

```
 
```

this.mCatapultDetector = new CatapultDetector(this);

this.mCatapultDetector.setEnabled(true);

```
 
```
```
scene.setOnSceneTouchListener(this);
```
```
scene.setTouchAreaBindingEnabled(true);
```
```
 
```
```
return scene;
```
```
}
```
```
 
```
```
 
```
```
@Override
```

public void onCharge(CatapultDetector pCatapultDetector,

TouchEvent pTouchEvent, float pDistance, float pAngle) {

Log.d(TAG, "Cargando... {Distancia:" + pDistance + ", angulo: "

```
+ pAngle + "}");
```
```
this.mActivePlayer.setRotation(pAngle);
```
```
 
```
```
}
```
```
 
```
```
@Override
```

public void onShoot(CatapultDetector pCatapultDetector,

TouchEvent pTouchEvent, float pDistance, float pAngle) {

Log.d(TAG, "Disparo... {Distancia:" + pDistance + ", angulo: " + pAngle

```
+ "}");
```
```
} 
```
```
 
```
```
 
```
```
@Override
```

public void onScroll(ScrollDetector pScollDetector, TouchEvent pTouchEvent,

```
float pDistanceX, float pDistanceY) {
```

this.mCamera.offsetCenter(-pDistanceX, -pDistanceY);

```
}
```
```
 
```
```
@Override
```

public boolean onSceneTouchEvent(Scene pScene, TouchEvent pSceneTouchEvent) {

```
if (this.mActivePlayer != null) {
```

this.mCatapultDetector.onTouchEvent(pSceneTouchEvent);

```
}
```
```
return true;
```
```
}
```
```
 
```

// ===========================================================

```
// Methods
```

// ===========================================================

```
 
```
```
private void createPlayer() {
```

final Scene scene = this.mEngine.getScene();

```
 
```

final Player sprite = new Player(200, 100, this.mPlayerTextureRegion);

scene.getLastChild().attachChild(sprite);

```
 
```
```
this.mActivePlayer = sprite;
```
```
} 
```
```
 
```
```
 
```

// ===========================================================

```
// Inner and Anonymous Classes
```

// ===========================================================

```
}
```
```
 
```

Parsed in 0.129 seconds at 53.47 KB/s, using GeSHi 1.0.8.10

CatapultDetector.java

```
package com.pruebas.andengine;
```
```
 
```

import org.anddev.andengine.input.touch.TouchEvent;

import org.anddev.andengine.input.touch.detector.BaseDetector;

```
 
```
```
import android.view.MotionEvent;
```
```
 
```

public class CatapultDetector extends BaseDetector {

// ===========================================================

```
// Constants
```

// ===========================================================

private static final float TRIGGER_SCROLL_MINIMUM_DISTANCE_DEFAULT = 10;

private static final float ANGLE_CONSTANT = 10;

private static final int DEFAULT_STEPS = 6;

private float DEFAULT_MAX_DISTANCE = 100;

// ===========================================================

```
// Fields
```

// ===========================================================

```
 
```
```
//Minimum distance to execute 
```

private float mTriggerScrollMinimumDistance;

```
 
```
```
//Listener for the Detector
```

private final ICatapultDetectorListener mCatapultDetectorListener;

```
 
```
```
private boolean mTriggered;
```
```
 
```
```
//First Touch
```
```
private float mFirstX;
```
```
private float mFirstY;
```
```
 
```
```
//Last Touch
```
```
private float mLastX;
```
```
private float mLastY;
```
```
 
```
```
private int mSteps;
```
```
private float mMaxDistance;
```
```
 
```

// ===========================================================

```
// Constructors
```

// ===========================================================

```
 
```
```
public CatapultDetector(
```

final ICatapultDetectorListener pCatapultDetectorListener) {

this(TRIGGER_SCROLL_MINIMUM_DISTANCE_DEFAULT, pCatapultDetectorListener);

```
}
```
```
 
```

public CatapultDetector(final float pTriggerScrollMinimumDistance,

final ICatapultDetectorListener pCatapultDetectorListener) {

this.setTriggerScrollMinimumDistance(pTriggerScrollMinimumDistance);

this.mCatapultDetectorListener = pCatapultDetectorListener;

```
}
```
```
 
```
```
 
```
```
 
```

// ===========================================================

// Methods for/from SuperClass/Interfaces

// ===========================================================

```
 
```
```
@Override
```

protected boolean onManagedTouchEvent(TouchEvent pSceneTouchEvent) {

final float touchX = this.getX(pSceneTouchEvent);

final float touchY = this.getY(pSceneTouchEvent);

```
 
```
```
switch (pSceneTouchEvent.getAction()) {
```
```
case MotionEvent.ACTION_DOWN:
```
```
this.mFirstX = touchX;
```
```
this.mFirstY = touchY;
```
```
this.mLastX = touchX;
```
```
this.mLastY = touchY;
```
```
this.mTriggered = false;
```
```
return true;
```
```
case MotionEvent.ACTION_MOVE:
```
```
case MotionEvent.ACTION_UP:
```
```
case MotionEvent.ACTION_CANCEL:
```

final float distanceX = touchX - this.mLastX;

final float distanceY = touchY - this.mLastY;

if (pSceneTouchEvent.getAction() == MotionEvent.ACTION_MOVE) {

final float triggerScrollMinimumDistance = this.mTriggerScrollMinimumDistance;

```
if (this.mTriggered
```

|| Math.abs(distanceX) > triggerScrollMinimumDistance

|| Math.abs(distanceY) > triggerScrollMinimumDistance) {

final float distance = (float)Math.hypot((double)distanceX,(double)distanceY);

final double angleX = touchX - this.mFirstX;

final double angleY = touchY - this.mFirstY;

final float angle = (float)Math.toDegrees(Math.atan2(angleY, angleX));

this.mCatapultDetectorListener.onCharge(this, pSceneTouchEvent, distance, angle);

```
this.mLastX = touchX;
```
```
this.mLastY = touchY;
```
```
this.mTriggered = true;
```
```
}
```
```
else
```
```
{
```
```
 
```
```
 
```
```
}
```
```
}
```
```
return true;
```
```
default:
```
```
return false;
```
```
}
```
```
}
```
```
 
```

// ===========================================================

```
// Getter & Setter
```

// ===========================================================

```
 
```

public void setTriggerScrollMinimumDistance(

```
float mTriggerScrollMinimumDistance) {
```

this.mTriggerScrollMinimumDistance = mTriggerScrollMinimumDistance;

```
}
```
```
 
```

public float getTriggerScrollMinimumDistance() {

```
return mTriggerScrollMinimumDistance;
```
```
}
```
```
 
```

// ===========================================================

```
// Methods
```

// ===========================================================

```
 
```

protected float getX(final TouchEvent pTouchEvent) {

```
return pTouchEvent.getX();
```
```
}
```
```
 
```

protected float getY(final TouchEvent pTouchEvent) {

```
return pTouchEvent.getY();
```
```
} 
```
```
 
```
```
 
```

// ===========================================================

```
// Inner and Anonymous Classes
```

// ===========================================================

```
 
```

public static interface ICatapultDetectorListener {

// ===========================================================

```
// Constants
```

// ===========================================================

```
 
```

// ===========================================================

```
// Methods
```

// ===========================================================

```
 
```

public void onCharge(final CatapultDetector pCatapultDetector,

final TouchEvent pTouchEvent, final float pDistance,

```
final float pAngle);
```
```
 
```

public void onShoot(final CatapultDetector pCatapultDetector,

final TouchEvent pTouchEvent, final float pDistance,

```
final float pAngle);
```
```
}
```
```
 
```
```
}
```
```
 
```

Parsed in 0.126 seconds at 38.60 KB/s, using GeSHi 1.0.8.10

Bueno, por hoy está bien, voy a seguir trabajando en el Detector y cuando lo tenga terminado lo pongo en el foro de AndEngine y subo otro artículo siguiendo por la misma línea.

7 comentarios:

MeKaWeNDie dijo...: Sigue así crack !!!

A ver si puedo ir sacando tiempo y puedo mirarlo un poco más a fondo todo.

Muchas gracias por tu trabajo!; 29 de marzo de 2011, 10:46
Angel dijo...: Gracias por el comentario.

Voy a pasar unas semanas en las que no voy a poder dedicarle tiempo a esto, pero ya tengo metido el motor de físicas box2d para el proyecto, y funciona de lujo. Para el siguiente artículo lo pongo.; 29 de marzo de 2011, 18:20
@MMMM87 dijo...: Estoy tratando hacer funcionar las librerias y el motor de fisicas pero no lo he conseguido. Es necesario tenerlas separadas?! o pueden estar en un solo archivo jar(la libreria y las extensiones)??; 30 de agosto de 2011, 22:31
Osiris dijo...: Nesecito más! plis!!; 29 de septiembre de 2011, 19:58
Gonzalo Santacruz dijo...: Buscando info sobre andengine y desarrollo de juegos 2D he encontrado tu blog. Es muy interesante lo que aquí explicas.

Te expongo mi problema a ver si tu te has encontrado con lo mismo:
Yo estoy intentando desarrollar un juego de mesa en android. El tema es que para el tablero intento ver ejemplos de trabajo con polígonos (regulares, triángulos, cuadrados y también círculos) y aunque encuentro ejemplos en andengine no consigo que compilen porque no veo esas clases en la extensión.
Agradecería ayudas...;-); 28 de febrero de 2012, 16:01
Paco dijo...: Hola Angel
Como vas con este tutorial,... he realizado todos los capitulos y me he quedado con la miel en los labios,... hay mas tutoriales?; 13 de abril de 2012, 16:10
Cristian Garcia Escobar dijo...: hola como vas excelentes tutoriales, vas a continuar con ellos?; 4 de enero de 2013, 23:17

Pages

viernes, 25 de marzo de 2011

Introducción a AndEngine (Parte IV)

Anteriormente en Droideando

Objetivos de hoy

Creamos el jugador

Creando un Detector

7 comentarios:

Publicar un comentario

Entradas populares

Temas

Pages

viernes, 25 de marzo de 2011

Introducción a AndEngine (Parte IV)

Anteriormente en Droideando

Objetivos de hoy

Creamos el jugador

Creando un Detector

7 comentarios:

Publicar un comentario

Entradas populares

Temas

Suscribirse a