Droideando

domingo, 12 de junio de 2011

Como compilar tu propio andengine.jar

Consiguiendo los fuentes

Primero necesitamos los fuentes de andengine. Usaremos un Cliente de Mercurial.

En mi caso (debian) "apt-get install mercurial", en ubuntu deberia funcionar también. Si estás usando windows, de los clientes de arriba usa el que más te guste, pero no los he probado y ahí no te puedo ayudar. Creamos un directorio en nuestro pc, y vamos con un terminal a ese directorio.

hg clone https://andengine.googlecode.com/hg/ andengine

Nos tiene que dar una salida como ésta:
requesting all changes
adding changesets
adding manifests
adding file changes
added 818 changesets with 3243 changes to 703 files (+4 heads)
updating to branch default
410 files updated, 0 files merged, 0 files removed, 0 files unresolved

Enhorabuena, nuestro primer paso para tener nuestro propio andengine.jar esta completo.

Importando los fuentes al android

En Eclipse, vamos a File -> Import

Seleccionamos "Existing Projects into Workspace" y le damos a Siguiente. Ahora en "Select root directory" vamos al directorio que creamos anteriormente para bajar los fuentes de andengine. En mi caso, esto pinta como ésto:

Si has seguido los pasos bien, en Projects debes ver AndEngine chequeado. Dale a Finish.

Ahora tenemos el proyecto metido en eclipse, pero tiene algún error.

Arreglando los errores

Una vez importado el proyecto en Eclipse, necesitamos crear un directorio "res", hacemos click derecho en el raiz del proyecto AndEngine, y le damos a New -> Folder.

Una vez creados el directorio res, ya no ha errores en el proyecto.

Creando el archivo .jar

Botón derecho en el raiz del proyecto AndEngine y seleccionamos export.

Ahora seleccionamos Java -> Jar y hacemos click en Siguiente.

En la siguiente pantalla necesitamos hacer algo importante, necesitamos quitar del andengine.jar lo que no necesitamos. En la parte de la derecha, deschequear TODO lo de andengine, porque no es necesario. También he quitado la carpeta donde hay imagenes y uml...
Ahora le damos una salida al archivo jar y hacemos click en finish.

Espero que os haya servido de ayuda. Un saludo.

viernes, 8 de abril de 2011

Estado actual del proyecto

Perdon por la calidad del video. Espero en los proximos dias subir a subversion el codigo del proyecto y hacer unos 3 articulo para llegar de lo que tenemos ahora a lo que se ve en el video. Usando Box2d para las físicas. Espero que os guste.

sábado, 26 de marzo de 2011

Introducción a AndEngine (Parte V)

Anteriormente en Droideando

Objetivos de hoy

Terminar el CatapultDetector para hacerlo funcionar bien
Hacer que el jugador reaccione al Detector

Con el Detector

Ya tengo terminado el detector, pongo aqui el código completo y luego vamos a verlo por partes

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 ANGLE_CONSTANT = 90;

private static final float DEFAULT_MAX_DISTANCE = 80;

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

```
// Fields
```

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

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

private final ICatapultDetectorListener mCatapultDetectorListener;

```
private float mMaxDistance;
```
```
 
```
```
// First Touch
```
```
private float mFirstX;
```
```
private float mFirstY;
```
```
 
```

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

```
// Constructors
```

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

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

