Seguramente, muchos de los que habéis compilado y jugado al Duke Nukem 3D en GNU/Linux habréis bajado el código fuente desde icculus.org; y ahora estaréis pensando, "vale, puedo jugar al Duke, pero yo quiero jugarlo con gráficos buenos, con texturas de alta resolución y todo eso". Pues bien, para eso tenemos el puerto JFDuke (también llamado Jonof), que además de proporcionarnos aceleración gráfica soporta modelos en 3D y texturas de alta resolución (o sea, el Hight Resolution Pack o HRP); y lo mejor de todo, ¡¡HAY VERSIÓN LINUXERA!!

Sí, es una genial noticia, pero no la única; ya que en este caso... ¡No hay que compilar nada! De hecho sólo tendremos que bajarnos los binarios —es decir, los archivos ejecutables correspondientes— y listo.

Requisitos:

Aunque no tengamos que compilar, sí necesitaremos bajarnos y configurar las librerías con las que han sido compilados los ejecutables, y son las siguientes (probablemente, algunas o incluso la mayoría de ellas ya vendrán con tu distribución):

• libSDL 1.2 ó superior.
• libgtk-x11 2.0 ó superior.
• libPango 1.0 ó superior.
• libglib 2.0 ó superior.
• libSDL_mixer 1.2 ó superior.
• libcairo.
• libfreetype.
• libvorbis.
• libogg.
• libsmpeg.
• libICE.
• ncurses.

Una vez que tengamos instaladas las anteriores librerías, ya podremos ejecutar el binario sin problema alguno.

Configuración e instalación

Bueno, más sencillo imposible:

Empezaremos creando una carpeta en nuestro directorio personal, o donde queramos tener instalado el juego; por ejemplo, en /home/pepito/juegos/jfduke.

A continuación nos descargamos los binarios del JFBuild y JFDuke. Sin embargo, no hace falta abrir el Firefox para bajárselos. Simplemente hacemos un "wget" a la siguiente dirección:
http://www.mephisto.ma.cx/mephisto/jfduke3d-20050531-bin.tar.bz2

Lo cual nos descargará el archivo jfduke3d-20050531-bin.tar.bz2 del sitio de Internet http://www.mephisto.ma.cx/mephisto, y lo copiará en la carpeta en la cual estemos situados. De todos modos, estos binarios ahora también podéis descargarlos de Arcades 3D; o bien conseguir estos otros, los de la última versión del JFDuke3D —en el momento de escribir esto, la de octubre de 2005—, compilados por un servidor...

A continuación descomprimimos el fichero que hemos bajado:

Y ya tenemos los ejecutables... Ahora necesitaremos los siguientes archivos de la versión atómica del Duke Nukem 3D:

• duke3d.grp
• USER.CON
• GAME.CON
• DEFS.CON
• lookup.dat

Ten en cuenta las mayúsculas y minúsculas.

Estos archivos los tendrás que conseguir de algún lado —si tienes el juego original, mejor que mejor —. Mira, por ejemplo, en www.arcades3d.com. Una vez que estén en tu poder, coloca estos cinco archivos en la carpeta en la que tienes los ejecutables; y desde un terminal, ejcutamos el binario duke3d, y ¡a jugaaar!:

Y para arrancar el Build —editor de mapas—:

Con esto ya podemos disfrutar del juego usando el puerto JFDuke...

Ahora bien, si lo que queremos es ejecutar el Duke con el HRP (High Resolution Pack) para gozar de los modelos en 3D y demás pijadas gráficas, procederemos de la siguiente forma:

Primero hacemos un "wget" a la siguiente dirección:
http://moreplease.free.fr/HRP/Parkar/dn3d_hrp-2005-11-01.zip

O sea:

En total son unos 100 MB —así que paciencia—. Cuando acabe la descarga, podemos descomprir el fichero usando la herramienta de descompresión File-Roller —o cualquier otra a vuestro gusto—:

$ file-roller dn3d_hrp-2005-11-01.zip

Tendremos que descomprimir los ficheros en la carpeta principal del Duke Nukem 3D, dónde hemos colocado antes los binarios. Como nosotros tenemos la versión atómica, extraeremos los ficheros duke3d_hrp.zip y maphacks.zip, dentro del subdirectorio comprimido maphacks_atomic. Fíjate que estos dos ficheros NO los tienes que descomprimir. O sea, seleccionas el primero de los citados, y lo guardas en la carpeta del Duke; y lo mismo para el segundo.

Ahora, tendremos que ejecutar el Duke, pero deberemos indicarle que lea estos dos archivos; y para ello, escribiremos una pequeña línea de comandos:

Así el señor Duke tendrá un aspecto mucho mejor.

Te parecerá un poco pesado escribir ese largo comando cada vez que quieras jugar..., pero no te preocupes, es posible ahorrárselo. Podemos preparar un sencillo script que lo haga automáticamente.

Abre un editor de textos, por ejemplo el Gedit, Kate o cualquier otro, y copia y pega el siguiente texto, tal y como aparece aquí (sustituyendo evidentemente /home/pepito por el directorio que hayas usado tú):

