Antes de enseñaros a hacerlos, prefiero que ayudaros a buscar los que ya hay. Enseñaros también a abrirlos y a sacar provecho de ellos.

Los primeros que debeis conocer son los propios del juego. En la carpeta baseq3 hay 9 archivos pk3 que van del pak0 al pak8. Esos están creados por los técnicos de ID y por lo tanto por profesionales. De estos archivos podréis aprender mucho más de lo que yo os pueda enseñar.

Un pk3 no es más que un zip disfrazado. Para abrirlos lo único que hay que hacer es copiarlos fuera del baseq3 (en nuestra querida carpeta Quake por ejemplo) y sustituir el .pk3 por .zip, así de fácil. Por supuesto Windows nos pondrá un obstáculo para hacerlo. Si estáis en Vista entrad en Panel de Control>Apariencia y personalización>Opciónes de Carpeta y entrais en la pestaña Ver. Allí desactiváis la casilla Ocultar las extensiones de archivo para archivos conocidos. En W7 supongo que será algo similar.

Una vez tengamos el zip solo hay que descomprimirlo. El pak0 es un archivo de medio Giga, así que vigilad el espacio de vuestro disco duro.

Como vereis, en los pk3 no solo van los mapas, sino que tambien las texturas, los bots, los modelos, los menús… Todo. Pero antes de descifrar todos lo misterios veamos que otros pk3 podemos conseguir.

• Mapas: lvlWorld
• Modelos: PlanetQuake model of the week

Antes de convertir vuestro baseq3 en un almacén de basura os recomiendo que seleccionéis mucho y cojais solo lo que os gusta de verdad, ya que creo que esta carpeta se satura si tiene demasiados pk3 y si se repite algún archivo. Al menos a mí me dio problemas una vez.

Para crear nuestro pk3 no es necesario (ni recomendable) meter texturas, scripts, etc. de los pk3 originales del juego, ya que todo el mundo los tiene. Tendremos que meter lo que copiemos de otros pk3 y nuestro contenido original.

• maps: aquí metemos todos los archivos de mapas que compilemos; se puede meter el .map si queremos difundirlo.
• levelshots: aquí metemos una captura de pantalla del juego, o la imagen con la que queramos representar nuestro mapa.
• textures: aquí metemos las texturas que hayamos utilizado y que no vengan incluidas en el juego.
• scripts: aquí metemos los shaders correspondientes a las texturas y el archivo .arena, que define los parámetros por defecto.
• sound: aquí se meten los sonidos .wav utilizados
• models: aquí los modelos 3D
• env: aquí los archivos necesarios para un skybox; observad también la correspondencia con su shader
• leeme: normalmente se coloca un archivo de texto con una descripción breve del mapa y su autor.

No es necesario colocar todas las carpetas, solo las utilizadas. Hagamos un ejemplo:

Buscamos todos los archivos que hemos compilado para nuestra primeraprueba3 (.bsp, .aas, .srt y .map), y los metemos en una carpeta maps que crearemos en el escritorio. Las texturas que hemos utilizado son originales del juego, así que no hay que complicarse con eso. Por la misma razón tampoco necesitamos shaders. Pero sí necesitaremos el .arena. Creamos una carpeta scripts en el escritorio y dentro creamos el archivo primeraprueba3.txt. Lo abrimos y escribimos lo siguiente:

{

map “primeraprueba3″

longname “Primera Prueba”

bots “sarge doom”

fraglimit 10

type “ffa tourney team”

}

línea en blanco

No os olvidéis de dejar la última línea vacía. Los corchetes indican al juego una unidad de información, algo que puede comprender. Map es el nombre de archivo de nuestro mapa, lo que en la imagen viene como “mimapa”. Longname es el nombre que aparecerá en el juego. Bots son evidentemente los bots que vendrán marcados por defecto en el juego. Fraglimit es el número de muertes necesarias para terminar la partida. Type es el tipo de juego en el que estará activo nuestro mapa (ffa = free for all; tourney = tournament; team = team deathmatch; ctf = capture the flag).

Una vez escrito eso, y comprendido, guardamos y le sustituimos el .txt por .arena. Ya hemos escrito nuestro primer script, que es otro logro.

