Aravid

Tutoriales, Gamer Sense, opinión y más

Archivos mensuales: mayo 2012

Documentos de diseño

Aunque en la etapa de preproducción se realizan muchos documentos de diseño, voy a hablar de los tres que son más relevantes en esta fase y que sirven para describir la evolución de la idea del juego, por llamarlo de alguna manera.

Si alguien tiene dudas sobre el proceso de creación de un videojuego, les remito a Game Over, el primer programa satírico sobre videojuegos, programa de radio y podcast en el que fanatiko tiene una sección llamada “Destripando la industria” donde habló sobre Las fases de desarrollo de un videojuego.

Su artículo es especialmente interesante porque la mejor visión posible es la de alguien que trabaja ya en la industria, porque aunque yo intentara hablar sobre ello, no sería más que un enfoque teórico, porque aún no he participado en ningún desarrollo.

Comenzando con el meollo, los tres documentos a tratar son el

  1. Game Design Overview o One-sheet
  2. Ten-Pager
  3. Game Design Document o GDD
Todos tienen una serie de características comunes y es bueno tenerlas en cuenta a la hora de redactarlos:
  • Concreción. Sobre todo en las versiones “técnicas” de los mismos, es decir, los que van orientados a tu grupo de trabajo.
  • Precisión. Los documentos serán la información base con la que la gente trabajará y creará los contenidos. Cuanto más exacto mejor porque evitarás interpretaciones erróneas y eso ahorrará tiempo.
  • Ameno. Mucha gente va a leer el documento, y si es un ladrillo, será pesado para los que lo tienen que consultar. Intenta organizarlo lo mejor posible y utiliza las herramientas disponibles, como índices, enlaces y listas.
  • Bien escrito. Al igual que por la razón que el punto anterior, mucha gente terminará consultando tus documentos, y los fallos gramaticales o tipográficos pueden dar una sensación de dejadez o de falta de interés a la hora de redactar los documentos, así que revísalos.

One-Sheet

Como su nombre indica, es un documento que idealmente debe de ocupar una cara y tener la capacidad de ser atractivo, porque va a ser la carta de presentación de tu idea. ¡Y vas a tener solo una cara para expresar lo maravilloso que va a ser! Siempre va a ser insuficiente y hay una serie de datos que es más que recomendable que aparezcan, reduciendo aún más tu espacio. Tampoco es obligatorio hablar sobre los datos que comentaré a continuación, pero es una plantilla bastante buena.

  • Título del juego
  • Plataformas en las que estará disponible
  • Edad objetivo
  • Calificación por edades (PEGI y ESRB)
  • Resumen de la historia
  • Jugabilidad
  • Unique Selling Points o USP. Es decir, qué hace especial a tu juego
  • Competencia

Otra cosa importante sobre este documento es que, por lo general, no va a estar dirigido a una persona que juega habitualmente. Este documento, con el que pretender vender tu idea, estará leído por gente que tiene que invertir o por jefazos, así que intentar hacerlo lo más ameno posible será buena idea.

Ten-Pager

El Ten-Pager es la evolución del One-Sheet, si la cosa funciona como es debido, la idea debe de desarrollarse, en este caso, hasta que ocupe unas diez páginas, pero al igual que el documento anterior, si es posible que sea más escueto, es incluso beneficioso.

Como detalle y para posibles contingencias, no está de más que este documento tenga forma de presentación de diapositivas, porque si la idea gustó, probablemente la siguiente fase sea enseñar, en forma de pequeña presentación, por qué tu juego es el mejor en este momento prematuro y deben de invertir su dinero a lo loco en tí.

Pero un Ten-Pager más técnico para que tu grupo pueda comenzar a trabajar tampoco está de más, por lo que mi recomendación es hacer dos documentos (por suerte no son extensos) siendo uno más centrado a la venta de tu producto y otro más centrado a las características del juego.

Los apartados recomendados para este documento, y con una longitud de aproximadamente una página por cada uno son:

  • Página del título
  • Resumen del juego
  • Personajes
  • Jugabilidad
  • Mundo
  • Experiencia de juego
  • Mecánicas
  • Enemigos
  • Cutscenes
  • Material extra
