Entradas con el tag ‘Java’

Galaga Paso 02: Velocidad constante

martes 26 de abril de 2016

Creación de juegos desde cero: C# y SFML

Con la implementación realizada en el Paso01, ya tenemos un juego muy simple que permite mover a nuestro jugador (una bola azul) por la pantalla. Toda la magia de este movimiento reside en el bucle principal del juego, un bucle infinito (al menos hasta que la ventana se cierre) que se encarga de obtener las entradas, calcular las nuevas posiciones y redibujar la pelota en su nueva ubicación.

El problema surge con la velocidad de la pelota. Independientemente de que podamos hacer que avance más o menos pixeles en cada actualización, lo que está claro es que el número de veces que se ejecutará el bucle en un determinado tiempo va a ser muy variable.

(más…)

Galaga. Paso 00: Herramientas

jueves 10 de marzo de 2016

Creación de juegos desde cero: C# y SFML

Antes de empezar a entrar en materia hay que definir cuáles van a ser las herramientas con las que vamos a trabajar y como instalarlas. Nuestras herramientas fundamentales de trabajo van a ser el Visual Studio en caso de trabajar con C# o NetBeans en caso de usar Java y, por otra parte, git.

Es posible trabajar tanto en Windows como en Linux como en MacOS si bien en estos dos últimos lo más sencillo es trabajar con el desarrollo en Java [1].

(más…)

Creación de juegos desde cero con SFML y C#

sábado 27 de febrero de 2016

Creación de juegos desde cero: C# y SFML

 

Sin duda, una de las facetas que más interés suscita a los estudiantes que empiezan en el mundo de la programación, es la creación de videojuegos. Desgraciadamente (o afortunadamente nunca lo tendré claro del todo :)),  el desarrollo de videojuegos es una de las especialidades más complejas de la programación,  no solamente por la necesidad de conocimientos de computación sino también de matemáticas, física, diseño gráfico, etc.

Durante estos últimos meses ha surgido la necesidad de crear un curso que permitiera a los alumnos con conocimientos medios de programación introducirse en este mundo.  En estos casos, la solución más  habitual suele ser la de recurrir al uso de algún motor como AndEngine o de más alto nivel como Unity. Sin embargo, la idea en este caso era hacer algo diferente:  el objetivo no tendría que ser únicamente la creación de un juego, si no utilizar el desarrollo del mismo como vehículo para el aprendizaje de técnicas y conceptos de programación.

(más…)

Error de ejecución JOGL con NetBeans

viernes 17 de enero de 2014

 

jogljava

Una de las mejores maneras, sino la mejor, de poder utilizar OpenGL en Java es el uso de la librería JOGL. En la sencillez de su planteamiento radica su potencia, ya que se podría decir lo único que hace es mapear la gran mayoría de las funciones nativas de OpenGL de manera que puedan ser utilizadas de la misma manera que en C o C++ pero en Java. Por ejemplo, lo que en C podría ser el dibujo de una línea:

glBegin(GL.GL_LINES);
    glVertex3f(1.0f,0.0f,0.0f);
    glVertex3f(4.0f,1.0f,0.0f);
glEnd();

en Java quedaría como:

GL gl = drawable.getGL();

gl.glBegin(GL.GL_LINES);
    gl.glVertex3f(1.0f,0.0f,0.0f);
    gl.glVertex3f(4.0f,1.0f,0.0f);
gl.glEnd();

Desde entornos como NetBeans podemos acceder a plugin que además de proporcionar la librería, instalan asistentes, ejemplos e incluso componentes preparados para que se pueda dibujar sobre ellos directamente como es GLCanvas. Generalmente su uso es sencillo (independientemente de la complejidad de OpenGL), pero en ocasiones surgen problemas de ejecución debidos a la no localización de la librería nativa de OpenGL con la que se hace el mapeo. En estos casos el error que suele aparecer es similar a:

java.lang.UnsatisfiedLinkError: no gluegen-rt in java.library.path

