16/7/14

[RoundWar] Minijuego

Buenas gente!

Esta va a ser una entrada rápida para que le echéis un vistazo al juego en el que me he basado para hacer la mayoría de los tutoriales aquí.

Por supuesto, aun tiene millones de fallos, pero es un ejemplo de lo mucho que se puede hacer con libGDX, un poco de paciencia y GIMP para dibujar las imágenes.

El APK del juego os lo podéis descargar de aquí.

Si queréis ver el código, podéis verlo aquí.

Este juego no creo que lo suba a la App Store ya que le quedan demasiadas cosas por arreglar y prefiero hacer otros juegos más pequeños para mejorar la estructuración de clases o aprender sobre diferentes temas, más que centrarme en un solo juego.

Os dejo algunas capturas de pantalla del juego, para que os hagáis una idea de cómo es:


Selección de partida
Menú principal

Selección de personaje

Jugando
Jugando en otro escenario

Como siempre, si tenéis alguna duda o sugerencia, no dudéis en decírmelo :)

7/7/14

[Tutorial] Como crear un panel de scroll (libGDX)

Buenas gente! en esta entrada vamos a ver que herramienta nos proporciona libGDX y como usarla para crear nuestra propia lista de objetos con scroll para desplazarnos por ellos. Vamos a ello:

Creando el Scroll


Primero necesitaremos una clase Scroll que extienda de la clase ScrollPane de libGDX en ella tendremos varias variables:


Crearemos una lista de objetos (más adelante veremos como crearla)

También tendremos un texto que mostraremos cuando no haya ningún objeto.

Por último también guardaremos el tamaño que tendrán los objetos. En mi case, un 25% del alto de la pantalla, pero puede ser el que queráis.

Veamos ahora como inicializar nuestro Scroll en el constructor:


A nuestro constructor le pasaremos la lista de objetos (veremos más adelante como crearlos). En un principio llamaremos al constructor de la clase superior con null, es decir, sin asignarle ningún widget (línea 2) ya que en el siguiente paso crearemos nuestra lista rawList pasándole la lista de objetos que se le pasa al constructor y la asignaremos como widget al Scroll (líneas 3 y 4).

Para continuar hacemos que el Scroll tenga el mismo tamaño que la lista (líneas 5 y 6).

Con la función de la línea 7 le indicamos hacia donde se hará el scroll, el primer booleano indica si queremos que se haga en horizontal y el segundo en vertical. En mi caso puse para que solo se pudiese hacer scroll en vertical, ponedlo según os interese.

Si queremos añadir una vez creado el Scroll nuevos objetos, deberemos añadir a nuestra clase la siguiente función:


En esta función le asignamos a la lista los nuevos objetos y le decimos al scroll que pase a tener el mismo alto que la lista (en caso de que los nuevos objetos también modifiquen el ancho de la lista tendremos que poner al Scroll el ancho de la lista también).

Creando la lista de objetos


Ahora vamos a crear la clase de la lista de objetos.

Tanto la clase de la lista como la de los objetos las podemos poner dentro de la misma clase Scroll, o bien ponerlas en ficheros separados como suele hacerse normalmente.

Creamos entonces nuestra clase MyRawList (Podéis llamarla como queráis) que extienda de la clase Widget. Veamos el código de ejemplo y ahora lo explicaré paso a paso:


En primer lugar, tendremos una variable de tipo Scroll donde guardaremos el Scroll al que pertenecerá nuestra lista. Tendremos también la lista de objetos que contendrá la lista y el tamaño de esta.

En el constructor asignaremos los objetos que se le pasan a la lista, y se le define el ancho y alto que tendrá.

En la función setItems(...) le asignamos los objetos que le pasamos y, en caso de que sean mayor que 0, se calcula el tamaño de la lista según el número de objetos y el tamaño de estos.

La función draw primero mirará si hay objetos. En caso de no haberlos muestra por pantalla el texto indicándolo y termina la función.

En caso de si haber objetos, recorremos cada uno de los objetos para dibujarlos en caso de que estén dentro del rango de visión de la pantalla. (línea 40).

Si está dentro de un rango en el que se ve el objeto pasamos a dibujar todo lo que haya dentro suya (línea 50). Esta parte dependerá de qué contengan vuestros objetos, así que llamaremos a la función draw(...) que tendrán nuestros objetos para cada uno de ellos.

Veremos en el próximo apartado como crear cada uno de los objetos.

Creando los objetos


Ahora veremos como crear un objeto de la lista. Esta clase dependerá completamente de lo que queráis añadir en cada objeto. Yo os muestro como hacer un objeto con un fondo, una imagen y un texto:


Simplemente tenemos que crear una clase con los elementos que queramos, inicializarlos con los valores que le pasemos al constructor y crear una función que dibuje todos los elementos del objeto.

Para el fondo simplemente le indico donde y con que tamaño quiero que se dibuje. Para la imagen le indico donde quiero que se sitúe y luego la dibujo. Para la fuente primero la escalo para que tenga un tamaño adecuado y luego la dibujo.

Con esto ya tendremos todo listo para crear donde queramos nuestro Scroll.

Creando nuestro Scroll


Para crear nuestro Scroll primero necesitaremos crear los objetos que tendrá. Para ello creamos un nuevo ScrollItem[] en el que meteremos los objetos que iremos creando. Luego le pasaremos este vector al Scroll cuando lo creemos:


Puedes crear los objetos con un bucle, leyendo desde un fichero o como mejor te venga. En este caso, y a modo de ejemplo, los he creado uno por uno directamente.

Para dibujar nuestro Scroll tan solo tendremos que añadirlo a nuestra Table o a nuestro Stage.

Notas


  • No olvides hacer el dispose() de los objetos Texture que crees para liberar la memoria.
  • Aunque en este ejemplo hemos visto el Scroll para una lista de objetos, puedes hacerlo para una imagen, un texto, etc. Puedes ver más información aquí.
  • Puedes ver más información y funciones del ScrollPane aquí.

30/6/14

[Tutorial] Usando el acelerómetro y el vibrador (libGDX)

Buenas gente! En esta entrada veremos cómo obtener los datos del acelerómetro de un dispositivo móvil.

