Instalación del entorno (nuevo)

Buenas noches, voy a aprovechar que tengo un rato libre para reescribir la entrada en la que describía cómo se instala el entorno de programación para utiliza LibWiiEsp. Voy a intentar que quede lo más resumido posible.

Recuerdo que este tutorial de instalación del entorno es para sistemas GNU/Linux, que es el que yo utilizo, pero cambiando un par de detalles se puede instalar también en sistemas Windows.

Empezamos:

Cambios menores

Buenas a tod@s un día más. Hoy no traigo la descripción de ninguna clase, únicamente vengo a comentar algunas actualizaciones menores que he ido haciendo a algunas clases.

• Para empezar, clase Screen ahora puede dibujar un cuadro de textura invertido respecto al eje vertical a partir de una textura que no se modifica; por lo tanto, a la hora de que un personaje tenga, por ejemplo, una animación de movimiento, ésta se podrá aplicar para ambas direcciones sin necesidad de tener en memoria dos imágenes distintas. Además, este cambio es muy eficiente, ya que sólo realiza un par de operaciones extra.
• He reorganizado la estructura de directorios del proyecto, de tal manera que ahora, en el directorio raíz se encuentra el Makefile (convenientemente adaptado al cambio), la carpeta source (donde están los fuentes), la carpeta xml (donde están los archivos de datos), la carpeta media (donde he incluido los recursos que estoy utilizando para hacer las pruebas), y la carpeta lib (dentro de la cual se encuentran ahora las bibliotecas externas del proyecto).
• Estoy trabajando (y casi tengo terminada) en una clase abstracta para los actores del juego (explicación sobre qué es un actor más abajo)
• En los próximos días, comenzaré a preparar la flamante carpeta doc, donde irá la documentación que he ido redactando hasta ahora (generada, por supuesto, con Doxygen), y la que queda (que no es poca, precisamente).
• Al haber añadido los recursos media, ahora basta con tener el entorno de desarrollo preparado, hacer el checkout del proyecto y compilar para poder ver los ejemplos de código.
• Voy a subir a la forja un archivo tar.gz con la libogc 1.8.4, ya que sólo se encuentran disponibles los fuentes ahora (y dentro de poco puede que ni eso). Este archivo estará preparado para únicamente ser descomprimido dentro de la carpeta devkitpro, e incluirá la libfat 1.0.7. (ver entrada sobre la instalación del entorno). También voy a reescribir próximamente esa entrada para adaptarlo a los cambios, e incluiré el manual en la documentación.

Y ahora, voy a explicar eso del actor. La biblioteca que tengo en desarrollo va a permitir trabajar a 2 niveles. El más bajo trabajaría de una forma parecida a como lo hace SDL, es decir, proporciona cierta abstracción de los componentes media del programa y de los controles (en este caso, los mandos), y nos permite trabajar con ellos. Además, se cuenta con el soporte de idiomas, la galería de recursos, la cabecera de utilidades, las animaciones, las figuras de colisión y un logger. En este punto es en el que está la biblioteca, es decir, sobre lo que hay ya se pueden crear juegos completos para Nintendo Wii.

El nivel más alto de la biblioteca, que es el que acabo de comenzar con la clase Actor, pretende proporcionar una serie de clases (casi todas abstractas) para trabajar de una forma más cómoda con la consola. Las plantillas serán Actor (cualquier objeto móvil que haya en el juego), Escenario (tendrá un fondo de pantalla y un conjunto de actores, además de gestión del scroll y de los límites del escenario), Escena (las partes del juego como tal: menú, presentación, el propio juego, créditos, etc.), y Juego (que gestionara las distintas escenas, y será la clase principal de un proyecto). Los nombres no son definitivos, y estas clases abstractas serán muy genéricas, de tal manera que se puedan utilizar en prácticamente cualquier juego.

Por supuesto, en su momento lo detallaré todo con el mismo nivel que al resto de las clases, pero ahora mismo espero que más o menos quede claro.

A partir de la siguiente entrada en el blog continuaré con la documentación, pero como ya avisé, voy a ir intercalando documentación y desarrollo. De momento, continúo con la clase Actor.

Más noticias pronto. Cambio y corto.

La clase Imagen

¡Hola a tod@s! De momento, soy el más sorprendido de todos, porque hoy es el quinto día consecutivo que os traigo novedades.

Por cierto, el Planet del Concurso de Software Libre no recoge mis entradas en estos momentos, así que si estás leyendo esto, gracias por preocuparte por el avance de la biblioteca y demás detalles del proyecto.

Sin más preámbulos, paso a describir el siguiente peso pesado que forma parte de este tinglado. Hoy aprenderemos a cargar nuestras propias texturas desde un archivo situado en la tarjeta SD (textura, tarjeta… si tienes alguna duda llegado a este punto, consulta las entradas anteriores, está todo bien explicado).

Os presento la clase Imagen.

La clase Sdcard

Buenas de nuevo, hoy estoy algo más animado, y es que el pequeño monstruito que es mi PC regresó a la vida tras un par de horas de informática forense anoche.