en el que se nos indica que no se ha podido enlazar con la librería nativa (es decir, la de cada SO) correspondiente. La solución suele venir por la indicación de manera explícita a la máquina virtual de donde está ubicada esa librería nativa. En ese caso lo primero es localizar su ubicación. Si estamos trabajamos con NetBeans y hemos instalado el plugin de JOGL, las liberias se suelen encontrar en una carpeta oculta dentro de la carpeta del usuario. Por ejemplo en Linux en /home/usuario/.netbeans/7.0 y allí distribuidas por librería y plataforma. En este caso (Linux sobre amd64) el parámetro necesario para la ejecución correcta sería

-Djava.library.path=/home/usuario/.netbeans/7.0/gluegen-runtime/gluegen-rt.jar-natives-linux-amd64

Este parámetro puede ser añadido desde Run/Set Project Configuration/Customize y en esa ventana dentro de las opción VM Options. Aún así es probable que siga apareciendo el error :(. Si es así lo más probable sea que en el fichero de propiedades del proyecto la plataforma no este bien configurada (cosa muy habitual si trabajamos en plataformas distintas). Para ello no hay más que editar nbproject/private/config.properties y cambiar la propiedad natives.platform por aquella que en esos momentos estemos utilizando.

+info: JOGL
+info: OpenGL pack for NetBeans 

 

Como hacer una calculadora simple en Android (y II)

domingo 24 de junio de 2012

En la entrada anterior estuvimos diseñando la layout de nuestra calculadora. Ahora toca hacer que funcione 🙂

Código

Aparte del algoritmo básico de la calculadora, lo principal es darle funcionalidad a los distintos botones. Para ello vamos a hacer uso de los listeners.

Un listener (o “escuchador” en español) es un objeto de una clase que implementa un interfaz que “le obliga” a tener una función que se ejecutará en el caso de que se produzca un evento determinado. Dicho así queda confuso, así que lo mejor es implementarlo para nuestra calculadora.

Lo primero será crear para cada uno de los recursos de la calculadora una variable de control, por ejemplo:

private EditText _edit;
private Button _b1;

Lo siguiente es asignar a cada una de estas variables, los objetos de cada uno de los recursos que ya han sido creados por la función setContentView(R.layout.main);. Para ello utilizamos la función miembro de la clase Activity findViewById, que busca un recurso por su identificador. En nuestro caso, y siguiendo con los dos recursos anteriores;

_edit = (EditText)findViewById(R.id.editTextos);
_b0 = (Button)findViewById(R.id.button0);

Y por fin, el listener. En nuestro caso tenemos 16 botones, pero 10 de ellos tiene un funcionalidad similar: queremos que al pulsar, aparezca en la casilla de edición el número que aparece como texto en el botón. Es por esto, que en vez de hacer 10 listeners para cada uno de los botones, optamos por la creación de un único listener común a todos ellos:

View.OnClickListener lsBoton = new View.OnClickListener() {
     @Override
     public void onClick(View arg0) {
         _edit.setText(_edit.getText()+((Button)arg0).getText().toString());
     }
};

Analicémoslo:

View.OnClickListener, es un interfaz que han de implementar aquellas clases que vayan a crear objetos listeners. Para no crear la clase ya que solo va a tener un uso mu concreto, hacemos un new del interfaz, pero definiendo la función que el listener nos “obliga” a tener, en este caso OnClick(). Dicha función recibe como argumento la View del recurso sobre el que se pincha (arg0), así que son un casting  podemos obtener de manera sencilla el valor del rótulo del botón.

Sólo nos queda asociar este listener a nuestro botones:

_b1.setOnClickListener(lsBoton);

Sólo nos queda repitir este paso para todos los botones numéricos, repitir un proceso similar con los botones de las operaciones y aplicar la lógica de la calculadora.

Extra

Existe otras dos  posibilidades para asignar el listener al botón.

La primera es definirlo desde el propio layout. Simplemente se le añade la propiedad android:onClick, dándole como valor la función a la que se llamará en el caso de producirse el evento Click. Por ejemplo:

android:onClick="funcion"

La segunda es hacer que la propia Activity implemente el interfaz View.OnClickListener, con lo cual será necesario definir la función onClick en su interior, pero podríamos asignar el objeto this como valor a las funciones de asignación de listeners

_b1.setOnClickListener(this);
class Calculadora extends Activity implments View.OnClickListener {
     ...
     @Override
     public void onClick(View v) {
           ...
     }
     ...
}

Puedes acceder al código de la calculadora en github
+ Info en | Android developers

 

Como hacer una calculadora simple en Android (I)

jueves 21 de junio de 2012

En estas dos entradas vamos a crear una primera aplicación en Android, consistente en una calculadora que únicamente procese números enteros. La idea es manejar el TableLayout y los listeners.

Creando el proyecto

Para empezar desde Eclipse, seleccionamos File/New/Android Project… Le damos como nombre de proyecto Calculadora, elegimos una de las plataformas que tenemos instaladas y en la última ventana elegimos el nombre del paquete al que pertenece la aplicación. Este nombre es importante, ya que será el nombre completo con el que la aplicación será conocida, y podría entrar en conflicto con otras aplicaciones si el nombre se repitiera. En este caso ponemos: edu.uhuru.moviles.android.Calculadora

Creando el layout

Vamos al fichero main.xml que está dentro de la carpeta res. En ese fichero se define el diseño de la actividad principal (y única en nuestro caso). Desde el diseñador gráfico incluímos un TableLayout.

Nota: en muchas ocasiones puede ser interesante insertar los layouts en la ventana de Outline, que muestra el árbol de recursos de la Activity

Los layouts son los elementos invisibles pensando para controlar la distribución, posición y dimensiones de los controles que van en su interior. Hay varios disponibles, pero en este nos decidimos por un TableLayout, que organiza a sus hijos en forma de tabla. Se compone de elementos TableRow (filas). Cada fila puede contener cero o mas celdas. El ancho de la columna viene normalmente definido por el ancho de la celda más ancha, aunque siempre es posible aplicar algún atributo para jugar con el tamaño de las columnas.

Por defecto se nos crean 4 filas, así que añadimos una más simplemente arrastrando desde la paleta de controles una TableRow. Una vez añadida, procedemos a ir incorporando a cada fila los distintos recursos:

  1. Fila 1: 1 EditText
  2. Fila 2: 4 Buttons
  3. Fila 3: 4 Buttons
  4. Fila 4: 4 Buttons
  5. Fila 5: 4 Buttons

El siguiente problema es como hacer “crecer” el EditText para que ocupe las 4 columnas. Para ello utilizamos la propiedad  layout_span=”4″, que al igual que en HTML, nos expande la columna para que ocupe 4 columnas. Para colocar estas propiedades es casi más recomendable (y rápido) dejar el editor visual y trabajar directamente sobre el HTML:

<EditText  android:id="@+id/editTextos" 
            android:layout_width="wrap_content" 
            android:layout_height="wrap_content" 
            android:layout_span="4" />

A continuación hay que ajustar los botones, para que se repartan de manera equitativa por todo el ancho de la actividad. Para ello utilizamos la propiedad android:stretchColumns=”*”, que indica que columnas (en nuestro caso todas, *) pueden expandirse para absorver el espacio libre dejado por las demás columnas a la derecha de la pantalla. De esta forma, los botones aparecerán ya compensados. O al menos aparentemente. El problema vendría si alguno de los botones tuviera más de un caracter (por ejemplo si pusiéramos  +/- , MR …). En ese caso, todos los botones de la columna de ese botón aumentaría su ancho. El problema se soluciona de una manera simple mediante  el uso de la propiedad  android:layout_weight=”1″.

Esta propiedad indica el peso relativo que ha de tener ese recursos con sus hermanos. Por ejemplo, si a 3 de los botones les pusieramos android:layout_weight=”1″ y al cuarto android:layout_weight=”2″, este último sería el doble de ancho que el primero. Como en nuestro caso queremos tener todos del mismo ancho indicamos android:layout_weight=”1″.

Por otra parte, necesitamos indicar al renderizador que el ancho de los botones no ha de ir en función de su tamaño “natural” (cuanto más texto tenga dentro, más grande). Por ello cambiaremos el ancho de wrap_content a 0dip. Juntando cada una de estas dos opciones en uno de los botones (por ejemplo el 7) quedaría:

<Button android:id="@+id/button7"
         android:layout_width="0dip"
         android:layout_height="wrap_content"
         android:text="7"
         android:layout_weight="1" />

Por último, para darle los últimos detalles estéticos, vamos a justificar el texto del EditText a la derecha, a no permitir la edición y a ocultar el cursor. Para ello, modificamos el EditText añadiendo:

<EditText  android:id="@+id/editTextos" 
            android:layout_width="wrap_content" 
            android:layout_height="wrap_content" 
            android:layout_span="4" 
            android:editable="false"
            android:gravity="right"
            android:cursorVisible="false" />

 

Programar dispositivos Android: Herramientas e instalación.

jueves 24 de mayo de 2012

Lo primero es descargarse e instalar las herramientas necesarias Herramientas:

  1. JDK 6: Se puede encontrar aquí para los 3 SO principales.
  2. Eclipse. Va a ser nuestro entorno de desarrollo (IDE). Desde el sitio de descargas es posible bajar varias versiones. En principio con la Eclipse Classis es más que suficiente.
  3. SDK Android. Se puede descargar de aquí y posteriormente descomprímirlo en un carpeta. En este paquete realmente sólo se encuentran las herramientas básicas que proporciona el SDK. Para empezar a trabajar es necesario descargarse al menos una plataforma de Android y las herramientas de plataforma.
  4. Instalar ADT (o lo que es lo mismo Android Development Tools). ADT es un plugin para Eclipse que ayuda al desarrollo de aplicaciones para Android. Para ello dentro de Eclipse, en la opción Working with que se encuentra en Help / Install new software… se debe añadir la URL: https://dl-ssl.google.com/android/eclipse/. Una vez añadida se conectará y mostrará en la parte inferior la entrada Developer Tools. Hay que seleccionarla y darle a siguiente. Este último paso puede dar problemas de dependencias por varias razones: a)  si estás con una versión relativamente antigua de Eclipse (Galileo – 3.5). Para evitar este problema añade la url http://download.eclipse.org/releases/galileo en Available Software Sites dentro del menú Window / Preferences. b) Si has instalado Eclipse mediante los paquetes que te ofrece tu distribución de Linux. En ese caso has de incluir en Windows / Preferences / Install/Update / Available Software Repositories, el repositorio de tu versión de Eclipse. Por ejemplo, https://download.eclipse.org/releases/indigo
  5. El siguiente paso es la instalación de las plataformas. Para ello lo primero es indicarle a Eclipse donde se encuentra el SDK descargado en el paso 3, lo que se hará desde Window / Preferences / Android. Una vez indicada la ruta, dentro en Window /SDK and AVD Manager encontraremos las opciones para cargar las plataformas. En available packages se encuentran los paquetes disponibles para la instalación, mientras que en Virtual Devices y en installed packages están emuladores y plataformas instalados respectivamente. Una vez instaladas las plataformas, instalar un emulador es muy sencillo.

Te recomiendo que utilices la última versión de Eclipse (en el momento de escribir estas líneas es Indigo, la 3.7) para evitar problemas. Si desde tu distribución Linux no tienes aún acceso a ella, puedes seguir este pequeño tutorial, que te ayudará a instalarla. Fácil ¿verdad?. Ahora ya está todo preparado para poder empezar a programar.

Empezando a programar aplicaciones para dispositivos móviles

domingo 26 de diciembre de 2010

“¡Por fin! Ya tenemos una idea para crear alguna aplicación para un móvil.  ¿Y ahora qué?” Eso mismo nos preguntamos hace unos meses, cuando empezamos a pensar en desarrollar aplicaciones para móviles: ¿por dónde empezamos?.

Tal vez la primera pregunta a hacerse sea para qué dispositivo trabajar. No cabe duda que el mercado está cada vez más lleno de opciones y cada una con un sistema operativo, unas herramientas de desarrollo y una serie de recursos disponibles. Pero no sólo eso. Además de la parte técnica hay una importantísima parte comercial, en la que hay que contestar a preguntas como ¿a qué tipo de personas va dirigido el software que  desarrollamos? ¿qué dispositivo(s) es mayoritario en ese sector? ¿cómo funciona el canal de distribución (AppStore, OVI, Android Market…)?, etc. En esta serie de posts vamos a olvidar esta parte comercial y vamos a centrarnos en la parte técnica. Es decir, una vez elegido el sistema de destino ¿cómo se programa para él?.

Y para empezar lo primero es centrarnos en intentar hacer un resumen de lo que hoy en día podemos encontrar en la calle, especificando, aunque sea de manera muy superficial, que tipo de lenguajes y con que herramientas es posible programar cada una de ellas. ¿Preparados? Empezamos 🙂

Hoy por hoy tenemos 7 Sistemas Operativos para móviles que copan el mercado:

  • iOS (iPhone, iPad)
  • Windows 7 Phone (HTC, Samsung, LG, Sony Ericsson, ..)
  • Android (HTC, Motorola, Samsung, Nexus…)
  • RIM (BlackBerry)
  • Symbian (Nokia)
  • MeeGo (Nokia, algunos coches, )
  • WebOS (Palm, HP)

La programación sobre iOS y sobre W7P va aparte y merece una atención especial (incluso porque las herramientas de desarrollo sólo existen en sus “hermanos mayores” MacOS y Windows). El primero permite el desarrollo con Objective-C, sobre Cocoa, con XCode como herramienta de desarrollo principal. El segundo parece que se centrará en la plataforma .Net con lenguajes como C# o en Silverlight, aquel framework que creó Microsoft para hacer la competencia en el desarrollo de aplicaciones web enriquecidas a Flash y a Ajax y que, visto lo visto, parece que va a terminar centrándose en ser el sistema de desarrollo de aplicaciones para Windows Phone. Su IDE de trabajo es Visual Studio y Expression Blend.

WebOS es un sistema relativamente reciente. Está desarrollado por la Palm, Inc que ahora pertenece a HP y basado en Linux (como Android y MeeGO). Para programar sobre él se requiere básicamente conocimientos de creación de paginas web: HTML, Javascript, CSS, JSON … y como entorno de programación se dispone de Ares, un IDE integrado en un navegador web, con un editor visual bastante útil.

De MeeGO podríamos decir que es la descendencia de Linux para móviles ya que, a diferencia de Android y WebOS, Meego esta apoyado por la Linux Foundation. Un aplicación para MeeGo es como una aplicación normal escrita para KDE, es decir con las librerías Qt, sólo que con las características especiales que supone programar para dispositivos con recursos limitados.

Por su parte Symbian desarrolla en C++ y Java (aunque de esta opción hablaremos más adelante), normalmente sobre Eclipse. Aun así, existen otras opciones como Origo IDE, que permite la creación de aplicaciones de manera rápida y visual con un lenguaje de script propio o lenguajes más comunes como python o ruby,

Por último, programar en el resto (BlackBerry, Android o incluso en Symbian) puede tener similitudes que hagan que nuestros programas “puedan” ser ejecutados en un sistema u otro. ¿por qué? por el uso de Java , en concreto de J2ME, común, en principio, a todas las plataformas. Será sobre estos últimos sistemas sobre los que hablaremos en las próximas entradas.

Más información | Visual Studio, Eclipse, OrigoIDE, Ares, Silverlight