Buenas, vamos a explicar detalladamente cómo configurar Eclipse o Netbeans para poder programar para andorid y emular la ejecución. Para ello necesitamos descargar , instalar y configurar lo siguiente:

Java SE 7 (JDK 7) y JRE 7 (Máquina Virtual de Java). Y se instalan.
o    http://www.oracle.com/technetwork/java/javase/downloads/index.html.

Eclipse IDE for Java EE Developers Paquete INDINGO (El más usado).
o   http://www.eclipse.org/downloads/ (No se instala solo se ejecuta). Más concretamente de aquí:
o   http://www.eclipse.org/downloads/packages/release/indigo/r
Ó en su defecto Netbeans 7 español para java y luego instalar el plugin Nbandroid de kenai.

SDK Android. android-sdk_r18-windows.zip (Luego harán falta más descargas).
o   http://developer.android.com/sdk/index.html
Nos creamos en nuestro disco duro, por ejemplo en C: un directorio que se llame android y descomprimimos dentro él el archivo comprimido de eclipse y el SDK de android. Cada uno deberá quedar dentro de una carpeta. En el Android ejecutamos el SDK manager e instalaremos las versiones de Android que deseemos trabajar, se recomienda todas las versiones 2.x.

Ahora debemos de incluir las en las variables PATH de nuestro sistema operativos la ruta del directorio SDK. En windows se hace de la siguiente forma:

Botón derecho en el icono Equipo o MiPc y elegimos Propiedades. Luego en “configuración avanzada del sistema”, luego en “variables de entorno” , luego seleccionamos en Variables de sistemas “CLASSPATH” o “Path”, pulsamos editar y añadimos nuestra ruta del SDK Manager. Como ya tendrás varias rutas metidas, añade un punto y coma al final ; y tu ruta. La ruta debe ser similar a la siguiente C:\Android\android-sdk-windows\SDK Manager.exe

Luego ya abrimos eclipse, elegimos un espacio de trabajo y nos disponemos a instalar el plugin ADT. Picamos en help, instalar nuevo software y añadimos ADT y la siguiente dirección:

https://dl-ssl.google.com/android/eclipse

Luego acepta los términos del contrato y termina la instalación. Deberás reiniciar eclipse y en Windows Preferences entrar en la opción Android y comprobar si está seleccionada la carpeta donde tenemos el SDK.

En Eclipse nos vamos a Window y luego a AVD MANAGER y nos crearemos un nuevo emulador para poder correr nuestros proyectos. Le damos a New… y configuramos lo siguiente y le damos a crear.

EJEMPLO

1.       Creamos un nuevo proyecto Andorid en Eclipse. Nos vamos a File -> New -> Others y elegimos Android Project.
2.       El nombre del proyecto (El del juego será) killthemall-training.
3.       Elegimos la versión para Android 2.1
4.      El nombre de la aplicación pondremos: Kill Them All
5.      El paquete pondremos: com.jabatogames.android.killthemall
6.      Activity: Main
7.       Minimun SDK: 7
PASO 1

Se nos generará nuestro archivo Main el cual modificaremos lo siguiente:

package com.jabatogames.android.killthemall;

import android.app.Activity;

import android.os.Bundle;

import android.view.Window;

public class Main extends Activity {

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

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

requestWindowFeature(Window.FEATURE_NO_TITLE);

setContentView(new GameView(this));

}

No vamos a utilizar la interfaz del eclipse sino que vamos a generar nuestro juego desde código java.

Por lo tanto ahora crearemos un nuevo archivo (clase) dentro de nuestro proyecto llamado GameView el cual irá pintando nuestro juego. Tendremos que poner en él el siguiente código:

package com.jabatogames.android.killthemall;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Color;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

public class GameView extends SurfaceView {

private Bitmap bmp;

private SurfaceHolder holder;

public GameView(Context context) {

super(context);

holder = getHolder();

holder.addCallback(new SurfaceHolder.Callback() {

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

}

@Override

public void surfaceCreated(SurfaceHolder holder) {

Canvas c = holder.lockCanvas(null);

onDraw(c);

holder.unlockCanvasAndPost(c);

}

@Override

public void surfaceChanged(SurfaceHolder holder, int format,

int width, int height) {

}

});

bmp = BitmapFactory.decodeResource(getResources(), R.drawable.ic_launcher);

}

@Override

protected void onDraw(Canvas canvas) {

canvas.drawColor(Color.BLACK);

canvas.drawBitmap(bmp, 10, 10, null);

}