Un acelerómetro mide la aceleración de un dispositivo móviles Android en tres ejes y, a partir de ellos se puede deducir la inclinación u orientación de este.

La aceleración se mide en metros por segundo al cuadrado (m / s^2). Si un eje está
apuntando directamente hacia el centro de la tierra, su aceleración será más o menos 9'8 m / s^2.
Si apunta en la dirección opuesta, la aceleración será -10 m / s^2.

Los ejes en un dispositivo Android se configuran de la siguiente manera:


Los dispositivos Android tienen un término llamado orientación predeterminada, que indicará el estado por defecto de la orientación de la pantalla. Para los teléfonos, modo retrato ( portrait en inglés, es como en la imagen de arriba) es la orientación predeterminada. Para tablets, el modo de paisaje se tratará como la orientación predeterminada. Un dispositivo de orientación horizontal por defecto tiene sus ejes de rotación, de modo que los puntos del eje y hasta la parte más pequeña del dispositivo y los puntos del eje X a la derecha de la parte más ancha.

Comprobar disponibilidad del acelerómetro y orientación del dispositivo


Una vez vista la teoría del acelerómetro, veamos como comprobar si el dispositivo en el que se está ejecutando nuestra aplicación tiene acelerómetro. Para ello ejecutamos allí donde queramos comprobarlo la siguiente línea de código:



Esta función nos devolverá una variable booleana, true en caso de existir el acelerómetro, false en caso contrario.

Ahora veamos como saber la orientación actual que tiene nuestro dispositivo, para ello, ejecutamos la siguiente línea de código donde queramos conocer la orientación:



Esta función devolverá una variable de tipo int, con un valor de 0, 90, 180 o 270 grados, que indica la diferencia angular entre la orientación actual y la orientación nativa.

Ahora veamos como saber la orientación nativa de nuestro dispositivo:



Esto nos devuelve una variable de tipo Orientation con valor de Orientation.Landscape u Orientation.Portrait.

Lecturas del acelerómetro

Llegamos a la parte que nos interesa: Usar los datos que nos da el acelerómetro.

Para ello usaremos las siguientes funciones para saber el valor que devuelve:



Como hemos dicho antes en cada eje se moverá entre los valores flotantes de 10 y -10.

Para mover a un actor por la pantalla deberemos entonces, seguir los siguientes pasos:
  • Multiplicar el valor obtenido al comprobar el acelerómetro en un eje determinado por un delta para adecuar la velocidad a la que queramos 
    • Si el delta usado es 1 se moverá a una velocidad de entre 10 y -10 cada frame.
    • Si el delta usado es 0.5 se moverá a la mitad de velocidad.
    • Si el delta usado es negativo se moverá en la dirección contraria a donde giremos el dispositivo móvil.
    • Deberemos hacer varias pruebas y ajustar el delta a datos como el tamaño de la pantalla y la velocidad a la que queremos que avance el actor deseado.
  • Aplicar el incremento (o decremento) de posición al actor que queramos mover. Para ello sumamos el valor obtenido anteriormente a la posición actual del actor en su función de actualizar (act(...)) si es un objeto de la clase Actor o de una heredada de esta.
  • Dibujar de nuevo el actor para mostrar su nueva posición. Esto se hará en el método draw(...).

Con estos simples pasos podremos mover cualquier objeto por la pantalla de nuestro dispositivo en el eje que queramos (o en varios ejes a la vez).

Vibrador


El vibrador, como ya sabemos, sirve para hacer vibrar el móvil.

Para que nuestra aplicación pueda hacer vibrar el móvil, deberemos ponerle un permiso especial. Para esto nos vamos a nuestro fichero AndroidManifest.xml y añadimos la siguiente línea de permisos:



Con esto ya podremos hacer vibrar el dispositivo el tiempo que queramos con la función siguiente:



El tiempo se especificará en milisegundos.

Si queremos patrones de vibración más sofisticada usaremos la siguiente forma:



Aquí enciende el vibrador durante 200 milisegundos, y luego lo apaga durante 200
milisegundos después de nuevo lo enciende hasta dentro de 200 milisegundos. El segundo
parámetro especifica que el patrón no se debe repetir.

Notas:

  • Los dispositivos que no tengan acelerómetro devolverán 0 en las funciones de obtener la aceleración en algún eje.
  • Aunque no es obligatorio, es recomendable añadir a nuestro fichero AndroidManifest.xml las siguientes líneas para informar de que nuestra aplicación hará uso del acelerómetro para funcionar:



Referencias

23/6/14

[Drop 2048] Primera aplicación en Play Store

Buenas gente!! Hoy vengo a hacer un poco de publicidad de la primera aplicación que he subido al Play Store.

Drop 2048




Es un juego simple que ha sido mi conejillo de indias para ver como va el tema de subir aplicaciones, la publicidad, encriptación de datos y muchas más cosas.

Podéis descargaros la versión desde aquí. Se llama Drop 2048.

Todas las descargas, comentarios y puntuaciones en el Play Store serán bien recibidas ^^ (sobre todo si son buenas).





El juego trata de mover a tu bloque, que está situado en la parte baja de la pantalla e ir cogiendo los bloques con tu mismo número o bloques especiales.


Los bloques especiales podrán darte más puntuación, aumentarte la velocidad a la que caen los bloques, disminuirla, volver al número y velocidad inicial... Todo viene explicado en la pantalla de instrucciones, en un inglés muy simple.



El objetivo del juego es conseguir la mayor puntuación posible en cualquiera de sus dificultades.

Las 10 mejores puntuaciones de cada nivel se guardarán y podrás verlas en cualquier momento en la pantalla de puntuaciones del menú principal.




Futuras mejoras al juego


Ya que este juego es mi conejillo de indias, quiero probar con él varias cosas antes de hacer un juego más currado.

1) En primer lugar quiero añadirle la API de Google Analystics, que te dará mucha más información sobre el uso que hace la gente de tu aplicación, como por ejemplo el tiempo que están en ella, visitas diarias, etc.

Puedes además, enlazar tu aplicación si usas Admob, y ver desde su página toda la información en gráficos.

Una vez lo haya integrado con la aplicación crearé una entrada comentando como hacerlo :D