En cuanto a modelos, skybox, y sonidos, como no usamos, no nos preocupamos. Falta la captura de pantalla, pero primero tendremos que encontrarla. Para hacerla entrad en el juego (deberéis copiar los mapas al baseq3 primero) y entrad en el mapa. Buscad vuestra tecla de captura. La mía es F11. Cuando capturéis una imagen os aparecerá un texto blanco arriba a la izquierda: wrote shot0001.tga. Salid del juego y buscad una carpeta oculta llamada C:\Users\Tú\AppData\Local\VirtualStore\Program Files\Quake III Arena\baseq3\screenshots y buscad la captura deseada. Copiadla a una carpeta nueva llamada screenshots en el escritorio. Renombrad el archivo como primeraprueba3.tga. Listo.

Ahora seleccionamos las tres carpetas y el leeme (si lo quisisteis escribir) y lo comprimimos todo en un zip. Lo renombramos como primeraprueba3.pk3 (comprobad que no sea un *.pk3.zip) y ya está, lo tenemos. Lo copiamos a la carpeta baseq3 y, para que los mapas no estén repetidos, borramos los que están en la carpeta maps.

Abrimos el Quake y entramos en Single Player. Le damos al botón skirmish para que nos aparezcan todos los mapas, y, entre ellos, estará el nuestro.

Si no aparece en la lista de mapas es porque el archivo .arena ha fallado.

Caulk es una textura con shader, una textura activa. Un shader es un archivo que modifica la imagen de una textura e incluso las propiedades del bloque o brush pintado por esa textura. Puedes hacer que la imagen sea translucida, animada o que se mueva en el espacio, o que un bloque sea líquido, niebla, invisible… Las posibilidades son infinitas. El Quake tiene una carpeta de texturas que son exclusivamente shaders, sin imagen. Son las texturas de la carpeta common. Todas ellas son usadas frecuentemente para cambiar las propiedades de los bloques. Entre ellas se encuentra caulk, la joya de las texturas. Caulk transforma un bloque en invisible, no solo para el ojo, sino también para el compilador, con lo que reduce el peso de los mapas sustancialmente. Además es sólido como una roca, no permite el paso ni del jugador, ni de los bots, ni de las balas. Vamos que es perfecta.

Pero la gran cualidad de esta textura es que nos evita problemas frecuentes y difíciles de resolver como el z-fighting y los leaks o fugas.

Un z-fighting ocurre cuando dos texturas con imagen se encuentran en el mismo plano. El compilador realiza ambas pero, como están superpuestas, el Quake mostrará las dos a la vez haciendo un efecto muy feo y difícil de calcular para la tarjeta gráfica. Es decir: 2texturas/plano = tarda el doble en compilar + doble peso del archivo + resultado pobre y feo + tarjeta gráfica petada. Para solucionar esto se utiliza nuestro querido caulk. Da mucho trabajo al editar nuestro mapa, pero el resultado vale la pena, especialmente en los grandes mapas. La cuestion es que cuando dos bloques se toquen y compartan una cara, pintar las dos superficies con caulk, o como mínimo una de ellas.

Con ejemplos se ve más claro. Abrimos el Radiant y creamos un bloque cúbico de 2x2x2m. Al vaciarlo (darle a hollow) con una cuadrícula de 8u construirá automáticamente unos muros. Seleccionamos todo (esc para deseleccionar todo e I para invertir la selección). Abrimos las texturas base_floor y pinchamos en la primera. Ahora todo está pintado con esa textura. Pulsamos esc y después shift+click izqd en el 3D en uno de los bloques para seleccionarlo. Podremos darnos cuenta donde se comparten caras y por lo tanto  donde hay z-fighting.

En un solo bloque todas sus caras laterales tienen ese problema. Su cara cuadrada exterior también tiene ese problema en los cuatro bordes, especialmente en las esquinas que hay un z-fighting triple. En un bloque el problema aparece 12 veces (4 de las cuales de forma triple). Eso quiere decir que en un pequeño cubo que hemos vaciado aparecen 12×6=72 z-fightings. Cuando empieza a crecer el mapa el problema se hace insostenible.