Ahora se puede dar a compilar (debug as…) y elegir el AVD (emulador) creado en el apartado anterior. Si no se actualiza en el emulador vamos hacia atrás en el móvil.

PASO 2

Creamos una nueva clase (archivo) llamada GameLoopThread, será la clase que vaya comprobando todas las interacciones con nuestro juego. Es decir, el gameloop es un bucle continuo el cual va pintando el juego y esperando nuestras interacciones con él. Metemos el siguiente código.

package com.jabatogames.android.killthemall;

import android.graphics.Canvas;

public class GameLoopThread extends Thread {

private GameView view;

private boolean running = false;

public GameLoopThread(GameView view) {

this.view = view;

}

public void setRunning(boolean run) {

running = run;

}

@Override

public void run() {

while (running) {

Canvas c = null;

try {

c = view.getHolder().lockCanvas();

synchronized (view.getHolder()) {

view.onDraw(c);

}

} finally {

if (c != null) {

view.getHolder().unlockCanvasAndPost(c);

}

En el archivo GameView haremos modificaciones para que llame a la clase GameLoopThread quedando así:

package com.jabatogames.android.killthemall;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Color;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

public class GameView extends SurfaceView {

private Bitmap bmp;

private SurfaceHolder holder;

private GameLoopThread gameLoopThread;

private int x = 0;

public GameView(Context context) {

super(context);

gameLoopThread = new GameLoopThread(this);

holder = getHolder();

holder.addCallback(new SurfaceHolder.Callback() {

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

boolean retry = true;

gameLoopThread.setRunning(false);

while (retry) {

try {

gameLoopThread.join();

retry = false;

} catch (InterruptedException e) {

}

@Override

public void surfaceCreated(SurfaceHolder holder) {

gameLoopThread.setRunning(true);

gameLoopThread.start();

}

@Override

public void surfaceChanged(SurfaceHolder holder, int format,

int width, int height) {

}

});

bmp = BitmapFactory.decodeResource(getResources(), R.drawable.ic_launcher);

}

@Override

protected void onDraw(Canvas canvas) {

canvas.drawColor(Color.BLACK);

if (x < getWidth() - bmp.getWidth()) {

x++;

}

canvas.drawBitmap(bmp, x, 10, null);

}

Ahora se puede dar a compilar (debug as…) y elegir el AVD (emulador) creado en el apartado anterior. Si no se actualiza en el emulador vamos hacia atrás en el móvil. Se verá la imagen del muñeco Android desplazándose por la pantalla.

PASO 3

Ahora nos crearemos la clase Sprite. Esta clase será la que genere imágenes en la pantalla.

Introducimos este código en la clase Sprite.

package com.jabatogames.android.killthemall;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Rect;

public class Sprite {

private static final int BMP_ROWS = 4;

private static final int BMP_COLUMNS = 3;

private int x = 0;

private int y = 0;

private int xSpeed = 5;

private GameView gameView;

private Bitmap bmp;

private int currentFrame = 0;

private int width;

private int height;

public Sprite(GameView gameView, Bitmap bmp) {

this.gameView = gameView;

this.bmp = bmp;

this.width = bmp.getWidth() / BMP_COLUMNS;

this.height = bmp.getHeight() / BMP_ROWS;

}

private void update() {

if (x > gameView.getWidth() - width - xSpeed) {

xSpeed = -5;

}

if (x + xSpeed < 0) {

xSpeed = 5;

}

x = x + xSpeed;

currentFrame = ++currentFrame % BMP_COLUMNS;

}

public void onDraw(Canvas canvas) {

update();

int srcX = currentFrame * width;

int srcY = 1 * height;

Rect src = new Rect(srcX, srcY, srcX + width, srcY + height);

Rect dst = new Rect(x, y, x + width, y + height);

canvas.drawBitmap(bmp, src, dst, null);

}

Os adjunto unas imagen llamada bad1.png, bad2.png…, las cuales las teneis que arrastrar e introducir en vuestro proyecto en la carpeta “res” -> “Drawable-mdpi”

Y cambiamos el GameView por el siguiente:

package com.jabatogames.android.killthemall;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Color;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

public class GameView extends SurfaceView {

private Bitmap bmp;

private SurfaceHolder holder;

private GameLoopThread gameLoopThread;

private Sprite sprite;

public GameView(Context context) {

super(context);

gameLoopThread = new GameLoopThread(this);

holder = getHolder();

holder.addCallback(new SurfaceHolder.Callback() {

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

boolean retry = true;

gameLoopThread.setRunning(false);

while (retry) {

try {

gameLoopThread.join();

retry = false;

} catch (InterruptedException e) {

}

@Override

public void surfaceCreated(SurfaceHolder holder) {

gameLoopThread.setRunning(true);

gameLoopThread.start();

}

@Override

public void surfaceChanged(SurfaceHolder holder, int format,

int width, int height) {

}

});

bmp = BitmapFactory.decodeResource(getResources(), R.drawable.bad1);

sprite = new Sprite(this,bmp);

}

@Override

protected void onDraw(Canvas canvas) {

canvas.drawColor(Color.BLACK);

sprite.onDraw(canvas);

}

Podeis ejecutar el programa y saldrá el muñeco caminando.

PASO 4.

Queremos hacer que el muñeco se mueva rebotando en toda la pantalla y no de izquierda a derecha y además que dependiendo de la dirección salga el muñeco de una posición o de otra.

Así que cambiamos la clase Sprite por la siguiente:

package com.jabatogames.android.killthemall;

import java.util.Random;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Rect;

public class Sprite {

// direction = 0 up, 1 left, 2 down, 3 right,

// animation = 3 back, 1 left, 0 front, 2 right

int[] DIRECTION_TO_ANIMATION_MAP = { 3, 1, 0, 2 };

private static final int BMP_ROWS = 4;

private static final int BMP_COLUMNS = 3;

private static final int MAX_SPEED = 5;

private GameView gameView;

private Bitmap bmp;

private int x = 0;

private int y = 0;

private int xSpeed;

private int ySpeed;

private int currentFrame = 0;

private int width;

private int height;

public Sprite(GameView gameView, Bitmap bmp) {

this.width = bmp.getWidth() / BMP_COLUMNS;

this.height = bmp.getHeight() / BMP_ROWS;

this.gameView = gameView;

this.bmp = bmp;

Random rnd = new Random();

x = rnd.nextInt(gameView.getWidth() - width);

y = rnd.nextInt(gameView.getHeight() - height);

xSpeed = rnd.nextInt(MAX_SPEED * 2) - MAX_SPEED;

ySpeed = rnd.nextInt(MAX_SPEED * 2) - MAX_SPEED;

}

private void update() {

if (x >= gameView.getWidth() - width - xSpeed || x + xSpeed <= 0) {

xSpeed = -xSpeed;

}

x = x + xSpeed;

if (y >= gameView.getHeight() - height - ySpeed || y + ySpeed <= 0) {

ySpeed = -ySpeed;

}

y = y + ySpeed;

currentFrame = ++currentFrame % BMP_COLUMNS;

}

public void onDraw(Canvas canvas) {

update();

int srcX = currentFrame * width;

int srcY = getAnimationRow() * height;

Rect src = new Rect(srcX, srcY, srcX + width, srcY + height);

Rect dst = new Rect(x, y, x + width, y + height);

canvas.drawBitmap(bmp, src, dst, null);

}

private int getAnimationRow() {

double dirDouble = (Math.atan2(xSpeed, ySpeed) / (Math.PI / 2) + 2);

int direction = (int) Math.round(dirDouble) % BMP_ROWS;

return DIRECTION_TO_ANIMATION_MAP[direction];

}

También queremos que salgan varios muñeocs, así que modificamos la GameView:

package com.jabatogames.android.killthemall;

import java.util.ArrayList;

import java.util.List;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Color;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

public class GameView extends SurfaceView {

private SurfaceHolder holder;

private GameLoopThread gameLoopThread;

private List<Sprite> sprites = new ArrayList<Sprite>();

public GameView(Context context) {

super(context);

gameLoopThread = new GameLoopThread(this);

holder = getHolder();

holder.addCallback(new SurfaceHolder.Callback() {

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

boolean retry = true;

gameLoopThread.setRunning(false);

while (retry) {

try {

gameLoopThread.join();

retry = false;

} catch (InterruptedException e) {

}

@Override

public void surfaceCreated(SurfaceHolder holder) {

createSprites();

gameLoopThread.setRunning(true);

gameLoopThread.start();

}

@Override

public void surfaceChanged(SurfaceHolder holder, int format,

int width, int height) {

}

});

}

private void createSprites() {

sprites.add(createSprite(R.drawable.bad1));

sprites.add(createSprite(R.drawable.bad2));

sprites.add(createSprite(R.drawable.bad3));

sprites.add(createSprite(R.drawable.bad4));

sprites.add(createSprite(R.drawable.bad5));

sprites.add(createSprite(R.drawable.bad6));

sprites.add(createSprite(R.drawable.good1));

sprites.add(createSprite(R.drawable.good2));

sprites.add(createSprite(R.drawable.good3));

sprites.add(createSprite(R.drawable.good4));

sprites.add(createSprite(R.drawable.good5));

sprites.add(createSprite(R.drawable.good6));

}

private Sprite createSprite(int resouce) {

Bitmap bmp = BitmapFactory.decodeResource(getResources(), resouce);

return new Sprite(this,bmp);

}

@Override

protected void onDraw(Canvas canvas) {

canvas.drawColor(Color.BLACK);

for (Sprite sprite : sprites) {

sprite.onDraw(canvas);

}

Podemos probar el juego.

PASO 5

Queremos hacer que al tocar un muñeco este desaparezca.

Clase GameView:

package com.jabatogames.android.killthemall;

import java.util.ArrayList;

import java.util.List;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Color;

import android.view.MotionEvent;

import android.view.SurfaceHolder;

import android.view.SurfaceHolder.Callback;

import android.view.SurfaceView;

public class GameView extends SurfaceView {

private Bitmap bmp;

private SurfaceHolder holder;

private GameLoopThread gameLoopThread;

private List<Sprite> sprites = new ArrayList<Sprite>();

private long lastClick;

public GameView(Context context) {

super(context);

gameLoopThread = new GameLoopThread(this);

holder = getHolder();

holder.addCallback(new Callback() {

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

}

@Override

public void surfaceCreated(SurfaceHolder holder) {

createSprites();

gameLoopThread.setRunning(true);

gameLoopThread.start();

}

@Override

public void surfaceChanged(SurfaceHolder holder, int format,

int width, int height) {

}

});

}

private void createSprites() {

sprites.add(createSprite(R.drawable.bad1));

sprites.add(createSprite(R.drawable.bad2));

sprites.add(createSprite(R.drawable.bad3));

sprites.add(createSprite(R.drawable.bad4));

sprites.add(createSprite(R.drawable.bad5));

sprites.add(createSprite(R.drawable.bad6));

sprites.add(createSprite(R.drawable.good1));

sprites.add(createSprite(R.drawable.good2));

sprites.add(createSprite(R.drawable.good3));

sprites.add(createSprite(R.drawable.good4));

sprites.add(createSprite(R.drawable.good5));

sprites.add(createSprite(R.drawable.good6));

}

private Sprite createSprite(int resouce) {

Bitmap bmp = BitmapFactory.decodeResource(getResources(), resouce);

return new Sprite(this, bmp);

}

@Override

protected void onDraw(Canvas canvas) {

canvas.drawColor(Color.BLACK);

for (Sprite sprite : sprites) {

sprite.onDraw(canvas);

}

@Override

public boolean onTouchEvent(MotionEvent event) {

if (System.currentTimeMillis() - lastClick > 500) {

lastClick = System.currentTimeMillis();

synchronized (getHolder()) {

for (int i = sprites.size() - 1; i >= 0; i--) {

Sprite sprite = sprites.get(i);

if (sprite.isCollition(event.getX(), event.getY())) {

sprites.remove(sprite);

break;

}

return true;

}

Clase sprite:

package com.jabatogames.android.killthemall;

import java.util.Random;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Rect;

public class Sprite {

// direction = 0 up, 1 left, 2 down, 3 right,

// animation = 3 back, 1 left, 0 front, 2 right

int[] DIRECTION_TO_ANIMATION_MAP = { 3, 1, 0, 2 };

private static final int BMP_ROWS = 4;

private static final int BMP_COLUMNS = 3;

private static final int MAX_SPEED = 5;

private GameView gameView;

private Bitmap bmp;

private int x = 0;

private int y = 0;

private int xSpeed;

private int ySpeed;

private int currentFrame = 0;

private int width;

private int height;

public Sprite(GameView gameView, Bitmap bmp) {

this.width = bmp.getWidth() / BMP_COLUMNS;

this.height = bmp.getHeight() / BMP_ROWS;

this.gameView = gameView;

this.bmp = bmp;

Random rnd = new Random();

x = rnd.nextInt(gameView.getWidth() - width);

y = rnd.nextInt(gameView.getHeight() - height);

xSpeed = rnd.nextInt(MAX_SPEED * 2) - MAX_SPEED;

ySpeed = rnd.nextInt(MAX_SPEED * 2) - MAX_SPEED;

}

private void update() {

if (x >= gameView.getWidth() - width - xSpeed || x + xSpeed <= 0) {

xSpeed = -xSpeed;

}

x = x + xSpeed;

if (y >= gameView.getHeight() - height - ySpeed || y + ySpeed <= 0) {

ySpeed = -ySpeed;

}

y = y + ySpeed;

currentFrame = ++currentFrame % BMP_COLUMNS;

}

public void onDraw(Canvas canvas) {

update();

int srcX = currentFrame * width;

int srcY = getAnimationRow() * height;

Rect src = new Rect(srcX, srcY, srcX + width, srcY + height);

Rect dst = new Rect(x, y, x + width, y + height);

canvas.drawBitmap(bmp, src, dst, null);

}

private int getAnimationRow() {

double dirDouble = (Math.atan2(xSpeed, ySpeed) / (Math.PI / 2) + 2);

int direction = (int) Math.round(dirDouble) % BMP_ROWS;

return DIRECTION_TO_ANIMATION_MAP[direction];

}

public boolean isCollition(float x2, float y2) {

return x2 > x && x2 < x + width && y2 > y && y2 < y + height;

}

Clase GameLoopThread:

package com.jabatogames.android.killthemall;

import android.graphics.Canvas;

public class GameLoopThread extends Thread {

static final long FPS = 10;

private GameView view;

private boolean running = false;

public GameLoopThread(GameView view) {

this.view = view;

}

public void setRunning(boolean run) {

running = run;

}

@Override

public void run() {

long ticksPS = 1000 / FPS;

long startTime;

long sleepTime;

while (running) {

Canvas c = null;

startTime = System.currentTimeMillis();

try {

c = view.getHolder().lockCanvas();

synchronized (view.getHolder()) {

view.onDraw(c);

}

} finally {

if (c != null) {

view.getHolder().unlockCanvasAndPost(c);

}

sleepTime = ticksPS - (System.currentTimeMillis() - startTime);

try {

if (sleepTime > 0)

sleep(sleepTime);

else

sleep(10);

} catch (Exception e) {}

}

PASO 6: Sprite temporal. Mancha de sangre.

Añadimos la clase TempSprite:

package com.jabatogames.android.killthemall;

import java.util.List;

import android.graphics.Bitmap;

import android.graphics.Canvas;

public class TempSprite {

private float x;

private float y;

private Bitmap bmp;

private int life = 15;

private List<TempSprite> temps;

public TempSprite(List<TempSprite> temps, GameView gameView, float x,

float y, Bitmap bmp) {

this.x = Math.min(Math.max(x - bmp.getWidth() / 2, 0),

gameView.getWidth() - bmp.getWidth());

this.y = Math.min(Math.max(y - bmp.getHeight() / 2, 0),

gameView.getHeight() - bmp.getHeight());

this.bmp = bmp;

this.temps = temps;

}

public void onDraw(Canvas canvas) {

update();

canvas.drawBitmap(bmp, x, y, null);

}

private void update() {

if (--life < 1) {

temps.remove(this);

}

El nuevo GameView

package com.jabatogames.android.killthemall;

import java.util.ArrayList;

import java.util.List;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.Color;

import android.view.MotionEvent;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

public class GameView extends SurfaceView {

private GameLoopThread gameLoopThread;

private List<Sprite> sprites = new ArrayList<Sprite>();

private List<TempSprite> temps = new ArrayList<TempSprite>();

private long lastClick;

private Bitmap bmpBlood;

public GameView(Context context) {

super(context);

gameLoopThread = new GameLoopThread(this);

getHolder().addCallback(new SurfaceHolder.Callback() {

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

boolean retry = true;

gameLoopThread.setRunning(false);

while (retry) {

try {

gameLoopThread.join();

retry = false;

} catch (InterruptedException e) {}

}

@Override

public void surfaceCreated(SurfaceHolder holder) {

createSprites();

gameLoopThread.setRunning(true);

gameLoopThread.start();

}

@Override

public void surfaceChanged(SurfaceHolder holder, int format,

int width, int height) {

}

});

bmpBlood = BitmapFactory.decodeResource(getResources(), R.drawable.blood1);

}

private void createSprites() {

sprites.add(createSprite(R.drawable.bad1));

sprites.add(createSprite(R.drawable.bad2));

sprites.add(createSprite(R.drawable.bad3));

sprites.add(createSprite(R.drawable.bad4));

sprites.add(createSprite(R.drawable.bad5));

sprites.add(createSprite(R.drawable.bad6));

sprites.add(createSprite(R.drawable.good1));

sprites.add(createSprite(R.drawable.good2));

sprites.add(createSprite(R.drawable.good3));

sprites.add(createSprite(R.drawable.good4));

sprites.add(createSprite(R.drawable.good5));

sprites.add(createSprite(R.drawable.good6));

}

private Sprite createSprite(int resouce) {

Bitmap bmp = BitmapFactory.decodeResource(getResources(), resouce);

return new Sprite(this, bmp);

}

@Override

protected void onDraw(Canvas canvas) {

canvas.drawColor(Color.BLACK);

for (int i = temps.size() - 1; i >= 0; i--) {

temps.get(i).onDraw(canvas);

}

for (Sprite sprite : sprites) {

sprite.onDraw(canvas);

}

@Override

public boolean onTouchEvent(MotionEvent event) {

if (System.currentTimeMillis() - lastClick > 300) {

lastClick = System.currentTimeMillis();

float x = event.getX();

float y = event.getY();

synchronized (getHolder()) {

for (int i = sprites.size() - 1; i >= 0; i--) {

Sprite sprite = sprites.get(i);

if (sprite.isCollition(x, y)) {

sprites.remove(sprite);

temps.add(new TempSprite(temps, this, x, y, bmpBlood));

break;

}

return true;

}

Podemos probarlo y exportarlo como Aplicación Android.

Podéis encontrar los videotutoriales en:

Videotutoriales Juegos en Android (Haz click con ctrl pulsado en el enlace).

1. Introducción y panorama general.

2. Dibujo de una imagen utilizando SurfaceView.

3. Game Loop y Animación.

4. Nuestro primer Sprite.

5. Sprites velocidad y Animación.

6. Trabajar con múltiples Sprites.

7. Eventos de Touch y detección de colisiones de Sprite.

8. Sprites Temporales.

http://jabatogames.blogspot.com.es/2012/05/programacion-en-android-recursos-en.html

ANEXO:

Configuración del Android SDK en NetBeans 7

Este tutorial fue hecho para aquellas personas que ya instalaron el SDK de android, pero no les convence mucho la idea de usar Eclipse. Para configurar NetBeans y poder crear proyectos de Android, solo hay que hacer lo siguiente:

1. Abrir NetBeans

2. Ir al menú Tools, Plugins, esperar a que la ventana se cargue y entrar a la pestaña Settings

3. Presionar el botón Add

4. En la siguiente ventana, usar el campo Name y alimentar el valor “NBAndroid”

5. Marcar la casilla Check for updates automatically.

6. Por último, en el campo URL, copiar la siguiente dirección que corresponde al plugin NBAndroid de Kenai:http://deadlock.netbeans.org/hudson/job/nbandroid/lastStableBuild/artifact/build/updates/updates.xml

Una vez hecho esto, ir a la pestaña Available Plugins, hay que localizar los plugins Android y Android Test Runner for NetBeans 7.0+, marcarlos y presionar el botón Install

Presionamos Next, aceptamos los términos de la licencia y finalmente apretamos el botón Install, esto descargará el plugin a nuestro equipo, así que habrá que esperar a que termine la descarga. Terminado este proceso, tendremos una advertencia mostrándonos que el plugin no está oficialmente respaldado por Oracle, presionemos Continue

Después, presionamos el botón Finish. Para activarlo, nos movemos a la pestaña Installed, y podemos ver que efectivamente, ambos componentes están instalados y activados.

Crear un nuevo proyecto Android con NetBeans

Vamos a File, New Project, ahora ya tenemos disponible el grupo de proyectos de Android.

Seleccionemos el grupo Android, y el tipo de proyecto Android Project, entonces demos click en Next, encontraremos los siguientes campos.

1. Project Name: Es el nombre que se le va a dar al proyecto.

2. Project Location: La carpeta donde se va a guardar el proyecto

3. Project Folder: El nombre que va a recibir la carpeta del proyecto dentro del Project Location, es decir, es una subcarpeta con el nombre del proyecto.

4. Set as Main Project: Establece el proyecto como el principal.

5. Package Name: Nombre que va a recibir el package, mínimo solicita dividirlo en dos partes, usando un punto como separador.

6. Activity Name: Nombre de la actividad, es el archivo fuente principal del proyecto.

7. Target Platform: Seleccionar la versión del SDK de Android a utilizar

En mi caso, he creado un primer proyecto de ejemplo con los siguientes datos

Importante: En caso de que no encontrar el SDK de Android (Me sucedió una vez), se presiona el botón Manage Android SDK y se alimenta el campo SDK Location con la ruta de instalación del SDK, por lo general está ubicado en C:\Program Files\Android\android-sdk

Lo siguiente es crear un dispositivo Android donde correr nuestros ejemplos, para ellos vamos a Menú Inicio, Todos los programas, Android SDK Tools, SDK Manager, del lado izquierdo de la ventana seleccionamos Virtual devices y presionamos el botón New.

Los campos más importantes son: Name que es el nombre que le damos al dispositivo sin espacios y solo letras y números, Targetes la versión del sistema operativo o del API a utilizar y Size que es el tamaño de la SD Card virtual. Una vez establecido nuestro dispositivo presionemos Create AVD, tendremos un mensaje de confirmación que debemos aceptar.

Regresando a NetBeans, presionemos F11 para compilar el proyecto, luego F6 para probarlo. La primera vez, se nos solicitará que seleccionemos el dispositivo a utilizar, deberíamos tener en ese lista el que creamos con anterioridad bajo la sección Start AVD, seleccionemos nuestro dispositivo y presionemos OK para ver nuestro proyecto (que no hace nada en realidad) en el emulador seleccionado.

Instalar Android SDK

Herramientas, Programación

Android SDK es el kit de desarrollo para crear aplicaciones para la plataforma Android.

Tiene soporte para los siguientes sistemas operativo:

· Windows XP (32-bit), Vista (32 y 64 bit), o Windows 7 (32 y 64-bit)

· Mac OS X 10.5.8 o posterior (sólo x86)

· Linux (probado en Ubuntu Linux, Lucid Lynx)

Yo voy a explicar el proceso de instalación en la plataforma Windows, pero no hay mucha diferencia entre las otras plataformas e igualmente puedes utilizar este tutorial para instalar el SDK de Android.

Lo primero que tenemos que hacer es entrar en la página Android Developers y pulsamos en la etiqueta SDK.

Descarga del SDK de Android

Pulsamos en el enlace de nuestro sistema operativo. Ha fecha de este artículo, la versión del SDK de Android es la r11.

Una vez descargado el archivo, creamos una carpeta en nuestro disco duro y descomprimimos el contenido en dicho directorio.

Ejecutamos en archivo SDK Manager.exe para que nos aparezca el gestor de descargas del SDK Android. Lo primero que hace siempre que se ejecuta el gestor de descargas, es comprobar los paquetes nuevos y nos da la opción de seleccionar los que queremos instalar.

Si ves que no aparece ningún paquete es porque el gestor no se ha podido conectar al repositorio oficial de Android. Lo que tienes que hacer es pinchar en la etiqueta Settings y marcar la casilla Force https://…

Cuando se termine de actualizar el registro del repositorio aparecerá el listado de paquetes que podemosdescargar e instalar. Yo recomiendo que te descargues las plataformas entre la 2.1 y la 3.1, ya que las plataformas 1.5 y 1.6 ya están obsoletas. No olvides también descargar las API (documentación) de las plataformas que te descargues. Cuando ya decidas que instalar pulsa en el botón Install.

Una vez descargado se instalaran los paquetes y pulsaremos en el botón done. En la pestaña Instaled packages podemos comprobar que se han instalado los paquetes correctamente.

Ya sólo nos queda configurar las máquinas virtuales, en las cuales podrémos probar las aplicaciones que vayamos creando. Para crear la máquina virtual tenemos que pinchar en la etiqueta Virtual devices y pulsar en el botón new.

Editamos los diferentes campos.

Name: Es el nombre que le vamos a poner a nuestra máquina virtual.

Target: Aquí seleccionamos la plataforma Android que tendrá nuestra máquina virtual.

Snapshot: Sirve para que al cerrar el emulador, la máquina virtual se suspenda y la próxima vez arranque más rápido.

Skin: Esta opción es para elegir el tamaño de la pantalla que tendrá nuestra maquina emulada.

Hardware: Pulsando en New… podemos añadir diferentes componentes a nuestra maquina virtual, soporte para lectura detarjetas SD, Acelerómetro, teclado, etc.

Una vez terminado de configurar las diferentes opciones pulsamos en el botón Create AVD y se nos creará nuestra máquina virtual.

Para hacer funcionar nuestra máquina virtual Android y comprobar que funciona correctamente, seleccionamos la máquina que queramos y pulsamos en el botón Start…

Se nos abrirá una ventana y podremos seleccionar que se ejecute la máquina virtual de Android a escala real o no. Al pulsar en el botón Launch empezará a arrancar la máquina y podremos utilizarla.

Aquí termina la instalación del SDK Android y su configuración. Pero para poder desarrollar aplicaciones y juegos para Android aun nos falta instalar el Entorno de Desarrollo (IDE) dónde crearemos nuestras aplicaciones. En un próximo artículo explicaré cómo instalarEclipse, que es el IDE oficial de desarrollo para Android y cómo configurarlo para crear nuestra primera aplicación de Android.

CONFIGURAR NETBEANS

En un artículo anterior expliqué cómo instalar y configurar el SDK de Android. En este tutorial os voy a mostrar cómo configurar el IDE NetBeans 7.0 para poder utilizar el SDK de Android y desarrollar nuestras aplicaciones para nuestros Smartphone y Tablets.

Un IDE es un entorno de programación que, con sus herramientas, nos facilita la tarea de programar.

Lo primero que tenemos que hacer es descargar el IDE NetBeans 7.0 desde su web oficial. Elegimos el idioma preferido y pulsamos en “Download” en Java SE para tener los requisitos mínimos o en All para tener todos los complementos.

Una vez descargado e instalado, lo ejecutamos y en el menú Herramientas pinchamos en Complementos. Una vez abierta la venta de Complementos pulsamos en la pestaña Configuración y pulsamos en el botón Agregar.

Se nos abrirá una nueva ventana donde configuraremos el plugin NBAndroid. En el campo Nombre pondremos el nombre del plugin “NBAndroid“. En el campo URL pondremos la dirección de descarga:http://kenai.com/projects/nbandroid/downloads/download/updatecenter/updates.xml. Dejaremos marcada la casilla “Comprobar actualizaciones automáticamente“ para cuando haya una nueva versión, se actualice sólo. Una vez rellenado todos los campos, pulsamos en el botón Aceptar.

Con esto habremos añadido el plugin de Android a nuestro repertorio de plugins. Pulsamos en la pestaña Pluginsdisponibles, marcamos la casilla del plugin que se llama “Android” y pulsamos en el botón Aceptar.

Nos aparecerá una ventana nueva donde nos indicará que vamos a proceder a instalar el complemento de Android, la versión 1.7 en el momento de la edición de este artículo. Pulsamos en el botón Siguiente para confirmar la instalación.

Después de pulsar en Siguiente nos aparecerá un mensaje de Advertencia de validación y pulsamos en el botónContinuar.

Aquí ya habremos terminado con la instalación del complemento y podremos empezar a desarrollar aplicaciones con el SDK de Android. Para confirmar que tenemos el plugin correctamente instalados, pulsamos en la pestañaInstalado y marcamos la casilla Mostrar detalles.

Ya sólo nos queda crear un nuevo proyecto y ponernos a crear programas. Para ello, en Archivo pulsamos en Proyecto Nuevo…, seleccionamos Android > Android Project y pulsamos en el botón Siguiente.

Nos aperecerá la ventana de Nuevo Android Application y tenemos que configurar varios campos:

· Project Name: Aquí pondremos el nombre de nuestro Proyecto de Android.

· Project Location: Es el directorio donde almacenaremos nuestro Proyecto de Android.

· Package Name: Es el nombre del paquete. Siempre empieza por com.nombre de la aplicación. Yo siempre pongo en mis proyectos com.proeugame.nombre, así se queda reflejado que el programa es creado por mi.

· Manage Android SDK…: Si aún no hemos configurado el directorio donde está instalado el SDK de Android, debemos pulsar este botón e indicar la ruta donde se encuentra nuestro SDK de Android.

· Target Platform: En esta sección nos aparecerá el listado de las plataformas instaladas en nuestro SDK de Android y debemos elegir una.

Por último, pulsamos el botón Terminar y nos generará nuestro proyecto de Android listo para empezar a programar.

Aquí termina este artículo con un tutorial para instalar el plugin de Android en NetBeans 7.0. Ahora disfrutad de él y cread todo lo que vuestra imaginación os permita.

http://www.youtube.com/watch?annotation_id=annotation_873677&feature=iv&src_vid=IaA7SVDEQcQ&v=pkN7vJHmlZc

http://www.oracle.com/splash/kenai.com/maintenance/index.html