Ya sabemos gestionar la entrada mediante los mandos de la consola, y además, crear y dibujar figuras geométricas y texturas, así que lo suyo es que, seguidamente, aprendamos a cargar nuestras propias texturas. Pero claro, para poder cargar lo que sea desde un archivo necesitamos poder acceder al soporte en el que se encuentra ese archivo; en el caso de nuestra blanquita de Nintendo, todos los recursos los tendremos en la tarjeta SD.

Y de eso mismo se encarga de gestionar esta clase que os presento hoy. Es relativamente sencilla, y nos proporciona acceso a este medio de almacenamiento masivo, de tal forma que podamos leer (y escribir) en él.

Entorno de desarrollo

Empezamos a entrar en materia, hoy voy a detallar el entorno de programación que estoy utilizando para desarrollar Wii Pang, y los pasos necesarios para instalarlo y poder compilar y ejecutar el código que se encuentra en la Forja.

Como sistema operativo se puede emplear tanto Windows como Linux; yo utilizo una distribución Ubuntu 9.10, y voy a redactar este artículo basándome en ella, pero es aplicable a cualquier otra distribución.

No es necesario que tengamos instalado ningún compilador de C++, ya que en DevKitPro vienen incluidas todas las herramientas necesarias para poder trabajar en código Wii.

En primer lugar, procedemos a preparar la base de la compilación de este lenguaje para Nintendo Wii. Esta base consiste en el conjunto de herramientas DevKitPro (click en el nombre para acceder a SourceForge). Necesitamos los siguientes paquetes:

devkitPPC / previous / devkitPPC release 21 / devkitPPC_r21-i686-linux.tar.bz2
libogc / previous / libogc-1.8.4.tar.bz2
libfat / libfat-ogc-1.0.7.tar.bz2

Detalle a comentar es que no utilizo las últimas releases de DevKitPPC ni de libogc, debido a que me he familiarizado con las versiones que sugiero (además de que proporcionan la potencia suficiente, y de sobra, para el desarrollo que pretendo), y, por eso, Wii Pang se va a basar en ellas.

Por otro lado, necesitamos la biblioteca gráfica screenlib, creada por Hermes (entuwii.net y elotrolado.net), pero que no es necesario descargar, ya que la he incluido como biblioteca local.

Una vez descargados todos los paquetes, creamos (con la orden sudo) la siguiente estructura de directorios:

/opt/devkitpro
/opt/devkitpro/devkitPPC
/opt/devkitpro/libogc


Siguiente paso, asignar permisos suficientes para que cualquier usuario del sistema pueda utilizar dichos directorios:

sudo chmod 777 /opt/devkitpro

Ahora, nos vamos al directorio /opt/devkitpro, y desempaquetamos el DevKitPpc con la siguiente orden:

tar -xvjf /ruta/al/archivo/devkitPPC_r21-i686-linux.tar.bz2

Ya queda menos… Vamos a instalar ahora la libogc y la libfat, para lo cual, nos vamos al directorio /opt/devkitpro/libogc, y desempaquetamos la biblioteca con las ordenes:

tar -xvjf /ruta/al/archivo/libogc-1.8.4.tar.bz2
tar -xvjf /ruta/al/archivo/libfat-ogc-1.0.7.tar.bz2

El último paso para poder compilar el proyecto es establecer variables de entorno en las que el sistema sepa dónde encontrar devkitppc y devkitpro. Para ello, basta con añadir a nuestro archivo ~/.bashrc las siguientes líneas al final:

export DEVKITPRO=/opt/devkitpro
export DEVKITPPC=$DEVKITPRO/devkitPPC

Y con esto y un bizcocho, tenemos las herramientas necesarias para compilar la versión de los repositorios de Wii Pang.

Pero eso no es todo, amigos. Con lo explicado hasta aquí, podemos generar un archivo ejecutable con extensión dol, que debemos colocar en la tarjeta SD, y ejecutarlo en la Wii por el método preferido por cada uno (yo recomiendo HomeBrew Channel).

Ciertamente, es una tarea tediosa (cuanto menos) el pasar el .dol a la SD, insertar la SD en la consola, ejecutar, etc. para probar cada compilación. Podemos librarnos de este contratiempo si tenemos la Wii conectada a la misma LAN en la que esté nuestro puesto de desarrollo. Basta con hacer uso de la herramienta Wiiload, para cargar directamente el boot.dol generado en el HomeBrew Channel. (Más información sobre esta maravillosa herramienta haciendo click en el nombre)

Y ahora sí, doy por concluida la entrada, espero que esté más o menos claro cómo preparar un entorno de desarrollo para Nintendo Wii. Puede que en el futuro cree un script para dejarlo todo listo sin comerse tanto la cabeza, pero de momento, hay que hacerlo de modo manual.

En la siguiente entrada, hablaré de la estructura de directorios de un proyecto C++ para Nintendo Wii, y del Makefile necesario para compilarlo.

¡Hasta la próxima!