2) El siguiente añadido que le quiero introducir es los servicios de juegos de la google play. Esto es realmente interesante porque por ejemplo, los usuarios pueden jugar con rivales de sus círculos de Google+, ver los marcadores para comparar sus puntuaciones con otros jugadores, desbloquear logros y sincronizar el progreso del juego en todos sus dispositivos. Todo esto hace de tu juego uno mucho más interesante al poder comparar puntuaciones de personas de todo el mundo o de tus amigos, lo que da mayor difusión al juego.

De nuevo, en cuanto tenga añadido esto crearé una entrada para explicaros cómo se hace.

3) El siguiente cambio que quiero añadirle es añadir el soporte para varios lenguajes. Ahora mismo está todo en inglés, así que quiero que según el idioma cambie todo. Como mínimo entre inglés y español.

4) Otro cambio ya más relacionado con el juego es el permitir uso de distintas texturas para los bloques. Así, en vez de usar solo números, se podrán jugar con frutas, colores u otros objetos, para ampliar el grupo de población al que puede llegar el juego.

5) Añadir música y sonidos. Aunque esto es algo que ya tengo implementado en el otro juego que hice, no estaba del todo segura de las licencias, así que no puse música en este juego. Estoy a la espera de un amigo que hace música para videojuegos para poder añadirle música a mi juego.

Una vez le añada música crearé otra entrada diciendo como se pone música, como activarla y desactivarla, ponerla en bucle para que no deje de sonar nunca, etc.

Ya que la carga de la música suele durar un poco, también crearé una entrada para enseñaros una forma fácil de crear vuestra propia pantalla de carga al principio de la aplicación.

6) El resto de cambios como pueden ser añadir nuevos bloques especiales, permitir cambiar el número de columnas de bloques que caen, activar o desactivar bloques especiales, etc. no son realmente relevantes para mostrarlos en entradas como tutoriales, así que tampoco los pondré aquí.

Notas


  • De nuevo no os olvidéis de descargaros y puntuar la aplicación, es algo que solo cuesta un minutillo y siempre se agradece.
  • Si estos tutoriales os sirven para crear vuestra aplicación no olvidéis dejarme un comentario con vuestra aplicación, estará encantada de verlas, descargármelas y probarlas!
  • Cualquier idea de tutoriales o entradas en general que os gustaría que pusiera son bien recibidas. El aprender nunca está de más!

21/6/14

[Tutorial] Como subir tu primera aplicación al Play Store

Buenas gente! En esta entrada vamos a ver cómo subir nuestras preciadas aplicaciones a la Google Play Store!

Creando la cuenta de desarrollador de aplicaciones


En primer lugar tenemos que crearnos una cuenta de "play developer", para ello entraremos en esta página.

Una vez dentro tendremos que registrarnos y tendremos que pagar 25$ (Precio a 21/06/14). Será el único pago que tendremos que hacer y se puede hacer por tarjeta. El pago se hará inmediatamente y ya podrás entrar en tu cuenta.

Si quisiéramos crearnos nuestra cuenta para subir aplicaciones a la Apple Store necesitarías pagar 99$ al año. Cosa no muy recomendable para empezar...


Preparando tu aplicación para subirla: APK con firma


Para que tu APK sea aceptado debe cumplir una serie de requisitos:

Primero deberá estar firmada. Para ello abrimos nuestro Eclipse, seleccionamos nuestro proyecto Android y le damos a exportar, seleccionamos la opción que se muestra a continuación:


Le damos a continuar tras ver que el nombre del proyecto android es el correcto y en el siguiente paso deberemos crear una firma o utilizar una que ya tengamos.

Para crear una indicamos la dirección donde queremos que se nos guarde el fichero con la firma y una contraseña:


Le damos a continuar y nos pedirá que rellenemos algunos datos como nuestro nombre, una contraseña, etc. También nos pedirá que decidamos cuantos años de validez queremos que tenga nuestra firma. Recomiendan poner 25 así que eso ponemos. No tenemos que rellenar todos los campos, con rellenar el Alias, contraseñas, años de validez y un campo que elijamos más es suficiente:



Continuamos a la siguiente pantalla y solo nos quedará elegir la ruta donde crear nuestro APK y su nombre. Tras esto ya tendrás tu aplicación firmada para que solo tú puedas editarla.

Preparando tu aplicación para subirla: Optimizar tu APK


El siguiente paso necesario para subir la aplicación es optimizar tu APK para adaptarlo a los requisitos que necesita el sistema Android.

Para ello usaremos una herramienta: ZipAlign.

Esta herramienta ya viene incluida en nuestro SDK, y lo podemos encontrar en la siguiente dirección:

/sdk/tools/

Donde es la carpeta donde tenemos nuestro ADT.

Una vez localizamos la herramienta se usa de la siguiente forma:



Indicamos donde está nuestro fichero a optimizar y donde queremos crear el nuevo fichero ya optimizado.

Tras esto ya tendremos nuestro fichero APK listo para ser subido.

Subiendo la aplicación


Una vez tenemos lista nuestra aplicación para ser subida volvemos a la página que vimos al principio.

Y hacemos click en añadir nueva aplicación.

Deberemos rellenar varios campos como es la descripción y título de la aplicación en tantos idiomas como queramos (o sepamos) y subir varias capturas de pantalla de la aplicación.

Deberemos también aceptar las licencias que nos impone google y, tras esto, nos dirá que nuestra aplicación se publicará en unas pocas horas si todo va bien.

Y ya está! Pasado un tiempo tu aplicación estará subida en la Play Store y habrás dado un gran paso para comenzar tu camino como desarrollador de aplicaciones para Android! Felicidades!


17/6/14

[Tutorial] Cómo poner publicidad con AdMob en tu aplicación (libGDX)

Buenas gente! En la entrada anterior vimos distintos modelos de negocio para conseguir monetizar nuestras aplicaciones. En esta entrada nos centraremos en el modelo de aplicación gratuita con publicidad.

Para ello nos crearemos una cuenta en la plataforma Google AdMob, que, al igual que Google Adwords y Google Adsense en el mundo web, actúa de intermediario para poder poner publicidad en tus aplicaciones y está disponible para casi todas las plataformas móviles, como Android, iPhone/iPad y Windows Phone.