Una regla que se aplica en este documento y en el siguiente es la regla de los tres ejemplos, porque los ejemplos son un gran aliado. Permiten explicar situaciones con todo lujo de detalles y la resolución de las mismas, permitiéndonos aclarar posibles puntos oscuros. Siguiendo con la regla de los ejemplos:
  • El primer ejemplo da una idea al lector sobre la situación, pero puede que no quede claro.
  • El segundo ejemplo nos permite comparar con el primer ejemplo.
  • El tercero anula el efecto binario, y complementa los ejemplos anteriores.

¿Quiere esto decir que cada vez que hay que poner un ejemplo, debemos de invertir el espacio y la capacidad de atención del lector con tres? Evidentemente no, hay que saber cuándo utilizar esta técnica.

Game Design Document

Este ladrillo de innumerables páginas será vuestra peor pesadilla por varias razones, pero para desarrollos grandes, mi opinión es que hace falta, ya que en él TODO debe de estar especificado, explicado y detallado para que cualquier desarrollador, en un momento dado, si tiene que consultarlo para saber cómo realizar algo, lo encuentre y no tenga que molestar a las personas que han dedicado su tiempo a la creación de este documento.

Por desgracia todos conocemos a la gente y lo vaga que es, y en más de una ocasión pasarán de buscar en el documento y preguntarán directamente. Esto es inevitable a menos que dispongas de un elemento disuasorio en una posición privilegiada y visible (como por ejemplo, un trofeo de caza con la cabeza del último desarrollador que preguntó demasiado), pero se puede mitigar siendo un documento ordenado, fácil de entender y ameno (cosa imposible para este documento).

Otro de los grandes problemas que traerá este documento, es que el proceso de desarrollo de un juego es un proceso vivo, y a lo largo del tiempo, ciertas cosas ya especificadas serán modificadas por alguna razón, y todos esos cambios deben de figurar en este documento, así que mantenerlo al día debería ser imperativo.

Nota: Si os habéis dado cuenta, estos documentos están enfocados a la entrega a un publisher y un desarrollo para un grupo grande. Esto no quiere decir que no os pueda servir para un desarrollo individual o para grupos pequeños. Mi experiencia es que estos documentos habrían sido de gran ayuda en el caso de haberlos realizado correctamente y habernos ceñido a ellos.

Aprovecho para agradecer a Victor Cerezo por la clase sobre Documentación, sin la que éste artículo no habría sido posible.

Scaleform: Integración en UDK

Después de los dos tutoriales anteriores, ya tenemos una película de Flash preparada para que pueda ser importada en UDK. Para ello, debemos de hacer una clase que se encargue de la película en sí y de implementar los métodos que llamamos desde Actionscript.

El primer paso es importar a nuestro paquete de assets la película siguiendo los pasos a continuación:

  1. Lanzamos el Unreal Editor y nos vamos al Content Browser.
  2. Seleccionamos nuestro paquete de assets (en mi caso, DCleanerAssets) y pulsamos el botón Import.
  3. Seleccionamos la película que se encuentra en UDK\UDKGame\Flash\DCleanerAssets (Recordar que no podemos especificar a qué paquete de assets se añadirá la película. Lo hará en uno con el nombre de la carpeta, por eso mi carpeta se llama igual que el paquete de assets).
Ahora en nuestro paquete de assets tendremos un SwfMovie que es la película que hemos importado y una Texture2D que es el puntero del ratón.
Nota: Lo que importamos no es el fichero .fla, lo que importamos en el fichero .fla una vez publicado, que su extensión es .swf

A continuación, nos vamos a nuestra carpeta donde se encuentran todos los ficheros de UnrealScript, en mi caso y siguiendo las convenciones habituales, se encuentra en Development\Src\DCleaner\Classes siendo DCleaner vuestra carpeta para código propio. Como recordatorio, esta carpeta se definió en el primer artículo de UDK: Estructura de carpetas, y en dicha carpeta creamos un nuevo fichero que yo llamaré DCleanerPauseMenu.uc

Recomendación: Ya dije en el artículo de UDK: Herramientas que lo mejor para trabajar con UnrealScript es tener nFringe instalado, y para crear un fichero desde nFringe, nos vamos a la carpeta donde debería de estar el fichero, y con botón derecho -> Add -> New Item y seleccionando un fichero de UnrealScript, nFringe ya se encarga de crearlo y además el autocompletado de código funcionará mejor que si importamos el fichero.

Ya tenemos el fichero, y debemos especificar el nombre de la clase y de qué clase vamos a heredar. Yo llamaré a la clase igual que al fichero, es decir DCleanerPauseMenu y toda película de Flash debe de heredar de GFxMoviePlayer, así que sabiendo esto, podemos poner la primera línea:

class DCleanerPauseMenu extends GFxMoviePlayer;

A continuación, rellenamos el bloque de defaultProperties con el nombre de la película que vamos a reproducir, y activamos el boolean bPauseGameWhileActive que se encargará de pausar el juego mientras mostramos la película, que es exactamente lo que queremos para nuestro menú de pausa. También necesitamos capturar la entrada del juego, así que también activamos el boolean bCaptureInput. El bloque quedará así:

defaultProperties
{
	MovieInfo = SwfMovie'DCleanerAssets.PauseMenu'
	bCaptureInput=true
	bPauseGameWhileActive=true
}

Nota: Para obtener el nombre completo de la película, nos vamos al Content Browser y con botón derecho sobre el item del que queremos obtener el nombre completo, seleccionamos la opción de Copy fullname to clipboard.

Ahora tenemos que implementar el método Init(), que lo llamaremos para inicializar la película.

function Init(optional LocalPlayer LocPlay)
{
	super.Init(LocPlay); // Llamamos al método de la clase padre
	Start(); // Inicializamos la película

	/* Los siguientes métodos especifican el escalado de la película, al igual 
	que su alineación en la pantalla, los posibles valores de cada uno están 
	definidos en GFxMoviePlayer.uc pero como no me cuesta nada, os los copio 
	aquí para que conozcáis las posibilidades de cada método

	enum GFxScaleMode
	{
		SM_NoScale,
		SM_ShowAll,
		SM_ExactFit,
		SM_NoBorder
	};

	enum GFxAlign
	{
		Align_Center,
		Align_TopCenter,
		Align_BottomCenter,
		Align_CenterLeft,
		Align_CenterRight,
		Align_TopLeft,
		Align_TopRight,
		Align_BottomLeft,
		Align_BottomRight
	}; */

	SetViewScaleMode(SM_NoScale);
	SetAlignment(Align_Center);
	Advance(0.f); // Especificamos que vaya al frame 0 de la película
}

Solo nos falta implementar los métodos que son llamados desde ActionScript, los nombres que le dimos a estos métodos eran ExitMenu() y ExitGame(), así que los declaramos y los rellenamos.

function ExitMenu()
{
	ConsoleCommand("TogglePauseMenu");
}

function ExitGame()
{
	ConsoleCommand("exit");
}

Nota: El método ConsoleCommand lo que invoca es el método que se le pasa por parámetro como si lo hubieramos introducido en la consola.

El comando de consola exit ya existe, por lo que no tenemos que hacer nada con él, pero TogglePauseMenu no existe, y debemos de declararlo de forma que pueda ser invocado por consola para que todo funcione correctamente. El lugar más adecuado para este método es la clase personalizada para mostrar el HUD que ya debería de existir. Yo abro mi fichero DCleanerHUD.uc y al final, declaramos el método TogglePauseMenu que abrirá la película si está abierta, y en el caso de estar abierta, la cerrará.

/* Al comienzo del fichero, declaramos una variable de tipo DCleanerPauseMenu */
var DCleanerPauseMenu PauseMenu;

exec function TogglePauseMenu()
{
	/* Si el fichero no es igual a none y el flag de que la película está 
	abierta es true, lo que hacemos es cerrar la película. */
	if(PauseMenu != None && PauseMenu.bMovieIsOpen)
	{
		/* Cerramos la película. El parámetro de la función es si deseamos 
		eliminar de la memoria la película. En nuestro caso, como es un
		menú de pausa que será invocado en más de una ocasión, mejor no 
		eliminarlo porque la siguiente vez que fuera invocado, tendría que
		copiarlo a memoria de nuevo. */
		PauseMenu.Close(false);
	}
	/* Si por otro lado, la película no es igual a None o no se encuentra 
	abierta */
	else
	{
		/* Comprobamos si la película es igual a none, para inicializar la 
		variable. Lo realizamos así, porque al no descargar la película, 
		podría ocurrir que la película estuviera cerrada, pero que PauseMenu 
		no fuera none */
		if(PauseMenu == None)
		{
			/* Sabiendo que la película no está inicializada, la 
			inicializamos haciendo un new en nuestra variable */
			PauseMenu = new class'DCleanerPauseMenu';
		}
		/* Llegados a este punto, estando ya la película creada, o recién 
		creada, debemos llamar a este método para que muestre la película. 
		Recuerdo que este método lo hemos escrito en nuestra clase*/
		PauseMenu.Init();
	}
}