La solución es primero pintar todo de caulk. Seleccionamos todo. Para pintar con caulk hay dos opciones. En el GtkRadiant 1.5.0 hay un botón en la barra de herramientas que es para eso . Si no lo teneís abrid las texturas common en la ventana de texturas. Ahí vienen muchas texturas similares. Cuando están rodeadas por un cuadrado blanco es que tienen un shader asociado. Buscad caulk y seleccionarla. Nuestro cubo estará pintado ahora de rosa con la palabra caulk grabada.

Ahora haremos que todas las piezas encajen correctamente. En el caso de este cubo las caras deben estar todas biseladas. Para ello seleccionamos un bloque y le damos a E para poder editar los bordes. Rotamos las vistas y vamos moviendo los bordes interiores hasta tener una pirámide truncada como la siguiente:

Hacemos lo mismo con el resto de los bloques, hasta que todo encaje perfecto. Después pintamos las caras cuadradas con la textura anterior. Para pintar solo una cara y no el bloque entero recordad que primero había que deseleccionar todo, seleccionar la textura, y luego, mientras manteníamos pulsadas ctrl+shift, ir clickando con la rueda del ratón las superficies en el 3D.

En la siguiente imágen he retirado uno de los bloques para mostrar como son los encuentros:

Los encuentros en esquina deben ser, como veis, biselados. Pero hay muchos tipos más de encuentros: en T, huecos, etc… La solución siempre es pintar todo de caulk, modificar los bordes, minimizar el número de bloques, y por último pintar todas las superficies vistas con alguna textura. Siempre hay que evitar un z-fighting.

El otro gran problema son los leaks. Un leak o fuga es un hueco en el mapa por el cual una entidad o entity podría escapar al infinito. Y es que en el Quake el jugador debe estar encerrado de alguna manera, no puede escapar al infinito. Si en algún momento aparece una fuga, la solución rápida es rodear todo con un gran bloque de caulk que vaciaremos. No es una buena solución, pero si no hay otra, esa vale. También caulk tiene un defecto. Si está colocado entre el observador y el infinito o el cielo hará una cosa muy psicodélica y muy molesta cuando estemos en el juego.

Además de las soluciónes anteriores, el caulk también puede solucionar problemas de rugosidad donde el jugador o los bots se quedan atascados.

Este problema también lo solucionan las texturas clip (también pertenecen a las common), que ya están especificamente diseñadas para eso.

Abrimos en GtkRadiant nuestro primeraprueba.map.

Primero colocaremos una luz. Para ello clickamos con el botón derecho en la planta, dentro de la habitación, y le daremos a light. Nos saldrá una ventana que nos pedirá la intensidad de la luz. Por defecto viene 100, que es más o menos equivalente a 1000 lumen (la luz que emitía una bombilla clásica de 100W, cuando aún se medían por consumo). Para un espacio cúbico de 4x4x4 metros lo adecuado son unos 4000 lumen, así que ponemos 400 (si vuestra pantalla no tiene brillo suficiente podéis poner un poco más) y le damos a OK. La movemos para que quede en el centro de la habitación. Para ver que nos queda correctamente colocada ocultaremos la cuadrícula pulsando 0. La podremos visualizar de nuevo pulsando otra vez el 0.

Ahora pintaremos los muros con una textura. Pulsamos esc para no tener ningún objeto seleccionado y en la ventana de texturas desplegamos la pestaña base y abrimos base_floor. A la derecha apareceran muchas texturas. Clickamos en la primera (atchung_clang) y veremos un marco rojo que indica que está seleccionada. Pintaremos directamente en el 3D. Para ello mantendremos pulsadas ctrl+shift y pincharemos con la rueda del ratón cada superficie en blanco. Solo es necesario dentro, ya que no veremos el cubo por fuera.

Ya que estámos pondremos también un lanzacohetes, porque mola. Para ello clickamos con el botón derecho en el 2D, dentro de la habitación, y le daremos a weapon>weapon_rocketlauncher. Ya sabéis colocar cualquier arma donde queráis.

Ahora guardamos como primeraprueba2.map en nuestra carpeta Quake como siempre.

Pasamos ahora a la compilación. Primero compilamos como antes (Build>Q3Map2: (single) BSP -meta), pero antes de probarlo guardamos otra vez como primeraprueba3.map. Ahora aprenderemos a compilar correctamente.