final ICatapultDetectorListener pCatapultDetectorListener) {

this(DEFAULT_MAX_DISTANCE, pCatapultDetectorListener);

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

public CatapultDetector(final float pMaxDistance,

final ICatapultDetectorListener pCatapultDetectorListener) {

```
this.setMaxDistance(pMaxDistance);
```

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);

final int action = pSceneTouchEvent.getAction();

```
 
```
```
switch (action) {
```
```
case MotionEvent.ACTION_DOWN:
```
```
this.mFirstX = touchX;
```
```
this.mFirstY = touchY;
```
```
return true;
```
```
case MotionEvent.ACTION_MOVE:
```
```
case MotionEvent.ACTION_UP:
```
```
// case MotionEvent.ACTION_CANCEL:
```

final float distanceX = Math.abs(touchX - this.mFirstX);

final float distanceY = Math.abs(touchY - this.mFirstY);

final float distance = Math.min((float) Math.hypot(

(double) distanceX, (double) distanceY), mMaxDistance);

final double angleX = touchX - this.mFirstX;

final double angleY = touchY - this.mFirstY;

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

```
angleX))
```
```
+ ANGLE_CONSTANT;
```

if (action == MotionEvent.ACTION_MOVE) {

this.mCatapultDetectorListener.onCharge(this, pSceneTouchEvent,

```
distance, angle);
```
```
} else {
```

this.mCatapultDetectorListener.onShoot(this, pSceneTouchEvent,

```
distance, angle);
```
```
}
```
```
return true;
```
```
default:
```
```
return false;
```
```
}
```
```
}
```
```
 
```

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

```
// Getter & Setter
```

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

```
 
```

public void setMaxDistance(float mMaxDistance) {

```
this.mMaxDistance = mMaxDistance;
```
```
}
```
```
 
```
```
public float getMaxDistance() {
```
```
return mMaxDistance;
```
```
}
```
```
 
```

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

```
// 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.130 seconds at 31.87 KB/s, using GeSHi 1.0.8.10

Vamos primero a profundizar un poco en el Listener que es lo primero que hay que hacer bajo mi punto de vista

Listener de la clase CatapultDetector

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.091 seconds at 7.05 KB/s, using GeSHi 1.0.8.10

Este Listener tiene que responder a dos eventos, cuando estamos cargando y cuando soltamos para realizar el disparo. Para el primero usamos un método onCharge(), que le pasa los siguientes parámetros:

pCatapultDetector: El propio detector.
pTouchEvent: El evento en pantalla que ha desencadenado la acción.
pDistance: la distancia desde el punto incial de pulsación hasta el punto actual.
pAngle: En ángulo formado desde el primer punto de pulsación al actual. Este parámetro se puede aplicar a un sprite y girará correctamente .

Los parámetros del el onShoot() son los mismos, solo que el evento implica disparo. Veamos ahora las variables del Detector.

Variables de la clase CatapultDetector

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

```
// Constants
```

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

private static final float ANGLE_CONSTANT = 90;

private static final float DEFAULT_MAX_DISTANCE = 80;

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

```
// Fields
```

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

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

private final ICatapultDetectorListener mCatapultDetectorListener;

```
private float mMaxDistance;
```
```
 
```
```
// First Touch
```
```
private float mFirstX;
```
```
private float mFirstY;
```

Parsed in 0.086 seconds at 6.68 KB/s, using GeSHi 1.0.8.10

Tenemos primero las constantes

ANGLE_CONSTANT: En las pruebas que realicé con el Detector, tenia que sumarle 90 al ángulo que calculaba para que el sprite rotara en la dirección que yo necesitaba.
DEFAULT_MAX_DISTANCE: Distancia máxima de carga por defecto, si no se le indica ninguna, la velocidad máxima de carga son 80 pixeles. Esto quiere decir que si alejo el dedo mas de 80 píxeles del punto inicial de toque, no carga a 81 ni a 90, el máximo es 80. Recordad que siempre son 80 pixeles relativos a la resolución deseada de trabajar, Si luego ejecutamos el programa en un terminal con una resolución mayor, AndEngine controlará ésto .

Un repaso a las variables

mCatapultDetectorListener: Es un ICatapultDetectorListener que hemos visto antes. Es obligado para un Detector tener un Listener que "escuche" los eventos que este Detector dispara. Se le indica en el constructor de la clase.
mMaxDistance: Variable donde guardamos la máxima distancia actual para este detector.
mFirstX,mFirstY: Aqui guardamos la posición de la primera pulsación para calcular la distancia el ángulo.

Veamos los dos constructures de la clase

Constructores de la clase CatapultDetector

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

```
// Constructors
```

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

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

final ICatapultDetectorListener pCatapultDetectorListener) {

this(DEFAULT_MAX_DISTANCE, pCatapultDetectorListener);

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

public CatapultDetector(final float pMaxDistance,

final ICatapultDetectorListener pCatapultDetectorListener) {

```
this.setMaxDistance(pMaxDistance);
```

this.mCatapultDetectorListener = pCatapultDetectorListener;

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

Parsed in 0.086 seconds at 5.98 KB/s, using GeSHi 1.0.8.10

Tenemos dos constructores. Al primero se le manda solamente el ICatapultDetectorListener que va a escuchar, con este constructor se usa la máxima distancia por defecto. Éste llama al segundo con el parámetro de maxima distancia con la constante antes vista. El segundo es el más completo, que aparte del listener recibe la máxima distancia de carga.

La miga del Detector está en el método onManagedTouchEvent(). Recibe como parámetro únicamente el TouchEvent. Vamos por partes.

final float touchX = this.getX(pSceneTouchEvent);

final float touchY = this.getY(pSceneTouchEvent);

final int action = pSceneTouchEvent.getAction();

Parsed in 0.081 seconds at 1.88 KB/s, using GeSHi 1.0.8.10

Aqui usamos variables finales para guardar datos que vamos a usar despues. En la primera línea guardamos la posición X pulsada, en la segunda guardamos la posición Y y en la tercera guardamos la acción realizada, en este caso vamos a controlar los siguientes:

ACTION_DOWN : Cuando se pulsa la pantalla.
ACTION_MOVE : Cuando ya tenemos la pantalla pulsada y lo que hacemos es mover el dedo por la pantalla.
ACTION_UP : Acción de levantar el dedo.

Cuando el evento es ACTION_DOWN, lo único que hacemos es guardar los puntos donde hemos pulsado para posteriormente calcular ángulos y distancia.

Para el ACTION_MOVE y ACTION_UP tenemos un mismo código que controla los dos.

ACTION_MOVE y ACTION_UP

final float distanceX = Math.abs(touchX - this.mFirstX);

final float distanceY = Math.abs(touchY - this.mFirstY);

final float distance = Math.min((float) Math.hypot(

(double) distanceX, (double) distanceY), mMaxDistance);

final double angleX = touchX - this.mFirstX;

final double angleY = touchY - this.mFirstY;

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

```
angleX))
```
```
+ ANGLE_CONSTANT;
```

if (action == MotionEvent.ACTION_MOVE) {

this.mCatapultDetectorListener.onCharge(this, pSceneTouchEvent,

```
distance, angle);
```
```
} else {
```

this.mCatapultDetectorListener.onShoot(this, pSceneTouchEvent,

```
distance, angle);
```
```
}
```
```
return true;
```

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

Primera y segunda linea, cogemos el número de píxeles de distancia desde el primero toque hasta el actual. En la tercera línea calculamos con la función hypot de Math la distancia real entre los dos puntos de toque, el inicial y el actual. En esa tercera línea realmente cogemos el mínimo de la distancia Real y la variable mMaxDistance, con lo cual si la distancia es mayor que la máxima nos devuelve nMaxDistance. Ya tenemos calculada la distancia, vamos a por el ángulo.

La mejor manera que encontré de hallar el ángulo entre los dos puntos es la de las siguientes lineas. hasta que guardamos en la variable angle el valor del ángulo.

Luego si la acción es ACTION_MOVE lanzamos un onCharge() y si es un ACTION_UP lanzamos un onShoot().

Con esto terminamos por completo el Detector, habrá maneras más bonitas y eficientes de hacerlo, pero a mi con esta me vale por ahora. Si alguien ve mejoras/correcciones sobre el Detector le mandaré unas cañas virtuales.

Repaso a la clase Player

Primero si miramos el sprite que hemos creado del jugador, realmente lo hemos guardado en un objeto AnimatedSprite, para poder hacer la animación del balanceo de cuando se suelta el jugador o cuando la pelota lo golpee.

Tenemos aqui los diferentes frames de la animación. Vamos al tajo. Definimos una constante para definir el frame máximo para la carga, los dos últimos son para hacer el movimiento de rebote cuando se suelta.

private static final int PLAYER_CHARGE_ANIMATIONS = 5;

Parsed in 0.073 seconds at 737 B/s, using GeSHi 1.0.8.10

Ahora añadimos un procedimiento a la clase

Añadir este procedimiento a la clase Player

public void setCharge(final float angle, final float distance)

```
{
```

final int step = Math.round(distance * PLAYER_CHARGE_ANIMATIONS / Main.MAX_CHARGE_DISTANCE);

```
this.stopAnimation(step);
```
```
this.setRotation(angle);  
```
```
}
```

Parsed in 0.067 seconds at 3.32 KB/s, using GeSHi 1.0.8.10

En la primera linea sacamos por una regla de 3 el paso correspondiente a la distancia que nos ha enviado el Detector. Aqui usamos una constante Main.MAX_CHARGE_DISTANCE que definiremos después. Una vez tenemos el sprite que vamos a pintar, usamos el método stopAnimation de SpriteAnimation para parar la animación en ese frame y luego lo rotamos en el ángulo que toca.

Vamos ahora al Main.java y metemos esa constante. A mi se me quedan así.

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

```
// Constants
```

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

private static final int CAMERA_WIDTH = 480;

private static final int CAMERA_HEIGHT = 320;

public static final float MAX_CHARGE_DISTANCE = 80;

```
 
