Embed Size (px)
Citation preview
UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA CIENCIAS FÍSICAS Y MATEMÁTICA
CARRERA DE INGENIERÍA EN COMPUTACIÓN GRÁFICA
INTELIGENCIA ARTIFICIAL DEL VIDEOJUEGO LA DAMA
TRABAJO DE GRADUACIÓN PREVIO LA OBTENCIÓN DEL TÍTULO DE INGENIERO
EN COMPUTACIÓN GRÁFICA
AUTOR:
WILMER PATRICIO PUJOS CASTRO
TUTOR:
Fis. GONZALO BAYARDO CAMPUZANO NIETO
QUITO - 28 JUNIO
2016
ii
DEDICATORIA
Dedico este trabajo a mi madre Gardenia Castro, pues ella fue el principal cimiento para
la construcción de mi vida profesional, sembró en mí los valores de la responsabilidad y
deseos de superación, en ella tengo un espejo en el cual me quiero ver reflejado, sus
virtudes son infinitas y el amor por sus hijos me llevan admirarla cada día más.
iii
AGRADECIMIENTOS
En el presente proyecto integrador me gustaría primeramente agradecer a Dios, por
bendecirme para llegar hasta donde he llegado, ya que hizo realidad este sueño
anhelado. A la Universidad Central del Ecuador por darme la oportunidad de pertenecer
a tan prestigiosa institución y ser un profesional. A mi tutor del proyecto de titulación
Fis. Gonzalo Bayardo Campuzano Nieto, quien con su conocimiento, experiencia y
paciencia ha logrado guiarme y así pueda terminar mis estudios con éxito. A mi familia
Jaime Pujos, Gardenia Castro, Jenifer Pujos, Magaly Solís, Edgar Fuentes, Stalin
Bonilla, Steven Tapia, Jorge Maldonado y David Sandoval, quienes fueron mi motor,
mis pilares para que siempre siguiera adelante.
Son muchas las personas que han formado parte de mi vida profesional, me encantaría
agradecerles su amistad, consejos, apoyo y ánimos en los momentos más difíciles de mi
vida. Para todos ellos:
Muchas gracias y que Dios los bendiga.
iv
AUTORIZACIÓN DE LA AUTORÍA INTELECTUAL
Yo, Wilmer Patricio Pujos Castro en calidad de autor del proyecto integrador realizado
sobre: Inteligencia Artificial Del Videojuego La Dama, autorizo a la UNIVERSIDAD
CENTRAL DEL ECUADOR hacer uso de todos los contenidos que me pertenece o
parte de los que contiene esta obra, con fines estrictamente académicos o de
investigación.
Los derechos que como autores me corresponden, con excepción de la presente
autorización, seguirán vigentes a mi favor, de conformidad con lo establecido en los
artículos 5, 6, 8; 19 y demás pertinentes de la Ley de Propiedad Intelectual y su
Reglamento.
En la ciudad de Quito, a los 15 días del mes de junio del 2016
Wilmer Patricio Pujos Castro
CC. 172224625-1
Telf. 0999039050
Email: [email protected]
v
CERTIFICACIÓN DEL TUTOR
Yo, Gonzalo Bayardo Campuzano Nieto en calidad de tutor del trabajo de titulación
INTELIGENCIA ARTIFICIAL DEL VIDEOJUEGO LA DAMA, elaborado por el
estudiante Wilmer Patricio Pujos Castro de la Carrera de Ingeniería en Computación
Gráfica, Facultad de Ciencias Físicas y Matemáticas de la Universidad Central del
Ecuador, considero que el mismo reúne los requisitos y méritos necesarios en el campo
metodológico y en el campo epistemológico, para ser sometido a la evaluación por
parte del jurado examinador que se designe, por lo que lo APRUEBO, a fin de que
trabajo investigativo sea habilitado para continuar con el proceso de titulación
determinado por la Universidad Central del Ecuador.
En la ciudad de Quito, a los 15 días del mes junio de 2016.
Gonzalo Bayardo Campuzano Nieto
CC. 1708459118
vi
vii
viii
CONTENIDO
RESUMEN .................................................................................................................... xiii
ABSTRACT .................................................................................................................. xiv
INTRODUCCIÓN ............................................................................................................ 1
1 PLANTEAMIENTO DEL PROBLEMA ..................................................................... 2
1.1 Antecedentes .......................................................................................................... 2
1.2 Formulación y descripción de problema. ............................................................... 3
1.3 Objetivos. ............................................................................................................... 3
1.3.1 Objetivo General. ............................................................................................ 3
1.3.2 Objetivos Específicos. ..................................................................................... 3
1.4 Justificación. .......................................................................................................... 4
1.5 Alcance .................................................................................................................. 4
1.6 Diseño Metodológico ............................................................................................. 5
2 MARCO TEÓRICO ..................................................................................................... 7
2.1 Definición Inteligencia artificial en videojuegos. .................................................. 7
2.2 Historia de la inteligencia artificial en los videojuegos. ....................................... 7
2.3 Técnicas de inteligencia artificial. ......................................................................... 8
2.3.1 Path Planning (Búsqueda de caminos) ........................................................... 8
2.3.2 Máquina de Estados Finitos ............................................................................ 9
2.3.3 Redes Neuronales Artificiales (RNA). .......................................................... 11
2.3.4 Árbol De Decisiones. .................................................................................... 12
2.3.5 Goal Oriented Action Planning (GOAP) ...................................................... 13
2.4 Estado del arte ...................................................................................................... 14
3 METODOLOGÍA ....................................................................................................... 16
3.1 Historia del videojuego “La Dama”. ..................................................................... 16
3.1.1 Introducción ................................................................................................... 16
3.1.2 Guion Literario ............................................................................................... 16
3.2 Análisis y diseño de las técnicas de inteligencia artificial. ................................... 19
3.2.1 Propósito ....................................................................................................... 19
3.2.2 Peatón ............................................................................................................ 19
3.2.3 Cantinero ........................................................................................................... 21
ix
3.2.4 Animales ........................................................................................................... 22
3.2.5 Enemigo (La Dama) .......................................................................................... 23
3.2.6 Diagramas de Estados Finitos de las inteligencias artificiales. ......................... 25
3.3 Herramientas ........................................................................................................ 27
4 PRUEBAS Y RESULTADOS .................................................................................... 29
4.1 Pruebas ................................................................................................................. 29
4.1.1 Proyecto de demostración ............................................................................. 29
4.1.2 Diagrama de Clases. ....................................................................................... 31
4.2 Programación y Resultados................................................................................... 33
4.2.1 Demostración de la Maquina de estados del Peatón tipo A. .......................... 33
4.2.2 Demostración de la Máquina de estados del Peatón tipo B. .......................... 34
4.2.3 Demostración de la Maquina de estados del Cantinero. ................................ 37
4.2.4 Demostración de la Maquina de estados del Enemigo. .................................. 39
4.2.5 Rendimiento ................................................................................................... 43
5 CONCLUSIONES Y RECOMENDACIONES ......................................................... 46
5.1 Conclusiones ......................................................................................................... 46
5.2 Recomendaciones ................................................................................................. 47
BIBLIOGRAFÍA ............................................................................................................ 48
GLOSARIO .................................................................................................................... 50
ANEXOS ........................................................................................................................ 51
x
LISTA DE FIGURAS
Figura 2.1. Ejemplo de diagrama de Estados Finitos. ...................................................... 9
Figura 2.2. Ejemplo de un esquema de RNA. ................................................................ 11
Figura 2.3. Ejemplo de un diagrama de árboles de decisiones. ...................................... 12
Figura 2.4. Ejemplo de precondición – efectos. ............................................................. 13
Figura 2.5. Pasos que realiza un GOAP ......................................................................... 14
Figura 3.1. Esquema de puntos randómicos en el mapa. ................................................ 20
Figura 3.2. El camino que debería tomar el peatón A ................................................... 20
Figura 3.3. El camino que NO debería tomar el Peatón A ............................................ 20
Figura 3.4. Esquema del peatón tipo B inactivo. ............................................................ 21
Figura 3.5. Esquema del peatón tipo B cuando se activa. .............................................. 21
Figura 3.6. Rutina que la IA del cantinero ejecutará. ..................................................... 22
Figura 3.7. Interacción del cantinero con el jugador. ..................................................... 22
Figura 3.8. Animal antes de la interacción con el jugador. ............................................ 23
Figura 3.9. IA del animal después de la interacción con el jugador. .............................. 23
Figura 3.10. Máquina de estados finitos del peatón tipo A ............................................ 25
Figura 3.11. Máquina de estados finitos del peatón tipo B ............................................ 25
Figura 3.12. Máquina de estados finitos del cantinero ................................................... 26
Figura 3.13. Máquina de estados finitos de los animales ............................................... 26
Figura 3.14. Máquina de estados finitos del enemigo .................................................... 27
Figura 4.1. Diagrama de Clases Parte 1.......................................................................... 31
Figura 4.2. Diagrama Clases Parte 2 .............................................................................. 32
Figura 4.3. El camino que debería tomar el peatón A .................................................... 34
Figura 4.4. Estado 0 (Estática) del Peatón tipo B. .......................................................... 35
Figura 4.5. El Peatón tipo B detecta la presencia del jugador. ....................................... 36
Figura 4.6. Estado 1 del Peatón tipo B interactuando con el jugador............................. 36
Figura 4.7. Estado 0 (inicial) del cantinero. ................................................................... 38
Figura 4.8. El cantinero detecta la presencia del jugador. .............................................. 38
Figura 4.9. Estado 1 interacción con el jugador ............................................................. 39
Figura 4.10. Estado 0 del Enemigo................................................................................. 42
xi
Figura 4.11. Estado 1 del Enemigo................................................................................. 42
Figura 4.12. Estado 2 del Enemigo................................................................................. 43
Figura 4.13. Aplicación subida a Google Play ............................................................... 44
Figura 4.14. Comentarios de los Jugadores en Google Play .......................................... 45
xii
LISTA DE TABLAS
Tabla 3.1. Herramientas de Software ............................................................................. 27
Tabla 4.1. Dispositivo Móvil Gama Baja ....................................................................... 43
Tabla 4.2. Dispositivo Móvil Gama Media .................................................................... 43
Tabla 4.3. Dispositivo Móvil Gama Alta ....................................................................... 44
xiii
RESUMEN
INTELIGENCIA ARTIFICIAL DEL VIDEOJUEGO LA DAMA
Autor: Wilmer Patricio Pujos Castro
Tutor: Fis. Gonzalo Bayardo Campuzano Nieto
El presente proyecto, tiene como objetivo el desarrollo de la lógica de los diferentes
tipos de agentes, que intervienen en el videojuego “La Dama”, utilizando técnicas de
inteligencia artificial, para la plataforma Android, el mismo que permitirá recatar las
culturas y leyendas urbanas de la ciudad de Quito. Aplicando Plath Planning y Máquina
de Estados Finitos, como técnica de Inteligencia Artificial en videojuegos, se ofrece el
diseño, especificación y posteriormente una API de prueba basado en estas dos técnicas,
en el lenguaje de programación C#, utilizando como motor de videojuegos Unity3D y
su entorno de desarrollo MonoDevelop.
Se crea diferentes tipos de comportamientos personalizados, para cada uno de los
NPC’s que componen el videojuego, algunos de los cuales se los implementa usando
Agentes (NavMeshAgent), herramienta que es proporcionada por el Game Engine de
Unity.
PALABRAS CLAVES: / VIDEOJUEGO “LA DAMA”/ PATH PLANNING/
TÉCNICAS DE I A/ PERSONAJE NO JUGADOR / MÁQUINA DE ESTADOS
FINITOS/ PLATAFORMA ANDROID/ UNITY 3D
xiv
ABSTRACT
ARTIFICIAL INTELIGENCE IN THE VIDEOGAME CALLED “LA DAMA”
Author: Wilmer Patricio Pujos Castro
Tutor: Phis. Gonzalo Bayardo Campuzano Nieto
This project has as its main objective the development in logic of the different types of
agents involved in the video game "La Dama", using artificial intelligence techniques
for the Android platform, and at the same time, allowing the rescue of cultures and
urban legends in Quito. Applying the Plath Planning and Finite State Machine as a
technique of artificial intelligence in video games, the design, specification and then a
test API based on these two techniques are offered in the programming language C #,
using engine Unity3D game and its surrounding in the MonoDevelop development.
Different types of personalized behaviors are created for each of the NPC's that make up
the game, some of which are implemented using the Agents (NavMeshAgent) tool that
is provided by the Game Engine Unity.
KEY WORDS: / VIDEOGAME “LA DAMA”/ PATH PLANNING/ IA
TECHNIQUES/ NON PLAYER CHARACTER / FINITE STATE MACHINE/
ANDROID PLATFORM / UNITY 3D.
I CERTIFY that the above and foregoing is a true and correct translation of the
original document in Spanish.
Andrea de los Ángeles Rosero Morales
Certified Translator
ID: 171385011-1
Bachelor Degree (SENECYT): 1005-04-540533; 1004-09-695818
1
INTRODUCCIÓN
El campo de la informática y las nuevas tecnologías, están experimentando un constante
cambio en la actualidad, debido a los continuos progresos investigativos, que se ha ido
incrementando especialmente desde mediados del siglo XX.
Los avances en la programación informática, con el desarrollo de algoritmos basados en
la resolución de problemas complejos, como también en los estudios en cuanto a
psicología cognitiva y la lógica matemática, han sido la antesala para la aparición de
Sistemas Inteligentes, que basan sus capacidades de proceso y metodología en la
Inteligencia Artificial.
Una de las industrias en las que ha tenido una influencia importante es en los
videojuegos. Si bien es cierto el concepto de Inteligencia Artificial en el campo de la
informática no es estrictamente el mismo que en la de videojuegos, las metodologías
que se aplican son directamente técnicas extraídas del primer campo.
En los videojuegos, se interpreta a la Inteligencia Artificial como todo aquello que dota
de un comportamiento a un personaje, pero no necesariamente se centra en la mejor
solución. Se utilizan técnicas estrictamente de Inteligencia Artificial ampliamente
conocidas y extendidas en el mundo, quizás las más utilizadas sean las técnicas basadas
en Búsqueda de Caminos (Plath Plannig) y la de Maquinas de Estados Finitos (Finite
State Machines), esto se debe a la facilidad de uso y comprensión.
Los avances en cuanto a la tecnología se refiere, han sido capaces de crear máquinas
con una velocidad de computó y capacidad de memoria impensables hace años atrás. Es
así que gracias a las investigaciones en las áreas mencionadas, los progresos en la
industria del hardware, se ha logrado que la aplicación de la Inteligencia Artificial
crezca considerablemente.
Este proyecto se basa en la aplicación de diferentes técnicas de Inteligencia Artificial,
como la Búsqueda de Caminos y Máquina de Estados Finitos, aplicados a diferentes
personajes, los cuales forman parte del videojuego “La Dama”, desarrollado para la
plataforma Android.
2
1 PLANTEAMIENTO DEL PROBLEMA
1.1 Antecedentes
La industria de los videojuegos es una de las industrias que mayor crecimiento tienen en
el mercado, con la llegada de nuevos avances tecnológicos, ha hecho que los usuarios
exijan una experiencia más real a la hora de escoger un videojuego; es por ello que, un
punto muy importante a la hora de estudiarlo y criticarlo, es parte concerniente al uso de
la inteligencia artificial que se le otorgue a ciertos personajes de éste, de tal manera que
logre sorprender al espectador.
La aparición de los microprocesadores permitieron avanzar en el campo de la IA
(inteligencia Artificial), consiguiendo añadir cierta aleatoriedad a los enemigos que
mejoraban su inteligencia. Numerosos avances se consiguieron a finales de los 70 en
la inteligencia artificial en juegos como el famoso space invaders (1978) y el
Galaxian (1979), que añadieron complejidad al juego introduciendo funciones hash
que “aprendían” de los actos del jugador, considerándose los primeros sistemas de
aprendizaje introducidos en el mundo del videojuego. (Martínez & Sotillo, 2015,
p.1).
Los avances en cuanto a la inteligencia artificial en los últimos años parece que se ha
llegado a un tope y la verdadera inteligencia de nuestros aliados y enemigos virtuales se
ha estancado, por otro lado las consolas de videojuegos, pasaron de ser consolas fijas
(Nintendo, Xbox, Play Station), a poder llevarlos a cualquier lugar en un dispositivo
móvil, y tomando en cuenta que, el uso de estos dispositivos móviles ha ido creciendo,
haciéndolos que sean imprescindibles en nuestros hogares y dando lugar a crear nuevas
formas de aprendizaje, las cuales son más entretenidas e interactivas para los jóvenes.
El presente proyecto trata de presentar a Quito en un ambiente en el que el usuario
experimente mediante un entorno 3D, uno de los lugares más turísticos de Quito (La
Ronda), a la vez que interactúa con diferentes personajes del Quito antiguo en el año
1563 y el Quito moderno, con ellos se consigue observar cómo ha ido variando
costumbres, tradiciones e infraestructura entre estas dos épocas.
3
1.2 Formulación y descripción de problema.
En la actualidad no existen videojuegos que aporten a la cultura y relaten acerca de las
leyendas de Quito, las cuales se han ido perdiendo con el pasar del tiempo, por esta
razón se ha visto la necesidad de crear un videojuego en el cual se aplica técnicas de
Inteligencia Artificial, las cuales brindan el realismo necesario al entorno y a los
personajes, permitiendo captar la atención de los jóvenes, y así conseguir que se
interesen en aprender sobre temas culturales a través del videojuego.
El juego está orientado a plataformas móviles, ya que según la encuesta realizada en
TIC e INEC (2015), el 87.7% de la población total del Ecuador, utiliza dispositivos
móviles. (Instituto Nacional de estadísticas y censos, 2015); Mientras que, una encuesta
realizada por Nicolás Montés, coloca a la plataforma Android como la segunda
plataforma más usada en dispositivos móviles con un 47.5%, un 5% más alto que su
rival IOS, para este 2016 se espera que el número de usuarios, que utilicen el sistema
operativo Android crezca. (Universidad Cardenal Herrera, 2015)
1.3 Objetivos.
1.3.1 Objetivo General.
Desarrollar un módulo del videojuego “La Dama”, utilizando gráficos en 3D de
personas, animales y fantasmas, a los cuales se les implementará Inteligencia Artificial,
esto influirá en la mecánica del juego, permitiendo que ciertos elementos que lo
componen tenga un comportamiento más realista.
1.3.2 Objetivos Específicos.
Desarrollar una serie de algoritmos inteligentes, encargados de dar autonomía a
distintos elementos del videojuego (personas, animales y enemigos), reconocer
las limitaciones de su comportamiento, exhibir verdadera creatividad, tomar sus
propias decisiones e interactuar con el medio que la rodee.
Simular las acciones del enemigo frente a situaciones de riesgo en el que éste se
encuentre.
Diseñar una máquina de estados finita, para determinar las rutinas que deberá
tener los distintos personajes del videojuego.
4
1.4 Justificación.
Aprovechando la capacidad que da la plataforma Android a los dispositivos móviles, los
cuales manejan una unidad de procesamiento de gráficos medianamente alto, se
desarrolla un videojuego interactivo 3D, el mismo que sirve como soporte para la
enseñanza sobre la cultura y leyenda “La Dama” de Quito, haciendo que éste sea más
entretenido y capte la atención del jugador. En este sentido es necesario, dotar de
realismo en la interacción con diferentes personajes de su entorno, los mismos a los
cuales se les ha implementado técnicas de inteligencia artificial para que sean
autónomos y tomen sus propias decisiones.
Las nuevas tecnologías permiten mayor cantidad de información y velocidad para
procesar los algoritmos relacionados a la parte de inteligencia artificial, no obstante se
ha tomado en cuenta a qué tipo de tecnología va dirigida el videojuego y se la ha
ajustado a su capacidad, por las limitación del hardware de los dispositivos móviles.
1.5 Alcance
El juego se orienta al proceso de enseñanza y del aprendizaje para jóvenes a partir de 15
años, porque el tipo de videojuego que se escogió es Survival Horror, y está acorde a lo
descrito en la leyenda urbana de “La Dama Tapada”.
El videojuego tiene un nivel, el entorno gráfico en el que se desarrolla consta de dos
diferentes ambientes, el primero en el Centro Histórico de Quito - La Ronda y al final
en un bosque situado a las afueras de Quito, éste último tendrá 5 pistas generadas al
azar. Al enemigo (La Dama) y a los pobladores de “La Ronda”, se les implementa
técnicas de inteligencia artificial para que interactúen según la situación lo amerite.
El videojuego se ha diseñado para correr en plataforma Android, teniendo en cuenta
como su mínima versión Kit-Kat, podrá ser manipulado por cualquier dispositivo móvil
(Tablets, SmartPhones, SmartTvs, etc…).
5
1.6 Diseño Metodológico
Para este proyecto se sigue varios pasos o etapas de un proceso sistemático, el cual nos
permite desarrollar la parte relacionada a inteligencia artificial, que consisten en:
Análisis
Diseño
Desarrollo
Implementación
Prueba y ajustes.
a) Etapa de Análisis.- Se define, la(s) técnica(s) de inteligencia artificial a
implementar en el videojuego. Entre las más utilizadas existen:
Máquinas de estados finitos
Redes de neuronas
Computación evolutiva
Lógica difusa
Arboles de comportamiento
GOAP
Path-Planning
Las que se han tomado en cuenta para el presente proyecto, es la Máquina de estados
finitos y Path Plannig.
La Máquina de estados finitos ayuda a establecer los diferentes tipos de rutinas que
tienen los personajes dentro de la escena del juego.
El Path-Plannig considerando el bajo recurso de memoria disponible en dispositivos.
Esta técnica es la encargada de llevar a los personajes de un punto a otro, se la
desarrolla con la consideración descrita anteriormente, para que funcione sin pérdidas
de fps (fotogramas por segundo), en el dispositivo móvil. Esto se hace con pocos puntos
origen-destino, en los cuales los personajes no jugadores se desplazan.
b) Etapa del Diseño.- Establecer un esquema general, en el cual se especifique cuáles
son los estados que tiene los personajes no jugadores (PNJ), con el fin de tener en
cuenta las acción que éste ejecuta, en las diferentes situaciones que se le presente.
6
c) Etapa del desarrollo. Se define los tools (herramientas) las cuales proporciona la
plataforma Unity, para el manejo de Path Planning (búsqueda de caminos), se usa Nav
Mesh Agent (Navegación de agentes por medio de una malla de triángulos), el cual
permite patrullar, en el caso del enemigo (la dama), las pistas que ésta proteja. Para
programar los algoritmos de inteligencia artificial se utiliza como lenguaje de
programación C#. Previamente se debe hacer un test al modelado 3D, para ver que el
Riggin este correctamente hecho, ya que esto podría influir en las acciones a ejecutar
del PNJ.
d) Etapa de la implementación.- Se añade la Máquina de estados finitos a los
modelos 3D, cabe mencionar que cada personaje (la dama, peatones, animales y
cantinero), tienen diferentes estados, ya que cada uno cumple diferentes roles en el
juego.
e) Etapa de pruebas y ajustes.- Se hace un Test en dispositivos móviles de gama baja,
media y alta; con el fin de observar, cual es el desempeño que éstos tienen, constatar
que no haya retraso en la fluidez de las acciones del PNJ, o que no haya perdidas de
FPS en el juego, esto incide a que no en todos los dispositivos se ejecuta con fluidez y
ayuda a determinar las características básicas, que debe tener el dispositivo para el
correcto funcionamiento del juego.
7
2 MARCO TEÓRICO
2.1 Definición Inteligencia artificial en videojuegos.
Es la simulación de comportamientos de los personajes no manejados por el jugador:
NPCs (Personajes no jugadores), enemigos, jefes finales, animales, etc... Es un agente
electrónico que puede pensar, evaluar y actuar en ciertos principios de la optimización y
la coherencia para cumplir con una meta o propósito. (Alcalá, 2011, p.2)
2.2 Historia de la inteligencia artificial en los videojuegos.1
Los primeros sistemas de inteligencia artificial se originaron en los años 50, se
aplicaron a juegos de mesa: damas (Arthur Samuel) y ajedrez (Claude Shannon). No es
sino, en los años 60 se desarrollaron juegos como el Pong o Spacewar, basados en la
lógica.
Años después por los años 70 surgieron juegos de un jugador, contra enemigos que se
movían mediante patrones almacenados.
Space Invaders en 1978 añadió dificultad creciente y respondía a las acciones del
jugador. Pac-Man en 1980 incorporó algoritmos de búsqueda en laberintos. Dragon
Warrior en 1990 fue el primer RPG, permitía variar las rutinas de la inteligencia
artificial de los enemigos durante las batallas.
En los años 90 se produjo un boom de nuevos géneros y nuevas técnicas de inteligencia
artificial
Máquinas de estados finitos
Redes de neuronas
Computación evolutiva
Lógica difusa
1 Esta sección se extrajo de (Alcalá, 2011)
8
En el año 1996 el videojuego Battelcruiser 3000AD, incorpora redes de neuronas. Hasta
la fecha habido un estancamiento en cuento a nuevas técnicas de inteligencia artificial
se refiere, y los videojuegos hasta el día de hoy usan algunas de las técnicas
anteriormente mencionadas.
2.3 Técnicas de inteligencia artificial.
2.3.1 Path Planning (Búsqueda de caminos)
Tiene como objetivo encontrar una secuencia de acciones que permitan al jugador
moverse desde un punto de mapa A hasta otro punto del mapa B, esto se puede apreciar
en el Anexo A.1.
La información que necesita este tipo de inteligencia artificial es:
Representación del mapa.
Movilidad de las unidades o del jugador.
Coste de las acciones de las unidades o del jugador.
a) Representación del mapa.- En esta parte es donde se le proporciona toda la
información del juego, como está estructurado, esta representación puede ser
tridimensional visualmente, pero realmente funciona como una imagen bidimensional y
está constituida por una matriz. La información que se proporcione en este punto es
muy importante, por ejemplo: Si se restringiera la iteración del jugador con el entorno;
es decir, definir en un punto en el mapa en el cual la inteligencia artificial no pudiera
interaccionar, como fuera el caso de una roca gigante, entonces la inteligencia artificial
debería esquivarla. Para ver un ejemplo de las diferentes representaciones de mapas ver
el Anexo A.2.
b) Movilidad de las unidades o el jugador.- Se toma en cuenta la movilidad que
deberían tener las unidades o del jugador. Si se tratara de un juego en primera persona
(Shooter), normalmente se controla a un único jugador; en cambio, si se tratara de un
juego de estrategia, en el cual hay un conjunto de unidades, las cuales todas y cada una
de éstas es un jugador independiente, tiene que calcular su camino, para llegar a un
punto determinado de forma independiente. Un ejemplo de esto se puede apreciar en el
Anexo A.3 y A.4
9
c) Coste de las acciones de las unidades o del jugador.- Cada una de las acciones de
la inteligencia artificial tiene un coste (valor), por ejemplo: Se define que si la
inteligencia artificial se mueve en diagonal tiene un valor de 1, si salta tiene el valor de
50, estos valores son los que influyen en que un algoritmo encuentre o no un camino
más rápido o más lentamente. (Martínez M. , 2014, p.8)
2.3.2 Máquina de Estados Finitos
Figura 2.1. Ejemplo de diagrama de Estados Finitos. (Torrico, 2016)
Una Máquina de Estado Finito (Finite State Machine), llamada también Autómata
Finito es una abstracción computacional que describe el comportamiento de un sistema
reactivo mediante un número determinado de Estados y un número determinado de
Transiciones entre dicho Estados.
Las Transiciones de un estado a otro se generan en respuesta a eventos de entrada
externos e internos; a su vez estas transiciones y/o subsecuentes estados pueden generar
otros eventos de salida. Esta dependencia de las acciones (respuesta) del sistema a los
eventos de entrada hace que las Máquinas de Estado Finito (MEF) sean una herramienta
adecuada para el diseño de Sistemas Reactivos y la Programación Conducida por
Eventos (Event Driven Programming), cual es el caso de la mayoría de los sistemas
embebidos basados en microcontroladores o microprocesadores.
Las MEF se describen gráficamente mediante los llamados Diagramas de Estado Finito
(DEF), llamados también Diagramas de Transición de Estados. (Torrico, 2016)
10
1) Sistemas Reactivos
Un Sistema Reactivo es aquel que interactúa constantemente con su medio ambiente,
tiene la característica de ser conducido por eventos (event driven), la respuesta de
tiempo es crítica y una vez que el sistema se activa permanece en ese estado de manera
indefinida. En estos sistemas los eventos llegan en tiempos impredecibles y el sistema
debe tener la capacidad de responder de manera inmediata, en el orden de los
milisegundos o microsegundos, sobre todo en sistemas donde la seguridad es crítica
(ejemplo: un piloto automático en un avión o una máquina para soporte de vida en un
hospital).
La gran mayoría de los sistemas embebidos (en base a microcontroladores o
microprocesadores) corresponden a esta categoría, debido a que estos sistemas están
típicamente conectados a varios tipos de sensores y transductores de entrada encargados
de captar los estímulos del medio ambiente (temperatura, presión, luz, magnetismo,
fuerza / peso, etc.), procesar dicha información y generar una respuesta del sistema
hacia el medio ambiente a través de transductores de salida y actuadores. (Torrico,
2016)
2) Sistemas Transformacionales
A diferencia de los Sistemas Reactivos un Sistema Transformacional es aquel que
recibe cierta información de entrada, realiza una cierta cantidad de cómputo, produce
cierta información de salida y luego termina. No muchos sistemas embebidos caen en
esta categoría; ejemplos más típicos son las aplicaciones para PC, como por ejemplo:
Un procesador de texto.
3) Diagrama de Estado Finito o Diagrama de Transición de Estados
Un Diagrama de Estado Finito es un gráfico que representa los diferentes estados de una
MEF y todas las transiciones posibles entre los estados.
Como en la Figura 2.1, consideremos un muy simplificado sistema de control de un
ascensor:
Estados: El sistema está formado por tres estados:
DETENIDO
YENDO_ARRIBA
YENDO_ABAJO.
11
Los diferentes estados se los representa mediante bloques cuadrados (como en este
caso) o círculos.
Transiciones: Las transiciones se las representa mediante flechas que indican la
dirección de transición de un estado a otro.
Eventos: Los eventos para el sistema en este ejemplo son los siguientes:
seleccion_piso: Es un evento externo que se genera toda vez que un usuario selecciona
un piso o llama al ascensor desde otro piso.
arribo_nuevo_piso: Es un evento interno que se genera cada vez que los sensores
detectan que se ha arribado al nuevo piso seleccionado por el usuario.
Los eventos se anotan en el gráfico por encima de las flechas de transición.
Condiciones de Transición: Dos transiciones en este sistema de ejemplo tienen
asociadas sus respectivas Condiciones de Transición. No todas las transiciones poseen
Condiciones de Transición.
piso_nuevo > piso_actual: Es la condición necesaria para que se produzca una
transición del estado DETENIDO al estado YENDO_ARRIBA.
piso_nuevo < piso_actual: Es la condición necesaria para que se produzca una
transición del estado DETENIDO al estado YENDO_ABAJO.
Las Condiciones de Transición se anotan por debajo de las flechas de transición.
Una pseudo transición inicial del punto rojo al estado DETENIDO identifica a este
último como el estado inicial de la MEF. (Torrico, 2016)
2.3.3 Redes Neuronales Artificiales (RNA).
Figura 2.2. Ejemplo de un esquema de RNA. (Mallo & Martínez Ruiz, 2013, p.5)
Es un sistema que sigue el modelo de las redes neuronales biológicas, estando
conformado por las entradas a la red, las salidas, y los nodos o neuronas junto con las
interconexiones entre ellas.
12
La principal ventaja de este tipo de redes es que podemos conseguir un sistema que
proporcione salidas adecuadas en función de unas entradas sin saber exactamente la
función total de transferencia, sino simplemente entrenándola bien, generalizando el
reconocimiento en patrones. Como punto negativo tenemos que requiere un
entrenamiento supervisado exhaustivo, cuanto más profundo sea el entrenamiento mejor
reaccionará la red. (Mallo & Martínez Ruiz, 2013, p.4)
Los ejemplos típicos de RNAs son el perceptrón simple y el multicapa, aunque en la
mayoría de los casos actuales el multicapa es usado.
Esta capacidad de devolver el resultado más correcto ante una entrada desconocida
convierte a las RNAs en un modelo muy productivo para la inteligencia artificial en los
videojuegos.
Una de las aplicaciones más comunes es en las técnicas de reconocimiento de
obstáculos y objetivos, así como en el movimiento autónomo.
En la Figura 2.2 se puede observar el que podría ser un ejemplo de perceptrón multicapa
para un sistema de avance con obstáculos, de tal forma que recibiendo mediciones de
distancia de por la izquierda, derecha y centro hasta un obstáculo el sistema supiese si
hay que seguir de frente, girar a la derecha o a la izquierda.
Se ha de mencionar que en el caso de que la población para entrenamiento no sea lo
suficientemente grande se pueden aplicar técnicas más avanzadas, que permiten
adaptarse más fácilmente durante el juego a los cambios del entorno. (Mallo & Martínez
Ruiz, 2013, p.5)
2.3.4 Árbol De Decisiones.
Figura 2.3. Ejemplo de un diagrama de árboles de decisiones. (Afonso & García Durán,
2010)
13
Los árboles de decisión son rápidos, fácilmente implementables y sencillos de entender.
Aunque sean el tipo de técnicas de toma de decisión más sencillas, pueden resultar
bastante sofisticados con algunas extensiones/variaciones.
Como vemos en la figura 2.3, está formado por un punto de decisión, que se denomina
la raíz. Cuando llegamos a un punto de decisión, la bifurcación que elegimos depende
del estado de entrada, esto es, de la información de la que se dispone en el momento en
el que se ha iniciado el proceso de toma de decisión.
Cuando el algoritmo de decisión llega a una determinada acción, entonces esa acción es
llevada a cabo inmediatamente. El árbol mostrado en la Figura 2.3 es muy sencillo con
opciones de tipo binario (YES/NO), pero se podría complicar con opciones numéricas,
vectores... Incluso añadir una componente aleatoria mediante estados alternativos a los
que se acceden con una determinada probabilidad. (Afonso & García Durán, 2010, p.6)
2.3.5 Goal Oriented Action Planning (GOAP)
Consiste en la planificación de acciones orientadas a las metas. Igual que los seres
humanos tenemos objetivos al realizar ciertas acciones la realidad aumentada también
debería tenerlos, para ser mucho más interactivos.
El goap se basa en que cada NPC del juego se les otorga de:
Un conjunto de metas que son alcanzables.
Un conjunto de condiciones asociadas a cada una de las metas.
Un conjunto de acciones formadas por dos elementos:
o Precondiciones
o Efectos
Por ejemplo.
Figura 2.4. Ejemplo de precondición – efectos. (Martínez M. , 2014)
Entrar a la
habitación
Abrir Puerta
Precondiciones: Puerta Abierta
Efectos: Dentro de la habiltación
Precondiciones: Cofre Cerrado,
tengo las llaves
Efectos: Cofre abierto.
14
a) ¿Cómo funciona el GOAP?
Figura 2.5. Pasos que realiza un GOAP (Martínez M. , 2014)
2.4 Estado del arte
El proyecto de “Representación específica de la mitología ecuatoriana descrita en una
obra histórica, a través del Demo jugable de un videojuego de estrategia” del autor
Jonnathan Cóndor, el cual interpreta una historia del Reino de Quito en la América
meridional y lo recrea en videojuego de estrategia con el fin de reforzar la identidad
histórica ecuatoriana. (Cóndor, 2015)
El proyecto “Diseño y desarrollo de un video-juego educativo con técnicas de
inteligencia artificial para plataforma Android utilizando metodología OOHDM” del
autor González Sotomayor, Itamar Soledad, quien explica que los videojuegos lúdicos o
educativos es uno de los tipos de videojuegos que más se aplican como parte del
proceso de enseñanza-aprendizaje en los niños, para el desarrollo del pensamiento y
para el desarrollo psico-motriz de los mismos. Las aplicaciones de entretenimiento en
3D son las más apetecidas por niños y jóvenes cuando de jugar se trata y en los
momentos de ocio. No cabe duda que la industria del videojuego es una de las que más
ingresos generan a nivel mundial y los consumidores de este tipo de aplicaciones son
millones de usuarios en todo el mundo. (Soledad, 2014)
El proyecto “Creación de juegos lúdicos utilizando técnicas de inteligencia artificial
sobre la plataforma c# .net con las librerías gdi+, para el desarrollo cognitivo de los
niños entre 7 y 11 años caso de estudio optimización del juego del tres en raya con
niveles de dificultad e ia, para la empresa vlbs cia Ltda” del autor Basurto Guerrero,
Mario Oswaldo, Villacís Silva y César Javier, el cual consiste en desarrollar un vídeo
15
juego educativo, conocido como el juego del “Tres en Raya” o “Tic-Tac-Toe” en el
idioma Inglés, utilizando Técnicas Heurísticas de Inteligencia Artificial, implementadas
mediante un Método Numérico propio optimizado del clásico modelo del Min-Max y
además se pretende evaluar su efectividad como una actividad de aprendizaje lúdica en
el proceso de enseñanza-aprendizaje, este tipo de video juegos educativos incrementan
la estimulación del pensamiento cognitivo en el área lógica y espacial de los niños entre
7 y 11 años. (Silva, 2014)
El proyecto “Videojuegos y comunicación: estudio de la relación comunicacional del
jugador con el mundo del videojuego, en el sistema de realidad virtual Kinect” del
autor Yaguana Padilla, Carlos Daniel, el cual integra la tecnología Kinect, la cual simula
la realidad a través de la generación de contenidos interactivos y personalizados en un
contexto lúdico. En estas condiciones, los jugadores percibieron a esta tecnología como
un "cuasi otro”. Esta relación se explicó a través de la para comunicación, como una
simulación comunicativa entre el hombre y la máquina. (Padilla, 2014)
A diferencia de los proyectos expuestos anteriormente, mantiene la línea de educación y
cultura, pero además el presente proyecto se crea tomando en cuenta dos tipos de
técnicas de inteligencia artificial, las cuales se trata de máquinas de estados finitos y
Path Planning, además se implementa distintos tipos de inteligencia artificial, cada una
de éstas tienen diferentes funciones en el videojuego y ejecutan diferentes acciones.
16
3 METODOLOGÍA
3.1 Historia del videojuego “La Dama”.
3.1.1 Introducción
El presente apartado describe la leyenda de la Dama Tapada, historia que permite
determinar los diferentes tipos de reacciones de los personajes, a los cuales se les dotará
de inteligencia artificial, haciendo que éstos tengan un comportamiento autónomo.
3.1.2 Guion Literario
J. Smith, escritor proveniente de Canadá llega al Ecuador a realizar un estudio de la
cultura de Quito y sus leyendas urbanas para la publicación de su libro.
Smith arribó al aeropuerto en horas de la tarde y luego de haberse registrado en el hotel,
salió a recolectar información, en su incursión por las calles de Quito llegó a una cantina
y decidió ingresar. Pide un trago y comienza a dialogar con el cantinero sobre algún
acontecimiento extraño que se haya suscitado por el sector, el cantinero le menciona la
historia de una dama que aparecía a altas horas de la noche, aquella mujer seducía a los
hombres que se encontraban en estado etílico y nunca más se los volvía a ver. Esto hace
despertar la curiosidad en Smith y solicita más detalles de los acontecimientos.
a. Cantinero
“Por los años 1563, Efrain y Aurora eran una pareja de esposos, que vivían en una casa
ubicada en los alrededores de la Real Audiencia de Quito. Efrain tenía graves problemas
con el alcohol, en una ocasión cuando el reloj se acercaba a la media noche, tuvieron
una discusión y Efrain bajo influencias del alcohol salió de casa llevando consigo un
objeto entre sus manos y no volvió a ser visto jamás.
Aurora con el pasar el tiempo fue consumida por el dolor y el odio que causo Efrain, por
su constante abandono al dedicar su tiempo a las cantinas. Aurora murió sentada en la
sala de su casa, el odio en su alma hizo que no encuentre descanso y busque venganza. “
17
Durante el transcurso de la conversación Smith entre trago y trago, al darse cuenta de
que eran altas horas de la noche decide salir a su hotel, sin antes ser advertido por el
cantinero que tenga cuidado con la dama en son de broma, en su caminar tambaleante
divisa a lo lejos una silueta que parece ser una mujer de hermosa figura y atuendo
obscuro. De pronto todo a su alrededor se oscurece.
Smith despierta en una casa en las afueras de la ciudad, toma un candelabro que estaba
cerca y con él comienza a inspeccionar el lugar, encuentra un porta retrato en el cual se
observa a una pareja, mientras sigue explorando llega a un dormitorio que parece ser el
cuarto principal de la casa y es ahí donde encuentra la mitad de una nota en la que dice:
“Aurora amada mía he querido por mucho tiempo decirte…”; cuando de repente se ve
una sombra en la ventana que desaparece rápidamente. Smith recuerda la conversación
con el cantinero en la que mencionaba a Aurora y Efraín, deduce que la carta que
encontró tiene relación con aquella historia, decide irse del lugar con intenciones de
regresar al día siguiente a investigar.
Al salir se da cuenta que está rodeado por un bosque tenebroso, mientras caminaba en
su intento de regresar al hotel se percata que está dando vueltas en círculo, de repente la
llama del candelabro se atenúa, por lo que Smith debe encontrar la manera de abastecer
el candelabro.
Mientras sigue caminando Smith encuentra un medallón en la rama de un árbol caído, lo
abre y nota que las personas de las fotos son las mismas del porta retrato, escucha pasos
que se acercan lentamente esto llama la atención de Smith causándole escalofríos y
huye de ese lugar, al sentirse seguro Smith sigue buscando la forma de salir del bosque.
En el transcurso del camino encuentra un saco manchado de sangre seca a lado de una
piedra grande y vuelve a sonar los pasos atrás de él, Smith se aleja del sitio de manera
rápida.
Smith mientras corre logra divisar un objeto en el suelo, se dirige ese lugar recoge el
objeto y se da cuenta que era un reloj viejo, en su interior se encuentra una fotografía de
Aurora. Smith empieza a cuestionarse sobre la razón de que todos los objetos están
tirados en el bosque y por qué desapareció Efraín, cuando de repente frente a él aparece
La Dama haciendo que huya por su vida.
18
Smith de tanto caminar se encuentra desorientado y encuentra una cueva para pasar la
noche, sin saber que dentro de ella se encuentra el fin de la historia, en el interior logra
percibir un olor putrefacto y se dirige a lo que cree ser el origen de aquel repulsivo
aroma, encontrándose con la osamenta de una persona y a su costado un trozo de papel,
el cual contiene el complemento de la carta que recogió en la habitación de aquella casa.
La carta dice lo siguiente:
Aurora
Amada mía
He querido por mucho tiempo decirte que siento mucho haberte hecho sufrir y dejarte
sola en esas largas noches, estoy muriendo tengo una enfermedad terminal y solo
quiero pedir perdón a la persona que fue mi compañera durante todo este tiempo,
quiero amarte los últimos días de mi vida y hacerte muy feliz.
Atentamente
Efraín.
Smith se da cuenta que el medallón, el reloj, el saco manchado de sangre y lo restos en
esa cueva, fueron indicios de que Efraín al salir de casa furioso y ebrio tuvo un
accidente causándole la muerte, siendo esta la razón por la cual no regreso con su
esposa.
Smith ve una sombra en la entrada de la cueva gira y ve a La Dama que se acerca hacia
él para matarlo, rápidamente Smith muestra la carta a su perseguidora, ella la observa,
acto seguido rompe en llanto le dirige una mirada a Smith y se desvanece perdonándole
la vida, él sale de la cueva y observa que el sol ha salido, se muestra un sendero que lo
dirige a la ciudad.
Smith crea su libro y lo publica, contando la experiencia vivida.
Meses después…
Un borracho se encuentra caminando por el centro de Quito a altas horas de la noche, en
la esquina bajo la luz de una lámpara, aparece La Dama y éste lanza un grito
desgarrador.
19
3.2 Análisis y diseño de las técnicas de inteligencia artificial.
3.2.1 Propósito
El propósito del presente apartado, es definir los requerimientos, las metas y
condiciones, que se debe tomar en cuenta a la hora de desarrollar las técnicas
inteligencia artificial, las cuales se añade a los diferentes personajes del videojuego,
entre los cuales se tiene:
Los peatones
El cantinero
Animales
El enemigo (la dama)
3.2.2 Peatón
La técnica de inteligencia artificial que se desarrolló en los peatones se divide en dos
tipos:
Peatón tipo A
Peatón tipo B
a) Peatón tipo A
La técnica de inteligencia artificial utilizada es Path Planning, ya que se desplaza por
todo el mapa, toma información del entorno y del terreno, esquivando obstáculos que se
le presenten, pero no interactúa con el jugador.
¿Cómo funciona esta técnica de inteligencia artificial en el peatón A?
Para definir las rutinas del peatón tipo A, se generaron puntos randómicos por todo el
terreno, tal como se muestra en la figura 3.1.
20
Figura 3.1. Esquema de puntos randómicos en el mapa.
El peatón tipo A deberá ser capaz de encontrar el camino más corto, para ir de un punto
origen a un destino. En las figuras 3.2 y 3.3 se muestra como se movería el peatón del
punto P1 a P4.
En ambos casos el peatón tipo A irá esquivando los obstáculos que en su camino
aparezcan.
b) Peatón tipo B
A diferencia del Peatón tipo A, esta técnica de inteligencia artificial se acciona cuando
el jugador interactúe directamente con ella.
Figura 3.2. El camino que
debería tomar el peatón A
Figura 3.3. El camino que NO
debería tomar el Peatón A
21
¿Cómo funciona esta técnica de inteligencia artificial en el peatón B?
El peatón tipo B permanece estático, tal como se muestra en la figura 3.4.
Figura 3.4. Esquema del peatón tipo B inactivo.
Al momento que el jugador atraviese el campo de interacción, el peatón tipo B se activa
y ejecuta cualquier acción que se le haya establecido. Como se muestra en la figura 3.5.
Figura 3.5. Esquema del peatón tipo B cuando se activa.
3.2.3 Cantinero
El cantinero tiene rutinas las cuales harán que se desplace por una parte del terreno y
cuando detecte la presencia del jugador, éste interactúa con el jugador.
¿Cómo funciona esta técnica de inteligencia artificial en el Cantinero?
Como se muestra en la Figura 3.6. El cantinero está ejecutando una rutina, seguirá
haciendo esto en un bucle infinito.
22
Figura 3.6. Rutina que la IA del cantinero ejecutará.
Al momento que detecta la presencia del jugador, el cantinero se acerca y comienza a
interactuar con el jugador, como se observa en la Figura 3.7.
Figura 3.7. Interacción del cantinero con el jugador.
3.2.4 Animales
La técnica de inteligencia artificial que se les añadirá a los animales, va hacer que estos
huyan cuando sientan la presencia, del jugador o de alguna persona, dentro de su
entorno.
¿Cómo funciona esta técnica de inteligencia artificial en los animales?
En la figura 3.8 se puede observar que el animal está en un modo pasivo.
23
Figura 3.8. Animal antes de la interacción con el jugador.
Al momento que se acerca el jugador el animal detecta esta presencia, éste huira hasta
un punto donde este a salvo, este punto será cualquier que se sitúe encima del mapa,
lejos del jugador. Observar la Figura 3.9.
Figura 3.9. IA del animal después de la interacción con el jugador.
3.2.5 Enemigo (La Dama)
Anteriormente se había explicado las técnicas de IA de diferentes personajes y/o
elementos que componen el presente videojuego, en esta sección se expone la técnica de
IA del enemigo, el cual está en una constante interacción con el jugador, ésta la más
compleja que las anteriores. Para la implementación de esta técnica de IA se debe tomar
en cuenta el coste computacional que tendrá, ya que contiene muchas acciones, más
cálculos y la cantidad de información que se maneja será considerable para el
dispositivo móvil.
24
¿Cómo funciona esta técnica de inteligencia artificial en el enemigo?
El enemigo debe custodiar un objeto de su importancia, quien intente quitar el objeto
custodiado reacciona atacándole. Lo que le hace interesante al enemigo es que prioriza
sus acciones; es decir, va a llegar un punto que tenga que decidir si persigue al jugador o
regresa a custodiar el objeto.
La función matemática que está definida para esta inteligencia artificial, es la ecuación
de una recta, la cual se puede observar en (1).
𝑓(𝑥) = (1 − 𝑥)𝐴 + 𝑥𝐵 (1)
Donde:
x pertenece a [0,1]
A es la variable que define la persecución
B es la variable que define el resguardo del objeto.
Si x=0, entonces:
𝑓(𝑥) = (1 − 0)𝐴 + 0 ∗ 𝐵
𝑓(𝑥) = 𝐴 (1.1)
Indica que el enemigo debe perseguir al jugador
Si x=1/2, entonces:
𝑓(𝑥) = (1 −1
2) 𝐴 +
1
2𝐵
𝑓(𝑥) = 0.5𝐴 + 0.5𝐵 (1.2)
Indica que el enemigo debe comenzarse a tener conflictos al perseguir al jugador
Si x=1, entonces:
𝑓(𝑥) = (1 − 1)𝐴 + 1 ∗ 𝐵
𝑓(𝑥) = 𝐵 (1.3)
Indica que el enemigo decide dejar de perseguir al jugador y volver a custodiar el
objeto.
25
3.2.6 Diagramas de Estados Finitos de las inteligencias artificiales.
A continuación se define los diagramas de las máquinas de estados finitos, que se les
implemento en cada una de las técnicas de inteligencias artificiales (peatones tipo A y
tipo B, cantinero, enemigo).
a) Peatón Tipo A.
Se trata de un diagrama muy fundamental, consta de un único estado, ya que este tipo de
inteligencia tiene como objetivo deambular por todo el terreno, tal como se puede
observar en la figura 3.10.
Figura 3.10. Máquina de estados finitos del peatón tipo A
b) Peatón Tipo B.
El peatón tipo B, posee dos estados el cual es estar inactivo, y el segundo interactuar
con el jugador.
Figura 3.11. Máquina de estados finitos del peatón tipo B
26
c) Cantinero.
Al igual que el peatón de tipo B, tiene dos estados, lo que le diferencia es que este tipo
de inteligencia posee una rutina e igual tiene que interactuar con el jugador haciéndole
una pregunta.
Figura 3.12. Máquina de estados finitos del cantinero
d) Animales.
Tendrán una interacción unilateral con el jugador. Los animales tendrán dos estados:
Caminar y huir.
Figura 3.13. Máquina de estados finitos de los animales
e) Enemigo (la dama).
El enemigo posee tres estados, los cuales se puede observar en la figura 3.14.
27
Figura 3.14. Máquina de estados finitos del enemigo
3.3 Herramientas
Tabla 3.1. Herramientas de Software
Sistema Operativo Windows
Nombre Descripción
Windows 7 Sistema Operativo desarrollado por la empresa Microsoft, el
cual sirve para gestionar los recursos de hardware y proveer
servicios a las aplicaciones.
Lenguaje de programación.
Nombre Descripción
C# C# es un lenguaje de programación que se ha diseñado para
compilar diversas aplicaciones que se ejecutan en .NET
Framework. C# es simple, eficaz, con seguridad de tipos y
orientado a objetos. Las numerosas innovaciones de C# permiten
desarrollar aplicaciones rápidamente y mantener la expresividad y
elegancia de los lenguajes de estilo de C.
28
Motor de juegos 3D (3D Game Engine)
Nombre Descripción
Unity
5.3.3f
Unity está disponible como plataforma de desarrollo para
Microsoft Windows, OS X y Linux, y permite crear juegos para
Windows, OS X, Linux, Xbox 360, PlayStation 3, Playstation
Vita, Wii, Wii U, iPad, iPhone, Android y Windows Phone.
Gracias al plugin web de Unity, también se pueden desarrollar
videojuegos de navegador para Windows y Mac.
29
4 PRUEBAS Y RESULTADOS
4.1 Pruebas
En esta sección se exponen las pruebas realizadas a los algoritmos de IA, que componen
el juego, además de exponer algunos detalles relativos al rendimiento que tiene cada
inteligencia.
4.1.1 Proyecto de demostración
Como proyecto de demostración se procede a realizar una serie de pruebas en Unity,
donde se otorga una escena, se presenta una escena y varias clases donde este la
inteligencia artificial en ejecución.
1) Scripts Generales.- A continuación se detallan algunos de los scripts que son
comunes, y que se utilizaron para implementar los diferentes tipos de inteligencia
artificial.
a) La clase InteraccionIA.cs representa el control de interacción que tiene el Peatón de
tipo A y el Cantinero con el jugador, en ambos casos la inteligencia se acerca al jugador
a “dialogar”.
b) La clase ControllerState.cs está encargada de manejar las animaciones, que debe
tener la inteligencia artificial. Por ejemplo: Estar quieto, caminar, corre o atacar.
c) NotificationCenter.cs es una librería que permite pasar datos de una clase a otra de
una manera rápida por medio de notificaciones. (García & Lobato, 2014)
2) Scripts Específicos.- Se detallan los script más relevantes, que se utiliza para cada
inteligencia artificial.
30
a) Peatón tipo A.
WaypointsController.cs controla el desplazamiento que deben tener los peatones
cuando deambulan de un lugar a otro, se define una ruta la cual debe seguir, para tener
un mejor control de sus desplazamientos.
Aleatorio.cs esta clase es encargada de generar número randómicos (no repetidos), los
cuales hacen que las rutas tomadas por estos peatones, no sean siempre las mismas.
b) Peatón Tipo B.
GuiaTuristicoIA.cs clase en la cual se encuentra implementada la interacción peatón
tipo B con el jugador.
c) Cantinero.
CantinerIA.cs aquí se determina la ruta que debe seguir el cantinero y a qué momento
debe interaccionar con el jugador para dialogar.
d) Enemigo.
EnemigoIA.cs esta clase implementa los diferentes tipos de estados que tendrá el
enemigo, el cual se interacciona con el objeto a custodiar y con el jugador.
Para probar la demostración de las diferentes técnicas de inteligencias artificiales, es
necesario abrir el proyecto con el IDE (Unity 5.3.3), y abrir la escena Scene.unity. Una
vez cargada la escena hay que ejecutarla haciendo clic en el botón “Play”.
Es posible interaccionar con el teclado, mediante las teclas.
W para desplazarse hacia adelante.
S para desplazarse hacia abajo.
A para desplazarse hacia la izquierda.
D para desplazarse hacia la derecha.
Q y E para interaccionar respectivamente.
A continuación se explica cómo funciona la máquina de estados en cada técnica de
inteligencia artificial. Para la demostración de las pruebas se usaran cubos y esferas.
31
4.1.2 Diagrama de Clases.
Figura 4.1. Diagrama de Clases Parte 1
32
Figura 4.2. Diagrama Clases Parte 2
33
4.2 Programación y Resultados
4.2.1 Demostración de la Maquina de estados del Peatón tipo A.
Para la implementación de esta técnica de IA, se utilizaron dos tools que por defecto
vienen en el Engine de Unity, los cuales son:
NavMesh.- Es una clase se puede utilizar para hacer consultas espaciales, como las
pruebas de pathfinding y transitabilidad, establece el coste búsqueda de caminos para
los tipos de áreas específicas, y para retocar el comportamiento global de la búsqueda de
caminos y la elusión. (Technologies, 2016)
NavMeshAgent.- Este componente está unido a un carácter móvil en el juego, para
permitir que navegue por la escena utilizando un NavMesh. (Technologies, 2016)
Se muestra un fragmento de la implementación, creado en el WaypointsController.cs,
para más detalle del código (Ver Anexo B.1):
void Start(){ agent = GetComponent<NavMeshAgent> (); indicesAlet = new ArrayList (); sizeWP = wayPoints.Length; indicesAlet = aletWP.generaAleatorio (sizeWP); currentWayPoint = (int)indicesAlet [contador]; } void Update () { if (contador >= sizeWP) { indicesAlet = new ArrayList (); indicesAlet = aletWP.generaAleatorio (wayPoints.Length); contador=0; } wayPoint = wayPoints [currentWayPoint]; //Maquina de estados. // Estado 0 if (isMoving) { agent.SetDestination (wayPoint.position); } }
Como se puede apreciar en el punto 1, se define el estado para el peatón A, el cual
deambula aleatoriamente por todos los puntos, creando así diferentes rutas. No se
incluye el cs completo debido a su longitud. De igual manera resulta suficiente para
visualizar la máquina de estados que tiene esta inteligencia.
1
34
Al observar la Figura 4.3, el peatón A, a medida que se va desplazando, va a ir
esquivando cada obstáculos que se le ponga en frente, en este caso se puso cilindros.
Las esferas en el piso son los diferentes puntos donde se ira desplazando.
Figura 4.3. El camino que debería tomar el peatón A
4.2.2 Demostración de la Máquina de estados del Peatón tipo B.
Para la implementación del Peaton B se usa de igual manera los componentes NavMesh
y NavhMeshAgent. Esta inteligencia tiene un estado inicial pasivo.
Como se mencionó esta técnica de IA posee dos estados: Estado Estático y Estado
Interactivo.
Se muestra a continuación un fragmento de código de la clase GuiaTuristico.cs, para
más detalle del código se lo puede observar en el Anexo B.2. Se puede observar donde
se implementa los diferentes estados que tiene la IA. La distanciaPC es la distancia
mínima que el peatón se acerca al jugador.
// El Estado por default es 0 es decir estara quieto //Estado 1 if (interaccion) { pulsoBtn = true; float distanciaPC = Vector3.Distance (agent.transform.position, player.transform.position); if (distanciaPC > 1.3) { agent.SetDestination (player.transform.position); } else { pause(); } } }
2
35
guiarJugador es un método, que permite al peatón de tipo B guiar al jugador de un punto
A hacia un punto B.
public void guiarJugador(){ agent.SetDestination (ptGuia1.transform.position); }
El método que se muestra a continuación, permite que el peatón tipo B detecte al
jugador.
void OnTriggerEnter(Collider other){ if(other.name.Equals ("puntoGuia1")){ Debug.Log("Choco guia 1:"); agent.SetDestination (ptGuia2.transform.position); } if (other.name.Equals ("puntoGuia2")) { Debug.Log("Choco guia 2:"); agent.SetDestination(ptGuia3.transform.position); } if (other.tag.Equals ("Player")) { mensaje = "Pulsa Q para hablar"; mostrarMensaje =true; } }
A continuación una muestra de la inteligencia del Peatón B en ejecución. Para lo cual se
añadió un campo de detección. Como se puede observar en la Figura 4.4, el estado 0 del
peatón B no está en movimiento, no interactúa hasta que el jugador atraviese su campo
de detección.
Figura 4.4. Estado 0 (Estática) del Peatón tipo B.
36
En la Figura 4.5 se puede apreciar el proceso intermedio del peatón tipo B y el jugador,
este proceso es saber si el jugador está cerca o no para ejecutar una acción.
Figura 4.5. El Peatón tipo B detecta la presencia del jugador.
La Figura 4.6 muestra la interacción del peatón tipo B con el jugador, el cual tiene como
objetivo llevarlo de un punto A hacia un punto B, teniendo cuidado con los obstáculos
que estén en dicho camino.
Figura 4.6. Estado 1 del Peatón tipo B interactuando con el jugador.
37
4.2.3 Demostración de la Maquina de estados del Cantinero.
A continuación se presenta la demostración ejecutando la técnica de inteligencia
artificial del cantinero, éste contiene dos estados, como se había mencionado
anteriormente, el primer estado es el de describir una ruta secuencial y va a interactuar
con el jugador.
Debido a la longitud del archivo, se muestra un fragmento de código de la clase
CantineroIA.cs, para más detalle del código (Ver Anexo B.3):
//Estado 0 if (isMoving) { agent.SetDestination (wayPoint.position); } //Estado 1 if (interacciono) { float distanciaPC = Vector3.Distance (agent.transform.position, player.transform.position); if (distanciaPC > 1.3) { agent.SetDestination (player.transform.position); } } if (Input.GetKeyDown("e")) { interacciono = true; romperMensaje = true; } }
Tal como se puede observar en el punto 3, en esa parte de código se está implementando
los dos estados que tendrá el caninero, por un lado esta es IsMoving, encargado de
mover al cantinero por la ruta descrita y por otra parte está el interacciono, quien define
la interacción del jugador con el cantinero.
Observando la Figura 4.7 se puede apreciar al cantinero, describiendo una ruta asignada.
Continuara así en un bucle infinito, hasta que no note la presencia del jugador alrededor
de él.
3
38
Figura 4.7. Estado 0 (inicial) del cantinero.
En la Figura 4.8, al momento que el jugador entra al campo de detección del cantinero,
éste pasa a un estado en reposo y espera que el jugador decida si va a interactuar o no.
Figura 4.8. El cantinero detecta la presencia del jugador.
Como se puede observar en la Figura 4.9, al decidir interactuar con el cantinero, éste
ejecuta una acción, en el caso del proyecto de demostración la acción a ejecutar es la de
acercarse al jugador.
39
Figura 4.9. Estado 1 interacción con el jugador
4.2.4 Demostración de la Maquina de estados del Enemigo.
En esta sección se describe los diferentes tipos estados de las técnicas de IA
implementadas en el enemigo (La Dama), para este caso en particular no se usó
NavMesh - NavMeshAgent, por la cantidad de recursos que consume el aplicar el Bake
(Mapeo de la superficie) en el NavMesh.
Al no tener NavMeshAgent el cual es encargado de hacer el Path Planning, se
implementó un algoritmo personalizado, para que persigue y ataque al jugador.
El enemigo tiene tres estados establecidos, cada uno de ellos depende de lo que haga el
jugador y de donde este alojado el objeto que custodia.
A continuación se muestra un fragmento de código de la clase EnemigoIA.cs, para más
detalles del código (Ver Anexo B.4).
En el punto 4, se implementa el primer estado que tiene el enemigo, el cual va a ser
cuidar la pista, se define la velocidad con que patrulla, los puntos donde va a patrullar.
//Maquina de Estados if (estado == 0) { //Cuando esta Patrullando velRotacion=2; pointTrayec = pointsTrayec [indiceActual]; velMovimientoIni = lastVelocidadInicial; persigueJugador (pointTrayec,this.velMovimientoIni); }
4
40
Por otro lado, el punto 5 corresponde al segundo estado, el cual si detecta la presencia
del jugador en su entorno, el enemigo lo que hace es perseguirlo. Se define una
velocidad que aumenta con el tiempo hasta llegar a 7. Si este supera el rango máximo de
persecución el enemigo regresa a custodiar el objeto.
if (estado == 1) { velRotacion=7; distanciaCont = Vector3.Distance (player.transform.position, transform.position); if (distanciaCont > distanciaEnemigo) { //Cuando Persigue persigueJugador(player.transform, velMovimientoIni); if (velMovimientoIni < velMovimientoFinal) { velMovimientoIni += velMovimientoIni * Time.deltaTime; } } else {
Finalmente el punto 6, se implementa el tercer estado, quien se encarga de atacar al
jugador hasta matarlo. Se define la mínima distancia entre el jugador y el enemigo para
comenzar a atacarlo.
//Cuando Ataca Debug.Log("Atacar..."); } distanciaCont = Vector3.Distance (pista.transform.position, transform.position); if (distanciaCont > distanciaPersecucion) { estado = 0; } } }
A continuación se muestra el método el cual se encarga de perseguir al jugador, los
parámetros que recibe es el objetivo y la velocidad con la cual le perseguirá.
void persigueJugador (Transform target,float velocidadIA){ Vector3 tgtDir = target.position - transf.position; float tgtDist = tgtDir.magnitude; // obtiene la distancia del objetivo Vector3 moveDir = target.position - transf.position; moveDir.y = 0; // previene que el enemigo sufra una inclinación Quaternion rot = Quaternion.FromToRotation(Vector3.forward, moveDir); transf.rotation = Quaternion.Slerp (transform.rotation, Quaternion.LookRotation (target.position - transform.position), velRotacion * Time.deltaTime);
5
6
41
MoveCharacter(moveDir, velocidadIA); }
El método MoveCharacter se encarga de mover al enemigo de un punto a otro en una
dirección dada, los parámetros que recibe es la dirección y la velocidad con la cual que
lo mueve.
public void MoveCharacter(Vector3 dir, float speed){ var vel = dir.normalized * speed; // vel = velocitidad de movimiento // retringe a la velocidad vertical actual para el uso de la gravedad vel.y = Mathf.Clamp(character.velocity.y, -30, 2); vel.y -= gravity * Time.deltaTime; // aplica la gravedad character.Move(vel * Time.deltaTime); // mueve }
En la Figura 4.10 se observa los siguientes elementos:
Enemigo.- Objeto en el cual está implementado la Máquina de Estados Finitos.
Pista.- Objeto que el enemigo protege, es un elemento estático en la escena.
Campo detección 1.- Campo el cual se crea alrededor del enemigo, si el jugador
traspasa dicho campo el enemigo lo ataca.
Campo detección 2.- Campo externo al enemigo, similar al “Campo detección 1”,
pero no pertenece al enemigo sino al escenario, si el jugador entra a este campo, el
enemigo se percata de ello y corre a atacarlo.
Todos los componentes anteriormente expuestos, influyen en las decisiones del
Enemigo y están ligados a las acciones que el jugador ejecute en ese instante. Esta
inteligencia es más rápida en ejecución que las anteriores ya que el algoritmo con la que
se creó no necesita de un Bake para ejecutar, esto implica que haya menos información
que procesar, una de esta son las del tipo de terreno en el cual tenga que caminar.
42
Figura 4.10. Estado 0 del Enemigo
Como se puede observar en la Figura 4.11, cuando el jugador entra en cualquier de los
dos campos de detección, el modo “persecución” se activa y el enemigo corre hacia el
jugador para atacarlo, cuando se encuentre a una distancia mínima especificada, el
enemigo atacara al jugador.
Figura 4.11. Estado 1 del Enemigo
43
Tal como se observa en la Figura 4.12, cuando lleve un tiempo persiguiéndole al
jugador el enemigo, dada la ecuación (1), el enemigo tiene que evaluar, si seguir
persiguiendo al jugador o regresar a custodiar la pista.
Figura 4.12. Estado 2 del Enemigo
4.2.5 Rendimiento
A continuación se procede a describir los dispositivos móviles, en los cuales se ejecutó
el proyecto de prueba, con el fin de ver si hay pérdida o no de FPS. Se considera que el
promedio óptimo de FPS es de 46 a 47.
Tabla 4.1. Dispositivo Móvil Gama Baja
Modelo AOC MW0711
Versión de Android 4.1.1 (JELLY BEAN)
Procesador Single Core 1.01GHz
Ram 1 GB
Resolución 800 x 480 Pixeles
Como se muestra en la Tabla 2, se ejecutó en este dispositivo el proyecto con las
técnicas de inteligencias artificiales empleadas en los cuatro personajes del videojuego,
al ejecutar da como resultado 38 fps, con pérdida aproximada de 8 fotogramas, aun con
esa pérdida de fps se ejecuta con un retraso mínimo en la interacciona con el jugador.
Tabla 4.2. Dispositivo Móvil Gama Media
Modelo Samsung S4 GTI9500
Versión de Android 5.0.1 (Lollipop)
44
Procesador Exynos 5 Octa octa-core 1.6 GHz
Ram 2GB
Resolución 1080 x 1920 Pixeles
Con un dispositivo con características descritas en la Tabla 3, al ejecutar el proyecto da
como resultado 41-42 fps, con pérdida aproximada de 4 fotogramas, el retraso en la
interacciona con el jugador es escaso.
Tabla 4.3. Dispositivo Móvil Gama Alta
Modelo Samsung S6 Edge
Versión de Android 6.0.1 (Marshmallow)
Procesador Exynos 7420 Quad-core 1.5GHz and Quad-Core
2.1GHz
Ram 2.62 GB
Resolución 1440x2560 Pixeles
Tomando un dispositivo de gama Alta, con las características descritas en la Tabla 4, al
ejecutar el proyecto da un fps, casi por el promedio de 44 a 46, con pérdida casi nula,
dando como resultado una interacción con el jugador muy rápida.
Aplicación en Google Play
Como se puede apreciar en la figura 4.13 el videojuego tiene un promedio de aceptación
del 4.4/5, lo que quiere decir que ha cumplido con las expectativas del usuario/jugador.
Figura 4.13. Aplicación subida a Google Play
45
Entre los comentarios que hacen referencia a la interacción del jugador con los NPC’s,
podemos citar los siguientes:
Figura 4.14. Comentarios de los Jugadores en Google Play
46
5 CONCLUSIONES Y RECOMENDACIONES
5.1 Conclusiones
La búsqueda de caminos (Path Planning) utilizando NavMeshAgent, se implementó
únicamente para el cantinero, animales y peatones, considerando previamente dos tipos
de elementos, animados y no animados dependiendo de su composición, por ello los
elementos que conforman el escenario se los consideró como elemento básicos.
Para el enemigo se creó un algoritmo propio, cuya función principal es perseguir al
jugador, esto debido a que los diferentes algoritmos existentes en el Engine de Unity, no
soporta el número de polígonos por las características de hardware de los equipos.
La ejecución de las técnicas de IA en diferentes dispositivos, se ejecutó con fluidez,
demostrando ser óptimas al momento de implementarlas; la facilidad al procesar
acciones de dichas técnicas de IA, depende tanto de la complejidad del modelado 3D,
como del tipo de terreno en que éstas se ejecuten.
Tanto la técnica de Path Planning y las Máquinas de Estados Finitos, se ejecutaron de
manera eficiente, en los diferentes dispositivos de Gama Baja y de Gama Media-Alta
utilizados, observando respuestas rápidas sin pérdida considerables de FPS
47
5.2 Recomendaciones
Sería posible a futuro mejorar el algoritmo de persecución del enemigo, el cual debe
decidir el camino más rápido para llegar hacia el jugador, con el fin de optimizar la
carga computacional que éste representa en tiempo de ejecución.
Implementar más métodos de inteligencia Artificial y aumentar más estados tanto en
enemigos, personas y animales, con el fin de tener una diversidad de interacciones con
el jugador, esto no presenta el trabajo actual, debido a que los tiempos establecidos
fueron muy cortos, pero con una planificación adecuada, se podrían implementar
satisfactoriamente.
Para el adecuado funcionamiento de las Maquinas de Estado Finitos y Path Planning,
es recomendable ejecutarlo en un dispositivo de gama media o alta, para un mejor
aprovechamiento del aplicativo.
Se puede hacer los cambios requeridos para que pueda ser ejecutado en PCs, para
poder implementar un mayor número de métodos y técnicas de inteligencia artificial,
gracias a los recursos de hardware que estos poseen. Para los Test de prueba se podría
usar la plataforma de juegos Steam, con su complemento llamado Steam-Tester.
48
BIBLIOGRAFÍA
1. García Durán, Alfonso. (2010). Inteligencia artificial en los videojuegos. Madrid.
2. Alcalá, J. (2011). Inteligencia Artificial en Videojuegos. Ciclo de conferencias Game
Spirit 2, (pág. 46).
3. ALVERSPIN. (2015). Videojuegos Y Arte. Obtenido de
http://videojuegosyarte.blogspot.com/2011_10_01_archive.html
4. CÓNDOR, J. E. (2015). Representación Específica De La Mitologia Ecuatoriana
Descrita En Una Obra Histórica, A Través Del Demo Jugable De Un
Videojuego De Estrategia.
5. CHANNEL, h. (13 de diciembre de 2011). Youtube. Obtenido de
https://www.youtube.com/watch?v=y0YUUi_3S38
6. EFFECTS, n. B. (12 de julio de 2014). Youtube. Obtenido de
https://www.youtube.com/watch?v=W2ohJrq-G_g
7. EFFECTS, S. S. (7 de octubre de 2014). Youtube. Obtenido de
https://www.youtube.com/watch?v=D7SwYsdnE7w
8. FX, S. (15 de julio de 2014). Youtube. Obtenido de
https://www.youtube.com/watch?v=3t_eV3aJAw4
9. GARCÍA, A., & Lobato, A. (2014). Hagamos Videojuegos. Obtenido de
https://www.youtube.com/user/juande
10. INSTITUTO NACIONAL DE ESTADÍSTICAS Y CENSOS. (2015).
ecuadorencifras. Obtenido de Tecnologías de la Información y Comunicaciones
(TIC´S) 2015: http://www.ecuadorencifras.gob.ec/
11. MALLO J, MARTÍNEZ, Carlos. (2013). Inteligencia Artificial en los Videojuegos.
Madrid.
12. MARTÍNEZ, C., SOTILLO, J. (2015). Inteligencia Artificial en los Videojuegos. 8.
13. MARTÍNEZ, J. M. (28 de Mayo de 2007). UltimaGame. Obtenido de
http://www.ultimagame.es/
14. MARTÍNEZ, M. (2014). Inteligencia Artificial en Videojuegos. T3chFest 2014.
15. OVERMARS, M. H. (2011). Path Planning For Games. Netherlands.
49
16. PADILLA, C. D. (2014). Videojuegos y comunicación: estudio de la relación
comunicacional del jugador con el mundo del videojuego, en el sistema de
realidad virtual Kinect.
17. SILVA, C. J. (2014). Creación De Juegos Lúdicos Utilizando Técnicas De
Inteligencia Artificial Sobre La Plataforma C# .Net Con Las Librerías Gdi+,
Para El Desarrollo Cognitivo De Los Niños Entre 7 Y 11 Años. Caso De
Estudio: Optimización Del Juego Del Tres En Raya Con Niveles.
18. SOLEDAD, G. S. (2014). Diseño Y Desarrollo De Un Videojuego Educativo Con
Técnicas De Inteligencia Artificial Para La Plataforma Android Aplicando La
Metodología Oohdm.
19. SOUNDBIBLE. (2014). SoundBible.com . Obtenido de http://soundbible.com/free-
sound-effects-1.html
20. SOUNDS, A. (1 de Noviembre de 2014). Youtube. Obtenido de
https://www.youtube.com/watch?v=9pxOB-_h9aA
21. TECHNOLOGIES, U. (2016). Unity Documentataion. Obtenido de
http://docs.unity3d.com/
22. TORRICO, R. A. (14 de Abrl de 2016). Introducción a las Máquinas de Estado
Finito. Obtenido de TecBolivia: http://tecbolivia.com/
23. UNIVERSIDAD CARDENAL HERRERA. (25 de Febrero de 2015). Blogs CEU
Informática. Obtenido de https://blog.uchceu.es/
24. WIKIA. (2015). WOWWIKI. Obtenido de
http://es.worldofwarcraft.wikia.com/wiki/NPC
25. WONG, K. W., PRICE, M. (2008). Artificial Intelligence for Computer Games.
Abdennour El Rhalibi.
50
GLOSARIO
Definición, acrónimos y abreviaturas.
IA.- Corresponde a la abreviatura en español de Inteligencia Artificial, que se define
como la capacidad de un agento no vivo de razonar.
NPC.- Un PNJ (Personaje no jugador) o NPC (Non Player Character) es un personaje
con el que se puede interactuar, pero no es un jugador, sino que está controlado por el
software.
Jugador.- Se define como el usuario de un videojuego interactivo sea en 2D o en 3D.
TIC.- Tecnologías de la Información y Comunicación.
INEC.- Es el Instituto Nacional de Estadística y Censos de Ecuador.
Survival Horror.- Se denomina Survival Horror o videojuego de terror al subgénero de
videojuegos enfocados principalmente a atemorizar al jugador, con lo que se pretende
provocar inquietud, desasosiego o incluso miedo.
51
ANEXOS
ANEXO A ......................................................................................................................... I
ANEXO B....................................................................................................................... III
ANEXO C....................................................................................................................... XI
I
ANEXO A
Anexo A.1. Ejemplo Path Planning
Figura A.1. Implementación Path – Planning con puntos origen-destino. (Overmars,
2011, p.3)
Anexo A.2. Representación del mapa
Figura A.2. Ejemplo - representación de un mapa Bidimensional. (Alverspin, 2015)
II
Anexo A.3. Juego Call Of Dutty (Shooter).
Figura A.3. Modo de juego Shooter (Primera Persona). (Martínez J. M., 2007)
Anexo A.4. Juego de Estrategia - Multijugador.
Figura A.4. Control de varias unidades. (Overmars, 2011, p.2)
III
ANEXO B
Anexo B.1. Script donde se implementa la Máquina de estados de los Peatón tipo A.
WaypointsController.cs
using UnityEngine; using System.Collections; using System.Collections.Generic; public class WaypointsController : MonoBehaviour { public Transform[] wayPoints; private Transform wayPoint; private int currentWayPoint; private bool isMoving = true; private NavMeshAgent agent; private ArrayList indicesAlet; private Aleatorio aletWP; public int contador=0; private int sizeWP; private int iterador=1; // Use this for initialization void Awake(){ aletWP = new Aleatorio (); } void Start(){ agent = GetComponent<NavMeshAgent> (); indicesAlet = new ArrayList (); sizeWP = wayPoints.Length; indicesAlet = aletWP.generaAleatorio (sizeWP); currentWayPoint = (int)indicesAlet [contador]; } void Update () { if (contador >= sizeWP) { indicesAlet = new ArrayList (); indicesAlet = aletWP.generaAleatorio (wayPoints.Length); contador=0; } wayPoint = wayPoints [currentWayPoint]; //Maquina de estados. // Estado 0 if (isMoving) { agent.SetDestination (wayPoint.position); } } void OnTriggerEnter (Collider other) { if (other.tag == "Waypoint") { isMoving = false; //Entre punto y punto se pone un delay para que despues avance al siguiente punto
IV
Invoke ("activaMovimiento", Random.Range (1f, 2.5f)); } } public void activaMovimiento () { isMoving = true; contador++; iterador++; if (contador < sizeWP) { currentWayPoint = (int)indicesAlet [contador]; } } }
Anexo B.2. Script en el cual se implementa la máquina de estados de los peatones tipo
B.
GuiaTuristicoIA.cs
using UnityEngine; using System.Collections; public class GuiaTuristicoIA : MonoBehaviour { private NavMeshAgent agent; private GameObject player; private bool isMoving; private Vector3 lastAgentVelocity; private NavMeshPath lastAgentPath; public bool interaccion; public bool pulsoBtn; private bool llegoPtGuia; public GameObject ptGuia1, ptGuia2,ptGuia3; private bool mostrarMensaje, romperMensaje; private string mensaje; // Use this for initialization void Start () { player = GameObject.FindWithTag ("Player"); agent = gameObject.GetComponent<NavMeshAgent> (); } void Update(){ if (Input.GetKeyDown("q")) { mensaje = "Sigueme..."; interaccion = true; romperMensaje = true; } // El Estado por default es 0 es decir estara quieto //Estado 1 if (interaccion) { pulsoBtn = true; float distanciaPC = Vector3.Distance (agent.transform.position, player.transform.position); if (distanciaPC > 1.3) { agent.SetDestination (player.transform.position); } else { pause(); } } }
V
public void hablarConJugador() { interaccion = true; } public void pause () { interaccion = false; isMoving = false; lastAgentVelocity = agent.velocity; lastAgentPath = agent.path; agent.velocity = Vector3.zero; agent.ResetPath (); } public void resume () { agent.velocity = lastAgentVelocity; agent.SetPath (lastAgentPath); isMoving = true; } //Estado 2 guia al jugador a un destino public void guiarJugador(){ agent.SetDestination (ptGuia1.transform.position); } void OnTriggerEnter(Collider other){ if(other.name.Equals ("puntoGuia1")){ Debug.Log("Choco guia 1:"); agent.SetDestination (ptGuia2.transform.position); } if (other.name.Equals ("puntoGuia2")) { Debug.Log("Choco guia 2:"); agent.SetDestination(ptGuia3.transform.position); } if (other.tag.Equals ("Player")) { mensaje = "Pulsa Q para hablar"; mostrarMensaje =true; } } void OnGUI(){ if (mostrarMensaje) { GUIStyle myButtonStyle = new GUIStyle(GUI.skin.button); myButtonStyle.fontSize = Screen.width/30; myButtonStyle.normal.textColor = Color.white; float width = Screen.width/0.5f; float height = Screen.height/6; GUI.Box(new Rect((Screen.width / 2) - width / 2, 0 + height / 2, width, height), mensaje, myButtonStyle); if (romperMensaje) { Invoke("eliminarMensaje", 2f); } } }
VI
public void eliminarMensaje(){ mostrarMensaje = false; agent.SetDestination (ptGuia1.transform.position); } }
Anexo B.3. Clase que contiene la máquina de estados del Cantinero.
CanineroIA.cs
using UnityEngine; using System.Collections; public class CatineroIA : MonoBehaviour { public Transform[] wayPoints; private Transform wayPoint; private bool isMoving = true; private int currentWayPoint; private NavMeshAgent agent; private int sizeWP; private Vector3 lastAgentVelocity; private NavMeshPath lastAgentPath; public bool interacciono, romperMensaje, mostrarMensaje; private string mensaje; GameObject player; // Use this for initialization void Start () { agent = GetComponent<NavMeshAgent> (); currentWayPoint = 0; sizeWP = wayPoints.Length; player = GameObject.FindWithTag("Player"); mensaje = "Aplaste E para Hablar..."; } // Update is called once per frame void Update () { //Máquina de estados wayPoint = wayPoints [currentWayPoint]; //Estado 1 if (isMoving) { agent.SetDestination (wayPoint.position); } //Estado 2 if (interacciono) { float distanciaPC = Vector3.Distance (agent.transform.position, player.transform.position); if (distanciaPC > 1.3) { agent.SetDestination (player.transform.position); } } if (Input.GetKeyDown("e")) { interacciono = true; romperMensaje = true; } } void OnTriggerEnter (Collider other)
VII
{ if (other.tag == "Waypoint" && !interacciono) { isMoving = false; Invoke ("activaMovimiento", Random.Range (1f, 2.5f)); } if (other.tag == "Player") { mostrarMensaje = true; } } public void activaMovimiento () { isMoving = true; if (currentWayPoint < sizeWP - 1) { currentWayPoint++; } else { currentWayPoint = 0; } } public void pause () { isMoving = false; //NotificationCenter.DefaultCenter ().PostNotification (this, "executeAnim", "quieto"); lastAgentVelocity = agent.velocity; lastAgentPath = agent.path; agent.velocity = Vector3.zero; agent.ResetPath (); } public void resume () { //NotificationCenter.DefaultCenter ().PostNotification (this, "executeAnim", "camina"); agent.velocity = lastAgentVelocity; agent.SetPath (lastAgentPath); isMoving = true; } public void hablarConJugador () { interacciono = true; } void OnGUI() { if (mostrarMensaje) { GUIStyle myButtonStyle = new GUIStyle(GUI.skin.button); myButtonStyle.fontSize = Screen.width / 30; myButtonStyle.normal.textColor = Color.white; float width = Screen.width / 0.5f; float height = Screen.height / 6; GUI.Box(new Rect((Screen.width / 2) - width / 2, 0 + height / 2, width, height), mensaje, myButtonStyle); if (romperMensaje) { Invoke("eliminarMensaje", 2f); }
VIII
} } public void eliminarMensaje() { mostrarMensaje = false; } }
Anexo B.4. Clase que contiene la máquina de estados del Enemigo y el algoritmo
creado para la persecución al jugador.
EnemigoIA.cs
using UnityEngine; using System.Collections; public class EnemigoIA : MonoBehaviour { public float distanciaEnemigo; public float distanciaPersecucion; private float distanciaCont; public int estado; //Atributos enemigo. private GameObject player; private Transform transf; public GameObject pista; private CharacterController character; public float velRotacion; public float velMovimientoIni; public float velMovimientoFinal; private float lastVelocidadInicial; private float gravity = 9.8f; //Array que describe al trayectoria del enemigo public Transform[] pointsTrayec; private Transform pointTrayec; private int numPoitns; private int indiceActual; //Controlador de animaciones void Awake () { estado = 0; numPoitns = pointsTrayec.Length; } // Use this for initialization void Start () { indiceActual = 0; //Inciando las notificaciones uqe nos serviran para los estados del enemigo NotificationCenter.DefaultCenter ().AddObserver (this, "controladorDeteccion"); lastVelocidadInicial = velMovimientoIni; transf = transform; player = GameObject.FindWithTag ("Player"); character = GetComponent<CharacterController>(); }
IX
// Update is called once per frame void Update () { //Maquina de Estados if (estado == 0) { //Cuando esta Patrullando velRotacion=2; pointTrayec = pointsTrayec [indiceActual]; velMovimientoIni = lastVelocidadInicial; persigueJugador (pointTrayec,this.velMovimientoIni); } if (estado == 1) { velRotacion=7; //Cuando Persigue distanciaCont = Vector3.Distance (player.transform.position, transform.position); if (distanciaCont > distanciaEnemigo) { persigueJugador(player.transform, velMovimientoIni); if (velMovimientoIni < velMovimientoFinal) { velMovimientoIni += velMovimientoIni * Time.deltaTime; } } else { //Ataca Debug.Log("Atacar..."); } distanciaCont = Vector3.Distance (pista.transform.position, transform.position); if (distanciaCont > distanciaPersecucion) { estado = 0; } } } void controladorDeteccion (Notification notification) { estado = (int)notification.data; } void OnTriggerEnter (Collider other) { if (other.tag == "Waypoint") { if (indiceActual < (numPoitns - 1)) { indiceActual++; } else { indiceActual = 0; } } if (other.tag == "Player") { estado = 1; } } void persigueJugador (Transform target,float velocidadIA){ Vector3 tgtDir = target.position - transf.position;
X
float tgtDist = tgtDir.magnitude; // obtiene la distancia del objetivo Vector3 moveDir = target.position - transf.position; moveDir.y = 0; // previene que el enemigo sufra una inclinación Quaternion rot = Quaternion.FromToRotation(Vector3.forward, moveDir); transf.rotation = Quaternion.Slerp (transform.rotation, Quaternion.LookRotation (target.position - transform.position), velRotacion * Time.deltaTime); MoveCharacter(moveDir, velocidadIA); } public void MoveCharacter(Vector3 dir, float speed){ var vel = dir.normalized * speed; // vel = velocitidad de movimiento // retringe a la velocidad vertical actual para el uso de la gravedad vel.y = Mathf.Clamp(character.velocity.y, -30, 2); vel.y -= gravity * Time.deltaTime; // aplica la gravedad character.Move(vel * Time.deltaTime); // mueve } }
XI
ANEXO C
Anexo C1. Audios Utilizados:
Efecto de Audio del Terremoto. (Sounds, 2014)
Efecto de Audio del Grito de la Dama. (Effects S. S., 2014)
Efecto de Audio de Impacto. (Effects n. B., 2014)
Efecto Ambiente de la Ronda. (FX, 2014)
Efecto Ambiente del Bosque. (SoundBible, 2014)
Efecto Ambiente de la Cueva. (channel, 2011)