Nota: la palabra reservada exec se utiliza para especificar que un método puede ser invocado por consola. Lo que nos permite invocarlo con el método ConsoleCommand.

Ya hemos terminado con la integración de un fichero de Flash en UDK. Como habéis podido ver, es realmente fácil y una vez realizado uno, todos son iguales. Un pequeño resumen de los pasos es:

  1. Realizamos la película con los widgets específicos de Scaleform.
  2. Importamos la película a nuestro paquete de assets.
  3. Declaramos el fichero que hereda de GFxMoviePlayer.
  4. En el bloque de defaultProperties, especificamos la película y todos los parámetros por defecto, como bCaptureInput o bPauseGameWhileActive.
  5. Reescribimos el método Init() y modificamos la alineación o escalado al gusto.
  6. Y Voilá. Tenemos que buscar un sitio en nuestro código donde llamaremos a la película para mostrarla, y acordarnos de disponer de una manera de cerrar la película, o no podremos volver al juego.

Scaleform: Creación del Interfaz II

Continuamos desde el tutorial Scaleform: Creación del Interfaz I, primero tenemos que buscar una imagen bonita para nuestro cursor. También podemos crear nuestro propio cursor utilizando las herramientas de Flash para dibujarlo. Yo voy a explicar el uso de una imagen porque requiere un proceso añadido, y así aprovecho para explicarlo.

En la carpeta donde hemos guardado el fichero, tenemos que crear una carpeta con el mismo nombre del fichero. En mi caso, al tratarse de un menú de pausa, he llamado al fichero “PauseMenu.fla” y como consecuencia, el nombre de la carpeta que tendría que crear, es “PauseMenu”, que es donde hay que colocar los ficheros que tenemos que utilizar, siempre en formato PNG. El cursor que voy a gastar es gracias a http://www.totallyfreecursors.com/ y antes de usarlo, hay que eliminar la zona blanca que lo rodea, para que sea transparente.