```

private static final String TAG = "AndEngineTest";

```
 
```

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

Ahora en el onLoadScene() tocamos donde se crea el CatapultDetector y le pasamos esta constante.

this.mScrollDetector = new SurfaceScrollDetector(this);

this.mScrollDetector.setEnabled(false);

```
 
```

this.mCatapultDetector = new CatapultDetector(MAX_CHARGE_DISTANCE,this);

this.mCatapultDetector.setEnabled(true);

Parsed in 0.089 seconds at 2.46 KB/s, using GeSHi 1.0.8.10

Y cambiamos el método onCharge()

```
@Override
```

public void onCharge(CatapultDetector pCatapultDetector,

TouchEvent pTouchEvent, float pDistance, float pAngle) {

this.mActivePlayer.setCharge(pAngle,pDistance);

```
}
```

Parsed in 0.076 seconds at 2.42 KB/s, using GeSHi 1.0.8.10

Donde le pasamos al jugador la carga. Con esto ya funciona perfectamente el movimiento. En mi caso esto funciona bien. Si teneis algún problema con esta parte del tutorial decidmelo y aclaro ese punto. Por hoy está bien, en el siguiente voy a intentar hacer las animaciones de soltar al jugador, y poner un HUD para el marcador.

viernes, 25 de marzo de 2011

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.

Pages

domingo, 12 de junio de 2011

Como compilar tu propio andengine.jar

Consiguiendo los fuentes

Importando los fuentes al android

Arreglando los errores

Creando el archivo .jar

viernes, 8 de abril de 2011

Estado actual del proyecto

sábado, 26 de marzo de 2011

Introducción a AndEngine (Parte V)

Anteriormente en Droideando

Objetivos de hoy

Con el Detector

Repaso a la clase Player

viernes, 25 de marzo de 2011

Introducción a AndEngine (Parte IV)

Anteriormente en Droideando

Objetivos de hoy

Creamos el jugador

Creando un Detector

Entradas populares

Temas

Pages

domingo, 12 de junio de 2011

Como compilar tu propio andengine.jar

Consiguiendo los fuentes

Importando los fuentes al android

Arreglando los errores

Creando el archivo .jar

viernes, 8 de abril de 2011

Estado actual del proyecto

sábado, 26 de marzo de 2011

Introducción a AndEngine (Parte V)

Anteriormente en Droideando

Objetivos de hoy

Con el Detector

Repaso a la clase Player

viernes, 25 de marzo de 2011

Introducción a AndEngine (Parte IV)

Anteriormente en Droideando

Objetivos de hoy

Creamos el jugador

Creando un Detector

Entradas populares

Temas

Suscribirse a