La compilación consta de cuatro partes: BSP, Vis, Light y Aas. El BSP es la compilación del mapa, se colocan todos los elementos en su sitio: bloques, entidades, superficies, etc. El Vis es la compilación de los espacios; se resume el mapa en espacios y portales para facilitar el cálculo de recorridos. El Light es la compilación de la luz; sin esto el mapa estaría a oscuras, o con luces forzadas con un resultado muy pobre. El Aas, por último, es la compilación de bots; sin esto no se pueden añadir los bots al mapa; es un compilado que no está incluido en el GtkRadiant, por lo que tendremos que utilizar DOS.

A continuación explico como compilo yo, pero después vosotros podréis buscar vuestro método preferido. El caso es que los compilados que vienen por defecto en el Radiant no os los recomiendo usar, excepto el primero para las diversas pruebas rápidas, porque si no se comprende el funcionamiento de la compilación no se obtienen los resultados deseados. Cuanto más aprendáis sobre ello más control tendréis sobre la calidad de vuestros mapas. Creo también que es mejor aprenderlo desde el principio. Cuando hagáis mapas grandes el tiempo de compilación es muy muy largo. Es mejor no equivocarse, y para eso se necesita experiencia. Para completar lo aprendido aquí abrir Help>Quake III Arena/Quake III: Team Arena>Compiling Manual (q3map & bspc) en el GtkRadiant.

Vamos a crear los compilados para BSP, Vis y Light. Para crear uno nuevo entramos en Build>Customize. Nos aparecerá una ventana y bajamos en el build menu hasta el espacio en blanco (A2). Lo clickamos dos veces y nos dejará escribir. Ahí pondremos lo que queramos que nos aparezca en el menu Build cuando lo despleguemos, por ejemplo: Q3Map2: BSP Mapeando Juegos y le damos a enter. Seleccionamos otro y volvemos a seleccionar el nuestro (A1) (para que lo acepte y  nos deje escribir en el Commandline). En el Commandline clickamos dos veces en la primera linea y (B1) escribimos: [q3map2] -meta -v “[MapFile]“ y le damos a enter. Volvemos a hacer lo mismo para Vis (en el Commandline ponemos [q3map2] -vis -v “[MapFile]“) y para la Luz (ponemos [q3map2] -light -fast -patchshadows -samples 3 -bounce 8 -gamma 2 -compensate 3 -dirty -v “[MapFile]“). Atención al copiar y al pegar los comandos desde aquí, porque las comillas de WordPress son distintas de las del Radiant y dan error.

Le damos a OK y empezamos a compilar. Ahora en la barra de menu>Build aparecen nuestros tres nuevos compilados. Siempre hay que seguir el mismo orden: BSP, Vis y luz. Una vez hayamos terminado con el Radiant aún falta el Aas.

Para compilar el archivo de bots copiamos directamente nuestro archivo primeraprueba3.bsp en C:\. Abrimos C:\Archivos de programa\GtkRadiant 1.5.0 y buscamos el bscp.exe y lo copiamos también en C:\. Ahora le damos a Inicio y buscamos cmd en el cuadro de busqueda. Clickamos con el derecho y le damos a ejecutar como administrador. Se nos abrirá DOS.

En DOS entramos en C:\ (para ello escribimos dos veces cd.. y pulsamos enter). Si ahora escribimos bspc y le damos a enter se abrirá el compilador y nos explicará todas las opciones. Yo recomiendo escribir lo siguiente: bspc -forcesidesvisible -optimize -bsp2aas C:\primeraprueba3.bsp. Cuando le demos a enter comenzará a compilar. Cuando ponga closed log bspc.log sabremos que ha terminado. En C:\ aparecerá un nuevo archivo primeraprueba3.aas que moveremos a nuestra carpeta Quake. Quitaremos los archivos compilados de C:\ ya que no conviene saturar esa carpeta, pero dejaremos el bspc.exe.

Ahora tenemos todos los archivos compilados en nuestra carpeta. Los copiaremos todos (menos los .map) a la carpeta maps del juego (C:\Archivos de programa\Quake III Arena\baseq3\maps), incluídos los del primeraprueba2.