Ahora, a los pasos para importar imágenes:

  1. Archivo -> Importar -> Importar a la biblioteca.
  2. Importar un fichero a nuestra biblioteca

  3. Seleccionamos el fichero que hemos guardado en la carpeta que hemos creado anteriormente.
  4. Botón derecho -> Propiedades sobre la imagen que ahora se encuentra en la biblioteca.
  5. Activamos el tick de Permitir suavizado si se encuentra desactivado, y en el desplegable de Compresión, seleccionamos Sin pérdida (PNG/GIF).
  6. Activamos los dos ticks de Exportar para Actionscript y Exportar en fotograma 1, y en el campo Identificador, ponemos el nombre del fichero sin la extensión.
  7. A partir de ahora, cuando importemos la película en UDK, además del fichero, se añadirá una Texture2D por cada una de las imágenes que estén añadidas a la biblioteca.

    Ya disponemos de la imagen en nuestra biblioteca, los siguientes pasos nos indicarán cómo conseguir que esa imagen, se convierta en un cursor:

    1. Creamos una nueva capa, para que el cursor siempre se encuentre por encima del resto de elementos. Si la capa se crea por debajo de la actual, subirla para que se encuentre por encima de la capa donde hemos añadido los elementos anteriormente. También modificamos su nombre por “Cursor” y la seleccionamos.
    2. Arrastramos la imagen que hemos seleccionado para hacer de cursor a la zona de trabajo.
    3. Aspecto de la zona de trabajo, añadiendo el cursor

    4. Seleccionamos la imagen en la zona de trabajo, y botón derecho -> Convertir en símbolo.
    5. En la ventana que ha aparecido, seleccionamos en el desplegable de Tipo la opción de Clip de película, y en el campo Nombre escribiremos el nombre que aparecerá en la biblioteca para este nuevo símbolo, que será añadido automáticamente.
    6. En el panel de Propiedades, le damos un nombre de instancia, porque trabajaremos con él desde el Actionscript. En mi caso, lo llamaré “Cursor”.
    7. Ahora tenemos que crear una capa para albergar nuestro código de Actionscript, le damos el nombre de “Actionscript” y nos colocamos en la primera celda del mismo, y botón derecho -> Acciones. Esto nos abrirá el editor de Actionscript.
    8. Ahí, tenemos que copiar el siguiente código, que será el encargado de ocultar el ratón habitual, y colocar en su posición, nuestra imagen que representa el cursor.
      var cursorListener:Object = new Object();
      
      Mouse.hide();
      
      Cursor._x = _root._xmouse;
      Cursor._y = _root._ymouse;
      
      cursorListener.onMouseMove = function ()
      {
      	Cursor._x = _root._xmouse;
      	Cursor._y = _root._ymouse;
      }
      
      Mouse.addListener(cursorListener);

    Nota: Lo que realiza el código es ocultar el ratón por defecto, crear un Listener que cada vez que se mueva el ratón, invoque a la función que coloca nuestro cursor en la posición del ratón, y como último paso, registrar ese Listener.

    Ahora podemos probar por primera vez nuestro fichero, y comprobar que funciona.

    Me estoy aficionando demasiado a esto de los pasos numerados, continuamos:

    1. Si no utilizamos ratón, necesitamos que un boton tenga la propiedad de focused a true. La razón, es que al utilizar teclas, nos moveremos entre los botones con respecto al que esté seleccionado, y para seleccionar uno, tenemos que activar la propiedad focused. El botón que lo tenga da igual, pero será el que esté resaltado al lanzar la película. Nos vamos a la capa de Actionscript, y en la primera celda, volvemos a darle botón derecho -> Acciones, y al comienzo del editor, añadimos la línea
      Btn_Continue.focused = true;
    2. Ahora tenemos que crear los métodos que van a ser llamados cuando hagamos click en nuestros botones, de momento, los métodos estarán vacíos porque su contenido está relacionado con la comunicación con UDK y aún no hemos hablado sobre ello. Destacar que no se pueden pasar parámetros a estas funciones que se invocan al realizar alguna acción. Añadimos al final del editor el siguiente código.
      function btn_continue_click()
      {
      
      }
      
      function btn_exit_click()
      {
      
      }
    3. Bien, ya disponemos de los cuerpos, que serán llamados cuando hagamos click en nuestros botones. Ahora tenemos que añadir los EventListener a nuestros botones. Si conocéis Flash, este no es el método habitual de añadir la funcionalidad del click a un botón, y el proceso se hace como se ve en las siguientes líneas de código.
      Btn_Continue.addEventListener("click",this,"btn_continue_click");
      Btn_Exit.addEventListener("click",this,"btn_exit_click");

    A parte de click, también podemos añadir un EventListener con otros eventos, como un over, por si queremos realizar alguna acción especial cuando el cursor esté por encima del botón. Es tan fácil como crear un método que será invocado, y cambiar la cadena que especifica la acción que invoca el método. De hecho, para mostrar esto, vamos a añadir algo de funcionalidad a nuestro menú de pausa.

    1. Siguiendo los pasos que están en Scaleform: Creación del Interfaz I para clonar un widget, clonamos el Label que tenemos en la biblioteca, para así poder modificar las características de la fuente y que sea distinto al título de “Menú de Pausa”. Añadimos el nuevo widget y modificamos su nombre de instancia a “Lab_Info” y en el panel de propiedades, el textValue a “Seleccione alguna de las opciones”.
    2. La colocamos de forma que quede debajo de los botones, y centrada. Hay que hacerla de un tamaño suficiente para que las distintas cadenas que mostrará entren, o se cortarán.
    3. La utilidad de este label es cambiar su texto cuando nos encontremos encima de uno de los botones, mostrando la frase “Pulse Continuar para seguir con el juego” en el botón Btn_Continue y la frase “Pulse Salir para salir del juego” en el Btn_Exit, creamos nuevos métodos que tendrán el siguiente aspecto.
      function btn_continue_over()
      {
      	Lab_Info.text ="Pulse Continuar para seguir con el juego";
      }
      
      function btn_exit_over()
      {
      	Lab_Info.text ="Pulse Salir para salir del juego";
      }
    4. Ahora hay que crear un nuevo método, que será el invocado cuando dejemos de estar encima de alguno de los dos botones, que volverá a dejar la Label con el texto inicial de “Seleccione alguna de las opciones”. Lo conseguiremos creando un nuevo método que se encargue de este trabajo.
      function btn_rollout()
      {
      	Lab_Info.text ="Seleccione alguna de las dos opciones";
      }
    5. Ahora que tenemos los métodos, tenemos que añadir los EventListener, que quedarán tal como se muestra a continuación.
      Btn_Continue.addEventListener("rollOver",this,"btn_continue_over");
      Btn_Exit.addEventListener("rollOver",this,"btn_exit_over");
      Btn_Continue.addEventListener("rollOut",this,"btn_rollout");
      Btn_Exit.addEventListener("rollOut",this,"btn_rollout");

    Ya hemos terminado, ahora si probamos de nuevo el fichero con el FxMediaPlayer, si pasamos el ratón por encima de los botones, veremos cómo cambia el texto de este Label que hemos creado. Ahora a por el último paso, rellenar los métodos que se invocan al hacer click, y explicar cómo se comunica desde Actionscript con UDK Script.

    Antes de comenzar con los pasos, voy a hablar sobre el funcionamiento de la comunicación Actionscript -> UDK.

    Para poder reproducir una película Flash en UDK, debemos de crear una clase que hereda de GFxMoviePlayer y en ella, especificar la película y algunas de las características de la misma, como el tamaño y la alineación de la misma. En ese fichero podemos especificar métodos, y cuando desde el código de Actionscript se invoca uno, se busca en su clase y desde el método en UDK podemos realizar las acciones consecuentes.

    1. En la capa de Actionscript, con la primera celda seleccionada, entramos en botón derecho -> Acciones.
    2. Bajamos todo el texto una línea, y en la primera línea, que ahora estará libre, importamos una librería que nos hará falta para poder comunicarse con UDK.
      import flash.external.ExternalInterface;
    3. Rellenamos los métodos que teníamos vacíos conforme a lo siguiente. El método ExternalInterface.callrealiza una llamada al método cuyo nombre es el primer parámetro y le pasa unos parámetros que se especifican a continuación. Tenemos que tener preparado un método en la clase que se encarga de la película que acepte esos parámetros y realice alguna acción.
      function btn_continue_click()
      {
      	ExternalInterface.call("ExitMenu");
      }
      
      function btn_exit_click()
      {
      	ExternalInterface.call("ExitGame");
      }

    Si ahora probamos la pelícla con el FxMediaPlayer y hacemos click en alguno de los botones, en la ventana de consola que se abre, aparecerá una línea de color azul que nos informa de qué método se invoca y en el caso de tener parámetros, también.

    Prueba final de nuestro menú, completamente funcional

    En el siguiente tutorial explicaremos cómo crear una clase para que cargue una película, y se escribirán los métodos que se invocan al hacer click.

    Antes de terminar, voy a poner todo el ActionScript que tenemos en nuestro archivo

    import flash.external.ExternalInterface;
    
    var cursorListener:Object = new Object();
    
    Mouse.hide();
    
    Cursor._x = _root._xmouse;
    Cursor._y = _root._ymouse;
    
    cursorListener.onMouseMove = function ()
    {
    	Cursor._x = _root._xmouse;
    	Cursor._y = _root._ymouse;
    }
    
    Mouse.addListener(cursorListener);
    
    function btn_continue_click()
    {
    	ExternalInterface.call("ExitMenu");
    }
    
    function btn_exit_click()
    {
    	ExternalInterface.call("ExitGame");
    }
    
    function btn_continue_over()
    {
    	Lab_Info.text ="Pulse Continuar para seguir con el juego";
    }
    
    function btn_exit_over()
    {
    	Lab_Info.text ="Pulse Salir para salir del juego";
    }
    
    function btn_rollout()
    {
    	Lab_Info.text ="Seleccione alguna de las dos opciones";
    }
    
    Btn_Continue.addEventListener("click",this,"btn_continue_click");
    Btn_Exit.addEventListener("click",this,"btn_exit_click");
    Btn_Continue.addEventListener("rollOver",this,"btn_continue_over");
    Btn_Exit.addEventListener("rollOver",this,"btn_exit_over");
    Btn_Continue.addEventListener("rollOut",this,"btn_rollout");
    Btn_Exit.addEventListener("rollOut",this,"btn_rollout");

