La funcionalidad básica es la del proyecto 1 (Pacman III). Sobre ella reemplazamos la interfaz de usuario para adaptarla al nuevo entorno

Transcripción

1 Pacman en android Objetivos Pasar el juego del proyecto 1 (Pacman III) a una plataforma Android. movimiento del jugador dirigido por el dedo programación de menús contextuales gestión de threads (hilos) AsyncTask almacenamiento de situaciones de juego en una base de datos y recuperación posterior 2 Funcionalidad La funcionalidad básica es la del proyecto 1 (Pacman III). Sobre ella reemplazamos la interfaz de usuario para adaptarla al nuevo entorno el jugador se mueve con el dedo, el menú emergente aparece si tocamos pero no movemos y aparece un menú para resetear y para guardar y recuperar de la base de datos. Puede familiarizarse con esta especificación descargándose el juego de Si el alumno desea modificar esta funcionalidad, debe consultar al profesor. 3 Arquitectura de la solución Clases java que vienen del proyecto 1: Casilla Direccion EstadoJuego Pared Paredes Terreno Movil Jugador extends Movil Estatua extends Movil Fantasma00 extends Movil implements Runnable Depredador extends Movil implements Runnable Las clases GUI y Juego hay que modificarlas notablemente para pasar a android. Aparecen clases nuevas relacionadas con Activities de android