Abrimos el Quake. Escribimos sv_pure 0 en la consola y luego map primeraprueba3. Ahí está nuestra habitación con luz, textura y un lanzacohetes. Le damos a esc y a Add bots, clickamos en uno, le damos a OK y volvemos al juego. Ahora estamos compitiendo en nuestro propio mapa. Eso ya es un gran logro.

Por último podemos comparar el resultado final con la compilación de prueba abriendo primeraprueba2. La diferencia es brutal.

Antes de abrir nada crearemos una estructura de carpetas que nos facilitará el trabajo en el futuro:

• En Documentos crearemos una carpeta llamada Quake, donde meteremos todos nuestros mapas. (Esto es importante porque para cada mapa tendremos que hacer múltiples pruebas, y no es recomendable llenar mucho el directorio de mapas de juego, porque lo saturaremos y esto puede dar problemas).

Para que el GtkRadiant funcione correctamente en Windows Vista (y supongo que también en Windows 7), tendremos que prepararlo para que sea compatible con Windows XP y utilizarlo con propiedades de administrador. Para ello:

• Entramos en C:/Archivos de programa/GtkRadiant 1.5.0, pinchamos con el botón derecho en GtkRadiant.exe y le damos a propiedades. En esta ventana le damos a la pestaña Compatibilidad (esto es en Vista, supongo que en W7 será similar) y marcamos las pestañas “Ejecutar en modo de compatibilidad para: Windows XP (Service Pack 2)” y “Ejecutar este programa como administrador”.

Bien, con todo eso en orden podemos comenzar:

Abrir el GtkRadiant. Como le hemos activado la ejecución como administrador aparecerá una ventana de aviso; no hay que preocuparse, le damos a permitir. Justo después aparece una ventana de  GtkRadiant que nos pregunta que juego queremos editar, escogemos por supuesto Quake III Arena/Quake III Team Arena

Para tener una idea básica de la escala y como usar la cuadrícula, los cuadrados grandes son de 1×1 metros que equivale a 64×64 unidades de juego y los pequeñitos de 12,5×12,5 cm o 8×8 unidades.

Para cambiar la escala de la cuadrícula es necesario ir a barra de menú>grid y ahi se selecciona otro tamaño de cuadrícula, pero para comenzar recomiendo usar la de 8u, la que viene por defecto.

Para acabar pronto, como es el primer mapa usaremos un método muy rápido pero poco recomendable para mapas grandes ya que hace que aumente el tiempo de compilación y el tamaño del archivo.

Crearemos el cubo de 4x4x4 metros. Para trazar un bloque (o brush como lo llaman en el programa) pinchamos con el boton izquierdo del ratón en el punto de origen y arrastramos hasta hacer un cuadrado de 4×4 metros. Bien, ese es el volumen exterior, pero nosotros queremos 4x4x4 de espacio en el interior, para eso necesitamos expandir el cuadrado el grosor del muro (12,5 cm). Pinchamos fuera del cuadrado cerca de un borde, y lo arrastramos un cuadrado pequeño de distancia, y luego repetimos eso con los demás bordes.

Ahora toca darle altura. Para rotar las vistas de planta a alzado pulsamos ctrl+TAB (Planta = plano XY / Alzado = plano XZ / Perfil = plano YZ). Arrastramos la parte superior del bloque a una altura de 4m+8u sobre el origen y la parte inferior a 8u bajo el origen (así el suelo quedará entre 0 y -8).

Ahora tenemos un cubo macizo de 4m de lado más el grosor del muro. Para vaciarlo pulsamos el botón hollow en la barra de herramientas (éste es el proceso que añade peso al mapa)

La habitación ya está terminada. Pulsamos esc para deseleccionar todo. Para verla usamos la ventana de cámara sitúada arriba a la derecha y para movernos utilizamos las flechas del teclado y las letras D y C para subir y bajar. Para mirar arriba y abajo utilizamos A y Z. Podemos usar también la rueda del ratón para acercar o alejar (siempre que hayamos habilitado el ratón de 3 botones en las preferencias).