Últimas adquisiciones

Hace un tiempo, fui al Game de Gran Vía con el máximo comentador del blog y me compré un par de cositas a unos precios muy interesantes. Aquí tengo las fotos para compartir con una pequeña reseña de cada una de las ediciones de coleccionista.

Final Fantasy XIII tiene poco contenido, pero es por la que menos he pagado, en su precio original no sé cuánto sería, pero tiene muy poca cosa.

  • Las postales tienen ilustración por ambos lados, por lo que no puedes disfrutar de las dos imágenes ya que te obligan a elegir, cosa que no entiendo.
  • Dos pegatinas por el precio de una. Así no duele gastar una para alguna cosa y mantener la otra guardada (aunque tampoco tiene mucho sentido guardar las cosas, luego se quedan en una estantería criando polvo). Aún no he comenzado con el juego por lo que no conozco el símbolo, pero la caja promete que es recurrente y reconocible.
  • El CD de la BSO es bastante escueto, 10 canciones. La música de los Final Fantasy siempre ha sido bastante  buena, por lo que no entiendo el hecho de incluir un CD con tan poco contenido. Remarco que en el sobre de cartón pone selección, imagino que por eso se guardan las espaldas de hacerlo así.
  • El libro de ilustraciones no está mal, pero nada memorable. Tenían que rellenar la caja y pillaron renders de prueba de los modelados y una pequeña descripción de lo que se ve y poca cosa más. Es como el apartado de Ilustraciones que hay en algunos juegos al terminarlo, pero impreso. Ver una vez y a la caja.