Crear una cuenta en AdMob


Lo primero de todo será crearnos una cuenta en AdMod, para ello nos vamos a su página web.

Una vez dentro nos registramos usando una cuenta de gmail. Deberemos dar algunos de nuestros datos como país donde vivimos, nombre completo, etc.

Una vez estemos registrados, nos vamos al menú "Monetizar" y añadimos el nombre de nuestra aplicación.

Hacemos click en añadir nuevo bloque de anuncios y le damos un nombre y un tipo (veremos más adelante los tipos que hay).

Tendrás que crear un nuevo bloque por cada espacio de anuncios que quieras poner en la aplicación (banner superior, publicidad de pantalla completa, etc.)

Cada bloque tendrá su propio id que usaremos más adelante.

Importando librerías en eclipse


Necesitaremos descargar un par de librerías para poder usar la API de google y sus anuncios. Para ello nos vamos a nuestro ADT y vamos al menú "Window -> Android SDK Manager" una vez dentro buscamos en la API 17 o superior el paquete Google APIs y lo señalamos para instalar.



Ahora bajamos en la lista hasta llegar a Extra e instalamos el paquete Google Play Services:



Una vez instalados ambos, seleccionamos File-> Import-> Android-> Existing Android Code into Workspace

Nos situamos en la carpeta donde instalamos nuestro ADT y SDK y desde ahí importamos:

/extras/google/google_play_services/libproject/google-play-services_lib/

El siguiente paso es seleccionar nuestro proyecto android, hacemos click derecho en él y vamos a sus preferencias.

En el menú de Android veremos en la parte de abajo para importar librerias, hacemos click en el botón de añadir y añadimosla librería google-play-services_lib que acabamos de importar a eclipse.

Con esto ya tendremos nuestro proyecto listo para usar la API de google.

Modificando nuestro AndroidManifest.xml


Lo primero que hay que cambiar es nuestro fichero .xml para añadir un activity nuevo para el anuncio y añadir los permisos de internet y comprobación de red necesarios para que puedan verse los anuncios. El fichero quedará parecido al siguiente:



Modificando nuestra clase AndroidLauncher.java


Deberemos modificar la única clase que tenemos en el paquete android y añadirle los anuncios que queramos. Quedará parecido a esto:



En la línea 36, en vez de ID_AD tendrás que poner el Id del bloque de anuncio que ponga en la página de AdMob y que creaste antes.

En la línea 37 indicas que tipo de anuncio será. Puede ser un banner, como en este caso, pantalla completa, etc. Puedes ver los tipos disponibles aquí.

Las líneas 40 y 41 solo son necesarias cuando estás haciendo pruebas, para indicar el Id del dispositivo en el que vas a hacer las pruebas.

Esto es necesario ya que si realizas muchas pruebas AdMob podría detectar que estás haciendo clicks "fraudulentos" y llegar a bloquearte la cuenta. Para ello le indicas que estas haciendo pruebas en ese dispositivo.

En la línea 52 indicas donde quieres que se coloque el anuncio dentro de la pantalla. En este caso está puesto an la parte inferior de la pantalla.

Modificando nuestra clase principal


Primero deberemos crear una interfaz dentro del proyecto principal de la aplicación:



Después deberemos crear una variable de esa interfaz dentro de nuestra clase principal de la aplicación:



Tras esto solo nos quedará activar el mostrar los anuncios:



Tras esto ya podremos ejecutar nuestra aplicación en un dispositivo android y se verá la publicidad.

Notas

  • Esta API de google solo funciona para versiones de Android iguales o superiores a la 2.3
  • Deberás crear un AdView por cada uno de los bloques de anuncios que quieras crear.
  • Las primeras veces que intentes ver el anuncio o cuando pasen 24 horas sin que nadie lo vea puede que el anuncio tarde en cargar. Deja la aplicación abierta durante un par de minutos y con el tiempo cargará el anuncio.

Referencias

[Información] Como ganar dinero con tu aplicación

Buenas gente! En esta entrada veremos cuales son los distintos modelos de negocio a la hora de querer rentabilizar tus aplicaciones. Aunque existen muchos modelos nos centraremos en los 6 más comúnmente usados:


De pago

La opción más lógica si intentas obtener dinero de tus aplicaciones es cobrar por ellas. El usuario paga un precio normalmente menor a 7 euros por tener la aplicación.

De el precio total que paga el usuario, tú como creador te llevas un 70% de las ganancias y google un 30%.

Gratuita

Aunque estas aplicaciones no den dinero sirven para darte publicidad, ya que muchos usuarios la descargarán por probarla.


Freemium

Esta aplicación se puede descargar de forma gratuita pero tendrá ciertas limitaciones (escenarios o personajes bloqueados, publicidad, etc.)

El usuario podrá pagar para tener la versión premium de la aplicación donde se le eliminarán las restricciones de la versión gratuita.

Demo

Esta aplicación será gratuita y se usará para dar publicidad como demostración de una aplicación de pago.

Añadidos

Esta aplicación será gratuita pero contará con una "tienda" dentro de la propia aplicación para desbloquear ciertos contenidos (personajes, armas, niveles, gemas, etc).

El usuario decidirá si quiere desbloquear alguno de esos contenidos.


Gratuita con publicidad

Esta es la más recomendable según mi punto de vista. El usuario puede descargarse la aplicación de forma gratuita y tú recibes ingresos según distintos criterios:


  • Impresiones
    • Cada 1000 veces que vean el anuncio obtendrás una pequeña cantidad de dinero.
    • Para que esto sea rentable deberás tener muchos usuarios en tu aplicación, ya que recibirás apenas unos pocos céntimos por cada 1000 visitas.
  • Por click
    • Cada vez que alguien hace click en el anuncio ganas una cantidad de dinero algo mayor a la que recibes por 1000 visitas.
    • Las empresas que dan estos servicios de publicidad tienen sistemas para detectar clicks "fraudulentos" o inválidos y pueden llegar a cerrarte tu cuenta.
  • Por formulario
    • Aquí recibes el ingreso cuando alguien hace click en el anuncio y rellena un formulario.
    • El ingreso aquí es bastante mas elevado (puede que un par de euros por cada usuario que rellene el formulario) aunque poca gente lo hace.
  • Por acción
    • Cuando un usuario hace click en la publicidad y lleva acabo una compra, descarga, o lo que proceda, tu recibirás una buena cantidad de dinero (entre 5 y 10 euros, dependerá del anuncio).