Aunque la habitación esté terminada no hemos acabado. Para que el juego sepa donde tiene que nacer el jugador es necesario crear una entidad o entity. Ésto es imprescindible. Nos aseguramos de que no haya nada seleccionado. Para crearla pinchamos con el botón derecho dentro de la habitación (en la planta, no en el 3D). Saldrá un menú contextual enorme. Seleccionamos info>info_player_deathmatch. Aparecerá un prisma con una flecha, que indica hacia donde mira el jugador según nace. Lo colocamos de forma que tenga espacio para dar el primer paso al frente y nos aseguramos de que no atraviese el suelo, incluso podemos dejarle un colchón de aire de 8u, y así da un pequeño salto según aparece.

Ya está. Le damos a Barra de menu>File>Save as y nos aparecera la ventana de guardar como. Desplegamos la pestaña Browse in other folders y buscamos nuestra carpeta C:\Users\(tu nombre de Usuario)\Documentos\Quake que creamos hace poco. Como recurriremos muchas veces a esta carpeta haremos un acceso directo. Para ello observamos que la ruta viene dividida en botones; mantenemos pinchado el botón Quake y lo arrastramos a la subventana Places. Ahora tendremos ese acceso directo siempre ahi. Llamamos al archivo primeraprueba.map (no olvidarse del .map) y le damos a Save. La parte de mapeado concluyó.

Es el turno ahora de compilar. El compilado es el proceso de convertir nuestro archivo de mapa editable a los archivos que lee el Quake. Para ello pinchamos en Barra de menú>Build>Q3Map2: (single) BSP -meta (es imprescindible que el mapa esté guardado) y esperamos a que termine (tiene que poner Connection closed).

Ahora abrimos nuestra carpeta Quake y aparecerán cuatro archivos: el primeraprueba.map que guardamos (no sirve para el Quake, solo sirve para editar en el GtkRadiant) y los .bsp, .prt y .srf que hemos compilado. Estos tres últimos los copiamos en una carpeta (maps) dentro de la carpeta del juego C:\Archivos de programa\Quake III Arena\baseq3 que si no existe tendremos que crear. Las rutas finales tienen que ser C:\Archivos de programa\Quake III Arena\baseq3\maps\primeraprueba.bsp, etc.

Ahora está todo listo y sólo tenemos que abrirlo en el juego. Como no hemos respetado la estructura pk3 no nos aparecerá en la lista de mapas. No os preocupeis. Para las pruebas este método es más rápido y menos pesado. Para abrirlo tendremos que ejecutar la consola de comandos en el juego. Una vez dentro del juego tendremos que pulsar una tecla que la active. En mi caso es la que está entre esc, el 1 y TAB. Sé que en otros es el F12, pero depende del teclado, así que buscad la vuestra. Sabréis que estáis en la consola cuando baje algo con mucho texto que os cubrirá media pantalla. Una vez allí teclearemos sv_pure 0, pulsamos enter, tecleamos maps primeraprueba y cuando pulsemos enter entraremos por fin en nuestra primera habitación.

Con esto hemos establecido las bases de todo mapeado para este juego, pero las posibilidades para el Quake son inmensas. Seguiremos avanzando en los siguientes tutoriales.

Antes de abrir nada crearemos una estructura de carpetas que nos facilitará el trabajo en el futuro:

• En C:\ crearemos una carpeta llamada MOHAA, donde meteremos todos nuestros mapas. (Esto es importante porque para cada mapa tendremos que hacer multiples pruebas, y no es recomendable llenar mucho el directorio de mapas de juego, porque lo saturaremos y esto puede dar problemas)
• En C:\ copiaremos también los compiladores q3map y mohlight que vienen incluidos en C:\Archivos de programa\MOHAATools, que se usan en DOS (símbolo de sistema). Para los mapeadores de Quake, esto los sorprenderá, porque a diferencia del GtkRadiant, el MohRadiant no deja compilar desde el programa; tranquilos, se puede compilar sin problemas desde DOS.

Bien con todo eso en orden podemos comenzar:

Abrir el MohRadiant. Para los que empezais os recomiendo abrir preferencias (Barra de menu>Edit>Preferences) y activar la primera vista

Esta vista tiene la ventaja de poder trabajar en planta a casi toda pantalla y al mismo tiempo dar altura.

Para tener una idea básica de la escala y como usar la cuadrícula, los cuadrados grandes son de 1×1 metros que equivale a 64×64 unidades de juego y los pequeñitos de 12,5×12,5 cm o 8×8 unidades.

