SÍNTESIS Y ANIMACIÓN DE IMÁGENES 2014 LA ISLA Contenido Daniel García Rubio y Marcos López García
La Isla Daniel García Rubio y Marcos López García
2
Contenido
Contenido ...................................................................................................................................... 2
Historia .......................................................................................................................................... 3
Controles ....................................................................................................................................... 5
Modelado ...................................................................................................................................... 5
Creación de árboles ................................................................................................................... 5
Creación de textura de agua ..................................................................................................... 8
Animación ..................................................................................................................................... 8
Animación en Game Engine afectada por la malla de colisión original .................................... 8
Lógica........................................................................................................................................... 10
Captación de una cadena de caracteres ................................................................................. 10
Uso de capas para la aparición de objetos al acercarse ......................................................... 11
Muro de seguridad .................................................................................................................. 12
Personaje ................................................................................................................................. 13
Interfaz .................................................................................................................................... 13
Rendimiento ................................................................................................................................ 14
Solución a problemas de fluidez en la ejecución .................................................................... 14
Solución al problema de tamaño del archivo.......................................................................... 15
Proceso de Trabajo ...................................................................................................................... 16
Implementación de la lógica antes de modelar los objetos ................................................... 16
Organización de la ventana outliner cuando se trabaja con muchos objetos ........................ 17
Python ......................................................................................................................................... 18
Mostrar y ocultar cursor ......................................................................................................... 18
Actualización de variables ....................................................................................................... 18
Otros ............................................................................................................................................ 19
Creación de un mapa .............................................................................................................. 19
Implementación del sitema de Menús y pantallas de información ........................................ 20
Problemas con la ejecución en Blender Game de objetos linkeados ..................................... 21
Controladora de Sonidos ......................................................................................................... 21
Extras ........................................................................................................................................... 21
Para cualquier jugador ............................................................................................................ 21
Para pruebas de ejecución ...................................................................................................... 21
La Isla Daniel García Rubio y Marcos López García
3
Historia
Nuestro personaje tras hacer un experimento fallido, abre un vórtice en el espacio que le
transporta a una Isla sin civilización aparente. Una vez llega tiene que cumplir una serie de
objetivos que van a estar divididos entre dos escenarios.
Norte de la Isla
En primer lugar ha de encontrar alimento para poder tener energía y desplazarse por
la Isla. Debe buscar en los árboles.
Deberá encontrar un machete para desenvolverse en la Isla.
Debe derrotar algún enemigo con el machete.
Deberá conseguir ramas usando el machete.
Una vez consiga las ramas suficientes deberá construir un puente para cruzar a la zona
de la cueva.
Deberá encontrar un mechero.
Deberá generar una antorcha usando ramas y el mechero.
Deberá entrar a la Cueva.
Además de estos objetivos obligatorios, el jugador puede entrar al bunker para conseguir una
ayuda especial para completar el juego o encontrar el mapa de la isla para orientarse mejor.
En esta zona el jugador se encontrará con tres tipos de árboles:
Árboles comunes
Arboles con 3 ramas: además de poder cortarse las ramas con el machete dejan caer
manzanas que proporcionan 40 unidades de energía.
Árboles que dejan caer bellotas, las cuales proporcionan 20 unidades de energía
Además hay 3 tipos de enemigos (en orden creciente de peligrosidad):
Cangrejos: aparecen en grupos de 6 en la playa. Siempre hay 3 grupos de 6 cangrejos
juntos formando un supergrupo, aunque cada grupo de 6 aparece
independientemente. Se mueven en círculos y restan 5 unidades de energía al tocar al
jugador. Se les puede eliminar empleando el machete, obteniendo de este modo 10
unidades de energía.
Escorpiones: aparecen en grupos de 6 en el césped, al igual que los cangrejos, aunque
no hay supergrupos de escorpiones. Mismo comportamiento que los cangrejos,
aunque restan 10 unidades de energía al tocar al jugador y se obtienen 20 unidades
de energía al derrotarlos.
La Isla Daniel García Rubio y Marcos López García
4
Plantas carnívoras: se trata de un enemigo especialmente fuerte, aunque no atacará si
el jugador no se acerca mucho a él por delante. Aparecen debajo del suelo cuando el
jugador se comienza a acercar a ellas, y ataca violentamente si se pone delante de
ellas. En ocasiones es posible verlas ocultas en el suelo antes de atacar. Poseen 100
unidades de salud, y la recuperan a razón de 3 por segundo. Restan 30 unidades de
energía si consiguen atacar al jugador. Este podrá eliminarlas atacándolas con el
machete o con el mechero, restándolas 30 de salud en cada ataque. Una vez
derrotadas proporcionan 30 unidades de energía al jugador.
Sur de la Isla
Deberá conseguir lianas usando el machete.
Deberá usar lianas para formar un puente colgante con el que alcanzar el islote.
Deberá conseguir un hacha.
Deberá conseguir troncos usando el hacha.
Deberá conseguir algún trozo de tela que pueda usar como vela.
Deberá conseguir los objetos necesarios para generar la balsa y escapar de la isla.
En esta zona el jugador se encontrará con tres tipos de árboles (todos ellos se pueden talar
con el hacha para obtener troncos):
Árboles comunes
Arboles con 3 ramas: además de poder cortarse las ramas con el machete dejan caer
manzanas que proporcionan 40 unidades de energía.
Árboles con 2 lianas: además de poder cortarse las lianas con el machete dejan caer
bellotas que proporcionan 20 unidades de energía
Además hay 3 tipos de enemigos (en orden creciente de peligrosidad):
Cangrejos: mismo comportamiento que en el norte, se pueden derrotar con el hacha
también.
Escorpiones: mismo comportamiento que en el norte, se pueden derrotar con el hacha
también.
Plantas carnívoras: mismo comportamiento que en el norte. Atacándolas con el hacha
se les resta 50 unidades de salud, de este modo es más fácil derrotarlas.
Un elemento nuevo introducido en esta zona son las casas de madera, muestra evidente de
que en algún momento la isla estuvo poblada. En ellas se pueden encontrar latas de comida,
que proporcionan 20 unidades de energía, así como otros objetos relevantes para el
desarrollo de la historia. La mayoría de ellas sin embargo están vacías para servir de decorado
y despistar un poco al jugador.
La Isla Daniel García Rubio y Marcos López García
5
Controles
Respecto al planteamiento inicial se ha decidido simplificar al máximo posible el control del
juego para que el jugador no lo encuentre incomprensible o demasiado complejo como para
jugar con él. A continuación se explican las diferentes Acciones que se pueden realizar
Control del movimiento del personaje
Rotación del personaje Posicionamiento del ratón
Avance del personaje W
Avance rápido del personaje W + Shift (izquierdo)
Saltar Barra espaciadora
Retroceso y desplazamientos laterales S, A, D
Control de armas y objetos
Cambio de arma E (comportamiento rotatorio, cada pulsación pasa a la siguiente
arma)
Cambio de objeto Q (comportamiento rotatorio, cada pulsación pasa al siguiente
objeto)
Usar Arma Botón derecho del ratón
Usar Objeto Botón izquierdo del ratón
Otros
Cambio de cámara Tabulador
Modelado
La Totalidad de los objetos han sido íntegramente modelados por nosotros a excepción de los
cangrejos, que han sido modelados por Almudena Gil, Sara González y Bascués Romero. La
mayoría de objetos han sido modelados usando las técnicas básicas aprendidas a lo largo del
curso y no hay ninguna técnica nueva respecto a esas. El único objeto que sí ha sido modelado
de una forma especial, han sido los árboles. A continuación se indica cómo se han generado.
Creación de árboles
Para crear los múltiples árboles que se encuentran a lo largo de la isla, hemos utilizado una
herramienta de Blender, que permite una fácil creación de varios modelos de árboles. A
continuación se explican los pasos requeridos para su creación:
La Isla Daniel García Rubio y Marcos López García
6
1) Se crea un plano que servirá de base Add/Mesh/Plane
2) Activamos la funcionalidad de Blender que permite generar los árboles File/User
Preferences.
3) En la pestaña Addons ponemos en el buscador Sapling y nos saldrá la opción que
buscamos “Add Curve: Sapling” Marcamos el cuadrado de la derecha que lo activa y
ya es funcional.
4) Con el plano que antes se creó seleccionamos, añadimos el árbol Add/Curve/Add Tree
5) Ahora se observa una estructura básica del árbol. A continuación se analizan los
parámetros más relevantes que nos permiten modificarlo.
6) Podemos modificar las características desde el panel de herramientas (Tecla T) o
pulsando F6 para que salga la ventana de propiedades de la herramienta.
La Isla Daniel García Rubio y Marcos López García
7
7) En la opción Settings están las diferentes funcionalidades. Entre las más útiles se
encuentra Branch Splitting, que permite determinar el número de niveles de ramas
que tendrá el árbol. Lo normal es usar tres.
8) Otra función útil es Leaves, que nos permite la creación de las hojas, nos permite
determinar el número de hojas y la forma de las mismas.
Observaciones:
No recomendamos el uso de formas complejas en las hojas, ni de muchas hojas ni de
muchas ramas. Al introducir muchos árboles, el procesamiento se vuelve muy pesado
y lento.
Tampoco recomendamos el uso de texturas, con un color acertado queda bastante
real y no incurrimos en un gasto de recursos
Finalmente en el proyecto se optó por dos niveles de ramas y hojas rectangulares, para
mejorar el rendimiento. El resultado es igualmente muy satisfactorio
La Isla Daniel García Rubio y Marcos López García
8
Creación de textura de agua
La creación del agua se ha hecho animando un mapa UV que contiene 100 fotogramas. Luego
superpuesta una textura de fondo que simule el agua. Aunque parece complicado, es
exactamente el mismo proceso que el utilizado en el ejercicio de clase de animación de la
llama. La única complicación está en encontrar en internet un mapa UV de animación de agua.
Animación
En el juego aparecen las siguientes animaciones:
Acciones del personaje principal
Movimiento de cangrejos
Movimiento de escorpiones
Movimiento de planta carnívora
Apertura del Bunker
A excepción de la de los cangrejos, que como ya se mencionó, nos cedieron su uso, el resto
han sido totalmente implementadas por nosotros con los conocimientos básicos de la
asignatura y sin ninguna técnica destacable. Si cabe destacar un problema que nos
encontramos al ejecutar una animación en Game Engine que se documenta a continuación.
Aunque el objeto se desplace en la animación, la malla de colisión, de forma invisible sigue
como al inicio, esto impide por ejemplo que al animar la apertura de una puerta, se pueda
entrar a la sala, aunque visualmente esté abierta. A continuación se documentan un par de
posibles soluciones.
Animación en Game Engine afectada por la malla de colisión original
Solución 1: declarar objeto animado como "no collision"
Para que sea más instructivo, se va a explicar para nuestro caso real. Implementamos la
animación de la entrada al Bunker, que era un único objeto. Al intentar entrar, se abría la
puerta, pero no se podía acceder a él, ya que la malla de colisión seguía como al inicio cerrada.
Para ello seguimos el siguiente proceso.
1) Crear la animación sobre el objeto único es decir el Bunker
2) En modo edición seleccionar los elementos de la puerta y separarlos formando otro
objeto pulsando la tecla P y dando a “Selection”.
3) Declaramos la puerta como un objeto “No collision”.
4) Ahora el Bunker es accesible esté abierto o cerrado. Para solucionar esto se aplica un
Muro de seguridad como se explica en el apartado de lógica.
La Isla Daniel García Rubio y Marcos López García
9
Solución 2: sustituir la animación por movimiento físico del objeto
En aquellas animaciones en las que sea importante que la malla de colisión quede en la misma
posición que se aprecia visualmente, se puede optar por esta segunda solución que tiene un
mejor resultado físico, pero es más compleja. Por ello solo se recomienda para animaciones
realmente simples. En nuestro caso se ha empleado en las puertas de las casas de la zona sur
de la isla:
1) Separamos cada elemento que vaya a tener movimiento independiente (lo que sería la
parte de la malla asociada a cada hueso) en un objeto distinto. En nuestro caso se trata
de picaporte, puerta y casa.
2) Se establece una jerarquía de parentesco entre los objetos igual a la que tendrían los
huesos del esqueleto. En nuestro caso es (de mayor a menor jerarquía) casa - puerta -
picaporte
3) Se edita el movimiento de cada objeto mediante lógica, con los actuadores de
movimiento simple, y sensores que indiquen cuándo se activa cada movimiento. En
nuestro caso se ha empleado un sensor de colisión que detecta si el personaje ha
tocado el picaporte. Entonces se pone a 0 una variable de tipo temporizador. Un
sensor de propiedad asociado a esta variable controla el giro del picaporte durante 0.2
segundos. Mediante otro sensor de propiedad asociado al temporizador se hace girar
a la puerta hasta los 0.9 segundos. El picaporte la acompaña debido a la relación de
parentesco.
La Isla Daniel García Rubio y Marcos López García
10
Cabe destacar que los temporizadores están incrementándose a razón de 1 unidad por
segundo constantemente desde que se carga la escena, por lo que conviene inicializa su valor
a un dato superior al que vaya a alcanzar la animación (10 segundos en nuestro caso) y ponerlo
a 0 en el momento en el que se desee que ésta comience.
Lógica
Sin lugar a duda si hay un aspecto que se ha cuidado y desarrollado mucho en el juego, este ha
sido la lógica. Le dimos la mayor importancia, desde el segundo uno como se podrá ver más
adelante en el proceso de trabajo. Cualquiera que vea el proyecto, observará que la cantidad
de lógica del juego es muy alta y con toda seguridad, será difícil que encuentre coherencia si
no se la explican debido al elevado número de sensores y actuadores que puede llegar a haber
por objeto. Parte de la lógica puede considerarse de uso básico, pero a continuación
explicamos aquellos procesos que consideramos de especial interés para usos futuros.
Captación de una cadena de caracteres
Puede ser interesante el acceder a una escena o a determinada ventaja, solo en el caso de que
el usuario introduzca una secuencia de teclas adecuada. A continuación se explica el proceso,
que en nuestro caso se ha utilizado para el acceso al búnker, en caso de querer usarla con otro
propósito, bastaría con cambiar el actuador de Scene. Partimos de la imagen de la lógica
totalmente desarrollada
1) Delimitar la zona del escenario en la que se va a poder captar esa señal, en caso de
que sea necesario. Para ello se introduce un sensor Near en el objeto deseado
configurando los parámetros de forma correcta.
2) Añadimos otro sensor de propiedad en este caso, que determinará la cadena que
queremos captar. En Value, introducimos la cadena que queremos que de acceso a esa
escena o ventaja. En nuestro caso “4815162342”.
La Isla Daniel García Rubio y Marcos López García
11
3) Añadimos el sensor Keyboard que captará los caracteres marcados en el teclado. Este
sensor, empezará a captar solo cuando se cumpla la propiedad Registro, que se activa
cuando el personaje está cerca del objeto, es decir, cuando el Near lo ordena. Del
mismo modo, cuando se aleja, Registro toma el valor False para que deje de realizar la
captación.
4) Por último solo falta enlazar la cadena deseada con el actuador que determina la
ventaja de haber introducido dicha cadena.
Observaciones:
Recomendamos que la cadena de caracteres no tenga ninguna de las teclas que se
usan para jugar. Esto puede causar puntualmente problemas en la lógica y causar que
la ventaja nunca se produzca aunque esté bien introducida la cadena.
Recomendamos utilizar un Near para delimitar la zona en la que se capta ya que de
otra forma puede dar problemas.
Hay ciertas teclas que no quedan registradas correctamente o no se pueden comparar
con el sensor de propiedad, como el tabulador o el "enter". Se desaconseja su uso.
La tecla de retroceso funciona a la perfección para borrar caracteres mal introducidos
en tiempo de ejecución.
Uso de capas para la aparición de objetos al acercarse
Es importarte limitar la carga de rendering y sobre todo no abrumar al jugador con muchos
elementos. Debido a esto tomamos la decisión de hacer que los “enemigos” del juego, solo
aparecieran por proximidad al jugador. Para ello hemos seguido el siguiente proceso, que
implica el uso de las capas de Blender:
1) Tener todos los objetos que queremos que estén ocultos, en una capa no visible,
diferente de la principal.
2) Crear un Empty en la capa principal en el punto en el que queremos que aparezcan
dichos objetos Add/Empty.
3) A continuación añadimos la lógica necesaria:
4) En primer lugar añadimos un sensor de proximidad Near, que determine a que
distancia del Near aparecen los enemigos
5) Añadimos un actuador Edit Objet en modo Add Object diciéndole cual es el objeto que
debe aparecer (es decir, el que tenemos en la capa no visible).
6) Añadimos un actuador Edit Objet en modo End Object para que el empty finalice una
vez el objeto ha sido añadido.
La Isla Daniel García Rubio y Marcos López García
12
Observaciones:
En nuestro caso hemos usado un sensor Near, pero podría usarse otro sensor de forma
que por ejemplo, el objeto apareciera al conseguir otro objeto.
El objeto que aparece lo hace de forma que su origen coincide con el origen del empty,
y con la misma rotación global que este tuviera.
No se deben emplear objetos con física de colisión para hacer aparecer a otros que
también la tengan, porque provoca problemas en el motor de física si las mallas de
colisión coinciden en algún espacio y ambos objetos pueden salir disparados. Por ello
se emplea un empty para hacer aparecer a los enemigos.
El empty se destruye una vez creado el enemigo para que solo aparezca un enemigo
por objeto empty. Si se deseara que aparecieran enemigos cada vez que el jugador se
acerque bastaría con no destruir el objeto empty.
Muro de seguridad
Debido a que las animaciones en Blender y aparición de objetos pueden generar problemas de
física o de acceso a áreas no deseadas, hemos tomado la decisión de implementar muros
invisibles que eviten el problema. Para ello seguimos el siguiente proceso:
1) Creación de un plano Add/Mesh/Plane en la zona problemática.
2) Lo declaramos en su pestaña de física como Static e Invisible.
3) Para que se elimine cuando ya se puede acceder o ya no se puede producir el
problema de física, depende totalmente la situación en la que se esté usando por
ejemplo.
a) Si queremos que se elimine a la vez que otro objeto, basta con hacerlo hijo de este
objeto. Al emplear el actuador end object sobre un objeto, todos sus hijos también
desaparecen.
b) Si queremos que se elimine de forma autónoma ante X situación, hay que usar los
sensores apropiados para el caso, junto al actuador edit object/end object
Observaciones:
Intentad pegar lo máximo posible el plano a la zona a la que queráis evitar el paso.
Hemos observado que si el jugador no entiende que por ahí no puede pasar y sigue
dándole a avanzar, cuando de repente pueda seguir porque ha salido de la acción del
plano va a salir disparado. Esto creemos que es debido a un error de Blender, que hace
que se acumule el movimiento aunque no avance.
La Isla Daniel García Rubio y Marcos López García
13
Personaje
Debido a lo compleja que ha resultado la lógica de del personaje y sus objetos asociados aquí
solo se muestra una breve explicación de la lógica que agrupa cada uno de ellos:
Personaje: control de teclado (capa lógica 1), movimiento (capa lógica 1), y energía
(capa lógica 2).
PersonajeArmadura: animaciones de movimiento y uso de armas y objetos.
CameraTarget: control de la cámara y el mapa.
Sonidos: todos los sonidos durante el juego se generan desde este objeto.
ControladorArmas: control del arma seleccionada, cambio de arma, acciones de
arma…
ControladorObjetos: control del objeto seleccionado, cambio de objeto, acciones de
objeto…
Cabe destacar que cada uno de los objetos del inventario existe en la mano del personaje
como hijo de su hueso desde el principio, solo que están ocultos y la lógica indica que aún no
se han recogido. Una vez recogidos, se hacen visibles en la mano y se actualiza la lógica para
permitir el uso del objeto. Estos objetos en la mano emplean la misma malla que los objetos
análogos que se recogen, solo que estos últimos están escalados para que se vean mejor desde
el punto de vista del jugador.
Interfaz
Para ayudar al jugador en el desarrollo de la historia se proporciona una interfaz superpuesta a
la imagen en las escenas norte y sur, que se muestra las siguientes informaciones:
Objetivo actual a cumplir: se trata de un texto que cambia su contenido en función del
objetivo que el jugador debe cumplir a continuación. Para determinar cuál es el
objetivo siguiente a mostrar, este texto almacena todos los objetivos ya cumplidos en
variables booleanas. Cuando recibe la información de que un objetivo podría haberse
cumplido (en forma de mensaje, o por aparición de un nuevo elemento en la propia
interfaz) se comprueba que no se haya cumplido previamente ni este, ni ninguno
posterior. En ese caso el texto se cambia por el siguiente objetivo a cumplir y se marca
el objetivo actual como cumplido. Esta lógica ha sido desarrollada de forma muy
sistemática y ordenada, debido a la gran cantidad de cableado, para no cometer
errores (si un mismo cable debía unirse muchas veces para diferentes objetos se ha
unido para todos a la vez, para no olvidar ninguno). La lógica ha resultado así de
compleja debido a que hay objetivos que podían cumplirse múltiples veces y/o en
desorden, como la recolección de troncos, ramas y lianas, y no se debe mostrar al
jugador un objetivo que ya ha cumplido previamente cuando tiene una tarea más
reciente por realizar.
La Isla Daniel García Rubio y Marcos López García
14
Objetos del inventario recolectados: cada uno de estos objetos tiene en la interfaz dos
representaciones, una semitransparente y otra opaca. Ambas están ocultas
inicialmente, y cuando el objeto se obtiene la representación semitransparente
aparece. Cuando el objeto está en uso, la representación opaca se muestra ocultando
la semitransparente. De este modo el jugador sabe qué objetos tiene disponibles y
cuál está usando. Adicionalmente, hay un contador que indica la cantidad de objetos
de los que el jugador dispone, que se actualiza con un sencillo script Python cada vez
que dicha variable del jugador cambia (esto evita gran cantidad de mensajes y ha
facilitado el desarrollo escalable del juego).
Armas encontradas: exactamente el mismo comportamiento que los objetos, solo que
sin contador ya que solo hay un arma de cada tipo.
Energía: este objeto muestra al jugador un número que representa la energía
disponible. Se actualiza con un script Python cada vez que dicha variable del jugador
cambia, al igual que los objetos del inventario. De este modo se ha centralizado el
control de la energía en el objeto personaje, ya que la interfaz siempre sigue a la
variable energía sea cual sea su valor.
Textos de información: se trata de un par de textos que se muestran cuando el
jugador recibe daño de enemigos o se mete en el agua.
Rendimiento
Nuestro escenario es muy amplio con muchos objetos, debido a esto el rendimiento ha sido un
reto. Utilizando varias técnicas explicadas a continuación hemos conseguido que el juego se
ejecute fluidamente
Solución a problemas de fluidez en la ejecución
Al intentar ejecutar el juego sin ningún tipo de limitación en el rendering, observamos que en
ordenadores poco potentes, había retardos muy apreciables. Para solucionarlo se ha
necesitado acortar la distancia de rendering de las cámaras. Esto conlleva un problema con el
cielo: al estar a mayor distancia que la de rendering, no se muestra en la ejecución. Para
solucionarlo, se ha implementado una esfera de menor radio que contiene el cielo y que se
mueve con el personaje pero no rota con él. Esta esfera va atravesando el escenario según el
personaje se mueve, por lo que está declarada como “no collision”. Una vez los objetos la han
atravesado son visibles.
Para emparentar la esfera del cielo de forma que se desplace con el pero no gire se han
seguido los siguientes pasos:
1) Introducir la esfera que contiene el cielo como un objeto de la escena.
2) Entrar en modo edición del personaje.
3) Con el botón control pulsado, seleccionar con botón derecho el cielo (esto es porque
es externo a la malla del personaje).
4) Añadir con shift un vértice central del personaje a la selección.
La Isla Daniel García Rubio y Marcos López García
15
5) Una vez hecho esto pulsamos Control + P para relacionarlos (vertex parenting).
6) Ajustar el tamaño de la cúpula y la distancia del rendering de la cámara hasta que
visualmente sea algo creíble sin perder velocidad de ejecución.
7) Añadir niebla con un color de entorno parecido al del cielo y unas distancias que hagan
parecer que los objetos aparecen poco a poco una vez han atravesado la cúpula del
cielo.
Observaciones:
El uso de niebla aparentemente no ofrece ninguna mejora en el rendimiento. Tan solo
es una mejora visual necesaria cuando se limita la distancia de rendering de la cámara,
para que los objetos se aprecien poco a poco en lugar de aparecer de golpe. Es la
distancia rendering de la cámara (unida a la complejidad de las mallas y la iluminación
de la escena) lo que realmente puede afectar positiva o negativamente al rendimiento.
Es imposible establecer ningún tipo de restricción al giro del objeto emparentado en el
Game Engine. La única forma que hemos encontrado de hacer que el objeto siga el
desplazamiento pero no el giro del personaje es el “vertex parenting”
Solución al problema de tamaño del archivo
En una etapa bastante temprana, nos empezamos a dar cuenta de que el archivo .blend
empezaba a ocupar demasiado megas. El motivo era evidente, la gran cantidad de objetos que
había en el juego con sus correspondientes mallas, materiales y texturas. Ya que la mayoría de
estos objetos estaban repetidos, tomamos la decisión de emplear una única malla por objeto
de las mismas características. A continuación se explica el proceso:
En caso de que se vaya a hacer una copia, tan sencillo como copiar con Alt +D
En caso de que los objetos ya estén copiados cambiar en la pestaña de la malla de los
objetos, la que figura, por la única que queremos usar en todos. Esto debe hacerse EN
MODO OBJETO ya que en modo edición no se permite cambiar la malla y Blender no
avisa del error.
Es muy útil buscar en las mallas ya existentes si hay alguna con la estructura
nombre.001 y sucesivos. Esto indica que una malla ha sido copiada y por lo tanto esta
guardada más de una vez. Cada malla eliminada puede ahorrar varios megas si es
compleja.
La Isla Daniel García Rubio y Marcos López García
16
Proceso de Trabajo
Implementación de la lógica antes de modelar los objetos
A la hora de abordar el juego, consideramos que lo primero de todo es comprobar, que la idea
que tenemos en mente, realmente se puede implementar en Blender de una forma factible.
Por ello decidimos diseñar en primer lugar toda la lógica del videojuego. Para ello creamos un
cubo o cilindro por cada objeto que iba a haber en el juego. Una vez creados todos con el
nombre del objeto al que representaban (muy importante seguir una nomenclatura correcta
para no cometer errores futuros), empezamos a aplicar la lógica como si los objetos fueran los
definitivos. Una vez creada y comprobado que el juego funcionaba correctamente,
empezamos a modelar y a sustituir los cubos por el objeto real. Para ellos seguimos el
siguiente proceso:
1) Diseño del objeto en un archivo .blend distinto (importante que todas las partes del
objeto, sean un solo objeto, control+J)
2) Importamos el objeto al archivo donde están todos los cubos y la lógica
implementados File/Append. Aquí seguimos el proceso habitual, buscando en la
carpeta obj del archivo .blend el objeto deseado.
3) Sustituimos la malla del cubo que representaba al objeto, por la del objeto definitivo,
para ellos, seleccionamos el cubo que representa al objeto y en las propiedades de
malla cambiamos la que aparece por la del objeto definitivo.
Observaciones:
Consideramos que este método de trabajo, facilita mucho la localización de los
puntos débiles de la idea original, ya que permite de una forma prematura,
observar que no es implementable de forma sencilla
Para poder realizar este proceso, es esencial tener una nomenclatura de los
objetos coherente, tanto de los cubos que representan como de los finales. Es
importante no solo cambiar el nombre del objeto, sino también el de la malla.
La Isla Daniel García Rubio y Marcos López García
17
Organización de la ventana outliner cuando se trabaja con muchos
objetos
Debido a la gran cantidad de objetos presentes en los escenarios de nuestro proyecto, se hacía
realmente difícil hallar un objeto deseado en el outliner. Por ello tomamos la decisión de
ordenar los objetos en esta ventana (especialmente aquellos que se repiten por todo el
escenario) emparentándolos con emptys con nombres significativos.
De este modo la ventana del outliner se convierte en un árbol jerárquico de objetos
emparentados entre sí que se pueden explorar como un árbol de carpetas en un explorador de
archivos. Esto nos ha resultado tremendamente útil a la hora de organizar los puntos de
aparición de enemigos, ya que en nuestro proyecto hay, por poner un ejemplo clarificador,
más de 700 puntos de aparición de cangrejos.
La Isla Daniel García Rubio y Marcos López García
18
Python
Hemos recurrido a Python para aquellas cosas, que implementar con sensores y actuadores
era excesivamente complejo o lioso. No hay ningún script muy complejo, pero a continuación
explicamos los más significativos y que pueden servir de utilidad.
Mostrar y ocultar cursor
Puede ser interesante que muestre el ratón en algunas escenas y en otras no. Para ello,
técnicamente, blender ofrece una opción en la pestaña de propiedades de escena, que
permite determinar si se ve o no. El problema viene, porque el marcar esa opción, implica
poner la variable que la controla a true, sin embargo, que no aparezca marcada, no implica
ponerla a false. Esto tiene un problema bastante molesto, una vez se modifique la variable con
este método, no será posible ocultar el cursor en otra escena. Debido a esto hemos
implementado dos Scripts muy sencillos, que modifican la variable en cada escena, de forma
que siempre controlamos si se ve o no el mouse. Los códigos son los siguientes:
1) Mostrar cursor
import bge
bge.render.showMouse(True)
2) Ocultar Cursor
import bge
bge.render.showMouse(False)
Actualización de variables
Blender no conserva las variables entre cambios de escenas. Esto supone un problema en un
juego como el nuestro, ya que los objetos son necesarios entre escenas. Debido a esto se ha
creado un script, que no guarda y recupera las variables del disco duro, como pudiera ser la
primera opción. Nos dimos cuenta de que la interfaz siempre está abierta y por lo tanto guarda
el número de objetos que tenemos (ya que se marcan en la pantalla como iconos). Debido a
esto hemos generado un script que identifique que objetos y cuantos de cada aparecen en la
interfaz, y lo aplique a las variables de la escena nueva. A continuación se explica el
funcionamiento, si se quiere ver el script integro, ir al archivo Isla.blend.
1) En primer lugar se busca la escena Interfaz
2) Obtenemos las propiedades y objetos de la escena Interfaz
3) Los copiamos a las variables de la escena deseada (si un objeto es visible en la interfaz
es porque el objeto análogo de la escena ha sido encontrado/se está usando)
Las variables que deseen conservarse entre cambios de escena y no queden reflejadas
de forma visual en la interfaz (como es el caso de haber encontrado el mapa o haber
hallado la fórmula de la inmortalidad en nuestro juego) pueden almacenarse en
cualquier objeto de la interfaz antes de salir de la escena y ser recuperadas igualmente
al iniciar otra escena.
La Isla Daniel García Rubio y Marcos López García
19
Otros
En este apartado se explican aquellos aspectos del juego que consideramos de interés, pero no
encajan en uno solo de los puntos anteriores.
Creación de un mapa
Tras darnos cuenta de que en determinados momentos el jugador podía sentirse desorientado
en el juego, tomamos la decisión de implementar un mapa que indicara la posición del jugador
en todo momento. Para usarlo, tomamos la decisión de que previamente el jugador debía
encontrar un objeto que habilitara dicha función. Una vez conseguido, se activa una nueva
vista de cámara, que muestra en un plano contrapicado el mapa entero. El proceso para la
creación del mapa ha sido el siguiente:
1) Creación de una nueva cámara que se colocará elevada en el eje Z de forma que se
observe toda la Isla. Add/Camera
2) Creación de un plano Add/Plane y lo modelamos a la forma deseada en nuestro caso
un triángulo. Situamos el plano justo encima del personaje y la emparentamos con
control P.
3) Hacemos que la flecha solo sea visible por el lado al que apunta la cámara
4) Aplicación de la lógica necesaria para la visualización de la cámara (Este paso depende
de cómo cada uno quiera activar el uso de la cámara).
La Isla Daniel García Rubio y Marcos López García
20
Implementación del sitema de Menús y pantallas de información
Para los menús, hemos creado una escena por cada elemento a mostrar por pantalla. Para
navegar entre ellas, decidimos usar el ratón ya que era lo más intuitivo y simple de cara al
usuario. Para Que cada escena parezca un plano para el usuario, basta con enfocar a un objeto
plano con la cámara. A continuación se detalla el sistema implementado para poder usar el
ratón:
1) Hay que crear un plano por cada zona en la que queremos que al pinchar, se produzca
un evento, en nuestro caso, enviar a otra escena Add/Mesh/Plane. Es muy importante
que el rectángulo creado, tenga la forma aproximada del texto al que representa, para
evitar interferencias con otros rectángulos, para ello escalamos usando la tecla S en el
eje conveniente. Comprobar que absolutamente ninguno se solape con otro.
2) Declaramos la totalidad de los planos como invisibles y estáticos en la pestaña de
Física de cada plano (Importante: Si no estás en Blender Game, esta opción no
aparece)
3) Asociamos a cada plano dos sensores tipo Mouse, uno que detecte si está el ratón
pasando por encima del plano y otro que detecte si se hace clic en el botón izquierdo.
Esto lo unimos al actuador de cambio de escena.
Observaciones:
Recomendamos intentar que los planos de escenas diferentes no cuadren en
posiciones similares. Puntualmente hemos observado que se puede producir un bucle
entre escenas, debido a que se queda funcionando alguno de los sensores.
Este problema también puede solucionarse activando la opción “tap” en el sensor que
detecta la pulsación del botón izquierdo del ratón. Así una vez cambiada la escena, el
sensor no manda más pulsos positivos y no se entra en un bucle de cambios de escena.
La Isla Daniel García Rubio y Marcos López García
21
Problemas con la ejecución en Blender Game de objetos linkeados
Como ya se ha comentado antes, para mejorar el rendimiento del juego, se ha recurrido a
linkear múltiples objetos. Esto ha generado un problema al ejecutar el juego en escenas que
tenían objetos linkeados de otras. Estos objetos, no se veían. El problema era el siguiente,
habíamos importado objetos que eran hijos de otro, pero no habíamos importado al padre.
Hay dos posibles soluciones:
1) Linkear también el objeto padre aunque lo ocultemos en la escena que no es necesario
2) Hacer una copia del objeto (no link) y quitarle el parentesco
Controladora de Sonidos
Cuando hay muchos objetos o acciones en un videojuego, los sonidos son fundamentales.
Como son demasiados, para tener un control constante en caso de problemas, tomamos la
decisión de hacer una controladora de sonidos que consigue en lo siguiente:
1) Crear un Empty hijo del personaje, que será el que tendrá todos los sensores de
sonidos.
2) Crear en ese Empty un mensaje que active cada uno de los sonidos
3) Enviar el mensaje en el objeto que debe sonar cuando se produzca dicha acción
De esta forma, conseguimos tener la totalidad de los ficheros de sonido en un único objeto, lo
que hace más fácil su control en caso de errores o de cambios grandes, por ejemplo por querer
comprimir ya todo una vez hecho.
Extras
Para cualquier jugador
Hemos implementado un Bunker que si el jugador consigue abrir, le aportara una especie de
“inmortalidad”. Consiste en un aumento de la vida constante, aunque si se juga muy mal, el
personaje puede llegar a morir, ya que no evita llegar a cero. Proceso para conseguirlo:
1) Encontrar el Bunker y acercarse a él
2) Introducir la cadena “4815162342”
3) Entrar al Bunker y coger el objeto del interior
Para pruebas de ejecución
Para facilitar las pruebas de ejecución hemos implementado un par de botones que le
proporcionan características especiales al jugador:
1) Pulsar el botón Shift del lado derecho del teclado proporciona inmortalidad (mismo
efecto que la lata del Bunker).
2) Pulsar el botón Control del lado derecho del teclado proporciona inmortalidad,
además de una unidad de cada objeto del inventario: ramas, lianas, troncos, sábanas,
machete, mechero, antorcha, hacha y mapa.