Todos los contenidos de la edición coleccionista del FF XIII

Duke Nukem Forever tenía unos contenidos que hacían que quisiera conseguir la coleccionista en cuanto su precio fuera reducido, la lástima es que casi todo tiene algún fallo. Vamos por partes:

  • Las fichas de casino me han molado, pesan bastante y el dibujo está bien. La lástima es que solo vienen dos y no están hechas como si fueran de casino de verdad, que imagino que era la intención. Grabar el nombre del casino que aparece, el “Lady Killer” y un valor para cada ficha le hubiera dado un toque espectacular. Lástima.
  • La baraja de naipes en formato mini. El reverso está bastante bien, pero lo primero que hice fue buscar los comodines, las figuras y los ases. Tenía la esperanza de que hubieran modificado esas cartas y pusiera algo gracioso. Me equivocaba, una baraja estándar. Decepcionante.
  • Los dados de casino. Una de las razones que hicieron que quisiera comprarme esta edición. Dando una baraja y las fichas de casino, me imaginé que los dados eran similares a los de un casino, y más o menos lo intenta. Yo tengo un par de dados de casino retirados y me encantan, pero cuando tuve estos en la mano la única palabra que se me ocurrió fue “infamia”. Son un despropósito total, por no tener, no tienen ni las caras planas, ni las aristas rectas. A partir de ahí, podéis haceros una idea de la calidad final de los dados.
  • El libro de tapa dura sí me ha gustado más. En esencia, es arte del juego, tanto desechado como incluido en el juego, con citas de los trabajadores y dividido en cinco secciones: Duke, el arsenal de Duke, aliens, amigos de Duke y entornos. Especialmente me ha gustado la parte que habla del diseño de Duke y de “NegaDuke”, un personaje que finalmente no apareció, que era la contrapartida de Duke.
  • Las postales son graciosas, y además, son postales de verdad. No es que sea importante que lo sean, pero me parece un buen detalle. Lo que me parece raro es que en la caja, hay una postal cambiada. La postal de Duke con el tiburón, en la caja es Duke en un ring con el cinturón de campeón, levantando los brazos. Las dos están bien, pero esta última creo que me habría gustado un poco más.
  • La pegatina está chula, adornará alguna de mis consolas o la carcasa del PC próximamente.
  • El recortable no tiene mal aspecto, el papel es bastante grueso y ligeramente satinado. Me da pena gastarlo, pero para que esté dentro de la caja, igual un día me pongo y lo hago. También pondré alguna fotito si ocurre.
  • El cómic, aunque algo corto, te cuenta qué fue de Duke durante todos estos años. Una invasión de S.M.A.R.T. Sharks y de extraterrestres lo mantuvieron ocupado, pero el rey ha vuelto. En resumen, no está del todo mal y tiene algunas salidas realmente divertidas.
  • El busto, que a mí me gusta especialmente. Con esta pieza sí que tenía esperanza cero porque me imaginaba un busto de plástico de mala calidad y mal acabado, pero ahora que la tengo en mis manos, debo decir que me ha sorprendido gratamente. Hace que me olvide de que sea de plástico.

Todos los contenidos de la edición coleccionista del Duke Nukem Forever, con su certificado de autenticidad y numerada, la 77775

Otro ángulo del maravilloso juego Duke Nukem Forever