Guarda el documento con el nombre jfduke_hrp, y añádele permisos de ejecución:

$ chmod u+x jfduke_hrp

A partir de ahora, siempre que ejecutemos el script arrancará el juego con JFDuke y el High Resolution Pack. Puedes guardar el script en el escritorio, o colocarlo en cualquier otro sitio que desees.

---

Y como siempre, las capturas de pantalla reglamentarias...
Aquí podéis ver el juego ejecutándose con JFDuke, del modo habitual:

Y aquí podéis ver el mismo rincón del primer nivel de Duke Nukem 3D... Pero esta vez, usando el High Resolution Pack:

---

Compilando el puerto JFDuke

Bueno, Karnizero nos explicó arriba cómo jugar empleando los binarios del puerto JFDuke. Pero el código fuente también está disponible para descargarlo, y los aficionados más maniáticos probablemente querrán compilarlo ellos mismos. Así que aquí comentaré cómo hacerlo —sí, yo soy uno de ellos y me divierte hacer un make install de vez en cuando—.

Pues nada, manos a la obra. Lo primero de todo, necesitaremos lo siguiente:

• Código fuente del motor gráfico (JFBuild).
• Código fuente del puerto JFDuke3D.
• Parche para JFBuild.
• Parche para el JFDuke3D.
• Librerías SDL instaladas (en este caso, SDL-dev, SDL_mixer-dev, SDL_ttf-dev y SDL_image-dev).
• Librería Fmod y el ensamblador NASM.

Muchas distribuciones de GNU/Linux incluirán ya en su instalación por defecto las librerías citadas; y las que no, probablemente las tengan disponibles en sus respectivos repositorios de paquetes. En todo caso, no debería resultar problemático obtenerlas, bien mediante herramientas como Apt, Emerge y similares, bien descargándolas directamente de sus sitios web:

• SDL: http://www.libsdl.org.
• Fmod: http://www.fmod.org -fmod 3, y no fmod Ex-.
• NASM: http://sourceforge.net/projects/nasm/.

Solucionado el asunto de las librerías —quién tenga que hacerlo—, ya podemos ponernos a instalar el JFDuke. Crearemos un directorio para almacenar los archivos comprimidos que contienen el código fuente, y los respectivos parches. En este ejemplo le he llamado jonof, y éste sería su contenido:

Ahora descomprimimos los archivos zip:

Habrán aparecido dos nuevas carpetas (jfbuild_src_20051009 y jfduke3d_src_20051009), con el contenido de ambos ficheros zip.

Y ahora aplicamos los parches. Éstos son necesarios porque el JFDuke original todavía no tiene implementado correctamente el sonido en GNU/Linux. Sus autores están trabajando en ello, pero mientras tanto alguien publicó estos parches, un pequeño apaño provisional que solventa el problema. Así que no hay por qué renunciar a los rugidos de los enemigos:

Para que la compilación vaya bien, necesitamos crear un enlace simbólico llamado build en esta misma carpeta, que apunte al directorio dónde hemos descomprimido el JFBuild:

Y ya falta menos...

Una vez hecho esto, entramos en el directorio del código del JFDuke3D. Tendremos que editar el archivo Makefile, pero no temáis, es sólo un pequeño cambio en una línea, nada serio. Esto podemos hacerlo con nuestro editor de texto favorito —Vi, Beaver..., cualquiera sirve—:

¿Y qué hay que hacer? Poca cosa. Buscamos la siguiente línea:

-I$(INC:/=) -I$(EINC:/=) -I$(SRC)jmact -I$(SRC)jaudiolib #-I../jfaud/inc

Y la sustituímos por esta otra:

-I$(INC:/=) -I$(EINC:/=) -I$(SRC)jmact -I$(SRC)jaudiolib -I/usr/local/include/fmod #-I../jfaud/inc

En realidad, la única diferencia entre ambas es el texto -I/usr/local/include/fmod. Sí, en la carpeta /usr/local/include deberemos tener un enlace simbólico llamado fmod, que apunte al directorio en el se guardan los "headers" de la librería Fmod; este directorio suele ser /usr/include/fmod, y los archivos que contiene, fmod.h y un par más de nombres similares.

Comento esto último sólo por afán informativo. Si la librería Fmod está bien instalada, no tendremos que preocuparnos por el citado enlace simbólico ni por nada que tenga que ver con él.

¡Y por fin llegó el momento de teclear la palabra mágica! Para compilar el puerto JFDuke no nos queda más que un último paso:

$ make

Y si todo va bien, después de unos minutos y montones de letras y números en la consola de comandos, tendremos dos archivos ejecutables: duke3d —el fichero para arrancar el juego— y build —el editor de mapas—. Simplemente los copiamos a la carpeta en la que tengamos instalado el Duke Nukem 3D original... Y ya podemos jugar.

---

Anexo: Instalando Fmod y Timidity

Librería Fmod

Lo prometido es deuda, y aquí explicaré cómo instalar manualmente la librería de sonido Fmod. Es algo que puede resultar problemático para la gente menos experimentada en GNU/Linux... De todos modos lo ideal sería descargarla de los repositorios de paquetes de vuestras distribuciones; aunque ya me imagino que si estáis leyendo esto es porque, por lo que sea, no la habéis encontrado en ellos.