2 Activity MainActivity DbSaveActivity extends Activity DbLoadActivity extends ListActivity res / layout activity_main activity_dbsave activity_dbload Y clases auxiliares relacionadas con la base de datos DbSaverTask extends AsyncTask<String, Void, Void> DbUtils MyDbAdapter o private static class DatabaseHelper extends SQLiteOpenHelper 4 Clases java 4.1 Terreno Método auxiliar para quitar un móvil de una casilla: public synchronized void clear(casilla casilla) { casilla.setmovil(null); Juego.getInstance().pintar(); Método auxiliar para vaciar el terreno de paredes y móviles: public synchronized void clear() { paredes.reset(); for (int x = 0; x < getn(); x++) { for (int y = 0; y < getn(); y++) { Casilla casilla = getcasilla(x, y); clear(casilla); Se adapta al ciclo de vida de android. Hay que congelar los móviles desde onpause() y descongelarlos desde onresume(): public synchronized void pausamoviles(boolean pause) { for (int x = 0; x < getn(); x++) { for (int y = 0; y < getn(); y++) { Casilla casilla = getcasilla(x, y); Movil movil = casilla.getmovil(); if (movil!= null) movil.pause(pause); Hay que resucitar los móviles en oncreate(): public synchronized void resucitarmoviles() { for (int x = 0; x < getn(); x++) { for (int y = 0; y < getn(); y++) { Casilla casilla = getcasilla(x, y); Movil movil = casilla.getmovil();

3 if (movil!= null) movil.restart(); 4.2 Móviles Movil Se adapta al manejo de imágenes en android. Aquí nos limitamos a apuntar qué imagen queremos que se dibuje y al pintar se tendrá en cuenta el escalado para ajustarse a la pantalla en cada momento. private int image; public int getimagen() { return image; public void setimage(int image) { this.image = image; Aparece una nueva funcionalidad para pausar la ejecución cuando la actividad se queda sin la pantalla, en onpause() y reanimarlo cuando recupera la pantalla en onresume(). private boolean pause = false; public void pause(boolean pause) { this.pause= pause; public boolean ispause() { return pause; Añade la funcionalidad de resucitar a un móvil. Las threads se abortan en ondestroy() y se resucitan desde oncreate() a través de Terreno.resucitarMoviles(). public abstract void restart(); La expresión resucitar significa que creamos nuevos móviles (new()) y los ponemos en marcha (start()).

4 4.2.2 Estatua extends Movil Como imagen gráfica se refiere a un recurso setimage(r.drawable.patito); Nuevo método para resucitar: public void restart() { Fantasma00 extends Movil implements Runnable Como imagen gráfica se refiere a un recurso setimage(r.drawable.fantasma_rojo); Nuevo método para resucitar: public void restart() { terreno.clear(casilla); Fantasma00 fantasma = new Fantasma00(terreno); terreno.put(casilla, fantasma); Thread thread = new Thread(fantasma); thread.start(); Debe tener en cuanta ispause() en la ejecución regular de la thread Depredador extends Movil implements Runnable Como imagen gráfica se refiere a un recurso setimage(r.drawable.anibal); Nuevo método para resucitar: public void restart() { terreno.clear(casilla); Depredador depredador = new Depredador(terreno); terreno.put(casilla, depredador); Thread thread = new Thread(depredador); thread.start(); Debe tener en cuanta ispause() en la ejecución regular de la thread Jugador extends Movil Como imagen gráfica se refiere a un recurso setimage(r.drawable.rastas); Nuevo método para resucitar:

5 public void restart() { vivo = true; 4.3 MainActivity Ciclo de vida En oncreate() inicializa el juego Juego juego = Juego.getInstance(); GUI gui = (GUI) findviewbyid(r.id.gui); juego.setgui(gui); Terreno terreno = juego.getterreno(); if (terreno == null) { juego.start(); terreno = juego.getterreno(); terreno.resucitarmoviles(); MyDbAdapter dbadapter = new MyDbAdapter(this); dbadapter.open(); juego.setdbadapter(dbadapter); En onresume() debe descongelar los móviles. En onpause() debe congelar los móviles. En ondestroy() debe matar los móviles Menú Si hemos hecho una ActionBarActivity, es bastante directo cargar un menú en oncreateoptionsmenu y actuar cuando se elige una entrada del menú en onoptionsitemselected Como menú se puede utilizar algo así res / menu / main.xml <menu xmlns:android=" xmlns:app=" xmlns:tools=" tools:context="es.upm.dit.adsw.pacman4.mainactivity" > <item android:id="@+id/button_reset" android:title="@string/button_reset"/> <item android:id="@+id/action_db" android:title="@string/action_db"> <menu> <item android:id="@+id/action_db_save" android:title="@string/action_db_save"/> <item android:id="@+id/action_db_load" android:title="@string/action_db_load"/> </menu>

6 </menu> </item> 4.4 GUI Graphical User Interface Es una View personalizada para pacman: public class GUI extends View { En su método ondraw() pinta el terreno y lo que hay en sus casillas: protected void ondraw(canvas canvas) { Hay que hacer un gestor de toques de la pantalla private class MyTouchListener implements OnTouchListener { que por una parte se encargue de capturar los eventos de apoyar el dedo en la pantalla y mover el jugador cuando se mueve el dedo, y de abrir un menú emergente si el dedo se levanta sin moverse. Si guardamos los tipos de fantasmas en 2 listas coordinadas entonces el menú emergente tiene esta pinta: private void popup(final Casilla casilla) { final String[] options = new String[names.size()]; for (int i = 0; i < options.length; i++) options[i] = names.get(i); AlertDialog.Builder builder = new AlertDialog.Builder(context); builder.settitle(juego.titulo); builder.setitems(options, new DialogInterface.OnClickListener() { public void onclick(dialoginterface dialog, int which) { final Juego juego = Juego.getInstance(); juego.pon(casilla, ids.get(which)); ); builder.show(); 5 Hilos Threads Aparte de la interfaz de usuario (presentación del terreno y captura de las acciones del usuario), cada móvil en movimiento es un thread (hilo) que se arranca al crear el móvil se suspende en onpause() se reanuda en onresume()

7 se destruye en ondestroy() se resucita en oncreate() 6 Base de datos (OPCIONAL) Usaremos una base de datos para guardar situaciones de juego con un nombre que las identifique. La base de datos, escenarios, tiene una única tabla, fotos, con el siguiente esquema de datos: Como interfaz con la base de datos usaremos sentencias SQL y el mecanismo de cursor. 6.1 Guardar una foto Llamaremos foto a la situación actual: situación de los móviles, atributos de las casillas y paredes entre las casillas. Cuando en el menú de MainActivity elegimos guardar una foto del juego

8 en la base de datos guardaremos columna valor _id name moviles este valor lo decide sqlite, debe ser un entero que no se repita en la base de datos; normalmente se elige el menos entero positivo que no aparece aún laberinto difícil J casillas.....o paredes LKNLLOJLDGJGEJCFDOBKIEFLDOAEAIIBGIENHDDHOFLLLDGNLOBCEBKNGMEEN GEN date :32:18 name tiene el nombre que le damos moviles tiene una codificación de qué hay en cada casilla (ver DbUtils) casillas tiene una codificación de los atributos de cada casilla (ver DbUtils) paredes tiene una codificación de las paredes de cada casilla (ver DbUtils) date contiene la fecha y hora en el formato "yyyy-mm-dd HH:mm:ss" Dado que, como regla general, guardar cosas en la base de datos es una operación lenta, la sacaremos de la thread principal usando una tarea en background 1. Esta clase la creamos cuando ya sabemos el nombre que le queemos dar a la foto, nombre que pasamos como parámetro: DbSaverTask task = new DbSaverTask(); task.execute(name); 1 En el juego que nos ocupa el almacenamiento es suficientemente rápido. Esta arquitectura tiene más sentido cuando el almacenamiento es externo, por ejemplo en la nube, donde dependemos del tiempo de respuesta de Internet y conviene que no paremos la tarea principal mientras esperamos al servidor remoto. La arquitectura sería la misma.

9 Dentro de la AsyncTask, en la parte previa a la ejecución (en la UI-thread) cargaremos los campos que vamos a necesitar. Esto ocurre mientras el juego está congelado. Luego, en la parte que ejecuta en paralelo, llamamos a SQLite para guardar los datos. public class DbSaverTask extends AsyncTask<String, Void, Void> { private MyDbAdapter dbadapter; private String moviles; private String casillas; private String paredes; protected void onpreexecute() { // inicializa los campos protected Void doinbackground(string... params) { // guarda en la base de datos return null; 6.2 Recuperar una foto Cuando en el menú de MainActivity elegims recuperar una foto del juego, toma control DbLoadActivity, que presenta una lista con las entradas en la base de datos, para que elijamos alguna: Al elegir una entrada de la lista, se va a la base de datos, se recupera esa entrada y se llama a las rutinas de DbUtils para ir cargando móviles, casillas y paredes. Cuando DbLoadActivity termina cargando una foto de la base de datos, los móviles están creados; pero no están arrancadas las threads. Cuando devuelve control a MainActivity, esta debe arrancarlos (resucitarlos). 6.3 DbUtils Se facilita programado; pero el alumno debe tener en cuenta que hay que modificar los métodos de guardar y recuperar móviles para tener en cuenta sus propios fantasmas: String getstringmoviles() void setstringmoviles()

10 char getcode(movil movil) { if (movil == null) return '.'; Class<? extends Movil> clazz = movil.getclass(); if (clazz == Jugador.class) return 'J'; if (clazz == Estatua.class) return 'E'; if (clazz == Fantasma00.class) return 'F'; if (clazz == Depredador.class) return 'D'; Movil mkmovil( char codigo, Terreno terreno) { if (codigo == 'J') return terreno.getjugador(); if (codigo == 'E') return new Estatua(); if (codigo == 'F') return new Fantasma00(terreno); if (codigo == 'D') return new Depredador(terreno); return null; return '.'; Y no debe olvidar que setstringmoviles() se limita a poner móviles en terreno. Este método se llama desde DbLoadActivity y cuando esta actividad devuelve control a MainActivity, MainActivity debe ponerlos en marcha (resucitarlos). 6.4 MyDbhelper Sigue el patrón estándar recomendado en android, envolviendo la especificación de la base de datos y las operaciones de acceso. En particular, se recurre a una personalización de SQLiteOpenHelper para gestionar la creación inicial y los cambios de versión. private static class DatabaseHelper extends SQLiteOpenHelper { private static final String DATABASE_CREATE = "..."; DatabaseHelper(Context context) { super(context, DATABASE_NAME, null, DATABASE_VERSION); public void oncreate(sqlitedatabase db) { db.execsql(database_create); public void onupgrade(sqlitedatabase db, int oldversion, int newversion) { db.execsql("drop TABLE IF EXISTS " + TABLE_FOTOS); oncreate(db);