Indiana Jones con SCUMMVM

2007/12/16

ScummVMSi alguna vez os han entrado sentimientos nostálgicos y ganas de volver a jugar a las aventuras gráficas de la época dorada de los videojuegos, y en especial a las de LucasArts desarrolladas con el sistema SCUMM (Script Creation Utility for Maniac Mansion), podemos hacerlo con la máquina virtual de SCUMM,un emulador libre programado para ejecutar los juegos creados con este sistema.

Nos la podemos descargar desde su página de descargas eligiendo la plataforma que tengamos (funciona para Windows, Linux, Mac, PSP, Nintendo DS, iPhone, GP32, Symbian, Palm…) o bien, si estamos en un Linux con apt, escribiendo:
sudo apt-get install scummvm

Luego simplemente tenemos que conseguir los archivos de los juegos y cargarlos en el scummvm, para echarlos a andar.

En la imagen tengo corriendo el maravilloso Indiana Jones y las llaves de Atlantis, que en su momento compré original y me terminé varias veces (incluyendo los 3 caminos posibles a seguir en la historia).

¿Cómo ejecutar los juegos?

RTFM! (Read The Fucking Manual!)

Bueno, de todas maneras os incluyo unas pequeñas notas como ayuda rápida ^_^

Existe un fichero llamado ~/.scummvm donde tienes la configuración en este formato:

[scummvm]
music_volume=192
midi_gain=100
speech_volume=192
browser_lastpath=/media/Almacen/scumm/monkey2/
aspect_ratio=false
music_driver=auto
lastselectedgame=atlantis
native_mt32=false
subtitles=true
fullscreen=false
sfx_volume=192
talkspeed=60
speech_mute=false
enable_gs=false
multi_midi=false
versioninfo=0.9.1
savepath=/home/danikaze/.scummvm

[atlantis]
description=Indiana Jones and the Fate of Atlantis
path=/media/Almacen/scumm/Indiana Jones and the fate of atlantis/
platform=linux
gameid=atlantis
language=es
donde cada linea es bastante fácil de comprender, y además todo esto se puede editar graficamente desde la GUI de la máquina virtual.

Otras cosas interesantes que incluye ScummVM y que no he visto en la GUI es el parámetro -g al ejecutarlo en linea de comandos, que permite seleccionar filtros para la salida de video, como por ejemplo interpolación para eliminar los píxeles marcados.

Ejemplo de la pantalla inicial del Indy4 sin antialias con escalado a doble tamaño, escalado a doble tamaño con 2xsai, y con escalado a doble tamaño con 2xsupersai (click para agrandar):

Indiana Jones and the Fate of Atlantis @ scummvm, pantallazo-indiana-jones-and-the-fate-of-atlantis-2xsai.png, pantallazo-indiana-jones-and-the-fate-of-atlantis-super2xsai.png

Como podéis ver, esto mejora un poco la imagen, aunque yo soy bastante retro y me encanta el pixel art, así que prefiero dejarlo a 2x sin filtro ninguno 🙂


Transistores 3D para los 50GHz

2007/12/08

Vía barrapunto vía tecnyo, leo que la empresa japonesa Unisantis, desarrolla un nuevo tipo de transistor con el que se podrían alcanzar frecuencias de 50 GHz, gracias a que reduce la distancia a recorrer por los electrones, genera menos calor, cuesta menos de producir y por supuesto aumenta su velocidad y rendimiento.

Esto es gracias a que este nuevo tipo de transistor, utiliza un diseño en tres dimensiones, en lugar de la clásica estructura vertical que se usa actualmente.

Con este nuevo desarrollo, incluso podríamos volver a los entornos mononúcleos de los procesadores satisfaciendo de sobra las necesidades de los nuevos softwares.

Además, otro tema importante es como se lapidaría la computación cuántica, ya que no habría necesidad de seguir investigando (al menos por ahora) al tener esta nueva tecnología con gran futuro (aunque seguro que se seguirá con el tema cuántico).

De todas maneras, será interesante ver que nos depara el futuro, ya que si os parais a pensar, últimamente, las frecuencias de los procesadores apenas suben (por estas limitaciones físicas que teníamos), y se mejoraban aumentando su capacidad concurrente (aumentando el número de núcleos), lo cual es más difícil de explotar por el sistema operativo y las aplicaciones programadas.


Configurando un servidor de FTP en la Nintendo DS

2007/11/16

Si teneis un cartucho como el Supercard, M3, R4… para la Nintendo DS, y acostumbrais a meter y sacar mucho la tarjeta SD para transferir nuevos archivos (sobre todo los desarrolladores de Homebrew para probar los cambios), es muy recomendable instalar el DSFTP, un servidor de FTP para la Nintendo DS, de manera que puedas acceder a los archivos vía WiFi ^_^

Para ello, descargamos la aplicación (DSFTP 2.4.1), la descomprimimos y copiamos el archivo .nds en la tarjeta SD que irá a la NDS.