Pues nada, en primer lugar nos descargamos el archivo correspondiente —en el momento de escribir esto, fmodapi375linux.tar.gz—, y lo descomprimimos:

A continuación tendremos que crear varias carpetas dentro de /usr/local/ —para hacerlo es probable que necesitéis acceder a la cuenta del administrador—. Así, por ejemplo:

Y accedemos a los contenidos que acabamos de descomprimir para comenzar a copiar los archivos necesarios. Lo único que nos interesa aquí es la carpeta llamada api:

Ahora necesitamos crear algunos enlaces simbólicos, para que los diversos programas puedan encontrar fácilmente la librería Fmod cuando lo requieran:

Y ya lo tenemos... Al final no era tan difícil, ¿verdad?

Timidity

Esto ya se explicó en otro tutorial, el de Doom y derivados (con Zdoom), y de hecho lo que sigue es más o menos una copia del texto que escribí en él. Sucede que descubrí por casualidad que con Timidity y cierto archivo de fuentes de sonido también es posible escuchar la música de Duke Nukem 3D. Así que, si queréis deleitaros con las fantásticas melodías del juego, seguid leyendo...

Timidity es una utilidad que nos permite reproducir melodías midi en GNU/Linux y otros sistemas. Aquí comentaré los pasos a seguir para instalarlo y configurarlo... De todas formas, en http://www.ubuntu-es.org/node/3777 hay un tutorial muy útil y recomendable sobre esto.

Antes que nada, usuarios de Ubuntu: abrid Synaptic, buscad Timidity, marcadlo, clicad con el ratón en Aplicar... ¡Hecho! No hace falta que sigáis leyendo...

¿Pero qué pasa si vuestra distribución de Linux no tiene Timidity en sus repositorios, o si un meteorito destruye todos los servidores de Canonical y asociados, o si...? Lógicamente, el primer paso sería descargarnos alguna versión de Timidity. La más reciente a día de hoy creo que es la 2.13; podéis echar un vistazo a su página oficial —http://timidity.sourceforge.net— para conseguirla.

En principio, como ya he dicho, sería preferible descargar paquetes ya compilados para vuestras distribuciones. Pero si por alguna razón deseáis compilar Timidity vosotros mismos —o vuestra distribución no cuenta con dichos paquetes—, el proceso es sencillo. Una vez descomprimido el código fuente, basta con teclear lo siguiente en una consola de comandos:

Como podéis ver, la primera orden (./configure) admite diversas opciones; son importantes, porque con ellas indicaremos qué características del programa queremos activar. Así, en este ejemplo configuramos Timidity para que emplee OSS o ALSA para reproducir los midis (--enable-audio=oss,alsa), cosa que funcionará en la mayoría de sistemas GNU/Linux; las otras dos opciones no sabría explicar bien para qué sirven exactamente, pero creo que es recomendable usarlas...

En fin, si deseáis ver con tranquilidad todas las opciones de configuración que pueden emplearse con Timidity, teclead una orden como ésta:

$ ./configure --help ¦less

Aunque de todas formas, Timidity compilado tal y como muestra el ejemplo anterior probablemente correrá sin problemas en casi todas las máquinas con GNU/Linux y una tarjeta de sonido bien configurada.

Bueno, ya tenemos Timidity compilado e instalado en nuestro ordenador... Pero aún no hemos terminado. Lo siguiente que nos hará falta será un archivo de sonidos digitalizados, correspondientes a las notas e instrumentos que emulará Timidity al reproducir la música. Supongo que habrán bastantes circulando por Internet. El que uso actualmente, después de haber probado varios, y me ha dado mejores resultados, es éste, enlazado al final de la página oficial de la librería SDL_mixer.

No obstante, también puede obtenerse rápida y cómodamente usando Wget:

$ wget http://www.libsdl.org/projects/SDL_mixer/timidity/timidity.tar.gz

Una vez tengamos el fichero de sonidos a buen recaudo en nuestro ordenador, lo descomprimimos e instalamos:

Esto crea un directorio llamado timidity dentro de /usr/local/lib, con todo el contenido necesario para funcionar. Sí, incluido un archivo timidity.cfg hecho a medida —en versiones viejas de este tutorial, usando otros ficheros de sonidos, había que escribirlo desde cero o buscarse la vida—.

Por último, es posible que necesitéis una copia —o un enlace simbólico— de este archivo en el directorio /usr/local/share/timidity. En mi caso lo solucioné de esta manera:

Y ahora sí, hemos terminado... Reiniciad el ordenador para aseguraros de que todo funciona correctamente, y a disfrutar.

---

Este manual es más largo que un día sin pan, así que añadiré otra captura de pantalla para que no se haga tan aburrido... Aquí podéis ver las opciones gráficas del JFDuke3D —el juego está usando el modo gráfico original, 256 colores y renderización por software—:

- Manual escrito por Eye del Cul y Karnizero.

Podéis copiar libremente cualquier contenido de esta página. Si se trata del texto o las imágenes, mencionad la fuente (www.arcades3d.com)...