Correr Clasicos en Linux

Tema en 'Soft y Hard' comenzado por Ciclón de Hojas, 28/Jun/2010.

  1. Ciclón de Hojas

    Ciclón de Hojas Moonlight Ice Wizzard

    Ingreso:
    12/Ago/2004
    Mensajes:
    5.909
    Ubicación:
    Redwood City, SL
    Aqui les dejo una guia completa de los juegos que he encontrado para correr el Linux, aclararé las fuentes mas abajo:

    Juegos Basados en Doom en Linux
    Pues aquí estamos otra vez, con un nuevo tutorial para poder jugar a nuestros títulos favoritos en GNU/Linux. Ahora explicaré los pasos necesarios para ejecutar los juegos que utilizan el motor de Doom. En esta ocasión, Doom y su segunda parte, y también Heretic; Doom Legacy no es compatible con Hexen o Strife.

    Antes de comenzar, nos aseguraremos de que nuestro Linux, sea la distribución que sea, tenga las siguientes características:

    * Kernel 2.4.27 o más reciente.
    * Drivers de nuestra tarjeta gráfica instalados y activados; ésta deberá contar obligatoriamente con aceleración 3D si queremos usar renderización por OpenGL.
    * Deberemos tener instaladas la serie de librerías LibGL (si deseamos ejecutarlo bajo SDL) o la serie de librerías LibX (si usamos el gestor gráfico nativo de X).
    * Y finalmente necesitaremos el archivo .WAD del juego que queramos ejecutar (sólo hace falta el WAD, los demás ficheros no).

    Con todos estos archivos nos aseguraremos de que los juegos funcionarán perfectamente, y con aceleración 3D si así lo deseamos.

    Cuando cumplamos todos los requisitos anteriores, tendremos que descargarnos de la red de redes —o sea, Internet—, el launcher para GNU/Linux con el que podremos ejecutar estos juegos.

    En realidad hay muchos de ellos disponibles (por ejemplo, Doomsday o Zdoom). Pero el que a mí más me gusta es el Doom Legacy, también conocido como NewDoom. Y uso éste porque, además de soportar aceleración 3D, se ejecuta desde consola, lo que reduce enormemente el consumo de recursos; además permite muchas opciones avanzadas.

    Este launcher nos lo descargaremos de aquí:
    http://legacy.newdoom.com/downloads.php.

    Mientras se descarga, podemos echarnos unas partidillas al GLTron o al TuxCart (jajaja, fastidiaros usuarios de Windows, que vosotros no tenéis estos juegazos :risa:).

    Una vez descargado el fichero, que es un .tar.gz, lo descomprimimos en una carpeta a nuestra elección. Dentro de dicha carpeta se nos crearán una serie de archivos y librerías, de los cuales nosotros vamos a usar dos. A saber: el denominado llxdoom (ele, ele, equis, "doom"), y el lsdldoom. El primero nos ejecutará el juego usando las X sin SDL, y el segundo empleará el entorno SDL. Yo uso el segundo, el lsdldoom.

    Para comenzar a jugar, tendremos que copiar el archivo .WAD del juego "víctima" a la carpeta en la que hayamos descomprimido el Doom Legacy. A continuación, abrimos una consola de comandos, y escribimos el siguiente —en este caso, para lsdldoom—:

    $ lsdldoom -IWAD <archivo_wad>

    En dónde <archivo_wad> hace referencia al WAD que copiamos antes. Por ejemplo:

    $ lsdldoom -IWAD doom.wad

    Por lo demás, se procedería de la misma forma con llxdoom:

    $ llxdoom -IWAD <archivo_wad>

    Otro ejemplo:

    $ llxdoom -IWAD doom.wad

    Por último, cuando ejecutemos el NewDoom (o Doom Legacy), será posible escribir opciones de ejecución, para activar o desactivar ciertas características del juego:

    * La opción -nosound sirve para desactivar el sonido.
    * Con la opción -opengl activaremos el soporte 3D por hardware para el juego en cuestión.
    * El comando -file <archivo_wad> nos permite cargar wads externos (mapas, gráficos, músicas, etc).

    Por ejemplo:

    $ lsdldoom -opengl -nosound -IWAD doom2.wad <-- Ejecutaremos el juego Doom 2 con aceleración 3D y sin sonido.

    Todas estas opciones vienen explicadas en la documentación de Doom Legacy. Lo que no veo lógico es por qué alguien querría jugar sin sonido, cuando éste se oye perfectamente (¿?).

    En esta imagen que os pongo podéis ver cómo se ejecuta Heretic en GNU/Linux. Aquí sin aceleración 3D:

    [​IMG]

    En esta otra captura vemos Heretic corriendo con aceleración 3D. Fijaos en el efecto de niebla que hay hacia el fondo:

    [​IMG]

    ZDoom en Linux

    Hace tiempo, al poco de comenzar con esta sección de "juegos en Linux", Karnizero nos explicó cómo instalar el puerto Doom Legacy —y quién esté interesado puede consultar ese texto—, con el que podíamos jugar cómodamente a Doom o Heretic... Y bueno, ahora me toca a mí hacer lo propio con el puerto Zdoom.

    Zdoom es, al igual que Doom Legacy, un puerto que permite ejecutar los viejos títulos basados en el "Doom engine" en nuestros sistemas modernos: en este caso, Linux y las variantes recientes de Windows, aunque con un poco de ingenio también es posible hacerlo funcionar en FreeBSD... Esto es importante porque, tratándose de juegos que aparecieron en la primera mitad de los noventa —hace más de diez años—, sus versiones originales sólo funcionaban en MS-DOS.

    ¿Y por qué Zdoom? Bueno, hay gente a la que no le acaba de gustar Doom Legacy... Y además, Zdoom tiene algunas ventajas destacables. Por ejemplo, permite arrancar más juegos —es totalmente compatible con Hexen y Strife, y las últimas versiones incluyen también compatibilidad con Chex Quest—. Y el sonido resulta más fácil de configurar; puede emular las melodías midi de los juegos originales con el sintetizador que trae incorporado, o bien mediante Timidity. Para que nos entendamos; ¡con Zdoom hay música! —con Doom Legacy se supone que también..., para quién sepa cómo configurarla, que no es mi caso—.
    Requisitos

    Así que vamos a ponernos manos a la obra. Para ejecutar Zdoom necesitamos lo siguiente:

    * Librerías SDL.
    * Librería de sonido Fmod, en su versión 3.75. (Aunque a partir de la versión 2.3.0 de Zdoom se requieren las versiones 4.x de la librería Fmod).
    * libFLAC y libFLAC++.
    * Un entorno gráfico (el X Window System).
    * Timidity (recomendable aunque no imprescindible).
    * Si vais a usar la versión 2.3.0 de Zdoom o más recientes, necesitaréis también una instalación más o menos actual de las librerías GTK2. Los binarios que podéis descargar desde Arcades 3D fueron compilados con la versión 2.12.9 de GTK2, y la verdad es que no sé cómo funcionarán con otras más antiguas.
    * El archivo WAD del juego que queramos ejecutar (Doom, Doom 2, Hexen...)

    Probablemente casi todo esto vendrá ya incluido en la mayoría de las distribuciones grandes —Debian, Ubuntu, Mandriva, etc—. Quizás Timidity —una utilidad para reproducir melodías midi— y la librería Fmod sean lo más problemático de instalar, puesto que no estarán disponibles en muchos repositorios; así que he escrito un anexo al final de este tutorial, con las instrucciones necesarias para tener ambas cosas instaladas y funcionando.
    Instalando Zdoom

    Como ya hemos visto en otros manuales de esta serie, podemos descargarnos unos binarios listos para usar, o conseguir el código fuente del Zdoom para compilarnos unos propios. Obviamente, lo primero es lo más sencillo, y lo que explicaré a continuación.

    Daré por supuesto que ya tenéis Timidity y la librería Fmod bien instalados y configurados —consultad el anexo si tenéis dudas sobre ello—. En realidad, Timidity no es imprescindible para poder disfrutar de Zdoom, ni siquiera para la música. Zdoom puede reproducir directamente las melodías MUS —el formato nativo de Doom, Heretic y demás, una variación de los midis que encontramos habitualmente—; sin embargo, algunos mapas creados por usuarios sí emplean música en el formato midi original, y si queremos oírla necesitaremos Timidity.

    Seamos ordenados; antes que nada, crearemos una carpeta en la que colocar el Zdoom y el archivo WAD del juego que nos interese —Doom, Hexen, Strife, etc—:

    $ pwd
    /home/chiquito
    $ mkdir juegos
    $ cd juegos
    $ mkdir zdoom
    $ cd zdoom

    Ahora tendremos que descargar los binarios del Zdoom. En esta misma sección "Linux" de Arcades 3D podéis encontrarlos. Por ejemplo, pueden obtenerse cómodamente usando Wget (en el momento de escribir esto se trata de la versión 2.1.7, pero evidentemente cambiará con el tiempo):

    $ wget http://www.arcades3d.com/linux/zdoom_bin-2.1.7.tar.bz2

    Estos binarios deberían funcionar en la mayoría de los sistemas. Los compilé en un viejo Pentium II corriendo Debian GNU/Linux, y las dependencias son las siguientes —lo comento porque quizás alguien necesite saberlo—:

    $ ldd zdoom
    libFLAC++.so.5 => /usr/local/lib/libFLAC++.so.5
    libFLAC.so.7 => /usr/local/lib/libFLAC.so.7
    libz.so.1 => /usr/lib/libz.so.1
    libjpeg.so.62 => /usr/lib/libjpeg.so.62
    libfmod.so => /usr/local/lib/libfmod.so
    libSDL-1.2.so.0 => /usr/local/lib/libSDL-1.2.so.0
    libpthread.so.0 => /lib/libpthread.so.0
    libstdc++.so.5 => /usr/lib/libstdc++.so.5
    libm.so.6 => /lib/libm.so.6
    libgcc_s.so.1 => /lib/libgcc_s.so.1
    libc.so.6 => /lib/libc.so.6
    libdl.so.2 => /lib/libdl.so.2
    libX11.so.6 => /usr/X11R6/lib/libX11.so.6
    libXext.so.6 => /usr/X11R6/lib/libXext.so.6

    De todas formas, las versiones de Zdoom de la 2.3.0 en adelante requieren también las librerías GTK2, tal y como se ha dicho anteriormente. Quiero decir, esta lista de dependencias está ya un poco desfasada y no es aplicable a las ediciones modernas de Zdoom... Tenedlo en cuenta.

    Pero bueno, no nos desviemos del tema. Acabamos de descargarnos el Zdoom, comprimido en un archivo .tar.bz2; lógicamente, hay que descomprimirlo:

    $ tar -jxvf zdoom_bin-2.1.7.tar.bz2

    Con esto habrán aparecido en nuestro directorio unos cuantos ficheros nuevos, junto con una carpeta llamada wadsrc; hay un ejecutable con el nombre de zdoom, y otros archivos como zdoom.map y zdoom.pk3 —éste es un enlace simbólico a wadsrc/zdoom.pk3—.

    Y ahora sólo nos falta el archivo WAD del juego que nos interese ejecutar con Zdoom. Por ejemplo, en el caso de Doom 2 sería algo así:

    $ cp ~/juegos/doom2/doom2.wad ~/juegos/zdoom

    ...Vamos, esto suponiendo que tenemos una copia del Doom 2 instalada en la carpeta /home/usuario/juegos/doom2. Zdoom puede funcionar con varios juegos: Doom, Doom 2, Ultimate Doom, Heretic, Hexen, Strife..., y quizás algún otro que no recuerde ahora :risa:.

    En fin, hecho esto ya podríamos arrancar el Zdoom. Bastaría con acceder a la carpeta en la que lo hemos instalado, y escribir:

    $ ./zdoom

    La primera vez que ejecutemos el Zdoom se creará automáticamente una carpeta oculta en el directorio raíz de nuestro usuario —como hacen muchos otros programas—, situada en ~/.zdoom. En ella se grabarán nuestras partidas guardadas, así como el archivo de configuración zdoom.ini —importante, por cierto—.

    Para escuchar las melodías del juego, arrancaremos Zdoom del modo habitual. Tendremos que acceder, en el menú principal, a "Options -> Sound Options -> Advanced Options"; y una vez aquí, activamos la opción "Use FM synth to MUS Music". Esto hace que la música en formato MUS —el formato nativo de Doom, similar al midi— se reproduzca mediante sonido digitalizado. A partir de la versión 2.3.0, la opción correspondiente se encuentra en "Options -> Sound Options -> Midi Device".

    No obstante, y como ya comenté al principio, Zdoom también puede reproducir midis corrientes. De hecho, hay algunos mapas circulando por Internet que emplean melodías en formato MID, en lugar del formato MUS tradicional de Doom. Si deseamos oír la música en estos casos, deberemos tener bien instalado Timidity; y es posible que haya que modificar el archivo de configuración del Zdoom (~/zdoom/zdoom.ini) del siguiente modo:

    timidity_extargs=-Os

    De este modo especificamos que Timidity reproduzca la música mediante ALSA —para lo cual necesitaremos haberlo compilado con soporte para ALSA; en el anexo lo explico con detalle—. Puede ser necesario cambiar así esta línea, o no; depende de cómo tengamos configurado el sonido en nuestro ordenador.
    ¡Zdoom se cuelga!

    A algunas personas —yo entre ellas :risa:— les ha sucedido esto la primera vez que han intentado comenzar una partida. Una forma de solucionarlo es editar el archivo de configuración del Zdoom, que suele estar colocado en ~/.zdoom/zdoom.ini. En este fichero encontraremos probablemente una línea como ésta:

    snd_output=default

    Pues bueno, bastaría con sustituir "default" por "alsa" —o por "oss", si esto no da resultado, o no escucháis ningún sonido al jugar con Zdoom—:

    snd_output=alsa

    Y por último, si este archivo (zdoom.ini) no existe, basta con cargar el Zdoom y salir inmediatamente de él —con la opción de "Quit Game", sin comenzar ninguna partida— para que sea creado automáticamente.

    Bueno, no pueden faltar un par de capturas de pantalla que demuestren lo comentado en este tutorial.

    En esta primera imagen estoy jugando el primer nivel de Doom 2, usando la versión 2.1.0 de Zdoom. El ordenador es un Pentium II a 350 MHz funcionando con Debian GNU/Linux y un bonito escritorio Fluxbox:
    [​IMG]

    Como no sólo de Doom vive el hombre, en esta otra captura de pantalla podéis ver cómo se ejecuta Strife con la versión 2.3.0 de Zdoom. La compatibilidad es completa, y el juego puede disfrutarse sin ningún inconveniente:
    [​IMG]

    Compilando Zdoom

    A la gente que no quiera complicarse mucho la vida probablemente le interesará más usar los binarios ya compilados, tal y como acabo de explicar arriba. Sin embargo, puede haber quién necesite compilarse unos propios porque los anteriores no le funcionen, o porque quiera tener Zdoom lo más optimizado posible para su máquina, o simplemente porque le guste más hacer las cosas así. Si éste es tu caso, sigue leyendo...

    Hasta la llegada de la versión 2.1.0, compilar Zdoom en GNU/Linux podía resultar un auténtico dolor de cabeza. Había que aplicar un parche al código fuente que hubiésemos descargado —parche que estaba escondido en un hilo del foro oficial de Zdoom—, usar unas versiones muy concretas de NASM y la librería Fmod, y cruzar los dedos para que todo funcionase sin problemas... Afortunadamente ya no es así; y la versión 2.1.0, que al parecer es la siguiente versión oficial desde la ya lejana 1.22, puede compilarse sin mayores complicaciones.
    Versiones 2.1.x

    Bueno, he mencionado la versión 2.1.0, pero lo comentado aquí también sirve para la 2.1.1 —aparecida mientras preparaba este manual—, y las siguientes. Sin embargo, a partir de la versión 2.3.0 los autores de Zdoom han hecho varios cambios importantes, y por eso el modo de compilarlas se explica más adelante.
    Requisitos

    Y basta de charla..., pongámonos ya manos a la obra. Para compilar Zdoom vamos a necesitar lo siguiente:

    * Código fuente de Zdoom (disponible en aquí mismo, en Arcades 3D, o en la página oficial).
    * Librerías SDL.
    * Librería de sonido Fmod.
    * Ensamblador NASM.
    * libFLAC y libFLAC++.

    Si no tenéis alguna de estas librerías probablemente podréis conseguirlas en los repositorios de vuestras distribuciones. Y si no es así, siempre se pueden encontrar en sus páginas oficiales:

    * SDL: Simple DirectMedia Layer.
    * Fmod: fmod - interactive audio middleware —mirad en Fmod 3, y no en Fmod Ex, ya que son dos cosas diferentes—.
    * NASM: The Netwide Assembler | Download The Netwide Assembler software for free at SourceForge.net.

    De todas ellas, quizás la más problemática de instalar sea Fmod; consultad el anexo si tenés alguna duda con esto... De momento asumiré que ya está instalada en vuestras máquinas.
    Compilación e Instalación

    Bueno, empezaremos por descargarnos el código fuente del Zdoom, y crear una carpeta para guardarlo y descomprimirlo:

    $ mkdir zdoomsrc
    $ cd zdoomsrc
    $ wget http://www.arcades3d.com/linux/zdoom_src-2.1.7.tar.bz2

    Y ahora extraemos el contenido del archivo tar.bz2:

    tar -jxvf zdoom_src-2.1.7.tar.bz2

    Esto creará una nueva carpeta llamada zdoom, dentro de la que hemos añadido un poco más arriba (zdoomsrc en este ejemplo). En ella encontraremos todo el código fuente que necesitamos compilar.

    Sin embargo, hay que pulir algún detallito antes de ponernos a la tarea. Por algún motivo el compilador busca algunas de las dependencias —las librerías necesarias que ya he mencionado— en el directorio /usr/lib, en lugar de /usr/local/lib como suele ser habitual en algunas distribuciones de Linux. No sé si sucederá siempre así, pero es un problema que he encontrado en las dos máquinas en que lo he probado.

    Algo muy fácil de solucionar, por otra parte. Basta con crear algunos enlaces simbólicos en /usr/lib y /usr/include que apunten a las librerías originales. Para ello necesitaréis acceder a la cuenta del administrador:

    $ su
    Password:
    # ln -s /usr/local/fmod/lib/libfmod-3.75.so /usr/lib/libfmod.so
    # ln -s /usr/local/fmod/include/fmod /usr/include/fmod
    # ln -s /usr/local/fmod/include/fmod/fmod.h /usr/include/fmod.h
    # ln -s /usr/local/lib/libFLAC.so /usr/lib/libFLAC.so
    # ln -s /usr/local/lib/libFLAC++.so /usr/lib/libFLAC++.so
    # exit
    $

    Una vez resuelto este pequeño inconveniente —si es necesario hacerlo— ya podemos compilar el Zdoom. Para ello accederemos a la carpeta llamada zdoom, y con una sencilla orden make todo echará a andar:

    $ pwd
    /home/usuario/zdoomsrc
    $ cd zdoom
    $ make

    Puede costarle un buen rato terminar, sobre todo en las máquinas más viejas. En mi Pentium II a 350 MHz la compilación se prolongó durante veinte minutos más o menos... Lo digo para que no os desesperéis si tarda más de lo que esperábais.

    Cuando termine, habrán aparecido los siguientes archivos:

    * zdoom (ejecutable)
    * zdoom.map
    * wadsrc/zdoom.pk3
    * zdoom.pk3 (enlace simbólico al anterior)

    Y con esto hemos terminado... Sólo nos faltaría copiar el archivo WAD del juego que nos interese —doom2.wad para jugar a Doom 2, heretic.wad para el Heretic, etc— a esta misma carpeta; o, más recomendable, hacer lo contrario.

    Nada más. Que lo disfrutéis...
    Versiones 2.3.x y más recientes

    El modo de compilar estas versiones de Zdoom cambia respecto a las anteriores, y por eso he decidido dedicarles una sección por separado. Como hicimos antes, veremos primero los requisitos necesarios.
    Requisitos

    Bien, vamos a necesitar lo siguiente:

    * Una versión moderna de GCC. Aunque en la wiki de Zdoom mencionan la 3.4.6, yo la he probado y no funciona. Mi recomendación es que uséis alguna de la serie 4.2.x o más recientes.
    * Cmake 2.6 o 2.4.
    * Librerías SDL.
    * Librería de sonido Fmod; usad la versión 4.20 y posteriores.
    * Ensamblador NASM.
    * libFLAC y libFLAC++.
    * GTK2 (opcional).

    Notad que GTK2 es opcional. Si tenéis instaladas estas librerías, Zdoom las usará, y de lo contrario se compilará sin ellas.

    Respecto a lo demás, lo recomendable es que uséis los gestores de paquetes de vuestras distribuciones. Quizás la librería Fmod no se halle en ellos; en tal caso, tendréis que descargarla de su página oficial e instalarla manualmente en vuestro sistema. No es difícil de hacer; en el anexo se explica cómo.
    Compilación e Instalación

    El primer paso es descargarse el código fuente de Zdoom y descomprimirlo en una carpeta a vuestra elección. No tiene mucho sentido repetir aquí la explicación escrita un poco más arriba, así que asumiré que ya tenéis el código fuente preparado en la carpeta /home/usuario/zdoomsrc.

    A continuación —y aquí comienzan las diferencias respecto a las versiones viejas de Zdoom— hay que crear un directorio de trabajo dentro de la carpeta principal del código fuente. Más o menos así (en este ejemplo lo he llamado compilacion, pero cualquier otro nombre serviría):

    $ pwd
    /home/usuario/zdoomsrc
    $ cd zdoom
    $ mkdir compilacion
    $ cd compilacion

    Y ahora usamos CMake de la siguiente manera:

    $ cmake -DCMAKE_BUILD_TYPE=Release ..

    ¡Fijaos en los dos puntos del final de la línea, son importantes!

    Si CMake ha hecho correctamente su parte y no han surgido problemas, ya estáis listos para comenzar el trabajo. Sin salir del directorio compilacion, escribimos:

    $ make

    Y ya sólo queda esperar. La compilación puede prolongarse bastante rato, y en las máquinas más viejas no sería extraño que superarse la media hora. Cuando termine, encontraréis los tres archivos necesarios para ejecutar Zdoom:

    * zdoom (ejecutable).
    * zdoom.pk3.
    * liboutput_sdl.so

    Simplemente copiadlos a la carpeta en la que tengáis instalado el juego que os interese: Doom, Doom 2, Heretic, Hexen, Strife, y creo que incluso Chex Quest.
    Anexo: Cómo instalar Fmod y Timidity

    Algunas personas pueden tener problemas a la hora de instalar alguna de estas dos cosas. Por ello he decidido escribir esta última parte del manual, que debería servir de ayuda para quién se sienta perdido...
    Librería Fmod
    Versión 3.75

    Comencemos con Fmod... Este texto en realidad ya lo he escrito en otros manuales —los de Duke Nukem 3D y Shadow Warrior—, pero no está de más repetirlo aquí.

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

    $ wget http://www.fmod.org/files/fmodapi375linux.tar.gz
    $ tar -zxvf fmodapi375linux.tar.gz

    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:

    $ su
    Password: <-- Introducimos la contraseña del administrador...
    # mkdir -p /usr/local/fmod/include/fmod
    # mkdir -p /usr/local/fmod/lib

    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:

    # cd fmodapi375linux
    # cd api
    # cp -v libfmod-3.75.so /usr/local/fmod/lib
    # cp -v inc/* /usr/local/fmod/include/fmod

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

    # ln -s /usr/local/fmod/lib/libfmod-3.75.so /usr/local/fmod/lib/libfmod.so
    # ln -s /usr/local/fmod/lib/libfmod-3.75.so /usr/local/lib/libfmod.so
    # ln -s /usr/local/fmod/include/fmod /usr/local/include/fmod

    Y ya lo tenemos... De todas formas, si pensáis compilar Zdoom vosotros mismos, podéis encontraros con que durante el proceso el ordenador busque la librería Fmod en la carpeta /usr/lib, en vez de en /usr/local/lib. Para solucionar esto, añadiremos algunos enlaces simbólicos más:

    $ ln -s /usr/local/fmod/lib/libfmod-3.75.so /usr/lib/libfmod.so
    $ ln -s /usr/local/fmod/include/fmod /usr/include/fmod
    $ ln -s /usr/local/fmod/include/fmod/fmod.h /usr/include/fmod.h
    Versiones 4.x

    La instalación de estas versiones de Fmod resulta más sencilla que la de las anteriores. Basta con descargarlas, descomprimir el fichero correspondiente, y ejecutar un make install desde la cuenta del administrador. Veámoslo con detalle.

    Descargar Fmod es tan fácil como acudir a la página oficial y conseguir la última versión. O bien, usar Wget desde la línea de comandos:

    $ wget http//www.fmod.org/index.php/release/version/fmodapi42202linux.tar.gz

    En este ejemplo se trata de la versión 4.22, pero para cuando leáis esto pueden haber otras. De hecho, existen también versiones de Fmod para sistemas de 64 bits.

    Ahora descomprimimos el archivo que hemos descargado:

    $ tar -zxvf fmodapi42202linux.tar.gz

    Y hecho esto, procedemos a la instalación. Para ello habrá que usar la cuenta del administrador (o el comando sudo, en Ubuntu y otras distribuciones similares):

    $ cd fmodapi42202linux
    $ su
    Password:
    # make install

    Y ya está hecho. Como véis, no tenía mucho misterio.
    Timidity

    Se trata de una utilidad que nos permite reproducir melodías midi en GNU/Linux y otros sistemas. Como ya he explicado más arriba, no resulta imprescindible para jugar con Zdoom, pero sí puede venir bien para escuchar la música de algunos mapas que no emplean el formato MUS nativo de Doom. Aquí explicaré los pasos a seguir para instalarlo y configurarlo... De todas formas, en COMO Escuchar MIDI con timidity y pmidi | Ubuntu-es hay un tutorial muy útil y recomendable sobre esto.

    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.
    Compilar Timidity

    En principio 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:

    $ ./configure --enable-audio=oss,alsa --enable-server --enable-alsaseq
    $ make
    $ su
    Password: <-- Accedemos a la cuenta del administrador.
    # make install

    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... :risa

    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.
    Instalando el archivo de sonidos

    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:

    $ su
    Password:
    # cd /usr/local/lib
    # tar -zxvf timidity.tar.gz

    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:

    # cd /usr/local/share
    # ln -s /usr/local/lib/timidity timidity

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

    Duke Nukem 3D

    Aquí explicaré cómo hacer funcionar el Duke Nukem 3D en GNU/Linux. Y como siempre, comenzaremos con los requisitos, que en este caso son muy pocos:

    * Necesitaremos las librerías SDL, SDL_mixer, SDL_net, SDL_dev, SDL_mixer_dev y SDL_net_dev. Las "dev" nos servirán para compilar el código fuente que nos descargaremos más adelante (en muchas distribuciones los paquetes "dev" no existen porque su contenido ya se incluye en los paquetes SDL correspondientes de sus respectivos repositorios).
    * Tarjeta de sonido compatible con OSS/ALSA.
    * Entorno gráfico X.
    * GCC 3.x (o sea, GCC 3.0 y superiores).
    * Código fuente de Duke Nukem 3D y Build (que podéis descargar de Arcades 3D).

    Y en principio, esto es todo.
    Ahora, también necesitaremos algunos archivos del Duke Nukem 3D original, a saber:

    * game.con
    * defs.con
    * user.con
    * duke3d.grp
    * duke3d.cfg
    * build.cfg

    Estos ficheros tienen que ser de la edición atómica. Con los de la versión normal de Duke Nukem 3D también lo he probado, pero no funciona.

    Bien, abrimos una sesión de consola, y creamos una carpeta que se llame "juegos".

    $ mkdir juegos

    Y dentro de ella, otra llamada "duke3d".

    Es recomendable, tanto si usáis Linux como Windows, que tengáis todos los juegos —y, en general, todos los programas de una misma categoría— almacenados en el mismo directorio.

    $ cd juegos
    $ pwd
    /home/alberto/juegos
    $ mkdir duke3d

    Y a continuación, copiaremos todos los archivos que he citado arriba a este directorio (en este ejemplo, /home/alberto/juegos/duke3d).

    Una vez hecho, nos bajaremos el código fuente del juego desde Internet. Seguramente sabréis que 3D Realms ha liberado el código fuente de Duke Nukem 3D y Shadow Warrior, así que lo podremos descargar sin problemas. El único contratiempo es que dicho código está escrito para ser compilado con un compilador llamado Watcom C++, el cual ya NO es gratuito. Watcom C++ es un lenguaje de programación basado en C++; resulta casi igual a éste, excepto por una serie de librerías y componentes, que fueron utilizados por 3D Realms para compilar el juego.

    Así que si nos bajásemos el código fuente original no nos serviría de mucho. Y de esto mismo también se dieron cuenta en Icculus.org; así que revisaron todo el código para que pueda ser compilado con un compilador normal de C++.

    Así que lo que tendremos que descargarnos es el código fuente de Icculus. Podéis conseguirlo aquí mismo, en Arcades 3D, o bien en Icculus.org.

    En el segundo caso, antes necesitábamos algún programa para acceder a directorios CVS, pero ahora los autores utilizan Subversion para alojar este código fuente, por lo que tendremos que usar un cliente SVN. La mayoría de las distribuciones actuales de GNU/Linux cuentan con alguno, o al menos lo tendrán disponible para instalar desde sus respectivos repositorios de paquetes.

    Ya con un cliente SVN instalado en nuestro sistema, abriremos una sesión de consola, y teclearemos lo siguiente (o bien, copiar-pegar):

    $ mkdir fuentes
    $ cd fuentes
    $ svn co svn://svn.icculus.org/duke3d/trunk duke3d

    Con esto crearemos un directorio llamado fuentes y comenzaremos a descargarnos el código fuente desde el repositorio SVN —cosa que puede llevar su tiempo, sobre todo a la gente con conexiones lentas; en total son más de diez megabytes—.

    En fin, si tenéis problemas con el SVN, podéis echar una ojeada a la página de Duke Nukem 3D en Icculus, cuyas instrucciones pueden serviros de ayuda.

    Lo hayamos descargado de aquí o de allá, comprobaremos que hay varias carpetas, entre las cuales encontraremos una denominada source, que contiene el código que debemos compilar. Si todo está bien, procederemos a la compilación.

    Así que listamos el contenido de la carpeta source:

    $ pwd
    /home/alberto/juegos/duke3d/fuentes/duke3d/source
    $ ls
    .
    ..
    ...
    Makefile <-- Fijaos en la existencia de este archivo.
    ....
    .....
    ......

    Siempre que aparezca un makefile, entenderemos que estamos ante código que se puede compilar, a no ser que exista otro archivo llamado configure. En este último caso, ejecutaríamos primero el configure, y luego compilaríamos.

    Como aquí sólo tenemos el makefile, procedemos a compilar directamente:

    $ make
    .
    .
    .
    .
    $

    Y si no surgió ningún error de compilación, ya tenemos el Duke Nukem 3D compilado, con los ejecutables correspondientes. En la carpeta source encontraremos el ejecutable para arrancar el juego —duke3d—, y dentro de buildengine el editor de mapas Build. Para jugar, bastaría con colocar estos dos archivos en la carpeta donde hemos dejado los ficheros .con, .grp y .cfg del Duke Nukem original, mencionados al principio.

    Y como siempre, un par de capturas de pantalla... Si a alguien le pica la curiosidad, están tomadas en Vector Linux corriendo en un Pentium II a 350 MHz y 96 MB de memoria RAM. En esta máquina el juego funciona sin inconvenientes. Por defecto se ejecuta a pantalla completa, pero pulsando [ALT] + [INTRO] podéis convertirlo en una ventana del escritorio.

    Aquí vemos el Duke Nukem Atomic cargando en una ventana del escritorio IceWM:
    [​IMG]

    Quake [con Darkplaces]

    En este tutorial aprenderemos a ejecutar el juego que revolucionó el mundillo de los arcades 3D; el primer Quake. Como hemos hecho siempre, comenzaremos con los requisitos necesarios para poder jugarlo. Éstos son los siguientes:

    * Un entorno gráfico (XFree86/Xorg más Xfce, Gnome, KDE, etc).
    * Los archivos .PAK del juego original (explicado más adelante).
    * Tarjeta gráfica aceleradora, con sus controladores instalados y el Kernel configurado para ella.
    * Ganas de jugar a Quake risa.

    Hasta aquí los requisitos, todos ellos obligatorios. Y ahora pasaré a explicar el procedimiento para instalar y ejecutar el juego.

    Lo que tendremos que hacer antes de nada es copiar los archivos .PAK del Quake al directorio donde instalaremos el juego. Para ello, primero hay que instalar el juego en Windows, ya que los ejecutables de Windows no correrán en GNU/Linux.

    Una vez instalado el juego desde Windows, regresaremos a Linux. Montaremos la partición de Windows y nos dirigiremos a la carpeta en la que hayamos instalado Quake.

    $ su root <-- Nos identificamos como root (administrador).
    Password: <-- Introducimos la contraseña del administrador.
    # mount /dev/hda1 /mnt/win98 <-- En este caso montamos la partición de Windows. Si no sabéis cómo se hace, leed el tutorial en el que lo explico.
    # cd /mnt/win98/juegos/quake1
    # pwd
    /mnt/win98/juegos/quake1
    # cd id1
    # ls
    .
    ..
    pak0.pak
    pak1.pak
    autoexec.cfg
    # mkdir ~/juegos/quake1 <-- El símbolo "~" indica "directorio del usuario"; es decir, /home/alberto (es mi nombre de usuario), home/pepito (en el caso del usuario Pepito), etc.
    # mkdir ~/juegos/quake1/id1
    # cp -v *.pak ~/juegos/quake1/id1
    .
    .
    .
    #

    Y ya hemos copiado los dos archivos.
    Ahora, volveremos a identificarnos como usuario normal:

    # exit

    O bien:

    # su alberto <-- En mi caso es "alberto", en el vuestro sería "# su <nombreusuario>".

    A continuación, tendremos que bajarnos de Internet los archivos necesarios para poder jugar a Quake. Para ello, accederemos a la siguiente dirección web:
    LordHavoc's DarkPlaces Quake Modification.

    Y ya en ella, haremos clic sobre el enlace que dice "DarkPlaces engine Windows OpenGL build 20041019" —ésa era la última versión disponible cuando se escribió este manual; Dark Places Engine es un proyecto en desarrollo, así que han ido apareciendo otras más recientes, aunque hasta el momento el método de instalación no ha cambiado—. No os asustéis porque ahí ponga "Windows"; lo que os descargaréis es un ejecutable para Windows, y el código fuente correspondiente.

    Como seguramente muchos de vosotros os estáis imaginando, efectivamente tendremos que compilar este código fuente. Pero tranquilos, que es relativamente sencillo. En esta explicación, Quake sólo podrá ser jugado por nosotros; esto es, por el usuario que compiló el juego, puesto que no lo instalaremos para todo el sistema.

    Una vez descargado el paquete, que se trata de un archivo .zip, lo abrimos, y veremos dos cosas:

    * Por un lado, encontraremos una serie de archivos .dll, .rc, .exe..., los cuales no nos interesan, ya que los EXE no se ejecutan en GNU/Linux.
    * Pero también hay otro fichero .zip, llamado darkplacesenginesource.zip; será precisamente éste, también comprimido, el que nos interesará.

    Descomprimimos este segundo archivo, copiando todo su contenido a la carpeta en la cual queremos instalar el Quake. Una vez hecho esto, nos dispondremos a compilar el engine para poder jugar.

    Para ello, seguiremos los siguientes pasos:

    * Primero, deberemos tener instalado el GCC (no sé si con CPP funcionaría).
    * Después, tendremos que localizar un archivo llamado Makefile (la mayúscula es importante).
    * Si este fichero existe, es que hemos hecho lo correcto hasta ahora.

    Y ahora compilamos el engine (supongamos que instalamos el juego en la carpeta /home/alberto/quake1):

    $ make
    .
    .
    .

    Veremos que aparecen una serie de líneas, que nos indican lo que tenemos que escribir. Según lo que escribamos, obtendremos una cosa u otra. Nosotros deseamos un ejecutable para poder arrancar el juego en forma "cliente", no "servidor dedicado". Así que deberemos escoger la primera de las opciones. Entonces procederemos del siguiente modo:

    $ make debug
    .
    .
    .
    .

    Aparecerán un montón de letras, que indican el progreso de la compilación. Si algo resulta mal, saldrá el error correspondiente, indicando lo que falta. En este caso, yo lo instalé con la opción debug, ya que así me aparecerá en la consola todo lo que el juego va haciendo durante la ejecución, y en caso de que aparezca un error sabré cómo corregirlo.

    Si por el contrario todo ha ido bien, obtendremos los binarios —es decir, los ejecutables para GNU/Linux—, y algunos archivos más. Para ejecutar el juego, escribiremos desde la carpeta de instalación ./darkplaces-glx.

    Y con esto habremos terminado la instalación de Quake. El resto de la configuración del juego se hace igual que en Windows.

    Y finalmente, os pondré unas imágenes del juego corriendo en GNU/Linux, en mi ordenador:

    Aquí vemos el menú principal de Quake.
    [​IMG]

    Quake 2
    Para poder jugar a este fantástico juego realizado por Id Software, necesitaremos copiar a nuestra partición de GNU/Linux los archivos instalados del Quake 2 de Windows. Para ello abrimos una consola de comandos y nos identificamos como root:

    $ su root
    password: <-- Aquí escribimos la contraseña del administrador.
    # <-- Ya estamos identificados como administrador.

    Una vez aquí, montamos la partición de Windows -si no sabéis cómo hacerlo, mirad en el anexo-, y copiamos todos los archivos del Quake 2 al directorio "home" del administrador.

    A continuación deberemos descargarnos de Internet el launcher del Quake 2 para GNU/Linux. Para ello visitaremos la siguiente dirección:
    Index of /quake2/installers

    Y de aquí nos descargamos el archivo llamado: icculus_org_quake2-cdless.run. Una vez descargado, lo ejecutamos. Para ello, iniciaríamos una sesión de consola, y escribiríamos lo siguiente:

    $ su root <-- Nos identificamos como root.
    password: <-- Ponemos la cotraseña.
    # ./icculus_org_quake2-cdless.run <-- Ejecutamos el script (fijaos en que hay que poner "./" -punto barra-).

    Éste es un script que nos copiará los archivos del Quake 2 a un directorio al que todos los usuarios podrán acceder. También compilará los ficheros .SO necesarios, que son librerías legibles por GNU/Linux.

    Y ya está. Para jugar, montamos la unidad de CD-ROM (o DVD), y tecleamos lo siguiente:

    $ quake2 <-- Como usuario normal...

    O bien:

    # quake2 <-- Como administrador.

    El directorio de instalación del Quake 2 ya lo hemos especificado durante la ejecución del script mencionado arriba; el directorio de las partidas guardadas y los archivos de configuración de las teclas se encuentran dentro del directorio personal de cada usuario: por ejemplo, home/pepito/.quake2. Fijaos en el punto antes del nombre del directorio del Quake 2 (.quake2); esto indica que se trata de un directorio oculto.

    En este directorio se almacenan las partidas guardadas y los ficheros .CFG del jugador. Por lo tanto, cada usuario que entre tendrá sus propias partidas y sus propias teclas configuradas, de forma que no interfieren con las de otros usuarios.

    Ahora explicaré cómo configurar los distintos aspectos del juego:

    Para poder escuchar sonido mientras jugamos, tendremos que cerrar todas las demás aplicaciones que lo utilicen.

    Los gráficos soportados por Quake 2 bajo Linux pueden ser con aceleración 3D, o sin ella. Además, está demostrado que ejecutar Quake 2 en GNU/Linux es más rápido que en Windows.

    Para poner aceleración 3D al Quake 2, seleccionaremos el tipo de video denominado "Default 3D SDL". También deberemos -lógicamente- tener instalados los drivers de nuestra tarjeta 3D, las librerías de extensiones SDL, y las extensiones de SDL 3D.

    Si poseéis un ratón con ruedecilla, podéis configurarla también, para que se comporte como un control más. Yo la tengo para que me actúe como zoom. Antes que nada, nos aseguraremos de que tenemos activas la emulación de tres botones y la emulación de scroll. Para ello, habrá que realizar los siguientes pasos:

    Primero, accederemos a la consola de comandos de Quake 2. Una vez dentro del juego, pulsamos la tecla que se encuentra arriba del tabulador y a la izquierda del 1 -suele ser [º]-; aunque si no funciona dicha tecla, siempre podréis entrar a la consola desde el menú "Options" (escogiendo la opción "go to console").

    Y segundo, ya en la consola de comandos, escribimos un bind. Un bind es una asociación de una acción a una tecla. La sintaxis es la siguiente:

    Bind <tecla> <acción>

    Por ejemplo, "bind q quit"; en este caso, cuando pulsemos la tecla Q se ejecuta el comando "quit" (salir del juego). Otro ejemplo sería "bind mouse2 jump" (al pulsar el botón derecho del ratón saltaremos). Entonces, si lo que deseamos es usar la ruedecilla del ratón para hacer zoom y quitarlo, escribiremos el bind de la siguiente forma:

    bind mwheelup fov 20 <-- Para aumentar el zoom.
    bind mwheeldown fov 90 <-- Para quitar el zoom.

    Y para terminar, un ejemplo del juego en marcha.
    En esta imagen vemos el Quake 2 funcionando sin aceleración 3D, y bajo el escritorio Xfce:

    [​IMG]

    Anexo: Montar una partición de Windows

    Aquí aclararé cómo montar la partición de Windows en GNU/Linux. El primer paso es identificarnos como administrador:

    $ su root
    password:
    #

    A continuación crearemos una nueva carpeta, dentro del directorio /mnt, de la siguiente forma (esto no haría falta hacerlo, si ya existiese en /mnt una carpeta "Windows"):

    # mkdir /mnt/windows

    Y ahora, procederemos a montar la partición de Windows:

    # mount /dev/hdXY /mnt/windows <-- Aquí la X equivale a 'a', 'b', 'c'..., indicando estas letras el disco duro en el que está instalado Windows. Por otra parte, la Y equivale a '1', '2', '3'... Estos números hacen referencia a la partición, dentro de ese disco duro, que ocupa Windows.

    Por ejemplo:

    # mount /dev/hda1 /mnt/windows
    Hace referencia al primer disco duro (por la 'a'), y a su primera partición (por el '1').

    # mount /dev/hdb3 /mnt/windows
    Así montaríamos la tercera partición de nuestro segundo disco duro.

    Hexen II

    Bueno, como podéis comprobar, el "linuxero" de pro ha regresado después de unas más que merecidas vacaciones de Semana Santa, y como estoy contento después del descanso —aunque no he descansado mucho, sobre todo por las noches risa—, os obsequio con un nuevo manual... Cómo ejecutar el Hexen 2 bajo GNU/Linux.

    Como siempre hemos hecho, primero estudiaremos los requisitos mínimos, sin los cuales el juego no funcionará:

    * Necesitaremos un ordenador con lo siguiente: AMD/Pentium a 200 MHz por lo menos (300 MHz recomendados), 64 MB de memoria RAM, 200 MB libres en el disco duro, y una tarjeta gráfica para quién desee aceleración 3D.
    * Las librerías SDL, y el Kernel compilado con soporte 3D, con todos sus módulos y extensiones, para quién desee aceleración 3D.
    * Drivers de sonido para dar soporte a ALSA.
    * El CD-ROM de Hexen 2 o Hexen 2: Hammer of Thyrion. (Obligatorio para la instalación, opcional para la música ambiental del juego).

    Y hasta aquí los requerimientos mínimos. Ahora, para correr Hexen 2 en GNU/Linux necesitaremos el siguiente material:

    * El CD-ROM de instalación del juego.
    * El launcher de Hexen 2 para GNU/Linux, que descargaremos de Sourceforge.

    Este launcher hace lo mismo que el de Quake 2 (explicado en el tutorial correspondiente). Abrirá los archivos .dll del juego y los compilará de nuevo en formato .so, legible por GNU/Linux. Además, creará un fichero ejecutable para que podamos arrancar el juego, y copiará todos los archivos necesarios desde el CD-ROM.

    Una vez descargado el launcher —que son cerca de 13 MB—, abrimos una consola de comandos, y nos identificamos como root (administrador):

    $ su root
    Password:
    #

    Y ya estamos como administrador. Ahora nos dirigimos al directorio dónde hayamos descargado el launcher. Si, por ejemplo, lo hemos descargado en /home/alberto/downloads, escribimos:

    # cd /home/alberto/downloads

    Una vez dentro de este directorio, simplemente ejecutamos el launcher, y la instalación comenzará. Para ello, escribimos:

    # ./hexen2*run

    Como podéis ver, el archivo que nos descargamos tenía un nombre bastante más largo. Sin embargo, no resulta necesario escribirlo completo para ejecutarlo, ya que el * (asterisco) es un carácter comodín. Esto quiere decir que el * sustituye a una cadena de carácteres. Por ejemplo, escribiendo hexen2*run, el propio Linux busca todos los archivos que comiencen por "hexen2" y terminen en "run".

    En este caso, como sólo hay uno, únicamente se ejecutará ése. Si hubiesen más ficheros que siguiesen el mismo patrón, se ejecutarían todos en orden alfabético.

    Durante la instalación se nos pedirá la carpeta de destino de los archivos del juego, de los links para ejecutarlo y las entradas en el panel de KDE y GNOME. Es recomendable que dejéis estos datos tal y como vienen. Pulsad "siguiente" para comenzar la copia de archivos.

    Finalizada ésta, simplemente tendréis que escribir hexen2 en la consola para jugar.

    Como podéis comprobar, el proceso es bien sencillo, aunque puede que dé algunos problemas con el Hexen 2. Pero si habéis conseguido arrancar el Quake 2, no deberíais tener inconvenientes con este otro juego.

    Además, todas las caraterísticas del juego original para Windows están disponibles también en GNU/Linux.

    Y a continuación os dejo unos cuantos screenshots del juego corriendo bajo mi queridísimo Linux.

    Éste es el launcher del Hexen 2 una vez instalado. Como podéis ver, permite cambiar ciertos parámetros del juego, y del motor gráfico en sí:
    [​IMG]

    Wolfenstein 3D

    Pues eso; ¿queréis echaros unas partidillas al Wolfenstein 3D? Aquí explicaré las alternativas que tenemos para hacer funcionar en GNU/Linux este clásico inmortal de Id Software. Alternativas que vienen a ser tres: la recomendable, la fácil y la menos fácil. Escoger una u otra depende de las preferencias de cada cuál y de las posibilidades de su ordenador.

    Bueno, vamos a ello...
    Lo recomendable...

    Dejarse de rollos y ejecutar Wolfenstein 3D con un emulador. Hoy por hoy, cuando el que más o el que menos dispone de un Pentium III con un montón de megahertzios, es una opción muy asequible. Wolfenstein 3D funciona perfectamente en DOSBox o en Dosemu —yo mismo lo he probado en Dosemu con una máquina P2/350 MHz, y era más o menos jugable—. De este modo podremos disfrutar del juego con sus gráficos y sonidos originales sin calentarnos demasiado la cabeza...

    La emulación con DOSBox es más completa; el inconveniente está en que se necesita una máquina un poco más potente que con Dosemu. Pero bueno, insisto; esto sólo significa un problema con los ordenadores más viejos. Los jugones más atrevidos incluso pueden probar correr el Wolfenstein 3D con el puerto NewWolf, emulándolo con Wine.

    De todas maneras no he escrito este manual para ponerme a hablar sobre emuladores. Es todo un mundillo, y quienes no sepan usarlos y quieran aprender deberían buscar en otro lado los tutoriales oportunos.
    Lo fácil...

    Se trata de usar el puerto WolfGL, que podéis descargar de su página oficial (WolfGL Home), aunque también está disponible en Arcades 3D. Y lo mejor, no resultará necesario compilar código fuente ni nada similar; WolfGL se distribuye en varios archivos ejecutables, dos para Wolfenstein 3D —uno para la demo y otro para la versión completa— y otros tantos para Spear of Destiny, que basta con colocar en la carpeta dónde instalemos los juegos originales.

    Los requerimientos se resumen pronto: una copia de Wolfenstein 3D o Spear of Destiny, y una tarjeta gráfica correctamente instalada y configurada —puesto que WolfGL, como su nombre indica, usa renderización por OpenGL—. Respecto al primer punto, cuidado, porque se publicaron diferentes versiones del Wolfenstein 3D, y WolfGL sólo funciona en principio con la 1.4.

    Para jugar, basta con copiar los ficheros originales del juego en cuestión en la carpeta que deseemos (por ejemplo, /home/condemor/wolf3d), y añadir después el ejecutable correspondiente del WolfGL. Luego sólo queda ejecutarlo; desde una consola de comandos, sin ir más lejos:

    $ cd wolf3d
    $ ./wolfgl

    Y a funcionar...

    Podemos modificar la resolución por defecto y ejecutar WolfGL en ventanas de diversos tamaños, mediante los parámetros -width y -height:

    $ ./wolfgl -width 800 -height 600 <-- Abre WolfGL en una ventana de 800x600.

    ¿Los inconvenientes? Pues mayormente que WolfGL es un proyecto viejo, al parecer abandonado desde hace tiempo, y no está muy pulido. Los sprites renderizados con OpenGL lucen a veces un tanto feos; y lo peor, el puerto no incluye soporte para la música, por lo que nos quedaremos sin oir los magníficos midis del juego.
    Y lo menos fácil...

    También tenemos la posibilidad de utilizar el puerto que preparó en su día la gente de Icculus.org. El problema está, al igual que ocurría con WolfGL, en que no es todavía un trabajo muy depurado; así, ni el sonido ni la música están implementados —actualización: he vuelto a descargar el código de Icculus.org en noviembre de 2006, y ahora sí hay soporte para el sonido y la música, usando OSS—. Si a pesar de esto os decidís por esta opción, seguid leyendo...

    Lo primero que deberíamos hacer es descargarnos el código fuente. Éste se encuentra disponible en Icculus.org (concretamente, en la página Wolfenstein 3D Linux), y podemos obtenerlo desde el repositorio SVN —antiguamente usaban CVS, pero hace poco lo han sustituido por Subversion—, o bien bajarnos el archivo comprimido que contiene la edición de octubre de 2001, cuya dirección es http://www.icculus.org/wolf3d/wolf3d-20011028.tar.gz. Quizás sea más recomendable la primera opción, dado que con SVN conseguiremos la versión más actualizada posible del código, y parece que recientemente han hecho cambios importantes, como añadir el soporte para el sonido.

    También podéis obtenerlo de Arcades 3D; se trata de una copia descargada del directorio SVN en noviembre de 2006.

    En el caso de decantarnos por el SVN necesitaremos algún programa especial para ello... No debería ser un gran problema, ya que la mayoría de las distribuciones de uso general de GNU/Linux incluyen alguno, o al menos lo tendrán disponible para instalar desde sus respectivos repositorios de paquetes.

    Por ejemplo, utilizando el cliente SVN desde una consola de comandos, escribiríamos lo siguiente:

    $ cd juegos
    $ svn co svn://svn.icculus.org/wolf3d/trunk wolf3d-fuentes

    Con estos comandos descargaríamos el código fuente desde Icculus.org y lo guardaríamos en una nueva carpeta llamada wolf3d-fuentes, alojada dentro de juegos.

    Bien, sea cuál sea nuestro método para conseguirlo (SVN para los más rebuscados, algún fichero comprimido para quién no quiera complicarse la vida...), probablemente nos encontraremos con varias carpetas; éstas son docs, src y macsrc.

    Estos directorios podemos colocarlos dónde mejor nos convenga. En el ejemplo anterior se encontrarían en /home/miusuario/juegos/wolf3d-fuentes; y en la consola de comandos tendríamos algo así:

    $ cd wolf3d-fuentes
    $ pwd
    /home/miusuario/juegos/wolf3d-fuentes
    $ ls
    docs
    src
    macsrc

    Más que nada, para hacernos una idea de cómo está esto organizado; las tres carpetas del código fuente del juego se hallan dentro de /home/miusuario/juegos/wolf3d-fuentes. ¿Fácil no? El siguiente paso, evidentemente, será compilarlo..., pero antes, detengámonos en los requisitos mínimos necesarios.
    Requisitos

    Básicamente son los siguientes:

    * Librerías SDL, versión 1.2 o superiores.
    * Copia del Wolfenstein 3D o Spear of Destiny originales —aunque sólo nos interesan los archivos de datos del juego—. Algunas versiones del Wolfenstein 3D pueden no funcionar correctamente; lo mejor es que uséis la 1.4.

    Respecto a las librerías SDL, probablemente vendrán incluidas "de fábrica" en tu distribución. Y de lo contrario, ya sabéis; usad Apt-get u otros gestores de paquetes similares. O si lo preferís, acercaros por Simple DirectMedia Layer..., aunque, insisto, no creo que sean muchos los que tengan que preocuparse por instalar las SDL.

    En mi caso, —yo utilizo Vector Linux—, la cosa sería más bien así, usando la consola de comandos:

    $ su
    Password:
    # slapt-get --install SDL*

    Aunque no he tenido el placer de comprobarlo :risa:; las SDL vienen por defecto en la instalación habitual de Vector Linux. Así que un dolor de cabeza menos...
    Compilación

    Bueno, y ahora que tenemos listas las librerías SDL, ya podemos ponernos manos a la obra. Aunque debemos tener en cuenta una cosa; el puerto para GNU/Linux de Wolfenstein 3D es compatible en realidad con varios títulos y versiones de ellos: el Wolfenstein 3D original, la edición shareware, y también Spear of Destiny y su respectiva demo. Y antes de compilar nada, tendremos que especificar cuál vamos a usar.

    Para ello, hay un archivo llamado version.h, dentro de la carpeta src. Habrá que editarlo y cambiar un pequeño valor. Veámoslo:

    $ cd src
    $ pwd
    /home/perez/juegos/wolf3d/src
    $ vi version.h

    Bueno, quién dice Vi dice Beaver o cualquier otro editor de texto...

    La edición que tenemos que hacer es muy sencilla, y cualquier persona un poco despierta tendrá más que suficiente con los comentarios que incluye el propio archivo. Pero por si acaso, lo comentamos rápidamente.

    Hay que buscar tres líneas, en la mitad superior del fichero:

    #ifndef WMODE
    #define WMODE 3 <-- O "2", o "1", etc.
    #endif

    El número que sigue a "#define WMODE" indica la versión de Wolfenstein 3D o Spear of Destiny para la que queremos compilar el puerto. Los valores pueden ser los siguientes:

    * 0: Wolfenstein 3D shareware (archivos de datos con cabecera .WL1).
    * 1: Wolfenstein 3D completo (archivos de datos con cabecera .WL6).
    * 2: Demo de Spear of Destiny (archivos de datos con cabecera .SDM).
    * 3: Spear of Destiny (archivos de datos con cabecera .SOD).

    Basta con cambiar el valor que venga preestablecido —0, o el que sea— por uno de estos cuatro números, dependiendo del juego en concreto que nos interese. Y con esto ya podemos compilar tranquilamente el código:

    $ pwd
    /home/miusuario/juegos/wolf3d-fuentes/src
    $ make
    .
    . <-- (Montones de letras y números).
    .
    $

    Esto es bastante rápido. Cuando la compilación termine, tendremos en el directorio src un archivo ejecutable llamado sdlwolf3d. Como somos gente ordenada, lo movemos a una carpeta vacía a nuestra elección, que será la ubicación definitiva del juego:

    $ mv sdlwolf3d /home/miusuario/juegos/wolf3d
    Sonido y música

    Llegados a este punto, conviene aclarar que, por defecto, se compila una versión sin sonido del juego. Si queremos sonido, tendremos que modificar también el archivo src/Makefile, aunque no temáis, es algo muy sencillo. Así, lo abrimos con cualquier editor de texto, y buscamos las siguientes líneas —son el tercer o cuarto párrafo—:

    # no sound
    OBJS += sd_null.o
    # sound using OSS
    #OBJS += sd_oss.o fmopl.o
    #CFLAGS += -D_REENTRANT
    #LDLIBS += -lpthread

    Sí, es justo lo que estáis pensando; comentamos la línea "OBJS += sd_null.o" y quitamos las almohadillas que preceden a las que hay bajo de "# sound using OSS". De este modo, nos quedaría algo así:

    # no sound
    #OBJS += sd_null.o
    # sound using OSS
    OBJS += sd_oss.o fmopl.o
    CFLAGS += -D_REENTRANT
    LDLIBS += -lpthread

    Y tras hacer estos cambios, guardamos el archivo y procedemos a compilar el código tal y como hemos visto arriba, usando el comando make.
    Instalación

    Una vez compilado el puerto de Icculus —con soporte para sonido o sin él—, sólo nos quedaría copiar a la carpeta dónde dejamos el fichero sdlwolf3d los archivos de datos del juego original —que se supone que tenemos :risa:—. Éstos son los siguientes, aunque como ya he comentado antes, la cabecera cambia según el juego que estemos instalando; WL6 para Wolfenstein 3D, SOD para Spear of Destiny, etc:

    * audiohed.wl6
    * audiot.wl6
    * config.wl6
    * gamemaps.wl6
    * maphead.wl6
    * vgadict.wl6
    * vgagraph.wl6
    * vgahead.wl6
    * vswap.wl6

    Cuidado, no olvidéis que estáis usando un sistema tipo Unix, y que por lo tanto "config.wl6" no es lo mismo que "CONFIG.WL6"; los archivos anteriores deben estar en minúsculas, o el puerto no los encontrará. Lo comento para evitar a más de uno algún dolor de cabeza estúpido...

    Y ahora ya podemos jugar... Ejecutemos sin más el fichero sdlwolf3d:

    $ ./sdlwolf3d

    El juego arrancará en una pequeña ventana, pero debería ser posible ponerlo a pantalla completa pulsando al mismo tiempo [ALT] y [INTRO]. Si no, podemos ejecutarlo del siguiente modo:

    $ ./sdlwolf3d -fullscreen

    Y bueno, ahora deleitémonos con algunas capturas de pantalla:

    Aquí vemos el Spear of Destiny ejecutándose con el puerto WolfGL, en mi escritorio FluxBox...
    [​IMG]

    Shadow Warrior

    ¿Recordáis Shadow Warrior? Fue el siguiente juego publicado por 3D Realms, tras Duke Nukem 3D; en él manejábamos a una especie de ninja vacilón llamado Lo Wang, que luchaba contra la malvada corporación Zilla y sus esbirros. Pues bueno, hará cosa de un año se liberó su código fuente... Y ni cortos ni perezosos, tanto la gente de Icculus.org como Jonathon Fowler —autor del puerto JFDuke3D— sacaron rápidamente sendas versiones para GNU/Linux.

    Bien, aquí comentaré el modo de jugar a Shadow Warrior con el puerto JFSW, desarrollado por Jonathon Fowler, que es en realidad la única opción asequible. El puerto de Icculus.org se trata de algo experimental y no está lo suficientemente maduro para jugar con él... Si alguien quiere probarlo, allá él; yo ni siquiera he conseguido compilarlo.
    Requisitos

    Bueno, pues en principio necesitaremos las siguientes librerías. En cualquier distribución moderna de GNU/Linux de uso general —dejando aparte minidistros como Damn Small Linux y similares— vendrán ya instaladas todas o casi todas:

    * libSDL 1.2 o superior.
    * libgtk-x11 2.0 o superior.
    * libPango 1.0 o superior.
    * libglib 2.0 o superior.
    * libSDL_mixer 1.2 o superior.
    * libcairo.
    * libfreetype.
    * libvorbis.
    * libogg.

    Además, necesitaremos una máquina con, al menos, 32 MB de RAM y un procesador a 133 MHz... Bueno, ya me imagino que esto no será un problema; basta con un ordenador que no se esté cayendo a pedazos de puro viejo. Y si disponemos de aceleración gráfica, mejor que mejor, aunque no es imprescindible.
    Configuración e instalación

    Bueno, tenemos dos opciones. Descargarnos el código fuente del JFSW y compilarlo por nuestra cuenta, u obtener directamente unos binarios listos para usar. Ésta última es la opción más sencilla y cómoda para la gente que no quiera calentarse demasiado la cabeza, así que la comentaré en primer lugar.

    Bien, podéis conseguir los binarios de Arcades 3D —mirad en la sección "Linux"—. Los compilé yo mismo, aplicando de paso los parches necesarios para activar el sonido —JFSW todavía no incluye soporte de forma oficial, aunque parece que en la próxima versión esto cambiará—.

    Quizá la forma más práctica de descargarlos sea abriendo una consola de comandos y usando Wget, aunque cada uno tiene sus costumbres... En el siguiente ejemplo, creamos una carpeta para almacenar el Shadow Warrior y nos bajamos el archivo comprimido con los binarios:

    $ mkdir juegos
    $ cd juegos
    $ mkdir swarrior
    $ cd swarrior
    $ wget http://www.arcades3d.com/linux/jfsw-20051009-bin.tar.bz2

    Ahora hay que descomprimir el fichero que acabamos de descargar:

    $ tar -jxvf jfsw_binarios_09102005.tar.bz2
    $ ls
    .
    . <-- Cuatro o cinco ficheros, entre ellos sw y build.
    .
    $

    Ahora tendremos unos pocos archivos en nuestro recién creado directorio, entre ellos dos ejecutables; sw nos servirá para comenzar una partida a Shadow Warrior, y build para cargar el editor de mapas.

    Pero para esto necesitaremos una copia del Shadow Warrior original. El juego puede encontrarse en algunas páginas dedicadas al abandonware; sin ir más lejos podéis mirar aquí en Arcades 3D, o en 3D Shooter Legends, entre otros sitios... En realidad no hace falta todo el contenido del juego; basta con los siguientes archivos —ojo a las minúsculas—:

    * tables.dat
    * sw.grp

    Sólo con estos dos ya deberíamos jugar y editar mapas sin problemas —al fin y al cabo el juego propiamente dicho, los niveles, armas, enemigos y demás, está guardado en el archivo sw.grp—. No obstante, quizás alguien necesite también algún otro, como sw.rts o sw.cfg; aunque ya digo que en principio no hacen falta.

    En fin, simplemente copiamos los archivos necesarios a la carpeta en la que descomprimimos los binarios. Y ya en ella, para comenzar una partida basta con ejecutar:

    $ ./sw

    O para cargar el editor de mapas Build:

    $ ./build

    Y bueno, nada más. Que disfrutéis del juego... Sólo me quedaría por comentar que las partidas guardadas y las capturas de pantalla que hagáis se guardan en una carpeta oculta, situada en ˜/.jfsw.

    Antes de que se me olvide: el sonido tiene cierto bug, bastante incómodo, que puede hacer que el Shadow Warrior se quede colgado, acaparando memoria RAM y recursos del procesador hasta ser interrumpido por el propio sistema. Esto sólo sucede cuando la opción "Ambience" —dentro del menú "Sound"— está activada; así que lo primero que deberíais hacer al arrancar el juego es aseguraros de desactivarla.

    Por supuesto, no pueden faltar un par de capturas de pantalla.
    Por ejemplo, aquí tenéis el juego recién cargado y con el menú de presentación, corriendo en Vector Linux y mi escritorio Fluxbox:

    [​IMG]

    Unreal Tournament


    Llevaba mucho tiempo queriendo escribir este tutorial, porque Unreal Tournament es un juego que me gusta bastante. El problema era mi ordenador, una máquina de segunda mano con una tarjeta Intel, integrada, y sin aceleración gráfica... Pero mi buen amigo Anarko sí posee el sistema adecuado para jugarlo, y hace unos días pasamos una entretenida tarde intentando instalar Unreal Tournament en su Linux. Así que aquí va nuestra experiencia.

    Unreal Tournament fue creado por los programadores de Epic, y se publicó en 1999; también se le llama UT99, para diferenciarlo de las secuelas que han ido apareciendo posteriormente. Se trata más bien de una variante del primer Unreal enfocada a las partidas por Internet. Los paisajes monumentales y la exploración relajada que hicieron a su antecesor tan especial —o tan aburrido, según algunos— se ven sustituidos aquí por una acción frenética contra bots y jugadores de la otra punta del mundo. Deathmatch en sus diversas variantes, vaya.

    Bien, Unreal Tournament puede jugarse en Linux de forma nativa. El modo de hacerlo no es tan obvio como parecía, surgieron algunos errores inesperados... Pero, con todo, no es difícil de instalar.

    Me queda decir que existen dos ediciones del juego: la normal, y la GOTY (de "game of the year"). La diferencia es que el Unreal Tournament GOTY se distribuía en dos discos, uno con el juego en sí y otro con texturas en alta resolución y mapas añadidos. Nosotros instalamos el Unreal Tournament original; sin embargo, lo que comentaremos aquí se aplica, a grandes rasgos, también a la edición GOTY.
    Requisitos

    Como siempre, veremos primero los requisitos necesarios para instalar y disfrutar el juego. Son los siguientes:

    * Linux con un kernel 2.2.x o superior —a día de hoy, cualquier Linux que tenga menos de diez años—.
    * Librerías SDL.
    * Librería libmikmod —en realidad creo que no es imprescindible, pero sin ella no escucharéis la música del juego—.
    * CD de Unreal Tournament. O CDs, en plural, si tenéis la edición GOTY.
    * Instaladores del juego para Linux.

    Tanto SDL como libmikmod vendrán ya instaladas en la mayoría de las distribuciones grandes de Linux. Y si no es así, seguramente podréis descargarlas sin complicaciones con vuestros gestores de paquetes —Synaptic, Apt, etc—.

    Los instaladores para Linux son dos: uno para la versión original de Unreal Tournament —buscad ut-install-436.run—, y otro para la edición GOTY —ut-install-436-goty.run—. Necesitaréis uno u otro, dependiendo de la edición del juego que queráis instalar. Más sobre ellos un poco más abajo.

    Por último, para jugar también vais a necesitar una máquina con lo siguiente:

    * Procesador Pentium II o superior.
    * 64 MB de memoria RAM (128 MB recomendados).
    * Tarjeta gráfica con aceleración 3D —en Linux el juego usa OpenGL—.
    * Tarjeta de sonido compatible con OSS/ALSA.
    * Un mínimo de 550 MB de espacio libre en el disco duro.

    Naturalmente, damos por supuesto que tenéis vuestra tarjeta gráfica bien configurada en Linux; y también que estáis usando un sistema de escritorio con Xorg/XFree86 —si puedes leer esto en una ventanita de colores en tu monitor probablemente lo tienes, a no ser que estés usando alguna distro exótica configurada con alternativas como TinyX o SVGAlib—.
    Descargando los instaladores

    Antes dije que hay que descargar un instalador para Linux de Unreal Tournament, y que hay dos de ellos, correspondientes a la edición original del juego y a la GOTY. Bien, pues podéis conseguirlos de los enlaces que nombraré a continuación. Aunque tampoco son difíciles de encontrar en Google:
    Para el Unreal Tournament original

    El archivo necesario se llama ut-install-436.run, y lo podréis descargar de los siguientes sitios de Internet:

    * Download UT Linux Retail v436 Patch
    * ut-install-436.run - Download Unreal Tournament v4.36 patch for Linux. This patch include
    * http://www.gamershell.com/outofhell/beyondunreal/official/ut/ut-install-436.run
    * ftp://beyondunreal.gameservers.net/official/ut/ut-install-436.run
    * http://modrzew.info/download/ut-install-436.run

    Para la edición "Game of the Year" (GOTY)

    El instalador que os interesa tiene el nombre de ut-install-436-goty.run. Clicad en alguno de los siguientes enlaces para descargarlo:

    * Download Unreal Tournament ut install 436 GOTY.run
    * ut-install-436-goty.run - GamersHell.com Third Parties Download Section - GamersHell.com
    * ftp://beyondunreal.gameservers.net/official/ut/ut-install-436-goty.run
    * http://mirrors.dotsrc.org/lokigames/beta/ut/ut-install-436-GOTY.run

    Configuración e instalación

    ¿Ya tenéis todo lo necesario? ¿El disco del juego, el instalador para Linux, y las librerías mencionadas anteriormente? Pues nada, manos a la obra.

    Vamos a suponer que habéis descargado el instalador en la carpeta /home/miusuario/ut.
    Montamos el CD-ROM del juego

    Lo primero es abrir una terminal, insertar el CD del juego, y montarlo para que el instalador lo pueda leer. En la mayoría de las distribuciones modernas de Linux —Ubuntu, por ejemplo— los CDs se montan automáticamente al meterlos en el lector, así que podríais pasar al siguiente paso... En fin, si podéis examinar el contenido del CD con un explorador de archivos, está montado. De lo contrario, tendréis que escribir un comando como éste:

    $ mount /dev/cdrom

    En mi caso al menos es así. Esto depende mucho de cómo esté configurado vuestro sistema, del contenido de vuestro archivo /etc/fstab y de otros detalles de los que suelen ocuparse los creadores de cada distribución de Linux. Pero insisto en que en cualquier sistema razonablemente moderno los CDs se montan solos...
    Ejecutamos el instalador

    En fin, ya con el CD montado, accedemos a la carpeta donde dejamos el instalador y le damos permisos de ejecución:

    $ cd /home/miusuario/ut
    $ chmod a+x ut-install-436.run

    Y ahora accedemos a la cuenta del administrador, y lo ejecutamos:

    $ su
    Password:
    # ./ut-install-436.run --keep

    Ojo, hay distribuciones de Linux, como Ubuntu, en las que no existe cuenta de administrador... Los comandos que necesitan ejecutarse de este modo se arrancan con sudo. Así, por ejemplo:

    $ sudo ./ut-install-436.run --keep

    Dependiendo de vuestro sistema, el instalador puede ejecutarse sin problemas, o pueden surgir errores indescifrables. En mi Vector Linux 5.9 arranca sin inconvenientes, pero en el Ubuntu 8.04 de mi amigo Anarko hubo que hacer algunos ajustes. Veamos algunos errores frecuentes y el modo de resolverlos.
    Primer error misterioso

    Precisamente, hemos usado la opción --keep para esquivar el primero de estos errores. No sé para qué sirve ni qué es exactamente lo que hace. Pero suele suceder que, si ejecutáis el instalador así:

    # ./ut-intall-436.run

    ...Se interrumpa al cabo de unos segundos con un mensaje como éste —en mi ordenador—:

    Uncompressing Unreal Tournament version 436 Linux installtrap: usage: trap [lp] [arg signal_spec ...]

    O este otro —en Ubuntu 8.04—:

    Uncompressing Unreal Tournament version 436 Linux installtrap: 154: cd /tmp; /bin/rm -rf $tmpdir; exit $res; bad trap

    Y el modo de evitarlos es precisamente arrancar el instalador escribiendo esa opción --keep. Quién lo hubiese adivinado... Desde aquí sólo me queda agradecer a Alejandro la entrada sobre el tema que escribió en Demonios y Pingüinos.
    Segundo error misterioso

    Otra cosa que puede suceder es que la ejecución del instalador se interrumpa con el siguiente mensaje abominable —o similar—:

    Verifying archive integrity...tail: no se puede abrir «+6» para lectura: No existe el fichero o el directorio.

    Esto tiene un remedio, y es ejecutar el instalador de la siguiente manera:

    # export _POSIX2_VERSION=199209
    # ./ut-install-436.run --keep

    En Ubuntu me tropecé con este problema, pero en mi Vector Linux no. Desconozco la razón. Parece que en algún sitio —¿tail, tal vez?— se ha roto la compatibilidad hacia atrás con versiones más viejas...
    Esperamos a que el instalador termine

    Bueno, resueltos estos errores el instalador del juego debería funcionar sin problemas. Puede ejecutarse en modo texto en una terminal, o en una ventanita del escritorio. En cualquiera de los dos casos, las cuatro opciones que hay se explican por sí mismas.

    El instalador propone instalar el juego en el directorio /usr/local/games/ut, y los ejecutables para arrancarlo en /usr/local/bin. No os aconsejo que lo cambiéis, a no ser que tengáis claro qué estáis haciendo y por qué.

    La gran mayoría de vosotros querrá usar OpenGL como modo gráfico por defecto, o "default renderer"... Y también tendréis que decir que sí a "Instalar Binary Files" e "Instalar Data Files".

    Y bueno, cuando el instalador comience la tarea y vuestro lector de CD-ROM empiece a trabajar, sólo queda esperar...
    Antes de arrancar el juego

    Cuando el instalador termine, tendréis Unreal Tournament esperando en vuestro disco duro. ¿Listo para jugar? Pues tal vez..., o tal vez no. Podéis averiguarlo ejecutando el juego desde la terminal:

    $ ut

    Si todo va bien, felicidades. De lo contrario, seguid leyendo.
    Tercer error misterioso

    Puede que el juego no cargue, y os encontréis en la terminal con un error como éste:

    dirname: missing operand
    Pruebe `dirname --help' para más información.
    Couldn't run Unreal Tournament (ut-bin). Is UT_DATA_PATH set?

    Lo que pasa aquí es que el juego requiere una variable (UT_DATA_PATH) que no está especificada. Para corregir esta situación, sin salir de la terminal, teclearemos:

    $ export UT_DATA_PATH=/usr/local/games/ut/System

    Y procederemos a arrancar el juego como antes.

    Esto habría que hacerlo cada vez que queramos jugar a Unreal Tournament. Cosa que sería un coñazo; alguien estará pensando, "¿de verdad tengo que escribir toda esa mierda antes de poner en marcha el juego?". Y la respuesta es... ¡No! Simplemente crearemos un script que lo haga por nosotros.

    Abrid un editor de texto y teclead en él lo siguiente:

    #!/bin/bash
    export UT_DATA_PATH=/usr/local/games/ut/System
    ut

    Lo guardáis con el nombre de unreal, le dais permisos de ejecución, y lo movéis al directorio /usr/local/bin:

    $ chmod +x unreal
    $ su
    Password:
    # mv unreal /usr/local/bin

    Y de este modo, cada vez que queráis ejecutar el juego, bastará con que abráis una terminal y escribáis:

    $ unreal
    Cuarto error misterioso

    Una vez solucionado el problema anterior, después de haber creado el susodicho script y de usarlo para arrancar el juego, es posible que Unreal Tournament siga negándose a funcionar. Ahora, con esta excusa:

    Failed to load `Entry': Can't find file `Entry'
    Failed to load `Level None.MyLevel': Can't find file `Entry'
    appError called:
    Failed to enter Entry: Can't find file `Entry'

    Esto sucede porque el instalador ha copiado los mapas del juego comprimidos. Si listáis el contenido del directorio /usr/local/games/ut/Maps, veréis que todos los archivos que se guardan ahí —los niveles— tienen una extensión .unr.uz.

    Bien, habrá que descomprimirlos —¿que por qué esto no se hace automáticamente al instalar el juego? Hmm, buena pregunta—. Para ello, entraremos en la cuenta del administrador y usaremos ucc, un descompresor hecho a propósito para esto que se incluye con Unreal Tournament, y que se instala en el sistema junto con el juego.

    Quiero decir, algo así:

    $ su
    Password:
    # export UT_DATA_PATH=/usr/local/games/ut/System
    # cd /usr/local/games/ut/Maps
    # for i in *unr.uz; do ucc decompress ../Maps/$i; done

    Esto tardará un rato.

    Lo que hemos hecho ha sido crear una lista con todos los ficheros .unr.uz de la carpeta Maps —mediante la orden for i in *unr.uz— e ir descomprimiéndolos uno por uno —ucc decompress ../Maps/$i—. (Hablando con propiedad, for no "crea listas", sino bucles que avanzan de forma recursiva; algo como "por cada uno de éstos, haz esto otro que indico aquí". Pero como explicación rápida e improvisada para la gente que no programa ordenadores creo que, más o menos, sirve).

    Los mapas descomprimidos, en contra de lo que podríamos esperar, no se guardarán en la carpeta Maps del juego, sino en la carpeta personal del usuario que los haya descomprimido. Como en este caso se trataba del administrador, estarán en /root/.loki/ut/System.

    Así que procedemos a moverlos al árbol de directorios del juego en /usr/local/games/ut:

    # pwd
    /usr/local/games/ut/Maps
    # mv /root/.loki/ut/System/*unr .

    Y si queréis ahorrar espacio en el disco duro, podéis borrar los mapas comprimidos, que ya no os servirán de nada:

    # rm *unr.uz
    Misión cumplida

    Y ya está. A falta de más "errores misteriosos", ya deberíais poder disfrutar sin inconvenientes de Unreal Tournament. Si encontráis algún problema que no esté explicado aquí siempre podéis pedir auxilio en el foro de Arcades 3D, donde quizás alguien sepa cómo ayudaros. Yo he descrito aquí el proceso de instalación de Unreal Tournament en el Ubuntu de mi amiguete Anarko, y lo que más tarde vi en mi propio ordenador —Vector Linux 5.9—.

    La verdad es que el juego tiene un funcionamiento impecable bajo Linux, siempre y cuando lo pongáis a pantalla completa —en una ventana de escritorio resulta poco práctico, porque hay que mantener el puntero del ratón dentro de ella—.

    Nada más. A correr...

    [​IMG]

    Tutoriales escritos por: Karnizero y Eye del Cul


    Pronto iré actualizando _ok
     
    #1
  2. Perito

    Perito Señor Miembro

    Ingreso:
    27/Ene/2006
    Mensajes:
    306
    Ubicación:
    En arjentina
    gracias, esto me sirve un montón
     
    #2
  3. Ciclón de Hojas

    Ciclón de Hojas Moonlight Ice Wizzard

    Ingreso:
    12/Ago/2004
    Mensajes:
    5.909
    Ubicación:
    Redwood City, SL
    De nada pronto agregaré mas info ;)
     
    #3
  4. Daedalus

    Daedalus Cuevino Milenario

    Ingreso:
    31/Dic/2009
    Mensajes:
    1.457
    WTF??? Y estos quienes son? xD

    Bueno, lindos tutoriales, te pego lo del linux parece, como granito de arena, tambien se pueden jugar varias AG en linux con el ScummVm tambien, solo instalenlo con su gestor de paquetes favorito, y haganse una carpeta en el home con los juegos, despues van a ScummVm, mantienen apretada la tecla shift, y el boton "Add Game" se convertira en el boton "Mass Add", clic en este boton, van a donde estan todos los juegos y le dan a Add, y se les agregan todos los juegos que tengan. Y ya estan listos para jugar!! _ok
     
    #4
  5. Ciclón de Hojas

    Ciclón de Hojas Moonlight Ice Wizzard

    Ingreso:
    12/Ago/2004
    Mensajes:
    5.909
    Ubicación:
    Redwood City, SL
    Los que escribieron el tutorial xD

    Iba a agregar tu información al post pero resulta que es demasiado grande para abrirlo xD
     
    #5
    Última modificación: 11/Nov/2013
  6. djleoli

    djleoli bebiendo retro

    Ingreso:
    4/Sep/2005
    Mensajes:
    937
    Ubicación:
    en fastfileshare
    tanbien se puede jugar perfecto al geneseis con gens y al play 1 con epsxe :D
     
    #6
  7. tfontana82

    tfontana82 n00b

    Ingreso:
    28/Dic/2011
    Mensajes:
    1
    Hola, estuve tratando de instalar doom legacy y no pude, no se que es eso de kernel, me podrias explicar un poco mas, ya instale doom y le copie el archivo doom2.wad, pero a la hora de ejecutar los $ lsld... -IWAD me da un error. Yo tengo ubuntu 10.04 LTS - la versión Lucid Lynx, no se si sera otro comando el que tenga que utilizar.

    Gracias!

    Tomás.
     
    #7
  8. Tavo

    Tavo No one

    Ingreso:
    25/Abr/2006
    Mensajes:
    6.030
    Tenés que ejecutarlo asi

    Código:
    lsdldoom -IWAD doom2.wad
    Si asi no te funciona copiá el error que te da asi sabemos por donde viene el problema.

    PD: Bienvenido!
     
    #8

Compartinos

Cargando...