Existen muchas empresas que se dedican a actuar de intermediario para permitir que puedas poner publicidad en tus aplicaciones. Algunas de ellas son las siguientes:



Referencias


30/5/14

[Tutorial] [LibGDX] Añadiendo escuchadores de eventos a actores

Buenas gente!
En esta entrada vamos a ver como añadir eventos a cualquier actor de tu aplicación. Con estos eventos podrás controlar lo que pase cuando se haga click o se arrastre un actor, por ejemplo.

Creando e inicializando las variables necesarias


Lo primero que tenemos que tener es un objeto de la clase Actor o de alguna clase que herede de este (botones, tablas, imágenes... puedes ver más información sobre los actores de libGDX aquí.)

Después necesitaremos un Stage, un Batch o una cámara para que nos muestre el Actor en la pantalla. ( Puedes ver más información sobre Stages y SpriteBatch aquí y aquí)


Recuerda añadir un procesador de entradas a tu Stage:


Con esto harás que sea ese Stage el que reciba los eventos. En caso de tener varios Stages en una misma aplicación deberás decidir en cada caso cual quieres que reciba los eventos. Sólo podrá haber un Stage recibiendo eventos al mismo tiempo.

Añadiendo eventos a un Actor


Una vez tenemos todo listo tan solo deberemos añadir el siguiente código para que nuestro Actor reciba eventos determinados.

Aquí tienes el código de distintos eventos que se pueden añadir. Tan solo tienes que coger las funciones para el evento que quieras coger:


Puedes ver todos los eventos que puedes usar aquí.

Notas


  • Los Stages también pueden recibir eventos de la misma forma que los Actores, al igual que los TextButtons, Tables, etc.
  • Aquellas funciones que devuelven un boolean, en caso de devolver true se detendrá en esa función y no se ejecutará para el resto de escuchadores de eventos que tengas. Es decir, si pones una función en el Stage de escuchar un evento de hacer click (touchDown) que devuelva true, este evento no lo recogerá ninguno de los actores que tenga el Stage. Por eso es recomendable que devuelva siempre false, salvo excepciones.

27/5/14

[Tutorial] Instalaciones necesarias para trabajar con libGDX y Android

Buenas gente!

Hoy, al ir a crear un nuevo proyecto para Android ví que el post que hice explicando cómo se hacía está ya desactualizado por la parte de libGDX, por lo que en esta entrada pondré la versión que hay actualmente (a día 27/05/14) y dejaré la entrada anterior por si alguien tiene versiones anteriores.

Como ya expliqué antes, usaremos el SDK de Android y la librería libGDK. Esta librería te permite tener tu juego tanto en el ordenador como en Android, por lo que las pruebas podrán hacerse directamente en tu ordenador y no necesitaremos usar un emulador de Android, lo que agilizará todas las pruebas.

Descargas e instalación


Lo primero es tener instalado Eclipse. Si no lo tenemos, en Ubuntu es tan sencillo como instalarlo desde terminal con el comando:

# apt-get install eclipse

Si no tienes Ubuntu puedes descargarte Eclipse desde su página.

Además tendremos que descargarnos un par de cosas:

La librería libGDX desde esta web.
El ADT de Android desde esta web.

Una vez descargados, descomprimimos el ADT donde queramos tenerlo, ya que no necesita instalación. En mi caso lo coloqué en mi carpeta personal con el nombre ".adt-eclipse" para que se mantuviese oculta y no estorbase y luego cree un acceso directo al fichero ejecutable ".adt-eclipse/eclipse/eclipse" en mi escritorio, pero puedes ponerla donde y con el nombre que quieras.

Este fichero de antes es una versión modificada de Eclipse denominada Android IDE que viene ya preparado para comenzar a trabajar con Android.

Creación de proyectos


Para crear nuestros proyectos descomprimiremos el archivo libGDX que nos hemos descargado. Dentro de él ejecutaremos el archivo:

gdx-setup.jar



En la pantalla que nos aparece le indicaremos el nombre de nuestro proyecto, como queremos que se llame el paquete por defecto y la clase principal.

Le indicaremos también donde queremos guardarlo y donde se encuentra el SDK. En nuestro caso, el SDK será la carpeta llamada con el mismo nombre dentro de la carpeta que descomprimimos en un principio de nuestro ADT.

Podemos seleccionar a que vamos a querer exportar nuestro proyecto, que puede ser para ordenador (desktop), Android, IOs o Html.

Por último le damos a generar. Tras lo cual ya tendremos nuestros proyectos creados y listos para usar.

Ahora tenemos que importar los proyectos que ha creado para que podamos usarlos en Eclipse. Para ello entramos dentro de Eclipse con el ejecutable de antes (dentro de la carpeta que descomprimimos en un principio entramos en la carpeta eclipse y el ejecutable llamado elipse que hay ahí).

Seleccionamos "File->Import...->Gradle->Gradle Proyect"




Si no nos aparece esta opción, deberemos instalar el plugin. Para ello vamos al menú Help -> Install new software...

Añadimos la siguiente dirección: http://dist.springsource.com/release/TOOLS/gradle y le damos a add


Le damos a continuar y tras instalarlo ya podremos importar proyectos gradle.

Tras estos pasos ya tendremos nuestros proyectos en el workspace y tendremos nuestro entorno listo para ponernos a trabajar en nuestra aplicación!

Notas


  • Todas las clases y código se crearán en el proyecto principal. En los otros proyectos solo habrá una clase para adaptar y crear el proyecto ya sea en Android o en el ordenador y cambiar detalles como la resolución de la pantalla.
  • Los archivos estáticos como las imágenes o textos irán en la carpeta assets del proyecto android. El resto de proyectos tienen enlazada su carpeta para poder usar estos archivos automáticamente.
  • El programa de libGDX que hemos usado permite también crear proyectos para exportar tu aplicación a otras plataformas como IOs o html. Tan solo tienes que seleccionar los proyectos que deseas que te cree y deseleccionar aquellos que no te interesen.