Para configurarlo, tendremos que tener un fichero llamado ftp.conf en /data/settings obligatoriamente, que es donde tendremos las preferencias para los usuarios que se conecten.

Tenemos un ejemplo de configuración en la página oficial.

Para usarlo, simplemente entramos como en un FTP cualquiera, poniendo como dirección la IP de nuestra DS (el propio DSFTP nos lo indica en la parte de abajo, de la pantalla superior, como se puede ver en la foto), en el puerto 21 (por defecto).

En linux podemos usar el comando ftp desde consola, o la aplicación gftp para usar un entorno gnome.

DSFTP en acción


Errores en Windows

2007/10/22

Vía GeekNews, veo uno de los mejores errores de Windows:

No error en Windows

Si ya sabía yo, que el que Windows no diese un error, no podía estar bien xD


Crear GIFs con el GIMP

2007/10/13

Desde siempre me ha gustado muchísimo el estilo de dibujo pixel art, del que seguramente hablaré más adelante más veces ^_^. Ayer comencé a hacer un personajillo, y para enseñarlo, pues se me ocurrió hacerle una pequeña animación de un simple parpadeo.

Para hacer la animación pensé en el formato GIF, que se puede crear con el GIMP fácilmente, aunque para los no iniciados puede ser difícil de encontrar cómo hacerlo.

Paso 1: Creando los fotogramas

Lo primero de todo es hacer los dibujos que se usarán en los frames de la animación. Aquí vemos los míos

GIF-capa1 GIF-capa2

Paso 2: Optimizando la imagen

Una vez tenemos todas las capas, hacemos que el GIMP nos optimice la imagen, en cuestión de tamaño y demás, con lo siguiente:

Filtro -> Animación -> Optimizar (para GIF)

Esto nos crea un nuevo documento, habiendo recortado lo necesario de cada capa, para que ocupe lo mínimo, y además las pone en modo composición (esto es, que por ejemplo, en esos fotogramas solo varían los ojos, pues el 1er fotograma está tal cual, pero el 2º solo tiene los ojos, y lo demás es transparente, y a la hora de redibujar, en vez de dibujar todo el frame, se dibuja sólo lo necesario ^_^)

Además, hace una indexación de colores con los mínimos necesarios.

Paso 3: Definiendo la duración de cada fotograma

GIF-capasSi nos fijamos, el documento creado por el paso 2, ha modificado los nombres de las capas, añadiendo (100ms) a las capas y (composed) a algunas. Esto es porque el GIMP pone por defecto una duración de 1/10 de segundo para cada frame, y el composed es para lo que hemos explicado en el paso 2.

Pues, aunque pueda parecer un parche cutre ( xD ), la duración de cada fotograma, se pone en el nombre de la capa con ese formato. Yo en este ejemplo le he puesto 2 segundos a la de los ojos abiertos, y 100 ms para los ojos cerrados, de manera que mi bicho parpadeará cada 2 segundos, durante 100 ms.

Paso 4: Guardando la imagen

Ya solo nos queda darle a Archivo -> Guardar como… y escribir el nombre del archivo con extensión .gif

Cuando nos pregunte como debe manejar las capas, marcamos Guardar como animación, de manera que cada capa sea un frame.

Paso 5: Disfrutando del resultado ^_^

Ya podemos ver el resultado:

Animación GIF creada con el GIMP


Doble/Triple buffering y Page flipping

2007/10/10

Hoy toca hablar de los métodos de buffering al pintar en pantalla en Allegro (Bueno, en cualquier programa, pero implementado en Allegro xD)

Cuando se hace un juego, siempre hay que ir pintando los gráficos en pantalla, y si se hace sin ningún tipo de buffer, se pinta a la vez que el monitor se refresca, provocando los molestos efectos que hacen que parece que la pantalla parpadea. Esto es, en resumidas cuentas, porque cuando estamos pintando el frame N, también hay restos del N-1, y el monitor pinta partes de cada uno.

Para evitar esto, se usa un buffer donde se pinta todo lo necesario del frame y después se vuelca a la memoria de video para que el monitor lo actualice. Hay varias técnicas.

Page Flipping:

Consiste en tener el doble de memoria (dos páginas de memoria) de lo que la pantalla usa. Es decir, si tenemos una resolución de 800×600 a 16bpp, se usa casi 1 Mbyte de memoria de video. Pues en este caso usaríamos casi 2, para que mientras se dibuja en una página, se muestra la otra.

Por ejemplo, inicializamos el sistema gráfico de la siguiente manera:

BITMAP *pantalla_buffer[2];
int pantalla_actual;
BITMAP *pantalla;