Para cambiar la escala de la cuadrícula es necesario ir a barra de menú>grid y ahi se selecciona otro tamaño de cuadricula, pero para comenzar recomiendo usar la de 8u, la que viene por defecto.

Para acabar rápido, como es el primer mapa usaremos un método muy rápido pero poco recomendable para mapas grandes ya que hace que aumente el tiempo de compilación y el tamaño del archivo.

Crearemos el cubo de 4x4x4 metros. Para trazar un bloque (o brush como lo llaman en el programa) pinchamos con el boton izquierdo del ratón en el punto de origen y arrastramos hasta hacer un cuadrado de 4×4 metros. Bien, ese es el volumen exterior, pero nosotros queremos 4x4x4 de espacio en el interior, para eso necesitamos expandir el cuadrado el grosor del muro (12,5 cm). Pinchamos fuera del cuadrado cerca de un borde, y lo arrastramos un cuadrado pequeño de distancia, y luego repetimos eso con los demás bordes.

Ahora toca darle altura. En la barra vertical de la izquierda hay un rectángulo de borde rojo. Pinchamos debajo de él y arrastramos una linea, para que el suelo quede entre 0 y -8. Despues Pinchamos por encima y arrastramos hasta conseguir 4m y 8u.

Ahora tenemos un cubo macizo de 4m de lado más el grosor del muro. Para vaciarlo pulsamos el botón hollow en la barra de herramientas (este es el proceso que añade peso al mapa)

La habitación ya está terminada. Pulsa esc para deseleccionar todo. Para verla usa la ventana de cámara sitúada arriba a la derecha y para moverte utiliza las flechas del teclado y las letras D y C para subir y bajar. Para mirar arriba y abajo utiliza A y Z. Puedes arrastrar también el botón derecho del ratón por la ventana de la cámara para moverte más rápido (si quieres que la cámara vaya más despacio pincha en el botón del ojo, el último de la barra de herramientas)

Aunque la habitación esté terminada no hemos acabado. Para que el juego sepa donde tiene que nacer el jugador es necesario crear una entidad o entity. Esto es imprescindible. Nos aseguramos de que no haya nada seleccionado. Para crearla pinchamos con el botón derecho dentro de la habitación (en la planta, no en el 3D). Saldrá un menú contextual enorme. Seleccionamos info>player>deathmatch. Aparecerá un prisma con una flecha, que indica hacia donde mira el jugador según nace. Colocalo de forma que tenga espacio para dar el primer paso al frente y asegurate de que no atraviese el suelo, incluso podemos dejarle un colchón de aire de 8u, y asi da un pequeño salto según aparece. Para rotar entre planta y alzados usaremos ctrl+TAB.

Ya está. Guardamos (Barra de menu>File>Save as) en la carpeta C:\MOHAA que creamos hace poco y le llamamos primeraprueba.map (no olvidarse del .map). La parte de MohRadiant concluyó.

Es el turno ahora de compilar. Abrimos símbolo de sistema (en accesorios o en Inicio>Buscar y escribes cmd). Para los que no estén familiarizados con DOS, se usa cd.. para salir de una carpeta. Tecleamos cd.. hasta que quede C:\.

La compilación consta de tres partes importantes:

• El bsp –> el mapa que lee el Medal
• El vis –> el archivo de visibilidad
• El prt –> el archivo de luz

Para conseguir estos archivos necesitamos usar los compiladores; tecleamos:

• q3map -gamedir c:\mohaa c:\mohaa\primeraprueba.map
• q3map -vis -gamedir c:\mohaa c:\mohaa\primeraprueba.map
• mohlight -gamedir c:\mohaa c:\mohaa\primeraprueba.map

Ya podemos cerrar DOS. En nuestro directorio MOHAA aparecerán 4 archivos: .map .bsp .prt y .srt. El .map no lo necesita el juego (solo el MohRadiant para seguir editando). Copiamos los otros 3 y los pegamos en C:\Archivos de programa\EA Games\MOHAA\main\maps\dm y con eso ya está todo listo.

Abrimos el Medal y creamos una partida en red local, un Free for all, y buscamos nuestro mapa. Le damos a crear y ya está.

Como dije al principio, no hemos puesto luz, tiene sólo la de la textura. En el siguiente tutorial meteremos una luz.