16/5/14

[Noticia] Keepod, el 'gadget' inventado para acabar con la brecha digital en el mundo

Buenas gente! Hoy en vez de un tutorial os traigo una noticia interesante que he leído hoy.

Se trata de Keepod, un dispositivo de bajo coste que almacena un SO Android 4.4 para que el usuario pueda tener su escritorio y archivos y acceder a ellos desde cualquier ordenador de forma segura.

El aparato es un pendrive que cuesta tan solo 7 dólares y tiene una capacidad de 8GB (El SO apenas ocupa 1GB de espacio) y ha sido inventado por dos jóvenes israelíes. Con el objetivo de dar uso a cualquier ordenador viejo, permitiendo al usuario poder tener su propia información, programas y configuración.

Una buena opción cuando un ordenador va a ser usado por muchas personas o alguien va a usar distintos ordenadores y no tiene acceso a Internet para mantener sus archivos y demás en la nube.

Podéis leer la noticia completa aquí.

15/5/14

[Tutorial] Dibujar formas (libGDX)

Buenas gente! En esta entrada vamos a ver como dibujar distintas formas en nuestra aplicación sin tener que usar texturas o imágenes. Para ello usaremos la clase ShapeRenderer que nos proporciona libGDX. Veamos cómo podemos usarla en nuestra aplicación.

Inicialización de variables


Simplemente tendremos que inicializar nuestra variable ShapeRenderer con un constructor vacío:


Esta misma variable nos servirá para dibujar rectángulos, círculos, arcos, conos, elipses, etc. En el siguiente apartado veremos como.

También deberás tener en algún lado la información de la posición x e y donde quieres dibujar la figura, su radio, color, etc. Esta información puedes guardarla en variables, pasárselas por función, o como te venga mejor para tu aplicación en concreto.

No olvides hacer el dispose( ) de la variable para liberar los datos de la variable al finalizar la aplicación o cuando vayas a dejar de usar la variable.

Dibujando la figura


Para dibujar nuestra figura iremos a nuestra función draw en donde pondremos el siguiente código:


La línea 3 solo es necesaria si quieres que tus formas tengan canal alfa, es decir, transparencias.

Al iniciar con begin(ShapeType) le puedes indicar como quieres que te dibuje la forma:

  • ShapeType.Line → Sólo dibujará la línea exterior.
  • ShapeType.Filled → Dibujará la forma rellena.

Después puedes indicarle el color con el que quieres que se dibujen las siguientes figuras (Si no has puesto la línea 3 dará igual el valor que pongas en el cuarto valor del color).

Después podrás dibujar las figuras que quieras como puedes ver en las líneas 8, 14, 20 y 25.

Estos son unos pocos ejemplos de todas las figuras que puedes hacer, si quieres ver todas las posibilidades, mira aquí.

En la función del círculo (línea 8) el último valor es opcional e indica el número de segmentos con los que se dibujará el círculo.

Por último, cierra el dibujado de figuras con la función end( ).

Puedes ejecutar el begin( ) / end( ) todas las veces que quieras para dibujar formas rellenas o solo con líneas.

Notas

  • No te olvides de hacer el dispose( ) del ShapeRenderer.
  • Si estás usando SpriteBatch o Stages tendrás que parar el SpriteBatch ( batch.end( ) ) antes de dibujar las figuras y volverlo a iniciar (batch.begin( ) ) tras dibujarlas todas.
  • La posición que les indicas para dibujar las figuras es la esquina inferior izquierda, no el centro de la figura.
  • El color que indiques se aplicará a las figuras que dibujes a partir de ahí. Si quieres una figura de otro color deberás llamar de nuevo a la función cada vez.
  • Con un número de segmentos bajo puedes utilizar la función de dibujar círculos para dibujar hexágonos, pentágonos, octógonos, etc.   

28/4/14

[Tutorial] Guardar información cifrada (libGDX)

Buenas gente!

Como bien sabéis, la mayoría de las aplicaciones necesitan guardar cierta información, como puede ser puntuaciones, niveles, opciones de música o sonido, etc. Alguna información no es necesario ocultarla, como puede ser la configuración del perfil que se puede cambiar en el menú de opciones (el volumen al que queremos la música, etc.) pero otra información importante no queremos que esté a simple vista y que cualquiera pueda cambiarla fácilmente (por ejemplo la puntuación máxima que hemos obtenido en el juego, etc.). Esta última información irá cifrada.

En esta entrada veremos como guardar la información tanto cifrada como no.

Adaptando nuestras clases para guardar en fichero


Para guardar nuestra información en un fichero crearemos una clase que contenga esa información e implemente la interfaz Serializable.

Veremos un ejemplo con una clase Profile donde guardaremos algunos datos del perfil del jugador de nuestra aplicación:


Como podemos ver necesitamos dos funciones, una para guardar nuestros datos en fichero y otra para leerlos.

En la función write guardaremos valor a valor con la función:


El nombre que pongamos aquí será el que tengamos que usar para leer esa variable del fichero.

Como nota especial, para guardar un vector o una lista indicaremos el comienzo y el final de la lectura del vector con:


En la función read leeremos todos los valores usando los nombres que les pusimos en la función anterior e indicando la clase de cada variable (Integer.class para tipo int, String.class para las cadenas de caracteres, etc.).


Con esto ya tenemos lista nuestra clase para que sea guardada y leída en un fichero de tipo JSON.

Creando la clase de lectura y escritura de datos


Una vez que tenemos las clases que queremos guardar serializadas vamos a crear una clase que se encargue de organizarlo todo, de modo que con una llamada a una función de esta clase se guarden todos los datos, se creen los que no estén creados, etc. La clase debe ser parecida a esta:


En una variable de la clase guardaremos la dirección del fichero donde queremos guardar todos los datos, y tendremos una variable de cada clase que queramos leer/escribir en fichero.

Esta clase además tiene dos funciones: Read y Write, veamos que hace cada una de ellas.

  • Función read()

Si ya existe un perfil creado devuelve ese perfil.