pantalla_buffer[0] = create_video_bitmap(SCREEN_W, SCREEN_H);
pantalla_buffer[1] = create_video_bitmap(SCREEN_W, SCREEN_H);
pantalla_actual = 0;
pantalla = pantalla_buffer[pantalla_actual];
Con esto estamos reservando dos páginas (pantalla_buffer) e indicando que la actual es la 0. Además tenemos la variable pantalla, que será a la que nos refiramos siempre por comodidad, para no tener que estar poniendo pantalla_buffer[pantalla_actual] siempre, y además la haremos accesible al resto de paquetes.

Y para actualizar la pantalla, se llamaría en cada proceso de renderizado (en cada frame) a:

show_video_bitmap(pantalla);
pantalla_actual = (pantalla_actual+1)%2;
pantalla = pantalla_buffer[pantalla_actual];

Con la primera linea lo que hacemos es pedir que se pinte el bitmap pantalla (la página donde hemos pintado). Con las dos siguientes lineas actualizamos la página actual, para que en el siguiente frame, al pintar sobre el bitmap pantalla, pintemos en la otra página a la que se está mostrando.

En algunos sistemas hay que especificar la memoria de video concreta que hay que reservar, así que, antes de nada habría que poner:


#ifdef ALLEGRO_VRAM_SINGLE_SURFACE
error_init = set_gfx_mode(GFX_AUTODETECT_WINDOWED, w, h, w*2, h);
#else
error_init = set_gfx_mode(GFX_AUTODETECT_WINDOWED, w, h, 0, 0);
#endif

Doble Buffer:

Es una técnica bastante parecida, pero en vez de tener dos páginas de memoria de video, tenemos un buffer de memoria principal, que volcaremos sobre la pantalla en cada frame.

Para inicializar el sistema gráfico lo haríamos con:


BITMAP *pantalla = create_bitmap(SCREEN_W, SCREEN_H);

En este caso la variable pantalla actuaría de buffer. Y para actualizar la pantalla copiaríamos el buffer en la memoria de video con:


blit(pantalla, screen, 0, 0, 0, 0, SCREEN_W, SCREEN_H);

Triple Buffer:

Aunque por su nombre parezca que es como el doble buffer, la verdad es que su implementación se parece más a la del page flipping, pero con tres páginas.

Además, esta técnica no la soportan todos los sistemas, y por ello se debería de dar opcional a las otras técnicas, por si no funciona. Para comprobar si se puede o no, se usa:


gfx_capabilities & GFX_CAN_TRIPLE_BUFFER

Si el flag comprobado no está activado, puede intentar activarse de todas maneras con la funcion enable_triple_buffer()

Una vez se haya comprobado que se puede, se inicializa igual que el page_flipping, pero en vez de ser un array de 2 páginas, es de 3:


BITMAP *pantalla_buffer[3];
int pantalla_actual;
BITMAP *pantalla;

pantalla_buffer[0] = create_video_bitmap(SCREEN_W, SCREEN_H);
pantalla_buffer[1] = create_video_bitmap(SCREEN_W, SCREEN_H);
pantalla_buffer[2] = create_video_bitmap(SCREEN_W, SCREEN_H);
pantalla_actual = 0;
pantalla = pantalla_buffer[pantalla_actual];
Y se actualiza cada frame de la siguiente manera:


while(poll_scroll());
request_video_bitmap(pantalla);
pantalla_actual = (pantalla_actual+1)%3
pantalla = pantalla_buffer[pantalla_actual];

Lo que hacemos con la primera linea es comprobar el estado del hardware para ver si está listo o no. Con la segunda pide una página de la memoria de video, pero no espera para un repintado. Y con las dos últimas lineas, se actualiza la página actual, de igual manera que en el page flipping.

Ya que disponemos del código para cada tipo de renderizado, y no es muy complicado, lo suyo sería encapsularlo en funciones y hacer posible que el usuario seleccionase cual quiere, por si alguna le va mejor que otras en su sistema (por ejemplo, en mis pruebas, con page_flipping me va muy rápido en Linux, pero lento en Windows…)


Neo Geo en Linux

2007/10/02

Se me ha antojado así por las buenas, volver a jugar al maravilloso Metal Slug mientras sale o no para la Nintendo DS…

gngeo logo

Así que manos a la obra…

Empezamos bajando el emulador gngeo de aquí. Lo descomprimimos e instalamos:

./configure
make
sudo make install

Ya lo tenemos instalado y podemos ejecutar las roms con el comando gngeo nombre_rom. Pero también podemos instalar una interfaz gráfica.Lo mismo, bajamos desde aquí, y la descomprimimos.

XgnGeo

Esta vez, ejecutamos un script de python, que nos lo configurará todo solito ^_^:
sudo python setup.py install

Ya tenemos la interfaz instalada, pero tenemos que configurar donde están las BIOS y el archivo de drivers. Simplemente bájalos de emulatronia y arrancad el xgngeo, donde os saldrá una ventana en la que podeis introducir el directorio donde teneis las BIOS y las Roms.

[Descargar BIOS] [Descargar archivo de drivers]

Configuración del xgngeo

A jugar!