La Isla - Collaboration · Creación de árboles ... Problemas con la ejecución en Blender Game de...

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


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.


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.


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:


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.


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


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.


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.


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”.


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.


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.


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.


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.


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.


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.


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.


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.


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).


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.


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.

La Isla - Collaboration · Creación de árboles ... Problemas con la ejecución en Blender Game de...

Documents

Transcript of La Isla - Collaboration · Creación de árboles ... Problemas con la ejecución en Blender Game de...