Crea un nuevo objeto de tipo Json para tratar con él y crea un enlace con el fichero que le hemos indicado. Si no existiese el fichero el mismo se encargaría de crearlo.

Si existe ese archivo mira a ver si tiene información correcta. Para ello guarda toda la información en un String y lo decodifica (Si no necesitáis la información codificada podéis borrar la línea 14 y usar en la línea 16 profileAsCode en vez de profileAsText). Una vez tiene la información se la pasa a nuestra clase Profile para que tome los datos de ella (Si se tienen varias clases se les pasa a todas las clases).

Si no existe el fichero crea un nuevo perfil (si tienes más clases las creas aquí también) y lo guarda en el nuevo fichero creado.

  • Función write(Clases_a_leer)

Esta función crea un nuevo Json para tratar con él, y el enlace al fichero en el que escribiremos los datos.

Crea un String con los datos obtenidos de la clase Profile (Si tenéis más de una es solo concatenar las cadenas resultantes de leer todas las clases).

Despues codifica la información (de nuevo si no queréis información codificada podéis eliminar esta línea y sustituir en la línea 36 el profileAsCode por la variable profileAsText).

Una vez está la información lista para ser escrita la pasa al fichero.

Y con esto ya podremos guardar nuestros datos en un fichero de forma segura.

Ahora solo tendremos que llamar a nuestro ProfileSerializer.read() o ProfileSerializer.write(...) cada vez que queramos obtener los datos de perfil (por ejemplo al inicio de la aplicación, cuando seleccionamos una partida concreta, etc.) y guardar esos datos (por ejemplo al terminar una partida, al llegar a ciertos puntos, al cerrar la aplicación...).

Notas:


  •   El fichero se ha guardado en local, de modo que si se ejecuta nuestra aplicación en un ordenador se creará el fichero a partir de la ruta por defecto del usuario, es decir, en su carpeta personal.
  • Es recomendable poner un “.” delante del nombre de la carpeta donde vamos a guardar nuestros datos ya que en algunos sistemas como Linux esto indica que es una carpeta oculta y no nos molestará a la vista una vez creada.
  • El archivo puede tener la extensión que queramos, los más comunes son .json, .dat o .txt.

14/4/14

[Tutorial] Animación de sprites (libGDX)

Buenas gente! En esta entrada vamos a ver como hacer animaciones con nuestros sprites, de forma que nuestro jugador, enemigos y demás cobren vida :)

Variables necesarias


Primero necesitaremos alguna variable que nos indique en que animación se encuentra en estos momentos. Yo uso un enum por comodidad, pero se puede usar un string, un int o cualquier cosa que te guste más:


Para este ejemplo cambiaremos entre dos animaciones: parado (IDLE) y andando (WALK).

Ahora necesitamos una imagen que contenga la animación. Para ello nos vale una imagen .png. Esta imagen deberá estar dividida en cuadrados y cada cuadrado será un cambio en la animación. Lo normal es poner todos los pasos de una animación en una misma imagen o, incluso, todas las animaciones en una misma imagen. Veamos un ejemplo de imagen con nuestro querido personaje principal Pirko:




Esta imagen la cargaremos en la clase de nuestro personaje como una Texture:


Necesitaremos también un TextureRegion para indicar cual es la imagen actual de la animación que el programa tiene que mostrar y un Vector de TextureRegion por cada animación (o un solo TextureRegión si es solo una imagen estática la animación):


Ahora necesitamos tantas variables del tipo Animation como animaciones vayamos a tener y una más para tener la animación actual:


Creando una animación


Vamos a ver ahora como inicializar esas variables de tipo Animation. Para ello primero creamos un vector temporal con todas las TextureRegion de la imagen:


Con la línea anterior hemos cogido la textura con nuestra imagen y dividido en tantos cuadrados según su tamaño y el número de frames que tiene tanto por columnas (FRAME_COLS) como por fila (FRAME_ROWS). (Los frames son los cuadrados en los que se subdivide nuestra imagen con cada paso de la animación). Para nuestro ejemplo, FRAME_COLS vale 4 y FRAME_ROWS vale 1.

Una vez tenemos todas las TextureRegion en el vector temporal, inicializaremos cada vector de TextureRegion que habíamos creado antes para cada animación. Para ello nos vale con una inicialización y un bucle simple:



*Si la animación ocupase más de una fila, tendríamos que hacer dos bucles anidados para recorrerlas.*

Con la animación de estar quieto no necesitamos un bucle ya que será solo una imagen estática:


Ahora ya podemos inicializar nuestras variables de Animation, pasándoles el vector de TextureRegion y el tiempo en segundos que habrá entre un frame de la animación y el siguiente. A menor tiempo, más rápido irá la animación:


Cambiando la animación de nuestro personaje


Para indicarle a nuestra aplicación si nuestro personaje se encuentra andando, parado o cualquier otro estado usaremos una función como la siguiente:


Llamaremos a esta función cada vez que el personaje comience a moverse, se pare o, en definitiva, cambie su estado, pasándole como parámetro un valor del enum que creamos en un principio. Si el estado es diferente al que tiene actualmente, cambiará su animación.

Dibujando al personaje


Una vez que tenemos el estado del personaje y su animación correspondiente vamos a ver como mostrarlo por pantalla. Dado que nuestro personaje es un Actor, usaremos las funciones act(float delta) y draw(SpriteBatch batch, float parentAlpha) que ya vimos en entradas anteriores para que nuestro Stage se encargue de dibujarlo (Ver más información sobre el uso de Stage y Actor aquí).

Comenzamos con la función que actualiza el estado de la animación. Para ello tendremos que usar la siguiente línea dentro de la función:


Con esto seleccionamos el TextureRegion que se tiene que mostrar en ese instante de tiempo de la animación actual.

Ahora veamos que hay que poner en la función de dibujado:


Con la línea anterior le mandamos al SpriteBatch (ver más información sobre SpriteBatch aquí) de nuestro Stage a dibujar el frame de nuestro personaje que le corresponde, comenzando en la posición (posX, posY) con centro en (width/2, height/2), con un tamaño de (width, height), con una escala en los ejes x e y de scaleX y scaleY respectivamente (lo normal es tenerlo a 1) y con una rotación rotation en grados.

¡Tras esto ya podremos ejecutar nuestra aplicación y ver moverse a nuestro personaje!

Notas:


  • Recuerda hacer el dispose() de la textura. No es necesario hacerlo para los TextureRegion o las Animation.
  • Puedes crear animaciones para realizar ataques, recibir daño, morir o cualquier cosa que se te ocurra.
  • Este mismo tutorial vale para animar enemigos, ataques, objetos, etc.

2/4/14

[Tutorial] Mapa con TiledMap

Buenas gente! En esta entrada vamos a ver una herramienta muy útil para crear mapas: TiledMap. Es una herramienta completamente gratuita que podéis descargar de su página web aquí.

Con este editor podremos crear de forma rápida mapas tanto en vista ortogonal como isométrica, pudiendo hacer mapas de tipo plataforma o el típico mapa visto desde arriba.

Primero veremos como crear un mapa simple con este programa y luego veremos cómo añadirlo a nuestro juego fácilmente y como coger información de él.

Usando TiledMap


Para hacer un mapa, en primer lugar necesitaremos una imagen de donde sacar los patrones o “tiles” para nuestro mapa. Un ejemplo de imagen de patrones podría ser la siguiente:



Como podemos ver, la imagen tiene 4 cuadrados, de 64 píxeles cada uno. Esto serán nuestros 4 tiles. Por supuesto, estos son solo tiles de ejemplo, pero puedes crear mapas impresionantes. Otros mapas de patrones que puedes usar es este zip que puedes descargar en la página web de TiledMap como ejemplo. En él te viene un mapa de patrones además de imágenes de arbustos, un árbol y un mapa de ejemplo.

Una vez que tenemos nuestro mapa de patrones abrimos TiledMap y le damos a nuevo. En nuestro caso usaremos una perspectiva ortogonal. En ancho del patrón seleccionamos el tamaño de los “tiles”, suelen ser de 16 o 32 píxeles, pero nosotros usaremos de 64, para que se vean grandes. En el tamaño del mapa pondremos el número de tiles que queramos que tenga.

Ahora que tenemos nuestro mapa vacío vamos a cargar nuestra imagen con los patrones. Para ello vamos al menú de arriba y le damos a Mapa → Nuevo conjunto de patrones...

En la ventana que se nos abre seleccionamos nuestra imagen, le ponemos el nombre que queramos y nos aseguramos que el ancho y alto de nuestros tiles sea el mismo que hemos seleccionado para el mapa.



Ahora ya podemos ir seleccionando los tiles que queramos e ir dibujando nuestro mapa poco a poco. Podemos poner varias capas fácilmente haciendo click derecho en el menú de capas, a la derecha del mapa y seleccionando Nueva capa de patrones...

Yo he creado dos capas para mi juego, la capa suelo que será por donde mi personaje pueda ir andando y la capa de colisiones, donde pondré aquellos objetos que no se podrán traspasar.

Se pueden añadir atributos a cada tipo de tile. Esto nos puede servir por ejemplo para indicar distintas propiedades de cada tile, como puede ser que sea agua, por lo que nuestro personaje tuviera que ir más lento y nadando, que fuera un punto de aparición de enemigos, y cualquier cosa que se nos ocurra que podamos necesitar para nuestro juego. Para ello hacemos click derecho en el tipo de tile que queramos darle un atributo dentro de la pestaña conjunto de patrones, al lado del mapa donde dibujamos y seleccionamos Atributos del patrón... y añadir todos los atributos que queramos.

En mi caso, he puesto los cuadrados morado y rojo en la capa de colisión y he puesto como propiedad a todos los cuadrados verdes que sean el punto de aparición de mi personaje, de modo que no tenga para cada mapa que indicárselo yo manualmente.



Con esto ya tenemos nuestro mapa listo para usarse en el juego. Para ello lo guardamos como fichero con extensión .tmx y lo colocamos en nuestra carpeta Assets de nuestro proyecto name-android, junto con la imagen que hemos usado para los tiles.

Usando el mapa creado en nuestro juego


Una vez tenemos el mapa en la carpeta correcta, vamos a nuestro código. Creamos una nueva clase para colocar aquí todo lo que necesitemos de nuestro mapa. Necesitaremos los siguientes objetos:


El primero será nuestro mapa, cargado de nuestro fichero .tmx como veremos ahora.

El segundo será el encargado de renderizar y mostrar por pantalla el mapa.

El tercero es opcional y guardará una capa del mapa, en mi caso, la de colisión.

Ahora vamos a inicializarlos, para ello, usaremos las siguientes líneas:


Para inicializar nuestro mapa crearemos un nuevo TiledMap y cargaremos el fichero .tmx que hemos creado.

Para obtener nuestra capa de colisiones cogeremos del mapa recién creado la capa con el nombre que hayamos puesto, en mi caso “Colisiones”.

Por último, inicializamos el renderer pasándole nuestro mapa y un SpriteBatch, que puede ser alguno que ya estemos usando. Puedes ver más información sobre SpriteBatch aquí.

Para dibujar nuestro mapa tan solo tendremos que ejecutar la siguiente línea de código donde queramos que se dibuje:


Al cerrar la aplicación tendrás que hacer un dispose() tanto del mapa como del renderer:


Puedes coger la celda de una capa en determinada posición con la línea:


En este caso, i y j son números enteros, para pasar de una posición de pantalla a un número de celda deberás dividir la posición entre el tamaño de cada celda:


Podrás ver los atributos de una celda con la siguiente línea:


Puedes ver más funciones y usos de estos mapas en esta página.




Notas:


  •   Recuerda hacer el dispose() del mapa y su renderer. No es necesario hacerlo de las capas.
  • Puedes dibujar todo el mapa, como hemos hecho aquí, o dibujar solo una o varias capas que tu decidas.
  • Si ya tienes el batch que usas en el renderer iniciado deberás pararlo (batch.end()), luego dibujar el mapa con el renderer y por último volver a iniciar el batch (batch.begin()). Si no te dará un fallo.
  • Cada tile acepta canal alfa, por lo que puedes crear tiles con transparencias y que se vea el tile de la capa inferior al dibujarse una celda.